Hook up ProximityAuthSystem in EasyUnlockService.

chrome/browser/signin/easy_unlock_service_regular.h

 // Copyright 2014 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 CHROME_BROWSER_SIGNIN_EASY_UNLOCK_SERVICE_REGULAR_H_
 #define CHROME_BROWSER_SIGNIN_EASY_UNLOCK_SERVICE_REGULAR_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/time/time.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
+#include "components/proximity_auth/cryptauth/cryptauth_device_manager.h"
 #include "components/proximity_auth/screenlock_bridge.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/easy_unlock/short_lived_user_context.h"
 #endif
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace cryptauth {
 class ToggleEasyUnlockResponse;
 }
 
 namespace proximity_auth {
 class CryptAuthClient;
 class CryptAuthGCMManager;
 class CryptAuthEnrollmentManager;
-class CryptAuthDeviceManager;
+class RemoteDeviceLoader;
 }
 
 class EasyUnlockAppManager;
 class EasyUnlockToggleFlow;
 class Profile;
 
 // EasyUnlockService instance that should be used for regular, non-signin
 // profiles.
 class EasyUnlockServiceRegular
     : public EasyUnlockService,
       public proximity_auth::ScreenlockBridge::Observer,
+      public proximity_auth::CryptAuthDeviceManager::Observer,
       public OAuth2TokenService::Observer {
  public:
   explicit EasyUnlockServiceRegular(Profile* profile);
   ~EasyUnlockServiceRegular() override;
 
   // Returns the CryptAuthEnrollmentManager, which manages the profile's
   // CryptAuth enrollment.
   proximity_auth::CryptAuthEnrollmentManager* GetCryptAuthEnrollmentManager();
 
   // Returns the CryptAuthEnrollmentManager, which manages the profile's
   // synced devices from CryptAuth.
   proximity_auth::CryptAuthDeviceManager* GetCryptAuthDeviceManager();
 
  private:
+  // Loads the RemoteDevice instances that will be supplied to
+  // ProximityAuthSystem.
+  void LoadRemoteDevices();
+
+  // Called when |remote_device_loader_| completes.
+  void OnRemoteDevicesLoaded(
+      const std::vector<proximity_auth::RemoteDevice>& remote_devices);
+
   // EasyUnlockService implementation:
   EasyUnlockService::Type GetType() const override;
   std::string GetUserEmail() const override;
   void LaunchSetup() override;
   const base::DictionaryValue* GetPermitAccess() const override;
   void SetPermitAccess(const base::DictionaryValue& permit) override;
   void ClearPermitAccess() override;
   const base::ListValue* GetRemoteDevices() const override;
   void SetRemoteDevices(const base::ListValue& devices) override;
   void RunTurnOffFlow() override;
   void ResetTurnOffFlow() override;
   TurnOffFlowStatus GetTurnOffFlowStatus() const override;
   std::string GetChallenge() const override;
   std::string GetWrappedSecret() const override;
   void RecordEasySignInOutcome(const std::string& user_id,
                                bool success) const override;
   void RecordPasswordLoginEvent(const std::string& user_id) const override;
   void StartAutoPairing(const AutoPairingResultCallback& callback) override;
   void SetAutoPairingResult(bool success, const std::string& error) override;
   void InitializeInternal() override;
   void ShutdownInternal() override;
   bool IsAllowedInternal() const override;
   void OnWillFinalizeUnlock(bool success) override;
-  void OnSuspendDone() override;
+  void OnSuspendDoneInternal() override;
 
   // OAuth2TokenService::Observer:
   void OnRefreshTokenAvailable(const std::string& account_id) override;
 
+  // CryptAuthDeviceManager::Observer:
+  void OnSyncStarted() override;
+  void OnSyncFinished(
+      proximity_auth::CryptAuthDeviceManager::SyncResult sync_result,
+      proximity_auth::CryptAuthDeviceManager::DeviceChangeResult
+          device_change_result) override;
+
   // proximity_auth::ScreenlockBridge::Observer implementation:
   void OnScreenDidLock(proximity_auth::ScreenlockBridge::LockHandler::ScreenType
                            screen_type) override;
   void OnScreenDidUnlock(
       proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type)
       override;
   void OnFocusedUserChanged(const std::string& user_id) override;
 
 
   // Callback when the controlling pref changes.
@@ skipping 49 matching lines @@
   // sleep -- e.g. by opening the lid -- but can also be shown if the screen is
   // locked but the computer does not go to sleep.
   base::TimeTicks lock_screen_last_shown_timestamp_;
 
   // Managers responsible for handling syncing and communications with
   // CryptAuth.
   scoped_ptr<proximity_auth::CryptAuthGCMManager> gcm_manager_;
   scoped_ptr<proximity_auth::CryptAuthEnrollmentManager> enrollment_manager_;
   scoped_ptr<proximity_auth::CryptAuthDeviceManager> device_manager_;
 
+  // Loads the RemoteDevice instances from CryptAuth and local data.
+  scoped_ptr<proximity_auth::RemoteDeviceLoader> remote_device_loader_;
+
+  // If a new RemoteDevice was synced while the screen is locked, for security
+  // reasons, we defer loading the RemoteDevice until the screen is unlocked.
+  bool deferring_device_load_;

[sacomoto, 2015/09/29 18:45:57]

What exactly do you mean by security reasons?

[Tim Song, 2015/09/30 00:05:04]

Basically, we don't want a network event to change things on the lock screen.
For example, if an attacker gets access to your Google account, they can
register their own unlock key. We also have another flow where syncing a new
device while logged in will require you to enter your password once after
locking.

I clarified the comments.

+
   base::WeakPtrFactory<EasyUnlockServiceRegular> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockServiceRegular);
 };
 
 #endif  // CHROME_BROWSER_SIGNIN_EASY_UNLOCK_SERVICE_REGULAR_H_