Move alternate 404 error page loading out of WebFrame and into RenderView....

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 1265 matching lines @@
   } else {
     alt_html = html;
   }
 
   frame->LoadHTMLString(alt_html,
                         GURL(kUnreachableWebDataURL),
                         failed_url,
                         replace);
 }
 
+void RenderView::DidReceiveDocumentData(WebFrame* frame, const char* data,
+                                        size_t data_len) {
+  NavigationState* navigation_state =
+      NavigationState::FromDataSource(frame->GetDataSource());
+  if (!navigation_state->postpone_loading_data()) {
+    frame->CommitDocumentData(data, data_len);
+    return;
+  }
+
+  // Continue buffering the response data for the original 404 page.  If it
+  // grows too large, then we'll just let it through.
+  navigation_state->append_postponed_data(data, data_len);
+  if (navigation_state->postponed_data().size() >= 512) {
+    navigation_state->set_postpone_loading_data(false);
+    frame->CommitDocumentData(navigation_state->postponed_data().data(),
+                              navigation_state->postponed_data().size());
+    navigation_state->clear_postponed_data();
+  }
+}
+
 void RenderView::DidCommitLoadForFrame(WebView *webview, WebFrame* frame,
                                        bool is_new_navigation) {
   NavigationState* navigation_state =
       NavigationState::FromDataSource(frame->GetDataSource());
 
   navigation_state->set_commit_load_time(Time::Now());
   if (is_new_navigation) {
     // When we perform a new navigation, we need to update the previous session
     // history entry with state for the page we are leaving.
     UpdateSessionHistory(frame);
@@ skipping 139 matching lines @@
   navigation_state->set_password_form_data(
       PasswordFormDomManager::CreatePasswordForm(form));
 
   if (form.isAutoCompleteEnabled()) {
     scoped_ptr<AutofillForm> autofill_form(AutofillForm::Create(form));
     if (autofill_form.get())
       Send(new ViewHostMsg_AutofillFormSubmitted(routing_id_, *autofill_form));
   }
 }
 
-void RenderView::WillSendRequest(WebView* webview,
-                                 uint32 identifier,
+void RenderView::WillSendRequest(WebFrame* frame, uint32 identifier,
                                  WebURLRequest* request) {
   request->setRequestorID(routing_id_);
 }
 
-void RenderView::BindDOMAutomationController(WebFrame* webframe) {
+void RenderView::DidReceiveResponse(WebFrame* frame, uint32 identifier,
+                                    const WebURLResponse& response) {
+  // Consider loading an alternate error page for 404 responses.
+  if (response.httpStatusCode() != 404)
+    return;
+
+  // Only do this for responses that correspond to a provisional data source
+  // of the top-most frame.  If we have a provisional data source, then we
+  // can't have any sub-resources yet, so we know that this response must
+  // correspond to a frame load.
+  if (!frame->GetProvisionalDataSource() || frame->GetParent())
+    return;
+
+  // If we are in view source mode, then just let the user see the source of
+  // the server's 404 error page.
+  if (frame->GetInViewSourceMode())
+    return;
+
+  // Can we even load an alternate error page for this URL?
+  if (!GetAlternateErrorPageURL(response.url(), HTTP_404).is_valid())
+    return;
+
+  NavigationState* navigation_state =
+      NavigationState::FromDataSource(frame->GetProvisionalDataSource());
+  navigation_state->set_postpone_loading_data(true);
+  navigation_state->clear_postponed_data();
+}
+
+void RenderView::DidFinishLoading(WebFrame* frame, uint32 identifier) {
+  NavigationState* navigation_state =
+      NavigationState::FromDataSource(frame->GetDataSource());
+  if (!navigation_state->postpone_loading_data())
+    return;
+
+  // The server returned a 404 and the content was < 512 bytes (which we
+  // suppressed).  Go ahead and fetch the alternate page content.
+
+  const GURL& frame_url = frame->GetURL();
+
+  const GURL& error_page_url = GetAlternateErrorPageURL(frame_url, HTTP_404);
+  DCHECK(error_page_url.is_valid());
+
+  WebURLError original_error;
+  original_error.unreachableURL = frame_url;
+
+  navigation_state->set_alt_error_page_fetcher(
+      new AltErrorPageResourceFetcher(
+          error_page_url, frame, original_error,
+          NewCallback(this, &RenderView::AltErrorPageFinished)));
+}
+
+void RenderView::BindDOMAutomationController(WebFrame* frame) {
   dom_automation_controller_.set_message_sender(this);
   dom_automation_controller_.set_routing_id(routing_id_);
-  dom_automation_controller_.BindToJavascript(webframe,
+  dom_automation_controller_.BindToJavascript(frame,
                                               L"domAutomationController");
 }
 
-void RenderView::WindowObjectCleared(WebFrame* webframe) {
+void RenderView::WindowObjectCleared(WebFrame* frame) {
   if (BindingsPolicy::is_dom_automation_enabled(enabled_bindings_))
-    BindDOMAutomationController(webframe);
+    BindDOMAutomationController(frame);
   if (BindingsPolicy::is_dom_ui_enabled(enabled_bindings_)) {
     dom_ui_bindings_.set_message_sender(this);
     dom_ui_bindings_.set_routing_id(routing_id_);
-    dom_ui_bindings_.BindToJavascript(webframe, L"chrome");
+    dom_ui_bindings_.BindToJavascript(frame, L"chrome");
   }
   if (BindingsPolicy::is_external_host_enabled(enabled_bindings_)) {
     external_host_bindings_.set_message_sender(this);
     external_host_bindings_.set_routing_id(routing_id_);
-    external_host_bindings_.BindToJavascript(webframe, L"externalHost");
+    external_host_bindings_.BindToJavascript(frame, L"externalHost");
   }
 }
 
 void RenderView::DocumentElementAvailable(WebFrame* frame) {
   // TODO(mpcomplete): remove this before Chrome extensions ship.
   // HACK.  This is a temporary workaround to allow cross-origin XHR for Chrome
   // extensions.  It grants full access to every origin, when we really want
   // to be able to restrict them more specifically.
   if (frame->GetURL().SchemeIs(chrome::kExtensionScheme))
     frame->GrantUniversalAccess();
@@ skipping 619 matching lines @@
   for (size_t i = 0; i < app_info.icons.size(); ++i) {
     if (app_info.icons[i].url.SchemeIs(chrome::kDataScheme)) {
       app_info.icons.erase(app_info.icons.begin() + i);
       --i;
     }
   }
 
   Send(new ViewHostMsg_DidGetApplicationInfo(routing_id_, page_id, app_info));
 }
 
-GURL RenderView::GetAlternateErrorPageURL(const GURL& failedURL,
+GURL RenderView::GetAlternateErrorPageURL(const GURL& failed_url,
                                           ErrorPageType error_type) {
-  if (failedURL.SchemeIsSecure()) {
+  if (failed_url.SchemeIsSecure()) {
     // If the URL that failed was secure, then the embedding web page was not
     // expecting a network attacker to be able to manipulate its contents.  As
     // we fetch alternate error pages over HTTP, we would be allowing a network
     // attacker to manipulate the contents of the response if we tried to use
     // the link doctor here.
     return GURL::EmptyGURL();
   }
 
   // Grab the base URL from the browser process.
   if (!alternate_error_page_url_.is_valid())
     return GURL::EmptyGURL();
 
   // Strip query params from the failed URL.
   GURL::Replacements remove_params;
   remove_params.ClearUsername();
   remove_params.ClearPassword();
   remove_params.ClearQuery();
   remove_params.ClearRef();
-  const GURL url_to_send = failedURL.ReplaceComponents(remove_params);
+  const GURL url_to_send = failed_url.ReplaceComponents(remove_params);
 
   // Construct the query params to send to link doctor.
   std::string params(alternate_error_page_url_.query());
   params.append("&url=");
   params.append(EscapeQueryParamValue(url_to_send.spec()));
   params.append("&sourceid=chrome");
   params.append("&error=");
   switch (error_type) {
     case DNS_ERROR:
       params.append("dnserror");
@@ skipping 707 matching lines @@
   // 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);
+      ec == net::ERR_NAME_NOT_RESOLVED ? DNS_ERROR : 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);
 
@@ skipping 22 matching lines @@
 
   // "t" is the id of the templates root node.
   return jstemplate_builder::GetTemplatesHtml(
       template_html, &error_strings, "t");
 }
 
 void RenderView::AltErrorPageFinished(WebFrame* frame,
                                       const WebURLError& original_error,
                                       const std::string& html) {
   // Here, we replace the blank page we loaded previously.
-  LoadNavigationErrorPage(frame, WebURLRequest(), original_error, html, true);
+
+  // If we failed to download the alternate error page, fall back to the
+  // original error page if present.  Otherwise, LoadNavigationErrorPage
+  // will simply display a default error page.
+  const std::string* html_to_load = &html;
+  if (html.empty()) {
+    NavigationState* navigation_state =
+        NavigationState::FromDataSource(frame->GetDataSource());
+    html_to_load = &navigation_state->postponed_data();

[tony, 2009/08/04 17:07:45]

Ah, good catch about showing the original error page.

[darin (slow to review), 2009/08/04 17:34:49]

The existing code for alt404 already handled this.  See the old code in
WebFrameLoaderClientImpl::Alt404PageFinished.  

In the case of other alt error pages, LoadNavigationErrorPage already deals with
an empty html string by constructing a default error page from original_error.

+  }
+  LoadNavigationErrorPage(
+      frame, WebURLRequest(), original_error, *html_to_load, true);
 }
 
 void RenderView::OnMoveOrResizeStarted() {
   if (webview())
     webview()->HideAutofillPopup();
 }
 
 void RenderView::OnResize(const gfx::Size& new_size,
                           const gfx::Rect& resizer_rect) {
   if (webview())
@@ skipping 266 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);
 }