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

dbus/test_service.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 "dbus/test_service.h"
 
 #include "base/bind.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "dbus/bus.h"
@@ skipping 225 matching lines @@
     LOG(ERROR) << "The number of methods does not match";
   }
   message_loop->Run();
 }
 
 void TestService::Echo(MethodCall* method_call,
                        dbus::ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string text_message;
   if (!reader.PopString(&text_message)) {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
-  Response* response = Response::FromMethodCall(method_call);
-  MessageWriter writer(response);
+  scoped_ptr<Response> response = Response::FromMethodCall(method_call);
+  MessageWriter writer(response.get());
   writer.AppendString(text_message);
-  response_sender.Run(response);
+  response_sender.Run(response.Pass());
 }
 
 void TestService::SlowEcho(
     MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   Echo(method_call, response_sender);
 }
 
 void TestService::AsyncEcho(
     MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   // Schedule a call to Echo() to send an asynchronous response after we return.
   message_loop()->PostDelayedTask(FROM_HERE,
                                   base::Bind(&TestService::Echo,
                                              base::Unretained(this),
                                              method_call,
                                              response_sender),
                                   TestTimeouts::tiny_timeout());
 }
 
 void TestService::BrokenMethod(
     MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
-  response_sender.Run(NULL);
+  response_sender.Run(scoped_ptr<dbus::Response>());
 }
 
 
 void TestService::GetAllProperties(
     MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string interface;
   if (!reader.PopString(&interface)) {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
   // The properties response is a dictionary of strings identifying the
   // property and a variant containing the property value. We return all
   // of the properties, thus the response is:
   //
   // {
   //   "Name": Variant<"TestService">,
   //   "Version": Variant<10>,
   //   "Methods": Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]>,
   //   "Objects": Variant<[objectpath:"/TestObjectPath"]>
   // ]
 
-  Response* response = Response::FromMethodCall(method_call);
-  MessageWriter writer(response);
+  scoped_ptr<Response> response = Response::FromMethodCall(method_call);
+  MessageWriter writer(response.get());
 
   MessageWriter array_writer(NULL);
   MessageWriter dict_entry_writer(NULL);
   MessageWriter variant_writer(NULL);
   MessageWriter variant_array_writer(NULL);
 
   writer.OpenArray("{sv}", &array_writer);
 
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString("Name");
@@ skipping 21 matching lines @@
   dict_entry_writer.AppendString("Objects");
   dict_entry_writer.OpenVariant("ao", &variant_writer);
   variant_writer.OpenArray("o", &variant_array_writer);
   variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath"));
   variant_writer.CloseContainer(&variant_array_writer);
   dict_entry_writer.CloseContainer(&variant_writer);
   array_writer.CloseContainer(&dict_entry_writer);
 
   writer.CloseContainer(&array_writer);
 
-  response_sender.Run(response);
+  response_sender.Run(response.Pass());
 }
 
 void TestService::GetProperty(
     MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string interface;
   if (!reader.PopString(&interface)) {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
   std::string name;
   if (!reader.PopString(&name)) {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
   if (name == "Name") {
     // Return the previous value for the "Name" property:
     // Variant<"TestService">
-    Response* response = Response::FromMethodCall(method_call);
-    MessageWriter writer(response);
+    scoped_ptr<Response> response = Response::FromMethodCall(method_call);
+    MessageWriter writer(response.get());
 
     writer.AppendVariantOfString("TestService");
 
-    response_sender.Run(response);
+    response_sender.Run(response.Pass());
   } else if (name == "Version") {
     // Return a new value for the "Version" property:
     // Variant<20>
-    Response* response = Response::FromMethodCall(method_call);
-    MessageWriter writer(response);
+    scoped_ptr<Response> response = Response::FromMethodCall(method_call);
+    MessageWriter writer(response.get());
 
     writer.AppendVariantOfInt16(20);
 
-    response_sender.Run(response);
+    response_sender.Run(response.Pass());
   } else if (name == "Methods") {
     // Return the previous value for the "Methods" property:
     // Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]>
-    Response* response = Response::FromMethodCall(method_call);
-    MessageWriter writer(response);
+    scoped_ptr<Response> response = Response::FromMethodCall(method_call);
+    MessageWriter writer(response.get());
     MessageWriter variant_writer(NULL);
     MessageWriter variant_array_writer(NULL);
 
     writer.OpenVariant("as", &variant_writer);
     variant_writer.OpenArray("s", &variant_array_writer);
     variant_array_writer.AppendString("Echo");
     variant_array_writer.AppendString("SlowEcho");
     variant_array_writer.AppendString("AsyncEcho");
     variant_array_writer.AppendString("BrokenMethod");
     variant_writer.CloseContainer(&variant_array_writer);
     writer.CloseContainer(&variant_writer);
 
-    response_sender.Run(response);
+    response_sender.Run(response.Pass());
   } else if (name == "Objects") {
     // Return the previous value for the "Objects" property:
     // Variant<[objectpath:"/TestObjectPath"]>
-    Response* response = Response::FromMethodCall(method_call);
-    MessageWriter writer(response);
+    scoped_ptr<Response> response = Response::FromMethodCall(method_call);
+    MessageWriter writer(response.get());
     MessageWriter variant_writer(NULL);
     MessageWriter variant_array_writer(NULL);
 
     writer.OpenVariant("ao", &variant_writer);
     variant_writer.OpenArray("o", &variant_array_writer);
     variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath"));
     variant_writer.CloseContainer(&variant_array_writer);
     writer.CloseContainer(&variant_writer);
 
-    response_sender.Run(response);
+    response_sender.Run(response.Pass());
   } else {
     // Return error.
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 }
 
 void TestService::SetProperty(
     MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string interface;
   if (!reader.PopString(&interface)) {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
   std::string name;
   if (!reader.PopString(&name)) {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
   if (name != "Name") {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
   std::string value;
   if (!reader.PopVariantOfString(&value)) {
-    response_sender.Run(NULL);
+    response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
 
   SendPropertyChangedSignal(value);
 
-  Response* response = Response::FromMethodCall(method_call);
-  response_sender.Run(response);
+  response_sender.Run(Response::FromMethodCall(method_call));
 }
 
 void TestService::SendPropertyChangedSignal(const std::string& name) {
   message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TestService::SendPropertyChangedSignalInternal,
                  base::Unretained(this),
                  name));
 }
 
 void TestService::SendPropertyChangedSignalInternal(const std::string& name) {
   dbus::Signal signal(kPropertiesInterface, kPropertiesChanged);
   dbus::MessageWriter writer(&signal);
   writer.AppendString("org.chromium.TestService");
 
   MessageWriter array_writer(NULL);
   MessageWriter dict_entry_writer(NULL);
 
   writer.OpenArray("{sv}", &array_writer);
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString("Name");
   dict_entry_writer.AppendVariantOfString(name);
   array_writer.CloseContainer(&dict_entry_writer);
   writer.CloseContainer(&array_writer);
 
   exported_object_->SendSignal(&signal);
 }
 
 }  // namespace dbus