Supporting multiple keyboard layouts.

chromeos/ime/component_extension_ime_manager.cc

 // Copyright 2013 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 "base/logging.h"
 #include "base/string_util.h"
 #include "chromeos/ime/component_extension_ime_manager.h"
 
 namespace chromeos {
 namespace {
 const char* kComponentExtensionIMEPrefix = "_comp_ime_";
 }  // namespace
 
+ComponentExtensionEngine::ComponentExtensionEngine() {
+}
+
+ComponentExtensionEngine::~ComponentExtensionEngine() {
+}
+
 ComponentExtensionIME::ComponentExtensionIME() {
 }
 
 ComponentExtensionIME::~ComponentExtensionIME() {
 }
 
 ComponentExtensionIMEManagerDelegate::ComponentExtensionIMEManagerDelegate() {
 }
 
 ComponentExtensionIMEManagerDelegate::~ComponentExtensionIMEManagerDelegate() {
@@ skipping 62 matching lines @@
   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
     if (component_extension_imes_[i].id == extension_id)
       return true;
   }
   return false;
 }
 
 std::string ComponentExtensionIMEManager::GetId(
     const std::string& extension_id,
     const std::string& engine_id) {
-  IBusComponent::EngineDescription engine;
+  ComponentExtensionEngine engine;
   const std::string& input_method_id =
       GetComponentExtensionIMEId(extension_id, engine_id);
   if (!FindEngineEntry(input_method_id, NULL, &engine))
     return "";
   return input_method_id;
 }
 
 std::string ComponentExtensionIMEManager::GetName(
     const std::string& input_method_id) {
-  IBusComponent::EngineDescription engine;
+  ComponentExtensionEngine engine;
   if (!FindEngineEntry(input_method_id, NULL, &engine))
     return "";
   return engine.display_name;
 }
 
 std::string ComponentExtensionIMEManager::GetDescription(
     const std::string& input_method_id) {
-  IBusComponent::EngineDescription engine;
+  ComponentExtensionEngine engine;
   if (!FindEngineEntry(input_method_id, NULL, &engine))
     return "";
   return engine.description;
 }
 
 std::vector<std::string> ComponentExtensionIMEManager::ListIMEByLanguage(
     const std::string& language) {
   std::vector<std::string> result;
   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
     for (size_t j = 0; j < component_extension_imes_[i].engines.size(); ++j) {
@@ skipping 11 matching lines @@
     ComponentExtensionIMEManager::GetAllIMEAsInputMethodDescriptor() {
   input_method::InputMethodDescriptors result;
   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
     for (size_t j = 0; j < component_extension_imes_[i].engines.size(); ++j) {
       result.push_back(
           input_method::InputMethodDescriptor(
               GetComponentExtensionIMEId(
                   component_extension_imes_[i].id,
                   component_extension_imes_[i].engines[j].engine_id),
               component_extension_imes_[i].engines[j].display_name,
-              component_extension_imes_[i].engines[j].layout,
+              component_extension_imes_[i].engines[j].layouts,
               component_extension_imes_[i].engines[j].language_code,
               component_extension_imes_[i].options_page_url));
     }
   }
   return result;
 }
 
 void ComponentExtensionIMEManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ComponentExtensionIMEManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool ComponentExtensionIMEManager::FindEngineEntry(
     const std::string& input_method_id,
     ComponentExtensionIME* out_extension,
-    IBusComponent::EngineDescription* out_engine) {
+    ComponentExtensionEngine* out_engine) {
   if (!IsComponentExtensionIMEId(input_method_id))
     return false;
   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
     const std::string extension_id = component_extension_imes_[i].id;
-    const std::vector<IBusComponent::EngineDescription>& engines =
+    const std::vector<ComponentExtensionEngine>& engines =
         component_extension_imes_[i].engines;
 
     for (size_t j = 0; j < engines.size(); ++j) {
       const std::string trial_ime_id = GetComponentExtensionIMEId(
           extension_id, engines[j].engine_id);
       if (trial_ime_id != input_method_id)
         continue;
 
       if (out_extension)
         *out_extension = component_extension_imes_[i];
       if (out_engine)
         *out_engine = component_extension_imes_[i].engines[j];
       return true;
     }
   }
   return false;
 }
 
 }  // namespace chromeos