[CrOS PhoneHub] Set PhoneHub to not supported for secondary users.

PhoneHub features will be set to FeatureState::kNotSupportedByChromebook
if the current logged in user is secondary.

Fixed: 1156309
Change-Id: Iea97c13c3fa2fe9edc103b00df8aa21b9447cef0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2590492
Commit-Queue: Regan Hsu <hsuregan@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#837729}

chrome/browser/chromeos/multidevice_setup/multidevice_setup_service_factory.cc

@@ -17,12 +17,14 @@
 #include "chrome/browser/chromeos/multidevice_setup/auth_token_validator_factory.h"
 #include "chrome/browser/chromeos/multidevice_setup/auth_token_validator_impl.h"
 #include "chrome/browser/chromeos/multidevice_setup/oobe_completion_tracker_factory.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chromeos/services/multidevice_setup/multidevice_setup_service.h"
 #include "chromeos/services/multidevice_setup/public/cpp/prefs.h"
 #include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/keyed_service/core/keyed_service.h"
+#include "components/user_manager/user_manager.h"
 
 namespace chromeos {
 namespace multidevice_setup {
@@ -34,6 +36,17 @@ class MultiDeviceSetupServiceHolder : public KeyedService {
  public:
   explicit MultiDeviceSetupServiceHolder(content::BrowserContext* context)
       : profile_(Profile::FromBrowserContext(context)) {
+    const user_manager::User* user =
+        ProfileHelper::Get()->GetUserByProfile(profile_);
+    const user_manager::User* primary_user =
+        user_manager::UserManager::Get()->GetPrimaryUser();
+
+    DCHECK(user);
+    DCHECK(primary_user);
+
+    bool is_secondary_user =
+        user->GetAccountId() != primary_user->GetAccountId();
+
     android_sms::AndroidSmsService* android_sms_service =
         chromeos::android_sms::AndroidSmsServiceFactory::GetForBrowserContext(
             context);
@@ -47,7 +60,7 @@ class MultiDeviceSetupServiceHolder : public KeyedService {
         android_sms_service
             ? android_sms_service->android_sms_pairing_state_tracker()
             : nullptr,
-        GcmDeviceInfoProviderImpl::GetInstance());
+        GcmDeviceInfoProviderImpl::GetInstance(), is_secondary_user);
   }
 
   MultiDeviceSetupService* multidevice_setup_service() {

chromeos/services/multidevice_setup/feature_state_manager_impl.cc

@@ -250,16 +250,19 @@ std::unique_ptr<FeatureStateManager> FeatureStateManagerImpl::Factory::Create(
     HostStatusProvider* host_status_provider,
     device_sync::DeviceSyncClient* device_sync_client,
     AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-    WifiSyncFeatureManager* wifi_sync_feature_manager) {
+    WifiSyncFeatureManager* wifi_sync_feature_manager,
+    bool is_secondary_user) {
   if (test_factory_) {
     return test_factory_->CreateInstance(
         pref_service, host_status_provider, device_sync_client,
-        android_sms_pairing_state_tracker, wifi_sync_feature_manager);
+        android_sms_pairing_state_tracker, wifi_sync_feature_manager,
+        is_secondary_user);
   }
 
   return base::WrapUnique(new FeatureStateManagerImpl(
       pref_service, host_status_provider, device_sync_client,
-      android_sms_pairing_state_tracker, wifi_sync_feature_manager));
+      android_sms_pairing_state_tracker, wifi_sync_feature_manager,
+      is_secondary_user));
 }
 
 // static
@@ -275,12 +278,14 @@ FeatureStateManagerImpl::FeatureStateManagerImpl(
     HostStatusProvider* host_status_provider,
     device_sync::DeviceSyncClient* device_sync_client,
     AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-    WifiSyncFeatureManager* wifi_sync_feature_manager)
+    WifiSyncFeatureManager* wifi_sync_feature_manager,
+    bool is_secondary_user)
     : pref_service_(pref_service),
       host_status_provider_(host_status_provider),
       device_sync_client_(device_sync_client),
       android_sms_pairing_state_tracker_(android_sms_pairing_state_tracker),
       wifi_sync_feature_manager_(wifi_sync_feature_manager),
+      is_secondary_user_(is_secondary_user),
       feature_to_enabled_pref_name_map_(GenerateFeatureToEnabledPrefNameMap()),
       feature_to_allowed_pref_name_map_(GenerateFeatureToAllowedPrefNameMap()),
       cached_feature_state_map_(GenerateInitialDefaultCachedStateMap()) {
@@ -452,6 +457,11 @@ bool FeatureStateManagerImpl::IsSupportedByChromebook(mojom::Feature feature) {
     if (pair.first != feature)
       continue;
 
+    if (pair.second == multidevice::SoftwareFeature::kPhoneHubClient &&
+        is_secondary_user_) {
+      return false;
+    }
+
     return device_sync_client_->GetLocalDeviceMetadata()
                ->GetSoftwareFeatureState(pair.second) !=
            multidevice::SoftwareFeatureState::kNotSupported;

chromeos/services/multidevice_setup/feature_state_manager_impl.h

@@ -38,7 +38,8 @@ class FeatureStateManagerImpl : public FeatureStateManager,
         HostStatusProvider* host_status_provider,
         device_sync::DeviceSyncClient* device_sync_client,
         AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-        WifiSyncFeatureManager* wifi_sync_feature_manager);
+        WifiSyncFeatureManager* wifi_sync_feature_manager,
+        bool is_secondary_user);
     static void SetFactoryForTesting(Factory* test_factory);
 
    protected:
@@ -48,7 +49,8 @@ class FeatureStateManagerImpl : public FeatureStateManager,
         HostStatusProvider* host_status_provider,
         device_sync::DeviceSyncClient* device_sync_client,
         AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-        WifiSyncFeatureManager* wifi_sync_feature_manager) = 0;
+        WifiSyncFeatureManager* wifi_sync_feature_manager,
+        bool is_secondary_user) = 0;
 
    private:
     static Factory* test_factory_;
@@ -62,7 +64,8 @@ class FeatureStateManagerImpl : public FeatureStateManager,
       HostStatusProvider* host_status_provider,
       device_sync::DeviceSyncClient* device_sync_client,
       AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-      WifiSyncFeatureManager* wifi_sync_feature_manager);
+      WifiSyncFeatureManager* wifi_sync_feature_manager,
+      bool is_secondary_user);
 
   // FeatureStateManager:
   FeatureStatesMap GetFeatureStates() override;
@@ -97,6 +100,10 @@ class FeatureStateManagerImpl : public FeatureStateManager,
   AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker_;
   WifiSyncFeatureManager* wifi_sync_feature_manager_;
 
+  // Certain features may be unavailable to secondary users logged into a
+  // Chromebook. Currently, such features include PhoneHub and its subfeatures.
+  const bool is_secondary_user_;
+
   // Map from feature to the pref name which indicates the enabled/disabled
   // boolean state for the feature.
   base::flat_map<mojom::Feature, std::string> feature_to_enabled_pref_name_map_;

chromeos/services/multidevice_setup/feature_state_manager_impl_unittest.cc

@@ -88,8 +88,7 @@ class MultiDeviceSetupFeatureStateManagerImplTest : public testing::Test {
         test_host_device_(CreateTestHostDevice()) {}
   ~MultiDeviceSetupFeatureStateManagerImplTest() override = default;
 
-  // testing::Test:
-  void SetUp() override {
+  void SetupFeatureStateManager(bool is_secondary_user = false) {
     test_pref_service_ =
         std::make_unique<sync_preferences::TestingPrefServiceSyncable>();
     user_prefs::PrefRegistrySyncable* registry = test_pref_service_->registry();
@@ -115,7 +114,7 @@ class MultiDeviceSetupFeatureStateManagerImplTest : public testing::Test {
         test_pref_service_.get(), fake_host_status_provider_.get(),
         fake_device_sync_client_.get(),
         fake_android_sms_pairing_state_tracker_.get(),
-        fake_wifi_sync_feature_manager_.get());
+        fake_wifi_sync_feature_manager_.get(), is_secondary_user);
 
     fake_observer_ = std::make_unique<FakeFeatureStateManagerObserver>();
     manager_->AddObserver(fake_observer_.get());
@@ -185,13 +184,16 @@ class MultiDeviceSetupFeatureStateManagerImplTest : public testing::Test {
               fake_observer_->feature_state_updates().size());
   }
 
-  void MakeBetterTogetherSuiteDisabledByUser() {
+  void MakeBetterTogetherSuiteDisabledByUser(
+      const mojom::FeatureState& expected_state_upon_disabling =
+          mojom::FeatureState::kDisabledByUser) {
     SetSoftwareFeatureState(true /* use_local_device */,
                             multidevice::SoftwareFeature::kBetterTogetherClient,
                             multidevice::SoftwareFeatureState::kSupported);
     test_pref_service_->SetBoolean(kBetterTogetherSuiteEnabledPrefName, false);
+
     EXPECT_EQ(
-        mojom::FeatureState::kDisabledByUser,
+        expected_state_upon_disabling,
         manager_->GetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
   }
 
@@ -255,6 +257,8 @@ class MultiDeviceSetupFeatureStateManagerImplTest : public testing::Test {
 };
 
 TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, BetterTogetherSuite) {
+  SetupFeatureStateManager();
+
   TryAllUnverifiedHostStatesAndVerifyFeatureState(
       mojom::Feature::kBetterTogetherSuite);
 
@@ -315,7 +319,72 @@ TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, BetterTogetherSuite) {
                            mojom::FeatureState::kProhibitedByPolicy);
 }
 
+TEST_F(MultiDeviceSetupFeatureStateManagerImplTest,
+       BetterTogetherSuiteForSecondaryUsers) {
+  SetupFeatureStateManager(/*is_secondary_user=*/true);
+
+  TryAllUnverifiedHostStatesAndVerifyFeatureState(
+      mojom::Feature::kBetterTogetherSuite);
+
+  SetVerifiedHost();
+  VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                     mojom::Feature::kBetterTogetherSuite);
+
+  // Add support for the suite; it should still remain unsupported, since there
+  // are no sub-features which are supported.
+  SetSoftwareFeatureState(true /* use_local_device */,
+                          multidevice::SoftwareFeature::kBetterTogetherClient,
+                          multidevice::SoftwareFeatureState::kSupported);
+  VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                     mojom::Feature::kBetterTogetherSuite);
+
+  // Add support for child features.
+  SetSoftwareFeatureState(true /* use_local_device */,
+                          multidevice::SoftwareFeature::kInstantTetheringClient,
+                          multidevice::SoftwareFeatureState::kSupported);
+  SetSoftwareFeatureState(true /* use_local_device */,
+                          multidevice::SoftwareFeature::kSmartLockClient,
+                          multidevice::SoftwareFeatureState::kSupported);
+  SetSoftwareFeatureState(true /* use_local_device */,
+                          multidevice::SoftwareFeature::kMessagesForWebClient,
+                          multidevice::SoftwareFeatureState::kSupported);
+  SetSoftwareFeatureState(true /* use_local_device */,
+                          multidevice::SoftwareFeature::kPhoneHubClient,
+                          multidevice::SoftwareFeatureState::kSupported);
+  SetSoftwareFeatureState(true /* use_local_device */,
+                          multidevice::SoftwareFeature::kWifiSyncClient,
+                          multidevice::SoftwareFeatureState::kSupported);
+
+  // Now, the suite should be considered enabled.
+  VerifyFeatureState(mojom::FeatureState::kEnabledByUser,
+                     mojom::Feature::kBetterTogetherSuite);
+  VerifyFeatureStateChange(4u /* expected_index */,
+                           mojom::Feature::kBetterTogetherSuite,
+                           mojom::FeatureState::kEnabledByUser);
+
+  test_pref_service()->SetBoolean(kBetterTogetherSuiteEnabledPrefName, false);
+  VerifyFeatureState(mojom::FeatureState::kDisabledByUser,
+                     mojom::Feature::kBetterTogetherSuite);
+  VerifyFeatureStateChange(5u /* expected_index */,
+                           mojom::Feature::kBetterTogetherSuite,
+                           mojom::FeatureState::kDisabledByUser);
+
+  // Set all features to prohibited. This should cause the Better Together suite
+  // to become prohibited as well.
+  test_pref_service()->SetBoolean(kInstantTetheringAllowedPrefName, false);
+  test_pref_service()->SetBoolean(kMessagesAllowedPrefName, false);
+  test_pref_service()->SetBoolean(kSmartLockAllowedPrefName, false);
+  test_pref_service()->SetBoolean(kPhoneHubAllowedPrefName, false);
+  test_pref_service()->SetBoolean(kWifiSyncAllowedPrefName, false);
+  VerifyFeatureState(mojom::FeatureState::kProhibitedByPolicy,
+                     mojom::Feature::kBetterTogetherSuite);
+  VerifyFeatureStateChange(10u /* expected_index */,
+                           mojom::Feature::kBetterTogetherSuite,
+                           mojom::FeatureState::kProhibitedByPolicy);
+}
+
 TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, InstantTethering) {
+  SetupFeatureStateManager();
   TryAllUnverifiedHostStatesAndVerifyFeatureState(
       mojom::Feature::kInstantTethering);
 
@@ -364,6 +433,8 @@ TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, InstantTethering) {
 }
 
 TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, Messages) {
+  SetupFeatureStateManager();
+
   TryAllUnverifiedHostStatesAndVerifyFeatureState(mojom::Feature::kMessages);
 
   SetVerifiedHost();
@@ -423,6 +494,8 @@ TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, Messages) {
 }
 
 TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, SmartLock) {
+  SetupFeatureStateManager();
+
   TryAllUnverifiedHostStatesAndVerifyFeatureState(mojom::Feature::kSmartLock);
 
   SetVerifiedHost();
@@ -465,7 +538,80 @@ TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, SmartLock) {
                            mojom::FeatureState::kProhibitedByPolicy);
 }
 
+TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, PhoneHubForSecondaryUsers) {
+  SetupFeatureStateManager(/*is_secondary_user=*/true);
+
+  const std::vector<mojom::Feature> kAllPhoneHubFeatures{
+      mojom::Feature::kPhoneHub, mojom::Feature::kPhoneHubNotifications,
+      mojom::Feature::kPhoneHubTaskContinuation};
+
+  for (const auto& phone_hub_feature : kAllPhoneHubFeatures)
+    TryAllUnverifiedHostStatesAndVerifyFeatureState(phone_hub_feature);
+
+  SetVerifiedHost();
+  for (const auto& phone_hub_feature : kAllPhoneHubFeatures) {
+    VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                       phone_hub_feature);
+  }
+
+  SetSoftwareFeatureState(true /* use_local_device */,
+                          multidevice::SoftwareFeature::kPhoneHubClient,
+                          multidevice::SoftwareFeatureState::kSupported);
+  for (const auto& phone_hub_feature : kAllPhoneHubFeatures) {
+    VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                       phone_hub_feature);
+  }
+
+  // This pref should is disabled for existing Better Together users;
+  // they must go to settings to explicitly enable PhoneHub.
+  test_pref_service()->SetBoolean(kPhoneHubEnabledPrefName, true);
+  SetSoftwareFeatureState(false /* use_local_device */,
+                          multidevice::SoftwareFeature::kPhoneHubHost,
+                          multidevice::SoftwareFeatureState::kEnabled);
+  for (const auto& phone_hub_feature : kAllPhoneHubFeatures) {
+    VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                       phone_hub_feature);
+  }
+
+  MakeBetterTogetherSuiteDisabledByUser(
+      /*expected_state_upon_disabling=*/mojom::FeatureState::
+          kNotSupportedByChromebook);
+  for (const auto& phone_hub_feature : kAllPhoneHubFeatures) {
+    VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                       phone_hub_feature);
+  }
+
+  test_pref_service()->SetBoolean(kPhoneHubNotificationsEnabledPrefName, false);
+  VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                     mojom::Feature::kPhoneHubNotifications);
+
+  test_pref_service()->SetBoolean(kPhoneHubNotificationsEnabledPrefName, true);
+  test_pref_service()->SetBoolean(kPhoneHubEnabledPrefName, false);
+  for (const auto& phone_hub_feature : kAllPhoneHubFeatures) {
+    VerifyFeatureState(mojom::FeatureState::kNotSupportedByChromebook,
+                       phone_hub_feature);
+  }
+
+  test_pref_service()->SetBoolean(kPhoneHubNotificationsAllowedPrefName, false);
+  VerifyFeatureState(mojom::FeatureState::kProhibitedByPolicy,
+                     mojom::Feature::kPhoneHubNotifications);
+  VerifyFeatureStateChange(1u /* expected_index */,
+                           mojom::Feature::kPhoneHubNotifications,
+                           mojom::FeatureState::kProhibitedByPolicy);
+
+  // Prohibiting Phone Hub implicitly prohibits all of its sub-features.
+  test_pref_service()->SetBoolean(kPhoneHubAllowedPrefName, false);
+  for (const auto& phone_hub_feature : kAllPhoneHubFeatures) {
+    VerifyFeatureState(mojom::FeatureState::kProhibitedByPolicy,
+                       phone_hub_feature);
+  }
+  VerifyFeatureStateChange(2u /* expected_index */, mojom::Feature::kPhoneHub,
+                           mojom::FeatureState::kProhibitedByPolicy);
+}
+
 TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, PhoneHub) {
+  SetupFeatureStateManager();
+
   const std::vector<mojom::Feature> kAllPhoneHubFeatures{
       mojom::Feature::kPhoneHub, mojom::Feature::kPhoneHubNotifications,
       mojom::Feature::kPhoneHubTaskContinuation};
@@ -547,6 +693,8 @@ TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, PhoneHub) {
 }
 
 TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, WifiSync) {
+  SetupFeatureStateManager();
+
   TryAllUnverifiedHostStatesAndVerifyFeatureState(mojom::Feature::kWifiSync);
 
   SetVerifiedHost();

chromeos/services/multidevice_setup/multidevice_setup_impl.cc

@@ -67,18 +67,21 @@ std::unique_ptr<MultiDeviceSetupBase> MultiDeviceSetupImpl::Factory::Create(
     OobeCompletionTracker* oobe_completion_tracker,
     AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
     AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider) {
+    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+    bool is_secondary_user) {
   if (test_factory_) {
     return test_factory_->CreateInstance(
         pref_service, device_sync_client, auth_token_validator,
         oobe_completion_tracker, android_sms_app_helper_delegate,
-        android_sms_pairing_state_tracker, gcm_device_info_provider);
+        android_sms_pairing_state_tracker, gcm_device_info_provider,
+        is_secondary_user);
   }
 
   return base::WrapUnique(new MultiDeviceSetupImpl(
       pref_service, device_sync_client, auth_token_validator,
       oobe_completion_tracker, android_sms_app_helper_delegate,
-      android_sms_pairing_state_tracker, gcm_device_info_provider));
+      android_sms_pairing_state_tracker, gcm_device_info_provider,
+      is_secondary_user));
 }
 
 // static
@@ -96,7 +99,8 @@ MultiDeviceSetupImpl::MultiDeviceSetupImpl(
     OobeCompletionTracker* oobe_completion_tracker,
     AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
     AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider)
+    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+    bool is_secondary_user)
     : eligible_host_devices_provider_(
           EligibleHostDevicesProviderImpl::Factory::Create(device_sync_client)),
       host_backend_delegate_(HostBackendDelegateImpl::Factory::Create(
@@ -126,7 +130,8 @@ MultiDeviceSetupImpl::MultiDeviceSetupImpl(
           host_status_provider_.get(),
           device_sync_client,
           android_sms_pairing_state_tracker,
-          wifi_sync_feature_manager_.get())),
+          wifi_sync_feature_manager_.get(),
+          is_secondary_user)),
       host_device_timestamp_manager_(
           HostDeviceTimestampManagerImpl::Factory::Create(
               host_status_provider_.get(),

chromeos/services/multidevice_setup/multidevice_setup_impl.h

@@ -58,7 +58,8 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase,
         OobeCompletionTracker* oobe_completion_tracker,
         AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
         AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider);
+        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+        bool is_secondary_user);
     static void SetFactoryForTesting(Factory* test_factory);
 
    protected:
@@ -70,7 +71,8 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase,
         OobeCompletionTracker* oobe_completion_tracker,
         AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
         AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider) = 0;
+        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+        bool is_secondary_user) = 0;
 
    private:
     static Factory* test_factory_;
@@ -88,7 +90,8 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase,
       OobeCompletionTracker* oobe_completion_tracker,
       AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
       AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider);
+      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+      bool is_secondary_user);
 
   // mojom::MultiDeviceSetup:
   void SetAccountStatusChangeDelegate(

chromeos/services/multidevice_setup/multidevice_setup_impl_unittest.cc

@@ -329,12 +329,14 @@ class FakeFeatureStateManagerFactory : public FeatureStateManagerImpl::Factory {
       FakeHostStatusProviderFactory* fake_host_status_provider_factory,
       device_sync::FakeDeviceSyncClient* expected_device_sync_client,
       FakeAndroidSmsPairingStateTracker*
-          expected_android_sms_pairing_state_tracker)
+          expected_android_sms_pairing_state_tracker,
+      bool expected_is_secondary_user)
       : 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),
         expected_android_sms_pairing_state_tracker_(
-            expected_android_sms_pairing_state_tracker) {}
+            expected_android_sms_pairing_state_tracker),
+        expected_is_secondary_user_(expected_is_secondary_user) {}
 
   ~FakeFeatureStateManagerFactory() override = default;
 
@@ -347,7 +349,8 @@ class FakeFeatureStateManagerFactory : public FeatureStateManagerImpl::Factory {
       HostStatusProvider* host_status_provider,
       device_sync::DeviceSyncClient* device_sync_client,
       AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-      WifiSyncFeatureManager* wifi_sync_feature_manager) override {
+      WifiSyncFeatureManager* wifi_sync_feature_manager,
+      bool is_secondary_user) override {
     EXPECT_FALSE(instance_);
     EXPECT_EQ(expected_testing_pref_service_, pref_service);
     EXPECT_EQ(fake_host_status_provider_factory_->instance(),
@@ -355,6 +358,7 @@ class FakeFeatureStateManagerFactory : public FeatureStateManagerImpl::Factory {
     EXPECT_EQ(expected_device_sync_client_, device_sync_client);
     EXPECT_EQ(expected_android_sms_pairing_state_tracker_,
               android_sms_pairing_state_tracker);
+    EXPECT_EQ(expected_is_secondary_user_, is_secondary_user);
 
     auto instance = std::make_unique<FakeFeatureStateManager>();
     instance_ = instance.get();
@@ -366,6 +370,7 @@ class FakeFeatureStateManagerFactory : public FeatureStateManagerImpl::Factory {
   device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
   FakeAndroidSmsPairingStateTracker*
       expected_android_sms_pairing_state_tracker_;
+  bool expected_is_secondary_user_;
 
   FakeFeatureStateManager* instance_ = nullptr;
 
@@ -607,7 +612,7 @@ class MultiDeviceSetupImplTest : public ::testing::TestWithParam<bool> {
         std::make_unique<FakeFeatureStateManagerFactory>(
             test_pref_service_.get(), fake_host_status_provider_factory_.get(),
             fake_device_sync_client_.get(),
-            fake_android_sms_pairing_state_tracker_.get());
+            fake_android_sms_pairing_state_tracker_.get(), is_secondary_user_);
     FeatureStateManagerImpl::Factory::SetFactoryForTesting(
         fake_feature_state_manager_factory_.get());
 
@@ -645,7 +650,7 @@ class MultiDeviceSetupImplTest : public ::testing::TestWithParam<bool> {
         fake_auth_token_validator_.get(), fake_oobe_completion_tracker_.get(),
         fake_android_sms_app_helper_delegate_.get(),
         fake_android_sms_pairing_state_tracker_.get(),
-        fake_gcm_device_info_provider_.get());
+        fake_gcm_device_info_provider_.get(), is_secondary_user_);
   }
 
   void TearDown() override {
@@ -974,6 +979,7 @@ class MultiDeviceSetupImplTest : public ::testing::TestWithParam<bool> {
   std::unique_ptr<OobeCompletionTracker> fake_oobe_completion_tracker_;
   std::unique_ptr<device_sync::FakeGcmDeviceInfoProvider>
       fake_gcm_device_info_provider_;
+  bool is_secondary_user_ = false;
 
   std::unique_ptr<FakeEligibleHostDevicesProviderFactory>
       fake_eligible_host_devices_provider_factory_;

chromeos/services/multidevice_setup/multidevice_setup_initializer.cc

@@ -30,18 +30,21 @@ MultiDeviceSetupInitializer::Factory::Create(
     OobeCompletionTracker* oobe_completion_tracker,
     AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
     AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider) {
+    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+    bool is_secondary_user) {
   if (test_factory_) {
     return test_factory_->CreateInstance(
         pref_service, device_sync_client, auth_token_validator,
         oobe_completion_tracker, android_sms_app_helper_delegate,
-        android_sms_pairing_state_tracker, gcm_device_info_provider);
+        android_sms_pairing_state_tracker, gcm_device_info_provider,
+        is_secondary_user);
   }
 
   return base::WrapUnique(new MultiDeviceSetupInitializer(
       pref_service, device_sync_client, auth_token_validator,
       oobe_completion_tracker, android_sms_app_helper_delegate,
-      android_sms_pairing_state_tracker, gcm_device_info_provider));
+      android_sms_pairing_state_tracker, gcm_device_info_provider,
+      is_secondary_user));
 }
 
 // static
@@ -77,14 +80,16 @@ MultiDeviceSetupInitializer::MultiDeviceSetupInitializer(
     OobeCompletionTracker* oobe_completion_tracker,
     AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
     AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider)
+    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+    bool is_secondary_user)
     : pref_service_(pref_service),
       device_sync_client_(device_sync_client),
       auth_token_validator_(auth_token_validator),
       oobe_completion_tracker_(oobe_completion_tracker),
       android_sms_app_helper_delegate_(android_sms_app_helper_delegate),
       android_sms_pairing_state_tracker_(android_sms_pairing_state_tracker),
-      gcm_device_info_provider_(gcm_device_info_provider) {
+      gcm_device_info_provider_(gcm_device_info_provider),
+      is_secondary_user_(is_secondary_user) {
   // If |device_sync_client_| is null, this interface cannot perform its tasks.
   if (!device_sync_client_)
     return;
@@ -280,7 +285,8 @@ void MultiDeviceSetupInitializer::InitializeImplementation() {
   multidevice_setup_impl_ = MultiDeviceSetupImpl::Factory::Create(
       pref_service_, device_sync_client_, auth_token_validator_,
       oobe_completion_tracker_, android_sms_app_helper_delegate_,
-      android_sms_pairing_state_tracker_, gcm_device_info_provider_);
+      android_sms_pairing_state_tracker_, gcm_device_info_provider_,
+      is_secondary_user_);
 
   if (pending_delegate_) {
     multidevice_setup_impl_->SetAccountStatusChangeDelegate(

chromeos/services/multidevice_setup/multidevice_setup_initializer.h

@@ -45,7 +45,8 @@ class MultiDeviceSetupInitializer
         OobeCompletionTracker* oobe_completion_tracker,
         AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
         AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider);
+        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+        bool is_secondary_user);
     static void SetFactoryForTesting(Factory* test_factory);
 
    protected:
@@ -57,7 +58,8 @@ class MultiDeviceSetupInitializer
         OobeCompletionTracker* oobe_completion_tracker,
         AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
         AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider) = 0;
+        const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+        bool is_secondary_user) = 0;
 
    private:
     static Factory* test_factory_;
@@ -93,7 +95,8 @@ class MultiDeviceSetupInitializer
       OobeCompletionTracker* oobe_completion_tracker,
       AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
       AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider);
+      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+      bool is_secondary_user);
 
   // mojom::MultiDeviceSetup:
   void SetAccountStatusChangeDelegate(
@@ -139,6 +142,7 @@ class MultiDeviceSetupInitializer
   AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate_;
   AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker_;
   const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider_;
+  bool is_secondary_user_;
 
   std::unique_ptr<MultiDeviceSetupBase> multidevice_setup_impl_;
 

chromeos/services/multidevice_setup/multidevice_setup_service.cc

@@ -45,7 +45,8 @@ MultiDeviceSetupService::MultiDeviceSetupService(
     OobeCompletionTracker* oobe_completion_tracker,
     AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
     AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider)
+    const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+    bool is_secondary_user)
     : multidevice_setup_(MultiDeviceSetupInitializer::Factory::Create(
           pref_service,
           device_sync_client,
@@ -53,7 +54,8 @@ MultiDeviceSetupService::MultiDeviceSetupService(
           oobe_completion_tracker,
           android_sms_app_helper_delegate,
           android_sms_pairing_state_tracker,
-          gcm_device_info_provider)),
+          gcm_device_info_provider,
+          is_secondary_user)),
       privileged_host_device_setter_(
           PrivilegedHostDeviceSetterImpl::Factory::Create(
               multidevice_setup_.get())) {}

chromeos/services/multidevice_setup/multidevice_setup_service.h

@@ -40,7 +40,8 @@ class MultiDeviceSetupService {
       OobeCompletionTracker* oobe_completion_tracker,
       AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
       AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider);
+      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+      bool is_secondary_user);
   ~MultiDeviceSetupService();
 
   static void RegisterProfilePrefs(PrefRegistrySimple* registry);

chromeos/services/multidevice_setup/multidevice_setup_service_unittest.cc

@@ -46,7 +46,8 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
       FakeAndroidSmsPairingStateTracker*
           expected_android_sms_pairing_state_tracker,
       const device_sync::FakeGcmDeviceInfoProvider*
-          expected_gcm_device_info_provider)
+          expected_gcm_device_info_provider,
+      bool expected_is_secondary_user)
       : expected_testing_pref_service_(expected_testing_pref_service),
         expected_device_sync_client_(expected_device_sync_client),
         expected_auth_token_validator_(expected_auth_token_validator),
@@ -55,7 +56,8 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
             expected_android_sms_app_helper_delegate),
         expected_android_sms_pairing_state_tracker_(
             expected_android_sms_pairing_state_tracker),
-        expected_gcm_device_info_provider_(expected_gcm_device_info_provider) {}
+        expected_gcm_device_info_provider_(expected_gcm_device_info_provider),
+        expected_is_secondary_user_(expected_is_secondary_user) {}
 
   ~FakeMultiDeviceSetupFactory() override = default;
 
@@ -69,8 +71,8 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
       OobeCompletionTracker* oobe_completion_tracker,
       AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
       AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider)
-      override {
+      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+      bool is_secondary_user) override {
     EXPECT_FALSE(instance_);
     EXPECT_EQ(expected_testing_pref_service_, pref_service);
     EXPECT_EQ(expected_device_sync_client_, device_sync_client);
@@ -81,6 +83,7 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
     EXPECT_EQ(expected_android_sms_pairing_state_tracker_,
               android_sms_pairing_state_tracker);
     EXPECT_EQ(expected_gcm_device_info_provider_, gcm_device_info_provider);
+    EXPECT_EQ(expected_is_secondary_user_, is_secondary_user);
 
     auto instance = std::make_unique<FakeMultiDeviceSetup>();
     instance_ = instance.get();
@@ -96,6 +99,7 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
       expected_android_sms_pairing_state_tracker_;
   const device_sync::FakeGcmDeviceInfoProvider*
       expected_gcm_device_info_provider_;
+  bool expected_is_secondary_user_;
 
   FakeMultiDeviceSetup* instance_ = nullptr;
 
@@ -134,7 +138,7 @@ class MultiDeviceSetupServiceTest : public testing::Test {
             fake_oobe_completion_tracker_.get(),
             fake_android_sms_app_helper_delegate_.get(),
             fake_android_sms_pairing_state_tracker_.get(),
-            fake_gcm_device_info_provider_.get());
+            fake_gcm_device_info_provider_.get(), is_secondary_user_);
     MultiDeviceSetupImpl::Factory::SetFactoryForTesting(
         fake_multidevice_setup_factory_.get());
 
@@ -143,7 +147,7 @@ class MultiDeviceSetupServiceTest : public testing::Test {
         fake_auth_token_validator_.get(), fake_oobe_completion_tracker_.get(),
         fake_android_sms_app_helper_delegate_.get(),
         fake_android_sms_pairing_state_tracker_.get(),
-        fake_gcm_device_info_provider_.get());
+        fake_gcm_device_info_provider_.get(), is_secondary_user_);
 
     service_->BindMultiDeviceSetup(
         multidevice_setup_remote_.BindNewPipeAndPassReceiver());
@@ -211,6 +215,7 @@ class MultiDeviceSetupServiceTest : public testing::Test {
       fake_android_sms_pairing_state_tracker_;
   std::unique_ptr<device_sync::FakeGcmDeviceInfoProvider>
       fake_gcm_device_info_provider_;
+  bool is_secondary_user_ = false;
 
   std::unique_ptr<FakeMultiDeviceSetupFactory> fake_multidevice_setup_factory_;
 

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

@@ -48,8 +48,8 @@ class FakeMultiDeviceSetupInitializerFactory
       OobeCompletionTracker* oobe_completion_tracker,
       AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate,
       AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
-      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider)
-      override {
+      const device_sync::GcmDeviceInfoProvider* gcm_device_info_provider,
+      bool is_secondary_user) override {
     EXPECT_TRUE(fake_multidevice_setup_);
     return std::move(fake_multidevice_setup_);
   }
@@ -127,7 +127,7 @@ class MultiDeviceSetupClientImplTest : public testing::Test {
         nullptr /* oobe_completion_tracker */,
         nullptr /* android_sms_app_helper_delegate */,
         nullptr /* android_sms_pairing_state_tracker */,
-        nullptr /* gcm_device_info_provider */);
+        nullptr /* gcm_device_info_provider */, false /* is_secondary_user */);
   }
 
   void InitializeClient(