Convert //dbus from scoped_ptr to std::unique_ptr

dbus/mock_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_exported_object.h"
 #include "dbus/mock_object_proxy.h"
 #include "dbus/object_path.h"
 #include "dbus/scoped_dbus_error.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 56 matching lines @@
     if (response) {
       MessageReader reader(response);
       ASSERT_TRUE(reader.PopString(&response_string_));
     }
     run_loop_->Quit();
   };
 
  protected:
   std::string response_string_;
   base::MessageLoop message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
   scoped_refptr<MockBus> mock_bus_;
   scoped_refptr<MockObjectProxy> mock_proxy_;
 
  private:
   // Returns a response for the given method call. Used to implement
   // CallMethodAndBlock() for |mock_proxy_|.
   Response* CreateMockProxyResponse(MethodCall* method_call,
                                     int timeout_ms) {
     if (method_call->GetInterface() == "org.chromium.TestInterface" &&
         method_call->GetMember() == "Echo") {
       MessageReader reader(method_call);
       std::string text_message;
       if (reader.PopString(&text_message)) {
-        scoped_ptr<Response> response = Response::CreateEmpty();
+        std::unique_ptr<Response> response = Response::CreateEmpty();
         MessageWriter writer(response.get());
         writer.AppendString(text_message);
         return response.release();
       }
     }
 
     LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
     return NULL;
   }
 
@@ skipping 34 matching lines @@
   ObjectProxy* proxy = mock_bus_->GetObjectProxy(
       "org.chromium.TestService",
       ObjectPath("/org/chromium/TestObject"));
 
   // Create a method call.
   MethodCall method_call("org.chromium.TestInterface", "Echo");
   MessageWriter writer(&method_call);
   writer.AppendString(kHello);
 
   // Call the method.
-  scoped_ptr<Response> response(
-      proxy->CallMethodAndBlock(&method_call,
-                                ObjectProxy::TIMEOUT_USE_DEFAULT));
+  std::unique_ptr<Response> response(proxy->CallMethodAndBlock(
+      &method_call, ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   // Check the response.
   ASSERT_TRUE(response.get());
   MessageReader reader(response.get());
   std::string text_message;
   ASSERT_TRUE(reader.PopString(&text_message));
   // The text message should be echo'ed back.
   EXPECT_EQ(kHello, text_message);
 }
 
 TEST_F(MockTest, CallMethodAndBlockWithErrorDetails) {
   // Get an object proxy from the mock bus.
   ObjectProxy* proxy = mock_bus_->GetObjectProxy(
       "org.chromium.TestService",
       ObjectPath("/org/chromium/TestObject"));
 
   // Create a method call.
   MethodCall method_call("org.chromium.TestInterface", "Echo");
 
   ScopedDBusError error;
   // Call the method.
-  scoped_ptr<Response> response(
-      proxy->CallMethodAndBlockWithErrorDetails(
-          &method_call, ObjectProxy::TIMEOUT_USE_DEFAULT, &error));
+  std::unique_ptr<Response> response(proxy->CallMethodAndBlockWithErrorDetails(
+      &method_call, ObjectProxy::TIMEOUT_USE_DEFAULT, &error));
 
   // Check the response.
   ASSERT_FALSE(response.get());
   ASSERT_TRUE(error.is_set());
   EXPECT_STREQ(DBUS_ERROR_NOT_SUPPORTED, error.name());
   EXPECT_STREQ("Not implemented", error.message());
 }
 
 // This test demonstrates how to mock an asynchronous method call using the
 // mock classes.
@@ skipping 16 matching lines @@
                     ObjectProxy::TIMEOUT_USE_DEFAULT,
                     base::Bind(&MockTest::OnResponse,
                                base::Unretained(this)));
   // Run the message loop to let OnResponse be called.
   run_loop_->Run();
 
   EXPECT_EQ(kHello, response_string_);
 }
 
 }  // namespace dbus