Build chrome.input.ime.* API in GN mode.

chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc

 // Copyright 2015 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/extensions/api/input_ime/input_ime_api.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 268 matching lines @@
     return "normal";
   }
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserverChromeOS);
 };
 
 }  // namespace
 
 namespace extensions {
 
-bool InputImeEventRouter::RegisterImeExtension(
-    const std::string& extension_id,
-    const std::vector<extensions::InputComponentInfo>& input_components) {
-  VLOG(1) << "RegisterImeExtension: " << extension_id;
-
-  if (engine_map_[extension_id])
-    return false;
-
-  chromeos::input_method::InputMethodManager* manager =
-      chromeos::input_method::InputMethodManager::Get();
-  chromeos::ComponentExtensionIMEManager* comp_ext_ime_manager =
-      manager->GetComponentExtensionIMEManager();
-
-  chromeos::input_method::InputMethodDescriptors descriptors;
-  // Only creates descriptors for 3rd party IME extension, because the
-  // descriptors for component IME extensions are managed by InputMethodUtil.
-  if (!comp_ext_ime_manager->IsWhitelistedExtension(extension_id)) {
-    for (std::vector<extensions::InputComponentInfo>::const_iterator it =
-             input_components.begin();
-         it != input_components.end();
-         ++it) {
-      const extensions::InputComponentInfo& component = *it;
-      DCHECK(component.type == extensions::INPUT_COMPONENT_TYPE_IME);
-
-      std::vector<std::string> layouts;
-      layouts.assign(component.layouts.begin(), component.layouts.end());
-      std::vector<std::string> languages;
-      languages.assign(component.languages.begin(), component.languages.end());
-
-      const std::string& input_method_id =
-          chromeos::extension_ime_util::GetInputMethodID(extension_id,
-                                                         component.id);
-      descriptors.push_back(chromeos::input_method::InputMethodDescriptor(
-          input_method_id,
-          component.name,
-          std::string(),  // TODO(uekawa): Set short name.
-          layouts,
-          languages,
-          false,  // 3rd party IMEs are always not for login.
-          component.options_page_url,
-          component.input_view_url));
-    }
-  }
-
-  scoped_ptr<ui::IMEEngineObserver> observer(
-      new ImeObserverChromeOS(extension_id, profile_));
-  chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
-  engine->Initialize(std::move(observer), extension_id.c_str(), profile_);
-  engine_map_[extension_id] = engine;
-  chromeos::UserSessionManager::GetInstance()
-      ->GetDefaultIMEState(profile_)
-      ->AddInputMethodExtension(extension_id, descriptors, engine);
-
-  return true;
-}
-
-void InputImeEventRouter::UnregisterAllImes(const std::string& extension_id) {
-  std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
-      engine_map_.find(extension_id);
-  if (it != engine_map_.end()) {
-    chromeos::input_method::InputMethodManager::Get()
-        ->GetActiveIMEState()
-        ->RemoveInputMethodExtension(extension_id);
-    delete it->second;
-    engine_map_.erase(it);
-  }
-}
-
 bool InputImeSetCompositionFunction::RunSync() {
   IMEEngineHandlerInterface* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetComposition::Params> parent_params(
@@ skipping 318 matching lines @@
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   engine->DeleteSurroundingText(params.context_id, params.offset, params.length,
                                 &error_);
   return true;
 }
 
+bool InputImeEventRouter::RegisterImeExtension(
+    const std::string& extension_id,
+    const std::vector<extensions::InputComponentInfo>& input_components) {
+  VLOG(1) << "RegisterImeExtension: " << extension_id;
+
+  if (engine_map_[extension_id])
+    return false;
+
+  chromeos::input_method::InputMethodManager* manager =
+      chromeos::input_method::InputMethodManager::Get();
+  chromeos::ComponentExtensionIMEManager* comp_ext_ime_manager =
+      manager->GetComponentExtensionIMEManager();
+
+  chromeos::input_method::InputMethodDescriptors descriptors;
+  // Only creates descriptors for 3rd party IME extension, because the
+  // descriptors for component IME extensions are managed by InputMethodUtil.
+  if (!comp_ext_ime_manager->IsWhitelistedExtension(extension_id)) {
+    for (std::vector<extensions::InputComponentInfo>::const_iterator it =
+             input_components.begin();
+         it != input_components.end();
+         ++it) {
+      const extensions::InputComponentInfo& component = *it;
+      DCHECK(component.type == extensions::INPUT_COMPONENT_TYPE_IME);
+
+      std::vector<std::string> layouts;
+      layouts.assign(component.layouts.begin(), component.layouts.end());
+      std::vector<std::string> languages;
+      languages.assign(component.languages.begin(), component.languages.end());
+
+      const std::string& input_method_id =
+          chromeos::extension_ime_util::GetInputMethodID(extension_id,
+                                                         component.id);
+      descriptors.push_back(chromeos::input_method::InputMethodDescriptor(
+          input_method_id,
+          component.name,
+          std::string(),  // TODO(uekawa): Set short name.
+          layouts,
+          languages,
+          false,  // 3rd party IMEs are always not for login.
+          component.options_page_url,
+          component.input_view_url));
+    }
+  }
+
+  scoped_ptr<ui::IMEEngineObserver> observer(
+      new ImeObserverChromeOS(extension_id, profile_));
+  chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
+  engine->Initialize(std::move(observer), extension_id.c_str(), profile_);
+  engine_map_[extension_id] = engine;
+  chromeos::UserSessionManager::GetInstance()
+      ->GetDefaultIMEState(profile_)
+      ->AddInputMethodExtension(extension_id, descriptors, engine);
+
+  return true;
+}
+
+void InputImeEventRouter::UnregisterAllImes(const std::string& extension_id) {
+  std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
+      engine_map_.find(extension_id);
+  if (it != engine_map_.end()) {
+    chromeos::input_method::InputMethodManager::Get()
+        ->GetActiveIMEState()
+        ->RemoveInputMethodExtension(extension_id);
+    delete it->second;
+    engine_map_.erase(it);
+  }
+}
+
+IMEEngineHandlerInterface* InputImeEventRouter::GetEngine(
+    const std::string& extension_id,
+    const std::string& component_id) {
+  std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
+      engine_map_.find(extension_id);
+  if (it != engine_map_.end())
+    return it->second;
+  return NULL;
+}
+
+IMEEngineHandlerInterface* InputImeEventRouter::GetActiveEngine(
+    const std::string& extension_id) {
+  std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
+      engine_map_.find(extension_id);
+  if (it != engine_map_.end() && it->second->IsActive())
+    return it->second;
+  return NULL;
+}
+
+void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
+                                    const Extension* extension) {
+  const std::vector<InputComponentInfo>* input_components =
+      extensions::InputComponents::GetInputComponents(extension);
+  if (input_components)
+    GetInputImeEventRouter(Profile::FromBrowserContext(browser_context))
+        ->RegisterImeExtension(extension->id(), *input_components);
+}
+
+void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
+                                      const Extension* extension,
+                                      UnloadedExtensionInfo::Reason reason) {
+  const std::vector<InputComponentInfo>* input_components =
+      extensions::InputComponents::GetInputComponents(extension);
+  if (!input_components)
+    return;
+  if (input_components->size() > 0) {
+    GetInputImeEventRouter(Profile::FromBrowserContext(browser_context))
+        ->UnregisterAllImes(extension->id());
+  }
+}
+
+void InputImeAPI::OnListenerAdded(const EventListenerInfo& details) {
+  if (!details.browser_context)
+    return;
+  IMEEngineHandlerInterface* engine =
+      GetInputImeEventRouter(
+          Profile::FromBrowserContext(details.browser_context))
+          ->GetActiveEngine(details.extension_id);
+  // Notifies the IME extension for IME ready with onActivate/onFocus events.
+  if (engine)
+    engine->Enable(engine->GetActiveComponentId());
+}
+
 }  // namespace extensions