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 193 matching lines @@
   DCHECK(match_rules_added_.empty());
   DCHECK(filter_functions_added_.empty());
   DCHECK(registered_object_paths_.empty());
   DCHECK_EQ(0, num_pending_watches_);
   // TODO(satorux): This check fails occasionally in browser_tests for tests
   // that run very quickly. Perhaps something does not have time to clean up.
   // Despite the check failing, the tests seem to run fine. crosbug.com/23416
   // DCHECK_EQ(0, num_pending_timeouts_);
 }
 
+void Bus::SetDisconnectedCallback(const base::Closure& closure) {
+  on_disconnected_closure_ = closure;
+}
+
 ObjectProxy* Bus::GetObjectProxy(const std::string& service_name,
                                  const ObjectPath& object_path) {
   return GetObjectProxyWithOptions(service_name, object_path,
                                    ObjectProxy::DEFAULT_OPTIONS);
 }
 
 ObjectProxy* Bus::GetObjectProxyWithOptions(const std::string& service_name,
                                             const dbus::ObjectPath& object_path,
                                             int options) {
   AssertOnOriginThread();
@@ skipping 142 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::CloseConnection() {
+  // dbus_connection_close is blocking call.
+  AssertOnDBusThread();
+
+  if (connection_type_ == PRIVATE)
+    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 482 matching lines @@
                                   this));
 }
 
 void Bus::OnConnectionDisconnected(DBusConnection* connection) {
   AssertOnDBusThread();
 
   if (!connection)
     return;
   DCHECK(!dbus_connection_get_is_connected(connection));
 
+  if (!on_disconnected_closure_.is_null())
+    PostTaskToOriginThread(FROM_HERE, on_disconnected_closure_);
+
   if (shutdown_completed_)
     return;  // Do nothing if the shutdown is already completed.
 
   // Unexpected disconnection, maybe the peer closes the connection.
   DCHECK_EQ(connection, connection_);
   ShutdownAndBlock();
 }
 
 dbus_bool_t Bus::OnAddWatchThunk(DBusWatch* raw_watch, void* data) {
   Bus* self = static_cast<Bus*>(data);
@@ skipping 41 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