components/proximity_auth/cryptauth/cryptauth_device_manager.h

   1 // Copyright 2015 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
   5 #ifndef COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CRYPTAUTH_DEVICE_MANAGER_H
   6 #define COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CRYPTAUTH_DEVICE_MANAGER_H
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/memory/weak_ptr.h"
  10 #include "base/observer_list.h"
  11 #include "base/time/clock.h"
  12 #include "base/time/time.h"
  13 #include "components/proximity_auth/cryptauth/cryptauth_gcm_manager.h"
  14 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
  15 #include "components/proximity_auth/cryptauth/sync_scheduler.h"
  16
  17 class PrefService;
  18 class PrefRegistrySimple;
  19
  20 namespace proximity_auth {
  21
  22 class CryptAuthClient;
  23 class CryptAuthClientFactory;
  24
  25 // This class manages syncing and storing the user's phones that are registered
  26 // with CryptAuth and are capable of unlocking the user's other devices. These
  27 // phones are called "unlock keys".
  28 // The manager periodically syncs the user's devices from CryptAuth to keep the
  29 // list of unlock keys fresh. If a sync attempts fails, the manager will
  30 // schedule the next sync more aggressively to recover.
  31 class CryptAuthDeviceManager : public SyncScheduler::Delegate,
  32                                public CryptAuthGCMManager::Observer {
  33  public:
  34   // Respresents the success result of a sync attempt.
  35   enum class SyncResult { SUCCESS, FAILURE };
  36
  37   // Represents whether the list of unlock keys has changed after a sync
  38   // attempt completes.
  39   enum class DeviceChangeResult {
  40     UNCHANGED,
  41     CHANGED,
  42   };
  43
  44   class Observer {
  45    public:
  46     // Called when a sync attempt is started.
  47     virtual void OnSyncStarted() = 0;
  48
  49     // Called when a sync attempt finishes with the |success| of the request.
  50     // |devices_changed| specifies if the sync caused the stored unlock keys to
  51     // change.
  52     virtual void OnSyncFinished(SyncResult sync_result,
  53                                 DeviceChangeResult device_change_result) = 0;
  54
  55     virtual ~Observer() {}
  56   };
  57
  58   // Creates the manager:
  59   // |clock|: Used to determine the time between sync attempts.
  60   // |client_factory|: Creates CryptAuthClient instances to perform each sync.
  61   // |gcm_manager|: Notifies when GCM push messages trigger device syncs.
  62   //                Not owned and must outlive this instance.
  63   // |pref_service|: Stores syncing metadata and unlock key information to
  64   //                 persist across browser restarts. Must already be registered
  65   //                 with RegisterPrefs().
  66   CryptAuthDeviceManager(scoped_ptr<base::Clock> clock,
  67                          scoped_ptr<CryptAuthClientFactory> client_factory,
  68                          CryptAuthGCMManager* gcm_manager,
  69                          PrefService* pref_service);
  70
  71   ~CryptAuthDeviceManager() override;
  72
  73   // Registers the prefs used by this class to the given |registry|.
  74   static void RegisterPrefs(PrefRegistrySimple* registry);
  75
  76   // Starts device manager to begin syncing devices.
  77   void Start();
  78
  79   // Adds an observer.
  80   void AddObserver(Observer* observer);
  81
  82   // Removes an observer.
  83   void RemoveObserver(Observer* observer);
  84
  85   // Skips the waiting period and forces a sync immediately. If a
  86   // sync attempt is already in progress, this function does nothing.
  87   // |invocation_reason| specifies the reason that the sync was triggered,
  88   // which is upload to the server.
  89   void ForceSyncNow(cryptauth::InvocationReason invocation_reason);
  90
  91   // Returns the timestamp of the last successful sync. If no sync
  92   // has ever been made, then returns a null base::Time object.
  93   base::Time GetLastSyncTime() const;
  94
  95   // Returns the time to the next sync attempt.
  96   base::TimeDelta GetTimeToNextAttempt() const;
  97
  98   // Returns true if a device sync attempt is currently in progress.
  99   bool IsSyncInProgress() const;
 100
 101   // Returns true if the last device sync failed and the manager is now
 102   // scheduling sync attempts more aggressively to recover. If no enrollment
 103   // has ever been recorded, then this function will also return true.
 104   bool IsRecoveringFromFailure() const;
 105
 106   // Returns a list of remote devices that can unlock the user's other devices.
 107   const std::vector<cryptauth::ExternalDeviceInfo>& unlock_keys() const {
 108     return unlock_keys_;
 109   }
 110
 111  protected:
 112   // Creates a new SyncScheduler instance. Exposed for testing.
 113   virtual scoped_ptr<SyncScheduler> CreateSyncScheduler();
 114
 115  private:
 116   // CryptAuthGCMManager::Observer:
 117   void OnResyncMessage() override;
 118
 119   // Updates |unlock_keys_| by fetching the list stored in |pref_service_|.
 120   void UpdateUnlockKeysFromPrefs();
 121
 122   // SyncScheduler::Delegate:
 123   void OnSyncRequested(
 124       scoped_ptr<SyncScheduler::SyncRequest> sync_request) override;
 125
 126   // Callback when |cryptauth_client_| completes with the response.
 127   void OnGetMyDevicesSuccess(const cryptauth::GetMyDevicesResponse& response);
 128   void OnGetMyDevicesFailure(const std::string& error);
 129
 130   // Used to determine the time.
 131   scoped_ptr<base::Clock> clock_;
 132
 133   // Creates CryptAuthClient instances for each sync attempt.
 134   scoped_ptr<CryptAuthClientFactory> client_factory_;
 135
 136   // Notifies when GCM push messages trigger device sync. Not owned and must
 137   // outlive this instance.
 138   CryptAuthGCMManager* gcm_manager_;
 139
 140   // Contains preferences that outlive the lifetime of this object and across
 141   // process restarts. |pref_service_| must outlive the lifetime of this
 142   // instance.
 143   PrefService* const pref_service_;
 144
 145   // The unlock keys currently synced from CryptAuth.
 146   std::vector<cryptauth::ExternalDeviceInfo> unlock_keys_;
 147
 148   // Schedules the time between device sync attempts.
 149   scoped_ptr<SyncScheduler> scheduler_;
 150
 151   // Contains the SyncRequest that |scheduler_| requests when a device sync
 152   // attempt is made.
 153   scoped_ptr<SyncScheduler::SyncRequest> sync_request_;
 154
 155   // The CryptAuthEnroller instance for the current sync attempt. A new
 156   // instance will be created for each individual attempt.
 157   scoped_ptr<CryptAuthClient> cryptauth_client_;
 158
 159   // List of observers.
 160   base::ObserverList<Observer> observers_;
 161
 162   base::WeakPtrFactory<CryptAuthDeviceManager> weak_ptr_factory_;
 163
 164   DISALLOW_COPY_AND_ASSIGN(CryptAuthDeviceManager);
 165 };
 166
 167 }  // namespace proximity_auth
 168
 169 #endif  // COMPONENTS_PROXIMITY_CRYPTAUTH_CRYPTAUTH_DEVICE_MANAGER_H