Make Linux restore Omnibox contents on tab switch.

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 "app/l10n_util.h"
@@ skipping 16 matching lines @@
 namespace {
 
 const char kTextBaseColor[] = "#808080";
 const char kSecureSchemeColor[] = "#009614";
 const char kInsecureSchemeColor[] = "#c80000";
 
 size_t GetUTF8Offset(const std::wstring& wide_text, size_t wide_text_offset) {
   return WideToUTF8(wide_text.substr(0, wide_text_offset)).size();
 }
 
+// Stores GTK+-specific state so it can be restored after switching tabs.
+struct ViewState {
+  explicit ViewState(const AutocompleteEditViewGtk::CharRange& selection_range)
+      : selection_range(selection_range) {
+  }
+
+  // Range of selected text.
+  AutocompleteEditViewGtk::CharRange selection_range;
+};
+
+struct AutocompleteEditState {
+  AutocompleteEditState(const AutocompleteEditModel::State& model_state,
+                        const ViewState& view_state)
+      : model_state(model_state),
+        view_state(view_state) {
+  }
+
+  const AutocompleteEditModel::State model_state;
+  const ViewState view_state;
+};
+
+// Returns a lazily initialized property bag accessor for saving our state in a
+// TabContents.
+PropertyAccessor<AutocompleteEditState>* GetStateAccessor() {
+  static PropertyAccessor<AutocompleteEditState> state;
+  return &state;
+}
+
 }  // namespace
 
 AutocompleteEditViewGtk::AutocompleteEditViewGtk(
     AutocompleteEditController* controller,
     ToolbarModel* toolbar_model,
     Profile* profile,
     CommandUpdater* command_updater,
     AutocompletePopupPositioner* popup_positioner)
     : text_view_(NULL),
       tag_table_(NULL),
       text_buffer_(NULL),
       base_tag_(NULL),
       secure_scheme_tag_(NULL),
       insecure_scheme_tag_(NULL),
-      primary_clipboard_(NULL),
       model_(new AutocompleteEditModel(this, controller, profile)),
       popup_view_(new AutocompletePopupViewGtk(this, model_.get(), profile,
                                                popup_positioner)),
       controller_(controller),
       toolbar_model_(toolbar_model),
       command_updater_(command_updater),
       popup_window_mode_(false),  // TODO(deanm)
-      scheme_security_level_(ToolbarModel::NORMAL) {
+      scheme_security_level_(ToolbarModel::NORMAL),
+      selection_saved_(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 68 matching lines @@
   // signal, but it is very convenient and clean for catching up/down.
   g_signal_connect(text_view_, "move-cursor",
                    G_CALLBACK(&HandleViewMoveCursorThunk), this);
   // Override the size request.  We want to keep the original height request
   // from the widget, since that's font dependent.  We want to ignore the width
   // so we don't force a minimum width based on the text length.
   g_signal_connect(text_view_, "size-request",
                    G_CALLBACK(&HandleViewSizeRequestThunk), this);
   g_signal_connect(text_view_, "populate-popup",
                    G_CALLBACK(&HandlePopulatePopupThunk), this);
+  g_signal_connect(text_buffer_, "mark-set",
+                   G_CALLBACK(&HandleMarkSetThunk), this);
 }
 
 void AutocompleteEditViewGtk::SetFocus() {
   gtk_widget_grab_focus(text_view_);
 }
 
 void AutocompleteEditViewGtk::SaveStateToTab(TabContents* tab) {
-  NOTIMPLEMENTED();
+  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_) {
+    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) {
     gtk_widget_modify_base(text_view_, GTK_STATE_NORMAL,
         &LocationBarViewGtk::kBackgroundColorByLevel[security_level]);
   }
 
   if (contents) {
+    selected_text_.clear();
+    selection_saved_ = false;
     RevertAll();
-    // TODO(deanm): Tab switching.  The Windows code puts some state in a
-    // PropertyBag on the tab contents, and restores state from there.
+    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(
+          state->view_state.selection_range, &selection_iter, &insert_iter);
+      // TODO(derat): Restore the selection range instead of just the cursor
+      // ("insert") position.  This in itself is trivial to do using
+      // gtk_text_buffer_select_range(), but then it also becomes necessary to
+      // invalidate hidden tabs' saved ranges when another tab or another app
+      // takes the selection, lest we incorrectly regrab a stale selection when
+      // a hidden tab is later shown.
+      gtk_text_buffer_place_cursor(text_buffer_, &insert_iter);
+    }
   } else if (visibly_changed_permanent_text) {
     RevertAll();
     // TODO(deanm): There should be code to restore select all here.
   } else if (changed_security_level) {
     EmphasizeURLComponents();
   }
 }
 
 void AutocompleteEditViewGtk::OpenURL(const GURL& url,
                                       WindowOpenDisposition disposition,
@@ skipping 99 matching lines @@
   // TODO(deanm): Ignoring save_original_selection here, etc.
   SetWindowTextAndCaretPos(display_text, display_text.length());
   TextChanged();
 }
 
 bool AutocompleteEditViewGtk::OnInlineAutocompleteTextMaybeChanged(
     const std::wstring& display_text,
     size_t user_text_length) {
   if (display_text == GetText())
     return false;
-  
+
   // We need to get the clipboard while it's attached to the toplevel.  The
   // easiest thing to do is just to lazily pull the clipboard here.
-  if (primary_clipboard_ == NULL) {
-    primary_clipboard_ = gtk_widget_get_clipboard(text_view_,
-                                                  GDK_SELECTION_PRIMARY);
-  }
+  GtkClipboard* clipboard =
+      gtk_widget_get_clipboard(text_view_, GDK_SELECTION_PRIMARY);
+  DCHECK(clipboard);
+  if (!clipboard)
+    return true;
 
   // Remove the PRIMARY clipboard to avoid having "clipboard helpers" like
   // klipper and glipper race with / remove our inline autocomplete selection.
-  gtk_text_buffer_remove_selection_clipboard(text_buffer_, primary_clipboard_);
+  gtk_text_buffer_remove_selection_clipboard(text_buffer_, clipboard);
   SetWindowTextAndCaretPos(display_text, 0);
 
   // Select the part of the text that was inline autocompleted.
   GtkTextIter bound, insert;
   gtk_text_buffer_get_bounds(text_buffer_, &insert, &bound);
   gtk_text_buffer_get_iter_at_offset(text_buffer_, &insert, user_text_length);
   gtk_text_buffer_select_range(text_buffer_, &insert, &bound);
 
   TextChanged();
   // Put the PRIMARY clipboard back, so that selection still somewhat works.
-  gtk_text_buffer_add_selection_clipboard(text_buffer_, primary_clipboard_);
+  gtk_text_buffer_add_selection_clipboard(text_buffer_, clipboard);
 
   return true;
 }
 
 void AutocompleteEditViewGtk::OnRevertTemporaryText() {
   NOTIMPLEMENTED();
 }
 
 void AutocompleteEditViewGtk::OnBeforePossibleChange() {
   // Record our state.
@@ skipping 112 matching lines @@
   // clicked handling code.  If we were to try to set the selection from
   // the focus-in event, it's just going to be undone by the click handler.
   // This is a bit ugly.  We shim in to get the click before the GtkTextView,
   // then if we don't have focus, we (hopefully safely) assume that the click
   // will cause us to become focused.  We call GtkTextView's default handler
   // and then stop propagation.  This allows us to run our code after the
   // default handler, even if that handler stopped propagation.
   if (GTK_WIDGET_HAS_FOCUS(text_view_))
     return FALSE;  // Continue to propagate into the GtkTextView handler.
 
+  // We only want to select everything on left-click; otherwise we'll end up
+  // stealing the PRIMARY selection when the user middle-clicks to paste it
+  // here.
+  if (event->button != 1)
+    return FALSE;
+
   // Call the GtkTextView default handler, ignoring the fact that it will
   // likely have told us to stop propagating.  We want to handle selection.
   GtkWidgetClass* klass = GTK_WIDGET_GET_CLASS(text_view_);
   klass->button_press_event(text_view_, event);
 
   // Select the full input when we get focus.
   SelectAll(false);
   // 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
@@ skipping 76 matching lines @@
   gtk_clipboard_request_text(x_clipboard, HandlePasteAndGoReceivedTextThunk,
                              this);
 }
 
 void AutocompleteEditViewGtk::HandlePasteAndGoReceivedText(
     const std::wstring& text) {
   if (model_->CanPasteAndGo(text))
     model_->PasteAndGo();
 }
 
+void AutocompleteEditViewGtk::HandleMarkSet(GtkTextBuffer* buffer,
+                                            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.
+  GtkTextIter start, end;
+  if (!gtk_text_buffer_get_selection_bounds(text_buffer_, &start, &end)) {
+    no_text_selected = true;
+  } else {
+    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;
+    }
+    g_free(text);
+  }
+
+  // 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;
+  }
+}
+
 AutocompleteEditViewGtk::CharRange AutocompleteEditViewGtk::GetSelection() {
   // You can not just use get_selection_bounds here, since the order will be
   // ascending, and you don't know where the user's start and end of the
   // selection was (if the selection was forwards or backwards).  Get the
   // actual marks so that we can preserve the selection direction.
   GtkTextIter start, insert;
   GtkTextMark* mark;
 
   mark = gtk_text_buffer_get_selection_bound(text_buffer_);
   gtk_text_buffer_get_iter_at_mark(text_buffer_, &start, mark);
@@ skipping 70 matching lines @@
       gtk_text_buffer_apply_tag(text_buffer_, insecure_scheme_tag_,
                                 &start, &end);
     }
   }
 }
 
 void AutocompleteEditViewGtk::TextChanged() {
   EmphasizeURLComponents();
   controller_->OnChanged();
 }
+
+void AutocompleteEditViewGtk::SavePrimarySelection(
+    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());
+}