Code cleaning: Uses scoped_ptr<> to express ownership rather than writing ownership in comments.

chrome/browser/chromeos/dbus/service_provider_test_helper.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 "chrome/browser/chromeos/dbus/service_provider_test_helper.h"
 
 #include "base/bind.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 39 matching lines @@
               ExportMethod(kLibCrosServiceInterface,
                            exported_method_name, _, _))
       .WillOnce(Invoke(this, &ServiceProviderTestHelper::MockExportMethod));
 
   // Create a mock object proxy, with which we call a method of
   // |mock_exported_object_|.
   mock_object_proxy_ =
       new dbus::MockObjectProxy(mock_bus_.get(),
                                 kLibCrosServiceName,
                                 dbus::ObjectPath(kLibCrosServicePath));
-  // |mock_object_proxy_|'s CallMethodAndBlock() will use
+  // |mock_object_proxy_|'s MockCallMethodAndBlock() will use
   // MockCallMethodAndBlock() to return responses.
   EXPECT_CALL(*mock_object_proxy_,
-              CallMethodAndBlock(
+              MockCallMethodAndBlock(
                   AllOf(
                       ResultOf(
                           std::mem_fun(&dbus::MethodCall::GetInterface),
-                                        kLibCrosServiceInterface),
+                          kLibCrosServiceInterface),
                       ResultOf(
                           std::mem_fun(&dbus::MethodCall::GetMember),
-                                        exported_method_name)),
+                          exported_method_name)),
                   _))
       .WillOnce(Invoke(this,
                        &ServiceProviderTestHelper::MockCallMethodAndBlock));
 
   service_provider->Start(mock_exported_object_.get());
 }
 
 void ServiceProviderTestHelper::TearDown() {
   mock_bus_->ShutdownAndBlock();
   mock_exported_object_ = NULL;
@@ skipping 14 matching lines @@
   // |mock_object_proxy_|'s ConnectToSignal will use
   // MockConnectToSignal().
   EXPECT_CALL(*mock_object_proxy_,
               ConnectToSignal(interface_name, signal_name, _, _))
       .WillOnce(Invoke(this, &ServiceProviderTestHelper::MockConnectToSignal));
 
   mock_object_proxy_->ConnectToSignal(interface_name, signal_name,
                                       signal_callback, on_connected_callback);
 }
 
-dbus::Response* ServiceProviderTestHelper::CallMethod(
+scoped_ptr<dbus::Response> ServiceProviderTestHelper::CallMethod(
     dbus::MethodCall* method_call) {
-  return mock_object_proxy_->CallMethodAndBlock(method_call,
+  return mock_object_proxy_->CallMethodAndBlock(
+      method_call,
       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
 }
 
 void ServiceProviderTestHelper::MockExportMethod(
     const std::string& interface_name,
     const std::string& method_name,
     dbus::ExportedObject::MethodCallCallback method_callback,
     dbus::ExportedObject::OnExportedCallback on_exported_callback) {
   // Tell the call back that the method is exported successfully.
   on_exported_callback.Run(interface_name, method_name, true);
@@ skipping 30 matching lines @@
   // Capture the callback, so we can run this at a later time.
   on_signal_callback_ = signal_callback;
 }
 
 void ServiceProviderTestHelper::MockSendSignal(dbus::Signal* signal) {
   // Run the callback captured in MockConnectToSignal(). This will call
   // OnSignalReceived().
   on_signal_callback_.Run(signal);
 }
 
-void ServiceProviderTestHelper::OnResponse(dbus::Response* response) {
-  response_.reset(response);
+void ServiceProviderTestHelper::OnResponse(
+    scoped_ptr<dbus::Response> response) {
+  response_ = response.Pass();
   response_received_ = true;
   if (message_loop_.is_running())
     message_loop_.Quit();
 }
 
 }  // namespace chromeos
-