Refactor user pods to use authType property for distinct authentication modes.

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/audio/sounds.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.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/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/chromeos/extensions/screenlock_private_api.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 213 matching lines @@
   authentication_capture_.reset();
   weak_factory_.InvalidateWeakPtrs();
 
   VLOG(1) << "Hiding the lock screen.";
   chromeos::ScreenLocker::Hide();
 }
 
 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();
 
+  // Send authentication request to app using chrome.screenlockPrivate API
+  // if the authentication type is not the system password.
+  LoginDisplay::AuthType auth_type = GetAuthType(user_context.username);
+  if (auth_type != LoginDisplay::OFFLINE_PASSWORD) {
+    const User* unlock_user =
+        UserManager::Get()->FindUser(user_context.username);

[xiyuan, 2014/02/19 21:48:44]

nit: It's better use the |users_| of ScreenLocker, which is a subset of the user
list in UserManager and contains only the user that shows up.

[Tim Song, 2014/02/20 00:06:46]

Done.

+    LOG_ASSERT(unlock_user);
+    Profile* profile = UserManager::Get()->GetProfileByUser(unlock_user);
+    extensions::ScreenlockPrivateEventRouter* router =
+        extensions::ScreenlockPrivateEventRouter::GetFactoryInstance()
+            ->GetForProfile(profile);
+    router->OnAuthAttempted(auth_type, user_context.password);
+    return;
+  }
+
   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, ""));
@@ skipping 23 matching lines @@
 }
 
 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);
 
-  // Append the current time to the URL so the image will not be cached.
-  std::string icon_url = ScreenlockIconSource::GetIconURLForUser(username)
-       + "?" + base::Int64ToString(base::Time::Now().ToInternalValue());
-  delegate_->ShowUserPodButton(username, icon_url, click_callback);
+  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::SetAuthType(const std::string& username,
+                               LoginDisplay::AuthType auth_type,
+                               const std::string& initial_value) {
+  if (!locked_)
+    return;
+  delegate_->SetAuthType(username, auth_type, initial_value);
+}
+
+LoginDisplay::AuthType ScreenLocker::GetAuthType(const std::string& username)
+    const {
+  // Return default authentication type when not locked.
+  if (!locked_)
+    return LoginDisplay::OFFLINE_PASSWORD;
+  return delegate_->GetAuthType(username);
 }
 
 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(
@@ skipping 154 matching lines @@
 
 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