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.
 //
@@ skipping 37 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));
+//   bool success = !!response.get();

[satorux1, 2011/09/06 17:15:57]

Thank you for updating this!

!! is a bit tricky. Something like this may be more useful as example code:

  if (response.get()) {  // Success.
    ...

[Mike Mammarella, 2011/09/06 19:11:08]

Done.

 //
 // 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 is set, the bus object will use that message loop to
+    // process asynchronous operations. While the type of dbus_thread is
+    // MessageLoopProxy, this is only for convenience so it can be set with
+    // BrowserThread::GetMessageLoopProxyForThread().

[satorux1, 2011/09/06 17:15:57]

I like the idea of using MessageLoopProxy.

The name |dbus_thread| may be a bit irrelevant. It's a bit long but what about
dbus_thread_message_loop_proxy? Then, I think you can remove the excuse about
the type of dbus_thread.

[Mike Mammarella, 2011/09/06 19:11:08]

Done.

     //
     // The thread should meet the following requirements:
     // 1) Already running.
     // 2) Has a MessageLoopForIO.
     // 3) Outlives the bus.

[satorux1, 2011/09/06 17:15:57]

3) may be now irrelevant, as MessageLoopProxy takes care of the lifetime
problem.

[Mike Mammarella, 2011/09/06 19:11:08]

Done.

-    base::Thread* dbus_thread;  // NULL by default.
+    scoped_refptr<base::MessageLoopProxy> dbus_thread;  // NULL by default.
   };
 
   // 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_;
   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_