diff --git a/apmanager/daemon.cc b/apmanager/daemon.cc
index 46882c6..15d457c 100644
--- a/apmanager/daemon.cc
+++ b/apmanager/daemon.cc
@@ -6,7 +6,6 @@
 
 #include <sysexits.h>
 
-#include <base/bind.h>
 #include <base/logging.h>
 #include <base/message_loop/message_loop_proxy.h>
 #include <base/run_loop.h>
diff --git a/apmanager/daemon.h b/apmanager/daemon.h
index 3588da9..cd6af1c 100644
--- a/apmanager/daemon.h
+++ b/apmanager/daemon.h
@@ -5,7 +5,7 @@
 #ifndef APMANAGER_DAEMON_H_
 #define APMANAGER_DAEMON_H_
 
-#include <base/cancelable_callback.h>
+#include <base/callback_forward.h>
 #include <chromeos/daemons/dbus_daemon.h>
 
 #include "apmanager/manager.h"
diff --git a/apmanager/manager.cc b/apmanager/manager.cc
index 2472777..959119d 100644
--- a/apmanager/manager.cc
+++ b/apmanager/manager.cc
@@ -54,11 +54,11 @@
 }
 
 void Manager::CreateService(
-    scoped_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
+    std::unique_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
     dbus::Message* message) {
   LOG(INFO) << "Manager::CreateService";
   scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
-  scoped_ptr<Service> service(new Service(this, service_identifier_));
+  std::unique_ptr<Service> service(new Service(this, service_identifier_));
 
   service->RegisterAsync(
       dbus_object_->GetObjectManager().get(), bus_, sequencer.get());
@@ -160,8 +160,8 @@
 }
 
 void Manager::OnServiceRegistered(
-    scoped_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
-    scoped_ptr<Service> service,
+    std::unique_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
+    std::unique_ptr<Service> service,
     bool success) {
   LOG(INFO) << "ServiceRegistered";
   // Success should always be true since we've said that failures are fatal.
@@ -181,7 +181,7 @@
   // Add service to the service list and return the service dbus path for the
   // CreateService call.
   dbus::ObjectPath service_path = service->dbus_path();
-  services_.push_back(std::unique_ptr<Service>(service.release()));
+  services_.push_back(std::move(service));
   response->Return(service_path);
 }
 
diff --git a/apmanager/manager.h b/apmanager/manager.h
index 0ee7766..9c5fb93 100644
--- a/apmanager/manager.h
+++ b/apmanager/manager.h
@@ -10,7 +10,6 @@
 #include <vector>
 
 #include <base/macros.h>
-#include <base/memory/scoped_ptr.h>
 #include <chromeos/dbus/dbus_service_watcher.h>
 
 #include "apmanager/dbus_adaptors/org.chromium.apmanager.Manager.h"
@@ -25,6 +24,9 @@
 class Manager : public org::chromium::apmanager::ManagerAdaptor,
                 public org::chromium::apmanager::ManagerInterface {
  public:
+  template<typename T>
+  using DBusMethodResponse = chromeos::dbus_utils::DBusMethodResponse<T>;
+
   Manager();
   virtual ~Manager();
 
@@ -33,8 +35,7 @@
   // This is an asynchronous call, response is invoked when Service and Config
   // dbus objects complete the DBus service registration.
   virtual void CreateService(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<dbus::ObjectPath>>
-          response,
+      std::unique_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
       dbus::Message* message);
   // Handles calls to org.chromium.apmanager.Manager.RemoveService().
   virtual bool RemoveService(chromeos::ErrorPtr* error,
@@ -75,9 +76,8 @@
   // A callback that will be called when the Service/Config D-Bus
   // objects/interfaces are exported successfully and ready to be used.
   void OnServiceRegistered(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<dbus::ObjectPath>>
-          response,
-      scoped_ptr<Service> service,
+      std::unique_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
+      std::unique_ptr<Service> service,
       bool success);
 
   // A callback that will be called when a Device D-Bus object/interface is
diff --git a/attestation/server/dbus_service.cc b/attestation/server/dbus_service.cc
index 7e70731..9f0141c 100644
--- a/attestation/server/dbus_service.cc
+++ b/attestation/server/dbus_service.cc
@@ -36,7 +36,7 @@
 }
 
 void DBusService::HandleCreateGoogleAttestedKey(
-    scoped_ptr<DBusMethodResponse<const CreateGoogleAttestedKeyReply&>>
+    std::unique_ptr<DBusMethodResponse<const CreateGoogleAttestedKeyReply&>>
         response,
     const CreateGoogleAttestedKeyRequest& request) {
   VLOG(1) << __func__;
diff --git a/attestation/server/dbus_service.h b/attestation/server/dbus_service.h
index e880c16..70e5c61 100644
--- a/attestation/server/dbus_service.h
+++ b/attestation/server/dbus_service.h
@@ -5,7 +5,8 @@
 #ifndef ATTESTATION_SERVER_DBUS_SERVICE_H_
 #define ATTESTATION_SERVER_DBUS_SERVICE_H_
 
-#include <base/memory/scoped_ptr.h>
+#include <memory>
+
 #include <chromeos/dbus/dbus_method_response.h>
 #include <chromeos/dbus/dbus_object.h>
 #include <dbus/bus.h>
@@ -39,7 +40,7 @@
 
   // Handles a CreateGoogleAttestedKey D-Bus call.
   void HandleCreateGoogleAttestedKey(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
           const CreateGoogleAttestedKeyReply&>> response,
       const CreateGoogleAttestedKeyRequest& request);
 
diff --git a/buffet/manager.cc b/buffet/manager.cc
index 33b1763..7b710f1 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -210,7 +210,7 @@
 }
 
 void Manager::SetCommandVisibility(
-    scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<>> response,
+    std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<>> response,
     const std::vector<std::string>& in_names,
     const std::string& in_visibility) {
   CommandDefinition::Visibility visibility;
diff --git a/buffet/manager.h b/buffet/manager.h
index 3cf7021..cc3a114 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -37,7 +37,7 @@
 
 template<typename... Types>
 using DBusMethodResponse =
-    scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<Types...>>;
+    std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<Types...>>;
 
 // The Manager is responsible for global state of Buffet.  It exposes
 // interfaces which affect the entire device such as device registration and
@@ -74,7 +74,7 @@
   void GetCommand(DBusMethodResponse<std::string> response,
                   const std::string& id) override;
   void SetCommandVisibility(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<>> response,
+      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<>> response,
       const std::vector<std::string>& in_names,
       const std::string& in_visibility) override;
   std::string TestMethod(const std::string& message) override;
diff --git a/chromeos-dbus-bindings/adaptor_generator.cc b/chromeos-dbus-bindings/adaptor_generator.cc
index 97c4a8b..44897a1 100644
--- a/chromeos-dbus-bindings/adaptor_generator.cc
+++ b/chromeos-dbus-bindings/adaptor_generator.cc
@@ -271,7 +271,8 @@
           out_types.push_back(param_type);
         }
         method_params.push_back(base::StringPrintf(
-            "scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<%s>> response",
+            "std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<%s>> "
+            "response",
              chromeos::string_utils::Join(", ", out_types).c_str()));
         if (method.include_dbus_message)
           method_params.push_back("dbus::Message* message");
diff --git a/chromeos-dbus-bindings/adaptor_generator_unittest.cc b/chromeos-dbus-bindings/adaptor_generator_unittest.cc
index 772552d..6fe34bb 100644
--- a/chromeos-dbus-bindings/adaptor_generator_unittest.cc
+++ b/chromeos-dbus-bindings/adaptor_generator_unittest.cc
@@ -179,10 +179,10 @@
   virtual std::string Kaneda2(
       const std::string& in_iwata) const = 0;
   virtual void Tetsuo2(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<int64_t>> response,
+      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<int64_t>> response,
       int32_t in_1) = 0;
   virtual void Kei2(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<bool>> response,
+      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<bool>> response,
       dbus::Message* message) = 0;
 };
 
diff --git a/libchromeos/chromeos/daemons/dbus_daemon.h b/libchromeos/chromeos/daemons/dbus_daemon.h
index 0ba2f23..2f08dfa 100644
--- a/libchromeos/chromeos/daemons/dbus_daemon.h
+++ b/libchromeos/chromeos/daemons/dbus_daemon.h
@@ -9,7 +9,7 @@
 #include <string>
 
 #include <base/strings/string_piece.h>
-#include <base/memory/scoped_ptr.h>
+#include <base/memory/ref_counted.h>
 #include <chromeos/chromeos_export.h>
 #include <chromeos/daemons/daemon.h>
 #include <chromeos/dbus/exported_object_manager.h>
diff --git a/libchromeos/chromeos/dbus/dbus_method_response.cc b/libchromeos/chromeos/dbus/dbus_method_response.cc
index e376a0a..25d0b27 100644
--- a/libchromeos/chromeos/dbus/dbus_method_response.cc
+++ b/libchromeos/chromeos/dbus/dbus_method_response.cc
@@ -24,7 +24,7 @@
 void DBusMethodResponseBase::ReplyWithError(const chromeos::Error* error) {
   CheckCanSendResponse();
   auto response = GetDBusError(method_call_, error);
-  SendRawResponse(scoped_ptr<dbus::Response>(response.release()));
+  SendRawResponse(std::move(response));
 }
 
 void DBusMethodResponseBase::ReplyWithError(
@@ -38,19 +38,20 @@
 }
 
 void DBusMethodResponseBase::Abort() {
-  SendRawResponse(scoped_ptr<dbus::Response>());
+  SendRawResponse(std::unique_ptr<dbus::Response>());
 }
 
 void DBusMethodResponseBase::SendRawResponse(
-    scoped_ptr<dbus::Response> response) {
+    std::unique_ptr<dbus::Response> response) {
   CheckCanSendResponse();
   method_call_ = nullptr;  // Mark response as sent.
-  sender_.Run(response.Pass());
+  sender_.Run(scoped_ptr<dbus::Response>{response.release()});
 }
 
-scoped_ptr<dbus::Response>
+std::unique_ptr<dbus::Response>
 DBusMethodResponseBase::CreateCustomResponse() const {
-  return dbus::Response::FromMethodCall(method_call_);
+  return std::unique_ptr<dbus::Response>{
+      dbus::Response::FromMethodCall(method_call_).release()};
 }
 
 bool DBusMethodResponseBase::IsResponseSent() const {
diff --git a/libchromeos/chromeos/dbus/dbus_method_response.h b/libchromeos/chromeos/dbus/dbus_method_response.h
index 374abf5..b0c69b6 100644
--- a/libchromeos/chromeos/dbus/dbus_method_response.h
+++ b/libchromeos/chromeos/dbus/dbus_method_response.h
@@ -46,10 +46,10 @@
                       const std::string& error_message);
 
   // Sends a raw D-Bus response message.
-  void SendRawResponse(scoped_ptr<dbus::Response> response);
+  void SendRawResponse(std::unique_ptr<dbus::Response> response);
 
   // Creates a custom response object for the current method call.
-  scoped_ptr<dbus::Response> CreateCustomResponse() const;
+  std::unique_ptr<dbus::Response> CreateCustomResponse() const;
 
   // Checks if the response has been sent already.
   bool IsResponseSent() const;
@@ -63,7 +63,7 @@
  private:
   // A callback to be called to send the method call response message.
   ResponseSender sender_;
-  // |method_call_| is actually owned by |sender_| (it is embedded as scoped_ptr
+  // |method_call_| is actually owned by |sender_| (it is embedded as unique_ptr
   // in the bound parameter list in the Callback). We set it to nullptr after
   // the method call response has been sent to ensure we can't possibly try
   // to send a response again somehow.
@@ -88,7 +88,7 @@
     auto response = CreateCustomResponse();
     dbus::MessageWriter writer(response.get());
     DBusParamWriter::Append(&writer, return_values...);
-    SendRawResponse(response.Pass());
+    SendRawResponse(std::move(response));
   }
 };
 
diff --git a/libchromeos/chromeos/dbus/dbus_object.h b/libchromeos/chromeos/dbus/dbus_object.h
index 14d6c31..16fe59b 100644
--- a/libchromeos/chromeos/dbus/dbus_object.h
+++ b/libchromeos/chromeos/dbus/dbus_object.h
@@ -42,7 +42,7 @@
   chromeos::dbus_utils::ExportedProperty<int> prop2_;
   int Method1() { return 5; }
   bool Method2(chromeos::ErrorPtr* error, const std::string& message);
-  void Method3(scoped_ptr<DBusMethodResponse<int_32>> response,
+  void Method3(std::unique_ptr<DBusMethodResponse<int_32>> response,
                const std::string& message) {
     if (message.empty()) {
        response->ReplyWithError(chromeos::errors::dbus::kDomain,
@@ -104,9 +104,10 @@
 // The signature of the handler for AddSimpleMethodHandlerWithErrorAndMessage:
 //    bool(ErrorPtr* error, dbus::Message* msg, Args... args) [IN/OUT]
 // The signature of the handler for AddMethodHandler must be:
-//    void(scoped_ptr<DBusMethodResponse<T...>> response, Args... args) [IN]
+//    void(std::unique_ptr<DBusMethodResponse<T...>> response,
+//         Args... args) [IN]
 // The signature of the handler for AddMethodHandlerWithMessage must be:
-//    void(scoped_ptr<DBusMethodResponse<T...>> response,
+//    void(std::unique_ptr<DBusMethodResponse<T...>> response,
 //         dbus::Message* msg, Args... args) [IN]
 // There is also an AddRawMethodHandler() call that lets provide a custom
 // handler that can parse its own input parameter and construct a custom
@@ -242,7 +243,7 @@
   template<typename Response, typename... Args>
   inline void AddMethodHandler(
       const std::string& method_name,
-      const base::Callback<void(scoped_ptr<Response>, Args...)>& handler) {
+      const base::Callback<void(std::unique_ptr<Response>, Args...)>& handler) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
     Handler<DBusInterfaceMethodHandler<Response, Args...>>::Add(
@@ -252,8 +253,9 @@
   // Register an async D-Bus method handler for |method_name| as a static
   // function.
   template<typename Response, typename... Args>
-  inline void AddMethodHandler(const std::string& method_name,
-                               void (*handler)(scoped_ptr<Response>, Args...)) {
+  inline void AddMethodHandler(
+      const std::string& method_name,
+      void (*handler)(std::unique_ptr<Response>, Args...)) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
     Handler<DBusInterfaceMethodHandler<Response, Args...>>::Add(
@@ -269,7 +271,7 @@
   inline void AddMethodHandler(
       const std::string& method_name,
       Instance instance,
-      void(Class::*handler)(scoped_ptr<Response>, Args...)) {
+      void(Class::*handler)(std::unique_ptr<Response>, Args...)) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
     Handler<DBusInterfaceMethodHandler<Response, Args...>>::Add(
@@ -284,7 +286,7 @@
   inline void AddMethodHandler(
       const std::string& method_name,
       Instance instance,
-      void(Class::*handler)(scoped_ptr<Response>, Args...) const) {
+      void(Class::*handler)(std::unique_ptr<Response>, Args...) const) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
     Handler<DBusInterfaceMethodHandler<Response, Args...>>::Add(
@@ -295,7 +297,7 @@
   template<typename Response, typename... Args>
   inline void AddMethodHandlerWithMessage(
       const std::string& method_name,
-      const base::Callback<void(scoped_ptr<Response>, dbus::Message*,
+      const base::Callback<void(std::unique_ptr<Response>, dbus::Message*,
                                 Args...)>& handler) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
@@ -308,7 +310,7 @@
   template<typename Response, typename... Args>
   inline void AddMethodHandlerWithMessage(
       const std::string& method_name,
-      void (*handler)(scoped_ptr<Response>, dbus::Message*, Args...)) {
+      void (*handler)(std::unique_ptr<Response>, dbus::Message*, Args...)) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
     Handler<DBusInterfaceMethodHandlerWithMessage<Response, Args...>>::Add(
@@ -324,7 +326,8 @@
   inline void AddMethodHandlerWithMessage(
       const std::string& method_name,
       Instance instance,
-      void(Class::*handler)(scoped_ptr<Response>, dbus::Message*, Args...)) {
+      void(Class::*handler)(std::unique_ptr<Response>,
+                            dbus::Message*, Args...)) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
     Handler<DBusInterfaceMethodHandlerWithMessage<Response, Args...>>::Add(
@@ -339,7 +342,7 @@
   inline void AddMethodHandlerWithMessage(
       const std::string& method_name,
       Instance instance,
-      void(Class::*handler)(scoped_ptr<Response>, dbus::Message*,
+      void(Class::*handler)(std::unique_ptr<Response>, dbus::Message*,
                             Args...) const) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
diff --git a/libchromeos/chromeos/dbus/dbus_object_internal_impl.h b/libchromeos/chromeos/dbus/dbus_object_internal_impl.h
index 7ecd477..544dadb 100644
--- a/libchromeos/chromeos/dbus/dbus_object_internal_impl.h
+++ b/libchromeos/chromeos/dbus/dbus_object_internal_impl.h
@@ -19,7 +19,7 @@
 //    void handler(Args...);
 //    ReturnType handler(Args...);
 //    bool handler(ErrorPtr* error, Args...);
-//    void handler(scoped_ptr<DBusMethodResponse<T1, T2,...>>, Args...);
+//    void handler(std::unique_ptr<DBusMethodResponse<T1, T2,...>>, Args...);
 //
 // To make this all work, we craft a simple callback suitable for
 // DBusParamReader using a lambda in DBusInvoker::Invoke() and redirect the call
@@ -118,7 +118,7 @@
       auto response = method_response.CreateCustomResponse();
       dbus::MessageWriter writer(response.get());
       DBusParamWriter::AppendDBusOutParams(&writer, args...);
-      method_response.SendRawResponse(response.Pass());
+      method_response.SendRawResponse(std::move(response));
     };
 
     ErrorPtr param_reader_error;
@@ -167,7 +167,7 @@
         auto response = method_response.CreateCustomResponse();
         dbus::MessageWriter writer(response.get());
         DBusParamWriter::AppendDBusOutParams(&writer, args...);
-        method_response.SendRawResponse(response.Pass());
+        method_response.SendRawResponse(std::move(response));
       }
     };
 
@@ -219,7 +219,7 @@
         auto response = method_response.CreateCustomResponse();
         dbus::MessageWriter writer(response.get());
         DBusParamWriter::AppendDBusOutParams(&writer, args...);
-        method_response.SendRawResponse(response.Pass());
+        method_response.SendRawResponse(std::move(response));
       }
     };
 
@@ -244,14 +244,14 @@
 // the method call response (including a possible error response) using
 // the provided DBusMethodResponse object.
 // The signature of the callback handler is expected to be:
-//    void(scoped_ptr<DBusMethodResponse<RetTypes...>, Args...)
+//    void(std::unique_ptr<DBusMethodResponse<RetTypes...>, Args...)
 template<typename Response, typename... Args>
 class DBusInterfaceMethodHandler : public DBusInterfaceMethodHandlerInterface {
  public:
   // A constructor that takes a |handler| to be called when HandleMethod()
   // virtual function is invoked.
   explicit DBusInterfaceMethodHandler(
-      const base::Callback<void(scoped_ptr<Response>, Args...)>& handler)
+      const base::Callback<void(std::unique_ptr<Response>, Args...)>& handler)
       : handler_(handler) {}
 
   // This method forwards the call to |handler_| after extracting the required
@@ -260,8 +260,8 @@
   void HandleMethod(dbus::MethodCall* method_call,
                     ResponseSender sender) override {
     auto invoke_callback = [this, method_call, &sender](const Args&... args) {
-      scoped_ptr<Response> response(new Response(method_call, sender));
-      handler_.Run(response.Pass(), args...);
+      std::unique_ptr<Response> response(new Response(method_call, sender));
+      handler_.Run(std::move(response), args...);
     };
 
     ErrorPtr param_reader_error;
@@ -276,7 +276,7 @@
 
  private:
   // C++ callback to be called when a D-Bus method is dispatched.
-  base::Callback<void(scoped_ptr<Response>, Args...)> handler_;
+  base::Callback<void(std::unique_ptr<Response>, Args...)> handler_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusInterfaceMethodHandler);
 };
@@ -288,7 +288,8 @@
 // type |Args...| and send the method call response (including a possible error
 // response) using the provided DBusMethodResponse object.
 // The signature of the callback handler is expected to be:
-//    void(scoped_ptr<DBusMethodResponse<RetTypes...>, dbus::Message*, Args...);
+//    void(std::unique_ptr<DBusMethodResponse<RetTypes...>, dbus::Message*,
+//         Args...);
 template<typename Response, typename... Args>
 class DBusInterfaceMethodHandlerWithMessage
     : public DBusInterfaceMethodHandlerInterface {
@@ -296,7 +297,7 @@
   // A constructor that takes a |handler| to be called when HandleMethod()
   // virtual function is invoked.
   explicit DBusInterfaceMethodHandlerWithMessage(
-      const base::Callback<void(scoped_ptr<Response>, dbus::Message*,
+      const base::Callback<void(std::unique_ptr<Response>, dbus::Message*,
                                 Args...)>& handler)
       : handler_(handler) {}
 
@@ -306,8 +307,8 @@
   void HandleMethod(dbus::MethodCall* method_call,
                     ResponseSender sender) override {
     auto invoke_callback = [this, method_call, &sender](const Args&... args) {
-      scoped_ptr<Response> response(new Response(method_call, sender));
-      handler_.Run(response.Pass(), method_call, args...);
+      std::unique_ptr<Response> response(new Response(method_call, sender));
+      handler_.Run(std::move(response), method_call, args...);
     };
 
     ErrorPtr param_reader_error;
@@ -322,7 +323,8 @@
 
  private:
   // C++ callback to be called when a D-Bus method is dispatched.
-  base::Callback<void(scoped_ptr<Response>, dbus::Message*, Args...)> handler_;
+  base::Callback<void(std::unique_ptr<Response>,
+                      dbus::Message*, Args...)> handler_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusInterfaceMethodHandlerWithMessage);
 };
diff --git a/libchromeos/chromeos/dbus/dbus_object_test_helpers.h b/libchromeos/chromeos/dbus/dbus_object_test_helpers.h
index c9349d8..a8307cd 100644
--- a/libchromeos/chromeos/dbus/dbus_object_test_helpers.h
+++ b/libchromeos/chromeos/dbus/dbus_object_test_helpers.h
@@ -91,17 +91,18 @@
   static RetType Call(
       ErrorPtr* error,
       Class* instance,
-      void(Class::*method)(scoped_ptr<DBusMethodResponse<RetType>>, Params...),
+      void(Class::*method)(std::unique_ptr<DBusMethodResponse<RetType>>,
+                           Params...),
       Args... args) {
     ResponseHolder response_holder;
     dbus::MethodCall method_call("test.interface", "TestMethod");
     method_call.SetSerial(123);
-    scoped_ptr<DBusMethodResponse<RetType>> method_response{
+    std::unique_ptr<DBusMethodResponse<RetType>> method_response{
       new DBusMethodResponse<RetType>(
         &method_call, base::Bind(&ResponseHolder::ReceiveResponse,
                                  response_holder.AsWeakPtr()))
     };
-    (instance->*method)(method_response.Pass(), args...);
+    (instance->*method)(std::move(method_response), args...);
     CHECK(response_holder.response_.get())
         << "No response received. Asynchronous methods are not supported.";
     RetType ret_val;
@@ -118,17 +119,17 @@
   static void Call(
       ErrorPtr* error,
       Class* instance,
-      void(Class::*method)(scoped_ptr<DBusMethodResponse<>>, Params...),
+      void(Class::*method)(std::unique_ptr<DBusMethodResponse<>>, Params...),
       Args... args) {
     ResponseHolder response_holder;
     dbus::MethodCall method_call("test.interface", "TestMethod");
     method_call.SetSerial(123);
-    scoped_ptr<DBusMethodResponse<>> method_response{
+    std::unique_ptr<DBusMethodResponse<>> method_response{
       new DBusMethodResponse<>(&method_call,
                                base::Bind(&ResponseHolder::ReceiveResponse,
                                           response_holder.AsWeakPtr()))
     };
-    (instance->*method)(method_response.Pass(), args...);
+    (instance->*method)(std::move(method_response), args...);
     CHECK(response_holder.response_.get())
         << "No response received. Asynchronous methods are not supported.";
     ExtractMethodCallResults(response_holder.response_.get(), error);
diff --git a/libchromeos/chromeos/dbus/dbus_object_unittest.cc b/libchromeos/chromeos/dbus/dbus_object_unittest.cc
index d39d956..87a79e8 100644
--- a/libchromeos/chromeos/dbus/dbus_object_unittest.cc
+++ b/libchromeos/chromeos/dbus/dbus_object_unittest.cc
@@ -46,7 +46,8 @@
 struct Calc {
   int Add(int x, int y) { return x + y; }
   int Negate(int x) { return -x; }
-  void Positive(scoped_ptr<DBusMethodResponse<double>> response, double x) {
+  void Positive(std::unique_ptr<DBusMethodResponse<double>> response,
+                double x) {
     if (x >= 0.0) {
       response->Return(x);
       return;
@@ -82,8 +83,9 @@
   return true;
 }
 
-void TestWithMessageAsync(scoped_ptr<DBusMethodResponse<std::string>> response,
-                         dbus::Message* message) {
+void TestWithMessageAsync(
+    std::unique_ptr<DBusMethodResponse<std::string>> response,
+    dbus::Message* message) {
   response->Return(message->GetSender());
 }
 
diff --git a/libchromeos/chromeos/dbus/dbus_signal_handler_unittest.cc b/libchromeos/chromeos/dbus/dbus_signal_handler_unittest.cc
index 08172ea..88d5559 100644
--- a/libchromeos/chromeos/dbus/dbus_signal_handler_unittest.cc
+++ b/libchromeos/chromeos/dbus/dbus_signal_handler_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <string>
 
-#include <base/memory/scoped_ptr.h>
 #include <chromeos/bind_lambda.h>
 #include <chromeos/dbus/dbus_param_writer.h>
 #include <dbus/mock_bus.h>
diff --git a/libchromeos/chromeos/dbus/exported_object_manager_unittest.cc b/libchromeos/chromeos/dbus/exported_object_manager_unittest.cc
index 9ae3b20..3df1466 100644
--- a/libchromeos/chromeos/dbus/exported_object_manager_unittest.cc
+++ b/libchromeos/chromeos/dbus/exported_object_manager_unittest.cc
@@ -131,9 +131,8 @@
 
   scoped_refptr<dbus::MockBus> bus_;
   scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
-  scoped_ptr<ExportedObjectManager> om_;
+  std::unique_ptr<ExportedObjectManager> om_;
   ExportedPropertySet::PropertyWriter property_writer_;
-  scoped_ptr<dbus::Response> last_response_;
 };
 
 TEST_F(ExportedObjectManagerTest, ClaimInterfaceSendsSignals) {
diff --git a/libchromeos/chromeos/dbus/exported_property_set_unittest.cc b/libchromeos/chromeos/dbus/exported_property_set_unittest.cc
index 5ecd08b..ff38c37 100644
--- a/libchromeos/chromeos/dbus/exported_property_set_unittest.cc
+++ b/libchromeos/chromeos/dbus/exported_property_set_unittest.cc
@@ -162,10 +162,10 @@
     return testing::CallMethod(p_->dbus_object_, &method_call);
   }
 
-  scoped_ptr<dbus::Response> last_response_;
+  std::unique_ptr<dbus::Response> last_response_;
   scoped_refptr<dbus::MockBus> bus_;
   scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
-  scoped_ptr<Properties> p_;
+  std::unique_ptr<Properties> p_;
 };
 
 template<typename T>