Fix control key and paste behavior in Linux omnibox.

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 86 matching lines @@
       popup_window_mode_(popup_window_mode),
       scheme_security_level_(ToolbarModel::NORMAL),
       selection_saved_(false),
       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
-      tab_was_pressed_(false) {
+      tab_was_pressed_(false),
+      paste_clipboard_requested_(false) {
   model_->set_popup_model(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 86 matching lines @@
   g_signal_connect(text_view_, "populate-popup",
                    G_CALLBACK(&HandlePopulatePopupThunk), this);
   mark_set_handler_id_ = g_signal_connect(
       text_buffer_, "mark-set", G_CALLBACK(&HandleMarkSetThunk), this);
   g_signal_connect(text_view_, "drag-data-received",
                    G_CALLBACK(&HandleDragDataReceivedThunk), this);
   g_signal_connect(text_view_, "backspace",
                    G_CALLBACK(&HandleBackSpaceThunk), this);
   g_signal_connect(text_view_, "copy-clipboard",
                    G_CALLBACK(&HandleCopyClipboardThunk), this);
+  g_signal_connect(text_view_, "paste-clipboard",
+                   G_CALLBACK(&HandlePasteClipboardThunk), this);
 
 #if !defined(TOOLKIT_VIEWS)
   registrar_.Add(this,
                  NotificationType::BROWSER_THEME_CHANGED,
                  NotificationService::AllSources());
   theme_provider_->InitThemesFor(this);
 #else
   // Manually invoke SetBaseColor() because TOOLKIT_VIEWS doesn't observe
   // themes.
   SetBaseColor();
@@ skipping 129 matching lines @@
     gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
     gtk_text_buffer_get_iter_at_offset(text_buffer_, &start, 1);
     StartUpdatingHighlightedText();
     gtk_text_buffer_select_range(text_buffer_, &start, &end);
     FinishUpdatingHighlightedText();
   }
 }
 
 bool AutocompleteEditViewGtk::IsSelectAll() {
   GtkTextIter sel_start, sel_end;
-  if (!gtk_text_buffer_get_selection_bounds(text_buffer_, &sel_start, &sel_end))
-    return false;
+  gtk_text_buffer_get_selection_bounds(text_buffer_, &sel_start, &sel_end);
 
   GtkTextIter start, end;
   gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
 
+  // Returns true if the |text_buffer_| is empty.
   return gtk_text_iter_equal(&start, &sel_start) &&
       gtk_text_iter_equal(&end, &sel_end);
 }
 
 void AutocompleteEditViewGtk::SelectAll(bool reversed) {
   // SelectAll() is invoked as a side effect of other actions (e.g.  switching
   // tabs or hitting Escape) in autocomplete_edit.cc, so we don't update the
   // PRIMARY selection here.
   // TODO(derat): But this is also called by LocationBarView::FocusLocation() --
   // should the X selection be updated when the user hits Ctrl-L?
   SelectAllInternal(reversed, false);
 }
 
 void AutocompleteEditViewGtk::RevertAll() {
   ClosePopup();
   model_->Revert();
   TextChanged();
 }
 
 void AutocompleteEditViewGtk::UpdatePopup() {
   model_->SetInputInProgress(true);
   if (!model_->has_focus())
     return;
 
   // Don't inline autocomplete when the caret/selection isn't at the end of
   // the text.
   CharRange sel = GetSelection();
-  model_->StartAutocomplete(sel.cp_max < GetTextLength());
+  model_->StartAutocomplete(std::max(sel.cp_max, sel.cp_min) < GetTextLength());
 }
 
 void AutocompleteEditViewGtk::ClosePopup() {
   popup_view_->GetModel()->StopAutocomplete();
 }
 
 void AutocompleteEditViewGtk::OnTemporaryTextMaybeChanged(
     const std::wstring& display_text,
     bool save_original_selection) {
   if (save_original_selection) {
@@ skipping 29 matching lines @@
 
 void AutocompleteEditViewGtk::OnRevertTemporaryText() {
   StartUpdatingHighlightedText();
   SetTextAndSelectedRange(saved_temporary_text_, saved_temporary_selection_);
   FinishUpdatingHighlightedText();
   saved_temporary_text_.clear();
   TextChanged();
 }
 
 void AutocompleteEditViewGtk::OnBeforePossibleChange() {
+  // If this change is caused by a paste clipboard action and all text is
+  // selected, then call model_->on_paste_replacing_all() to prevent inline
+  // autocomplete.
+  if (paste_clipboard_requested_) {
+    paste_clipboard_requested_ = false;
+    if (IsSelectAll())
+      model_->on_paste_replacing_all();
+  }
+
   // Record our state.
   text_before_change_ = GetText();
   sel_before_change_ = GetSelection();
 }
 
 // TODO(deanm): This is mostly stolen from Windows, and will need some work.
 bool AutocompleteEditViewGtk::OnAfterPossibleChange() {
   CharRange new_sel = GetSelection();
   int length = GetTextLength();
   bool selection_differs = (new_sel.cp_min != sel_before_change_.cp_min) ||
@@ skipping 149 matching lines @@
   }
 
   // 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 |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_pressed && (char_inserted_ == '\n' || char_inserted_ == '\r')) {
@@ skipping 52 matching lines @@
       model_->OnControlKeyChanged(false);
   }
 
   // Even though we handled the press ourselves, let GtkTextView handle the
   // release.  It shouldn't do anything particularly interesting, but it will
   // handle the IME work for us.
   return FALSE;  // Propagate into GtkTextView.
 }
 
 gboolean AutocompleteEditViewGtk::HandleViewButtonPress(GdkEventButton* event) {
+  // We don't need to care about double and triple clicks.
+  if (event->type != GDK_BUTTON_PRESS)
+    return FALSE;
+
   if (event->button == 1) {
     // When the first button is pressed, track some stuff that will help us
     // determine whether we should select all of the text when the button is
     // released.
     button_1_pressed_ = true;
     text_view_focused_before_button_press_ = GTK_WIDGET_HAS_FOCUS(text_view_);
     text_selected_during_click_ = false;
+  } else if (event->button == 2) {
+    // GtkTextView pastes PRIMARY selection with middle click.
+    // We can't call model_->on_paste_replacing_all() here, because the actual
+    // paste clipboard action may not be performed if the clipboard is empty.
+    paste_clipboard_requested_ = true;
   }
   return FALSE;
 }
 
 gboolean AutocompleteEditViewGtk::HandleViewButtonRelease(
     GdkEventButton* event) {
   if (event->button != 1)
     return FALSE;
 
   button_1_pressed_ = false;
@@ skipping 14 matching lines @@
     // code it will skip an important loop.  Use -1 to achieve the same.
     GtkTextIter start, end;
     gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
     gtk_text_view_move_visually(GTK_TEXT_VIEW(text_view_), &start, -1);
   }
 
   return TRUE;  // Don't continue, we called the default handler already.
 }
 
 gboolean AutocompleteEditViewGtk::HandleViewFocusIn() {
-  model_->OnSetFocus(false);
+  GdkModifierType modifiers;
+  gdk_window_get_pointer(text_view_->window, NULL, NULL, &modifiers);
+  model_->OnSetFocus((modifiers & GDK_CONTROL_MASK) != 0);
   // TODO(deanm): Some keyword hit business, etc here.
 
   return FALSE;  // Continue propagation.
 }
 
 gboolean AutocompleteEditViewGtk::HandleViewFocusOut() {
   // Close the popup.
   ClosePopup();
   // Tell the model to reset itself.
   model_->OnKillFocus();
@@ skipping 122 matching lines @@
     SavePrimarySelection(selected_text_);
     selection_saved_ = true;
   }
 }
 
 // Just use the default behavior for DnD, except if the drop can be a PasteAndGo
 // then override.
 void AutocompleteEditViewGtk::HandleDragDataReceived(
     GdkDragContext* context, gint x, gint y,
     GtkSelectionData* selection_data, guint target_type, guint time) {
+  // Reset |paste_clipboard_requested_| to make sure we won't misinterpret this
+  // drop action as a paste action.
+  paste_clipboard_requested_ = false;
+
   // Don't try to PasteAndGo on drops originating from this omnibox. However, do
   // allow default behavior for such drags.
   if (context->source_window == text_view_->window)
     return;
 
   guchar* text = gtk_selection_data_get_text(selection_data);
   if (!text)
     return;
 
   std::wstring possible_url = UTF8ToWide(reinterpret_cast<char*>(text));
@@ skipping 103 matching lines @@
   // don't want to do (and it also appears to at least sometimes trigger a
   // failed G_IS_OBJECT() assertion).
   if (gtk_clipboard_get_owner(clipboard) == G_OBJECT(text_buffer_))
     return;
 
   // We can't just call SavePrimarySelection(); that makes the text view lose
   // the selection and unhighlight its text.
   gtk_text_buffer_copy_clipboard(text_buffer_, clipboard);
 }
 
+void AutocompleteEditViewGtk::HandlePasteClipboard() {
+  // We can't call model_->on_paste_replacing_all() here, because the actual
+  // paste clipboard action may not be performed if the clipboard is empty.
+  paste_clipboard_requested_ = true;
+}
+
 void AutocompleteEditViewGtk::SelectAllInternal(bool reversed,
                                                 bool update_primary_selection) {
   GtkTextIter start, end;
   if (reversed) {
     gtk_text_buffer_get_bounds(text_buffer_, &end, &start);
   } else {
     gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
   }
   if (!update_primary_selection)
     StartUpdatingHighlightedText();
@@ skipping 115 matching lines @@
     const std::string& selected_text) {
   GtkClipboard* clipboard =
       gtk_widget_get_clipboard(text_view_, GDK_SELECTION_PRIMARY);
   DCHECK(clipboard);
   if (!clipboard)
     return;
 
   gtk_clipboard_set_text(
       clipboard, selected_text.data(), selected_text.size());
 }