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";
+const char kErrorSetKeyEventsFail[] = "Could not send key events";
+}
 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_));
+  EXTENSION_FUNCTION_VALIDATE(parent_params);
+  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 (const auto& key_event : key_data) {
+    InputMethodEngineBase::KeyboardEvent event;
+    event.type = input_ime::ToString(key_event->type);
+    event.key = key_event->key;
+    event.code = key_event->code;
+    event.key_code = key_event->key_code.get() ? *(key_event->key_code) : 0;
+    event.alt_key = key_event->alt_key ? *(key_event->alt_key) : false;
+    event.ctrl_key = key_event->ctrl_key ? *(key_event->ctrl_key) : false;
+    event.shift_key = key_event->shift_key ? *(key_event->shift_key) : false;
+    event.caps_lock = key_event->caps_lock ? *(key_event->caps_lock) : false;
+    key_data_out.push_back(event);
+  }
+  if (!engine->SendKeyEvents(params.context_id, key_data_out))
+    return RespondNow(Error(kErrorSetKeyEventsFail));
+  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