PlzNavigate: Show error pages when the navigation failed before commit

content/child/web_url_loader_impl.cc

 // Copyright 2014 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 "content/child/web_url_loader_impl.h"
 
 #include <algorithm>
 #include <deque>
 #include <string>
 
@@ skipping 53 matching lines @@
 using blink::WebURLLoaderClient;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
 namespace content {
 
 // Utilities ------------------------------------------------------------------
 
 namespace {
 
-const char kThrottledErrorDescription[] =
-    "Request throttled. Visit http://dev.chromium.org/throttling for more "
-    "information.";
 const size_t kBodyStreamPipeCapacity = 4 * 1024;
 
 typedef ResourceDevToolsInfo::HeadersVector HeadersVector;
 
 // Converts timing data from |load_timing| to the format used by WebKit.
 void PopulateURLLoadTiming(const net::LoadTimingInfo& load_timing,
                            WebURLLoadTiming* url_timing) {
   DCHECK(!load_timing.request_start.is_null());
 
   const TimeTicks kNullTicks;
@@ skipping 598 matching lines @@
                                                int data_length,
                                                int encoded_data_length) {
   if (!client_)
     return;
 
   if (request_.useStreamOnResponse()) {
     // We don't support ftp_listening_delegate_ and multipart_delegate_ for now.
     // TODO(yhirano): Support ftp listening and multipart.
     MojoResult rv = WriteDataOnBodyStream(data, data_length);
     if (rv != MOJO_RESULT_OK && client_) {
-      client_->didFail(loader_,
-                       loader_->CreateError(request_.url(),
-                                            false,
-                                            net::ERR_FAILED));
+      client_->didFail(
+          loader_, CreateWebURLError(request_.url(), false, net::ERR_FAILED));
     }
   } else if (ftp_listing_delegate_) {
     // The FTP listing delegate will make the appropriate calls to
     // client_->didReceiveData and client_->didReceiveResponse.  Since the
     // delegate may want to do work after sending data to the delegate, keep
     // |this| and the delegate alive until it's finished handling the data.
     scoped_refptr<Context> protect(this);
     ftp_listing_delegate_->OnReceivedData(data, data_length);
   } else if (multipart_delegate_) {
     // The multipart delegate will make the appropriate calls to
@@ skipping 29 matching lines @@
   if (ftp_listing_delegate_) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   } else if (multipart_delegate_) {
     multipart_delegate_->OnCompletedRequest();
     multipart_delegate_.reset(NULL);
   }
 
   if (client_) {
     if (error_code != net::OK) {
-      client_->didFail(loader_, CreateError(request_.url(),
-                                            stale_copy_in_cache,
-                                            error_code));
+      client_->didFail(
+          loader_,
+          CreateWebURLError(request_.url(), stale_copy_in_cache, error_code));
     } else {
       if (request_.useStreamOnResponse()) {
         got_all_stream_body_data_ = true;
         if (body_stream_buffer_.empty()) {
           // Close the handle to notify the end of data.
           body_stream_writer_.reset();
           client_->didFinishLoading(
               loader_, (completion_time - TimeTicks()).InSecondsF(),
               total_transfer_size);
         }
@@ skipping 135 matching lines @@
         MOJO_DEADLINE_INDEFINITE,
         base::Bind(&WebURLLoaderImpl::Context::OnHandleGotWritable,
                    base::Unretained(this)));
   }
   return rv;
 }
 
 void WebURLLoaderImpl::Context::OnHandleGotWritable(MojoResult result) {
   if (result != MOJO_RESULT_OK) {
     if (client_) {
-      client_->didFail(loader_,
-                       loader_->CreateError(request_.url(),
-                                            false,
-                                            net::ERR_FAILED));
+      client_->didFail(
+          loader_, CreateWebURLError(request_.url(), false, net::ERR_FAILED));
       // |this| can be deleted here.
     }
     return;
   }
 
   if (body_stream_buffer_.empty())
     return;
 
   MojoResult rv = WriteDataOnBodyStream(nullptr, 0);
   if (rv == MOJO_RESULT_OK) {
     if (got_all_stream_body_data_ && body_stream_buffer_.empty()) {
       // Close the handle to notify the end of data.
       body_stream_writer_.reset();
       if (client_) {
         // TODO(yhirano): Pass appropriate arguments.
         client_->didFinishLoading(loader_, 0, 0);
         // |this| can be deleted here.
       }
     }
   } else {
     if (client_) {
-      client_->didFail(loader_, loader_->CreateError(request_.url(),
-                                                     false,
-                                                     net::ERR_FAILED));
+      client_->didFail(
+          loader_, CreateWebURLError(request_.url(), false, net::ERR_FAILED));
       // |this| can be deleted here.
     }
   }
 }
 
 // WebURLLoaderImpl -----------------------------------------------------------
 
 WebURLLoaderImpl::WebURLLoaderImpl(
     ResourceDispatcher* resource_dispatcher,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_(new Context(this, resource_dispatcher, task_runner)) {
 }
 
 WebURLLoaderImpl::~WebURLLoaderImpl() {
   cancel();
 }
 
-WebURLError WebURLLoaderImpl::CreateError(const WebURL& unreachable_url,
-                                          bool stale_copy_in_cache,
-                                          int reason) {
-  WebURLError error;
-  error.domain = WebString::fromUTF8(net::kErrorDomain);
-  error.reason = reason;
-  error.unreachableURL = unreachable_url;
-  error.staleCopyInCache = stale_copy_in_cache;
-  if (reason == net::ERR_ABORTED) {
-    error.isCancellation = true;
-  } else if (reason == net::ERR_TEMPORARILY_THROTTLED) {
-    error.localizedDescription = WebString::fromUTF8(
-        kThrottledErrorDescription);
-  } else {
-    error.localizedDescription = WebString::fromUTF8(
-        net::ErrorToString(reason));
-  }
-  return error;
-}
-
 void WebURLLoaderImpl::PopulateURLResponse(const GURL& url,
                                            const ResourceResponseInfo& info,
                                            WebURLResponse* response) {
   response->setURL(url);
   response->setResponseTime(info.response_time.ToInternalValue());
   response->setMIMEType(WebString::fromUTF8(info.mime_type));
   response->setTextEncodingName(WebString::fromUTF8(info.charset));
   response->setExpectedContentLength(info.content_length);
   response->setSecurityInfo(info.security_info);
   response->setAppCacheID(info.appcache_id);
@@ skipping 159 matching lines @@
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 bool WebURLLoaderImpl::attachThreadedDataReceiver(
     blink::WebThreadedDataReceiver* threaded_data_receiver) {
   return context_->AttachThreadedDataReceiver(threaded_data_receiver);
 }
 
 }  // namespace content