[Easy signin] Wire up userClick auth attempt to easy unlock app and back

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 <string>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "chrome/browser/signin/easy_unlock_screenlock_state_handler.h"
 #include "components/keyed_service/core/keyed_service.h"
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
-class EasyUnlockScreenlockStateHandler;
+class EasyUnlockAuthAttempt;
 class EasyUnlockServiceObserver;
 class Profile;
 
 class EasyUnlockService : public KeyedService {
  public:
   enum TurnOffFlowStatus {
     IDLE,
     PENDING,
     FAIL,
   };
@@ skipping 30 matching lines @@
 
   // Runs the flow for turning Easy unlock off.
   virtual void RunTurnOffFlow() = 0;
 
   // Resets the turn off flow if one is in progress.
   virtual void ResetTurnOffFlow() = 0;
 
   // Returns the current turn off flow status.
   virtual TurnOffFlowStatus GetTurnOffFlowStatus() const = 0;
 
-  // Gets the challenge bytes for the currently associated user.
+  // Gets the challenge bytes for the user currently associated with the
+  // service.
   virtual std::string GetChallenge() const = 0;
 
-  // 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();
+  // Retrieved wrapped secret that should be used to unlock cryptohome for the
+  // user currently associated with the service. If the service does not support
+  // signin (i.e. service for a regular profile) or there is no secret available
+  // for the user, returns an empty string.
+  virtual std::string GetWrappedSecret() const = 0;
 
   // Whether easy unlock is allowed to be used. If the controlling preference
   // is set (from policy), this returns the preference value. Otherwise, it is
   // permitted either the flag is enabled or its field trial is enabled.
   bool IsAllowed();
 
+  // Updates the user pod on the signin/lock screen for the user associated with
+  // the service to reflect the provided screenlock state.
+  bool UpdateScreenlockState(EasyUnlockScreenlockStateHandler::State state);
+
+  // Starts an auth attempt for the user associated with the service. The
+  // attempt type (unlock vs. signin) will depend on the service type.
+  void AttemptAuth(const std::string& user_id);
+
+  // Finalizes the previously started auth attempt for easy unlock. If called on
+  // signin profile service, it will cancel the current auth attempt if one
+  // exists.
+  void FinalizeUnlock(bool success);
+
+  // Finalizes previously started auth attempt for easy signin. If called on
+  // regular profile service, it will cancel the current auth attempt if one
+  // exists.
+  void FinalizeSignin(const std::string& secret);
+
   void AddObserver(EasyUnlockServiceObserver* observer);
   void RemoveObserver(EasyUnlockServiceObserver* observer);
 
  protected:
   explicit EasyUnlockService(Profile* profile);
   virtual ~EasyUnlockService();
 
   // Does a service type specific initialization.
   virtual void InitializeInternal() = 0;
 
@@ skipping 26 matching lines @@
 
   // Checks whether Easy unlock should be running and updates app state.
   void UpdateAppState();
 
   // Notifies the easy unlock app that the user state has been updated.
   void NotifyUserUpdated();
 
   // Notifies observers that the turn off flow status changed.
   void NotifyTurnOffOperationStatusChanged();
 
-  // Resets |screenlock_state_handler_|.
-  void ResetScreenlockStateHandler();
+  // Resets the screenlock state set by this service.
+  void ResetScreenlockState();
 
  private:
   // A class to detect whether a bluetooth adapter is present.
   class BluetoothDetector;
 
   // Initializes the service after ExtensionService is ready.
   void Initialize();
 
+  // 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();
 
   Profile* profile_;
 
   // 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_;
+
   scoped_ptr<BluetoothDetector> bluetooth_detector_;
 
 #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_;
 
   ObserverList<EasyUnlockServiceObserver> observers_;
 
   base::WeakPtrFactory<EasyUnlockService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockService);
 };
 
 #endif  // CHROME_BROWSER_SIGNIN_EASY_UNLOCK_SERVICE_H_