Guest Mode: input method should default to the underlying latin keyboard layout.

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 25 matching lines @@
 bool Contains(const std::vector<std::string>& container,
               const std::string& value) {
   return std::find(container.begin(), container.end(), value) !=
       container.end();
 }
 
 }  // namespace
 
 bool InputMethodManagerImpl::IsLoginKeyboard(
     const std::string& layout) const {
-  const InputMethodDescriptor* ime =
-      util_.GetInputMethodDescriptorFromId(layout);
-  return ime ? ime->is_login_keyboard() : false;
+  return util_.IsLoginKeyboard(layout);
 }
 
 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) {
 }
@@ skipping 81 matching lines @@
 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) {
+                                           const std::string& initial_layout,
+                                           const bool login_layouts_only) {
   if (state_ == STATE_TERMINATING)
     return;
 
   std::vector<std::string> candidates;
   // Add input methods associated with the language.
   util_.GetInputMethodIdsFromLanguageCode(language_code,
                                           kKeyboardLayoutsOnly,
                                           &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());
+  candidates.push_back(util_.GetHardwareLoginInputMethodId());
 
   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) &&
-      IsLoginKeyboard(initial_layout)) {
-    layouts.push_back(initial_layout);
+  if (util_.IsValidInputMethodId(initial_layout)) {
+    if (login_layouts_only && !IsLoginKeyboard(initial_layout)) {
+      DVLOG(1) << "EnableLayouts: ignoring non-login initial keyboard layout:"
+               << initial_layout;
+    } else {
+      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) && IsLoginKeyboard(candidate))
+    if (!Contains(layouts, candidate) &&
+        (!login_layouts_only || IsLoginKeyboard(candidate)))
       layouts.push_back(candidate);
   }
 
   active_input_method_ids_.swap(layouts);
 
   // Initialize candidate window controller and widgets such as
   // candidate window, infolist and mode indicator.  Note, mode
   // indicator is used by only keyboard layout input methods.
   if (active_input_method_ids_.size() > 1)
     MaybeInitializeCandidateWindowController();
@@ skipping 339 matching lines @@
     const std::string locale = g_browser_process->GetApplicationLocale();
     // If the preferred keyboard for the login screen has been saved, use it.
     PrefService* prefs = g_browser_process->local_state();
     std::string initial_input_method_id =
         prefs->GetString(chromeos::language_prefs::kPreferredKeyboardLayout);
     if (initial_input_method_id.empty()) {
       // If kPreferredKeyboardLayout is not specified, use the hardware layout.
       initial_input_method_id =
           GetInputMethodUtil()->GetHardwareInputMethodId();
     }
-    EnableLayouts(locale, initial_input_method_id);
+    EnableLayouts(
+        locale, initial_input_method_id, true /* login_layouts_only */);
   }
 }
 
 bool InputMethodManagerImpl::SwitchToNextInputMethod() {
   // Sanity checks.
   if (active_input_method_ids_.empty()) {
     DVLOG(1) << "active input method is empty";
     return false;
   }
 
@@ skipping 264 matching lines @@
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 }  // namespace input_method
 }  // namespace chromeos