Enable Wifi Sync after Multidevice Setup

Wifi Sync is enabled from a Chrome OS device if the multidevice setup
is complete and the Wifi Sync flag is enabled on the Chrome OS device.

This CL adds a pending state kEnableOnVerify that gets set when
the Multidevice setup is complete on a Chrome OS device with the
Wifi Sync flag enabled. The kEnableOnVerify state listens for the
host to become verified and enables Wifi Sync if it is not already
enabled.

The kEnableOnVerify state gets cleared if the host device is removed.

Bug: 1117619
Change-Id: I34070149b963629aa0ff0dc2da8c3022c2fcef5c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2457047
Commit-Queue: Claude van der Merwe <cvandermerwe@google.com>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Jon Mann <jonmann@chromium.org>
Cr-Commit-Position: refs/heads/master@{#816209}

chromeos/services/multidevice_setup/wifi_sync_feature_manager_impl.cc

@@ -84,17 +84,36 @@ WifiSyncFeatureManagerImpl::WifiSyncFeatureManagerImpl(
   if (GetCurrentState() == CurrentState::kValidPendingRequest) {
     AttemptSetWifiSyncHostStateNetworkRequest(false /* is_retry */);
   }
+
+  if (ShouldEnableOnVerify()) {
+    ProcessEnableOnVerifyAttempt();
+  }
 }
 
 void WifiSyncFeatureManagerImpl::OnHostStatusChange(
     const HostStatusProvider::HostStatusWithDevice& host_status_with_device) {
-  if (GetCurrentState() == CurrentState::kNoVerifiedHost) {
+  if (GetCurrentState() == CurrentState::kNoVerifiedHost &&
+      !ShouldEnableOnVerify()) {
     ResetPendingWifiSyncHostNetworkRequest();
   }
+  // kHostSetLocallyButWaitingForBackendConfirmation is only possible if the
+  // setup flow has been completed on the local device.
+  if (host_status_with_device.host_status() ==
+          mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation &&
+      features::IsWifiSyncAndroidEnabled()) {
+    SetPendingWifiSyncHostNetworkRequest(
+        PendingState::kSetPendingEnableOnVerify);
+    return;
+  }
+
+  if (ShouldEnableOnVerify()) {
+    ProcessEnableOnVerifyAttempt();
+  }
 }
 
 void WifiSyncFeatureManagerImpl::OnNewDevicesSynced() {
-  if (GetCurrentState() != CurrentState::kValidPendingRequest) {
+  if (GetCurrentState() != CurrentState::kValidPendingRequest &&
+      !ShouldEnableOnVerify()) {
     ResetPendingWifiSyncHostNetworkRequest();
   }
 }
@@ -151,7 +170,13 @@ WifiSyncFeatureManagerImpl::GetCurrentState() {
     return CurrentState::kNoVerifiedHost;
   }
 
-  if (GetPendingState() == PendingState::kPendingNone) {
+  PendingState pending_state = GetPendingState();
+
+  // If the pending request is kSetPendingEnableOnVerify then there is no
+  // actionable pending equest. The pending request will be changed from
+  // kSetPendingEnableOnVerify when the host has been verified.
+  if (pending_state == PendingState::kPendingNone ||
+      pending_state == PendingState::kSetPendingEnableOnVerify) {
     return CurrentState::kNoPendingRequest;
   }
 
@@ -161,7 +186,7 @@ WifiSyncFeatureManagerImpl::GetCurrentState() {
            ->GetSoftwareFeatureState(
                multidevice::SoftwareFeature::kWifiSyncHost) ==
        multidevice::SoftwareFeatureState::kEnabled);
-  bool pending_enabled = (GetPendingState() == PendingState::kPendingEnable);
+  bool pending_enabled = (pending_state == PendingState::kPendingEnable);
 
   if (pending_enabled == enabled_on_host) {
     return CurrentState::kPendingMatchesBackend;
@@ -265,6 +290,33 @@ void WifiSyncFeatureManagerImpl::OnSetWifiSyncHostStateNetworkRequestFinished(
   }
 }
 
+bool WifiSyncFeatureManagerImpl::ShouldEnableOnVerify() {
+  return (GetPendingState() == PendingState::kSetPendingEnableOnVerify);
+}
+
+void WifiSyncFeatureManagerImpl::ProcessEnableOnVerifyAttempt() {
+  mojom::HostStatus host_status =
+      host_status_provider_->GetHostWithStatus().host_status();
+
+  // If host is not set.
+  if (host_status == mojom::HostStatus::kNoEligibleHosts ||
+      host_status == mojom::HostStatus::kEligibleHostExistsButNoHostSet) {
+    ResetPendingWifiSyncHostNetworkRequest();
+    return;
+  }
+
+  if (host_status != mojom::HostStatus::kHostVerified) {
+    return;
+  }
+
+  if (IsWifiSyncEnabled()) {
+    ResetPendingWifiSyncHostNetworkRequest();
+    return;
+  }
+
+  SetIsWifiSyncEnabled(true);
+}
+
 }  // namespace multidevice_setup
 
 }  // namespace chromeos

chromeos/services/multidevice_setup/wifi_sync_feature_manager_impl.h

@@ -102,7 +102,8 @@ class WifiSyncFeatureManagerImpl
   enum class PendingState {
     kPendingNone = 0,
     kPendingEnable = 1,
-    kPendingDisable = 2
+    kPendingDisable = 2,
+    kSetPendingEnableOnVerify = 3
   };
 
   enum class CurrentState {
@@ -120,6 +121,8 @@ class WifiSyncFeatureManagerImpl
   void OnSetWifiSyncHostStateNetworkRequestFinished(
       bool attempted_to_enable,
       device_sync::mojom::NetworkRequestResult result_code);
+  bool ShouldEnableOnVerify();
+  void ProcessEnableOnVerifyAttempt();
 
   HostStatusProvider* host_status_provider_;
   PrefService* pref_service_;

chromeos/services/multidevice_setup/wifi_sync_feature_manager_impl_unittest.cc

@@ -31,7 +31,12 @@ namespace {
 const char kPendingWifiSyncRequestEnabledPrefName[] =
     "multidevice_setup.pending_set_wifi_sync_enabled_request";
 
-enum PendingState { PendingNone = 0, PendingEnable = 1, PendingDisable = 2 };
+enum PendingState {
+  kPendingNone = 0,
+  kPendingEnable = 1,
+  kPendingDisable = 2,
+  kSetPendingEnableOnVerify = 3
+};
 
 const size_t kNumTestDevices = 4;
 
@@ -47,8 +52,6 @@ class MultiDeviceSetupWifiSyncFeatureManagerImplTest
 
   // testing::Test:
   void SetUp() override {
-    SetFeatureFlags(GetParam() /* use_v1_devicesync */);
-
     // Tests are run once to simulate when v1 DeviceSync is enabled and once to
     // simulate when it is disabled, leaving only v2 DeviceSync operational. In
     // the former case, only public keys are needed, and in the latter case,
@@ -104,7 +107,7 @@ class MultiDeviceSetupWifiSyncFeatureManagerImplTest
 
   void CreateDelegate(
       const base::Optional<multidevice::RemoteDeviceRef>& initial_host,
-      int initial_pending_wifi_sync_request = PendingNone) {
+      int initial_pending_wifi_sync_request = kPendingNone) {
     SetHostInDeviceSyncClient(initial_host);
     test_pref_service_->SetInteger(kPendingWifiSyncRequestEnabledPrefName,
                                    initial_pending_wifi_sync_request);
@@ -216,6 +219,33 @@ class MultiDeviceSetupWifiSyncFeatureManagerImplTest
     fake_device_sync_client_->NotifyNewDevicesSynced();
   }
 
+  void SetFeatureFlags(bool use_v1_devicesync, bool enable_wifi_sync) {
+    std::vector<base::Feature> enabled_features;
+    std::vector<base::Feature> disabled_features;
+
+    // These flags have no direct effect of on the wifi sync feature manager;
+    // however, v2 Enrollment and DeviceSync must be enabled before v1
+    // DeviceSync can be disabled.
+    enabled_features.push_back(chromeos::features::kCryptAuthV2Enrollment);
+    enabled_features.push_back(chromeos::features::kCryptAuthV2DeviceSync);
+
+    if (use_v1_devicesync) {
+      disabled_features.push_back(
+          chromeos::features::kDisableCryptAuthV1DeviceSync);
+    } else {
+      enabled_features.push_back(
+          chromeos::features::kDisableCryptAuthV1DeviceSync);
+    }
+
+    if (enable_wifi_sync) {
+      enabled_features.push_back(chromeos::features::kWifiSyncAndroid);
+    } else {
+      disabled_features.push_back(chromeos::features::kWifiSyncAndroid);
+    }
+
+    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);
+  }
+
   FakeHostStatusProvider* fake_host_status_provider() {
     return fake_host_status_provider_.get();
   }
@@ -235,29 +265,7 @@ class MultiDeviceSetupWifiSyncFeatureManagerImplTest
   const multidevice::RemoteDeviceRefList& test_devices() const {
     return test_devices_;
   }
-
  private:
-  void SetFeatureFlags(bool use_v1_devicesync) {
-    std::vector<base::Feature> enabled_features;
-    std::vector<base::Feature> disabled_features;
-
-    // These flags have no direct effect of on the host backend delegate;
-    // however, v2 Enrollment and DeviceSync must be enabled before v1
-    // DeviceSync can be disabled.
-    enabled_features.push_back(chromeos::features::kCryptAuthV2Enrollment);
-    enabled_features.push_back(chromeos::features::kCryptAuthV2DeviceSync);
-
-    if (use_v1_devicesync) {
-      disabled_features.push_back(
-          chromeos::features::kDisableCryptAuthV1DeviceSync);
-    } else {
-      enabled_features.push_back(
-          chromeos::features::kDisableCryptAuthV1DeviceSync);
-    }
-
-    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);
-  }
-
   multidevice::RemoteDeviceRefList test_devices_;
 
   std::unique_ptr<FakeHostStatusProvider> fake_host_status_provider_;
@@ -274,6 +282,8 @@ class MultiDeviceSetupWifiSyncFeatureManagerImplTest
 };
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest, Success) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   // Attempt to enable wifi sync on host device and succeed
@@ -318,6 +328,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest, Success) {
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        NewDevicesSyncedBeforeCallback) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   // Attempt to enable wifi sync on host device and succeed
@@ -346,6 +358,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 }
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest, Failure) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   // Attempt to enable wifi sync on host device and fail
@@ -390,6 +404,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest, Failure) {
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        MultipleRequests_FirstFail_ThenSucceed) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   // Attempt to enable wifi sync on host device and fail
@@ -434,6 +450,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        PendingRequest_NoSyncedHostDevice) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   // Attempt to enable wifi sync on test_device 0
@@ -463,8 +481,10 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        InitialPendingEnableRequest_NoInitialDevice) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(base::nullopt /* initial_host */,
-                 PendingEnable /* initial_pending_wifi_sync_request_enabled */);
+                 kPendingEnable /* initial_pending_wifi_sync_request*/);
 
   EXPECT_EQ(0, GetSetHostNetworkRequestCallbackQueueSize());
   EXPECT_EQ(test_devices()[0].GetSoftwareFeatureState(
@@ -474,8 +494,10 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        InitialPendingEnableRequest_Success) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */,
-                 PendingEnable /* initial_pending_wifi_sync_request_enabled */);
+                 kPendingEnable /* initial_pending_wifi_sync_request*/);
 
   EXPECT_EQ(1, GetSetHostNetworkRequestCallbackQueueSize());
   EXPECT_TRUE(delegate()->IsWifiSyncEnabled());
@@ -495,6 +517,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        MultiplePendingRequests_EnableDisable) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   // Attempt to enable->disable->enable wifi sync without invoking any
@@ -523,19 +547,23 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        PendingRequest_SyncedHostBecomesUnverified) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */,
-                 PendingEnable /* initial_pending_wifi_sync_request_enabled */);
+                 kPendingEnable /* initial_pending_wifi_sync_request */);
 
   fake_host_status_provider()->SetHostWithStatus(
       mojom::HostStatus::kHostSetButNotYetVerified, test_devices()[0]);
 
   EXPECT_EQ(
       test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
-      PendingNone);
+      kPendingNone);
 }
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        Retrying_SyncedHostBecomesUnverified) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   SetIsWifiSyncEnabled(true);
@@ -556,13 +584,15 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
       mojom::HostStatus::kHostSetButNotYetVerified, test_devices()[0]);
   EXPECT_EQ(
       test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
-      PendingNone);
+      kPendingNone);
   EXPECT_FALSE(mock_timer()->IsRunning());
   EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
 }
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        FailureCallback_SyncedHostBecomesUnverified) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   SetIsWifiSyncEnabled(true);
@@ -577,7 +607,7 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
       mojom::HostStatus::kHostSetButNotYetVerified, test_devices()[0]);
   EXPECT_EQ(
       test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
-      PendingNone);
+      kPendingNone);
 
   // Invoke failure callback. No retry should be scheduled.
   InvokePendingSetWifiSyncHostNetworkRequestCallback(
@@ -590,6 +620,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        NoVerifiedHost_AttemptToEnable) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   fake_host_status_provider()->SetHostWithStatus(
@@ -611,6 +643,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        StatusChangedOnRemoteDevice) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
@@ -625,6 +659,8 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
 
 TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
        SimultaneousRequests_StartOff_ToggleOnOff) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
   CreateDelegate(test_devices()[0] /* initial_host */);
 
   // Attempt to enable
@@ -657,6 +693,168 @@ TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
             multidevice::SoftwareFeatureState::kSupported);
 }
 
+TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
+       SetPendingEnableOnVerify_HostSetLocallyThenHostVerified) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
+  CreateDelegate(base::nullopt /* initial_host */);
+
+  // kHostSetLocallyButWaitingForBackendConfirmation is only possible if the
+  // setup flow has been completed on the local device.
+  SetHostInDeviceSyncClient(test_devices()[0]);
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
+      test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kSetPendingEnableOnVerify);
+  EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
+
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostVerified, test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kPendingEnable);
+  EXPECT_TRUE(delegate()->IsWifiSyncEnabled());
+  EXPECT_EQ(test_devices()[0].GetSoftwareFeatureState(
+                multidevice::SoftwareFeature::kWifiSyncHost),
+            multidevice::SoftwareFeatureState::kSupported);
+  InvokePendingSetWifiSyncHostNetworkRequestCallback(
+      device_sync::mojom::NetworkRequestResult::kSuccess,
+      false /* expected_to_notify_observer_and_start_retry_timer */);
+  EXPECT_EQ(0, GetSetHostNetworkRequestCallbackQueueSize());
+  SetWifiSyncHostInDeviceSyncClient(test_devices()[0], true /* enabled */);
+
+  EXPECT_EQ(test_devices()[0].GetSoftwareFeatureState(
+                multidevice::SoftwareFeature::kWifiSyncHost),
+            multidevice::SoftwareFeatureState::kEnabled);
+}
+
+TEST_P(
+    MultiDeviceSetupWifiSyncFeatureManagerImplTest,
+    SetPendingEnableOnVerify_HostSetLocallyThenHostSetNotVerifiedThenHostVerified) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
+  CreateDelegate(base::nullopt /* initial_host */);
+
+  // kHostSetLocallyButWaitingForBackendConfirmation is only possible if the
+  // setup flow has been completed on the local device.
+  SetHostInDeviceSyncClient(test_devices()[0]);
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
+      test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kSetPendingEnableOnVerify);
+  EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
+
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostSetButNotYetVerified, test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kSetPendingEnableOnVerify);
+  EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
+
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostVerified, test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kPendingEnable);
+  EXPECT_TRUE(delegate()->IsWifiSyncEnabled());
+  EXPECT_EQ(test_devices()[0].GetSoftwareFeatureState(
+                multidevice::SoftwareFeature::kWifiSyncHost),
+            multidevice::SoftwareFeatureState::kSupported);
+  InvokePendingSetWifiSyncHostNetworkRequestCallback(
+      device_sync::mojom::NetworkRequestResult::kSuccess,
+      false /* expected_to_notify_observer_and_start_retry_timer */);
+  EXPECT_EQ(0, GetSetHostNetworkRequestCallbackQueueSize());
+  SetWifiSyncHostInDeviceSyncClient(test_devices()[0], true /* enabled */);
+
+  EXPECT_EQ(test_devices()[0].GetSoftwareFeatureState(
+                multidevice::SoftwareFeature::kWifiSyncHost),
+            multidevice::SoftwareFeatureState::kEnabled);
+}
+
+TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
+       SetPendingEnableOnVerify_WifiSyncFlagOff) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  false /* enable_wifi_sync */);
+  CreateDelegate(base::nullopt /* initial_host */);
+
+  // kHostSetLocallyButWaitingForBackendConfirmation is only possible if the
+  // setup flow has been completed on the local device.
+  SetHostInDeviceSyncClient(test_devices()[0]);
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
+      test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kPendingNone);
+  EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
+}
+
+TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
+       SetPendingEnableOnVerify_HostRemoved) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
+  CreateDelegate(base::nullopt /* initial_host */);
+
+  // kHostSetLocallyButWaitingForBackendConfirmation is only possible if the
+  // setup flow has been completed on the local device.
+  SetHostInDeviceSyncClient(test_devices()[0]);
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
+      test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kSetPendingEnableOnVerify);
+  EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
+
+  // Host is added but not verified.
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostSetButNotYetVerified, test_devices()[0]);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kSetPendingEnableOnVerify);
+  EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
+
+  // Host is removed before it was verified. This simulates the user going
+  // through the forget phone flow before the phone was able to be verified.
+  // Wifi Sync should stop the enable attempt because it requires a paired host
+  // device that transitions from unverified to verified.
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kEligibleHostExistsButNoHostSet, base::nullopt);
+  EXPECT_EQ(
+      test_pref_service()->GetInteger(kPendingWifiSyncRequestEnabledPrefName),
+      kPendingNone);
+  EXPECT_FALSE(delegate()->IsWifiSyncEnabled());
+}
+
+TEST_P(MultiDeviceSetupWifiSyncFeatureManagerImplTest,
+       SetPendingEnableOnVerify_InitialPendingRequest) {
+  SetFeatureFlags(GetParam() /* use_v1_devicesync */,
+                  true /* enable_wifi_sync */);
+  fake_host_status_provider()->SetHostWithStatus(
+      mojom::HostStatus::kHostVerified, test_devices()[0]);
+  CreateDelegate(
+      test_devices()[0] /* initial_host */,
+      kSetPendingEnableOnVerify /* initial_pending_wifi_sync_request */);
+
+  EXPECT_TRUE(delegate()->IsWifiSyncEnabled());
+  EXPECT_EQ(test_devices()[0].GetSoftwareFeatureState(
+                multidevice::SoftwareFeature::kWifiSyncHost),
+            multidevice::SoftwareFeatureState::kSupported);
+  InvokePendingSetWifiSyncHostNetworkRequestCallback(
+      device_sync::mojom::NetworkRequestResult::kSuccess,
+      false /* expected_to_notify_observer_and_start_retry_timer */);
+  EXPECT_EQ(0, GetSetHostNetworkRequestCallbackQueueSize());
+  SetWifiSyncHostInDeviceSyncClient(test_devices()[0], true /* enabled */);
+
+  EXPECT_EQ(test_devices()[0].GetSoftwareFeatureState(
+                multidevice::SoftwareFeature::kWifiSyncHost),
+            multidevice::SoftwareFeatureState::kEnabled);
+}
+
 // Runs tests twice; once with v1 DeviceSync enabled and once with it disabled.
 // TODO(https://crbug.com/1019206): Remove when v1 DeviceSync is disabled,
 // when all devices should have an Instance ID.