Support comma separated hardware 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 21 matching lines @@
 
 const char nacl_mozc_jp_id[] =
     "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_jp";
 
 bool Contains(const std::vector<std::string>& container,
               const std::string& value) {
   return std::find(container.begin(), container.end(), value) !=
       container.end();
 }
 
+void UniquifyVectorWithKeepingOrder(std::vector<std::string>* v) {
+  DCHECK(v);
+  std::set<std::string> added_value;
+  size_t output_pos = 0;
+  for (size_t i = 0; i < v->size(); ++i) {
+    if ((*v)[i].empty())
+      continue;
+    if (added_value.find((*v)[i]) == added_value.end()) {
+      (*v)[output_pos++] = (*v)[i];
+      added_value.insert((*v)[i]);
+    }
+  }
+  v->resize(output_pos);
+}
+
 }  // namespace
 
 bool InputMethodManagerImpl::IsLoginKeyboard(
     const std::string& layout) const {
   return util_.IsLoginKeyboard(layout);
 }
 
 InputMethodManagerImpl::InputMethodManagerImpl(
     scoped_ptr<InputMethodDelegate> delegate)
     : delegate_(delegate.Pass()),
@@ skipping 100 matching lines @@
     std::map<std::string, InputMethodDescriptor>::const_iterator ix =
         extra_input_methods_.find(input_method_id);
     if (ix != extra_input_methods_.end())
       ime = &ix->second;
   }
   return ime;
 }
 
 void InputMethodManagerImpl::EnableLoginLayouts(
     const std::string& language_code,
-    const std::string& initial_layout) {
+    const std::vector<std::string>& initial_layouts) {
   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_.GetHardwareLoginInputMethodId());
+  std::vector<std::string> hardware_layouts;
+  util_.GetHardwareLoginInputMethodId(&hardware_layouts);
+  candidates.insert(candidates.end(), hardware_layouts.begin(),
+                    hardware_layouts.end());
 
   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)) {
-    if (!IsLoginKeyboard(initial_layout)) {
-      DVLOG(1)
-          << "EnableLoginLayouts: ignoring non-login initial keyboard layout:"
-          << initial_layout;
-    } else {
-      layouts.push_back(initial_layout);
+  for (size_t i = 0; i < initial_layouts.size(); ++i) {
+    if (util_.IsValidInputMethodId(initial_layouts[i])) {
+      if (!IsLoginKeyboard(initial_layouts[i])) {
+        DVLOG(1)
+            << "EnableLoginLayouts: ignoring non-login initial keyboard layout:"
+            << initial_layouts[i];
+      } else {
+        layouts.push_back(initial_layouts[i]);
+      }
+    } else if (!initial_layouts[i].empty()) {
+      DVLOG(1) << "EnableLoginLayouts: ignoring non-keyboard or invalid ID: "
+               << initial_layouts[i];
     }
-  } else if (!initial_layout.empty()) {
-    DVLOG(1) << "EnableLoginLayouts: 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))
       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();
 
-  ChangeInputMethod(initial_layout);  // you can pass empty |initial_layout|.
+  // you can pass empty |initial_layout|.
+  ChangeInputMethod(initial_layouts.empty() ? "" : initial_layouts[0]);
 }
 
 // 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 {
   DCHECK(new_active_input_method_ids);
   if (!util_.IsValidInputMethodId(input_method_id)) {
     DVLOG(1) << "EnableInputMethod: Invalid ID: " << input_method_id;
     return false;
@@ skipping 321 matching lines @@
 
 void InputMethodManagerImpl::SetInputMethodDefault() {
   // Set up keyboards. For example, when |locale| is "en-US", enable US qwerty
   // and US dvorak keyboard layouts.
   if (g_browser_process && g_browser_process->local_state()) {
     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);
+    std::vector<std::string> input_methods_to_be_enabled;
     if (initial_input_method_id.empty()) {
       // If kPreferredKeyboardLayout is not specified, use the hardware layout.
-      initial_input_method_id =
-          GetInputMethodUtil()->GetHardwareInputMethodId();
+      util_.GetHardwareInputMethodIds(&input_methods_to_be_enabled);

[Alexander Alekseev, 2014/02/11 13:36:02]

SetInputMethodDefault() is called only from signin code and is expected to set
up only login input methods.

Let's rename SetInputMethodDefault() to SetInputMethodLoginDefault()
and enable only login methods here. (i.e. GetHardwareLoginInputMethodIds())

[Seigo Nonaka, 2014/02/12 13:21:02]

Done.

+    } else {
+      input_methods_to_be_enabled.push_back(initial_input_method_id);
     }
-    EnableLoginLayouts(locale, initial_input_method_id);
+    EnableLoginLayouts(locale, input_methods_to_be_enabled);
   }
 }
 
 bool InputMethodManagerImpl::SwitchToNextInputMethod() {
   // Sanity checks.
   if (active_input_method_ids_.empty()) {
     DVLOG(1) << "active input method is empty";
     return false;
   }
 
@@ skipping 208 matching lines @@
   FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
                     candidate_window_observers_,
                     CandidateWindowClosed(this));
 }
 
 void InputMethodManagerImpl::OnScreenLocked() {
   saved_previous_input_method_ = previous_input_method_;
   saved_current_input_method_ = current_input_method_;
   saved_active_input_method_ids_ = active_input_method_ids_;
 
-  const std::string hardware_keyboard_id = util_.GetHardwareInputMethodId();
-  // 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;
+  std::vector<std::string> hardware_keyboard_ids;
+  util_.GetHardwareInputMethodIds(&hardware_keyboard_ids);

[Alexander Alekseev, 2014/02/11 13:36:02]

GetHardwareLoginInputMethodIds() (only login hardware input methods can be used
at lock screen)

[Seigo Nonaka, 2014/02/12 13:21:02]

Done.

 
   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 (!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);
+
+  // We'll add the hardware keyboard if it's not included in
+  // |active_input_method_ids_| so that the user can always use the hardware
+  // keyboard on the screen locker.
+  active_input_method_ids_.insert(active_input_method_ids_.end(),
+                                  hardware_keyboard_ids.begin(),
+                                  hardware_keyboard_ids.end());
+
+  UniquifyVectorWithKeepingOrder(&active_input_method_ids_);
 
   ChangeInputMethod(current_input_method_.id());
 }
 
 void InputMethodManagerImpl::OnScreenUnlocked() {
   previous_input_method_ = saved_previous_input_method_;
   current_input_method_ = saved_current_input_method_;
   active_input_method_ids_ = saved_active_input_method_ids_;
 
   ChangeInputMethod(current_input_method_.id());
@@ skipping 17 matching lines @@
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 }  // namespace input_method
 }  // namespace chromeos