Revert "Use libcros to convert input method ID to keyboard overlay ID."

chrome/browser/chromeos/input_method/input_method_util.cc

 // Copyright (c) 2010 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 91 matching lines @@
   { "xkb:tr::tur", "tr" },
   { "xkb:ua::ukr", "uk" },
 };
 
 // Map from language code to associated input method IDs, etc.
 typedef std::multimap<std::string, std::string> LanguageCodeToIdsMap;
 struct IdMaps {
   scoped_ptr<LanguageCodeToIdsMap> language_code_to_ids;
   scoped_ptr<std::map<std::string, std::string> > id_to_language_code;
   scoped_ptr<std::map<std::string, std::string> > id_to_display_name;
+  scoped_ptr<std::map<std::string, std::string> > id_to_keyboard_overlay_id;
 
   // Returns the singleton instance.
   static IdMaps* GetInstance() {
     return Singleton<IdMaps>::get();
   }
 
   void ReloadMaps() {
     chromeos::InputMethodLibrary* library =
         chromeos::CrosLibrary::Get()->GetInputMethodLibrary();
     scoped_ptr<chromeos::InputMethodDescriptors> supported_input_methods(
         library->GetSupportedInputMethods());
     if (supported_input_methods->size() <= 1) {
       LOG(ERROR) << "GetSupportedInputMethods returned a fallback ID";
       // TODO(yusukes): Handle this error in nicer way.
     }
 
     language_code_to_ids->clear();
     id_to_language_code->clear();
     id_to_display_name->clear();
+    id_to_keyboard_overlay_id->clear();
 
     // Build the id to descriptor map for handling kExtraLanguages later.
     typedef std::map<std::string,
         const chromeos::InputMethodDescriptor*> DescMap;
     DescMap id_to_descriptor_map;
 
     for (size_t i = 0; i < supported_input_methods->size(); ++i) {
       const chromeos::InputMethodDescriptor& input_method =
           supported_input_methods->at(i);
       const std::string language_code =
           chromeos::input_method::GetLanguageCodeFromDescriptor(input_method);
       AddInputMethodToMaps(language_code, input_method);
       // Remember the pair.
       id_to_descriptor_map.insert(
           std::make_pair(input_method.id, &input_method));
     }
 
+    for (size_t i = 0; i < arraysize(kInputMethodIdToKeyboardOverlayId); ++i) {
+      InputMethodIdToKeyboardOverlayId id_pair =
+          kInputMethodIdToKeyboardOverlayId[i];
+      id_to_keyboard_overlay_id->insert(
+          std::make_pair(id_pair.input_method_id, id_pair.keyboard_overlay_id));
+    }
+
     // Go through the languages listed in kExtraLanguages.
     using chromeos::input_method::kExtraLanguages;
     for (size_t i = 0; i < arraysize(kExtraLanguages); ++i) {
       const char* language_code = kExtraLanguages[i].language_code;
       const char* input_method_id = kExtraLanguages[i].input_method_id;
       DescMap::const_iterator iter = id_to_descriptor_map.find(input_method_id);
       // If the associated input method descriptor is found, add the
       // language code and the input method.
       if (iter != id_to_descriptor_map.end()) {
         const chromeos::InputMethodDescriptor& input_method = *(iter->second);
         AddInputMethodToMaps(language_code, input_method);
       }
     }
   }
 
  private:
   IdMaps() : language_code_to_ids(new LanguageCodeToIdsMap),
              id_to_language_code(new std::map<std::string, std::string>),
-             id_to_display_name(new std::map<std::string, std::string>) {
+             id_to_display_name(new std::map<std::string, std::string>),
+             id_to_keyboard_overlay_id(new std::map<std::string, std::string>) {
     ReloadMaps();
   }
 
   void AddInputMethodToMaps(
       const std::string& language_code,
       const chromeos::InputMethodDescriptor& input_method) {
     language_code_to_ids->insert(
         std::make_pair(language_code, input_method.id));
     id_to_language_code->insert(
         std::make_pair(input_method.id, language_code));
@@ skipping 367 matching lines @@
 std::string GetKeyboardLayoutName(const std::string& input_method_id) {
   if (!StartsWithASCII(input_method_id, "xkb:", true)) {
     return "";
   }
 
   std::vector<std::string> splitted_id;
   base::SplitString(input_method_id, ':', &splitted_id);
   return (splitted_id.size() > 1) ? splitted_id[1] : "";
 }
 
+std::string GetKeyboardOverlayId(const std::string& input_method_id) {
+  const std::map<std::string, std::string>& id_map =
+      *(IdMaps::GetInstance()->id_to_keyboard_overlay_id);
+  std::map<std::string, std::string>::const_iterator iter =
+      id_map.find(input_method_id);
+  return (iter == id_map.end() ? "" : iter->second);
+}
+
 std::string GetInputMethodDisplayNameFromId(
     const std::string& input_method_id) {
   static const char kDefaultDisplayName[] = "USA";
   std::map<std::string, std::string>::const_iterator iter
       = IdMaps::GetInstance()->id_to_display_name->find(input_method_id);
   return (iter == IdMaps::GetInstance()->id_to_display_name->end()) ?
       kDefaultDisplayName : iter->second;
 }
 
 string16 GetLanguageDisplayNameFromCode(const std::string& language_code) {
@@ skipping 110 matching lines @@
     library->ChangeInputMethod(initial_input_method_id);
   }
 }
 
 void OnLocaleChanged() {
   IdMaps::GetInstance()->ReloadMaps();
 }
 
 }  // namespace input_method
 }  // namespace chromeos