Move alternate error page loading out of WebFrame....

chrome/renderer/render_view.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/renderer/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 80 matching lines @@
 #include "webkit/glue/webview.h"
 
 #if defined(OS_WIN)
 // TODO(port): these files are currently Windows only because they concern:
 //   * theming
 #include "base/gfx/native_theme.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
+using webkit_glue::AltErrorPageResourceFetcher;
 using webkit_glue::AutofillForm;
 using webkit_glue::PasswordForm;
 using webkit_glue::PasswordFormDomManager;
 using webkit_glue::SearchableFormData;
 using WebKit::WebConsoleMessage;
 using WebKit::WebData;
 using WebKit::WebDataSource;
 using WebKit::WebDragData;
 using WebKit::WebForm;
 using WebKit::WebHistoryItem;
@@ skipping 847 matching lines @@
   } else {
     // Subframe navigation: the type depends on whether this navigation
     // generated a new session history entry. When they do generate a session
     // history entry, it means the user initiated the navigation and we should
     // mark it as such. This test checks if this is the first time UpdateURL
     // has been called since WillNavigateToURL was called to initiate the load.
     if (page_id_ > last_page_id_sent_to_browser_)
       params.transition = PageTransition::MANUAL_SUBFRAME;
     else
       params.transition = PageTransition::AUTO_SUBFRAME;
+    //XXX navigation_state->set_transition_type(params.transition);
 
     Send(new ViewHostMsg_FrameNavigate(routing_id_, params));
   }
 
   last_page_id_sent_to_browser_ =
       std::max(last_page_id_sent_to_browser_, page_id_);
 
   // If we end up reusing this WebRequest (for example, due to a #ref click),
   // we don't want the transition type to persist.  Just clear it.
   navigation_state->set_transition_type(PageTransition::LINK);
@@ skipping 155 matching lines @@
     if (event_time != 0.0)
       navigation_state->set_request_time(Time::FromDoubleT(event_time));
   }
 
   bool is_top_most = !frame->GetParent();
   if (is_top_most) {
     navigation_gesture_ = gesture;
 
     // Make sure redirect tracking state is clear for the new load.
     completed_client_redirect_src_ = GURL();
+  } else if (frame->GetParent()->IsLoading()) {
+    // Take note of AUTO_SUBFRAME loads here, so that we can know how to
+    // load an error page.  See DidFailProvisionalLoadWithError.
+    navigation_state->set_transition_type(PageTransition::AUTO_SUBFRAME);
   }
 
   Send(new ViewHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, is_top_most, ds->request().url()));
 }
 
 bool RenderView::DidLoadResourceFromMemoryCache(WebView* webview,
                                                 const WebURLRequest& request,
                                                 const WebURLResponse& response,
                                                 WebFrame* frame) {
@@ skipping 51 matching lines @@
       show_repost_interstitial));
 
   // Don't display an error page if this is simply a cancelled load.  Aside
   // from being dumb, WebCore doesn't expect it and it will cause a crash.
   if (error.reason == net::ERR_ABORTED)
     return;
 
   // Make sure we never show errors in view source mode.
   frame->SetInViewSourceMode(false);
 
+  NavigationState* navigation_state = NavigationState::FromDataSource(ds);
+
   // If this is a failed back/forward/reload navigation, then we need to do a
   // 'replace' load.  This is necessary to avoid messing up session history.
   // Otherwise, we do a normal load, which simulates a 'go' navigation as far
   // as session history is concerned.
-  bool replace = !NavigationState::FromDataSource(ds)->is_new_navigation();
+  //
+  // AUTO_SUBFRAME loads should always be treated as loads that do not advance
+  // the page id.
+  //
+  bool replace =
+      navigation_state->pending_page_id() != -1 ||
+      navigation_state->transition_type() == PageTransition::AUTO_SUBFRAME;
 
-  // Use the alternate error page service if this is a DNS failure or
-  // connection failure.  ERR_CONNECTION_FAILED can be dropped once we no longer
-  // use winhttp.
-  int ec = error.reason;
-  if (ec == net::ERR_NAME_NOT_RESOLVED ||
-      ec == net::ERR_CONNECTION_FAILED ||
-      ec == net::ERR_CONNECTION_REFUSED ||
-      ec == net::ERR_ADDRESS_UNREACHABLE ||
-      ec == net::ERR_TIMED_OUT) {
-    const GURL& failed_url = error.unreachableURL;
-    const GURL& error_page_url = GetAlternateErrorPageURL(failed_url,
-        ec == net::ERR_NAME_NOT_RESOLVED ? WebViewDelegate::DNS_ERROR
-                                         : WebViewDelegate::CONNECTION_ERROR);
-    if (error_page_url.is_valid()) {
-      // Ask the WebFrame to fetch the alternate error page for us.
-      frame->LoadAlternateHTMLErrorPage(failed_request, error, error_page_url,
-          replace, GURL(kUnreachableWebDataURL));
-      return;
-    }
+  // If we failed on a browser initiated request, then make sure that our error
+  // page load is regarded as the same browser initiated request.
+  if (!navigation_state->is_content_initiated()) {
+    pending_navigation_state_.reset(NavigationState::CreateBrowserInitiated(
+        navigation_state->pending_page_id(),
+        navigation_state->transition_type(),
+        navigation_state->request_time()));
   }
 
+  // Provide the user with a more helpful error page?
+  if (MaybeLoadAlternateErrorPage(frame, error, replace))
+    return;
+
   // Fallback to a local error page.
   LoadNavigationErrorPage(frame, failed_request, error, std::string(),
                           replace);
 }
 
 void RenderView::LoadNavigationErrorPage(WebFrame* frame,
                                          const WebURLRequest& failed_request,
                                          const WebURLError& error,
                                          const std::string& html,
                                          bool replace) {
@@ skipping 39 matching lines @@
     UpdateSessionHistory(frame);
 
     // We bump our Page ID to correspond with the new session history entry.
     page_id_ = next_page_id_++;
 
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         method_factory_.NewRunnableMethod(&RenderView::CapturePageInfo,
                                           page_id_, true),
         kDelayForForcedCaptureMs);
   } else {
-    // Inspect the navigation_state on the main frame (set in our Navigate
-    // method) to see if the navigation corresponds to a session history
-    // navigation...  Note: |frame| may or may not be the toplevel frame, but
-    // for the case of capturing session history, the first committed frame
-    // suffices.  We keep track of whether we've seen this commit before so
-    // that only capture session history once per navigation.
+    // Inspect the navigation_state on this frame to see if the navigation
+    // corresponds to a session history navigation...  Note: |frame| may or
+    // may not be the toplevel frame, but for the case of capturing session
+    // history, the first committed frame suffices.  We keep track of whether
+    // we've seen this commit before so that only capture session history once
+    // per navigation.
     //
     // Note that we need to check if the page ID changed. In the case of a
     // reload, the page ID doesn't change, and UpdateSessionHistory gets the
     // previous URL and the current page ID, which would be wrong.
-    if (!navigation_state->is_new_navigation() &&
-        !navigation_state->request_committed() &&
-        page_id_ != navigation_state->pending_page_id()) {
+    if (navigation_state->pending_page_id() != -1 &&
+        navigation_state->pending_page_id() != page_id_ &&
+        !navigation_state->request_committed()) {
       // This is a successful session history navigation!
       UpdateSessionHistory(frame);
       page_id_ = navigation_state->pending_page_id();
     }
   }
 
   // Remember that we've already processed this request, so we don't update
   // the session history again.  We do this regardless of whether this is
   // a session history navigation, because if we attempted a session history
   // navigation without valid HistoryItem state, WebCore will think it is a
@@ skipping 1497 matching lines @@
                                                          target);
 }
 
 void RenderView::OnDisassociateFromPopupCount() {
   if (decrement_shared_popup_at_destruction_)
     shared_popup_counter_->data--;
   shared_popup_counter_ = new SharedRenderViewCounter(0);
   decrement_shared_popup_at_destruction_ = false;
 }
 
+bool RenderView::MaybeLoadAlternateErrorPage(WebFrame* frame,
+                                             const WebURLError& error,
+                                             bool replace) {
+  // We only show alternate error pages in the main frame.  They are
+  // intended to assist the user when navigating, so there is not much
+  // value in showing them for failed subframes.  Ideally, we would be
+  // able to use the TYPED transition type for this, but that flag is
+  // not preserved across page reloads.
+  if (frame->GetParent())
+    return false;
+
+  // Use the alternate error page service if this is a DNS failure or
+  // connection failure.  ERR_CONNECTION_FAILED can be dropped once we no
+  // longer use winhttp.
+  int ec = error.reason;
+  if (ec != net::ERR_NAME_NOT_RESOLVED &&
+      ec != net::ERR_CONNECTION_FAILED &&
+      ec != net::ERR_CONNECTION_REFUSED &&
+      ec != net::ERR_ADDRESS_UNREACHABLE &&
+      ec != net::ERR_TIMED_OUT)
+    return false;
+
+  const GURL& error_page_url = GetAlternateErrorPageURL(error.unreachableURL,
+      ec == net::ERR_NAME_NOT_RESOLVED ? WebViewDelegate::DNS_ERROR
+                                       : WebViewDelegate::CONNECTION_ERROR);
+  if (!error_page_url.is_valid())
+    return false;
+
+  // Load an empty page first so there is an immediate response to the error,
+  // and then kick off a request for the alternate error page.
+  frame->LoadHTMLString(std::string(),
+                        GURL(kUnreachableWebDataURL),
+                        error.unreachableURL,
+                        replace);
+
+  // Now, create a fetcher for the error page and associate it with the data
+  // source we just created via the LoadHTMLString call.  That way if another
+  // navigation occurs, the fetcher will get destroyed.
+  NavigationState* navigation_state =
+      NavigationState::FromDataSource(frame->GetProvisionalDataSource());
+  navigation_state->set_alt_error_page_fetcher(
+      new AltErrorPageResourceFetcher(
+          error_page_url, frame, error.unreachableURL,
+          NewCallback(this, &RenderView::AltErrorPageFinished)));
+  return true;
+}
+
 std::string RenderView::GetAltHTMLForTemplate(
     const DictionaryValue& error_strings, int template_resource_id) const {
   const StringPiece template_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           template_resource_id));
 
   if (template_html.empty()) {
     NOTREACHED() << "unable to load template. ID: " << template_resource_id;
     return "";
   }
 
   // "t" is the id of the templates root node.
   return jstemplate_builder::GetTemplatesHtml(
       template_html, &error_strings, "t");
 }
 
+void RenderView::AltErrorPageFinished(WebFrame* frame,
+                                      const GURL& unreachable_url,
+                                      const std::string& html) {
+  // Here, we replace the blank page we loaded previously.
+  WebURLError error;
+  error.unreachableURL = unreachable_url;
+  LoadNavigationErrorPage(frame, WebURLRequest(), error, html, true);
+}
+
 void RenderView::OnMoveOrResizeStarted() {
   if (webview())
     webview()->HideAutofillPopup();
 }
 
 void RenderView::OnResize(const gfx::Size& new_size,
                           const gfx::Rect& resizer_rect) {
   if (webview())
     webview()->HideAutofillPopup();
   RenderWidget::OnResize(new_size, resizer_rect);
@@ skipping 242 matching lines @@
     Send(new ViewHostMsg_PasswordFormsSeen(routing_id_, password_forms));
 }
 
 void RenderView::Print(WebFrame* frame, bool script_initiated) {
   DCHECK(frame);
   if (print_helper_.get() == NULL) {
     print_helper_.reset(new PrintWebViewHelper(this));
   }
   print_helper_->Print(frame, script_initiated);
 }