[Linux]Workaround issue 50485

chrome/browser/renderer_host/gtk_im_context_wrapper.cc

 // Copyright (c) 2010 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/renderer_host/gtk_im_context_wrapper.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 #include <algorithm>
@@ skipping 20 matching lines @@
 GtkIMContextWrapper::GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view)
     : host_view_(host_view),
       context_(gtk_im_multicontext_new()),
       context_simple_(gtk_im_context_simple_new()),
       is_focused_(false),
       is_composing_text_(false),
       is_enabled_(false),
       is_in_key_event_handler_(false),
       preedit_selection_start_(0),
       preedit_selection_end_(0),
-      is_preedit_changed_(false) {
+      is_preedit_changed_(false),
+      suppress_next_commit_(false) {
   DCHECK(context_);
   DCHECK(context_simple_);
 
   // context_ and context_simple_ share the same callback handlers.
   // All data come from them are treated equally.
   // context_ is for full input method support.
   // context_simple_ is for supporting dead/compose keys when input method is
   // disabled by webkit, eg. in password input box.
   g_signal_connect(context_, "preedit_start",
                    G_CALLBACK(HandlePreeditStartThunk), this);
@@ skipping 26 matching lines @@
 }
 
 GtkIMContextWrapper::~GtkIMContextWrapper() {
   if (context_)
     g_object_unref(context_);
   if (context_simple_)
     g_object_unref(context_simple_);
 }
 
 void GtkIMContextWrapper::ProcessKeyEvent(GdkEventKey* event) {
+  suppress_next_commit_ = false;
+
   // Indicates preedit-changed and commit signal handlers that we are
   // processing a key event.
   is_in_key_event_handler_ = true;
   // Reset this flag so that we can know if preedit is changed after
   // processing this key event.
   is_preedit_changed_ = false;
   // Clear it so that we can know if something needs committing after
   // processing this key event.
   commit_text_.clear();
 
@@ skipping 69 matching lines @@
 
   // Send unfiltered keydown and keyup events after sending IME result.
   if (event->type == GDK_KEY_PRESS && !filtered)
     ProcessUnfilteredKeyPressEvent(&wke);
   else if (event->type == GDK_KEY_RELEASE)
     host_view_->ForwardKeyboardEvent(wke);
 }
 
 void GtkIMContextWrapper::UpdateInputMethodState(WebKit::WebTextInputType type,
                                                  const gfx::Rect& caret_rect) {
+  suppress_next_commit_ = false;
+
   // The renderer has updated its IME status.
   // Control the GtkIMContext object according to this status.
   if (!context_ || !is_focused_)
     return;
 
   DCHECK(!is_in_key_event_handler_);
 
   bool is_enabled = (type == WebKit::WebTextInputTypeText);
   if (is_enabled_ != is_enabled) {
     is_enabled_ = is_enabled;
@@ skipping 87 matching lines @@
 #endif
 
 void GtkIMContextWrapper::CancelComposition() {
   if (!is_enabled_)
     return;
 
   DCHECK(!is_in_key_event_handler_);
 
   // To prevent any text from being committed when resetting the |context_|;
   is_in_key_event_handler_ = true;
+  suppress_next_commit_ = true;
 
   gtk_im_context_reset(context_);
   gtk_im_context_reset(context_simple_);
 
   if (is_focused_) {
     // Some input methods may not honour the reset call. Focusing out/in the
     // |context_| to make sure it gets reset correctly.
     gtk_im_context_focus_out(context_);
     gtk_im_context_focus_in(context_);
   }
@@ skipping 129 matching lines @@
   if (is_composing_text_) {
     if (host_view_->GetRenderWidgetHost())
       host_view_->GetRenderWidgetHost()->ImeConfirmComposition();
 
     // Reset the input method.
     CancelComposition();
   }
 }
 
 void GtkIMContextWrapper::HandleCommit(const string16& text) {
+  if (suppress_next_commit_) {
+    suppress_next_commit_ = false;
+    return;
+  }
+
   // Append the text to the buffer, because commit signal might be fired
   // multiple times when processing a key event.
   commit_text_.append(text);
   // Nothing needs to do, if it's currently in ProcessKeyEvent()
   // handler, which will send commit text to webkit later. Otherwise,
   // we need send it here.
   // It's possible that commit signal is fired without a key event, for
   // example when user input via a voice or handwriting recognition software.
   // In this case, the text must be committed directly.
   if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost())
     host_view_->GetRenderWidgetHost()->ImeConfirmComposition(text);
 }
 
 void GtkIMContextWrapper::HandlePreeditStart() {
   is_composing_text_ = true;
 }
 
 void GtkIMContextWrapper::HandlePreeditChanged(const gchar* text,
                                                PangoAttrList* attrs,
                                                int cursor_position) {
+  suppress_next_commit_ = false;
   // Don't set is_preedit_changed_ to false if there is no change, because
   // this handler might be called multiple times with the same data.
   is_preedit_changed_ = true;
   preedit_text_.clear();
   preedit_underlines_.clear();
   preedit_selection_start_ = 0;
   preedit_selection_end_ = 0;
 
   ExtractCompositionInfo(text, attrs, cursor_position, &preedit_text_,
                          &preedit_underlines_, &preedit_selection_start_,
@@ skipping 169 matching lines @@
     } while (pango_attr_iterator_next(iter));
     pango_attr_iterator_destroy(iter);
   }
 
   // Use a black thin underline by default.
   if (underlines->empty()) {
     underlines->push_back(
         WebKit::WebCompositionUnderline(0, length, SK_ColorBLACK, false));
   }
 }