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

chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.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.
 
 // This file is for non-chromeos (win & linux) functions, such as
 // chrome.input.ime.activate, chrome.input.ime.createWindow and
 // chrome.input.ime.onSelectionChanged.
 // TODO(azurewei): May refactor the code structure by using delegate or
 // redesign the API to remove this platform-specific file in the future.
 
 #include "chrome/browser/extensions/api/input_ime/input_ime_api.h"
 
 #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 {

[Devlin, 2016/01/11 21:48:33]

\n

[Azure Wei, 2016/01/13 02:28:10]

Done.

+const char kErrorAPIDisabled[] =
+    "The chrome.input.ime API is not supported on the current platform";
 
 bool IsInputImeEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableInputImeAPI);
 }
 
 class ImeObserverNonChromeOS : public ui::ImeObserver {
  public:
   ImeObserverNonChromeOS(const std::string& extension_id, Profile* profile)
       : ImeObserver(extension_id, profile) {}
@@ skipping 10 matching lines @@
       return;
     }
 
     scoped_ptr<extensions::Event> event(
         new extensions::Event(histogram_value, event_name, std::move(args)));
     event->restrict_to_browser_context = profile_;
     extensions::EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, std::move(event));
   }
 
-  std::string GetCurrentScreenType() override {
-    return "normal";
-  }
+  std::string GetCurrentScreenType() override { return "normal"; }
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserverNonChromeOS);
 };
 
 }  // namespace
 
 namespace extensions {
 
 InputImeEventRouter::InputImeEventRouter(Profile* profile)
     : InputImeEventRouterBase(profile) {}
 
 InputImeEventRouter::~InputImeEventRouter() {}
 
+bool InputImeEventRouter::RegisterImeExtension(
+    const std::string& extension_id) {
+  VLOG(1) << "RegisterImeExtension: " << extension_id;

[Devlin, 2016/01/11 21:48:33]

Remove debugging logs.

[Azure Wei, 2016/01/13 02:28:10]

Done.

+
+  // Already regsitered

[Devlin, 2016/01/11 21:48:33]

typo + add period.

[Azure Wei, 2016/01/13 02:28:10]

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->GetExtensionId() == extension_id) {
+      engine = nullptr;

[Devlin, 2016/01/11 21:48:33]

What is this supposed to do?  It's just a local raw ptr, so resetting it
(AFAICT) doesn't have any effect...

[Azure Wei, 2016/01/13 02:28:10]

Changed it with ui::IMEBridge()::Get()->SetCurrentEngineHandler(nullptr);

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

Heh that's quite a difference...

+    }
+    extension_ids_.erase(it);
+  }
+}
+
+IMEEngineHandlerInterface* InputImeEventRouter::GetActiveEngine(
+    const std::string& extension_id) {
+  IMEEngineHandlerInterface* engine =
+      ui::IMEBridge::Get()->GetCurrentEngineHandler();
+  if (engine && engine->GetExtensionId() == extension_id)
+    return engine;

[Devlin, 2016/01/11 21:48:33]

ternary.

[Azure Wei, 2016/01/13 02:28:10]

Done.

+  return nullptr;
+}
+
+void InputImeEventRouter::SetActiveEngine(const std::string& extension_id) {
+  IMEEngineHandlerInterface* engine =
+      ui::IMEBridge::Get()->GetCurrentEngineHandler();
+  if (engine) {
+    engine->Disable();
+  }
+  input_method::InputMethodEngine* input_engine =

[Devlin, 2016/01/11 21:48:33]

nit: Wrap in a scoped_ptr until ownership is passed.

[Azure Wei, 2016/01/13 02:28:10]

Done.

+      new input_method::InputMethodEngine();
+  scoped_ptr<ui::IMEEngineObserver> observer(
+      new ImeObserverNonChromeOS(extension_id, profile()));
+  input_engine->Initialize(std::move(observer), extension_id.c_str(),
+                           profile());
+  ui::IMEBridge::Get()->SetCurrentEngineHandler(input_engine);
+  engine = ui::IMEBridge::Get()->GetCurrentEngineHandler();

[Devlin, 2016/01/11 21:48:33]

Is there any way this is different from |input_engine|?  If so, document how.

[Azure Wei, 2016/01/13 02:28:10]

The only difference is that |input_engine| has Initialize() function. I've
changed the sequence of SetCurrentEngineHandler() with engine->Enable() to avoid
using two engine.

+  engine->Enable("");
+  return;
+}
+
+bool InputImeActivateFunction::RunSync() {
+  if (!IsInputImeEnabled()) {
+    error_ = kErrorAPIDisabled;
+    return false;
+  }
+  InputImeEventRouter* event_router =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
+  event_router->RegisterImeExtension(extension_id());
+  event_router->SetActiveEngine(extension_id());
+  return true;
+}
+
+bool InputImeDeactivateFunction::RunSync() {
+  if (!IsInputImeEnabled()) {
+    error_ = kErrorAPIDisabled;
+    return false;
+  }
+  InputImeEventRouter* event_router =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
+  event_router->UnregisterImeExtension(extension_id());
+  return true;
+}
+
 void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
-                                    const Extension* extension) {}
+                                    const Extension* extension) {
+  ui::IMEBridge::Initialize();

[Devlin, 2016/01/11 21:48:33]

If this is guaranteed to be a no-op, put a comment.  Otherwise, ensure we only
call this once.

[Azure Wei, 2016/01/13 02:28:10]

Done.

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

I'd prefer just a "// No-op if called multiple times." rather than including
implementation details about the method here.

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

Done.

+}
 
 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) {}
 
 }  // namespace extensions