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

chrome/browser/signin/easy_unlock_service.cc

 // 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.
 
 #include "chrome/browser/signin/easy_unlock_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/signin/easy_unlock_screenlock_state_handler.h"
+#include "chrome/browser/signin/easy_unlock_auth_attempt.h"
 #include "chrome/browser/signin/easy_unlock_service_factory.h"
 #include "chrome/browser/signin/easy_unlock_service_observer.h"
 #include "chrome/browser/signin/screenlock_bridge.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/easy_unlock_private.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
@@ skipping 169 matching lines @@
     return NULL;
   if (!screenlock_state_handler_) {
     screenlock_state_handler_.reset(new EasyUnlockScreenlockStateHandler(
         GetUserEmail(),
         GetType() == TYPE_REGULAR ? profile_->GetPrefs() : NULL,
         ScreenlockBridge::Get()));
   }
   return screenlock_state_handler_.get();
 }
 
+bool EasyUnlockService::UpdateScreenlockState(
+    EasyUnlockScreenlockStateHandler::State state) {
+  EasyUnlockScreenlockStateHandler* handler = GetScreenlockStateHandler();
+  if (!handler)
+    return false;
+
+  handler->ChangeState(state);
+
+  if (state != EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED)
+    auth_attempt_.reset();
+  return true;
+}
+
+void EasyUnlockService::AttemptAuth(const std::string& user_id) {
+  auth_attempt_.reset(new EasyUnlockAuthAttempt(
+      profile_,
+      GetUserEmail(),
+      GetType() == TYPE_REGULAR ? EasyUnlockAuthAttempt::TYPE_UNLOCK
+                                : EasyUnlockAuthAttempt::TYPE_SIGNIN));
+  if (!auth_attempt_->Start(user_id))
+    auth_attempt_.reset();
+}
+
+void EasyUnlockService::FinalizeUnlock(bool success) {
+  if (auth_attempt_)
+    auth_attempt_->FinalizeUnlock(GetUserEmail(), success);
+  auth_attempt_.reset();
+}
+
+void EasyUnlockService::FinalizeSignin(const std::string& key) {
+  if (!auth_attempt_)
+    return;
+  std::string wrapped_secret = GetWrappedSecret();
+  if (!wrapped_secret.empty())
+    auth_attempt_->FinalizeSignin(GetUserEmail(), wrapped_secret, key);
+  auth_attempt_.reset();
+}
+
 void EasyUnlockService::AddObserver(EasyUnlockServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void EasyUnlockService::RemoveObserver(EasyUnlockServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void  EasyUnlockService::Shutdown() {
   if (shut_down_)
     return;
   shut_down_ = true;
 
   ShutdownInternal();
 
   weak_ptr_factory_.InvalidateWeakPtrs();
 
-  ResetScreenlockStateHandler();
+  ResetScreenlockState();
   bluetooth_detector_.reset();
 #if defined(OS_CHROMEOS)
   power_monitor_.reset();
 #endif
 }
 
 void EasyUnlockService::LoadApp() {
   DCHECK(IsAllowed());
 
 #if defined(GOOGLE_CHROME_BUILD)
@@ skipping 20 matching lines @@
         extensions::ExtensionSystem::Get(profile_)->extension_service();
     extension_service->EnableExtension(extension_misc::kEasyUnlockAppId);
 
     NotifyUserUpdated();
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 }
 
 void EasyUnlockService::DisableAppIfLoaded() {
   // Make sure lock screen state set by the extension gets reset.
-  ResetScreenlockStateHandler();
+  ResetScreenlockState();
 
   extensions::ComponentLoader* loader = GetComponentLoader(profile_);
   if (!loader->Exists(extension_misc::kEasyUnlockAppId))
     return;
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   extension_service->DisableExtension(extension_misc::kEasyUnlockAppId,
                                       extensions::Extension::DISABLE_RELOAD);
 }
 
 void EasyUnlockService::UnloadApp() {
   GetComponentLoader(profile_)->Remove(extension_misc::kEasyUnlockAppId);
 }
 
 void EasyUnlockService::ReloadApp() {
   // Make sure lock screen state set by the extension gets reset.
-  ResetScreenlockStateHandler();
+  ResetScreenlockState();
 
   if (!GetComponentLoader(profile_)->Exists(extension_misc::kEasyUnlockAppId))
     return;
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile_);
   extension_system->extension_service()->ReloadExtension(
       extension_misc::kEasyUnlockAppId);
   NotifyUserUpdated();
 }
 
@@ skipping 15 matching lines @@
 
 void EasyUnlockService::NotifyUserUpdated() {
   std::string user_id = GetUserEmail();
   if (user_id.empty())
     return;
 
   // Notify the easy unlock app that the user info changed.
   extensions::api::easy_unlock_private::UserInfo info;
   info.user_id = user_id;
   info.logged_in = GetType() == TYPE_REGULAR;
-  info.data_ready = GetRemoteDevices() != NULL;
+  info.data_ready = info.logged_in || GetRemoteDevices() != NULL;
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(info.ToValue().release());
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::api::easy_unlock_private::OnUserInfoUpdated::kEventName,
       args.Pass()));
 
   extensions::EventRouter::Get(profile_)->DispatchEventToExtension(
        extension_misc::kEasyUnlockAppId, event.Pass());
 }
 
 void EasyUnlockService::NotifyTurnOffOperationStatusChanged() {
   FOR_EACH_OBSERVER(
       EasyUnlockServiceObserver, observers_, OnTurnOffOperationStatusChanged());
 }
 
-void EasyUnlockService::ResetScreenlockStateHandler() {
+void EasyUnlockService::ResetScreenlockState() {
   screenlock_state_handler_.reset();
+  auth_attempt_.reset();
 }
 
 void EasyUnlockService::Initialize() {
   InitializeInternal();
 
 #if defined(OS_CHROMEOS)
   // Only start Bluetooth detection for ChromeOS since the feature is
   // only offered on ChromeOS. Enabling this on non-ChromeOS platforms
   // previously introduced a performance regression: http://crbug.com/404482
   // Make sure not to reintroduce a performance regression if re-enabling on
   // additional platforms.
   // TODO(xiyuan): Revisit when non-chromeos platforms are supported.
   bluetooth_detector_->Initialize();
 #endif  // defined(OS_CHROMEOS)
 }
 
 void EasyUnlockService::OnBluetoothAdapterPresentChanged() {
   UpdateAppState();
 }