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

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc

 // Copyright (c) 2013 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/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/ui/webui_login_display.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/consumer_management_service.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
-#include "chrome/browser/extensions/api/screenlock_private/screenlock_private_api.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/ui/webui/chromeos/login/authenticated_user_email_retriever.h"
 #include "chrome/browser/ui/webui/chromeos/login/error_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/native_window_delegate.h"
 #include "chrome/browser/ui/webui/chromeos/login/network_state_informer.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
@@ skipping 917 matching lines @@
 ScreenlockBridge::LockHandler::AuthType SigninScreenHandler::GetAuthType(
     const std::string& username) const {
   return delegate_->GetAuthType(username);
 }
 
 void SigninScreenHandler::Unlock(const std::string& user_email) {
   DCHECK(ScreenLocker::default_screen_locker());
   ScreenLocker::Hide();
 }
 
+void SigninScreenHandler::AttemptUserClickLogin(const std::string& user_email,
+                                                const std::string& secret,
+                                                const std::string& key_label) {
+  DCHECK(!ScreenLocker::default_screen_locker());
+  if (!delegate_)
+    return;
+
+  UserContext user_context(user_email);
+  user_context.SetAuthFlow(UserContext::AUTH_FLOW_EASY_UNLOCK);
+  user_context.SetKey(Key(secret));
+  user_context.GetKey()->SetLabel(key_label);
+
+  // TODO(tbarzic): Handle empty secret. The delegate will end up ignoring login
+  // attempt if the key is not set, and the UI will remain disabled.
+  DCHECK(!secret.empty());
+
+  delegate_->Login(user_context, SigninSpecifics());

[Tim Song, 2014/09/23 19:37:59]

Is the delegate hooked up yet for logging in with the secret?

[xiyuan, 2014/09/23 19:56:58]

The delegate should be set when sign-in screen is visible.

[tbarzic, 2014/09/23 19:58:35]

Yeah, it should work fine.

+}
+
 void SigninScreenHandler::OnMaximizeModeStarted() {
   CallJS("login.AccountPickerScreen.setTouchViewState", true);
 }
 
 void SigninScreenHandler::OnMaximizeModeEnded() {
   CallJS("login.AccountPickerScreen.setTouchViewState", false);
 }
 
 bool SigninScreenHandler::ShouldLoadGaia() const {
   // Fetching of the extension is not started before account picker page is
@@ skipping 48 matching lines @@
 void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
                                                  const std::string& password) {
   if (!delegate_)
     return;
   UserContext user_context(username);
   user_context.SetKey(Key(password));
   delegate_->Login(user_context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleAttemptUnlock(const std::string& username) {
-  DCHECK(ScreenLocker::default_screen_locker());
+  if (!ScreenLocker::default_screen_locker()) {
+    OobeUI* oobe_ui = static_cast<OobeUI*>(web_ui()->GetController());
+    if (oobe_ui->display_type() != OobeUI::kLoginDisplay)
+      return;
+  }
 
   const user_manager::User* unlock_user = NULL;
   const user_manager::UserList& users = delegate_->GetUsers();
   for (user_manager::UserList::const_iterator it = users.begin();
        it != users.end();
        ++it) {
     if ((*it)->email() == username) {
       unlock_user = *it;
       break;
     }
   }
   if (!unlock_user)
     return;
 
-  Profile* profile = ProfileHelper::Get()->GetProfileByUserUnsafe(unlock_user);
-  extensions::ScreenlockPrivateEventRouter* router =
-      extensions::ScreenlockPrivateEventRouter::GetFactoryInstance()->Get(
-          profile);
-  router->OnAuthAttempted(GetAuthType(username), "");
+  ProfileHelper* profile_helper = ProfileHelper::Get();
+  Profile* profile = profile_helper->GetProfileByUser(unlock_user);

[xiyuan, 2014/09/23 01:24:29]

This call probably has side effect. I suspect that it would create a profile in
the user hash dir without mounting cryptohome.

Can we use the knowledge in line 1073-1077 above to determine the profile? That
is, if it is a lock screen, then we call this to get user profile. Otherwise,
use Profile::FromWebUI(web_ui()) and DCHECK it is the sign-in profile. 

[tbarzic, 2014/09/23 01:50:21]

According to the method comment, it returns NULL if the user's profile is not
fully initialized.
"Returns profile of the |user| if it is created and fully initialized.
Otherwise, returns NULL."

Though, I guess I can go the other way, too.

[xiyuan, 2014/09/23 02:49:24]

I see. In this case, I am okay leaving as is.

+
+  // The user profile should exists if and only if this is lock screen.
+  DCHECK_NE(!profile, !ScreenLocker::default_screen_locker());
+
+  if (!profile)
+    profile = profile_helper->GetSigninProfile();
+
+  EasyUnlockService::Get(profile)->AttemptAuth(username);
 }
 
 void SigninScreenHandler::HandleLaunchDemoUser() {
   UserContext context(user_manager::USER_TYPE_RETAIL_MODE, std::string());
   if (delegate_)
     delegate_->Login(context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleLaunchIncognito() {
   UserContext context(user_manager::USER_TYPE_GUEST, std::string());
@@ skipping 125 matching lines @@
       core_oobe_actor_->ShowDeviceResetScreen();
       return;
     }
   }
 
   is_account_picker_showing_first_time_ = true;
   gaia_screen_handler_->MaybePreloadAuthExtension();
 
   if (ScreenLocker::default_screen_locker()) {
     ScreenLocker::default_screen_locker()->delegate()->OnLockWebUIReady();
-    ScreenlockBridge::Get()->SetLockHandler(this);
   }
+  ScreenlockBridge::Get()->SetLockHandler(this);
 
   if (delegate_)
     delegate_->OnSigninScreenReady();
 }
 
 void SigninScreenHandler::HandleWallpaperReady() {
   if (ScreenLocker::default_screen_locker()) {
     ScreenLocker::default_screen_locker()->delegate()->
         OnLockBackgroundDisplayed();
   }
@@ skipping 283 matching lines @@
   return gaia_screen_handler_->frame_error();
 }
 
 void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
   caps_lock_enabled_ = enabled;
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
 }
 
 }  // namespace chromeos