Supporting callback for Disconnected signal.

dbus/bus.cc

 // Copyright (c) 2012 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.
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 171 matching lines @@
     : bus_type_(options.bus_type),
       connection_type_(options.connection_type),
       dbus_thread_message_loop_proxy_(options.dbus_thread_message_loop_proxy),
       on_shutdown_(false /* manual_reset */, false /* initially_signaled */),
       connection_(NULL),
       origin_thread_id_(base::PlatformThread::CurrentId()),
       async_operations_set_up_(false),
       shutdown_completed_(false),
       num_pending_watches_(0),
       num_pending_timeouts_(0),
-      address_(options.address) {
+      address_(options.address),
+      on_disconnected_closure_(options.disconnected_callback) {
   // This is safe to call multiple times.
   dbus_threads_init_default();
   // The origin message loop is unnecessary if the client uses synchronous
   // functions only.
   if (MessageLoop::current())
     origin_message_loop_proxy_ =  MessageLoop::current()->message_loop_proxy();
 }
 
 Bus::~Bus() {
   DCHECK(!connection_);
@@ skipping 163 matching lines @@
   // We shouldn't exit on the disconnected signal.
   dbus_connection_set_exit_on_disconnect(connection_, false);
 
   // Watch Disconnected signal.
   AddFilterFunction(Bus::OnConnectionDisconnectedFilter, this);
   AddMatch(kDisconnectedMatchRule, error.get());
 
   return true;
 }
 
+void Bus::ClosePrivateConnection() {
+  // dbus_connection_close is blocking call.
+  AssertOnDBusThread();
+  DCHECK_EQ(PRIVATE, connection_type_)
+      << "non-private connection should not be closed";
+  dbus_connection_close(connection_);
+}
+
 void Bus::ShutdownAndBlock() {
   AssertOnDBusThread();
 
   if (shutdown_completed_)
     return;  // Already shutdowned, just return.
 
   // Unregister the exported objects.
   for (ExportedObjectTable::iterator iter = exported_object_table_.begin();
        iter != exported_object_table_.end(); ++iter) {
     iter->second->Unregister();
@@ skipping 25 matching lines @@
   exported_object_table_.clear();
 
   // Private connection should be closed.
   if (connection_) {
     // Remove Disconnected watcher.
     ScopedDBusError error;
     RemoveFilterFunction(Bus::OnConnectionDisconnectedFilter, this);
     RemoveMatch(kDisconnectedMatchRule, error.get());
 
     if (connection_type_ == PRIVATE)
-      dbus_connection_close(connection_);
+      ClosePrivateConnection();
     // dbus_connection_close() won't unref.
     dbus_connection_unref(connection_);
   }
 
   connection_ = NULL;
   shutdown_completed_ = true;
 }
 
 void Bus::ShutdownOnDBusThreadAndBlock() {
   AssertOnOriginThread();
@@ skipping 432 matching lines @@
   // prohibited by the D-Bus library. Hence, we post a task here instead.
   // See comments for dbus_connection_set_dispatch_status_function().
   PostTaskToDBusThread(FROM_HERE,
                        base::Bind(&Bus::ProcessAllIncomingDataIfAny,
                                   this));
 }
 
 void Bus::OnConnectionDisconnected(DBusConnection* connection) {
   AssertOnDBusThread();
 
+  if (!on_disconnected_closure_.is_null())
+    PostTaskToOriginThread(FROM_HERE, on_disconnected_closure_);
+
   if (!connection)
     return;
   DCHECK(!dbus_connection_get_is_connected(connection));
 
   ShutdownAndBlock();
 }
 
 dbus_bool_t Bus::OnAddWatchThunk(DBusWatch* raw_watch, void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnAddWatch(raw_watch);
@@ skipping 40 matching lines @@
                              kDisconnectedSignal)) {
     Bus* self = static_cast<Bus*>(data);
     self->AssertOnDBusThread();
     self->OnConnectionDisconnected(connection);
     return DBUS_HANDLER_RESULT_HANDLED;
   }
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus