Cleanup: Put DBus unit tests in the dbus namespace, so one does not need to write dbus:: everywhere…

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 73 matching lines @@
 
 void TestService::SendTestSignalFromRoot(const std::string& message) {
   message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TestService::SendTestSignalFromRootInternal,
                  base::Unretained(this),
                  message));
 }
 
 void TestService::SendTestSignalInternal(const std::string& message) {
-  dbus::Signal signal("org.chromium.TestInterface", "Test");
-  dbus::MessageWriter writer(&signal);
+  Signal signal("org.chromium.TestInterface", "Test");
+  MessageWriter writer(&signal);
   writer.AppendString(message);
   exported_object_->SendSignal(&signal);
 }
 
 void TestService::SendTestSignalFromRootInternal(const std::string& message) {
-  dbus::Signal signal("org.chromium.TestInterface", "Test");
-  dbus::MessageWriter writer(&signal);
+  Signal signal("org.chromium.TestInterface", "Test");
+  MessageWriter writer(&signal);
   writer.AppendString(message);
 
   bus_->RequestOwnership("org.chromium.TestService",
                          base::Bind(&TestService::OnOwnership,
                                     base::Unretained(this),
                                     base::Bind(&EmptyCallback)));
 
   // Use "/" just like dbus-send does.
-  ExportedObject* root_object =
-      bus_->GetExportedObject(dbus::ObjectPath("/"));
+  ExportedObject* root_object = bus_->GetExportedObject(ObjectPath("/"));
   root_object->SendSignal(&signal);
 }
 
 void TestService::RequestOwnership(base::Callback<void(bool)> callback) {
   message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TestService::RequestOwnershipInternal,
                  base::Unretained(this),
                  callback));
 }
@@ skipping 36 matching lines @@
   bus_options.connection_type = Bus::PRIVATE;
   bus_options.dbus_task_runner = dbus_task_runner_;
   bus_ = new Bus(bus_options);
 
   bus_->RequestOwnership("org.chromium.TestService",
                          base::Bind(&TestService::OnOwnership,
                                     base::Unretained(this),
                                     base::Bind(&EmptyCallback)));
 
   exported_object_ = bus_->GetExportedObject(
-      dbus::ObjectPath("/org/chromium/TestObject"));
+      ObjectPath("/org/chromium/TestObject"));
 
   int num_methods = 0;
   exported_object_->ExportMethod(
       "org.chromium.TestInterface",
       "Echo",
       base::Bind(&TestService::Echo,
                  base::Unretained(this)),
       base::Bind(&TestService::OnExported,
                  base::Unretained(this)));
   ++num_methods;
@@ skipping 55 matching lines @@
   exported_object_->ExportMethod(
        kPropertiesInterface,
        kPropertiesSet,
        base::Bind(&TestService::SetProperty,
                   base::Unretained(this)),
        base::Bind(&TestService::OnExported,
                   base::Unretained(this)));
   ++num_methods;
 
   exported_object_manager_ = bus_->GetExportedObject(
-    dbus::ObjectPath("/org/chromium/TestService"));
+      ObjectPath("/org/chromium/TestService"));
 
   exported_object_manager_->ExportMethod(
        kObjectManagerInterface,
        kObjectManagerGetManagedObjects,
        base::Bind(&TestService::GetManagedObjects,
                   base::Unretained(this)),
        base::Bind(&TestService::OnExported,
                   base::Unretained(this)));
   ++num_methods;
 
   // Just print an error message as we don't want to crash tests.
   // Tests will fail at a call to WaitUntilServiceIsStarted().
   if (num_methods != kNumMethodsToExport) {
     LOG(ERROR) << "The number of methods does not match";
   }
   message_loop->Run();
 }
 
 void TestService::Echo(MethodCall* method_call,
-                       dbus::ExportedObject::ResponseSender response_sender) {
+                       ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string text_message;
   if (!reader.PopString(&text_message)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
   MessageWriter writer(response.get());
   writer.AppendString(text_message);
   response_sender.Run(response.Pass());
 }
 
-void TestService::SlowEcho(
-    MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
+void TestService::SlowEcho(MethodCall* method_call,
+                           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) {
+void TestService::AsyncEcho(MethodCall* method_call,
+                            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(scoped_ptr<dbus::Response>());
+void TestService::BrokenMethod(MethodCall* method_call,
+                               ExportedObject::ResponseSender response_sender) {
+  response_sender.Run(scoped_ptr<Response>());
 }
 
 
 void TestService::GetAllProperties(
     MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
+    ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string interface;
   if (!reader.PopString(&interface)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
   MessageWriter writer(response.get());
 
   AddPropertiesToWriter(&writer);
 
   response_sender.Run(response.Pass());
 }
 
-void TestService::GetProperty(
-    MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
+void TestService::GetProperty(MethodCall* method_call,
+                              ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string interface;
   if (!reader.PopString(&interface)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   std::string name;
   if (!reader.PopString(&name)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   if (name == "Name") {
     // Return the previous value for the "Name" property:
     // Variant<"TestService">
     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
     MessageWriter writer(response.get());
 
     writer.AppendVariantOfString("TestService");
@@ skipping 29 matching lines @@
   } else if (name == "Objects") {
     // Return the previous value for the "Objects" property:
     // Variant<[objectpath:"/TestObjectPath"]>
     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_array_writer.AppendObjectPath(ObjectPath("/TestObjectPath"));
     variant_writer.CloseContainer(&variant_array_writer);
     writer.CloseContainer(&variant_writer);
 
     response_sender.Run(response.Pass());
   } else {
     // Return error.
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 }
 
-void TestService::SetProperty(
-    MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
+void TestService::SetProperty(MethodCall* method_call,
+                              ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string interface;
   if (!reader.PopString(&interface)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   std::string name;
   if (!reader.PopString(&name)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   if (name != "Name") {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   std::string value;
   if (!reader.PopVariantOfString(&value)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   SendPropertyChangedSignal(value);
 
   response_sender.Run(Response::FromMethodCall(method_call));
 }
 
 void TestService::PerformAction(
       MethodCall* method_call,
-      dbus::ExportedObject::ResponseSender response_sender) {
+      ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string action;
-  dbus::ObjectPath object_path;
+  ObjectPath object_path;
   if (!reader.PopString(&action) || !reader.PopObjectPath(&object_path)) {
-    response_sender.Run(scoped_ptr<dbus::Response>());
+    response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   if (action == "AddObject")
     AddObject(object_path);
   else if (action == "RemoveObject")
     RemoveObject(object_path);
 
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
   response_sender.Run(response.Pass());
 }
 
 void TestService::GetManagedObjects(
     MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
+    ExportedObject::ResponseSender response_sender) {
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
   MessageWriter writer(response.get());
 
   // The managed objects response is a dictionary of object paths identifying
   // the object(s) with a dictionary of strings identifying the interface(s)
   // they implement and then a dictionary of property values.
   //
   // Thus this looks something like:
   //
   // {
   //   "/org/chromium/TestObject": {
   //     "org.chromium.TestInterface": { /* Properties */ }
   //   }
   // }
 
 
   MessageWriter array_writer(NULL);
   MessageWriter dict_entry_writer(NULL);
   MessageWriter object_array_writer(NULL);
   MessageWriter object_dict_entry_writer(NULL);
 
   writer.OpenArray("{oa{sa{sv}}}", &array_writer);
 
   array_writer.OpenDictEntry(&dict_entry_writer);
-  dict_entry_writer.AppendObjectPath(
-      dbus::ObjectPath("/org/chromium/TestObject"));
+  dict_entry_writer.AppendObjectPath(ObjectPath("/org/chromium/TestObject"));
   dict_entry_writer.OpenArray("{sa{sv}}", &object_array_writer);
 
   object_array_writer.OpenDictEntry(&object_dict_entry_writer);
   object_dict_entry_writer.AppendString("org.chromium.TestInterface");
   AddPropertiesToWriter(&object_dict_entry_writer);
   object_array_writer.CloseContainer(&object_dict_entry_writer);
 
   dict_entry_writer.CloseContainer(&object_array_writer);
 
   array_writer.CloseContainer(&dict_entry_writer);
   writer.CloseContainer(&array_writer);
 
   response_sender.Run(response.Pass());
 }
 
-void TestService::AddPropertiesToWriter(MessageWriter* writer)
-{
+void TestService::AddPropertiesToWriter(MessageWriter* writer) {
   // 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"]>
-  // ]
+  // }
 
   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 14 matching lines @@
   variant_array_writer.AppendString("AsyncEcho");
   variant_array_writer.AppendString("BrokenMethod");
   variant_writer.CloseContainer(&variant_array_writer);
   dict_entry_writer.CloseContainer(&variant_writer);
   array_writer.CloseContainer(&dict_entry_writer);
 
   array_writer.OpenDictEntry(&dict_entry_writer);
   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_array_writer.AppendObjectPath(ObjectPath("/TestObjectPath"));
   variant_writer.CloseContainer(&variant_array_writer);
   dict_entry_writer.CloseContainer(&variant_writer);
   array_writer.CloseContainer(&dict_entry_writer);
 
   writer->CloseContainer(&array_writer);
 }
 
-void TestService::AddObject(const dbus::ObjectPath& object_path) {
+void TestService::AddObject(const ObjectPath& object_path) {
   message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TestService::AddObjectInternal,
                  base::Unretained(this),
                  object_path));
 }
 
-void TestService::AddObjectInternal(const dbus::ObjectPath& object_path) {
-  dbus::Signal signal(kObjectManagerInterface, kObjectManagerInterfacesAdded);
-  dbus::MessageWriter writer(&signal);
+void TestService::AddObjectInternal(const ObjectPath& object_path) {
+  Signal signal(kObjectManagerInterface, kObjectManagerInterfacesAdded);
+  MessageWriter writer(&signal);
   writer.AppendObjectPath(object_path);
 
   MessageWriter array_writer(NULL);
   MessageWriter dict_entry_writer(NULL);
 
   writer.OpenArray("{sa{sv}}", &array_writer);
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString("org.chromium.TestInterface");
   AddPropertiesToWriter(&dict_entry_writer);
   array_writer.CloseContainer(&dict_entry_writer);
   writer.CloseContainer(&array_writer);
 
   exported_object_manager_->SendSignal(&signal);
 }
 
-void TestService::RemoveObject(const dbus::ObjectPath& object_path) {
-    message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TestService::RemoveObjectInternal,
-                 base::Unretained(this),
-                 object_path));
+void TestService::RemoveObject(const ObjectPath& object_path) {
+  message_loop()->PostTask(FROM_HERE,
+                           base::Bind(&TestService::RemoveObjectInternal,
+                                      base::Unretained(this),
+                                      object_path));
 }
 
-void TestService::RemoveObjectInternal(const dbus::ObjectPath& object_path) {
-  dbus::Signal signal(kObjectManagerInterface, kObjectManagerInterfacesRemoved);
-  dbus::MessageWriter writer(&signal);
+void TestService::RemoveObjectInternal(const ObjectPath& object_path) {
+  Signal signal(kObjectManagerInterface, kObjectManagerInterfacesRemoved);
+  MessageWriter writer(&signal);
 
   writer.AppendObjectPath(object_path);
 
   std::vector<std::string> interfaces;
   interfaces.push_back("org.chromium.TestInterface");
   writer.AppendArrayOfStrings(interfaces);
 
   exported_object_manager_->SendSignal(&signal);
 }
 
 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);
+  Signal signal(kPropertiesInterface, kPropertiesChanged);
+  MessageWriter writer(&signal);
   writer.AppendString("org.chromium.TestInterface");
 
   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