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 92 matching lines @@
 } 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" },
 };
 
 }  // namespace
 
+bool InputMethodManagerImpl::IsFullLatinKeyboard(
+    const std::string& layout) const {
+  const std::string& lang = util_.GetLanguageCodeFromInputMethodId(layout);
+  return full_latin_keyboard_checker.IsFullLatinKeyboard(layout, lang);
+}
+
 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);
 }
 
@@ skipping 77 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.
+void InputMethodManagerImpl::ReconfigureIMFramework() {
+  if (component_extension_ime_manager_->IsInitialized())
+    LoadNecessaryComponentExtensions();
+
+  if (ContainsOnlyKeyboardLayout(active_input_method_ids_)) {
+    // Do NOT call ibus_controller_->Stop(); here to work around a crash issue
+    // at crbug.com/27051.
+    // TODO(yusukes): We can safely call Stop(); here once crbug.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 252 matching lines @@
 void InputMethodManagerImpl::RemoveInputMethodExtension(const std::string& id) {
   if (!extension_ime_util::IsExtensionIME(id))
     DVLOG(1) << id << " is not a valid extension input method ID.";
 
   std::vector<std::string>::iterator i = std::find(
       active_input_method_ids_.begin(), active_input_method_ids_.end(), id);
   if (i != active_input_method_ids_.end())
     active_input_method_ids_.erase(i);
   extra_input_methods_.erase(id);
 
-  if (ContainOnlyKeyboardLayout(active_input_method_ids_)) {
+  if (ContainsOnlyKeyboardLayout(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.
   }
 
   // If |current_input_method| is no longer in |active_input_method_ids_|,
   // switch to the first one in |active_input_method_ids_|.
   ChangeInputMethod(current_input_method_.id());
 
@@ skipping 333 matching lines @@
   active_input_method_ids_ = saved_active_input_method_ids_;
 
   ChangeInputMethod(current_input_method_.id());
 }
 
 bool InputMethodManagerImpl::InputMethodIsActivated(
     const std::string& input_method_id) {
   return Contains(active_input_method_ids_, input_method_id);
 }
 
-bool InputMethodManagerImpl::ContainOnlyKeyboardLayout(
+bool InputMethodManagerImpl::ContainsOnlyKeyboardLayout(
     const std::vector<std::string>& value) {
   for (size_t i = 0; i < value.size(); ++i) {
     if (!InputMethodUtil::IsKeyboardLayout(value[i]))
       return false;
   }
   return true;
 }
 
 void InputMethodManagerImpl::MaybeInitializeCandidateWindowController() {
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   if (candidate_window_controller_->Init())
     candidate_window_controller_->AddObserver(this);
   else
     DVLOG(1) << "Failed to initialize the candidate window controller";
 }
 
 bool InputMethodManagerImpl::IsIBusConnectionAlive() {
   return DBusThreadManager::Get() && DBusThreadManager::Get()->GetIBusClient();
 }
 
 }  // namespace input_method
 }  // namespace chromeos