Show IDN in error screens (DNS failure etc.)

content/test/net/url_request_failed_job.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/test/net/url_request_failed_job.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 14 matching lines @@
   std::string path = request->url().path();
   if (path[0] == '/' && base::StringToInt(path.c_str() + 1, &net_error)) {
     CHECK_LT(net_error, 0);
     CHECK_NE(net_error, net::ERR_IO_PENDING);
     return net_error;
   }
   NOTREACHED();
   return net::ERR_UNEXPECTED;
 }
 
-GURL GetMockUrl(const std::string& scheme, int net_error) {
+GURL GetMockUrl(const std::string& scheme,
+                const std::string& hostname,
+                int net_error) {
   CHECK_LT(net_error, 0);
   CHECK_NE(net_error, net::ERR_IO_PENDING);
-  return GURL(scheme + "://" + kMockHostname + "/" +
-              base::IntToString(net_error));
+  return GURL(scheme + "://" + hostname + "/" + base::IntToString(net_error));
 }
 
 }  // namespace
 
 URLRequestFailedJob::URLRequestFailedJob(net::URLRequest* request,
                                          net::NetworkDelegate* network_delegate,
                                          int net_error)
     : net::URLRequestJob(request, network_delegate),
       net_error_(net_error),
       weak_factory_(this) {}
 
 URLRequestFailedJob::~URLRequestFailedJob() {}
 
 void URLRequestFailedJob::Start() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestFailedJob::StartAsync, weak_factory_.GetWeakPtr()));
 }
 
 // static
 void URLRequestFailedJob::AddUrlHandler() {
-  // Add kMockHostname to net::URLRequestFilter for HTTP and HTTPS.
+  return AddUrlHandlerForHostname(kMockHostname);
+}
+
+// static
+void URLRequestFailedJob::AddUrlHandlerForHostname(
+    const std::string& hostname) {
+  // Add |hostname| to net::URLRequestFilter for HTTP and HTTPS.
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
-  filter->AddHostnameHandler("http", kMockHostname,
-                             URLRequestFailedJob::Factory);
-  filter->AddHostnameHandler("https", kMockHostname,
-                             URLRequestFailedJob::Factory);
+  filter->AddHostnameHandler("http", hostname, URLRequestFailedJob::Factory);
+  filter->AddHostnameHandler("https", hostname, URLRequestFailedJob::Factory);
 }
 
 // static
 GURL URLRequestFailedJob::GetMockHttpUrl(int net_error) {
-  return GetMockUrl("http", net_error);
+  return GetMockHttpUrlForHostname(net_error, kMockHostname);
 }
 
 // static
 GURL URLRequestFailedJob::GetMockHttpsUrl(int net_error) {
-  return GetMockUrl("https", net_error);
+  return GetMockHttpsUrlForHostname(net_error, kMockHostname);
+}
+
+// static
+GURL URLRequestFailedJob::GetMockHttpUrlForHostname(
+    int net_error, const std::string& hostname) {
+  return GetMockUrl("http", hostname, net_error);
+}
+
+// static
+GURL URLRequestFailedJob::GetMockHttpsUrlForHostname(
+    int net_error, const std::string& hostname) {
+  return GetMockUrl("https", hostname, net_error);
 }
 
 // static
 net::URLRequestJob* URLRequestFailedJob::Factory(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const std::string& scheme) {
   return new URLRequestFailedJob(
       request, network_delegate, GetErrorCode(request));
 }
 
 void URLRequestFailedJob::StartAsync() {
   NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                          net_error_));
 }
 
 }  // namespace content