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

dbus/bus.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/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 105 matching lines @@
     dbus_timeout_set_data(raw_timeout_, this, NULL);
     AddRef();  // Balanced on Complete().
   }
 
   // Returns true if the timeout is ready to be monitored.
   bool IsReadyToBeMonitored() {
     return dbus_timeout_get_enabled(raw_timeout_);
   }
 
   // Starts monitoring the timeout.
-  void StartMonitoring(dbus::Bus* bus) {
+  void StartMonitoring(Bus* bus) {
     bus->PostDelayedTaskToDBusThread(FROM_HERE,
                                      base::Bind(&Timeout::HandleTimeout,
                                                 this),
                                      GetInterval());
     monitoring_is_active_ = true;
   }
 
   // Stops monitoring the timeout.
   void StopMonitoring() {
     // We cannot take back the delayed task we posted in
@@ skipping 83 matching lines @@
   // DCHECK_EQ(0, num_pending_timeouts_);
 }
 
 ObjectProxy* Bus::GetObjectProxy(const std::string& service_name,
                                  const ObjectPath& object_path) {
   return GetObjectProxyWithOptions(service_name, object_path,
                                    ObjectProxy::DEFAULT_OPTIONS);
 }
 
 ObjectProxy* Bus::GetObjectProxyWithOptions(const std::string& service_name,
-                                            const dbus::ObjectPath& object_path,
+                                            const ObjectPath& object_path,
                                             int options) {
   AssertOnOriginThread();
 
   // Check if we already have the requested object proxy.
   const ObjectProxyTable::key_type key(service_name + object_path.value(),
                                        options);
   ObjectProxyTable::iterator iter = object_proxy_table_.find(key);
   if (iter != object_proxy_table_.end()) {
     return iter->second.get();
   }
 
   scoped_refptr<ObjectProxy> object_proxy =
       new ObjectProxy(this, service_name, object_path, options);
   object_proxy_table_[key] = object_proxy;
 
   return object_proxy.get();
 }
 
 bool Bus::RemoveObjectProxy(const std::string& service_name,
                             const ObjectPath& object_path,
                             const base::Closure& callback) {
   return RemoveObjectProxyWithOptions(service_name, object_path,
                                       ObjectProxy::DEFAULT_OPTIONS,
                                       callback);
 }
 
 bool Bus::RemoveObjectProxyWithOptions(const std::string& service_name,
-                                       const dbus::ObjectPath& object_path,
+                                       const ObjectPath& object_path,
                                        int options,
                                        const base::Closure& callback) {
   AssertOnOriginThread();
 
   // Check if we have the requested object proxy.
   const ObjectProxyTable::key_type key(service_name + object_path.value(),
                                        options);
   ObjectProxyTable::iterator iter = object_proxy_table_.find(key);
   if (iter != object_proxy_table_.end()) {
     // Object is present. Remove it now and Detach in the DBus thread.
     PostTaskToDBusThread(FROM_HERE, base::Bind(
         &Bus::RemoveObjectProxyInternal,
         this, iter->second, callback));
 
     object_proxy_table_.erase(iter);
     return true;
   }
   return false;
 }
 
-void Bus::RemoveObjectProxyInternal(
-    scoped_refptr<dbus::ObjectProxy> object_proxy,
-    const base::Closure& callback) {
+void Bus::RemoveObjectProxyInternal(scoped_refptr<ObjectProxy> object_proxy,
+                                    const base::Closure& callback) {
   AssertOnDBusThread();
 
   object_proxy.get()->Detach();
 
   PostTaskToOriginThread(FROM_HERE, callback);
 }
 
 ExportedObject* Bus::GetExportedObject(const ObjectPath& object_path) {
   AssertOnOriginThread();
 
@@ skipping 26 matching lines @@
   // Since the registration also happens on the D-Bus thread in
   // TryRegisterObjectPath(), and the task runner we post to is a
   // SequencedTaskRunner, there is a guarantee that this will happen before any
   // future registration call.
   PostTaskToDBusThread(FROM_HERE,
                        base::Bind(&Bus::UnregisterExportedObjectInternal,
                                   this, exported_object));
 }
 
 void Bus::UnregisterExportedObjectInternal(
-    scoped_refptr<dbus::ExportedObject> exported_object) {
+    scoped_refptr<ExportedObject> exported_object) {
   AssertOnDBusThread();
 
   exported_object->Unregister();
 }
 
 ObjectManager* Bus::GetObjectManager(const std::string& service_name,
                                      const ObjectPath& object_path) {
   AssertOnOriginThread();
 
   // Check if we already have the requested object manager.
@@ skipping 436 matching lines @@
   // As mentioned at the class comment in .h file, connection_ can be NULL.
   if (!connection_)
     return;
 
   // It is safe and necessary to call dbus_connection_get_dispatch_status even
   // if the connection is lost. Otherwise we will miss "Disconnected" signal.
   // (crbug.com/174431)
   if (dbus_connection_get_dispatch_status(connection_) ==
       DBUS_DISPATCH_DATA_REMAINS) {
     while (dbus_connection_dispatch(connection_) ==
-           DBUS_DISPATCH_DATA_REMAINS);
+           DBUS_DISPATCH_DATA_REMAINS) {
+    }
   }
 }
 
 void Bus::PostTaskToDBusThreadAndReply(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     const base::Closure& reply) {
   AssertOnOriginThread();
 
   if (dbus_task_runner_.get()) {
@@ skipping 428 matching lines @@
                              kNameOwnerChangedSignal)) {
     Bus* self = static_cast<Bus*>(data);
     self->OnServiceOwnerChanged(message);
   }
   // Always return unhandled to let others, e.g. ObjectProxies, handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus