ChromeOS: "Add New User" screen should enable all hardware keyboards.

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 <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 157 matching lines @@
 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,
-    chromeos::input_method::InputMethodManager* manager) {
-  PrefService* const local_state = g_browser_process->local_state();
-
-  const base::DictionaryValue* users_lru_input_methods =
-      local_state->GetDictionary(prefs::kUsersLRUInputMethod);
-
-  if (users_lru_input_methods == NULL) {
-    DLOG(WARNING) << "SetUserInputMethod('" << username
-                  << "'): no kUsersLRUInputMethod";
-    return false;
-  }
-
-  std::string input_method;
-
-  if (!users_lru_input_methods->GetStringWithoutPathExpansion(username,
-                                                              &input_method)) {
-    DVLOG(0) << "SetUserInputMethod('" << username
-               << "'): no input method for this user";
-    return false;
-  }
-
-  if (input_method.empty())
-    return false;
-
-  if (!manager->IsLoginKeyboard(input_method)) {
+    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 LRU input method '" << input_method
+                 << "'): stored user LRU 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::kUsersLRUInputMethod);
 
     base::DictionaryValue* const users_lru_input_methods = updater.Get();
     if (users_lru_input_methods != NULL) {
       users_lru_input_methods->SetStringWithoutPathExpansion(username, "");
     }
     return false;
   }
 
-  if (!Contains(manager->GetActiveIMEState()->GetActiveInputMethodIds(),
-                input_method)) {
-    if (!manager->GetActiveIMEState()->EnableInputMethod(input_method)) {
+  if (!Contains(ime_state->GetActiveInputMethodIds(), user_input_method)) {
+    if (!ime_state->EnableInputMethod(user_input_method)) {
       DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << username
-                  << "'): user input method '" << input_method
+                  << "'): user input method '" << user_input_method
                   << "' is not enabled and enabling failed (ignored!).";
     }
   }
-  manager->GetActiveIMEState()->ChangeInputMethod(input_method,
-                                                  false /* show_message */);
+  ime_state->ChangeInputMethod(user_input_method, false /* show_message */);
 
   return true;
 }
 
 }  // namespace
 
 // LoginScreenContext implementation ------------------------------------------
 
 LoginScreenContext::LoginScreenContext() {
   Init();
@@ skipping 70 matching lines @@
   policy::ConsumerManagementService* consumer_management =
       g_browser_process->platform_part()->browser_policy_connector_chromeos()->
           GetConsumerManagementService();
   is_enrolling_consumer_management_ =
       consumer_management &&
       consumer_management->GetEnrollmentStage() ==
           policy::ConsumerManagementService::ENROLLMENT_STAGE_REQUESTED;
 }
 
 SigninScreenHandler::~SigninScreenHandler() {
+  OobeUI* oobe_ui = GetOobeUI();
+  if (oobe_ui)
+    oobe_ui->RemoveObserver(this);
   chromeos::input_method::ImeKeyboard* keyboard =
       chromeos::input_method::InputMethodManager::Get()->GetImeKeyboard();
   if (keyboard)
     keyboard->RemoveObserver(this);
   weak_factory_.InvalidateWeakPtrs();
   if (delegate_)
     delegate_->SetWebUIHandler(NULL);
   network_state_informer_->RemoveObserver(this);
   if (max_mode_delegate_) {
     max_mode_delegate_->RemoveObserver(this);
@@ skipping 151 matching lines @@
 }
 
 // SigninScreenHandler, private: -----------------------------------------------
 
 void SigninScreenHandler::ShowImpl() {
   if (!page_is_ready()) {
     show_on_init_ = true;
     return;
   }
 
+  if (!ime_state_)
+    ime_state_ = input_method::InputMethodManager::Get()->GetActiveIMEState();
+
+  GetOobeUI()->AddObserver(this);
+
   if (oobe_ui_ || is_enrolling_consumer_management_) {
     // Shows new user sign-in for OOBE.
     OnShowAddUser();
   } else {
     // Populates account picker. Animation is turned off for now until we
     // figure out how to make it fast enough.
     delegate_->HandleGetUsers();
 
     // Reset Caps Lock state when login screen is shown.
     input_method::InputMethodManager::Get()
@@ skipping 288 matching lines @@
 
   // This message is sent by the kiosk app menu, but is handled here
   // so we can tell the delegate to launch the app.
   AddCallback("launchKioskApp", &SigninScreenHandler::HandleLaunchKioskApp);
 }
 
 void SigninScreenHandler::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kUsersLRUInputMethod);
 }
 
+void SigninScreenHandler::OnCurrentScreenChanged(OobeUI::Screen current_screen,
+                                                 OobeUI::Screen new_screen) {
+  if (new_screen == OobeUI::SCREEN_ACCOUNT_PICKER) {
+    // Restore active IME state if returning to user pod row screen.
+    input_method::InputMethodManager::Get()->SetState(ime_state_);
+  }
+}
+
+std::string SigninScreenHandler::GetUserLRUInputMethod(
+    const std::string& username) const {
+  PrefService* const local_state = g_browser_process->local_state();
+  const base::DictionaryValue* users_lru_input_methods =
+      local_state->GetDictionary(prefs::kUsersLRUInputMethod);
+
+  if (users_lru_input_methods == NULL) {
+    DLOG(WARNING) << "GetUserLRUInputMethod('" << username
+                  << "'): no kUsersLRUInputMethod";
+    return std::string();
+  }
+
+  std::string input_method;
+
+  if (!users_lru_input_methods->GetStringWithoutPathExpansion(username,
+                                                              &input_method)) {
+    DVLOG(0) << "GetUserLRUInputMethod('" << username
+             << "'): no input method for this user";
+    return std::string();
+  }
+
+  return input_method;
+}
+
 void SigninScreenHandler::HandleGetUsers() {
   if (delegate_)
     delegate_->HandleGetUsers();
 }
 
 void SigninScreenHandler::ClearAndEnablePassword() {
   core_oobe_actor_->ResetSignInUI(false);
 }
 
 void SigninScreenHandler::ClearUserPodPassword() {
@@ skipping 186 matching lines @@
 
 bool SigninScreenHandler::ShouldLoadGaia() const {
   // Fetching of the extension is not started before account picker page is
   // loaded because it can affect the loading speed.
   // Do not load the extension for the screen locker, see crosbug.com/25018.
   return !ScreenLocker::default_screen_locker() &&
          is_account_picker_showing_first_time_;
 }
 
 // Update keyboard layout to least recently used by the user.
-void SigninScreenHandler::SetUserInputMethod(const std::string& username) {
+void SigninScreenHandler::SetUserInputMethod(
+    const std::string& username,
+    input_method::InputMethodManager::State* ime_state) {
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (user_manager->IsUserLoggedIn()) {
     // We are on sign-in screen inside user session (adding new user to
     // the session or on lock screen), don't switch input methods in this case.
     // TODO(dpolukhin): adding user and sign-in should be consistent
     // crbug.com/292774
     return;
   }
 
-  chromeos::input_method::InputMethodManager* const manager =
-      chromeos::input_method::InputMethodManager::Get();
+  bool succeed = false;
 
-  const bool succeed = SetUserInputMethodImpl(username, manager);
+  const std::string input_method = GetUserLRUInputMethod(username);
+
+  if (!input_method.empty())
+    succeed = SetUserInputMethodImpl(username, input_method, ime_state);
 
   // This is also a case when LRU 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.";
 
-    manager->GetActiveIMEState()->SetInputMethodLoginDefault();
+    ime_state->SetInputMethodLoginDefault();
   }
 }
 
 
 void SigninScreenHandler::UserSettingsChanged() {
   DCHECK(gaia_screen_handler_);
   GaiaContext context;
   if (delegate_)
     context.has_users = !delegate_->GetUsers().empty();
   gaia_screen_handler_->UpdateGaia(context);
@@ skipping 282 matching lines @@
 
 void SigninScreenHandler::HandleShowLoadingTimeoutError() {
   UpdateState(ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT);
 }
 
 void SigninScreenHandler::HandleUpdateOfflineLogin(bool offline_login_active) {
   offline_login_active_ = offline_login_active;
 }
 
 void SigninScreenHandler::HandleFocusPod(const std::string& user_id) {
-  SetUserInputMethod(user_id);
+  SetUserInputMethod(user_id, ime_state_.get());
   WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
 }
 
 void SigninScreenHandler::HandleHardlockPod(const std::string& user_id) {
   SetAuthType(user_id,
               ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
               base::string16());
   HideUserPodCustomIcon(user_id);
 }
 
@@ skipping 81 matching lines @@
   return true;
 }
 
 void SigninScreenHandler::CancelPasswordChangedFlowInternal() {
   if (delegate_) {
     ShowImpl();
     delegate_->CancelPasswordChangedFlow();
   }
 }
 
+OobeUI* SigninScreenHandler::GetOobeUI() const {
+  return static_cast<OobeUI*>(web_ui()->GetController());
+}
+
 OobeUI::Screen SigninScreenHandler::GetCurrentScreen() const {
   OobeUI::Screen screen = OobeUI::SCREEN_UNKNOWN;
-  OobeUI* oobe_ui = static_cast<OobeUI*>(web_ui()->GetController());
+  OobeUI* oobe_ui = GetOobeUI();
   if (oobe_ui)
     screen = oobe_ui->current_screen();
   return screen;
 }
 
 bool SigninScreenHandler::IsGaiaVisible() const {
   return IsSigninScreen(GetCurrentScreen()) &&
       ui_state_ == UI_STATE_GAIA_SIGNIN;
 }
 
@@ skipping 70 matching lines @@
   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_);
 }
 
 }  // namespace chromeos