mash: Allow a subset of D-Bus clients to be created in DBusThreadManager

chromeos/dbus/dbus_client_bundle.cc

 // Copyright 2014 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_client_bundle.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 78 matching lines @@
   for (size_t i = 0; i < arraysize(client_type_map); i++) {
     if (base::LowerCaseEqualsASCII(client_type_name,
                                    client_type_map[i].param_name))
       return client_type_map[i].client_type;
   }
   return DBusClientBundle::NO_CLIENT;
 }
 
 }  // namespace
 
-DBusClientBundle::DBusClientBundle(DBusClientTypeMask unstub_client_mask)
-    : unstub_client_mask_(unstub_client_mask) {
-  if (!IsUsingStub(ARC_OBB_MOUNTER))
+DBusClientBundle::DBusClientBundle(DBusClientTypeMask real_client_mask,
+                                   DBusClientTypeMask fake_client_mask)
+    : real_client_mask_(real_client_mask), fake_client_mask_(fake_client_mask) {
+  DCHECK(!(real_client_mask & fake_client_mask))
+      << "D-Bus clients cannot be both fake and real.";
+  DCHECK(real_client_mask | fake_client_mask)
+      << "Must initialize at least one D-Bus client.";
+
+  if (IsUsingReal(ARC_OBB_MOUNTER))
     arc_obb_mounter_client_.reset(ArcObbMounterClient::Create());
-  else
+  else if (IsUsingFake(ARC_OBB_MOUNTER))
     arc_obb_mounter_client_.reset(new FakeArcObbMounterClient);
 
-  if (!IsUsingStub(CRAS))
+  if (IsUsingReal(CRAS))
     cras_audio_client_.reset(CrasAudioClient::Create());
-  else
+  else if (IsUsingFake(CRAS))
     cras_audio_client_.reset(new FakeCrasAudioClient);
 
-  cros_disks_client_.reset(CrosDisksClient::Create(
-      IsUsingStub(CROS_DISKS) ? STUB_DBUS_CLIENT_IMPLEMENTATION
-                              : REAL_DBUS_CLIENT_IMPLEMENTATION));
+  if (IsUsingReal(CROS_DISKS)) {
+    cros_disks_client_.reset(
+        CrosDisksClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION));
+  } else if (IsUsingFake(CROS_DISKS)) {
+    cros_disks_client_.reset(
+        CrosDisksClient::Create(FAKE_DBUS_CLIENT_IMPLEMENTATION));
+  }
 
-  if (!IsUsingStub(CRYPTOHOME))
+  if (IsUsingReal(CRYPTOHOME))
     cryptohome_client_.reset(CryptohomeClient::Create());
-  else
+  else if (IsUsingFake(CRYPTOHOME))
     cryptohome_client_.reset(new FakeCryptohomeClient);
 
-  if (!IsUsingStub(DEBUG_DAEMON))
+  if (IsUsingReal(DEBUG_DAEMON))
     debug_daemon_client_.reset(DebugDaemonClient::Create());
-  else
+  else if (IsUsingFake(DEBUG_DAEMON))
     debug_daemon_client_.reset(new FakeDebugDaemonClient);
 
-  if (!IsUsingStub(EASY_UNLOCK))
+  if (IsUsingReal(EASY_UNLOCK))
     easy_unlock_client_.reset(EasyUnlockClient::Create());
-  else
+  else if (IsUsingFake(EASY_UNLOCK))
     easy_unlock_client_.reset(new FakeEasyUnlockClient);
 
-  if (!IsUsingStub(LORGNETTE_MANAGER))
+  if (IsUsingReal(LORGNETTE_MANAGER))
     lorgnette_manager_client_.reset(LorgnetteManagerClient::Create());
-  else
+  else if (IsUsingFake(LORGNETTE_MANAGER))
     lorgnette_manager_client_.reset(new FakeLorgnetteManagerClient);
 
-  if (!IsUsingStub(SHILL)) {
+  if (IsUsingReal(SHILL)) {
     shill_manager_client_.reset(ShillManagerClient::Create());
     shill_device_client_.reset(ShillDeviceClient::Create());
     shill_ipconfig_client_.reset(ShillIPConfigClient::Create());
     shill_service_client_.reset(ShillServiceClient::Create());
     shill_profile_client_.reset(ShillProfileClient::Create());
     shill_third_party_vpn_driver_client_.reset(
         ShillThirdPartyVpnDriverClient::Create());
-  } else {
+  } else if (IsUsingFake(SHILL)) {
     shill_manager_client_.reset(new FakeShillManagerClient);
     shill_device_client_.reset(new FakeShillDeviceClient);
     shill_ipconfig_client_.reset(new FakeShillIPConfigClient);
     shill_service_client_.reset(new FakeShillServiceClient);
     shill_profile_client_.reset(new FakeShillProfileClient);
     shill_third_party_vpn_driver_client_.reset(
         new FakeShillThirdPartyVpnDriverClient);
   }
 
-  if (!IsUsingStub(GSM_SMS)) {
+  if (IsUsingReal(GSM_SMS)) {
     gsm_sms_client_.reset(GsmSMSClient::Create());
-  } else {
+  } else if (IsUsingFake(GSM_SMS)) {
     FakeGsmSMSClient* gsm_sms_client = new FakeGsmSMSClient();
     gsm_sms_client->set_sms_test_message_switch_present(
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             chromeos::switches::kSmsTestMessages));
     gsm_sms_client_.reset(gsm_sms_client);
   }
 
-  if (!IsUsingStub(IMAGE_BURNER))
+  if (IsUsingReal(IMAGE_BURNER))
     image_burner_client_.reset(ImageBurnerClient::Create());
-  else
+  else if (IsUsingFake(IMAGE_BURNER))
     image_burner_client_.reset(new FakeImageBurnerClient);
 
-  if (!IsUsingStub(MODEM_MESSAGING))
+  if (IsUsingReal(MODEM_MESSAGING))
     modem_messaging_client_.reset(ModemMessagingClient::Create());
-  else
+  else if (IsUsingFake(MODEM_MESSAGING))
     modem_messaging_client_.reset(new FakeModemMessagingClient);
 
-  if (!IsUsingStub(PERMISSION_BROKER))
+  if (IsUsingReal(PERMISSION_BROKER))
     permission_broker_client_.reset(PermissionBrokerClient::Create());
-  else
+  else if (IsUsingFake(PERMISSION_BROKER))
     permission_broker_client_.reset(new FakePermissionBrokerClient);
 
-  power_manager_client_.reset(PowerManagerClient::Create(
-      IsUsingStub(POWER_MANAGER) ? STUB_DBUS_CLIENT_IMPLEMENTATION
-                                 : REAL_DBUS_CLIENT_IMPLEMENTATION));
+  if (IsUsingReal(POWER_MANAGER)) {
+    power_manager_client_.reset(
+        PowerManagerClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION));
+  } else if (IsUsingFake(POWER_MANAGER)) {
+    power_manager_client_.reset(
+        PowerManagerClient::Create(FAKE_DBUS_CLIENT_IMPLEMENTATION));
+  }
 
-  session_manager_client_.reset(SessionManagerClient::Create(
-      IsUsingStub(SESSION_MANAGER) ? STUB_DBUS_CLIENT_IMPLEMENTATION
-                                   : REAL_DBUS_CLIENT_IMPLEMENTATION));
+  if (IsUsingReal(SESSION_MANAGER)) {
+    session_manager_client_.reset(
+        SessionManagerClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION));
+  } else if (IsUsingFake(SESSION_MANAGER)) {
+    session_manager_client_.reset(
+        SessionManagerClient::Create(FAKE_DBUS_CLIENT_IMPLEMENTATION));
+  }
 
-  if (!IsUsingStub(SMS))
+  if (IsUsingReal(SMS))
     sms_client_.reset(SMSClient::Create());
-  else
+  else if (IsUsingFake(SMS))
     sms_client_.reset(new FakeSMSClient);
 
-  if (!IsUsingStub(SYSTEM_CLOCK))
+  if (IsUsingReal(SYSTEM_CLOCK))
     system_clock_client_.reset(SystemClockClient::Create());
-  else
+  else if (IsUsingFake(SYSTEM_CLOCK))
     system_clock_client_.reset(new FakeSystemClockClient);
 
-  update_engine_client_.reset(UpdateEngineClient::Create(
-      IsUsingStub(UPDATE_ENGINE) ? STUB_DBUS_CLIENT_IMPLEMENTATION
-                                 : REAL_DBUS_CLIENT_IMPLEMENTATION));
+  if (IsUsingReal(UPDATE_ENGINE)) {
+    update_engine_client_.reset(
+        UpdateEngineClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION));
+  } else if (IsUsingFake(UPDATE_ENGINE)) {
+    update_engine_client_.reset(
+        UpdateEngineClient::Create(FAKE_DBUS_CLIENT_IMPLEMENTATION));
+  }
 }
 
 DBusClientBundle::~DBusClientBundle() {
 }
 
-bool DBusClientBundle::IsUsingStub(DBusClientType client) {
-  return !(unstub_client_mask_ & client);
+bool DBusClientBundle::IsUsingFake(DBusClientType client) const {
+  return fake_client_mask_ & client;
+}
+
+bool DBusClientBundle::IsUsingReal(DBusClientType client) const {
+  return real_client_mask_ & client;
 }
 
 bool DBusClientBundle::IsUsingAnyRealClient() {
-  // 'Using any real client' is equivalent to 'Unstubbed any client'.
-  return unstub_client_mask_ != 0;
+  return real_client_mask_ != 0;
 }
 
 void DBusClientBundle::SetupDefaultEnvironment() {
+  if (!shill_manager_client_)
+    return;
   ShillManagerClient::TestInterface* manager =
       shill_manager_client_->GetTestInterface();
   if (manager)
     manager->SetupDefaultEnvironment();
 }
 
 // static
-DBusClientBundle::DBusClientTypeMask DBusClientBundle::ParseUnstubList(
+DBusClientTypeMask DBusClientBundle::ParseUnstubList(
     const std::string& unstub_list) {
   DBusClientTypeMask unstub_mask = 0;
   for (const std::string& cur : base::SplitString(
            unstub_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     DBusClientBundle::DBusClientType client = GetDBusClientType(cur);
     if (client != NO_CLIENT) {
       LOG(WARNING) << "Unstubbing dbus client for " << cur;
       unstub_mask |= client;
     } else {
       LOG(ERROR) << "Unknown dbus client: " << cur;
     }
   }
 
   return unstub_mask;
 }
 
 }  // namespace chromeos