Move screenlock_bridge to components/proximity_auth

chrome/browser/ui/webui/signin/user_manager_screen_handler.cc

 // Copyright 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/signin/user_manager_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/screenlock_private/screenlock_private_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_info_cache_observer.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
+#include "chrome/browser/signin/easy_unlock_util.h"
 #include "chrome/browser/signin/local_auth.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/user_manager.h"
@@ skipping 256 matching lines @@
 
 UserManagerScreenHandler::UserManagerScreenHandler()
     : desktop_type_(chrome::GetActiveDesktop()),
       weak_ptr_factory_(this) {
   profileInfoCacheObserver_.reset(
       new UserManagerScreenHandler::ProfileUpdateObserver(
           g_browser_process->profile_manager(), this));
 }
 
 UserManagerScreenHandler::~UserManagerScreenHandler() {
-  ScreenlockBridge::Get()->SetLockHandler(NULL);
+  GetScreenlockBridgeInstance()->SetLockHandler(NULL);
 }
 
 void UserManagerScreenHandler::ShowBannerMessage(
     const base::string16& message) {
   web_ui()->CallJavascriptFunction(
       "login.AccountPickerScreen.showBannerMessage",
       base::StringValue(message));
 }
 
 void UserManagerScreenHandler::ShowUserPodCustomIcon(
     const std::string& user_email,
-    const ScreenlockBridge::UserPodCustomIconOptions& icon_options) {
+    const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions&
+        icon_options) {
   scoped_ptr<base::DictionaryValue> icon = icon_options.ToDictionaryValue();
   if (!icon || icon->empty())
     return;
   web_ui()->CallJavascriptFunction(
       "login.AccountPickerScreen.showUserPodCustomIcon",
       base::StringValue(user_email),
       *icon);
 }
 
 void UserManagerScreenHandler::HideUserPodCustomIcon(
     const std::string& user_email) {
   web_ui()->CallJavascriptFunction(
       "login.AccountPickerScreen.hideUserPodCustomIcon",
       base::StringValue(user_email));
 }
 
 void UserManagerScreenHandler::EnableInput() {
   // Nothing here because UI is not disabled when starting to authenticate.
 }
 
 void UserManagerScreenHandler::SetAuthType(
     const std::string& user_email,
-    ScreenlockBridge::LockHandler::AuthType auth_type,
+    proximity_auth::ScreenlockBridge::LockHandler::AuthType auth_type,
     const base::string16& auth_value) {
   if (GetAuthType(user_email) ==
-          ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD)
+      proximity_auth::ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD)
     return;
 
   user_auth_type_map_[user_email] = auth_type;
   web_ui()->CallJavascriptFunction(
       "login.AccountPickerScreen.setAuthType",
       base::StringValue(user_email),
       base::FundamentalValue(auth_type),
       base::StringValue(auth_value));
 }
 
-ScreenlockBridge::LockHandler::AuthType UserManagerScreenHandler::GetAuthType(
-      const std::string& user_email) const {
+proximity_auth::ScreenlockBridge::LockHandler::AuthType
+UserManagerScreenHandler::GetAuthType(const std::string& user_email) const {
   UserAuthTypeMap::const_iterator it = user_auth_type_map_.find(user_email);
   if (it == user_auth_type_map_.end())
-    return ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
+    return proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
   return it->second;
 }
 
-ScreenlockBridge::LockHandler::ScreenType
+proximity_auth::ScreenlockBridge::LockHandler::ScreenType
 UserManagerScreenHandler::GetScreenType() const {
-  return ScreenlockBridge::LockHandler::LOCK_SCREEN;
+  return proximity_auth::ScreenlockBridge::LockHandler::LOCK_SCREEN;
 }
 
 void UserManagerScreenHandler::Unlock(const std::string& user_email) {
   const ProfileInfoCache& info_cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   const size_t profile_index =
       GetIndexOfProfileWithEmail(info_cache, user_email);
   DCHECK_LT(profile_index, info_cache.GetNumberOfProfiles());
 
   authenticating_profile_index_ = profile_index;
@@ skipping 11 matching lines @@
   // If the URL has a hash parameter, store it for later.
   args->GetString(0, &url_hash_);
 
   SendUserList();
   web_ui()->CallJavascriptFunction("cr.ui.Oobe.showUserManagerScreen",
       base::FundamentalValue(IsGuestModeEnabled()),
       base::FundamentalValue(IsAddPersonEnabled()));
   desktop_type_ = chrome::GetHostDesktopTypeForNativeView(
       web_ui()->GetWebContents()->GetNativeView());
 
-  ScreenlockBridge::Get()->SetLockHandler(this);
+  GetScreenlockBridgeInstance()->SetLockHandler(this);
 }
 
 void UserManagerScreenHandler::HandleAddUser(const base::ListValue* args) {
   if (!IsAddPersonEnabled()) {
     // The 'Add User' UI should not be showing.
     NOTREACHED();
     return;
   }
   profiles::CreateAndSwitchToNewProfile(
       desktop_type_,
@@ skipping 137 matching lines @@
     const base::ListValue* args) {
   std::string email;
   CHECK(args->GetString(0, &email));
   GetScreenlockRouter(email)->OnAuthAttempted(GetAuthType(email), "");
 }
 
 void UserManagerScreenHandler::HandleHardlockUserPod(
     const base::ListValue* args) {
   std::string email;
   CHECK(args->GetString(0, &email));
-  SetAuthType(email,
-              ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
-              base::string16());
+  SetAuthType(
+      email,
+      proximity_auth::ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
+      base::string16());
   HideUserPodCustomIcon(email);
 }
 
 void UserManagerScreenHandler::OnClientLoginSuccess(
     const ClientLoginResult& result) {
   LocalAuth::SetLocalAuthCredentials(authenticating_profile_index_,
                                      password_attempt_);
   ReportAuthenticationResult(true, ProfileMetrics::AUTH_ONLINE);
 }
 
@@ skipping 304 matching lines @@
     Profile* profile, Profile::CreateStatus profile_create_status) {
   Browser* browser = chrome::FindAnyBrowser(profile, false, desktop_type_);
   if (browser && browser->window()) {
     OnBrowserWindowReady(browser);
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }