cros: Clean up screenlockPrivate plumbing.

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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 24 matching lines @@
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/chromeos/login/screens/core_oobe_actor.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/wallpaper_manager.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/net/network_portal_detector.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.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/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/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/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "chromeos/ime/ime_keyboard.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
+#include "ui/base/webui/web_ui_util.h"
 
 #if defined(USE_AURA)
 #include "ash/shell.h"
 #include "ash/wm/lock_state_controller.h"
 #endif
 
 using content::BrowserThread;
 
 namespace {
 
@@ skipping 259 matching lines @@
                  chrome::NOTIFICATION_AUTH_CANCELLED,
                  content::NotificationService::AllSources());
 }
 
 SigninScreenHandler::~SigninScreenHandler() {
   ash::Shell::GetInstance()->RemovePreTargetHandler(this);
   weak_factory_.InvalidateWeakPtrs();
   if (delegate_)
     delegate_->SetWebUIHandler(NULL);
   network_state_informer_->RemoveObserver(this);
+  ScreenlockBridge::Get()->SetLockHandler(NULL);
 }
 
 void SigninScreenHandler::DeclareLocalizedValues(
     LocalizedValuesBuilder* builder) {
   builder->Add("passwordHint", IDS_LOGIN_POD_EMPTY_PASSWORD_TEXT);
   builder->Add("podMenuButtonAccessibleName",
                IDS_LOGIN_POD_MENU_BUTTON_ACCESSIBLE_NAME);
   builder->Add("podMenuRemoveItemAccessibleName",
                IDS_LOGIN_POD_MENU_REMOVE_ITEM_ACCESSIBLE_NAME);
   builder->Add("passwordFieldAccessibleName",
@@ skipping 382 matching lines @@
   return NULL;
 }
 
 void SigninScreenHandler::RegisterMessages() {
   AddCallback("usingSAMLAPI", &SigninScreenHandler::HandleUsingSAMLAPI);
   AddCallback("scrapedPasswordCount",
               &SigninScreenHandler::HandleScrapedPasswordCount);
   AddCallback("scrapedPasswordVerificationFailed",
               &SigninScreenHandler::HandleScrapedPasswordVerificationFailed);
   AddCallback("authenticateUser", &SigninScreenHandler::HandleAuthenticateUser);
+  AddCallback("attemptUnlock", &SigninScreenHandler::HandleAttemptUnlock);
   AddCallback("completeLogin", &SigninScreenHandler::HandleCompleteLogin);
   AddCallback("completeAuthentication",
               &SigninScreenHandler::HandleCompleteAuthentication);
   AddCallback("getUsers", &SigninScreenHandler::HandleGetUsers);
   AddCallback("launchDemoUser", &SigninScreenHandler::HandleLaunchDemoUser);
   AddCallback("launchIncognito", &SigninScreenHandler::HandleLaunchIncognito);
   AddCallback("showLocallyManagedUserCreationScreen",
               &SigninScreenHandler::HandleShowLocallyManagedUserCreationScreen);
   AddCallback("launchPublicAccount",
               &SigninScreenHandler::HandleLaunchPublicAccount);
@@ skipping 24 matching lines @@
   AddCallback("resyncUserData", &SigninScreenHandler::HandleResyncUserData);
   AddCallback("loginUIStateChanged",
               &SigninScreenHandler::HandleLoginUIStateChanged);
   AddCallback("unlockOnLoginSuccess",
               &SigninScreenHandler::HandleUnlockOnLoginSuccess);
   AddCallback("showLoadingTimeoutError",
               &SigninScreenHandler::HandleShowLoadingTimeoutError);
   AddCallback("updateOfflineLogin",
               &SigninScreenHandler::HandleUpdateOfflineLogin);
   AddCallback("focusPod", &SigninScreenHandler::HandleFocusPod);
-  AddCallback("customButtonClicked",
-              &SigninScreenHandler::HandleCustomButtonClicked);
   AddCallback("retrieveAuthenticatedUserEmail",
               &SigninScreenHandler::HandleRetrieveAuthenticatedUserEmail);
 
   // This message is sent by the kiosk app menu, but is handled here
   // so we can tell the delegate to launch the app.
   AddCallback("launchKioskApp", &SigninScreenHandler::HandleLaunchKioskApp);
 }
 
 void SigninScreenHandler::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kUsersLRUInputMethod);
@@ skipping 45 matching lines @@
     SendUserList(false);
     UpdateUIState(UI_STATE_ACCOUNT_PICKER, NULL);
   }
   preferences_changed_delayed_ = false;
 }
 
 void SigninScreenHandler::ResetSigninScreenHandlerDelegate() {
   SetDelegate(NULL);
 }
 
-void SigninScreenHandler::ShowBannerMessage(const std::string& message) {
-  CallJS("login.AccountPickerScreen.showBannerMessage", message);
-}
-
-void SigninScreenHandler::ShowUserPodButton(
-    const std::string& username,
-    const std::string& iconURL,
-    const base::Closure& click_callback) {
-  user_pod_button_callback_map_[username] = click_callback;
-  CallJS("login.AccountPickerScreen.showUserPodButton", username, iconURL);
-
-  // TODO(tengs): Move this code once we move unlocking to native code.
-  if (ScreenLocker::default_screen_locker()) {
-    UserManager* user_manager = UserManager::Get();
-    const User* user = user_manager->FindUser(username);
-    if (!user)
-      return;
-    PrefService* profile_prefs =
-        user_manager->GetProfileByUser(user)->GetPrefs();
-    if (profile_prefs->GetBoolean(prefs::kEasyUnlockShowTutorial)) {
-      CallJS("login.AccountPickerScreen.showEasyUnlockBubble");
-      profile_prefs->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
-    }
-  }
-}
-
-void SigninScreenHandler::HideUserPodButton(const std::string& username) {
-  CallJS("login.AccountPickerScreen.hideUserPodButton", username);
-}
-
-void SigninScreenHandler::SetAuthType(const std::string& username,
-                                      LoginDisplay::AuthType auth_type,
-                                      const std::string& initial_value) {
-  user_auth_type_map_[username] = auth_type;
-  CallJS("login.AccountPickerScreen.setAuthType",
-         username,
-         static_cast<int>(auth_type),
-         base::StringValue(initial_value));
-}
-
-LoginDisplay::AuthType SigninScreenHandler::GetAuthType(
-    const std::string& username) const {
-  if (user_auth_type_map_.find(username) == user_auth_type_map_.end())
-    return LoginDisplay::OFFLINE_PASSWORD;
-  return user_auth_type_map_.find(username)->second;
-}
-
 void SigninScreenHandler::ShowError(int login_attempts,
                                     const std::string& error_text,
                                     const std::string& help_link_text,
                                     HelpAppLauncher::HelpTopic help_topic_id) {
   core_oobe_actor_->ShowSignInError(login_attempts, error_text, help_link_text,
                                     help_topic_id);
 }
 
 void SigninScreenHandler::ShowErrorScreen(LoginDisplay::SigninError error_id) {
   switch (error_id) {
@@ skipping 13 matching lines @@
 void SigninScreenHandler::ShowControlBar(bool show) {
   core_oobe_actor_->ShowControlBar(show);
 }
 
 void SigninScreenHandler::ShowGaiaPasswordChanged(const std::string& username) {
   email_ = username;
   password_changed_for_.insert(email_);
   core_oobe_actor_->ShowSignInUI(email_);
   CallJS("login.setAuthType",
          username,
-         static_cast<int>(LoginDisplay::ONLINE_SIGN_IN),
+         static_cast<int>(ONLINE_SIGN_IN),
          base::StringValue(""));
 }
 
 void SigninScreenHandler::ShowPasswordChangedDialog(bool show_password_error) {
   core_oobe_actor_->ShowPasswordChangedScreen(show_password_error);
 }
 
 void SigninScreenHandler::ShowSigninScreenForCreds(
     const std::string& username,
     const std::string& password) {
@@ skipping 47 matching lines @@
       // Don't reload auth extension if proxy auth dialog was cancelled.
       has_pending_auth_ui_ = false;
       update_state_closure_.Cancel();
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification " << type;
   }
 }
 
+void SigninScreenHandler::ShowBannerMessage(const std::string& message) {
+  CallJS("login.AccountPickerScreen.showBannerMessage", message);
+}
+
+void SigninScreenHandler::ShowUserPodCustomIcon(
+    const std::string& username,
+    const gfx::Image& icon) {
+  GURL icon_url(webui::GetBitmapDataUrl(icon.AsBitmap()));
+  CallJS("login.AccountPickerScreen.showUserPodCustomIcon",
+      username, icon_url.spec());
+
+  // TODO(tengs): Move this code once we move unlocking to native code.
+  if (ScreenLocker::default_screen_locker()) {
+    UserManager* user_manager = UserManager::Get();
+    const User* user = user_manager->FindUser(username);
+    if (!user)
+      return;
+    PrefService* profile_prefs =
+        user_manager->GetProfileByUser(user)->GetPrefs();
+    if (profile_prefs->GetBoolean(prefs::kEasyUnlockShowTutorial)) {
+      CallJS("login.AccountPickerScreen.showEasyUnlockBubble");
+      profile_prefs->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+    }
+  }
+}
+
+void SigninScreenHandler::HideUserPodCustomIcon(const std::string& username) {
+  CallJS("login.AccountPickerScreen.hideUserPodCustomIcon", username);
+}
+
+void SigninScreenHandler::EnableInput() {
+  // Only for lock screen at the moment.
+  ScreenLocker::default_screen_locker()->EnableInput();
+}
+
+void SigninScreenHandler::SetAuthType(
+    const std::string& username,
+    ScreenlockBridge::LockHandler::AuthType auth_type,
+    const std::string& initial_value) {
+  user_auth_type_map_[username] = auth_type;
+  CallJS("login.AccountPickerScreen.setAuthType",
+         username,
+         static_cast<int>(auth_type),
+         base::StringValue(initial_value));
+}
+
+ScreenlockBridge::LockHandler::AuthType SigninScreenHandler::GetAuthType(
+    const std::string& username) const {
+  if (user_auth_type_map_.find(username) == user_auth_type_map_.end())
+    return OFFLINE_PASSWORD;
+  return user_auth_type_map_.find(username)->second;
+}
+
+void SigninScreenHandler::Unlock(const std::string& user_email) {
+  DCHECK(ScreenLocker::default_screen_locker());
+  ScreenLocker::Hide();
+}
+
 void SigninScreenHandler::OnDnsCleared() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   dns_clear_task_running_ = false;
   dns_cleared_ = true;
   ShowSigninScreenIfReady();
 }
 
 // Update keyboard layout to least recently used by the user.
 void SigninScreenHandler::SetUserInputMethod(const std::string& username) {
   UserManager* user_manager = UserManager::Get();
@@ skipping 156 matching lines @@
 
 void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
                                                  const std::string& password) {
   if (!delegate_)
     return;
   delegate_->Login(UserContext(gaia::SanitizeEmail(username),
                                password,
                                std::string()));  // auth_code
 }
 
+void SigninScreenHandler::HandleAttemptUnlock(const std::string& username) {
+  DCHECK(ScreenLocker::default_screen_locker());
+
+  const User* unlock_user = NULL;
+  const UserList& users = delegate_->GetUsers();
+  for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
+    if ((*it)->email() == username) {
+      unlock_user = *it;
+      break;
+    }
+  }
+  if (!unlock_user)
+    return;
+
+  Profile* profile = UserManager::Get()->GetProfileByUser(unlock_user);
+  extensions::ScreenlockPrivateEventRouter* router =
+      extensions::ScreenlockPrivateEventRouter::GetFactoryInstance()->Get(
+          profile);
+  router->OnAuthAttempted(GetAuthType(username), "");
+}
+
 void SigninScreenHandler::HandleLaunchDemoUser() {
   if (delegate_)
     delegate_->LoginAsRetailModeUser();
 }
 
 void SigninScreenHandler::HandleLaunchIncognito() {
   if (delegate_)
     delegate_->LoginAsGuest();
 }
 
@@ skipping 81 matching lines @@
   }
 }
 
 void SigninScreenHandler::HandleToggleKioskAutolaunchScreen() {
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   if (delegate_ && !connector->IsEnterpriseManaged())
     delegate_->ShowKioskAutolaunchScreen();
 }
 
-void SigninScreenHandler::FillUserDictionary(User* user,
-                                             bool is_owner,
-                                             bool is_signin_to_add,
-                                             LoginDisplay::AuthType auth_type,
-                                             base::DictionaryValue* user_dict) {
+void SigninScreenHandler::FillUserDictionary(
+    User* user,
+    bool is_owner,
+    bool is_signin_to_add,
+    ScreenlockBridge::LockHandler::AuthType auth_type,
+    base::DictionaryValue* user_dict) {
   const std::string& email = user->email();
   const bool is_public_account =
       user->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT;
   const bool is_locally_managed_user =
       user->GetType() == User::USER_TYPE_LOCALLY_MANAGED;
 
   user_dict->SetString(kKeyUsername, email);
   user_dict->SetString(kKeyEmailAddress, user->display_email());
   user_dict->SetString(kKeyDisplayName, user->GetDisplayName());
   user_dict->SetBoolean(kKeyPublicAccount, is_public_account);
@@ skipping 37 matching lines @@
   BootTimesLoader::Get()->RecordCurrentStats("login-send-user-list");
 
   base::ListValue users_list;
   const UserList& users = delegate_->GetUsers();
 
   // TODO(nkostylev): Move to a separate method in UserManager.
   // http://crbug.com/230852
   bool is_signin_to_add = LoginDisplayHostImpl::default_host() &&
       UserManager::Get()->IsUserLoggedIn();
 
-  user_pod_button_callback_map_.clear();
   user_auth_type_map_.clear();
 
   bool single_user = users.size() == 1;
   std::string owner;
   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
   bool has_owner = owner.size() > 0;
   size_t max_non_owner_users = has_owner ? kMaxUsers - 1 : kMaxUsers;
   size_t non_owner_count = 0;
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->
           browser_policy_connector_chromeos();
   bool is_enterprise_managed = connector->IsEnterpriseManaged();
 
 
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     const std::string& email = (*it)->email();
     bool is_owner = (email == owner);
     bool is_public_account =
         ((*it)->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT);
 
     if ((is_public_account && !is_signin_to_add) ||
         is_owner ||
         (!is_public_account && non_owner_count < max_non_owner_users)) {
-      LoginDisplay::AuthType initial_auth_type =
-          ShouldForceOnlineSignIn(*it) ? LoginDisplay::ONLINE_SIGN_IN
-                                       : LoginDisplay::OFFLINE_PASSWORD;
+      AuthType initial_auth_type =
+          ShouldForceOnlineSignIn(*it) ? ONLINE_SIGN_IN : OFFLINE_PASSWORD;
       user_auth_type_map_[email] = initial_auth_type;
 
       base::DictionaryValue* user_dict = new base::DictionaryValue();
       FillUserDictionary(
           *it, is_owner, is_signin_to_add, initial_auth_type, user_dict);
       bool signed_in = (*it)->is_logged_in();
       // Single user check here is necessary because owner info might not be
       // available when running into login screen on first boot.
       // See http://crosbug.com/12723
       bool can_remove_user = ((!single_user || is_enterprise_managed) &&
@@ skipping 31 matching lines @@
   PrefService* prefs = g_browser_process->local_state();
   if (prefs->GetBoolean(prefs::kFactoryResetRequested)) {
     if (core_oobe_actor_)
       core_oobe_actor_->ShowDeviceResetScreen();
     return;
   }
 
   is_account_picker_showing_first_time_ = true;
   MaybePreloadAuthExtension();
 
-  if (ScreenLocker::default_screen_locker())
+  if (ScreenLocker::default_screen_locker()) {
     ScreenLocker::default_screen_locker()->delegate()->OnLockWebUIReady();
+    ScreenlockBridge::Get()->SetLockHandler(this);
+  }
 
   if (delegate_)
     delegate_->OnSigninScreenReady();
 }
 
 void SigninScreenHandler::HandleWallpaperReady() {
   if (ScreenLocker::default_screen_locker()) {
     ScreenLocker::default_screen_locker()->delegate()->
         OnLockBackgroundDisplayed();
   }
@@ skipping 125 matching lines @@
 
 void SigninScreenHandler::HandleUpdateOfflineLogin(bool offline_login_active) {
   offline_login_active_ = offline_login_active;
 }
 
 void SigninScreenHandler::HandleFocusPod(const std::string& user_id) {
   SetUserInputMethod(user_id);
   WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
 }
 
-void SigninScreenHandler::HandleCustomButtonClicked(
-    const std::string& username) {
-  if (user_pod_button_callback_map_.find(username)
-      == user_pod_button_callback_map_.end()) {
-    LOG(WARNING) << "User pod custom button clicked but no callback found";
-    return;
-  }
-  user_pod_button_callback_map_[username].Run();
-}
-
 void SigninScreenHandler::HandleRetrieveAuthenticatedUserEmail(
     double attempt_token) {
   email_retriever_.reset(new AuthenticatedUserEmailRetriever(
       base::Bind(&SigninScreenHandler::CallJS<double, std::string>,
                  base::Unretained(this),
                  "login.GaiaSigninScreen.setAuthenticatedUserEmail",
                  attempt_token),
       Profile::FromWebUI(web_ui())->GetRequestContext()));
 }
 
@@ skipping 191 matching lines @@
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_state();
 }
 
 net::Error SigninScreenHandler::FrameError() const {
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_error();
 }
 
 }  // namespace chromeos