cros: Clean up screenlockPrivate plumbing.

chrome/browser/chromeos/login/screen_locker.cc

 // Copyright (c) 2012 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/chromeos/login/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/managed/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/user_adding_screen.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/webui_screen_locker.h"
 #include "chrome/browser/extensions/api/screenlock_private/screenlock_private_api.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/signin/screenlock_bridge.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/webui/chromeos/login/screenlock_icon_provider.h"
 #include "chrome/browser/ui/webui/chromeos/login/screenlock_icon_source.h"
 #include "chrome/common/chrome_switches.h"
 #include "chromeos/audio/chromeos_sounds.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/signin/core/browser/signin_manager.h"
@@ skipping 65 matching lines @@
 
  private:
   bool session_started_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockObserver);
 };
 
 ScreenLockObserver* g_screen_lock_observer = NULL;
 
-// TODO(xiyuan): Get rid of LoginDisplay::AuthType and the mappers below.
-ScreenlockBridge::LockHandler::AuthType ToLockHandlerAuthType(
-    LoginDisplay::AuthType auth_type) {
-  switch (auth_type) {
-    case LoginDisplay::OFFLINE_PASSWORD:
-      return ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
-    case LoginDisplay::ONLINE_SIGN_IN:
-      return ScreenlockBridge::LockHandler::ONLINE_SIGN_IN;
-    case LoginDisplay::NUMERIC_PIN:
-      return ScreenlockBridge::LockHandler::NUMERIC_PIN;
-    case LoginDisplay::USER_CLICK:
-      return ScreenlockBridge::LockHandler::USER_CLICK;
-  }
-  NOTREACHED();
-  return ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
-}
-
-LoginDisplay::AuthType FromLockHandlerAuthType(
-    ScreenlockBridge::LockHandler::AuthType auth_type) {
-  switch (auth_type) {
-    case ScreenlockBridge::LockHandler::OFFLINE_PASSWORD:
-      return LoginDisplay::OFFLINE_PASSWORD;
-    case ScreenlockBridge::LockHandler::ONLINE_SIGN_IN:
-      return LoginDisplay::ONLINE_SIGN_IN;
-    case ScreenlockBridge::LockHandler::NUMERIC_PIN:
-      return LoginDisplay::NUMERIC_PIN;
-    case ScreenlockBridge::LockHandler::USER_CLICK:
-      return LoginDisplay::USER_CLICK;
-  }
-  NOTREACHED();
-  return LoginDisplay::OFFLINE_PASSWORD;
-}
-
 }  // namespace
 
 // static
 ScreenLocker* ScreenLocker::screen_locker_ = NULL;
 
 //////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, public:
 
 ScreenLocker::ScreenLocker(const UserList& users)
     : users_(users),
@@ skipping 116 matching lines @@
 void ScreenLocker::Authenticate(const UserContext& user_context) {
   LOG_ASSERT(IsUserLoggedIn(user_context.GetUserID()))
       << "Invalid user trying to unlock.";
 
   authentication_start_time_ = base::Time::Now();
   delegate_->SetInputEnabled(false);
   delegate_->OnAuthenticate();
 
   // Send authentication request to chrome.screenlockPrivate API event router
   // if the authentication type is not the system password.
-  LoginDisplay::AuthType auth_type =
-      FromLockHandlerAuthType(GetAuthType(user_context.GetUserID()));
-  if (auth_type != LoginDisplay::OFFLINE_PASSWORD) {
+  ScreenlockBridge::LockHandler::AuthType auth_type =
+      ScreenlockBridge::Get()->lock_handler()->GetAuthType(
+          user_context.GetUserID());
+  if (auth_type != ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {

[Tim Song, 2014/05/16 18:38:47]

Does it still make sense to wire up the OnAuthAttempted event here rather than
the SigninScreenHandler? This event is routed from the UserManagerScreenHandler
in the non-ChromeOS case.

[xiyuan, 2014/05/16 23:00:56]

Done.

     const User* unlock_user = FindUnlockUser(user_context.GetUserID());
     LOG_ASSERT(unlock_user);
 
     Profile* profile = UserManager::Get()->GetProfileByUser(unlock_user);
     extensions::ScreenlockPrivateEventRouter* router =
         extensions::ScreenlockPrivateEventRouter::GetFactoryInstance()->Get(
             profile);
-    router->OnAuthAttempted(ToLockHandlerAuthType(auth_type),
+    router->OnAuthAttempted(auth_type,
                             user_context.GetPassword());
     return;
   }
 
   // Special case: supervised users. Use special authenticator.
   if (const User* user = FindUnlockUser(user_context.GetUserID())) {
     if (user->GetType() == User::USER_TYPE_LOCALLY_MANAGED) {
       UserContext updated_context =
           UserManager::Get()
               ->GetSupervisedUserManager()
@@ skipping 40 matching lines @@
   delegate_->ClearErrors();
   content::RecordAction(UserMetricsAction("ScreenLocker_Signout"));
   // We expect that this call will not wait for any user input.
   // If it changes at some point, we will need to force exit.
   chrome::AttemptUserExit();
 
   // Don't hide yet the locker because the chrome screen may become visible
   // briefly.
 }
 
-void ScreenLocker::ShowBannerMessage(const std::string& message) {
-  delegate_->ShowBannerMessage(message);
-}
-
-void ScreenLocker::ShowUserPodButton(const std::string& username,
-                                     const gfx::Image& icon,
-                                     const base::Closure& click_callback) {
-  if (!locked_)
-    return;
-
-  screenlock_icon_provider_->AddIcon(username, icon);
-
-  if (!username.empty()) {
-    // Append the current time to the URL so the image will not be cached.
-    std::string icon_url =
-        ScreenlockIconSource::GetIconURLForUser(username) + "?uniq=" +
-        base::Int64ToString(base::Time::Now().ToInternalValue());
-    delegate_->ShowUserPodButton(username, icon_url, click_callback);
-  }
-}
-
-void ScreenLocker::HideUserPodButton(const std::string& username) {
-  if (!locked_)
-    return;
-  screenlock_icon_provider_->RemoveIcon(username);
-  delegate_->HideUserPodButton(username);
-}
-
 void ScreenLocker::EnableInput() {
   delegate_->SetInputEnabled(true);
 }
 
-void ScreenLocker::SetAuthType(
-    const std::string& username,
-    ScreenlockBridge::LockHandler::AuthType auth_type,
-    const std::string& initial_value) {
-  if (!locked_)
-    return;
-  delegate_->SetAuthType(
-      username, FromLockHandlerAuthType(auth_type), initial_value);
-}
-
-ScreenlockBridge::LockHandler::AuthType ScreenLocker::GetAuthType(
-    const std::string& username) const {
-  // Return default authentication type when not locked.
-  if (!locked_)
-    return ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
-  return ToLockHandlerAuthType(delegate_->GetAuthType(username));
-}
-
-void ScreenLocker::Unlock(const std::string& user_email) {
-  chromeos::ScreenLocker::Hide();
-}
-
 void ScreenLocker::ShowErrorMessage(int error_msg_id,
                                     HelpAppLauncher::HelpTopic help_topic_id,
                                     bool sign_out_only) {
   delegate_->SetInputEnabled(!sign_out_only);
   delegate_->ShowErrorMessage(error_msg_id, help_topic_id);
 }
 
 void ScreenLocker::SetLoginStatusConsumer(
     chromeos::LoginStatusConsumer* consumer) {
   login_status_consumer_ = consumer;
@@ skipping 151 matching lines @@
       desktop_background_controller()->MoveDesktopToLockedContainer();
 
   bool state = true;
   VLOG(1) << "Emitting SCREEN_LOCK_STATE_CHANGED with state=" << state;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
       content::Source<ScreenLocker>(this),
       content::Details<bool>(&state));
   VLOG(1) << "Calling session manager's HandleLockScreenShown D-Bus method";
   DBusThreadManager::Get()->GetSessionManagerClient()->NotifyLockScreenShown();
-
-  ScreenlockBridge::Get()->SetLockHandler(this);
 }
 
 content::WebUI* ScreenLocker::GetAssociatedWebUI() {
   return delegate_->GetAssociatedWebUI();
 }
 
 bool ScreenLocker::IsUserLoggedIn(const std::string& username) {
   for (UserList::const_iterator it = users_.begin(); it != users_.end(); ++it) {
     if ((*it)->email() == username)
       return true;
   }
   return false;
 }
 
 }  // namespace chromeos