Fix minor issues about DBusThreadManager.

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 "base/command_line.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 36 matching lines @@
 #include "chromeos/dbus/system_clock_client.h"
 #include "chromeos/dbus/update_engine_client.h"
 #include "dbus/bus.h"
 #include "dbus/dbus_statistics.h"
 
 namespace chromeos {
 
 static DBusThreadManager* g_dbus_thread_manager = NULL;
 static bool g_using_dbus_thread_manager_for_testing = false;
 
-DBusClientBundle::DBusClientTypeMask
-    DBusThreadManager::unstub_client_mask_ = DBusClientBundle::NO_CLIENTS;
+DBusThreadManager::DBusThreadManager(scoped_ptr<DBusClientBundle> client_bundle)
+    : client_bundle_(client_bundle.Pass()) {
+  dbus::statistics::Initialize();
 
-DBusThreadManager::DBusThreadManager() {
-  dbus::statistics::Initialize();
-  if (!DBusThreadManager::IsUsingStub(DBusClientBundle::ALL_CLIENTS)) {
+  if (client_bundle_->IsUsingAnyRegularClient()) {
+    // At least one real DBusClient is used.
     // Create the D-Bus thread.
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::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);
   }
 
-  CreateDefaultClients();
+  // TODO(crbug.com/345586): Move PowerPolicyController out of
+  // DBusThreadManager.
+  power_policy_controller_.reset(new PowerPolicyController);
 }
 
 DBusThreadManager::~DBusThreadManager() {
   // PowerPolicyController's destructor depends on PowerManagerClient.
   power_policy_controller_.reset();
 
   // Delete all D-Bus clients before shutting down the system bus.
   client_bundle_.reset();
 
   // Shut down the bus. During the browser shutdown, it's ok to shut down
   // the bus synchronously.
   if (system_bus_)
     system_bus_->ShutdownOnDBusThreadAndBlock();
 
   // Stop the D-Bus thread.
   if (dbus_thread_)
     dbus_thread_->Stop();
 
   dbus::statistics::Shutdown();
 
-  if (g_dbus_thread_manager == NULL)
+  if (!g_dbus_thread_manager)
     return;  // Called form Shutdown() or local test instance.
 
   // There should never be both a global instance and a local instance.
   CHECK(this == g_dbus_thread_manager);
   if (g_using_dbus_thread_manager_for_testing) {
     g_dbus_thread_manager = NULL;
     g_using_dbus_thread_manager_for_testing = false;
     VLOG(1) << "DBusThreadManager destroyed";
   } else {
     LOG(FATAL) << "~DBusThreadManager() called outside of Shutdown()";
@@ skipping 152 matching lines @@
 }
 
 UpdateEngineClient* DBusThreadManager::GetUpdateEngineClient() {
   return client_bundle_->update_engine_client();
 }
 
 PowerPolicyController* DBusThreadManager::GetPowerPolicyController() {
   return power_policy_controller_.get();
 }
 
-void DBusThreadManager::CreateDefaultClients() {
-  client_bundle_.reset(new DBusClientBundle());
-  // TODO(crbug.com/345586): Move PowerPolicyController out of
-  // DBusThreadManager.
-  power_policy_controller_.reset(new PowerPolicyController);
-}
-
 void DBusThreadManager::InitializeClients() {
   GetBluetoothAdapterClient()->Init(GetSystemBus());
   GetBluetoothAgentManagerClient()->Init(GetSystemBus());
   GetBluetoothDeviceClient()->Init(GetSystemBus());
   GetBluetoothGattCharacteristicClient()->Init(GetSystemBus());
   GetBluetoothGattDescriptorClient()->Init(GetSystemBus());
   GetBluetoothGattManagerClient()->Init(GetSystemBus());
   GetBluetoothGattServiceClient()->Init(GetSystemBus());
   GetBluetoothInputClient()->Init(GetSystemBus());
   GetBluetoothProfileManagerClient()->Init(GetSystemBus());
@@ skipping 34 matching lines @@
     GetPowerPolicyController()->Init(this);
 
   // This must be called after the list of clients so they've each had a
   // chance to register with their object g_dbus_thread_managers.
   if (GetSystemBus())
     GetSystemBus()->GetManagedObjects();
 
   client_bundle_->SetupDefaultEnvironment();
 }
 
-// static
 bool DBusThreadManager::IsUsingStub(DBusClientBundle::DBusClientType client) {
-  return !(unstub_client_mask_ & client);
+  return client_bundle_->IsUsingStub(client);
 }
 
 // static
 void DBusThreadManager::Initialize() {
   // If we initialize DBusThreadManager twice we may also be shutting it down
   // early; do not allow that.
   if (g_using_dbus_thread_manager_for_testing)
     return;
 
-  CHECK(g_dbus_thread_manager == NULL);
+  CHECK(!g_dbus_thread_manager);
   bool use_dbus_stub = !base::SysInfo::IsRunningOnChromeOS() ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kDbusStub);
   bool force_unstub_clients = CommandLine::ForCurrentProcess()->HasSwitch(
       chromeos::switches::kDbusUnstubClients);
   // Determine whether we use stub or real client implementations.
   if (force_unstub_clients) {
     InitializeWithPartialStub(
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             chromeos::switches::kDbusUnstubClients));
   } else if (use_dbus_stub) {
     InitializeWithStubs();
   } else {
     InitializeRegular();
   }
 }
 
 // static
 scoped_ptr<DBusThreadManagerSetter> DBusThreadManager::GetSetterForTesting() {
   if (!g_using_dbus_thread_manager_for_testing) {
     g_using_dbus_thread_manager_for_testing = true;
     InitializeWithStubs();
   }
 
   return make_scoped_ptr(new DBusThreadManagerSetter());
 }
 
 // static
-void DBusThreadManager::CreateGlobalInstance() {
+void DBusThreadManager::CreateGlobalInstance(
+    DBusClientBundle::DBusClientTypeMask unstub_client_mask) {
   CHECK(!g_dbus_thread_manager);
-  g_dbus_thread_manager = new DBusThreadManager();
+  g_dbus_thread_manager = new DBusThreadManager(
+      make_scoped_ptr(new DBusClientBundle(unstub_client_mask)));
   g_dbus_thread_manager->InitializeClients();
 }
 
 // static
 void DBusThreadManager::InitializeRegular() {
-  unstub_client_mask_ = DBusClientBundle::ALL_CLIENTS;
-  CreateGlobalInstance();
+  CreateGlobalInstance(DBusClientBundle::ALL_CLIENTS);
   VLOG(1) << "DBusThreadManager initialized for Chrome OS";
 }
 
 // static
 void DBusThreadManager::InitializeWithStubs() {
-  unstub_client_mask_ = DBusClientBundle::NO_CLIENTS;
-  CreateGlobalInstance();
+  CreateGlobalInstance(DBusClientBundle::NO_CLIENTS);
   VLOG(1) << "DBusThreadManager created for testing";
 }
 
 // static
 void DBusThreadManager::InitializeWithPartialStub(
     const std::string& unstub_clients) {
-  unstub_client_mask_ = DBusClientBundle::ParseUnstubList(unstub_clients);
+  DBusClientBundle::DBusClientTypeMask unstub_client_mask =
+      DBusClientBundle::ParseUnstubList(unstub_clients);
   // We should have something parsed correctly here.
-  if (unstub_client_mask_ == 0) {
-    LOG(FATAL) << "Switch values for --"
-               << chromeos::switches::kDbusUnstubClients
-               << " cannot be parsed: "
-               << unstub_clients;
-  }
+  LOG_IF(FATAL, unstub_client_mask == 0)
+      << "Switch values for --" << chromeos::switches::kDbusUnstubClients
+      << " cannot be parsed: " << unstub_clients;
   VLOG(1) << "DBusThreadManager initialized for mixed runtime environment";
-  CreateGlobalInstance();
+  CreateGlobalInstance(unstub_client_mask);
 }
 
 // static
 bool DBusThreadManager::IsInitialized() {
   return g_dbus_thread_manager != NULL;
 }
 
 // static
 void DBusThreadManager::Shutdown() {
   // Ensure that we only shutdown DBusThreadManager once.
@@ skipping 215 matching lines @@
       client.Pass();
 }
 
 void DBusThreadManagerSetter::SetUpdateEngineClient(
     scoped_ptr<UpdateEngineClient> client) {
   DBusThreadManager::Get()->client_bundle_->update_engine_client_ =
       client.Pass();
 }
 
 }  // namespace chromeos