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 233 matching lines @@
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
   InputMethodEngineBase* engine =
       event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
   if (engine) {
     engine->KeyEventHandled(extension_id(), params->request_id,
                             params->response);
   }
   return RespondNow(NoArguments());
 }
 
+ExtensionFunction::ResponseAction InputImeSetCompositionFunction::Run() {
+  bool success = false;
+  InputImeEventRouter* event_router =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
+  InputMethodEngineBase* engine =
+      event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
+  if (engine) {
+    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;
+    success = engine->SetComposition(params.context_id, params.text.c_str(),
+                                     selection_start, selection_end,
+                                     params.cursor, segments, &error_);
+  }
+  scoped_ptr<base::ListValue> output = SetComposition::Results::Create(success);
+  return RespondNow(ArgumentList(std::move(output)));
+}
+
+ExtensionFunction::ResponseAction InputImeCommitTextFunction::Run() {
+  bool success = false;
+  InputImeEventRouter* event_router =
+      GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
+  InputMethodEngineBase* engine =
+      event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
+  if (engine) {
+    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)));
+}
+
 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