Adding mojo calls for several lock screen related operations.

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc

 // Copyright (c) 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/chromeos/login/signin_screen_handler.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 22 matching lines @@
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/browser/chromeos/lock_screen_apps/state_controller.h"
 #include "chrome/browser/chromeos/login/error_screens_histogram_helper.h"
 #include "chrome/browser/chromeos/login/hwid_checker.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/lock/webui_screen_locker.h"
+#include "chrome/browser/chromeos/login/lock_screen_utils.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_factory.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_storage.h"
 #include "chrome/browser/chromeos/login/reauth_stats.h"
 #include "chrome/browser/chromeos/login/screens/core_oobe_view.h"
 #include "chrome/browser/chromeos/login/screens/network_error.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/ui/login_feedback.h"
 #include "chrome/browser/chromeos/login/ui/webui_login_display.h"
@@ skipping 66 matching lines @@
 
 // Type of the login screen UI that is currently presented to user.
 const char kSourceGaiaSignin[] = "gaia-signin";
 const char kSourceAccountPicker[] = "account-picker";
 
 // Constants for lock screen apps activity state values:
 const char kNoLockScreenApps[] = "LOCK_SCREEN_APPS_STATE.NONE";
 const char kBackgroundLockScreenApps[] = "LOCK_SCREEN_APPS_STATE.BACKGROUND";
 const char kForegroundLockScreenApps[] = "LOCK_SCREEN_APPS_STATE.FOREGROUND";
 
-static bool Contains(const std::vector<std::string>& container,
-                     const std::string& value) {
-  return std::find(container.begin(), container.end(), value) !=
-         container.end();
-}
-
 class CallOnReturn {
  public:
   explicit CallOnReturn(const base::Closure& callback)
       : callback_(callback), call_scheduled_(false) {}
 
   ~CallOnReturn() {
     if (call_scheduled_ && !callback_.is_null())
       callback_.Run();
   }
 
@@ skipping 51 matching lines @@
 
 // Returns network name by service path.
 std::string GetNetworkName(const std::string& service_path) {
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!network)
     return std::string();
   return network->name();
 }
 
-static bool SetUserInputMethodImpl(
-    const std::string& username,
-    const std::string& user_input_method,
-    input_method::InputMethodManager::State* ime_state) {
-  if (!chromeos::input_method::InputMethodManager::Get()->IsLoginKeyboard(
-          user_input_method)) {
-    LOG(WARNING) << "SetUserInputMethod('" << username
-                 << "'): stored user last input method '" << user_input_method
-                 << "' is no longer Full Latin Keyboard Language"
-                 << " (entry dropped). Use hardware default instead.";
-
-    PrefService* const local_state = g_browser_process->local_state();
-    DictionaryPrefUpdate updater(local_state, prefs::kUsersLastInputMethod);
-
-    base::DictionaryValue* const users_last_input_methods = updater.Get();
-    if (users_last_input_methods != nullptr) {
-      users_last_input_methods->SetStringWithoutPathExpansion(username, "");
-    }
-    return false;
-  }
-
-  if (!Contains(ime_state->GetActiveInputMethodIds(), user_input_method)) {
-    if (!ime_state->EnableInputMethod(user_input_method)) {
-      DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << username
-                  << "'): user input method '" << user_input_method
-                  << "' is not enabled and enabling failed (ignored!).";
-    }
-  }
-  ime_state->ChangeInputMethod(user_input_method, false /* show_message */);
-
-  return true;
-}
-
-void EnforcePolicyInputMethods(std::string user_input_method) {
-  chromeos::CrosSettings* cros_settings = chromeos::CrosSettings::Get();
-  const base::ListValue* login_screen_input_methods = nullptr;
-  if (!cros_settings->GetList(chromeos::kDeviceLoginScreenInputMethods,
-                              &login_screen_input_methods)) {
-    return;
-  }
-
-  std::vector<std::string> allowed_input_methods;
-
-  // Add user's input method first so it is pre-selected.
-  if (!user_input_method.empty()) {
-    allowed_input_methods.push_back(user_input_method);
-  }
-
-  std::string input_method;
-  for (const auto& input_method_entry : *login_screen_input_methods) {
-    if (input_method_entry.GetAsString(&input_method))
-      allowed_input_methods.push_back(input_method);
-  }
-  chromeos::input_method::InputMethodManager* imm =
-      chromeos::input_method::InputMethodManager::Get();
-  imm->GetActiveIMEState()->SetAllowedInputMethods(allowed_input_methods);
-}
-
 void StopEnforcingPolicyInputMethods() {
   // Empty means all input methods are allowed
   std::vector<std::string> allowed_input_methods;
   chromeos::input_method::InputMethodManager* imm =
       chromeos::input_method::InputMethodManager::Get();
   imm->GetActiveIMEState()->SetAllowedInputMethods(allowed_input_methods);
 }
 
 }  // namespace
 
@@ skipping 92 matching lines @@
     keyboard->RemoveObserver(this);
   StopEnforcingPolicyInputMethods();
   weak_factory_.InvalidateWeakPtrs();
   if (delegate_)
     delegate_->SetWebUIHandler(nullptr);
   network_state_informer_->RemoveObserver(this);
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(nullptr);
   proximity_auth::ScreenlockBridge::Get()->SetFocusedUser(EmptyAccountId());
 }
 
-// static
-std::string SigninScreenHandler::GetUserLastInputMethod(
-    const std::string& username) {
-  PrefService* const local_state = g_browser_process->local_state();
-  const base::DictionaryValue* users_last_input_methods =
-      local_state->GetDictionary(prefs::kUsersLastInputMethod);
-
-  if (!users_last_input_methods) {
-    DLOG(WARNING) << "GetUserLastInputMethod('" << username
-                  << "'): no kUsersLastInputMethod";
-    return std::string();
-  }
-
-  std::string input_method;
-
-  if (!users_last_input_methods->GetStringWithoutPathExpansion(username,
-                                                               &input_method)) {
-    DVLOG(0) << "GetUserLastInputMethod('" << username
-             << "'): no input method for this user";
-    return std::string();
-  }
-
-  return input_method;
-}
-
-// static
-// Update keyboard layout to least recently used by the user.
-void SigninScreenHandler::SetUserInputMethod(
-    const std::string& username,
-    input_method::InputMethodManager::State* ime_state) {
-  bool succeed = false;
-
-  const std::string input_method = GetUserLastInputMethod(username);
-
-  EnforcePolicyInputMethods(input_method);
-
-  if (!input_method.empty())
-    succeed = SetUserInputMethodImpl(username, input_method, ime_state);
-
-  // This is also a case when last layout is set only for a few local users,
-  // thus others need to be switched to default locale.
-  // Otherwise they will end up using another user's locale to log in.
-  if (!succeed) {
-    DVLOG(0) << "SetUserInputMethod('" << username
-             << "'): failed to set user layout. Switching to default.";
-
-    ime_state->SetInputMethodLoginDefault();
-  }
-}
-
 void SigninScreenHandler::DeclareLocalizedValues(
     ::login::LocalizedValuesBuilder* builder) {
   // Format numbers to be used on the pin keyboard.
   for (int j = 0; j <= 9; j++) {
     builder->Add("pinKeyboard" + base::IntToString(j),
                  base::FormatNumber(int64_t{j}));
   }
 
   builder->Add("passwordHint", IDS_LOGIN_POD_EMPTY_PASSWORD_TEXT);
   builder->Add("pinKeyboardPlaceholderPin",
@@ skipping 1050 matching lines @@
     test_focus_pod_callback_.Run();
 
   focused_pod_account_id_ = base::MakeUnique<AccountId>(account_id);
 
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(account_id);
   // |user| may be nullptr in kiosk mode or unit tests.
   if (user && user->is_logged_in() && !user->is_active()) {
     SessionControllerClient::DoSwitchActiveUser(account_id);
   } else {
-    SetUserInputMethod(account_id.GetUserEmail(), ime_state_.get());
-    SetKeyboardSettings(account_id);
+    lock_screen_utils::SetUserInputMethod(account_id.GetUserEmail(),
+                                          ime_state_.get());
+    lock_screen_utils::SetKeyboardSettings(account_id);
     WallpaperManager::Get()->SetUserWallpaperDelayed(account_id);
 
     bool use_24hour_clock = false;
     if (user_manager::known_user::GetBooleanPref(
             account_id, prefs::kUse24HourClock, &use_24hour_clock)) {
       g_browser_process->platform_part()
           ->GetSystemClock()
           ->SetLastFocusedPodHourClockType(
               use_24hour_clock ? base::k24HourClock : base::k12HourClock);
     }
   }
 }
 
 void SigninScreenHandler::HandleNoPodFocused() {
   focused_pod_account_id_.reset();
-  EnforcePolicyInputMethods(std::string());
+  lock_screen_utils::EnforcePolicyInputMethods(std::string());
 }
 
 void SigninScreenHandler::HandleGetPublicSessionKeyboardLayouts(
     const AccountId& account_id,
     const std::string& locale) {
   GetKeyboardLayoutsForLocale(
       base::Bind(&SigninScreenHandler::SendPublicSessionKeyboardLayouts,
                  weak_factory_.GetWeakPtr(), account_id, locale),
       locale);
 }
@@ skipping 120 matching lines @@
   CrosSettings* cros_settings = CrosSettings::Get();
   if (!cros_settings)
     return false;
   bool allow_guest;
   cros_settings->GetBoolean(kAccountsPrefAllowGuest, &allow_guest);
   return allow_guest;
 }
 
 void SigninScreenHandler::OnShowAddUser() {
   is_account_picker_showing_first_time_ = false;
-  EnforcePolicyInputMethods(std::string());
+  lock_screen_utils::EnforcePolicyInputMethods(std::string());
   gaia_screen_handler_->ShowGaiaAsync();
 }
 
 net::Error SigninScreenHandler::FrameError() const {
   return gaia_screen_handler_->frame_error();
 }
 
 void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
   caps_lock_enabled_ = enabled;
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
 }
 
 void SigninScreenHandler::OnFeedbackFinished() {
   CallJS("login.UnrecoverableCryptohomeErrorScreen.resumeAfterFeedbackUI");
 
   // Recreate user's cryptohome after the feedback is attempted.
   HandleResyncUserData();
 }
 
 void SigninScreenHandler::OnAllowedInputMethodsChanged() {
   if (!webui_visible_)
     return;
 
   if (focused_pod_account_id_) {
-    std::string user_input_method =
-        GetUserLastInputMethod(focused_pod_account_id_->GetUserEmail());
-    EnforcePolicyInputMethods(user_input_method);
+    std::string user_input_method = lock_screen_utils::GetUserLastInputMethod(
+        focused_pod_account_id_->GetUserEmail());
+    lock_screen_utils::EnforcePolicyInputMethods(user_input_method);
   } else {
-    EnforcePolicyInputMethods(std::string());
+    lock_screen_utils::EnforcePolicyInputMethods(std::string());
   }
 }
 
-void SigninScreenHandler::SetKeyboardSettings(const AccountId& account_id) {
-  bool auto_repeat_enabled = language_prefs::kXkbAutoRepeatEnabled;
-  if (user_manager::known_user::GetBooleanPref(
-          account_id, prefs::kLanguageXkbAutoRepeatEnabled,
-          &auto_repeat_enabled) &&
-      !auto_repeat_enabled) {
-    input_method::InputMethodManager::Get()
-        ->GetImeKeyboard()
-        ->SetAutoRepeatEnabled(false);
-    return;
-  }
-
-  int auto_repeat_delay = language_prefs::kXkbAutoRepeatDelayInMs;
-  int auto_repeat_interval = language_prefs::kXkbAutoRepeatIntervalInMs;
-  user_manager::known_user::GetIntegerPref(
-      account_id, prefs::kLanguageXkbAutoRepeatDelay, &auto_repeat_delay);
-  user_manager::known_user::GetIntegerPref(
-      account_id, prefs::kLanguageXkbAutoRepeatInterval, &auto_repeat_interval);
-  input_method::AutoRepeatRate rate;
-  rate.initial_delay_in_ms = auto_repeat_delay;
-  rate.repeat_interval_in_ms = auto_repeat_interval;
-  input_method::InputMethodManager::Get()
-      ->GetImeKeyboard()
-      ->SetAutoRepeatEnabled(true);
-  input_method::InputMethodManager::Get()->GetImeKeyboard()->SetAutoRepeatRate(
-      rate);
-}
-
 }  // namespace chromeos