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

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.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/extensions/api/easy_unlock_private/easy_unlock_private_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 23 matching lines @@
 static base::LazyInstance<BrowserContextKeyedAPIFactory<EasyUnlockPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // Utility method for getting the API's crypto delegate.
 EasyUnlockPrivateCryptoDelegate* GetCryptoDelegate(
     content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<EasyUnlockPrivateAPI>::Get(context)
              ->crypto_delegate();
 }
 
-EasyUnlockScreenlockStateHandler* GetScreenlockStateHandler(
-    content::BrowserContext* context) {
-  return EasyUnlockService::Get(Profile::FromBrowserContext(context))
-      ->GetScreenlockStateHandler();
-}
-
 EasyUnlockScreenlockStateHandler::State ToScreenlockStateHandlerState(
     easy_unlock_private::State state) {
   switch (state) {
     case easy_unlock_private::STATE_NO_BLUETOOTH:
       return EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH;
     case easy_unlock_private::STATE_BLUETOOTH_CONNECTING:
       return EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING;
     case easy_unlock_private::STATE_NO_PHONE:
       return EasyUnlockScreenlockStateHandler::STATE_NO_PHONE;
     case easy_unlock_private::STATE_PHONE_NOT_AUTHENTICATED:
@@ skipping 359 matching lines @@
     EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 
 EasyUnlockPrivateUpdateScreenlockStateFunction::
     ~EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 
 bool EasyUnlockPrivateUpdateScreenlockStateFunction::RunSync() {
   scoped_ptr<easy_unlock_private::UpdateScreenlockState::Params> params(
       easy_unlock_private::UpdateScreenlockState::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  EasyUnlockScreenlockStateHandler* screenlock_state_handler =
-      GetScreenlockStateHandler(browser_context());
-  if (screenlock_state_handler) {
-    screenlock_state_handler->ChangeState(
-        ToScreenlockStateHandlerState(params->state));
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  if (EasyUnlockService::Get(profile)->UpdateScreenlockState(
+          ToScreenlockStateHandlerState(params->state)))
     return true;
-  }
 
   SetError("Not allowed");
   return false;
 }
 
 EasyUnlockPrivateSetPermitAccessFunction::
     EasyUnlockPrivateSetPermitAccessFunction() {
 }
 
 EasyUnlockPrivateSetPermitAccessFunction::
@@ skipping 110 matching lines @@
 }
 
 EasyUnlockPrivateTrySignInSecretFunction::
     EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
 EasyUnlockPrivateTrySignInSecretFunction::
     ~EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
-bool EasyUnlockPrivateTrySignInSecretFunction::RunAsync() {
-  SetError("Not implemented");
-  SendResponse(false);
+bool EasyUnlockPrivateTrySignInSecretFunction::RunSync() {
+  scoped_ptr<easy_unlock_private::TrySignInSecret::Params> params(
+      easy_unlock_private::TrySignInSecret::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  EasyUnlockService::Get(profile)->FinalizeSignin(params->sign_in_secret);
   return true;
 }
 
 EasyUnlockPrivateGetUserInfoFunction::EasyUnlockPrivateGetUserInfoFunction() {
 }
 
 EasyUnlockPrivateGetUserInfoFunction::~EasyUnlockPrivateGetUserInfoFunction() {
 }
 
 bool EasyUnlockPrivateGetUserInfoFunction::RunSync() {
   EasyUnlockService* service =
       EasyUnlockService::Get(Profile::FromBrowserContext(browser_context()));
   std::vector<linked_ptr<easy_unlock_private::UserInfo> > users;
   std::string user_id = service->GetUserEmail();
   if (!user_id.empty()) {
     users.push_back(
         linked_ptr<easy_unlock_private::UserInfo>(
             new easy_unlock_private::UserInfo()));
     users[0]->user_id = user_id;
     users[0]->logged_in = service->GetType() == EasyUnlockService::TYPE_REGULAR;
-    users[0]->data_ready = service->GetRemoteDevices() != NULL;
+    users[0]->data_ready = users[0]->logged_in ||
+                           service->GetRemoteDevices() != NULL;
   }
   results_ = easy_unlock_private::GetUserInfo::Results::Create(users);
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions