chromeos: Refactor D-Bus client type enum and stub vs. fake naming

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 <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/arc_obb_mounter_client.h"
 #include "chromeos/dbus/cras_audio_client.h"
 #include "chromeos/dbus/cros_disks_client.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_client.h"
+#include "chromeos/dbus/dbus_client_bundle.h"
 #include "chromeos/dbus/debug_daemon_client.h"
 #include "chromeos/dbus/easy_unlock_client.h"
 #include "chromeos/dbus/gsm_sms_client.h"
 #include "chromeos/dbus/image_burner_client.h"
 #include "chromeos/dbus/lorgnette_manager_client.h"
 #include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/dbus/shill_device_client.h"
@@ skipping 183 matching lines @@
   GetShillServiceClient()->Init(GetSystemBus());
   GetShillProfileClient()->Init(GetSystemBus());
   GetShillThirdPartyVpnDriverClient()->Init(GetSystemBus());
   GetSMSClient()->Init(GetSystemBus());
   GetSystemClockClient()->Init(GetSystemBus());
   GetUpdateEngineClient()->Init(GetSystemBus());
 
   client_bundle_->SetupDefaultEnvironment();
 }
 
-bool DBusThreadManager::IsUsingStub(DBusClientBundle::DBusClientType client) {
-  return client_bundle_->IsUsingStub(client);
+bool DBusThreadManager::IsUsingFake(DBusClientType client) {
+  return !client_bundle_->IsUsingReal(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);
-  bool use_dbus_stub = !base::SysInfo::IsRunningOnChromeOS() ||
-                       base::CommandLine::ForCurrentProcess()->HasSwitch(
-                           chromeos::switches::kDbusStub);
+  bool use_fakes = !base::SysInfo::IsRunningOnChromeOS() ||
+                   base::CommandLine::ForCurrentProcess()->HasSwitch(
+                       chromeos::switches::kDbusStub);
   bool force_unstub_clients = base::CommandLine::ForCurrentProcess()->HasSwitch(
       chromeos::switches::kDbusUnstubClients);
-  // Determine whether we use stub or real client implementations.
+  // Determine whether we use fake or real client implementations.
   if (force_unstub_clients) {
-    InitializeWithPartialStub(
+    InitializeWithPartialFakes(
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             chromeos::switches::kDbusUnstubClients));
-  } else if (use_dbus_stub) {
-    InitializeWithStubs();
+  } else if (use_fakes) {
+    InitializeWithFakeClients();
   } else {
     InitializeWithRealClients();
   }
 }
 
 // static
 std::unique_ptr<DBusThreadManagerSetter>
 DBusThreadManager::GetSetterForTesting() {
   if (!g_using_dbus_thread_manager_for_testing) {
     g_using_dbus_thread_manager_for_testing = true;
-    InitializeWithStubs();
+    InitializeWithFakeClients();
   }
 
   return base::WrapUnique(new DBusThreadManagerSetter());
 }
 
 // static
 void DBusThreadManager::CreateGlobalInstance(
-    DBusClientBundle::DBusClientTypeMask unstub_client_mask) {
+    DBusClientTypeMask real_client_mask) {
   CHECK(!g_dbus_thread_manager);
   g_dbus_thread_manager = new DBusThreadManager(
-      base::MakeUnique<DBusClientBundle>(unstub_client_mask));
+      base::MakeUnique<DBusClientBundle>(real_client_mask));
   g_dbus_thread_manager->InitializeClients();
 }
 
 // static
 void DBusThreadManager::InitializeWithRealClients() {
-  CreateGlobalInstance(~static_cast<DBusClientBundle::DBusClientTypeMask>(0));
+  CreateGlobalInstance(static_cast<DBusClientTypeMask>(DBusClientType::ALL));
   VLOG(1) << "DBusThreadManager initialized for Chrome OS";
 }
 
 // static
-void DBusThreadManager::InitializeWithStubs() {
-  CreateGlobalInstance(0 /* unstub_client_mask */);
+void DBusThreadManager::InitializeWithFakeClients() {
+  CreateGlobalInstance(static_cast<DBusClientTypeMask>(DBusClientType::NONE));
   VLOG(1) << "DBusThreadManager created for testing";
 }
 
 // static
-void DBusThreadManager::InitializeWithPartialStub(
-    const std::string& unstub_clients) {
-  DBusClientBundle::DBusClientTypeMask unstub_client_mask =
-      DBusClientBundle::ParseUnstubList(unstub_clients);
+void DBusThreadManager::InitializeWithPartialFakes(
+    const std::string& force_real_clients) {
+  DBusClientTypeMask real_client_mask =
+      ParseDBusUnstubClientsList(force_real_clients);
   // We should have something parsed correctly here.
-  LOG_IF(FATAL, unstub_client_mask == 0)
+  LOG_IF(FATAL, real_client_mask == 0)
       << "Switch values for --" << chromeos::switches::kDbusUnstubClients
-      << " cannot be parsed: " << unstub_clients;
+      << " cannot be parsed: " << real_client_mask;
   VLOG(1) << "DBusThreadManager initialized for mixed runtime environment";
-  CreateGlobalInstance(unstub_client_mask);
+  CreateGlobalInstance(real_client_mask);
 }
 
 // static
 bool DBusThreadManager::IsInitialized() {
   return g_dbus_thread_manager != NULL;
 }
 
 // static
 void DBusThreadManager::Shutdown() {
   // Ensure that we only shutdown DBusThreadManager once.
@@ skipping 136 matching lines @@
       std::move(client);
 }
 
 void DBusThreadManagerSetter::SetUpdateEngineClient(
     std::unique_ptr<UpdateEngineClient> client) {
   DBusThreadManager::Get()->client_bundle_->update_engine_client_ =
       std::move(client);
 }
 
 }  // namespace chromeos