[CrOS MultiDevice] Initialize MultiDeviceSetupService.

This CL:
(1) Initializes the SetupFlowCompletionRecorder and
    AccountStatusChangeDelegateNotifier classes when the service starts
    up. Previously, they were not actually integrated into the service.
(2) Adds a MultiDeviceSetupInitializer class which initializes the
    service by waiting until the DeviceSyncClient has loaded the local
    remote device before continuing. This task must complete before
    AccountStatusChangeDelegateNotifier is created as that class
    assumes that the client has been fully initialized.
(3) Adjusts ProfileImpl to pass various parameters to the service which
    are required for the initialization described above.

Bug: 824568
Change-Id: I09240f00d29cd44e2768e3068b3284abe16b3801
Reviewed-on: https://chromium-review.googlesource.com/1110953Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
Reviewed-by: Bernhard Bauer <bauerb@chromium.org>
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#569754}

chrome/browser/profiles/profile_impl.cc

@@ -140,6 +140,7 @@
 #include "chrome/browser/chromeos/arc/arc_service_launcher.h"
 #include "chrome/browser/chromeos/authpolicy/auth_policy_credentials_manager.h"
 #include "chrome/browser/chromeos/cryptauth/gcm_device_info_provider_impl.h"
+#include "chrome/browser/chromeos/device_sync/device_sync_client_factory.h"
 #include "chrome/browser/chromeos/locale_change_guard.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #include "chrome/browser/chromeos/net/delay_network_call.h"
@@ -147,6 +148,7 @@
 #include "chrome/browser/chromeos/policy/user_policy_manager_factory_chromeos.h"
 #include "chrome/browser/chromeos/preferences.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/chromeos/secure_channel/secure_channel_client_provider.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chromeos/account_manager/account_manager.h"
 #include "chromeos/account_manager/account_manager_factory.h"
@@ -1174,16 +1176,15 @@ void ProfileImpl::RegisterInProcessServices(StaticServiceMap* services) {
   }
 
   if (base::FeatureList::IsEnabled(
-          chromeos::features::kEnableUnifiedMultiDeviceSetup)) {
+          chromeos::features::kEnableUnifiedMultiDeviceSetup) &&
+      base::FeatureList::IsEnabled(chromeos::features::kMultiDeviceApi)) {
+    chromeos::multidevice_setup::MultiDeviceSetupService::RegisterProfilePrefs(
+        pref_registry_.get());
     service_manager::EmbeddedServiceInfo info;
     info.task_runner = base::ThreadTaskRunnerHandle::Get();
-    info.factory = base::BindRepeating([] {
-      return std::unique_ptr<service_manager::Service>(
-          std::make_unique<
-              chromeos::multidevice_setup::MultiDeviceSetupService>());
-    });
-    services->insert(
-        std::make_pair(chromeos::multidevice_setup::mojom::kServiceName, info));
+    info.factory = base::BindRepeating(
+        &ProfileImpl::CreateMultiDeviceSetupService, base::Unretained(this));
+    services->emplace(chromeos::multidevice_setup::mojom::kServiceName, info);
   }
 #endif
 
@@ -1511,4 +1512,14 @@ ProfileImpl::CreateDeviceSyncService() {
       gcm::GCMProfileServiceFactory::GetForProfile(this)->driver(),
       chromeos::GcmDeviceInfoProviderImpl::GetInstance(), GetRequestContext());
 }
+
+std::unique_ptr<service_manager::Service>
+ProfileImpl::CreateMultiDeviceSetupService() {
+  return std::make_unique<chromeos::multidevice_setup::MultiDeviceSetupService>(
+      GetPrefs(),
+      chromeos::device_sync::DeviceSyncClientFactory::GetForProfile(this),
+      chromeos::secure_channel::SecureChannelClientProvider::GetInstance()
+          ->GetClient());
+}
+
 #endif  // defined(OS_CHROMEOS)

chrome/browser/profiles/profile_impl.h

@@ -209,6 +209,7 @@ class ProfileImpl : public Profile, public content_settings::Observer {
 
 #if defined(OS_CHROMEOS)
   std::unique_ptr<service_manager::Service> CreateDeviceSyncService();
+  std::unique_ptr<service_manager::Service> CreateMultiDeviceSetupService();
 #endif  // defined(OS_CHROMEOS)
 
   PrefChangeRegistrar pref_change_registrar_;

chromeos/services/multidevice_setup/BUILD.gn

@@ -18,6 +18,8 @@ static_library("multidevice_setup") {
     "multidevice_setup_base.h",
     "multidevice_setup_impl.cc",
     "multidevice_setup_impl.h",
+    "multidevice_setup_initializer.cc",
+    "multidevice_setup_initializer.h",
     "multidevice_setup_service.cc",
     "multidevice_setup_service.h",
     "setup_flow_completion_recorder.h",
@@ -31,6 +33,8 @@ static_library("multidevice_setup") {
     "//chromeos/services/device_sync/public/cpp",
     "//chromeos/services/device_sync/public/mojom",
     "//chromeos/services/multidevice_setup/public/mojom",
+    "//chromeos/services/secure_channel/public/cpp/client",
+    "//chromeos/services/secure_channel/public/mojom",
     "//components/cryptauth",
     "//components/pref_registry",
     "//components/prefs:prefs",
@@ -50,6 +54,8 @@ static_library("test_support") {
     "fake_account_status_change_delegate.cc",
     "fake_account_status_change_delegate.h",
     "fake_account_status_change_delegate_notifier.h",
+    "fake_multidevice_setup.cc",
+    "fake_multidevice_setup.h",
     "fake_setup_flow_completion_recorder.cc",
     "fake_setup_flow_completion_recorder.h",
   ]
@@ -68,6 +74,7 @@ source_set("unit_tests") {
 
   sources = [
     "account_status_change_delegate_notifier_impl_unittest.cc",
+    "multidevice_setup_impl_unittest.cc",
     "multidevice_setup_service_unittest.cc",
     "setup_flow_completion_recorder_impl_unittest.cc",
   ]
@@ -79,6 +86,7 @@ source_set("unit_tests") {
     "//base/test:test_support",
     "//chromeos/services/device_sync/public/cpp:test_support",
     "//chromeos/services/multidevice_setup/public/mojom",
+    "//chromeos/services/secure_channel/public/cpp/client:test_support",
     "//components/cryptauth:test_support",
     "//components/sync_preferences:test_support",
     "//services/service_manager/public/cpp/test:test_support",

chromeos/services/multidevice_setup/account_status_change_delegate_notifier.h

@@ -34,7 +34,9 @@ class AccountStatusChangeDelegateNotifier {
   mojom::AccountStatusChangeDelegate* delegate() { return delegate_ptr_.get(); }
 
  private:
+  friend class MultiDeviceSetupImpl;
   friend class MultiDeviceSetupAccountStatusChangeDelegateNotifierTest;
+  friend class MultiDeviceSetupImplTest;
 
   void FlushForTesting();
 

chromeos/services/multidevice_setup/fake_multidevice_setup.cc

+// Copyright 2018 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/services/multidevice_setup/fake_multidevice_setup.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+FakeMultiDeviceSetup::FakeMultiDeviceSetup() = default;
+
+FakeMultiDeviceSetup::~FakeMultiDeviceSetup() = default;
+
+void FakeMultiDeviceSetup::SetAccountStatusChangeDelegate(
+    mojom::AccountStatusChangeDelegatePtr delegate,
+    SetAccountStatusChangeDelegateCallback callback) {
+  delegate_ = std::move(delegate);
+  std::move(callback).Run();
+}
+
+void FakeMultiDeviceSetup::TriggerEventForDebugging(
+    mojom::EventTypeForDebugging type,
+    TriggerEventForDebuggingCallback callback) {
+  triggered_debug_events_.emplace_back(type, std::move(callback));
+}
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos

chromeos/services/multidevice_setup/fake_multidevice_setup.h

+// Copyright 2018 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_SERVICES_MULTIDEVICE_SETUP_FAKE_MULTIDEVICE_SETUP_H_
+#define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_FAKE_MULTIDEVICE_SETUP_H_
+
+#include <utility>
+#include <vector>
+
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+// Test MultiDeviceSetup implementation.
+class FakeMultiDeviceSetup : public mojom::MultiDeviceSetup {
+ public:
+  FakeMultiDeviceSetup();
+  ~FakeMultiDeviceSetup() override;
+
+  mojom::AccountStatusChangeDelegatePtr& delegate() { return delegate_; }
+
+  std::vector<std::pair<mojom::EventTypeForDebugging,
+                        TriggerEventForDebuggingCallback>>&
+  triggered_debug_events() {
+    return triggered_debug_events_;
+  }
+
+ private:
+  // mojom::MultiDeviceSetup:
+  void SetAccountStatusChangeDelegate(
+      mojom::AccountStatusChangeDelegatePtr delegate,
+      SetAccountStatusChangeDelegateCallback callback) override;
+  void TriggerEventForDebugging(
+      mojom::EventTypeForDebugging type,
+      TriggerEventForDebuggingCallback callback) override;
+
+  mojom::AccountStatusChangeDelegatePtr delegate_;
+
+  std::vector<
+      std::pair<mojom::EventTypeForDebugging, TriggerEventForDebuggingCallback>>
+      triggered_debug_events_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeMultiDeviceSetup);
+};
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_MULTIDEVICE_SETUP_FAKE_MULTIDEVICE_SETUP_H_

chromeos/services/multidevice_setup/multidevice_setup_impl.cc

@@ -6,7 +6,10 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/no_destructor.h"
+#include "base/time/default_clock.h"
 #include "chromeos/components/proximity_auth/logging/logging.h"
+#include "chromeos/services/multidevice_setup/account_status_change_delegate_notifier_impl.h"
+#include "chromeos/services/multidevice_setup/setup_flow_completion_recorder_impl.h"
 
 namespace chromeos {
 
@@ -33,44 +36,63 @@ void MultiDeviceSetupImpl::Factory::SetFactoryForTesting(
 
 MultiDeviceSetupImpl::Factory::~Factory() = default;
 
-std::unique_ptr<MultiDeviceSetupBase>
-MultiDeviceSetupImpl::Factory::BuildInstance() {
-  return base::WrapUnique(new MultiDeviceSetupImpl());
+std::unique_ptr<mojom::MultiDeviceSetup>
+MultiDeviceSetupImpl::Factory::BuildInstance(
+    PrefService* pref_service,
+    device_sync::DeviceSyncClient* device_sync_client,
+    secure_channel::SecureChannelClient* secure_channel_client) {
+  return base::WrapUnique(new MultiDeviceSetupImpl(
+      pref_service, device_sync_client, secure_channel_client));
 }
 
-MultiDeviceSetupImpl::MultiDeviceSetupImpl() = default;
+MultiDeviceSetupImpl::MultiDeviceSetupImpl(
+    PrefService* pref_service,
+    device_sync::DeviceSyncClient* device_sync_client,
+    secure_channel::SecureChannelClient* secure_channel_client)
+    : setup_flow_completion_recorder_(
+          SetupFlowCompletionRecorderImpl::Factory::Get()->BuildInstance(
+              pref_service,
+              base::DefaultClock::GetInstance())),
+      delegate_notifier_(
+          AccountStatusChangeDelegateNotifierImpl::Factory::Get()
+              ->BuildInstance(device_sync_client,
+                              pref_service,
+                              setup_flow_completion_recorder_.get(),
+                              base::DefaultClock::GetInstance())) {}
 
 MultiDeviceSetupImpl::~MultiDeviceSetupImpl() = default;
 
 void MultiDeviceSetupImpl::SetAccountStatusChangeDelegate(
     mojom::AccountStatusChangeDelegatePtr delegate,
     SetAccountStatusChangeDelegateCallback callback) {
-  delegate_ = std::move(delegate);
+  delegate_notifier_->SetAccountStatusChangeDelegatePtr(std::move(delegate));
   std::move(callback).Run();
 }
 
 void MultiDeviceSetupImpl::TriggerEventForDebugging(
     mojom::EventTypeForDebugging type,
     TriggerEventForDebuggingCallback callback) {
-  PA_LOG(INFO) << "MultiDeviceSetupImpl::TriggerEventForDebugging(" << type
-               << ") called.";
-
-  if (!delegate_.is_bound()) {
+  if (!delegate_notifier_->delegate_ptr_) {
     PA_LOG(ERROR) << "MultiDeviceSetupImpl::TriggerEventForDebugging(): No "
                   << "delgate has been set; cannot proceed.";
     std::move(callback).Run(false /* success */);
     return;
   }
 
+  PA_LOG(INFO) << "MultiDeviceSetupImpl::TriggerEventForDebugging(" << type
+               << ") called.";
+  mojom::AccountStatusChangeDelegate* delegate =
+      delegate_notifier_->delegate_ptr_.get();
+
   switch (type) {
     case mojom::EventTypeForDebugging::kNewUserPotentialHostExists:
-      delegate_->OnPotentialHostExistsForNewUser();
+      delegate->OnPotentialHostExistsForNewUser();
       break;
     case mojom::EventTypeForDebugging::kExistingUserConnectedHostSwitched:
-      delegate_->OnConnectedHostSwitchedForExistingUser();
+      delegate->OnConnectedHostSwitchedForExistingUser();
       break;
     case mojom::EventTypeForDebugging::kExistingUserNewChromebookAdded:
-      delegate_->OnNewChromebookAddedForExistingUser();
+      delegate->OnNewChromebookAddedForExistingUser();
       break;
     default:
       NOTREACHED();

chromeos/services/multidevice_setup/multidevice_setup_impl.h

@@ -7,25 +7,38 @@
 
 #include <memory>
 
-#include "chromeos/services/multidevice_setup/multidevice_setup_base.h"
 #include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
-#include "services/service_manager/public/cpp/binder_registry.h"
-#include "services/service_manager/public/cpp/service.h"
+
+class PrefService;
 
 namespace chromeos {
 
+namespace device_sync {
+class DeviceSyncClient;
+}  // namespace device_sync
+
+namespace secure_channel {
+class SecureChannelClient;
+}  // namespace secure_channel
+
 namespace multidevice_setup {
 
+class AccountStatusChangeDelegateNotifier;
+class SetupFlowCompletionRecorder;
+
 // Concrete MultiDeviceSetup implementation.
-class MultiDeviceSetupImpl : public MultiDeviceSetupBase {
+class MultiDeviceSetupImpl : public mojom::MultiDeviceSetup {
  public:
   class Factory {
    public:
     static Factory* Get();
     static void SetFactoryForTesting(Factory* test_factory);
     virtual ~Factory();
-    virtual std::unique_ptr<MultiDeviceSetupBase> BuildInstance();
+    virtual std::unique_ptr<mojom::MultiDeviceSetup> BuildInstance(
+        PrefService* pref_service,
+        device_sync::DeviceSyncClient* device_sync_client,
+        secure_channel::SecureChannelClient* secure_channel_client);
 
    private:
     static Factory* test_factory_;
@@ -34,7 +47,10 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase {
   ~MultiDeviceSetupImpl() override;
 
  private:
-  MultiDeviceSetupImpl();
+  MultiDeviceSetupImpl(
+      PrefService* pref_service,
+      device_sync::DeviceSyncClient* device_sync_client,
+      secure_channel::SecureChannelClient* secure_channel_client);
 
   // mojom::MultiDeviceSetup:
   void SetAccountStatusChangeDelegate(
@@ -44,7 +60,8 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase {
       mojom::EventTypeForDebugging type,
       TriggerEventForDebuggingCallback callback) override;
 
-  mojom::AccountStatusChangeDelegatePtr delegate_;
+  std::unique_ptr<SetupFlowCompletionRecorder> setup_flow_completion_recorder_;
+  std::unique_ptr<AccountStatusChangeDelegateNotifier> delegate_notifier_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiDeviceSetupImpl);
 };

chromeos/services/multidevice_setup/multidevice_setup_impl_unittest.cc

+// Copyright 2018 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 <memory>
+
+#include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
+#include "chromeos/services/device_sync/public/cpp/fake_device_sync_client.h"
+#include "chromeos/services/multidevice_setup/account_status_change_delegate_notifier_impl.h"
+#include "chromeos/services/multidevice_setup/fake_account_status_change_delegate.h"
+#include "chromeos/services/multidevice_setup/fake_account_status_change_delegate_notifier.h"
+#include "chromeos/services/multidevice_setup/fake_setup_flow_completion_recorder.h"
+#include "chromeos/services/multidevice_setup/multidevice_setup_impl.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
+#include "chromeos/services/multidevice_setup/setup_flow_completion_recorder_impl.h"
+#include "chromeos/services/secure_channel/public/cpp/client/fake_secure_channel_client.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+namespace {
+
+class FakeSetupFlowCompletionRecorderFactory
+    : public SetupFlowCompletionRecorderImpl::Factory {
+ public:
+  FakeSetupFlowCompletionRecorderFactory(
+      sync_preferences::TestingPrefServiceSyncable*
+          expected_testing_pref_service)
+      : expected_testing_pref_service_(expected_testing_pref_service) {}
+
+  ~FakeSetupFlowCompletionRecorderFactory() override = default;
+
+  FakeSetupFlowCompletionRecorder* instance() { return instance_; }
+
+ private:
+  // SetupFlowCompletionRecorderImpl::Factory:
+  std::unique_ptr<SetupFlowCompletionRecorder> BuildInstance(
+      PrefService* pref_service,
+      base::Clock* clock) override {
+    EXPECT_FALSE(instance_);
+    EXPECT_EQ(expected_testing_pref_service_, pref_service);
+
+    auto instance = std::make_unique<FakeSetupFlowCompletionRecorder>();
+    instance_ = instance.get();
+    return instance;
+  }
+
+  sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
+
+  FakeSetupFlowCompletionRecorder* instance_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeSetupFlowCompletionRecorderFactory);
+};
+
+class FakeAccountStatusChangeDelegateNotifierFactory
+    : public AccountStatusChangeDelegateNotifierImpl::Factory {
+ public:
+  FakeAccountStatusChangeDelegateNotifierFactory(
+      device_sync::FakeDeviceSyncClient* expected_device_sync_client,
+      sync_preferences::TestingPrefServiceSyncable*
+          expected_testing_pref_service,
+      FakeSetupFlowCompletionRecorderFactory*
+          fake_setup_flow_completion_recorder_factory)
+      : expected_device_sync_client_(expected_device_sync_client),
+        expected_testing_pref_service_(expected_testing_pref_service),
+        fake_setup_flow_completion_recorder_factory_(
+            fake_setup_flow_completion_recorder_factory) {}
+
+  ~FakeAccountStatusChangeDelegateNotifierFactory() override = default;
+
+  FakeAccountStatusChangeDelegateNotifier* instance() { return instance_; }
+
+ private:
+  // AccountStatusChangeDelegateNotifierImpl::Factory:
+  std::unique_ptr<AccountStatusChangeDelegateNotifier> BuildInstance(
+      device_sync::DeviceSyncClient* device_sync_client,
+      PrefService* pref_service,
+      SetupFlowCompletionRecorder* setup_flow_completion_recorder,
+      base::Clock* clock) override {
+    EXPECT_FALSE(instance_);
+    EXPECT_EQ(expected_device_sync_client_, device_sync_client);
+    EXPECT_EQ(expected_testing_pref_service_, pref_service);
+    EXPECT_EQ(fake_setup_flow_completion_recorder_factory_->instance(),
+              setup_flow_completion_recorder);
+
+    auto instance = std::make_unique<FakeAccountStatusChangeDelegateNotifier>();
+    instance_ = instance.get();
+    return instance;
+  }
+
+  device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
+  sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
+  FakeSetupFlowCompletionRecorderFactory*
+      fake_setup_flow_completion_recorder_factory_;
+
+  FakeAccountStatusChangeDelegateNotifier* instance_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeAccountStatusChangeDelegateNotifierFactory);
+};
+
+}  // namespace
+
+class MultiDeviceSetupImplTest : public testing::Test {
+ protected:
+  MultiDeviceSetupImplTest() = default;
+  ~MultiDeviceSetupImplTest() override = default;
+
+  void SetUp() override {
+    test_pref_service_ =
+        std::make_unique<sync_preferences::TestingPrefServiceSyncable>();
+    fake_device_sync_client_ =
+        std::make_unique<device_sync::FakeDeviceSyncClient>();
+    fake_secure_channel_client_ =
+        std::make_unique<secure_channel::FakeSecureChannelClient>();
+
+    fake_setup_flow_completion_recorder_factory_ =
+        std::make_unique<FakeSetupFlowCompletionRecorderFactory>(
+            test_pref_service_.get());
+    SetupFlowCompletionRecorderImpl::Factory::SetFactoryForTesting(
+        fake_setup_flow_completion_recorder_factory_.get());
+
+    fake_account_status_change_delegate_notifier_factory_ =
+        std::make_unique<FakeAccountStatusChangeDelegateNotifierFactory>(
+            fake_device_sync_client_.get(), test_pref_service_.get(),
+            fake_setup_flow_completion_recorder_factory_.get());
+    AccountStatusChangeDelegateNotifierImpl::Factory::SetFactoryForTesting(
+        fake_account_status_change_delegate_notifier_factory_.get());
+
+    multidevice_setup_ = MultiDeviceSetupImpl::Factory::Get()->BuildInstance(
+        test_pref_service_.get(), fake_device_sync_client_.get(),
+        fake_secure_channel_client_.get());
+  }
+
+  void TearDown() override {
+    SetupFlowCompletionRecorderImpl::Factory::SetFactoryForTesting(nullptr);
+    AccountStatusChangeDelegateNotifierImpl::Factory::SetFactoryForTesting(
+        nullptr);
+  }
+
+  void CallSetAccountStatusChangeDelegate() {
+    EXPECT_FALSE(fake_account_status_change_delegate_);
+
+    fake_account_status_change_delegate_ =
+        std::make_unique<FakeAccountStatusChangeDelegate>();
+
+    EXPECT_FALSE(fake_account_status_change_delegate_notifier()->delegate());
+    multidevice_setup_->SetAccountStatusChangeDelegate(
+        fake_account_status_change_delegate_->GenerateInterfacePtr(),
+        base::DoNothing());
+    EXPECT_TRUE(fake_account_status_change_delegate_notifier()->delegate());
+  }
+
+  bool CallTriggerEventForDebugging(mojom::EventTypeForDebugging type) {
+    EXPECT_FALSE(last_debug_event_success_);
+
+    base::RunLoop run_loop;
+    multidevice_setup_->TriggerEventForDebugging(
+        type, base::BindOnce(&MultiDeviceSetupImplTest::OnDebugEventTriggered,
+                             base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+
+    bool success = *last_debug_event_success_;
+    last_debug_event_success_.reset();
+
+    // If the delegate was set, fire off any pending Mojo messages.
+    if (success)
+      fake_account_status_change_delegate_notifier()->FlushForTesting();
+
+    return success;
+  }
+
+  FakeAccountStatusChangeDelegateNotifier*
+  fake_account_status_change_delegate_notifier() {
+    return fake_account_status_change_delegate_notifier_factory_->instance();
+  }
+
+  FakeAccountStatusChangeDelegate* fake_account_status_change_delegate() {
+    return fake_account_status_change_delegate_.get();
+  }
+
+ private:
+  void OnDebugEventTriggered(base::OnceClosure quit_closure, bool success) {
+    last_debug_event_success_ = success;
+    std::move(quit_closure).Run();
+  }
+
+  const base::test::ScopedTaskEnvironment scoped_task_environment_;
+
+  std::unique_ptr<sync_preferences::TestingPrefServiceSyncable>
+      test_pref_service_;
+  std::unique_ptr<device_sync::FakeDeviceSyncClient> fake_device_sync_client_;
+  std::unique_ptr<secure_channel::FakeSecureChannelClient>
+      fake_secure_channel_client_;
+
+  std::unique_ptr<FakeSetupFlowCompletionRecorderFactory>
+      fake_setup_flow_completion_recorder_factory_;
+  std::unique_ptr<FakeAccountStatusChangeDelegateNotifierFactory>
+      fake_account_status_change_delegate_notifier_factory_;
+
+  std::unique_ptr<FakeAccountStatusChangeDelegate>
+      fake_account_status_change_delegate_;
+  base::Optional<bool> last_debug_event_success_;
+
+  std::unique_ptr<mojom::MultiDeviceSetup> multidevice_setup_;
+
+  DISALLOW_COPY_AND_ASSIGN(MultiDeviceSetupImplTest);
+};
+
+TEST_F(MultiDeviceSetupImplTest, AccountStatusChangeDelegate) {
+  // All requests to trigger debug events should fail before the delegate has
+  // been set.
+  EXPECT_FALSE(CallTriggerEventForDebugging(
+      mojom::EventTypeForDebugging::kNewUserPotentialHostExists));
+  EXPECT_FALSE(CallTriggerEventForDebugging(
+      mojom::EventTypeForDebugging::kExistingUserConnectedHostSwitched));
+  EXPECT_FALSE(CallTriggerEventForDebugging(
+      mojom::EventTypeForDebugging::kExistingUserNewChromebookAdded));
+
+  CallSetAccountStatusChangeDelegate();
+
+  // All debug trigger events should now succeed.
+  EXPECT_TRUE(CallTriggerEventForDebugging(
+      mojom::EventTypeForDebugging::kNewUserPotentialHostExists));
+  EXPECT_EQ(
+      1u, fake_account_status_change_delegate()->num_new_user_events_handled());
+
+  EXPECT_TRUE(CallTriggerEventForDebugging(
+      mojom::EventTypeForDebugging::kExistingUserConnectedHostSwitched));
+  EXPECT_EQ(1u, fake_account_status_change_delegate()
+                    ->num_existing_user_host_switched_events_handled());
+
+  EXPECT_TRUE(CallTriggerEventForDebugging(
+      mojom::EventTypeForDebugging::kExistingUserNewChromebookAdded));
+  EXPECT_EQ(1u, fake_account_status_change_delegate()
+                    ->num_existing_user_chromebook_added_events_handled());
+}
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos

chromeos/services/multidevice_setup/multidevice_setup_initializer.cc

+// Copyright 2018 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/services/multidevice_setup/multidevice_setup_initializer.h"
+
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/no_destructor.h"
+#include "chromeos/components/proximity_auth/logging/logging.h"
+#include "chromeos/services/multidevice_setup/multidevice_setup_impl.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+// static
+MultiDeviceSetupInitializer::Factory*
+    MultiDeviceSetupInitializer::Factory::test_factory_ = nullptr;
+
+// static
+MultiDeviceSetupInitializer::Factory*
+MultiDeviceSetupInitializer::Factory::Get() {
+  if (test_factory_)
+    return test_factory_;
+
+  static base::NoDestructor<Factory> factory;
+  return factory.get();
+}
+
+// static
+void MultiDeviceSetupInitializer::Factory::SetFactoryForTesting(
+    Factory* test_factory) {
+  test_factory_ = test_factory;
+}
+
+MultiDeviceSetupInitializer::Factory::~Factory() = default;
+
+std::unique_ptr<MultiDeviceSetupBase>
+MultiDeviceSetupInitializer::Factory::BuildInstance(
+    PrefService* pref_service,
+    device_sync::DeviceSyncClient* device_sync_client,
+    secure_channel::SecureChannelClient* secure_channel_client) {
+  return base::WrapUnique(new MultiDeviceSetupInitializer(
+      pref_service, device_sync_client, secure_channel_client));
+}
+
+MultiDeviceSetupInitializer::MultiDeviceSetupInitializer(
+    PrefService* pref_service,
+    device_sync::DeviceSyncClient* device_sync_client,
+    secure_channel::SecureChannelClient* secure_channel_client)
+    : pref_service_(pref_service),
+      device_sync_client_(device_sync_client),
+      secure_channel_client_(secure_channel_client) {
+  if (device_sync_client_->GetLocalDeviceMetadata()) {
+    InitializeImplementation();
+    return;
+  }
+
+  device_sync_client_->AddObserver(this);
+}
+
+MultiDeviceSetupInitializer::~MultiDeviceSetupInitializer() = default;
+
+void MultiDeviceSetupInitializer::SetAccountStatusChangeDelegate(
+    mojom::AccountStatusChangeDelegatePtr delegate,
+    SetAccountStatusChangeDelegateCallback callback) {
+  if (multidevice_setup_impl_) {
+    multidevice_setup_impl_->SetAccountStatusChangeDelegate(
+        std::move(delegate), std::move(callback));
+    return;
+  }
+
+  PA_LOG(INFO) << "MultiDeviceSetupInitializer::"
+               << "SetAccountStatusChangeDelegate(): Delegate set before "
+               << "service was initialized; will be set once initialization is "
+               << "complete.";
+  pending_delegate_ = std::move(delegate);
+
+  std::move(callback).Run();
+}
+
+void MultiDeviceSetupInitializer::TriggerEventForDebugging(
+    mojom::EventTypeForDebugging type,
+    TriggerEventForDebuggingCallback callback) {
+  if (multidevice_setup_impl_) {
+    multidevice_setup_impl_->TriggerEventForDebugging(type,
+                                                      std::move(callback));
+    return;
+  }
+
+  // If initialization is not complete, no debug event can be sent.
+  std::move(callback).Run(false /* success */);
+}
+
+void MultiDeviceSetupInitializer::OnEnrollmentFinished() {
+  if (!device_sync_client_->GetLocalDeviceMetadata())
+    return;
+
+  device_sync_client_->RemoveObserver(this);
+  InitializeImplementation();
+}
+
+void MultiDeviceSetupInitializer::InitializeImplementation() {
+  DCHECK(!multidevice_setup_impl_);
+
+  multidevice_setup_impl_ = MultiDeviceSetupImpl::Factory::Get()->BuildInstance(
+      pref_service_, device_sync_client_, secure_channel_client_);
+
+  if (!pending_delegate_)
+    return;
+
+  multidevice_setup_impl_->SetAccountStatusChangeDelegate(
+      std::move(pending_delegate_), base::DoNothing());
+}
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos

chromeos/services/multidevice_setup/multidevice_setup_initializer.h

+// Copyright 2018 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_SERVICES_MULTIDEVICE_SETUP_MULTIDEVICE_SETUP_INITIALIZER_H_
+#define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_MULTIDEVICE_SETUP_INITIALIZER_H_
+
+#include "chromeos/services/device_sync/public/cpp/device_sync_client.h"
+#include "chromeos/services/multidevice_setup/multidevice_setup_base.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+
+class PrefService;
+
+namespace chromeos {
+
+namespace secure_channel {
+class SecureChannelClient;
+}  // namespace secure_channel
+
+namespace multidevice_setup {
+
+// Initializes the MultiDeviceSetup service. This class is responsible for
+// waiting for asynchronous initialization steps to complete before creating
+// the concrete implementation of the mojom::MultiDeviceSetup interface.
+class MultiDeviceSetupInitializer
+    : public MultiDeviceSetupBase,
+      public device_sync::DeviceSyncClient::Observer {
+ public:
+  class Factory {
+   public:
+    static Factory* Get();
+    static void SetFactoryForTesting(Factory* test_factory);
+    virtual ~Factory();
+    virtual std::unique_ptr<MultiDeviceSetupBase> BuildInstance(
+        PrefService* pref_service,
+        device_sync::DeviceSyncClient* device_sync_client,
+        secure_channel::SecureChannelClient* secure_channel_client);
+
+   private:
+    static Factory* test_factory_;
+  };
+
+  ~MultiDeviceSetupInitializer() override;
+
+ private:
+  MultiDeviceSetupInitializer(
+      PrefService* pref_service,
+      device_sync::DeviceSyncClient* device_sync_client,
+      secure_channel::SecureChannelClient* secure_channel_client);
+
+  // mojom::MultiDeviceSetup:
+  void SetAccountStatusChangeDelegate(
+      mojom::AccountStatusChangeDelegatePtr delegate,
+      SetAccountStatusChangeDelegateCallback callback) override;
+  void TriggerEventForDebugging(
+      mojom::EventTypeForDebugging type,
+      TriggerEventForDebuggingCallback callback) override;
+
+  // device_sync::DeviceSyncClient::Observer:
+  void OnEnrollmentFinished() override;
+
+  void InitializeImplementation();
+
+  PrefService* pref_service_;
+  device_sync::DeviceSyncClient* device_sync_client_;
+  secure_channel::SecureChannelClient* secure_channel_client_;
+
+  std::unique_ptr<mojom::MultiDeviceSetup> multidevice_setup_impl_;
+
+  // If SetAccountStatusChangeDelegate() is called before initialization is
+  // complete, |pending_delegate_| stores the pointer until it can be passed to
+  // the full MultiDeviceSetup implementation.
+  mojom::AccountStatusChangeDelegatePtr pending_delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(MultiDeviceSetupInitializer);
+};
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_MULTIDEVICE_SETUP_MULTIDEVICE_SETUP_INITIALIZER_H_

chromeos/services/multidevice_setup/multidevice_setup_service.cc

@@ -5,16 +5,29 @@
 #include "chromeos/services/multidevice_setup/multidevice_setup_service.h"
 
 #include "chromeos/components/proximity_auth/logging/logging.h"
+#include "chromeos/services/multidevice_setup/account_status_change_delegate_notifier_impl.h"
 #include "chromeos/services/multidevice_setup/multidevice_setup_base.h"
-#include "chromeos/services/multidevice_setup/multidevice_setup_impl.h"
+#include "chromeos/services/multidevice_setup/multidevice_setup_initializer.h"
 
 namespace chromeos {
 
 namespace multidevice_setup {
 
-MultiDeviceSetupService::MultiDeviceSetupService()
+// static
+void MultiDeviceSetupService::RegisterProfilePrefs(
+    PrefRegistrySimple* registry) {
+  AccountStatusChangeDelegateNotifierImpl::RegisterPrefs(registry);
+}
+
+MultiDeviceSetupService::MultiDeviceSetupService(
+    PrefService* pref_service,
+    device_sync::DeviceSyncClient* device_sync_client,
+    secure_channel::SecureChannelClient* secure_channel_client)
     : multidevice_setup_(
-          MultiDeviceSetupImpl::Factory::Get()->BuildInstance()) {}
+          MultiDeviceSetupInitializer::Factory::Get()->BuildInstance(
+              pref_service,
+              device_sync_client,
+              secure_channel_client)) {}
 
 MultiDeviceSetupService::~MultiDeviceSetupService() = default;
 

chromeos/services/multidevice_setup/multidevice_setup_service.h

@@ -11,8 +11,19 @@
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/service.h"
 
+class PrefService;
+class PrefRegistrySimple;
+
 namespace chromeos {
 
+namespace device_sync {
+class DeviceSyncClient;
+}  // namespace device_sync
+
+namespace secure_channel {
+class SecureChannelClient;
+}  // namespace secure_channel
+
 namespace multidevice_setup {
 
 class MultiDeviceSetupBase;
@@ -22,9 +33,14 @@ class MultiDeviceSetupBase;
 // requests.
 class MultiDeviceSetupService : public service_manager::Service {
  public:
-  MultiDeviceSetupService();
+  MultiDeviceSetupService(
+      PrefService* pref_service,
+      device_sync::DeviceSyncClient* device_sync_client,
+      secure_channel::SecureChannelClient* secure_channel_client);
   ~MultiDeviceSetupService() override;
 
+  static void RegisterProfilePrefs(PrefRegistrySimple* registry);
+
  private:
   // service_manager::Service:
   void OnStart() override;