Call get_dispatch_status function to handle Disconnected signal.

dbus/bus.h

 // 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.
 
 #ifndef DBUS_BUS_H_
 #define DBUS_BUS_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 282 matching lines @@
   // Must be called in the origin thread.
   virtual void UnregisterExportedObject(const ObjectPath& object_path);
 
   // Shuts down the bus and blocks until it's done. More specifically, this
   // function does the following:
   //
   // - Unregisters the object paths
   // - Releases the service names
   // - Closes the connection to dbus-daemon.
   //
+  // This function can be called multiple times and it is no-op for the 2nd time
+  // calling.
+  //
   // BLOCKING CALL.
   virtual void ShutdownAndBlock();
 
   // Similar to ShutdownAndBlock(), but this function is used to
   // synchronously shut down the bus that uses the D-Bus thread. This
   // function is intended to be used at the very end of the browser
   // shutdown, where it makes more sense to shut down the bus
   // synchronously, than trying to make it asynchronous.
   //
   // BLOCKING CALL, but must be called in the origin thread.
@@ skipping 214 matching lines @@
   void OnRemoveTimeout(DBusTimeout* raw_timeout);
 
   // Called when the "enabled" status of |raw_timeout| is toggled.
   void OnToggleTimeout(DBusTimeout* raw_timeout);
 
   // Called when the dispatch status (i.e. if any incoming data is
   // available) is changed.
   void OnDispatchStatusChanged(DBusConnection* connection,
                                DBusDispatchStatus status);
 
+  // Called when the connection is diconnected.
+  void OnConnectionDisconnected(DBusConnection* connection);
+
   // Callback helper functions. Redirects to the corresponding member function.
   static dbus_bool_t OnAddWatchThunk(DBusWatch* raw_watch, void* data);
   static void OnRemoveWatchThunk(DBusWatch* raw_watch, void* data);
   static void OnToggleWatchThunk(DBusWatch* raw_watch, void* data);
   static dbus_bool_t OnAddTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnRemoveTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnToggleTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnDispatchStatusChangedThunk(DBusConnection* connection,
                                            DBusDispatchStatus status,
                                            void* data);
+
+  // Calls OnConnectionDisconnected if the Diconnected signal is received.
+  static DBusHandlerResult OnConnectionDisconnectedFilter(
+      DBusConnection *connection,
+      DBusMessage *message,
+      void *user_data);
+
   const BusType bus_type_;
   const ConnectionType connection_type_;
   scoped_refptr<base::MessageLoopProxy> dbus_thread_message_loop_proxy_;
   base::WaitableEvent on_shutdown_;
   DBusConnection* connection_;
 
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   base::PlatformThreadId origin_thread_id_;
 
   std::set<std::string> owned_service_names_;
@@ skipping 31 matching lines @@
   int num_pending_timeouts_;
 
   std::string address_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_