Implement chrome.input.ime.setComposition/commitText API.

chrome/browser/ui/input_method/input_method_engine_base.cc

 // Copyright 2016 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/ui/input_method/input_method_engine_base.h"
 
 #undef FocusIn
 #undef FocusOut
 #undef RootWindow
 #include <algorithm>
@@ skipping 29 matching lines @@
 #include "ui/events/keycodes/keyboard_codes_posix.h"
 #endif
 
 namespace input_method {
 
 namespace {
 
 const char kErrorNotActive[] = "IME is not active";
 const char kErrorWrongContext[] = "Context is not active";
 
-// Notifies InputContextHandler that the composition is changed.
-void UpdateComposition(const ui::CompositionText& composition_text,
-                       uint32_t cursor_pos,
-                       bool is_visible) {
-  ui::IMEInputContextHandlerInterface* input_context =
-      ui::IMEBridge::Get()->GetInputContextHandler();
-  if (input_context)
-    input_context->UpdateCompositionText(composition_text, cursor_pos,
-                                         is_visible);
-}
-
-// Returns the length of characters of a UTF-8 string with unknown string
-// length. Cannot apply faster algorithm to count characters in an utf-8
-// string without knowing the string length,  so just does a full scan.
-size_t GetUtf8StringLength(const char* s) {
-  size_t ret = 0;
-  while (*s) {
-    if ((*s & 0xC0) != 0x80)
-      ret++;
-    ++s;
-  }
-  return ret;
-}
-
 #if defined(OS_CHROMEOS)
 std::string GetKeyFromEvent(const ui::KeyEvent& event) {
   const std::string code = event.GetCodeString();
   if (base::StartsWith(code, "Control", base::CompareCase::SENSITIVE))
     return "Ctrl";
   if (base::StartsWith(code, "Shift", base::CompareCase::SENSITIVE))
     return "Shift";
   if (base::StartsWith(code, "Alt", base::CompareCase::SENSITIVE))
     return "Alt";
   if (base::StartsWith(code, "Arrow", base::CompareCase::SENSITIVE))
@@ skipping 90 matching lines @@
 InputMethodEngineBase::KeyboardEvent::~KeyboardEvent() {}
 
 InputMethodEngineBase::InputMethodEngineBase()
     : current_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       context_id_(0),
       next_context_id_(1),
       composition_text_(new ui::CompositionText()),
       composition_cursor_(0),
       sent_key_event_(nullptr),
       profile_(nullptr),
-      next_request_id_(1) {}
+      next_request_id_(1),
+      text_(""),
+      handling_key_event_(false) {}
 
 InputMethodEngineBase::~InputMethodEngineBase() {}
 
 void InputMethodEngineBase::Initialize(
     scoped_ptr<InputMethodEngineBase::Observer> observer,
     const char* extension_id,
     Profile* profile) {
   DCHECK(observer) << "Observer must not be null.";
 
   // TODO(komatsu): It is probably better to set observer out of Initialize.
@@ skipping 83 matching lines @@
   if (!IsActive()) {
     // TODO: Commit the text anyways.
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
-  ui::IMEBridge::Get()->GetInputContextHandler()->CommitText(text);
-
-  // Records histograms for committed characters.
-  if (!composition_text_->text.empty()) {
-    size_t len = GetUtf8StringLength(text);
-    UMA_HISTOGRAM_CUSTOM_COUNTS("InputMethod.CommitLength", len, 1, 25, 25);
-    composition_text_.reset(new ui::CompositionText());
-  }
+  CommitTextToInputContext(context_id, std::string(text));
   return true;
 }
 
 bool InputMethodEngineBase::DeleteSurroundingText(int context_id,
                                                   int offset,
                                                   size_t number_of_chars,
                                                   std::string* error) {
   if (!IsActive()) {
     *error = kErrorNotActive;
     return false;
@@ skipping 67 matching lines @@
   composition_text_.reset(new ui::CompositionText());
   observer_->OnReset(active_component_id_);
 }
 
 bool InputMethodEngineBase::IsInterestedInKeyEvent() const {
   return observer_->IsInterestedInKeyEvent();
 }
 
 void InputMethodEngineBase::ProcessKeyEvent(const ui::KeyEvent& key_event,
                                             KeyEventDoneCallback& callback) {
+  // Make true that we don't handle IME API calling of setComposition and
+  // commitText while the extension is handling key event.
+  handling_key_event_ = true;
+
   KeyboardEvent ext_event;
   GetExtensionKeyboardEventFromKeyEvent(key_event, &ext_event);
 
   // If the given key event is equal to the key event sent by
   // SendKeyEvents, this engine ID is propagated to the extension IME.
   // Note, this check relies on that ui::KeyEvent is propagated as
   // reference without copying.
   if (&key_event == sent_key_event_)
     ext_event.extension_id = extension_id_;
 
   observer_->OnKeyEvent(active_component_id_, ext_event, callback);
 }
 
 void InputMethodEngineBase::SetSurroundingText(const std::string& text,
                                                uint32_t cursor_pos,
                                                uint32_t anchor_pos,
                                                uint32_t offset_pos) {
   observer_->OnSurroundingTextChanged(
       active_component_id_, text, static_cast<int>(cursor_pos),
       static_cast<int>(anchor_pos), static_cast<int>(offset_pos));
 }
 
 void InputMethodEngineBase::KeyEventHandled(const std::string& extension_id,
                                             const std::string& request_id,
                                             bool handled) {
+  handling_key_event_ = false;
+  // When finish handling key event, take care of the unprocessed setComposition
+  // and commitText calls.
+  ui::IMEInputContextHandlerInterface* input_context =
+      ui::IMEBridge::Get()->GetInputContextHandler();
+  if (!composition_.text.empty()) {
+    if (input_context) {
+      input_context->UpdateCompositionText(
+          composition_, composition_.selection.start(), true);
+    }
+    composition_.Clear();
+  }
+  if (!text_.empty()) {
+    if (input_context) {
+      input_context->CommitText(text_);
+    }
+    text_ = "";
+  }
+
   RequestMap::iterator request = request_map_.find(request_id);
   if (request == request_map_.end()) {
     LOG(ERROR) << "Request ID not found: " << request_id;
     return;
   }
 
   request->second.second.Run(handled);
   request_map_.erase(request);
 }
 
 std::string InputMethodEngineBase::AddRequest(
     const std::string& component_id,
     ui::IMEEngineHandlerInterface::KeyEventDoneCallback& key_data) {
   std::string request_id = base::IntToString(next_request_id_);
   ++next_request_id_;
 
   request_map_[request_id] = std::make_pair(component_id, key_data);
 
   return request_id;
 }
 
 }  // namespace input_method