Made possible to lock and unlock with several logged in users.

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"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "ash/wm/session_state_controller.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/timer.h"
-#include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/login_performer.h"
 #include "chrome/browser/chromeos/login/login_utils.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/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/signin_manager.h"
@@ skipping 112 matching lines @@
 }  // namespace
 
 namespace chromeos {
 
 // static
 ScreenLocker* ScreenLocker::screen_locker_ = NULL;
 
 //////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, public:
 
-ScreenLocker::ScreenLocker(const User& user)
-    : user_(user),
-      // TODO(oshima): support auto login mode (this is not implemented yet)
-      // http://crosbug.com/1881
-      unlock_on_input_(user_.email().empty()),
+ScreenLocker::ScreenLocker(const UserList& users)
+    : users_(users),
       locked_(false),
       start_time_(base::Time::Now()),
       login_status_consumer_(NULL),
       incorrect_passwords_count_(0),
       weak_factory_(this) {
   DCHECK(!screen_locker_);
   screen_locker_ = this;
 }
 
 void ScreenLocker::Init() {
   authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
   delegate_.reset(new WebUIScreenLocker(this));
-  delegate_->LockScreen(unlock_on_input_);
+  delegate_->LockScreen();
 }
 
 void ScreenLocker::OnLoginFailure(const LoginFailure& error) {
   content::RecordAction(UserMetricsAction("ScreenLocker_OnLoginFailure"));
   if (authentication_start_time_.is_null()) {
     LOG(ERROR) << "Start time is not set at authentication failure";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication failure: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationFailureTime", delta);
@@ skipping 19 matching lines @@
   incorrect_passwords_count_ = 0;
   if (authentication_start_time_.is_null()) {
     if (!user_context.username.empty())
       LOG(ERROR) << "Start time is not set at authentication success";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication success: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationSuccessTime", delta);
   }
 
-  Profile* profile = ProfileManager::GetDefaultProfile();
-  if (profile && !user_context.password.empty()) {
-    // We have a non-empty password, so notify listeners (such as the sync
-    // engine).
-    SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
-    DCHECK(signin);
-    GoogleServiceSigninSuccessDetails details(
-        signin->GetAuthenticatedUsername(),
-        user_context.password);
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
-        content::Source<Profile>(profile),
-        content::Details<const GoogleServiceSigninSuccessDetails>(&details));
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles)) {
+    // TODO(dzhioev): It seems like this branch never executed and should be
+    // removed before multi-profile enabling.
+    Profile* profile = ProfileManager::GetDefaultProfile();
+    if (profile && !user_context.password.empty()) {
+      // We have a non-empty password, so notify listeners (such as the sync
+      // engine).
+      SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
+      DCHECK(signin);
+      GoogleServiceSigninSuccessDetails details(
+          signin->GetAuthenticatedUsername(),
+          user_context.password);
+      content::NotificationService::current()->Notify(
+          chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
+          content::Source<Profile>(profile),
+          content::Details<const GoogleServiceSigninSuccessDetails>(&details));
+    }
+  }
+
+  if (const User* user = UserManager::Get()->FindUser(user_context.username)) {
+    if (!user->is_active())
+      UserManager::Get()->SwitchActiveUser(user_context.username);
+  } else {
+    NOTREACHED() << "Logged in user not found.";
   }
 
   authentication_capture_.reset(new AuthenticationParametersCapture());
   authentication_capture_->username = user_context.username;
   authentication_capture_->pending_requests = pending_requests;
   authentication_capture_->using_oauth = using_oauth;
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(ash::switches::kAshDisableNewLockAnimations)) {
     UnlockOnLoginSuccess();
@@ skipping 25 matching lines @@
         UserContext(authentication_capture_->username,
                     std::string(),   // password
                     std::string()),  // auth_code
         authentication_capture_->pending_requests,
         authentication_capture_->using_oauth);
   }
   authentication_capture_.reset();
   weak_factory_.InvalidateWeakPtrs();
 }
 
-void ScreenLocker::Authenticate(const string16& password) {
+void ScreenLocker::Authenticate(const UserContext& user_context) {
+  LOG_ASSERT(IsUserLoggedIn(user_context.username))
+      << "Invalid user trying to unlock.";
   authentication_start_time_ = base::Time::Now();
   delegate_->SetInputEnabled(false);
   delegate_->OnAuthenticate();
 
-  // If LoginPerformer instance exists,
-  // initial online login phase is still active.
-  if (LoginPerformer::default_performer()) {
-    DVLOG(1) << "Delegating authentication to LoginPerformer.";
-    LoginPerformer::default_performer()->PerformLogin(
-        UserContext(user_.email(),
-                    UTF16ToUTF8(password),
-                    std::string()),  // auth_code
-        LoginPerformer::AUTH_MODE_INTERNAL);
-  } else {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&Authenticator::AuthenticateToUnlock, authenticator_.get(),
-                   UserContext(user_.email(),
-                               UTF16ToUTF8(password),
-                               std::string())));  // auth_code
-  }
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&Authenticator::AuthenticateToUnlock,
+                 authenticator_.get(),
+                 user_context));
+}
+
+void ScreenLocker::AuthenticateByPassword(const std::string& password) {
+  LOG_ASSERT(users_.size() == 1);
+  Authenticate(UserContext(users_[0]->email(), password, ""));
 }
 
 void ScreenLocker::ClearErrors() {
   delegate_->ClearErrors();
 }
 
 void ScreenLocker::EnableInput() {
   delegate_->SetInputEnabled(true);
 }
 
@@ skipping 21 matching lines @@
 }
 
 // static
 void ScreenLocker::Show() {
   content::RecordAction(UserMetricsAction("ScreenLocker_Show"));
   DCHECK(base::MessageLoop::current()->type() == base::MessageLoop::TYPE_UI);
 
   // Check whether the currently logged in user is a guest account and if so,
   // refuse to lock the screen (crosbug.com/23764).
   // For a demo user, we should never show the lock screen (crosbug.com/27647).
-  // TODO(flackr): We can allow lock screen for guest accounts when
-  // unlock_on_input is supported by the WebUI screen locker.
   if (UserManager::Get()->IsLoggedInAsGuest() ||
       UserManager::Get()->IsLoggedInAsDemoUser()) {
     VLOG(1) << "Refusing to lock screen for guest/demo account";
     return;
   }
 
   // Exit fullscreen.
   Browser* browser = chrome::FindLastActiveWithHostDesktopType(
       chrome::HOST_DESKTOP_TYPE_ASH);
   // browser can be NULL if we receive a lock request before the first browser
   // window is shown.
   if (browser && browser->window()->IsFullscreen()) {
     chrome::ToggleFullscreenMode(browser);
   }
 
   if (!screen_locker_) {
     ScreenLocker* locker =
-        new ScreenLocker(*UserManager::Get()->GetLoggedInUser());
+        new ScreenLocker(UserManager::Get()->GetLRULoggedInUsers());
     VLOG(1) << "Created ScreenLocker " << locker;
     locker->Init();
   } else {
     VLOG(1) << "ScreenLocker " << screen_locker_ << " already exists; "
             << " calling session manager's HandleLockScreenShown D-Bus method";
     DBusThreadManager::Get()->GetSessionManagerClient()->
         NotifyLockScreenShown();
   }
 }
 
@@ skipping 78 matching lines @@
       content::Source<ScreenLocker>(this),
       content::Details<bool>(&state));
   VLOG(1) << "Calling session manager's HandleLockScreenShown D-Bus method";
   DBusThreadManager::Get()->GetSessionManagerClient()->NotifyLockScreenShown();
 }
 
 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
+