Call get_dispatch_status function to handle 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.
-//
-// TODO(satorux):
-// - Handle "disconnected" signal.
 
 #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_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/scoped_dbus_error.h"
 
 namespace dbus {
 
 namespace {
 
+const char kDisconnectedSignal[] = "Disconnected";
+const char kDisconnectedMatchRule[] =
+    "type='signal', path='/org/freedesktop/DBus/Local',"
+    "interface='org.freedesktop.DBus.Local', member='Disconnected'";
+
 // The class is used for watching the file descriptor used for D-Bus
 // communication.
 class Watch : public base::MessagePumpLibevent::Watcher {
  public:
   Watch(DBusWatch* watch)
       : raw_watch_(watch) {
     dbus_watch_set_data(raw_watch_, this, NULL);
   }
 
   virtual ~Watch() {
@@ skipping 320 matching lines @@
     // called internally.
     if (!dbus_bus_register(connection_, error.get())) {
       LOG(ERROR) << "Failed to register the bus component: "
                  << (error.is_set() ? error.message() : "");
       return false;
     }
   }
   // 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::ShutdownAndBlock() {
   AssertOnDBusThread();
 
+  if (shutdown_completed_)
+    return;  // Already shutdowned, just return.

[satorux1, 2013/02/08 13:39:06]

Do we need this? Looks unnecessary.

+
   // Unregister the exported objects.
   for (ExportedObjectTable::iterator iter = exported_object_table_.begin();
        iter != exported_object_table_.end(); ++iter) {
     iter->second->Unregister();
   }
 
   // Release all service names.
   for (std::set<std::string>::iterator iter = owned_service_names_.begin();
        iter != owned_service_names_.end();) {
     // This is a bit tricky but we should increment the iter here as
@@ skipping 13 matching lines @@
   }
 
   // Release object proxies and exported objects here. We should do this
   // here rather than in the destructor to avoid memory leaks due to
   // cyclic references.
   object_proxy_table_.clear();
   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_);
     // dbus_connection_close() won't unref.
     dbus_connection_unref(connection_);
   }
 
   connection_ = NULL;
   shutdown_completed_ = true;
 }
 
@@ skipping 281 matching lines @@
   AssertOnDBusThread();
 
   ShutdownAndBlock();
   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_))
+  if (!connection_)
     return;
 
+  // It is safe and necessary to call dbus_connection_get_dispatch_status even
+  // if the connection is lost. Otherwise we will miss "Disconnected" signal.
+  // (crbug.com/174431)
   if (dbus_connection_get_dispatch_status(connection_) ==
       DBUS_DISPATCH_DATA_REMAINS) {
     while (dbus_connection_dispatch(connection_) ==
            DBUS_DISPATCH_DATA_REMAINS);
   }
 }
 
 void Bus::PostTaskToOriginThread(const tracked_objects::Location& from_here,
                                  const base::Closure& task) {
   DCHECK(origin_message_loop_proxy_.get());
@@ skipping 115 matching lines @@
   } else {
     timeout->StopMonitoring();
   }
 }
 
 void Bus::OnDispatchStatusChanged(DBusConnection* connection,
                                   DBusDispatchStatus status) {
   DCHECK_EQ(connection, connection_);
   AssertOnDBusThread();
 
-  if (!dbus_connection_get_is_connected(connection))
-    return;
-
   // We cannot call ProcessAllIncomingDataIfAny() here, as calling
   // dbus_connection_dispatch() inside DBusDispatchStatusFunction is
   // 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 (!connection)
+    return;
+  DCHECK(!dbus_connection_get_is_connected(connection));
+
+  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);
   return self->OnAddWatch(raw_watch);
 }
 
 void Bus::OnRemoveWatchThunk(DBusWatch* raw_watch, void* data) {
   Bus* self = static_cast<Bus*>(data);
   self->OnRemoveWatch(raw_watch);
 }
 
@@ skipping 17 matching lines @@
   self->OnToggleTimeout(raw_timeout);
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   self->OnDispatchStatusChanged(connection, status);
 }
 
+DBusHandlerResult Bus::OnConnectionDisconnectedFilter(
+    DBusConnection *connection,
+    DBusMessage *message,
+    void *data) {
+  if (dbus_message_is_signal(message,
+                             DBUS_INTERFACE_LOCAL,
+                             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