Implement chrome.input.ime.setComposition/commitText 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;
 using ui::IMEEngineHandlerInterface;
 using input_method::InputMethodEngineBase;
 
 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))
@@ skipping 214 matching lines @@
 InputImeEventRouter* InputImeEventRouterFactory::GetRouter(Profile* profile) {
   InputImeEventRouter* router = router_map_[profile];
   if (!router) {
     router = new InputImeEventRouter(profile);
     router_map_[profile] = router;
   }
   return router;
 }
 
 bool InputImeKeyEventHandledFunction::RunAsync() {
+  InputMethodEngineBase* engine =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
+          ->GetActiveEngine(extension_id());
+  if (engine)
+    engine->KeyEventHandled();
+
   scoped_ptr<KeyEventHandled::Params> params(
       KeyEventHandled::Params::Create(*args_));
   GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
       ->OnKeyEventHandled(extension_id(), params->request_id, params->response);
   return true;
 }
 
+ExtensionFunction::ResponseAction InputImeSetCompositionFunction::Run() {
+  InputMethodEngineBase* engine =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
+          ->GetActiveEngine(extension_id());
+  base::DictionaryValue* output = new base::DictionaryValue();

[Devlin, 2016/02/04 00:09:17]

prefer scoped ptr generally, but also we should just be using
SetComposition::Results here.

[Azure Wei, 2016/02/04 03:21:19]

Done.

+  if (!engine) {
+    output->SetBoolean("success", false);
+  } else {
+    scoped_ptr<SetComposition::Params> parent_params(
+        SetComposition::Params::Create(*args_));
+    const SetComposition::Params::Parameters& params =
+        parent_params->parameters;
+    std::vector<InputMethodEngineBase::SegmentInfo> segments;
+    if (params.segments) {
+      const std::vector<
+          linked_ptr<SetComposition::Params::Parameters::SegmentsType>>&
+          segments_args = *params.segments;
+      for (const auto& segments_arg : segments_args) {
+        EXTENSION_FUNCTION_VALIDATE(segments_arg->style !=
+                                    input_ime::UNDERLINE_STYLE_NONE);
+        InputMethodEngineBase::SegmentInfo segment_info;
+        segment_info.start = segments_arg->start;
+        segment_info.end = segments_arg->end;
+        if (segments_arg->style == input_ime::UNDERLINE_STYLE_UNDERLINE) {
+          segment_info.style = InputMethodEngineBase::SEGMENT_STYLE_UNDERLINE;
+        } else if (segments_arg->style ==
+                   input_ime::UNDERLINE_STYLE_DOUBLEUNDERLINE) {
+          segment_info.style =
+              InputMethodEngineBase::SEGMENT_STYLE_DOUBLE_UNDERLINE;
+        } else {
+          segment_info.style =
+              InputMethodEngineBase::SEGMENT_STYLE_NO_UNDERLINE;
+        }
+        segments.push_back(segment_info);
+      }
+    }
+    int selection_start =
+        params.selection_start ? *params.selection_start : params.cursor;
+    int selection_end =
+        params.selection_end ? *params.selection_end : params.cursor;
+    output->SetBoolean(
+        "success", engine->SetComposition(
+                       params.context_id, params.text.c_str(), selection_start,
+                       selection_end, params.cursor, segments, &error_));
+  }
+  return RespondNow(OneArgument(output));
+}
+
+ExtensionFunction::ResponseAction InputImeCommitTextFunction::Run() {
+  base::DictionaryValue* output = new base::DictionaryValue();
+  InputMethodEngineBase* engine =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
+          ->GetActiveEngine(extension_id());
+
+  if (!engine) {
+    output->SetBoolean("success", false);
+  } else {
+    scoped_ptr<CommitText::Params> parent_params(
+        CommitText::Params::Create(*args_));
+    const CommitText::Params::Parameters& params = parent_params->parameters;
+    output->SetBoolean(
+        "success",
+        engine->CommitText(params.context_id, params.text.c_str(), &error_));
+  }
+  return RespondNow(OneArgument(output));
+}
+
 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);
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<InputImeAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<InputImeAPI>* InputImeAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 InputImeEventRouter* GetInputImeEventRouter(Profile* profile) {
   if (profile->HasOffTheRecordProfile())
     profile = profile->GetOffTheRecordProfile();
   return extensions::InputImeEventRouterFactory::GetInstance()->GetRouter(
       profile);
 }
 
 }  // namespace extensions