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),
       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_) {

[Mike Mammarella, 2011/09/04 19:23:52]

These DCHECKs are the only thing really "lost" in this change. I did not see any
way to check that the actual thread behind the message loop proxy is running, or
to examine its type. (Note that we can still check if we are on it, because
MessageLoopProxy does provide that.)

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

Never mind. The program will fail soon, if the message loop proxy is used
incorrectly. For instance, MessageLoopForIO::current() used in Watch class will
fail if the type is not IO.

-    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 360 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);
+    dbus_thread_->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);
+    dbus_thread_->PostDelayedTask(from_here, task, delay_ms);
   else
     origin_loop_->PostDelayedTask(from_here, task, delay_ms);
 }
 
 bool Bus::HasDBusThread() {
   return dbus_thread_ != 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());
+    DCHECK(dbus_thread_->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