Linux: Fix two issues of 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 482 matching lines @@
   // sure the caret, which should be after any insertion, hasn't moved
   // forward of the old selection start.)
   bool just_deleted_text =
       (text_before_change_.length() > new_text.length()) &&
       (new_sel.cp_min <= std::min(sel_before_change_.cp_min,
                                  sel_before_change_.cp_max));
 
   bool something_changed = model_->OnAfterPossibleChange(new_text,
       selection_differs, text_changed_, just_deleted_text, at_end_of_edit);
 
+  // If only selection was changed, we don't need to call |controller_|'s
+  // OnChanged() method, which is called in TextChanged().
+  // But we still need to call EmphasizeURLComponents() to make sure the text
+  // attributes are updated correctly.
   if (something_changed && text_changed_)
     TextChanged();
+  else if (selection_differs)
+    EmphasizeURLComponents();
 
   return something_changed;
 }
 
 gfx::NativeView AutocompleteEditViewGtk::GetNativeView() const {
   return alignment_.get();
 }
 
 void AutocompleteEditViewGtk::Observe(NotificationType type,
                                       const NotificationSource& source,
@@ skipping 208 matching lines @@
   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;
+
+    // Button press event may change the selection, we need to record the change
+    // and report it to |model_| later when button is released.
+    OnBeforePossibleChange();
   } 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(
@@ skipping 15 matching lines @@
 
     // So we told the buffer where the cursor should be, but make sure to tell
     // the view so it can scroll it to be visible if needed.
     // NOTE: This function doesn't seem to like a count of 0, looking at the
     // 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);
   }
 
+  // Inform |model_| about possible text selection change.
+  OnAfterPossibleChange();
+
   return TRUE;  // Don't continue, we called the default handler already.
 }
 
 gboolean AutocompleteEditViewGtk::HandleViewFocusIn() {
   GdkModifierType modifiers;
   gdk_window_get_pointer(text_view_->window, NULL, NULL, &modifiers);
   model_->OnSetFocus((modifiers & GDK_CONTROL_MASK) != 0);
   controller_->OnSetFocus();
   // 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();
   return FALSE;  // Pass the event on to the GtkTextView.
 }
 
 void AutocompleteEditViewGtk::HandleViewMoveCursor(
     GtkMovementStep step,
     gint count,
     gboolean extend_selection) {
+  GtkTextIter sel_start, sel_end;
+  gboolean has_selection =
+      gtk_text_buffer_get_selection_bounds(text_buffer_, &sel_start, &sel_end);
+
   // We want the GtkEntry behavior when you move the cursor while you have a
   // selection.  GtkTextView just drops the selection and moves the cursor, but
   // instead we want to move the cursor to the appropiate end of the selection.
-  GtkTextIter sstart, send;
-  if (step == GTK_MOVEMENT_VISUAL_POSITIONS &&
-      !extend_selection &&
-      (count == 1 || count == -1) &&
-      gtk_text_buffer_get_selection_bounds(text_buffer_, &sstart, &send)) {
+  if (step == GTK_MOVEMENT_VISUAL_POSITIONS && !extend_selection &&
+      (count == 1 || count == -1) && has_selection) {
     // We have a selection and start / end are in ascending order.
-    gtk_text_buffer_place_cursor(text_buffer_, count == 1 ? &send : &sstart);
+    // Cursor placement will remove the selection, so we need inform |model_|
+    // about this change by calling On{Before|After}PossibleChange() methods.
+    OnBeforePossibleChange();
+    gtk_text_buffer_place_cursor(text_buffer_,
+                                 count == 1 ? &sel_end : &sel_start);
+    OnAfterPossibleChange();
   } else if (step == GTK_MOVEMENT_PAGES) {  // Page up and down.
     // Multiply by count for the direction (if we move too much that's ok).
     model_->OnUpOrDownKeyPressed(model_->result().size() * count);
   } else if (step == GTK_MOVEMENT_DISPLAY_LINES) {  // Arrow up and down.
     model_->OnUpOrDownKeyPressed(count);
   } else {
-    return;  // Propagate into GtkTextView
+    // Cursor movement may change the selection, we need to record the change
+    // and report it to |model_|.
+    if (has_selection || extend_selection)
+      OnBeforePossibleChange();
+
+    // Propagate into GtkTextView
+    GtkTextViewClass* klass = GTK_TEXT_VIEW_GET_CLASS(text_view_);
+    klass->move_cursor(GTK_TEXT_VIEW(text_view_), step, count,
+                       extend_selection);
+
+    if (has_selection || extend_selection)
+      OnAfterPossibleChange();
   }
 
   // move-cursor doesn't use a signal accumulator on the return value (it
   // just ignores then), so we have to stop the propagation.
   static guint signal_id = g_signal_lookup("move-cursor", GTK_TYPE_TEXT_VIEW);
   g_signal_stop_emission(text_view_, signal_id, 0);
 }
 
 void AutocompleteEditViewGtk::HandleViewSizeRequest(GtkRequisition* req) {
   // Don't force a minimum width, but use the font-relative height.  This is a
@@ skipping 431 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);
 }