Rename ScreelockBridge to SigninScreenBridge

chrome/browser/chromeos/login/screens/user_selection_screen.cc

 // Copyright 2014 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/screens/user_selection_screen.h"
 
 #include "ash/shell.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
-#include "chrome/browser/signin/screenlock_bridge.h"
+#include "chrome/browser/signin/signin_screen_bridge.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "ui/wm/core/user_activity_detector.h"
 
 namespace chromeos {
 
 namespace {
@@ skipping 85 matching lines @@
   if (activity_detector->HasObserver(this))
     activity_detector->RemoveObserver(this);
 #endif
 }
 
 // static
 void UserSelectionScreen::FillUserDictionary(
     user_manager::User* user,
     bool is_owner,
     bool is_signin_to_add,
-    ScreenlockBridge::LockHandler::AuthType auth_type,
+    SigninScreenBridge::LockHandler::AuthType auth_type,
     const std::vector<std::string>* public_session_recommended_locales,
     base::DictionaryValue* user_dict) {
   const std::string& user_id = user->email();
   const bool is_public_session =
       user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT;
   const bool is_supervised_user =
       user->GetType() == user_manager::USER_TYPE_SUPERVISED;
 
   user_dict->SetString(kKeyUsername, user_id);
   user_dict->SetString(kKeyEmailAddress, user->display_email());
@@ skipping 142 matching lines @@
   for (user_manager::UserList::const_iterator it = users.begin();
        it != users.end();
        ++it) {
     const std::string& user_id = (*it)->email();
     bool is_owner = (user_id == owner);
     bool is_public_account =
         ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT);
 
     if ((is_public_account && !is_signin_to_add) || is_owner ||
         (!is_public_account && non_owner_count < max_non_owner_users)) {
-
       if (!is_owner)
         ++non_owner_count;
       if (is_owner && users_to_send.size() > kMaxUsers) {
         // Owner is always in the list.
         users_to_send.insert(users_to_send.begin() + (kMaxUsers - 1), *it);
         while (users_to_send.size() > kMaxUsers)
           users_to_send.erase(users_to_send.begin() + kMaxUsers);
       } else if (users_to_send.size() < kMaxUsers) {
         users_to_send.push_back(*it);
       }
@@ skipping 24 matching lines @@
   user_auth_type_map_.clear();
 
   const std::vector<std::string> kEmptyRecommendedLocales;
   for (user_manager::UserList::const_iterator it = users_to_send.begin();
        it != users_to_send.end();
        ++it) {
     const std::string& user_id = (*it)->email();
     bool is_owner = (user_id == owner);
     const bool is_public_account =
         ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT);
-    const ScreenlockBridge::LockHandler::AuthType initial_auth_type =
+    const SigninScreenBridge::LockHandler::AuthType initial_auth_type =
         is_public_account
-            ? ScreenlockBridge::LockHandler::EXPAND_THEN_USER_CLICK
+            ? SigninScreenBridge::LockHandler::EXPAND_THEN_USER_CLICK
             : (ShouldForceOnlineSignIn(*it)
-                   ? ScreenlockBridge::LockHandler::ONLINE_SIGN_IN
-                   : ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
+                   ? SigninScreenBridge::LockHandler::ONLINE_SIGN_IN
+                   : SigninScreenBridge::LockHandler::OFFLINE_PASSWORD);
     user_auth_type_map_[user_id] = initial_auth_type;
 
     base::DictionaryValue* user_dict = new base::DictionaryValue();
     const std::vector<std::string>* public_session_recommended_locales =
         public_session_recommended_locales_.find(user_id) ==
             public_session_recommended_locales_.end() ?
                 &kEmptyRecommendedLocales :
                 &public_session_recommended_locales_[user_id];
     FillUserDictionary(*it,
                        is_owner,
@@ skipping 14 matching lines @@
 
   handler_->LoadUsers(users_list, show_guest_);
 }
 
 void UserSelectionScreen::HandleGetUsers() {
   SendUserList();
 }
 
 void UserSelectionScreen::SetAuthType(
     const std::string& username,
-    ScreenlockBridge::LockHandler::AuthType auth_type) {
+    SigninScreenBridge::LockHandler::AuthType auth_type) {
   DCHECK(GetAuthType(username) !=
-             ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD ||
-         auth_type == ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD);
+             SigninScreenBridge::LockHandler::FORCE_OFFLINE_PASSWORD ||
+         auth_type == SigninScreenBridge::LockHandler::FORCE_OFFLINE_PASSWORD);
   user_auth_type_map_[username] = auth_type;
 }
 
-ScreenlockBridge::LockHandler::AuthType UserSelectionScreen::GetAuthType(
+SigninScreenBridge::LockHandler::AuthType UserSelectionScreen::GetAuthType(
     const std::string& username) const {
   if (user_auth_type_map_.find(username) == user_auth_type_map_.end())
-    return ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
+    return SigninScreenBridge::LockHandler::OFFLINE_PASSWORD;
   return user_auth_type_map_.find(username)->second;
 }
 
 }  // namespace chromeos