Disable non Latin keyboard layout on Lock screen and Sign-in screen.

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 97 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(
+bool InputMethodManagerImpl::IsLoginKeyboard(
     const std::string& layout) const {
-  const std::string& lang = util_.GetLanguageCodeFromInputMethodId(layout);
-  return full_latin_keyboard_checker.IsFullLatinKeyboard(layout, lang);
+  const InputMethodDescriptor* ime =
+      util_.GetInputMethodDescriptorFromId(layout);
+  return ime ? ime->is_login_keyboard() : false;
 }
 
 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 107 matching lines @@
                                           &candidates);
   // Add the hardware keyboard as well. We should always add this so users
   // can use the hardware keyboard on the login screen and the screen locker.
   candidates.push_back(util_.GetHardwareInputMethodId());
 
   std::vector<std::string> layouts;
   // First, add the initial input method ID, if it's requested, to
   // layouts, so it appears first on the list of active input
   // methods at the input language status menu.
   if (util_.IsValidInputMethodId(initial_layout) &&
-      InputMethodUtil::IsKeyboardLayout(initial_layout)) {
+      IsLoginKeyboard(initial_layout)) {
     layouts.push_back(initial_layout);
   } else if (!initial_layout.empty()) {
     DVLOG(1) << "EnableLayouts: ignoring non-keyboard or invalid ID: "
              << initial_layout;
   }
 
   // Add candidates to layouts, while skipping duplicates.
   for (size_t i = 0; i < candidates.size(); ++i) {
     const std::string& candidate = candidates[i];
     // Not efficient, but should be fine, as the two vectors are very
     // short (2-5 items).
-    if (!Contains(layouts, candidate))
+    if (!Contains(layouts, candidate) && IsLoginKeyboard(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,
@@ skipping 296 matching lines @@
   if (state_ == STATE_TERMINATING)
     return;
 
   if (!extension_ime_util::IsExtensionIME(id) &&
       !ComponentExtensionIMEManager::IsComponentExtensionIMEId(id)) {
     DVLOG(1) << id << " is not a valid extension input method ID.";
     return;
   }
 
   extra_input_methods_[id] =
-      InputMethodDescriptor(id, name, layouts, languages, options_url);
+      InputMethodDescriptor(id, name, layouts, languages, false, options_url);
   if (Contains(enabled_extension_imes_, id) &&
       !ComponentExtensionIMEManager::IsComponentExtensionIMEId(id)) {
     if (!Contains(active_input_method_ids_, id)) {
       active_input_method_ids_.push_back(id);
     } else {
       DVLOG(1) << "AddInputMethodExtension: alread added: "
                << id << ", " << name;
       // Call Start() anyway, just in case.
     }
 
@@ skipping 342 matching lines @@
   // We'll add the hardware keyboard if it's not included in
   // |active_input_method_list| so that the user can always use the hardware
   // keyboard on the screen locker.
   bool should_add_hardware_keyboard = true;
 
   active_input_method_ids_.clear();
   for (size_t i = 0; i < saved_active_input_method_ids_.size(); ++i) {
     const std::string& input_method_id = saved_active_input_method_ids_[i];
     // Skip if it's not a keyboard layout. Drop input methods including
     // extension ones.
-    if (!InputMethodUtil::IsKeyboardLayout(input_method_id))
+    if (!IsLoginKeyboard(input_method_id))
       continue;
     active_input_method_ids_.push_back(input_method_id);
     if (input_method_id == hardware_keyboard_id)
       should_add_hardware_keyboard = false;
   }
   if (should_add_hardware_keyboard)
     active_input_method_ids_.push_back(hardware_keyboard_id);
 
   ChangeInputMethod(current_input_method_.id());
 }
@@ skipping 31 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