Remove IBus specific hack from InputMethodIBus.

ui/base/ime/input_method_ibus.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 "ui/base/ime/input_method_ibus.h"
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #undef FocusIn
@@ skipping 73 matching lines @@
 namespace ui {
 
 // InputMethodIBus implementation -----------------------------------------
 InputMethodIBus::InputMethodIBus(
     internal::InputMethodDelegate* delegate)
     : input_context_state_(INPUT_CONTEXT_STOP),
       create_input_context_fail_count_(0),
       context_focused_(false),
       composing_text_(false),
       composition_changed_(false),
-      suppress_next_result_(false),
       current_keyevent_id_(0),
       weak_ptr_factory_(this) {
   SetDelegate(delegate);
 
   // chromeos::IBusDaemonController is not available in case of some testing,
   // e.g. content_browser test can't initialize IBusDaemonController.
   DCHECK(!base::chromeos::IsRunningOnChromeOS() ||
          chromeos::IBusDaemonController::GetInstance());
 
   if (chromeos::IBusDaemonController::GetInstance())
@@ skipping 121 matching lines @@
                  ibus_keyval,
                  ibus_keycode,
                  ibus_state);
 
   GetInputContextClient()->ProcessKeyEvent(ibus_keyval,
                                            ibus_keycode,
                                            ibus_state,
                                            callback,
                                            base::Bind(callback, false));
   ++current_keyevent_id_;
-
-  // We don't want to suppress the result generated by this key event, but it
-  // may cause problem. See comment in ResetContext() method.
-  suppress_next_result_ = false;
   return true;
 }
 
 bool InputMethodIBus::DispatchFabricatedKeyEvent(const ui::KeyEvent& event) {
   // TODO(bryeung): The fabricated events should also pass through IME.
   if (event.type() == ET_KEY_PRESSED) {
     ProcessUnfilteredFabricatedKeyPressEvent(
         ET_KEY_PRESSED, event.key_code(), event.flags());
   } else {
     DispatchFabricatedKeyEventPostIME(
@@ skipping 172 matching lines @@
 
   ResetContext();
 }
 
 void InputMethodIBus::ResetContext() {
   if (!context_focused_ || !GetTextInputClient())
     return;
 
   DCHECK(system_toplevel_window_focused());
 
-  // Because ibus runs in asynchronous mode, the input method may still send us
-  // results after sending out the reset request, so we use a flag to discard
-  // all results generated by previous key events. But because ibus does not
-  // have a mechanism to identify each key event and corresponding results, this
-  // approach will not work for some corner cases. For example if the user types
-  // very fast, then the next key event may come in before the |context_| is
-  // really reset. Then we actually cannot know whether or not the next
-  // result should be discard.
-  suppress_next_result_ = true;
-
   composition_.Clear();
   result_text_.clear();
   composing_text_ = false;
   composition_changed_ = false;
 
   // We need to abandon all pending key events, but as above comment says, there
   // is no reliable way to abandon all results generated by these abandoned key
   // events.
   AbandonAllPendingKeyEvents();
 
@@ skipping 208 matching lines @@
   DispatchFabricatedKeyEventPostIME(pressed ? ET_KEY_PRESSED : ET_KEY_RELEASED,
                                     VKEY_PROCESSKEY,
                                     0);
 }
 
 void InputMethodIBus::AbandonAllPendingKeyEvents() {
   pending_key_events_.clear();
 }
 
 void InputMethodIBus::CommitText(const chromeos::IBusText& text) {
-  if (suppress_next_result_ || text.text().empty())
+  if (text.text().empty())
     return;
 
   // We need to receive input method result even if the text input type is
   // TEXT_INPUT_TYPE_NONE, to make sure we can always send correct
   // character for each key event to the focused text input client.
   if (!GetTextInputClient())
     return;
 
   const string16 utf16_text = UTF8ToUTF16(text.text());
   if (utf16_text.empty())
@@ skipping 31 matching lines @@
   // results.
   if (event_type == ET_KEY_PRESSED) {
     ProcessUnfilteredFabricatedKeyPressEvent(event_type, ui_key_code,
                                              event_flags);
   } else {
     DispatchFabricatedKeyEventPostIME(event_type, ui_key_code, event_flags);
   }
 }
 
 void InputMethodIBus::ShowPreeditText() {
-  if (suppress_next_result_ || IsTextInputTypeNone())
+  if (IsTextInputTypeNone())
     return;
 
   composing_text_ = true;
 }
 
 void InputMethodIBus::UpdatePreeditText(const chromeos::IBusText& text,
                                         uint32 cursor_pos,
                                         bool visible) {
-  if (suppress_next_result_ || IsTextInputTypeNone())
+  if (IsTextInputTypeNone())
     return;
 
   // |visible| argument is very confusing. For example, what's the correct
   // behavior when:
   // 1. OnUpdatePreeditText() is called with a text and visible == false, then
   // 2. OnShowPreeditText() is called afterwards.
   //
   // If it's only for clearing the current preedit text, then why not just use
   // OnHidePreeditText()?
   if (!visible) {
@@ skipping 111 matching lines @@
 }
 
 bool InputMethodIBus::ExecuteCharacterComposer(uint32 ibus_keyval,
                                                uint32 ibus_keycode,
                                                uint32 ibus_state) {
   bool consumed = character_composer_.FilterKeyPress(
       ibus_keyval,
       ibus_keycode,
       EventFlagsFromXState(ibus_state));
 
-  suppress_next_result_ = false;
   chromeos::IBusText preedit;
   preedit.set_text(
       UTF16ToUTF8(character_composer_.preedit_string()));
   UpdatePreeditText(preedit, preedit.text().size(),
                     !preedit.text().empty());
    std::string commit_text =
       UTF16ToUTF8(character_composer_.composed_character());
   if (!commit_text.empty()) {
     chromeos::IBusText ibus_text;
     ibus_text.set_text(commit_text);
@@ skipping 95 matching lines @@
   }
 
   // Use a black thin underline by default.
   if (out_composition->underlines.empty()) {
     out_composition->underlines.push_back(CompositionUnderline(
         0, length, SK_ColorBLACK, false /* thick */));
   }
 }
 
 }  // namespace ui