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 89 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_(NULL),
-      profile_(NULL) {}
+      profile_(NULL),

[Shu Chen, 2016/02/04 08:00:46]

s/NULL/nullptr/g

[Azure Wei, 2016/02/04 11:57:21]

Done.

+      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() {
+  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)

[Shu Chen, 2016/02/04 08:00:46]

bracket.

[Azure Wei, 2016/02/04 11:57:21]

Done.

+      input_context->UpdateCompositionText(
+          composition_, composition_.selection.start(), true);
+    composition_.Clear();
+  }
+  if (!text_.empty()) {
+    if (input_context)
+      input_context->CommitText(text_);
+    text_ = "";
+  }
+}
+
 }  // namespace input_method