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

dbus/bus.h

 // 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.
 
 #ifndef DBUS_BUS_H_
 #define DBUS_BUS_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <dbus/dbus.h>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/tracked_objects.h"
 
 class MessageLoop;
 
 namespace base {
 class Thread;
 }
 
 namespace dbus {
@@ skipping 191 matching lines @@
   //
   // BLOCKING CALL.
   virtual void ShutdownAndBlock();
 
   // Shuts down the bus in the D-Bus thread. |callback| will be called in
   // the origin thread.
   //
   // Must be called in the origin thread.
   virtual void Shutdown(OnShutdownCallback callback);
 
+  // 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.
+  virtual void ShutdownAndBlockWithDBusThread();

[stevenjb, 2011/09/01 17:53:44]

Do we need to expose both ShutdownAndBlock and ShutdownAndBlockWithDBusThread in
the public API, or could we make this ShutdownAndBlock, and the make the
existing function private, e.g. ShutdownAndBlockInternal? It seems a bit
excessive to have three public Shutdown methods.

[satorux1, 2011/09/01 17:57:30]

ShutdownAndBlock() is already used in wifi_data_provider_linux.cc, that runs on
its own thread.

ShutdownAndBlockWithDBusThread() will be used.

Shutdown() is currently only used in tests. This can be removed, as we probably
don't use it in the production code.

[stevenjb, 2011/09/01 18:19:33]

OK. In that case I suggest we name this ShutdownOnDBusThreadAndBlock(), and make
Shutdown() private (with tests as friends) or remove it.

+
+  // Returns true if the shutdown has been completed.
+  bool shutdown_completed() { return shutdown_completed_; }
+
   //
   // The public functions below are not intended to be used in client
   // code. These are used to implement ObjectProxy and ExportedObject.
   //
 
   // Connects the bus to the dbus-daemon.
   // Returns true on success, or the bus is already connected.
   //
   // BLOCKING CALL.
   virtual bool Connect();
@@ skipping 139 matching lines @@
  protected:
   // This is protected, so we can define sub classes.
   virtual ~Bus();
 
  private:
   friend class base::RefCountedThreadSafe<Bus>;
 
   // Helper function used for Shutdown().
   void ShutdownInternal(OnShutdownCallback callback);
 
+  // Helper function used for ShutdownAndBlockWithDBusThread().
+  void ShutdownAndBlockWithDBusThreadInternal();
+
   // Processes the all incoming data to the connection, if any.
   //
   // BLOCKING CALL.
   void ProcessAllIncomingDataIfAny();
 
   // Called when a watch object is added. Used to start monitoring the
   // file descriptor used for D-Bus communication.
   dbus_bool_t OnAddWatch(DBusWatch* raw_watch);
 
   // Called when a watch object is removed.
@@ skipping 23 matching lines @@
   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);
   const BusType bus_type_;
   const ConnectionType connection_type_;
   base::Thread* dbus_thread_;
+  base::WaitableEvent on_shutdown_;
   DBusConnection* connection_;
 
   MessageLoop* origin_loop_;
   base::PlatformThreadId origin_thread_id_;
   base::PlatformThreadId dbus_thread_id_;
 
   std::set<std::string> owned_service_names_;
   // The following sets are used to check if rules/object_paths/filters
   // are properly cleaned up before destruction of the bus object.
   std::set<std::string> match_rules_added_;
   std::set<std::string> registered_object_paths_;
   std::set<DBusHandleMessageFunction> filter_functions_added_;
 
   // ObjectProxyTable is used to hold the object proxies created by the
   // bus object. Key is a concatenated string of service name + object path,
   // like "org.chromium.TestService/org/chromium/TestObject".
   typedef std::map<std::string,
                    scoped_refptr<dbus::ObjectProxy> > ObjectProxyTable;
   ObjectProxyTable object_proxy_table_;
 
   // ExportedObjectTable is used to hold the exported objects created by
   // the bus object. Key is a concatenated string of service name +
   // object path, like "org.chromium.TestService/org/chromium/TestObject".
   typedef std::map<std::string,
                    scoped_refptr<dbus::ExportedObject> > ExportedObjectTable;
   ExportedObjectTable exported_object_table_;
 
   bool async_operations_set_up_;
+  bool shutdown_completed_;
 
   // Counters to make sure that OnAddWatch()/OnRemoveWatch() and
   // OnAddTimeout()/OnRemoveTimeou() are balanced.
   int num_pending_watches_;
   int num_pending_timeouts_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_