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 659 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) {
+  if (!chrome::ShouldPreferRemoteNTPOnStartup()) {
+    // We only need to fall back on errors if we're showing the online page
+    // at startup, as otherwise we fall back correctly when trying to show
+    // a page that hasn't yet indicated that it supports the InstantExtended
+    // API.
+    return;
+  }
+
+  GURL local_fallback_url = chrome::GetLocalInstantURL(browser_->profile());

[samarth, 2013/05/02 21:57:18]

not used anymore

[David Black, 2013/05/02 23:30:01]

Done.

+
+  if (IsContentsFrom(instant_tab(), contents)) {
+    std::string instant_url = GetInstantURL();

[samarth, 2013/05/02 21:57:18]

const std::string&

[David Black, 2013/05/02 23:30:01]

Bloody c++ and its inability to have a basic string type.  Done.

+    if (instant_tab_->IsLocal() || contents->GetURL() != GURL(instant_url))
+      return;
+    RedirectToLocalNTP(contents);

[samarth, 2013/05/02 21:57:18]

Please add a comment explaining why we only redirect in this case.

[David Black, 2013/05/02 23:30:01]

You're talking about the url != url condition above, right?  Done.

+  }
+
+  if (IsContentsFrom(ntp(), contents)) {
+    if (ntp_->IsLocal())

[samarth, 2013/05/02 21:57:18]

I don't see how a local page would ever fail, but if it does, we should call
DeletePageSoon in that case too (so we don't use it). But ResetNTP should only
be called in the non-local case as you have it.

Same thing for overlay below.

[David Black, 2013/05/02 23:30:01]

Done.

+      return;
+    DeletePageSoon(ntp_.Pass());
+    ResetNTP(GetLocalInstantURL());
+  }
+
+  if (IsContentsFrom(overlay(), contents)) {
+    if (overlay_->IsLocal())
+      return;
+    DeletePageSoon(overlay_.Pass());
+    ResetOverlay(GetLocalInstantURL());
+  }
+}
+
 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 404 matching lines @@
     bool supports_instant) {
   if (IsContentsFrom(instant_tab(), contents)) {
     if (!supports_instant)
       MessageLoop::current()->DeleteSoon(FROM_HERE, instant_tab_.release());
 
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_TAB_SUPPORT_DETERMINED,
         content::Source<InstantController>(this),
         content::NotificationService::NoDetails());
   } else if (IsContentsFrom(ntp(), contents)) {
     if (!supports_instant)

[samarth, 2013/05/02 21:57:18]

I think it's a good idea to do the same thing here as you're doing in
InstantPageLoadFailed -- which is to preload the local page unless this was
already the local page.

If you'd rather not add it in this CL, I can send out a change for it.

[David Black, 2013/05/02 23:30:01]

Done.

       DeletePageSoon(ntp_.Pass());
 
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_NTP_SUPPORT_DETERMINED,
         content::Source<InstantController>(this),
         content::NotificationService::NoDetails());
 
   } else if (IsContentsFrom(overlay(), contents)) {
     if (!supports_instant) {
       HideInternal();
@@ skipping 15 matching lines @@
   } else if (IsContentsFrom(ntp(), contents)) {
     DeletePageSoon(ntp_.Pass());
   } 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.

[samarth, 2013/05/02 21:57:18]

nit: The Instant tab navigated.

[David Black, 2013/05/02 23:30:01]

AARG.  THAT MAKES THE LINE 81 CHARS LONG.

Done.

+    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 267 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();
 }
 
 void InstantController::HideInternal() {
   LOG_INSTANT_DEBUG_EVENT(this, "Hide");
 
   // If GetOverlayContents() returns NULL, either we're already in the desired
   // MODE_DEFAULT state, or we're in the commit path. For the latter, don't
@@ skipping 203 matching lines @@
     }
   }
 
   return false;
 }
 
 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.
+}