Linux: use MessageLoopProxy instead of base::Thread in our DBus client library.

dbus/bus.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <dbus/dbus.h>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/tracked_objects.h"
 
 class MessageLoop;
 
 namespace base {
 class Thread;
+class MessageLoopProxy;
 }
 
 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
 // descriptor used for D-Bus communication. By default, the bus will use
-// the current thread's MessageLoopForIO. If |dbus_thread| option is
-// specified, the bus will use the D-Bus thread's message loop.
+// the current thread's MessageLoopForIO. If |dbus_thread_message_loop_proxy|
+// option is specified, the bus will use that message loop 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 supplied by |dbus_thread| option.
+// - The D-Bus thread: the thread servicing |dbus_thread_message_loop_proxy|.
 //
 // 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 15 matching lines @@
 //
 //   dbus::Bus::Options options;
 //   // Set up the bus options here.
 //   ...
 //   dbus::Bus bus(options);
 //
 //   dbus::ObjectProxy* object_proxy =
 //       bus.GetObjectProxy(service_name, object_path);
 //
 //   dbus::MethodCall method_call(interface_name, method_name);
-//   dbus::Response response;
-//   bool success =
-//       object_proxy.CallMethodAndBlock(&method_call, timeout_ms, &response);
+//   scoped_ptr<dbus::Response> response(
+//       object_proxy.CallMethodAndBlock(&method_call, timeout_ms));
+//   if (response.get() != NULL) {  // Success.
+//     ...
+//   }
 //
 // Asynchronous method call:
 //
 //   void OnResponse(dbus::Response* response) {
 //     // response is NULL if the method call failed.
 //     if (!response)
 //       return;
 //   }
 //
 //   ...
@@ skipping 52 matching lines @@
     SHARED,
   };
 
   // Options used to create a Bus object.
   struct Options {
     Options();
     ~Options();
 
     BusType bus_type;  // SESSION by default.
     ConnectionType connection_type;  // PRIVATE by default.
-    // If the thread is set, the bus object will use the message loop
-    // attached to the thread to process asynchronous operations.
+    // If dbus_thread_message_loop_proxy is set, the bus object will use that
+    // message loop to process asynchronous operations.
     //
-    // The thread should meet the following requirements:
+    // The thread servicing the message loop proxy should meet the following
+    // requirements:
     // 1) Already running.
     // 2) Has a MessageLoopForIO.
-    // 3) Outlives the bus.
-    base::Thread* dbus_thread;  // NULL by default.
+    scoped_refptr<base::MessageLoopProxy> dbus_thread_message_loop_proxy;
   };
 
   // Creates a Bus object. The actual connection will be established when
   // Connect() is called.
   explicit Bus(const Options& options);
 
   // Gets the object proxy for the given service name and the object path.
   // The caller must not delete the returned object.
   //
   // Returns an existing object proxy if the bus object already owns the
@@ skipping 248 matching lines @@
   static void OnRemoveWatchThunk(DBusWatch* raw_watch, void* data);
   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);
   const BusType bus_type_;
   const ConnectionType connection_type_;
-  base::Thread* dbus_thread_;
+  scoped_refptr<base::MessageLoopProxy> dbus_thread_message_loop_proxy_;
   base::WaitableEvent on_shutdown_;
   DBusConnection* connection_;
 
   MessageLoop* origin_loop_;
   base::PlatformThreadId origin_thread_id_;
-  base::PlatformThreadId dbus_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.
   std::set<std::string> match_rules_added_;
   std::set<std::string> registered_object_paths_;
   std::set<DBusHandleMessageFunction> filter_functions_added_;
 
   // ObjectProxyTable is used to hold the object proxies created by the
   // bus object. Key is a concatenated string of service name + object path,
@@ skipping 16 matching lines @@
   // OnAddTimeout()/OnRemoveTimeou() are balanced.
   int num_pending_watches_;
   int num_pending_timeouts_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_