blob: 128a81616a205d5493f444b75dc425169cdd205d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_CRYPTAUTH_CRYPTAUTH_DEVICE_MANAGER_IMPL_H_
#define COMPONENTS_CRYPTAUTH_CRYPTAUTH_DEVICE_MANAGER_IMPL_H_
#include <memory>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/time/clock.h"
#include "base/time/time.h"
#include "components/cryptauth/cryptauth_device_manager.h"
#include "components/cryptauth/cryptauth_gcm_manager.h"
#include "components/cryptauth/proto/cryptauth_api.pb.h"
#include "components/cryptauth/sync_scheduler.h"
class PrefService;
namespace cryptauth {
class CryptAuthClient;
class CryptAuthClientFactory;
class CryptAuthDeviceManagerImpl : public CryptAuthDeviceManager,
public SyncScheduler::Delegate,
public CryptAuthGCMManager::Observer {
public:
class Factory {
public:
static std::unique_ptr<CryptAuthDeviceManager> NewInstance(
base::Clock* clock,
CryptAuthClientFactory* cryptauth_client_factory,
CryptAuthGCMManager* gcm_manager,
PrefService* pref_service);
static void SetInstanceForTesting(Factory* factory);
protected:
virtual ~Factory();
virtual std::unique_ptr<CryptAuthDeviceManager> BuildInstance(
base::Clock* clock,
CryptAuthClientFactory* cryptauth_client_factory,
CryptAuthGCMManager* gcm_manager,
PrefService* pref_service);
private:
static Factory* factory_instance_;
};
~CryptAuthDeviceManagerImpl() override;
// CryptAuthDeviceManager:
void Start() override;
void ForceSyncNow(InvocationReason invocation_reason) override;
base::Time GetLastSyncTime() const override;
base::TimeDelta GetTimeToNextAttempt() const override;
bool IsSyncInProgress() const override;
bool IsRecoveringFromFailure() const override;
std::vector<ExternalDeviceInfo> GetSyncedDevices() const override;
std::vector<ExternalDeviceInfo> GetUnlockKeys() const override;
std::vector<ExternalDeviceInfo> GetPixelUnlockKeys() const override;
std::vector<ExternalDeviceInfo> GetTetherHosts() const override;
std::vector<ExternalDeviceInfo> GetPixelTetherHosts() const override;
protected:
// Creates the manager:
// |clock|: Used to determine the time between sync attempts.
// |cryptauth_client_factory|: Creates CryptAuthClient instances to perform
// each sync. |gcm_manager|: Notifies when GCM push messages trigger device
// syncs.
// Not owned and must outlive this instance.
// |pref_service|: Stores syncing metadata and unlock key information to
// persist across browser restarts. Must already be registered
// with RegisterPrefs().
CryptAuthDeviceManagerImpl(base::Clock* clock,
CryptAuthClientFactory* cryptauth_client_factory,
CryptAuthGCMManager* gcm_manager,
PrefService* pref_service);
void SetSyncSchedulerForTest(std::unique_ptr<SyncScheduler> sync_scheduler);
private:
// CryptAuthGCMManager::Observer:
void OnResyncMessage() override;
// Updates |unlock_keys_| by fetching the list stored in |pref_service_|.
void UpdateUnlockKeysFromPrefs();
// SyncScheduler::Delegate:
void OnSyncRequested(
std::unique_ptr<SyncScheduler::SyncRequest> sync_request) override;
// Callback when |cryptauth_client_| completes with the response.
void OnGetMyDevicesSuccess(const GetMyDevicesResponse& response);
void OnGetMyDevicesFailure(const std::string& error);
// Used to determine the time.
base::Clock* clock_;
// Creates CryptAuthClient instances for each sync attempt.
CryptAuthClientFactory* cryptauth_client_factory_;
// Notifies when GCM push messages trigger device sync. Not owned and must
// outlive this instance.
CryptAuthGCMManager* gcm_manager_;
// Contains preferences that outlive the lifetime of this object and across
// process restarts. |pref_service_| must outlive the lifetime of this
// instance.
PrefService* const pref_service_;
// All devices currently synced from CryptAuth.
std::vector<ExternalDeviceInfo> synced_devices_;
// Schedules the time between device sync attempts.
std::unique_ptr<SyncScheduler> scheduler_;
// Contains the SyncRequest that |scheduler_| requests when a device sync
// attempt is made.
std::unique_ptr<SyncScheduler::SyncRequest> sync_request_;
// The CryptAuthEnroller instance for the current sync attempt. A new
// instance will be created for each individual attempt.
std::unique_ptr<CryptAuthClient> cryptauth_client_;
base::WeakPtrFactory<CryptAuthDeviceManagerImpl> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(CryptAuthDeviceManagerImpl);
};
} // namespace cryptauth
#endif // COMPONENTS_CRYPTAUTH_CRYPTAUTH_DEVICE_MANAGER_IMPL_H_
|
