Improve network stub behavior

chromeos/dbus/dbus_thread_manager.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 "chromeos/dbus/dbus_thread_manager.h"
 
 #include <map>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
@@ skipping 36 matching lines @@
 #include "dbus/dbus_statistics.h"
 
 namespace chromeos {
 
 static DBusThreadManager* g_dbus_thread_manager = NULL;
 static bool g_dbus_thread_manager_set_for_testing = false;
 
 // The DBusThreadManager implementation used in production.
 class DBusThreadManagerImpl : public DBusThreadManager {
  public:
-  explicit DBusThreadManagerImpl(DBusClientImplementationType client_type) {
+  explicit DBusThreadManagerImpl(DBusClientImplementationType client_type)
+      : client_type_(client_type),
+        client_type_override_(client_type) {
     // If --dbus-stub was requested, pass STUB to specific components;
     // Many components like login are not useful with a stub implementation.
-    DBusClientImplementationType client_type_maybe_stub = client_type;
     if (CommandLine::ForCurrentProcess()->HasSwitch(
-            chromeos::switches::kDbusStub))
-      client_type_maybe_stub = STUB_DBUS_CLIENT_IMPLEMENTATION;
+            chromeos::switches::kDbusStub)) {
+      client_type_override_ = STUB_DBUS_CLIENT_IMPLEMENTATION;
+    }
 
     // Create the D-Bus thread.
     base::Thread::Options thread_options;
     thread_options.message_loop_type = MessageLoop::TYPE_IO;
     dbus_thread_.reset(new base::Thread("D-Bus thread"));
     dbus_thread_->StartWithOptions(thread_options);
 
     // Create the connection to the system bus.
     dbus::Bus::Options system_bus_options;
     system_bus_options.bus_type = dbus::Bus::SYSTEM;
     system_bus_options.connection_type = dbus::Bus::PRIVATE;
     system_bus_options.dbus_task_runner = dbus_thread_->message_loop_proxy();
     system_bus_ = new dbus::Bus(system_bus_options);
+  }
 
+  // InitializeClients gets called after g_dbus_thread_manager is set.
+  // NOTE: Clients that access other clients in their constructor must be
+  // construced in the correct order.
+  void InitializeClients() {
     bluetooth_manager_client_.reset(BluetoothManagerClient::Create(
-        client_type, system_bus_.get()));
+        client_type_, system_bus_.get()));
     bluetooth_adapter_client_.reset(BluetoothAdapterClient::Create(
-        client_type, system_bus_.get(), bluetooth_manager_client_.get()));
+        client_type_, system_bus_.get(), bluetooth_manager_client_.get()));
     bluetooth_device_client_.reset(BluetoothDeviceClient::Create(
-        client_type, system_bus_.get(), bluetooth_adapter_client_.get()));
+        client_type_, system_bus_.get(), bluetooth_adapter_client_.get()));
     bluetooth_input_client_.reset(BluetoothInputClient::Create(
-        client_type, system_bus_.get(), bluetooth_adapter_client_.get()));
+        client_type_, system_bus_.get(), bluetooth_adapter_client_.get()));
     bluetooth_node_client_.reset(BluetoothNodeClient::Create(
-        client_type, system_bus_.get(), bluetooth_device_client_.get()));
+        client_type_, system_bus_.get(), bluetooth_device_client_.get()));
     bluetooth_out_of_band_client_.reset(BluetoothOutOfBandClient::Create(
-        client_type, system_bus_.get()));
+        client_type_, system_bus_.get()));
     cros_disks_client_.reset(
-        CrosDisksClient::Create(client_type, system_bus_.get()));
+        CrosDisksClient::Create(client_type_, system_bus_.get()));
     cryptohome_client_.reset(
-        CryptohomeClient::Create(client_type, system_bus_.get()));
+        CryptohomeClient::Create(client_type_, system_bus_.get()));
     debug_daemon_client_.reset(
-        DebugDaemonClient::Create(client_type, system_bus_.get()));
+        DebugDaemonClient::Create(client_type_, system_bus_.get()));
+
+    shill_manager_client_.reset(
+        ShillManagerClient::Create(client_type_override_, system_bus_.get()));
     shill_device_client_.reset(
-        ShillDeviceClient::Create(client_type, system_bus_.get()));
+        ShillDeviceClient::Create(client_type_override_, system_bus_.get()));
     shill_ipconfig_client_.reset(
-        ShillIPConfigClient::Create(client_type, system_bus_.get()));
-    shill_manager_client_.reset(
-        ShillManagerClient::Create(client_type, system_bus_.get()));
+        ShillIPConfigClient::Create(client_type_override_, system_bus_.get()));
     shill_profile_client_.reset(
-        ShillProfileClient::Create(client_type, system_bus_.get()));
+        ShillProfileClient::Create(client_type_override_, system_bus_.get()));
     shill_service_client_.reset(
-        ShillServiceClient::Create(client_type, system_bus_.get()));
+        ShillServiceClient::Create(client_type_override_, system_bus_.get()));
     gsm_sms_client_.reset(
-        GsmSMSClient::Create(client_type, system_bus_.get()));
-    image_burner_client_.reset(ImageBurnerClient::Create(client_type,
+        GsmSMSClient::Create(client_type_override_, system_bus_.get()));
+
+    image_burner_client_.reset(ImageBurnerClient::Create(client_type_,
                                                          system_bus_.get()));
     introspectable_client_.reset(
-        IntrospectableClient::Create(client_type, system_bus_.get()));
+        IntrospectableClient::Create(client_type_, system_bus_.get()));
     modem_messaging_client_.reset(
-        ModemMessagingClient::Create(client_type, system_bus_.get()));
+        ModemMessagingClient::Create(client_type_, system_bus_.get()));
     permission_broker_client_.reset(
-        PermissionBrokerClient::Create(client_type, system_bus_.get()));
+        PermissionBrokerClient::Create(client_type_, system_bus_.get()));
     power_manager_client_.reset(
-        PowerManagerClient::Create(client_type_maybe_stub, system_bus_.get()));
+        PowerManagerClient::Create(client_type_override_, system_bus_.get()));
     session_manager_client_.reset(
-        SessionManagerClient::Create(client_type, system_bus_.get()));
+        SessionManagerClient::Create(client_type_, system_bus_.get()));
     sms_client_.reset(
-        SMSClient::Create(client_type, system_bus_.get()));
+        SMSClient::Create(client_type_, system_bus_.get()));
     update_engine_client_.reset(
-        UpdateEngineClient::Create(client_type, system_bus_.get()));
+        UpdateEngineClient::Create(client_type_, system_bus_.get()));
 
     // PowerPolicyController is dependent on PowerManagerClient, so
     // initialize it after the main list of clients.
     power_policy_controller_.reset(
         new PowerPolicyController(this, power_manager_client_.get()));
   }
 
   virtual ~DBusThreadManagerImpl() {
     FOR_EACH_OBSERVER(DBusThreadManagerObserver, observers_,
                       OnDBusThreadManagerDestroying(this));
@@ skipping 205 matching lines @@
       return;
     }
     delete ibus_engine_services_[object_path];
     ibus_engine_services_.erase(object_path);
   }
 
   virtual IBusPanelService* GetIBusPanelService() OVERRIDE {
     return ibus_panel_service_.get();
   }
 
+  DBusClientImplementationType client_type_;
+  DBusClientImplementationType client_type_override_;
+
   // Note: Keep this before other members so they can call AddObserver() in
   // their c'tors.
   ObserverList<DBusThreadManagerObserver> observers_;
 
   scoped_ptr<base::Thread> dbus_thread_;
   scoped_refptr<dbus::Bus> system_bus_;
   scoped_refptr<dbus::Bus> ibus_bus_;
   scoped_ptr<BluetoothAdapterClient> bluetooth_adapter_client_;
   scoped_ptr<BluetoothDeviceClient> bluetooth_device_client_;
   scoped_ptr<BluetoothInputClient> bluetooth_input_client_;
@@ skipping 30 matching lines @@
 
 // static
 void DBusThreadManager::Initialize() {
   // Ignore Initialize() if we set a test DBusThreadManager.
   if (g_dbus_thread_manager_set_for_testing)
     return;
   // If we initialize DBusThreadManager twice we may also be shutting it down
   // early; do not allow that.
   CHECK(g_dbus_thread_manager == NULL);
   // Determine whether we use stub or real client implementations.
+  DBusThreadManagerImpl* dbus_thread_manager_impl;
   if (base::chromeos::IsRunningOnChromeOS()) {
-    g_dbus_thread_manager =
+    dbus_thread_manager_impl =
         new DBusThreadManagerImpl(REAL_DBUS_CLIENT_IMPLEMENTATION);
     VLOG(1) << "DBusThreadManager initialized for ChromeOS";
   } else {
-    g_dbus_thread_manager =
+    dbus_thread_manager_impl =
         new DBusThreadManagerImpl(STUB_DBUS_CLIENT_IMPLEMENTATION);
     VLOG(1) << "DBusThreadManager initialized with Stub";
   }
+  g_dbus_thread_manager = dbus_thread_manager_impl;
+  dbus_thread_manager_impl->InitializeClients();
 }
 
 // static
 void DBusThreadManager::InitializeForTesting(
     DBusThreadManager* dbus_thread_manager) {
   // If we initialize DBusThreadManager twice we may also be shutting it down
   // early; do not allow that.
   CHECK(g_dbus_thread_manager == NULL);
   CHECK(dbus_thread_manager);
   g_dbus_thread_manager = dbus_thread_manager;
   g_dbus_thread_manager_set_for_testing = true;
   VLOG(1) << "DBusThreadManager initialized with test implementation";
 }
 
 // static
 void DBusThreadManager::InitializeWithStub() {
   // If we initialize DBusThreadManager twice we may also be shutting it down
   // early; do not allow that.
   CHECK(g_dbus_thread_manager == NULL);
-  g_dbus_thread_manager =
-        new DBusThreadManagerImpl(STUB_DBUS_CLIENT_IMPLEMENTATION);
+  DBusThreadManagerImpl* dbus_thread_manager_impl =
+      new DBusThreadManagerImpl(STUB_DBUS_CLIENT_IMPLEMENTATION);
+  g_dbus_thread_manager = dbus_thread_manager_impl;
+  dbus_thread_manager_impl->InitializeClients();
   VLOG(1) << "DBusThreadManager initialized with stub implementation";
 }
 
 // static
 bool DBusThreadManager::IsInitialized() {
   return g_dbus_thread_manager != NULL;
 }
 
 // static
 void DBusThreadManager::Shutdown() {
@@ skipping 14 matching lines @@
 }
 
 // static
 DBusThreadManager* DBusThreadManager::Get() {
   CHECK(g_dbus_thread_manager)
       << "DBusThreadManager::Get() called before Initialize()";
   return g_dbus_thread_manager;
 }
 
 }  // namespace chromeos