Implement chrome://network-error with network service.

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 <utility>
 
 #include "base/bind.h"
@@ skipping 330 matching lines @@
     return;
 
   if (!backend_->StartRequest(request_, this)) {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_INVALID_URL));
   }
 }
 
 namespace {
 
-bool IsValidNetworkErrorCode(int error_code) {
-  std::unique_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;
-    }
-  }
-
-  if (net_error_codes_dict != nullptr) {
-    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:
   ChromeProtocolHandler(ResourceContext* resource_context,
                         ChromeBlobStorageContext* blob_storage_context)
       : resource_context_(resource_context),
         blob_storage_context_(blob_storage_context) {}
   ~ChromeProtocolHandler() override {}
 
   net::URLRequestJob* MaybeCreateJob(
@@ skipping 21 matching lines @@
     // Check for chrome://network-error/, which uses its own job type.
     if (request->url().SchemeIs(kChromeUIScheme) &&
         request->url().host_piece() == kChromeUINetworkErrorHost) {
       // Get the error code passed in via the request URL path.
       std::basic_string<char> error_code_string =
           request->url().path().substr(1);
 
       int error_code;
       if (base::StringToInt(error_code_string, &error_code)) {
         // Check for a valid error code.
-        if (IsValidNetworkErrorCode(error_code) &&
+        if (URLDataManagerBackend::IsValidNetworkErrorCode(error_code) &&
             error_code != net::Error::ERR_IO_PENDING) {
           return new net::URLRequestErrorJob(request, network_delegate,
                                              error_code);
         }
       }
     }
 
     // Check for chrome://dino which is an alias for chrome://network-error/-106
     if (request->url().SchemeIs(kChromeUIScheme) &&
         request->url().host() == kChromeUIDinoHost) {
@@ skipping 267 matching lines @@
                                              std::string* path) {
   const std::string& spec = url.possibly_invalid_spec();
   const url::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
   // + 1 to skip the slash at the beginning of the path.
   int offset = parsed.CountCharactersBefore(url::Parsed::PATH, false) + 1;
 
   if (offset < static_cast<int>(spec.size()))
     path->assign(spec.substr(offset));
 }
 
+bool URLDataManagerBackend::IsValidNetworkErrorCode(int error_code) {
+  std::unique_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;
+    }
+  }
+
+  if (net_error_codes_dict != nullptr) {
+    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;
+}
+
 std::vector<std::string> URLDataManagerBackend::GetWebUISchemes() {
   std::vector<std::string> schemes;
   schemes.push_back(kChromeUIScheme);
   GetContentClient()->browser()->GetAdditionalWebUISchemes(&schemes);
   return schemes;
 }
 
 namespace {
 
 class DevToolsJobFactory
@@ skipping 30 matching lines @@
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateDevToolsProtocolHandler(
     ResourceContext* resource_context) {
   return new DevToolsJobFactory(resource_context);
 }
 
 }  // namespace content