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 32 matching lines @@
       error_screen_actor_(error_screen_actor),
       core_oobe_actor_(core_oobe_actor),
       is_first_update_state_call_(true),
       offline_login_active_(false),
       last_network_state_(NetworkStateInformer::UNKNOWN),
       has_pending_auth_ui_(false),
       caps_lock_enabled_(chromeos::input_method::InputMethodManager::Get()
                              ->GetImeKeyboard()
                              ->CapsLockIsEnabled()),
       gaia_screen_handler_(gaia_screen_handler),
+      oobe_ui_observer_added_(false),
       weak_factory_(this) {
   DCHECK(network_state_informer_.get());
   DCHECK(error_screen_actor_);
   DCHECK(core_oobe_actor_);
   DCHECK(gaia_screen_handler_);
   gaia_screen_handler_->SetSigninScreenHandler(this);
   network_state_informer_->AddObserver(this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_NEEDED,
@@ skipping 18 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_observer_added_)
+    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 144 matching lines @@
 void SigninScreenHandler::OnNetworkReady() {
   VLOG(1) << "OnNetworkReady() call.";
   DCHECK(gaia_screen_handler_);
   gaia_screen_handler_->MaybePreloadAuthExtension();
 }
 
 void SigninScreenHandler::UpdateState(ErrorScreenActor::ErrorReason reason) {
   UpdateStateInternal(reason, false);
 }
 
+void SigninScreenHandler::SetFocusPODCallbackForTesting(
+    base::Closure callback) {
+  test_focus_pod_callback_ = callback;
+}
+
 // SigninScreenHandler, private: -----------------------------------------------
 
 void SigninScreenHandler::ShowImpl() {
   if (!page_is_ready()) {
     show_on_init_ = true;
     return;
   }
 
+  if (!ime_state_.get())
+    ime_state_ = input_method::InputMethodManager::Get()->GetActiveIMEState();
+
+  if (!oobe_ui_observer_added_) {
+    oobe_ui_observer_added_ = true;
+    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());
 #if !defined(USE_ATHENA)
   // TODO(dpolukhin):  crbug.com/408734.
   WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
 #endif
   ScreenlockBridge::Get()->SetFocusedUser(user_id);
+  if (!test_focus_pod_callback_.is_null())
+    test_focus_pod_callback_.Run();
 }
 
 void SigninScreenHandler::HandleHardlockPod(const std::string& user_id) {
   SetAuthType(user_id,
               ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
               base::string16());
   HideUserPodCustomIcon(user_id);
 }
 
 void SigninScreenHandler::HandleRetrieveAuthenticatedUserEmail(
@@ skipping 80 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