Fall back to local page if online NTP fails to load.

chrome/browser/ui/search/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/ui/search/instant_controller.h"
 
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 691 matching lines @@
 }
 
 void InstantController::OmniboxNavigateToURL() {
   if (!extended_enabled_)
     return;
   RecordNavigationHistogram(UsingLocalPage(), false);
   if (instant_tab_)
     instant_tab_->Submit(string16());
 }
 
+void InstantController::InstantPageLoadFailed(content::WebContents* contents) {
+  GURL local_fallback_url = chrome::GetLocalInstantURL(browser_->profile());
+
+  if (instant_tab_ && IsContentsFrom(instant_tab(), contents)) {

[samarth, 2013/05/02 03:12:56]

IsContentsFrom already checks that the page is not null so the first clause is
not necessary.

[David Black, 2013/05/02 05:02:49]

Done.

+    std::string instant_url;
+    bool has_online_url = GetInstantURL(
+        browser_->profile(), true, &instant_url);
+    if (instant_tab_->IsLocal() || !has_online_url ||
+        contents->GetURL() != GURL(instant_url))
+      return;
+    RedirectToLocalNTP(contents);
+  }
+
+  if (ntp_ && IsContentsFrom(ntp(), contents)) {
+    if (ntp_->IsLocal())
+      return;
+    MessageLoop::current()->DeleteSoon(FROM_HERE, ntp_.release());

[samarth, 2013/05/02 03:12:56]

It's best to also delete the contents held by ntp_ so we don't get continue to
get IPCs from the renderer until ntp_ is actually deleted.  Same for overlay
below.

You can just use the DeletePageSoon() helper I added in 13873010 (which I'll
land as soon as the tree re-opens).

[David Black, 2013/05/02 05:02:49]

Ok.  That'll require a bunch of rebasing on my part anyway.

+    ResetNTP(false, true);
+  }
+
+  if (overlay_ && IsContentsFrom(overlay(), contents)) {
+    if (overlay_->IsLocal())
+      return;
+    MessageLoop::current()->DeleteSoon(FROM_HERE, overlay_.release());
+    CreateOverlay(local_fallback_url.spec(), contents);
+  }
+}
+
 content::WebContents* InstantController::GetOverlayContents() const {
   return overlay_ ? overlay_->contents() : NULL;
 }
 
 bool InstantController::IsOverlayingSearchResults() const {
   return model_.mode().is_search_suggestions() && IsFullHeight(model_) &&
          (last_match_was_search_ ||
           last_suggestion_.behavior == INSTANT_COMPLETE_NEVER);
 }
 
@@ skipping 427 matching lines @@
     BlacklistAndResetOverlay();
   else if (IsContentsFrom(ntp(), contents))
     BlacklistAndResetNTP();
   else
     NOTREACHED();
 }
 
 void InstantController::InstantPageAboutToNavigateMainFrame(
     const content::WebContents* contents,
     const GURL& url) {
-  DCHECK(IsContentsFrom(overlay(), contents));
+  if (IsContentsFrom(overlay(), contents)) {
+    // If the page does not yet support Instant, we allow redirects and other
+    // navigations to go through since the Instant URL can redirect - e.g. to
+    // country specific pages.
+    if (!overlay_->supports_instant())
+      return;
 
-  // If the page does not yet support Instant, we allow redirects and other
-  // navigations to go through since the Instant URL can redirect - e.g. to
-  // country specific pages.
-  if (!overlay_->supports_instant())
-    return;
+    GURL instant_url(overlay_->instant_url());
 
-  GURL instant_url(overlay_->instant_url());
+    // If we are navigating to the Instant URL, do nothing.
+    if (url == instant_url)
+      return;
 
-  // If we are navigating to the Instant URL, do nothing.
-  if (url == instant_url)
-    return;
-
-  // 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);
+    // 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 if (IsContentsFrom(instant_tab(), contents)) {
+    // The Instant tab loaded.  Send it the data it needs to display properly.
+    UpdateInfoForInstantTab();
+  } else {
+    NOTREACHED();
   }
 }
 
 void InstantController::SetSuggestions(
     const content::WebContents* contents,
     const std::vector<InstantSuggestion>& suggestions) {
   LOG_INSTANT_DEBUG_EVENT(this, "SetSuggestions");
 
   // Ignore if the message is from an unexpected source.
   if (IsContentsFrom(ntp(), contents))
@@ skipping 197 matching lines @@
 
 void InstantController::ResetInstantTab() {
   // Do not wire up the InstantTab in Incognito, to prevent it from sending data
   // to the page.
   if (!search_mode_.is_origin_default() &&
       !browser_->profile()->IsOffTheRecord()) {
     content::WebContents* active_tab = browser_->GetActiveWebContents();
     if (!instant_tab_ || active_tab != instant_tab_->contents()) {
       instant_tab_.reset(new InstantTab(this));
       instant_tab_->Init(active_tab);
-      // Update theme info for this tab.
-      browser_->UpdateThemeInfo();
-      instant_tab_->SetDisplayInstantResults(instant_enabled_);
-      instant_tab_->SetOmniboxBounds(omnibox_bounds_);
-      instant_tab_->InitializeFonts();
-      StartListeningToMostVisitedChanges();
-      instant_tab_->KeyCaptureChanged(
-          omnibox_focus_state_ == OMNIBOX_FOCUS_INVISIBLE);
+      UpdateInfoForInstantTab();
     }
 
     // Hide the |overlay_| since we are now using |instant_tab_| instead.
     HideOverlay();
   } else {
     instant_tab_.reset();
   }
 }
 
+void InstantController::UpdateInfoForInstantTab() {
+  if (instant_tab_) {
+    browser_->UpdateThemeInfo();
+    instant_tab_->SetDisplayInstantResults(instant_enabled_);
+    instant_tab_->SetOmniboxBounds(omnibox_bounds_);
+    instant_tab_->InitializeFonts();
+    StartListeningToMostVisitedChanges();
+    instant_tab_->KeyCaptureChanged(
+        omnibox_focus_state_ == OMNIBOX_FOCUS_INVISIBLE);
+  }
+}
+
 void InstantController::HideOverlay() {
   HideInternal();
   ReloadOverlayIfStale();
   MaybeSwitchToRemoteOverlay();
 }
 
 void InstantController::HideInternal() {
   LOG_INSTANT_DEBUG_EVENT(this, "Hide");
 
   // If GetOverlayContents() returns NULL, either we're already in the desired
@@ skipping 286 matching lines @@
   if (browser_->GetActiveWebContents())
     return true;
 
   return chrome::IsAggressiveLocalNTPFallbackEnabled();
 }
 
 bool InstantController::UsingLocalPage() const {
   return (instant_tab_ && instant_tab_->IsLocal()) ||
       (!instant_tab_ && overlay_ && overlay_->IsLocal());
 }
+
+void InstantController::RedirectToLocalNTP(content::WebContents* contents) {
+  contents->GetController().LoadURL(
+    chrome::GetLocalInstantURL(browser_->profile()),
+    content::Referrer(),
+    content::PAGE_TRANSITION_SERVER_REDIRECT,
+    std::string());  // No extra headers.
+  // TODO(dcblack): Remove extraneous history entry.
+}