Add chrome.input.ime.activate and chrome.input.ime.deactivate API

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

Index: chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc
diff --git a/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc b/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc
index 9511f015971cd427dfc4a5f808727f35043a0f25..dee1ee6cd33d2677640857189c265216d2f4b5aa 100644
--- a/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc
+++ b/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc
@@ -12,14 +12,23 @@
 
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "chrome/browser/input_method/input_method_engine.h"
 #include "chrome/common/chrome_switches.h"
+#include "ui/base/ime/ime_bridge.h"
+
+using ui::IMEEngineHandlerInterface;
+using input_method::InputMethodEngine;
 
 namespace {
 
+const char kErrorAPIDisabled[] =
+    "The chrome.input.ime API is not supported on the current platform";
+
 bool IsInputImeEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableInputImeAPI);
-}
+
+}  // namespace
 
 class ImeObserverNonChromeOS : public ui::ImeObserver {
  public:
@@ -45,9 +54,7 @@ class ImeObserverNonChromeOS : public ui::ImeObserver {
         ->DispatchEventToExtension(extension_id_, std::move(event));
   }
 
-  std::string GetCurrentScreenType() override {
-    return "normal";
-  }
+  std::string GetCurrentScreenType() override { return "normal"; }
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserverNonChromeOS);
 };
@@ -61,12 +68,94 @@ InputImeEventRouter::InputImeEventRouter(Profile* profile)
 
 InputImeEventRouter::~InputImeEventRouter() {}
 
+bool InputImeEventRouter::RegisterImeExtension(
+    const std::string& extension_id) {
+  // Already regsitered.

[Devlin, 2016/01/13 18:22:59]

Typo: registered
Also, let's make this a bit more clear; "Check if the IME extension is already
registered."

[Azure Wei, 2016/01/14 14:03:48]

Done.

+  if (std::find(extension_ids_.begin(), extension_ids_.end(), extension_id) !=
+      extension_ids_.end())
+    return false;
+
+  extension_ids_.push_back(extension_id);
+  return true;
+}
+
+void InputImeEventRouter::UnregisterImeExtension(
+    const std::string& extension_id) {
+  std::vector<std::string>::iterator it =
+      std::find(extension_ids_.begin(), extension_ids_.end(), extension_id);
+  if (it != extension_ids_.end()) {
+    IMEEngineHandlerInterface* engine =
+        ui::IMEBridge::Get()->GetCurrentEngineHandler();
+    if (engine && engine->GetExtensionId() == extension_id) {
+      engine->Disable();
+      delete engine;

[Devlin, 2016/01/13 18:22:59]

This lifetime management is pretty wonky.  Do we have a guarantee that
UnregisterImeExtension will always be called so that the engine doesn't leak?

[Azure Wei, 2016/01/14 14:03:48]

A new private function DeleteInputMethodEngine() is added. It will be called in
UnregisterImeExtension(), ~InputImeEventRouter() and SetActiveEngine(). I think
these will guarantee the InputMethodEngine will be deleted.

+      ui::IMEBridge::Get()->SetCurrentEngineHandler(nullptr);
+    }
+    extension_ids_.erase(it);
+  }
+}
+
+IMEEngineHandlerInterface* InputImeEventRouter::GetActiveEngine(
+    const std::string& extension_id) {
+  IMEEngineHandlerInterface* engine =
+      ui::IMEBridge::Get()->GetCurrentEngineHandler();
+  return (engine && engine->GetExtensionId() == extension_id) ? engine
+                                                              : nullptr;
+}
+
+void InputImeEventRouter::SetActiveEngine(const std::string& extension_id) {
+  IMEEngineHandlerInterface* pre_engine =
+      ui::IMEBridge::Get()->GetCurrentEngineHandler();
+  if (pre_engine) {
+    if (pre_engine->GetExtensionId() == extension_id)
+      return;
+    pre_engine->Disable();
+    delete pre_engine;
+    ui::IMEBridge::Get()->SetCurrentEngineHandler(nullptr);
+  }
+  scoped_ptr<input_method::InputMethodEngine> engine(
+      new input_method::InputMethodEngine());
+  scoped_ptr<ui::IMEEngineObserver> observer(
+      new ImeObserverNonChromeOS(extension_id, profile()));
+  engine->Initialize(std::move(observer), extension_id.c_str(), profile());
+  engine->Enable("");
+  ui::IMEBridge::Get()->SetCurrentEngineHandler(engine.release());
+  return;

[Devlin, 2016/01/13 18:22:59]

?

[Azure Wei, 2016/01/14 14:03:48]

Deleted.

+}
+
+ExtensionFunction::ResponseAction InputImeActivateFunction::Run() {
+  if (!IsInputImeEnabled())
+    return RespondNow(Error(kErrorAPIDisabled));
+
+  InputImeEventRouter* event_router =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
+  event_router->RegisterImeExtension(extension_id());
+  event_router->SetActiveEngine(extension_id());
+  return RespondNow(NoArguments());
+}
+
+ExtensionFunction::ResponseAction InputImeDeactivateFunction::Run() {
+  if (!IsInputImeEnabled())
+    return RespondNow(Error(kErrorAPIDisabled));
+
+  InputImeEventRouter* event_router =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
+  event_router->UnregisterImeExtension(extension_id());
+  return RespondNow(NoArguments());
+}
+
 void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
-                                    const Extension* extension) {}
+                                    const Extension* extension) {
+  // Initialize the static |g_ime_bridge | if it is NULL.
+  ui::IMEBridge::Initialize();
+}
 
 void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
-                                      UnloadedExtensionInfo::Reason reason) {}
+                                      UnloadedExtensionInfo::Reason reason) {
+  GetInputImeEventRouter(Profile::FromBrowserContext(browser_context))
+      ->UnregisterImeExtension(extension->id());
+}
 
 void InputImeAPI::OnListenerAdded(const EventListenerInfo& details) {}