We should switch the keyboard layout to the layout the user set according to

chrome/browser/chromeos/input_method/input_method_manager_impl.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/input_method/input_method_manager_impl.h"
 
 #include <algorithm>  // std::find
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 90 matching lines @@
   const char* keyboard_id;
   const char* ime_id;
 } kMigrationHangulKeyboardToInputMethodID[] = {
   { "2", "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_2set" },
   { "3f", "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3setfinal" },
   { "39", "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3set390" },
   { "3s", "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3setnoshift" },
   { "ro", "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_romaja" },
 };
 
+static bool ContainsTwoLetterLanguageCode(
+    const std::vector<InputMethodManagerImpl::TwoLetterLanguageCode>& all,
+    const std::string& lang) {
+  if (lang.size() < 2) {
+    return false;
+  }
+  return std::binary_search(
+      all.begin(),
+      all.end(),
+      InputMethodManagerImpl::TwoLetterLanguageCode(lang.c_str()));
+}
+
+// A list of languages having full 26 latin letter set on keyboard.
+// (If all input methods of a given language can be used at login screen.)
+const char* kFullLatinKeyboardLanguageList[] = {

[Seigo Nonaka, 2013/07/11 09:43:56]

Please notice that there is "xkb:jp::jpn" keyboard which is for Latin character
input in jp109 keyboard. (http://en.wikipedia.org/wiki/Keyboard_layout#Japanese)

[Alexander Alekseev, 2013/07/12 20:10:49]

That's a good point. I've been waiting for something like that. ;-)

I think I should extend this structure to keep a list of "explicitly allowed
keyboards for this language".
NULL would mean "any". So that I can have only one list for "jp" with a single
entry "xkb:jp::jpn" for now.

+  "ca",  // Catalan
+  "cs",  // Czech
+  "da",  // Danish
+  "de",  // German
+  "en",  // English
+  "es",  // Spanish
+  "et",  // Estonian
+  "fi",  // Finnish
+  "fr",  // French
+  "hr",  // Croatian
+  "hu",  // Hungarian
+  "is",  // Icelandic
+  "it",  // Italian
+  "lt",  // Lithuanian
+  "lv",  // Latvian
+  "nb",  // Norwegian (Bokmal)
+  "nl",  // Dutch
+  "pl",  // Polish
+  "pt",  // Portuguese
+  "ro",  // Romanian
+  "sk",  // Slovak
+  "sl",  // Slovenian
+  "sv",  // Swedish
+  "tr",  // Turkish
+};
+
 }  // namespace
 
+// Note, that language may be longer than 2 letters. Like "en-US".
+// but ContainsTwoLetterLanguageCode() compares only 2 first letters.
+bool InputMethodManagerImpl::IsLanguageFullLatinKeyboard(
+    const std::string& lang) const {
+  return ContainsTwoLetterLanguageCode(full_latin_keyboard_languages_, lang);
+}
+
+InputMethodManagerImpl::TwoLetterLanguageCode::TwoLetterLanguageCode(
+    const char* lang)
+    : val(base::ToLowerASCII(lang[0]) * 256 + base::ToLowerASCII(lang[1])) {}
+
 InputMethodManagerImpl::InputMethodManagerImpl(
     scoped_ptr<InputMethodDelegate> delegate)
     : delegate_(delegate.Pass()),
       state_(STATE_LOGIN_SCREEN),
       util_(delegate_.get(), GetSupportedInputMethods()),
       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
       weak_ptr_factory_(this) {
   IBusDaemonController::GetInstance()->AddObserver(this);
+
+  full_latin_keyboard_languages_.reserve(
+      arraysize(kFullLatinKeyboardLanguageList));
+
+  for (size_t i = 0; i < arraysize(kFullLatinKeyboardLanguageList); ++i) {
+    full_latin_keyboard_languages_.push_back(
+        TwoLetterLanguageCode(kFullLatinKeyboardLanguageList[i]));
+  }
+  std::sort(full_latin_keyboard_languages_.begin(),
+            full_latin_keyboard_languages_.end());
 }
 
 InputMethodManagerImpl::~InputMethodManagerImpl() {
   if (ibus_controller_.get())
     ibus_controller_->RemoveObserver(this);
   IBusDaemonController::GetInstance()->RemoveObserver(this);
   if (candidate_window_controller_.get()) {
     candidate_window_controller_->RemoveObserver(this);
     candidate_window_controller_->Shutdown();
   }
@@ skipping 69 matching lines @@
   }
   if (result->empty()) {
     // Initially |active_input_method_ids_| is empty. browser_tests might take
     // this path.
     result->push_back(
         InputMethodUtil::GetFallbackInputMethodDescriptor());
   }
   return result.Pass();
 }
 
+const std::vector<std::string>&
+InputMethodManagerImpl::GetActiveInputMethodIds() const {
+  return active_input_method_ids_;
+}
+
 size_t InputMethodManagerImpl::GetNumActiveInputMethods() const {
   return active_input_method_ids_.size();
 }
 
 void InputMethodManagerImpl::EnableLayouts(const std::string& language_code,
                                            const std::string& initial_layout) {
   if (state_ == STATE_TERMINATING)
     return;
 
   std::vector<std::string> candidates;
@@ skipping 23 matching lines @@
     // Not efficient, but should be fine, as the two vectors are very
     // short (2-5 items).
     if (!Contains(layouts, candidate))
       layouts.push_back(candidate);
   }
 
   active_input_method_ids_.swap(layouts);
   ChangeInputMethod(initial_layout);  // you can pass empty |initial_layout|.
 }
 
+// Adds new input method to given list.
+bool InputMethodManagerImpl::EnableInputMethodImpl(
+    const std::string& input_method_id,
+    std::vector<std::string>& new_active_input_method_ids) const {
+  if (!util_.IsValidInputMethodId(input_method_id)) {
+    DVLOG(1) << "EnableInputMethod: Invalid ID: " << input_method_id;
+    return false;
+  }
+
+  if (!Contains(new_active_input_method_ids, input_method_id))
+    new_active_input_method_ids.push_back(input_method_id);
+
+  return true;
+}
+
+// starts or stops the system input method framework as needed.

[Mattias Nissler (ping if slow), 2013/07/11 10:05:49]

nit: Starts

[Alexander Alekseev, 2013/07/12 20:10:49]

Done.

+void InputMethodManagerImpl::ReconfigureIMFramework() {
+  if (component_extension_ime_manager_->IsInitialized())
+    LoadNecessaryComponentExtensions();
+
+  if (ContainOnlyKeyboardLayout(active_input_method_ids_)) {

[Mattias Nissler (ping if slow), 2013/07/11 10:05:49]

nit: ContainOnlyKeyboardLayout should be ContainsOnlyKeyboardLayout (imperative
"contain" certainly doesn't make sense here).

[Alexander Alekseev, 2013/07/12 20:10:49]

Done.

+    // Do NOT call ibus_controller_->Stop(); here to work around a crash issue
+    // at crosbug.com/27051.

[Mattias Nissler (ping if slow), 2013/07/11 10:05:49]

nit: new code should refer to crbug.com IMHO

[Alexander Alekseev, 2013/07/12 20:10:49]

Done.

+    // TODO(yusukes): We can safely call Stop(); here once crosbug.com/26443
+    // is implemented.
+  } else {
+    MaybeInitializeCandidateWindowController();
+    IBusDaemonController::GetInstance()->Start();
+  }
+}
+
+bool InputMethodManagerImpl::EnableInputMethod(
+    const std::string& input_method_id) {
+  if (!EnableInputMethodImpl(input_method_id, active_input_method_ids_))
+    return false;
+
+  ReconfigureIMFramework();
+  return true;
+}
+
 bool InputMethodManagerImpl::EnableInputMethods(
     const std::vector<std::string>& new_active_input_method_ids) {
   if (state_ == STATE_TERMINATING)
     return false;
 
   // Filter unknown or obsolete IDs.
   std::vector<std::string> new_active_input_method_ids_filtered;
 
-  for (size_t i = 0; i < new_active_input_method_ids.size(); ++i) {
-    const std::string& input_method_id = new_active_input_method_ids[i];
-    if (util_.IsValidInputMethodId(input_method_id))
-      new_active_input_method_ids_filtered.push_back(input_method_id);
-    else
-      DVLOG(1) << "EnableInputMethods: Invalid ID: " << input_method_id;
-  }
+  for (size_t i = 0; i < new_active_input_method_ids.size(); ++i)
+    EnableInputMethodImpl(new_active_input_method_ids[i],
+                          new_active_input_method_ids_filtered);
 
   if (new_active_input_method_ids_filtered.empty()) {
     DVLOG(1) << "EnableInputMethods: No valid input method ID";
     return false;
   }
 
   // Copy extension IDs to |new_active_input_method_ids_filtered|. We have to
   // keep relative order of the extension input method IDs.
   for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
     const std::string& input_method_id = active_input_method_ids_[i];
     if (extension_ime_util::IsExtensionIME(input_method_id))
       new_active_input_method_ids_filtered.push_back(input_method_id);
   }
   active_input_method_ids_.swap(new_active_input_method_ids_filtered);
 
-  if (component_extension_ime_manager_->IsInitialized())
-    LoadNecessaryComponentExtensions();
-
-  if (ContainOnlyKeyboardLayout(active_input_method_ids_)) {
-    // Do NOT call ibus_controller_->Stop(); here to work around a crash issue
-    // at crosbug.com/27051.
-    // TODO(yusukes): We can safely call Stop(); here once crosbug.com/26443
-    // is implemented.
-  } else {
-    MaybeInitializeCandidateWindowController();
-    IBusDaemonController::GetInstance()->Start();
-  }
+  ReconfigureIMFramework();
 
   // If |current_input_method| is no longer in |active_input_method_ids_|,
   // ChangeInputMethod() picks the first one in |active_input_method_ids_|.
   ChangeInputMethod(current_input_method_.id());
   return true;
 }
 
 bool InputMethodManagerImpl::MigrateOldInputMethods(
     std::vector<std::string>* input_method_ids) {
   bool rewritten = false;
@@ skipping 633 matching lines @@
   else
     DVLOG(1) << "Failed to initialize the candidate window controller";
 }
 
 bool InputMethodManagerImpl::IsIBusConnectionAlive() {
   return DBusThreadManager::Get() && DBusThreadManager::Get()->GetIBusClient();
 }
 
 }  // namespace input_method
 }  // namespace chromeos