[CrOS MultiDevice] Add feature state management to MultiDeviceSetup.

This CL adds a new set of APIs for getting/setting the states of the
multi-device features as well as adding an observer pattern for
receiving updates to these feature states.

Bug: 824568
Change-Id: If79c713b9737a738bcb9347871f0db913b7abb5b
Reviewed-on: https://chromium-review.googlesource.com/1172707
Commit-Queue: Ryan Hansberry <hansberry@chromium.org>
Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#583445}

chrome/browser/resources/chromeos/multidevice_setup/fake_mojo_service.js

@@ -21,10 +21,22 @@ class FakeMojoService {
   }
 
   /** @override */
-  setAccountStatusChangeDelegate(delegate) {}
+  setAccountStatusChangeDelegate(delegate) {
+    // Unimplemented; never called from setup flow.
+    assertNotReached();
+  }
+
+  /** @override */
+  addHostStatusObserver(observer) {
+    // Unimplemented; never called from setup flow.
+    assertNotReached();
+  }
 
   /** @override */
-  addHostStatusObserver(observer) {}
+  addFeatureStateObserver(observer) {
+    // Unimplemented; never called from setup flow.
+    assertNotReached();
+  }
 
   /** @override */
   getEligibleHostDevices() {
@@ -66,6 +78,20 @@ class FakeMojoService {
     });
   }
 
+  /** @override */
+  setFeatureEnabledState() {
+    return new Promise((resolve, reject) => {
+      reject('Unimplemented; never called from setup flow.');
+    });
+  }
+
+  /** @override */
+  getFeatureStates() {
+    return new Promise((resolve, reject) => {
+      reject('Unimplemented; never called from setup flow.');
+    });
+  }
+
   /** @override */
   retrySetHostNow() {
     return new Promise((resolve, reject) => {

chromeos/services/multidevice_setup/BUILD.gn

@@ -79,6 +79,8 @@ static_library("test_support") {
     "fake_eligible_host_devices_provider.h",
     "fake_feature_state_manager.cc",
     "fake_feature_state_manager.h",
+    "fake_feature_state_observer.cc",
+    "fake_feature_state_observer.h",
     "fake_host_backend_delegate.cc",
     "fake_host_backend_delegate.h",
     "fake_host_status_observer.cc",

chromeos/services/multidevice_setup/fake_feature_state_observer.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_feature_state_observer.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+FakeFeatureStateObserver::FakeFeatureStateObserver() = default;
+
+FakeFeatureStateObserver::~FakeFeatureStateObserver() = default;
+
+mojom::FeatureStateObserverPtr
+FakeFeatureStateObserver::GenerateInterfacePtr() {
+  mojom::FeatureStateObserverPtr interface_ptr;
+  bindings_.AddBinding(this, mojo::MakeRequest(&interface_ptr));
+  return interface_ptr;
+}
+
+void FakeFeatureStateObserver::OnFeatureStatesChanged(
+    const base::flat_map<mojom::Feature, mojom::FeatureState>&
+        feature_states_map) {
+  feature_state_updates_.emplace_back(feature_states_map);
+}
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos

chromeos/services/multidevice_setup/fake_feature_state_observer.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_FEATURE_STATE_OBSERVER_H_
+#define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_FAKE_FEATURE_STATE_OBSERVER_H_
+
+#include "base/containers/flat_map.h"
+#include "base/macros.h"
+#include "base/optional.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+// Fake mojom::FeatureStateObserver implementation for tests.
+class FakeFeatureStateObserver : public mojom::FeatureStateObserver {
+ public:
+  FakeFeatureStateObserver();
+  ~FakeFeatureStateObserver() override;
+
+  mojom::FeatureStateObserverPtr GenerateInterfacePtr();
+
+  const std::vector<base::flat_map<mojom::Feature, mojom::FeatureState>>&
+  feature_state_updates() {
+    return feature_state_updates_;
+  }
+
+ private:
+  // mojom::FeatureStateObserver:
+  void OnFeatureStatesChanged(
+      const base::flat_map<mojom::Feature, mojom::FeatureState>&
+          feature_states_map) override;
+
+  std::vector<base::flat_map<mojom::Feature, mojom::FeatureState>>
+      feature_state_updates_;
+
+  mojo::BindingSet<mojom::FeatureStateObserver> bindings_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeFeatureStateObserver);
+};
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_MULTIDEVICE_SETUP_FAKE_FEATURE_STATE_OBSERVER_H_

chromeos/services/multidevice_setup/multidevice_setup_impl.cc

@@ -10,6 +10,7 @@
 #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/eligible_host_devices_provider_impl.h"
+#include "chromeos/services/multidevice_setup/feature_state_manager_impl.h"
 #include "chromeos/services/multidevice_setup/host_backend_delegate_impl.h"
 #include "chromeos/services/multidevice_setup/host_status_provider_impl.h"
 #include "chromeos/services/multidevice_setup/host_verifier_impl.h"
@@ -71,6 +72,11 @@ MultiDeviceSetupImpl::MultiDeviceSetupImpl(
               host_backend_delegate_.get(),
               host_verifier_.get(),
               device_sync_client)),
+      feature_state_manager_(
+          FeatureStateManagerImpl::Factory::Get()->BuildInstance(
+              pref_service,
+              host_status_provider_.get(),
+              device_sync_client)),
       setup_flow_completion_recorder_(
           SetupFlowCompletionRecorderImpl::Factory::Get()->BuildInstance(
               pref_service,
@@ -82,10 +88,12 @@ MultiDeviceSetupImpl::MultiDeviceSetupImpl(
                               setup_flow_completion_recorder_.get(),
                               base::DefaultClock::GetInstance())) {
   host_status_provider_->AddObserver(this);
+  feature_state_manager_->AddObserver(this);
 }
 
 MultiDeviceSetupImpl::~MultiDeviceSetupImpl() {
   host_status_provider_->RemoveObserver(this);
+  feature_state_manager_->RemoveObserver(this);
 }
 
 void MultiDeviceSetupImpl::SetAccountStatusChangeDelegate(
@@ -98,6 +106,11 @@ void MultiDeviceSetupImpl::AddHostStatusObserver(
   host_status_observers_.AddPtr(std::move(observer));
 }
 
+void MultiDeviceSetupImpl::AddFeatureStateObserver(
+    mojom::FeatureStateObserverPtr observer) {
+  feature_state_observers_.AddPtr(std::move(observer));
+}
+
 void MultiDeviceSetupImpl::GetEligibleHostDevices(
     GetEligibleHostDevicesCallback callback) {
   std::vector<cryptauth::RemoteDevice> eligible_remote_devices;
@@ -149,6 +162,18 @@ void MultiDeviceSetupImpl::GetHostStatus(GetHostStatusCallback callback) {
                           device_for_callback);
 }
 
+void MultiDeviceSetupImpl::SetFeatureEnabledState(
+    mojom::Feature feature,
+    bool enabled,
+    SetFeatureEnabledStateCallback callback) {
+  std::move(callback).Run(
+      feature_state_manager_->SetFeatureEnabledState(feature, enabled));
+}
+
+void MultiDeviceSetupImpl::GetFeatureStates(GetFeatureStatesCallback callback) {
+  std::move(callback).Run(feature_state_manager_->GetFeatureStates());
+}
+
 void MultiDeviceSetupImpl::RetrySetHostNow(RetrySetHostNowCallback callback) {
   HostStatusProvider::HostStatusWithDevice host_status_with_device =
       host_status_provider_->GetHostWithStatus();
@@ -223,8 +248,17 @@ void MultiDeviceSetupImpl::OnHostStatusChange(
       });
 }
 
+void MultiDeviceSetupImpl::OnFeatureStatesChange(
+    const FeatureStateManager::FeatureStatesMap& feature_states_map) {
+  feature_state_observers_.ForAllPtrs(
+      [&feature_states_map](mojom::FeatureStateObserver* observer) {
+        observer->OnFeatureStatesChanged(feature_states_map);
+      });
+}
+
 void MultiDeviceSetupImpl::FlushForTesting() {
   host_status_observers_.FlushForTesting();
+  feature_state_observers_.FlushForTesting();
 }
 
 }  // namespace multidevice_setup

chromeos/services/multidevice_setup/multidevice_setup_impl.h

@@ -7,6 +7,8 @@
 
 #include <memory>
 
+#include "base/containers/flat_map.h"
+#include "chromeos/services/multidevice_setup/feature_state_manager.h"
 #include "chromeos/services/multidevice_setup/host_status_provider.h"
 #include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
@@ -35,7 +37,8 @@ class SetupFlowCompletionRecorder;
 
 // Concrete MultiDeviceSetup implementation.
 class MultiDeviceSetupImpl : public mojom::MultiDeviceSetup,
-                             public HostStatusProvider::Observer {
+                             public HostStatusProvider::Observer,
+                             public FeatureStateManager::Observer {
  public:
   class Factory {
    public:
@@ -65,11 +68,17 @@ class MultiDeviceSetupImpl : public mojom::MultiDeviceSetup,
   void SetAccountStatusChangeDelegate(
       mojom::AccountStatusChangeDelegatePtr delegate) override;
   void AddHostStatusObserver(mojom::HostStatusObserverPtr observer) override;
+  void AddFeatureStateObserver(
+      mojom::FeatureStateObserverPtr observer) override;
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void SetHostDevice(const std::string& host_device_id,
                      SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;
   void GetHostStatus(GetHostStatusCallback callback) override;
+  void SetFeatureEnabledState(mojom::Feature feature,
+                              bool enabled,
+                              SetFeatureEnabledStateCallback callback) override;
+  void GetFeatureStates(GetFeatureStatesCallback callback) override;
   void RetrySetHostNow(RetrySetHostNowCallback callback) override;
   void TriggerEventForDebugging(
       mojom::EventTypeForDebugging type,
@@ -79,16 +88,22 @@ class MultiDeviceSetupImpl : public mojom::MultiDeviceSetup,
   void OnHostStatusChange(const HostStatusProvider::HostStatusWithDevice&
                               host_status_with_device) override;
 
+  // FeatureStateManager::Observer:
+  void OnFeatureStatesChange(
+      const FeatureStateManager::FeatureStatesMap& feature_states_map) override;
+
   void FlushForTesting();
 
   std::unique_ptr<EligibleHostDevicesProvider> eligible_host_devices_provider_;
   std::unique_ptr<HostBackendDelegate> host_backend_delegate_;
   std::unique_ptr<HostVerifier> host_verifier_;
   std::unique_ptr<HostStatusProvider> host_status_provider_;
+  std::unique_ptr<FeatureStateManager> feature_state_manager_;
   std::unique_ptr<SetupFlowCompletionRecorder> setup_flow_completion_recorder_;
   std::unique_ptr<AccountStatusChangeDelegateNotifier> delegate_notifier_;
 
   mojo::InterfacePtrSet<mojom::HostStatusObserver> host_status_observers_;
+  mojo::InterfacePtrSet<mojom::FeatureStateObserver> feature_state_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiDeviceSetupImpl);
 };

chromeos/services/multidevice_setup/multidevice_setup_impl_unittest.cc

@@ -14,11 +14,14 @@
 #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_eligible_host_devices_provider.h"
+#include "chromeos/services/multidevice_setup/fake_feature_state_manager.h"
+#include "chromeos/services/multidevice_setup/fake_feature_state_observer.h"
 #include "chromeos/services/multidevice_setup/fake_host_backend_delegate.h"
 #include "chromeos/services/multidevice_setup/fake_host_status_observer.h"
 #include "chromeos/services/multidevice_setup/fake_host_status_provider.h"
 #include "chromeos/services/multidevice_setup/fake_host_verifier.h"
 #include "chromeos/services/multidevice_setup/fake_setup_flow_completion_recorder.h"
+#include "chromeos/services/multidevice_setup/feature_state_manager_impl.h"
 #include "chromeos/services/multidevice_setup/host_backend_delegate_impl.h"
 #include "chromeos/services/multidevice_setup/host_status_provider_impl.h"
 #include "chromeos/services/multidevice_setup/host_verifier_impl.h"
@@ -223,6 +226,47 @@ class FakeHostStatusProviderFactory : public HostStatusProviderImpl::Factory {
   DISALLOW_COPY_AND_ASSIGN(FakeHostStatusProviderFactory);
 };
 
+class FakeFeatureStateManagerFactory : public FeatureStateManagerImpl::Factory {
+ public:
+  FakeFeatureStateManagerFactory(
+      sync_preferences::TestingPrefServiceSyncable*
+          expected_testing_pref_service,
+      FakeHostStatusProviderFactory* fake_host_status_provider_factory,
+      device_sync::FakeDeviceSyncClient* expected_device_sync_client)
+      : expected_testing_pref_service_(expected_testing_pref_service),
+        fake_host_status_provider_factory_(fake_host_status_provider_factory),
+        expected_device_sync_client_(expected_device_sync_client) {}
+
+  ~FakeFeatureStateManagerFactory() override = default;
+
+  FakeFeatureStateManager* instance() { return instance_; }
+
+ private:
+  // FeatureStateManagerImpl::Factory:
+  std::unique_ptr<FeatureStateManager> BuildInstance(
+      PrefService* pref_service,
+      HostStatusProvider* host_status_provider,
+      device_sync::DeviceSyncClient* device_sync_client) override {
+    EXPECT_FALSE(instance_);
+    EXPECT_EQ(expected_testing_pref_service_, pref_service);
+    EXPECT_EQ(fake_host_status_provider_factory_->instance(),
+              host_status_provider);
+    EXPECT_EQ(expected_device_sync_client_, device_sync_client);
+
+    auto instance = std::make_unique<FakeFeatureStateManager>();
+    instance_ = instance.get();
+    return instance;
+  }
+
+  sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
+  FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
+  device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
+
+  FakeFeatureStateManager* instance_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeFeatureStateManagerFactory);
+};
+
 class FakeSetupFlowCompletionRecorderFactory
     : public SetupFlowCompletionRecorderImpl::Factory {
  public:
@@ -345,6 +389,13 @@ class MultiDeviceSetupImplTest : public testing::Test {
     HostStatusProviderImpl::Factory::SetFactoryForTesting(
         fake_host_status_provider_factory_.get());
 
+    fake_feature_state_manager_factory_ =
+        std::make_unique<FakeFeatureStateManagerFactory>(
+            test_pref_service_.get(), fake_host_status_provider_factory_.get(),
+            fake_device_sync_client_.get());
+    FeatureStateManagerImpl::Factory::SetFactoryForTesting(
+        fake_feature_state_manager_factory_.get());
+
     fake_setup_flow_completion_recorder_factory_ =
         std::make_unique<FakeSetupFlowCompletionRecorderFactory>(
             test_pref_service_.get());
@@ -368,6 +419,7 @@ class MultiDeviceSetupImplTest : public testing::Test {
     HostBackendDelegateImpl::Factory::SetFactoryForTesting(nullptr);
     HostVerifierImpl::Factory::SetFactoryForTesting(nullptr);
     HostStatusProviderImpl::Factory::SetFactoryForTesting(nullptr);
+    FeatureStateManagerImpl::Factory::SetFactoryForTesting(nullptr);
     SetupFlowCompletionRecorderImpl::Factory::SetFactoryForTesting(nullptr);
     AccountStatusChangeDelegateNotifierImpl::Factory::SetFactoryForTesting(
         nullptr);
@@ -428,6 +480,34 @@ class MultiDeviceSetupImplTest : public testing::Test {
     return host_status_update;
   }
 
+  bool CallSetFeatureEnabledState(mojom::Feature feature, bool enabled) {
+    base::RunLoop run_loop;
+    multidevice_setup_->SetFeatureEnabledState(
+        feature, enabled,
+        base::BindOnce(&MultiDeviceSetupImplTest::OnSetFeatureEnabled,
+                       base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+
+    bool success = *last_set_host_success_;
+    last_set_host_success_.reset();
+
+    return success;
+  }
+
+  base::flat_map<mojom::Feature, mojom::FeatureState> CallGetFeatureStates() {
+    base::RunLoop run_loop;
+    multidevice_setup_->GetFeatureStates(
+        base::BindOnce(&MultiDeviceSetupImplTest::OnGetFeatureStates,
+                       base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+
+    base::flat_map<mojom::Feature, mojom::FeatureState> feature_states_map =
+        *last_get_feature_states_result_;
+    last_get_feature_states_result_.reset();
+
+    return feature_states_map;
+  }
+
   bool CallRetrySetHostNow() {
     base::RunLoop run_loop;
     multidevice_setup_->RetrySetHostNow(
@@ -503,6 +583,10 @@ class MultiDeviceSetupImplTest : public testing::Test {
     return fake_host_status_provider_factory_->instance();
   }
 
+  FakeFeatureStateManager* fake_feature_state_manager() {
+    return fake_feature_state_manager_factory_->instance();
+  }
+
   FakeSetupFlowCompletionRecorder* fake_setup_flow_completion_recorder() {
     return fake_setup_flow_completion_recorder_factory_->instance();
   }
@@ -542,6 +626,21 @@ class MultiDeviceSetupImplTest : public testing::Test {
     std::move(quit_closure).Run();
   }
 
+  void OnSetFeatureEnabled(base::OnceClosure quit_closure, bool success) {
+    EXPECT_FALSE(last_set_host_success_);
+    last_set_host_success_ = success;
+    std::move(quit_closure).Run();
+  }
+
+  void OnGetFeatureStates(
+      base::OnceClosure quit_closure,
+      const base::flat_map<mojom::Feature, mojom::FeatureState>&
+          feature_states_map) {
+    EXPECT_FALSE(last_get_feature_states_result_);
+    last_get_feature_states_result_ = feature_states_map;
+    std::move(quit_closure).Run();
+  }
+
   void OnHostRetried(base::OnceClosure quit_closure, bool success) {
     EXPECT_FALSE(last_retry_success_);
     last_retry_success_ = success;
@@ -571,6 +670,8 @@ class MultiDeviceSetupImplTest : public testing::Test {
   std::unique_ptr<FakeHostVerifierFactory> fake_host_verifier_factory_;
   std::unique_ptr<FakeHostStatusProviderFactory>
       fake_host_status_provider_factory_;
+  std::unique_ptr<FakeFeatureStateManagerFactory>
+      fake_feature_state_manager_factory_;
   std::unique_ptr<FakeSetupFlowCompletionRecorderFactory>
       fake_setup_flow_completion_recorder_factory_;
   std::unique_ptr<FakeAccountStatusChangeDelegateNotifierFactory>
@@ -585,6 +686,9 @@ class MultiDeviceSetupImplTest : public testing::Test {
   base::Optional<
       std::pair<mojom::HostStatus, base::Optional<cryptauth::RemoteDevice>>>
       last_host_status_;
+  base::Optional<bool> last_set_feature_enabled_state_success_;
+  base::Optional<base::flat_map<mojom::Feature, mojom::FeatureState>>
+      last_get_feature_states_result_;
   base::Optional<bool> last_retry_success_;
 
   std::unique_ptr<mojom::MultiDeviceSetup> multidevice_setup_;
@@ -621,6 +725,38 @@ TEST_F(MultiDeviceSetupImplTest, AccountStatusChangeDelegate) {
                     ->num_existing_user_chromebook_added_events_handled());
 }
 
+TEST_F(MultiDeviceSetupImplTest, FeatureStateChanges) {
+  auto observer = std::make_unique<FakeFeatureStateObserver>();
+  multidevice_setup()->AddFeatureStateObserver(
+      observer->GenerateInterfacePtr());
+
+  EXPECT_EQ(mojom::FeatureState::kUnavailableNoVerifiedHost,
+            CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
+
+  fake_feature_state_manager()->SetFeatureState(
+      mojom::Feature::kBetterTogetherSuite,
+      mojom::FeatureState::kNotSupportedByChromebook);
+  SendPendingObserverMessages();
+  EXPECT_EQ(mojom::FeatureState::kNotSupportedByChromebook,
+            CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
+  EXPECT_EQ(1u, observer->feature_state_updates().size());
+
+  fake_feature_state_manager()->SetFeatureState(
+      mojom::Feature::kBetterTogetherSuite,
+      mojom::FeatureState::kEnabledByUser);
+  SendPendingObserverMessages();
+  EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
+            CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
+  EXPECT_EQ(2u, observer->feature_state_updates().size());
+
+  EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
+                                         false /* enabled */));
+  SendPendingObserverMessages();
+  EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
+            CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
+  EXPECT_EQ(3u, observer->feature_state_updates().size());
+}
+
 TEST_F(MultiDeviceSetupImplTest, ComprehensiveHostTest) {
   // Start with no eligible devices.
   EXPECT_TRUE(CallGetEligibleHostDevices().empty());

chromeos/services/multidevice_setup/multidevice_setup_initializer.cc

@@ -80,7 +80,17 @@ void MultiDeviceSetupInitializer::AddHostStatusObserver(
     return;
   }
 
-  pending_observers_.push_back(std::move(observer));
+  pending_host_status_observers_.push_back(std::move(observer));
+}
+
+void MultiDeviceSetupInitializer::AddFeatureStateObserver(
+    mojom::FeatureStateObserverPtr observer) {
+  if (multidevice_setup_impl_) {
+    multidevice_setup_impl_->AddFeatureStateObserver(std::move(observer));
+    return;
+  }
+
+  pending_feature_state_observers_.push_back(std::move(observer));
 }
 
 void MultiDeviceSetupInitializer::GetEligibleHostDevices(
@@ -139,6 +149,30 @@ void MultiDeviceSetupInitializer::GetHostStatus(
   pending_get_host_args_.push_back(std::move(callback));
 }
 
+void MultiDeviceSetupInitializer::SetFeatureEnabledState(
+    mojom::Feature feature,
+    bool enabled,
+    SetFeatureEnabledStateCallback callback) {
+  if (multidevice_setup_impl_) {
+    multidevice_setup_impl_->SetFeatureEnabledState(feature, enabled,
+                                                    std::move(callback));
+    return;
+  }
+
+  pending_set_feature_enabled_args_.emplace_back(feature, enabled,
+                                                 std::move(callback));
+}
+
+void MultiDeviceSetupInitializer::GetFeatureStates(
+    GetFeatureStatesCallback callback) {
+  if (multidevice_setup_impl_) {
+    multidevice_setup_impl_->GetFeatureStates(std::move(callback));
+    return;
+  }
+
+  pending_get_feature_states_args_.emplace_back(std::move(callback));
+}
+
 void MultiDeviceSetupInitializer::RetrySetHostNow(
     RetrySetHostNowCallback callback) {
   if (multidevice_setup_impl_) {
@@ -178,9 +212,13 @@ void MultiDeviceSetupInitializer::InitializeImplementation() {
         std::move(pending_delegate_));
   }
 
-  for (auto& observer : pending_observers_)
+  for (auto& observer : pending_host_status_observers_)
     multidevice_setup_impl_->AddHostStatusObserver(std::move(observer));
-  pending_observers_.clear();
+  pending_host_status_observers_.clear();
+
+  for (auto& observer : pending_feature_state_observers_)
+    multidevice_setup_impl_->AddFeatureStateObserver(std::move(observer));
+  pending_feature_state_observers_.clear();
 
   if (pending_set_host_args_) {
     DCHECK(!pending_should_remove_host_device_);
@@ -194,6 +232,20 @@ void MultiDeviceSetupInitializer::InitializeImplementation() {
     multidevice_setup_impl_->RemoveHostDevice();
   pending_should_remove_host_device_ = false;
 
+  for (auto& set_feature_enabled_args : pending_set_feature_enabled_args_) {
+    multidevice_setup_impl_->SetFeatureEnabledState(
+        std::get<0>(set_feature_enabled_args),
+        std::get<1>(set_feature_enabled_args),
+        std::move(std::get<2>(set_feature_enabled_args)));
+  }
+  pending_set_feature_enabled_args_.clear();
+
+  for (auto& get_feature_states_callback : pending_get_feature_states_args_) {
+    multidevice_setup_impl_->GetFeatureStates(
+        std::move(get_feature_states_callback));
+  }
+  pending_get_feature_states_args_.clear();
+
   for (auto& retry_callback : pending_retry_set_host_args_)
     multidevice_setup_impl_->RetrySetHostNow(std::move(retry_callback));
   pending_retry_set_host_args_.clear();

chromeos/services/multidevice_setup/multidevice_setup_initializer.h

@@ -5,6 +5,8 @@
 #ifndef CHROMEOS_SERVICES_MULTIDEVICE_SETUP_MULTIDEVICE_SETUP_INITIALIZER_H_
 #define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_MULTIDEVICE_SETUP_INITIALIZER_H_
 
+#include <tuple>
+#include <utility>
 #include <vector>
 
 #include "chromeos/services/device_sync/public/cpp/device_sync_client.h"
@@ -55,11 +57,17 @@ class MultiDeviceSetupInitializer
   void SetAccountStatusChangeDelegate(
       mojom::AccountStatusChangeDelegatePtr delegate) override;
   void AddHostStatusObserver(mojom::HostStatusObserverPtr observer) override;
+  void AddFeatureStateObserver(
+      mojom::FeatureStateObserverPtr observer) override;
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void SetHostDevice(const std::string& host_device_id,
                      SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;
   void GetHostStatus(GetHostStatusCallback callback) override;
+  void SetFeatureEnabledState(mojom::Feature feature,
+                              bool enabled,
+                              SetFeatureEnabledStateCallback callback) override;
+  void GetFeatureStates(GetFeatureStatesCallback callback) override;
   void RetrySetHostNow(RetrySetHostNowCallback callback) override;
   void TriggerEventForDebugging(
       mojom::EventTypeForDebugging type,
@@ -80,9 +88,13 @@ class MultiDeviceSetupInitializer
   // parameters are cached here. Once asynchronous initialization is complete,
   // the parameters are passed to |multidevice_setup_impl_|.
   mojom::AccountStatusChangeDelegatePtr pending_delegate_;
-  std::vector<mojom::HostStatusObserverPtr> pending_observers_;
+  std::vector<mojom::HostStatusObserverPtr> pending_host_status_observers_;
+  std::vector<mojom::FeatureStateObserverPtr> pending_feature_state_observers_;
   std::vector<GetEligibleHostDevicesCallback> pending_get_eligible_hosts_args_;
   std::vector<GetHostStatusCallback> pending_get_host_args_;
+  std::vector<std::tuple<mojom::Feature, bool, SetFeatureEnabledStateCallback>>
+      pending_set_feature_enabled_args_;
+  std::vector<GetFeatureStatesCallback> pending_get_feature_states_args_;
   std::vector<RetrySetHostNowCallback> pending_retry_set_host_args_;
 
   // Special case: for SetHostDevice() and RemoveHostDevice(), only keep track

chromeos/services/multidevice_setup/multidevice_setup_service_unittest.cc

@@ -195,6 +195,16 @@ TEST_F(MultiDeviceSetupServiceTest, CallFunctionsBeforeInitialization) {
   multidevice_setup_ptr()->GetHostStatus(base::DoNothing());
   multidevice_setup_ptr().FlushForTesting();
 
+  // SetFeatureEnabledState().
+  multidevice_setup_ptr()->SetFeatureEnabledState(
+      mojom::Feature::kBetterTogetherSuite, true /* enabled */,
+      base::DoNothing());
+  multidevice_setup_ptr().FlushForTesting();
+
+  // GetFeatureStates().
+  multidevice_setup_ptr()->GetFeatureStates(base::DoNothing());
+  multidevice_setup_ptr().FlushForTesting();
+
   // RetrySetHostNow().
   multidevice_setup_ptr()->RetrySetHostNow(base::DoNothing());
   multidevice_setup_ptr().FlushForTesting();
@@ -206,9 +216,11 @@ TEST_F(MultiDeviceSetupServiceTest, CallFunctionsBeforeInitialization) {
   // Finish initialization; all of the pending calls should have been forwarded.
   FinishInitialization();
   EXPECT_TRUE(fake_multidevice_setup()->delegate());
-  EXPECT_EQ(1u, fake_multidevice_setup()->observers().size());
+  EXPECT_EQ(1u, fake_multidevice_setup()->host_status_observers().size());
   EXPECT_EQ(1u, fake_multidevice_setup()->get_eligible_hosts_args().size());
   EXPECT_EQ(1u, fake_multidevice_setup()->get_host_args().size());
+  EXPECT_EQ(1u, fake_multidevice_setup()->set_feature_enabled_args().size());
+  EXPECT_EQ(1u, fake_multidevice_setup()->get_feature_states_args().size());
   EXPECT_EQ(1u, fake_multidevice_setup()->retry_set_host_now_args().size());
 }
 
@@ -267,7 +279,7 @@ TEST_F(MultiDeviceSetupServiceTest, FinishInitializationFirst) {
   multidevice_setup_ptr()->AddHostStatusObserver(
       fake_host_status_observer->GenerateInterfacePtr());
   multidevice_setup_ptr().FlushForTesting();
-  EXPECT_EQ(1u, fake_multidevice_setup()->observers().size());
+  EXPECT_EQ(1u, fake_multidevice_setup()->host_status_observers().size());
 
   // GetEligibleHostDevices().
   multidevice_setup_ptr()->GetEligibleHostDevices(base::DoNothing());
@@ -289,6 +301,18 @@ TEST_F(MultiDeviceSetupServiceTest, FinishInitializationFirst) {
   multidevice_setup_ptr().FlushForTesting();
   EXPECT_EQ(1u, fake_multidevice_setup()->get_host_args().size());
 
+  // SetFeatureEnabledState().
+  multidevice_setup_ptr()->SetFeatureEnabledState(
+      mojom::Feature::kBetterTogetherSuite, true /* enabled */,
+      base::DoNothing());
+  multidevice_setup_ptr().FlushForTesting();
+  EXPECT_EQ(1u, fake_multidevice_setup()->set_feature_enabled_args().size());
+
+  // GetFeatureStates().
+  multidevice_setup_ptr()->GetFeatureStates(base::DoNothing());
+  multidevice_setup_ptr().FlushForTesting();
+  EXPECT_EQ(1u, fake_multidevice_setup()->get_feature_states_args().size());
+
   // RetrySetHostNow().
   multidevice_setup_ptr()->RetrySetHostNow(base::DoNothing());
   multidevice_setup_ptr().FlushForTesting();

chromeos/services/multidevice_setup/public/cpp/fake_multidevice_setup.cc

@@ -4,6 +4,7 @@
 
 #include "chromeos/services/multidevice_setup/public/cpp/fake_multidevice_setup.h"
 
+#include "base/containers/flat_map.h"
 #include "components/cryptauth/remote_device.h"
 
 namespace chromeos {
@@ -33,6 +34,18 @@ FakeMultiDeviceSetup::~FakeMultiDeviceSetup() {
     }
   }
 
+  for (auto& set_feature_enabled_args : set_feature_enabled_args_) {
+    if (std::get<2>(set_feature_enabled_args))
+      std::move(std::get<2>(set_feature_enabled_args)).Run(false /* success */);
+  }
+
+  for (auto& get_feature_states_arg : get_feature_states_args_) {
+    if (get_feature_states_arg) {
+      std::move(get_feature_states_arg)
+          .Run(base::flat_map<mojom::Feature, mojom::FeatureState>());
+    }
+  }
+
   for (auto& retry_set_host_now_arg : retry_set_host_now_args_) {
     if (retry_set_host_now_arg)
       std::move(retry_set_host_now_arg).Run(false /* success */);
@@ -56,7 +69,12 @@ void FakeMultiDeviceSetup::SetAccountStatusChangeDelegate(
 
 void FakeMultiDeviceSetup::AddHostStatusObserver(
     mojom::HostStatusObserverPtr observer) {
-  observers_.push_back(std::move(observer));
+  host_status_observers_.push_back(std::move(observer));
+}
+
+void FakeMultiDeviceSetup::AddFeatureStateObserver(
+    mojom::FeatureStateObserverPtr observer) {
+  feature_state_observers_.push_back(std::move(observer));
 }
 
 void FakeMultiDeviceSetup::GetEligibleHostDevices(
@@ -77,6 +95,17 @@ void FakeMultiDeviceSetup::GetHostStatus(GetHostStatusCallback callback) {
   get_host_args_.push_back(std::move(callback));
 }
 
+void FakeMultiDeviceSetup::SetFeatureEnabledState(
+    mojom::Feature feature,
+    bool enabled,
+    SetFeatureEnabledStateCallback callback) {
+  set_feature_enabled_args_.emplace_back(feature, enabled, std::move(callback));
+}
+
+void FakeMultiDeviceSetup::GetFeatureStates(GetFeatureStatesCallback callback) {
+  get_feature_states_args_.emplace_back(std::move(callback));
+}
+
 void FakeMultiDeviceSetup::RetrySetHostNow(RetrySetHostNowCallback callback) {
   retry_set_host_now_args_.push_back(std::move(callback));
 }

chromeos/services/multidevice_setup/public/cpp/fake_multidevice_setup.h

@@ -5,6 +5,7 @@
 #ifndef CHROMEOS_SERVICES_MULTIDEVICE_SETUP_PUBLIC_CPP_FAKE_MULTIDEVICE_SETUP_H_
 #define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_PUBLIC_CPP_FAKE_MULTIDEVICE_SETUP_H_
 
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -26,7 +27,13 @@ class FakeMultiDeviceSetup : public MultiDeviceSetupBase {
 
   mojom::AccountStatusChangeDelegatePtr& delegate() { return delegate_; }
 
-  std::vector<mojom::HostStatusObserverPtr>& observers() { return observers_; }
+  std::vector<mojom::HostStatusObserverPtr>& host_status_observers() {
+    return host_status_observers_;
+  }
+
+  std::vector<mojom::FeatureStateObserverPtr>& feature_state_observers() {
+    return feature_state_observers_;
+  }
 
   std::vector<GetEligibleHostDevicesCallback>& get_eligible_hosts_args() {
     return get_eligible_hosts_args_;
@@ -40,6 +47,15 @@ class FakeMultiDeviceSetup : public MultiDeviceSetupBase {
 
   std::vector<GetHostStatusCallback>& get_host_args() { return get_host_args_; }
 
+  std::vector<std::tuple<mojom::Feature, bool, SetFeatureEnabledStateCallback>>&
+  set_feature_enabled_args() {
+    return set_feature_enabled_args_;
+  }
+
+  std::vector<GetFeatureStatesCallback>& get_feature_states_args() {
+    return get_feature_states_args_;
+  }
+
   std::vector<RetrySetHostNowCallback>& retry_set_host_now_args() {
     return retry_set_host_now_args_;
   }
@@ -55,22 +71,32 @@ class FakeMultiDeviceSetup : public MultiDeviceSetupBase {
   void SetAccountStatusChangeDelegate(
       mojom::AccountStatusChangeDelegatePtr delegate) override;
   void AddHostStatusObserver(mojom::HostStatusObserverPtr observer) override;
+  void AddFeatureStateObserver(
+      mojom::FeatureStateObserverPtr observer) override;
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void SetHostDevice(const std::string& host_device_id,
                      SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;
   void GetHostStatus(GetHostStatusCallback callback) override;
+  void SetFeatureEnabledState(mojom::Feature feature,
+                              bool enabled,
+                              SetFeatureEnabledStateCallback callback) override;
+  void GetFeatureStates(GetFeatureStatesCallback callback) override;
   void RetrySetHostNow(RetrySetHostNowCallback callback) override;
   void TriggerEventForDebugging(
       mojom::EventTypeForDebugging type,
       TriggerEventForDebuggingCallback callback) override;
 
   mojom::AccountStatusChangeDelegatePtr delegate_;
-  std::vector<mojom::HostStatusObserverPtr> observers_;
+  std::vector<mojom::HostStatusObserverPtr> host_status_observers_;
+  std::vector<mojom::FeatureStateObserverPtr> feature_state_observers_;
   std::vector<GetEligibleHostDevicesCallback> get_eligible_hosts_args_;
   std::vector<std::pair<std::string, SetHostDeviceCallback>> set_host_args_;
   size_t num_remove_host_calls_ = 0u;
   std::vector<GetHostStatusCallback> get_host_args_;
+  std::vector<std::tuple<mojom::Feature, bool, SetFeatureEnabledStateCallback>>
+      set_feature_enabled_args_;
+  std::vector<GetFeatureStatesCallback> get_feature_states_args_;
   std::vector<RetrySetHostNowCallback> retry_set_host_now_args_;
   std::vector<
       std::pair<mojom::EventTypeForDebugging, TriggerEventForDebuggingCallback>>

chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom

@@ -103,6 +103,11 @@ interface HostStatusObserver {
                       chromeos.device_sync.mojom.RemoteDevice? host_device);
 };
 
+interface FeatureStateObserver {
+  // Invoked when one or more features have changed state.
+  OnFeatureStatesChanged(map<Feature, FeatureState> feature_states_map);
+};
+
 // Provides an API to the MultiDevice Setup flow. Designed to be exposed
 // primarily to the MultiDevice setup flow at chrome://multidevice-setup (normal
 // usage) as well as the ProximityAuth debug WebUI page at
@@ -117,6 +122,10 @@ interface MultiDeviceSetup {
   // HostStatusObserverPtr passed here.
   AddHostStatusObserver(HostStatusObserver observer);
 
+  // Adds an observer of feature state changes. To stop observing, disconnect
+  // the FeatureStateObserverPtr passed here.
+  AddFeatureStateObserver(FeatureStateObserver observer);
+
   // Provides a list of all eligible host devices (i.e., those which can be
   // passed to SetHostDevice()).
   GetEligibleHostDevices() =>
@@ -142,6 +151,14 @@ interface MultiDeviceSetup {
   GetHostStatus() => (HostStatus host_status,
                       chromeos.device_sync.mojom.RemoteDevice? host_device);
 
+  // Attempts to enable or disable |feature|. This function succeeds only if
+  // |feature|'s current state is FeatureState::kEnabledByUser or
+  // FeatureState::kDisabledByUser.
+  SetFeatureEnabledState(Feature feature, bool enabled) => (bool success);
+
+  // Provides the states of all Features.
+  GetFeatureStates() => (map<Feature, FeatureState> feature_states_map);
+
   // Retries the most recent SetHostDevice() call.
   //
   // If the current status is