Linux: Simplify omnibox selection code and stop taking back selection.

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 78 matching lines @@
       model_(new AutocompleteEditModel(this, controller, profile)),
       popup_view_(AutocompletePopupView::CreatePopupView(gfx::Font(), this,
                                                          model_.get(),
                                                          profile,
                                                          popup_positioner)),
       controller_(controller),
       toolbar_model_(toolbar_model),
       command_updater_(command_updater),
       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),
       paste_clipboard_requested_(false) {
   model_->set_popup_model(popup_view_->GetModel());
@@ skipping 125 matching lines @@
 
 void AutocompleteEditViewGtk::SaveStateToTab(TabContents* tab) {
   DCHECK(tab);
   GetStateAccessor()->SetProperty(
       tab->property_bag(),
       AutocompleteEditState(model_->GetStateForTabSwitch(),
                             ViewState(GetSelection())));
 
   // If any text has been selected, register it as the PRIMARY selection so it
   // can still be pasted via middle-click after the text view is cleared.
-  if (!selected_text_.empty() && !selection_saved_) {
+  if (!selected_text_.empty()) {
     SavePrimarySelection(selected_text_);
-    selection_saved_ = true;
   }
 }
 
 void AutocompleteEditViewGtk::Update(const TabContents* contents) {
   // NOTE: We're getting the URL text here from the ToolbarModel.
   bool visibly_changed_permanent_text =
       model_->UpdatePermanentText(toolbar_model_->GetText());
 
   ToolbarModel::SecurityLevel security_level =
         toolbar_model_->GetSchemeSecurityLevel();
   bool changed_security_level = (security_level != scheme_security_level_);
   scheme_security_level_ = security_level;
 
   // TODO(deanm): This doesn't exactly match Windows.  There there is a member
   // background_color_.  I think we can get away with just the level though.
   if (changed_security_level) {
     SetBaseColor();
   }
 
   if (contents) {
     selected_text_.clear();
-    selection_saved_ = false;
     RevertAll();
     const AutocompleteEditState* state =
         GetStateAccessor()->GetProperty(contents->property_bag());
     if (state) {
       model_->RestoreState(state->model_state);
 
       // Move the marks for the cursor and the other end of the selection to
       // the previously-saved offsets.
       GtkTextIter selection_iter, insert_iter;
       ItersFromCharRange(
@@ skipping 569 matching lines @@
                                             GtkTextIter* location,
                                             GtkTextMark* mark) {
   if (!text_buffer_ || buffer != text_buffer_)
     return;
 
   if (mark != gtk_text_buffer_get_insert(text_buffer_) &&
       mark != gtk_text_buffer_get_selection_bound(text_buffer_)) {
     return;
   }
 
-  // Is no text selected in the GtkTextView?
-  bool no_text_selected = false;
-
   // Get the currently-selected text, if there is any.
+  std::string new_selected_text;
   GtkTextIter start, end;
-  if (!gtk_text_buffer_get_selection_bounds(text_buffer_, &start, &end)) {
-    no_text_selected = true;
-  } else {
+  if (gtk_text_buffer_get_selection_bounds(text_buffer_, &start, &end)) {
     gchar* text = gtk_text_iter_get_text(&start, &end);
     size_t text_len = strlen(text);
-    if (!text_len) {
-      no_text_selected = true;
-    } else {
-      selected_text_ = std::string(text, text_len);
-      selection_saved_ = false;
+    if (text_len) {
+      new_selected_text = std::string(text, text_len);
     }
     g_free(text);
   }
 
   // If the user just selected some text with the mouse (or at least while the
   // mouse button was down), make sure that we won't blow their selection away
   // later by selecting all of the text when the button is released.
-  if (button_1_pressed_ && !no_text_selected) {
+  if (button_1_pressed_ && !new_selected_text.empty()) {
     text_selected_during_click_ = true;
   }
 
-  // If we have some previously-selected text but it's no longer highlighted
-  // and we haven't saved it as the selection yet, we save it now.
-  if (!selected_text_.empty() && no_text_selected && !selection_saved_) {
-    SavePrimarySelection(selected_text_);
-    selection_saved_ = true;
+  // If we had some text selected earlier but it's no longer highlighted, we
+  // might need to save it now...
+  if (!selected_text_.empty() && new_selected_text.empty()) {
+    // ... but only if we currently own the selection.  We want to manually
+    // update the selection when the text is unhighlighted because the user
+    // clicked in a blank area of the text view, but not when it's unhighlighted
+    // because another client or widget took the selection.  (This handler gets
+    // called before the default handler, so as long as nobody else took the
+    // selection, the text buffer still owns it even if GTK is about to take it
+    // away in the default handler.)
+    GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
+    if (gtk_clipboard_get_owner(clipboard) == G_OBJECT(text_buffer_)) {
+      SavePrimarySelection(selected_text_);
+    }
   }
+
+  selected_text_ = new_selected_text;
 }
 
 // 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;
@@ skipping 255 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());
 }