multidevice_setup_impl_unittest.cc 63 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471
  1. // Copyright 2018 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include <algorithm>
  5. #include <memory>
  6. #include <vector>
  7. #include "ash/components/multidevice/remote_device_test_util.h"
  8. #include "ash/constants/ash_features.h"
  9. #include "ash/services/device_sync/public/cpp/fake_device_sync_client.h"
  10. #include "ash/services/device_sync/public/cpp/fake_gcm_device_info_provider.h"
  11. #include "ash/services/multidevice_setup/account_status_change_delegate_notifier_impl.h"
  12. #include "ash/services/multidevice_setup/android_sms_app_installing_status_observer.h"
  13. #include "ash/services/multidevice_setup/eligible_host_devices_provider_impl.h"
  14. #include "ash/services/multidevice_setup/fake_account_status_change_delegate.h"
  15. #include "ash/services/multidevice_setup/fake_account_status_change_delegate_notifier.h"
  16. #include "ash/services/multidevice_setup/fake_eligible_host_devices_provider.h"
  17. #include "ash/services/multidevice_setup/fake_feature_state_manager.h"
  18. #include "ash/services/multidevice_setup/fake_feature_state_observer.h"
  19. #include "ash/services/multidevice_setup/fake_global_state_feature_manager.h"
  20. #include "ash/services/multidevice_setup/fake_host_backend_delegate.h"
  21. #include "ash/services/multidevice_setup/fake_host_device_timestamp_manager.h"
  22. #include "ash/services/multidevice_setup/fake_host_status_observer.h"
  23. #include "ash/services/multidevice_setup/fake_host_status_provider.h"
  24. #include "ash/services/multidevice_setup/fake_host_verifier.h"
  25. #include "ash/services/multidevice_setup/feature_state_manager_impl.h"
  26. #include "ash/services/multidevice_setup/global_state_feature_manager.h"
  27. #include "ash/services/multidevice_setup/global_state_feature_manager_impl.h"
  28. #include "ash/services/multidevice_setup/grandfathered_easy_unlock_host_disabler.h"
  29. #include "ash/services/multidevice_setup/host_backend_delegate_impl.h"
  30. #include "ash/services/multidevice_setup/host_device_timestamp_manager_impl.h"
  31. #include "ash/services/multidevice_setup/host_status_provider_impl.h"
  32. #include "ash/services/multidevice_setup/host_verifier_impl.h"
  33. #include "ash/services/multidevice_setup/multidevice_setup_impl.h"
  34. #include "ash/services/multidevice_setup/public/cpp/fake_android_sms_app_helper_delegate.h"
  35. #include "ash/services/multidevice_setup/public/cpp/fake_android_sms_pairing_state_tracker.h"
  36. #include "ash/services/multidevice_setup/public/cpp/fake_auth_token_validator.h"
  37. #include "ash/services/multidevice_setup/public/cpp/oobe_completion_tracker.h"
  38. #include "ash/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
  39. #include "ash/services/multidevice_setup/wifi_sync_notification_controller.h"
  40. #include "base/bind.h"
  41. #include "base/containers/flat_map.h"
  42. #include "base/run_loop.h"
  43. #include "base/test/scoped_feature_list.h"
  44. #include "base/test/task_environment.h"
  45. #include "components/sync_preferences/testing_pref_service_syncable.h"
  46. #include "testing/gtest/include/gtest/gtest.h"
  47. namespace ash {
  48. namespace multidevice_setup {
  49. namespace {
  50. const size_t kNumTestDevices = 3;
  51. const char kValidAuthToken[] = "validAuthToken";
  52. multidevice::RemoteDeviceList RefListToRawList(
  53. const multidevice::RemoteDeviceRefList& ref_list) {
  54. multidevice::RemoteDeviceList raw_list;
  55. std::transform(ref_list.begin(), ref_list.end(), std::back_inserter(raw_list),
  56. [](const multidevice::RemoteDeviceRef ref) {
  57. return *GetMutableRemoteDevice(ref);
  58. });
  59. return raw_list;
  60. }
  61. absl::optional<multidevice::RemoteDevice> RefToRaw(
  62. const absl::optional<multidevice::RemoteDeviceRef>& ref) {
  63. if (!ref)
  64. return absl::nullopt;
  65. return *GetMutableRemoteDevice(*ref);
  66. }
  67. class FakeEligibleHostDevicesProviderFactory
  68. : public EligibleHostDevicesProviderImpl::Factory {
  69. public:
  70. explicit FakeEligibleHostDevicesProviderFactory(
  71. device_sync::FakeDeviceSyncClient* expected_device_sync_client)
  72. : expected_device_sync_client_(expected_device_sync_client) {}
  73. FakeEligibleHostDevicesProviderFactory(
  74. const FakeEligibleHostDevicesProviderFactory&) = delete;
  75. FakeEligibleHostDevicesProviderFactory& operator=(
  76. const FakeEligibleHostDevicesProviderFactory&) = delete;
  77. ~FakeEligibleHostDevicesProviderFactory() override = default;
  78. FakeEligibleHostDevicesProvider* instance() { return instance_; }
  79. private:
  80. // EligibleHostDevicesProviderImpl::Factory:
  81. std::unique_ptr<EligibleHostDevicesProvider> CreateInstance(
  82. device_sync::DeviceSyncClient* device_sync_client) override {
  83. EXPECT_FALSE(instance_);
  84. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  85. auto instance = std::make_unique<FakeEligibleHostDevicesProvider>();
  86. instance_ = instance.get();
  87. return instance;
  88. }
  89. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  90. FakeEligibleHostDevicesProvider* instance_ = nullptr;
  91. };
  92. class FakeHostBackendDelegateFactory : public HostBackendDelegateImpl::Factory {
  93. public:
  94. FakeHostBackendDelegateFactory(
  95. FakeEligibleHostDevicesProviderFactory*
  96. fake_eligible_host_devices_provider_factory,
  97. sync_preferences::TestingPrefServiceSyncable*
  98. expected_testing_pref_service,
  99. device_sync::FakeDeviceSyncClient* expected_device_sync_client)
  100. : fake_eligible_host_devices_provider_factory_(
  101. fake_eligible_host_devices_provider_factory),
  102. expected_testing_pref_service_(expected_testing_pref_service),
  103. expected_device_sync_client_(expected_device_sync_client) {}
  104. FakeHostBackendDelegateFactory(const FakeHostBackendDelegateFactory&) =
  105. delete;
  106. FakeHostBackendDelegateFactory& operator=(
  107. const FakeHostBackendDelegateFactory&) = delete;
  108. ~FakeHostBackendDelegateFactory() override = default;
  109. FakeHostBackendDelegate* instance() { return instance_; }
  110. private:
  111. // HostBackendDelegateImpl::Factory:
  112. std::unique_ptr<HostBackendDelegate> CreateInstance(
  113. EligibleHostDevicesProvider* eligible_host_devices_provider,
  114. PrefService* pref_service,
  115. device_sync::DeviceSyncClient* device_sync_client,
  116. std::unique_ptr<base::OneShotTimer> timer) override {
  117. EXPECT_FALSE(instance_);
  118. EXPECT_EQ(fake_eligible_host_devices_provider_factory_->instance(),
  119. eligible_host_devices_provider);
  120. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  121. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  122. auto instance = std::make_unique<FakeHostBackendDelegate>();
  123. instance_ = instance.get();
  124. return instance;
  125. }
  126. FakeEligibleHostDevicesProviderFactory*
  127. fake_eligible_host_devices_provider_factory_;
  128. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  129. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  130. FakeHostBackendDelegate* instance_ = nullptr;
  131. };
  132. class FakeHostVerifierFactory : public HostVerifierImpl::Factory {
  133. public:
  134. FakeHostVerifierFactory(
  135. FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory,
  136. device_sync::FakeDeviceSyncClient* expected_device_sync_client,
  137. sync_preferences::TestingPrefServiceSyncable*
  138. expected_testing_pref_service)
  139. : fake_host_backend_delegate_factory_(fake_host_backend_delegate_factory),
  140. expected_device_sync_client_(expected_device_sync_client),
  141. expected_testing_pref_service_(expected_testing_pref_service) {}
  142. FakeHostVerifierFactory(const FakeHostVerifierFactory&) = delete;
  143. FakeHostVerifierFactory& operator=(const FakeHostVerifierFactory&) = delete;
  144. ~FakeHostVerifierFactory() override = default;
  145. FakeHostVerifier* instance() { return instance_; }
  146. private:
  147. // HostVerifierImpl::Factory:
  148. std::unique_ptr<HostVerifier> CreateInstance(
  149. HostBackendDelegate* host_backend_delegate,
  150. device_sync::DeviceSyncClient* device_sync_client,
  151. PrefService* pref_service,
  152. base::Clock* clock,
  153. std::unique_ptr<base::OneShotTimer> retry_timer,
  154. std::unique_ptr<base::OneShotTimer> sync_timer) override {
  155. EXPECT_FALSE(instance_);
  156. EXPECT_EQ(fake_host_backend_delegate_factory_->instance(),
  157. host_backend_delegate);
  158. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  159. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  160. auto instance = std::make_unique<FakeHostVerifier>();
  161. instance_ = instance.get();
  162. return instance;
  163. }
  164. FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory_;
  165. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  166. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  167. FakeHostVerifier* instance_ = nullptr;
  168. };
  169. class FakeHostStatusProviderFactory : public HostStatusProviderImpl::Factory {
  170. public:
  171. FakeHostStatusProviderFactory(
  172. FakeEligibleHostDevicesProviderFactory*
  173. fake_eligible_host_devices_provider_factory,
  174. FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory,
  175. FakeHostVerifierFactory* fake_host_verifier_factory,
  176. device_sync::FakeDeviceSyncClient* expected_device_sync_client)
  177. : fake_eligible_host_devices_provider_factory_(
  178. fake_eligible_host_devices_provider_factory),
  179. fake_host_backend_delegate_factory_(fake_host_backend_delegate_factory),
  180. fake_host_verifier_factory_(fake_host_verifier_factory),
  181. expected_device_sync_client_(expected_device_sync_client) {}
  182. FakeHostStatusProviderFactory(const FakeHostStatusProviderFactory&) = delete;
  183. FakeHostStatusProviderFactory& operator=(
  184. const FakeHostStatusProviderFactory&) = delete;
  185. ~FakeHostStatusProviderFactory() override = default;
  186. FakeHostStatusProvider* instance() { return instance_; }
  187. private:
  188. // HostStatusProviderImpl::Factory:
  189. std::unique_ptr<HostStatusProvider> CreateInstance(
  190. EligibleHostDevicesProvider* eligible_host_devices_provider,
  191. HostBackendDelegate* host_backend_delegate,
  192. HostVerifier* host_verifier,
  193. device_sync::DeviceSyncClient* device_sync_client) override {
  194. EXPECT_FALSE(instance_);
  195. EXPECT_EQ(fake_eligible_host_devices_provider_factory_->instance(),
  196. eligible_host_devices_provider);
  197. EXPECT_EQ(fake_host_backend_delegate_factory_->instance(),
  198. host_backend_delegate);
  199. EXPECT_EQ(fake_host_verifier_factory_->instance(), host_verifier);
  200. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  201. auto instance = std::make_unique<FakeHostStatusProvider>();
  202. instance_ = instance.get();
  203. return instance;
  204. }
  205. FakeEligibleHostDevicesProviderFactory*
  206. fake_eligible_host_devices_provider_factory_;
  207. FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory_;
  208. FakeHostVerifierFactory* fake_host_verifier_factory_;
  209. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  210. FakeHostStatusProvider* instance_ = nullptr;
  211. };
  212. class FakeGlobalStateFeatureManagerFactory
  213. : public GlobalStateFeatureManagerImpl::Factory {
  214. public:
  215. FakeGlobalStateFeatureManagerFactory(
  216. FakeHostStatusProviderFactory* fake_host_status_provider_factory,
  217. sync_preferences::TestingPrefServiceSyncable*
  218. expected_testing_pref_service,
  219. device_sync::FakeDeviceSyncClient* expected_device_sync_client)
  220. : fake_host_status_provider_factory_(fake_host_status_provider_factory),
  221. expected_testing_pref_service_(expected_testing_pref_service),
  222. expected_device_sync_client_(expected_device_sync_client) {}
  223. FakeGlobalStateFeatureManagerFactory(
  224. const FakeGlobalStateFeatureManagerFactory&) = delete;
  225. FakeGlobalStateFeatureManagerFactory& operator=(
  226. const FakeGlobalStateFeatureManagerFactory&) = delete;
  227. ~FakeGlobalStateFeatureManagerFactory() override = default;
  228. private:
  229. // GlobalStateFeatureManagerImpl::Factory:
  230. std::unique_ptr<GlobalStateFeatureManager> CreateInstance(
  231. GlobalStateFeatureManagerImpl::Factory::Option option,
  232. HostStatusProvider* host_status_provider,
  233. PrefService* pref_service,
  234. device_sync::DeviceSyncClient* device_sync_client,
  235. std::unique_ptr<base::OneShotTimer> timer) override {
  236. EXPECT_EQ(fake_host_status_provider_factory_->instance(),
  237. host_status_provider);
  238. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  239. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  240. return std::make_unique<FakeGlobalStateFeatureManager>();
  241. }
  242. FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
  243. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  244. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  245. };
  246. class FakeWifiSyncNotificationControllerFactory
  247. : public WifiSyncNotificationController::Factory {
  248. public:
  249. FakeWifiSyncNotificationControllerFactory(
  250. FakeHostStatusProviderFactory* fake_host_status_provider_factory,
  251. sync_preferences::TestingPrefServiceSyncable*
  252. expected_testing_pref_service,
  253. device_sync::FakeDeviceSyncClient* expected_device_sync_client)
  254. : fake_host_status_provider_factory_(fake_host_status_provider_factory),
  255. expected_testing_pref_service_(expected_testing_pref_service),
  256. expected_device_sync_client_(expected_device_sync_client) {}
  257. FakeWifiSyncNotificationControllerFactory(
  258. const FakeWifiSyncNotificationControllerFactory&) = delete;
  259. FakeWifiSyncNotificationControllerFactory& operator=(
  260. const FakeWifiSyncNotificationControllerFactory&) = delete;
  261. ~FakeWifiSyncNotificationControllerFactory() override = default;
  262. private:
  263. // WifiSyncNotificationController::Factory:
  264. std::unique_ptr<WifiSyncNotificationController> CreateInstance(
  265. GlobalStateFeatureManager* wifi_sync_feature_manager,
  266. HostStatusProvider* host_status_provider,
  267. PrefService* pref_service,
  268. device_sync::DeviceSyncClient* device_sync_client,
  269. AccountStatusChangeDelegateNotifier* delegate_notifier) override {
  270. EXPECT_EQ(fake_host_status_provider_factory_->instance(),
  271. host_status_provider);
  272. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  273. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  274. // Only check inputs and return nullptr. We do not want to trigger any logic
  275. // in these unit tests.
  276. return nullptr;
  277. }
  278. FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
  279. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  280. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  281. };
  282. class FakeGrandfatheredEasyUnlockHostDisablerFactory
  283. : public GrandfatheredEasyUnlockHostDisabler::Factory {
  284. public:
  285. FakeGrandfatheredEasyUnlockHostDisablerFactory(
  286. FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory,
  287. device_sync::FakeDeviceSyncClient* expected_device_sync_client,
  288. sync_preferences::TestingPrefServiceSyncable*
  289. expected_testing_pref_service)
  290. : fake_host_backend_delegate_factory_(fake_host_backend_delegate_factory),
  291. expected_device_sync_client_(expected_device_sync_client),
  292. expected_testing_pref_service_(expected_testing_pref_service) {}
  293. FakeGrandfatheredEasyUnlockHostDisablerFactory(
  294. const FakeGrandfatheredEasyUnlockHostDisablerFactory&) = delete;
  295. FakeGrandfatheredEasyUnlockHostDisablerFactory& operator=(
  296. const FakeGrandfatheredEasyUnlockHostDisablerFactory&) = delete;
  297. ~FakeGrandfatheredEasyUnlockHostDisablerFactory() override = default;
  298. private:
  299. // GrandfatheredEasyUnlockHostDisabler::Factory:
  300. std::unique_ptr<GrandfatheredEasyUnlockHostDisabler> CreateInstance(
  301. HostBackendDelegate* host_backend_delegate,
  302. device_sync::DeviceSyncClient* device_sync_client,
  303. PrefService* pref_service,
  304. std::unique_ptr<base::OneShotTimer> timer) override {
  305. EXPECT_EQ(fake_host_backend_delegate_factory_->instance(),
  306. host_backend_delegate);
  307. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  308. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  309. // Only check inputs and return nullptr. We do not want to trigger any logic
  310. // in these unit tests.
  311. return nullptr;
  312. }
  313. FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory_;
  314. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  315. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  316. };
  317. class FakeFeatureStateManagerFactory : public FeatureStateManagerImpl::Factory {
  318. public:
  319. FakeFeatureStateManagerFactory(
  320. sync_preferences::TestingPrefServiceSyncable*
  321. expected_testing_pref_service,
  322. FakeHostStatusProviderFactory* fake_host_status_provider_factory,
  323. device_sync::FakeDeviceSyncClient* expected_device_sync_client,
  324. FakeAndroidSmsPairingStateTracker*
  325. expected_android_sms_pairing_state_tracker,
  326. bool expected_is_secondary_user)
  327. : expected_testing_pref_service_(expected_testing_pref_service),
  328. fake_host_status_provider_factory_(fake_host_status_provider_factory),
  329. expected_device_sync_client_(expected_device_sync_client),
  330. expected_android_sms_pairing_state_tracker_(
  331. expected_android_sms_pairing_state_tracker),
  332. expected_is_secondary_user_(expected_is_secondary_user) {}
  333. FakeFeatureStateManagerFactory(const FakeFeatureStateManagerFactory&) =
  334. delete;
  335. FakeFeatureStateManagerFactory& operator=(
  336. const FakeFeatureStateManagerFactory&) = delete;
  337. ~FakeFeatureStateManagerFactory() override = default;
  338. FakeFeatureStateManager* instance() { return instance_; }
  339. private:
  340. // FeatureStateManagerImpl::Factory:
  341. std::unique_ptr<FeatureStateManager> CreateInstance(
  342. PrefService* pref_service,
  343. HostStatusProvider* host_status_provider,
  344. device_sync::DeviceSyncClient* device_sync_client,
  345. AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
  346. const base::flat_map<mojom::Feature, GlobalStateFeatureManager*>&
  347. global_state_feature_managers,
  348. bool is_secondary_user) override {
  349. EXPECT_FALSE(instance_);
  350. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  351. EXPECT_EQ(fake_host_status_provider_factory_->instance(),
  352. host_status_provider);
  353. EXPECT_EQ(expected_device_sync_client_, device_sync_client);
  354. EXPECT_EQ(expected_android_sms_pairing_state_tracker_,
  355. android_sms_pairing_state_tracker);
  356. EXPECT_EQ(expected_is_secondary_user_, is_secondary_user);
  357. auto instance = std::make_unique<FakeFeatureStateManager>();
  358. instance_ = instance.get();
  359. return instance;
  360. }
  361. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  362. FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
  363. device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
  364. FakeAndroidSmsPairingStateTracker*
  365. expected_android_sms_pairing_state_tracker_;
  366. bool expected_is_secondary_user_;
  367. FakeFeatureStateManager* instance_ = nullptr;
  368. };
  369. class FakeHostDeviceTimestampManagerFactory
  370. : public HostDeviceTimestampManagerImpl::Factory {
  371. public:
  372. FakeHostDeviceTimestampManagerFactory(
  373. FakeHostStatusProviderFactory* fake_host_status_provider_factory,
  374. sync_preferences::TestingPrefServiceSyncable*
  375. expected_testing_pref_service)
  376. : fake_host_status_provider_factory_(fake_host_status_provider_factory),
  377. expected_testing_pref_service_(expected_testing_pref_service) {}
  378. FakeHostDeviceTimestampManagerFactory(
  379. const FakeHostDeviceTimestampManagerFactory&) = delete;
  380. FakeHostDeviceTimestampManagerFactory& operator=(
  381. const FakeHostDeviceTimestampManagerFactory&) = delete;
  382. ~FakeHostDeviceTimestampManagerFactory() override = default;
  383. FakeHostDeviceTimestampManager* instance() { return instance_; }
  384. private:
  385. // HostDeviceTimestampManagerImpl::Factory:
  386. std::unique_ptr<HostDeviceTimestampManager> CreateInstance(
  387. HostStatusProvider* host_status_provider,
  388. PrefService* pref_service,
  389. base::Clock* clock) override {
  390. EXPECT_FALSE(instance_);
  391. EXPECT_EQ(fake_host_status_provider_factory_->instance(),
  392. host_status_provider);
  393. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  394. auto instance = std::make_unique<FakeHostDeviceTimestampManager>();
  395. instance_ = instance.get();
  396. return instance;
  397. }
  398. FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
  399. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  400. FakeHostDeviceTimestampManager* instance_ = nullptr;
  401. };
  402. class FakeAccountStatusChangeDelegateNotifierFactory
  403. : public AccountStatusChangeDelegateNotifierImpl::Factory {
  404. public:
  405. FakeAccountStatusChangeDelegateNotifierFactory(
  406. FakeHostStatusProviderFactory* fake_host_status_provider_factory,
  407. sync_preferences::TestingPrefServiceSyncable*
  408. expected_testing_pref_service,
  409. FakeHostDeviceTimestampManagerFactory*
  410. fake_host_device_timestamp_manager_factory,
  411. OobeCompletionTracker* expected_oobe_completion_tracker)
  412. : fake_host_status_provider_factory_(fake_host_status_provider_factory),
  413. expected_testing_pref_service_(expected_testing_pref_service),
  414. fake_host_device_timestamp_manager_factory_(
  415. fake_host_device_timestamp_manager_factory),
  416. expected_oobe_completion_tracker_(expected_oobe_completion_tracker) {}
  417. FakeAccountStatusChangeDelegateNotifierFactory(
  418. const FakeAccountStatusChangeDelegateNotifierFactory&) = delete;
  419. FakeAccountStatusChangeDelegateNotifierFactory& operator=(
  420. const FakeAccountStatusChangeDelegateNotifierFactory&) = delete;
  421. ~FakeAccountStatusChangeDelegateNotifierFactory() override = default;
  422. FakeAccountStatusChangeDelegateNotifier* instance() { return instance_; }
  423. private:
  424. // AccountStatusChangeDelegateNotifierImpl::Factory:
  425. std::unique_ptr<AccountStatusChangeDelegateNotifier> CreateInstance(
  426. HostStatusProvider* host_status_provider,
  427. PrefService* pref_service,
  428. HostDeviceTimestampManager* host_device_timestamp_manager,
  429. OobeCompletionTracker* oobe_completion_tracker,
  430. base::Clock* clock) override {
  431. EXPECT_FALSE(instance_);
  432. EXPECT_EQ(fake_host_status_provider_factory_->instance(),
  433. host_status_provider);
  434. EXPECT_EQ(expected_testing_pref_service_, pref_service);
  435. EXPECT_EQ(fake_host_device_timestamp_manager_factory_->instance(),
  436. host_device_timestamp_manager);
  437. EXPECT_EQ(expected_oobe_completion_tracker_, oobe_completion_tracker);
  438. auto instance = std::make_unique<FakeAccountStatusChangeDelegateNotifier>();
  439. instance_ = instance.get();
  440. return instance;
  441. }
  442. FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
  443. sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
  444. FakeHostDeviceTimestampManagerFactory*
  445. fake_host_device_timestamp_manager_factory_;
  446. OobeCompletionTracker* expected_oobe_completion_tracker_;
  447. FakeAccountStatusChangeDelegateNotifier* instance_ = nullptr;
  448. };
  449. class FakeAndroidSmsAppInstallingStatusObserverFactory
  450. : public AndroidSmsAppInstallingStatusObserver::Factory {
  451. public:
  452. FakeAndroidSmsAppInstallingStatusObserverFactory(
  453. FakeHostStatusProviderFactory* fake_host_status_provider_factory,
  454. FakeFeatureStateManagerFactory* fake_feature_state_manager_factory,
  455. AndroidSmsAppHelperDelegate* expected_android_sms_app_helper_delegate)
  456. : fake_host_status_provider_factory_(fake_host_status_provider_factory),
  457. fake_feature_state_manager_factory_(fake_feature_state_manager_factory),
  458. expected_android_sms_app_helper_delegate_(
  459. expected_android_sms_app_helper_delegate) {}
  460. FakeAndroidSmsAppInstallingStatusObserverFactory(
  461. const FakeAndroidSmsAppInstallingStatusObserverFactory&) = delete;
  462. FakeAndroidSmsAppInstallingStatusObserverFactory& operator=(
  463. const FakeAndroidSmsAppInstallingStatusObserverFactory&) = delete;
  464. ~FakeAndroidSmsAppInstallingStatusObserverFactory() override = default;
  465. private:
  466. // AndroidSmsAppInstallingStatusObserver::Factory:
  467. std::unique_ptr<AndroidSmsAppInstallingStatusObserver> CreateInstance(
  468. HostStatusProvider* host_status_provider,
  469. FeatureStateManager* feature_state_manager,
  470. AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate) override {
  471. EXPECT_EQ(fake_host_status_provider_factory_->instance(),
  472. host_status_provider);
  473. EXPECT_EQ(fake_feature_state_manager_factory_->instance(),
  474. feature_state_manager);
  475. EXPECT_EQ(expected_android_sms_app_helper_delegate_,
  476. android_sms_app_helper_delegate);
  477. // Only check inputs and return nullptr. We do not want to trigger the
  478. // AndroidSmsAppInstallingStatusObserver logic in these unit tests.
  479. return nullptr;
  480. }
  481. FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
  482. FakeFeatureStateManagerFactory* fake_feature_state_manager_factory_;
  483. AndroidSmsAppHelperDelegate* expected_android_sms_app_helper_delegate_;
  484. };
  485. } // namespace
  486. class MultiDeviceSetupImplTest : public ::testing::TestWithParam<bool> {
  487. public:
  488. MultiDeviceSetupImplTest(const MultiDeviceSetupImplTest&) = delete;
  489. MultiDeviceSetupImplTest& operator=(const MultiDeviceSetupImplTest&) = delete;
  490. protected:
  491. MultiDeviceSetupImplTest()
  492. : test_devices_(
  493. multidevice::CreateRemoteDeviceRefListForTest(kNumTestDevices)) {}
  494. ~MultiDeviceSetupImplTest() override = default;
  495. void SetUp() override {
  496. SetDeviceSyncFeatureFlags(IsV1DeviceSyncEnabled());
  497. test_pref_service_ =
  498. std::make_unique<sync_preferences::TestingPrefServiceSyncable>();
  499. fake_device_sync_client_ =
  500. std::make_unique<device_sync::FakeDeviceSyncClient>();
  501. fake_auth_token_validator_ = std::make_unique<FakeAuthTokenValidator>();
  502. fake_auth_token_validator_->set_expected_auth_token(kValidAuthToken);
  503. fake_oobe_completion_tracker_ = std::make_unique<OobeCompletionTracker>();
  504. fake_android_sms_app_helper_delegate_ =
  505. std::make_unique<FakeAndroidSmsAppHelperDelegate>();
  506. fake_android_sms_pairing_state_tracker_ =
  507. std::make_unique<FakeAndroidSmsPairingStateTracker>();
  508. fake_gcm_device_info_provider_ =
  509. std::make_unique<device_sync::FakeGcmDeviceInfoProvider>(
  510. cryptauth::GcmDeviceInfo());
  511. fake_eligible_host_devices_provider_factory_ =
  512. std::make_unique<FakeEligibleHostDevicesProviderFactory>(
  513. fake_device_sync_client_.get());
  514. EligibleHostDevicesProviderImpl::Factory::SetFactoryForTesting(
  515. fake_eligible_host_devices_provider_factory_.get());
  516. fake_host_backend_delegate_factory_ =
  517. std::make_unique<FakeHostBackendDelegateFactory>(
  518. fake_eligible_host_devices_provider_factory_.get(),
  519. test_pref_service_.get(), fake_device_sync_client_.get());
  520. HostBackendDelegateImpl::Factory::SetFactoryForTesting(
  521. fake_host_backend_delegate_factory_.get());
  522. fake_host_verifier_factory_ = std::make_unique<FakeHostVerifierFactory>(
  523. fake_host_backend_delegate_factory_.get(),
  524. fake_device_sync_client_.get(), test_pref_service_.get());
  525. HostVerifierImpl::Factory::SetFactoryForTesting(
  526. fake_host_verifier_factory_.get());
  527. fake_host_status_provider_factory_ =
  528. std::make_unique<FakeHostStatusProviderFactory>(
  529. fake_eligible_host_devices_provider_factory_.get(),
  530. fake_host_backend_delegate_factory_.get(),
  531. fake_host_verifier_factory_.get(), fake_device_sync_client_.get());
  532. HostStatusProviderImpl::Factory::SetFactoryForTesting(
  533. fake_host_status_provider_factory_.get());
  534. fake_global_state_feature_manager_factory_ =
  535. std::make_unique<FakeGlobalStateFeatureManagerFactory>(
  536. fake_host_status_provider_factory_.get(), test_pref_service_.get(),
  537. fake_device_sync_client_.get());
  538. GlobalStateFeatureManagerImpl::Factory::SetFactoryForTesting(
  539. fake_global_state_feature_manager_factory_.get());
  540. fake_wifi_sync_notification_controller_factory_ =
  541. std::make_unique<FakeWifiSyncNotificationControllerFactory>(
  542. fake_host_status_provider_factory_.get(), test_pref_service_.get(),
  543. fake_device_sync_client_.get());
  544. WifiSyncNotificationController::Factory::SetFactoryForTesting(
  545. fake_wifi_sync_notification_controller_factory_.get());
  546. fake_grandfathered_easy_unlock_host_disabler_factory_ =
  547. std::make_unique<FakeGrandfatheredEasyUnlockHostDisablerFactory>(
  548. fake_host_backend_delegate_factory_.get(),
  549. fake_device_sync_client_.get(), test_pref_service_.get());
  550. GrandfatheredEasyUnlockHostDisabler::Factory::SetFactoryForTesting(
  551. fake_grandfathered_easy_unlock_host_disabler_factory_.get());
  552. fake_feature_state_manager_factory_ =
  553. std::make_unique<FakeFeatureStateManagerFactory>(
  554. test_pref_service_.get(), fake_host_status_provider_factory_.get(),
  555. fake_device_sync_client_.get(),
  556. fake_android_sms_pairing_state_tracker_.get(), is_secondary_user_);
  557. FeatureStateManagerImpl::Factory::SetFactoryForTesting(
  558. fake_feature_state_manager_factory_.get());
  559. fake_host_device_timestamp_manager_factory_ =
  560. std::make_unique<FakeHostDeviceTimestampManagerFactory>(
  561. fake_host_status_provider_factory_.get(), test_pref_service_.get());
  562. HostDeviceTimestampManagerImpl::Factory::SetFactoryForTesting(
  563. fake_host_device_timestamp_manager_factory_.get());
  564. fake_account_status_change_delegate_notifier_factory_ =
  565. std::make_unique<FakeAccountStatusChangeDelegateNotifierFactory>(
  566. fake_host_status_provider_factory_.get(), test_pref_service_.get(),
  567. fake_host_device_timestamp_manager_factory_.get(),
  568. fake_oobe_completion_tracker_.get());
  569. AccountStatusChangeDelegateNotifierImpl::Factory::SetFactoryForTesting(
  570. fake_account_status_change_delegate_notifier_factory_.get());
  571. fake_android_sms_app_installing_status_observer_factory_ =
  572. std::make_unique<FakeAndroidSmsAppInstallingStatusObserverFactory>(
  573. fake_host_status_provider_factory_.get(),
  574. fake_feature_state_manager_factory_.get(),
  575. fake_android_sms_app_helper_delegate_.get());
  576. AndroidSmsAppInstallingStatusObserver::Factory::SetFactoryForTesting(
  577. fake_android_sms_app_installing_status_observer_factory_.get());
  578. multidevice_setup_ = MultiDeviceSetupImpl::Factory::Create(
  579. test_pref_service_.get(), fake_device_sync_client_.get(),
  580. fake_auth_token_validator_.get(), fake_oobe_completion_tracker_.get(),
  581. fake_android_sms_app_helper_delegate_.get(),
  582. fake_android_sms_pairing_state_tracker_.get(),
  583. fake_gcm_device_info_provider_.get(), is_secondary_user_);
  584. }
  585. void TearDown() override {
  586. EligibleHostDevicesProviderImpl::Factory::SetFactoryForTesting(nullptr);
  587. HostBackendDelegateImpl::Factory::SetFactoryForTesting(nullptr);
  588. HostVerifierImpl::Factory::SetFactoryForTesting(nullptr);
  589. HostStatusProviderImpl::Factory::SetFactoryForTesting(nullptr);
  590. GrandfatheredEasyUnlockHostDisabler::Factory::SetFactoryForTesting(nullptr);
  591. FeatureStateManagerImpl::Factory::SetFactoryForTesting(nullptr);
  592. HostDeviceTimestampManagerImpl::Factory::SetFactoryForTesting(nullptr);
  593. AccountStatusChangeDelegateNotifierImpl::Factory::SetFactoryForTesting(
  594. nullptr);
  595. AndroidSmsAppInstallingStatusObserver::Factory::SetFactoryForTesting(
  596. nullptr);
  597. GlobalStateFeatureManagerImpl::Factory::SetFactoryForTesting(nullptr);
  598. WifiSyncNotificationController::Factory::SetFactoryForTesting(nullptr);
  599. }
  600. bool IsV1DeviceSyncEnabled() { return GetParam(); }
  601. void CallSetAccountStatusChangeDelegate() {
  602. EXPECT_FALSE(fake_account_status_change_delegate_);
  603. fake_account_status_change_delegate_ =
  604. std::make_unique<FakeAccountStatusChangeDelegate>();
  605. EXPECT_FALSE(fake_account_status_change_delegate_notifier()->delegate());
  606. multidevice_setup_->SetAccountStatusChangeDelegate(
  607. fake_account_status_change_delegate_->GenerateRemote());
  608. EXPECT_TRUE(fake_account_status_change_delegate_notifier()->delegate());
  609. }
  610. multidevice::RemoteDeviceList CallGetEligibleHostDevices() {
  611. base::RunLoop run_loop;
  612. multidevice_setup_->GetEligibleHostDevices(
  613. base::BindOnce(&MultiDeviceSetupImplTest::OnEligibleDevicesFetched,
  614. base::Unretained(this), run_loop.QuitClosure()));
  615. run_loop.Run();
  616. multidevice::RemoteDeviceList eligible_devices_list =
  617. *last_eligible_devices_list_;
  618. last_eligible_devices_list_.reset();
  619. return eligible_devices_list;
  620. }
  621. std::vector<mojom::HostDevicePtr> CallGetEligibleActiveHostDevices() {
  622. base::RunLoop run_loop;
  623. multidevice_setup_->GetEligibleActiveHostDevices(base::BindOnce(
  624. &MultiDeviceSetupImplTest::OnEligibleActiveHostDevicesFetched,
  625. base::Unretained(this), run_loop.QuitClosure()));
  626. run_loop.Run();
  627. std::vector<mojom::HostDevicePtr> eligible_devices_list =
  628. std::move(*last_eligible_active_devices_list_);
  629. last_eligible_active_devices_list_.reset();
  630. return eligible_devices_list;
  631. }
  632. bool CallSetHostDevice(
  633. const std::string& host_instance_id_or_legacy_device_id,
  634. const std::string& auth_token) {
  635. base::RunLoop run_loop;
  636. multidevice_setup_->SetHostDevice(
  637. host_instance_id_or_legacy_device_id, auth_token,
  638. base::BindOnce(&MultiDeviceSetupImplTest::OnSetHostDeviceResult,
  639. base::Unretained(this), run_loop.QuitClosure()));
  640. run_loop.Run();
  641. bool success = *last_set_host_success_;
  642. last_set_host_success_.reset();
  643. return success;
  644. }
  645. bool CallSetHostDeviceWithoutAuth(
  646. const std::string& host_instance_id_or_legacy_device_id) {
  647. base::RunLoop run_loop;
  648. multidevice_setup_->SetHostDeviceWithoutAuthToken(
  649. host_instance_id_or_legacy_device_id,
  650. base::BindOnce(
  651. &MultiDeviceSetupImplTest::OnSetHostDeviceWithoutAuthResult,
  652. base::Unretained(this), run_loop.QuitClosure()));
  653. run_loop.Run();
  654. bool success = *last_set_host_without_auth_success_;
  655. last_set_host_without_auth_success_.reset();
  656. return success;
  657. }
  658. std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>
  659. CallGetHostStatus() {
  660. base::RunLoop run_loop;
  661. multidevice_setup_->GetHostStatus(
  662. base::BindOnce(&MultiDeviceSetupImplTest::OnHostStatusReceived,
  663. base::Unretained(this), run_loop.QuitClosure()));
  664. run_loop.Run();
  665. std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>
  666. host_status_update = *last_host_status_;
  667. last_host_status_.reset();
  668. return host_status_update;
  669. }
  670. bool CallSetFeatureEnabledState(
  671. mojom::Feature feature,
  672. bool enabled,
  673. const absl::optional<std::string>& auth_token) {
  674. base::RunLoop run_loop;
  675. multidevice_setup_->SetFeatureEnabledState(
  676. feature, enabled, auth_token,
  677. base::BindOnce(&MultiDeviceSetupImplTest::OnSetFeatureEnabled,
  678. base::Unretained(this), run_loop.QuitClosure()));
  679. run_loop.Run();
  680. bool success = *last_set_feature_enabled_state_success_;
  681. last_set_feature_enabled_state_success_.reset();
  682. return success;
  683. }
  684. base::flat_map<mojom::Feature, mojom::FeatureState> CallGetFeatureStates() {
  685. base::RunLoop run_loop;
  686. multidevice_setup_->GetFeatureStates(
  687. base::BindOnce(&MultiDeviceSetupImplTest::OnGetFeatureStates,
  688. base::Unretained(this), run_loop.QuitClosure()));
  689. run_loop.Run();
  690. base::flat_map<mojom::Feature, mojom::FeatureState> feature_states_map =
  691. *last_get_feature_states_result_;
  692. last_get_feature_states_result_.reset();
  693. return feature_states_map;
  694. }
  695. bool CallRetrySetHostNow() {
  696. base::RunLoop run_loop;
  697. multidevice_setup_->RetrySetHostNow(
  698. base::BindOnce(&MultiDeviceSetupImplTest::OnHostRetried,
  699. base::Unretained(this), run_loop.QuitClosure()));
  700. run_loop.Run();
  701. bool success = *last_retry_success_;
  702. last_retry_success_.reset();
  703. return success;
  704. }
  705. bool CallTriggerEventForDebugging(mojom::EventTypeForDebugging type) {
  706. base::RunLoop run_loop;
  707. multidevice_setup_->TriggerEventForDebugging(
  708. type, base::BindOnce(&MultiDeviceSetupImplTest::OnDebugEventTriggered,
  709. base::Unretained(this), run_loop.QuitClosure()));
  710. run_loop.Run();
  711. bool success = *last_debug_event_success_;
  712. last_debug_event_success_.reset();
  713. // If the delegate was set, fire off any pending Mojo messages.
  714. if (success)
  715. fake_account_status_change_delegate_notifier()->FlushForTesting();
  716. return success;
  717. }
  718. void VerifyCurrentHostStatus(
  719. mojom::HostStatus host_status,
  720. const absl::optional<multidevice::RemoteDeviceRef>& host_device,
  721. FakeHostStatusObserver* observer = nullptr,
  722. size_t expected_observer_index = 0u) {
  723. std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>
  724. host_status_and_device = CallGetHostStatus();
  725. EXPECT_EQ(host_status, host_status_and_device.first);
  726. EXPECT_EQ(RefToRaw(host_device), host_status_and_device.second);
  727. if (!observer)
  728. return;
  729. EXPECT_EQ(host_status,
  730. observer->host_status_updates()[expected_observer_index].first);
  731. EXPECT_EQ(RefToRaw(host_device),
  732. observer->host_status_updates()[expected_observer_index].second);
  733. }
  734. void SendPendingObserverMessages() {
  735. MultiDeviceSetupImpl* derived_ptr =
  736. static_cast<MultiDeviceSetupImpl*>(multidevice_setup_.get());
  737. derived_ptr->FlushForTesting();
  738. }
  739. FakeAccountStatusChangeDelegate* fake_account_status_change_delegate() {
  740. return fake_account_status_change_delegate_.get();
  741. }
  742. FakeEligibleHostDevicesProvider* fake_eligible_host_devices_provider() {
  743. return fake_eligible_host_devices_provider_factory_->instance();
  744. }
  745. FakeHostBackendDelegate* fake_host_backend_delegate() {
  746. return fake_host_backend_delegate_factory_->instance();
  747. }
  748. FakeHostVerifier* fake_host_verifier() {
  749. return fake_host_verifier_factory_->instance();
  750. }
  751. FakeHostStatusProvider* fake_host_status_provider() {
  752. return fake_host_status_provider_factory_->instance();
  753. }
  754. FakeFeatureStateManager* fake_feature_state_manager() {
  755. return fake_feature_state_manager_factory_->instance();
  756. }
  757. FakeHostDeviceTimestampManager* fake_host_device_timestamp_manager() {
  758. return fake_host_device_timestamp_manager_factory_->instance();
  759. }
  760. FakeAccountStatusChangeDelegateNotifier*
  761. fake_account_status_change_delegate_notifier() {
  762. return fake_account_status_change_delegate_notifier_factory_->instance();
  763. }
  764. multidevice::RemoteDeviceRefList& test_devices() { return test_devices_; }
  765. MultiDeviceSetupBase* multidevice_setup() { return multidevice_setup_.get(); }
  766. private:
  767. void SetDeviceSyncFeatureFlags(bool use_v1) {
  768. std::vector<base::Feature> enabled_features;
  769. std::vector<base::Feature> disabled_features;
  770. // These flags have no direct effect; however, v2 Enrollment and v2
  771. // DeviceSync are prerequisites for disabling v1 DeviceSync.
  772. enabled_features.push_back(chromeos::features::kCryptAuthV2Enrollment);
  773. enabled_features.push_back(chromeos::features::kCryptAuthV2DeviceSync);
  774. if (use_v1) {
  775. disabled_features.push_back(
  776. chromeos::features::kDisableCryptAuthV1DeviceSync);
  777. } else {
  778. enabled_features.push_back(
  779. chromeos::features::kDisableCryptAuthV1DeviceSync);
  780. }
  781. scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);
  782. }
  783. void OnEligibleDevicesFetched(
  784. base::OnceClosure quit_closure,
  785. const multidevice::RemoteDeviceList& eligible_devices_list) {
  786. EXPECT_FALSE(last_eligible_devices_list_);
  787. last_eligible_devices_list_ = eligible_devices_list;
  788. std::move(quit_closure).Run();
  789. }
  790. void OnEligibleActiveHostDevicesFetched(
  791. base::OnceClosure quit_closure,
  792. std::vector<mojom::HostDevicePtr> eligible_active_devices_list) {
  793. EXPECT_FALSE(last_eligible_active_devices_list_);
  794. last_eligible_active_devices_list_ =
  795. std::move(eligible_active_devices_list);
  796. std::move(quit_closure).Run();
  797. }
  798. void OnSetHostDeviceResult(base::OnceClosure quit_closure, bool success) {
  799. EXPECT_FALSE(last_set_host_success_);
  800. last_set_host_success_ = success;
  801. std::move(quit_closure).Run();
  802. }
  803. void OnSetHostDeviceWithoutAuthResult(base::OnceClosure quit_closure,
  804. bool success) {
  805. EXPECT_FALSE(last_set_host_without_auth_success_);
  806. last_set_host_without_auth_success_ = success;
  807. std::move(quit_closure).Run();
  808. }
  809. void OnHostStatusReceived(
  810. base::OnceClosure quit_closure,
  811. mojom::HostStatus host_status,
  812. const absl::optional<multidevice::RemoteDevice>& host_device) {
  813. EXPECT_FALSE(last_host_status_);
  814. last_host_status_ = std::make_pair(host_status, host_device);
  815. std::move(quit_closure).Run();
  816. }
  817. void OnSetFeatureEnabled(base::OnceClosure quit_closure, bool success) {
  818. EXPECT_FALSE(last_set_feature_enabled_state_success_);
  819. last_set_feature_enabled_state_success_ = success;
  820. std::move(quit_closure).Run();
  821. }
  822. void OnGetFeatureStates(
  823. base::OnceClosure quit_closure,
  824. const base::flat_map<mojom::Feature, mojom::FeatureState>&
  825. feature_states_map) {
  826. EXPECT_FALSE(last_get_feature_states_result_);
  827. last_get_feature_states_result_ = feature_states_map;
  828. std::move(quit_closure).Run();
  829. }
  830. void OnHostRetried(base::OnceClosure quit_closure, bool success) {
  831. EXPECT_FALSE(last_retry_success_);
  832. last_retry_success_ = success;
  833. std::move(quit_closure).Run();
  834. }
  835. void OnDebugEventTriggered(base::OnceClosure quit_closure, bool success) {
  836. EXPECT_FALSE(last_debug_event_success_);
  837. last_debug_event_success_ = success;
  838. std::move(quit_closure).Run();
  839. }
  840. base::test::TaskEnvironment task_environment_;
  841. multidevice::RemoteDeviceRefList test_devices_;
  842. std::unique_ptr<sync_preferences::TestingPrefServiceSyncable>
  843. test_pref_service_;
  844. std::unique_ptr<device_sync::FakeDeviceSyncClient> fake_device_sync_client_;
  845. std::unique_ptr<FakeAuthTokenValidator> fake_auth_token_validator_;
  846. std::unique_ptr<OobeCompletionTracker> fake_oobe_completion_tracker_;
  847. std::unique_ptr<device_sync::FakeGcmDeviceInfoProvider>
  848. fake_gcm_device_info_provider_;
  849. bool is_secondary_user_ = false;
  850. std::unique_ptr<FakeEligibleHostDevicesProviderFactory>
  851. fake_eligible_host_devices_provider_factory_;
  852. std::unique_ptr<FakeHostBackendDelegateFactory>
  853. fake_host_backend_delegate_factory_;
  854. std::unique_ptr<FakeHostVerifierFactory> fake_host_verifier_factory_;
  855. std::unique_ptr<FakeHostStatusProviderFactory>
  856. fake_host_status_provider_factory_;
  857. std::unique_ptr<FakeGlobalStateFeatureManagerFactory>
  858. fake_global_state_feature_manager_factory_;
  859. std::unique_ptr<FakeWifiSyncNotificationControllerFactory>
  860. fake_wifi_sync_notification_controller_factory_;
  861. std::unique_ptr<FakeGrandfatheredEasyUnlockHostDisablerFactory>
  862. fake_grandfathered_easy_unlock_host_disabler_factory_;
  863. std::unique_ptr<FakeFeatureStateManagerFactory>
  864. fake_feature_state_manager_factory_;
  865. std::unique_ptr<FakeHostDeviceTimestampManagerFactory>
  866. fake_host_device_timestamp_manager_factory_;
  867. std::unique_ptr<FakeAccountStatusChangeDelegateNotifierFactory>
  868. fake_account_status_change_delegate_notifier_factory_;
  869. std::unique_ptr<FakeAndroidSmsAppInstallingStatusObserverFactory>
  870. fake_android_sms_app_installing_status_observer_factory_;
  871. std::unique_ptr<FakeAndroidSmsAppHelperDelegate>
  872. fake_android_sms_app_helper_delegate_;
  873. std::unique_ptr<FakeAndroidSmsPairingStateTracker>
  874. fake_android_sms_pairing_state_tracker_;
  875. std::unique_ptr<FakeAccountStatusChangeDelegate>
  876. fake_account_status_change_delegate_;
  877. base::test::ScopedFeatureList scoped_feature_list_;
  878. absl::optional<bool> last_debug_event_success_;
  879. absl::optional<multidevice::RemoteDeviceList> last_eligible_devices_list_;
  880. absl::optional<std::vector<mojom::HostDevicePtr>>
  881. last_eligible_active_devices_list_;
  882. absl::optional<bool> last_set_host_success_;
  883. absl::optional<bool> last_set_host_without_auth_success_;
  884. absl::optional<
  885. std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>>
  886. last_host_status_;
  887. absl::optional<bool> last_set_feature_enabled_state_success_;
  888. absl::optional<base::flat_map<mojom::Feature, mojom::FeatureState>>
  889. last_get_feature_states_result_;
  890. absl::optional<bool> last_retry_success_;
  891. std::unique_ptr<MultiDeviceSetupBase> multidevice_setup_;
  892. };
  893. TEST_P(MultiDeviceSetupImplTest, AccountStatusChangeDelegate) {
  894. // All requests to trigger debug events should fail before the delegate has
  895. // been set.
  896. EXPECT_FALSE(CallTriggerEventForDebugging(
  897. mojom::EventTypeForDebugging::kNewUserPotentialHostExists));
  898. EXPECT_FALSE(CallTriggerEventForDebugging(
  899. mojom::EventTypeForDebugging::kExistingUserConnectedHostSwitched));
  900. EXPECT_FALSE(CallTriggerEventForDebugging(
  901. mojom::EventTypeForDebugging::kExistingUserNewChromebookAdded));
  902. CallSetAccountStatusChangeDelegate();
  903. // All debug trigger events should now succeed.
  904. EXPECT_TRUE(CallTriggerEventForDebugging(
  905. mojom::EventTypeForDebugging::kNewUserPotentialHostExists));
  906. EXPECT_EQ(1u, fake_account_status_change_delegate()
  907. ->num_new_user_potential_host_events_handled());
  908. EXPECT_TRUE(CallTriggerEventForDebugging(
  909. mojom::EventTypeForDebugging::kExistingUserConnectedHostSwitched));
  910. EXPECT_EQ(1u, fake_account_status_change_delegate()
  911. ->num_existing_user_host_switched_events_handled());
  912. EXPECT_TRUE(CallTriggerEventForDebugging(
  913. mojom::EventTypeForDebugging::kExistingUserNewChromebookAdded));
  914. EXPECT_EQ(1u, fake_account_status_change_delegate()
  915. ->num_existing_user_chromebook_added_events_handled());
  916. }
  917. // The feature mojom::Feature::kInstantTethering is used throughout this test
  918. // because it never requires authentication for either enabling or disabling.
  919. TEST_P(MultiDeviceSetupImplTest, FeatureStateChanges_NoAuthTokenRequired) {
  920. auto observer = std::make_unique<FakeFeatureStateObserver>();
  921. multidevice_setup()->AddFeatureStateObserver(observer->GenerateRemote());
  922. EXPECT_EQ(mojom::FeatureState::kUnavailableNoVerifiedHost_NoEligibleHosts,
  923. CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
  924. fake_feature_state_manager()->SetFeatureState(
  925. mojom::Feature::kInstantTethering,
  926. mojom::FeatureState::kNotSupportedByChromebook);
  927. SendPendingObserverMessages();
  928. EXPECT_EQ(mojom::FeatureState::kNotSupportedByChromebook,
  929. CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
  930. EXPECT_EQ(1u, observer->feature_state_updates().size());
  931. fake_feature_state_manager()->SetFeatureState(
  932. mojom::Feature::kInstantTethering, mojom::FeatureState::kEnabledByUser);
  933. SendPendingObserverMessages();
  934. EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
  935. CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
  936. EXPECT_EQ(2u, observer->feature_state_updates().size());
  937. EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kInstantTethering,
  938. false /* enabled */,
  939. absl::nullopt /* auth_token */));
  940. SendPendingObserverMessages();
  941. EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
  942. CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
  943. EXPECT_EQ(3u, observer->feature_state_updates().size());
  944. }
  945. // mojom::Feature::kSmartLock requires authentication when attempting to enable.
  946. TEST_P(MultiDeviceSetupImplTest,
  947. FeatureStateChanges_AuthTokenRequired_SmartLock) {
  948. auto observer = std::make_unique<FakeFeatureStateObserver>();
  949. multidevice_setup()->AddFeatureStateObserver(observer->GenerateRemote());
  950. EXPECT_EQ(mojom::FeatureState::kUnavailableNoVerifiedHost_NoEligibleHosts,
  951. CallGetFeatureStates()[mojom::Feature::kSmartLock]);
  952. fake_feature_state_manager()->SetFeatureState(
  953. mojom::Feature::kSmartLock, mojom::FeatureState::kEnabledByUser);
  954. SendPendingObserverMessages();
  955. EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
  956. CallGetFeatureStates()[mojom::Feature::kSmartLock]);
  957. EXPECT_EQ(1u, observer->feature_state_updates().size());
  958. // No authentication is required to disable the feature.
  959. EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kSmartLock,
  960. false /* enabled */,
  961. absl::nullopt /* auth_token */));
  962. SendPendingObserverMessages();
  963. EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
  964. CallGetFeatureStates()[mojom::Feature::kSmartLock]);
  965. EXPECT_EQ(2u, observer->feature_state_updates().size());
  966. // However, authentication is required to enable the feature.
  967. EXPECT_FALSE(CallSetFeatureEnabledState(
  968. mojom::Feature::kSmartLock, true /* enabled */, "invalidAuthToken"));
  969. SendPendingObserverMessages();
  970. EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
  971. CallGetFeatureStates()[mojom::Feature::kSmartLock]);
  972. EXPECT_EQ(2u, observer->feature_state_updates().size());
  973. // Now, send a valid auth token; it should successfully enable.
  974. EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kSmartLock,
  975. true /* enabled */, kValidAuthToken));
  976. SendPendingObserverMessages();
  977. EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
  978. CallGetFeatureStates()[mojom::Feature::kSmartLock]);
  979. EXPECT_EQ(3u, observer->feature_state_updates().size());
  980. }
  981. // mojom::Feature::kBetterTogetherSuite requires authentication when attempting
  982. // to enable, but only if the Smart Lock pref is enabled.
  983. TEST_P(MultiDeviceSetupImplTest,
  984. FeatureStateChanges_AuthTokenRequired_BetterTogetherSuite) {
  985. auto observer = std::make_unique<FakeFeatureStateObserver>();
  986. multidevice_setup()->AddFeatureStateObserver(observer->GenerateRemote());
  987. EXPECT_EQ(mojom::FeatureState::kUnavailableNoVerifiedHost_NoEligibleHosts,
  988. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  989. fake_feature_state_manager()->SetFeatureState(
  990. mojom::Feature::kBetterTogetherSuite,
  991. mojom::FeatureState::kEnabledByUser);
  992. SendPendingObserverMessages();
  993. EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
  994. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  995. EXPECT_EQ(1u, observer->feature_state_updates().size());
  996. // No authentication is required to disable the feature.
  997. EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
  998. false /* enabled */,
  999. absl::nullopt /* auth_token */));
  1000. SendPendingObserverMessages();
  1001. EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
  1002. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  1003. EXPECT_EQ(2u, observer->feature_state_updates().size());
  1004. // Authentication is required to enable the feature if SmartLock's state is
  1005. // kUnavailableInsufficientSecurity.
  1006. fake_feature_state_manager()->SetFeatureState(
  1007. mojom::Feature::kSmartLock,
  1008. mojom::FeatureState::kUnavailableInsufficientSecurity);
  1009. EXPECT_FALSE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
  1010. true /* enabled */,
  1011. "invalidAuthToken"));
  1012. SendPendingObserverMessages();
  1013. EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
  1014. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  1015. EXPECT_EQ(3u, observer->feature_state_updates().size());
  1016. // Now, send a valid auth token; it should successfully enable.
  1017. EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
  1018. true /* enabled */, kValidAuthToken));
  1019. SendPendingObserverMessages();
  1020. EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
  1021. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  1022. EXPECT_EQ(4u, observer->feature_state_updates().size());
  1023. // Disable one more time.
  1024. EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
  1025. false /* enabled */,
  1026. absl::nullopt /* auth_token */));
  1027. SendPendingObserverMessages();
  1028. EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
  1029. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  1030. EXPECT_EQ(5u, observer->feature_state_updates().size());
  1031. // Authentication is required to enable the feature if SmartLock's state is
  1032. // kUnavailableSuiteDisabled.
  1033. fake_feature_state_manager()->SetFeatureState(
  1034. mojom::Feature::kSmartLock,
  1035. mojom::FeatureState::kUnavailableSuiteDisabled);
  1036. EXPECT_FALSE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
  1037. true /* enabled */,
  1038. "invalidAuthToken"));
  1039. SendPendingObserverMessages();
  1040. EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
  1041. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  1042. EXPECT_EQ(6u, observer->feature_state_updates().size());
  1043. // Now, send a valid auth token; it should successfully enable.
  1044. EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
  1045. true /* enabled */, kValidAuthToken));
  1046. SendPendingObserverMessages();
  1047. EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
  1048. CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
  1049. EXPECT_EQ(7u, observer->feature_state_updates().size());
  1050. }
  1051. TEST_P(MultiDeviceSetupImplTest, ComprehensiveHostTest) {
  1052. // Start with no eligible devices.
  1053. EXPECT_TRUE(CallGetEligibleHostDevices().empty());
  1054. VerifyCurrentHostStatus(mojom::HostStatus::kNoEligibleHosts,
  1055. absl::nullopt /* host_device */);
  1056. // Cannot retry without a host.
  1057. EXPECT_FALSE(CallRetrySetHostNow());
  1058. // Add a status observer.
  1059. auto observer = std::make_unique<FakeHostStatusObserver>();
  1060. multidevice_setup()->AddHostStatusObserver(observer->GenerateRemote());
  1061. // Simulate a sync occurring; now, all of the test devices are eligible hosts.
  1062. fake_eligible_host_devices_provider()->set_eligible_host_devices(
  1063. test_devices());
  1064. EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
  1065. fake_host_status_provider()->SetHostWithStatus(
  1066. mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1067. absl::nullopt /* host_device */);
  1068. SendPendingObserverMessages();
  1069. VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1070. absl::nullopt /* host_device */, observer.get(),
  1071. 0u /* expected_observer_index */);
  1072. // There are eligible hosts, but none is set; thus, cannot retry.
  1073. EXPECT_FALSE(CallRetrySetHostNow());
  1074. // Set an invalid host as the host device; this should fail.
  1075. EXPECT_FALSE(CallSetHostDevice("invalidHostDeviceId", kValidAuthToken));
  1076. EXPECT_FALSE(fake_host_backend_delegate()->HasPendingHostRequest());
  1077. // Set device 0 as the host; this should succeed.
  1078. std::string host_id = IsV1DeviceSyncEnabled()
  1079. ? test_devices()[0].GetDeviceId()
  1080. : test_devices()[0].instance_id();
  1081. EXPECT_TRUE(CallSetHostDevice(host_id, kValidAuthToken));
  1082. EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
  1083. EXPECT_EQ(test_devices()[0],
  1084. fake_host_backend_delegate()->GetPendingHostRequest());
  1085. fake_host_status_provider()->SetHostWithStatus(
  1086. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1087. test_devices()[0]);
  1088. SendPendingObserverMessages();
  1089. VerifyCurrentHostStatus(
  1090. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1091. test_devices()[0], observer.get(), 1u /* expected_observer_index */);
  1092. // It should now be possible to retry.
  1093. EXPECT_TRUE(CallRetrySetHostNow());
  1094. // Simulate the retry succeeding and the host being set on the back-end.
  1095. fake_host_backend_delegate()->NotifyHostChangedOnBackend(test_devices()[0]);
  1096. fake_host_status_provider()->SetHostWithStatus(
  1097. mojom::HostStatus::kHostSetButNotYetVerified, test_devices()[0]);
  1098. SendPendingObserverMessages();
  1099. VerifyCurrentHostStatus(mojom::HostStatus::kHostSetButNotYetVerified,
  1100. test_devices()[0], observer.get(),
  1101. 2u /* expected_observer_index */);
  1102. // It should still be possible to retry (this time, retrying verification).
  1103. EXPECT_TRUE(CallRetrySetHostNow());
  1104. // Simulate verification succeeding.
  1105. fake_host_verifier()->set_is_host_verified(true);
  1106. fake_host_status_provider()->SetHostWithStatus(
  1107. mojom::HostStatus::kHostVerified, test_devices()[0]);
  1108. SendPendingObserverMessages();
  1109. VerifyCurrentHostStatus(mojom::HostStatus::kHostVerified, test_devices()[0],
  1110. observer.get(), 3u /* expected_observer_index */);
  1111. // Remove the host.
  1112. multidevice_setup()->RemoveHostDevice();
  1113. fake_host_verifier()->set_is_host_verified(false);
  1114. fake_host_status_provider()->SetHostWithStatus(
  1115. mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1116. absl::nullopt /* host_device */);
  1117. SendPendingObserverMessages();
  1118. VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1119. absl::nullopt /* host_device */, observer.get(),
  1120. 4u /* expected_observer_index */);
  1121. // Simulate the host being removed on the back-end.
  1122. fake_host_backend_delegate()->NotifyHostChangedOnBackend(absl::nullopt);
  1123. }
  1124. TEST_P(MultiDeviceSetupImplTest, TestGetEligibleActiveHosts) {
  1125. // Start with no eligible devices.
  1126. EXPECT_TRUE(CallGetEligibleActiveHostDevices().empty());
  1127. multidevice::DeviceWithConnectivityStatusList host_device_list;
  1128. for (auto remote_device_ref : test_devices()) {
  1129. host_device_list.emplace_back(multidevice::DeviceWithConnectivityStatus(
  1130. remote_device_ref, cryptauthv2::ConnectivityStatus::ONLINE));
  1131. }
  1132. // Simulate a sync occurring; now, all of the test devices are eligible hosts.
  1133. fake_eligible_host_devices_provider()->set_eligible_active_host_devices(
  1134. host_device_list);
  1135. std::vector<mojom::HostDevicePtr> result_hosts =
  1136. CallGetEligibleActiveHostDevices();
  1137. for (size_t i = 0; i < kNumTestDevices; i++) {
  1138. EXPECT_EQ(*GetMutableRemoteDevice(test_devices()[i]),
  1139. result_hosts[i]->remote_device);
  1140. EXPECT_EQ(cryptauthv2::ConnectivityStatus::ONLINE,
  1141. result_hosts[i]->connectivity_status);
  1142. }
  1143. }
  1144. TEST_P(MultiDeviceSetupImplTest, TestSetHostDevice_InvalidAuthToken) {
  1145. // Start valid eligible host devices.
  1146. fake_eligible_host_devices_provider()->set_eligible_host_devices(
  1147. test_devices());
  1148. EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
  1149. fake_host_status_provider()->SetHostWithStatus(
  1150. mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1151. absl::nullopt /* host_device */);
  1152. // Set a valid host as the host device, but pass an invalid token.
  1153. std::string host_id = IsV1DeviceSyncEnabled()
  1154. ? test_devices()[0].GetDeviceId()
  1155. : test_devices()[0].instance_id();
  1156. EXPECT_FALSE(CallSetHostDevice(host_id, "invalidAuthToken"));
  1157. EXPECT_FALSE(fake_host_backend_delegate()->HasPendingHostRequest());
  1158. }
  1159. TEST_P(MultiDeviceSetupImplTest, TestSetHostDeviceWithoutAuthToken) {
  1160. // Add a status observer.
  1161. auto observer = std::make_unique<FakeHostStatusObserver>();
  1162. multidevice_setup()->AddHostStatusObserver(observer->GenerateRemote());
  1163. // Start valid eligible host devices.
  1164. fake_eligible_host_devices_provider()->set_eligible_host_devices(
  1165. test_devices());
  1166. EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
  1167. fake_host_status_provider()->SetHostWithStatus(
  1168. mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1169. absl::nullopt /* host_device */);
  1170. SendPendingObserverMessages();
  1171. VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1172. absl::nullopt /* host_device */, observer.get(),
  1173. 0u /* expected_observer_index */);
  1174. // Set a valid host as the host device without an auth token.
  1175. std::string host_id = IsV1DeviceSyncEnabled()
  1176. ? test_devices()[0].GetDeviceId()
  1177. : test_devices()[0].instance_id();
  1178. EXPECT_TRUE(CallSetHostDeviceWithoutAuth(host_id));
  1179. EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
  1180. EXPECT_EQ(test_devices()[0],
  1181. fake_host_backend_delegate()->GetPendingHostRequest());
  1182. fake_host_status_provider()->SetHostWithStatus(
  1183. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1184. test_devices()[0]);
  1185. SendPendingObserverMessages();
  1186. VerifyCurrentHostStatus(
  1187. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1188. test_devices()[0], observer.get(), 1u /* expected_observer_index */);
  1189. }
  1190. TEST_P(MultiDeviceSetupImplTest,
  1191. TestSetHostDevice_AcceptInstanceIdOrLegacyDeviceId) {
  1192. // We can set the host using the legacy device ID or the Instance ID if and
  1193. // only if v1 DeviceSync is enabled.
  1194. if (!IsV1DeviceSyncEnabled())
  1195. return;
  1196. // Add a status observer.
  1197. auto observer = std::make_unique<FakeHostStatusObserver>();
  1198. multidevice_setup()->AddHostStatusObserver(observer->GenerateRemote());
  1199. // Start valid eligible host devices.
  1200. fake_eligible_host_devices_provider()->set_eligible_host_devices(
  1201. test_devices());
  1202. EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
  1203. fake_host_status_provider()->SetHostWithStatus(
  1204. mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1205. absl::nullopt /* host_device */);
  1206. SendPendingObserverMessages();
  1207. VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
  1208. absl::nullopt /* host_device */, observer.get(),
  1209. 0u /* expected_observer_index */);
  1210. // Set the host device using its legacy device ID.
  1211. EXPECT_TRUE(
  1212. CallSetHostDevice(test_devices()[0].GetDeviceId(), kValidAuthToken));
  1213. EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
  1214. EXPECT_EQ(test_devices()[0],
  1215. fake_host_backend_delegate()->GetPendingHostRequest());
  1216. fake_host_status_provider()->SetHostWithStatus(
  1217. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1218. test_devices()[0]);
  1219. SendPendingObserverMessages();
  1220. VerifyCurrentHostStatus(
  1221. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1222. test_devices()[0], observer.get(), 1u /* expected_observer_index */);
  1223. // Set the host device using its Instance ID.
  1224. EXPECT_TRUE(
  1225. CallSetHostDevice(test_devices()[1].instance_id(), kValidAuthToken));
  1226. EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
  1227. EXPECT_EQ(test_devices()[1],
  1228. fake_host_backend_delegate()->GetPendingHostRequest());
  1229. fake_host_status_provider()->SetHostWithStatus(
  1230. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1231. test_devices()[1]);
  1232. SendPendingObserverMessages();
  1233. VerifyCurrentHostStatus(
  1234. mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
  1235. test_devices()[1], observer.get(), 2u /* expected_observer_index */);
  1236. }
  1237. // Runs tests twice; once with v1 DeviceSync enabled and once with it disabled.
  1238. // TODO(https://crbug.com/1019206): Remove when v1 DeviceSync is disabled,
  1239. // when all devices should have an Instance ID.
  1240. INSTANTIATE_TEST_SUITE_P(All, MultiDeviceSetupImplTest, ::testing::Bool());
  1241. } // namespace multidevice_setup
  1242. } // namespace ash