[DeviceSync v2] Use legacy ID and Instance ID for multidevice setup

Update the multi-device setup service function SetHostDevice() and
related functions to accept either a device's Instance ID or legacy
RemoteDevice ID. The former is only present for devices using v2
DeviceSync and the latter is the encoded public key--given by
RemoteDevice::GetDeviceId(). The legacy device ID will not be available
from the v2 DeviceSync service until device metadata can be decrypted.
This delay could prevent multi-device setup, especially during OOBE,
unless SetHostDevice() also supports use of the Instance ID.

By design, the Chrome OS CryptAuth client code guarantees that while v1
DeviceSync is running--whether in parallel with v2 DeviceSync or alone--
every device will always have an unencrypted legacy device ID, though
some may not have an Instance ID. When v1 DeviceSync is turned off,
however, only an Instance ID is guaranteed, and this CL is necessary.

This CL is meant to be temporary. When v1 DeviceSync is turned off and
no rollback is expected, the changes in this CL should be revised to
only use Instance IDs since those are always guaranteed to exist in v2
DeviceSync.

Variable name changes from |host_device_id| to the elegant
|host_instance_id_or_legacy_device_id| comprise the bulk of this CL. The
crucial logic changes are in start_setup_page.html/js and
multidevice_setup_impl.cc.

Bug: 951969, 1019206
Change-Id: I99c3b79cbb8414da65ee7b95dab80f661f15b13b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2000972Reviewed-by: Mustafa Emre Acer <meacer@chromium.org>
Reviewed-by: Achuith Bhandarkar <achuith@chromium.org>
Commit-Queue: Josh Nohle <nohle@chromium.org>
Cr-Commit-Position: refs/heads/master@{#735679}

chrome/browser/resources/chromeos/login/multidevice_setup_first_run.js

@@ -25,7 +25,7 @@ cr.define('multidevice_setup', function() {
     }
 
     /** @override */
-    setHostDevice(hostDeviceId, opt_authToken) {
+    setHostDevice(hostInstanceIdOrLegacyDeviceId, opt_authToken) {
       // An authentication token is not expected since a password is not
       // required.
       assert(!opt_authToken);
@@ -37,7 +37,7 @@ cr.define('multidevice_setup', function() {
       }
 
       return /** @type {!Promise<{success: boolean}>} */ (
-          this.remote_.setHostDevice(hostDeviceId));
+          this.remote_.setHostDevice(hostInstanceIdOrLegacyDeviceId));
     }
 
     /** @override */

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

@@ -11,7 +11,7 @@ cr.define('multidevice_setup', function() {
     }
 
     /** @override */
-    setHostDevice(hostDeviceId, opt_authToken) {
+    setHostDevice(hostInstanceIdOrLegacyDeviceId, opt_authToken) {
       // An authentication token is required to set the host device post-OOBE.
       assert(!!opt_authToken);
 
@@ -22,7 +22,7 @@ cr.define('multidevice_setup', function() {
       return /** @type {!Promise<{success: boolean}>} */ (
           multidevice_setup.MojoInterfaceProviderImpl.getInstance()
               .getMojoServiceRemote()
-              .setHostDevice(hostDeviceId, opt_authToken));
+              .setHostDevice(hostInstanceIdOrLegacyDeviceId, opt_authToken));
     }
 
     /** @override */

chrome/test/data/webui/multidevice_setup/integration_test.js

@@ -30,7 +30,7 @@ cr.define('multidevice_setup', () => {
     }
 
     /** @override */
-    setHostDevice(hostDeviceId, opt_authToken) {
+    setHostDevice(hostInstanceIdOrLegacyDeviceId, opt_authToken) {
       return new Promise((resolve) => {
         this.numSetHostDeviceCalls++;
         resolve({success: this.shouldSetHostSucceed_});

chrome/test/data/webui/multidevice_setup/start_setup_page_test.js

@@ -31,22 +31,35 @@ cr.define('multidevice_setup', () => {
       let startSetupPageElement;
 
       const START = 'start-setup-page';
+
+      // TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, all
+      // devices should have an Instance ID.
       const DEVICES = [
         {
-          remoteDevice: {deviceName: 'Pixel XL', deviceId: 'abcdxl'},
+          remoteDevice: {deviceName: 'Pixel XL', deviceId: 'legacy-id-1'},
           connectivityStatus:
               chromeos.deviceSync.mojom.ConnectivityStatus.kOnline
         },
         {
-          remoteDevice: {deviceName: 'Nexus 6P', deviceId: 'PpPpPp'},
+          remoteDevice: {deviceName: 'Nexus 6P', instanceId: 'iid-2'},
           connectivityStatus:
               chromeos.deviceSync.mojom.ConnectivityStatus.kOffline
         },
         {
-          remoteDevice: {deviceName: 'Nexus 5', deviceId: '12345'},
+          remoteDevice: {
+            deviceName: 'Nexus 5',
+            deviceId: 'legacy-id-3',
+            instanceId: 'iid-3'
+          },
           connectivityStatus:
               chromeos.deviceSync.mojom.ConnectivityStatus.kUnknownConnectivity
         },
+        {
+          remoteDevice:
+              {deviceName: 'Pixel 4', deviceId: 'legacy-id-4', instanceId: ''},
+          connectivityStatus:
+              chromeos.deviceSync.mojom.ConnectivityStatus.kOnline
+        },
       ];
 
       setup(() => {
@@ -68,6 +81,8 @@ cr.define('multidevice_setup', () => {
         }
       };
 
+      // TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, all
+      // selected IDs will be Instance IDs.
       test(
           'Finding devices populates dropdown and defines selected device',
           () => {
@@ -76,17 +91,28 @@ cr.define('multidevice_setup', () => {
                     .querySelectorAll('option')
                     .length,
                 DEVICES.length);
-            assertEquals(startSetupPageElement.selectedDeviceId, 'abcdxl');
+            assertEquals(
+                startSetupPageElement.selectedInstanceIdOrLegacyDeviceId,
+                'legacy-id-1');
           });
 
-      test(
-          'selectedDeviceId changes when dropdown options are selected', () => {
+      // TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, all
+      // selected IDs will be Instance IDs.
+      test('Selected ID changes when dropdown options are selected', () => {
         selectOptionByTextContent('Nexus 6P (offline)');
-            assertEquals(startSetupPageElement.selectedDeviceId, 'PpPpPp');
+        assertEquals(
+            startSetupPageElement.selectedInstanceIdOrLegacyDeviceId, 'iid-2');
         selectOptionByTextContent('Nexus 5');
-            assertEquals(startSetupPageElement.selectedDeviceId, '12345');
+        assertEquals(
+            startSetupPageElement.selectedInstanceIdOrLegacyDeviceId, 'iid-3');
+        selectOptionByTextContent('Pixel 4');
+        assertEquals(
+            startSetupPageElement.selectedInstanceIdOrLegacyDeviceId,
+            'legacy-id-4');
         selectOptionByTextContent('Pixel XL');
-            assertEquals(startSetupPageElement.selectedDeviceId, 'abcdxl');
+        assertEquals(
+            startSetupPageElement.selectedInstanceIdOrLegacyDeviceId,
+            'legacy-id-1');
       });
     });
   }

chromeos/services/multidevice_setup/multidevice_setup_base.h

@@ -23,8 +23,10 @@ class MultiDeviceSetupBase : public mojom::MultiDeviceSetup {
 
   // Sets the device with the given ID as the multi-device host for this
   // account.
+  // TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only
+  // use Instance ID since all devices are guaranteed to have one.
   virtual void SetHostDeviceWithoutAuthToken(
-      const std::string& host_device_id,
+      const std::string& host_instance_id_or_legacy_device_id,
       mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback) = 0;
 
  protected:

chromeos/services/multidevice_setup/multidevice_setup_impl.cc

@@ -12,6 +12,7 @@
 #include "base/no_destructor.h"
 #include "base/time/default_clock.h"
 #include "chromeos/components/multidevice/logging/logging.h"
+#include "chromeos/constants/chromeos_features.h"
 #include "chromeos/services/multidevice_setup/account_status_change_delegate_notifier_impl.h"
 #include "chromeos/services/multidevice_setup/android_sms_app_installing_status_observer.h"
 #include "chromeos/services/multidevice_setup/device_reenroller.h"
@@ -198,7 +199,8 @@ void MultiDeviceSetupImpl::GetEligibleActiveHostDevices(
   std::move(callback).Run(std::move(eligible_active_hosts));
 }
 
-void MultiDeviceSetupImpl::SetHostDevice(const std::string& host_device_id,
+void MultiDeviceSetupImpl::SetHostDevice(
+    const std::string& host_instance_id_or_legacy_device_id,
     const std::string& auth_token,
     SetHostDeviceCallback callback) {
   if (!auth_token_validator_->IsAuthTokenValid(auth_token)) {
@@ -206,7 +208,7 @@ void MultiDeviceSetupImpl::SetHostDevice(const std::string& host_device_id,
     return;
   }
 
-  std::move(callback).Run(AttemptSetHost(host_device_id));
+  std::move(callback).Run(AttemptSetHost(host_instance_id_or_legacy_device_id));
 }
 
 void MultiDeviceSetupImpl::RemoveHostDevice() {
@@ -313,9 +315,9 @@ void MultiDeviceSetupImpl::TriggerEventForDebugging(
 }
 
 void MultiDeviceSetupImpl::SetHostDeviceWithoutAuthToken(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback) {
-  std::move(callback).Run(AttemptSetHost(host_device_id));
+  std::move(callback).Run(AttemptSetHost(host_instance_id_or_legacy_device_id));
 }
 
 void MultiDeviceSetupImpl::OnHostStatusChange(
@@ -340,13 +342,27 @@ void MultiDeviceSetupImpl::OnFeatureStatesChange(
     observer->OnFeatureStatesChanged(feature_states_map);
 }
 
-bool MultiDeviceSetupImpl::AttemptSetHost(const std::string& host_device_id) {
+bool MultiDeviceSetupImpl::AttemptSetHost(
+    const std::string& host_instance_id_or_legacy_device_id) {
+  DCHECK(!host_instance_id_or_legacy_device_id.empty());
+
   multidevice::RemoteDeviceRefList eligible_devices =
       eligible_host_devices_provider_->GetEligibleHostDevices();
-  auto it =
-      std::find_if(eligible_devices.begin(), eligible_devices.end(),
-                   [&host_device_id](const auto& eligible_device) {
-                     return eligible_device.GetDeviceId() == host_device_id;
+
+  // TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only use
+  // Instance ID since all devices are guaranteed to have one.
+  auto it = std::find_if(
+      eligible_devices.begin(), eligible_devices.end(),
+      [&host_instance_id_or_legacy_device_id](const auto& eligible_device) {
+        if (features::ShouldUseV1DeviceSync()) {
+          return eligible_device.instance_id() ==
+                     host_instance_id_or_legacy_device_id ||
+                 eligible_device.GetDeviceId() ==
+                     host_instance_id_or_legacy_device_id;
+        }
+
+        return eligible_device.instance_id() ==
+               host_instance_id_or_legacy_device_id;
       });
 
   if (it == eligible_devices.end())

chromeos/services/multidevice_setup/multidevice_setup_impl.h

@@ -6,6 +6,7 @@
 #define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_MULTIDEVICE_SETUP_IMPL_H_
 
 #include <memory>
+#include <string>
 
 #include "base/containers/flat_map.h"
 #include "chromeos/services/multidevice_setup/feature_state_manager.h"
@@ -89,7 +90,7 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase,
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void GetEligibleActiveHostDevices(
       GetEligibleActiveHostDevicesCallback callback) override;
-  void SetHostDevice(const std::string& host_device_id,
+  void SetHostDevice(const std::string& host_instance_id_or_legacy_device_id,
                      const std::string& auth_token,
                      SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;
@@ -106,7 +107,7 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase,
 
   // MultiDeviceSetupBase:
   void SetHostDeviceWithoutAuthToken(
-      const std::string& host_device_id,
+      const std::string& host_instance_id_or_legacy_device_id,
       mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback)
       override;
 
@@ -120,7 +121,7 @@ class MultiDeviceSetupImpl : public MultiDeviceSetupBase,
 
   // Attempts to set the host device, returning a boolean of whether the attempt
   // was successful.
-  bool AttemptSetHost(const std::string& host_device_id);
+  bool AttemptSetHost(const std::string& host_instance_id_or_legacy_device_id);
   bool IsAuthTokenRequiredForFeatureStateChange(mojom::Feature feature,
                                                 bool enabled);
 

chromeos/services/multidevice_setup/multidevice_setup_initializer.cc

@@ -56,17 +56,20 @@ MultiDeviceSetupInitializer::Factory::BuildInstance(
 }
 
 MultiDeviceSetupInitializer::SetHostDeviceArgs::SetHostDeviceArgs(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     const std::string& auth_token,
     SetHostDeviceCallback callback)
-    : host_device_id(host_device_id),
+    : host_instance_id_or_legacy_device_id(
+          host_instance_id_or_legacy_device_id),
       auth_token(auth_token),
       callback(std::move(callback)) {}
 
 MultiDeviceSetupInitializer::SetHostDeviceArgs::SetHostDeviceArgs(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback)
-    : host_device_id(host_device_id), callback(std::move(callback)) {}
+    : host_instance_id_or_legacy_device_id(
+          host_instance_id_or_legacy_device_id),
+      callback(std::move(callback)) {}
 
 MultiDeviceSetupInitializer::SetHostDeviceArgs::~SetHostDeviceArgs() = default;
 
@@ -151,12 +154,12 @@ void MultiDeviceSetupInitializer::GetEligibleActiveHostDevices(
 }
 
 void MultiDeviceSetupInitializer::SetHostDevice(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     const std::string& auth_token,
     SetHostDeviceCallback callback) {
   if (multidevice_setup_impl_) {
-    multidevice_setup_impl_->SetHostDevice(host_device_id, auth_token,
-                                           std::move(callback));
+    multidevice_setup_impl_->SetHostDevice(host_instance_id_or_legacy_device_id,
+                                           auth_token, std::move(callback));
     return;
   }
 
@@ -168,8 +171,8 @@ void MultiDeviceSetupInitializer::SetHostDevice(
   // If a pending request to remove the current device exists, cancel it.
   pending_should_remove_host_device_ = false;
 
-  pending_set_host_args_.emplace(host_device_id, auth_token,
-                                 std::move(callback));
+  pending_set_host_args_.emplace(host_instance_id_or_legacy_device_id,
+                                 auth_token, std::move(callback));
 }
 
 void MultiDeviceSetupInitializer::RemoveHostDevice() {
@@ -247,11 +250,11 @@ void MultiDeviceSetupInitializer::TriggerEventForDebugging(
 }
 
 void MultiDeviceSetupInitializer::SetHostDeviceWithoutAuthToken(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback) {
   if (multidevice_setup_impl_) {
-    multidevice_setup_impl_->SetHostDeviceWithoutAuthToken(host_device_id,
-                                                           std::move(callback));
+    multidevice_setup_impl_->SetHostDeviceWithoutAuthToken(
+        host_instance_id_or_legacy_device_id, std::move(callback));
     return;
   }
 
@@ -265,7 +268,8 @@ void MultiDeviceSetupInitializer::SetHostDeviceWithoutAuthToken(
   // If a pending request to remove the current device exists, cancel it.
   pending_should_remove_host_device_ = false;
 
-  pending_set_host_args_.emplace(host_device_id, std::move(callback));
+  pending_set_host_args_.emplace(host_instance_id_or_legacy_device_id,
+                                 std::move(callback));
 }
 
 void MultiDeviceSetupInitializer::OnReady() {
@@ -298,12 +302,12 @@ void MultiDeviceSetupInitializer::InitializeImplementation() {
     DCHECK(!pending_should_remove_host_device_);
     if (pending_set_host_args_->auth_token) {
       multidevice_setup_impl_->SetHostDevice(
-          pending_set_host_args_->host_device_id,
+          pending_set_host_args_->host_instance_id_or_legacy_device_id,
           *pending_set_host_args_->auth_token,
           std::move(pending_set_host_args_->callback));
     } else {
       multidevice_setup_impl_->SetHostDeviceWithoutAuthToken(
-          pending_set_host_args_->host_device_id,
+          pending_set_host_args_->host_instance_id_or_legacy_device_id,
           std::move(pending_set_host_args_->callback));
     }
     pending_set_host_args_.reset();

chromeos/services/multidevice_setup/multidevice_setup_initializer.h

@@ -60,18 +60,18 @@ class MultiDeviceSetupInitializer
   // Used for both SetHostDevice() and SetHostDeviceWithoutAuthToken().
   struct SetHostDeviceArgs {
     // For SetHostDevice().
-    SetHostDeviceArgs(const std::string& host_device_id,
+    SetHostDeviceArgs(const std::string& host_instance_id_or_legacy_device_id,
                       const std::string& auth_token,
                       SetHostDeviceCallback callback);
 
     // For SetHostDeviceWithoutAuthToken().
     SetHostDeviceArgs(
-        const std::string& host_device_id,
+        const std::string& host_instance_id_or_legacy_device_id,
         mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback);
 
     ~SetHostDeviceArgs();
 
-    std::string host_device_id;
+    std::string host_instance_id_or_legacy_device_id;
     // Null for SetHostDeviceWithoutAuthToken().
     base::Optional<std::string> auth_token;
     base::OnceCallback<void(bool)> callback;
@@ -97,7 +97,7 @@ class MultiDeviceSetupInitializer
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void GetEligibleActiveHostDevices(
       GetEligibleActiveHostDevicesCallback callback) override;
-  void SetHostDevice(const std::string& host_device_id,
+  void SetHostDevice(const std::string& host_instance_id_or_legacy_device_id,
                      const std::string& auth_token,
                      SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;
@@ -114,7 +114,7 @@ class MultiDeviceSetupInitializer
 
   // MultiDeviceSetupBase:
   void SetHostDeviceWithoutAuthToken(
-      const std::string& host_device_id,
+      const std::string& host_instance_id_or_legacy_device_id,
       mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback)
       override;
 

chromeos/services/multidevice_setup/multidevice_setup_service_unittest.cc

@@ -294,11 +294,11 @@ TEST_F(MultiDeviceSetupServiceTest, CallFunctionsBeforeInitialization) {
 }
 
 TEST_F(MultiDeviceSetupServiceTest, SetThenRemoveBeforeInitialization) {
-  multidevice_setup_remote()->SetHostDevice("deviceId1", "authToken",
+  multidevice_setup_remote()->SetHostDevice("id1", "authToken",
                                             base::DoNothing());
   multidevice_setup_remote().FlushForTesting();
 
-  privileged_host_device_setter_remote()->SetHostDevice("deviceId2",
+  privileged_host_device_setter_remote()->SetHostDevice("id2",
                                                         base::DoNothing());
   privileged_host_device_setter_remote().FlushForTesting();
 
@@ -320,15 +320,15 @@ TEST_F(MultiDeviceSetupServiceTest, RemoveThenSetThenSetBeforeInitialization) {
   multidevice_setup_remote()->RemoveHostDevice();
   multidevice_setup_remote().FlushForTesting();
 
-  privileged_host_device_setter_remote()->SetHostDevice("deviceId1",
+  privileged_host_device_setter_remote()->SetHostDevice("id1",
                                                         base::DoNothing());
   privileged_host_device_setter_remote().FlushForTesting();
 
-  multidevice_setup_remote()->SetHostDevice("deviceId2", "authToken2",
+  multidevice_setup_remote()->SetHostDevice("id2", "authToken2",
                                             base::DoNothing());
   multidevice_setup_remote().FlushForTesting();
 
-  multidevice_setup_remote()->SetHostDevice("deviceId3", "authToken3",
+  multidevice_setup_remote()->SetHostDevice("id3", "authToken3",
                                             base::DoNothing());
   multidevice_setup_remote().FlushForTesting();
 
@@ -340,8 +340,7 @@ TEST_F(MultiDeviceSetupServiceTest, RemoveThenSetThenSetBeforeInitialization) {
   EXPECT_EQ(0u, fake_multidevice_setup()->num_remove_host_calls());
   EXPECT_TRUE(fake_multidevice_setup()->set_host_without_auth_args().empty());
   EXPECT_EQ(1u, fake_multidevice_setup()->set_host_args().size());
-  EXPECT_EQ("deviceId3",
-            std::get<0>(fake_multidevice_setup()->set_host_args()[0]));
+  EXPECT_EQ("id3", std::get<0>(fake_multidevice_setup()->set_host_args()[0]));
   EXPECT_EQ("authToken3",
             std::get<1>(fake_multidevice_setup()->set_host_args()[0]));
 }
@@ -351,15 +350,15 @@ TEST_F(MultiDeviceSetupServiceTest,
   multidevice_setup_remote()->RemoveHostDevice();
   multidevice_setup_remote().FlushForTesting();
 
-  multidevice_setup_remote()->SetHostDevice("deviceId1", "authToken1",
+  multidevice_setup_remote()->SetHostDevice("id1", "authToken1",
                                             base::DoNothing());
   multidevice_setup_remote().FlushForTesting();
 
-  multidevice_setup_remote()->SetHostDevice("deviceId2", "authToken2",
+  multidevice_setup_remote()->SetHostDevice("id2", "authToken2",
                                             base::DoNothing());
   multidevice_setup_remote().FlushForTesting();
 
-  privileged_host_device_setter_remote()->SetHostDevice("deviceId3",
+  privileged_host_device_setter_remote()->SetHostDevice("id3",
                                                         base::DoNothing());
   privileged_host_device_setter_remote().FlushForTesting();
 
@@ -371,7 +370,7 @@ TEST_F(MultiDeviceSetupServiceTest,
   EXPECT_EQ(0u, fake_multidevice_setup()->num_remove_host_calls());
   EXPECT_TRUE(fake_multidevice_setup()->set_host_args().empty());
   EXPECT_EQ(1u, fake_multidevice_setup()->set_host_without_auth_args().size());
-  EXPECT_EQ("deviceId3",
+  EXPECT_EQ("id3",
             fake_multidevice_setup()->set_host_without_auth_args()[0].first);
 }
 
@@ -409,7 +408,7 @@ TEST_F(MultiDeviceSetupServiceTest, FinishInitializationFirst) {
   EXPECT_EQ(1u, fake_multidevice_setup()->get_eligible_hosts_args().size());
 
   // SetHostDevice().
-  multidevice_setup_remote()->SetHostDevice("deviceId", "authToken",
+  multidevice_setup_remote()->SetHostDevice("id", "authToken",
                                             base::DoNothing());
   multidevice_setup_remote().FlushForTesting();
   EXPECT_EQ(1u, fake_multidevice_setup()->set_host_args().size());
@@ -442,7 +441,7 @@ TEST_F(MultiDeviceSetupServiceTest, FinishInitializationFirst) {
   EXPECT_EQ(1u, fake_multidevice_setup()->retry_set_host_now_args().size());
 
   // SetHostDevice(), without an auth token.
-  privileged_host_device_setter_remote()->SetHostDevice("deviceId",
+  privileged_host_device_setter_remote()->SetHostDevice("id",
                                                         base::DoNothing());
   privileged_host_device_setter_remote().FlushForTesting();
   EXPECT_EQ(1u, fake_multidevice_setup()->set_host_without_auth_args().size());

chromeos/services/multidevice_setup/privileged_host_device_setter_impl.cc

@@ -49,10 +49,10 @@ PrivilegedHostDeviceSetterImpl::PrivilegedHostDeviceSetterImpl(
 PrivilegedHostDeviceSetterImpl::~PrivilegedHostDeviceSetterImpl() = default;
 
 void PrivilegedHostDeviceSetterImpl::SetHostDevice(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     SetHostDeviceCallback callback) {
-  multidevice_setup_->SetHostDeviceWithoutAuthToken(host_device_id,
-                                                    std::move(callback));
+  multidevice_setup_->SetHostDeviceWithoutAuthToken(
+      host_instance_id_or_legacy_device_id, std::move(callback));
 }
 
 }  // namespace multidevice_setup

chromeos/services/multidevice_setup/privileged_host_device_setter_impl.h

@@ -37,7 +37,7 @@ class PrivilegedHostDeviceSetterImpl : public PrivilegedHostDeviceSetterBase {
       MultiDeviceSetupBase* multidevice_setup);
 
   // mojom::PrivilegedHostDeviceSetter:
-  void SetHostDevice(const std::string& host_device_id,
+  void SetHostDevice(const std::string& host_instance_id_or_legacy_device_id,
                      SetHostDeviceCallback callback) override;
 
   MultiDeviceSetupBase* multidevice_setup_;

chromeos/services/multidevice_setup/privileged_host_device_setter_impl_unittest.cc

@@ -29,19 +29,20 @@ class MultiDeviceSetupPrivilegedHostDeviceSetterImplTest
             fake_multidevice_setup_.get());
   }
 
-  void CallSetHostDevice(const std::string& host_device_id,
+  void CallSetHostDevice(
+      const std::string& host_instance_id_or_legacy_device_id,
       bool should_succeed) {
     auto& args = fake_multidevice_setup_->set_host_without_auth_args();
     size_t num_calls_before = args.size();
 
     host_setter_->SetHostDevice(
-        host_device_id,
+        host_instance_id_or_legacy_device_id,
         base::BindOnce(&MultiDeviceSetupPrivilegedHostDeviceSetterImplTest::
                            OnSetHostDeviceResult,
                        base::Unretained(this)));
 
     EXPECT_EQ(num_calls_before + 1u, args.size());
-    EXPECT_EQ(host_device_id, args.back().first);
+    EXPECT_EQ(host_instance_id_or_legacy_device_id, args.back().first);
     std::move(args.back().second).Run(should_succeed);
     EXPECT_EQ(should_succeed, *last_set_host_success_);
     last_set_host_success_.reset();
@@ -64,8 +65,8 @@ class MultiDeviceSetupPrivilegedHostDeviceSetterImplTest
 };
 
 TEST_F(MultiDeviceSetupPrivilegedHostDeviceSetterImplTest, SetHostDevice) {
-  CallSetHostDevice("hostDeviceId1", false /* should_succeed */);
-  CallSetHostDevice("hostDeviceId2", true /* should_succeed */);
+  CallSetHostDevice("hostId1", false /* should_succeed */);
+  CallSetHostDevice("hostId2", true /* should_succeed */);
 }
 
 }  // namespace multidevice_setup

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

@@ -125,10 +125,12 @@ void FakeMultiDeviceSetup::GetEligibleActiveHostDevices(
   get_eligible_active_hosts_args_.push_back(std::move(callback));
 }
 
-void FakeMultiDeviceSetup::SetHostDevice(const std::string& host_device_id,
+void FakeMultiDeviceSetup::SetHostDevice(
+    const std::string& host_instance_id_or_legacy_device_id,
     const std::string& auth_token,
     SetHostDeviceCallback callback) {
-  set_host_args_.emplace_back(host_device_id, auth_token, std::move(callback));
+  set_host_args_.emplace_back(host_instance_id_or_legacy_device_id, auth_token,
+                              std::move(callback));
 }
 
 void FakeMultiDeviceSetup::RemoveHostDevice() {
@@ -163,9 +165,10 @@ void FakeMultiDeviceSetup::TriggerEventForDebugging(
 }
 
 void FakeMultiDeviceSetup::SetHostDeviceWithoutAuthToken(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback) {
-  set_host_without_auth_args_.emplace_back(host_device_id, std::move(callback));
+  set_host_without_auth_args_.emplace_back(host_instance_id_or_legacy_device_id,
+                                           std::move(callback));
 }
 
 }  // namespace multidevice_setup

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

@@ -95,7 +95,7 @@ class FakeMultiDeviceSetup : public MultiDeviceSetupBase {
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void GetEligibleActiveHostDevices(
       GetEligibleActiveHostDevicesCallback callback) override;
-  void SetHostDevice(const std::string& host_device_id,
+  void SetHostDevice(const std::string& host_instance_id_or_legacy_device_id,
                      const std::string& auth_token,
                      SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;
@@ -112,7 +112,7 @@ class FakeMultiDeviceSetup : public MultiDeviceSetupBase {
 
   // MultiDeviceSetupBase:
   void SetHostDeviceWithoutAuthToken(
-      const std::string& host_device_id,
+      const std::string& host_instance_id_or_legacy_device_id,
       mojom::PrivilegedHostDeviceSetter::SetHostDeviceCallback callback)
       override;
 

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

@@ -56,10 +56,11 @@ void FakeMultiDeviceSetupClient::InvokePendingGetEligibleHostDevicesCallback(
 }
 
 void FakeMultiDeviceSetupClient::InvokePendingSetHostDeviceCallback(
-    const std::string& expected_device_id,
+    const std::string& expected_instance_id_or_legacy_device_id,
     const std::string& expected_auth_token,
     bool success) {
-  DCHECK_EQ(expected_device_id, std::get<0>(set_host_args_queue_.front()));
+  DCHECK_EQ(expected_instance_id_or_legacy_device_id,
+            std::get<0>(set_host_args_queue_.front()));
   DCHECK_EQ(expected_auth_token, std::get<1>(set_host_args_queue_.front()));
   std::move(std::get<2>(set_host_args_queue_.front())).Run(success);
   set_host_args_queue_.pop();
@@ -100,10 +101,11 @@ void FakeMultiDeviceSetupClient::GetEligibleHostDevices(
 }
 
 void FakeMultiDeviceSetupClient::SetHostDevice(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     const std::string& auth_token,
     mojom::MultiDeviceSetup::SetHostDeviceCallback callback) {
-  set_host_args_queue_.emplace(host_device_id, auth_token, std::move(callback));
+  set_host_args_queue_.emplace(host_instance_id_or_legacy_device_id, auth_token,
+                               std::move(callback));
 }
 
 void FakeMultiDeviceSetupClient::RemoveHostDevice() {

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

@@ -36,7 +36,7 @@ class FakeMultiDeviceSetupClient : public MultiDeviceSetupClient {
   void InvokePendingGetEligibleHostDevicesCallback(
       const multidevice::RemoteDeviceRefList& eligible_devices);
   void InvokePendingSetHostDeviceCallback(
-      const std::string& expected_device_id,
+      const std::string& expected_instance_id_or_legacy_device_id,
       const std::string& expected_auth_token,
       bool success);
   void InvokePendingSetFeatureEnabledStateCallback(
@@ -61,7 +61,7 @@ class FakeMultiDeviceSetupClient : public MultiDeviceSetupClient {
   // MultiDeviceSetupClient:
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void SetHostDevice(
-      const std::string& host_device_id,
+      const std::string& host_instance_id_or_legacy_device_id,
       const std::string& auth_token,
       mojom::MultiDeviceSetup::SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;

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

@@ -13,9 +13,10 @@ FakePrivilegedHostDeviceSetter::FakePrivilegedHostDeviceSetter() = default;
 FakePrivilegedHostDeviceSetter::~FakePrivilegedHostDeviceSetter() = default;
 
 void FakePrivilegedHostDeviceSetter::SetHostDevice(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     SetHostDeviceCallback callback) {
-  set_host_args_.emplace_back(host_device_id, std::move(callback));
+  set_host_args_.emplace_back(host_instance_id_or_legacy_device_id,
+                              std::move(callback));
 }
 
 }  // namespace multidevice_setup

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

@@ -27,7 +27,7 @@ class FakePrivilegedHostDeviceSetter : public PrivilegedHostDeviceSetterBase {
 
  private:
   // mojom::PrivilegedHostDeviceSetter:
-  void SetHostDevice(const std::string& host_device_id,
+  void SetHostDevice(const std::string& host_instance_id_or_legacy_device_id,
                      SetHostDeviceCallback callback) override;
 
   std::vector<std::pair<std::string, SetHostDeviceCallback>> set_host_args_;

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

@@ -60,7 +60,7 @@ class MultiDeviceSetupClient {
   virtual void GetEligibleHostDevices(
       GetEligibleHostDevicesCallback callback) = 0;
   virtual void SetHostDevice(
-      const std::string& host_device_id,
+      const std::string& host_instance_id_or_legacy_device_id,
       const std::string& auth_token,
       mojom::MultiDeviceSetup::SetHostDeviceCallback callback) = 0;
   virtual void RemoveHostDevice() = 0;

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

@@ -74,11 +74,11 @@ void MultiDeviceSetupClientImpl::GetEligibleHostDevices(
 }
 
 void MultiDeviceSetupClientImpl::SetHostDevice(
-    const std::string& host_device_id,
+    const std::string& host_instance_id_or_legacy_device_id,
     const std::string& auth_token,
     mojom::MultiDeviceSetup::SetHostDeviceCallback callback) {
-  multidevice_setup_remote_->SetHostDevice(host_device_id, auth_token,
-                                           std::move(callback));
+  multidevice_setup_remote_->SetHostDevice(host_instance_id_or_legacy_device_id,
+                                           auth_token, std::move(callback));
 }
 
 void MultiDeviceSetupClientImpl::RemoveHostDevice() {

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

@@ -46,7 +46,7 @@ class MultiDeviceSetupClientImpl : public MultiDeviceSetupClient,
   // MultiDeviceSetupClient:
   void GetEligibleHostDevices(GetEligibleHostDevicesCallback callback) override;
   void SetHostDevice(
-      const std::string& host_device_id,
+      const std::string& host_instance_id_or_legacy_device_id,
       const std::string& auth_token,
       mojom::MultiDeviceSetup::SetHostDeviceCallback callback) override;
   void RemoveHostDevice() override;

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

@@ -216,13 +216,14 @@ class MultiDeviceSetupClientImplTest : public testing::Test {
         *eligible_host_devices_, expected_eligible_host_devices);
   }
 
-  void CallSetHostDevice(const std::string& public_key,
+  void CallSetHostDevice(
+      const std::string& host_instance_id_or_legacy_device_id,
       const std::string& auth_token,
       bool expect_success) {
     base::RunLoop run_loop;
 
     client_->SetHostDevice(
-        public_key, auth_token,
+        host_instance_id_or_legacy_device_id, auth_token,
         base::BindOnce(
             &MultiDeviceSetupClientImplTest::OnSetHostDeviceCompleted,
             base::Unretained(this), run_loop.QuitClosure()));
@@ -233,7 +234,7 @@ class MultiDeviceSetupClientImplTest : public testing::Test {
                            mojom::MultiDeviceSetup::SetHostDeviceCallback>>&
         callbacks = fake_multidevice_setup_->set_host_args();
     EXPECT_EQ(1u, callbacks.size());
-    EXPECT_EQ(public_key, std::get<0>(callbacks[0]));
+    EXPECT_EQ(host_instance_id_or_legacy_device_id, std::get<0>(callbacks[0]));
     EXPECT_EQ(auth_token, std::get<1>(callbacks[0]));
     std::move(std::get<2>(callbacks[0])).Run(expect_success);
 
@@ -447,14 +448,12 @@ TEST_F(MultiDeviceSetupClientImplTest, TestGetEligibleHostDevices) {
 
 TEST_F(MultiDeviceSetupClientImplTest, TestSetHostDevice_Success) {
   InitializeClient();
-  CallSetHostDevice(test_remote_device_list_[0].public_key, "authToken",
-                    true /* expect_success */);
+  CallSetHostDevice("hostId", "authToken", true /* expect_success */);
 }
 
 TEST_F(MultiDeviceSetupClientImplTest, TestSetHostDevice_Failure) {
   InitializeClient();
-  CallSetHostDevice(test_remote_device_list_[0].public_key, "authToken",
-                    false /* expect_success */);
+  CallSetHostDevice("hostId", "authToken", false /* expect_success */);
 }
 
 TEST_F(MultiDeviceSetupClientImplTest, TestRemoveHostDevice) {

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

@@ -168,16 +168,21 @@ interface MultiDeviceSetup {
   GetEligibleActiveHostDevices() =>
       (array<HostDevice> eligible_host_devices);
 
-  // Sets the host associated with the provided device ID as the host device
-  // for this account. The provided auth token must be valid in order to prove
-  // that the user is authenticated. If called when there is no current host or
-  // when the current host is a different device from the one passed, this
-  // function initiates a connection to the back-end and attempts to set the
-  // host. When called with the same device that is already the host, this
-  // function is a no-op. Returns a success boolean; this function will fail if
-  // the provided device ID does not correspond to an eligible host device on
-  // the account, or the provided auth token is invalid.
-  SetHostDevice(string device_id, string auth_token) => (bool success);
+  // Sets the host associated with the provided ID--Instance ID or legacy
+  // device ID, depending on whether the device is using v2 or v1 DeviceSync,
+  // respectively--as the host device for this account. The provided auth token
+  // must be valid in order to prove that the user is authenticated. If called
+  // when there is no current host or when the current host is a different
+  // device from the one passed, this function initiates a connection to the
+  // back-end and attempts to set the host. When called with the same device
+  // that is already the host, this function is a no-op. Returns a success
+  // boolean; this function will fail if the provided ID does not correspond to
+  // an eligible host device on the account, or the provided auth token is
+  // invalid.
+  // TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only
+  // use Instance ID since all devices are guaranteed to have one.
+  SetHostDevice(string instance_id_or_legacy_device_id, string auth_token) =>
+      (bool success);
 
   // Removes the currently-set host as the multi-device host for this account.
   // If there was no host set to begin with, this function is a no-op.
@@ -229,5 +234,7 @@ interface MultiDeviceSetup {
 interface PrivilegedHostDeviceSetter {
   // Same functionality as MultiDeviceSetup's SetHostDevice() function above,
   // except that no auth token is required.
-  SetHostDevice(string device_id) => (bool success);
+  // TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only
+  // use Instance ID since all devices are guaranteed to have one.
+  SetHostDevice(string instance_id_or_legacy_device_id) => (bool success);
 };

ui/webui/resources/cr_components/chromeos/multidevice_setup/fake_mojo_service.js

@@ -67,10 +67,11 @@ class FakeMojoService {
   }
 
   /** @override */
-  setHostDevice(deviceId) {
+  setHostDevice(hostInstanceIdOrLegacyDeviceId) {
     if (this.shouldSetHostSucceed) {
       console.log(
-          'setHostDevice(' + deviceId + ') called; simulating ' +
+          'setHostDevice(' + hostInstanceIdOrLegacyDeviceId +
+          ') called; simulating ' +
           'success.');
     } else {
       console.warn('setHostDevice() called; simulating failure.');

ui/webui/resources/cr_components/chromeos/multidevice_setup/multidevice_setup.html

@@ -89,7 +89,7 @@
         </template>
         <start-setup-page class="ui-page"
             devices="[[devices_]]"
-            selected-device-id="{{selectedDeviceId_}}"
+            selected-instance-id-or-legacy-device-id="{{selectedInstanceIdOrLegacyDeviceId_}}"
             delegate="[[delegate]]">
         </start-setup-page>
       </iron-pages>

ui/webui/resources/cr_components/chromeos/multidevice_setup/multidevice_setup.js

@@ -96,14 +96,18 @@ cr.define('multidevice_setup', function() {
       devices_: Array,
 
       /**
-       * Unique identifier for the currently selected host device.
+       * Unique identifier for the currently selected host device. This uses the
+       * device's Instance ID if it is available; otherwise, the device's legacy
+       * device ID is used.
+       * TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only
+       * use Instance ID since all devices are guaranteed to have one.
        *
        * Undefined if the no list of potential hosts has been received from mojo
        * service.
        *
        * @private {string|undefined}
        */
-      selectedDeviceId_: String,
+      selectedInstanceIdOrLegacyDeviceId_: String,
 
       /**
        * Whether the password page reports that the forward button should be
@@ -261,11 +265,14 @@ cr.define('multidevice_setup', function() {
       // An authentication token must be set if a password is required.
       assert(this.delegate.isPasswordRequiredToSetHost() === !!this.authToken_);
 
-      const deviceId = /** @type {string} */ (this.selectedDeviceId_);
-      this.delegate.setHostDevice(deviceId, this.authToken_)
+      const instanceIdOrLegacyDeviceId =
+          /** @type {string} */ (this.selectedInstanceIdOrLegacyDeviceId_);
+      this.delegate.setHostDevice(instanceIdOrLegacyDeviceId, this.authToken_)
           .then((responseParams) => {
             if (!responseParams.success) {
-              console.warn('Failure setting host with device ID: ' + deviceId);
+              console.warn(
+                  'Failure setting host with ID: ' +
+                  instanceIdOrLegacyDeviceId);
               return;
             }
 

ui/webui/resources/cr_components/chromeos/multidevice_setup/multidevice_setup_delegate.js

@@ -13,12 +13,14 @@ cr.define('multidevice_setup', function() {
     isPasswordRequiredToSetHost() {}
 
     /**
-     * @param {string} hostDeviceId The ID of the host to set.
+     * @param {string} hostInstanceIdOrLegacyDeviceId The ID of the host to set.
      * @param {string=} opt_authToken An auth token to authenticate the request;
      *     only necessary if isPasswordRequiredToSetHost() returns true.
      * @return {!Promise<{success: boolean}>}
+     * TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only
+     * use Instance ID since all devices are guaranteed to have one.
      */
-    setHostDevice(hostDeviceId, opt_authToken) {}
+    setHostDevice(hostInstanceIdOrLegacyDeviceId, opt_authToken) {}
 
     /** @return {boolean} */
     shouldExitSetupFlowAfterSettingHost() {}

ui/webui/resources/cr_components/chromeos/multidevice_setup/start_setup_page.html

@@ -124,7 +124,7 @@
                 <template is="dom-repeat" items="[[devices]]">
                   <option
                       class$="[[getDeviceOptionClass_(item.connectivityStatus)]]"
-                      value$="[[item.remoteDevice.deviceId]]">
+                      value$="[[getInstanceIdOrLegacyDeviceId_(item)]]">
                     [[getDeviceNameWithConnectivityStatus_(item)]]
                   </option>
                 </template>

ui/webui/resources/cr_components/chromeos/multidevice_setup/start_setup_page.js

@@ -30,14 +30,18 @@ Polymer({
     },
 
     /**
-     * Unique identifier for the currently selected host device.
+     * Unique identifier for the currently selected host device. This uses the
+     * device's Instance ID if it is available; otherwise, the device's legacy
+     * device ID is used.
+     * TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only
+     * use Instance ID since all devices are guaranteed to have one.
      *
      * Undefined if the no list of potential hosts has been received from mojo
      * service.
      *
      * @type {string|undefined}
      */
-    selectedDeviceId: {
+    selectedInstanceIdOrLegacyDeviceId: {
       type: String,
       notify: true,
     },
@@ -155,16 +159,34 @@ Polymer({
         device.remoteDevice.deviceName;
   },
 
+  /**
+   * @param {!chromeos.multideviceSetup.mojom.HostDevice} device
+   * @return {string} Returns a unique identifier for the input device, using
+   *     the device's Instance ID if it is available; otherwise, the device's
+   *     legacy device ID is used.
+   *     TODO(https://crbug.com/1019206): When v1 DeviceSync is turned off, only
+   *     use Instance ID since all devices are guaranteed to have one.
+   * @private
+   */
+  getInstanceIdOrLegacyDeviceId_(device) {
+    if (device.remoteDevice.instanceId) {
+      return device.remoteDevice.instanceId;
+    }
+
+    return device.remoteDevice.deviceId;
+  },
+
   /** @private */
   devicesChanged_() {
     if (this.devices.length > 0) {
-      this.selectedDeviceId = this.devices[0].remoteDevice.deviceId;
+      this.selectedInstanceIdOrLegacyDeviceId =
+          this.getInstanceIdOrLegacyDeviceId_(this.devices[0]);
     }
   },
 
   /** @private */
   onDeviceDropdownSelectionChanged_() {
-    this.selectedDeviceId = this.$.deviceDropdown.value;
+    this.selectedInstanceIdOrLegacyDeviceId = this.$.deviceDropdown.value;
   },
 
   /**