InputMethod should stop TextInputClient::InsertChar/InsertText calls when the event is stopped prop…

ui/base/ime/input_method_chromeos.cc

 // Copyright 2014 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 "ui/base/ime/input_method_chromeos.h"
 
 #include <algorithm>
 #include <cstring>
 #include <set>
 #include <vector>
@@ skipping 328 matching lines @@
 void InputMethodChromeOS::ProcessKeyEventPostIME(const ui::KeyEvent& event,
                                                  bool handled) {
   TextInputClient* client = GetTextInputClient();
   if (!client) {
     // As ibus works asynchronously, there is a chance that the focused client
     // loses focus before this method gets called.
     DispatchKeyEventPostIME(event);
     return;
   }
 
-  if (event.type() == ET_KEY_PRESSED && handled)
-    ProcessFilteredKeyPressEvent(event);
+  if (event.type() == ET_KEY_PRESSED && handled) {
+    if (ProcessFilteredKeyPressEvent(event)) {
+      ResetContext();
+      return;
+    }
+  }
 
   // In case the focus was changed by the key event. The |context_| should have
   // been reset when the focused window changed.
   if (client != GetTextInputClient())
     return;
 
   if (HasInputMethodResult())
     ProcessInputMethodResult(event, handled);
 
   // In case the focus was changed when sending input method results to the
   // focused window.
   if (client != GetTextInputClient())
     return;
 
   if (handled)
     return;  // IME handled the key event. do not forward.
 
   if (event.type() == ET_KEY_PRESSED)
     ProcessUnfilteredKeyPressEvent(event);
   else if (event.type() == ET_KEY_RELEASED)
     DispatchKeyEventPostIME(event);
 }
 
-void InputMethodChromeOS::ProcessFilteredKeyPressEvent(
+bool InputMethodChromeOS::ProcessFilteredKeyPressEvent(
     const ui::KeyEvent& event) {
-  if (NeedInsertChar()) {
-    DispatchKeyEventPostIME(event);
-  } else {
-    const ui::KeyEvent fabricated_event(ET_KEY_PRESSED,
-                                        VKEY_PROCESSKEY,
-                                        event.flags());
-    DispatchKeyEventPostIME(fabricated_event);
-  }
+  if (NeedInsertChar())
+    return DispatchKeyEventPostIME(event);
+  const ui::KeyEvent fabricated_event(ET_KEY_PRESSED,
+                                      VKEY_PROCESSKEY,
+                                      event.flags());
+  return DispatchKeyEventPostIME(fabricated_event);
 }
 
 void InputMethodChromeOS::ProcessUnfilteredKeyPressEvent(
     const ui::KeyEvent& event) {
   const TextInputClient* prev_client = GetTextInputClient();
-  DispatchKeyEventPostIME(event);
+  if (DispatchKeyEventPostIME(event)) {
+    ResetContext();
+    return;
+  }
 
   // We shouldn't dispatch the character anymore if the key event dispatch
   // caused focus change. For example, in the following scenario,
   // 1. visit a web page which has a <textarea>.
   // 2. click Omnibox.
   // 3. enable Korean IME, press A, then press Tab to move the focus to the web
   //    page.
   // We should return here not to send the Tab key event to RWHV.
   TextInputClient* client = GetTextInputClient();
   if (!client || client != prev_client)
     return;
 
   // If a key event was not filtered by |context_| and |character_composer_|,
   // then it means the key event didn't generate any result text. So we need
   // to send corresponding character to the focused text input client.
   uint16 ch = event.GetCharacter();
   if (ch)
     client->InsertChar(ch, event.flags());
 }
 
 void InputMethodChromeOS::ProcessInputMethodResult(const ui::KeyEvent& event,
-                                               bool handled) {
+                                                   bool handled) {
   TextInputClient* client = GetTextInputClient();
   DCHECK(client);
 
   if (result_text_.length()) {
     if (handled && NeedInsertChar()) {
       for (base::string16::const_iterator i = result_text_.begin();
            i != result_text_.end(); ++i) {
         client->InsertChar(*i, event.flags());
       }
     } else {
@@ skipping 243 matching lines @@
 bool InputMethodChromeOS::IsNonPasswordInputFieldFocused() {
   TextInputType type = GetTextInputType();
   return (type != TEXT_INPUT_TYPE_NONE) && (type != TEXT_INPUT_TYPE_PASSWORD);
 }
 
 bool InputMethodChromeOS::IsInputFieldFocused() {
   return GetTextInputType() != TEXT_INPUT_TYPE_NONE;
 }
 
 }  // namespace ui