chromeos: Refactor D-Bus client creation for ash and browser processes

In mustash we need to have some D-Bus clients in the ash window manager
process and some in the browser process. In traditional ash we need everything
in the browser process. Allow per-process initialization of subsets of clients.

* Split ownership of clients into DBusClientsBrowser, DBusClientsAsh and
DBusClientsCommon
* Make DBusThreadManager::Initialize() take a process enum. This isn't great,
but see code review comments
* Remove unnecessary setters from DBusThreadManagerSetter
* Use ash/DEPS to restrict which clients can be used in //ash
* Only initialize ash clients in ash_unittests
* When running in mustash, limit which clients are initialized in the ash
and browser processes

This is a transitional step toward cleaner multi-process initialization of
clients as discussed in go/chromeos-dbus-clients option (G)

BUG=644414,647367
TEST=chromeos_unittests, ash_unittests

Review-Url: https://codereview.chromium.org/2343993003
Cr-Commit-Position: refs/heads/master@{#419481}

ash/DEPS

@@ -18,6 +18,15 @@ include_rules = [
   "+win8",
   "-ash/host",
   "-content",
+
+  # Only allow D-Bus clients accessible to the ash process on mustash.
+  "-chromeos/dbus",
+  "+chromeos/dbus/dbus_client_types.h",
+  "+chromeos/dbus/dbus_thread_manager.h",
+  "+chromeos/dbus/fake_power_manager_client.h",
+  "+chromeos/dbus/fake_session_manager_client.h",
+  "+chromeos/dbus/power_manager_client.h",
+  "+chromeos/dbus/session_manager_client.h",
 ]
 
 specific_include_rules = {

ash/mus/window_manager_application.cc

@@ -46,7 +46,8 @@ void InitializeComponents() {
 #if defined(OS_CHROMEOS)
   // Must occur after mojo::ApplicationRunner has initialized AtExitManager, but
   // before WindowManager::Init().
-  chromeos::DBusThreadManager::Initialize();
+  chromeos::DBusThreadManager::Initialize(
+      chromeos::DBusThreadManager::PROCESS_ASH);
 
   // See ChromeBrowserMainPartsChromeos for ordering details.
   bluez::BluezDBusManager::Initialize(

ash/shell/content/client/shell_browser_main_parts.cc

@@ -96,7 +96,8 @@ void ShellBrowserMainParts::PreMainMessageLoopStart() {
 
 void ShellBrowserMainParts::PostMainMessageLoopStart() {
 #if defined(OS_CHROMEOS)
-  chromeos::DBusThreadManager::Initialize();
+  chromeos::DBusThreadManager::Initialize(
+      chromeos::DBusThreadManager::PROCESS_ASH);
 #endif
 }
 

ash/test/ash_test_helper.cc

@@ -93,7 +93,8 @@ void AshTestHelper::SetUp(bool start_session,
 #if defined(OS_CHROMEOS)
   // Create DBusThreadManager for testing.
   if (!chromeos::DBusThreadManager::IsInitialized()) {
-    chromeos::DBusThreadManager::Initialize();
+    chromeos::DBusThreadManager::Initialize(
+        chromeos::DBusThreadManager::PROCESS_ASH);
     dbus_thread_manager_initialized_ = true;
   }
 

chrome/browser/chromeos/chrome_browser_main_chromeos.cc

@@ -198,9 +198,14 @@ namespace internal {
 class DBusServices {
  public:
   explicit DBusServices(const content::MainFunctionParams& parameters) {
+    // Under mash, some D-Bus clients are owned by other processes.
+    DBusThreadManager::ProcessMask process_mask =
+        chrome::IsRunningInMash() ? DBusThreadManager::PROCESS_BROWSER
+                                  : DBusThreadManager::PROCESS_ALL;
+
     // Initialize DBusThreadManager for the browser. This must be done after
     // the main message loop is started, as it uses the message loop.
-    DBusThreadManager::Initialize();
+    DBusThreadManager::Initialize(process_mask);
 
     bluez::BluezDBusManager::Initialize(
         DBusThreadManager::Get()->GetSystemBus(),

chromeos/chromeos.gyp

@@ -93,10 +93,12 @@
       'dbus/cros_disks_client.h',
       'dbus/cryptohome_client.cc',
       'dbus/cryptohome_client.h',
-      'dbus/dbus_client_bundle.cc',
-      'dbus/dbus_client_bundle.h',
       'dbus/dbus_client_types.cc',
       'dbus/dbus_client_types.h',
+      'dbus/dbus_clients_browser.cc',
+      'dbus/dbus_clients_browser.h',
+      'dbus/dbus_clients_common.cc',
+      'dbus/dbus_clients_common.h',
       'dbus/dbus_method_call_status.cc',
       'dbus/dbus_method_call_status.h',
       'dbus/dbus_thread_manager.cc',

chromeos/dbus/dbus_client.h

@@ -26,7 +26,8 @@ class DBusClient {
   virtual void Init(dbus::Bus* bus) = 0;
 
  private:
-  friend class DBusThreadManager;
+  friend class DBusClientsBrowser;
+  friend class DBusClientsCommon;
 
   DISALLOW_ASSIGN(DBusClient);
 };

chromeos/dbus/dbus_client_bundle_unittest.cc

@@ -2,8 +2,6 @@
 // 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 "chromeos/dbus/dbus_client_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -17,26 +15,6 @@ DBusClientTypeMask AsClientTypeMask(DBusClientType type) {
 
 }  // namespace
 
-// Tests that real and fake clients can be created.
-TEST(DBusClientBundleTest, CreateClientBundle) {
-  const DBusClientTypeMask real_clients =
-      AsClientTypeMask(DBusClientType::CRAS) |
-      AsClientTypeMask(DBusClientType::CROS_DISKS);
-  DBusClientBundle bundle(real_clients);
-
-  // Real clients are real.
-  EXPECT_TRUE(bundle.cras_audio_client());
-  EXPECT_TRUE(bundle.cros_disks_client());
-  EXPECT_TRUE(bundle.IsUsingReal(DBusClientType::CRAS));
-  EXPECT_TRUE(bundle.IsUsingReal(DBusClientType::CROS_DISKS));
-
-  // Fake clients are fake.
-  EXPECT_TRUE(bundle.permission_broker_client());
-  EXPECT_TRUE(bundle.power_manager_client());
-  EXPECT_FALSE(bundle.IsUsingReal(DBusClientType::PERMISSION_BROKER));
-  EXPECT_FALSE(bundle.IsUsingReal(DBusClientType::POWER_MANAGER));
-}
-
 TEST(DBusClientBundleTest, RealClientsFlagParser) {
   EXPECT_EQ(AsClientTypeMask(DBusClientType::NONE),
             ParseDBusRealClientsList("foo"));

chromeos/dbus/dbus_clients_browser.cc

+// Copyright 2016 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_clients_browser.h"
+
+#include "base/logging.h"
+#include "chromeos/dbus/arc_obb_mounter_client.h"
+#include "chromeos/dbus/cros_disks_client.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/debug_daemon_client.h"
+#include "chromeos/dbus/easy_unlock_client.h"
+#include "chromeos/dbus/fake_arc_obb_mounter_client.h"
+#include "chromeos/dbus/fake_debug_daemon_client.h"
+#include "chromeos/dbus/fake_easy_unlock_client.h"
+#include "chromeos/dbus/fake_image_burner_client.h"
+#include "chromeos/dbus/fake_lorgnette_manager_client.h"
+#include "chromeos/dbus/image_burner_client.h"
+#include "chromeos/dbus/lorgnette_manager_client.h"
+
+namespace chromeos {
+namespace {
+
+// Avoid ugly casts below.
+bool IsUsingReal(DBusClientTypeMask real_clients, DBusClientType type) {
+  return real_clients & static_cast<DBusClientTypeMask>(type);
+}
+
+}  // namespace
+
+DBusClientsBrowser::DBusClientsBrowser(DBusClientTypeMask real_clients) {
+  if (IsUsingReal(real_clients, DBusClientType::ARC_OBB_MOUNTER))
+    arc_obb_mounter_client_.reset(ArcObbMounterClient::Create());
+  else
+    arc_obb_mounter_client_.reset(new FakeArcObbMounterClient);
+
+  cros_disks_client_.reset(CrosDisksClient::Create(
+      IsUsingReal(real_clients, DBusClientType::CROS_DISKS)
+          ? REAL_DBUS_CLIENT_IMPLEMENTATION
+          : FAKE_DBUS_CLIENT_IMPLEMENTATION));
+
+  if (IsUsingReal(real_clients, DBusClientType::DEBUG_DAEMON))
+    debug_daemon_client_.reset(DebugDaemonClient::Create());
+  else
+    debug_daemon_client_.reset(new FakeDebugDaemonClient);
+
+  if (IsUsingReal(real_clients, DBusClientType::EASY_UNLOCK))
+    easy_unlock_client_.reset(EasyUnlockClient::Create());
+  else
+    easy_unlock_client_.reset(new FakeEasyUnlockClient);
+
+  if (IsUsingReal(real_clients, DBusClientType::IMAGE_BURNER))
+    image_burner_client_.reset(ImageBurnerClient::Create());
+  else
+    image_burner_client_.reset(new FakeImageBurnerClient);
+
+  if (IsUsingReal(real_clients, DBusClientType::LORGNETTE_MANAGER))
+    lorgnette_manager_client_.reset(LorgnetteManagerClient::Create());
+  else
+    lorgnette_manager_client_.reset(new FakeLorgnetteManagerClient);
+}
+
+DBusClientsBrowser::~DBusClientsBrowser() {}
+
+void DBusClientsBrowser::Initialize(dbus::Bus* system_bus) {
+  DCHECK(DBusThreadManager::IsInitialized());
+
+  arc_obb_mounter_client_->Init(system_bus);
+  cros_disks_client_->Init(system_bus);
+  debug_daemon_client_->Init(system_bus);
+  easy_unlock_client_->Init(system_bus);
+  image_burner_client_->Init(system_bus);
+  lorgnette_manager_client_->Init(system_bus);
+}
+
+}  // namespace chromeos

chromeos/dbus/dbus_clients_browser.h

+// Copyright 2016 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 CHROMEOS_DBUS_DBUS_CLIENTS_BROWSER_H_
+#define CHROMEOS_DBUS_DBUS_CLIENTS_BROWSER_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_client_types.h"
+
+namespace dbus {
+class Bus;
+}
+
+namespace chromeos {
+
+class ArcObbMounterClient;
+class CrosDisksClient;
+class CryptohomeClient;
+class DebugDaemonClient;
+class EasyUnlockClient;
+class ImageBurnerClient;
+class LorgnetteManagerClient;
+
+// D-Bus clients used only in the browser process.
+// TODO(jamescook): Move this under //chrome/browser. http://crbug.com/647367
+class CHROMEOS_EXPORT DBusClientsBrowser {
+ public:
+  // Creates real implementations for |real_clients| and fakes for all others.
+  // Fakes are used when running on Linux desktop and in tests.
+  explicit DBusClientsBrowser(DBusClientTypeMask real_clients);
+  ~DBusClientsBrowser();
+
+  void Initialize(dbus::Bus* system_bus);
+
+ private:
+  friend class DBusThreadManager;
+  friend class DBusThreadManagerSetter;
+
+  std::unique_ptr<ArcObbMounterClient> arc_obb_mounter_client_;
+  std::unique_ptr<CrosDisksClient> cros_disks_client_;
+  std::unique_ptr<DebugDaemonClient> debug_daemon_client_;
+  std::unique_ptr<EasyUnlockClient> easy_unlock_client_;
+  std::unique_ptr<ImageBurnerClient> image_burner_client_;
+  std::unique_ptr<LorgnetteManagerClient> lorgnette_manager_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(DBusClientsBrowser);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_DBUS_CLIENTS_BROWSER_H_

chromeos/dbus/dbus_client_bundle.cc → chromeos/dbus/dbus_clients_common.cc

@@ -2,28 +2,16 @@
 // 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>
+#include "chromeos/dbus/dbus_clients_common.h"
 
 #include "base/command_line.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/debug_daemon_client.h"
-#include "chromeos/dbus/easy_unlock_client.h"
-#include "chromeos/dbus/fake_arc_obb_mounter_client.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cras_audio_client.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
-#include "chromeos/dbus/fake_debug_daemon_client.h"
-#include "chromeos/dbus/fake_easy_unlock_client.h"
 #include "chromeos/dbus/fake_gsm_sms_client.h"
-#include "chromeos/dbus/fake_image_burner_client.h"
-#include "chromeos/dbus/fake_lorgnette_manager_client.h"
 #include "chromeos/dbus/fake_modem_messaging_client.h"
 #include "chromeos/dbus/fake_permission_broker_client.h"
 #include "chromeos/dbus/fake_shill_device_client.h"
@@ -35,8 +23,6 @@
 #include "chromeos/dbus/fake_sms_client.h"
 #include "chromeos/dbus/fake_system_clock_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"
@@ -54,43 +40,18 @@
 
 namespace chromeos {
 
-DBusClientBundle::DBusClientBundle(DBusClientTypeMask real_client_mask)
+DBusClientsCommon::DBusClientsCommon(DBusClientTypeMask real_client_mask)
     : real_client_mask_(real_client_mask) {
-  if (IsUsingReal(DBusClientType::ARC_OBB_MOUNTER))
-    arc_obb_mounter_client_.reset(ArcObbMounterClient::Create());
-  else
-    arc_obb_mounter_client_.reset(new FakeArcObbMounterClient);
-
   if (IsUsingReal(DBusClientType::CRAS))
     cras_audio_client_.reset(CrasAudioClient::Create());
   else
     cras_audio_client_.reset(new FakeCrasAudioClient);
 
-  cros_disks_client_.reset(
-      CrosDisksClient::Create(IsUsingReal(DBusClientType::CROS_DISKS)
-                                  ? REAL_DBUS_CLIENT_IMPLEMENTATION
-                                  : FAKE_DBUS_CLIENT_IMPLEMENTATION));
-
   if (IsUsingReal(DBusClientType::CRYPTOHOME))
     cryptohome_client_.reset(CryptohomeClient::Create());
   else
     cryptohome_client_.reset(new FakeCryptohomeClient);
 
-  if (IsUsingReal(DBusClientType::DEBUG_DAEMON))
-    debug_daemon_client_.reset(DebugDaemonClient::Create());
-  else
-    debug_daemon_client_.reset(new FakeDebugDaemonClient);
-
-  if (IsUsingReal(DBusClientType::EASY_UNLOCK))
-    easy_unlock_client_.reset(EasyUnlockClient::Create());
-  else
-    easy_unlock_client_.reset(new FakeEasyUnlockClient);
-
-  if (IsUsingReal(DBusClientType::LORGNETTE_MANAGER))
-    lorgnette_manager_client_.reset(LorgnetteManagerClient::Create());
-  else
-    lorgnette_manager_client_.reset(new FakeLorgnetteManagerClient);
-
   if (IsUsingReal(DBusClientType::SHILL)) {
     shill_manager_client_.reset(ShillManagerClient::Create());
     shill_device_client_.reset(ShillDeviceClient::Create());
@@ -119,11 +80,6 @@ DBusClientBundle::DBusClientBundle(DBusClientTypeMask real_client_mask)
     gsm_sms_client_.reset(gsm_sms_client);
   }
 
-  if (IsUsingReal(DBusClientType::IMAGE_BURNER))
-    image_burner_client_.reset(ImageBurnerClient::Create());
-  else
-    image_burner_client_.reset(new FakeImageBurnerClient);
-
   if (IsUsingReal(DBusClientType::MODEM_MESSAGING))
     modem_messaging_client_.reset(ModemMessagingClient::Create());
   else
@@ -160,18 +116,32 @@ DBusClientBundle::DBusClientBundle(DBusClientTypeMask real_client_mask)
                                      : FAKE_DBUS_CLIENT_IMPLEMENTATION));
 }
 
-DBusClientBundle::~DBusClientBundle() {}
+DBusClientsCommon::~DBusClientsCommon() {}
 
-bool DBusClientBundle::IsUsingReal(DBusClientType client) const {
+bool DBusClientsCommon::IsUsingReal(DBusClientType client) const {
   return real_client_mask_ & static_cast<DBusClientTypeMask>(client);
 }
 
-bool DBusClientBundle::IsUsingAnyRealClient() const {
-  return real_client_mask_ !=
-         static_cast<DBusClientTypeMask>(DBusClientType::NONE);
-}
+void DBusClientsCommon::Initialize(dbus::Bus* system_bus) {
+  DCHECK(DBusThreadManager::IsInitialized());
+
+  cras_audio_client_->Init(system_bus);
+  cryptohome_client_->Init(system_bus);
+  gsm_sms_client_->Init(system_bus);
+  modem_messaging_client_->Init(system_bus);
+  permission_broker_client_->Init(system_bus);
+  power_manager_client_->Init(system_bus);
+  session_manager_client_->Init(system_bus);
+  shill_device_client_->Init(system_bus);
+  shill_ipconfig_client_->Init(system_bus);
+  shill_manager_client_->Init(system_bus);
+  shill_service_client_->Init(system_bus);
+  shill_profile_client_->Init(system_bus);
+  shill_third_party_vpn_driver_client_->Init(system_bus);
+  sms_client_->Init(system_bus);
+  system_clock_client_->Init(system_bus);
+  update_engine_client_->Init(system_bus);
 
-void DBusClientBundle::SetupDefaultEnvironment() {
   ShillManagerClient::TestInterface* manager =
       shill_manager_client_->GetTestInterface();
   if (manager)

chromeos/dbus/dbus_client_bundle.h → chromeos/dbus/dbus_clients_common.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROMEOS_DBUS_DBUS_CLIENT_BUNDLE_H_
-#define CHROMEOS_DBUS_DBUS_CLIENT_BUNDLE_H_
+#ifndef CHROMEOS_DBUS_DBUS_CLIENTS_COMMON_H_
+#define CHROMEOS_DBUS_DBUS_CLIENTS_COMMON_H_
 
 #include <memory>
 #include <string>
@@ -12,21 +12,18 @@
 #include "chromeos/chromeos_export.h"
 #include "chromeos/dbus/dbus_client_types.h"
 
+namespace dbus {
+class Bus;
+}
+
 namespace chromeos {
 
-class ArcObbMounterClient;
 class CrasAudioClient;
-class CrosDisksClient;
 class CryptohomeClient;
-class DebugDaemonClient;
-class EasyUnlockClient;
 class GsmSMSClient;
-class ImageBurnerClient;
-class LorgnetteManagerClient;
 class ModemMessagingClient;
 class PermissionBrokerClient;
 class PowerManagerClient;
-class SMSClient;
 class SessionManagerClient;
 class ShillDeviceClient;
 class ShillIPConfigClient;
@@ -34,129 +31,35 @@ class ShillManagerClient;
 class ShillProfileClient;
 class ShillServiceClient;
 class ShillThirdPartyVpnDriverClient;
+class SMSClient;
 class SystemClockClient;
 class UpdateEngineClient;
 
-// The bundle of all D-Bus clients used in DBusThreadManager. The bundle
-// is used to delete them at once in the right order before shutting down the
-// system bus. See also the comment in the destructor of DBusThreadManager.
-class CHROMEOS_EXPORT DBusClientBundle {
+// D-Bus clients used in multiple processes (e.g. ash, browser, mus).
+class CHROMEOS_EXPORT DBusClientsCommon {
  public:
   // Creates real implementations for |real_client_mask| and fakes for all
   // others. Fakes are used when running on Linux desktop and in tests.
-  explicit DBusClientBundle(DBusClientTypeMask real_client_mask);
-  ~DBusClientBundle();
+  explicit DBusClientsCommon(DBusClientTypeMask real_client_mask);
+  ~DBusClientsCommon();
 
   // Returns true if |client| has a real (non-fake) client implementation.
   bool IsUsingReal(DBusClientType client) const;
 
-  // Returns true if any real DBusClient is used.
-  bool IsUsingAnyRealClient() const;
-
   // Initialize proper runtime environment for its dbus clients.
-  void SetupDefaultEnvironment();
-
-  ArcObbMounterClient* arc_obb_mounter_client() {
-    return arc_obb_mounter_client_.get();
-  }
-
-  CrasAudioClient* cras_audio_client() {
-    return cras_audio_client_.get();
-  }
-
-  CrosDisksClient* cros_disks_client() {
-    return cros_disks_client_.get();
-  }
-
-  CryptohomeClient* cryptohome_client() {
-    return cryptohome_client_.get();
-  }
-
-  DebugDaemonClient* debug_daemon_client() {
-    return debug_daemon_client_.get();
-  }
-
-  EasyUnlockClient* easy_unlock_client() {
-    return easy_unlock_client_.get();
-  }
-
-  LorgnetteManagerClient* lorgnette_manager_client() {
-    return lorgnette_manager_client_.get();
-  }
-
-  ShillDeviceClient* shill_device_client() {
-    return shill_device_client_.get();
-  }
-
-  ShillIPConfigClient* shill_ipconfig_client() {
-    return shill_ipconfig_client_.get();
-  }
-
-  ShillManagerClient* shill_manager_client() {
-    return shill_manager_client_.get();
-  }
-
-  ShillServiceClient* shill_service_client() {
-    return shill_service_client_.get();
-  }
-
-  ShillProfileClient* shill_profile_client() {
-    return shill_profile_client_.get();
-  }
-
-  ShillThirdPartyVpnDriverClient* shill_third_party_vpn_driver_client() {
-    return shill_third_party_vpn_driver_client_.get();
-  }
-
-  GsmSMSClient* gsm_sms_client() {
-    return gsm_sms_client_.get();
-  }
-
-  ImageBurnerClient* image_burner_client() {
-    return image_burner_client_.get();
-  }
-
-  ModemMessagingClient* modem_messaging_client() {
-    return modem_messaging_client_.get();
-  }
-
-  PermissionBrokerClient* permission_broker_client() {
-    return permission_broker_client_.get();
-  }
-
-  SystemClockClient* system_clock_client() {
-    return system_clock_client_.get();
-  }
-
-  PowerManagerClient* power_manager_client() {
-    return power_manager_client_.get();
-  }
-
-  SessionManagerClient* session_manager_client() {
-    return session_manager_client_.get();
-  }
-
-  SMSClient* sms_client() {
-    return sms_client_.get();
-  }
-
-  UpdateEngineClient* update_engine_client() {
-    return update_engine_client_.get();
-  }
+  void Initialize(dbus::Bus* system_bus);
 
  private:
+  friend class DBusThreadManager;
   friend class DBusThreadManagerSetter;
 
   // Bitmask for clients with real implementations.
   const DBusClientTypeMask real_client_mask_;
 
-  std::unique_ptr<ArcObbMounterClient> arc_obb_mounter_client_;
   std::unique_ptr<CrasAudioClient> cras_audio_client_;
-  std::unique_ptr<CrosDisksClient> cros_disks_client_;
   std::unique_ptr<CryptohomeClient> cryptohome_client_;
-  std::unique_ptr<DebugDaemonClient> debug_daemon_client_;
-  std::unique_ptr<EasyUnlockClient> easy_unlock_client_;
-  std::unique_ptr<LorgnetteManagerClient> lorgnette_manager_client_;
+  std::unique_ptr<GsmSMSClient> gsm_sms_client_;
+  std::unique_ptr<ModemMessagingClient> modem_messaging_client_;
   std::unique_ptr<ShillDeviceClient> shill_device_client_;
   std::unique_ptr<ShillIPConfigClient> shill_ipconfig_client_;
   std::unique_ptr<ShillManagerClient> shill_manager_client_;
@@ -164,19 +67,16 @@ class CHROMEOS_EXPORT DBusClientBundle {
   std::unique_ptr<ShillProfileClient> shill_profile_client_;
   std::unique_ptr<ShillThirdPartyVpnDriverClient>
       shill_third_party_vpn_driver_client_;
-  std::unique_ptr<GsmSMSClient> gsm_sms_client_;
-  std::unique_ptr<ImageBurnerClient> image_burner_client_;
-  std::unique_ptr<ModemMessagingClient> modem_messaging_client_;
   std::unique_ptr<PermissionBrokerClient> permission_broker_client_;
+  std::unique_ptr<SMSClient> sms_client_;
   std::unique_ptr<SystemClockClient> system_clock_client_;
   std::unique_ptr<PowerManagerClient> power_manager_client_;
   std::unique_ptr<SessionManagerClient> session_manager_client_;
-  std::unique_ptr<SMSClient> sms_client_;
   std::unique_ptr<UpdateEngineClient> update_engine_client_;
 
-  DISALLOW_COPY_AND_ASSIGN(DBusClientBundle);
+  DISALLOW_COPY_AND_ASSIGN(DBusClientsCommon);
 };
 
 }  // namespace chromeos
 
-#endif  // CHROMEOS_DBUS_DBUS_CLIENT_BUNDLE_H_
+#endif  // CHROMEOS_DBUS_DBUS_CLIENTS_COMMON_H_

chromeos/dbus/dbus_thread_manager.h

@@ -30,7 +30,8 @@ class ArcObbMounterClient;
 class CrasAudioClient;
 class CrosDisksClient;
 class CryptohomeClient;
-class DBusClientBundle;
+class DBusClientsBrowser;
+class DBusClientsCommon;
 class DBusThreadManagerSetter;
 class DebugDaemonClient;
 class EasyUnlockClient;
@@ -71,11 +72,24 @@ class UpdateEngineClient;
 //
 class CHROMEOS_EXPORT DBusThreadManager {
  public:
+  // Processes for which to create and initialize the D-Bus clients.
+  // TODO(jamescook): Move creation of clients into //ash and //chrome/browser.
+  // http://crbug.com/647367
+  enum ProcessMask {
+    PROCESS_ASH = 1 << 0,
+    PROCESS_BROWSER = 1 << 1,
+    PROCESS_ALL = ~0,
+  };
   // Sets the global instance. Must be called before any calls to Get().
   // We explicitly initialize and shut down the global object, rather than
   // making it a Singleton, to ensure clean startup and shutdown.
   // This will initialize real or fake DBusClients depending on command-line
   // arguments and whether this process runs in a ChromeOS environment.
+  // Only D-Bus clients available in the processes in |process_mask| will be
+  // created.
+  static void Initialize(ProcessMask process_mask);
+
+  // Equivalent to Initialize(PROCESS_ALL).
   static void Initialize();
 
   // Returns a DBusThreadManagerSetter instance that allows tests to
@@ -101,6 +115,8 @@ class CHROMEOS_EXPORT DBusThreadManager {
 
   // All returned objects are owned by DBusThreadManager.  Do not use these
   // pointers after DBusThreadManager has been shut down.
+  // TODO(jamescook): Replace this with calls to FooClient::Get().
+  // http://crbug.com/647367
   ArcObbMounterClient* GetArcObbMounterClient();
   CrasAudioClient* GetCrasAudioClient();
   CrosDisksClient* GetCrosDisksClient();
@@ -127,27 +143,28 @@ class CHROMEOS_EXPORT DBusThreadManager {
  private:
   friend class DBusThreadManagerSetter;
 
-  // Creates a new DBusThreadManager using the DBusClients set in
-  // |client_bundle|.
-  explicit DBusThreadManager(std::unique_ptr<DBusClientBundle> client_bundle);
+  DBusThreadManager(ProcessMask process_mask,
+                    DBusClientTypeMask real_client_mask);
   ~DBusThreadManager();
 
   // Creates a global instance of DBusThreadManager with the real
   // implementations for all clients that are listed in |real_client_mask| and
   // fake implementations for all clients that are not included. Cannot be
   // called more than once.
-  static void CreateGlobalInstance(DBusClientTypeMask real_client_mask);
+  static void CreateGlobalInstance(ProcessMask process_mask,
+                                   DBusClientTypeMask real_client_mask);
 
   // Initialize global thread manager instance with all real dbus client
   // implementations.
-  static void InitializeWithRealClients();
+  static void InitializeWithRealClients(ProcessMask process_mask);
 
   // Initialize global thread manager instance with fake dbus clients.
-  static void InitializeWithFakeClients();
+  static void InitializeWithFakeClients(ProcessMask process_mask);
 
   // Initialize with fake implementations for only certain clients that are
   // not included in the comma-separated |force_real_clients| list.
-  static void InitializeWithPartialFakes(const std::string& force_real_clients);
+  static void InitializeWithPartialFakes(ProcessMask process_mask,
+                                         const std::string& force_real_clients);
 
   // Initializes all currently stored DBusClients with the system bus and
   // performs additional setup.
@@ -155,11 +172,17 @@ class CHROMEOS_EXPORT DBusThreadManager {
 
   std::unique_ptr<base::Thread> dbus_thread_;
   scoped_refptr<dbus::Bus> system_bus_;
-  std::unique_ptr<DBusClientBundle> client_bundle_;
+
+  // Clients used by multiple processes.
+  std::unique_ptr<DBusClientsCommon> clients_common_;
+
+  // Clients used only by the browser process. Null in other processes.
+  std::unique_ptr<DBusClientsBrowser> clients_browser_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusThreadManager);
 };
 
+// TODO(jamescook): Replace these with FooClient::InitializeForTesting().
 class CHROMEOS_EXPORT DBusThreadManagerSetter {
  public:
   ~DBusThreadManagerSetter();
@@ -168,9 +191,6 @@ class CHROMEOS_EXPORT DBusThreadManagerSetter {
   void SetCrosDisksClient(std::unique_ptr<CrosDisksClient> client);
   void SetCryptohomeClient(std::unique_ptr<CryptohomeClient> client);
   void SetDebugDaemonClient(std::unique_ptr<DebugDaemonClient> client);
-  void SetEasyUnlockClient(std::unique_ptr<EasyUnlockClient> client);
-  void SetLorgnetteManagerClient(
-      std::unique_ptr<LorgnetteManagerClient> client);
   void SetShillDeviceClient(std::unique_ptr<ShillDeviceClient> client);
   void SetShillIPConfigClient(std::unique_ptr<ShillIPConfigClient> client);
   void SetShillManagerClient(std::unique_ptr<ShillManagerClient> client);
@@ -178,15 +198,11 @@ class CHROMEOS_EXPORT DBusThreadManagerSetter {
   void SetShillProfileClient(std::unique_ptr<ShillProfileClient> client);
   void SetShillThirdPartyVpnDriverClient(
       std::unique_ptr<ShillThirdPartyVpnDriverClient> client);
-  void SetGsmSMSClient(std::unique_ptr<GsmSMSClient> client);
   void SetImageBurnerClient(std::unique_ptr<ImageBurnerClient> client);
-  void SetModemMessagingClient(std::unique_ptr<ModemMessagingClient> client);
   void SetPermissionBrokerClient(
       std::unique_ptr<PermissionBrokerClient> client);
   void SetPowerManagerClient(std::unique_ptr<PowerManagerClient> client);
   void SetSessionManagerClient(std::unique_ptr<SessionManagerClient> client);
-  void SetSMSClient(std::unique_ptr<SMSClient> client);
-  void SetSystemClockClient(std::unique_ptr<SystemClockClient> client);
   void SetUpdateEngineClient(std::unique_ptr<UpdateEngineClient> client);
 
  private:

chromeos/dbus/dbus_thread_manager_unittest.cc

@@ -9,7 +9,7 @@
 
 namespace chromeos {
 
-// Tests that clients can be created.
+// Tests that real and fake clients can be created.
 TEST(DBusThreadManagerTest, Initialize) {
   DBusThreadManager::Initialize();
   EXPECT_TRUE(DBusThreadManager::IsInitialized());
@@ -18,15 +18,121 @@ TEST(DBusThreadManagerTest, Initialize) {
   ASSERT_TRUE(manager);
 
   // In tests, clients are fake.
+  // NOTE: Order matches DBusClientType enum.
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::BLUETOOTH));
   EXPECT_TRUE(manager->IsUsingFake(DBusClientType::CRAS));
   EXPECT_TRUE(manager->IsUsingFake(DBusClientType::CROS_DISKS));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::CRYPTOHOME));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::DEBUG_DAEMON));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::EASY_UNLOCK));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::LORGNETTE_MANAGER));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::SHILL));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::GSM_SMS));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::IMAGE_BURNER));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::MODEM_MESSAGING));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::PERMISSION_BROKER));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::POWER_MANAGER));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::SMS));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::SYSTEM_CLOCK));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::UPDATE_ENGINE));
+  EXPECT_TRUE(manager->IsUsingFake(DBusClientType::ARC_OBB_MOUNTER));
 
   // Clients were created.
+  EXPECT_TRUE(manager->GetArcObbMounterClient());
   EXPECT_TRUE(manager->GetCrasAudioClient());
   EXPECT_TRUE(manager->GetCrosDisksClient());
+  EXPECT_TRUE(manager->GetCryptohomeClient());
+  EXPECT_TRUE(manager->GetDebugDaemonClient());
+  EXPECT_TRUE(manager->GetEasyUnlockClient());
+  EXPECT_TRUE(manager->GetGsmSMSClient());
+  EXPECT_TRUE(manager->GetImageBurnerClient());
+  EXPECT_TRUE(manager->GetLorgnetteManagerClient());
+  EXPECT_TRUE(manager->GetModemMessagingClient());
+  EXPECT_TRUE(manager->GetPermissionBrokerClient());
+  EXPECT_TRUE(manager->GetPowerManagerClient());
+  EXPECT_TRUE(manager->GetSessionManagerClient());
+  EXPECT_TRUE(manager->GetShillDeviceClient());
+  EXPECT_TRUE(manager->GetShillIPConfigClient());
+  EXPECT_TRUE(manager->GetShillManagerClient());
+  EXPECT_TRUE(manager->GetShillServiceClient());
+  EXPECT_TRUE(manager->GetShillProfileClient());
+  EXPECT_TRUE(manager->GetShillThirdPartyVpnDriverClient());
+  EXPECT_TRUE(manager->GetSMSClient());
+  EXPECT_TRUE(manager->GetSystemClockClient());
+  EXPECT_TRUE(manager->GetUpdateEngineClient());
 
   DBusThreadManager::Shutdown();
   EXPECT_FALSE(DBusThreadManager::IsInitialized());
 }
 
+// Tests that clients can be created for the browser process.
+TEST(DBusThreadManagerTest, InitializeForBrowser) {
+  DBusThreadManager::Initialize(DBusThreadManager::PROCESS_BROWSER);
+  DBusThreadManager* manager = DBusThreadManager::Get();
+  ASSERT_TRUE(manager);
+
+  // Common clients were created.
+  EXPECT_TRUE(manager->GetCrasAudioClient());
+  EXPECT_TRUE(manager->GetCryptohomeClient());
+  EXPECT_TRUE(manager->GetGsmSMSClient());
+  EXPECT_TRUE(manager->GetModemMessagingClient());
+  EXPECT_TRUE(manager->GetPermissionBrokerClient());
+  EXPECT_TRUE(manager->GetPowerManagerClient());
+  EXPECT_TRUE(manager->GetSessionManagerClient());
+  EXPECT_TRUE(manager->GetShillDeviceClient());
+  EXPECT_TRUE(manager->GetShillIPConfigClient());
+  EXPECT_TRUE(manager->GetShillManagerClient());
+  EXPECT_TRUE(manager->GetShillProfileClient());
+  EXPECT_TRUE(manager->GetShillServiceClient());
+  EXPECT_TRUE(manager->GetShillThirdPartyVpnDriverClient());
+  EXPECT_TRUE(manager->GetSMSClient());
+  EXPECT_TRUE(manager->GetSystemClockClient());
+  EXPECT_TRUE(manager->GetUpdateEngineClient());
+
+  // Clients for the browser were created.
+  EXPECT_TRUE(manager->GetArcObbMounterClient());
+  EXPECT_TRUE(manager->GetCrosDisksClient());
+  EXPECT_TRUE(manager->GetDebugDaemonClient());
+  EXPECT_TRUE(manager->GetEasyUnlockClient());
+  EXPECT_TRUE(manager->GetImageBurnerClient());
+  EXPECT_TRUE(manager->GetLorgnetteManagerClient());
+
+  DBusThreadManager::Shutdown();
+}
+
+// Tests that clients can be created for the ash process.
+TEST(DBusThreadManagerTest, InitializeForAsh) {
+  DBusThreadManager::Initialize(DBusThreadManager::PROCESS_ASH);
+  DBusThreadManager* manager = DBusThreadManager::Get();
+  ASSERT_TRUE(manager);
+
+  // Common clients were created.
+  EXPECT_TRUE(manager->GetCrasAudioClient());
+  EXPECT_TRUE(manager->GetCryptohomeClient());
+  EXPECT_TRUE(manager->GetGsmSMSClient());
+  EXPECT_TRUE(manager->GetModemMessagingClient());
+  EXPECT_TRUE(manager->GetPermissionBrokerClient());
+  EXPECT_TRUE(manager->GetPowerManagerClient());
+  EXPECT_TRUE(manager->GetSessionManagerClient());
+  EXPECT_TRUE(manager->GetShillDeviceClient());
+  EXPECT_TRUE(manager->GetShillIPConfigClient());
+  EXPECT_TRUE(manager->GetShillManagerClient());
+  EXPECT_TRUE(manager->GetShillProfileClient());
+  EXPECT_TRUE(manager->GetShillServiceClient());
+  EXPECT_TRUE(manager->GetShillThirdPartyVpnDriverClient());
+  EXPECT_TRUE(manager->GetSMSClient());
+  EXPECT_TRUE(manager->GetSystemClockClient());
+  EXPECT_TRUE(manager->GetUpdateEngineClient());
+
+  // Clients for other processes were not created.
+  EXPECT_FALSE(manager->GetArcObbMounterClient());
+  EXPECT_FALSE(manager->GetCrosDisksClient());
+  EXPECT_FALSE(manager->GetDebugDaemonClient());
+  EXPECT_FALSE(manager->GetEasyUnlockClient());
+  EXPECT_FALSE(manager->GetImageBurnerClient());
+  EXPECT_FALSE(manager->GetLorgnetteManagerClient());
+
+  DBusThreadManager::Shutdown();
+}
+
 }  // namespace chromeos