Implement chrome://network-errors for direct access to network error interstitials

content/browser/webui/url_data_manager_backend.cc

 // Copyright (c) 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 "content/browser/webui/url_data_manager_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/histogram_internals_request_job.h"
 #include "content/browser/net/view_blob_internals_job_factory.h"
 #include "content/browser/net/view_http_cache_job_factory.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/tcmalloc_internals_request_job.h"
 #include "content/browser/webui/shared_resources_data_source.h"
 #include "content/browser/webui/url_data_source_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
+#include "net/log/net_log_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
+
 #include "url/url_util.h"
 
 namespace content {
 
 namespace {
 
 const char kChromeURLContentSecurityPolicyHeaderBase[] =
     "Content-Security-Policy: script-src chrome://resources 'self'";
 
 const char kChromeURLXFrameOptionsHeader[] = "X-Frame-Options: DENY";
-
+static const char kNetworkErrorKey[] = "netError";
 const int kNoRenderProcessId = -1;
 
 bool SchemeIsInSchemes(const std::string& scheme,
                        const std::vector<std::string>& schemes) {
   return std::find(schemes.begin(), schemes.end(), scheme) != schemes.end();
 }
 
 // Returns whether |url| passes some sanity checks and is a valid GURL.
 bool CheckURLIsValid(const GURL& url) {
   std::vector<std::string> additional_schemes;
@@ skipping 388 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::string mime_type = source->source()->GetMimeType(path);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&URLRequestChromeJob::MimeTypeAvailable, job, mime_type));
 }
 
 }  // namespace
 
 namespace {
+bool IsValidNetworkErrorCode(int error_code) {
+  scoped_ptr<base::DictionaryValue> error_codes = net::GetNetConstants();
+  const base::DictionaryValue* net_error_codes_dict = nullptr;
+
+  for (base::DictionaryValue::Iterator itr(*error_codes); !itr.IsAtEnd();
+           itr.Advance()) {
+    if (itr.key() == kNetworkErrorKey) {
+      itr.value().GetAsDictionary(&net_error_codes_dict);
+      break;
+    }
+  }
+
+  for (base::DictionaryValue::Iterator itr(*net_error_codes_dict);
+           !itr.IsAtEnd(); itr.Advance()) {
+    int net_error_code;
+    itr.value().GetAsInteger(&net_error_code);
+    if (error_code == net_error_code)
+      return true;
+  }
+  return false;
+}
 
 class ChromeProtocolHandler
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   // |is_incognito| should be set for incognito profiles.
   ChromeProtocolHandler(ResourceContext* resource_context,
                         bool is_incognito,
                         AppCacheServiceImpl* appcache_service,
                         ChromeBlobStorageContext* blob_storage_context)
       : resource_context_(resource_context),
@@ skipping 25 matching lines @@
       return new TcmallocInternalsRequestJob(request, network_delegate);
     }
 #endif
 
     // Next check for chrome://histograms/, which uses its own job type.
     if (request->url().SchemeIs(kChromeUIScheme) &&
         request->url().host() == kChromeUIHistogramHost) {
       return new HistogramInternalsRequestJob(request, network_delegate);
     }
 
+    // Check for chrome://network-error/, which uses its own job type.
+    if (request->url().SchemeIs(kChromeUIScheme) &&
+        request->url().host() == kChromeUINetworkErrorHost) {
+      // Get the error code passed in via the request URL path.
+      std::basic_string<char> error_code_string =
+          request->url().path().substr(1, std::string::npos);

[Dan Beam, 2015/12/01 04:24:17]

this is equivalent to substr(1), I believe

[edwardjung, 2015/12/01 12:30:08]

Yep, confirmed.

+
+      int error_code;
+      if (base::StringToInt(error_code_string, &error_code)) {
+        // Check for a valid error code.
+        if (IsValidNetworkErrorCode(error_code) &&
+            error_code != net::Error::ERR_IO_PENDING) {
+          return new net::URLRequestErrorJob(request, network_delegate,
+                                             error_code);
+        }
+      }
+    }
+
     // Fall back to using a custom handler
     return new URLRequestChromeJob(
         request, network_delegate,
         GetURLDataManagerForResourceContext(resource_context_), is_incognito_);
   }
 
   bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
@@ skipping 253 matching lines @@
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
 CreateDevToolsProtocolHandler(content::ResourceContext* resource_context,
                               bool is_incognito) {
   return new DevToolsJobFactory(resource_context, is_incognito);
 }
 
 }  // namespace content