host_verifier_impl.h 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115
  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. #ifndef ASH_SERVICES_MULTIDEVICE_SETUP_HOST_VERIFIER_IMPL_H_
  5. #define ASH_SERVICES_MULTIDEVICE_SETUP_HOST_VERIFIER_IMPL_H_
  6. #include <memory>
  7. #include "ash/components/multidevice/remote_device_ref.h"
  8. #include "ash/services/device_sync/public/cpp/device_sync_client.h"
  9. #include "ash/services/multidevice_setup/host_backend_delegate.h"
  10. #include "ash/services/multidevice_setup/host_verifier.h"
  11. #include "base/memory/weak_ptr.h"
  12. #include "base/time/default_clock.h"
  13. #include "base/timer/timer.h"
  14. class PrefRegistrySimple;
  15. class PrefService;
  16. namespace ash {
  17. namespace multidevice_setup {
  18. // Concrete HostVerifier implementation, which starts trying to verify a host as
  19. // soon as it is set on the back-end. If verification fails, HostVerifierImpl
  20. // uses an exponential back-off to retry verification until it succeeds.
  21. //
  22. // If the MultiDevice host is changed while verification is in progress, the
  23. // previous verification attempt is canceled and a new attempt begins with the
  24. // updated device.
  25. class HostVerifierImpl : public HostVerifier,
  26. public HostBackendDelegate::Observer,
  27. public device_sync::DeviceSyncClient::Observer {
  28. public:
  29. class Factory {
  30. public:
  31. static std::unique_ptr<HostVerifier> Create(
  32. HostBackendDelegate* host_backend_delegate,
  33. device_sync::DeviceSyncClient* device_sync_client,
  34. PrefService* pref_service,
  35. base::Clock* clock = base::DefaultClock::GetInstance(),
  36. std::unique_ptr<base::OneShotTimer> retry_timer =
  37. std::make_unique<base::OneShotTimer>(),
  38. std::unique_ptr<base::OneShotTimer> sync_timer =
  39. std::make_unique<base::OneShotTimer>());
  40. static void SetFactoryForTesting(Factory* test_factory);
  41. protected:
  42. virtual ~Factory();
  43. virtual std::unique_ptr<HostVerifier> CreateInstance(
  44. HostBackendDelegate* host_backend_delegate,
  45. device_sync::DeviceSyncClient* device_sync_client,
  46. PrefService* pref_service,
  47. base::Clock* clock,
  48. std::unique_ptr<base::OneShotTimer> retry_timer,
  49. std::unique_ptr<base::OneShotTimer> sync_timer) = 0;
  50. private:
  51. static Factory* test_factory_;
  52. };
  53. static void RegisterPrefs(PrefRegistrySimple* registry);
  54. HostVerifierImpl(const HostVerifierImpl&) = delete;
  55. HostVerifierImpl& operator=(const HostVerifierImpl&) = delete;
  56. ~HostVerifierImpl() override;
  57. private:
  58. HostVerifierImpl(HostBackendDelegate* host_backend_delegate,
  59. device_sync::DeviceSyncClient* device_sync_client,
  60. PrefService* pref_service,
  61. base::Clock* clock,
  62. std::unique_ptr<base::OneShotTimer> retry_timer,
  63. std::unique_ptr<base::OneShotTimer> sync_timer);
  64. // HostVerifier:
  65. bool IsHostVerified() override;
  66. void PerformAttemptVerificationNow() override;
  67. // HostBackendDelegate::Observer:
  68. void OnHostChangedOnBackend() override;
  69. // device_sync::DeviceSyncClient::Observer:
  70. void OnNewDevicesSynced() override;
  71. void UpdateRetryState();
  72. void StopRetryTimerAndClearPrefs();
  73. void AttemptVerificationWithInitialTimeout();
  74. void AttemptVerificationAfterInitialTimeout(
  75. const base::Time& retry_time_from_prefs);
  76. void StartRetryTimer(const base::Time& time_to_fire);
  77. void AttemptHostVerification();
  78. void OnFindEligibleDevicesResult(
  79. device_sync::mojom::NetworkRequestResult result,
  80. multidevice::RemoteDeviceRefList eligible_devices,
  81. multidevice::RemoteDeviceRefList ineligible_devices);
  82. void OnNotifyDevicesFinished(device_sync::mojom::NetworkRequestResult result);
  83. void OnSyncTimerFired();
  84. HostBackendDelegate* host_backend_delegate_;
  85. device_sync::DeviceSyncClient* device_sync_client_;
  86. PrefService* pref_service_;
  87. base::Clock* clock_;
  88. std::unique_ptr<base::OneShotTimer> retry_timer_;
  89. std::unique_ptr<base::OneShotTimer> sync_timer_;
  90. base::WeakPtrFactory<HostVerifierImpl> weak_ptr_factory_{this};
  91. };
  92. } // namespace multidevice_setup
  93. } // namespace ash
  94. #endif // ASH_SERVICES_MULTIDEVICE_SETUP_HOST_VERIFIER_IMPL_H_