Fix issue 21587, a regression of CL 196020....

chrome/browser/autocomplete/autocomplete_edit_view_gtk.cc

 // Copyright (c) 2009 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/autocomplete/autocomplete_edit_view_gtk.h"
 
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
@@ skipping 90 matching lines @@
       scheme_security_level_(ToolbarModel::NORMAL),
       mark_set_handler_id_(0),
       button_1_pressed_(false),
       text_selected_during_click_(false),
       text_view_focused_before_button_press_(false),
 #if !defined(TOOLKIT_VIEWS)
       theme_provider_(GtkThemeProvider::GetFrom(profile)),
 #endif
       enter_was_pressed_(false),
       tab_was_pressed_(false),
-      paste_clipboard_requested_(false) {
+      paste_clipboard_requested_(false),
+      enter_was_inserted_(false) {
   model_->SetPopupModel(popup_view_->GetModel());
 }
 
 AutocompleteEditViewGtk::~AutocompleteEditViewGtk() {
   NotificationService::current()->Notify(
       NotificationType::AUTOCOMPLETE_EDIT_DESTROYED,
       Source<AutocompleteEditViewGtk>(this),
       NotificationService::NoDetails());
 
   // Explicitly teardown members which have a reference to us.  Just to be safe
@@ skipping 333 matching lines @@
   text_before_change_ = GetText();
   sel_before_change_ = GetSelection();
 }
 
 // TODO(deanm): This is mostly stolen from Windows, and will need some work.
 bool AutocompleteEditViewGtk::OnAfterPossibleChange() {
   // If the change is caused by an Enter key press event, and the event was not
   // handled by IME, then it's an unexpected change and shall be reverted here.
   // {Start|Finish}UpdatingHighlightedText() are called here to prevent the
   // PRIMARY selection from being changed.
-  if (enter_was_pressed_ &&
-      (char_inserted_ == '\n' || char_inserted_ == '\r')) {
+  if (enter_was_pressed_ && enter_was_inserted_) {
     StartUpdatingHighlightedText();
     SetTextAndSelectedRange(text_before_change_, sel_before_change_);
     FinishUpdatingHighlightedText();
     return false;
   }
 
   CharRange new_sel = GetSelection();
   int length = GetTextLength();
   bool selection_differs = (new_sel.cp_min != sel_before_change_.cp_min) ||
                            (new_sel.cp_max != sel_before_change_.cp_max);
@@ skipping 113 matching lines @@
   // handler will delete current selection range and insert '\n' and always
   // return TRUE. We need to prevent |text_view_| from performing this default
   // action if IME did not handle the key event, because we don't want the
   // content of omnibox to be changed before triggering our special behavior.
   // Otherwise our special behavior would not be performed correctly.
   //
   // But there is no way for us to prevent GtkTextView from handling the key
   // event and performing built-in operation. So in order to achieve our goal,
   // "insert-text" signal of |text_buffer_| object is intercepted, and
   // following actions are done in the signal handler:
-  // - If there is only one character in inserted text, save it in
-  //   char_inserted_.
+  // - If there is only one character in inserted text, and it's '\n' or '\r',
+  //   then set |enter_was_inserted_| to true.
   // - Filter out all new line and tab characters.
   //
-  // So if |char_inserted_| equals '\n' after calling |text_view_|'s
-  // default signal handler against an Enter key press event, then we know that
-  // the Enter key press event was handled by GtkTextView rather than IME, and
-  // can perform the special behavior for Enter key safely.
+  // So if |enter_was_inserted_| is true after calling |text_view_|'s default
+  // signal handler against an Enter key press event, then we know that the
+  // Enter key press event was handled by GtkTextView rather than IME, and can
+  // perform the special behavior for Enter key safely.
   //
   // Now the last thing is to prevent the content of omnibox from being changed
   // by GtkTextView when Enter key is pressed. As OnBeforePossibleChange() and
   // OnAfterPossibleChange() will be called by GtkTextView before and after
   // changing the content, and the content is already saved in
   // OnBeforePossibleChange(), so if the Enter key press event was not handled
   // by IME, it's easy to restore the content in OnAfterPossibleChange(), as if
   // it's not changed at all.
 
   GtkWidgetClass* klass = GTK_WIDGET_GET_CLASS(widget);
 
   enter_was_pressed_ = (event->keyval == GDK_Return ||
                         event->keyval == GDK_ISO_Enter ||
                         event->keyval == GDK_KP_Enter);
 
   // Set |tab_was_pressed_| to true if it's a Tab key press event, so that our
   // handler of "move-focus" signal can trigger Tab to search behavior when
   // necessary.
   tab_was_pressed_ = ((event->keyval == GDK_Tab ||
                        event->keyval == GDK_ISO_Left_Tab ||
                        event->keyval == GDK_KP_Tab) &&
                       !(event->state & GDK_CONTROL_MASK));
 
-  // Reset |char_inserted_|, which may be set in the "insert-text" signal
+  // Reset |enter_was_inserted_|, which may be set in the "insert-text" signal
   // handler, so that we'll know if an Enter key event was handled by IME.
-  char_inserted_ = 0;
+  enter_was_inserted_ = false;
 
   // Reset |paste_clipboard_requested_| to make sure we won't misinterpret this
   // key input action as a paste action.
   paste_clipboard_requested_ = false;
 
   // Call the default handler, so that IME can work as normal.
   // New line characters will be filtered out by our "insert-text"
   // signal handler attached to |text_buffer_| object.
   gboolean result = klass->key_press_event(widget, event);
 
   // Set |tab_was_pressed_| to false, to make sure Tab to search behavior can
   // only be triggered by pressing Tab key.
   tab_was_pressed_ = false;
 
-  if (enter_was_pressed_ &&
-      (char_inserted_ == '\n' || char_inserted_ == '\r')) {
+  if (enter_was_pressed_ && enter_was_inserted_) {
     bool alt_held = (event->state & GDK_MOD1_MASK);
     model_->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
     result = TRUE;
   } else if (!result && event->keyval == GDK_Escape &&
              (event->state & gtk_accelerator_get_default_mod_mask()) == 0) {
     // We can handle the Escape key if |text_view_| did not handle it.
     // If it's not handled by us, then we need to propagate it up to the parent
     // widgets, so that Escape accelerator can still work.
     result = model_->OnEscapeKeyPressed();
   } else if (event->keyval == GDK_Control_L || event->keyval == GDK_Control_R) {
@@ skipping 273 matching lines @@
   filtered_text.reserve(len);
 
   // Filter out new line and tab characters.
   // |text| is guaranteed to be a valid UTF-8 string, so it's safe here to
   // filter byte by byte.
   //
   // If there was only a single character, then it might be generated by a key
   // event. In this case, we save the single character to help our
   // "key-press-event" signal handler distinguish if an Enter key event is
   // handled by IME or not.
-  if (len == 1)
-    char_inserted_ = text[0];
+  if (len == 1 && (text[0] == '\n' || text[0] == '\r'))
+    enter_was_inserted_ = true;
 
   for (gint i = 0; i < len; ++i) {
     gchar c = text[i];
     if (c == '\n' || c == '\r' || c == '\t')
       continue;
 
     filtered_text.push_back(c);
   }
 
   if (filtered_text.length()) {
@@ skipping 221 matching lines @@
   std::string utf8 = WideToUTF8(text);
   gtk_text_buffer_set_text(text_buffer_, utf8.data(), utf8.length());
   SetSelectedRange(range);
 }
 
 void AutocompleteEditViewGtk::SetSelectedRange(const CharRange& range) {
   GtkTextIter insert, bound;
   ItersFromCharRange(range, &bound, &insert);
   gtk_text_buffer_select_range(text_buffer_, &insert, &bound);
 }