Convert //dbus from scoped_ptr to std::unique_ptr

dbus/mock_object_proxy.h

Index: dbus/mock_object_proxy.h
diff --git a/dbus/mock_object_proxy.h b/dbus/mock_object_proxy.h
index 66f485ad06ff31c6fa632edde692a5de6808fb41..bad1c93a1abd6bd5e67a5cdbc7e80fe5707d725f 100644
--- a/dbus/mock_object_proxy.h
+++ b/dbus/mock_object_proxy.h
@@ -21,7 +21,8 @@ class MockObjectProxy : public ObjectProxy {
                   const std::string& service_name,
                   const ObjectPath& object_path);
 
-  // GMock doesn't support the return type of scoped_ptr<> because scoped_ptr is
+  // GMock doesn't support the return type of std::unique_ptr<> because
+  // scoped_ptr is

[hashimoto, 2016/04/08 04:55:36]

scoped_ptr -> unique_ptr
Also, please format the comment.

[dcheng, 2016/04/08 05:02:02]

Done.

   // uncopyable. This is a workaround which defines |MockCallMethodAndBlock| as
   // a mock method and makes |CallMethodAndBlock| call the mocked method.
   // Use |MockCallMethodAndBlock| for setting/testing expectations.
@@ -29,19 +30,19 @@ class MockObjectProxy : public ObjectProxy {
                Response*(MethodCall* method_call,
                          int timeout_ms,
                          ScopedDBusError* error));
-  scoped_ptr<Response> CallMethodAndBlockWithErrorDetails(
+  std::unique_ptr<Response> CallMethodAndBlockWithErrorDetails(
       MethodCall* method_call,
       int timeout_ms,
       ScopedDBusError* error) override {
-    return scoped_ptr<Response>(
+    return std::unique_ptr<Response>(
         MockCallMethodAndBlockWithErrorDetails(method_call, timeout_ms, error));
   }
   MOCK_METHOD2(MockCallMethodAndBlock, Response*(MethodCall* method_call,
                                                  int timeout_ms));
-  scoped_ptr<Response> CallMethodAndBlock(MethodCall* method_call,
-                                          int timeout_ms) override {
-    return scoped_ptr<Response>(MockCallMethodAndBlock(method_call,
-                                                       timeout_ms));
+  std::unique_ptr<Response> CallMethodAndBlock(MethodCall* method_call,
+                                               int timeout_ms) override {
+    return std::unique_ptr<Response>(
+        MockCallMethodAndBlock(method_call, timeout_ms));
   }
   MOCK_METHOD3(CallMethod, void(MethodCall* method_call,
                                 int timeout_ms,