Hook up ProximityAuthSystem in EasyUnlockService.

chrome/browser/signin/easy_unlock_service.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_H_
 #define CHROME_BROWSER_SIGNIN_EASY_UNLOCK_SERVICE_H_
 
 #include <set>
 #include <string>
 
@@ skipping 21 matching lines @@
 namespace user_manager {
 class User;
 }
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 namespace proximity_auth {
 class ProximityAuthBleSystem;
+class ProximityAuthSystem;
+class RemoteDevice;
 }
 
 class EasyUnlockAppManager;
 class EasyUnlockServiceObserver;
 class Profile;
 class PrefRegistrySimple;
 
 class EasyUnlockService : public KeyedService {
  public:
   enum TurnOffFlowStatus {
@@ skipping 181 matching lines @@
   // Service type specific tests for whether the service is allowed. Returns
   // false if service is not allowed. If true is returned, the service may still
   // not be allowed if common tests fail (e.g. if Bluetooth is not available).
   virtual bool IsAllowedInternal() const = 0;
 
   // Called while processing a user gesture to unlock the screen using Easy
   // Unlock, just before the screen is unlocked.
   virtual void OnWillFinalizeUnlock(bool success) = 0;
 
   // Called when the local device resumes after a suspend.
-  virtual void OnSuspendDone() = 0;
+  virtual void OnSuspendDoneInternal() = 0;
 
   // KeyedService override:
   void Shutdown() override;
 
   // Exposes the profile to which the service is attached to subclasses.
   const Profile* profile() const { return profile_; }
   Profile* profile() { return profile_; }
 
   // Opens an Easy Unlock Setup app window.
   void OpenSetupApp();
@@ skipping 32 matching lines @@
   // Saves hardlock state for the given user. Update UI if the currently
   // associated user is the same.
   void SetHardlockStateForUser(
       const std::string& user_id,
       EasyUnlockScreenlockStateHandler::HardlockState state);
 
   // Returns the authentication event for a recent password sign-in or unlock,
   // according to the current state of the service.
   EasyUnlockAuthEvent GetPasswordAuthEvent() const;
 
+  // Called by subclasses when the remote device allowed to unlock the screen
+  // changes. If |remote_device| is not null, then |proximity_auth_system_| will
+  // be recreated with the new remote device. Otherwise,
+  // |proximity_auth_system_| will be destroyed if no |remote_device| is set.
+  void OnRemoteDeviceChanged(const proximity_auth::RemoteDevice* remote_device);
+
  private:
   // A class to detect whether a bluetooth adapter is present.
   class BluetoothDetector;
 
   // Initializes the service after EasyUnlockAppManager is ready.
   void InitializeOnAppManagerReady();
 
   // Gets |screenlock_state_handler_|. Returns NULL if Easy Unlock is not
   // allowed. Otherwise, if |screenlock_state_handler_| is not set, an instance
   // is created. Do not cache the returned value, as it may go away if Easy
   // Unlock gets disabled.
   EasyUnlockScreenlockStateHandler* GetScreenlockStateHandler();
 
   // Callback when Bluetooth adapter present state changes.
   void OnBluetoothAdapterPresentChanged();
 
 #if defined(OS_CHROMEOS)
   // Callback for get key operation from CheckCryptohomeKeysAndMaybeHardlock.
   void OnCryptohomeKeysFetchedForChecking(
       const std::string& user_id,
       const std::set<std::string> paired_devices,
       bool success,
       const chromeos::EasyUnlockDeviceKeyDataList& key_data_list);
 #endif
 
   // Updates the service to state for handling system suspend.
   void PrepareForSuspend();
 
+  // Called when the system resumes from a suspended state.
+  void OnSuspendDone();
+
   void EnsureTpmKeyPresentIfNeeded();
 
   Profile* const profile_;
 
   ChromeProximityAuthClient proximity_auth_client_;
 
   scoped_ptr<EasyUnlockAppManager> app_manager_;
 
   // Created lazily in |GetScreenlockStateHandler|.
   scoped_ptr<EasyUnlockScreenlockStateHandler> screenlock_state_handler_;
 
   // The handler for the current auth attempt. Set iff an auth attempt is in
   // progress.
   scoped_ptr<EasyUnlockAuthAttempt> auth_attempt_;
 
+  // Detects when the system Bluetooth adapter status changes.
   scoped_ptr<BluetoothDetector> bluetooth_detector_;
 
-  // The proximity auth over Bluetooth Low Energy system. This is main entry
-  // point to bootstap Smart Lock to discover phones over Bluetooth Low
-  // Energy.
-  scoped_ptr<proximity_auth::ProximityAuthBleSystem> proximity_auth_ble_system_;
+  // Handles connecting, authenticating, and updating the UI on the lock/sign-in
+  // screen. After a |RemoteDevice| instance is provided, this object will
+  // handle the rest.
+  // TODO(tengs): This object is intended as a replacement of the background
+  // page of the easy_unlock Chrome app. We are in the process of removing the
+  // app in favor of |proximity_auth_system_|.
+  scoped_ptr<proximity_auth::ProximityAuthSystem> proximity_auth_system_;
 
 #if defined(OS_CHROMEOS)
   // Monitors suspend and wake state of ChromeOS.
   class PowerMonitor;
   scoped_ptr<PowerMonitor> power_monitor_;
 #endif
 
   // Whether the service has been shut down.
   bool shut_down_;
 
   bool tpm_key_checked_;
 
   base::ObserverList<EasyUnlockServiceObserver> observers_;
 
   base::WeakPtrFactory<EasyUnlockService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockService);
 };
 
 #endif  // CHROME_BROWSER_SIGNIN_EASY_UNLOCK_SERVICE_H_