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

dbus/bus.cc

 // 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.
 //
 // TODO(satorux):
 // - Handle "disconnected" signal.
 // - Collect metrics (ex. # of method calls, method call time, etc.)
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "dbus/exported_object.h"
 #include "dbus/object_proxy.h"
 #include "dbus/scoped_dbus_error.h"
 
 namespace dbus {
 
@@ skipping 137 matching lines @@
 
   DBusTimeout* raw_timeout_;
   bool monitoring_is_active_;
   bool is_completed;
 };
 
 }  // namespace
 
 Bus::Options::Options()
   : bus_type(SESSION),
-    connection_type(PRIVATE),
-    dbus_thread(NULL) {
+    connection_type(PRIVATE) {
 }
 
 Bus::Options::~Options() {
 }
 
 Bus::Bus(const Options& options)
     : bus_type_(options.bus_type),
       connection_type_(options.connection_type),
-      dbus_thread_(options.dbus_thread),
+      dbus_thread_message_loop_proxy_(options.dbus_thread_message_loop_proxy),
       on_shutdown_(false /* manual_reset */, false /* initially_signaled */),
       connection_(NULL),
       origin_loop_(MessageLoop::current()),
       origin_thread_id_(base::PlatformThread::CurrentId()),
-      dbus_thread_id_(base::kInvalidThreadId),
       async_operations_set_up_(false),
       shutdown_completed_(false),
       num_pending_watches_(0),
       num_pending_timeouts_(0) {
-  if (dbus_thread_) {
-    dbus_thread_id_ = dbus_thread_->thread_id();
-    DCHECK(dbus_thread_->IsRunning())
-        << "The D-Bus thread should be running";
-    DCHECK_EQ(MessageLoop::TYPE_IO,
-              dbus_thread_->message_loop()->type())
-        << "The D-Bus thread should have an MessageLoopForIO attached";
-  }
-
   // This is safe to call multiple times.
   dbus_threads_init_default();
 }
 
 Bus::~Bus() {
   DCHECK(!connection_);
   DCHECK(owned_service_names_.empty());
   DCHECK(match_rules_added_.empty());
   DCHECK(filter_functions_added_.empty());
   DCHECK(registered_object_paths_.empty());
@@ skipping 98 matching lines @@
     // dbus_connection_close() won't unref.
     dbus_connection_unref(connection_);
   }
 
   connection_ = NULL;
   shutdown_completed_ = true;
 }
 
 void Bus::ShutdownOnDBusThreadAndBlock() {
   AssertOnOriginThread();
-  DCHECK(dbus_thread_);
+  DCHECK(dbus_thread_message_loop_proxy_.get());
 
   PostTaskToDBusThread(FROM_HERE, base::Bind(
       &Bus::ShutdownOnDBusThreadAndBlockInternal,
       this));
 
   // Wait until the shutdown is complete on the D-Bus thread.
   // The shutdown should not hang, but set timeout just in case.
   const int kTimeoutSecs = 3;
   const base::TimeDelta timeout(base::TimeDelta::FromSeconds(kTimeoutSecs));
   const bool signaled = on_shutdown_.TimedWait(timeout);
@@ skipping 240 matching lines @@
   }
 }
 
 void Bus::PostTaskToOriginThread(const tracked_objects::Location& from_here,
                                  const base::Closure& task) {
   origin_loop_->PostTask(from_here, task);
 }
 
 void Bus::PostTaskToDBusThread(const tracked_objects::Location& from_here,
                                const base::Closure& task) {
-  if (dbus_thread_)
-    dbus_thread_->message_loop()->PostTask(from_here, task);
+  if (dbus_thread_message_loop_proxy_.get())
+    dbus_thread_message_loop_proxy_->PostTask(from_here, task);
   else
     origin_loop_->PostTask(from_here, task);
 }
 
 void Bus::PostDelayedTaskToDBusThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     int delay_ms) {
-  if (dbus_thread_)
-    dbus_thread_->message_loop()->PostDelayedTask(from_here, task, delay_ms);
+  if (dbus_thread_message_loop_proxy_.get())
+    dbus_thread_message_loop_proxy_->PostDelayedTask(from_here, task, delay_ms);
   else
     origin_loop_->PostDelayedTask(from_here, task, delay_ms);
 }
 
 bool Bus::HasDBusThread() {
-  return dbus_thread_ != NULL;
+  return dbus_thread_message_loop_proxy_.get() != NULL;
 }
 
 void Bus::AssertOnOriginThread() {
   DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
 }
 
 void Bus::AssertOnDBusThread() {
   base::ThreadRestrictions::AssertIOAllowed();
 
-  if (dbus_thread_) {
-    DCHECK_EQ(dbus_thread_id_, base::PlatformThread::CurrentId());
+  if (dbus_thread_message_loop_proxy_.get()) {
+    DCHECK(dbus_thread_message_loop_proxy_->BelongsToCurrentThread());
   } else {
     AssertOnOriginThread();
   }
 }
 
 dbus_bool_t Bus::OnAddWatch(DBusWatch* raw_watch) {
   AssertOnDBusThread();
 
   // watch will be deleted when raw_watch is removed in OnRemoveWatch().
   Watch* watch = new Watch(raw_watch);
@@ skipping 105 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus