Replace URLRequestFailedDnsJob with URLRequestFailedJob

content/test/net/url_request_failed_job.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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_dns_job.h"
+#include "content/test/net/url_request_failed_job.h"
 
 #include "base/bind.h"
-#include "base/compiler_specific.h"
+#include "base/logging.h"
 #include "base/message_loop.h"
-#include "googleurl/src/gurl.h"
+#include "base/string_number_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 
-const char URLRequestFailedDnsJob::kTestUrl[] =
-    "http://url.handled.by.fake.dns/";
+namespace {
 
-URLRequestFailedDnsJob::URLRequestFailedDnsJob(net::URLRequest* request)
+const char kMockHostname[] = "mock.failed.request";
+
+// Gets the numeric net error code from URL of the form:
+// scheme://kMockHostname/error_code.  The error code must be a valid
+// net error code, and not net::OK or net::ERR_IO_PENDING.
+int GetErrorCode(net::URLRequest* request) {
+  int net_error;
+  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) {
+  CHECK_LT(net_error, 0);
+  CHECK_NE(net_error, net::ERR_IO_PENDING);
+  return GURL(scheme + "://" + kMockHostname + "/" +
+              base::IntToString(net_error));
+}
+
+}  // namespace
+
+URLRequestFailedJob::URLRequestFailedJob(net::URLRequest* request,
+                                         int net_error)
     : net::URLRequestJob(request),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
+      net_error_(net_error) {}
 
-URLRequestFailedDnsJob::~URLRequestFailedDnsJob() {}
+URLRequestFailedJob::~URLRequestFailedJob() {}
 
-void URLRequestFailedDnsJob::Start() {
+void URLRequestFailedJob::Start() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&URLRequestFailedDnsJob::StartAsync,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&URLRequestFailedJob::StartAsync, AsWeakPtr()));
 }
 
 // static
-void URLRequestFailedDnsJob::AddUrlHandler() {
+void URLRequestFailedJob::AddUrlHandler() {
+  // Add kMockHostname to net::URLRequestFilter for HTTP and HTTPS.
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
-  filter->AddUrlHandler(GURL(kTestUrl),
-                        &URLRequestFailedDnsJob::Factory);
+  filter->AddHostnameHandler("http", kMockHostname,
+                             URLRequestFailedJob::Factory);
+  filter->AddHostnameHandler("https", kMockHostname,
+                             URLRequestFailedJob::Factory);
 }
 
-/*static */
-net::URLRequestJob* URLRequestFailedDnsJob::Factory(net::URLRequest* request,
-    const std::string& scheme) {
-  return new URLRequestFailedDnsJob(request);
+// static
+GURL URLRequestFailedJob::GetMockHttpUrl(int net_error) {
+  return GetMockUrl("http", net_error);
 }
 
-void URLRequestFailedDnsJob::StartAsync() {
+// static
+GURL URLRequestFailedJob::GetMockHttpsUrl(int net_error) {
+  return GetMockUrl("https", net_error);
+}
+
+// static
+net::URLRequestJob* URLRequestFailedJob::Factory(net::URLRequest* request,
+    const std::string& scheme) {
+  return new URLRequestFailedJob(request, GetErrorCode(request));
+}
+
+void URLRequestFailedJob::StartAsync() {
   NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                    net::ERR_NAME_NOT_RESOLVED));
+                                         net_error_));
 }