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 488 matching lines @@
   // content, and the new tab is also an NTP.
   if (!search_mode_.is_ntp() || !model_.mode().is_ntp())
     HideLoader();
 
   if (extended_enabled_)
     ResetInstantTab();
 }
 
 void InstantController::TabDeactivated(content::WebContents* contents) {
   DVLOG(1) << "TabDeactivated";
-  if (extended_enabled_ && !contents->IsBeingDestroyed())
-    CommitIfPossible(INSTANT_COMMIT_FOCUS_LOST);
+  if (extended_enabled_) {
+    if (!contents->IsBeingDestroyed()) {
+      CommitIfPossible(INSTANT_COMMIT_FOCUS_LOST);
+    } else {
+      // The tab is going away. Trying to restore its original transient entry
+      // would affect the wrong tab.
+      saved_transient_entry_.reset();

[sreeram, 2013/01/25 21:28:02]

Doesn't this break tab-restore? Quoting myself from earlier:
"""
Note that we can't just clear the state variables in InstantController alone. We
need to restore any previous transient entry (such as an SSL interstitial) of
the closing tab, to make sure tab-restore does the right thing.
"""

Test this scenario:
1. Have at least two tabs.
2. On tab A, navigate to ianfette.org. This should cause a malware interstitial.
3. Focus the omnibox and type a query (no Enter). Wait for the preview to
appear.
4. Close the tab.
5. Ctrl-Shift-T to restore the tab.

I'd expect that with the CL as it is, it would try to restore the Instant
overlay. This may seem okay, but would actually lead to trouble further down.
Because now, the restored tab has a transient Instant overlay, but not one that
InstantController knows about. So if you focus the omnibox and start typing
again, we'll end up treating the existing transient entry (Instant-created) as
something like the SSL interstitial, and replace it with yet another
Instant-created entry. Maybe it can all work, but it makes my head hurt.

So, I'd settle for having tab-restore the malware interstitial seen at step 2.

+    }
+  }
 }
 
 void InstantController::SetInstantEnabled(bool instant_enabled) {
   DVLOG(1) << "SetInstantEnabled: " << instant_enabled;
   instant_enabled_ = instant_enabled;
   HideInternal();
   loader_.reset();
   if (extended_enabled_ || instant_enabled_)
     CreateDefaultLoader();
   if (instant_tab_)
@@ skipping 198 matching lines @@
 
   // Commit the navigation if either:
   //  - The page is in NTP mode (so it could only navigate on a user click) or
   //  - The page is not in NTP mode and we are navigating to a URL with a
   //    different host or path than the instant URL. This enables the instant
   //    page when it is showing search results to change the query parameters
   //    and fragments of the URL without it navigating.
   if (model_.mode().is_ntp() ||
       (url.host() != instant_url.host() || url.path() != instant_url.path())) {
     CommitIfPossible(INSTANT_COMMIT_NAVIGATED);
+  } else {
+    UpdateTransientHistoryEntry(url);
   }
 }
 
 void InstantController::OmniboxLostFocus(gfx::NativeView view_gaining_focus) {
   // If the preview is showing custom NTP content, don't hide it, commit it
   // (no matter where the user clicked) or try to recreate it.
   if (model_.mode().is_ntp())
     return;
 
   // If the preview is not showing at all, recreate it if it's stale.
@@ skipping 159 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_)
+    saved_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);
+  active_tab->GetController().AddTransientEntry(new_transient_entry);
+  instant_set_transient_entry_ = true;
+}
+
+void InstantController::UpdateTransientHistoryEntry(const GURL& url) {
+  // URL should update so that if the user presses reload, we reload the page
+  // for the current query, but title remains unchanged so it doesn't flicker.
+  if (instant_set_transient_entry_) {
+    content::WebContents* active_tab = browser_->GetActiveWebContents();
+    content::NavigationEntry* transient_entry =
+        active_tab->GetController().GetTransientEntry();
+    transient_entry->SetURL(url);
+    transient_entry->SetVirtualURL(url);
+  }
+}
+
+void InstantController::ResetTransientHistoryEntry() {
+  content::NavigationEntry* old_transient_entry =
+      saved_transient_entry_.release();
+  if (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;
 }