Implement input.ime.sendKeyEvents API.

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

 // Copyright (c) 2012 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 "base/lazy_instance.h"
 #include "chrome/common/extensions/api/input_ime.h"
 #include "extensions/browser/extension_registry.h"
 
 namespace input_ime = extensions::api::input_ime;
 namespace KeyEventHandled = extensions::api::input_ime::KeyEventHandled;
 namespace SetComposition = extensions::api::input_ime::SetComposition;
 namespace CommitText = extensions::api::input_ime::CommitText;
+namespace SendKeyEvents = extensions::api::input_ime::SendKeyEvents;
 using ui::IMEEngineHandlerInterface;
 using input_method::InputMethodEngineBase;
 
+namespace {
+const char kErrorEngineNotAvailable[] = "Engine is not available";
+}
 namespace ui {
 
 ImeObserver::ImeObserver(const std::string& extension_id, Profile* profile)
     : extension_id_(extension_id), profile_(profile) {}
 
 void ImeObserver::OnActivate(const std::string& component_id) {
   if (extension_id_.empty() || !HasListener(input_ime::OnActivate::kEventName))
     return;
 
   scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(
@@ skipping 294 matching lines @@
     scoped_ptr<CommitText::Params> parent_params(
         CommitText::Params::Create(*args_));
     const CommitText::Params::Parameters& params = parent_params->parameters;
     success =
         engine->CommitText(params.context_id, params.text.c_str(), &error_);
   }
   scoped_ptr<base::ListValue> output = CommitText::Results::Create(success);
   return RespondNow(ArgumentList(std::move(output)));
 }
 
+ExtensionFunction::ResponseAction InputImeSendKeyEventsFunction::Run() {
+  InputImeEventRouter* event_router =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
+  InputMethodEngineBase* engine =
+      event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
+  if (!engine)
+    return RespondNow(Error(kErrorEngineNotAvailable));
+
+  scoped_ptr<SendKeyEvents::Params> parent_params(
+      SendKeyEvents::Params::Create(*args_));
+  const SendKeyEvents::Params::Parameters& params = parent_params->parameters;
+  const std::vector<linked_ptr<input_ime::KeyboardEvent>>& key_data =
+      params.key_data;
+  std::vector<InputMethodEngineBase::KeyboardEvent> key_data_out;
+
+  for (size_t i = 0; i < key_data.size(); ++i) {
+    InputMethodEngineBase::KeyboardEvent event;
+    event.type = input_ime::ToString(key_data[i]->type);
+    event.key = key_data[i]->key;
+    event.code = key_data[i]->code;
+    event.key_code = key_data[i]->key_code.get() ? *(key_data[i]->key_code) : 0;
+    if (key_data[i]->alt_key)
+      event.alt_key = *(key_data[i]->alt_key);
+    if (key_data[i]->ctrl_key)
+      event.ctrl_key = *(key_data[i]->ctrl_key);
+    if (key_data[i]->shift_key)
+      event.shift_key = *(key_data[i]->shift_key);
+    if (key_data[i]->caps_lock)
+      event.caps_lock = *(key_data[i]->caps_lock);
+    key_data_out.push_back(event);
+  }
+  engine->SendKeyEvents(params.context_id, key_data_out);

[Shu Chen, 2016/03/08 05:59:44]

Better to expose the errors.

[Azure Wei, 2016/03/08 11:42:29]

Done.

+  return RespondNow(NoArguments());
+}
+
 InputImeAPI::InputImeAPI(content::BrowserContext* context)
     : browser_context_(context), extension_registry_observer_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 
   EventRouter* event_router = EventRouter::Get(browser_context_);
   event_router->RegisterObserver(this, input_ime::OnFocus::kEventName);
 }
 
 InputImeAPI::~InputImeAPI() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
@@ skipping 10 matching lines @@
 InputImeEventRouter* GetInputImeEventRouter(Profile* profile) {
   if (!profile)
     return nullptr;
   if (profile->HasOffTheRecordProfile())
     profile = profile->GetOffTheRecordProfile();
   return extensions::InputImeEventRouterFactory::GetInstance()->GetRouter(
       profile);
 }
 
 }  // namespace extensions