InstantExtended: Transient naventry for preview.

chrome/browser/instant/instant_controller.cc

 // Copyright 2012 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/instant/instant_controller.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 162 matching lines @@
       instant_enabled_(false),
       use_local_preview_only_(use_local_preview_only),
       model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       last_omnibox_text_has_inline_autocompletion_(false),
       last_verbatim_(false),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
       last_match_was_search_(false),
       omnibox_focus_state_(OMNIBOX_FOCUS_NONE),
       start_margin_(0),
       end_margin_(0),
-      allow_preview_to_show_search_suggestions_(false) {
+      allow_preview_to_show_search_suggestions_(false),
+      instant_set_transient_entry_(false) {
 }
 
 InstantController::~InstantController() {
 }
 
 bool InstantController::Update(const AutocompleteMatch& match,
                                const string16& user_text,
                                const string16& full_text,
                                size_t selection_start,
                                size_t selection_end,
@@ skipping 147 matching lines @@
     } else if (StartsWith(full_text, last_omnibox_text_, false)) {
       // The user is typing forward. Normalize any added characters.
       reused_suggestion = NormalizeAndStripPrefix(&last_suggestion_.text,
           string16(full_text, last_omnibox_text_.size()));
     }
   }
   if (!reused_suggestion)
     last_suggestion_ = InstantSuggestion();
 
   last_omnibox_text_ = full_text;
+  SetTransientHistoryEntry();
 
   if (!extended_enabled_) {
     // In non-extended mode, the query is verbatim if there's any selection
     // (including inline autocompletion) or if the cursor is not at the end.
     verbatim = verbatim || selection_start != selection_end ||
                            selection_start != full_text.size();
   }
   last_verbatim_ = verbatim;
 
   last_transition_type_ = match.transition;
@@ skipping 441 matching lines @@
       last_suggestion_ = suggestion;
       DVLOG(1) << "SetInstantSuggestion: text='" << suggestion.text << "'"
                << " behavior=" << suggestion.behavior << " type="
                << suggestion.type;
       browser_->SetInstantSuggestion(suggestion);
     } else {
       last_suggestion_ = InstantSuggestion();
     }
   }
 
+  SetTransientHistoryEntry();
+
   // Extended mode pages will call ShowLoader() when they are ready.
   if (!extended_enabled_)
     ShowLoader(INSTANT_SHOWN_QUERY_SUGGESTIONS, 100, INSTANT_SIZE_PERCENT);
 }
 
 void InstantController::InstantSupportDetermined(
     const content::WebContents* contents,
     bool supports_instant) {
   if (instant_tab_ && instant_tab_->contents() == contents) {
     if (!supports_instant)
@@ skipping 259 matching lines @@
   // change the state just yet; else we may hide the preview unnecessarily.
   // Instead, the state will be set correctly after the commit is done.
   if (GetPreviewContents()) {
     model_.SetPreviewState(chrome::search::Mode(), 0, INSTANT_SIZE_PERCENT);
     allow_preview_to_show_search_suggestions_ = false;
 
     // Send a message asking the preview to clear out old results.
     loader_->Update(string16(), 0, 0, true);
   }
 
+  ResetTransientHistoryEntry();
+
   // Clear the first interaction timestamp for later use.
   first_interaction_time_ = base::Time();
 }
 
 void InstantController::ShowLoader(InstantShownReason reason,
                                    int height,
                                    InstantSizeUnits units) {
   // If we are on a committed search results page, the |loader_| is not in use.
   if (instant_tab_)
     return;
@@ skipping 37 matching lines @@
     model_.SetPreviewState(search_mode_, height, units);
   else
     model_.SetPreviewState(search_mode_, 100, INSTANT_SIZE_PERCENT);
 
   // If the user clicked on a query suggestion, also go ahead and commit the
   // overlay. This is necessary because if the overlay was partially visible
   // when the suggestion was clicked, the click itself would not commit the
   // overlay (because we're not full height).
   if (reason == INSTANT_SHOWN_CLICKED_QUERY_SUGGESTION)
     CommitIfPossible(INSTANT_COMMIT_CLICKED_QUERY_SUGGESTION);
+  else if (extended_enabled_ && IsFullHeight(model_))
+    SetTransientHistoryEntry();
+}
+
+void InstantController::SetTransientHistoryEntry() {
+  content::WebContents* active_tab = browser_->GetActiveWebContents();
+  // Save any transient entry already associated with the active tab.
+  content::NavigationEntry* old_transient_entry =
+      active_tab->GetController().GetTransientEntry();
+  if (old_transient_entry && !instant_set_transient_entry_)
+    transient_entry_.reset(
+        content::NavigationEntry::Create(*old_transient_entry));
+  // The loader's base navigation entry should describe the search provider
+  // without reference to a specific query. The alternative, updating the query
+  // in the tab title as the user types, would be distracting.
+  const content::NavigationEntry* base_entry = loader_->base_navigation_entry();
+  DCHECK(base_entry != NULL);
+  content::NavigationEntry* new_transient_entry =
+      content::NavigationEntry::Create(*base_entry);
+  // The URL should update so that if the user presses reload, we reload the
+  // page for the current query.
+  const TemplateURL* template_url = TemplateURLServiceFactory::GetForProfile(
+      Profile::FromBrowserContext(active_tab->GetBrowserContext()))->
+      GetDefaultSearchProvider();
+  const TemplateURLRef& url_ref = template_url->url_ref();
+  DCHECK(url_ref.IsValid());
+  TemplateURLRef::SearchTermsArgs search_terms(last_omnibox_text_ +
+                                               last_suggestion_.text);
+  std::string url = url_ref.ReplaceSearchTerms(search_terms);
+  new_transient_entry->SetURL(GURL(url));
+  new_transient_entry->SetVirtualURL(GURL(url));
+  active_tab->GetController().AddTransientEntry(new_transient_entry);
+  instant_set_transient_entry_ = true;

[sreeram, 2013/01/22 05:28:34]

Wow. This is really hacky. Why do we need this? Can't we just update the
transient entry URL whenever the InstantLoader observes a navigation? Yes, if
you type quickly and press Reload (before 3 seconds are up), you'll end up
reloading the "wrong" URL, but I'm not really concerned about that. I think it's
an extreme corner case brought about by the user's pathological action that we
don't have to worry about.

[Jered, 2013/01/23 21:52:07]

Navigating after 3 seconds is a very Google-specific behavior, so depending on
that would feel like more of a hack to me. This way seems like a portable way to
make reload search for what the user has typed, no?

+}
+
+void InstantController::ResetTransientHistoryEntry() {
+  content::NavigationEntry* old_transient_entry = transient_entry_.release();
+  if (old_transient_entry) {
+    DVLOG(1) << "ResetTransientHistoryEntry: restoring old transient entry";
+    content::WebContents* active_tab = browser_->GetActiveWebContents();
+    active_tab->GetController().AddTransientEntry(old_transient_entry);
+    chrome::search::SearchTabHelper::FromWebContents(active_tab)->
+        NavigationEntryUpdated();
+  }
+  instant_set_transient_entry_ = false;
 }
 
 void InstantController::SendPopupBoundsToPage() {
   if (last_popup_bounds_ == popup_bounds_ || !loader_ ||
       loader_->is_pointer_down_from_activate())
     return;
 
   last_popup_bounds_ = popup_bounds_;
   gfx::Rect preview_bounds = browser_->GetInstantBounds();
   gfx::Rect intersection = gfx::IntersectRects(popup_bounds_, preview_bounds);
@@ skipping 78 matching lines @@
   std::map<std::string, int>::const_iterator iter =
       blacklisted_urls_.find(*instant_url);
   if (iter != blacklisted_urls_.end() &&
       iter->second > kMaxInstantSupportFailures) {
     RecordEventHistogram(INSTANT_CONTROLLER_EVENT_URL_BLOCKED_BY_BLACKLIST);
     return false;
   }
 
   return true;
 }