Add Bus::ShutdownOnDBusThreadAndBlock() and remove bus::Shutdown()

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/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 {
 
 namespace {
 
 // The class is used for watching the file descriptor used for D-Bus
 // communication.
@@ skipping 144 matching lines @@
     dbus_thread(NULL) {
 }
 
 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_) {
     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";
   }
@@ skipping 96 matching lines @@
                << owned_service_names_.size();
   }
 
   // Detach from the remote objects.
   for (ObjectProxyTable::iterator iter = object_proxy_table_.begin();
        iter != object_proxy_table_.end(); ++iter) {
     iter->second->Detach();
   }
 
   // Private connection should be closed.
-  if (connection_ && connection_type_ == PRIVATE) {
-    dbus_connection_close(connection_);
+  if (connection_) {
+    if (connection_type_ == PRIVATE)
+      dbus_connection_close(connection_);
+    // dbus_connection_close() won't unref.
+    dbus_connection_unref(connection_);
   }
-  // dbus_connection_close() won't unref.
-  dbus_connection_unref(connection_);
 
   connection_ = NULL;
+  shutdown_completed_ = true;
 }
 
-void Bus::Shutdown(OnShutdownCallback callback) {
+void Bus::ShutdownOnDBusThreadAndBlock() {
   AssertOnOriginThread();
+  DCHECK(dbus_thread_);
 
-  PostTaskToDBusThread(FROM_HERE, base::Bind(&Bus::ShutdownInternal,
-                                             this,
-                                             callback));
+  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);
+  LOG_IF(ERROR, !signaled) << "Failed to shutdown the bus";
 }
 
 bool Bus::RequestOwnership(const std::string& service_name) {
   DCHECK(connection_);
   // dbus_bus_request_name() is a blocking call.
   AssertOnDBusThread();
 
   // Check if we already own the service name.
   if (owned_service_names_.find(service_name) != owned_service_names_.end()) {
     return true;
@@ skipping 201 matching lines @@
     return;
   }
 
   const bool success = dbus_connection_unregister_object_path(
       connection_,
       object_path.c_str());
   CHECK(success) << "Unable to allocate memory";
   registered_object_paths_.erase(object_path);
 }
 
-void Bus::ShutdownInternal(OnShutdownCallback callback) {
+void Bus::ShutdownOnDBusThreadAndBlockInternal() {
   AssertOnDBusThread();
 
   ShutdownAndBlock();
-  PostTaskToOriginThread(FROM_HERE, callback);
+  on_shutdown_.Signal();
 }
 
 void Bus::ProcessAllIncomingDataIfAny() {
   AssertOnDBusThread();
 
   // As mentioned at the class comment in .h file, connection_ can be NULL.
   if (!connection_ || !dbus_connection_get_is_connected(connection_))
     return;
 
   if (dbus_connection_get_dispatch_status(connection_) ==
@@ skipping 157 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus