DBus: Use TaskRunners instead of MessageLoopProxies.

dbus/bus.h

 // 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.
 
 #ifndef DBUS_BUS_H_
 #define DBUS_BUS_H_
 
+#include <dbus/dbus.h>
+
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
-#include <dbus/dbus.h>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
-#include "base/tracked_objects.h"
 #include "dbus/dbus_export.h"
 #include "dbus/object_path.h"
 
-class MessageLoop;
+namespace base {
+class SequencedTaskRunner;
+class SingleThreadTaskRunner;
+class Thread;
+}
 
-namespace base {
-class Thread;
-class MessageLoopProxy;
+namespace tracked_objects {
+class Location;
 }
 
 namespace dbus {
 
 class ExportedObject;
 class ObjectProxy;
 
 // Bus is used to establish a connection with D-Bus, create object
 // proxies, and export objects.
 //
 // For asynchronous operations such as an asynchronous method call, the
-// bus object will use a message loop to monitor the underlying file
+// bus object will use a task runner to monitor the underlying file
 // descriptor used for D-Bus communication. By default, the bus will use
-// the current thread's MessageLoopForIO. If |dbus_thread_message_loop_proxy|
-// option is specified, the bus will use that message loop instead.
+// the current thread's task runner. If |dbus_task_runner| option is
+// specified, the bus will use that task runner instead.
 //
 // THREADING
 //
 // In the D-Bus library, we use the two threads:
 //
 // - The origin thread: the thread that created the Bus object.
-// - The D-Bus thread: the thread servicing |dbus_thread_message_loop_proxy|.
+// - The D-Bus thread: the thread servicing |dbus_task_runner|.
 //
 // The origin thread is usually Chrome's UI thread. The D-Bus thread is
 // usually a dedicated thread for the D-Bus library.
 //
 // BLOCKING CALLS
 //
 // Functions that issue blocking calls are marked "BLOCKING CALL" and
 // these functions should be called in the D-Bus thread (if
 // supplied). AssertOnDBusThread() is placed in these functions.
 //
@@ skipping 98 matching lines @@
     SHARED,
   };
 
   // Options used to create a Bus object.
   struct CHROME_DBUS_EXPORT Options {
     Options();
     ~Options();
 
     BusType bus_type;  // SESSION by default.
     ConnectionType connection_type;  // PRIVATE by default.
-    // If dbus_thread_message_loop_proxy is set, the bus object will use that
-    // message loop to process asynchronous operations.
+    // If dbus_task_runner is set, the bus object will use that
+    // task runner to process asynchronous operations.
     //
-    // The thread servicing the message loop proxy should meet the following
+    // The thread servicing the task runner should meet the following
     // requirements:
     // 1) Already running.
     // 2) Has a MessageLoopForIO.
-    scoped_refptr<base::MessageLoopProxy> dbus_thread_message_loop_proxy;
+    scoped_refptr<base::SequencedTaskRunner> dbus_task_runner;
 
     // Specifies the server addresses to be connected. If you want to
     // communicate with non dbus-daemon such as ibus-daemon, set |bus_type| to
     // CUSTOM_ADDRESS, and |address| to the D-Bus server address you want to
     // connect to. The format of this address value is the dbus address style
     // which is described in
     // http://dbus.freedesktop.org/doc/dbus-specification.html#addresses
     //
     // EXAMPLE USAGE:
     //   dbus::Bus::Options options;
@@ skipping 271 matching lines @@
   virtual bool TryRegisterObjectPath(const ObjectPath& object_path,
                                      const DBusObjectPathVTable* vtable,
                                      void* user_data,
                                      DBusError* error);
 
   // Unregister the object path.
   //
   // BLOCKING CALL.
   virtual void UnregisterObjectPath(const ObjectPath& object_path);
 
-  // Posts the task to the message loop of the thread that created the bus.
+  // Posts the task to the task runner of the thread that created the bus.
   virtual void PostTaskToOriginThread(
       const tracked_objects::Location& from_here,
       const base::Closure& task);
 
-  // Posts the task to the message loop of the D-Bus thread. If D-Bus
-  // thread is not supplied, the message loop of the origin thread will be
+  // Posts the task to the task runner of the D-Bus thread. If D-Bus
+  // thread is not supplied, the task runner of the origin thread will be
   // used.
   virtual void PostTaskToDBusThread(
       const tracked_objects::Location& from_here,
       const base::Closure& task);
 
-  // Posts the delayed task to the message loop of the D-Bus thread. If
-  // D-Bus thread is not supplied, the message loop of the origin thread
+  // Posts the delayed task to the task runner of the D-Bus thread. If
+  // D-Bus thread is not supplied, the task runner of the origin thread
   // will be used.
   virtual void PostDelayedTaskToDBusThread(
       const tracked_objects::Location& from_here,
       const base::Closure& task,
       base::TimeDelta delay);
 
   // Returns true if the bus has the D-Bus thread.
   virtual bool HasDBusThread();
 
   // Check whether the current thread is on the origin thread (the thread
@@ skipping 69 matching lines @@
   static void OnToggleWatchThunk(DBusWatch* raw_watch, void* data);
   static dbus_bool_t OnAddTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnRemoveTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnToggleTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnDispatchStatusChangedThunk(DBusConnection* connection,
                                            DBusDispatchStatus status,
                                            void* data);
 
   // Calls OnConnectionDisconnected if the Diconnected signal is received.
   static DBusHandlerResult OnConnectionDisconnectedFilter(
-      DBusConnection *connection,
-      DBusMessage *message,
-      void *user_data);
+      DBusConnection* connection,
+      DBusMessage* message,
+      void* user_data);
 
   const BusType bus_type_;
   const ConnectionType connection_type_;
-  scoped_refptr<base::MessageLoopProxy> dbus_thread_message_loop_proxy_;
+  scoped_refptr<base::SequencedTaskRunner> dbus_task_runner_;
   base::WaitableEvent on_shutdown_;
   DBusConnection* connection_;
 
-  scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
   base::PlatformThreadId origin_thread_id_;
 
   std::set<std::string> owned_service_names_;
   // The following sets are used to check if rules/object_paths/filters
   // are properly cleaned up before destruction of the bus object.
   // Since it's not an error to add the same match rule twice, the repeated
   // match rules are counted in a map.
   std::map<std::string, int> match_rules_added_;
   std::set<ObjectPath> registered_object_paths_;
   std::set<std::pair<DBusHandleMessageFunction, void*> >
@@ skipping 25 matching lines @@
 
   std::string address_;
   base::Closure on_disconnected_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_