[IME] migrate the xkb ID to extension based xkb ID.

chrome/browser/chromeos/input_method/input_method_util.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_util.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <utility>
@@ skipping 441 matching lines @@
   // Special case for German, French and Dutch: these languages have multiple
   // keyboard layouts and share the same layout of keyboard (Belgian). We need
   // to show explicitly the language for the layout. For Arabic, Amharic, and
   // Indic languages: they share "Standard Input Method".
   const base::string16 standard_input_method_text =
       delegate_->GetLocalizedString(
           IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD);
   DCHECK(!input_method.language_codes().empty());
   const std::string language_code = input_method.language_codes().at(0);
 
-  base::string16 text = TranslateString(input_method.id());
+  // Before translate the string, convert the input method id to legacy xkb id
+  // if possible.
+  // TODO(shuchen): the GetInputMethodLongName() method should be removed when
+  // finish the wrapping of xkb to extension.
+  base::string16 text = TranslateString(
+      extension_ime_util::MaybeGetLegacyXkbId(input_method.id()));
   if (text == standard_input_method_text ||
              language_code == "de" ||
              language_code == "fr" ||
              language_code == "nl") {
     const base::string16 language_name = delegate_->GetDisplayLanguageName(
         language_code);
 
     text = language_name + base::UTF8ToUTF16(" - ") + text;
   }
 
   DCHECK(!text.empty());
   return text;
 }
 
 const InputMethodDescriptor* InputMethodUtil::GetInputMethodDescriptorFromId(
     const std::string& input_method_id) const {
   InputMethodIdToDescriptorMap::const_iterator iter
       = id_to_descriptor_.find(input_method_id);
-  return (iter == id_to_descriptor_.end()) ? NULL : &(iter->second);
+  if (iter == id_to_descriptor_.end()) {
+    // If failed to find the descriptor for given id, it may because of the id
+    // is a component extension xkb id (_comp_ime_...xkb:...).
+    // So try to convert it to legacy xkb id and find again.
+    // This hack is mainly for OOBE session, which requires a sync call to get
+    // the input method descriptor for extension xkb id.
+    // TODO(shuchen): need to support async wait for component extension
+    // loading in OOBE session. This hack won't be needed when it's been done.
+    iter = id_to_descriptor_.find(
+        extension_ime_util::MaybeGetLegacyXkbId(input_method_id));
+    if (iter == id_to_descriptor_.end())
+      return NULL;
+  }
+  return &(iter->second);
 }
 
 bool InputMethodUtil::GetInputMethodIdsFromLanguageCode(
     const std::string& normalized_language_code,
     InputMethodType type,
     std::vector<std::string>* out_input_method_ids) const {
   return GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_,
       normalized_language_code, type, out_input_method_ids);
 }
@@ skipping 112 matching lines @@
     const std::string& language_code) {
   std::vector<std::string> candidates;
   GetInputMethodIdsFromLanguageCode(
       language_code, input_method::kKeyboardLayoutsOnly, &candidates);
   if (candidates.size())
     return candidates.front();
 
   return std::string();
 }
 
+bool InputMethodUtil::MigrateXkbInputMethods(
+    std::vector<std::string>* input_method_ids) {
+  bool rewritten = false;
+  std::vector<std::string>& ids = *input_method_ids;
+  for (size_t i = 0; i < ids.size(); ++i) {
+    std::string id =
+        extension_ime_util::GetInputMethodIDByKeyboardLayout(ids[i]);
+    if (id != ids[i]) {
+      ids[i] = id;
+      rewritten = true;
+    }
+  }
+  if (rewritten) {
+    // Removes the duplicates.
+    std::vector<std::string> new_ids;
+    for (size_t i = 0; i < ids.size(); ++i) {
+      if (std::find(new_ids.begin(), new_ids.end(), ids[i]) == new_ids.end())
+        new_ids.push_back(ids[i]);
+    }
+    ids.swap(new_ids);
+  }
+  return rewritten;
+}
+
 void InputMethodUtil::UpdateHardwareLayoutCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   hardware_layouts_.clear();
   hardware_login_layouts_.clear();
   Tokenize(delegate_->GetHardwareKeyboardLayouts(), ",", &hardware_layouts_);
+  MigrateXkbInputMethods(&hardware_layouts_);
 
   for (size_t i = 0; i < hardware_layouts_.size(); ++i) {
     if (IsLoginKeyboard(hardware_layouts_[i]))
       hardware_login_layouts_.push_back(hardware_layouts_[i]);
   }
   if (hardware_layouts_.empty()) {
     // This is totally fine if it's empty. The hardware keyboard layout is
     // not stored if startup_manifest.json (OEM customization data) is not
     // present (ex. Cr48 doen't have that file).
     hardware_layouts_.push_back(GetFallbackInputMethodDescriptor().id());
@@ skipping 46 matching lines @@
     id_to_descriptor_.insert(
         std::make_pair(input_method.id(), input_method));
   }
 }
 
 InputMethodDescriptor InputMethodUtil::GetFallbackInputMethodDescriptor() {
   std::vector<std::string> layouts;
   layouts.push_back("us");
   std::vector<std::string> languages;
   languages.push_back("en-US");
-  return InputMethodDescriptor("xkb:us::eng",
-                               "",
-                               "US",
-                               layouts,
-                               languages,
-                               true,  // login keyboard.
-                               GURL(),  // options page, not available.
-                               GURL()); // input view page, not available.
+  return InputMethodDescriptor(
+      extension_ime_util::GetInputMethodIDByKeyboardLayout("xkb:us::eng"),
+      "",
+      "US",
+      layouts,
+      languages,
+      true,  // login keyboard.
+      GURL(),  // options page, not available.
+      GURL()); // input view page, not available.
 }
 
 void InputMethodUtil::ReloadInternalMaps() {
   if (supported_input_methods_->size() <= 1) {
     DVLOG(1) << "GetSupportedInputMethods returned a fallback ID";
     // TODO(yusukes): Handle this error in nicer way.
   }
 
   // Clear the existing maps.
   language_code_to_ids_.clear();
@@ skipping 18 matching lines @@
     if (IsKeyboardLayout(input_method.id())) {
       xkb_id_to_descriptor_.insert(
           std::make_pair(input_method.GetPreferredKeyboardLayout(),
                          input_method));
     }
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos