diff --git a/src/net/url_request/data_protocol_handler.cc b/src/net/url_request/data_protocol_handler.cc
new file mode 100644
index 0000000..3222f72
--- /dev/null
+++ b/src/net/url_request/data_protocol_handler.cc
@@ -0,0 +1,19 @@
+// 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 "net/url_request/data_protocol_handler.h"
+
+#include "net/url_request/url_request_data_job.h"
+
+namespace net {
+
+DataProtocolHandler::DataProtocolHandler() {
+}
+
+URLRequestJob* DataProtocolHandler::MaybeCreateJob(
+    URLRequest* request, NetworkDelegate* network_delegate) const {
+  return new URLRequestDataJob(request, network_delegate);
+}
+
+}  // namespace net
diff --git a/src/net/url_request/data_protocol_handler.h b/src/net/url_request/data_protocol_handler.h
new file mode 100644
index 0000000..abb5abe
--- /dev/null
+++ b/src/net/url_request/data_protocol_handler.h
@@ -0,0 +1,30 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_DATA_PROTOCOL_HANDLER_H_
+#define NET_URL_REQUEST_DATA_PROTOCOL_HANDLER_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "net/url_request/url_request_job_factory.h"
+
+namespace net {
+
+class URLRequestJob;
+
+// Implements a ProtocolHandler for Data jobs.
+class NET_EXPORT DataProtocolHandler
+    : public URLRequestJobFactory::ProtocolHandler {
+ public:
+  DataProtocolHandler();
+  virtual URLRequestJob* MaybeCreateJob(
+      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DataProtocolHandler);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_DATA_PROTOCOL_HANDLER_H_
diff --git a/src/net/url_request/file_protocol_handler.cc b/src/net/url_request/file_protocol_handler.cc
new file mode 100644
index 0000000..bbeac1c
--- /dev/null
+++ b/src/net/url_request/file_protocol_handler.cc
@@ -0,0 +1,47 @@
+// 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 "net/url_request/file_protocol_handler.h"
+
+#include "base/logging.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_file_dir_job.h"
+#include "net/url_request/url_request_file_job.h"
+
+namespace net {
+
+FileProtocolHandler::FileProtocolHandler() { }
+
+URLRequestJob* FileProtocolHandler::MaybeCreateJob(
+    URLRequest* request, NetworkDelegate* network_delegate) const {
+  FilePath file_path;
+  const bool is_file = FileURLToFilePath(request->url(), &file_path);
+
+  // Check file access permissions.
+  if (!network_delegate ||
+      !network_delegate->CanAccessFile(*request, file_path)) {
+    return new URLRequestErrorJob(request, network_delegate, ERR_ACCESS_DENIED);
+  }
+#if !defined (COBALT) // Cobalt doesn't support URLRequestFileDirJob
+  // We need to decide whether to create URLRequestFileJob for file access or
+  // URLRequestFileDirJob for directory access. To avoid accessing the
+  // filesystem, we only look at the path string here.
+  // The code in the URLRequestFileJob::Start() method discovers that a path,
+  // which doesn't end with a slash, should really be treated as a directory,
+  // and it then redirects to the URLRequestFileDirJob.
+  if (is_file &&
+      file_util::EndsWithSeparator(file_path) &&
+      file_path.IsAbsolute()) {
+    return new URLRequestFileDirJob(request, network_delegate, file_path);
+  }
+#endif
+  // Use a regular file request job for all non-directories (including invalid
+  // file names).
+  return new URLRequestFileJob(request, network_delegate, file_path);
+}
+
+}  // namespace net
diff --git a/src/net/url_request/file_protocol_handler.h b/src/net/url_request/file_protocol_handler.h
new file mode 100644
index 0000000..619227b
--- /dev/null
+++ b/src/net/url_request/file_protocol_handler.h
@@ -0,0 +1,32 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_FILE_PROTOCOL_HANDLER_H_
+#define NET_URL_REQUEST_FILE_PROTOCOL_HANDLER_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "net/url_request/url_request_job_factory.h"
+
+namespace net {
+
+class NetworkDelegate;
+class URLRequestJob;
+
+// Implements a ProtocolHandler for File jobs. If |network_delegate_| is NULL,
+// then all file requests will fail with ERR_ACCESS_DENIED.
+class NET_EXPORT FileProtocolHandler :
+    public URLRequestJobFactory::ProtocolHandler {
+ public:
+  FileProtocolHandler();
+  virtual URLRequestJob* MaybeCreateJob(
+      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FileProtocolHandler);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_FILE_PROTOCOL_HANDLER_H_
diff --git a/src/net/url_request/fraudulent_certificate_reporter.h b/src/net/url_request/fraudulent_certificate_reporter.h
new file mode 100644
index 0000000..007f660
--- /dev/null
+++ b/src/net/url_request/fraudulent_certificate_reporter.h
@@ -0,0 +1,33 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_FRAUDULENT_CERTIFICATE_REPORTER_H_
+#define NET_URL_REQUEST_FRAUDULENT_CERTIFICATE_REPORTER_H_
+
+#include <string>
+
+namespace net {
+
+class SSLInfo;
+
+// FraudulentCertificateReporter is an interface for asynchronously
+// reporting certificate chains that fail the certificate pinning
+// check.
+class FraudulentCertificateReporter {
+ public:
+  virtual ~FraudulentCertificateReporter() {}
+
+  // Sends a report to the report collection server containing the |ssl_info|
+  // associated with a connection to |hostname|. If |sni_available| is true,
+  // searches the SNI transport security metadata as well as the usual
+  // transport security metadata when determining policy for sending the report.
+  virtual void SendReport(const std::string& hostname,
+                          const SSLInfo& ssl_info,
+                          bool sni_available) = 0;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_FRAUDULENT_CERTIFICATE_REPORTER_H_
+
diff --git a/src/net/url_request/ftp_protocol_handler.cc b/src/net/url_request/ftp_protocol_handler.cc
new file mode 100644
index 0000000..7d9ba88
--- /dev/null
+++ b/src/net/url_request/ftp_protocol_handler.cc
@@ -0,0 +1,40 @@
+// 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 "net/url_request/ftp_protocol_handler.h"
+
+#include "base/logging.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_ftp_job.h"
+#include "googleurl/src/gurl.h"
+
+namespace net {
+
+FtpProtocolHandler::FtpProtocolHandler(
+    FtpTransactionFactory* ftp_transaction_factory,
+    FtpAuthCache* ftp_auth_cache)
+    : ftp_transaction_factory_(ftp_transaction_factory),
+      ftp_auth_cache_(ftp_auth_cache) {
+  DCHECK(ftp_transaction_factory_);
+  DCHECK(ftp_auth_cache_);
+}
+
+URLRequestJob* FtpProtocolHandler::MaybeCreateJob(
+    URLRequest* request, NetworkDelegate* network_delegate) const {
+  int port = request->url().IntPort();
+  if (request->url().has_port() &&
+      !IsPortAllowedByFtp(port) && !IsPortAllowedByOverride(port)) {
+    return new URLRequestErrorJob(request, network_delegate, ERR_UNSAFE_PORT);
+  }
+
+  return new URLRequestFtpJob(request,
+                              network_delegate,
+                              ftp_transaction_factory_,
+                              ftp_auth_cache_);
+}
+
+}  // namespace net
diff --git a/src/net/url_request/ftp_protocol_handler.h b/src/net/url_request/ftp_protocol_handler.h
new file mode 100644
index 0000000..871f422
--- /dev/null
+++ b/src/net/url_request/ftp_protocol_handler.h
@@ -0,0 +1,37 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_FTP_PROTOCOL_HANDLER_H_
+#define NET_URL_REQUEST_FTP_PROTOCOL_HANDLER_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "net/url_request/url_request_job_factory.h"
+
+namespace net {
+
+class FtpAuthCache;
+class FtpTransactionFactory;
+class NetworkDelegate;
+class URLRequestJob;
+
+// Implements a ProtocolHandler for FTP.
+class NET_EXPORT FtpProtocolHandler :
+    public URLRequestJobFactory::ProtocolHandler {
+ public:
+  FtpProtocolHandler(FtpTransactionFactory* ftp_transaction_factory,
+                     FtpAuthCache* ftp_auth_cache);
+  virtual URLRequestJob* MaybeCreateJob(
+      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
+
+ private:
+  FtpTransactionFactory* ftp_transaction_factory_;
+  FtpAuthCache* ftp_auth_cache_;
+
+  DISALLOW_COPY_AND_ASSIGN(FtpProtocolHandler);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_FTP_PROTOCOL_HANDLER_H_
diff --git a/src/net/url_request/http_user_agent_settings.h b/src/net/url_request/http_user_agent_settings.h
new file mode 100644
index 0000000..f04f556
--- /dev/null
+++ b/src/net/url_request/http_user_agent_settings.h
@@ -0,0 +1,40 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_HTTP_USER_AGENT_SETTINGS_H_
+#define NET_URL_REQUEST_HTTP_USER_AGENT_SETTINGS_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "net/base/net_export.h"
+
+class GURL;
+
+namespace net {
+
+// The interface used by HTTP jobs to retrieve HTTP Accept-Language,
+// Accept-Charset and User-Agent header values.
+class NET_EXPORT HttpUserAgentSettings {
+ public:
+  HttpUserAgentSettings() {}
+  virtual ~HttpUserAgentSettings() {}
+
+  // Gets the value of 'Accept-Language' header field.
+  virtual const std::string& GetAcceptLanguage() const = 0;
+
+  // Gets the value of 'Accept-Charset' header field.
+  virtual const std::string& GetAcceptCharset() const = 0;
+
+  // Gets the UA string.
+  virtual const std::string& GetUserAgent() const = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(HttpUserAgentSettings);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_HTTP_USER_AGENT_SETTINGS_H_
+
diff --git a/src/net/url_request/static_http_user_agent_settings.cc b/src/net/url_request/static_http_user_agent_settings.cc
new file mode 100644
index 0000000..d694326
--- /dev/null
+++ b/src/net/url_request/static_http_user_agent_settings.cc
@@ -0,0 +1,34 @@
+// 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 "net/url_request/static_http_user_agent_settings.h"
+
+namespace net {
+
+StaticHttpUserAgentSettings::StaticHttpUserAgentSettings(
+    const std::string& accept_language,
+    const std::string& accept_charset,
+    const std::string& user_agent)
+    : accept_language_(accept_language),
+      accept_charset_(accept_charset),
+      user_agent_(user_agent) {
+}
+
+StaticHttpUserAgentSettings::~StaticHttpUserAgentSettings() {
+}
+
+const std::string& StaticHttpUserAgentSettings::GetAcceptLanguage() const {
+  return accept_language_;
+}
+
+const std::string& StaticHttpUserAgentSettings::GetAcceptCharset() const {
+  return accept_charset_;
+}
+
+const std::string& StaticHttpUserAgentSettings::GetUserAgent() const {
+  return user_agent_;
+}
+
+}  // namespace net
+
diff --git a/src/net/url_request/static_http_user_agent_settings.h b/src/net/url_request/static_http_user_agent_settings.h
new file mode 100644
index 0000000..0663f93
--- /dev/null
+++ b/src/net/url_request/static_http_user_agent_settings.h
@@ -0,0 +1,43 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_STATIC_HTTP_USER_AGENT_SETTINGS_H_
+#define NET_URL_REQUEST_STATIC_HTTP_USER_AGENT_SETTINGS_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "net/base/net_export.h"
+#include "net/url_request/http_user_agent_settings.h"
+
+namespace net {
+
+// An implementation of |HttpUserAgentSettings| that always provides the
+// same constant values for the HTTP Accept-Language, Accept-Charset, and
+// User-Agent headers.
+class NET_EXPORT StaticHttpUserAgentSettings : public HttpUserAgentSettings {
+ public:
+  StaticHttpUserAgentSettings(const std::string& accept_language,
+                              const std::string& accept_charset,
+                              const std::string& user_agent);
+  virtual ~StaticHttpUserAgentSettings();
+
+  // HttpUserAgentSettings implementation
+  virtual const std::string& GetAcceptLanguage() const OVERRIDE;
+  virtual const std::string& GetAcceptCharset() const OVERRIDE;
+  virtual const std::string& GetUserAgent() const OVERRIDE;
+
+ private:
+  const std::string accept_language_;
+  const std::string accept_charset_;
+  const std::string user_agent_;
+
+  DISALLOW_COPY_AND_ASSIGN(StaticHttpUserAgentSettings);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_STATIC_HTTP_USER_AGENT_SETTINGS_H_
+
diff --git a/src/net/url_request/test_url_fetcher_factory.cc b/src/net/url_request/test_url_fetcher_factory.cc
new file mode 100644
index 0000000..4b076d2
--- /dev/null
+++ b/src/net/url_request/test_url_fetcher_factory.cc
@@ -0,0 +1,377 @@
+// 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 "net/url_request/test_url_fetcher_factory.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop.h"
+#include "net/base/host_port_pair.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_fetcher_impl.h"
+#include "net/url_request/url_request_status.h"
+
+namespace net {
+
+ScopedURLFetcherFactory::ScopedURLFetcherFactory(
+    URLFetcherFactory* factory) {
+  DCHECK(!URLFetcherImpl::factory());
+  URLFetcherImpl::set_factory(factory);
+}
+
+ScopedURLFetcherFactory::~ScopedURLFetcherFactory() {
+  DCHECK(URLFetcherImpl::factory());
+  URLFetcherImpl::set_factory(NULL);
+}
+
+TestURLFetcher::TestURLFetcher(int id,
+                               const GURL& url,
+                               URLFetcherDelegate* d)
+    : owner_(NULL),
+      id_(id),
+      original_url_(url),
+      delegate_(d),
+      delegate_for_tests_(NULL),
+      did_receive_last_chunk_(false),
+      fake_load_flags_(0),
+      fake_response_code_(-1),
+      fake_response_destination_(STRING),
+      fake_was_fetched_via_proxy_(false),
+      fake_max_retries_(0) {
+}
+
+TestURLFetcher::~TestURLFetcher() {
+  if (delegate_for_tests_)
+    delegate_for_tests_->OnRequestEnd(id_);
+  if (owner_)
+    owner_->RemoveFetcherFromMap(id_);
+}
+
+void TestURLFetcher::SetUploadData(const std::string& upload_content_type,
+                                   const std::string& upload_content) {
+  upload_data_ = upload_content;
+}
+
+void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) {
+}
+
+void TestURLFetcher::AppendChunkToUpload(const std::string& data,
+                                         bool is_last_chunk) {
+  DCHECK(!did_receive_last_chunk_);
+  did_receive_last_chunk_ = is_last_chunk;
+  chunks_.push_back(data);
+  if (delegate_for_tests_)
+    delegate_for_tests_->OnChunkUpload(id_);
+}
+
+void TestURLFetcher::SetLoadFlags(int load_flags) {
+  fake_load_flags_= load_flags;
+}
+
+int TestURLFetcher::GetLoadFlags() const {
+  return fake_load_flags_;
+}
+
+void TestURLFetcher::SetReferrer(const std::string& referrer) {
+}
+
+void TestURLFetcher::SetExtraRequestHeaders(
+    const std::string& extra_request_headers) {
+  fake_extra_request_headers_.Clear();
+  fake_extra_request_headers_.AddHeadersFromString(extra_request_headers);
+}
+
+void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) {
+  fake_extra_request_headers_.AddHeaderFromString(header_line);
+}
+
+void TestURLFetcher::GetExtraRequestHeaders(
+    HttpRequestHeaders* headers) const {
+  *headers = fake_extra_request_headers_;
+}
+
+void TestURLFetcher::SetRequestContext(
+    URLRequestContextGetter* request_context_getter) {
+}
+
+void TestURLFetcher::SetFirstPartyForCookies(
+    const GURL& first_party_for_cookies) {
+}
+
+void TestURLFetcher::SetURLRequestUserData(
+    const void* key,
+    const CreateDataCallback& create_data_callback) {
+}
+
+void TestURLFetcher::SetStopOnRedirect(bool stop_on_redirect) {
+}
+
+void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) {
+}
+
+void TestURLFetcher::SetMaxRetriesOn5xx(int max_retries) {
+  fake_max_retries_ = max_retries;
+}
+
+int TestURLFetcher::GetMaxRetriesOn5xx() const {
+  return fake_max_retries_;
+}
+
+base::TimeDelta TestURLFetcher::GetBackoffDelay() const {
+  return fake_backoff_delay_;
+}
+
+void TestURLFetcher::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
+}
+
+void TestURLFetcher::SaveResponseToFileAtPath(
+    const FilePath& file_path,
+    scoped_refptr<base::TaskRunner> file_task_runner) {
+}
+
+void TestURLFetcher::SaveResponseToTemporaryFile(
+    scoped_refptr<base::TaskRunner> file_task_runner) {
+}
+
+#if defined(COBALT)
+void TestURLFetcher::DiscardResponse() {
+}
+#endif
+
+HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
+  return fake_response_headers_;
+}
+
+HostPortPair TestURLFetcher::GetSocketAddress() const {
+  NOTIMPLEMENTED();
+  return HostPortPair();
+}
+
+bool TestURLFetcher::WasFetchedViaProxy() const {
+  return fake_was_fetched_via_proxy_;
+}
+
+void TestURLFetcher::Start() {
+  // Overriden to do nothing. It is assumed the caller will notify the delegate.
+  if (delegate_for_tests_)
+    delegate_for_tests_->OnRequestStart(id_);
+}
+
+const GURL& TestURLFetcher::GetOriginalURL() const {
+  return original_url_;
+}
+
+const GURL& TestURLFetcher::GetURL() const {
+  return fake_url_;
+}
+
+const URLRequestStatus& TestURLFetcher::GetStatus() const {
+  return fake_status_;
+}
+
+int TestURLFetcher::GetResponseCode() const {
+  return fake_response_code_;
+}
+
+const ResponseCookies& TestURLFetcher::GetCookies() const {
+  return fake_cookies_;
+}
+
+bool TestURLFetcher::FileErrorOccurred(
+    base::PlatformFileError* out_error_code) const {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+void TestURLFetcher::ReceivedContentWasMalformed() {
+}
+
+bool TestURLFetcher::GetResponseAsString(
+    std::string* out_response_string) const {
+  if (fake_response_destination_ != STRING)
+    return false;
+
+  *out_response_string = fake_response_string_;
+  return true;
+}
+
+bool TestURLFetcher::GetResponseAsFilePath(
+    bool take_ownership, FilePath* out_response_path) const {
+  if (fake_response_destination_ != TEMP_FILE)
+    return false;
+
+  *out_response_path = fake_response_file_path_;
+  return true;
+}
+
+void TestURLFetcher::set_status(const URLRequestStatus& status) {
+  fake_status_ = status;
+}
+
+void TestURLFetcher::set_was_fetched_via_proxy(bool flag) {
+  fake_was_fetched_via_proxy_ = flag;
+}
+
+void TestURLFetcher::set_response_headers(
+    scoped_refptr<HttpResponseHeaders> headers) {
+  fake_response_headers_ = headers;
+}
+
+void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) {
+  fake_backoff_delay_ = backoff_delay;
+}
+
+void TestURLFetcher::SetDelegateForTests(DelegateForTests* delegate_for_tests) {
+  delegate_for_tests_ = delegate_for_tests;
+}
+
+void TestURLFetcher::SetResponseString(const std::string& response) {
+  fake_response_destination_ = STRING;
+  fake_response_string_ = response;
+}
+
+void TestURLFetcher::SetResponseFilePath(const FilePath& path) {
+  fake_response_destination_ = TEMP_FILE;
+  fake_response_file_path_ = path;
+}
+
+TestURLFetcherFactory::TestURLFetcherFactory()
+    : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      delegate_for_tests_(NULL),
+      remove_fetcher_on_delete_(false) {
+}
+
+TestURLFetcherFactory::~TestURLFetcherFactory() {}
+
+URLFetcher* TestURLFetcherFactory::CreateURLFetcher(
+    int id,
+    const GURL& url,
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
+  TestURLFetcher* fetcher = new TestURLFetcher(id, url, d);
+  if (remove_fetcher_on_delete_)
+    fetcher->set_owner(this);
+  fetcher->SetDelegateForTests(delegate_for_tests_);
+  fetchers_[id] = fetcher;
+  return fetcher;
+}
+
+TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const {
+  Fetchers::const_iterator i = fetchers_.find(id);
+  return i == fetchers_.end() ? NULL : i->second;
+}
+
+void TestURLFetcherFactory::RemoveFetcherFromMap(int id) {
+  Fetchers::iterator i = fetchers_.find(id);
+  DCHECK(i != fetchers_.end());
+  fetchers_.erase(i);
+}
+
+void TestURLFetcherFactory::SetDelegateForTests(
+    TestURLFetcherDelegateForTests* delegate_for_tests) {
+  delegate_for_tests_ = delegate_for_tests;
+}
+
+// This class is used by the FakeURLFetcherFactory below.
+class FakeURLFetcher : public TestURLFetcher {
+ public:
+  // Normal URL fetcher constructor but also takes in a pre-baked response.
+  FakeURLFetcher(const GURL& url,
+                 URLFetcherDelegate* d,
+                 const std::string& response_data, bool success)
+      : TestURLFetcher(0, url, d),
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+    set_status(URLRequestStatus(
+        success ? URLRequestStatus::SUCCESS : URLRequestStatus::FAILED,
+        0));
+    set_response_code(success ? 200 : 500);
+    SetResponseString(response_data);
+  }
+
+  // Start the request.  This will call the given delegate asynchronously
+  // with the pre-baked response as parameter.
+  virtual void Start() OVERRIDE {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
+  }
+
+  virtual const GURL& GetURL() const OVERRIDE {
+    return TestURLFetcher::GetOriginalURL();
+  }
+
+ private:
+  virtual ~FakeURLFetcher() {
+  }
+
+  // This is the method which actually calls the delegate that is passed in the
+  // constructor.
+  void RunDelegate() {
+    delegate()->OnURLFetchComplete(this);
+  }
+
+  base::WeakPtrFactory<FakeURLFetcher> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeURLFetcher);
+};
+
+FakeURLFetcherFactory::FakeURLFetcherFactory()
+    : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      default_factory_(NULL) {
+}
+
+FakeURLFetcherFactory::FakeURLFetcherFactory(
+    URLFetcherFactory* default_factory)
+    : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      default_factory_(default_factory) {
+}
+
+FakeURLFetcherFactory::~FakeURLFetcherFactory() {}
+
+URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
+    int id,
+    const GURL& url,
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
+  FakeResponseMap::const_iterator it = fake_responses_.find(url);
+  if (it == fake_responses_.end()) {
+    if (default_factory_ == NULL) {
+      // If we don't have a baked response for that URL we return NULL.
+      DLOG(ERROR) << "No baked response for URL: " << url.spec();
+      return NULL;
+    } else {
+      return default_factory_->CreateURLFetcher(id, url, request_type, d);
+    }
+  }
+  return new FakeURLFetcher(url, d, it->second.first, it->second.second);
+}
+
+void FakeURLFetcherFactory::SetFakeResponse(const std::string& url,
+                                            const std::string& response_data,
+                                            bool success) {
+  // Overwrite existing URL if it already exists.
+  fake_responses_[GURL(url)] = std::make_pair(response_data, success);
+}
+
+void FakeURLFetcherFactory::ClearFakeResponses() {
+  fake_responses_.clear();
+}
+
+URLFetcherImplFactory::URLFetcherImplFactory() {}
+
+URLFetcherImplFactory::~URLFetcherImplFactory() {}
+
+URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
+    int id,
+    const GURL& url,
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
+  return new URLFetcherImpl(url, request_type, d);
+}
+
+}  // namespace net
diff --git a/src/net/url_request/test_url_fetcher_factory.h b/src/net/url_request/test_url_fetcher_factory.h
new file mode 100644
index 0000000..62c0efb
--- /dev/null
+++ b/src/net/url_request/test_url_fetcher_factory.h
@@ -0,0 +1,342 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_
+#define NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_
+
+#include <list>
+#include <map>
+#include <string>
+#include <utility>
+
+#include "base/compiler_specific.h"
+#include "base/threading/non_thread_safe.h"
+#include "googleurl/src/gurl.h"
+#include "net/http/http_request_headers.h"
+#include "net/url_request/url_fetcher_factory.h"
+#include "net/url_request/url_request_status.h"
+
+namespace net {
+
+// Changes URLFetcher's Factory for the lifetime of the object.
+// Note that this scoper cannot be nested (to make it even harder to misuse).
+class ScopedURLFetcherFactory : public base::NonThreadSafe {
+ public:
+  explicit ScopedURLFetcherFactory(URLFetcherFactory* factory);
+  virtual ~ScopedURLFetcherFactory();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedURLFetcherFactory);
+};
+
+// TestURLFetcher and TestURLFetcherFactory are used for testing consumers of
+// URLFetcher. TestURLFetcherFactory is a URLFetcherFactory that creates
+// TestURLFetchers. TestURLFetcher::Start is overriden to do nothing. It is
+// expected that you'll grab the delegate from the TestURLFetcher and invoke
+// the callback method when appropriate. In this way it's easy to mock a
+// URLFetcher.
+// Typical usage:
+//   // TestURLFetcher requires a MessageLoop.
+//   MessageLoop message_loop;
+//   // And an IO thread to release URLRequestContextGetter in URLFetcher::Core.
+//   BrowserThreadImpl io_thread(BrowserThread::IO, &message_loop);
+//   // Create factory (it automatically sets itself as URLFetcher's factory).
+//   TestURLFetcherFactory factory;
+//   // Do something that triggers creation of a URLFetcher.
+//   ...
+//   TestURLFetcher* fetcher = factory.GetFetcherByID(expected_id);
+//   DCHECK(fetcher);
+//   // Notify delegate with whatever data you want.
+//   fetcher->delegate()->OnURLFetchComplete(...);
+//   // Make sure consumer of URLFetcher does the right thing.
+//   ...
+//
+// Note: if you don't know when your request objects will be created you
+// might want to use the FakeURLFetcher and FakeURLFetcherFactory classes
+// below.
+
+class TestURLFetcherFactory;
+class TestURLFetcher : public URLFetcher {
+ public:
+  // Interface for tests to intercept production code classes using URLFetcher.
+  // Allows even-driven mock server classes to analyze the correctness of
+  // requests / uploads events and forge responses back at the right moment.
+  class DelegateForTests {
+   public:
+    // Callback issued correspondingly to the call to the |Start()| method.
+    virtual void OnRequestStart(int fetcher_id) = 0;
+
+    // Callback issued correspondingly to the call to |AppendChunkToUpload|.
+    // Uploaded chunks can be retrieved with the |upload_chunks()| getter.
+    virtual void OnChunkUpload(int fetcher_id) = 0;
+
+    // Callback issued correspondingly to the destructor.
+    virtual void OnRequestEnd(int fetcher_id) = 0;
+  };
+
+  TestURLFetcher(int id,
+                 const GURL& url,
+                 URLFetcherDelegate* d);
+  virtual ~TestURLFetcher();
+
+  // URLFetcher implementation
+  virtual void SetUploadData(const std::string& upload_content_type,
+                             const std::string& upload_content) OVERRIDE;
+  virtual void SetChunkedUpload(
+      const std::string& upload_content_type) OVERRIDE;
+  // Overriden to cache the chunks uploaded. Caller can read back the uploaded
+  // chunks with the upload_chunks() accessor.
+  virtual void AppendChunkToUpload(const std::string& data,
+                                   bool is_last_chunk) OVERRIDE;
+  virtual void SetLoadFlags(int load_flags) OVERRIDE;
+  virtual int GetLoadFlags() const OVERRIDE;
+  virtual void SetReferrer(const std::string& referrer) OVERRIDE;
+  virtual void SetExtraRequestHeaders(
+      const std::string& extra_request_headers) OVERRIDE;
+  virtual void AddExtraRequestHeader(const std::string& header_line) OVERRIDE;
+  virtual void GetExtraRequestHeaders(
+      HttpRequestHeaders* headers) const OVERRIDE;
+  virtual void SetRequestContext(
+      URLRequestContextGetter* request_context_getter) OVERRIDE;
+  virtual void SetFirstPartyForCookies(
+      const GURL& first_party_for_cookies) OVERRIDE;
+  virtual void SetURLRequestUserData(
+      const void* key,
+      const CreateDataCallback& create_data_callback) OVERRIDE;
+  virtual void SetStopOnRedirect(bool stop_on_redirect) OVERRIDE;
+  virtual void SetAutomaticallyRetryOn5xx(bool retry) OVERRIDE;
+  virtual void SetMaxRetriesOn5xx(int max_retries) OVERRIDE;
+  virtual int GetMaxRetriesOn5xx() const OVERRIDE;
+  virtual base::TimeDelta GetBackoffDelay() const OVERRIDE;
+  virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) OVERRIDE;
+  virtual void SaveResponseToFileAtPath(
+      const FilePath& file_path,
+      scoped_refptr<base::TaskRunner> file_task_runner) OVERRIDE;
+  virtual void SaveResponseToTemporaryFile(
+      scoped_refptr<base::TaskRunner> file_task_runner) OVERRIDE;
+#if defined(COBALT)
+  virtual void DiscardResponse() OVERRIDE;
+#endif
+  virtual HttpResponseHeaders* GetResponseHeaders() const OVERRIDE;
+  virtual HostPortPair GetSocketAddress() const OVERRIDE;
+  virtual bool WasFetchedViaProxy() const OVERRIDE;
+  virtual void Start() OVERRIDE;
+
+  // URL we were created with. Because of how we're using URLFetcher GetURL()
+  // always returns an empty URL. Chances are you'll want to use
+  // GetOriginalURL() in your tests.
+  virtual const GURL& GetOriginalURL() const OVERRIDE;
+  virtual const GURL& GetURL() const OVERRIDE;
+  virtual const URLRequestStatus& GetStatus() const OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+  virtual const ResponseCookies& GetCookies() const OVERRIDE;
+  virtual bool FileErrorOccurred(
+      base::PlatformFileError* out_error_code) const OVERRIDE;
+  virtual void ReceivedContentWasMalformed() OVERRIDE;
+  // Override response access functions to return fake data.
+  virtual bool GetResponseAsString(
+      std::string* out_response_string) const OVERRIDE;
+  virtual bool GetResponseAsFilePath(
+      bool take_ownership, FilePath* out_response_path) const OVERRIDE;
+
+  // Sets owner of this class.  Set it to a non-NULL value if you want
+  // to automatically unregister this fetcher from the owning factory
+  // upon destruction.
+  void set_owner(TestURLFetcherFactory* owner) { owner_ = owner; }
+
+  // Unique ID in our factory.
+  int id() const { return id_; }
+
+  // Returns the data uploaded on this URLFetcher.
+  const std::string& upload_data() const { return upload_data_; }
+
+  // Returns the chunks of data uploaded on this URLFetcher.
+  const std::list<std::string>& upload_chunks() const { return chunks_; }
+
+  // Checks whether the last call to |AppendChunkToUpload(...)| was final.
+  bool did_receive_last_chunk() const { return did_receive_last_chunk_; }
+
+  // Returns the delegate installed on the URLFetcher.
+  URLFetcherDelegate* delegate() const { return delegate_; }
+
+  void set_url(const GURL& url) { fake_url_ = url; }
+  void set_status(const URLRequestStatus& status);
+  void set_response_code(int response_code) {
+    fake_response_code_ = response_code;
+  }
+  void set_cookies(const ResponseCookies& c) { fake_cookies_ = c; }
+  void set_was_fetched_via_proxy(bool flag);
+  void set_response_headers(scoped_refptr<HttpResponseHeaders> headers);
+  void set_backoff_delay(base::TimeDelta backoff_delay);
+  void SetDelegateForTests(DelegateForTests* delegate_for_tests);
+
+  // Set string data.
+  void SetResponseString(const std::string& response);
+
+  // Set File data.
+  void SetResponseFilePath(const FilePath& path);
+
+ private:
+  enum ResponseDestinationType {
+    STRING,  // Default: In a std::string
+    TEMP_FILE  // Write to a temp file
+  };
+
+  TestURLFetcherFactory* owner_;
+  const int id_;
+  const GURL original_url_;
+  URLFetcherDelegate* delegate_;
+  DelegateForTests* delegate_for_tests_;
+  std::string upload_data_;
+  std::list<std::string> chunks_;
+  bool did_receive_last_chunk_;
+
+  // User can use set_* methods to provide values returned by getters.
+  // Setting the real values is not possible, because the real class
+  // has no setters. The data is a private member of a class defined
+  // in a .cc file, so we can't get at it with friendship.
+  int fake_load_flags_;
+  GURL fake_url_;
+  URLRequestStatus fake_status_;
+  int fake_response_code_;
+  ResponseCookies fake_cookies_;
+  ResponseDestinationType fake_response_destination_;
+  std::string fake_response_string_;
+  FilePath fake_response_file_path_;
+  bool fake_was_fetched_via_proxy_;
+  scoped_refptr<HttpResponseHeaders> fake_response_headers_;
+  HttpRequestHeaders fake_extra_request_headers_;
+  int fake_max_retries_;
+  base::TimeDelta fake_backoff_delay_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestURLFetcher);
+};
+
+typedef TestURLFetcher::DelegateForTests TestURLFetcherDelegateForTests;
+
+// Simple URLFetcherFactory method that creates TestURLFetchers. All fetchers
+// are registered in a map by the id passed to the create method.
+// Optionally, a fetcher may be automatically unregistered from the map upon
+// its destruction.
+class TestURLFetcherFactory : public URLFetcherFactory,
+                              public ScopedURLFetcherFactory {
+ public:
+  TestURLFetcherFactory();
+  virtual ~TestURLFetcherFactory();
+
+  virtual URLFetcher* CreateURLFetcher(
+      int id,
+      const GURL& url,
+      URLFetcher::RequestType request_type,
+      URLFetcherDelegate* d) OVERRIDE;
+  TestURLFetcher* GetFetcherByID(int id) const;
+  void RemoveFetcherFromMap(int id);
+  void SetDelegateForTests(TestURLFetcherDelegateForTests* delegate_for_tests);
+  void set_remove_fetcher_on_delete(bool remove_fetcher_on_delete) {
+    remove_fetcher_on_delete_ = remove_fetcher_on_delete;
+  }
+
+ private:
+  // Maps from id passed to create to the returned URLFetcher.
+  typedef std::map<int, TestURLFetcher*> Fetchers;
+  Fetchers fetchers_;
+  TestURLFetcherDelegateForTests* delegate_for_tests_;
+  // Whether to automatically unregister a fetcher from this factory upon its
+  // destruction, false by default.
+  bool remove_fetcher_on_delete_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestURLFetcherFactory);
+};
+
+// The FakeURLFetcher and FakeURLFetcherFactory classes are similar to the
+// ones above but don't require you to know when exactly the URLFetcher objects
+// will be created.
+//
+// These classes let you set pre-baked HTTP responses for particular URLs.
+// E.g., if the user requests http://a.com/ then respond with an HTTP/500.
+//
+// We assume that the thread that is calling Start() on the URLFetcher object
+// has a message loop running.
+//
+// This class is not thread-safe.  You should not call SetFakeResponse or
+// ClearFakeResponse at the same time you call CreateURLFetcher.  However, it is
+// OK to start URLFetcher objects while setting or clearning fake responses
+// since already created URLFetcher objects will not be affected by any changes
+// made to the fake responses (once a URLFetcher object is created you cannot
+// change its fake response).
+//
+// Example usage:
+//  FakeURLFetcherFactory factory;
+//
+//  // You know that class SomeService will request url http://a.com/ and you
+//  // want to test the service class by returning an error.
+//  factory.SetFakeResponse("http://a.com/", "", false);
+//  // But if the service requests http://b.com/asdf you want to respond with
+//  // a simple html page and an HTTP/200 code.
+//  factory.SetFakeResponse("http://b.com/asdf",
+//                          "<html><body>hello world</body></html>",
+//                          true);
+//
+//  SomeService service;
+//  service.Run();  // Will eventually request these two URLs.
+
+class FakeURLFetcherFactory : public URLFetcherFactory,
+                              public ScopedURLFetcherFactory {
+ public:
+  FakeURLFetcherFactory();
+  // FakeURLFetcherFactory that will delegate creating URLFetcher for unknown
+  // url to the given factory.
+  explicit FakeURLFetcherFactory(URLFetcherFactory* default_factory);
+  virtual ~FakeURLFetcherFactory();
+
+  // If no fake response is set for the given URL this method will delegate the
+  // call to |default_factory_| if it is not NULL, or return NULL if it is
+  // NULL.
+  // Otherwise, it will return a URLFetcher object which will respond with the
+  // pre-baked response that the client has set by calling SetFakeResponse().
+  virtual URLFetcher* CreateURLFetcher(
+      int id,
+      const GURL& url,
+      URLFetcher::RequestType request_type,
+      URLFetcherDelegate* d) OVERRIDE;
+
+  // Sets the fake response for a given URL.  If success is true we will serve
+  // an HTTP/200 and an HTTP/500 otherwise.  The |response_data| may be empty.
+  void SetFakeResponse(const std::string& url,
+                       const std::string& response_data,
+                       bool success);
+
+  // Clear all the fake responses that were previously set via
+  // SetFakeResponse().
+  void ClearFakeResponses();
+
+ private:
+  typedef std::map<GURL, std::pair<std::string, bool> > FakeResponseMap;
+  FakeResponseMap fake_responses_;
+  URLFetcherFactory* default_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeURLFetcherFactory);
+};
+
+// This is an implementation of URLFetcherFactory that will create a
+// URLFetcherImpl. It can be use in conjunction with a FakeURLFetcherFactory in
+// integration tests to control the behavior of some requests but execute
+// all the other ones.
+class URLFetcherImplFactory : public URLFetcherFactory {
+ public:
+  URLFetcherImplFactory();
+  virtual ~URLFetcherImplFactory();
+
+  // This method will create a real URLFetcher.
+  virtual URLFetcher* CreateURLFetcher(
+      int id,
+      const GURL& url,
+      URLFetcher::RequestType request_type,
+      URLFetcherDelegate* d) OVERRIDE;
+
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_
diff --git a/src/net/url_request/url_fetcher.cc b/src/net/url_request/url_fetcher.cc
new file mode 100644
index 0000000..3cc75ad
--- /dev/null
+++ b/src/net/url_request/url_fetcher.cc
@@ -0,0 +1,48 @@
+// 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 "net/url_request/url_fetcher.h"
+
+#include "net/url_request/url_fetcher_factory.h"
+#include "net/url_request/url_fetcher_impl.h"
+
+namespace net {
+
+URLFetcher::~URLFetcher() {}
+
+// static
+URLFetcher* net::URLFetcher::Create(
+    const GURL& url,
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
+  return new URLFetcherImpl(url, request_type, d);
+}
+
+// static
+URLFetcher* net::URLFetcher::Create(
+    int id,
+    const GURL& url,
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
+  URLFetcherFactory* factory = URLFetcherImpl::factory();
+  return factory ? factory->CreateURLFetcher(id, url, request_type, d) :
+                   new URLFetcherImpl(url, request_type, d);
+}
+
+// static
+void net::URLFetcher::CancelAll() {
+  URLFetcherImpl::CancelAll();
+}
+
+// static
+void net::URLFetcher::SetEnableInterceptionForTests(bool enabled) {
+  URLFetcherImpl::SetEnableInterceptionForTests(enabled);
+}
+
+// static
+void net::URLFetcher::SetIgnoreCertificateRequests(bool ignored) {
+  URLFetcherImpl::SetIgnoreCertificateRequests(ignored);
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_fetcher.h b/src/net/url_request/url_fetcher.h
new file mode 100644
index 0000000..59ca148
--- /dev/null
+++ b/src/net/url_request/url_fetcher.h
@@ -0,0 +1,297 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_FETCHER_H_
+#define NET_URL_REQUEST_URL_FETCHER_H_
+
+#include <string>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/memory/ref_counted.h"
+#include "base/platform_file.h"
+#include "base/supports_user_data.h"
+#include "base/task_runner.h"
+#include "net/base/net_export.h"
+
+class FilePath;
+class GURL;
+
+namespace base {
+class MessageLoopProxy;
+class TimeDelta;
+}
+
+namespace net {
+class HostPortPair;
+class HttpRequestHeaders;
+class HttpResponseHeaders;
+class URLFetcherDelegate;
+class URLRequestContextGetter;
+class URLRequestStatus;
+typedef std::vector<std::string> ResponseCookies;
+
+// To use this class, create an instance with the desired URL and a pointer to
+// the object to be notified when the URL has been loaded:
+//   URLFetcher* fetcher = URLFetcher::Create("http://www.google.com",
+//                                            URLFetcher::GET, this);
+//
+// You must also set a request context getter:
+//
+//   fetcher->SetRequestContext(&my_request_context_getter);
+//
+// Then, optionally set properties on this object, like the request context or
+// extra headers:
+//   fetcher->set_extra_request_headers("X-Foo: bar");
+//
+// Finally, start the request:
+//   fetcher->Start();
+//
+//
+// The object you supply as a delegate must inherit from URLFetcherDelegate.
+// When the response headers are received, OnURLFetchResponseStarted()
+// will be called with a pointer to the URLFetcher and GetResponseCode()/
+// GetResponseHeaders() can be called INSIDE it to retrieve the response code
+// and headers.  Note that when retry is enabled, the response code and headers
+// retrieved at this stage may different than the final ones.  When the fetch
+// is completed, OnURLFetchComplete() will be called with a pointer to the
+// URLFetcher.  From that point until the original URLFetcher instance is
+// destroyed, you may use accessor methods to see the result of the fetch.  You
+// should copy these objects if you need them to live longer than the
+// URLFetcher instance.  If the URLFetcher instance is destroyed before the
+// callback happens, the fetch will be canceled and no callback will occur.
+//
+// You may create the URLFetcher instance on any thread; OnURLFetchComplete()
+// will be called back on the same thread you use to create the instance.
+//
+//
+// NOTE: By default URLFetcher requests are NOT intercepted, except when
+// interception is explicitly enabled in tests.
+class NET_EXPORT URLFetcher {
+ public:
+  // Imposible http response code. Used to signal that no http response code
+  // was received.
+  enum ResponseCode {
+    RESPONSE_CODE_INVALID = -1
+  };
+
+  enum RequestType {
+    GET,
+    POST,
+    HEAD,
+    DELETE_REQUEST,   // DELETE is already taken on Windows.
+                      // <winnt.h> defines a DELETE macro.
+    PUT,
+  };
+
+  // Used by SetURLRequestUserData.  The callback should make a fresh
+  // base::SupportsUserData::Data object every time it's called.
+  typedef base::Callback<base::SupportsUserData::Data*()> CreateDataCallback;
+
+  virtual ~URLFetcher();
+
+  // |url| is the URL to send the request to.
+  // |request_type| is the type of request to make.
+  // |d| the object that will receive the callback on fetch completion.
+  static URLFetcher* Create(const GURL& url,
+                            URLFetcher::RequestType request_type,
+                            URLFetcherDelegate* d);
+
+  // Like above, but if there's a URLFetcherFactory registered with the
+  // implementation it will be used. |id| may be used during testing to identify
+  // who is creating the URLFetcher.
+  static URLFetcher* Create(int id,
+                            const GURL& url,
+                            URLFetcher::RequestType request_type,
+                            URLFetcherDelegate* d);
+
+  // Cancels all existing URLFetchers.  Will notify the URLFetcherDelegates.
+  // Note that any new URLFetchers created while this is running will not be
+  // cancelled.  Typically, one would call this in the CleanUp() method of an IO
+  // thread, so that no new URLRequests would be able to start on the IO thread
+  // anyway.  This doesn't prevent new URLFetchers from trying to post to the IO
+  // thread though, even though the task won't ever run.
+  static void CancelAll();
+
+  // Normally interception is disabled for URLFetcher, but you can use this
+  // to enable it for tests. Also see ScopedURLFetcherFactory for another way
+  // of testing code that uses an URLFetcher.
+  static void SetEnableInterceptionForTests(bool enabled);
+
+  // Normally, URLFetcher will abort loads that request SSL client certificate
+  // authentication, but this method may be used to cause URLFetchers to ignore
+  // requests for client certificates and continue anonymously. Because such
+  // behaviour affects the URLRequestContext's shared network state and socket
+  // pools, it should only be used for testing.
+  static void SetIgnoreCertificateRequests(bool ignored);
+
+  // Sets data only needed by POSTs.  All callers making POST requests should
+  // call this before the request is started.  |upload_content_type| is the MIME
+  // type of the content, while |upload_content| is the data to be sent (the
+  // Content-Length header value will be set to the length of this data).
+  virtual void SetUploadData(const std::string& upload_content_type,
+                             const std::string& upload_content) = 0;
+
+  // Indicates that the POST data is sent via chunked transfer encoding.
+  // This may only be called before calling Start().
+  // Use AppendChunkToUpload() to give the data chunks after calling Start().
+  virtual void SetChunkedUpload(const std::string& upload_content_type) = 0;
+
+  // Adds the given bytes to a request's POST data transmitted using chunked
+  // transfer encoding.
+  // This method should be called ONLY after calling Start().
+  virtual void AppendChunkToUpload(const std::string& data,
+                                   bool is_last_chunk) = 0;
+
+  // Set one or more load flags as defined in net/base/load_flags.h.  Must be
+  // called before the request is started.
+  virtual void SetLoadFlags(int load_flags) = 0;
+
+  // Returns the current load flags.
+  virtual int GetLoadFlags() const = 0;
+
+  // The referrer URL for the request. Must be called before the request is
+  // started.
+  virtual void SetReferrer(const std::string& referrer) = 0;
+
+  // Set extra headers on the request.  Must be called before the request
+  // is started.
+  // This replaces the entire extra request headers.
+  virtual void SetExtraRequestHeaders(
+      const std::string& extra_request_headers) = 0;
+
+  // Add header (with format field-name ":" [ field-value ]) to the request
+  // headers.  Must be called before the request is started.
+  // This appends the header to the current extra request headers.
+  virtual void AddExtraRequestHeader(const std::string& header_line) = 0;
+
+  virtual void GetExtraRequestHeaders(
+      HttpRequestHeaders* headers) const = 0;
+
+  // Set the URLRequestContext on the request.  Must be called before the
+  // request is started.
+  virtual void SetRequestContext(
+      URLRequestContextGetter* request_context_getter) = 0;
+
+  // Set the URL that should be consulted for the third-party cookie
+  // blocking policy.
+  virtual void SetFirstPartyForCookies(
+      const GURL& first_party_for_cookies) = 0;
+
+  // Set the key and data callback that is used when setting the user
+  // data on any URLRequest objects this object creates.
+  virtual void SetURLRequestUserData(
+      const void* key,
+      const CreateDataCallback& create_data_callback) = 0;
+
+  // If |stop_on_redirect| is true, 3xx responses will cause the fetch to halt
+  // immediately rather than continue through the redirect.  OnURLFetchComplete
+  // will be called, with the URLFetcher's URL set to the redirect destination,
+  // its status set to CANCELED, and its response code set to the relevant 3xx
+  // server response code.
+  virtual void SetStopOnRedirect(bool stop_on_redirect) = 0;
+
+  // If |retry| is false, 5xx responses will be propagated to the observer,
+  // if it is true URLFetcher will automatically re-execute the request,
+  // after backoff_delay() elapses. URLFetcher has it set to true by default.
+  virtual void SetAutomaticallyRetryOn5xx(bool retry) = 0;
+
+  virtual void SetMaxRetriesOn5xx(int max_retries) = 0;
+  virtual int GetMaxRetriesOn5xx() const = 0;
+
+  // Returns the back-off delay before the request will be retried,
+  // when a 5xx response was received.
+  virtual base::TimeDelta GetBackoffDelay() const = 0;
+
+  // Retries up to |max_retries| times when requests fail with
+  // ERR_NETWORK_CHANGED. If ERR_NETWORK_CHANGED is received after having
+  // retried |max_retries| times then it is propagated to the observer.
+  virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) = 0;
+
+  // By default, the response is saved in a string. Call this method to save the
+  // response to a file instead. Must be called before Start().
+  // |file_task_runner| will be used for all file operations.
+  // To save to a temporary file, use SaveResponseToTemporaryFile().
+  // The created file is removed when the URLFetcher is deleted unless you
+  // take ownership by calling GetResponseAsFilePath().
+  virtual void SaveResponseToFileAtPath(
+      const FilePath& file_path,
+      scoped_refptr<base::TaskRunner> file_task_runner) = 0;
+
+  // By default, the response is saved in a string. Call this method to save the
+  // response to a temporary file instead. Must be called before Start().
+  // |file_task_runner| will be used for all file operations.
+  // The created file is removed when the URLFetcher is deleted unless you
+  // take ownership by calling GetResponseAsFilePath().
+  virtual void SaveResponseToTemporaryFile(
+      scoped_refptr<base::TaskRunner> file_task_runner) = 0;
+
+#if defined(COBALT)
+  // By default, the response is saved in a string. Call this method to
+  // discard the response instead. Must be called before Start().
+  // This may be useful if your delegate will be implementing
+  // ShouldSendDownloadData() and buffering it internally.
+  virtual void DiscardResponse() = 0;
+#endif
+
+  // Retrieve the response headers from the request.  Must only be called
+  // inside the OnURLFetchReceivedResponseHeaders callback or after the
+  // OnURLFetchComplete callback is called.
+  virtual HttpResponseHeaders* GetResponseHeaders() const = 0;
+
+  // Retrieve the remote socket address from the request.  Must only
+  // be called after the OnURLFetchComplete callback has run and if
+  // the request has not failed.
+  virtual HostPortPair GetSocketAddress() const = 0;
+
+  // Returns true if the request was delivered through a proxy.  Must only
+  // be called after the OnURLFetchComplete callback has run and the request
+  // has not failed.
+  virtual bool WasFetchedViaProxy() const = 0;
+
+  // Start the request.  After this is called, you may not change any other
+  // settings.
+  virtual void Start() = 0;
+
+  // Return the URL that we were asked to fetch.
+  virtual const GURL& GetOriginalURL() const = 0;
+
+  // Return the URL that this fetcher is processing.
+  virtual const GURL& GetURL() const = 0;
+
+  // The status of the URL fetch.
+  virtual const URLRequestStatus& GetStatus() const = 0;
+
+  // The http response code received. Will return RESPONSE_CODE_INVALID
+  // if an error prevented any response from being received.
+  virtual int GetResponseCode() const = 0;
+
+  // Cookies recieved.
+  virtual const ResponseCookies& GetCookies() const = 0;
+
+  // Return true if any file system operation failed.  If so, set |error_code|
+  // to the error code. File system errors are only possible if user called
+  // SaveResponseToTemporaryFile().
+  virtual bool FileErrorOccurred(
+      base::PlatformFileError* out_error_code) const = 0;
+
+  // Reports that the received content was malformed.
+  virtual void ReceivedContentWasMalformed() = 0;
+
+  // Get the response as a string. Return false if the fetcher was not
+  // set to store the response as a string.
+  virtual bool GetResponseAsString(std::string* out_response_string) const = 0;
+
+  // Get the path to the file containing the response body. Returns false
+  // if the response body was not saved to a file. If take_ownership is
+  // true, caller takes responsibility for the file, and it will not
+  // be removed once the URLFetcher is destroyed.  User should not take
+  // ownership more than once, or call this method after taking ownership.
+  virtual bool GetResponseAsFilePath(bool take_ownership,
+                                     FilePath* out_response_path) const = 0;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_FETCHER_H_
diff --git a/src/net/url_request/url_fetcher_core.cc b/src/net/url_request/url_fetcher_core.cc
new file mode 100644
index 0000000..2097903
--- /dev/null
+++ b/src/net/url_request/url_fetcher_core.cc
@@ -0,0 +1,1123 @@
+// 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 "net/url_request/url_fetcher_core.h"
+
+#include "base/bind.h"
+#include "base/file_util_proxy.h"
+#include "base/logging.h"
+#include "base/single_thread_task_runner.h"
+#include "base/metrics/histogram.h"
+#include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/tracked_objects.h"
+#include "net/base/io_buffer.h"
+#include "net/base/load_flags.h"
+#include "net/base/net_errors.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_data_stream.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_throttler_manager.h"
+
+namespace {
+
+const int kBufferSize = 16384;
+const int kDownloadCacheSize = 65536;
+const int kUploadProgressTimerInterval = 100;
+bool g_interception_enabled = false;
+bool g_ignore_certificate_requests = false;
+
+}  // namespace
+
+namespace net {
+
+// URLFetcherCore::Registry ---------------------------------------------------
+
+URLFetcherCore::Registry::Registry() {}
+URLFetcherCore::Registry::~Registry() {}
+
+void URLFetcherCore::Registry::AddURLFetcherCore(URLFetcherCore* core) {
+  DCHECK(!ContainsKey(fetchers_, core));
+  fetchers_.insert(core);
+}
+
+void URLFetcherCore::Registry::RemoveURLFetcherCore(URLFetcherCore* core) {
+  DCHECK(ContainsKey(fetchers_, core));
+  fetchers_.erase(core);
+}
+
+void URLFetcherCore::Registry::CancelAll() {
+  while (!fetchers_.empty())
+    (*fetchers_.begin())->CancelURLRequest();
+}
+
+
+// URLFetcherCore::FileWriter -------------------------------------------------
+
+URLFetcherCore::FileWriter::FileWriter(
+    URLFetcherCore* core,
+    scoped_refptr<base::TaskRunner> file_task_runner)
+    : core_(core),
+      error_code_(base::PLATFORM_FILE_OK),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+      file_task_runner_(file_task_runner),
+      file_handle_(base::kInvalidPlatformFileValue) {
+}
+
+URLFetcherCore::FileWriter::~FileWriter() {
+  CloseAndDeleteFile();
+}
+
+void URLFetcherCore::FileWriter::CreateFileAtPath(
+    const FilePath& file_path) {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+  DCHECK(file_task_runner_.get());
+  base::FileUtilProxy::CreateOrOpen(
+      file_task_runner_,
+      file_path,
+      base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE,
+      base::Bind(&URLFetcherCore::FileWriter::DidCreateFile,
+                 weak_factory_.GetWeakPtr(),
+                 file_path));
+}
+
+void URLFetcherCore::FileWriter::CreateTempFile() {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+  DCHECK(file_task_runner_.get());
+  base::FileUtilProxy::CreateTemporary(
+      file_task_runner_,
+      0,  // No additional file flags.
+      base::Bind(&URLFetcherCore::FileWriter::DidCreateTempFile,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void URLFetcherCore::FileWriter::WriteBuffer(int num_bytes) {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+
+  // Start writing to the file by setting the initial state
+  // of |pending_bytes_| and |buffer_offset_| to indicate that the
+  // entire buffer has not yet been written.
+  pending_bytes_ = num_bytes;
+  buffer_offset_ = 0;
+  ContinueWrite(base::PLATFORM_FILE_OK, 0);
+}
+
+void URLFetcherCore::FileWriter::ContinueWrite(
+    base::PlatformFileError error_code,
+    int bytes_written) {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+
+  if (file_handle_ == base::kInvalidPlatformFileValue) {
+    // While a write was being done on the file thread, a request
+    // to close or disown the file occured on the IO thread.  At
+    // this point a request to close the file is pending on the
+    // file thread.
+    return;
+  }
+
+  // Every code path that resets |core_->request_| should reset
+  // |core->file_writer_| or cause the file writer to disown the file.  In the
+  // former case, this callback can not be called, because the weak pointer to
+  // |this| will be NULL. In the latter case, the check of |file_handle_| at the
+  // start of this method ensures that we can not reach this point.
+  CHECK(core_->request_.get());
+
+  if (base::PLATFORM_FILE_OK != error_code) {
+    error_code_ = error_code;
+    CloseAndDeleteFile();
+    core_->delegate_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
+    return;
+  }
+
+  total_bytes_written_ += bytes_written;
+  buffer_offset_ += bytes_written;
+  pending_bytes_ -= bytes_written;
+
+  if (pending_bytes_ > 0) {
+    base::FileUtilProxy::Write(
+        file_task_runner_, file_handle_,
+        total_bytes_written_,  // Append to the end
+        (core_->buffer_->data() + buffer_offset_), pending_bytes_,
+        base::Bind(&URLFetcherCore::FileWriter::ContinueWrite,
+                   weak_factory_.GetWeakPtr()));
+  } else {
+    // Finished writing core_->buffer_ to the file. Read some more.
+    core_->ReadResponse();
+  }
+}
+
+void URLFetcherCore::FileWriter::DisownFile() {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+
+  // Disowning is done by the delegate's OnURLFetchComplete method.
+  // The file should be closed by the time that method is called.
+  DCHECK(file_handle_ == base::kInvalidPlatformFileValue);
+
+  // Forget about any file by reseting the path.
+  file_path_.clear();
+}
+
+void URLFetcherCore::FileWriter::CloseFileAndCompleteRequest() {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+
+  if (file_handle_ != base::kInvalidPlatformFileValue) {
+    base::FileUtilProxy::Close(
+        file_task_runner_, file_handle_,
+        base::Bind(&URLFetcherCore::FileWriter::DidCloseFile,
+                   weak_factory_.GetWeakPtr()));
+    file_handle_ = base::kInvalidPlatformFileValue;
+  }
+}
+
+void URLFetcherCore::FileWriter::CloseAndDeleteFile() {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+
+  if (file_handle_ == base::kInvalidPlatformFileValue) {
+    DeleteFile(base::PLATFORM_FILE_OK);
+    return;
+  }
+  // Close the file if it is open.
+  base::FileUtilProxy::Close(
+      file_task_runner_, file_handle_,
+      base::Bind(&URLFetcherCore::FileWriter::DeleteFile,
+                 weak_factory_.GetWeakPtr()));
+  file_handle_ = base::kInvalidPlatformFileValue;
+}
+
+void URLFetcherCore::FileWriter::DeleteFile(
+    base::PlatformFileError error_code) {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+  if (file_path_.empty())
+    return;
+
+  base::FileUtilProxy::Delete(
+      file_task_runner_, file_path_,
+      false,  // No need to recurse, as the path is to a file.
+      base::FileUtilProxy::StatusCallback());
+  DisownFile();
+}
+
+void URLFetcherCore::FileWriter::DidCreateFile(
+    const FilePath& file_path,
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle,
+    bool created) {
+  DidCreateFileInternal(file_path, error_code, file_handle);
+}
+
+void URLFetcherCore::FileWriter::DidCreateTempFile(
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle,
+    const FilePath& file_path) {
+  DidCreateFileInternal(file_path, error_code, file_handle);
+}
+
+void URLFetcherCore::FileWriter::DidCreateFileInternal(
+    const FilePath& file_path,
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle) {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+
+  if (base::PLATFORM_FILE_OK != error_code) {
+    error_code_ = error_code;
+    CloseAndDeleteFile();
+    core_->delegate_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
+    return;
+  }
+
+  file_path_ = file_path;
+  file_handle_ = file_handle.ReleaseValue();
+  total_bytes_written_ = 0;
+
+  core_->network_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&URLFetcherCore::StartURLRequestWhenAppropriate, core_));
+}
+
+void URLFetcherCore::FileWriter::DidCloseFile(
+    base::PlatformFileError error_code) {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+
+  if (base::PLATFORM_FILE_OK != error_code) {
+    error_code_ = error_code;
+    CloseAndDeleteFile();
+    core_->delegate_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
+    return;
+  }
+
+  // If the file was successfully closed, then the URL request is complete.
+  core_->RetryOrCompleteUrlFetch();
+}
+
+
+// URLFetcherCore -------------------------------------------------------------
+
+// static
+base::LazyInstance<URLFetcherCore::Registry>
+    URLFetcherCore::g_registry = LAZY_INSTANCE_INITIALIZER;
+
+URLFetcherCore::URLFetcherCore(URLFetcher* fetcher,
+                               const GURL& original_url,
+                               URLFetcher::RequestType request_type,
+                               URLFetcherDelegate* d)
+    : fetcher_(fetcher),
+      original_url_(original_url),
+      request_type_(request_type),
+      delegate_(d),
+      delegate_task_runner_(
+          base::ThreadTaskRunnerHandle::Get()),
+      request_(NULL),
+      load_flags_(LOAD_NORMAL),
+      response_code_(URLFetcher::RESPONSE_CODE_INVALID),
+      buffer_(new IOBuffer(kBufferSize)),
+      url_request_data_key_(NULL),
+      was_fetched_via_proxy_(false),
+      is_chunked_upload_(false),
+      was_cancelled_(false),
+      response_destination_(STRING),
+      stop_on_redirect_(false),
+      stopped_on_redirect_(false),
+      automatically_retry_on_5xx_(true),
+      num_retries_on_5xx_(0),
+      max_retries_on_5xx_(0),
+      num_retries_on_network_changes_(0),
+      max_retries_on_network_changes_(0),
+      current_upload_bytes_(-1),
+      current_response_bytes_(0),
+      total_response_bytes_(-1) {
+  CHECK(original_url_.is_valid());
+}
+
+void URLFetcherCore::Start() {
+  DCHECK(delegate_task_runner_);
+  DCHECK(request_context_getter_) << "We need an URLRequestContext!";
+  if (network_task_runner_) {
+    DCHECK_EQ(network_task_runner_,
+              request_context_getter_->GetNetworkTaskRunner());
+  } else {
+    network_task_runner_ = request_context_getter_->GetNetworkTaskRunner();
+  }
+  DCHECK(network_task_runner_.get()) << "We need an IO task runner";
+
+  network_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+}
+
+void URLFetcherCore::Stop() {
+  if (delegate_task_runner_)  // May be NULL in tests.
+    DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+
+  delegate_ = NULL;
+  fetcher_ = NULL;
+  if (!network_task_runner_.get())
+    return;
+  if (network_task_runner_->RunsTasksOnCurrentThread()) {
+    CancelURLRequest();
+  } else {
+    network_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&URLFetcherCore::CancelURLRequest, this));
+  }
+}
+
+void URLFetcherCore::SetUploadData(const std::string& upload_content_type,
+                                   const std::string& upload_content) {
+  DCHECK(!is_chunked_upload_);
+  upload_content_type_ = upload_content_type;
+  upload_content_ = upload_content;
+}
+
+void URLFetcherCore::SetChunkedUpload(const std::string& content_type) {
+  DCHECK(is_chunked_upload_ ||
+         (upload_content_type_.empty() &&
+          upload_content_.empty()));
+  upload_content_type_ = content_type;
+  upload_content_.clear();
+  is_chunked_upload_ = true;
+}
+
+void URLFetcherCore::AppendChunkToUpload(const std::string& content,
+                                         bool is_last_chunk) {
+  DCHECK(delegate_task_runner_);
+  DCHECK(network_task_runner_.get());
+  network_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&URLFetcherCore::CompleteAddingUploadDataChunk, this, content,
+                 is_last_chunk));
+}
+
+void URLFetcherCore::SetLoadFlags(int load_flags) {
+  load_flags_ = load_flags;
+}
+
+int URLFetcherCore::GetLoadFlags() const {
+  return load_flags_;
+}
+
+void URLFetcherCore::SetReferrer(const std::string& referrer) {
+  referrer_ = referrer;
+}
+
+void URLFetcherCore::SetExtraRequestHeaders(
+    const std::string& extra_request_headers) {
+  extra_request_headers_.Clear();
+  extra_request_headers_.AddHeadersFromString(extra_request_headers);
+}
+
+void URLFetcherCore::AddExtraRequestHeader(const std::string& header_line) {
+  extra_request_headers_.AddHeaderFromString(header_line);
+}
+
+void URLFetcherCore::GetExtraRequestHeaders(
+    HttpRequestHeaders* headers) const {
+  headers->CopyFrom(extra_request_headers_);
+}
+
+void URLFetcherCore::SetRequestContext(
+    URLRequestContextGetter* request_context_getter) {
+  DCHECK(!request_context_getter_);
+  DCHECK(request_context_getter);
+  request_context_getter_ = request_context_getter;
+}
+
+void URLFetcherCore::SetFirstPartyForCookies(
+    const GURL& first_party_for_cookies) {
+  DCHECK(first_party_for_cookies_.is_empty());
+  first_party_for_cookies_ = first_party_for_cookies;
+}
+
+void URLFetcherCore::SetURLRequestUserData(
+    const void* key,
+    const URLFetcher::CreateDataCallback& create_data_callback) {
+  DCHECK(key);
+  DCHECK(!create_data_callback.is_null());
+  url_request_data_key_ = key;
+  url_request_create_data_callback_ = create_data_callback;
+}
+
+void URLFetcherCore::SetStopOnRedirect(bool stop_on_redirect) {
+  stop_on_redirect_ = stop_on_redirect;
+}
+
+void URLFetcherCore::SetAutomaticallyRetryOn5xx(bool retry) {
+  automatically_retry_on_5xx_ = retry;
+}
+
+void URLFetcherCore::SetMaxRetriesOn5xx(int max_retries) {
+  max_retries_on_5xx_ = max_retries;
+}
+
+int URLFetcherCore::GetMaxRetriesOn5xx() const {
+  return max_retries_on_5xx_;
+}
+
+base::TimeDelta URLFetcherCore::GetBackoffDelay() const {
+  return backoff_delay_;
+}
+
+void URLFetcherCore::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
+  max_retries_on_network_changes_ = max_retries;
+}
+
+void URLFetcherCore::SaveResponseToFileAtPath(
+    const FilePath& file_path,
+    scoped_refptr<base::TaskRunner> file_task_runner) {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  file_task_runner_ = file_task_runner;
+  response_destination_ = URLFetcherCore::PERMANENT_FILE;
+  response_destination_file_path_ = file_path;
+}
+
+void URLFetcherCore::SaveResponseToTemporaryFile(
+    scoped_refptr<base::TaskRunner> file_task_runner) {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  file_task_runner_ = file_task_runner;
+  response_destination_ = URLFetcherCore::TEMP_FILE;
+}
+
+#if defined(COBALT)
+void URLFetcherCore::DiscardResponse() {
+  response_destination_ = URLFetcherCore::DISCARD;
+}
+#endif
+
+HttpResponseHeaders* URLFetcherCore::GetResponseHeaders() const {
+  return response_headers_;
+}
+
+// TODO(panayiotis): socket_address_ is written in the IO thread,
+// if this is accessed in the UI thread, this could result in a race.
+// Same for response_headers_ above and was_fetched_via_proxy_ below.
+HostPortPair URLFetcherCore::GetSocketAddress() const {
+  return socket_address_;
+}
+
+bool URLFetcherCore::WasFetchedViaProxy() const {
+  return was_fetched_via_proxy_;
+}
+
+const GURL& URLFetcherCore::GetOriginalURL() const {
+  return original_url_;
+}
+
+const GURL& URLFetcherCore::GetURL() const {
+  return url_;
+}
+
+const URLRequestStatus& URLFetcherCore::GetStatus() const {
+  return status_;
+}
+
+int URLFetcherCore::GetResponseCode() const {
+  return response_code_;
+}
+
+const ResponseCookies& URLFetcherCore::GetCookies() const {
+  return cookies_;
+}
+
+bool URLFetcherCore::FileErrorOccurred(
+    base::PlatformFileError* out_error_code) const {
+
+  // Can't have a file error if no file is being created or written to.
+  if (!file_writer_.get())
+    return false;
+
+  base::PlatformFileError error_code = file_writer_->error_code();
+  if (error_code == base::PLATFORM_FILE_OK)
+    return false;
+
+  *out_error_code = error_code;
+  return true;
+}
+
+void URLFetcherCore::ReceivedContentWasMalformed() {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  if (network_task_runner_.get()) {
+    network_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&URLFetcherCore::NotifyMalformedContent, this));
+  }
+}
+
+bool URLFetcherCore::GetResponseAsString(
+    std::string* out_response_string) const {
+  if (response_destination_ != URLFetcherCore::STRING)
+    return false;
+
+  *out_response_string = data_;
+  UMA_HISTOGRAM_MEMORY_KB("UrlFetcher.StringResponseSize",
+                          (data_.length() / 1024));
+
+  return true;
+}
+
+bool URLFetcherCore::GetResponseAsFilePath(bool take_ownership,
+                                           FilePath* out_response_path) {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  const bool destination_is_file =
+      response_destination_ == URLFetcherCore::TEMP_FILE ||
+      response_destination_ == URLFetcherCore::PERMANENT_FILE;
+  if (!destination_is_file || !file_writer_.get())
+    return false;
+
+  *out_response_path = file_writer_->file_path();
+
+  if (take_ownership) {
+    network_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&URLFetcherCore::DisownFile, this));
+  }
+  return true;
+}
+
+void URLFetcherCore::OnReceivedRedirect(URLRequest* request,
+                                        const GURL& new_url,
+                                        bool* defer_redirect) {
+  DCHECK_EQ(request, request_.get());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  if (stop_on_redirect_) {
+    stopped_on_redirect_ = true;
+    url_ = new_url;
+    response_code_ = request_->GetResponseCode();
+    was_fetched_via_proxy_ = request_->was_fetched_via_proxy();
+    request->Cancel();
+    OnReadCompleted(request, 0);
+  }
+}
+
+void URLFetcherCore::OnResponseStarted(URLRequest* request) {
+  DCHECK_EQ(request, request_.get());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  if (request_->status().is_success()) {
+    response_code_ = request_->GetResponseCode();
+    response_headers_ = request_->response_headers();
+    socket_address_ = request_->GetSocketAddress();
+    was_fetched_via_proxy_ = request_->was_fetched_via_proxy();
+    total_response_bytes_ = request_->GetExpectedContentSize();
+
+#if defined(COBALT)
+    // We update this earlier than OnReadCompleted(), so that the delegate
+    // can know about it if they call GetURL() in any callback.
+    if (!stopped_on_redirect_) {
+      url_ = request_->url();
+    }
+    InformDelegateResponseStarted();
+#endif  // defined(COBALT)
+  }
+
+  ReadResponse();
+}
+
+void URLFetcherCore::OnCertificateRequested(
+    URLRequest* request,
+    SSLCertRequestInfo* cert_request_info) {
+  DCHECK_EQ(request, request_.get());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (g_ignore_certificate_requests) {
+    request->ContinueWithCertificate(NULL);
+  } else {
+    request->Cancel();
+  }
+}
+
+void URLFetcherCore::OnReadCompleted(URLRequest* request,
+                                     int bytes_read) {
+  DCHECK(request == request_);
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+#if !defined(COBALT)
+  if (!stopped_on_redirect_) {
+    url_ = request->url();
+  }
+#endif
+  URLRequestThrottlerManager* throttler_manager =
+      request->context()->throttler_manager();
+  if (throttler_manager) {
+    url_throttler_entry_ = throttler_manager->RegisterRequestUrl(url_);
+  }
+
+  download_data_cache_.reset();
+  bool waiting_on_write = false;
+  do {
+    if (!request_->status().is_success() || bytes_read <= 0)
+      break;
+
+    current_response_bytes_ += bytes_read;
+    InformDelegateDownloadDataIfNecessary(bytes_read);
+
+    if (!WriteBuffer(bytes_read)) {
+      // If WriteBuffer() returns false, we have a pending write to
+      // wait on before reading further.
+      waiting_on_write = true;
+      break;
+    }
+  } while (request_->Read(buffer_, kBufferSize, &bytes_read));
+  InformDelegateDownloadData();
+
+  const URLRequestStatus status = request_->status();
+
+  if (status.is_success())
+    request_->GetResponseCookies(&cookies_);
+
+  // See comments re: HEAD requests in ReadResponse().
+  if ((!status.is_io_pending() && !waiting_on_write) ||
+      (request_type_ == URLFetcher::HEAD)) {
+    status_ = status;
+    ReleaseRequest();
+
+    // If a file is open, close it.
+    if (file_writer_.get()) {
+      // If the file is open, close it.  After closing the file,
+      // RetryOrCompleteUrlFetch() will be called.
+      file_writer_->CloseFileAndCompleteRequest();
+    } else {
+      // Otherwise, complete or retry the URL request directly.
+      RetryOrCompleteUrlFetch();
+    }
+  }
+}
+
+void URLFetcherCore::CancelAll() {
+  g_registry.Get().CancelAll();
+}
+
+int URLFetcherCore::GetNumFetcherCores() {
+  return g_registry.Get().size();
+}
+
+void URLFetcherCore::SetEnableInterceptionForTests(bool enabled) {
+  g_interception_enabled = enabled;
+}
+
+void URLFetcherCore::SetIgnoreCertificateRequests(bool ignored) {
+  g_ignore_certificate_requests = ignored;
+}
+
+URLFetcherCore::~URLFetcherCore() {
+  // |request_| should be NULL.  If not, it's unsafe to delete it here since we
+  // may not be on the IO thread.
+  DCHECK(!request_.get());
+}
+
+void URLFetcherCore::StartOnIOThread() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  switch (response_destination_) {
+    case STRING:
+      StartURLRequestWhenAppropriate();
+      break;
+
+    case PERMANENT_FILE:
+    case TEMP_FILE:
+      DCHECK(file_task_runner_.get())
+          << "Need to set the file task runner.";
+
+      file_writer_.reset(new FileWriter(this, file_task_runner_));
+
+      // If the file is successfully created,
+      // URLFetcherCore::StartURLRequestWhenAppropriate() will be called.
+      switch (response_destination_) {
+        case PERMANENT_FILE:
+          file_writer_->CreateFileAtPath(response_destination_file_path_);
+          break;
+        case TEMP_FILE:
+          file_writer_->CreateTempFile();
+          break;
+        default:
+          NOTREACHED();
+      }
+      break;
+
+#if defined(COBALT)
+    case DISCARD:
+      StartURLRequestWhenAppropriate();
+      break;
+#endif
+
+    default:
+      NOTREACHED();
+  }
+}
+
+void URLFetcherCore::StartURLRequest() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (was_cancelled_) {
+    // Since StartURLRequest() is posted as a *delayed* task, it may
+    // run after the URLFetcher was already stopped.
+    return;
+  }
+
+  DCHECK(request_context_getter_);
+  DCHECK(!request_.get());
+
+  g_registry.Get().AddURLFetcherCore(this);
+  current_response_bytes_ = 0;
+  request_.reset(request_context_getter_->GetURLRequestContext()->CreateRequest(
+      original_url_, this));
+  request_->set_stack_trace(stack_trace_);
+  int flags = request_->load_flags() | load_flags_;
+  if (!g_interception_enabled)
+    flags = flags | LOAD_DISABLE_INTERCEPT;
+
+  if (is_chunked_upload_)
+    request_->EnableChunkedUpload();
+  request_->set_load_flags(flags);
+  request_->set_referrer(referrer_);
+  request_->set_first_party_for_cookies(first_party_for_cookies_.is_empty() ?
+      original_url_ : first_party_for_cookies_);
+  if (url_request_data_key_ && !url_request_create_data_callback_.is_null()) {
+    request_->SetUserData(url_request_data_key_,
+                          url_request_create_data_callback_.Run());
+  }
+
+  switch (request_type_) {
+    case URLFetcher::GET:
+      break;
+
+    case URLFetcher::POST:
+    case URLFetcher::PUT:
+#if !defined(COBALT)
+      // Allow not specifying a content type when uploading ArrayBuffer data.
+      DCHECK(!upload_content_type_.empty());
+#endif
+      request_->set_method(
+          request_type_ == URLFetcher::POST ? "POST" : "PUT");
+      if (!upload_content_type_.empty()) {
+        extra_request_headers_.SetHeader(HttpRequestHeaders::kContentType,
+                                         upload_content_type_);
+      }
+      if (!upload_content_.empty()) {
+        scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
+            upload_content_.data(), upload_content_.size()));
+        request_->set_upload(make_scoped_ptr(
+            UploadDataStream::CreateWithReader(reader.Pass(), 0)));
+      }
+
+      current_upload_bytes_ = -1;
+      // TODO(kinaba): http://crbug.com/118103. Implement upload callback in the
+      //  layer and avoid using timer here.
+      upload_progress_checker_timer_.reset(
+          new base::RepeatingTimer<URLFetcherCore>());
+      upload_progress_checker_timer_->Start(
+          FROM_HERE,
+          base::TimeDelta::FromMilliseconds(kUploadProgressTimerInterval),
+          this,
+          &URLFetcherCore::InformDelegateUploadProgress);
+      break;
+
+    case URLFetcher::HEAD:
+      request_->set_method("HEAD");
+      break;
+
+    case URLFetcher::DELETE_REQUEST:
+      request_->set_method("DELETE");
+      break;
+
+    default:
+      NOTREACHED();
+  }
+
+  if (!extra_request_headers_.IsEmpty())
+    request_->SetExtraRequestHeaders(extra_request_headers_);
+
+  // There might be data left over from a previous request attempt.
+  data_.clear();
+
+  // If we are writing the response to a file, the only caller
+  // of this function should have created it and not written yet.
+  DCHECK(!file_writer_.get() || file_writer_->total_bytes_written() == 0);
+
+  request_->Start();
+}
+
+void URLFetcherCore::StartURLRequestWhenAppropriate() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (was_cancelled_)
+    return;
+
+  DCHECK(request_context_getter_);
+
+  int64 delay = 0LL;
+  if (original_url_throttler_entry_ == NULL) {
+    URLRequestThrottlerManager* manager =
+        request_context_getter_->GetURLRequestContext()->throttler_manager();
+    if (manager) {
+      original_url_throttler_entry_ =
+          manager->RegisterRequestUrl(original_url_);
+    }
+  }
+  if (original_url_throttler_entry_ != NULL) {
+    delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
+        GetBackoffReleaseTime());
+  }
+
+  if (delay == 0) {
+    StartURLRequest();
+  } else {
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
+        base::TimeDelta::FromMilliseconds(delay));
+  }
+}
+
+void URLFetcherCore::CancelURLRequest() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (request_.get()) {
+    request_->Cancel();
+    ReleaseRequest();
+  }
+  // Release the reference to the request context. There could be multiple
+  // references to URLFetcher::Core at this point so it may take a while to
+  // delete the object, but we cannot delay the destruction of the request
+  // context.
+  request_context_getter_ = NULL;
+  first_party_for_cookies_ = GURL();
+  url_request_data_key_ = NULL;
+  url_request_create_data_callback_.Reset();
+  was_cancelled_ = true;
+  file_writer_.reset();
+}
+
+void URLFetcherCore::OnCompletedURLRequest(
+    base::TimeDelta backoff_delay) {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+
+  // Save the status and backoff_delay so that delegates can read it.
+  if (delegate_) {
+    backoff_delay_ = backoff_delay;
+    InformDelegateFetchIsComplete();
+  }
+}
+
+void URLFetcherCore::InformDelegateFetchIsComplete() {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  if (delegate_)
+    delegate_->OnURLFetchComplete(fetcher_);
+}
+
+void URLFetcherCore::NotifyMalformedContent() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  if (url_throttler_entry_ != NULL) {
+    int status_code = response_code_;
+    if (status_code == URLFetcher::RESPONSE_CODE_INVALID) {
+      // The status code will generally be known by the time clients
+      // call the |ReceivedContentWasMalformed()| function (which ends up
+      // calling the current function) but if it's not, we need to assume
+      // the response was successful so that the total failure count
+      // used to calculate exponential back-off goes up.
+      status_code = 200;
+    }
+    url_throttler_entry_->ReceivedContentWasMalformed(status_code);
+  }
+}
+
+void URLFetcherCore::RetryOrCompleteUrlFetch() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  base::TimeDelta backoff_delay;
+
+  // Checks the response from server.
+  if (response_code_ >= 500 ||
+      status_.error() == ERR_TEMPORARILY_THROTTLED) {
+    // When encountering a server error, we will send the request again
+    // after backoff time.
+    ++num_retries_on_5xx_;
+
+    // Note that backoff_delay may be 0 because (a) the
+    // URLRequestThrottlerManager and related code does not
+    // necessarily back off on the first error, (b) it only backs off
+    // on some of the 5xx status codes, (c) not all URLRequestContexts
+    // have a throttler manager.
+    base::TimeTicks backoff_release_time = GetBackoffReleaseTime();
+    backoff_delay = backoff_release_time - base::TimeTicks::Now();
+    if (backoff_delay < base::TimeDelta())
+      backoff_delay = base::TimeDelta();
+
+    if (automatically_retry_on_5xx_ &&
+        num_retries_on_5xx_ <= max_retries_on_5xx_) {
+      StartOnIOThread();
+      return;
+    }
+  } else {
+    backoff_delay = base::TimeDelta();
+  }
+
+  // Retry if the request failed due to network changes.
+  if (status_.error() == ERR_NETWORK_CHANGED &&
+      num_retries_on_network_changes_ < max_retries_on_network_changes_) {
+    ++num_retries_on_network_changes_;
+
+    // Retry soon, after flushing all the current tasks which may include
+    // further network change observers.
+    network_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+    return;
+  }
+
+  request_context_getter_ = NULL;
+  first_party_for_cookies_ = GURL();
+  url_request_data_key_ = NULL;
+  url_request_create_data_callback_.Reset();
+  bool posted = delegate_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&URLFetcherCore::OnCompletedURLRequest, this, backoff_delay));
+
+  // If the delegate message loop does not exist any more, then the delegate
+  // should be gone too.
+  DCHECK(posted || !delegate_);
+}
+
+void URLFetcherCore::ReleaseRequest() {
+#if defined(COBALT)
+  if (upload_progress_checker_timer_) {
+    // The request may have completed too quickly, before the upload
+    // progress checker had a chance to run. Force it to run here.
+    InformDelegateUploadProgress();
+  }
+#endif
+
+  upload_progress_checker_timer_.reset();
+  request_.reset();
+  g_registry.Get().RemoveURLFetcherCore(this);
+}
+
+base::TimeTicks URLFetcherCore::GetBackoffReleaseTime() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (original_url_throttler_entry_) {
+    base::TimeTicks original_url_backoff =
+        original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
+    base::TimeTicks destination_url_backoff;
+    if (url_throttler_entry_ != NULL &&
+        original_url_throttler_entry_ != url_throttler_entry_) {
+      destination_url_backoff =
+          url_throttler_entry_->GetExponentialBackoffReleaseTime();
+    }
+
+    return original_url_backoff > destination_url_backoff ?
+        original_url_backoff : destination_url_backoff;
+  } else {
+    return base::TimeTicks();
+  }
+}
+
+void URLFetcherCore::CompleteAddingUploadDataChunk(
+    const std::string& content, bool is_last_chunk) {
+  if (was_cancelled_) {
+    // Since CompleteAddingUploadDataChunk() is posted as a *delayed* task, it
+    // may run after the URLFetcher was already stopped.
+    return;
+  }
+  DCHECK(is_chunked_upload_);
+  DCHECK(request_.get());
+  DCHECK(!content.empty());
+  request_->AppendChunkToUpload(content.data(),
+                                static_cast<int>(content.length()),
+                                is_last_chunk);
+}
+
+// Return true if the write was done and reading may continue.
+// Return false if the write is pending, and the next read will
+// be done later.
+bool URLFetcherCore::WriteBuffer(int num_bytes) {
+  bool write_complete = false;
+  switch (response_destination_) {
+    case STRING:
+      data_.append(buffer_->data(), num_bytes);
+      write_complete = true;
+      break;
+
+    case PERMANENT_FILE:
+    case TEMP_FILE:
+      file_writer_->WriteBuffer(num_bytes);
+      // WriteBuffer() sends a request the file thread.
+      // The write is not done yet.
+      write_complete = false;
+      break;
+
+#if defined(COBALT)
+    case DISCARD:
+      write_complete = true;
+      break;
+#endif
+
+    default:
+      NOTREACHED();
+  }
+  return write_complete;
+}
+
+void URLFetcherCore::ReadResponse() {
+  // Some servers may treat HEAD requests as GET requests.  To free up the
+  // network connection as soon as possible, signal that the request has
+  // completed immediately, without trying to read any data back (all we care
+  // about is the response code and headers, which we already have).
+  int bytes_read = 0;
+  if (request_->status().is_success() &&
+      (request_type_ != URLFetcher::HEAD))
+    request_->Read(buffer_, kBufferSize, &bytes_read);
+  OnReadCompleted(request_.get(), bytes_read);
+}
+
+void URLFetcherCore::DisownFile() {
+  file_writer_->DisownFile();
+}
+
+#if defined(COBALT)
+
+void URLFetcherCore::InformDelegateResponseStarted() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  DCHECK(request_);
+
+  delegate_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &URLFetcherCore::InformDelegateResponseStartedInDelegateThread,
+          this));
+}
+
+void URLFetcherCore::InformDelegateResponseStartedInDelegateThread() {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  if (delegate_) {
+    delegate_->OnURLFetchResponseStarted(fetcher_);
+  }
+}
+
+#endif  // defined(COBALT)
+
+void URLFetcherCore::InformDelegateUploadProgress() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  if (request_.get()) {
+    int64 current = request_->GetUploadProgress().position();
+    if (current_upload_bytes_ != current) {
+      current_upload_bytes_ = current;
+      int64 total = -1;
+      if (!is_chunked_upload_)
+        total = static_cast<int64>(upload_content_.size());
+      delegate_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(
+              &URLFetcherCore::InformDelegateUploadProgressInDelegateThread,
+              this, current, total));
+    }
+  }
+}
+
+void URLFetcherCore::InformDelegateUploadProgressInDelegateThread(
+    int64 current, int64 total) {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  if (delegate_)
+    delegate_->OnURLFetchUploadProgress(fetcher_, current, total);
+}
+
+void URLFetcherCore::InformDelegateDownloadDataIfNecessary(int bytes_read) {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  if (delegate_ && delegate_->ShouldSendDownloadData() && bytes_read != 0) {
+    if (!download_data_cache_) {
+      download_data_cache_.reset(new std::string);
+      download_data_cache_->reserve(kDownloadCacheSize);
+    }
+    download_data_cache_->resize(download_data_cache_->size() + bytes_read);
+    memcpy(&(*download_data_cache_)[download_data_cache_->size() - bytes_read],
+           buffer_->data(), bytes_read);
+    if (download_data_cache_->size() >= kDownloadCacheSize) {
+      delegate_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(
+              &URLFetcherCore::InformDelegateDownloadDataInDelegateThread, this,
+              base::Passed(&download_data_cache_)));
+    }
+  }
+}
+
+void URLFetcherCore::InformDelegateDownloadData() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  if (delegate_ && delegate_->ShouldSendDownloadData() &&
+      download_data_cache_) {
+    delegate_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&URLFetcherCore::InformDelegateDownloadDataInDelegateThread,
+                   this, base::Passed(&download_data_cache_)));
+  }
+}
+
+void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
+    scoped_ptr<std::string> download_data) {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  if (delegate_) {
+    delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
+  }
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_fetcher_core.h b/src/net/url_request/url_fetcher_core.h
new file mode 100644
index 0000000..ff2c174
--- /dev/null
+++ b/src/net/url_request/url_fetcher_core.h
@@ -0,0 +1,434 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_FETCHER_CORE_H_
+#define NET_URL_REQUEST_URL_FETCHER_CORE_H_
+
+#include <set>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/debug/stack_trace.h"
+#include "base/file_path.h"
+#include "base/lazy_instance.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/platform_file.h"
+#include "base/timer.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/host_port_pair.h"
+#include "net/http/http_request_headers.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_status.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}  // namespace base
+
+namespace net {
+class HttpResponseHeaders;
+class IOBuffer;
+class URLFetcherDelegate;
+class URLRequestContextGetter;
+class URLRequestThrottlerEntryInterface;
+
+class URLFetcherCore
+    : public base::RefCountedThreadSafe<URLFetcherCore>,
+      public URLRequest::Delegate {
+ public:
+  URLFetcherCore(URLFetcher* fetcher,
+                 const GURL& original_url,
+                 URLFetcher::RequestType request_type,
+                 URLFetcherDelegate* d);
+
+  // Starts the load.  It's important that this not happen in the constructor
+  // because it causes the IO thread to begin AddRef()ing and Release()ing
+  // us.  If our caller hasn't had time to fully construct us and take a
+  // reference, the IO thread could interrupt things, run a task, Release()
+  // us, and destroy us, leaving the caller with an already-destroyed object
+  // when construction finishes.
+  void Start();
+
+  // Stops any in-progress load and ensures no callback will happen.  It is
+  // safe to call this multiple times.
+  void Stop();
+
+  // URLFetcher-like functions.
+
+  // For POST requests, set |content_type| to the MIME type of the
+  // content and set |content| to the data to upload.
+  void SetUploadData(const std::string& upload_content_type,
+                     const std::string& upload_content);
+  void SetChunkedUpload(const std::string& upload_content_type);
+  // Adds a block of data to be uploaded in a POST body. This can only be
+  // called after Start().
+  void AppendChunkToUpload(const std::string& data, bool is_last_chunk);
+  // |flags| are flags to apply to the load operation--these should be
+  // one or more of the LOAD_* flags defined in net/base/load_flags.h.
+  void SetLoadFlags(int load_flags);
+  int GetLoadFlags() const;
+  void SetReferrer(const std::string& referrer);
+  void SetExtraRequestHeaders(const std::string& extra_request_headers);
+  void AddExtraRequestHeader(const std::string& header_line);
+  void GetExtraRequestHeaders(HttpRequestHeaders* headers) const;
+  void SetRequestContext(URLRequestContextGetter* request_context_getter);
+  // Set the URL that should be consulted for the third-party cookie
+  // blocking policy.
+  void SetFirstPartyForCookies(const GURL& first_party_for_cookies);
+  // Set the key and data callback that is used when setting the user
+  // data on any URLRequest objects this object creates.
+  void SetURLRequestUserData(
+      const void* key,
+      const URLFetcher::CreateDataCallback& create_data_callback);
+  void SetStopOnRedirect(bool stop_on_redirect);
+  void SetAutomaticallyRetryOn5xx(bool retry);
+  void SetMaxRetriesOn5xx(int max_retries);
+  int GetMaxRetriesOn5xx() const;
+  base::TimeDelta GetBackoffDelay() const;
+  void SetAutomaticallyRetryOnNetworkChanges(int max_retries);
+  void SaveResponseToFileAtPath(
+      const FilePath& file_path,
+      scoped_refptr<base::TaskRunner> file_task_runner);
+  void SaveResponseToTemporaryFile(
+      scoped_refptr<base::TaskRunner> file_task_runner);
+#if defined(COBALT)
+  // Don't save the response.
+  void DiscardResponse();
+#endif
+  HttpResponseHeaders* GetResponseHeaders() const;
+  HostPortPair GetSocketAddress() const;
+  bool WasFetchedViaProxy() const;
+  const GURL& GetOriginalURL() const;
+  const GURL& GetURL() const;
+  const URLRequestStatus& GetStatus() const;
+  int GetResponseCode() const;
+  const ResponseCookies& GetCookies() const;
+  bool FileErrorOccurred(base::PlatformFileError* out_error_code) const;
+  // Reports that the received content was malformed (i.e. failed parsing
+  // or validation).  This makes the throttling logic that does exponential
+  // back-off when servers are having problems treat the current request as
+  // a failure.  Your call to this method will be ignored if your request is
+  // already considered a failure based on the HTTP response code or response
+  // headers.
+  void ReceivedContentWasMalformed();
+  bool GetResponseAsString(std::string* out_response_string) const;
+  bool GetResponseAsFilePath(bool take_ownership,
+                             FilePath* out_response_path);
+
+  // Overridden from URLRequest::Delegate:
+  virtual void OnReceivedRedirect(URLRequest* request,
+                                  const GURL& new_url,
+                                  bool* defer_redirect) OVERRIDE;
+  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+  virtual void OnReadCompleted(URLRequest* request,
+                               int bytes_read) OVERRIDE;
+  virtual void OnCertificateRequested(
+      URLRequest* request,
+      SSLCertRequestInfo* cert_request_info) OVERRIDE;
+
+  URLFetcherDelegate* delegate() const { return delegate_; }
+  static void CancelAll();
+  static int GetNumFetcherCores();
+  static void SetEnableInterceptionForTests(bool enabled);
+  static void SetIgnoreCertificateRequests(bool ignored);
+
+ private:
+  friend class base::RefCountedThreadSafe<URLFetcherCore>;
+
+  // How should the response be stored?
+  enum ResponseDestinationType {
+    STRING,  // Default: In a std::string
+    PERMANENT_FILE,  // Write to a permanent file.
+    TEMP_FILE,  // Write to a temporary file.
+#if defined(COBALT)
+    DISCARD,  // Don't store the response.
+#endif
+  };
+
+  class Registry {
+   public:
+    Registry();
+    ~Registry();
+
+    void AddURLFetcherCore(URLFetcherCore* core);
+    void RemoveURLFetcherCore(URLFetcherCore* core);
+
+    void CancelAll();
+
+    int size() const {
+      return fetchers_.size();
+    }
+
+   private:
+    std::set<URLFetcherCore*> fetchers_;
+
+    DISALLOW_COPY_AND_ASSIGN(Registry);
+  };
+
+  // Class FileWriter encapsulates all state involved in writing
+  // response bytes to a file. It is only used if
+  // |URLFetcherCore::response_destination_| == TEMP_FILE ||
+  // |URLFetcherCore::response_destination_| == PERMANENT_FILE.  Each
+  // instance of FileWriter is owned by a URLFetcherCore, which
+  // manages its lifetime and never transfers ownership. All file operations
+  // happen on |file_task_runner_|.
+  class FileWriter {
+   public:
+    FileWriter(URLFetcherCore* core,
+               scoped_refptr<base::TaskRunner> file_task_runner);
+    ~FileWriter();
+
+    void CreateFileAtPath(const FilePath& file_path);
+    void CreateTempFile();
+
+    // Record |num_bytes_| response bytes in |core_->buffer_| to the file.
+    void WriteBuffer(int num_bytes);
+
+    // Called when a write has been done.  Continues writing if there are
+    // any more bytes to write.  Otherwise, initiates a read in core_.
+    void ContinueWrite(base::PlatformFileError error_code, int bytes_written);
+
+    // Drop ownership of the file at |file_path_|.
+    // This class will not delete it or write to it again.
+    void DisownFile();
+
+    // Close the file if it is open.
+    void CloseFileAndCompleteRequest();
+
+    // Close the file if it is open and then delete it.
+    void CloseAndDeleteFile();
+
+    const FilePath& file_path() const { return file_path_; }
+    int64 total_bytes_written() { return total_bytes_written_; }
+    base::PlatformFileError error_code() const { return error_code_; }
+
+   private:
+    // Callback which gets the result of a permanent file creation.
+    void DidCreateFile(const FilePath& file_path,
+                       base::PlatformFileError error_code,
+                       base::PassPlatformFile file_handle,
+                       bool created);
+    // Callback which gets the result of a temporary file creation.
+    void DidCreateTempFile(base::PlatformFileError error_code,
+                           base::PassPlatformFile file_handle,
+                           const FilePath& file_path);
+    // This method is used to implement DidCreateFile and DidCreateTempFile.
+    void DidCreateFileInternal(const FilePath& file_path,
+                               base::PlatformFileError error_code,
+                               base::PassPlatformFile file_handle);
+
+    // Callback which gets the result of closing the file.
+    void DidCloseFile(base::PlatformFileError error);
+
+    // Callback which gets the result of closing the file. Deletes the file if
+    // it has been created.
+    void DeleteFile(base::PlatformFileError error_code);
+
+    // The URLFetcherCore which instantiated this class.
+    URLFetcherCore* core_;
+
+    // The last error encountered on a file operation.  base::PLATFORM_FILE_OK
+    // if no error occurred.
+    base::PlatformFileError error_code_;
+
+    // Callbacks are created for use with base::FileUtilProxy.
+    base::WeakPtrFactory<URLFetcherCore::FileWriter> weak_factory_;
+
+    // Task runner on which file operations should happen.
+    scoped_refptr<base::TaskRunner> file_task_runner_;
+
+    // Path to the file.  This path is empty when there is no file.
+    FilePath file_path_;
+
+    // Handle to the file.
+    base::PlatformFile file_handle_;
+
+    // We always append to the file.  Track the total number of bytes
+    // written, so that writes know the offset to give.
+    int64 total_bytes_written_;
+
+    // How many bytes did the last Write() try to write?  Needed so
+    // that if not all the bytes get written on a Write(), we can
+    // call Write() again with the rest.
+    int pending_bytes_;
+
+    // When writing, how many bytes from the buffer have been successfully
+    // written so far?
+    int buffer_offset_;
+  };
+
+  virtual ~URLFetcherCore();
+
+  // Wrapper functions that allow us to ensure actions happen on the right
+  // thread.
+  void StartOnIOThread();
+  void StartURLRequest();
+  void StartURLRequestWhenAppropriate();
+  void CancelURLRequest();
+  void OnCompletedURLRequest(base::TimeDelta backoff_delay);
+  void InformDelegateFetchIsComplete();
+  void NotifyMalformedContent();
+  void RetryOrCompleteUrlFetch();
+
+  // Deletes the request, removes it from the registry, and removes the
+  // destruction observer.
+  void ReleaseRequest();
+
+  // Returns the max value of exponential back-off release time for
+  // |original_url_| and |url_|.
+  base::TimeTicks GetBackoffReleaseTime();
+
+  void CompleteAddingUploadDataChunk(const std::string& data,
+                                     bool is_last_chunk);
+
+  // Store the response bytes in |buffer_| in the container indicated by
+  // |response_destination_|. Return true if the write has been
+  // done, and another read can overwrite |buffer_|.  If this function
+  // returns false, it will post a task that will read more bytes once the
+  // write is complete.
+  bool WriteBuffer(int num_bytes);
+
+  // Read response bytes from the request.
+  void ReadResponse();
+
+  // Drop ownership of any file managed by |file_path_|.
+  void DisownFile();
+
+  // Notify Delegate about the progress of upload/download.
+#if defined(COBALT)
+  void InformDelegateResponseStarted();
+  void InformDelegateResponseStartedInDelegateThread();
+#endif  // defined(COBALT)
+  void InformDelegateUploadProgress();
+  void InformDelegateUploadProgressInDelegateThread(int64 current, int64 total);
+  void InformDelegateDownloadDataIfNecessary(int bytes_read);
+  void InformDelegateDownloadData();
+  void InformDelegateDownloadDataInDelegateThread(
+      scoped_ptr<std::string> download_data);
+
+  URLFetcher* fetcher_;              // Corresponding fetcher object
+  GURL original_url_;                // The URL we were asked to fetch
+  GURL url_;                         // The URL we eventually wound up at
+  URLFetcher::RequestType request_type_;  // What type of request is this?
+  URLRequestStatus status_;          // Status of the request
+  URLFetcherDelegate* delegate_;     // Object to notify on completion
+  scoped_refptr<base::SingleThreadTaskRunner> delegate_task_runner_;
+                                     // Task runner for the creating thread.
+  scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
+                                     // Task runner for file access.
+  scoped_refptr<base::TaskRunner> file_task_runner_;
+                                     // Task runner for the thread
+                                     // on which file access happens.
+  scoped_ptr<URLRequest> request_;   // The actual request this wraps
+  int load_flags_;                   // Flags for the load operation
+  int response_code_;                // HTTP status code for the request
+  std::string data_;                 // Results of the request, when we are
+                                     // storing the response as a string.
+  scoped_refptr<IOBuffer> buffer_;   // Read buffer
+  // Caches the data to be sent to the request thread to minimize task posting.
+  scoped_ptr<std::string> download_data_cache_;
+  scoped_refptr<URLRequestContextGetter> request_context_getter_;
+                                     // Cookie/cache info for the request
+  GURL first_party_for_cookies_;     // The first party URL for the request
+  // The user data to add to each newly-created URLRequest.
+  const void* url_request_data_key_;
+  URLFetcher::CreateDataCallback url_request_create_data_callback_;
+  ResponseCookies cookies_;          // Response cookies
+  HttpRequestHeaders extra_request_headers_;
+  scoped_refptr<HttpResponseHeaders> response_headers_;
+  bool was_fetched_via_proxy_;
+  HostPortPair socket_address_;
+
+  std::string upload_content_;       // HTTP POST payload
+  std::string upload_content_type_;  // MIME type of POST payload
+  std::string referrer_;             // HTTP Referer header value
+  bool is_chunked_upload_;           // True if using chunked transfer encoding
+
+  // Used to determine how long to wait before making a request or doing a
+  // retry.
+  //
+  // Both of them can only be accessed on the IO thread.
+  //
+  // We need not only the throttler entry for |original_URL|, but also
+  // the one for |url|. For example, consider the case that URL A
+  // redirects to URL B, for which the server returns a 500
+  // response. In this case, the exponential back-off release time of
+  // URL A won't increase. If we retry without considering the
+  // back-off constraint of URL B, we may send out too many requests
+  // for URL A in a short period of time.
+  //
+  // Both of these will be NULL if
+  // URLRequestContext::throttler_manager() is NULL.
+  scoped_refptr<URLRequestThrottlerEntryInterface>
+      original_url_throttler_entry_;
+  scoped_refptr<URLRequestThrottlerEntryInterface> url_throttler_entry_;
+
+  // True if the URLFetcher has been cancelled.
+  bool was_cancelled_;
+
+  // If writing results to a file, |file_writer_| will manage creation,
+  // writing, and destruction of that file.
+  scoped_ptr<FileWriter> file_writer_;
+
+  // Where should responses be saved?
+  ResponseDestinationType response_destination_;
+
+  // Path to the file where the response is written.
+  FilePath response_destination_file_path_;
+
+  // By default any server-initiated redirects are automatically followed.  If
+  // this flag is set to true, however, a redirect will halt the fetch and call
+  // back to to the delegate immediately.
+  bool stop_on_redirect_;
+  // True when we're actually stopped due to a redirect halted by the above.  We
+  // use this to ensure that |url_| is set to the redirect destination rather
+  // than the originally-fetched URL.
+  bool stopped_on_redirect_;
+
+  // If |automatically_retry_on_5xx_| is false, 5xx responses will be
+  // propagated to the observer, if it is true URLFetcher will automatically
+  // re-execute the request, after the back-off delay has expired.
+  // true by default.
+  bool automatically_retry_on_5xx_;
+  // |num_retries_on_5xx_| indicates how many times we've failed to successfully
+  // fetch this URL due to 5xx responses.  Once this value exceeds the maximum
+  // number of retries specified by the owner URLFetcher instance,
+  // we'll give up.
+  int num_retries_on_5xx_;
+  // Maximum retries allowed when 5xx responses are received.
+  int max_retries_on_5xx_;
+  // Back-off time delay. 0 by default.
+  base::TimeDelta backoff_delay_;
+
+  // The number of retries that have been attempted due to ERR_NETWORK_CHANGED.
+  int num_retries_on_network_changes_;
+  // Maximum retries allowed when the request fails with ERR_NETWORK_CHANGED.
+  // 0 by default.
+  int max_retries_on_network_changes_;
+
+  // Timer to poll the progress of uploading for POST and PUT requests.
+  // When crbug.com/119629 is fixed, scoped_ptr is not necessary here.
+  scoped_ptr<base::RepeatingTimer<URLFetcherCore> >
+      upload_progress_checker_timer_;
+  // Number of bytes sent so far.
+  int64 current_upload_bytes_;
+  // Number of bytes received so far.
+  int64 current_response_bytes_;
+  // Total expected bytes to receive (-1 if it cannot be determined).
+  int64 total_response_bytes_;
+
+  // TODO(willchan): Get rid of this after debugging crbug.com/90971.
+  base::debug::StackTrace stack_trace_;
+
+  static base::LazyInstance<Registry> g_registry;
+
+  DISALLOW_COPY_AND_ASSIGN(URLFetcherCore);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_FETCHER_CORE_H_
diff --git a/src/net/url_request/url_fetcher_delegate.cc b/src/net/url_request/url_fetcher_delegate.cc
new file mode 100644
index 0000000..7759157
--- /dev/null
+++ b/src/net/url_request/url_fetcher_delegate.cc
@@ -0,0 +1,26 @@
+// 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 "net/url_request/url_fetcher_delegate.h"
+
+namespace net {
+
+#if defined(COBALT)
+void URLFetcherDelegate::OnURLFetchResponseStarted(
+    const URLFetcher* source) {}
+#endif  // defined(COBALT)
+
+void URLFetcherDelegate::OnURLFetchDownloadData(
+    const URLFetcher* source, scoped_ptr<std::string> download_data) {}
+
+void URLFetcherDelegate::OnURLFetchUploadProgress(
+    const URLFetcher* source, int64 current, int64 total) {}
+
+bool URLFetcherDelegate::ShouldSendDownloadData() {
+  return false;
+}
+
+URLFetcherDelegate::~URLFetcherDelegate() {}
+
+}  // namespace net
diff --git a/src/net/url_request/url_fetcher_delegate.h b/src/net/url_request/url_fetcher_delegate.h
new file mode 100644
index 0000000..0e643f8
--- /dev/null
+++ b/src/net/url_request/url_fetcher_delegate.h
@@ -0,0 +1,55 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_FETCHER_DELEGATE_H_
+#define NET_URL_REQUEST_URL_FETCHER_DELEGATE_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+class URLFetcher;
+
+// A delegate interface for users of URLFetcher.
+class NET_EXPORT URLFetcherDelegate {
+ public:
+#if defined(COBALT)
+  // This will be called when the response code and headers have been received.
+  virtual void OnURLFetchResponseStarted(const URLFetcher* source);
+#endif  // defined(COBALT)
+
+  // This will be called when the URL has been fetched, successfully or not.
+  // Use accessor methods on |source| to get the results.
+  virtual void OnURLFetchComplete(const URLFetcher* source) = 0;
+
+  // This will be called when some part of the response is read.
+  // |download_data| contains the current bytes received since the last call.
+  // This will be called after ShouldSendDownloadData() and only if the latter
+  // returns true.
+  virtual void OnURLFetchDownloadData(const URLFetcher* source,
+                                      scoped_ptr<std::string> download_data);
+
+  // This indicates if OnURLFetchDownloadData should be called.
+  // This will be called before OnURLFetchDownloadData is called, and only if
+  // this returns true.
+  // Default implementation is false.
+  virtual bool ShouldSendDownloadData();
+
+  // This will be called when uploading of POST or PUT requests proceeded.
+  // |current| denotes the number of bytes sent so far, and |total| is the
+  // total size of uploading data (or -1 if chunked upload is enabled).
+  virtual void OnURLFetchUploadProgress(const URLFetcher* source,
+                                        int64 current, int64 total);
+
+ protected:
+  virtual ~URLFetcherDelegate();
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_FETCHER_DELEGATE_H_
diff --git a/src/net/url_request/url_fetcher_factory.h b/src/net/url_request/url_fetcher_factory.h
new file mode 100644
index 0000000..0c5a5eb
--- /dev/null
+++ b/src/net/url_request/url_fetcher_factory.h
@@ -0,0 +1,29 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_FETCHER_FACTORY_H_
+#define NET_URL_REQUEST_URL_FETCHER_FACTORY_H_
+
+#include "net/url_request/url_fetcher.h"
+
+namespace net {
+class URLFetcherDelegate;
+
+// URLFetcher::Create uses the currently registered Factory to create the
+// URLFetcher. Factory is intended for testing.
+class URLFetcherFactory {
+ public:
+  virtual URLFetcher* CreateURLFetcher(
+      int id,
+      const GURL& url,
+      URLFetcher::RequestType request_type,
+      URLFetcherDelegate* delegate) = 0;
+
+ protected:
+  virtual ~URLFetcherFactory() {}
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_FETCHER_FACTORY_H_
diff --git a/src/net/url_request/url_fetcher_impl.cc b/src/net/url_request/url_fetcher_impl.cc
new file mode 100644
index 0000000..527a195
--- /dev/null
+++ b/src/net/url_request/url_fetcher_impl.cc
@@ -0,0 +1,216 @@
+// 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 "net/url_request/url_fetcher_impl.h"
+
+#include "base/bind.h"
+#include "base/message_loop_proxy.h"
+#include "net/url_request/url_fetcher_core.h"
+#include "net/url_request/url_fetcher_factory.h"
+
+namespace net {
+
+static URLFetcherFactory* g_factory = NULL;
+
+URLFetcherImpl::URLFetcherImpl(const GURL& url,
+                               RequestType request_type,
+                               URLFetcherDelegate* d)
+    : ALLOW_THIS_IN_INITIALIZER_LIST(
+        core_(new URLFetcherCore(this, url, request_type, d))) {
+}
+
+URLFetcherImpl::~URLFetcherImpl() {
+  core_->Stop();
+}
+
+void URLFetcherImpl::SetUploadData(const std::string& upload_content_type,
+                                   const std::string& upload_content) {
+  core_->SetUploadData(upload_content_type, upload_content);
+}
+
+void URLFetcherImpl::SetChunkedUpload(const std::string& content_type) {
+  core_->SetChunkedUpload(content_type);
+}
+
+void URLFetcherImpl::AppendChunkToUpload(const std::string& data,
+                                         bool is_last_chunk) {
+  DCHECK(data.length());
+  core_->AppendChunkToUpload(data, is_last_chunk);
+}
+
+void URLFetcherImpl::SetReferrer(const std::string& referrer) {
+  core_->SetReferrer(referrer);
+}
+
+void URLFetcherImpl::SetLoadFlags(int load_flags) {
+  core_->SetLoadFlags(load_flags);
+}
+
+int URLFetcherImpl::GetLoadFlags() const {
+  return core_->GetLoadFlags();
+}
+
+void URLFetcherImpl::SetExtraRequestHeaders(
+    const std::string& extra_request_headers) {
+  core_->SetExtraRequestHeaders(extra_request_headers);
+}
+
+void URLFetcherImpl::AddExtraRequestHeader(const std::string& header_line) {
+  core_->AddExtraRequestHeader(header_line);
+}
+
+void URLFetcherImpl::GetExtraRequestHeaders(
+    HttpRequestHeaders* headers) const {
+  core_->GetExtraRequestHeaders(headers);
+}
+
+void URLFetcherImpl::SetRequestContext(
+    URLRequestContextGetter* request_context_getter) {
+  core_->SetRequestContext(request_context_getter);
+}
+
+void URLFetcherImpl::SetFirstPartyForCookies(
+    const GURL& first_party_for_cookies) {
+  core_->SetFirstPartyForCookies(first_party_for_cookies);
+}
+
+void URLFetcherImpl::SetURLRequestUserData(
+    const void* key,
+    const CreateDataCallback& create_data_callback) {
+  core_->SetURLRequestUserData(key, create_data_callback);
+}
+
+void URLFetcherImpl::SetStopOnRedirect(bool stop_on_redirect) {
+  core_->SetStopOnRedirect(stop_on_redirect);
+}
+
+void URLFetcherImpl::SetAutomaticallyRetryOn5xx(bool retry) {
+  core_->SetAutomaticallyRetryOn5xx(retry);
+}
+
+void URLFetcherImpl::SetMaxRetriesOn5xx(int max_retries) {
+  core_->SetMaxRetriesOn5xx(max_retries);
+}
+
+int URLFetcherImpl::GetMaxRetriesOn5xx() const {
+  return core_->GetMaxRetriesOn5xx();
+}
+
+
+base::TimeDelta URLFetcherImpl::GetBackoffDelay() const {
+  return core_->GetBackoffDelay();
+}
+
+void URLFetcherImpl::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
+  core_->SetAutomaticallyRetryOnNetworkChanges(max_retries);
+}
+
+void URLFetcherImpl::SaveResponseToFileAtPath(
+    const FilePath& file_path,
+    scoped_refptr<base::TaskRunner> file_task_runner) {
+  core_->SaveResponseToFileAtPath(file_path, file_task_runner);
+}
+
+void URLFetcherImpl::SaveResponseToTemporaryFile(
+    scoped_refptr<base::TaskRunner> file_task_runner) {
+  core_->SaveResponseToTemporaryFile(file_task_runner);
+}
+
+#if defined(COBALT)
+void URLFetcherImpl::DiscardResponse() {
+  core_->DiscardResponse();
+}
+#endif
+
+HttpResponseHeaders* URLFetcherImpl::GetResponseHeaders() const {
+  return core_->GetResponseHeaders();
+}
+
+HostPortPair URLFetcherImpl::GetSocketAddress() const {
+  return core_->GetSocketAddress();
+}
+
+bool URLFetcherImpl::WasFetchedViaProxy() const {
+  return core_->WasFetchedViaProxy();
+}
+
+void URLFetcherImpl::Start() {
+  core_->Start();
+}
+
+const GURL& URLFetcherImpl::GetOriginalURL() const {
+  return core_->GetOriginalURL();
+}
+
+const GURL& URLFetcherImpl::GetURL() const {
+  return core_->GetURL();
+}
+
+const URLRequestStatus& URLFetcherImpl::GetStatus() const {
+  return core_->GetStatus();
+}
+
+int URLFetcherImpl::GetResponseCode() const {
+  return core_->GetResponseCode();
+}
+
+const ResponseCookies& URLFetcherImpl::GetCookies() const {
+  return core_->GetCookies();
+}
+
+bool URLFetcherImpl::FileErrorOccurred(
+    base::PlatformFileError* out_error_code) const {
+  return core_->FileErrorOccurred(out_error_code);
+}
+
+void URLFetcherImpl::ReceivedContentWasMalformed() {
+  core_->ReceivedContentWasMalformed();
+}
+
+bool URLFetcherImpl::GetResponseAsString(
+    std::string* out_response_string) const {
+  return core_->GetResponseAsString(out_response_string);
+}
+
+bool URLFetcherImpl::GetResponseAsFilePath(
+    bool take_ownership,
+    FilePath* out_response_path) const {
+  return core_->GetResponseAsFilePath(take_ownership, out_response_path);
+}
+
+// static
+void URLFetcherImpl::CancelAll() {
+  URLFetcherCore::CancelAll();
+}
+
+// static
+void URLFetcherImpl::SetEnableInterceptionForTests(bool enabled) {
+  URLFetcherCore::SetEnableInterceptionForTests(enabled);
+}
+
+// static
+void URLFetcherImpl::SetIgnoreCertificateRequests(bool ignored) {
+  URLFetcherCore::SetIgnoreCertificateRequests(ignored);
+}
+
+// static
+int URLFetcherImpl::GetNumFetcherCores() {
+  return URLFetcherCore::GetNumFetcherCores();
+}
+
+URLFetcherDelegate* URLFetcherImpl::delegate() const {
+  return core_->delegate();
+}
+
+// static
+URLFetcherFactory* URLFetcherImpl::factory() {
+  return g_factory;
+}
+
+// static
+void URLFetcherImpl::set_factory(URLFetcherFactory* factory) {
+  g_factory = factory;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_fetcher_impl.h b/src/net/url_request/url_fetcher_impl.h
new file mode 100644
index 0000000..5961b80
--- /dev/null
+++ b/src/net/url_request/url_fetcher_impl.h
@@ -0,0 +1,126 @@
+// 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.
+
+// This file contains URLFetcher, a wrapper around URLRequest that handles
+// low-level details like thread safety, ref counting, and incremental buffer
+// reading.  This is useful for callers who simply want to get the data from a
+// URL and don't care about all the nitty-gritty details.
+//
+// NOTE(willchan): Only one "IO" thread is supported for URLFetcher.  This is a
+// temporary situation.  We will work on allowing support for multiple "io"
+// threads per process.
+
+#ifndef NET_URL_REQUEST_URL_FETCHER_IMPL_H_
+#define NET_URL_REQUEST_URL_FETCHER_IMPL_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "net/base/net_export.h"
+#include "net/url_request/url_fetcher.h"
+
+namespace net {
+class URLFetcherCore;
+class URLFetcherDelegate;
+class URLFetcherFactory;
+
+class NET_EXPORT_PRIVATE URLFetcherImpl : public URLFetcher {
+ public:
+  // |url| is the URL to send the request to.
+  // |request_type| is the type of request to make.
+  // |d| the object that will receive the callback on fetch completion.
+  URLFetcherImpl(const GURL& url,
+                 RequestType request_type,
+                 URLFetcherDelegate* d);
+  virtual ~URLFetcherImpl();
+
+  // URLFetcher implementation:
+  virtual void SetUploadData(const std::string& upload_content_type,
+                             const std::string& upload_content) OVERRIDE;
+  virtual void SetChunkedUpload(
+      const std::string& upload_content_type) OVERRIDE;
+  virtual void AppendChunkToUpload(const std::string& data,
+                                   bool is_last_chunk) OVERRIDE;
+  virtual void SetLoadFlags(int load_flags) OVERRIDE;
+  virtual int GetLoadFlags() const OVERRIDE;
+  virtual void SetReferrer(const std::string& referrer) OVERRIDE;
+  virtual void SetExtraRequestHeaders(
+      const std::string& extra_request_headers) OVERRIDE;
+  virtual void AddExtraRequestHeader(const std::string& header_line) OVERRIDE;
+  virtual void GetExtraRequestHeaders(
+      HttpRequestHeaders* headers) const OVERRIDE;
+  virtual void SetRequestContext(
+      URLRequestContextGetter* request_context_getter) OVERRIDE;
+  virtual void SetFirstPartyForCookies(
+      const GURL& first_party_for_cookies) OVERRIDE;
+  virtual void SetURLRequestUserData(
+      const void* key,
+      const CreateDataCallback& create_data_callback) OVERRIDE;
+  virtual void SetStopOnRedirect(bool stop_on_redirect) OVERRIDE;
+  virtual void SetAutomaticallyRetryOn5xx(bool retry) OVERRIDE;
+  virtual void SetMaxRetriesOn5xx(int max_retries) OVERRIDE;
+  virtual int GetMaxRetriesOn5xx() const OVERRIDE;
+  virtual base::TimeDelta GetBackoffDelay() const OVERRIDE;
+  virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) OVERRIDE;
+  virtual void SaveResponseToFileAtPath(
+      const FilePath& file_path,
+      scoped_refptr<base::TaskRunner> file_task_runner) OVERRIDE;
+  virtual void SaveResponseToTemporaryFile(
+      scoped_refptr<base::TaskRunner> file_task_runner) OVERRIDE;
+#if defined(COBALT)
+  virtual void DiscardResponse() OVERRIDE;
+#endif
+  virtual HttpResponseHeaders* GetResponseHeaders() const OVERRIDE;
+  virtual HostPortPair GetSocketAddress() const OVERRIDE;
+  virtual bool WasFetchedViaProxy() const OVERRIDE;
+  virtual void Start() OVERRIDE;
+  virtual const GURL& GetOriginalURL() const OVERRIDE;
+  virtual const GURL& GetURL() const OVERRIDE;
+  virtual const URLRequestStatus& GetStatus() const OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+  virtual const ResponseCookies& GetCookies() const OVERRIDE;
+  virtual bool FileErrorOccurred(
+      base::PlatformFileError* out_error_code) const OVERRIDE;
+  virtual void ReceivedContentWasMalformed() OVERRIDE;
+  virtual bool GetResponseAsString(
+      std::string* out_response_string) const OVERRIDE;
+  virtual bool GetResponseAsFilePath(
+      bool take_ownership,
+      FilePath* out_response_path) const OVERRIDE;
+
+  static void CancelAll();
+
+  static void SetEnableInterceptionForTests(bool enabled);
+  static void SetIgnoreCertificateRequests(bool ignored);
+
+  // TODO(akalin): Make these private again once URLFetcher::Create()
+  // is in net/.
+
+  static URLFetcherFactory* factory();
+
+  // Sets the factory used by the static method Create to create a URLFetcher.
+  // URLFetcher does not take ownership of |factory|. A value of NULL results
+  // in a URLFetcher being created directly.
+  //
+  // NOTE: for safety, this should only be used through ScopedURLFetcherFactory!
+  static void set_factory(URLFetcherFactory* factory);
+
+ protected:
+  // Returns the delegate.
+  URLFetcherDelegate* delegate() const;
+
+ private:
+  friend class URLFetcherTest;
+
+  // Only used by URLFetcherTest, returns the number of URLFetcher::Core objects
+  // actively running.
+  static int GetNumFetcherCores();
+
+  const scoped_refptr<URLFetcherCore> core_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLFetcherImpl);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_FETCHER_IMPL_H_
diff --git a/src/net/url_request/url_fetcher_impl_unittest.cc b/src/net/url_request/url_fetcher_impl_unittest.cc
new file mode 100644
index 0000000..53723e6
--- /dev/null
+++ b/src/net/url_request/url_fetcher_impl_unittest.cc
@@ -0,0 +1,1449 @@
+// 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 "net/url_request/url_fetcher_impl.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "base/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/message_loop_proxy.h"
+#include "base/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "build/build_config.h"
+#include "crypto/nss_util.h"
+#include "net/base/mock_host_resolver.h"
+#include "net/base/network_change_notifier.h"
+#include "net/http/http_response_headers.h"
+#include "net/test/test_server.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_test_util.h"
+#include "net/url_request/url_request_throttler_manager.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#if defined(USE_NSS) || defined(OS_IOS)
+#include "net/ocsp/nss_ocsp.h"
+#endif
+
+namespace net {
+
+using base::Time;
+using base::TimeDelta;
+
+// TODO(eroman): Add a regression test for http://crbug.com/40505.
+
+namespace {
+
+// TODO(akalin): Move all the test data to somewhere under net/.
+const FilePath::CharType kDocRoot[] = FILE_PATH_LITERAL("chrome/test/data");
+const char kTestServerFilePrefix[] = "files/";
+
+class ThrottlingTestURLRequestContext : public TestURLRequestContext {
+ public:
+  ThrottlingTestURLRequestContext() : TestURLRequestContext(true) {
+    set_throttler_manager(&throttler_manager_);
+    Init();
+    DCHECK(throttler_manager() != NULL);
+  }
+
+ private:
+  URLRequestThrottlerManager throttler_manager_;
+};
+
+class ThrottlingTestURLRequestContextGetter
+    : public TestURLRequestContextGetter {
+ public:
+  ThrottlingTestURLRequestContextGetter(
+      base::MessageLoopProxy* io_message_loop_proxy,
+      TestURLRequestContext* request_context)
+      : TestURLRequestContextGetter(io_message_loop_proxy),
+        context_(request_context) {
+  }
+
+  // TestURLRequestContextGetter:
+  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
+    return context_;
+  }
+
+ protected:
+  virtual ~ThrottlingTestURLRequestContextGetter() {}
+
+  TestURLRequestContext* const context_;
+};
+
+}  // namespace
+
+class URLFetcherTest : public testing::Test,
+                       public URLFetcherDelegate {
+ public:
+  URLFetcherTest()
+      : fetcher_(NULL),
+        context_(NULL) {
+  }
+
+  static int GetNumFetcherCores() {
+    return URLFetcherImpl::GetNumFetcherCores();
+  }
+
+  // Creates a URLFetcher, using the program's main thread to do IO.
+  virtual void CreateFetcher(const GURL& url);
+
+  // URLFetcherDelegate:
+  // Subclasses that override this should either call this function or
+  // CleanupAfterFetchComplete() at the end of their processing, depending on
+  // whether they want to check for a non-empty HTTP 200 response or not.
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
+  // Deletes |fetcher| and terminates the message loop.
+  void CleanupAfterFetchComplete();
+
+  scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy() {
+    return io_message_loop_proxy_;
+  }
+
+  TestURLRequestContext* request_context() {
+    return context_.get();
+  }
+
+ protected:
+  // testing::Test:
+  virtual void SetUp() OVERRIDE {
+    testing::Test::SetUp();
+
+    context_.reset(new ThrottlingTestURLRequestContext());
+    io_message_loop_proxy_ = base::MessageLoopProxy::current();
+
+#if defined(USE_NSS) || defined(OS_IOS)
+    crypto::EnsureNSSInit();
+    EnsureNSSHttpIOInit();
+#endif
+  }
+
+  virtual void TearDown() OVERRIDE {
+#if defined(USE_NSS) || defined(OS_IOS)
+    ShutdownNSSHttpIO();
+#endif
+  }
+
+  // URLFetcher is designed to run on the main UI thread, but in our tests
+  // we assume that the current thread is the IO thread where the URLFetcher
+  // dispatches its requests to.  When we wish to simulate being used from
+  // a UI thread, we dispatch a worker thread to do so.
+  scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+
+  URLFetcherImpl* fetcher_;
+  scoped_ptr<TestURLRequestContext> context_;
+};
+
+// A test fixture that uses a MockHostResolver, so that name resolutions can
+// be manipulated by the tests to keep connections in the resolving state.
+class URLFetcherMockDnsTest : public URLFetcherTest {
+ public:
+  // testing::Test:
+  virtual void SetUp() OVERRIDE;
+
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
+ protected:
+  GURL test_url_;
+  scoped_ptr<TestServer> test_server_;
+  MockHostResolver resolver_;
+  scoped_ptr<URLFetcher> completed_fetcher_;
+};
+
+void URLFetcherTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  fetcher_->Start();
+}
+
+void URLFetcherTest::OnURLFetchComplete(const URLFetcher* source) {
+  EXPECT_TRUE(source->GetStatus().is_success());
+  EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
+
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
+  EXPECT_FALSE(data.empty());
+
+  CleanupAfterFetchComplete();
+}
+
+void URLFetcherTest::CleanupAfterFetchComplete() {
+  delete fetcher_;  // Have to delete this here and not in the destructor,
+                    // because the destructor won't necessarily run on the
+                    // same thread that CreateFetcher() did.
+
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  // If the current message loop is not the IO loop, it will be shut down when
+  // the main loop returns and this thread subsequently goes out of scope.
+}
+
+void URLFetcherMockDnsTest::SetUp() {
+  URLFetcherTest::SetUp();
+
+  resolver_.set_ondemand_mode(true);
+  resolver_.rules()->AddRule("example.com", "127.0.0.1");
+
+  context_.reset(new TestURLRequestContext(true));
+  context_->set_host_resolver(&resolver_);
+  context_->Init();
+
+  test_server_.reset(new TestServer(TestServer::TYPE_HTTP,
+                                    TestServer::kLocalhost,
+                                    FilePath(kDocRoot)));
+  ASSERT_TRUE(test_server_->Start());
+
+  // test_server_.GetURL() returns a URL with 127.0.0.1 (kLocalhost), that is
+  // immediately resolved by the MockHostResolver. Use a hostname instead to
+  // trigger an async resolve.
+  test_url_ = GURL(
+      base::StringPrintf("http://example.com:%d/defaultresponse",
+      test_server_->host_port_pair().port()));
+  ASSERT_TRUE(test_url_.is_valid());
+}
+
+void URLFetcherMockDnsTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+}
+
+void URLFetcherMockDnsTest::OnURLFetchComplete(const URLFetcher* source) {
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  ASSERT_EQ(fetcher_, source);
+  EXPECT_EQ(test_url_, source->GetOriginalURL());
+  completed_fetcher_.reset(fetcher_);
+}
+
+namespace {
+
+// Version of URLFetcherTest that does a POST instead
+class URLFetcherPostTest : public URLFetcherTest {
+ public:
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+};
+
+// Version of URLFetcherTest that does a POST instead with empty upload body
+class URLFetcherEmptyPostTest : public URLFetcherTest {
+ public:
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+};
+
+// Version of URLFetcherTest that tests download progress reports.
+class URLFetcherDownloadProgressTest : public URLFetcherTest {
+ public:
+  URLFetcherDownloadProgressTest()
+      : previous_progress_(0),
+        expected_total_(0) {
+  }
+
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
+                                          int64 current,
+                                          int64 total) OVERRIDE;
+
+ protected:
+  // Download progress returned by the previous callback.
+  int64 previous_progress_;
+  // Size of the file being downloaded, known in advance (provided by each test
+  // case).
+  int64 expected_total_;
+};
+
+// Version of URLFetcherTest that tests progress reports at cancellation.
+class URLFetcherDownloadProgressCancelTest : public URLFetcherTest {
+ public:
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
+                                          int64 current,
+                                          int64 total) OVERRIDE;
+ protected:
+  bool cancelled_;
+};
+
+// Version of URLFetcherTest that tests upload progress reports.
+class URLFetcherUploadProgressTest : public URLFetcherTest {
+ public:
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchUploadProgress(const URLFetcher* source,
+                                        int64 current,
+                                        int64 total) OVERRIDE;
+ protected:
+  int64 previous_progress_;
+  std::string chunk_;
+  int64 number_of_chunks_added_;
+};
+
+// Version of URLFetcherTest that tests headers.
+class URLFetcherHeadersTest : public URLFetcherTest {
+ public:
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+};
+
+// Version of URLFetcherTest that tests SocketAddress.
+class URLFetcherSocketAddressTest : public URLFetcherTest {
+ public:
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+ protected:
+  std::string expected_host_;
+  uint16 expected_port_;
+};
+
+// Version of URLFetcherTest that tests stopping on a redirect.
+class URLFetcherStopOnRedirectTest : public URLFetcherTest {
+ public:
+  URLFetcherStopOnRedirectTest();
+  virtual ~URLFetcherStopOnRedirectTest();
+
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
+ protected:
+  // The URL we should be redirected to.
+  static const char* kRedirectTarget;
+
+  bool callback_called_;  // Set to true in OnURLFetchComplete().
+};
+
+// Version of URLFetcherTest that tests overload protection.
+class URLFetcherProtectTest : public URLFetcherTest {
+ public:
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+ private:
+  Time start_time_;
+};
+
+// Version of URLFetcherTest that tests overload protection, when responses
+// passed through.
+class URLFetcherProtectTestPassedThrough : public URLFetcherTest {
+ public:
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+ private:
+  Time start_time_;
+};
+
+// Version of URLFetcherTest that tests bad HTTPS requests.
+class URLFetcherBadHTTPSTest : public URLFetcherTest {
+ public:
+  URLFetcherBadHTTPSTest();
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
+ private:
+  FilePath cert_dir_;
+};
+
+// Version of URLFetcherTest that tests request cancellation on shutdown.
+class URLFetcherCancelTest : public URLFetcherTest {
+ public:
+  // URLFetcherTest:
+  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
+  void CancelRequest();
+};
+
+// Version of TestURLRequestContext that posts a Quit task to the IO
+// thread once it is deleted.
+class CancelTestURLRequestContext : public ThrottlingTestURLRequestContext {
+ public:
+  explicit CancelTestURLRequestContext() {
+  }
+
+ private:
+  virtual ~CancelTestURLRequestContext() {
+    // The d'tor should execute in the IO thread. Post the quit task to the
+    // current thread.
+    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
+};
+
+class CancelTestURLRequestContextGetter
+    : public TestURLRequestContextGetter {
+ public:
+  CancelTestURLRequestContextGetter(
+      base::MessageLoopProxy* io_message_loop_proxy,
+      const GURL& throttle_for_url)
+      : TestURLRequestContextGetter(io_message_loop_proxy),
+        io_message_loop_proxy_(io_message_loop_proxy),
+        context_created_(false, false),
+        throttle_for_url_(throttle_for_url) {
+  }
+
+  // TestURLRequestContextGetter:
+  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
+    if (!context_.get()) {
+      context_.reset(new CancelTestURLRequestContext());
+      DCHECK(context_->throttler_manager());
+
+      // Registers an entry for test url. The backoff time is calculated by:
+      //     new_backoff = 2.0 * old_backoff + 0
+      // The initial backoff is 2 seconds and maximum backoff is 4 seconds.
+      // Maximum retries allowed is set to 2.
+      scoped_refptr<URLRequestThrottlerEntry> entry(
+          new URLRequestThrottlerEntry(
+              context_->throttler_manager(),
+              "", 200, 3, 2000, 2.0, 0.0, 4000));
+      context_->throttler_manager()->OverrideEntryForTests(
+          throttle_for_url_, entry);
+
+      context_created_.Signal();
+    }
+    return context_.get();
+  }
+
+  virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() const {
+    return io_message_loop_proxy_;
+  }
+
+  void WaitForContextCreation() {
+    context_created_.Wait();
+  }
+
+ protected:
+  virtual ~CancelTestURLRequestContextGetter() {}
+
+ private:
+  scoped_ptr<TestURLRequestContext> context_;
+  scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+  base::WaitableEvent context_created_;
+  GURL throttle_for_url_;
+};
+
+// Version of URLFetcherTest that tests retying the same request twice.
+class URLFetcherMultipleAttemptTest : public URLFetcherTest {
+ public:
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+ private:
+  std::string data_;
+};
+
+class URLFetcherFileTest : public URLFetcherTest {
+ public:
+  URLFetcherFileTest() : take_ownership_of_file_(false),
+                         expected_file_error_(base::PLATFORM_FILE_OK) {}
+
+  void CreateFetcherForFile(const GURL& url, const FilePath& file_path);
+  void CreateFetcherForTempFile(const GURL& url);
+
+  // URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
+ protected:
+  FilePath expected_file_;
+  FilePath file_path_;
+
+  // Set by the test. Used in OnURLFetchComplete() to decide if
+  // the URLFetcher should own the temp file, so that we can test
+  // disowning prevents the file from being deleted.
+  bool take_ownership_of_file_;
+
+  // Expected file error code for the test.
+  // PLATFORM_FILE_OK when expecting success.
+  base::PlatformFileError expected_file_error_;
+};
+
+void URLFetcherPostTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  fetcher_->SetUploadData("application/x-www-form-urlencoded",
+                          "bobsyeruncle");
+  fetcher_->Start();
+}
+
+void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source) {
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
+  EXPECT_EQ(std::string("bobsyeruncle"), data);
+  URLFetcherTest::OnURLFetchComplete(source);
+}
+
+void URLFetcherEmptyPostTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
+  fetcher_->SetRequestContext(new TestURLRequestContextGetter(
+      io_message_loop_proxy()));
+  fetcher_->SetUploadData("text/plain", "");
+  fetcher_->Start();
+}
+
+void URLFetcherEmptyPostTest::OnURLFetchComplete(const URLFetcher* source) {
+  EXPECT_TRUE(source->GetStatus().is_success());
+  EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
+
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
+  EXPECT_TRUE(data.empty());
+
+  CleanupAfterFetchComplete();
+  // Do not call the super class method URLFetcherTest::OnURLFetchComplete,
+  // since it expects a non-empty response.
+}
+
+void URLFetcherDownloadProgressTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  fetcher_->Start();
+}
+
+void URLFetcherDownloadProgressTest::OnURLFetchDownloadProgress(
+    const URLFetcher* source, int64 progress, int64 total) {
+  // Increasing between 0 and total.
+  EXPECT_LE(0, progress);
+  EXPECT_GE(total, progress);
+  EXPECT_LE(previous_progress_, progress);
+  EXPECT_EQ(expected_total_, total);
+  previous_progress_ = progress;
+}
+
+void URLFetcherDownloadProgressCancelTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  cancelled_ = false;
+  fetcher_->Start();
+}
+
+void URLFetcherDownloadProgressCancelTest::OnURLFetchDownloadProgress(
+    const URLFetcher* source, int64 current, int64 total) {
+  EXPECT_FALSE(cancelled_);
+  if (!cancelled_) {
+    cancelled_ = true;
+    CleanupAfterFetchComplete();
+  }
+}
+
+void URLFetcherDownloadProgressCancelTest::OnURLFetchComplete(
+    const URLFetcher* source) {
+  // Should have been cancelled.
+  ADD_FAILURE();
+  CleanupAfterFetchComplete();
+}
+
+void URLFetcherUploadProgressTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  previous_progress_ = 0;
+  // Large enough data to require more than one read from UploadDataStream.
+  chunk_.assign(1<<16, 'a');
+  // Use chunked upload to wait for a timer event of progress notification.
+  fetcher_->SetChunkedUpload("application/x-www-form-urlencoded");
+  fetcher_->Start();
+  number_of_chunks_added_ = 1;
+  fetcher_->AppendChunkToUpload(chunk_, false);
+}
+
+void URLFetcherUploadProgressTest::OnURLFetchUploadProgress(
+    const URLFetcher* source, int64 current, int64 total) {
+  // Increasing between 0 and total.
+  EXPECT_LE(0, current);
+  EXPECT_GE(static_cast<int64>(chunk_.size()) * number_of_chunks_added_,
+            current);
+  EXPECT_LE(previous_progress_, current);
+  previous_progress_ = current;
+  EXPECT_EQ(-1, total);
+
+  if (number_of_chunks_added_ < 2) {
+    number_of_chunks_added_ += 1;
+    fetcher_->AppendChunkToUpload(chunk_, true);
+  }
+}
+
+void URLFetcherHeadersTest::OnURLFetchComplete(
+    const URLFetcher* source) {
+  std::string header;
+  EXPECT_TRUE(source->GetResponseHeaders()->GetNormalizedHeader("cache-control",
+                                                                &header));
+  EXPECT_EQ("private", header);
+  URLFetcherTest::OnURLFetchComplete(source);
+}
+
+void URLFetcherSocketAddressTest::OnURLFetchComplete(
+    const URLFetcher* source) {
+  EXPECT_EQ("127.0.0.1", source->GetSocketAddress().host());
+  EXPECT_EQ(expected_port_, source->GetSocketAddress().port());
+  URLFetcherTest::OnURLFetchComplete(source);
+}
+
+// static
+const char* URLFetcherStopOnRedirectTest::kRedirectTarget =
+    "http://redirect.target.com";
+
+URLFetcherStopOnRedirectTest::URLFetcherStopOnRedirectTest()
+    : callback_called_(false) {
+}
+
+URLFetcherStopOnRedirectTest::~URLFetcherStopOnRedirectTest() {
+}
+
+void URLFetcherStopOnRedirectTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  fetcher_->SetStopOnRedirect(true);
+  fetcher_->Start();
+}
+
+void URLFetcherStopOnRedirectTest::OnURLFetchComplete(
+    const URLFetcher* source) {
+  callback_called_ = true;
+  EXPECT_EQ(GURL(kRedirectTarget), source->GetURL());
+  EXPECT_EQ(URLRequestStatus::CANCELED, source->GetStatus().status());
+  EXPECT_EQ(ERR_ABORTED, source->GetStatus().error());
+  EXPECT_EQ(301, source->GetResponseCode());
+  CleanupAfterFetchComplete();
+}
+
+void URLFetcherProtectTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  start_time_ = Time::Now();
+  fetcher_->SetMaxRetriesOn5xx(11);
+  fetcher_->Start();
+}
+
+void URLFetcherProtectTest::OnURLFetchComplete(const URLFetcher* source) {
+  const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
+  if (source->GetResponseCode() >= 500) {
+    // Now running ServerUnavailable test.
+    // It takes more than 1 second to finish all 11 requests.
+    EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
+    EXPECT_TRUE(source->GetStatus().is_success());
+    std::string data;
+    EXPECT_TRUE(source->GetResponseAsString(&data));
+    EXPECT_FALSE(data.empty());
+    CleanupAfterFetchComplete();
+  } else {
+    // Now running Overload test.
+    static int count = 0;
+    count++;
+    if (count < 20) {
+      fetcher_->SetRequestContext(
+          new ThrottlingTestURLRequestContextGetter(
+              io_message_loop_proxy(), request_context()));
+      fetcher_->Start();
+    } else {
+      // We have already sent 20 requests continuously. And we expect that
+      // it takes more than 1 second due to the overload protection settings.
+      EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
+      URLFetcherTest::OnURLFetchComplete(source);
+    }
+  }
+}
+
+void URLFetcherProtectTestPassedThrough::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+  fetcher_->SetAutomaticallyRetryOn5xx(false);
+  start_time_ = Time::Now();
+  fetcher_->SetMaxRetriesOn5xx(11);
+  fetcher_->Start();
+}
+
+void URLFetcherProtectTestPassedThrough::OnURLFetchComplete(
+    const URLFetcher* source) {
+  const TimeDelta one_minute = TimeDelta::FromMilliseconds(60000);
+  if (source->GetResponseCode() >= 500) {
+    // Now running ServerUnavailable test.
+    // It should get here on the first attempt, so almost immediately and
+    // *not* to attempt to execute all 11 requests (2.5 minutes).
+    EXPECT_TRUE(Time::Now() - start_time_ < one_minute);
+    EXPECT_TRUE(source->GetStatus().is_success());
+    // Check that suggested back off time is bigger than 0.
+    EXPECT_GT(fetcher_->GetBackoffDelay().InMicroseconds(), 0);
+    std::string data;
+    EXPECT_TRUE(source->GetResponseAsString(&data));
+    EXPECT_FALSE(data.empty());
+  } else {
+    // We should not get here!
+    ADD_FAILURE();
+  }
+
+  CleanupAfterFetchComplete();
+}
+
+
+URLFetcherBadHTTPSTest::URLFetcherBadHTTPSTest() {
+  PathService::Get(base::DIR_SOURCE_ROOT, &cert_dir_);
+  cert_dir_ = cert_dir_.AppendASCII("chrome");
+  cert_dir_ = cert_dir_.AppendASCII("test");
+  cert_dir_ = cert_dir_.AppendASCII("data");
+  cert_dir_ = cert_dir_.AppendASCII("ssl");
+  cert_dir_ = cert_dir_.AppendASCII("certificates");
+}
+
+// The "server certificate expired" error should result in automatic
+// cancellation of the request by
+// URLRequest::Delegate::OnSSLCertificateError.
+void URLFetcherBadHTTPSTest::OnURLFetchComplete(
+    const URLFetcher* source) {
+  // This part is different from URLFetcherTest::OnURLFetchComplete
+  // because this test expects the request to be cancelled.
+  EXPECT_EQ(URLRequestStatus::CANCELED, source->GetStatus().status());
+  EXPECT_EQ(ERR_ABORTED, source->GetStatus().error());
+  EXPECT_EQ(-1, source->GetResponseCode());
+  EXPECT_TRUE(source->GetCookies().empty());
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
+  EXPECT_TRUE(data.empty());
+  CleanupAfterFetchComplete();
+}
+
+void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  CancelTestURLRequestContextGetter* context_getter =
+      new CancelTestURLRequestContextGetter(io_message_loop_proxy(),
+                                            url);
+  fetcher_->SetRequestContext(context_getter);
+  fetcher_->SetMaxRetriesOn5xx(2);
+  fetcher_->Start();
+  // We need to wait for the creation of the URLRequestContext, since we
+  // rely on it being destroyed as a signal to end the test.
+  context_getter->WaitForContextCreation();
+  CancelRequest();
+}
+
+void URLFetcherCancelTest::OnURLFetchComplete(
+    const URLFetcher* source) {
+  // We should have cancelled the request before completion.
+  ADD_FAILURE();
+  CleanupAfterFetchComplete();
+}
+
+void URLFetcherCancelTest::CancelRequest() {
+  delete fetcher_;
+  // The URLFetcher's test context will post a Quit task once it is
+  // deleted. So if this test simply hangs, it means cancellation
+  // did not work.
+}
+
+void URLFetcherMultipleAttemptTest::OnURLFetchComplete(
+    const URLFetcher* source) {
+  EXPECT_TRUE(source->GetStatus().is_success());
+  EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
+  EXPECT_FALSE(data.empty());
+  if (!data.empty() && data_.empty()) {
+    data_ = data;
+    fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+        io_message_loop_proxy(), request_context()));
+    fetcher_->Start();
+  } else {
+    EXPECT_EQ(data, data_);
+    CleanupAfterFetchComplete();
+  }
+}
+
+void URLFetcherFileTest::CreateFetcherForFile(const GURL& url,
+                                              const FilePath& file_path) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+
+  // Use the IO message loop to do the file operations in this test.
+  fetcher_->SaveResponseToFileAtPath(file_path, io_message_loop_proxy());
+  fetcher_->Start();
+}
+
+void URLFetcherFileTest::CreateFetcherForTempFile(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy(), request_context()));
+
+  // Use the IO message loop to do the file operations in this test.
+  fetcher_->SaveResponseToTemporaryFile(io_message_loop_proxy());
+  fetcher_->Start();
+}
+
+void URLFetcherFileTest::OnURLFetchComplete(const URLFetcher* source) {
+  if (expected_file_error_ == base::PLATFORM_FILE_OK) {
+    EXPECT_TRUE(source->GetStatus().is_success());
+    EXPECT_EQ(source->GetResponseCode(), 200);
+
+    base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
+    EXPECT_FALSE(fetcher_->FileErrorOccurred(&error_code));
+
+    EXPECT_TRUE(source->GetResponseAsFilePath(
+        take_ownership_of_file_, &file_path_));
+
+    EXPECT_TRUE(file_util::ContentsEqual(expected_file_, file_path_));
+  } else {
+    base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
+    EXPECT_TRUE(fetcher_->FileErrorOccurred(&error_code));
+    EXPECT_EQ(expected_file_error_, error_code);
+  }
+  CleanupAfterFetchComplete();
+}
+
+TEST_F(URLFetcherTest, SameThreadsTest) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Create the fetcher on the main thread.  Since IO will happen on the main
+  // thread, this will test URLFetcher's ability to do everything on one
+  // thread.
+  CreateFetcher(test_server.GetURL("defaultresponse"));
+
+  MessageLoop::current()->Run();
+}
+
+#if defined(OS_MACOSX)
+// SIGSEGV on Mac: http://crbug.com/60426
+TEST_F(URLFetcherTest, DISABLED_DifferentThreadsTest) {
+#else
+TEST_F(URLFetcherTest, DifferentThreadsTest) {
+#endif
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Create a separate thread that will create the URLFetcher.  The current
+  // (main) thread will do the IO, and when the fetch is complete it will
+  // terminate the main thread's message loop; then the other thread's
+  // message loop will be shut down automatically as the thread goes out of
+  // scope.
+  base::Thread t("URLFetcher test thread");
+  ASSERT_TRUE(t.Start());
+  t.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLFetcherTest::CreateFetcher,
+                 base::Unretained(this),
+                 test_server.GetURL("defaultresponse")));
+
+  MessageLoop::current()->Run();
+}
+
+void CancelAllOnIO() {
+  EXPECT_EQ(1, URLFetcherTest::GetNumFetcherCores());
+  URLFetcherImpl::CancelAll();
+  EXPECT_EQ(0, URLFetcherTest::GetNumFetcherCores());
+}
+
+// Tests to make sure CancelAll() will successfully cancel existing URLFetchers.
+TEST_F(URLFetcherTest, CancelAll) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+  EXPECT_EQ(0, GetNumFetcherCores());
+
+  CreateFetcher(test_server.GetURL("defaultresponse"));
+  io_message_loop_proxy()->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&CancelAllOnIO),
+      MessageLoop::QuitClosure());
+  MessageLoop::current()->Run();
+  EXPECT_EQ(0, GetNumFetcherCores());
+  delete fetcher_;
+}
+
+TEST_F(URLFetcherMockDnsTest, DontRetryOnNetworkChangedByDefault) {
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
+
+  // This posts a task to start the fetcher.
+  CreateFetcher(test_url_);
+  fetcher_->Start();
+  EXPECT_EQ(0, GetNumFetcherCores());
+  MessageLoop::current()->RunUntilIdle();
+
+  // The fetcher is now running, but is pending the host resolve.
+  EXPECT_EQ(1, GetNumFetcherCores());
+  EXPECT_TRUE(resolver_.has_pending_requests());
+  ASSERT_FALSE(completed_fetcher_);
+
+  // A network change notification aborts the connect job.
+  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
+  ASSERT_TRUE(completed_fetcher_);
+
+  // And the owner of the fetcher gets the ERR_NETWORK_CHANGED error.
+  EXPECT_EQ(ERR_NETWORK_CHANGED, completed_fetcher_->GetStatus().error());
+}
+
+TEST_F(URLFetcherMockDnsTest, RetryOnNetworkChangedAndFail) {
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
+
+  // This posts a task to start the fetcher.
+  CreateFetcher(test_url_);
+  fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
+  fetcher_->Start();
+  EXPECT_EQ(0, GetNumFetcherCores());
+  MessageLoop::current()->RunUntilIdle();
+
+  // The fetcher is now running, but is pending the host resolve.
+  EXPECT_EQ(1, GetNumFetcherCores());
+  EXPECT_TRUE(resolver_.has_pending_requests());
+  ASSERT_FALSE(completed_fetcher_);
+
+  // Make it fail 3 times.
+  for (int i = 0; i < 3; ++i) {
+    // A network change notification aborts the connect job.
+    NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+    MessageLoop::current()->RunUntilIdle();
+
+    // But the fetcher retries automatically.
+    EXPECT_EQ(1, GetNumFetcherCores());
+    EXPECT_TRUE(resolver_.has_pending_requests());
+    ASSERT_FALSE(completed_fetcher_);
+  }
+
+  // A 4th failure doesn't trigger another retry, and propagates the error
+  // to the owner of the fetcher.
+  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
+  ASSERT_TRUE(completed_fetcher_);
+
+  // And the owner of the fetcher gets the ERR_NETWORK_CHANGED error.
+  EXPECT_EQ(ERR_NETWORK_CHANGED, completed_fetcher_->GetStatus().error());
+}
+
+TEST_F(URLFetcherMockDnsTest, RetryOnNetworkChangedAndSucceed) {
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
+
+  // This posts a task to start the fetcher.
+  CreateFetcher(test_url_);
+  fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
+  fetcher_->Start();
+  EXPECT_EQ(0, GetNumFetcherCores());
+  MessageLoop::current()->RunUntilIdle();
+
+  // The fetcher is now running, but is pending the host resolve.
+  EXPECT_EQ(1, GetNumFetcherCores());
+  EXPECT_TRUE(resolver_.has_pending_requests());
+  ASSERT_FALSE(completed_fetcher_);
+
+  // Make it fail 3 times.
+  for (int i = 0; i < 3; ++i) {
+    // A network change notification aborts the connect job.
+    NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+    MessageLoop::current()->RunUntilIdle();
+
+    // But the fetcher retries automatically.
+    EXPECT_EQ(1, GetNumFetcherCores());
+    EXPECT_TRUE(resolver_.has_pending_requests());
+    ASSERT_FALSE(completed_fetcher_);
+  }
+
+  // Now let it succeed by resolving the pending request.
+  resolver_.ResolveAllPending();
+  MessageLoop::current()->Run();
+
+  // URLFetcherMockDnsTest::OnURLFetchComplete() will quit the loop.
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
+  ASSERT_TRUE(completed_fetcher_);
+
+  // This time the request succeeded.
+  EXPECT_EQ(OK, completed_fetcher_->GetStatus().error());
+  EXPECT_EQ(200, completed_fetcher_->GetResponseCode());
+}
+
+#if defined(OS_MACOSX)
+// SIGSEGV on Mac: http://crbug.com/60426
+TEST_F(URLFetcherPostTest, DISABLED_Basic) {
+#else
+TEST_F(URLFetcherPostTest, Basic) {
+#endif
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  CreateFetcher(test_server.GetURL("echo"));
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherEmptyPostTest, Basic) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  CreateFetcher(test_server.GetURL("echo"));
+  MessageLoop::current()->Run();
+}
+
+#if defined(OS_MACOSX)
+// SIGSEGV on Mac: http://crbug.com/60426
+TEST_F(URLFetcherUploadProgressTest, DISABLED_Basic) {
+#else
+TEST_F(URLFetcherUploadProgressTest, Basic) {
+#endif
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  CreateFetcher(test_server.GetURL("echo"));
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherDownloadProgressTest, Basic) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a file large enough to require more than one read into
+  // URLFetcher::Core's IOBuffer.
+  static const char kFileToFetch[] = "animate1.gif";
+  // Hardcoded file size - it cannot be easily fetched when a remote http server
+  // is used for testing.
+  static const int64 kFileSize = 19021;
+
+  expected_total_ = kFileSize;
+
+  CreateFetcher(test_server.GetURL(
+      std::string(kTestServerFilePrefix) + kFileToFetch));
+
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherDownloadProgressCancelTest, CancelWhileProgressReport) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a file large enough to require more than one read into
+  // URLFetcher::Core's IOBuffer.
+  static const char kFileToFetch[] = "animate1.gif";
+  CreateFetcher(test_server.GetURL(
+      std::string(kTestServerFilePrefix) + kFileToFetch));
+
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherHeadersTest, Headers) {
+  TestServer test_server(
+      TestServer::TYPE_HTTP,
+      TestServer::kLocalhost,
+      FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  ASSERT_TRUE(test_server.Start());
+
+  CreateFetcher(test_server.GetURL("files/with-headers.html"));
+  MessageLoop::current()->Run();
+  // The actual tests are in the URLFetcherHeadersTest fixture.
+}
+
+TEST_F(URLFetcherSocketAddressTest, SocketAddress) {
+  TestServer test_server(
+      TestServer::TYPE_HTTP,
+      TestServer::kLocalhost,
+      FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  ASSERT_TRUE(test_server.Start());
+  expected_port_ = test_server.host_port_pair().port();
+
+  // Reusing "with-headers.html" but doesn't really matter.
+  CreateFetcher(test_server.GetURL("files/with-headers.html"));
+  MessageLoop::current()->Run();
+  // The actual tests are in the URLFetcherSocketAddressTest fixture.
+}
+
+TEST_F(URLFetcherStopOnRedirectTest, StopOnRedirect) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  CreateFetcher(
+      test_server.GetURL(std::string("server-redirect?") + kRedirectTarget));
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(callback_called_);
+}
+
+TEST_F(URLFetcherProtectTest, Overload) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  GURL url(test_server.GetURL("defaultresponse"));
+
+  // Registers an entry for test url. It only allows 3 requests to be sent
+  // in 200 milliseconds.
+  scoped_refptr<URLRequestThrottlerEntry> entry(
+      new URLRequestThrottlerEntry(
+          request_context()->throttler_manager(),
+          "", 200, 3, 1, 2.0, 0.0, 256));
+  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+
+  CreateFetcher(url);
+
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherProtectTest, ServerUnavailable) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  GURL url(test_server.GetURL("files/server-unavailable.html"));
+
+  // Registers an entry for test url. The backoff time is calculated by:
+  //     new_backoff = 2.0 * old_backoff + 0
+  // and maximum backoff time is 256 milliseconds.
+  // Maximum retries allowed is set to 11.
+  scoped_refptr<URLRequestThrottlerEntry> entry(
+      new URLRequestThrottlerEntry(
+          request_context()->throttler_manager(),
+          "", 200, 3, 1, 2.0, 0.0, 256));
+  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+
+  CreateFetcher(url);
+
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherProtectTestPassedThrough, ServerUnavailablePropagateResponse) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  GURL url(test_server.GetURL("files/server-unavailable.html"));
+
+  // Registers an entry for test url. The backoff time is calculated by:
+  //     new_backoff = 2.0 * old_backoff + 0
+  // and maximum backoff time is 150000 milliseconds.
+  // Maximum retries allowed is set to 11.
+  scoped_refptr<URLRequestThrottlerEntry> entry(
+      new URLRequestThrottlerEntry(
+          request_context()->throttler_manager(),
+          "", 200, 3, 100, 2.0, 0.0, 150000));
+  // Total time if *not* for not doing automatic backoff would be 150s.
+  // In reality it should be "as soon as server responds".
+  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+
+  CreateFetcher(url);
+
+  MessageLoop::current()->Run();
+}
+
+#if defined(OS_MACOSX)
+// SIGSEGV on Mac: http://crbug.com/60426
+TEST_F(URLFetcherBadHTTPSTest, DISABLED_BadHTTPSTest) {
+#else
+TEST_F(URLFetcherBadHTTPSTest, BadHTTPSTest) {
+#endif
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_EXPIRED);
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  CreateFetcher(test_server.GetURL("defaultresponse"));
+  MessageLoop::current()->Run();
+}
+
+#if defined(OS_MACOSX)
+// SIGSEGV on Mac: http://crbug.com/60426
+TEST_F(URLFetcherCancelTest, DISABLED_ReleasesContext) {
+#else
+TEST_F(URLFetcherCancelTest, ReleasesContext) {
+#endif
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  GURL url(test_server.GetURL("files/server-unavailable.html"));
+
+  // Create a separate thread that will create the URLFetcher.  The current
+  // (main) thread will do the IO, and when the fetch is complete it will
+  // terminate the main thread's message loop; then the other thread's
+  // message loop will be shut down automatically as the thread goes out of
+  // scope.
+  base::Thread t("URLFetcher test thread");
+  ASSERT_TRUE(t.Start());
+  t.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLFetcherCancelTest::CreateFetcher,
+                 base::Unretained(this), url));
+
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherCancelTest, CancelWhileDelayedStartTaskPending) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  GURL url(test_server.GetURL("files/server-unavailable.html"));
+
+  // Register an entry for test url.
+  // Using a sliding window of 4 seconds, and max of 1 request, under a fast
+  // run we expect to have a 4 second delay when posting the Start task.
+  scoped_refptr<URLRequestThrottlerEntry> entry(
+      new URLRequestThrottlerEntry(
+          request_context()->throttler_manager(),
+          "", 4000, 1, 2000, 2.0, 0.0, 4000));
+  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+  // Fake that a request has just started.
+  entry->ReserveSendingTimeForNextRequest(base::TimeTicks());
+
+  // The next request we try to send will be delayed by ~4 seconds.
+  // The slower the test runs, the less the delay will be (since it takes the
+  // time difference from now).
+
+  base::Thread t("URLFetcher test thread");
+  ASSERT_TRUE(t.Start());
+  t.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLFetcherTest::CreateFetcher, base::Unretained(this), url));
+
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherMultipleAttemptTest, SameData) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Create the fetcher on the main thread.  Since IO will happen on the main
+  // thread, this will test URLFetcher's ability to do everything on one
+  // thread.
+  CreateFetcher(test_server.GetURL("defaultresponse"));
+
+  MessageLoop::current()->Run();
+}
+
+TEST_F(URLFetcherFileTest, SmallGet) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  // Get a small file.
+  static const char kFileToFetch[] = "simple.html";
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForFile(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      temp_dir.path().AppendASCII(kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  ASSERT_FALSE(file_util::PathExists(file_path_))
+      << file_path_.value() << " not removed.";
+}
+
+TEST_F(URLFetcherFileTest, LargeGet) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  // Get a file large enough to require more than one read into
+  // URLFetcher::Core's IOBuffer.
+  static const char kFileToFetch[] = "animate1.gif";
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForFile(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      temp_dir.path().AppendASCII(kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+}
+
+TEST_F(URLFetcherFileTest, CanTakeOwnershipOfFile) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  // Get a small file.
+  static const char kFileToFetch[] = "simple.html";
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForFile(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      temp_dir.path().AppendASCII(kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  MessageLoop::current()->RunUntilIdle();
+  ASSERT_FALSE(file_util::PathExists(file_path_))
+      << file_path_.value() << " not removed.";
+}
+
+
+TEST_F(URLFetcherFileTest, OverwriteExistingFile) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  // Create a file before trying to fetch.
+  static const char kFileToFetch[] = "simple.html";
+  static const char kData[] = "abcdefghijklmnopqrstuvwxyz";
+  file_path_ = temp_dir.path().AppendASCII(kFileToFetch);
+  const int data_size = arraysize(kData);
+  ASSERT_EQ(file_util::WriteFile(file_path_, kData, data_size), data_size);
+  ASSERT_TRUE(file_util::PathExists(file_path_));
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  ASSERT_FALSE(file_util::ContentsEqual(file_path_, expected_file_));
+
+  // Get a small file.
+  CreateFetcherForFile(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      file_path_);
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+}
+
+TEST_F(URLFetcherFileTest, TryToOverwriteDirectory) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  // Create a directory before trying to fetch.
+  static const char kFileToFetch[] = "simple.html";
+  file_path_ = temp_dir.path().AppendASCII(kFileToFetch);
+  ASSERT_TRUE(file_util::CreateDirectory(file_path_));
+  ASSERT_TRUE(file_util::PathExists(file_path_));
+
+  // Get a small file.
+  expected_file_error_ = base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForFile(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      file_path_);
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  MessageLoop::current()->RunUntilIdle();
+}
+
+TEST_F(URLFetcherFileTest, SmallGetToTempFile) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a small file.
+  static const char kFileToFetch[] = "simple.html";
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForTempFile(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  ASSERT_FALSE(file_util::PathExists(file_path_))
+      << file_path_.value() << " not removed.";
+}
+
+TEST_F(URLFetcherFileTest, LargeGetToTempFile) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a file large enough to require more than one read into
+  // URLFetcher::Core's IOBuffer.
+  static const char kFileToFetch[] = "animate1.gif";
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForTempFile(test_server.GetURL(
+      std::string(kTestServerFilePrefix) + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+}
+
+TEST_F(URLFetcherFileTest, CanTakeOwnershipOfTempFile) {
+  TestServer test_server(TestServer::TYPE_HTTP,
+                         TestServer::kLocalhost,
+                         FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a small file.
+  static const char kFileToFetch[] = "simple.html";
+  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForTempFile(test_server.GetURL(
+      std::string(kTestServerFilePrefix) + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  MessageLoop::current()->RunUntilIdle();
+  ASSERT_FALSE(file_util::PathExists(file_path_))
+      << file_path_.value() << " not removed.";
+}
+
+}  // namespace
+
+}  // namespace net
diff --git a/src/net/url_request/url_request.cc b/src/net/url_request/url_request.cc
new file mode 100644
index 0000000..735a34d
--- /dev/null
+++ b/src/net/url_request/url_request.cc
@@ -0,0 +1,984 @@
+// 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 "net/url_request/url_request.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/debug/stack_trace.h"
+#include "base/lazy_instance.h"
+#include "base/memory/singleton.h"
+#include "base/message_loop.h"
+#include "base/metrics/stats_counters.h"
+#include "base/stl_util.h"
+#include "base/synchronization/lock.h"
+#include "net/base/auth.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/load_flags.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_log.h"
+#include "net/base/network_change_notifier.h"
+#include "net/base/network_delegate.h"
+#include "net/base/ssl_cert_request_info.h"
+#include "net/base/upload_data_stream.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_util.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_manager.h"
+#include "net/url_request/url_request_netlog_params.h"
+#include "net/url_request/url_request_redirect_job.h"
+
+using base::Time;
+using std::string;
+
+namespace net {
+
+namespace {
+
+// Max number of http redirects to follow.  Same number as gecko.
+const int kMaxRedirects = 20;
+
+// Discard headers which have meaning in POST (Content-Length, Content-Type,
+// Origin).
+void StripPostSpecificHeaders(HttpRequestHeaders* headers) {
+  // These are headers that may be attached to a POST.
+  headers->RemoveHeader(HttpRequestHeaders::kContentLength);
+  headers->RemoveHeader(HttpRequestHeaders::kContentType);
+  headers->RemoveHeader(HttpRequestHeaders::kOrigin);
+}
+
+// TODO(battre): Delete this, see http://crbug.com/89321:
+// This counter keeps track of the identifiers used for URL requests so far.
+// 0 is reserved to represent an invalid ID.
+uint64 g_next_url_request_identifier = 1;
+
+// This lock protects g_next_url_request_identifier.
+base::LazyInstance<base::Lock>::Leaky
+    g_next_url_request_identifier_lock = LAZY_INSTANCE_INITIALIZER;
+
+// Returns an prior unused identifier for URL requests.
+uint64 GenerateURLRequestIdentifier() {
+  base::AutoLock lock(g_next_url_request_identifier_lock.Get());
+  return g_next_url_request_identifier++;
+}
+
+// True once the first URLRequest was started.
+bool g_url_requests_started = false;
+
+// True if cookies are accepted by default.
+bool g_default_can_use_cookies = true;
+
+}  // namespace
+
+URLRequest::ProtocolFactory*
+URLRequest::Deprecated::RegisterProtocolFactory(const std::string& scheme,
+                                                ProtocolFactory* factory) {
+  return URLRequest::RegisterProtocolFactory(scheme, factory);
+}
+
+void URLRequest::Deprecated::RegisterRequestInterceptor(
+    Interceptor* interceptor) {
+  URLRequest::RegisterRequestInterceptor(interceptor);
+}
+
+void URLRequest::Deprecated::UnregisterRequestInterceptor(
+    Interceptor* interceptor) {
+  URLRequest::UnregisterRequestInterceptor(interceptor);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// URLRequest::Interceptor
+
+URLRequestJob* URLRequest::Interceptor::MaybeInterceptRedirect(
+    URLRequest* request,
+    NetworkDelegate* network_delegate,
+    const GURL& location) {
+  return NULL;
+}
+
+URLRequestJob* URLRequest::Interceptor::MaybeInterceptResponse(
+    URLRequest* request, NetworkDelegate* network_delegate) {
+  return NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// URLRequest::Delegate
+
+void URLRequest::Delegate::OnReceivedRedirect(URLRequest* request,
+                                              const GURL& new_url,
+                                              bool* defer_redirect) {
+}
+
+void URLRequest::Delegate::OnAuthRequired(URLRequest* request,
+                                          AuthChallengeInfo* auth_info) {
+  request->CancelAuth();
+}
+
+void URLRequest::Delegate::OnCertificateRequested(
+    URLRequest* request,
+    SSLCertRequestInfo* cert_request_info) {
+  request->Cancel();
+}
+
+void URLRequest::Delegate::OnSSLCertificateError(URLRequest* request,
+                                                 const SSLInfo& ssl_info,
+                                                 bool is_hsts_ok) {
+  request->Cancel();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// URLRequest
+
+// TODO(shalev): Get rid of this constructor in favour of the one below it.
+URLRequest::URLRequest(const GURL& url,
+                       Delegate* delegate,
+                       const URLRequestContext* context)
+    : context_(context),
+      network_delegate_(context->network_delegate()),
+      net_log_(BoundNetLog::Make(context->net_log(),
+                                 NetLog::SOURCE_URL_REQUEST)),
+      url_chain_(1, url),
+      method_("GET"),
+      referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
+      load_flags_(LOAD_NORMAL),
+      delegate_(delegate),
+      is_pending_(false),
+      is_redirecting_(false),
+      redirect_limit_(kMaxRedirects),
+      priority_(LOWEST),
+      identifier_(GenerateURLRequestIdentifier()),
+      blocked_on_delegate_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(before_request_callback_(
+          base::Bind(&URLRequest::BeforeRequestComplete,
+                     base::Unretained(this)))),
+      has_notified_completion_(false),
+      received_response_content_length_(0),
+      creation_time_(base::TimeTicks::Now()) {
+  SIMPLE_STATS_COUNTER("URLRequestCount");
+
+  // Sanity check out environment.
+  DCHECK(MessageLoop::current()) << "The current MessageLoop must exist";
+
+  DCHECK(MessageLoop::current()->IsType(MessageLoop::TYPE_IO)) << ""
+      "The current MessageLoop must be TYPE_IO";
+
+  CHECK(context);
+  context->url_requests()->insert(this);
+
+  net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
+}
+
+URLRequest::URLRequest(const GURL& url,
+                       Delegate* delegate,
+                       const URLRequestContext* context,
+                       NetworkDelegate* network_delegate)
+    : context_(context),
+      network_delegate_(network_delegate),
+      net_log_(BoundNetLog::Make(context->net_log(),
+                                 NetLog::SOURCE_URL_REQUEST)),
+      url_chain_(1, url),
+      method_("GET"),
+      referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
+      load_flags_(LOAD_NORMAL),
+      delegate_(delegate),
+      is_pending_(false),
+      is_redirecting_(false),
+      redirect_limit_(kMaxRedirects),
+      priority_(LOWEST),
+      identifier_(GenerateURLRequestIdentifier()),
+      blocked_on_delegate_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(before_request_callback_(
+          base::Bind(&URLRequest::BeforeRequestComplete,
+                     base::Unretained(this)))),
+      has_notified_completion_(false),
+      received_response_content_length_(0),
+      creation_time_(base::TimeTicks::Now()) {
+  SIMPLE_STATS_COUNTER("URLRequestCount");
+
+  // Sanity check out environment.
+  DCHECK(MessageLoop::current()) << "The current MessageLoop must exist";
+
+  DCHECK(MessageLoop::current()->IsType(MessageLoop::TYPE_IO)) << ""
+      "The current MessageLoop must be TYPE_IO";
+
+  CHECK(context);
+  context->url_requests()->insert(this);
+
+  net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
+}
+
+URLRequest::~URLRequest() {
+  Cancel();
+
+  if (network_delegate_) {
+    network_delegate_->NotifyURLRequestDestroyed(this);
+    if (job_)
+      job_->NotifyURLRequestDestroyed();
+  }
+
+  if (job_)
+    OrphanJob();
+
+  int deleted = context_->url_requests()->erase(this);
+  CHECK_EQ(1, deleted);
+
+  int net_error = OK;
+  // Log error only on failure, not cancellation, as even successful requests
+  // are "cancelled" on destruction.
+  if (status_.status() == URLRequestStatus::FAILED)
+    net_error = status_.error();
+  net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
+}
+
+// static
+URLRequest::ProtocolFactory* URLRequest::RegisterProtocolFactory(
+    const string& scheme, ProtocolFactory* factory) {
+  return URLRequestJobManager::GetInstance()->RegisterProtocolFactory(scheme,
+                                                                      factory);
+}
+
+// static
+void URLRequest::RegisterRequestInterceptor(Interceptor* interceptor) {
+  URLRequestJobManager::GetInstance()->RegisterRequestInterceptor(interceptor);
+}
+
+// static
+void URLRequest::UnregisterRequestInterceptor(Interceptor* interceptor) {
+  URLRequestJobManager::GetInstance()->UnregisterRequestInterceptor(
+      interceptor);
+}
+
+void URLRequest::EnableChunkedUpload() {
+  DCHECK(!upload_data_stream_ || upload_data_stream_->is_chunked());
+  if (!upload_data_stream_) {
+    upload_data_stream_.reset(
+        new UploadDataStream(UploadDataStream::CHUNKED, 0));
+  }
+}
+
+void URLRequest::AppendChunkToUpload(const char* bytes,
+                                     int bytes_len,
+                                     bool is_last_chunk) {
+  DCHECK(upload_data_stream_);
+  DCHECK(upload_data_stream_->is_chunked());
+  DCHECK_GT(bytes_len, 0);
+  upload_data_stream_->AppendChunk(bytes, bytes_len, is_last_chunk);
+}
+
+void URLRequest::set_upload(scoped_ptr<UploadDataStream> upload) {
+  DCHECK(!upload->is_chunked());
+  upload_data_stream_ = upload.Pass();
+}
+
+const UploadDataStream* URLRequest::get_upload() const {
+  return upload_data_stream_.get();
+}
+
+bool URLRequest::has_upload() const {
+  return upload_data_stream_.get() != NULL;
+}
+
+void URLRequest::SetExtraRequestHeaderById(int id, const string& value,
+                                           bool overwrite) {
+  DCHECK(!is_pending_ || is_redirecting_);
+  NOTREACHED() << "implement me!";
+}
+
+void URLRequest::SetExtraRequestHeaderByName(const string& name,
+                                             const string& value,
+                                             bool overwrite) {
+  DCHECK(!is_pending_ || is_redirecting_);
+  if (overwrite) {
+    extra_request_headers_.SetHeader(name, value);
+  } else {
+    extra_request_headers_.SetHeaderIfMissing(name, value);
+  }
+}
+
+void URLRequest::RemoveRequestHeaderByName(const string& name) {
+  DCHECK(!is_pending_ || is_redirecting_);
+  extra_request_headers_.RemoveHeader(name);
+}
+
+void URLRequest::SetExtraRequestHeaders(
+    const HttpRequestHeaders& headers) {
+  DCHECK(!is_pending_);
+  extra_request_headers_ = headers;
+
+  // NOTE: This method will likely become non-trivial once the other setters
+  // for request headers are implemented.
+}
+
+LoadStateWithParam URLRequest::GetLoadState() const {
+  // Only return LOAD_STATE_WAITING_FOR_DELEGATE if there's a load state param.
+  if (blocked_on_delegate_ && !load_state_param_.empty()) {
+    return LoadStateWithParam(LOAD_STATE_WAITING_FOR_DELEGATE,
+                              load_state_param_);
+  }
+  return LoadStateWithParam(job_ ? job_->GetLoadState() : LOAD_STATE_IDLE,
+                            string16());
+}
+
+UploadProgress URLRequest::GetUploadProgress() const {
+  if (!job_) {
+    // We haven't started or the request was cancelled
+    return UploadProgress();
+  }
+  if (final_upload_progress_.position()) {
+    // The first job completed and none of the subsequent series of
+    // GETs when following redirects will upload anything, so we return the
+    // cached results from the initial job, the POST.
+    return final_upload_progress_;
+  }
+  return job_->GetUploadProgress();
+}
+
+void URLRequest::GetResponseHeaderById(int id, string* value) {
+  DCHECK(job_);
+  NOTREACHED() << "implement me!";
+}
+
+void URLRequest::GetResponseHeaderByName(const string& name, string* value) {
+  DCHECK(value);
+  if (response_info_.headers) {
+    response_info_.headers->GetNormalizedHeader(name, value);
+  } else {
+    value->clear();
+  }
+}
+
+void URLRequest::GetAllResponseHeaders(string* headers) {
+  DCHECK(headers);
+  if (response_info_.headers) {
+    response_info_.headers->GetNormalizedHeaders(headers);
+  } else {
+    headers->clear();
+  }
+}
+
+HostPortPair URLRequest::GetSocketAddress() const {
+  DCHECK(job_);
+  return job_->GetSocketAddress();
+}
+
+HttpResponseHeaders* URLRequest::response_headers() const {
+  return response_info_.headers.get();
+}
+
+bool URLRequest::GetResponseCookies(ResponseCookies* cookies) {
+  DCHECK(job_);
+  return job_->GetResponseCookies(cookies);
+}
+
+void URLRequest::GetMimeType(string* mime_type) {
+  DCHECK(job_);
+  job_->GetMimeType(mime_type);
+}
+
+void URLRequest::GetCharset(string* charset) {
+  DCHECK(job_);
+  job_->GetCharset(charset);
+}
+
+int URLRequest::GetResponseCode() {
+  DCHECK(job_);
+  return job_->GetResponseCode();
+}
+
+// static
+void URLRequest::SetDefaultCookiePolicyToBlock() {
+  CHECK(!g_url_requests_started);
+  g_default_can_use_cookies = false;
+}
+
+// static
+bool URLRequest::IsHandledProtocol(const std::string& scheme) {
+  return URLRequestJobManager::GetInstance()->SupportsScheme(scheme);
+}
+
+// static
+bool URLRequest::IsHandledURL(const GURL& url) {
+  if (!url.is_valid()) {
+    // We handle error cases.
+    return true;
+  }
+
+  return IsHandledProtocol(url.scheme());
+}
+
+void URLRequest::set_first_party_for_cookies(
+    const GURL& first_party_for_cookies) {
+  first_party_for_cookies_ = first_party_for_cookies;
+}
+
+void URLRequest::set_method(const std::string& method) {
+  DCHECK(!is_pending_);
+  method_ = method;
+}
+
+void URLRequest::set_referrer(const std::string& referrer) {
+  DCHECK(!is_pending_);
+  referrer_ = referrer;
+}
+
+GURL URLRequest::GetSanitizedReferrer() const {
+  GURL ret(referrer());
+
+  // Ensure that we do not send username and password fields in the referrer.
+  if (ret.has_username() || ret.has_password()) {
+    GURL::Replacements referrer_mods;
+    referrer_mods.ClearUsername();
+    referrer_mods.ClearPassword();
+    ret = ret.ReplaceComponents(referrer_mods);
+  }
+
+  return ret;
+}
+
+void URLRequest::set_referrer_policy(ReferrerPolicy referrer_policy) {
+  DCHECK(!is_pending_);
+  referrer_policy_ = referrer_policy;
+}
+
+void URLRequest::set_delegate(Delegate* delegate) {
+  delegate_ = delegate;
+}
+
+void URLRequest::Start() {
+  DCHECK_EQ(network_delegate_, context_->network_delegate());
+
+  g_url_requests_started = true;
+  response_info_.request_time = Time::Now();
+
+  // Only notify the delegate for the initial request.
+  if (network_delegate_) {
+    int error = network_delegate_->NotifyBeforeURLRequest(
+        this, before_request_callback_, &delegate_redirect_url_);
+    if (error == net::ERR_IO_PENDING) {
+      // Paused on the delegate, will invoke |before_request_callback_| later.
+      SetBlockedOnDelegate();
+    } else {
+      BeforeRequestComplete(error);
+    }
+    return;
+  }
+
+  StartJob(URLRequestJobManager::GetInstance()->CreateJob(
+      this, network_delegate_));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void URLRequest::BeforeRequestComplete(int error) {
+  DCHECK(!job_);
+  DCHECK_NE(ERR_IO_PENDING, error);
+  DCHECK_EQ(network_delegate_, context_->network_delegate());
+
+  // Check that there are no callbacks to already canceled requests.
+  DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
+
+  if (blocked_on_delegate_)
+    SetUnblockedOnDelegate();
+
+  if (error != OK) {
+    std::string source("delegate");
+    net_log_.AddEvent(NetLog::TYPE_CANCELLED,
+                      NetLog::StringCallback("source", &source));
+    StartJob(new URLRequestErrorJob(this, network_delegate_, error));
+  } else if (!delegate_redirect_url_.is_empty()) {
+    GURL new_url;
+    new_url.Swap(&delegate_redirect_url_);
+
+    URLRequestRedirectJob* job = new URLRequestRedirectJob(
+        this, network_delegate_, new_url,
+        // Use status code 307 to preserve the method, so POST requests work.
+        URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT);
+    StartJob(job);
+  } else {
+    StartJob(URLRequestJobManager::GetInstance()->CreateJob(
+        this, network_delegate_));
+  }
+}
+
+void URLRequest::StartJob(URLRequestJob* job) {
+  DCHECK(!is_pending_);
+  DCHECK(!job_);
+
+  net_log_.BeginEvent(
+      NetLog::TYPE_URL_REQUEST_START_JOB,
+      base::Bind(&NetLogURLRequestStartCallback,
+                 &url(), &method_, load_flags_, priority_,
+                 upload_data_stream_ ? upload_data_stream_->identifier() : -1));
+
+  job_ = job;
+  job_->SetExtraRequestHeaders(extra_request_headers_);
+
+  if (upload_data_stream_.get())
+    job_->SetUpload(upload_data_stream_.get());
+
+  is_pending_ = true;
+  is_redirecting_ = false;
+
+  response_info_.was_cached = false;
+
+  // Don't allow errors to be sent from within Start().
+  // TODO(brettw) this may cause NotifyDone to be sent synchronously,
+  // we probably don't want this: they should be sent asynchronously so
+  // the caller does not get reentered.
+  job_->Start();
+}
+
+void URLRequest::Restart() {
+  // Should only be called if the original job didn't make any progress.
+  DCHECK(job_ && !job_->has_response_started());
+  RestartWithJob(URLRequestJobManager::GetInstance()->CreateJob(
+      this, network_delegate_));
+}
+
+void URLRequest::RestartWithJob(URLRequestJob *job) {
+  DCHECK(job->request() == this);
+  PrepareToRestart();
+  StartJob(job);
+}
+
+void URLRequest::Cancel() {
+  DoCancel(ERR_ABORTED, SSLInfo());
+}
+
+void URLRequest::CancelWithError(int error) {
+  DoCancel(error, SSLInfo());
+}
+
+void URLRequest::CancelWithSSLError(int error, const SSLInfo& ssl_info) {
+  // This should only be called on a started request.
+  if (!is_pending_ || !job_ || job_->has_response_started()) {
+    NOTREACHED();
+    return;
+  }
+  DoCancel(error, ssl_info);
+}
+
+void URLRequest::DoCancel(int error, const SSLInfo& ssl_info) {
+  DCHECK(error < 0);
+
+  // If the URL request already has an error status, then canceling is a no-op.
+  // Plus, we don't want to change the error status once it has been set.
+  if (status_.is_success()) {
+    status_.set_status(URLRequestStatus::CANCELED);
+    status_.set_error(error);
+    response_info_.ssl_info = ssl_info;
+
+    // If the request hasn't already been completed, log a cancellation event.
+    if (!has_notified_completion_) {
+      // Don't log an error code on ERR_ABORTED, since that's redundant.
+      net_log_.AddEventWithNetErrorCode(NetLog::TYPE_CANCELLED,
+                                        error == ERR_ABORTED ? OK : error);
+    }
+  }
+
+  if (is_pending_ && job_)
+    job_->Kill();
+
+  // We need to notify about the end of this job here synchronously. The
+  // Job sends an asynchronous notification but by the time this is processed,
+  // our |context_| is NULL.
+  NotifyRequestCompleted();
+
+  // The Job will call our NotifyDone method asynchronously.  This is done so
+  // that the Delegate implementation can call Cancel without having to worry
+  // about being called recursively.
+}
+
+bool URLRequest::Read(IOBuffer* dest, int dest_size, int* bytes_read) {
+  DCHECK(job_);
+  DCHECK(bytes_read);
+  *bytes_read = 0;
+
+  // This handles a cancel that happens while paused.
+  // TODO(ahendrickson): DCHECK() that it is not done after
+  // http://crbug.com/115705 is fixed.
+  if (job_->is_done())
+    return false;
+
+  if (dest_size == 0) {
+    // Caller is not too bright.  I guess we've done what they asked.
+    return true;
+  }
+
+  // Once the request fails or is cancelled, read will just return 0 bytes
+  // to indicate end of stream.
+  if (!status_.is_success()) {
+    return true;
+  }
+
+  bool rv = job_->Read(dest, dest_size, bytes_read);
+  // If rv is false, the status cannot be success.
+  DCHECK(rv || status_.status() != URLRequestStatus::SUCCESS);
+  if (rv && *bytes_read <= 0 && status_.is_success())
+    NotifyRequestCompleted();
+  return rv;
+}
+
+void URLRequest::StopCaching() {
+  DCHECK(job_);
+  job_->StopCaching();
+}
+
+void URLRequest::NotifyReceivedRedirect(const GURL& location,
+                                        bool* defer_redirect) {
+  is_redirecting_ = true;
+
+  URLRequestJob* job =
+      URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(
+          this, network_delegate_, location);
+  if (job) {
+    RestartWithJob(job);
+  } else if (delegate_) {
+    delegate_->OnReceivedRedirect(this, location, defer_redirect);
+    // |this| may be have been destroyed here.
+  }
+}
+
+void URLRequest::NotifyResponseStarted() {
+  int net_error = OK;
+  if (!status_.is_success())
+    net_error = status_.error();
+  net_log_.EndEventWithNetErrorCode(NetLog::TYPE_URL_REQUEST_START_JOB,
+                                    net_error);
+
+  URLRequestJob* job =
+      URLRequestJobManager::GetInstance()->MaybeInterceptResponse(
+          this, network_delegate_);
+  if (job) {
+    RestartWithJob(job);
+  } else {
+    if (delegate_) {
+      // In some cases (e.g. an event was canceled), we might have sent the
+      // completion event and receive a NotifyResponseStarted() later.
+      if (!has_notified_completion_ && status_.is_success()) {
+        if (network_delegate_)
+          network_delegate_->NotifyResponseStarted(this);
+      }
+
+      // Notify in case the entire URL Request has been finished.
+      if (!has_notified_completion_ && !status_.is_success())
+        NotifyRequestCompleted();
+
+      delegate_->OnResponseStarted(this);
+      // Nothing may appear below this line as OnResponseStarted may delete
+      // |this|.
+    }
+  }
+}
+
+void URLRequest::FollowDeferredRedirect() {
+  CHECK(job_);
+  CHECK(status_.is_success());
+
+  job_->FollowDeferredRedirect();
+}
+
+void URLRequest::SetAuth(const AuthCredentials& credentials) {
+  DCHECK(job_);
+  DCHECK(job_->NeedsAuth());
+
+  job_->SetAuth(credentials);
+}
+
+void URLRequest::CancelAuth() {
+  DCHECK(job_);
+  DCHECK(job_->NeedsAuth());
+
+  job_->CancelAuth();
+}
+
+void URLRequest::ContinueWithCertificate(X509Certificate* client_cert) {
+  DCHECK(job_);
+
+  job_->ContinueWithCertificate(client_cert);
+}
+
+void URLRequest::ContinueDespiteLastError() {
+  DCHECK(job_);
+
+  job_->ContinueDespiteLastError();
+}
+
+void URLRequest::PrepareToRestart() {
+  DCHECK(job_);
+
+  // Close the current URL_REQUEST_START_JOB, since we will be starting a new
+  // one.
+  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB);
+
+  OrphanJob();
+
+  response_info_ = HttpResponseInfo();
+  response_info_.request_time = Time::Now();
+  status_ = URLRequestStatus();
+  is_pending_ = false;
+}
+
+void URLRequest::OrphanJob() {
+  // When calling this function, please check that URLRequestHttpJob is
+  // not in between calling NetworkDelegate::NotifyHeadersReceived receiving
+  // the call back. This is currently guaranteed by the following strategies:
+  // - OrphanJob is called on JobRestart, in this case the URLRequestJob cannot
+  //   be receiving any headers at that time.
+  // - OrphanJob is called in ~URLRequest, in this case
+  //   NetworkDelegate::NotifyURLRequestDestroyed notifies the NetworkDelegate
+  //   that the callback becomes invalid.
+  job_->Kill();
+  job_->DetachRequest();  // ensures that the job will not call us again
+  job_ = NULL;
+}
+
+int URLRequest::Redirect(const GURL& location, int http_status_code) {
+  if (net_log_.IsLoggingAllEvents()) {
+    net_log_.AddEvent(
+        NetLog::TYPE_URL_REQUEST_REDIRECTED,
+        NetLog::StringCallback("location", &location.possibly_invalid_spec()));
+  }
+
+  if (network_delegate_)
+    network_delegate_->NotifyBeforeRedirect(this, location);
+
+  if (redirect_limit_ <= 0) {
+    DVLOG(1) << "disallowing redirect: exceeds limit";
+    return ERR_TOO_MANY_REDIRECTS;
+  }
+
+  if (!location.is_valid())
+    return ERR_INVALID_URL;
+
+  if (!job_->IsSafeRedirect(location)) {
+    DVLOG(1) << "disallowing redirect: unsafe protocol";
+    return ERR_UNSAFE_REDIRECT;
+  }
+
+  if (!final_upload_progress_.position())
+    final_upload_progress_ = job_->GetUploadProgress();
+  PrepareToRestart();
+
+  // For 303 redirects, all request methods except HEAD are converted to GET,
+  // as per the latest httpbis draft.  The draft also allows POST requests to
+  // be converted to GETs when following 301/302 redirects, for historical
+  // reasons. Most major browsers do this and so shall we.  Both RFC 2616 and
+  // the httpbis draft say to prompt the user to confirm the generation of new
+  // requests, other than GET and HEAD requests, but IE omits these prompts and
+  // so shall we.
+  // See:  https://tools.ietf.org/html/draft-ietf-httpbis-p2-semantics-17#section-7.3
+  bool was_post = method_ == "POST";
+  if ((http_status_code == 303 && method_ != "HEAD") ||
+      ((http_status_code == 301 || http_status_code == 302) && was_post)) {
+    method_ = "GET";
+    upload_data_stream_.reset();
+    if (was_post) {
+      // If being switched from POST to GET, must remove headers that were
+      // specific to the POST and don't have meaning in GET. For example
+      // the inclusion of a multipart Content-Type header in GET can cause
+      // problems with some servers:
+      // http://code.google.com/p/chromium/issues/detail?id=843
+      StripPostSpecificHeaders(&extra_request_headers_);
+    }
+  }
+
+  // Suppress the referrer if we're redirecting out of https.
+  if (referrer_policy_ ==
+          CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE &&
+      GURL(referrer_).SchemeIsSecure() && !location.SchemeIsSecure()) {
+    referrer_.clear();
+  }
+
+  url_chain_.push_back(location);
+  --redirect_limit_;
+
+  Start();
+  return OK;
+}
+
+const URLRequestContext* URLRequest::context() const {
+  return context_;
+}
+
+int64 URLRequest::GetExpectedContentSize() const {
+  int64 expected_content_size = -1;
+  if (job_)
+    expected_content_size = job_->expected_content_size();
+
+  return expected_content_size;
+}
+
+bool URLRequest::GetHSTSRedirect(GURL* redirect_url) const {
+  const GURL& url = this->url();
+  if (!url.SchemeIs("http"))
+    return false;
+  TransportSecurityState::DomainState domain_state;
+  if (context()->transport_security_state() &&
+      context()->transport_security_state()->GetDomainState(
+          url.host(),
+          SSLConfigService::IsSNIAvailable(context()->ssl_config_service()),
+          &domain_state) &&
+      domain_state.ShouldRedirectHTTPToHTTPS()) {
+    url_canon::Replacements<char> replacements;
+    const char kNewScheme[] = "https";
+    replacements.SetScheme(kNewScheme,
+                           url_parse::Component(0, strlen(kNewScheme)));
+    *redirect_url = url.ReplaceComponents(replacements);
+    return true;
+  }
+  return false;
+}
+
+void URLRequest::NotifyAuthRequired(AuthChallengeInfo* auth_info) {
+  NetworkDelegate::AuthRequiredResponse rv =
+      NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  auth_info_ = auth_info;
+  if (network_delegate_) {
+    rv = network_delegate_->NotifyAuthRequired(
+        this,
+        *auth_info,
+        base::Bind(&URLRequest::NotifyAuthRequiredComplete,
+                   base::Unretained(this)),
+        &auth_credentials_);
+  }
+
+  if (rv == NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING) {
+    SetBlockedOnDelegate();
+  } else {
+    NotifyAuthRequiredComplete(rv);
+  }
+}
+
+void URLRequest::NotifyAuthRequiredComplete(
+    NetworkDelegate::AuthRequiredResponse result) {
+  SetUnblockedOnDelegate();
+
+  // Check that there are no callbacks to already canceled requests.
+  DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
+
+  // NotifyAuthRequired may be called multiple times, such as
+  // when an authentication attempt fails. Clear out the data
+  // so it can be reset on another round.
+  AuthCredentials credentials = auth_credentials_;
+  auth_credentials_ = AuthCredentials();
+  scoped_refptr<AuthChallengeInfo> auth_info;
+  auth_info.swap(auth_info_);
+
+  switch (result) {
+    case NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION:
+      // Defer to the URLRequest::Delegate, since the NetworkDelegate
+      // didn't take an action.
+      if (delegate_)
+        delegate_->OnAuthRequired(this, auth_info.get());
+      break;
+
+    case NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH:
+      SetAuth(credentials);
+      break;
+
+    case NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH:
+      CancelAuth();
+      break;
+
+    case NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING:
+      NOTREACHED();
+      break;
+  }
+}
+
+void URLRequest::NotifyCertificateRequested(
+    SSLCertRequestInfo* cert_request_info) {
+  if (delegate_)
+    delegate_->OnCertificateRequested(this, cert_request_info);
+}
+
+void URLRequest::NotifySSLCertificateError(const SSLInfo& ssl_info,
+                                           bool fatal) {
+  if (delegate_)
+    delegate_->OnSSLCertificateError(this, ssl_info, fatal);
+}
+
+bool URLRequest::CanGetCookies(const CookieList& cookie_list) const {
+  DCHECK(!(load_flags_ & LOAD_DO_NOT_SEND_COOKIES));
+  if (network_delegate_) {
+    return network_delegate_->CanGetCookies(*this, cookie_list);
+  }
+  return g_default_can_use_cookies;
+}
+
+bool URLRequest::CanSetCookie(const std::string& cookie_line,
+                              CookieOptions* options) const {
+  DCHECK(!(load_flags_ & LOAD_DO_NOT_SAVE_COOKIES));
+  if (network_delegate_) {
+    return network_delegate_->CanSetCookie(*this, cookie_line, options);
+  }
+  return g_default_can_use_cookies;
+}
+
+
+void URLRequest::NotifyReadCompleted(int bytes_read) {
+  // Notify in case the entire URL Request has been finished.
+  if (bytes_read <= 0)
+    NotifyRequestCompleted();
+
+  // Notify NetworkChangeNotifier that we just received network data.
+  // This is to identify cases where the NetworkChangeNotifier thinks we
+  // are off-line but we are still receiving network data (crbug.com/124069).
+  if (bytes_read > 0 && !was_cached())
+    NetworkChangeNotifier::NotifyDataReceived(url());
+
+  if (delegate_)
+    delegate_->OnReadCompleted(this, bytes_read);
+
+  // Nothing below this line as OnReadCompleted may delete |this|.
+}
+
+void URLRequest::NotifyRequestCompleted() {
+  // TODO(battre): Get rid of this check, according to willchan it should
+  // not be needed.
+  if (has_notified_completion_)
+    return;
+
+  is_pending_ = false;
+  is_redirecting_ = false;
+  has_notified_completion_ = true;
+  if (network_delegate_)
+    network_delegate_->NotifyCompleted(this, job_ != NULL);
+}
+
+void URLRequest::SetBlockedOnDelegate() {
+  blocked_on_delegate_ = true;
+  if (!load_state_param_.empty()) {
+    net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE,
+                        NetLog::StringCallback("delegate", &load_state_param_));
+  } else {
+    net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
+  }
+}
+
+void URLRequest::SetUnblockedOnDelegate() {
+  if (!blocked_on_delegate_)
+    return;
+  blocked_on_delegate_ = false;
+  load_state_param_.clear();
+  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
+}
+
+void URLRequest::set_stack_trace(const base::debug::StackTrace& stack_trace) {
+  base::debug::StackTrace* stack_trace_copy =
+      new base::debug::StackTrace(NULL, 0);
+  *stack_trace_copy = stack_trace;
+  stack_trace_.reset(stack_trace_copy);
+}
+
+const base::debug::StackTrace* URLRequest::stack_trace() const {
+  return stack_trace_.get();
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request.h b/src/net/url_request/url_request.h
new file mode 100644
index 0000000..4081e75
--- /dev/null
+++ b/src/net/url_request/url_request.h
@@ -0,0 +1,849 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_H_
+#define NET_URL_REQUEST_URL_REQUEST_H_
+
+#include <string>
+#include <vector>
+
+#include "base/debug/leak_tracker.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/string16.h"
+#include "base/supports_user_data.h"
+#include "base/time.h"
+#include "base/threading/non_thread_safe.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/auth.h"
+#include "net/base/completion_callback.h"
+#include "net/base/load_states.h"
+#include "net/base/net_export.h"
+#include "net/base/net_log.h"
+#include "net/base/network_delegate.h"
+#include "net/base/request_priority.h"
+#include "net/base/upload_progress.h"
+#include "net/cookies/canonical_cookie.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_response_info.h"
+#include "net/url_request/url_request_status.h"
+
+class FilePath;
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+class ChildProcessSecurityPolicyTest;
+class ComponentUpdateInterceptor;
+class TestAutomationProvider;
+class URLRequestAutomationJob;
+
+namespace base {
+namespace debug {
+class StackTrace;
+}
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace appcache {
+class AppCacheInterceptor;
+class AppCacheRequestHandlerTest;
+class AppCacheURLRequestJobTest;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace content {
+class ResourceDispatcherHostTest;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace extensions {
+class AutoUpdateInterceptor;
+class UserScriptListenerTest;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace fileapi {
+class FileSystemDirURLRequestJobTest;
+class FileSystemURLRequestJobTest;
+class FileWriterDelegateTest;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace policy {
+class CannedResponseInterceptor;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace webkit_blob {
+class BlobURLRequestJobTest;
+}
+
+namespace net {
+
+class CookieOptions;
+class HostPortPair;
+class IOBuffer;
+class SSLCertRequestInfo;
+class SSLInfo;
+class UploadDataStream;
+class URLRequestContext;
+class URLRequestJob;
+class X509Certificate;
+
+// This stores the values of the Set-Cookie headers received during the request.
+// Each item in the vector corresponds to a Set-Cookie: line received,
+// excluding the "Set-Cookie:" part.
+typedef std::vector<std::string> ResponseCookies;
+
+//-----------------------------------------------------------------------------
+// A class  representing the asynchronous load of a data stream from an URL.
+//
+// The lifetime of an instance of this class is completely controlled by the
+// consumer, and the instance is not required to live on the heap or be
+// allocated in any special way.  It is also valid to delete an URLRequest
+// object during the handling of a callback to its delegate.  Of course, once
+// the URLRequest is deleted, no further callbacks to its delegate will occur.
+//
+// NOTE: All usage of all instances of this class should be on the same thread.
+//
+class NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe),
+                              public base::SupportsUserData {
+ public:
+  // Callback function implemented by protocol handlers to create new jobs.
+  // The factory may return NULL to indicate an error, which will cause other
+  // factories to be queried.  If no factory handles the request, then the
+  // default job will be used.
+  typedef URLRequestJob* (ProtocolFactory)(URLRequest* request,
+                                           NetworkDelegate* network_delegate,
+                                           const std::string& scheme);
+
+  // HTTP request/response header IDs (via some preprocessor fun) for use with
+  // SetRequestHeaderById and GetResponseHeaderById.
+  enum {
+#define HTTP_ATOM(x) HTTP_ ## x,
+#include "net/http/http_atom_list.h"
+#undef HTTP_ATOM
+  };
+
+  // Referrer policies (see set_referrer_policy): During server redirects, the
+  // referrer header might be cleared, if the protocol changes from HTTPS to
+  // HTTP. This is the default behavior of URLRequest, corresponding to
+  // CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE. Alternatively, the
+  // referrer policy can be set to never change the referrer header. This
+  // behavior corresponds to NEVER_CLEAR_REFERRER. Embedders will want to use
+  // NEVER_CLEAR_REFERRER when implementing the meta-referrer support
+  // (http://wiki.whatwg.org/wiki/Meta_referrer) and sending requests with a
+  // non-default referrer policy. Only the default referrer policy requires
+  // the referrer to be cleared on transitions from HTTPS to HTTP.
+  enum ReferrerPolicy {
+    CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
+    NEVER_CLEAR_REFERRER,
+  };
+
+  // This class handles network interception.  Use with
+  // (Un)RegisterRequestInterceptor.
+  class NET_EXPORT Interceptor {
+  public:
+    virtual ~Interceptor() {}
+
+    // Called for every request made.  Should return a new job to handle the
+    // request if it should be intercepted, or NULL to allow the request to
+    // be handled in the normal manner.
+    virtual URLRequestJob* MaybeIntercept(
+        URLRequest* request, NetworkDelegate* network_delegate) = 0;
+
+    // Called after having received a redirect response, but prior to the
+    // the request delegate being informed of the redirect. Can return a new
+    // job to replace the existing job if it should be intercepted, or NULL
+    // to allow the normal handling to continue. If a new job is provided,
+    // the delegate never sees the original redirect response, instead the
+    // response produced by the intercept job will be returned.
+    virtual URLRequestJob* MaybeInterceptRedirect(
+        URLRequest* request,
+        NetworkDelegate* network_delegate,
+        const GURL& location);
+
+    // Called after having received a final response, but prior to the
+    // the request delegate being informed of the response. This is also
+    // called when there is no server response at all to allow interception
+    // on dns or network errors. Can return a new job to replace the existing
+    // job if it should be intercepted, or NULL to allow the normal handling to
+    // continue. If a new job is provided, the delegate never sees the original
+    // response, instead the response produced by the intercept job will be
+    // returned.
+    virtual URLRequestJob* MaybeInterceptResponse(
+        URLRequest* request, NetworkDelegate* network_delegate);
+  };
+
+  // Deprecated interfaces in net::URLRequest. They have been moved to
+  // URLRequest's private section to prevent new uses. Existing uses are
+  // explicitly friended here and should be removed over time.
+  class NET_EXPORT Deprecated {
+   private:
+    // TODO(willchan): Kill off these friend declarations.
+    friend class extensions::AutoUpdateInterceptor;
+    friend class ::ChildProcessSecurityPolicyTest;
+    friend class ::ComponentUpdateInterceptor;
+    friend class ::TestAutomationProvider;
+    friend class ::URLRequestAutomationJob;
+    friend class TestInterceptor;
+    friend class URLRequestFilter;
+    friend class appcache::AppCacheInterceptor;
+    friend class appcache::AppCacheRequestHandlerTest;
+    friend class appcache::AppCacheURLRequestJobTest;
+    friend class content::ResourceDispatcherHostTest;
+    friend class extensions::UserScriptListenerTest;
+    friend class fileapi::FileSystemDirURLRequestJobTest;
+    friend class fileapi::FileSystemURLRequestJobTest;
+    friend class fileapi::FileWriterDelegateTest;
+    friend class policy::CannedResponseInterceptor;
+    friend class webkit_blob::BlobURLRequestJobTest;
+
+    // Use URLRequestJobFactory::ProtocolHandler instead.
+    static ProtocolFactory* RegisterProtocolFactory(const std::string& scheme,
+                                                    ProtocolFactory* factory);
+
+    // Use URLRequestJobFactory::Interceptor instead.
+    static void RegisterRequestInterceptor(Interceptor* interceptor);
+    static void UnregisterRequestInterceptor(Interceptor* interceptor);
+
+    DISALLOW_IMPLICIT_CONSTRUCTORS(Deprecated);
+  };
+
+  // The delegate's methods are called from the message loop of the thread
+  // on which the request's Start() method is called. See above for the
+  // ordering of callbacks.
+  //
+  // The callbacks will be called in the following order:
+  //   Start()
+  //    - OnCertificateRequested* (zero or more calls, if the SSL server and/or
+  //      SSL proxy requests a client certificate for authentication)
+  //    - OnSSLCertificateError* (zero or one call, if the SSL server's
+  //      certificate has an error)
+  //    - OnReceivedRedirect* (zero or more calls, for the number of redirects)
+  //    - OnAuthRequired* (zero or more calls, for the number of
+  //      authentication failures)
+  //    - OnResponseStarted
+  //   Read() initiated by delegate
+  //    - OnReadCompleted* (zero or more calls until all data is read)
+  //
+  // Read() must be called at least once. Read() returns true when it completed
+  // immediately, and false if an IO is pending or if there is an error.  When
+  // Read() returns false, the caller can check the Request's status() to see
+  // if an error occurred, or if the IO is just pending.  When Read() returns
+  // true with zero bytes read, it indicates the end of the response.
+  //
+  class NET_EXPORT Delegate {
+   public:
+    // Called upon a server-initiated redirect.  The delegate may call the
+    // request's Cancel method to prevent the redirect from being followed.
+    // Since there may be multiple chained redirects, there may also be more
+    // than one redirect call.
+    //
+    // When this function is called, the request will still contain the
+    // original URL, the destination of the redirect is provided in 'new_url'.
+    // If the delegate does not cancel the request and |*defer_redirect| is
+    // false, then the redirect will be followed, and the request's URL will be
+    // changed to the new URL.  Otherwise if the delegate does not cancel the
+    // request and |*defer_redirect| is true, then the redirect will be
+    // followed once FollowDeferredRedirect is called on the URLRequest.
+    //
+    // The caller must set |*defer_redirect| to false, so that delegates do not
+    // need to set it if they are happy with the default behavior of not
+    // deferring redirect.
+    virtual void OnReceivedRedirect(URLRequest* request,
+                                    const GURL& new_url,
+                                    bool* defer_redirect);
+
+    // Called when we receive an authentication failure.  The delegate should
+    // call request->SetAuth() with the user's credentials once it obtains them,
+    // or request->CancelAuth() to cancel the login and display the error page.
+    // When it does so, the request will be reissued, restarting the sequence
+    // of On* callbacks.
+    virtual void OnAuthRequired(URLRequest* request,
+                                AuthChallengeInfo* auth_info);
+
+    // Called when we receive an SSL CertificateRequest message for client
+    // authentication.  The delegate should call
+    // request->ContinueWithCertificate() with the client certificate the user
+    // selected, or request->ContinueWithCertificate(NULL) to continue the SSL
+    // handshake without a client certificate.
+    virtual void OnCertificateRequested(
+        URLRequest* request,
+        SSLCertRequestInfo* cert_request_info);
+
+    // Called when using SSL and the server responds with a certificate with
+    // an error, for example, whose common name does not match the common name
+    // we were expecting for that host.  The delegate should either do the
+    // safe thing and Cancel() the request or decide to proceed by calling
+    // ContinueDespiteLastError().  cert_error is a ERR_* error code
+    // indicating what's wrong with the certificate.
+    // If |fatal| is true then the host in question demands a higher level
+    // of security (due e.g. to HTTP Strict Transport Security, user
+    // preference, or built-in policy). In this case, errors must not be
+    // bypassable by the user.
+    virtual void OnSSLCertificateError(URLRequest* request,
+                                       const SSLInfo& ssl_info,
+                                       bool fatal);
+
+    // After calling Start(), the delegate will receive an OnResponseStarted
+    // callback when the request has completed.  If an error occurred, the
+    // request->status() will be set.  On success, all redirects have been
+    // followed and the final response is beginning to arrive.  At this point,
+    // meta data about the response is available, including for example HTTP
+    // response headers if this is a request for a HTTP resource.
+    virtual void OnResponseStarted(URLRequest* request) = 0;
+
+    // Called when the a Read of the response body is completed after an
+    // IO_PENDING status from a Read() call.
+    // The data read is filled into the buffer which the caller passed
+    // to Read() previously.
+    //
+    // If an error occurred, request->status() will contain the error,
+    // and bytes read will be -1.
+    virtual void OnReadCompleted(URLRequest* request, int bytes_read) = 0;
+
+   protected:
+    virtual ~Delegate() {}
+  };
+
+  // TODO(shalev): Get rid of this constructor in favour of the one below it.
+  // Initialize an URL request.
+  URLRequest(const GURL& url,
+             Delegate* delegate,
+             const URLRequestContext* context);
+
+  URLRequest(const GURL& url,
+             Delegate* delegate,
+             const URLRequestContext* context,
+             NetworkDelegate* network_delegate);
+
+  // If destroyed after Start() has been called but while IO is pending,
+  // then the request will be effectively canceled and the delegate
+  // will not have any more of its methods called.
+  virtual ~URLRequest();
+
+  // Changes the default cookie policy from allowing all cookies to blocking all
+  // cookies. Embedders that want to implement a more flexible policy should
+  // change the default to blocking all cookies, and provide a NetworkDelegate
+  // with the URLRequestContext that maintains the CookieStore.
+  // The cookie policy default has to be set before the first URLRequest is
+  // started. Once it was set to block all cookies, it cannot be changed back.
+  static void SetDefaultCookiePolicyToBlock();
+
+  // Returns true if the scheme can be handled by URLRequest. False otherwise.
+  static bool IsHandledProtocol(const std::string& scheme);
+
+  // Returns true if the url can be handled by URLRequest. False otherwise.
+  // The function returns true for invalid urls because URLRequest knows how
+  // to handle those.
+  // NOTE: This will also return true for URLs that are handled by
+  // ProtocolFactories that only work for requests that are scoped to a
+  // Profile.
+  static bool IsHandledURL(const GURL& url);
+
+  // The original url is the url used to initialize the request, and it may
+  // differ from the url if the request was redirected.
+  const GURL& original_url() const { return url_chain_.front(); }
+  // The chain of urls traversed by this request.  If the request had no
+  // redirects, this vector will contain one element.
+  const std::vector<GURL>& url_chain() const { return url_chain_; }
+  const GURL& url() const { return url_chain_.back(); }
+
+  // The URL that should be consulted for the third-party cookie blocking
+  // policy.
+  //
+  // WARNING: This URL must only be used for the third-party cookie blocking
+  //          policy. It MUST NEVER be used for any kind of SECURITY check.
+  //
+  //          For example, if a top-level navigation is redirected, the
+  //          first-party for cookies will be the URL of the first URL in the
+  //          redirect chain throughout the whole redirect. If it was used for
+  //          a security check, an attacker might try to get around this check
+  //          by starting from some page that redirects to the
+  //          host-to-be-attacked.
+  const GURL& first_party_for_cookies() const {
+    return first_party_for_cookies_;
+  }
+  // This method may be called before Start() or FollowDeferredRedirect() is
+  // called.
+  void set_first_party_for_cookies(const GURL& first_party_for_cookies);
+
+  // The request method, as an uppercase string.  "GET" is the default value.
+  // The request method may only be changed before Start() is called and
+  // should only be assigned an uppercase value.
+  const std::string& method() const { return method_; }
+  void set_method(const std::string& method);
+
+  // The referrer URL for the request.  This header may actually be suppressed
+  // from the underlying network request for security reasons (e.g., a HTTPS
+  // URL will not be sent as the referrer for a HTTP request).  The referrer
+  // may only be changed before Start() is called.
+  const std::string& referrer() const { return referrer_; }
+  void set_referrer(const std::string& referrer);
+  // Returns the referrer header with potential username and password removed.
+  GURL GetSanitizedReferrer() const;
+
+  // The referrer policy to apply when updating the referrer during redirects.
+  // The referrer policy may only be changed before Start() is called.
+  void set_referrer_policy(ReferrerPolicy referrer_policy);
+
+  // Sets the delegate of the request.  This value may be changed at any time,
+  // and it is permissible for it to be null.
+  void set_delegate(Delegate* delegate);
+
+  // Indicates that the request body should be sent using chunked transfer
+  // encoding. This method may only be called before Start() is called.
+  void EnableChunkedUpload();
+
+  // Appends the given bytes to the request's upload data to be sent
+  // immediately via chunked transfer encoding. When all data has been sent,
+  // call MarkEndOfChunks() to indicate the end of upload data.
+  //
+  // This method may be called only after calling EnableChunkedUpload().
+  void AppendChunkToUpload(const char* bytes,
+                           int bytes_len,
+                           bool is_last_chunk);
+
+  // Sets the upload data.
+  void set_upload(scoped_ptr<UploadDataStream> upload);
+
+  // Gets the upload data.
+  const UploadDataStream* get_upload() const;
+
+  // Returns true if the request has a non-empty message body to upload.
+  bool has_upload() const;
+
+  // Set an extra request header by ID or name, or remove one by name.  These
+  // methods may only be called before Start() is called, or before a new
+  // redirect in the request chain.
+  void SetExtraRequestHeaderById(int header_id, const std::string& value,
+                                 bool overwrite);
+  void SetExtraRequestHeaderByName(const std::string& name,
+                                   const std::string& value, bool overwrite);
+  void RemoveRequestHeaderByName(const std::string& name);
+
+  // Sets all extra request headers.  Any extra request headers set by other
+  // methods are overwritten by this method.  This method may only be called
+  // before Start() is called.  It is an error to call it later.
+  void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
+
+  const HttpRequestHeaders& extra_request_headers() const {
+    return extra_request_headers_;
+  }
+
+  // Returns the current load state for the request. |param| is an optional
+  // parameter describing details related to the load state. Not all load states
+  // have a parameter.
+  LoadStateWithParam GetLoadState() const;
+  void SetLoadStateParam(const string16& param) {
+    load_state_param_ = param;
+  }
+
+  // Returns the current upload progress in bytes. When the upload data is
+  // chunked, size is set to zero, but position will not be.
+  UploadProgress GetUploadProgress() const;
+
+  // Get response header(s) by ID or name.  These methods may only be called
+  // once the delegate's OnResponseStarted method has been called.  Headers
+  // that appear more than once in the response are coalesced, with values
+  // separated by commas (per RFC 2616). This will not work with cookies since
+  // comma can be used in cookie values.
+  // TODO(darin): add API to enumerate response headers.
+  void GetResponseHeaderById(int header_id, std::string* value);
+  void GetResponseHeaderByName(const std::string& name, std::string* value);
+
+  // Get all response headers, \n-delimited and \n\0-terminated.  This includes
+  // the response status line.  Restrictions on GetResponseHeaders apply.
+  void GetAllResponseHeaders(std::string* headers);
+
+  // The time when |this| was constructed.
+  base::TimeTicks creation_time() const { return creation_time_; }
+
+  // The time at which the returned response was requested.  For cached
+  // responses, this is the last time the cache entry was validated.
+  const base::Time& request_time() const {
+    return response_info_.request_time;
+  }
+
+  // The time at which the returned response was generated.  For cached
+  // responses, this is the last time the cache entry was validated.
+  const base::Time& response_time() const {
+    return response_info_.response_time;
+  }
+
+  // Indicate if this response was fetched from disk cache.
+  bool was_cached() const { return response_info_.was_cached; }
+
+  // Returns true if the URLRequest was delivered through a proxy.
+  bool was_fetched_via_proxy() const {
+    return response_info_.was_fetched_via_proxy;
+  }
+
+  // Returns the host and port that the content was fetched from.  See
+  // http_response_info.h for caveats relating to cached content.
+  HostPortPair GetSocketAddress() const;
+
+  // Get all response headers, as a HttpResponseHeaders object.  See comments
+  // in HttpResponseHeaders class as to the format of the data.
+  HttpResponseHeaders* response_headers() const;
+
+  // Get the SSL connection info.
+  const SSLInfo& ssl_info() const {
+    return response_info_.ssl_info;
+  }
+
+  // Returns the cookie values included in the response, if the request is one
+  // that can have cookies.  Returns true if the request is a cookie-bearing
+  // type, false otherwise.  This method may only be called once the
+  // delegate's OnResponseStarted method has been called.
+  bool GetResponseCookies(ResponseCookies* cookies);
+
+  // Get the mime type.  This method may only be called once the delegate's
+  // OnResponseStarted method has been called.
+  void GetMimeType(std::string* mime_type);
+
+  // Get the charset (character encoding).  This method may only be called once
+  // the delegate's OnResponseStarted method has been called.
+  void GetCharset(std::string* charset);
+
+  // Returns the HTTP response code (e.g., 200, 404, and so on).  This method
+  // may only be called once the delegate's OnResponseStarted method has been
+  // called.  For non-HTTP requests, this method returns -1.
+  int GetResponseCode();
+
+  // Get the HTTP response info in its entirety.
+  const HttpResponseInfo& response_info() const { return response_info_; }
+
+  // Access the LOAD_* flags modifying this request (see load_flags.h).
+  int load_flags() const { return load_flags_; }
+  void set_load_flags(int flags) { load_flags_ = flags; }
+
+  // Returns true if the request is "pending" (i.e., if Start() has been called,
+  // and the response has not yet been called).
+  bool is_pending() const { return is_pending_; }
+
+  // Returns true if the request is in the process of redirecting to a new
+  // URL but has not yet initiated the new request.
+  bool is_redirecting() const { return is_redirecting_; }
+
+  // Returns the error status of the request.
+  const URLRequestStatus& status() const { return status_; }
+
+  // Returns a globally unique identifier for this request.
+  uint64 identifier() const { return identifier_; }
+
+  // This method is called to start the request.  The delegate will receive
+  // a OnResponseStarted callback when the request is started.
+  void Start();
+
+  // This method may be called at any time after Start() has been called to
+  // cancel the request.  This method may be called many times, and it has
+  // no effect once the response has completed.  It is guaranteed that no
+  // methods of the delegate will be called after the request has been
+  // cancelled, except that this may call the delegate's OnReadCompleted()
+  // during the call to Cancel itself.
+  void Cancel();
+
+  // Cancels the request and sets the error to |error| (see net_error_list.h
+  // for values).
+  void CancelWithError(int error);
+
+  // Cancels the request and sets the error to |error| (see net_error_list.h
+  // for values) and attaches |ssl_info| as the SSLInfo for that request.  This
+  // is useful to attach a certificate and certificate error to a canceled
+  // request.
+  void CancelWithSSLError(int error, const SSLInfo& ssl_info);
+
+  // Read initiates an asynchronous read from the response, and must only
+  // be called after the OnResponseStarted callback is received with a
+  // successful status.
+  // If data is available, Read will return true, and the data and length will
+  // be returned immediately.  If data is not available, Read returns false,
+  // and an asynchronous Read is initiated.  The Read is finished when
+  // the caller receives the OnReadComplete callback.  Unless the request was
+  // cancelled, OnReadComplete will always be called, even if the read failed.
+  //
+  // The buf parameter is a buffer to receive the data.  If the operation
+  // completes asynchronously, the implementation will reference the buffer
+  // until OnReadComplete is called.  The buffer must be at least max_bytes in
+  // length.
+  //
+  // The max_bytes parameter is the maximum number of bytes to read.
+  //
+  // The bytes_read parameter is an output parameter containing the
+  // the number of bytes read.  A value of 0 indicates that there is no
+  // more data available to read from the stream.
+  //
+  // If a read error occurs, Read returns false and the request->status
+  // will be set to an error.
+  bool Read(IOBuffer* buf, int max_bytes, int* bytes_read);
+
+  // If this request is being cached by the HTTP cache, stop subsequent caching.
+  // Note that this method has no effect on other (simultaneous or not) requests
+  // for the same resource. The typical example is a request that results in
+  // the data being stored to disk (downloaded instead of rendered) so we don't
+  // want to store it twice.
+  void StopCaching();
+
+  // This method may be called to follow a redirect that was deferred in
+  // response to an OnReceivedRedirect call.
+  void FollowDeferredRedirect();
+
+  // One of the following two methods should be called in response to an
+  // OnAuthRequired() callback (and only then).
+  // SetAuth will reissue the request with the given credentials.
+  // CancelAuth will give up and display the error page.
+  void SetAuth(const AuthCredentials& credentials);
+  void CancelAuth();
+
+  // This method can be called after the user selects a client certificate to
+  // instruct this URLRequest to continue with the request with the
+  // certificate.  Pass NULL if the user doesn't have a client certificate.
+  void ContinueWithCertificate(X509Certificate* client_cert);
+
+  // This method can be called after some error notifications to instruct this
+  // URLRequest to ignore the current error and continue with the request.  To
+  // cancel the request instead, call Cancel().
+  void ContinueDespiteLastError();
+
+  // Used to specify the context (cookie store, cache) for this request.
+  const URLRequestContext* context() const;
+
+  const BoundNetLog& net_log() const { return net_log_; }
+
+  // Returns the expected content size if available
+  int64 GetExpectedContentSize() const;
+
+  // Returns the priority level for this request.
+  RequestPriority priority() const { return priority_; }
+  void set_priority(RequestPriority priority) {
+    DCHECK_GE(priority, MINIMUM_PRIORITY);
+    DCHECK_LT(priority, NUM_PRIORITIES);
+    priority_ = priority;
+  }
+
+  // Returns true iff this request would be internally redirected to HTTPS
+  // due to HSTS. If so, |redirect_url| is rewritten to the new HTTPS URL.
+  bool GetHSTSRedirect(GURL* redirect_url) const;
+
+  // TODO(willchan): Undo this. Only temporarily public.
+  bool has_delegate() const { return delegate_ != NULL; }
+
+  // NOTE(willchan): This is just temporary for debugging
+  // http://crbug.com/90971.
+  // Allows to setting debug info into the URLRequest.
+  void set_stack_trace(const base::debug::StackTrace& stack_trace);
+  const base::debug::StackTrace* stack_trace() const;
+
+  void set_received_response_content_length(int64 received_content_length) {
+    received_response_content_length_ = received_content_length;
+  }
+  int64 received_response_content_length() {
+    return received_response_content_length_;
+  }
+
+ protected:
+  // Allow the URLRequestJob class to control the is_pending() flag.
+  void set_is_pending(bool value) { is_pending_ = value; }
+
+  // Allow the URLRequestJob class to set our status too
+  void set_status(const URLRequestStatus& value) { status_ = value; }
+
+  // Allow the URLRequestJob to redirect this request.  Returns OK if
+  // successful, otherwise an error code is returned.
+  int Redirect(const GURL& location, int http_status_code);
+
+  // Called by URLRequestJob to allow interception when a redirect occurs.
+  void NotifyReceivedRedirect(const GURL& location, bool* defer_redirect);
+
+  // Allow an interceptor's URLRequestJob to restart this request.
+  // Should only be called if the original job has not started a response.
+  void Restart();
+
+ private:
+  friend class URLRequestJob;
+
+  // Registers a new protocol handler for the given scheme. If the scheme is
+  // already handled, this will overwrite the given factory. To delete the
+  // protocol factory, use NULL for the factory BUT this WILL NOT put back
+  // any previously registered protocol factory. It will have returned
+  // the previously registered factory (or NULL if none is registered) when
+  // the scheme was first registered so that the caller can manually put it
+  // back if desired.
+  //
+  // The scheme must be all-lowercase ASCII. See the ProtocolFactory
+  // declaration for its requirements.
+  //
+  // The registered protocol factory may return NULL, which will cause the
+  // regular "built-in" protocol factory to be used.
+  //
+  static ProtocolFactory* RegisterProtocolFactory(const std::string& scheme,
+                                                  ProtocolFactory* factory);
+
+  // Registers or unregisters a network interception class.
+  static void RegisterRequestInterceptor(Interceptor* interceptor);
+  static void UnregisterRequestInterceptor(Interceptor* interceptor);
+
+  // Resumes or blocks a request paused by the NetworkDelegate::OnBeforeRequest
+  // handler. If |blocked| is true, the request is blocked and an error page is
+  // returned indicating so. This should only be called after Start is called
+  // and OnBeforeRequest returns true (signalling that the request should be
+  // paused).
+  void BeforeRequestComplete(int error);
+
+  void StartJob(URLRequestJob* job);
+
+  // Restarting involves replacing the current job with a new one such as what
+  // happens when following a HTTP redirect.
+  void RestartWithJob(URLRequestJob* job);
+  void PrepareToRestart();
+
+  // Detaches the job from this request in preparation for this object going
+  // away or the job being replaced. The job will not call us back when it has
+  // been orphaned.
+  void OrphanJob();
+
+  // Cancels the request and set the error and ssl info for this request to the
+  // passed values.
+  void DoCancel(int error, const SSLInfo& ssl_info);
+
+  // Notifies the network delegate that the request has been completed.
+  // This does not imply a successful completion. Also a canceled request is
+  // considered completed.
+  void NotifyRequestCompleted();
+
+  // Called by URLRequestJob to allow interception when the final response
+  // occurs.
+  void NotifyResponseStarted();
+
+  // These functions delegate to |delegate_| and may only be used if
+  // |delegate_| is not NULL. See URLRequest::Delegate for the meaning
+  // of these functions.
+  void NotifyAuthRequired(AuthChallengeInfo* auth_info);
+  void NotifyAuthRequiredComplete(NetworkDelegate::AuthRequiredResponse result);
+  void NotifyCertificateRequested(SSLCertRequestInfo* cert_request_info);
+  void NotifySSLCertificateError(const SSLInfo& ssl_info, bool fatal);
+  void NotifyReadCompleted(int bytes_read);
+
+  // These functions delegate to |network_delegate_| if it is not NULL.
+  // If |network_delegate_| is NULL, cookies can be used unless
+  // SetDefaultCookiePolicyToBlock() has been called.
+  bool CanGetCookies(const CookieList& cookie_list) const;
+  bool CanSetCookie(const std::string& cookie_line,
+                    CookieOptions* options) const;
+
+  // Called when the delegate blocks or unblocks this request when intercepting
+  // certain requests.
+  void SetBlockedOnDelegate();
+  void SetUnblockedOnDelegate();
+
+  // Contextual information used for this request. Cannot be NULL. This contains
+  // most of the dependencies which are shared between requests (disk cache,
+  // cookie store, socket pool, etc.)
+  const URLRequestContext* context_;
+
+  NetworkDelegate* network_delegate_;
+
+  // Tracks the time spent in various load states throughout this request.
+  BoundNetLog net_log_;
+
+  scoped_refptr<URLRequestJob> job_;
+  scoped_ptr<UploadDataStream> upload_data_stream_;
+  std::vector<GURL> url_chain_;
+  GURL first_party_for_cookies_;
+  GURL delegate_redirect_url_;
+  std::string method_;  // "GET", "POST", etc. Should be all uppercase.
+  std::string referrer_;
+  ReferrerPolicy referrer_policy_;
+  HttpRequestHeaders extra_request_headers_;
+  int load_flags_;  // Flags indicating the request type for the load;
+                    // expected values are LOAD_* enums above.
+
+  // Never access methods of the |delegate_| directly. Always use the
+  // Notify... methods for this.
+  Delegate* delegate_;
+
+  // Current error status of the job. When no error has been encountered, this
+  // will be SUCCESS. If multiple errors have been encountered, this will be
+  // the first non-SUCCESS status seen.
+  URLRequestStatus status_;
+
+  // The HTTP response info, lazily initialized.
+  HttpResponseInfo response_info_;
+
+  // Tells us whether the job is outstanding. This is true from the time
+  // Start() is called to the time we dispatch RequestComplete and indicates
+  // whether the job is active.
+  bool is_pending_;
+
+  // Indicates if the request is in the process of redirecting to a new
+  // location.  It is true from the time the headers complete until a
+  // new request begins.
+  bool is_redirecting_;
+
+  // Number of times we're willing to redirect.  Used to guard against
+  // infinite redirects.
+  int redirect_limit_;
+
+  // Cached value for use after we've orphaned the job handling the
+  // first transaction in a request involving redirects.
+  UploadProgress final_upload_progress_;
+
+  // The priority level for this request.  Objects like ClientSocketPool use
+  // this to determine which URLRequest to allocate sockets to first.
+  RequestPriority priority_;
+
+  // TODO(battre): The only consumer of the identifier_ is currently the
+  // web request API. We need to match identifiers of requests between the
+  // web request API and the web navigation API. As the URLRequest does not
+  // exist when the web navigation API is triggered, the tracking probably
+  // needs to be done outside of the URLRequest anyway. Therefore, this
+  // identifier should be deleted here. http://crbug.com/89321
+  // A globally unique identifier for this request.
+  const uint64 identifier_;
+
+  // True if this request is blocked waiting for the network delegate to resume
+  // it.
+  bool blocked_on_delegate_;
+
+  // An optional parameter that provides additional information about the load
+  // state. Only used with the LOAD_STATE_WAITING_FOR_DELEGATE state.
+  string16 load_state_param_;
+
+  base::debug::LeakTracker<URLRequest> leak_tracker_;
+
+  // Callback passed to the network delegate to notify us when a blocked request
+  // is ready to be resumed or canceled.
+  CompletionCallback before_request_callback_;
+
+  // Safe-guard to ensure that we do not send multiple "I am completed"
+  // messages to network delegate.
+  // TODO(battre): Remove this. http://crbug.com/89049
+  bool has_notified_completion_;
+
+  // Authentication data used by the NetworkDelegate for this request,
+  // if one is present. |auth_credentials_| may be filled in when calling
+  // |NotifyAuthRequired| on the NetworkDelegate. |auth_info_| holds
+  // the authentication challenge being handled by |NotifyAuthRequired|.
+  AuthCredentials auth_credentials_;
+  scoped_refptr<AuthChallengeInfo> auth_info_;
+
+  int64 received_response_content_length_;
+
+  base::TimeTicks creation_time_;
+
+  scoped_ptr<const base::debug::StackTrace> stack_trace_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequest);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_H_
diff --git a/src/net/url_request/url_request_about_job.cc b/src/net/url_request/url_request_about_job.cc
new file mode 100644
index 0000000..242a735
--- /dev/null
+++ b/src/net/url_request/url_request_about_job.cc
@@ -0,0 +1,50 @@
+// 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.
+
+// Simple implementation of about: protocol handler that treats everything as
+// about:blank.  No other about: features should be available to web content,
+// so they're not implemented here.
+
+#include "net/url_request/url_request_about_job.h"
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+
+namespace net {
+
+URLRequestAboutJob::URLRequestAboutJob(URLRequest* request,
+                                       NetworkDelegate* network_delegate)
+    : URLRequestJob(request, network_delegate),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+}
+
+// static
+URLRequestJob* URLRequestAboutJob::Factory(URLRequest* request,
+                                           NetworkDelegate* network_delegate,
+                                           const std::string& scheme) {
+  return new URLRequestAboutJob(request, network_delegate);
+}
+
+void URLRequestAboutJob::Start() {
+  // Start reading asynchronously so that all error reporting and data
+  // callbacks happen as they would for network requests.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestAboutJob::StartAsync, weak_factory_.GetWeakPtr()));
+}
+
+bool URLRequestAboutJob::GetMimeType(std::string* mime_type) const {
+  *mime_type = "text/html";
+  return true;
+}
+
+URLRequestAboutJob::~URLRequestAboutJob() {
+}
+
+void URLRequestAboutJob::StartAsync() {
+  NotifyHeadersComplete();
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_about_job.h b/src/net/url_request/url_request_about_job.h
new file mode 100644
index 0000000..ea2b83f
--- /dev/null
+++ b/src/net/url_request/url_request_about_job.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_ABOUT_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_ABOUT_JOB_H_
+
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_job.h"
+
+namespace net {
+
+class NET_EXPORT URLRequestAboutJob : public URLRequestJob {
+ public:
+  URLRequestAboutJob(URLRequest* request, NetworkDelegate* network_delegate);
+
+  static URLRequest::ProtocolFactory Factory;
+
+  // URLRequestJob:
+  virtual void Start() OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+
+ private:
+  virtual ~URLRequestAboutJob();
+
+  void StartAsync();
+
+  base::WeakPtrFactory<URLRequestAboutJob> weak_factory_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_ABOUT_JOB_H_
diff --git a/src/net/url_request/url_request_context.cc b/src/net/url_request/url_request_context.cc
new file mode 100644
index 0000000..7dd2bb3
--- /dev/null
+++ b/src/net/url_request/url_request_context.cc
@@ -0,0 +1,128 @@
+// 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 "net/url_request/url_request_context.h"
+
+#include "base/compiler_specific.h"
+#include "base/debug/alias.h"
+#include "base/debug/stack_trace.h"
+#include "base/string_util.h"
+#include "net/base/host_resolver.h"
+#include "net/cookies/cookie_store.h"
+#include "net/ftp/ftp_transaction_factory.h"
+#include "net/http/http_transaction_factory.h"
+#include "net/url_request/http_user_agent_settings.h"
+#include "net/url_request/url_request.h"
+
+namespace net {
+
+URLRequestContext::URLRequestContext()
+    : net_log_(NULL),
+      host_resolver_(NULL),
+      cert_verifier_(NULL),
+      server_bound_cert_service_(NULL),
+      fraudulent_certificate_reporter_(NULL),
+      http_auth_handler_factory_(NULL),
+      proxy_service_(NULL),
+      network_delegate_(NULL),
+      http_server_properties_(NULL),
+      http_user_agent_settings_(NULL),
+      transport_security_state_(NULL),
+#if !defined(DISABLE_FTP_SUPPORT)
+      ftp_auth_cache_(new FtpAuthCache),
+#endif
+      http_transaction_factory_(NULL),
+      ftp_transaction_factory_(NULL),
+      job_factory_(NULL),
+      throttler_manager_(NULL),
+      url_requests_(new std::set<const URLRequest*>) {
+}
+
+URLRequestContext::~URLRequestContext() {
+#if !defined(__LB_SHELL__FOR_RELEASE__)
+  AssertNoURLRequests();
+#endif
+}
+
+void URLRequestContext::CopyFrom(const URLRequestContext* other) {
+  // Copy URLRequestContext parameters.
+  set_net_log(other->net_log_);
+  set_host_resolver(other->host_resolver_);
+  set_cert_verifier(other->cert_verifier_);
+  set_server_bound_cert_service(other->server_bound_cert_service_);
+  set_fraudulent_certificate_reporter(other->fraudulent_certificate_reporter_);
+  set_http_auth_handler_factory(other->http_auth_handler_factory_);
+  set_proxy_service(other->proxy_service_);
+  set_ssl_config_service(other->ssl_config_service_);
+  set_network_delegate(other->network_delegate_);
+  set_http_server_properties(other->http_server_properties_);
+  set_cookie_store(other->cookie_store_);
+  set_transport_security_state(other->transport_security_state_);
+  // FTPAuthCache is unique per context.
+  set_http_transaction_factory(other->http_transaction_factory_);
+  set_ftp_transaction_factory(other->ftp_transaction_factory_);
+  set_job_factory(other->job_factory_);
+  set_throttler_manager(other->throttler_manager_);
+  set_http_user_agent_settings(other->http_user_agent_settings_);
+}
+
+const HttpNetworkSession::Params* URLRequestContext::GetNetworkSessionParams(
+    ) const {
+  HttpTransactionFactory* transaction_factory = http_transaction_factory();
+  if (!transaction_factory)
+    return NULL;
+  HttpNetworkSession* network_session = transaction_factory->GetSession();
+  if (!network_session)
+    return NULL;
+  return &network_session->params();
+}
+
+URLRequest* URLRequestContext::CreateRequest(
+    const GURL& url, URLRequest::Delegate* delegate) const {
+  return new URLRequest(url, delegate, this, network_delegate_);
+}
+
+void URLRequestContext::set_cookie_store(CookieStore* cookie_store) {
+  cookie_store_ = cookie_store;
+}
+
+std::string URLRequestContext::GetAcceptCharset() const {
+  return http_user_agent_settings_ ?
+      http_user_agent_settings_->GetAcceptCharset() : EmptyString();
+}
+
+std::string URLRequestContext::GetAcceptLanguage() const {
+  return http_user_agent_settings_ ?
+      http_user_agent_settings_->GetAcceptLanguage() : EmptyString();
+}
+
+std::string URLRequestContext::GetUserAgent() const {
+  return http_user_agent_settings_ ? http_user_agent_settings_->GetUserAgent()
+                                   : EmptyString();
+}
+
+void URLRequestContext::AssertNoURLRequests() const {
+  int num_requests = url_requests_->size();
+  if (num_requests != 0) {
+    // We're leaking URLRequests :( Dump the URL of the first one and record how
+    // many we leaked so we have an idea of how bad it is.
+    char url_buf[128];
+    const URLRequest* request = *url_requests_->begin();
+    base::strlcpy(url_buf, request->url().spec().c_str(), arraysize(url_buf));
+    bool has_delegate = request->has_delegate();
+    int load_flags = request->load_flags();
+    base::debug::StackTrace stack_trace(NULL, 0);
+    if (request->stack_trace())
+      stack_trace = *request->stack_trace();
+    base::debug::Alias(url_buf);
+    base::debug::Alias(&num_requests);
+    base::debug::Alias(&has_delegate);
+    base::debug::Alias(&load_flags);
+    base::debug::Alias(&stack_trace);
+    CHECK(false) << "Leaked " << num_requests << " URLRequest(s). First URL: "
+                 << request->url().spec().c_str() << ".";
+  }
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_context.h b/src/net/url_request/url_request_context.h
new file mode 100644
index 0000000..f843789
--- /dev/null
+++ b/src/net/url_request/url_request_context.h
@@ -0,0 +1,264 @@
+// 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.
+
+// This class represents contextual information (cookies, cache, etc.)
+// that's useful when processing resource requests.
+// The class is reference-counted so that it can be cleaned up after any
+// requests that are using it have been completed.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
+#define NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
+
+#include <set>
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/non_thread_safe.h"
+#include "net/base/net_export.h"
+#include "net/base/net_log.h"
+#include "net/base/ssl_config_service.h"
+#include "net/base/transport_security_state.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_server_properties.h"
+#include "net/ftp/ftp_auth_cache.h"
+#include "net/url_request/url_request.h"
+
+namespace net {
+class CertVerifier;
+class CookieStore;
+class FraudulentCertificateReporter;
+class FtpTransactionFactory;
+class HostResolver;
+class HttpAuthHandlerFactory;
+class HttpTransactionFactory;
+class HttpUserAgentSettings;
+class NetworkDelegate;
+class ServerBoundCertService;
+class ProxyService;
+class URLRequest;
+class URLRequestJobFactory;
+class URLRequestThrottlerManager;
+
+// Subclass to provide application-specific context for URLRequest
+// instances. Note that URLRequestContext typically does not provide storage for
+// these member variables, since they may be shared. For the ones that aren't
+// shared, URLRequestContextStorage can be helpful in defining their storage.
+class NET_EXPORT URLRequestContext
+    : NON_EXPORTED_BASE(public base::NonThreadSafe) {
+ public:
+  URLRequestContext();
+  virtual ~URLRequestContext();
+
+  // Copies the state from |other| into this context.
+  void CopyFrom(const URLRequestContext* other);
+
+  // May return NULL if this context doesn't have an associated network session.
+  const HttpNetworkSession::Params* GetNetworkSessionParams() const;
+
+  URLRequest* CreateRequest(
+      const GURL& url, URLRequest::Delegate* delegate) const;
+
+  NetLog* net_log() const {
+    return net_log_;
+  }
+
+  void set_net_log(NetLog* net_log) {
+    net_log_ = net_log;
+  }
+
+  HostResolver* host_resolver() const {
+    return host_resolver_;
+  }
+
+  void set_host_resolver(HostResolver* host_resolver) {
+    host_resolver_ = host_resolver;
+  }
+
+  CertVerifier* cert_verifier() const {
+    return cert_verifier_;
+  }
+
+  void set_cert_verifier(CertVerifier* cert_verifier) {
+    cert_verifier_ = cert_verifier;
+  }
+
+  ServerBoundCertService* server_bound_cert_service() const {
+    return server_bound_cert_service_;
+  }
+
+  void set_server_bound_cert_service(
+      ServerBoundCertService* server_bound_cert_service) {
+    server_bound_cert_service_ = server_bound_cert_service;
+  }
+
+  FraudulentCertificateReporter* fraudulent_certificate_reporter() const {
+    return fraudulent_certificate_reporter_;
+  }
+  void set_fraudulent_certificate_reporter(
+      FraudulentCertificateReporter* fraudulent_certificate_reporter) {
+    fraudulent_certificate_reporter_ = fraudulent_certificate_reporter;
+  }
+
+  // Get the proxy service for this context.
+  ProxyService* proxy_service() const { return proxy_service_; }
+  void set_proxy_service(ProxyService* proxy_service) {
+    proxy_service_ = proxy_service;
+  }
+
+  // Get the ssl config service for this context.
+  SSLConfigService* ssl_config_service() const { return ssl_config_service_; }
+  void set_ssl_config_service(SSLConfigService* service) {
+    ssl_config_service_ = service;
+  }
+
+  // Gets the HTTP Authentication Handler Factory for this context.
+  // The factory is only valid for the lifetime of this URLRequestContext
+  HttpAuthHandlerFactory* http_auth_handler_factory() const {
+    return http_auth_handler_factory_;
+  }
+  void set_http_auth_handler_factory(HttpAuthHandlerFactory* factory) {
+    http_auth_handler_factory_ = factory;
+  }
+
+  // Gets the http transaction factory for this context.
+  HttpTransactionFactory* http_transaction_factory() const {
+    return http_transaction_factory_;
+  }
+  void set_http_transaction_factory(HttpTransactionFactory* factory) {
+    http_transaction_factory_ = factory;
+  }
+
+  // Gets the ftp transaction factory for this context.
+  FtpTransactionFactory* ftp_transaction_factory() const {
+    return ftp_transaction_factory_;
+  }
+  void set_ftp_transaction_factory(FtpTransactionFactory* factory) {
+    ftp_transaction_factory_ = factory;
+  }
+
+  void set_network_delegate(NetworkDelegate* network_delegate) {
+    network_delegate_ = network_delegate;
+  }
+  NetworkDelegate* network_delegate() const { return network_delegate_; }
+
+  void set_http_server_properties(
+      HttpServerProperties* http_server_properties) {
+    http_server_properties_ = http_server_properties;
+  }
+  HttpServerProperties* http_server_properties() const {
+    return http_server_properties_;
+  }
+
+  // Gets the cookie store for this context (may be null, in which case
+  // cookies are not stored).
+  CookieStore* cookie_store() const { return cookie_store_.get(); }
+  void set_cookie_store(CookieStore* cookie_store);
+
+  TransportSecurityState* transport_security_state() const {
+      return transport_security_state_;
+  }
+  void set_transport_security_state(
+      TransportSecurityState* state) {
+    transport_security_state_ = state;
+  }
+
+  // Gets the FTP authentication cache for this context.
+  FtpAuthCache* ftp_auth_cache() const {
+#if !defined(DISABLE_FTP_SUPPORT)
+    return ftp_auth_cache_.get();
+#else
+    return NULL;
+#endif
+  }
+
+  // ---------------------------------------------------------------------------
+  // Legacy accessors that delegate to http_user_agent_settings_.
+  // TODO(pauljensen): Remove after all clients are updated to directly access
+  // http_user_agent_settings_.
+  // Gets the value of 'Accept-Charset' header field.
+  std::string GetAcceptCharset() const;
+  // Gets the value of 'Accept-Language' header field.
+  std::string GetAcceptLanguage() const;
+  // Gets the UA string.
+  std::string GetUserAgent() const;
+  // ---------------------------------------------------------------------------
+
+  const URLRequestJobFactory* job_factory() const { return job_factory_; }
+  void set_job_factory(const URLRequestJobFactory* job_factory) {
+    job_factory_ = job_factory;
+  }
+
+  // May be NULL.
+  URLRequestThrottlerManager* throttler_manager() const {
+    return throttler_manager_;
+  }
+  void set_throttler_manager(URLRequestThrottlerManager* throttler_manager) {
+    throttler_manager_ = throttler_manager;
+  }
+
+  // Gets the URLRequest objects that hold a reference to this
+  // URLRequestContext.
+  std::set<const URLRequest*>* url_requests() const {
+    return url_requests_.get();
+  }
+
+  void AssertNoURLRequests() const;
+
+  // Get the underlying |HttpUserAgentSettings| implementation that provides
+  // the HTTP Accept-Language, Accept-Charset and User-Agent header values.
+  const HttpUserAgentSettings* http_user_agent_settings() const {
+    return http_user_agent_settings_;
+  }
+  void set_http_user_agent_settings(
+      HttpUserAgentSettings* http_user_agent_settings) {
+    http_user_agent_settings_ = http_user_agent_settings;
+  }
+
+ private:
+  // ---------------------------------------------------------------------------
+  // Important: When adding any new members below, consider whether they need to
+  // be added to CopyFrom.
+  // ---------------------------------------------------------------------------
+
+  // Ownership for these members are not defined here. Clients should either
+  // provide storage elsewhere or have a subclass take ownership.
+  NetLog* net_log_;
+  HostResolver* host_resolver_;
+  CertVerifier* cert_verifier_;
+  ServerBoundCertService* server_bound_cert_service_;
+  FraudulentCertificateReporter* fraudulent_certificate_reporter_;
+  HttpAuthHandlerFactory* http_auth_handler_factory_;
+  ProxyService* proxy_service_;
+  scoped_refptr<SSLConfigService> ssl_config_service_;
+  NetworkDelegate* network_delegate_;
+  HttpServerProperties* http_server_properties_;
+  HttpUserAgentSettings* http_user_agent_settings_;
+  scoped_refptr<CookieStore> cookie_store_;
+  TransportSecurityState* transport_security_state_;
+#if !defined(DISABLE_FTP_SUPPORT)
+  scoped_ptr<FtpAuthCache> ftp_auth_cache_;
+#endif
+  // The charset of the referrer where this request comes from. It's not
+  // used in communication with a server but is used to construct a suggested
+  // filename for file download.
+  HttpTransactionFactory* http_transaction_factory_;
+  FtpTransactionFactory* ftp_transaction_factory_;
+  const URLRequestJobFactory* job_factory_;
+  URLRequestThrottlerManager* throttler_manager_;
+
+  // ---------------------------------------------------------------------------
+  // Important: When adding any new members below, consider whether they need to
+  // be added to CopyFrom.
+  // ---------------------------------------------------------------------------
+
+  scoped_ptr<std::set<const URLRequest*> > url_requests_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestContext);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
diff --git a/src/net/url_request/url_request_context_builder.cc b/src/net/url_request/url_request_context_builder.cc
new file mode 100644
index 0000000..232ed22
--- /dev/null
+++ b/src/net/url_request/url_request_context_builder.cc
@@ -0,0 +1,304 @@
+// 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 "net/url_request/url_request_context_builder.h"
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "base/threading/thread.h"
+#include "base/thread_task_runner_handle.h"
+#include "net/base/cert_verifier.h"
+#include "net/base/host_resolver.h"
+#include "net/base/net_errors.h"
+#include "net/base/network_delegate.h"
+#include "net/base/ssl_config_service_defaults.h"
+#include "net/base/transport_security_state.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/ftp/ftp_network_layer.h"
+#include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_cache.h"
+#include "net/http/http_network_layer.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_server_properties_impl.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/static_http_user_agent_settings.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_storage.h"
+
+namespace net {
+
+namespace {
+
+class BasicNetworkDelegate : public NetworkDelegate {
+ public:
+  BasicNetworkDelegate() {}
+  virtual ~BasicNetworkDelegate() {}
+
+ private:
+  virtual int OnBeforeURLRequest(URLRequest* request,
+                                 const CompletionCallback& callback,
+                                 GURL* new_url) OVERRIDE {
+    return OK;
+  }
+
+  virtual int OnBeforeSendHeaders(URLRequest* request,
+                                  const CompletionCallback& callback,
+                                  HttpRequestHeaders* headers) OVERRIDE {
+    return OK;
+  }
+
+  virtual void OnSendHeaders(URLRequest* request,
+                             const HttpRequestHeaders& headers) OVERRIDE {}
+
+  virtual int OnHeadersReceived(
+      URLRequest* request,
+      const CompletionCallback& callback,
+      const HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers)
+      OVERRIDE {
+    return OK;
+  }
+
+  virtual void OnBeforeRedirect(URLRequest* request,
+                                const GURL& new_location) OVERRIDE {}
+
+  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {}
+
+  virtual void OnRawBytesRead(const URLRequest& request,
+                              int bytes_read) OVERRIDE {}
+
+  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE {}
+
+  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE {}
+
+  virtual void OnPACScriptError(int line_number,
+                                const string16& error) OVERRIDE {}
+
+  virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
+      URLRequest* request,
+      const AuthChallengeInfo& auth_info,
+      const AuthCallback& callback,
+      AuthCredentials* credentials) OVERRIDE {
+    return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  }
+
+  virtual bool OnCanGetCookies(const URLRequest& request,
+                               const CookieList& cookie_list) OVERRIDE {
+    return true;
+  }
+
+  virtual bool OnCanSetCookie(const URLRequest& request,
+                              const std::string& cookie_line,
+                              CookieOptions* options) OVERRIDE {
+    return true;
+  }
+
+  virtual bool OnCanAccessFile(const net::URLRequest& request,
+                               const FilePath& path) const OVERRIDE {
+    return true;
+  }
+
+  virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
+    return false;
+  }
+
+  virtual int OnBeforeSocketStreamConnect(
+      SocketStream* stream,
+      const CompletionCallback& callback) OVERRIDE {
+    return OK;
+  }
+
+  virtual void OnRequestWaitStateChange(const URLRequest& request,
+                                        RequestWaitState state) OVERRIDE {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
+};
+
+class BasicURLRequestContext : public URLRequestContext {
+ public:
+  BasicURLRequestContext()
+      : cache_thread_("Cache Thread"),
+        file_thread_("File Thread"),
+        ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) {}
+
+  URLRequestContextStorage* storage() {
+    return &storage_;
+  }
+
+  void StartCacheThread() {
+    cache_thread_.StartWithOptions(
+        base::Thread::Options(MessageLoop::TYPE_IO, 0));
+  }
+
+  scoped_refptr<base::MessageLoopProxy> cache_message_loop_proxy() {
+    DCHECK(cache_thread_.IsRunning());
+    return cache_thread_.message_loop_proxy();
+  }
+
+  void StartFileThread() {
+    file_thread_.StartWithOptions(
+        base::Thread::Options(MessageLoop::TYPE_DEFAULT, 0));
+  }
+
+  MessageLoop* file_message_loop() {
+    DCHECK(file_thread_.IsRunning());
+    return file_thread_.message_loop();
+  }
+
+ protected:
+  virtual ~BasicURLRequestContext() {}
+
+ private:
+  base::Thread cache_thread_;
+  base::Thread file_thread_;
+  URLRequestContextStorage storage_;
+  DISALLOW_COPY_AND_ASSIGN(BasicURLRequestContext);
+};
+
+}  // namespace
+
+URLRequestContextBuilder::HttpCacheParams::HttpCacheParams()
+    : type(IN_MEMORY),
+      max_size(0) {}
+URLRequestContextBuilder::HttpCacheParams::~HttpCacheParams() {}
+
+URLRequestContextBuilder::HttpNetworkSessionParams::HttpNetworkSessionParams()
+    : ignore_certificate_errors(false),
+      host_mapping_rules(NULL),
+      http_pipelining_enabled(false),
+      testing_fixed_http_port(0),
+      testing_fixed_https_port(0),
+      trusted_spdy_proxy() {}
+
+URLRequestContextBuilder::HttpNetworkSessionParams::~HttpNetworkSessionParams()
+{}
+
+URLRequestContextBuilder::URLRequestContextBuilder()
+    : ftp_enabled_(false),
+      http_cache_enabled_(true) {}
+URLRequestContextBuilder::~URLRequestContextBuilder() {}
+
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+void URLRequestContextBuilder::set_proxy_config_service(
+    ProxyConfigService* proxy_config_service) {
+  proxy_config_service_.reset(proxy_config_service);
+}
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+
+URLRequestContext* URLRequestContextBuilder::Build() {
+#if __LB_ENABLE_NATIVE_HTTP_STACK__
+  return NULL;
+#else
+  BasicURLRequestContext* context = new BasicURLRequestContext;
+  URLRequestContextStorage* storage = context->storage();
+
+  storage->set_http_user_agent_settings(new StaticHttpUserAgentSettings(
+      accept_language_, accept_charset_, user_agent_));
+
+  if (!network_delegate_)
+    network_delegate_.reset(new BasicNetworkDelegate);
+  storage->set_network_delegate(network_delegate_.release());
+
+  storage->set_host_resolver(net::HostResolver::CreateDefaultResolver(NULL));
+
+#if !DISABLE_FTP_SUPPORT
+  if (ftp_enabled_) {
+    storage->set_ftp_transaction_factory(
+        new FtpNetworkLayer(context->host_resolver()));
+  }
+#endif
+
+  context->StartFileThread();
+
+  // TODO(willchan): Switch to using this code when
+  // ProxyService::CreateSystemProxyConfigService()'s signature doesn't suck.
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  ProxyConfigService* proxy_config_service = proxy_config_service_.release();
+#else
+  ProxyConfigService* proxy_config_service =
+      ProxyService::CreateSystemProxyConfigService(
+          base::ThreadTaskRunnerHandle::Get(),
+          context->file_message_loop());
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+  storage->set_proxy_service(
+      ProxyService::CreateUsingSystemProxyResolver(
+          proxy_config_service,
+          4,  // TODO(willchan): Find a better constant somewhere.
+          context->net_log()));
+  storage->set_ssl_config_service(new net::SSLConfigServiceDefaults);
+  storage->set_http_auth_handler_factory(
+      net::HttpAuthHandlerRegistryFactory::CreateDefault(
+          context->host_resolver()));
+  storage->set_cookie_store(new CookieMonster(NULL, NULL));
+  storage->set_transport_security_state(new net::TransportSecurityState());
+  storage->set_http_server_properties(new net::HttpServerPropertiesImpl);
+  storage->set_cert_verifier(CertVerifier::CreateDefault());
+
+  net::HttpNetworkSession::Params network_session_params;
+  network_session_params.host_resolver = context->host_resolver();
+  network_session_params.cert_verifier = context->cert_verifier();
+  network_session_params.transport_security_state =
+      context->transport_security_state();
+  network_session_params.proxy_service = context->proxy_service();
+  network_session_params.ssl_config_service =
+      context->ssl_config_service();
+  network_session_params.http_auth_handler_factory =
+      context->http_auth_handler_factory();
+  network_session_params.network_delegate =
+      context->network_delegate();
+  network_session_params.http_server_properties =
+      context->http_server_properties();
+  network_session_params.net_log = context->net_log();
+  network_session_params.ignore_certificate_errors =
+      http_network_session_params_.ignore_certificate_errors;
+  network_session_params.host_mapping_rules =
+      http_network_session_params_.host_mapping_rules;
+  network_session_params.http_pipelining_enabled =
+      http_network_session_params_.http_pipelining_enabled;
+  network_session_params.testing_fixed_http_port =
+      http_network_session_params_.testing_fixed_http_port;
+  network_session_params.testing_fixed_https_port =
+      http_network_session_params_.testing_fixed_https_port;
+  network_session_params.trusted_spdy_proxy =
+      http_network_session_params_.trusted_spdy_proxy;
+
+  HttpTransactionFactory* http_transaction_factory = NULL;
+  if (http_cache_enabled_) {
+    network_session_params.server_bound_cert_service =
+        context->server_bound_cert_service();
+    HttpCache::BackendFactory* http_cache_backend = NULL;
+    if (http_cache_params_.type == HttpCacheParams::DISK) {
+      context->StartCacheThread();
+      http_cache_backend =
+          new HttpCache::DefaultBackend(DISK_CACHE,
+                                        http_cache_params_.path,
+                                        http_cache_params_.max_size,
+                                        context->cache_message_loop_proxy());
+    } else {
+      http_cache_backend =
+          HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);
+    }
+
+    http_transaction_factory = new HttpCache(
+        network_session_params, http_cache_backend);
+  } else {
+    scoped_refptr<net::HttpNetworkSession> network_session(
+        new net::HttpNetworkSession(network_session_params));
+
+    http_transaction_factory = new HttpNetworkLayer(network_session);
+  }
+  storage->set_http_transaction_factory(http_transaction_factory);
+
+  // TODO(willchan): Support sdch.
+
+  return context;
+#endif
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_context_builder.h b/src/net/url_request/url_request_context_builder.h
new file mode 100644
index 0000000..fd21f8a
--- /dev/null
+++ b/src/net/url_request/url_request_context_builder.h
@@ -0,0 +1,135 @@
+// 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.
+
+// This class is useful for building a simple URLRequestContext. Most creators
+// of new URLRequestContexts should use this helper class to construct it. Call
+// any configuration params, and when done, invoke Build() to construct the
+// URLRequestContext. This URLRequestContext will own all its own storage.
+//
+// URLRequestContextBuilder and its associated params classes are initially
+// populated with "sane" default values. Read through the comments to figure out
+// what these are.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
+#define NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "build/build_config.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+class HostMappingRules;
+class ProxyConfigService;
+class URLRequestContext;
+class NetworkDelegate;
+
+class NET_EXPORT URLRequestContextBuilder {
+ public:
+  struct NET_EXPORT HttpCacheParams {
+    enum Type {
+      IN_MEMORY,
+      DISK,
+    };
+
+    HttpCacheParams();
+    ~HttpCacheParams();
+
+    // The type of HTTP cache. Default is IN_MEMORY.
+    Type type;
+
+    // The max size of the cache in bytes. Default is algorithmically determined
+    // based off available disk space.
+    int max_size;
+
+    // The cache path (when type is DISK).
+    FilePath path;
+  };
+
+  struct NET_EXPORT HttpNetworkSessionParams {
+    HttpNetworkSessionParams();
+    ~HttpNetworkSessionParams();
+
+    // These fields mirror those in net::HttpNetworkSession::Params;
+    bool ignore_certificate_errors;
+    HostMappingRules* host_mapping_rules;
+    bool http_pipelining_enabled;
+    uint16 testing_fixed_http_port;
+    uint16 testing_fixed_https_port;
+    std::string trusted_spdy_proxy;
+  };
+
+  URLRequestContextBuilder();
+  ~URLRequestContextBuilder();
+
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  void set_proxy_config_service(ProxyConfigService* proxy_config_service);
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+
+  // Call these functions to specify hard-coded Accept-Language,
+  // Accept-Charset, or User-Agent header values for all requests that don't
+  // have the headers already set.
+  void set_accept_language(const std::string& accept_language) {
+    accept_language_ = accept_language;
+  }
+  void set_accept_charset(const std::string& accept_charset) {
+    accept_charset_ = accept_charset;
+  }
+  void set_user_agent(const std::string& user_agent) {
+    user_agent_ = user_agent;
+  }
+
+  // By default it's disabled.
+  void set_ftp_enabled(bool enable) {
+    ftp_enabled_ = enable;
+  }
+
+  // Uses BasicNetworkDelegate by default. Note that calling Build will unset
+  // any custom delegate in builder, so this must be called each time before
+  // Build is called.
+  void set_network_delegate(NetworkDelegate* delegate) {
+    network_delegate_.reset(delegate);
+  }
+
+  // By default HttpCache is enabled with a default constructed HttpCacheParams.
+  void EnableHttpCache(const HttpCacheParams& params) {
+    http_cache_params_ = params;
+  }
+
+  void DisableHttpCache() {
+    http_cache_params_ = HttpCacheParams();
+  }
+
+  // Override default net::HttpNetworkSession::Params settings.
+  void set_http_network_session_params(
+      const HttpNetworkSessionParams& http_network_session_params) {
+    http_network_session_params_ = http_network_session_params;
+  }
+
+  URLRequestContext* Build();
+
+ private:
+  std::string accept_language_;
+  std::string accept_charset_;
+  std::string user_agent_;
+  bool ftp_enabled_;
+  bool http_cache_enabled_;
+  HttpCacheParams http_cache_params_;
+  HttpNetworkSessionParams http_network_session_params_;
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  scoped_ptr<ProxyConfigService> proxy_config_service_;
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+  scoped_ptr<NetworkDelegate> network_delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestContextBuilder);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
diff --git a/src/net/url_request/url_request_context_builder_unittest.cc b/src/net/url_request/url_request_context_builder_unittest.cc
new file mode 100644
index 0000000..bc93416
--- /dev/null
+++ b/src/net/url_request/url_request_context_builder_unittest.cc
@@ -0,0 +1,83 @@
+// 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 "net/url_request/url_request_context_builder.h"
+
+#include "build/build_config.h"
+#include "net/test/test_server.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+#include "net/proxy/proxy_config.h"
+#include "net/proxy/proxy_config_service_fixed.h"
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+
+namespace net {
+
+namespace {
+
+// A subclass of TestServer that uses a statically-configured hostname. This is
+// to work around mysterious failures in chrome_frame_net_tests. See:
+// http://crbug.com/114369
+class LocalHttpTestServer : public TestServer {
+ public:
+  explicit LocalHttpTestServer(const FilePath& document_root)
+      : TestServer(TestServer::TYPE_HTTP,
+                   ScopedCustomUrlRequestTestHttpHost::value(),
+                   document_root) {}
+  LocalHttpTestServer()
+      : TestServer(TestServer::TYPE_HTTP,
+                   ScopedCustomUrlRequestTestHttpHost::value(),
+                   FilePath()) {}
+};
+
+class URLRequestContextBuilderTest : public PlatformTest {
+ protected:
+  URLRequestContextBuilderTest()
+      : test_server_(
+          FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))) {
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+    builder_.set_proxy_config_service(
+        new ProxyConfigServiceFixed(ProxyConfig::CreateDirect()));
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+  }
+
+  LocalHttpTestServer test_server_;
+  URLRequestContextBuilder builder_;
+};
+
+TEST_F(URLRequestContextBuilderTest, DefaultSettings) {
+  ASSERT_TRUE(test_server_.Start());
+
+  scoped_ptr<URLRequestContext> context(builder_.Build());
+  TestDelegate delegate;
+  URLRequest request(
+      test_server_.GetURL("echoheader?Foo"), &delegate, context.get());
+  request.set_method("GET");
+  request.SetExtraRequestHeaderByName("Foo", "Bar", false);
+  request.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("Bar", delegate.data_received());
+}
+
+TEST_F(URLRequestContextBuilderTest, UserAgent) {
+  ASSERT_TRUE(test_server_.Start());
+
+  builder_.set_user_agent("Bar");
+  scoped_ptr<URLRequestContext> context(builder_.Build());
+  TestDelegate delegate;
+  URLRequest request(
+      test_server_.GetURL("echoheader?User-Agent"), &delegate, context.get());
+  request.set_method("GET");
+  request.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("Bar", delegate.data_received());
+}
+
+}  // namespace
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_context_getter.cc b/src/net/url_request/url_request_context_getter.cc
new file mode 100644
index 0000000..44b7bf4
--- /dev/null
+++ b/src/net/url_request/url_request_context_getter.cc
@@ -0,0 +1,38 @@
+// 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 "net/url_request/url_request_context_getter.h"
+
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "net/url_request/url_request_context.h"
+
+namespace net {
+
+URLRequestContextGetter::URLRequestContextGetter() {}
+
+URLRequestContextGetter::~URLRequestContextGetter() {}
+
+void URLRequestContextGetter::OnDestruct() const {
+  scoped_refptr<base::SingleThreadTaskRunner> network_task_runner =
+      GetNetworkTaskRunner();
+  DCHECK(network_task_runner);
+  if (network_task_runner) {
+    if (network_task_runner->BelongsToCurrentThread()) {
+      delete this;
+    } else {
+      if (!network_task_runner->DeleteSoon(FROM_HERE, this)) {
+        // Can't force-delete the object here, because some derived classes
+        // can only be deleted on the owning thread, so just emit a warning to
+        // aid in debugging.
+        DLOG(WARNING) << "URLRequestContextGetter leaking due to no owning"
+                      << " thread.";
+      }
+    }
+  }
+  // If no IO message loop proxy was available, we will just leak memory.
+  // This is also true if the IO thread is gone.
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_context_getter.h b/src/net/url_request/url_request_context_getter.h
new file mode 100644
index 0000000..4c8e4af
--- /dev/null
+++ b/src/net/url_request/url_request_context_getter.h
@@ -0,0 +1,58 @@
+// 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.
+
+#ifndef CHROME_COMMON_NET_URL_REQUEST_CONTEXT_GETTER_H_
+#define CHROME_COMMON_NET_URL_REQUEST_CONTEXT_GETTER_H_
+
+#include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner_helpers.h"
+#include "net/base/net_export.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}  // namespace base
+
+namespace net {
+class CookieStore;
+class URLRequestContext;
+
+struct URLRequestContextGetterTraits;
+
+// Interface for retrieving an net::URLRequestContext.
+class NET_EXPORT URLRequestContextGetter
+    : public base::RefCountedThreadSafe<URLRequestContextGetter,
+                                        URLRequestContextGetterTraits> {
+ public:
+  virtual URLRequestContext* GetURLRequestContext() = 0;
+
+  // Returns a SingleThreadTaskRunner corresponding to the thread on
+  // which the network IO happens (the thread on which the returned
+  // net::URLRequestContext may be used).
+  virtual scoped_refptr<base::SingleThreadTaskRunner>
+      GetNetworkTaskRunner() const = 0;
+
+ protected:
+  friend class base::RefCountedThreadSafe<URLRequestContextGetter,
+                                          URLRequestContextGetterTraits>;
+  friend class base::DeleteHelper<URLRequestContextGetter>;
+  friend struct URLRequestContextGetterTraits;
+
+  URLRequestContextGetter();
+  virtual ~URLRequestContextGetter();
+
+ private:
+  // OnDestruct is meant to ensure deletion on the thread on which the request
+  // IO happens.
+  void OnDestruct() const;
+};
+
+struct URLRequestContextGetterTraits {
+  static void Destruct(const URLRequestContextGetter* context_getter) {
+    context_getter->OnDestruct();
+  }
+};
+
+}  // namespace net
+
+#endif  // CHROME_COMMON_NET_URL_REQUEST_CONTEXT_GETTER_H_
diff --git a/src/net/url_request/url_request_context_storage.cc b/src/net/url_request/url_request_context_storage.cc
new file mode 100644
index 0000000..cc57078
--- /dev/null
+++ b/src/net/url_request/url_request_context_storage.cc
@@ -0,0 +1,133 @@
+// 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 "net/url_request/url_request_context_storage.h"
+
+#include "base/logging.h"
+#include "net/base/cert_verifier.h"
+#include "net/base/host_resolver.h"
+#include "net/base/net_log.h"
+#include "net/base/network_delegate.h"
+#include "net/base/server_bound_cert_service.h"
+#include "net/cookies/cookie_store.h"
+#include "net/ftp/ftp_transaction_factory.h"
+#include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_server_properties.h"
+#include "net/http/http_transaction_factory.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/fraudulent_certificate_reporter.h"
+#include "net/url_request/http_user_agent_settings.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_job_factory.h"
+#include "net/url_request/url_request_throttler_manager.h"
+
+namespace net {
+
+URLRequestContextStorage::URLRequestContextStorage(URLRequestContext* context)
+    : context_(context) {
+  DCHECK(context);
+}
+
+URLRequestContextStorage::~URLRequestContextStorage() {}
+
+void URLRequestContextStorage::set_net_log(NetLog* net_log) {
+  context_->set_net_log(net_log);
+  net_log_.reset(net_log);
+}
+
+void URLRequestContextStorage::set_host_resolver(
+    scoped_ptr<HostResolver> host_resolver) {
+  context_->set_host_resolver(host_resolver.get());
+  host_resolver_ = host_resolver.Pass();
+}
+
+void URLRequestContextStorage::set_cert_verifier(CertVerifier* cert_verifier) {
+  context_->set_cert_verifier(cert_verifier);
+  cert_verifier_.reset(cert_verifier);
+}
+
+void URLRequestContextStorage::set_server_bound_cert_service(
+    ServerBoundCertService* server_bound_cert_service) {
+  context_->set_server_bound_cert_service(server_bound_cert_service);
+  server_bound_cert_service_.reset(server_bound_cert_service);
+}
+
+void URLRequestContextStorage::set_fraudulent_certificate_reporter(
+    FraudulentCertificateReporter* fraudulent_certificate_reporter) {
+  context_->set_fraudulent_certificate_reporter(
+      fraudulent_certificate_reporter);
+  fraudulent_certificate_reporter_.reset(fraudulent_certificate_reporter);
+}
+
+void URLRequestContextStorage::set_http_auth_handler_factory(
+    HttpAuthHandlerFactory* http_auth_handler_factory) {
+  context_->set_http_auth_handler_factory(http_auth_handler_factory);
+  http_auth_handler_factory_.reset(http_auth_handler_factory);
+}
+
+void URLRequestContextStorage::set_proxy_service(ProxyService* proxy_service) {
+  context_->set_proxy_service(proxy_service);
+  proxy_service_.reset(proxy_service);
+}
+
+void URLRequestContextStorage::set_ssl_config_service(
+    SSLConfigService* ssl_config_service) {
+  context_->set_ssl_config_service(ssl_config_service);
+  ssl_config_service_ = ssl_config_service;
+}
+
+void URLRequestContextStorage::set_network_delegate(
+    NetworkDelegate* network_delegate) {
+  context_->set_network_delegate(network_delegate);
+  network_delegate_.reset(network_delegate);
+}
+
+void URLRequestContextStorage::set_http_server_properties(
+    HttpServerProperties* http_server_properties) {
+  context_->set_http_server_properties(http_server_properties);
+  http_server_properties_.reset(http_server_properties);
+}
+
+void URLRequestContextStorage::set_cookie_store(CookieStore* cookie_store) {
+  context_->set_cookie_store(cookie_store);
+  cookie_store_ = cookie_store;
+}
+
+void URLRequestContextStorage::set_transport_security_state(
+    TransportSecurityState* transport_security_state) {
+  context_->set_transport_security_state(transport_security_state);
+  transport_security_state_.reset(transport_security_state);
+}
+
+void URLRequestContextStorage::set_http_transaction_factory(
+    HttpTransactionFactory* http_transaction_factory) {
+  context_->set_http_transaction_factory(http_transaction_factory);
+  http_transaction_factory_.reset(http_transaction_factory);
+}
+
+void URLRequestContextStorage::set_ftp_transaction_factory(
+    FtpTransactionFactory* ftp_transaction_factory) {
+  context_->set_ftp_transaction_factory(ftp_transaction_factory);
+  ftp_transaction_factory_.reset(ftp_transaction_factory);
+}
+
+void URLRequestContextStorage::set_job_factory(
+    URLRequestJobFactory* job_factory) {
+  context_->set_job_factory(job_factory);
+  job_factory_.reset(job_factory);
+}
+
+void URLRequestContextStorage::set_throttler_manager(
+    URLRequestThrottlerManager* throttler_manager) {
+  context_->set_throttler_manager(throttler_manager);
+  throttler_manager_.reset(throttler_manager);
+}
+
+void URLRequestContextStorage::set_http_user_agent_settings(
+    HttpUserAgentSettings* http_user_agent_settings) {
+  context_->set_http_user_agent_settings(http_user_agent_settings);
+  http_user_agent_settings_.reset(http_user_agent_settings);
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_context_storage.h b/src/net/url_request/url_request_context_storage.h
new file mode 100644
index 0000000..62f4c2a
--- /dev/null
+++ b/src/net/url_request/url_request_context_storage.h
@@ -0,0 +1,104 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_STORAGE_H_
+#define NET_URL_REQUEST_URL_REQUEST_CONTEXT_STORAGE_H_
+
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+class CertVerifier;
+class CookieStore;
+class FraudulentCertificateReporter;
+class FtpTransactionFactory;
+class HostResolver;
+class HttpAuthHandlerFactory;
+class HttpServerProperties;
+class HttpTransactionFactory;
+class HttpUserAgentSettings;
+class NetLog;
+class NetworkDelegate;
+class ServerBoundCertService;
+class ProxyService;
+class SSLConfigService;
+class TransportSecurityState;
+class URLRequestContext;
+class URLRequestJobFactory;
+class URLRequestThrottlerManager;
+
+// URLRequestContextStorage is a helper class that provides storage for unowned
+// member variables of URLRequestContext.
+class NET_EXPORT URLRequestContextStorage {
+ public:
+  // Note that URLRequestContextStorage does not acquire a reference to
+  // URLRequestContext, since it is often designed to be embedded in a
+  // URLRequestContext subclass.
+  explicit URLRequestContextStorage(URLRequestContext* context);
+  ~URLRequestContextStorage();
+
+  // These setters will set both the member variables and call the setter on the
+  // URLRequestContext object. In all cases, ownership is passed to |this|.
+
+  void set_net_log(NetLog* net_log);
+  void set_host_resolver(scoped_ptr<HostResolver> host_resolver);
+  void set_cert_verifier(CertVerifier* cert_verifier);
+  void set_server_bound_cert_service(
+      ServerBoundCertService* server_bound_cert_service);
+  void set_fraudulent_certificate_reporter(
+      FraudulentCertificateReporter* fraudulent_certificate_reporter);
+  void set_http_auth_handler_factory(
+      HttpAuthHandlerFactory* http_auth_handler_factory);
+  void set_proxy_service(ProxyService* proxy_service);
+  void set_ssl_config_service(SSLConfigService* ssl_config_service);
+  void set_network_delegate(NetworkDelegate* network_delegate);
+  void set_http_server_properties(HttpServerProperties* http_server_properties);
+  void set_cookie_store(CookieStore* cookie_store);
+  void set_transport_security_state(
+      TransportSecurityState* transport_security_state);
+  void set_http_transaction_factory(
+      HttpTransactionFactory* http_transaction_factory);
+  void set_ftp_transaction_factory(
+      FtpTransactionFactory* ftp_transaction_factory);
+  void set_job_factory(URLRequestJobFactory* job_factory);
+  void set_throttler_manager(URLRequestThrottlerManager* throttler_manager);
+  void set_http_user_agent_settings(
+      HttpUserAgentSettings* http_user_agent_settings);
+
+ private:
+  // We use a raw pointer to prevent reference cycles, since
+  // URLRequestContextStorage can often be contained within a URLRequestContext
+  // subclass.
+  URLRequestContext* const context_;
+
+  // Owned members.
+  scoped_ptr<NetLog> net_log_;
+  scoped_ptr<HostResolver> host_resolver_;
+  scoped_ptr<CertVerifier> cert_verifier_;
+  scoped_ptr<ServerBoundCertService> server_bound_cert_service_;
+  scoped_ptr<FraudulentCertificateReporter> fraudulent_certificate_reporter_;
+  scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_;
+  scoped_ptr<ProxyService> proxy_service_;
+  // TODO(willchan): Remove refcounting on these members.
+  scoped_refptr<SSLConfigService> ssl_config_service_;
+  scoped_ptr<NetworkDelegate> network_delegate_;
+  scoped_ptr<HttpServerProperties> http_server_properties_;
+  scoped_ptr<HttpUserAgentSettings> http_user_agent_settings_;
+  scoped_refptr<CookieStore> cookie_store_;
+  scoped_ptr<TransportSecurityState> transport_security_state_;
+
+  scoped_ptr<HttpTransactionFactory> http_transaction_factory_;
+  scoped_ptr<FtpTransactionFactory> ftp_transaction_factory_;
+  scoped_ptr<URLRequestJobFactory> job_factory_;
+  scoped_ptr<URLRequestThrottlerManager> throttler_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestContextStorage);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_CONTEXT_STORAGE_H_
diff --git a/src/net/url_request/url_request_data_job.cc b/src/net/url_request/url_request_data_job.cc
new file mode 100644
index 0000000..5dffe32
--- /dev/null
+++ b/src/net/url_request/url_request_data_job.cc
@@ -0,0 +1,41 @@
+// 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.
+
+// Simple implementation of a data: protocol handler.
+
+#include "net/url_request/url_request_data_job.h"
+
+#include "net/base/data_url.h"
+#include "net/base/net_errors.h"
+
+namespace net {
+
+URLRequestDataJob::URLRequestDataJob(
+    URLRequest* request, NetworkDelegate* network_delegate)
+    : URLRequestSimpleJob(request, network_delegate) {
+}
+
+// static
+URLRequestJob* URLRequestDataJob::Factory(URLRequest* request,
+                                          NetworkDelegate* network_delegate,
+                                          const std::string& scheme) {
+  return new URLRequestDataJob(request, network_delegate);
+}
+
+int URLRequestDataJob::GetData(std::string* mime_type,
+                               std::string* charset,
+                               std::string* data,
+                               const CompletionCallback& callback) const {
+  // Check if data URL is valid. If not, don't bother to try to extract data.
+  // Otherwise, parse the data from the data URL.
+  const GURL& url = request_->url();
+  if (!url.is_valid())
+    return ERR_INVALID_URL;
+  return DataURL::Parse(url, mime_type, charset, data)? OK: ERR_INVALID_URL;
+}
+
+URLRequestDataJob::~URLRequestDataJob() {
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_data_job.h b/src/net/url_request/url_request_data_job.h
new file mode 100644
index 0000000..7ab6561
--- /dev/null
+++ b/src/net/url_request/url_request_data_job.h
@@ -0,0 +1,37 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_DATA_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_DATA_JOB_H_
+
+#include <string>
+
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_simple_job.h"
+
+namespace net {
+
+class URLRequest;
+
+class URLRequestDataJob : public URLRequestSimpleJob {
+ public:
+  URLRequestDataJob(URLRequest* request, NetworkDelegate* network_delegate);
+
+  static URLRequest::ProtocolFactory Factory;
+
+  // URLRequestSimpleJob
+  virtual int GetData(std::string* mime_type,
+                      std::string* charset,
+                      std::string* data,
+                      const CompletionCallback& callback) const OVERRIDE;
+
+ private:
+  virtual ~URLRequestDataJob();
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestDataJob);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_DATA_JOB_H_
diff --git a/src/net/url_request/url_request_error_job.cc b/src/net/url_request/url_request_error_job.cc
new file mode 100644
index 0000000..71069f2
--- /dev/null
+++ b/src/net/url_request/url_request_error_job.cc
@@ -0,0 +1,33 @@
+// 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 "net/url_request/url_request_error_job.h"
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/url_request_status.h"
+
+namespace net {
+
+URLRequestErrorJob::URLRequestErrorJob(
+    URLRequest* request, NetworkDelegate* network_delegate, int error)
+    : URLRequestJob(request, network_delegate),
+      error_(error),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
+
+URLRequestErrorJob::~URLRequestErrorJob() {}
+
+void URLRequestErrorJob::Start() {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestErrorJob::StartAsync, weak_factory_.GetWeakPtr()));
+}
+
+void URLRequestErrorJob::StartAsync() {
+  NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error_));
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_error_job.h b/src/net/url_request/url_request_error_job.h
new file mode 100644
index 0000000..7c162f0
--- /dev/null
+++ b/src/net/url_request/url_request_error_job.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2011 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.
+//
+// Invalid URLs go through this URLRequestJob class rather than being
+// passed to the default job handler.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_ERROR_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_ERROR_JOB_H_
+
+#include "base/memory/weak_ptr.h"
+#include "net/base/net_export.h"
+#include "net/url_request/url_request_job.h"
+
+namespace net {
+
+class NET_EXPORT URLRequestErrorJob : public URLRequestJob {
+ public:
+  URLRequestErrorJob(URLRequest* request,
+                     NetworkDelegate* network_delegate,
+                     int error);
+
+  virtual void Start() OVERRIDE;
+
+ private:
+  virtual ~URLRequestErrorJob();
+
+  void StartAsync();
+
+  int error_;
+
+  base::WeakPtrFactory<URLRequestErrorJob> weak_factory_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_ERROR_JOB_H_
diff --git a/src/net/url_request/url_request_file_dir_job.cc b/src/net/url_request/url_request_file_dir_job.cc
new file mode 100644
index 0000000..445c1eb
--- /dev/null
+++ b/src/net/url_request/url_request_file_dir_job.cc
@@ -0,0 +1,197 @@
+// 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 "net/url_request/url_request_file_dir_job.h"
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+#include "base/sys_string_conversions.h"
+#include "base/utf_string_conversions.h"
+#include "base/time.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/url_request/url_request_status.h"
+
+#if defined(OS_POSIX)
+#include <sys/stat.h>
+#endif
+
+namespace net {
+
+URLRequestFileDirJob::URLRequestFileDirJob(URLRequest* request,
+                                           NetworkDelegate* network_delegate,
+                                           const FilePath& dir_path)
+    : URLRequestJob(request, network_delegate),
+      ALLOW_THIS_IN_INITIALIZER_LIST(lister_(dir_path, this)),
+      dir_path_(dir_path),
+      canceled_(false),
+      list_complete_(false),
+      wrote_header_(false),
+      read_pending_(false),
+      read_buffer_length_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+}
+
+void URLRequestFileDirJob::StartAsync() {
+  lister_.Start();
+
+  NotifyHeadersComplete();
+}
+
+void URLRequestFileDirJob::Start() {
+  // Start reading asynchronously so that all error reporting and data
+  // callbacks happen as they would for network requests.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestFileDirJob::StartAsync,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void URLRequestFileDirJob::Kill() {
+  if (canceled_)
+    return;
+
+  canceled_ = true;
+
+  if (!list_complete_)
+    lister_.Cancel();
+
+  URLRequestJob::Kill();
+
+  weak_factory_.InvalidateWeakPtrs();
+}
+
+bool URLRequestFileDirJob::ReadRawData(IOBuffer* buf, int buf_size,
+                                       int* bytes_read) {
+  DCHECK(bytes_read);
+  *bytes_read = 0;
+
+  if (is_done())
+    return true;
+
+  if (FillReadBuffer(buf->data(), buf_size, bytes_read))
+    return true;
+
+  // We are waiting for more data
+  read_pending_ = true;
+  read_buffer_ = buf;
+  read_buffer_length_ = buf_size;
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+  return false;
+}
+
+bool URLRequestFileDirJob::GetMimeType(std::string* mime_type) const {
+  *mime_type = "text/html";
+  return true;
+}
+
+bool URLRequestFileDirJob::GetCharset(std::string* charset) {
+  // All the filenames are converted to UTF-8 before being added.
+  *charset = "utf-8";
+  return true;
+}
+
+void URLRequestFileDirJob::OnListFile(
+    const DirectoryLister::DirectoryListerData& data) {
+  // We wait to write out the header until we get the first file, so that we
+  // can catch errors from DirectoryLister and show an error page.
+  if (!wrote_header_) {
+#if defined(OS_WIN)
+    const string16& title = dir_path_.value();
+#elif defined(OS_POSIX)
+    // TODO(jungshik): Add SysNativeMBToUTF16 to sys_string_conversions.
+    // On Mac, need to add NFKC->NFC conversion either here or in file_path.
+    // On Linux, the file system encoding is not defined, but we assume that
+    // SysNativeMBToWide takes care of it at least for now. We can try something
+    // more sophisticated if necessary later.
+    const string16& title = WideToUTF16(
+        base::SysNativeMBToWide(dir_path_.value()));
+#endif
+    data_.append(GetDirectoryListingHeader(title));
+    wrote_header_ = true;
+  }
+
+#if defined(OS_WIN)
+  int64 size = (static_cast<unsigned __int64>(data.info.nFileSizeHigh) << 32) |
+      data.info.nFileSizeLow;
+
+  // Note that we should not convert ftLastWriteTime to the local time because
+  // ICU's datetime formatting APIs expect time in UTC and take into account
+  // the timezone before formatting.
+  data_.append(GetDirectoryListingEntry(
+      data.info.cFileName,
+      std::string(),
+      ((data.info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0),
+      size,
+      base::Time::FromFileTime(data.info.ftLastWriteTime)));
+#elif defined(OS_POSIX)
+  // TOOD(jungshik): The same issue as for the directory name.
+  data_.append(GetDirectoryListingEntry(
+      WideToUTF16(base::SysNativeMBToWide(data.info.filename)),
+      data.info.filename,
+      S_ISDIR(data.info.stat.st_mode),
+      data.info.stat.st_size,
+      base::Time::FromTimeT(data.info.stat.st_mtime)));
+#endif
+
+  // TODO(darin): coalesce more?
+  CompleteRead();
+}
+
+void URLRequestFileDirJob::OnListDone(int error) {
+  DCHECK(!canceled_);
+  if (error != OK) {
+    read_pending_ = false;
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, error));
+  } else {
+    list_complete_ = true;
+    CompleteRead();
+  }
+}
+
+URLRequestFileDirJob::~URLRequestFileDirJob() {}
+
+void URLRequestFileDirJob::CompleteRead() {
+  if (read_pending_) {
+    int bytes_read;
+    if (FillReadBuffer(read_buffer_->data(), read_buffer_length_,
+                       &bytes_read)) {
+      // We completed the read, so reset the read buffer.
+      read_pending_ = false;
+      read_buffer_ = NULL;
+      read_buffer_length_ = 0;
+
+      SetStatus(URLRequestStatus());
+      NotifyReadComplete(bytes_read);
+    } else {
+      NOTREACHED();
+      // TODO: Better error code.
+      NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, 0));
+    }
+  }
+}
+
+bool URLRequestFileDirJob::FillReadBuffer(char* buf, int buf_size,
+                                          int* bytes_read) {
+  DCHECK(bytes_read);
+
+  *bytes_read = 0;
+
+  int count = std::min(buf_size, static_cast<int>(data_.size()));
+  if (count) {
+    memcpy(buf, &data_[0], count);
+    data_.erase(0, count);
+    *bytes_read = count;
+    return true;
+  } else if (list_complete_) {
+    // EOF
+    return true;
+  }
+  return false;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_file_dir_job.h b/src/net/url_request/url_request_file_dir_job.h
new file mode 100644
index 0000000..bc6cccb
--- /dev/null
+++ b/src/net/url_request/url_request_file_dir_job.h
@@ -0,0 +1,81 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_FILE_DIR_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_FILE_DIR_JOB_H_
+
+#include <string>
+
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/memory/weak_ptr.h"
+#include "net/base/directory_lister.h"
+#include "net/url_request/url_request_job.h"
+
+namespace net {
+
+class URLRequestFileDirJob
+  : public URLRequestJob,
+    public DirectoryLister::DirectoryListerDelegate {
+ public:
+  URLRequestFileDirJob(URLRequest* request,
+                       NetworkDelegate* network_delegate,
+                       const FilePath& dir_path);
+
+  bool list_complete() const { return list_complete_; }
+
+  virtual void StartAsync();
+
+  // Overridden from URLRequestJob:
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual bool GetCharset(std::string* charset) OVERRIDE;
+
+  // Overridden from DirectoryLister::DirectoryListerDelegate:
+  virtual void OnListFile(
+      const DirectoryLister::DirectoryListerData& data) OVERRIDE;
+  virtual void OnListDone(int error) OVERRIDE;
+
+ private:
+  virtual ~URLRequestFileDirJob();
+
+  void CloseLister();
+
+  // When we have data and a read has been pending, this function
+  // will fill the response buffer and notify the request
+  // appropriately.
+  void CompleteRead();
+
+  // Fills a buffer with the output.
+  bool FillReadBuffer(char *buf, int buf_size, int *bytes_read);
+
+  DirectoryLister lister_;
+  FilePath dir_path_;
+  std::string data_;
+  bool canceled_;
+
+  // Indicates whether we have the complete list of the dir
+  bool list_complete_;
+
+  // Indicates whether we have written the HTML header
+  bool wrote_header_;
+
+  // To simulate Async IO, we hold onto the Reader's buffer while
+  // we wait for IO to complete.  When done, we fill the buffer
+  // manually.
+  bool read_pending_;
+  scoped_refptr<IOBuffer> read_buffer_;
+  int read_buffer_length_;
+  base::WeakPtrFactory<URLRequestFileDirJob> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestFileDirJob);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_FILE_DIR_JOB_H_
diff --git a/src/net/url_request/url_request_file_job.cc b/src/net/url_request/url_request_file_job.cc
new file mode 100644
index 0000000..e6a17ab
--- /dev/null
+++ b/src/net/url_request/url_request_file_job.cc
@@ -0,0 +1,335 @@
+// 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.
+
+// For loading files, we make use of overlapped i/o to ensure that reading from
+// the filesystem (e.g., a network filesystem) does not block the calling
+// thread.  An alternative approach would be to use a background thread or pool
+// of threads, but it seems better to leverage the operating system's ability
+// to do background file reads for us.
+//
+// Since overlapped reads require a 'static' buffer for the duration of the
+// asynchronous read, the URLRequestFileJob keeps a buffer as a member var.  In
+// URLRequestFileJob::Read, data is simply copied from the object's buffer into
+// the given buffer.  If there is no data to copy, the URLRequestFileJob
+// attempts to read more from the file to fill its buffer.  If reading from the
+// file does not complete synchronously, then the URLRequestFileJob waits for a
+// signal from the OS that the overlapped read has completed.  It does so by
+// leveraging the MessageLoop::WatchObject API.
+
+#include "net/url_request/url_request_file_job.h"
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+#include "base/path_service.h"
+#include "base/platform_file.h"
+#include "base/string_util.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/worker_pool.h"
+#include "base/threading/thread_restrictions.h"
+#include "build/build_config.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/file_stream.h"
+#include "net/base/io_buffer.h"
+#include "net/base/load_flags.h"
+#include "net/base/mime_util.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/http/http_util.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_file_dir_job.h"
+
+#if defined(OS_WIN)
+#include "base/win/shortcut.h"
+#endif
+
+namespace net {
+
+URLRequestFileJob::FileMetaInfo::FileMetaInfo()
+    : file_size(0),
+      mime_type_result(false),
+      file_exists(false),
+      is_directory(false) {
+}
+
+URLRequestFileJob::URLRequestFileJob(URLRequest* request,
+                                     NetworkDelegate* network_delegate,
+                                     const FilePath& file_path)
+    : URLRequestJob(request, network_delegate),
+      file_path_(file_path),
+      stream_(new FileStream(NULL)),
+      remaining_bytes_(0),
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+}
+
+// static
+URLRequestJob* URLRequestFileJob::Factory(URLRequest* request,
+                                          NetworkDelegate* network_delegate,
+                                          const std::string& scheme) {
+  FilePath file_path;
+  const bool is_file = FileURLToFilePath(request->url(), &file_path);
+
+  // Check file access permissions.
+  if (!network_delegate ||
+      !network_delegate->CanAccessFile(*request, file_path)) {
+    return new URLRequestErrorJob(request, network_delegate, ERR_ACCESS_DENIED);
+  }
+
+
+  // We need to decide whether to create URLRequestFileJob for file access or
+  // URLRequestFileDirJob for directory access. To avoid accessing the
+  // filesystem, we only look at the path string here.
+  // The code in the URLRequestFileJob::Start() method discovers that a path,
+  // which doesn't end with a slash, should really be treated as a directory,
+  // and it then redirects to the URLRequestFileDirJob.
+  if (is_file &&
+      file_util::EndsWithSeparator(file_path) &&
+      file_path.IsAbsolute())
+#if defined(COBALT)
+    // We don't support FileDirJob.
+    return new URLRequestErrorJob(request, network_delegate, ERR_ACCESS_DENIED);
+#else
+    return new URLRequestFileDirJob(request, network_delegate, file_path);
+#endif
+
+  // Use a regular file request job for all non-directories (including invalid
+  // file names).
+  return new URLRequestFileJob(request, network_delegate, file_path);
+}
+
+void URLRequestFileJob::Start() {
+  FileMetaInfo* meta_info = new FileMetaInfo();
+  base::WorkerPool::PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&URLRequestFileJob::FetchMetaInfo, file_path_,
+                 base::Unretained(meta_info)),
+      base::Bind(&URLRequestFileJob::DidFetchMetaInfo,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Owned(meta_info)),
+      true);
+}
+
+void URLRequestFileJob::Kill() {
+  stream_.reset();
+  weak_ptr_factory_.InvalidateWeakPtrs();
+
+  URLRequestJob::Kill();
+}
+
+bool URLRequestFileJob::ReadRawData(IOBuffer* dest, int dest_size,
+                                    int *bytes_read) {
+  DCHECK_NE(dest_size, 0);
+  DCHECK(bytes_read);
+  DCHECK_GE(remaining_bytes_, 0);
+
+  if (remaining_bytes_ < dest_size)
+    dest_size = static_cast<int>(remaining_bytes_);
+
+  // If we should copy zero bytes because |remaining_bytes_| is zero, short
+  // circuit here.
+  if (!dest_size) {
+    *bytes_read = 0;
+    return true;
+  }
+
+  int rv = stream_->Read(dest, dest_size,
+                         base::Bind(&URLRequestFileJob::DidRead,
+                                    weak_ptr_factory_.GetWeakPtr()));
+  if (rv >= 0) {
+    // Data is immediately available.
+    *bytes_read = rv;
+    remaining_bytes_ -= rv;
+    DCHECK_GE(remaining_bytes_, 0);
+    return true;
+  }
+
+  // Otherwise, a read error occured.  We may just need to wait...
+  if (rv == ERR_IO_PENDING) {
+    SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+  } else {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
+  }
+  return false;
+}
+
+bool URLRequestFileJob::IsRedirectResponse(GURL* location,
+                                           int* http_status_code) {
+  if (meta_info_.is_directory) {
+    // This happens when we discovered the file is a directory, so needs a
+    // slash at the end of the path.
+    std::string new_path = request_->url().path();
+    new_path.push_back('/');
+    GURL::Replacements replacements;
+    replacements.SetPathStr(new_path);
+
+    *location = request_->url().ReplaceComponents(replacements);
+    *http_status_code = 301;  // simulate a permanent redirect
+    return true;
+  }
+
+#if defined(OS_WIN)
+  // Follow a Windows shortcut.
+  // We just resolve .lnk file, ignore others.
+  if (!LowerCaseEqualsASCII(file_path_.Extension(), ".lnk"))
+    return false;
+
+  FilePath new_path = file_path_;
+  bool resolved;
+  resolved = base::win::ResolveShortcut(new_path, &new_path, NULL);
+
+  // If shortcut is not resolved succesfully, do not redirect.
+  if (!resolved)
+    return false;
+
+  *location = FilePathToFileURL(new_path);
+  *http_status_code = 301;
+  return true;
+#else
+  return false;
+#endif
+}
+
+Filter* URLRequestFileJob::SetupFilter() const {
+  // Bug 9936 - .svgz files needs to be decompressed.
+  return LowerCaseEqualsASCII(file_path_.Extension(), ".svgz")
+      ? Filter::GZipFactory() : NULL;
+}
+
+bool URLRequestFileJob::GetMimeType(std::string* mime_type) const {
+  DCHECK(request_);
+  if (meta_info_.mime_type_result) {
+    *mime_type = meta_info_.mime_type;
+    return true;
+  }
+  return false;
+}
+
+void URLRequestFileJob::SetExtraRequestHeaders(
+    const HttpRequestHeaders& headers) {
+  std::string range_header;
+  if (headers.GetHeader(HttpRequestHeaders::kRange, &range_header)) {
+    // We only care about "Range" header here.
+    std::vector<HttpByteRange> ranges;
+    if (HttpUtil::ParseRangeHeader(range_header, &ranges)) {
+      if (ranges.size() == 1) {
+        byte_range_ = ranges[0];
+      } else {
+        // We don't support multiple range requests in one single URL request,
+        // because we need to do multipart encoding here.
+        // TODO(hclam): decide whether we want to support multiple range
+        // requests.
+        NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+                                    ERR_REQUEST_RANGE_NOT_SATISFIABLE));
+      }
+    }
+  }
+}
+
+URLRequestFileJob::~URLRequestFileJob() {
+}
+
+void URLRequestFileJob::FetchMetaInfo(const FilePath& file_path,
+                                      FileMetaInfo* meta_info) {
+  base::PlatformFileInfo platform_info;
+  meta_info->file_exists = file_util::GetFileInfo(file_path, &platform_info);
+  if (meta_info->file_exists) {
+    meta_info->file_size = platform_info.size;
+    meta_info->is_directory = platform_info.is_directory;
+  }
+  // On Windows GetMimeTypeFromFile() goes to the registry. Thus it should be
+  // done in WorkerPool.
+  meta_info->mime_type_result = GetMimeTypeFromFile(file_path,
+                                                    &meta_info->mime_type);
+}
+
+void URLRequestFileJob::DidFetchMetaInfo(const FileMetaInfo* meta_info) {
+  meta_info_ = *meta_info;
+
+  // We use URLRequestFileJob to handle files as well as directories without
+  // trailing slash.
+  // If a directory does not exist, we return ERR_FILE_NOT_FOUND. Otherwise,
+  // we will append trailing slash and redirect to FileDirJob.
+  // A special case is "\" on Windows. We should resolve as invalid.
+  // However, Windows resolves "\" to "C:\", thus reports it as existent.
+  // So what happens is we append it with trailing slash and redirect it to
+  // FileDirJob where it is resolved as invalid.
+  if (!meta_info_.file_exists) {
+    DidOpen(ERR_FILE_NOT_FOUND);
+    return;
+  }
+  if (meta_info_.is_directory) {
+    DidOpen(OK);
+    return;
+  }
+
+  int flags = base::PLATFORM_FILE_OPEN |
+              base::PLATFORM_FILE_READ |
+              base::PLATFORM_FILE_ASYNC;
+  int rv = stream_->Open(file_path_, flags,
+                         base::Bind(&URLRequestFileJob::DidOpen,
+                                    weak_ptr_factory_.GetWeakPtr()));
+  if (rv != ERR_IO_PENDING)
+    DidOpen(rv);
+}
+
+void URLRequestFileJob::DidOpen(int result) {
+  if (result != OK) {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
+    return;
+  }
+
+  if (!byte_range_.ComputeBounds(meta_info_.file_size)) {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+               ERR_REQUEST_RANGE_NOT_SATISFIABLE));
+    return;
+  }
+
+  remaining_bytes_ = byte_range_.last_byte_position() -
+                     byte_range_.first_byte_position() + 1;
+  DCHECK_GE(remaining_bytes_, 0);
+
+  if (remaining_bytes_ > 0 && byte_range_.first_byte_position() != 0) {
+    int rv = stream_->Seek(FROM_BEGIN, byte_range_.first_byte_position(),
+                           base::Bind(&URLRequestFileJob::DidSeek,
+                                      weak_ptr_factory_.GetWeakPtr()));
+    if (rv != ERR_IO_PENDING) {
+      // stream_->Seek() failed, so pass an intentionally erroneous value
+      // into DidSeek().
+      DidSeek(-1);
+    }
+  } else {
+    // We didn't need to call stream_->Seek() at all, so we pass to DidSeek()
+    // the value that would mean seek success. This way we skip the code
+    // handling seek failure.
+    DidSeek(byte_range_.first_byte_position());
+  }
+}
+
+void URLRequestFileJob::DidSeek(int64 result) {
+  if (result != byte_range_.first_byte_position()) {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+                                ERR_REQUEST_RANGE_NOT_SATISFIABLE));
+    return;
+  }
+
+  set_expected_content_size(remaining_bytes_);
+  NotifyHeadersComplete();
+}
+
+void URLRequestFileJob::DidRead(int result) {
+  if (result > 0) {
+    SetStatus(URLRequestStatus());  // Clear the IO_PENDING status
+  } else if (result == 0) {
+    NotifyDone(URLRequestStatus());
+  } else {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
+  }
+
+  remaining_bytes_ -= result;
+  DCHECK_GE(remaining_bytes_, 0);
+
+  NotifyReadComplete(result);
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_file_job.h b/src/net/url_request/url_request_file_job.h
new file mode 100644
index 0000000..9c2199c
--- /dev/null
+++ b/src/net/url_request/url_request_file_job.h
@@ -0,0 +1,107 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_FILE_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_FILE_JOB_H_
+
+#include <string>
+#include <vector>
+
+#include "base/file_path.h"
+#include "base/memory/weak_ptr.h"
+#include "net/base/net_export.h"
+#include "net/http/http_byte_range.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_job.h"
+
+namespace base{
+struct PlatformFileInfo;
+}
+namespace file_util {
+struct FileInfo;
+}
+
+namespace net {
+
+class FileStream;
+
+// A request job that handles reading file URLs
+class NET_EXPORT URLRequestFileJob : public URLRequestJob {
+ public:
+  URLRequestFileJob(URLRequest* request,
+                    NetworkDelegate* network_delegate,
+                    const FilePath& file_path);
+
+  static URLRequest::ProtocolFactory Factory;
+
+  // URLRequestJob:
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int* bytes_read) OVERRIDE;
+  virtual bool IsRedirectResponse(GURL* location,
+                                  int* http_status_code) OVERRIDE;
+  virtual Filter* SetupFilter() const OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual void SetExtraRequestHeaders(
+      const HttpRequestHeaders& headers) OVERRIDE;
+
+ protected:
+  virtual ~URLRequestFileJob();
+
+  // The OS-specific full path name of the file
+  FilePath file_path_;
+
+ private:
+  // Meta information about the file. It's used as a member in the
+  // URLRequestFileJob and also passed between threads because disk access is
+  // necessary to obtain it.
+  struct FileMetaInfo {
+    FileMetaInfo();
+
+    // Size of the file.
+    int64 file_size;
+    // Mime type associated with the file.
+    std::string mime_type;
+    // Result returned from GetMimeTypeFromFile(), i.e. flag showing whether
+    // obtaining of the mime type was successful.
+    bool mime_type_result;
+    // Flag showing whether the file exists.
+    bool file_exists;
+    // Flag showing whether the file name actually refers to a directory.
+    bool is_directory;
+  };
+
+  // Fetches file info on a background thread.
+  static void FetchMetaInfo(const FilePath& file_path,
+                            FileMetaInfo* meta_info);
+
+  // Callback after fetching file info on a background thread.
+  void DidFetchMetaInfo(const FileMetaInfo* meta_info);
+
+  // Callback after opening file on a background thread.
+  void DidOpen(int result);
+
+  // Callback after seeking to the beginning of |byte_range_| in the file
+  // on a background thread.
+  void DidSeek(int64 result);
+
+  // Callback after data is asynchronously read from the file.
+  void DidRead(int result);
+
+  scoped_ptr<FileStream> stream_;
+  FileMetaInfo meta_info_;
+
+  HttpByteRange byte_range_;
+  int64 remaining_bytes_;
+
+  base::WeakPtrFactory<URLRequestFileJob> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestFileJob);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_FILE_JOB_H_
diff --git a/src/net/url_request/url_request_filter.cc b/src/net/url_request/url_request_filter.cc
new file mode 100644
index 0000000..01b6069
--- /dev/null
+++ b/src/net/url_request/url_request_filter.cc
@@ -0,0 +1,150 @@
+// Copyright (c) 2011 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 "net/url_request/url_request_filter.h"
+
+#include <set>
+
+#include "base/logging.h"
+
+namespace net {
+
+URLRequestFilter* URLRequestFilter::shared_instance_ = NULL;
+
+URLRequestFilter::~URLRequestFilter() {}
+
+// static
+URLRequestJob* URLRequestFilter::Factory(URLRequest* request,
+                                         NetworkDelegate* network_delegate,
+                                         const std::string& scheme) {
+  // Returning null here just means that the built-in handler will be used.
+  return GetInstance()->FindRequestHandler(request, network_delegate, scheme);
+}
+
+// static
+URLRequestFilter* URLRequestFilter::GetInstance() {
+  if (!shared_instance_)
+    shared_instance_ = new URLRequestFilter;
+  return shared_instance_;
+}
+
+void URLRequestFilter::AddHostnameHandler(const std::string& scheme,
+    const std::string& hostname, URLRequest::ProtocolFactory* factory) {
+  hostname_handler_map_[make_pair(scheme, hostname)] = factory;
+
+  // Register with the ProtocolFactory.
+  URLRequest::Deprecated::RegisterProtocolFactory(
+      scheme, &URLRequestFilter::Factory);
+
+#ifndef NDEBUG
+  // Check to see if we're masking URLs in the url_handler_map_.
+  for (UrlHandlerMap::const_iterator i = url_handler_map_.begin();
+       i != url_handler_map_.end(); ++i) {
+    const GURL& url = GURL(i->first);
+    HostnameHandlerMap::iterator host_it =
+        hostname_handler_map_.find(make_pair(url.scheme(), url.host()));
+    if (host_it != hostname_handler_map_.end())
+      NOTREACHED();
+  }
+#endif  // !NDEBUG
+}
+
+void URLRequestFilter::RemoveHostnameHandler(const std::string& scheme,
+                                             const std::string& hostname) {
+  HostnameHandlerMap::iterator iter =
+      hostname_handler_map_.find(make_pair(scheme, hostname));
+  DCHECK(iter != hostname_handler_map_.end());
+
+  hostname_handler_map_.erase(iter);
+  // Note that we don't unregister from the URLRequest ProtocolFactory as
+  // this would left no protocol factory for the scheme.
+  // URLRequestFilter::Factory will keep forwarding the requests to the
+  // URLRequestInetJob.
+}
+
+bool URLRequestFilter::AddUrlHandler(
+    const GURL& url,
+    URLRequest::ProtocolFactory* factory) {
+  if (!url.is_valid())
+    return false;
+  url_handler_map_[url.spec()] = factory;
+
+  // Register with the ProtocolFactory.
+  URLRequest::Deprecated::RegisterProtocolFactory(url.scheme(),
+                                                  &URLRequestFilter::Factory);
+#ifndef NDEBUG
+  // Check to see if this URL is masked by a hostname handler.
+  HostnameHandlerMap::iterator host_it =
+      hostname_handler_map_.find(make_pair(url.scheme(), url.host()));
+  if (host_it != hostname_handler_map_.end())
+    NOTREACHED();
+#endif  // !NDEBUG
+
+  return true;
+}
+
+void URLRequestFilter::RemoveUrlHandler(const GURL& url) {
+  UrlHandlerMap::iterator iter = url_handler_map_.find(url.spec());
+  DCHECK(iter != url_handler_map_.end());
+
+  url_handler_map_.erase(iter);
+  // Note that we don't unregister from the URLRequest ProtocolFactory as
+  // this would left no protocol factory for the scheme.
+  // URLRequestFilter::Factory will keep forwarding the requests to the
+  // URLRequestInetJob.
+}
+
+void URLRequestFilter::ClearHandlers() {
+  // Unregister with the ProtocolFactory.
+  std::set<std::string> schemes;
+  for (UrlHandlerMap::const_iterator i = url_handler_map_.begin();
+       i != url_handler_map_.end(); ++i) {
+    schemes.insert(GURL(i->first).scheme());
+  }
+  for (HostnameHandlerMap::const_iterator i = hostname_handler_map_.begin();
+       i != hostname_handler_map_.end(); ++i) {
+    schemes.insert(i->first.first);
+  }
+  for (std::set<std::string>::const_iterator scheme = schemes.begin();
+       scheme != schemes.end(); ++scheme) {
+    URLRequest::Deprecated::RegisterProtocolFactory(*scheme, NULL);
+  }
+
+  url_handler_map_.clear();
+  hostname_handler_map_.clear();
+  hit_count_ = 0;
+}
+
+URLRequestFilter::URLRequestFilter() : hit_count_(0) { }
+
+URLRequestJob* URLRequestFilter::FindRequestHandler(
+    URLRequest* request,
+    NetworkDelegate* network_delegate,
+    const std::string& scheme) {
+  URLRequestJob* job = NULL;
+  if (request->url().is_valid()) {
+    // Check the hostname map first.
+    const std::string& hostname = request->url().host();
+
+    HostnameHandlerMap::iterator i =
+        hostname_handler_map_.find(make_pair(scheme, hostname));
+    if (i != hostname_handler_map_.end())
+      job = i->second(request, network_delegate, scheme);
+
+    if (!job) {
+      // Not in the hostname map, check the url map.
+      const std::string& url = request->url().spec();
+      UrlHandlerMap::iterator i = url_handler_map_.find(url);
+      if (i != url_handler_map_.end())
+        job = i->second(request, network_delegate, scheme);
+    }
+  }
+  if (job) {
+    DVLOG(1) << "URLRequestFilter hit for " << request->url().spec();
+    hit_count_++;
+  }
+  return job;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_filter.h b/src/net/url_request/url_request_filter.h
new file mode 100644
index 0000000..c039300
--- /dev/null
+++ b/src/net/url_request/url_request_filter.h
@@ -0,0 +1,94 @@
+// Copyright (c) 2011 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.
+//
+// A class to help filter URLRequest jobs based on the URL of the request
+// rather than just the scheme.  Example usage:
+//
+// // Use as an "http" handler.
+// URLRequest::RegisterProtocolFactory("http", &URLRequestFilter::Factory);
+// // Add special handling for the URL http://foo.com/
+// URLRequestFilter::GetInstance()->AddUrlHandler(
+//     GURL("http://foo.com/"),
+//     &URLRequestCustomJob::Factory);
+//
+// If URLRequestFilter::Factory can't find a handle for the request, it passes
+// it through to URLRequestInetJob::Factory and lets the default network stack
+// handle it.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_FILTER_H_
+#define NET_URL_REQUEST_URL_REQUEST_FILTER_H_
+
+#include <map>
+#include <string>
+
+#include "base/hash_tables.h"
+#include "net/base/net_export.h"
+#include "net/url_request/url_request.h"
+
+class GURL;
+
+namespace net {
+class URLRequestJob;
+
+class NET_EXPORT URLRequestFilter {
+ public:
+  // scheme,hostname -> ProtocolFactory
+  typedef std::map<std::pair<std::string, std::string>,
+      URLRequest::ProtocolFactory*> HostnameHandlerMap;
+  typedef base::hash_map<std::string, URLRequest::ProtocolFactory*>
+      UrlHandlerMap;
+
+  ~URLRequestFilter();
+
+  static URLRequest::ProtocolFactory Factory;
+
+  // Singleton instance for use.
+  static URLRequestFilter* GetInstance();
+
+  void AddHostnameHandler(const std::string& scheme,
+                          const std::string& hostname,
+                          URLRequest::ProtocolFactory* factory);
+  void RemoveHostnameHandler(const std::string& scheme,
+                             const std::string& hostname);
+
+  // Returns true if we successfully added the URL handler.  This will replace
+  // old handlers for the URL if one existed.
+  bool AddUrlHandler(const GURL& url,
+                     URLRequest::ProtocolFactory* factory);
+
+  void RemoveUrlHandler(const GURL& url);
+
+  // Clear all the existing URL handlers and unregister with the
+  // ProtocolFactory.  Resets the hit count.
+  void ClearHandlers();
+
+  // Returns the number of times a handler was used to service a request.
+  int hit_count() const { return hit_count_; }
+
+ protected:
+  URLRequestFilter();
+
+  // Helper method that looks up the request in the url_handler_map_.
+  URLRequestJob* FindRequestHandler(URLRequest* request,
+                                    NetworkDelegate* network_delegate,
+                                    const std::string& scheme);
+
+  // Maps hostnames to factories.  Hostnames take priority over URLs.
+  HostnameHandlerMap hostname_handler_map_;
+
+  // Maps URLs to factories.
+  UrlHandlerMap url_handler_map_;
+
+  int hit_count_;
+
+ private:
+  // Singleton instance.
+  static URLRequestFilter* shared_instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestFilter);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_FILTER_H_
diff --git a/src/net/url_request/url_request_filter_unittest.cc b/src/net/url_request/url_request_filter_unittest.cc
new file mode 100644
index 0000000..9f11675
--- /dev/null
+++ b/src/net/url_request/url_request_filter_unittest.cc
@@ -0,0 +1,131 @@
+// 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 "net/url_request/url_request_filter.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_job_factory.h"
+#include "net/url_request/url_request_test_job.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+URLRequestTestJob* job_a;
+
+URLRequestJob* FactoryA(URLRequest* request,
+                        NetworkDelegate* network_delegate,
+                        const std::string& scheme) {
+  job_a = new URLRequestTestJob(request, network_delegate);
+  return job_a;
+}
+
+URLRequestTestJob* job_b;
+
+URLRequestJob* FactoryB(URLRequest* request,
+                        NetworkDelegate* network_delegate,
+                        const std::string& scheme) {
+  job_b = new URLRequestTestJob(request, network_delegate);
+  return job_b;
+}
+
+TEST(URLRequestFilter, BasicMatching) {
+  TestDelegate delegate;
+  TestURLRequestContext request_context;
+
+  GURL url_1("http://foo.com/");
+  TestURLRequest request_1(url_1, &delegate, &request_context);
+
+  GURL url_2("http://bar.com/");
+  TestURLRequest request_2(url_2, &delegate, &request_context);
+
+  // Check AddUrlHandler checks for invalid URLs.
+  EXPECT_FALSE(URLRequestFilter::GetInstance()->AddUrlHandler(GURL(),
+                                                              &FactoryA));
+
+  // Check URL matching.
+  URLRequestFilter::GetInstance()->ClearHandlers();
+  EXPECT_TRUE(URLRequestFilter::GetInstance()->AddUrlHandler(url_1,
+                                                             &FactoryA));
+  {
+    scoped_refptr<URLRequestJob> found = URLRequestFilter::Factory(
+        &request_1, request_context.network_delegate(), url_1.scheme());
+    EXPECT_EQ(job_a, found);
+    EXPECT_TRUE(job_a != NULL);
+    job_a = NULL;
+  }
+  EXPECT_EQ(URLRequestFilter::GetInstance()->hit_count(), 1);
+
+  // Check we don't match other URLs.
+  EXPECT_TRUE(URLRequestFilter::Factory(
+      &request_2, request_context.network_delegate(), url_2.scheme()) == NULL);
+  EXPECT_EQ(1, URLRequestFilter::GetInstance()->hit_count());
+
+  // Check we can overwrite URL handler.
+  EXPECT_TRUE(URLRequestFilter::GetInstance()->AddUrlHandler(url_1,
+                                                             &FactoryB));
+  {
+    scoped_refptr<URLRequestJob> found = URLRequestFilter::Factory(
+        &request_1, request_context.network_delegate(), url_1.scheme());
+    EXPECT_EQ(job_b, found);
+    EXPECT_TRUE(job_b != NULL);
+    job_b = NULL;
+  }
+  EXPECT_EQ(2, URLRequestFilter::GetInstance()->hit_count());
+
+  // Check we can remove URL matching.
+  URLRequestFilter::GetInstance()->RemoveUrlHandler(url_1);
+  EXPECT_TRUE(URLRequestFilter::Factory(
+      &request_1, request_context.network_delegate(), url_1.scheme()) == NULL);
+  EXPECT_EQ(URLRequestFilter::GetInstance()->hit_count(), 2);
+
+  // Check hostname matching.
+  URLRequestFilter::GetInstance()->ClearHandlers();
+  EXPECT_EQ(0, URLRequestFilter::GetInstance()->hit_count());
+  URLRequestFilter::GetInstance()->AddHostnameHandler(url_1.scheme(),
+                                                      url_1.host(),
+                                                      &FactoryB);
+  {
+    scoped_refptr<URLRequestJob> found = URLRequestFilter::Factory(
+        &request_1, request_context.network_delegate(), url_1.scheme());
+    EXPECT_EQ(job_b, found);
+    EXPECT_TRUE(job_b != NULL);
+    job_b = NULL;
+  }
+  EXPECT_EQ(1, URLRequestFilter::GetInstance()->hit_count());
+
+  // Check we don't match other hostnames.
+  EXPECT_TRUE(URLRequestFilter::Factory(
+      &request_2, request_context.network_delegate(), url_2.scheme()) == NULL);
+  EXPECT_EQ(URLRequestFilter::GetInstance()->hit_count(), 1);
+
+  // Check we can overwrite hostname handler.
+  URLRequestFilter::GetInstance()->AddHostnameHandler(url_1.scheme(),
+                                                      url_1.host(),
+                                                      &FactoryA);
+  {
+    scoped_refptr<URLRequestJob> found = URLRequestFilter::Factory(
+        &request_1, request_context.network_delegate(), url_1.scheme());
+    EXPECT_EQ(job_a, found);
+    EXPECT_TRUE(job_a != NULL);
+    job_a = NULL;
+  }
+  EXPECT_EQ(2, URLRequestFilter::GetInstance()->hit_count());
+
+  // Check we can remove hostname matching.
+  URLRequestFilter::GetInstance()->RemoveHostnameHandler(url_1.scheme(),
+                                                         url_1.host());
+  EXPECT_TRUE(URLRequestFilter::Factory(
+      &request_1, request_context.network_delegate(), url_1.scheme()) == NULL);
+  EXPECT_EQ(2, URLRequestFilter::GetInstance()->hit_count());
+}
+
+}  // namespace
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_ftp_job.cc b/src/net/url_request/url_request_ftp_job.cc
new file mode 100644
index 0000000..27021a3
--- /dev/null
+++ b/src/net/url_request/url_request_ftp_job.cc
@@ -0,0 +1,264 @@
+// 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 "net/url_request/url_request_ftp_job.h"
+
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+#include "base/utf_string_conversions.h"
+#include "net/base/auth.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/ftp/ftp_response_info.h"
+#include "net/ftp/ftp_transaction_factory.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"
+
+namespace net {
+
+URLRequestFtpJob::URLRequestFtpJob(
+    URLRequest* request,
+    NetworkDelegate* network_delegate,
+    FtpTransactionFactory* ftp_transaction_factory,
+    FtpAuthCache* ftp_auth_cache)
+    : URLRequestJob(request, network_delegate),
+      read_in_progress_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+      ftp_transaction_factory_(ftp_transaction_factory),
+      ftp_auth_cache_(ftp_auth_cache) {
+  DCHECK(ftp_transaction_factory);
+  DCHECK(ftp_auth_cache);
+}
+
+// static
+URLRequestJob* URLRequestFtpJob::Factory(URLRequest* request,
+                                         NetworkDelegate* network_delegate,
+                                         const std::string& scheme) {
+  DCHECK_EQ(scheme, "ftp");
+
+  int port = request->url().IntPort();
+  if (request->url().has_port() &&
+      !IsPortAllowedByFtp(port) && !IsPortAllowedByOverride(port)) {
+    return new URLRequestErrorJob(request,
+                                  network_delegate,
+                                  ERR_UNSAFE_PORT);
+  }
+
+  return new URLRequestFtpJob(request,
+                              network_delegate,
+                              request->context()->ftp_transaction_factory(),
+                              request->context()->ftp_auth_cache());
+}
+
+bool URLRequestFtpJob::GetMimeType(std::string* mime_type) const {
+  if (transaction_->GetResponseInfo()->is_directory_listing) {
+    *mime_type = "text/vnd.chromium.ftp-dir";
+    return true;
+  }
+  return false;
+}
+
+HostPortPair URLRequestFtpJob::GetSocketAddress() const {
+  if (!transaction_.get()) {
+    return HostPortPair();
+  }
+  return transaction_->GetResponseInfo()->socket_address;
+}
+
+URLRequestFtpJob::~URLRequestFtpJob() {
+}
+
+void URLRequestFtpJob::StartTransaction() {
+  // Create a transaction.
+  DCHECK(!transaction_.get());
+
+  transaction_.reset(ftp_transaction_factory_->CreateTransaction());
+
+  // No matter what, we want to report our status as IO pending since we will
+  // be notifying our consumer asynchronously via OnStartCompleted.
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+  int rv;
+  if (transaction_.get()) {
+    rv = transaction_->Start(
+        &request_info_,
+        base::Bind(&URLRequestFtpJob::OnStartCompleted,
+                   base::Unretained(this)),
+        request_->net_log());
+    if (rv == ERR_IO_PENDING)
+      return;
+  } else {
+    rv = ERR_FAILED;
+  }
+  // The transaction started synchronously, but we need to notify the
+  // URLRequest delegate via the message loop.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestFtpJob::OnStartCompleted,
+                 weak_factory_.GetWeakPtr(), rv));
+}
+
+void URLRequestFtpJob::OnStartCompleted(int result) {
+  // Clear the IO_PENDING status
+  SetStatus(URLRequestStatus());
+
+  // Note that transaction_ may be NULL due to a creation failure.
+  if (transaction_.get()) {
+    // FTP obviously doesn't have HTTP Content-Length header. We have to pass
+    // the content size information manually.
+    set_expected_content_size(
+        transaction_->GetResponseInfo()->expected_content_size);
+  }
+
+  if (result == OK) {
+    NotifyHeadersComplete();
+  } else if (transaction_.get() &&
+             transaction_->GetResponseInfo()->needs_auth) {
+    GURL origin = request_->url().GetOrigin();
+    if (server_auth_ && server_auth_->state == AUTH_STATE_HAVE_AUTH) {
+      ftp_auth_cache_->Remove(origin, server_auth_->credentials);
+    } else if (!server_auth_) {
+      server_auth_ = new AuthData();
+    }
+    server_auth_->state = AUTH_STATE_NEED_AUTH;
+
+    FtpAuthCache::Entry* cached_auth = ftp_auth_cache_->Lookup(origin);
+    if (cached_auth) {
+      // Retry using cached auth data.
+      SetAuth(cached_auth->credentials);
+    } else {
+      // Prompt for a username/password.
+      NotifyHeadersComplete();
+    }
+  } else {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
+  }
+}
+
+void URLRequestFtpJob::OnReadCompleted(int result) {
+  read_in_progress_ = false;
+  if (result == 0) {
+    NotifyDone(URLRequestStatus());
+  } else if (result < 0) {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
+  } else {
+    // Clear the IO_PENDING status
+    SetStatus(URLRequestStatus());
+  }
+  NotifyReadComplete(result);
+}
+
+void URLRequestFtpJob::RestartTransactionWithAuth() {
+  DCHECK(server_auth_ && server_auth_->state == AUTH_STATE_HAVE_AUTH);
+
+  // No matter what, we want to report our status as IO pending since we will
+  // be notifying our consumer asynchronously via OnStartCompleted.
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+
+  int rv = transaction_->RestartWithAuth(
+      server_auth_->credentials,
+      base::Bind(&URLRequestFtpJob::OnStartCompleted,
+                 base::Unretained(this)));
+  if (rv == ERR_IO_PENDING)
+    return;
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestFtpJob::OnStartCompleted,
+                 weak_factory_.GetWeakPtr(), rv));
+}
+
+void URLRequestFtpJob::Start() {
+  DCHECK(!transaction_.get());
+  request_info_.url = request_->url();
+  StartTransaction();
+}
+
+void URLRequestFtpJob::Kill() {
+  if (!transaction_.get())
+    return;
+  transaction_.reset();
+  URLRequestJob::Kill();
+  weak_factory_.InvalidateWeakPtrs();
+}
+
+LoadState URLRequestFtpJob::GetLoadState() const {
+  return transaction_.get() ?
+      transaction_->GetLoadState() : LOAD_STATE_IDLE;
+}
+
+bool URLRequestFtpJob::NeedsAuth() {
+  // Note that we only have to worry about cases where an actual FTP server
+  // requires auth (and not a proxy), because connecting to FTP via proxy
+  // effectively means the browser communicates via HTTP, and uses HTTP's
+  // Proxy-Authenticate protocol when proxy servers require auth.
+  return server_auth_ && server_auth_->state == AUTH_STATE_NEED_AUTH;
+}
+
+void URLRequestFtpJob::GetAuthChallengeInfo(
+    scoped_refptr<AuthChallengeInfo>* result) {
+  DCHECK((server_auth_ != NULL) &&
+         (server_auth_->state == AUTH_STATE_NEED_AUTH));
+  scoped_refptr<AuthChallengeInfo> auth_info(new AuthChallengeInfo);
+  auth_info->is_proxy = false;
+  auth_info->challenger = HostPortPair::FromURL(request_->url());
+  // scheme and realm are kept empty.
+  DCHECK(auth_info->scheme.empty());
+  DCHECK(auth_info->realm.empty());
+  result->swap(auth_info);
+}
+
+void URLRequestFtpJob::SetAuth(const AuthCredentials& credentials) {
+  DCHECK(NeedsAuth());
+  server_auth_->state = AUTH_STATE_HAVE_AUTH;
+  server_auth_->credentials = credentials;
+
+  ftp_auth_cache_->Add(request_->url().GetOrigin(), server_auth_->credentials);
+
+  RestartTransactionWithAuth();
+}
+
+void URLRequestFtpJob::CancelAuth() {
+  DCHECK(NeedsAuth());
+  server_auth_->state = AUTH_STATE_CANCELED;
+
+  // Once the auth is cancelled, we proceed with the request as though
+  // there were no auth.  Schedule this for later so that we don't cause
+  // any recursing into the caller as a result of this call.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestFtpJob::OnStartCompleted,
+                 weak_factory_.GetWeakPtr(), OK));
+}
+
+UploadProgress URLRequestFtpJob::GetUploadProgress() const {
+  return UploadProgress();
+}
+
+bool URLRequestFtpJob::ReadRawData(IOBuffer* buf,
+                                   int buf_size,
+                                   int *bytes_read) {
+  DCHECK_NE(buf_size, 0);
+  DCHECK(bytes_read);
+  DCHECK(!read_in_progress_);
+
+  int rv = transaction_->Read(buf, buf_size,
+                              base::Bind(&URLRequestFtpJob::OnReadCompleted,
+                                         base::Unretained(this)));
+  if (rv >= 0) {
+    *bytes_read = rv;
+    return true;
+  }
+
+  if (rv == ERR_IO_PENDING) {
+    read_in_progress_ = true;
+    SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+  } else {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
+  }
+  return false;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_ftp_job.h b/src/net/url_request/url_request_ftp_job.h
new file mode 100644
index 0000000..d05e3d8
--- /dev/null
+++ b/src/net/url_request/url_request_ftp_job.h
@@ -0,0 +1,86 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_FTP_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_FTP_JOB_H_
+
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "net/base/auth.h"
+#include "net/base/completion_callback.h"
+#include "net/ftp/ftp_request_info.h"
+#include "net/ftp/ftp_transaction.h"
+#include "net/url_request/url_request_job.h"
+
+namespace net {
+
+class NetworkDelegate;
+class FtpTransactionFactory;
+class FtpAuthCache;
+
+// A URLRequestJob subclass that is built on top of FtpTransaction. It
+// provides an implementation for FTP.
+class URLRequestFtpJob : public URLRequestJob {
+ public:
+  URLRequestFtpJob(URLRequest* request,
+                   NetworkDelegate* network_delegate,
+                   FtpTransactionFactory* ftp_transaction_factory,
+                   FtpAuthCache* ftp_auth_cache);
+
+  // TODO(shalev): get rid of this function in favor of FtpProtocolHandler.
+  static URLRequestJob* Factory(URLRequest* request,
+                                NetworkDelegate* network_delegate,
+                                const std::string& scheme);
+
+  // Overridden from URLRequestJob:
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual HostPortPair GetSocketAddress() const OVERRIDE;
+
+ private:
+  virtual ~URLRequestFtpJob();
+
+  void StartTransaction();
+
+  void OnStartCompleted(int result);
+  void OnReadCompleted(int result);
+
+  void RestartTransactionWithAuth();
+
+  void LogFtpServerType(char server_type);
+
+  // Overridden from URLRequestJob:
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual bool NeedsAuth() OVERRIDE;
+  virtual void GetAuthChallengeInfo(
+      scoped_refptr<AuthChallengeInfo>* auth_info) OVERRIDE;
+  virtual void SetAuth(const AuthCredentials& credentials) OVERRIDE;
+  virtual void CancelAuth() OVERRIDE;
+
+  // TODO(ibrar):  Yet to give another look at this function.
+  virtual UploadProgress GetUploadProgress() const OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
+
+  FtpRequestInfo request_info_;
+  scoped_ptr<FtpTransaction> transaction_;
+
+  bool read_in_progress_;
+
+  scoped_refptr<AuthData> server_auth_;
+
+  base::WeakPtrFactory<URLRequestFtpJob> weak_factory_;
+
+  FtpTransactionFactory* ftp_transaction_factory_;
+  FtpAuthCache* ftp_auth_cache_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestFtpJob);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_FTP_JOB_H_
diff --git a/src/net/url_request/url_request_ftp_job_unittest.cc b/src/net/url_request/url_request_ftp_job_unittest.cc
new file mode 100644
index 0000000..e13a80d
--- /dev/null
+++ b/src/net/url_request/url_request_ftp_job_unittest.cc
@@ -0,0 +1,75 @@
+// 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 "net/ftp/ftp_auth_cache.h"
+#include "net/ftp/ftp_transaction.h"
+#include "net/ftp/ftp_transaction_factory.h"
+#include "net/url_request/ftp_protocol_handler.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_ftp_job.h"
+#include "net/url_request/url_request_status.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::Return;
+using ::testing::_;
+
+namespace net {
+
+class MockFtpTransactionFactory : public FtpTransactionFactory {
+ public:
+  MOCK_METHOD0(CreateTransaction, FtpTransaction*());
+  MOCK_METHOD1(Suspend, void(bool suspend));
+};
+
+class MockURLRequestDelegate : public URLRequest::Delegate {
+ public:
+  MOCK_METHOD3(OnReceivedRedirect, void(URLRequest* request,
+                                        const GURL& new_url,
+                                        bool* defer_redirect));
+  MOCK_METHOD2(OnAuthRequired, void(URLRequest* request,
+                                    AuthChallengeInfo* auth_info));
+  MOCK_METHOD2(OnCertificateRequested,
+               void(URLRequest* request,
+                    SSLCertRequestInfo* cert_request_info));
+  MOCK_METHOD3(OnSSLCertificateError, void(URLRequest* request,
+                                           const SSLInfo& ssl_info,
+                                           bool fatal));
+  MOCK_METHOD1(OnResponseStarted, void(URLRequest* request));
+  MOCK_METHOD2(OnReadCompleted, void(URLRequest* request, int bytes_read));
+};
+
+ACTION_P(HandleOnResponseStarted, expected_status) {
+  EXPECT_EQ(expected_status, arg0->status().status());
+}
+
+TEST(FtpProtocolHandlerTest, CreateTransactionFails) {
+  testing::InSequence in_sequence_;
+
+  ::testing::StrictMock<MockFtpTransactionFactory> ftp_transaction_factory;
+  ::testing::StrictMock<MockURLRequestDelegate> delegate;
+  FtpAuthCache ftp_auth_cache;
+
+  GURL url("ftp://example.com");
+  URLRequestContext context;
+  URLRequest url_request(url, &delegate, &context);
+
+  FtpProtocolHandler ftp_protocol_handler(
+      &ftp_transaction_factory, &ftp_auth_cache);
+
+  scoped_refptr<URLRequestJob> ftp_job(
+      ftp_protocol_handler.MaybeCreateJob(&url_request, NULL));
+  ASSERT_TRUE(ftp_job.get());
+
+  EXPECT_CALL(ftp_transaction_factory, CreateTransaction())
+      .WillOnce(Return(static_cast<FtpTransaction*>(NULL)));
+  ftp_job->Start();
+  EXPECT_CALL(delegate, OnResponseStarted(_))
+      .WillOnce(HandleOnResponseStarted(URLRequestStatus::FAILED));
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_FALSE(url_request.is_pending());
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_http_job.cc b/src/net/url_request/url_request_http_job.cc
new file mode 100644
index 0000000..4977f8c
--- /dev/null
+++ b/src/net/url_request/url_request_http_job.cc
@@ -0,0 +1,1631 @@
+// 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 "net/url_request/url_request_http_job.h"
+
+#include "base/base_switches.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/command_line.h"
+#include "base/compiler_specific.h"
+#include "base/file_util.h"
+#include "base/file_version_info.h"
+#include "base/message_loop.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
+#include "base/rand_util.h"
+#include "base/string_util.h"
+#include "base/time.h"
+#include "net/base/cert_status_flags.h"
+#include "net/base/filter.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/load_flags.h"
+#include "net/base/mime_util.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/base/network_delegate.h"
+#if !defined(__LB_SHELL__) && !defined(OS_STARBOARD)
+#include "net/base/sdch_manager.h"
+#endif
+#include "net/base/ssl_cert_request_info.h"
+#include "net/base/ssl_config_service.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_response_info.h"
+#include "net/http/http_status_code.h"
+#include "net/http/http_transaction.h"
+#include "net/http/http_transaction_delegate.h"
+#include "net/http/http_transaction_factory.h"
+#include "net/http/http_util.h"
+#include "net/url_request/fraudulent_certificate_reporter.h"
+#include "net/url_request/http_user_agent_settings.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_redirect_job.h"
+#include "net/url_request/url_request_throttler_header_adapter.h"
+#include "net/url_request/url_request_throttler_manager.h"
+
+namespace net {
+
+class URLRequestHttpJob::HttpFilterContext : public FilterContext {
+ public:
+  explicit HttpFilterContext(URLRequestHttpJob* job);
+  virtual ~HttpFilterContext();
+
+  // FilterContext implementation.
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual bool GetURL(GURL* gurl) const OVERRIDE;
+  virtual base::Time GetRequestTime() const OVERRIDE;
+  virtual bool IsCachedContent() const OVERRIDE;
+  virtual bool IsDownload() const OVERRIDE;
+  virtual bool IsSdchResponse() const OVERRIDE;
+  virtual int64 GetByteReadCount() const OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+  virtual void RecordPacketStats(StatisticSelector statistic) const OVERRIDE;
+
+  // Method to allow us to reset filter context for a response that should have
+  // been SDCH encoded when there is an update due to an explicit HTTP header.
+  void ResetSdchResponseToFalse();
+
+ private:
+  URLRequestHttpJob* job_;
+
+  DISALLOW_COPY_AND_ASSIGN(HttpFilterContext);
+};
+
+class URLRequestHttpJob::HttpTransactionDelegateImpl
+    : public HttpTransactionDelegate {
+ public:
+  explicit HttpTransactionDelegateImpl(URLRequest* request)
+      : request_(request),
+        network_delegate_(request->context()->network_delegate()),
+        cache_active_(false),
+        network_active_(false) {
+  }
+  virtual ~HttpTransactionDelegateImpl() {
+    OnDetachRequest();
+  }
+  void OnDetachRequest() {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    network_delegate_->NotifyRequestWaitStateChange(
+        *request_,
+        NetworkDelegate::REQUEST_WAIT_STATE_RESET);
+    cache_active_ = false;
+    network_active_ = false;
+    request_ = NULL;
+  }
+  virtual void OnCacheActionStart() OVERRIDE {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    DCHECK(!cache_active_ && !network_active_);
+    cache_active_ = true;
+    network_delegate_->NotifyRequestWaitStateChange(
+        *request_,
+        NetworkDelegate::REQUEST_WAIT_STATE_CACHE_START);
+  }
+  virtual void OnCacheActionFinish() OVERRIDE {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    DCHECK(cache_active_ && !network_active_);
+    cache_active_ = false;
+    network_delegate_->NotifyRequestWaitStateChange(
+        *request_,
+        NetworkDelegate::REQUEST_WAIT_STATE_CACHE_FINISH);
+  }
+  virtual void OnNetworkActionStart() OVERRIDE {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    DCHECK(!cache_active_ && !network_active_);
+    network_active_ = true;
+    network_delegate_->NotifyRequestWaitStateChange(
+        *request_,
+        NetworkDelegate::REQUEST_WAIT_STATE_NETWORK_START);
+  }
+  virtual void OnNetworkActionFinish() OVERRIDE {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    DCHECK(!cache_active_ && network_active_);
+    network_active_ = false;
+    network_delegate_->NotifyRequestWaitStateChange(
+        *request_,
+        NetworkDelegate::REQUEST_WAIT_STATE_NETWORK_FINISH);
+  }
+ private:
+  URLRequest* request_;
+  NetworkDelegate* network_delegate_;
+  bool cache_active_;
+  bool network_active_;
+};
+
+URLRequestHttpJob::HttpFilterContext::HttpFilterContext(URLRequestHttpJob* job)
+    : job_(job) {
+  DCHECK(job_);
+}
+
+URLRequestHttpJob::HttpFilterContext::~HttpFilterContext() {
+}
+
+bool URLRequestHttpJob::HttpFilterContext::GetMimeType(
+    std::string* mime_type) const {
+  return job_->GetMimeType(mime_type);
+}
+
+bool URLRequestHttpJob::HttpFilterContext::GetURL(GURL* gurl) const {
+  if (!job_->request())
+    return false;
+  *gurl = job_->request()->url();
+  return true;
+}
+
+base::Time URLRequestHttpJob::HttpFilterContext::GetRequestTime() const {
+  return job_->request() ? job_->request()->request_time() : base::Time();
+}
+
+bool URLRequestHttpJob::HttpFilterContext::IsCachedContent() const {
+  return job_->is_cached_content_;
+}
+
+bool URLRequestHttpJob::HttpFilterContext::IsDownload() const {
+  return (job_->request_info_.load_flags & LOAD_IS_DOWNLOAD) != 0;
+}
+
+void URLRequestHttpJob::HttpFilterContext::ResetSdchResponseToFalse() {
+  DCHECK(job_->sdch_dictionary_advertised_);
+  job_->sdch_dictionary_advertised_ = false;
+}
+
+bool URLRequestHttpJob::HttpFilterContext::IsSdchResponse() const {
+  return job_->sdch_dictionary_advertised_;
+}
+
+int64 URLRequestHttpJob::HttpFilterContext::GetByteReadCount() const {
+  return job_->filter_input_byte_count();
+}
+
+int URLRequestHttpJob::HttpFilterContext::GetResponseCode() const {
+  return job_->GetResponseCode();
+}
+
+void URLRequestHttpJob::HttpFilterContext::RecordPacketStats(
+    StatisticSelector statistic) const {
+  job_->RecordPacketStats(statistic);
+}
+
+// TODO(darin): make sure the port blocking code is not lost
+// static
+URLRequestJob* URLRequestHttpJob::Factory(URLRequest* request,
+                                          NetworkDelegate* network_delegate,
+                                          const std::string& scheme) {
+  DCHECK(scheme == "http" || scheme == "https");
+
+  if (!request->context()->http_transaction_factory()) {
+    NOTREACHED() << "requires a valid context";
+    return new URLRequestErrorJob(
+        request, network_delegate, ERR_INVALID_ARGUMENT);
+  }
+
+  GURL redirect_url;
+  if (request->GetHSTSRedirect(&redirect_url)) {
+    return new URLRequestRedirectJob(
+        request, network_delegate, redirect_url,
+        // Use status code 307 to preserve the method, so POST requests work.
+        URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT);
+  }
+  return new URLRequestHttpJob(request,
+                               network_delegate,
+                               request->context()->http_user_agent_settings());
+}
+
+
+URLRequestHttpJob::URLRequestHttpJob(
+    URLRequest* request,
+    NetworkDelegate* network_delegate,
+    const HttpUserAgentSettings* http_user_agent_settings)
+    : URLRequestJob(request, network_delegate),
+      response_info_(NULL),
+      response_cookies_save_index_(0),
+      proxy_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
+      server_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
+      ALLOW_THIS_IN_INITIALIZER_LIST(start_callback_(
+          base::Bind(&URLRequestHttpJob::OnStartCompleted,
+                     base::Unretained(this)))),
+      ALLOW_THIS_IN_INITIALIZER_LIST(notify_before_headers_sent_callback_(
+          base::Bind(&URLRequestHttpJob::NotifyBeforeSendHeadersCallback,
+                     base::Unretained(this)))),
+      read_in_progress_(false),
+      transaction_(NULL),
+      throttling_entry_(NULL),
+      sdch_dictionary_advertised_(false),
+      sdch_test_activated_(false),
+      sdch_test_control_(false),
+      is_cached_content_(false),
+      request_creation_time_(),
+      packet_timing_enabled_(false),
+      done_(false),
+      bytes_observed_in_packets_(0),
+      request_time_snapshot_(),
+      final_packet_time_(),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          filter_context_(new HttpFilterContext(this))),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(on_headers_received_callback_(
+          base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
+                     base::Unretained(this)))),
+      awaiting_callback_(false),
+      http_transaction_delegate_(new HttpTransactionDelegateImpl(request)),
+      http_user_agent_settings_(http_user_agent_settings) {
+  URLRequestThrottlerManager* manager = request->context()->throttler_manager();
+  if (manager)
+    throttling_entry_ = manager->RegisterRequestUrl(request->url());
+
+  ResetTimer();
+}
+
+void URLRequestHttpJob::NotifyHeadersComplete() {
+  DCHECK(!response_info_);
+
+  response_info_ = transaction_->GetResponseInfo();
+
+  // Save boolean, as we'll need this info at destruction time, and filters may
+  // also need this info.
+  is_cached_content_ = response_info_->was_cached;
+
+  if (!is_cached_content_ && throttling_entry_) {
+    URLRequestThrottlerHeaderAdapter response_adapter(GetResponseHeaders());
+    throttling_entry_->UpdateWithResponse(request_info_.url.host(),
+                                          &response_adapter);
+  }
+
+  // The ordering of these calls is not important.
+  ProcessStrictTransportSecurityHeader();
+  ProcessPublicKeyPinsHeader();
+
+#if !defined(__LB_SHELL__) && !defined(OS_STARBOARD)
+  if (SdchManager::Global() &&
+      SdchManager::Global()->IsInSupportedDomain(request_->url())) {
+    const std::string name = "Get-Dictionary";
+    std::string url_text;
+    void* iter = NULL;
+    // TODO(jar): We need to not fetch dictionaries the first time they are
+    // seen, but rather wait until we can justify their usefulness.
+    // For now, we will only fetch the first dictionary, which will at least
+    // require multiple suggestions before we get additional ones for this site.
+    // Eventually we should wait until a dictionary is requested several times
+    // before we even download it (so that we don't waste memory or bandwidth).
+    if (GetResponseHeaders()->EnumerateHeader(&iter, name, &url_text)) {
+      // request_->url() won't be valid in the destructor, so we use an
+      // alternate copy.
+      DCHECK_EQ(request_->url(), request_info_.url);
+      // Resolve suggested URL relative to request url.
+      sdch_dictionary_url_ = request_info_.url.Resolve(url_text);
+    }
+  }
+#endif
+
+  // The HTTP transaction may be restarted several times for the purposes
+  // of sending authorization information. Each time it restarts, we get
+  // notified of the headers completion so that we can update the cookie store.
+  if (transaction_->IsReadyToRestartForAuth()) {
+    DCHECK(!response_info_->auth_challenge.get());
+    // TODO(battre): This breaks the webrequest API for
+    // URLRequestTestHTTP.BasicAuthWithCookies
+    // where OnBeforeSendHeaders -> OnSendHeaders -> OnBeforeSendHeaders
+    // occurs.
+    RestartTransactionWithAuth(AuthCredentials());
+    return;
+  }
+
+  URLRequestJob::NotifyHeadersComplete();
+}
+
+void URLRequestHttpJob::NotifyDone(const URLRequestStatus& status) {
+  DoneWithRequest(FINISHED);
+  URLRequestJob::NotifyDone(status);
+}
+
+void URLRequestHttpJob::DestroyTransaction() {
+  DCHECK(transaction_.get());
+
+  DoneWithRequest(ABORTED);
+  transaction_.reset();
+  response_info_ = NULL;
+}
+
+void URLRequestHttpJob::StartTransaction() {
+  if (request_->context()->network_delegate()) {
+    int rv = request_->context()->network_delegate()->NotifyBeforeSendHeaders(
+        request_, notify_before_headers_sent_callback_,
+        &request_info_.extra_headers);
+    // If an extension blocks the request, we rely on the callback to
+    // MaybeStartTransactionInternal().
+    if (rv == ERR_IO_PENDING) {
+      SetBlockedOnDelegate();
+      return;
+    }
+    MaybeStartTransactionInternal(rv);
+    return;
+  }
+  StartTransactionInternal();
+}
+
+void URLRequestHttpJob::NotifyBeforeSendHeadersCallback(int result) {
+  SetUnblockedOnDelegate();
+
+  // Check that there are no callbacks to already canceled requests.
+  DCHECK_NE(URLRequestStatus::CANCELED, GetStatus().status());
+
+  MaybeStartTransactionInternal(result);
+}
+
+void URLRequestHttpJob::MaybeStartTransactionInternal(int result) {
+  if (result == OK) {
+    StartTransactionInternal();
+  } else {
+    std::string source("delegate");
+    request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
+                                 NetLog::StringCallback("source", &source));
+    NotifyCanceled();
+    NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
+  }
+}
+
+void URLRequestHttpJob::StartTransactionInternal() {
+  // NOTE: This method assumes that request_info_ is already setup properly.
+
+  // If we already have a transaction, then we should restart the transaction
+  // with auth provided by auth_credentials_.
+
+  int rv;
+
+  if (request_->context()->network_delegate()) {
+    request_->context()->network_delegate()->NotifySendHeaders(
+        request_, request_info_.extra_headers);
+  }
+
+  if (transaction_.get()) {
+    rv = transaction_->RestartWithAuth(auth_credentials_, start_callback_);
+    auth_credentials_ = AuthCredentials();
+  } else {
+    DCHECK(request_->context()->http_transaction_factory());
+
+    rv = request_->context()->http_transaction_factory()->CreateTransaction(
+        &transaction_, http_transaction_delegate_.get());
+    if (rv == OK) {
+      if (!throttling_entry_ ||
+          !throttling_entry_->ShouldRejectRequest(*request_)) {
+        rv = transaction_->Start(
+            &request_info_, start_callback_, request_->net_log());
+        start_time_ = base::TimeTicks::Now();
+      } else {
+        // Special error code for the exponential back-off module.
+        rv = ERR_TEMPORARILY_THROTTLED;
+      }
+    }
+  }
+
+  if (rv == ERR_IO_PENDING)
+    return;
+
+  // The transaction started synchronously, but we need to notify the
+  // URLRequest delegate via the message loop.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestHttpJob::OnStartCompleted,
+                 weak_factory_.GetWeakPtr(), rv));
+}
+
+void URLRequestHttpJob::AddExtraHeaders() {
+  // Supply Accept-Encoding field only if it is not already provided.
+  // It should be provided IF the content is known to have restrictions on
+  // potential encoding, such as streaming multi-media.
+  // For details see bug 47381.
+  // TODO(jar, enal): jpeg files etc. should set up a request header if
+  // possible. Right now it is done only by buffered_resource_loader and
+  // simple_data_source.
+  if (!request_info_.extra_headers.HasHeader(
+      HttpRequestHeaders::kAcceptEncoding)) {
+#if !defined(__LB_SHELL__) && !defined(OS_STARBOARD)
+    bool advertise_sdch = SdchManager::Global() &&
+        SdchManager::Global()->IsInSupportedDomain(request_->url());
+    std::string avail_dictionaries;
+    if (advertise_sdch) {
+      SdchManager::Global()->GetAvailDictionaryList(request_->url(),
+                                                    &avail_dictionaries);
+
+      // The AllowLatencyExperiment() is only true if we've successfully done a
+      // full SDCH compression recently in this browser session for this host.
+      // Note that for this path, there might be no applicable dictionaries,
+      // and hence we can't participate in the experiment.
+      if (!avail_dictionaries.empty() &&
+          SdchManager::Global()->AllowLatencyExperiment(request_->url())) {
+        // We are participating in the test (or control), and hence we'll
+        // eventually record statistics via either SDCH_EXPERIMENT_DECODE or
+        // SDCH_EXPERIMENT_HOLDBACK, and we'll need some packet timing data.
+        packet_timing_enabled_ = true;
+        if (base::RandDouble() < .01) {
+          sdch_test_control_ = true;  // 1% probability.
+          advertise_sdch = false;
+        } else {
+          sdch_test_activated_ = true;
+        }
+      }
+    }
+#else
+    bool advertise_sdch = false;
+#endif
+
+    // Supply Accept-Encoding headers first so that it is more likely that they
+    // will be in the first transmitted packet.  This can sometimes make it
+    // easier to filter and analyze the streams to assure that a proxy has not
+    // damaged these headers.  Some proxies deliberately corrupt Accept-Encoding
+    // headers.
+    if (!advertise_sdch) {
+      // Tell the server what compression formats we support (other than SDCH).
+      request_info_.extra_headers.SetHeader(
+          HttpRequestHeaders::kAcceptEncoding, "gzip,deflate");
+    } else {
+#if !defined(__LB_SHELL__) && !defined(COBALT) && !defined(OS_STARBOARD)
+      // Include SDCH in acceptable list.
+      request_info_.extra_headers.SetHeader(
+          HttpRequestHeaders::kAcceptEncoding, "gzip,deflate,sdch");
+      if (!avail_dictionaries.empty()) {
+        request_info_.extra_headers.SetHeader(
+            kAvailDictionaryHeader,
+            avail_dictionaries);
+        sdch_dictionary_advertised_ = true;
+        // Since we're tagging this transaction as advertising a dictionary,
+        // we'll definitely employ an SDCH filter (or tentative sdch filter)
+        // when we get a response.  When done, we'll record histograms via
+        // SDCH_DECODE or SDCH_PASSTHROUGH.  Hence we need to record packet
+        // arrival times.
+        packet_timing_enabled_ = true;
+      }
+#endif
+    }
+  }
+
+  if (http_user_agent_settings_) {
+    // Only add default Accept-Language and Accept-Charset if the request
+    // didn't have them specified.
+    std::string accept_language =
+        http_user_agent_settings_->GetAcceptLanguage();
+    if (!accept_language.empty()) {
+      request_info_.extra_headers.SetHeaderIfMissing(
+          HttpRequestHeaders::kAcceptLanguage,
+          accept_language);
+    }
+    std::string accept_charset = http_user_agent_settings_->GetAcceptCharset();
+    if (!accept_charset.empty()) {
+      request_info_.extra_headers.SetHeaderIfMissing(
+          HttpRequestHeaders::kAcceptCharset,
+          accept_charset);
+    }
+  }
+}
+
+void URLRequestHttpJob::AddCookieHeaderAndStart() {
+  // No matter what, we want to report our status as IO pending since we will
+  // be notifying our consumer asynchronously via OnStartCompleted.
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+
+  // If the request was destroyed, then there is no more work to do.
+  if (!request_)
+    return;
+
+  CookieStore* cookie_store = request_->context()->cookie_store();
+  if (cookie_store && !(request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES)) {
+    net::CookieMonster* cookie_monster = cookie_store->GetCookieMonster();
+    if (cookie_monster) {
+      cookie_monster->GetAllCookiesForURLAsync(
+          request_->url(),
+          base::Bind(&URLRequestHttpJob::CheckCookiePolicyAndLoad,
+                     weak_factory_.GetWeakPtr()));
+    } else {
+      CheckCookiePolicyAndLoad(CookieList());
+    }
+  } else {
+    DoStartTransaction();
+  }
+}
+
+void URLRequestHttpJob::DoLoadCookies() {
+  CookieOptions options;
+  options.set_include_httponly();
+  request_->context()->cookie_store()->GetCookiesWithInfoAsync(
+      request_->url(), options,
+      base::Bind(&URLRequestHttpJob::OnCookiesLoaded,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void URLRequestHttpJob::CheckCookiePolicyAndLoad(
+    const CookieList& cookie_list) {
+  if (CanGetCookies(cookie_list))
+    DoLoadCookies();
+  else
+    DoStartTransaction();
+}
+
+void URLRequestHttpJob::OnCookiesLoaded(
+    const std::string& cookie_line,
+    const std::vector<net::CookieStore::CookieInfo>& cookie_infos) {
+  if (!cookie_line.empty()) {
+    request_info_.extra_headers.SetHeader(
+        HttpRequestHeaders::kCookie, cookie_line);
+  }
+  DoStartTransaction();
+}
+
+void URLRequestHttpJob::DoStartTransaction() {
+  // We may have been canceled while retrieving cookies.
+  if (GetStatus().is_success()) {
+    StartTransaction();
+  } else {
+    NotifyCanceled();
+  }
+}
+
+void URLRequestHttpJob::SaveCookiesAndNotifyHeadersComplete(int result) {
+  if (result != net::OK) {
+    std::string source("delegate");
+    request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
+                                 NetLog::StringCallback("source", &source));
+    NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
+    return;
+  }
+
+  DCHECK(transaction_.get());
+
+  const HttpResponseInfo* response_info = transaction_->GetResponseInfo();
+  DCHECK(response_info);
+
+  response_cookies_.clear();
+  response_cookies_save_index_ = 0;
+
+  FetchResponseCookies(&response_cookies_);
+
+  if (!GetResponseHeaders()->GetDateValue(&response_date_))
+    response_date_ = base::Time();
+
+  // Now, loop over the response cookies, and attempt to persist each.
+  SaveNextCookie();
+}
+
+// If the save occurs synchronously, SaveNextCookie will loop and save the next
+// cookie. If the save is deferred, the callback is responsible for continuing
+// to iterate through the cookies.
+// TODO(erikwright): Modify the CookieStore API to indicate via return value
+// whether it completed synchronously or asynchronously.
+// See http://crbug.com/131066.
+void URLRequestHttpJob::SaveNextCookie() {
+  // No matter what, we want to report our status as IO pending since we will
+  // be notifying our consumer asynchronously via OnStartCompleted.
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+
+  // Used to communicate with the callback. See the implementation of
+  // OnCookieSaved.
+  scoped_refptr<SharedBoolean> callback_pending = new SharedBoolean(false);
+  scoped_refptr<SharedBoolean> save_next_cookie_running =
+      new SharedBoolean(true);
+
+  if (!(request_info_.load_flags & LOAD_DO_NOT_SAVE_COOKIES) &&
+      request_->context()->cookie_store() &&
+      response_cookies_.size() > 0) {
+    CookieOptions options;
+    options.set_include_httponly();
+    options.set_server_time(response_date_);
+
+    net::CookieStore::SetCookiesCallback callback(
+        base::Bind(&URLRequestHttpJob::OnCookieSaved,
+                   weak_factory_.GetWeakPtr(),
+                   save_next_cookie_running,
+                   callback_pending));
+
+    // Loop through the cookies as long as SetCookieWithOptionsAsync completes
+    // synchronously.
+    while (!callback_pending->data &&
+           response_cookies_save_index_ < response_cookies_.size()) {
+      if (CanSetCookie(
+          response_cookies_[response_cookies_save_index_], &options)) {
+        callback_pending->data = true;
+        request_->context()->cookie_store()->SetCookieWithOptionsAsync(
+            request_->url(), response_cookies_[response_cookies_save_index_],
+            options, callback);
+      }
+      ++response_cookies_save_index_;
+    }
+  }
+
+  save_next_cookie_running->data = false;
+
+  if (!callback_pending->data) {
+    response_cookies_.clear();
+    response_cookies_save_index_ = 0;
+    SetStatus(URLRequestStatus());  // Clear the IO_PENDING status
+    NotifyHeadersComplete();
+    return;
+  }
+}
+
+// |save_next_cookie_running| is true when the callback is bound and set to
+// false when SaveNextCookie exits, allowing the callback to determine if the
+// save occurred synchronously or asynchronously.
+// |callback_pending| is false when the callback is invoked and will be set to
+// true by the callback, allowing SaveNextCookie to detect whether the save
+// occurred synchronously.
+// See SaveNextCookie() for more information.
+void URLRequestHttpJob::OnCookieSaved(
+    scoped_refptr<SharedBoolean> save_next_cookie_running,
+    scoped_refptr<SharedBoolean> callback_pending,
+    bool cookie_status) {
+  callback_pending->data = false;
+
+  // If we were called synchronously, return.
+  if (save_next_cookie_running->data) {
+    return;
+  }
+
+  // We were called asynchronously, so trigger the next save.
+  // We may have been canceled within OnSetCookie.
+  if (GetStatus().is_success()) {
+    SaveNextCookie();
+  } else {
+    NotifyCanceled();
+  }
+}
+
+void URLRequestHttpJob::FetchResponseCookies(
+    std::vector<std::string>* cookies) {
+  const std::string name = "Set-Cookie";
+  std::string value;
+
+  void* iter = NULL;
+  HttpResponseHeaders* headers = GetResponseHeaders();
+  while (headers->EnumerateHeader(&iter, name, &value)) {
+    if (!value.empty())
+      cookies->push_back(value);
+  }
+}
+
+// NOTE: |ProcessStrictTransportSecurityHeader| and
+// |ProcessPublicKeyPinsHeader| have very similar structures, by design.
+// They manipulate different parts of |TransportSecurityState::DomainState|,
+// and they must remain complementary. If, in future changes here, there is
+// any conflict between their policies (such as in |domain_state.mode|), you
+// should resolve the conflict in favor of the more strict policy.
+void URLRequestHttpJob::ProcessStrictTransportSecurityHeader() {
+  DCHECK(response_info_);
+
+  const URLRequestContext* ctx = request_->context();
+  const SSLInfo& ssl_info = response_info_->ssl_info;
+
+  // Only accept strict transport security headers on HTTPS connections that
+  // have no certificate errors.
+  if (!ssl_info.is_valid() || IsCertStatusError(ssl_info.cert_status) ||
+      !ctx->transport_security_state()) {
+    return;
+  }
+
+  TransportSecurityState* security_state = ctx->transport_security_state();
+  TransportSecurityState::DomainState domain_state;
+  const std::string& host = request_info_.url.host();
+
+  bool sni_available =
+      SSLConfigService::IsSNIAvailable(ctx->ssl_config_service());
+  if (!security_state->GetDomainState(host, sni_available, &domain_state))
+    // |GetDomainState| may have altered |domain_state| while searching. If
+    // not found, start with a fresh state.
+    domain_state.upgrade_mode =
+        TransportSecurityState::DomainState::MODE_FORCE_HTTPS;
+
+  HttpResponseHeaders* headers = GetResponseHeaders();
+  std::string value;
+  void* iter = NULL;
+  base::Time now = base::Time::Now();
+
+  // http://tools.ietf.org/html/draft-ietf-websec-strict-transport-sec:
+  //
+  //   If a UA receives more than one STS header field in a HTTP response
+  //   message over secure transport, then the UA MUST process only the
+  //   first such header field.
+  bool seen_sts = false;
+  while (headers->EnumerateHeader(&iter, "Strict-Transport-Security", &value)) {
+    if (seen_sts)
+      return;
+    seen_sts = true;
+    TransportSecurityState::DomainState domain_state;
+    if (domain_state.ParseSTSHeader(now, value))
+      security_state->EnableHost(host, domain_state);
+  }
+}
+
+void URLRequestHttpJob::ProcessPublicKeyPinsHeader() {
+  DCHECK(response_info_);
+
+  const URLRequestContext* ctx = request_->context();
+  const SSLInfo& ssl_info = response_info_->ssl_info;
+
+  // Only accept public key pins headers on HTTPS connections that have no
+  // certificate errors.
+  if (!ssl_info.is_valid() || IsCertStatusError(ssl_info.cert_status) ||
+      !ctx->transport_security_state()) {
+    return;
+  }
+
+  TransportSecurityState* security_state = ctx->transport_security_state();
+  TransportSecurityState::DomainState domain_state;
+  const std::string& host = request_info_.url.host();
+
+  bool sni_available =
+      SSLConfigService::IsSNIAvailable(ctx->ssl_config_service());
+  if (!security_state->GetDomainState(host, sni_available, &domain_state))
+    // |GetDomainState| may have altered |domain_state| while searching. If
+    // not found, start with a fresh state.
+    domain_state.upgrade_mode =
+        TransportSecurityState::DomainState::MODE_DEFAULT;
+
+  HttpResponseHeaders* headers = GetResponseHeaders();
+  void* iter = NULL;
+  std::string value;
+  base::Time now = base::Time::Now();
+
+  while (headers->EnumerateHeader(&iter, "Public-Key-Pins", &value)) {
+    // Note that ParsePinsHeader updates |domain_state| (iff the header parses
+    // correctly), but does not completely overwrite it. It just updates the
+    // dynamic pinning metadata.
+    if (domain_state.ParsePinsHeader(now, value, ssl_info))
+      security_state->EnableHost(host, domain_state);
+  }
+}
+
+void URLRequestHttpJob::OnStartCompleted(int result) {
+  RecordTimer();
+
+  // If the request was destroyed, then there is no more work to do.
+  if (!request_)
+    return;
+
+  // If the transaction was destroyed, then the job was cancelled, and
+  // we can just ignore this notification.
+  if (!transaction_.get())
+    return;
+
+  // Clear the IO_PENDING status
+  SetStatus(URLRequestStatus());
+
+  const URLRequestContext* context = request_->context();
+
+  if (result == ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN &&
+      transaction_->GetResponseInfo() != NULL) {
+    FraudulentCertificateReporter* reporter =
+      context->fraudulent_certificate_reporter();
+    if (reporter != NULL) {
+      const SSLInfo& ssl_info = transaction_->GetResponseInfo()->ssl_info;
+      bool sni_available = SSLConfigService::IsSNIAvailable(
+          context->ssl_config_service());
+      const std::string& host = request_->url().host();
+
+      reporter->SendReport(host, ssl_info, sni_available);
+    }
+  }
+
+  if (result == OK) {
+    scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
+    if (context->network_delegate()) {
+      // Note that |this| may not be deleted until
+      // |on_headers_received_callback_| or
+      // |NetworkDelegate::URLRequestDestroyed()| has been called.
+      int error = context->network_delegate()->
+          NotifyHeadersReceived(request_, on_headers_received_callback_,
+                                headers, &override_response_headers_);
+      if (error != net::OK) {
+        if (error == net::ERR_IO_PENDING) {
+          awaiting_callback_ = true;
+          SetBlockedOnDelegate();
+        } else {
+          std::string source("delegate");
+          request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
+                                       NetLog::StringCallback("source",
+                                                              &source));
+          NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error));
+        }
+        return;
+      }
+    }
+
+    SaveCookiesAndNotifyHeadersComplete(net::OK);
+  } else if (IsCertificateError(result)) {
+    // We encountered an SSL certificate error.  Ask our delegate to decide
+    // what we should do.
+
+    TransportSecurityState::DomainState domain_state;
+    const URLRequestContext* context = request_->context();
+    const bool fatal =
+        context->transport_security_state() &&
+        context->transport_security_state()->GetDomainState(
+            request_info_.url.host(),
+            SSLConfigService::IsSNIAvailable(context->ssl_config_service()),
+            &domain_state);
+    NotifySSLCertificateError(transaction_->GetResponseInfo()->ssl_info, fatal);
+  } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
+    NotifyCertificateRequested(
+        transaction_->GetResponseInfo()->cert_request_info);
+  } else {
+    NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
+  }
+}
+
+void URLRequestHttpJob::OnHeadersReceivedCallback(int result) {
+  SetUnblockedOnDelegate();
+  awaiting_callback_ = false;
+
+  // Check that there are no callbacks to already canceled requests.
+  DCHECK_NE(URLRequestStatus::CANCELED, GetStatus().status());
+
+  SaveCookiesAndNotifyHeadersComplete(result);
+}
+
+void URLRequestHttpJob::OnReadCompleted(int result) {
+  read_in_progress_ = false;
+
+  if (ShouldFixMismatchedContentLength(result))
+    result = OK;
+
+  if (result == OK) {
+    NotifyDone(URLRequestStatus());
+  } else if (result < 0) {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
+  } else {
+    // Clear the IO_PENDING status
+    SetStatus(URLRequestStatus());
+  }
+
+  NotifyReadComplete(result);
+}
+
+void URLRequestHttpJob::RestartTransactionWithAuth(
+    const AuthCredentials& credentials) {
+  auth_credentials_ = credentials;
+
+  // These will be reset in OnStartCompleted.
+  response_info_ = NULL;
+  response_cookies_.clear();
+
+  ResetTimer();
+
+  // Update the cookies, since the cookie store may have been updated from the
+  // headers in the 401/407. Since cookies were already appended to
+  // extra_headers, we need to strip them out before adding them again.
+  request_info_.extra_headers.RemoveHeader(HttpRequestHeaders::kCookie);
+
+  AddCookieHeaderAndStart();
+}
+
+void URLRequestHttpJob::SetUpload(UploadDataStream* upload) {
+  DCHECK(!transaction_.get()) << "cannot change once started";
+  request_info_.upload_data_stream = upload;
+}
+
+void URLRequestHttpJob::SetExtraRequestHeaders(
+    const HttpRequestHeaders& headers) {
+  DCHECK(!transaction_.get()) << "cannot change once started";
+  request_info_.extra_headers.CopyFrom(headers);
+}
+
+void URLRequestHttpJob::Start() {
+  DCHECK(!transaction_.get());
+
+  // Ensure that we do not send username and password fields in the referrer.
+  GURL referrer(request_->GetSanitizedReferrer());
+
+  request_info_.url = request_->url();
+  request_info_.method = request_->method();
+  request_info_.load_flags = request_->load_flags();
+  request_info_.priority = request_->priority();
+  request_info_.request_id = request_->identifier();
+
+  // Strip Referer from request_info_.extra_headers to prevent, e.g., plugins
+  // from overriding headers that are controlled using other means. Otherwise a
+  // plugin could set a referrer although sending the referrer is inhibited.
+  request_info_.extra_headers.RemoveHeader(HttpRequestHeaders::kReferer);
+
+  // Our consumer should have made sure that this is a safe referrer.  See for
+  // instance WebCore::FrameLoader::HideReferrer.
+  if (referrer.is_valid()) {
+    request_info_.extra_headers.SetHeader(HttpRequestHeaders::kReferer,
+                                          referrer.spec());
+  }
+
+  request_info_.extra_headers.SetHeaderIfMissing(
+      HttpRequestHeaders::kUserAgent,
+      http_user_agent_settings_ ? http_user_agent_settings_->GetUserAgent()
+                                : EmptyString());
+
+  AddExtraHeaders();
+  AddCookieHeaderAndStart();
+}
+
+void URLRequestHttpJob::Kill() {
+  http_transaction_delegate_->OnDetachRequest();
+
+  if (!transaction_.get())
+    return;
+
+  weak_factory_.InvalidateWeakPtrs();
+  DestroyTransaction();
+  URLRequestJob::Kill();
+}
+
+LoadState URLRequestHttpJob::GetLoadState() const {
+  return transaction_.get() ?
+      transaction_->GetLoadState() : LOAD_STATE_IDLE;
+}
+
+UploadProgress URLRequestHttpJob::GetUploadProgress() const {
+  return transaction_.get() ?
+      transaction_->GetUploadProgress() : UploadProgress();
+}
+
+bool URLRequestHttpJob::GetMimeType(std::string* mime_type) const {
+  DCHECK(transaction_.get());
+
+  if (!response_info_)
+    return false;
+
+  return GetResponseHeaders()->GetMimeType(mime_type);
+}
+
+bool URLRequestHttpJob::GetCharset(std::string* charset) {
+  DCHECK(transaction_.get());
+
+  if (!response_info_)
+    return false;
+
+  return GetResponseHeaders()->GetCharset(charset);
+}
+
+void URLRequestHttpJob::GetResponseInfo(HttpResponseInfo* info) {
+  DCHECK(request_);
+  DCHECK(transaction_.get());
+
+  if (response_info_) {
+    *info = *response_info_;
+    if (override_response_headers_)
+      info->headers = override_response_headers_;
+  }
+}
+
+bool URLRequestHttpJob::GetResponseCookies(std::vector<std::string>* cookies) {
+  DCHECK(transaction_.get());
+
+  if (!response_info_)
+    return false;
+
+  // TODO(darin): Why are we extracting response cookies again?  Perhaps we
+  // should just leverage response_cookies_.
+
+  cookies->clear();
+  FetchResponseCookies(cookies);
+  return true;
+}
+
+int URLRequestHttpJob::GetResponseCode() const {
+  DCHECK(transaction_.get());
+
+  if (!response_info_)
+    return -1;
+
+  return GetResponseHeaders()->response_code();
+}
+
+Filter* URLRequestHttpJob::SetupFilter() const {
+  DCHECK(transaction_.get());
+  if (!response_info_)
+    return NULL;
+
+  std::vector<Filter::FilterType> encoding_types;
+  std::string encoding_type;
+  HttpResponseHeaders* headers = GetResponseHeaders();
+  void* iter = NULL;
+  while (headers->EnumerateHeader(&iter, "Content-Encoding", &encoding_type)) {
+    encoding_types.push_back(Filter::ConvertEncodingToType(encoding_type));
+  }
+
+  if (filter_context_->IsSdchResponse()) {
+    // We are wary of proxies that discard or damage SDCH encoding.  If a server
+    // explicitly states that this is not SDCH content, then we can correct our
+    // assumption that this is an SDCH response, and avoid the need to recover
+    // as though the content is corrupted (when we discover it is not SDCH
+    // encoded).
+    std::string sdch_response_status;
+    iter = NULL;
+    while (headers->EnumerateHeader(&iter, "X-Sdch-Encode",
+                                    &sdch_response_status)) {
+      if (sdch_response_status == "0") {
+        filter_context_->ResetSdchResponseToFalse();
+        break;
+      }
+    }
+  }
+
+  // Even if encoding types are empty, there is a chance that we need to add
+  // some decoding, as some proxies strip encoding completely. In such cases,
+  // we may need to add (for example) SDCH filtering (when the context suggests
+  // it is appropriate).
+  Filter::FixupEncodingTypes(*filter_context_, &encoding_types);
+
+  return !encoding_types.empty()
+      ? Filter::Factory(encoding_types, *filter_context_) : NULL;
+}
+
+bool URLRequestHttpJob::IsSafeRedirect(const GURL& location) {
+  // We only allow redirects to certain "safe" protocols.  This does not
+  // restrict redirects to externally handled protocols.  Our consumer would
+  // need to take care of those.
+
+  if (!URLRequest::IsHandledURL(location))
+    return true;
+
+  static const char* kSafeSchemes[] = {
+    "http",
+    "https",
+    "ftp"
+  };
+
+  for (size_t i = 0; i < arraysize(kSafeSchemes); ++i) {
+    if (location.SchemeIs(kSafeSchemes[i]))
+      return true;
+  }
+
+  return false;
+}
+
+bool URLRequestHttpJob::NeedsAuth() {
+  int code = GetResponseCode();
+  if (code == -1)
+    return false;
+
+  // Check if we need either Proxy or WWW Authentication.  This could happen
+  // because we either provided no auth info, or provided incorrect info.
+  switch (code) {
+    case 407:
+      if (proxy_auth_state_ == AUTH_STATE_CANCELED)
+        return false;
+      proxy_auth_state_ = AUTH_STATE_NEED_AUTH;
+      return true;
+    case 401:
+      if (server_auth_state_ == AUTH_STATE_CANCELED)
+        return false;
+      server_auth_state_ = AUTH_STATE_NEED_AUTH;
+      return true;
+  }
+  return false;
+}
+
+void URLRequestHttpJob::GetAuthChallengeInfo(
+    scoped_refptr<AuthChallengeInfo>* result) {
+  DCHECK(transaction_.get());
+  DCHECK(response_info_);
+
+  // sanity checks:
+  DCHECK(proxy_auth_state_ == AUTH_STATE_NEED_AUTH ||
+         server_auth_state_ == AUTH_STATE_NEED_AUTH);
+  DCHECK((GetResponseHeaders()->response_code() == HTTP_UNAUTHORIZED) ||
+         (GetResponseHeaders()->response_code() ==
+          HTTP_PROXY_AUTHENTICATION_REQUIRED));
+
+  *result = response_info_->auth_challenge;
+}
+
+void URLRequestHttpJob::SetAuth(const AuthCredentials& credentials) {
+  DCHECK(transaction_.get());
+
+  // Proxy gets set first, then WWW.
+  if (proxy_auth_state_ == AUTH_STATE_NEED_AUTH) {
+    proxy_auth_state_ = AUTH_STATE_HAVE_AUTH;
+  } else {
+    DCHECK_EQ(server_auth_state_, AUTH_STATE_NEED_AUTH);
+    server_auth_state_ = AUTH_STATE_HAVE_AUTH;
+  }
+
+  RestartTransactionWithAuth(credentials);
+}
+
+void URLRequestHttpJob::CancelAuth() {
+  // Proxy gets set first, then WWW.
+  if (proxy_auth_state_ == AUTH_STATE_NEED_AUTH) {
+    proxy_auth_state_ = AUTH_STATE_CANCELED;
+  } else {
+    DCHECK_EQ(server_auth_state_, AUTH_STATE_NEED_AUTH);
+    server_auth_state_ = AUTH_STATE_CANCELED;
+  }
+
+  // These will be reset in OnStartCompleted.
+  response_info_ = NULL;
+  response_cookies_.clear();
+
+  ResetTimer();
+
+  // OK, let the consumer read the error page...
+  //
+  // Because we set the AUTH_STATE_CANCELED flag, NeedsAuth will return false,
+  // which will cause the consumer to receive OnResponseStarted instead of
+  // OnAuthRequired.
+  //
+  // We have to do this via InvokeLater to avoid "recursing" the consumer.
+  //
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestHttpJob::OnStartCompleted,
+                 weak_factory_.GetWeakPtr(), OK));
+}
+
+void URLRequestHttpJob::ContinueWithCertificate(
+    X509Certificate* client_cert) {
+  DCHECK(transaction_.get());
+
+  DCHECK(!response_info_) << "should not have a response yet";
+
+  ResetTimer();
+
+  // No matter what, we want to report our status as IO pending since we will
+  // be notifying our consumer asynchronously via OnStartCompleted.
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+
+  int rv = transaction_->RestartWithCertificate(client_cert, start_callback_);
+  if (rv == ERR_IO_PENDING)
+    return;
+
+  // The transaction started synchronously, but we need to notify the
+  // URLRequest delegate via the message loop.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestHttpJob::OnStartCompleted,
+                 weak_factory_.GetWeakPtr(), rv));
+}
+
+void URLRequestHttpJob::ContinueDespiteLastError() {
+  // If the transaction was destroyed, then the job was cancelled.
+  if (!transaction_.get())
+    return;
+
+  DCHECK(!response_info_) << "should not have a response yet";
+
+  ResetTimer();
+
+  // No matter what, we want to report our status as IO pending since we will
+  // be notifying our consumer asynchronously via OnStartCompleted.
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+
+  int rv = transaction_->RestartIgnoringLastError(start_callback_);
+  if (rv == ERR_IO_PENDING)
+    return;
+
+  // The transaction started synchronously, but we need to notify the
+  // URLRequest delegate via the message loop.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestHttpJob::OnStartCompleted,
+                 weak_factory_.GetWeakPtr(), rv));
+}
+
+bool URLRequestHttpJob::ShouldFixMismatchedContentLength(int rv) const {
+  // Some servers send the body compressed, but specify the content length as
+  // the uncompressed size.  Although this violates the HTTP spec we want to
+  // support it (as IE and FireFox do), but *only* for an exact match.
+  // See http://crbug.com/79694.
+  if (rv == net::ERR_CONTENT_LENGTH_MISMATCH ||
+      rv == net::ERR_INCOMPLETE_CHUNKED_ENCODING) {
+    if (request_ && request_->response_headers()) {
+      int64 expected_length = request_->response_headers()->GetContentLength();
+      VLOG(1) << __FUNCTION__ << "() "
+              << "\"" << request_->url().spec() << "\""
+              << " content-length = " << expected_length
+              << " pre total = " << prefilter_bytes_read()
+              << " post total = " << postfilter_bytes_read();
+      if (postfilter_bytes_read() == expected_length) {
+        // Clear the error.
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool URLRequestHttpJob::ReadRawData(IOBuffer* buf, int buf_size,
+                                    int* bytes_read) {
+  DCHECK_NE(buf_size, 0);
+  DCHECK(bytes_read);
+  DCHECK(!read_in_progress_);
+
+  int rv = transaction_->Read(
+      buf, buf_size,
+      base::Bind(&URLRequestHttpJob::OnReadCompleted, base::Unretained(this)));
+
+  if (ShouldFixMismatchedContentLength(rv))
+    rv = 0;
+
+  if (rv >= 0) {
+    *bytes_read = rv;
+    if (!rv)
+      DoneWithRequest(FINISHED);
+    return true;
+  }
+
+  if (rv == ERR_IO_PENDING) {
+    read_in_progress_ = true;
+    SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+  } else {
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
+  }
+
+  return false;
+}
+
+void URLRequestHttpJob::StopCaching() {
+  if (transaction_.get())
+    transaction_->StopCaching();
+}
+
+void URLRequestHttpJob::DoneReading() {
+  if (transaction_.get())
+    transaction_->DoneReading();
+  DoneWithRequest(FINISHED);
+}
+
+HostPortPair URLRequestHttpJob::GetSocketAddress() const {
+  return response_info_ ? response_info_->socket_address : HostPortPair();
+}
+
+URLRequestHttpJob::~URLRequestHttpJob() {
+  CHECK(!awaiting_callback_);
+
+#if !defined(__LB_SHELL__) && !defined(OS_STARBOARD)
+  DCHECK(!sdch_test_control_ || !sdch_test_activated_);
+  if (!is_cached_content_) {
+    if (sdch_test_control_)
+      RecordPacketStats(FilterContext::SDCH_EXPERIMENT_HOLDBACK);
+    if (sdch_test_activated_)
+      RecordPacketStats(FilterContext::SDCH_EXPERIMENT_DECODE);
+  }
+  // Make sure SDCH filters are told to emit histogram data while
+  // filter_context_ is still alive.
+  DestroyFilters();
+
+  if (sdch_dictionary_url_.is_valid()) {
+    // Prior to reaching the destructor, request_ has been set to a NULL
+    // pointer, so request_->url() is no longer valid in the destructor, and we
+    // use an alternate copy |request_info_.url|.
+    SdchManager* manager = SdchManager::Global();
+    // To be extra safe, since this is a "different time" from when we decided
+    // to get the dictionary, we'll validate that an SdchManager is available.
+    // At shutdown time, care is taken to be sure that we don't delete this
+    // globally useful instance "too soon," so this check is just defensive
+    // coding to assure that IF the system is shutting down, we don't have any
+    // problem if the manager was deleted ahead of time.
+    if (manager)  // Defensive programming.
+      manager->FetchDictionary(request_info_.url, sdch_dictionary_url_);
+  }
+#endif
+  DoneWithRequest(ABORTED);
+}
+
+void URLRequestHttpJob::RecordTimer() {
+  if (request_creation_time_.is_null()) {
+    NOTREACHED()
+        << "The same transaction shouldn't start twice without new timing.";
+    return;
+  }
+
+  base::TimeDelta to_start = base::Time::Now() - request_creation_time_;
+  request_creation_time_ = base::Time();
+
+  UMA_HISTOGRAM_MEDIUM_TIMES("Net.HttpTimeToFirstByte", to_start);
+
+  static const bool use_overlapped_read_histogram =
+      base::FieldTrialList::TrialExists("OverlappedReadImpact");
+  if (use_overlapped_read_histogram) {
+    UMA_HISTOGRAM_MEDIUM_TIMES(
+        base::FieldTrial::MakeName("Net.HttpTimeToFirstByte",
+                                   "OverlappedReadImpact"),
+        to_start);
+  }
+
+  static const bool use_warm_socket_impact_histogram =
+      base::FieldTrialList::TrialExists("WarmSocketImpact");
+  if (use_warm_socket_impact_histogram) {
+    UMA_HISTOGRAM_MEDIUM_TIMES(
+        base::FieldTrial::MakeName("Net.HttpTimeToFirstByte",
+                                   "WarmSocketImpact"),
+        to_start);
+  }
+
+  static const bool use_prefetch_histogram =
+      base::FieldTrialList::TrialExists("Prefetch");
+  if (use_prefetch_histogram) {
+    UMA_HISTOGRAM_MEDIUM_TIMES(
+        base::FieldTrial::MakeName("Net.HttpTimeToFirstByte",
+                                   "Prefetch"),
+        to_start);
+  }
+  static const bool use_prerender_histogram =
+      base::FieldTrialList::TrialExists("Prerender");
+  if (use_prerender_histogram) {
+    UMA_HISTOGRAM_MEDIUM_TIMES(
+        base::FieldTrial::MakeName("Net.HttpTimeToFirstByte",
+                                   "Prerender"),
+        to_start);
+  }
+}
+
+void URLRequestHttpJob::ResetTimer() {
+  if (!request_creation_time_.is_null()) {
+    NOTREACHED()
+        << "The timer was reset before it was recorded.";
+    return;
+  }
+  request_creation_time_ = base::Time::Now();
+}
+
+void URLRequestHttpJob::UpdatePacketReadTimes() {
+  if (!packet_timing_enabled_)
+    return;
+
+  if (filter_input_byte_count() <= bytes_observed_in_packets_) {
+    DCHECK_EQ(filter_input_byte_count(), bytes_observed_in_packets_);
+    return;  // No new bytes have arrived.
+  }
+
+  final_packet_time_ = base::Time::Now();
+  if (!bytes_observed_in_packets_)
+    request_time_snapshot_ = request_ ? request_->request_time() : base::Time();
+
+  bytes_observed_in_packets_ = filter_input_byte_count();
+}
+
+void URLRequestHttpJob::RecordPacketStats(
+    FilterContext::StatisticSelector statistic) const {
+  if (!packet_timing_enabled_ || (final_packet_time_ == base::Time()))
+    return;
+
+  base::TimeDelta duration = final_packet_time_ - request_time_snapshot_;
+  switch (statistic) {
+    case FilterContext::SDCH_DECODE: {
+      UMA_HISTOGRAM_CUSTOM_COUNTS("Sdch3.Network_Decode_Bytes_Processed_b",
+          static_cast<int>(bytes_observed_in_packets_), 500, 100000, 100);
+      return;
+    }
+    case FilterContext::SDCH_PASSTHROUGH: {
+      // Despite advertising a dictionary, we handled non-sdch compressed
+      // content.
+      return;
+    }
+
+    case FilterContext::SDCH_EXPERIMENT_DECODE: {
+      UMA_HISTOGRAM_CUSTOM_TIMES("Sdch3.Experiment2_Decode",
+                                  duration,
+                                  base::TimeDelta::FromMilliseconds(20),
+                                  base::TimeDelta::FromMinutes(10), 100);
+      return;
+    }
+    case FilterContext::SDCH_EXPERIMENT_HOLDBACK: {
+      UMA_HISTOGRAM_CUSTOM_TIMES("Sdch3.Experiment2_Holdback",
+                                  duration,
+                                  base::TimeDelta::FromMilliseconds(20),
+                                  base::TimeDelta::FromMinutes(10), 100);
+      return;
+    }
+    default:
+      NOTREACHED();
+      return;
+  }
+}
+
+// The common type of histogram we use for all compression-tracking histograms.
+#define COMPRESSION_HISTOGRAM(name, sample) \
+    do { \
+      UMA_HISTOGRAM_CUSTOM_COUNTS("Net.Compress." name, sample, \
+                                  500, 1000000, 100); \
+    } while (0)
+
+void URLRequestHttpJob::RecordCompressionHistograms() {
+  DCHECK(request_);
+  if (!request_)
+    return;
+
+  if (is_cached_content_ ||                // Don't record cached content
+      !GetStatus().is_success() ||         // Don't record failed content
+      !IsCompressibleContent() ||          // Only record compressible content
+      !prefilter_bytes_read())       // Zero-byte responses aren't useful.
+    return;
+
+  // Miniature requests aren't really compressible.  Don't count them.
+  const int kMinSize = 16;
+  if (prefilter_bytes_read() < kMinSize)
+    return;
+
+  // Only record for http or https urls.
+  bool is_http = request_->url().SchemeIs("http");
+  bool is_https = request_->url().SchemeIs("https");
+  if (!is_http && !is_https)
+    return;
+
+  int compressed_B = prefilter_bytes_read();
+  int decompressed_B = postfilter_bytes_read();
+  bool was_filtered = HasFilter();
+
+  // We want to record how often downloaded resources are compressed.
+  // But, we recognize that different protocols may have different
+  // properties.  So, for each request, we'll put it into one of 3
+  // groups:
+  //      a) SSL resources
+  //         Proxies cannot tamper with compression headers with SSL.
+  //      b) Non-SSL, loaded-via-proxy resources
+  //         In this case, we know a proxy might have interfered.
+  //      c) Non-SSL, loaded-without-proxy resources
+  //         In this case, we know there was no explicit proxy.  However,
+  //         it is possible that a transparent proxy was still interfering.
+  //
+  // For each group, we record the same 3 histograms.
+
+  if (is_https) {
+    if (was_filtered) {
+      COMPRESSION_HISTOGRAM("SSL.BytesBeforeCompression", compressed_B);
+      COMPRESSION_HISTOGRAM("SSL.BytesAfterCompression", decompressed_B);
+    } else {
+      COMPRESSION_HISTOGRAM("SSL.ShouldHaveBeenCompressed", decompressed_B);
+    }
+    return;
+  }
+
+  if (request_->was_fetched_via_proxy()) {
+    if (was_filtered) {
+      COMPRESSION_HISTOGRAM("Proxy.BytesBeforeCompression", compressed_B);
+      COMPRESSION_HISTOGRAM("Proxy.BytesAfterCompression", decompressed_B);
+    } else {
+      COMPRESSION_HISTOGRAM("Proxy.ShouldHaveBeenCompressed", decompressed_B);
+    }
+    return;
+  }
+
+  if (was_filtered) {
+    COMPRESSION_HISTOGRAM("NoProxy.BytesBeforeCompression", compressed_B);
+    COMPRESSION_HISTOGRAM("NoProxy.BytesAfterCompression", decompressed_B);
+  } else {
+    COMPRESSION_HISTOGRAM("NoProxy.ShouldHaveBeenCompressed", decompressed_B);
+  }
+}
+
+bool URLRequestHttpJob::IsCompressibleContent() const {
+  std::string mime_type;
+  return GetMimeType(&mime_type) &&
+      (IsSupportedJavascriptMimeType(mime_type.c_str()) ||
+       IsSupportedNonImageMimeType(mime_type.c_str()));
+}
+
+void URLRequestHttpJob::RecordPerfHistograms(CompletionCause reason) {
+  if (start_time_.is_null())
+    return;
+
+  base::TimeDelta total_time = base::TimeTicks::Now() - start_time_;
+  UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTime", total_time);
+
+  if (reason == FINISHED) {
+    UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeSuccess", total_time);
+  } else {
+    UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeCancel", total_time);
+  }
+
+  if (response_info_) {
+    if (response_info_->was_cached) {
+      UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeCached", total_time);
+    } else  {
+      UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeNotCached", total_time);
+    }
+  }
+
+  static const bool use_overlapped_read_histogram =
+      base::FieldTrialList::TrialExists("OverlappedReadImpact");
+  if (use_overlapped_read_histogram) {
+    UMA_HISTOGRAM_TIMES(
+        base::FieldTrial::MakeName("Net.HttpJob.TotalTime",
+                                   "OverlappedReadImpact"),
+        total_time);
+
+    if (reason == FINISHED) {
+      UMA_HISTOGRAM_TIMES(
+          base::FieldTrial::MakeName("Net.HttpJob.TotalTimeSuccess",
+                                     "OverlappedReadImpact"),
+          total_time);
+    } else {
+      UMA_HISTOGRAM_TIMES(
+          base::FieldTrial::MakeName("Net.HttpJob.TotalTimeCancel",
+                                     "OverlappedReadImpact"),
+          total_time);
+    }
+
+    if (response_info_) {
+      if (response_info_->was_cached) {
+        UMA_HISTOGRAM_TIMES(
+            base::FieldTrial::MakeName("Net.HttpJob.TotalTimeCached",
+                                       "OverlappedReadImpact"),
+            total_time);
+      } else  {
+        UMA_HISTOGRAM_TIMES(
+            base::FieldTrial::MakeName("Net.HttpJob.TotalTimeNotCached",
+                                       "OverlappedReadImpact"),
+            total_time);
+      }
+    }
+  }
+
+  static const bool cache_sensitivity_analysis =
+      base::FieldTrialList::TrialExists("CacheSensitivityAnalysis");
+  if (cache_sensitivity_analysis) {
+    UMA_HISTOGRAM_TIMES(
+        base::FieldTrial::MakeName("Net.HttpJob.TotalTime",
+                                   "CacheSensitivityAnalysis"),
+        total_time);
+
+    if (reason == FINISHED) {
+      UMA_HISTOGRAM_TIMES(
+          base::FieldTrial::MakeName("Net.HttpJob.TotalTimeSuccess",
+                                     "CacheSensitivityAnalysis"),
+          total_time);
+    } else {
+      UMA_HISTOGRAM_TIMES(
+          base::FieldTrial::MakeName("Net.HttpJob.TotalTimeCancel",
+                                     "CacheSensitivityAnalysis"),
+          total_time);
+    }
+
+    if (response_info_) {
+      if (response_info_->was_cached) {
+        UMA_HISTOGRAM_TIMES(
+            base::FieldTrial::MakeName("Net.HttpJob.TotalTimeCached",
+                                       "CacheSensitivityAnalysis"),
+            total_time);
+      } else  {
+        UMA_HISTOGRAM_TIMES(
+            base::FieldTrial::MakeName("Net.HttpJob.TotalTimeNotCached",
+                                       "CacheSensitivityAnalysis"),
+            total_time);
+      }
+    }
+  }
+
+  start_time_ = base::TimeTicks();
+}
+
+void URLRequestHttpJob::DoneWithRequest(CompletionCause reason) {
+  if (done_)
+    return;
+  done_ = true;
+  RecordPerfHistograms(reason);
+  if (reason == FINISHED) {
+    request_->set_received_response_content_length(prefilter_bytes_read());
+    RecordCompressionHistograms();
+  }
+}
+
+HttpResponseHeaders* URLRequestHttpJob::GetResponseHeaders() const {
+  DCHECK(transaction_.get());
+  DCHECK(transaction_->GetResponseInfo());
+  return override_response_headers_.get() ?
+      override_response_headers_ :
+      transaction_->GetResponseInfo()->headers;
+}
+
+void URLRequestHttpJob::NotifyURLRequestDestroyed() {
+  awaiting_callback_ = false;
+}
+
+void URLRequestHttpJob::OnDetachRequest() {
+  http_transaction_delegate_->OnDetachRequest();
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_http_job.h b/src/net/url_request/url_request_http_job.h
new file mode 100644
index 0000000..9ef3884
--- /dev/null
+++ b/src/net/url_request/url_request_http_job.h
@@ -0,0 +1,258 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
+
+#include <string>
+#include <vector>
+
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/time.h"
+#include "net/base/auth.h"
+#include "net/base/completion_callback.h"
+#include "net/cookies/cookie_store.h"
+#include "net/http/http_request_info.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_throttler_entry_interface.h"
+
+namespace net {
+
+class HttpResponseHeaders;
+class HttpResponseInfo;
+class HttpTransaction;
+class HttpUserAgentSettings;
+class UploadDataStream;
+class URLRequestContext;
+
+// A URLRequestJob subclass that is built on top of HttpTransaction.  It
+// provides an implementation for both HTTP and HTTPS.
+class URLRequestHttpJob : public URLRequestJob {
+ public:
+  static URLRequestJob* Factory(URLRequest* request,
+                                NetworkDelegate* network_delegate,
+                                const std::string& scheme);
+
+ protected:
+  URLRequestHttpJob(URLRequest* request,
+                    NetworkDelegate* network_delegate,
+                    const HttpUserAgentSettings* http_user_agent_settings);
+
+  // Shadows URLRequestJob's version of this method so we can grab cookies.
+  void NotifyHeadersComplete();
+
+  // Shadows URLRequestJob's method so we can record histograms.
+  void NotifyDone(const URLRequestStatus& status);
+
+  void DestroyTransaction();
+
+  void AddExtraHeaders();
+  void AddCookieHeaderAndStart();
+  void SaveCookiesAndNotifyHeadersComplete(int result);
+  void SaveNextCookie();
+  void FetchResponseCookies(std::vector<std::string>* cookies);
+
+  // Processes the Strict-Transport-Security header, if one exists.
+  void ProcessStrictTransportSecurityHeader();
+
+  // Processes the Public-Key-Pins header, if one exists.
+  void ProcessPublicKeyPinsHeader();
+
+  // |result| should be net::OK, or the request is canceled.
+  void OnHeadersReceivedCallback(int result);
+  void OnStartCompleted(int result);
+  void OnReadCompleted(int result);
+  void NotifyBeforeSendHeadersCallback(int result);
+
+  void RestartTransactionWithAuth(const AuthCredentials& credentials);
+
+  // Overridden from URLRequestJob:
+  virtual void SetUpload(UploadDataStream* upload) OVERRIDE;
+  virtual void SetExtraRequestHeaders(
+      const HttpRequestHeaders& headers) OVERRIDE;
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual UploadProgress GetUploadProgress() const OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual bool GetCharset(std::string* charset) OVERRIDE;
+  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
+  virtual bool GetResponseCookies(std::vector<std::string>* cookies) OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+  virtual Filter* SetupFilter() const OVERRIDE;
+  virtual bool IsSafeRedirect(const GURL& location) OVERRIDE;
+  virtual bool NeedsAuth() OVERRIDE;
+  virtual void GetAuthChallengeInfo(scoped_refptr<AuthChallengeInfo>*) OVERRIDE;
+  virtual void SetAuth(const AuthCredentials& credentials) OVERRIDE;
+  virtual void CancelAuth() OVERRIDE;
+  virtual void ContinueWithCertificate(X509Certificate* client_cert) OVERRIDE;
+  virtual void ContinueDespiteLastError() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf, int buf_size,
+                           int* bytes_read) OVERRIDE;
+  virtual void StopCaching() OVERRIDE;
+  virtual void DoneReading() OVERRIDE;
+  virtual HostPortPair GetSocketAddress() const OVERRIDE;
+  virtual void NotifyURLRequestDestroyed() OVERRIDE;
+
+  HttpRequestInfo request_info_;
+  const HttpResponseInfo* response_info_;
+
+  std::vector<std::string> response_cookies_;
+  size_t response_cookies_save_index_;
+  base::Time response_date_;
+
+  // Auth states for proxy and origin server.
+  AuthState proxy_auth_state_;
+  AuthState server_auth_state_;
+  AuthCredentials auth_credentials_;
+
+  CompletionCallback start_callback_;
+  CompletionCallback notify_before_headers_sent_callback_;
+
+  bool read_in_progress_;
+
+  // An URL for an SDCH dictionary as suggested in a Get-Dictionary HTTP header.
+  GURL sdch_dictionary_url_;
+
+  scoped_ptr<HttpTransaction> transaction_;
+
+  // This is used to supervise traffic and enforce exponential
+  // back-off.  May be NULL.
+  scoped_refptr<URLRequestThrottlerEntryInterface> throttling_entry_;
+
+  // Indicated if an SDCH dictionary was advertised, and hence an SDCH
+  // compressed response is expected.  We use this to help detect (accidental?)
+  // proxy corruption of a response, which sometimes marks SDCH content as
+  // having no content encoding <oops>.
+  bool sdch_dictionary_advertised_;
+
+  // For SDCH latency experiments, when we are able to do SDCH, we may enable
+  // either an SDCH latency test xor a pass through test.  The following bools
+  // indicate what we decided on for this instance.
+  bool sdch_test_activated_;  // Advertising a dictionary for sdch.
+  bool sdch_test_control_;    // Not even accepting-content sdch.
+
+  // For recording of stats, we need to remember if this is cached content.
+  bool is_cached_content_;
+
+ private:
+  enum CompletionCause {
+    ABORTED,
+    FINISHED
+  };
+
+  typedef base::RefCountedData<bool> SharedBoolean;
+
+  class HttpFilterContext;
+  class HttpTransactionDelegateImpl;
+
+  virtual ~URLRequestHttpJob();
+
+  void RecordTimer();
+  void ResetTimer();
+
+  virtual void UpdatePacketReadTimes() OVERRIDE;
+  void RecordPacketStats(FilterContext::StatisticSelector statistic) const;
+
+  void RecordCompressionHistograms();
+  bool IsCompressibleContent() const;
+
+  // Starts the transaction if extensions using the webrequest API do not
+  // object.
+  void StartTransaction();
+  // If |result| is net::OK, calls StartTransactionInternal. Otherwise notifies
+  // cancellation.
+  void MaybeStartTransactionInternal(int result);
+  void StartTransactionInternal();
+
+  void RecordPerfHistograms(CompletionCause reason);
+  void DoneWithRequest(CompletionCause reason);
+
+  // Callback functions for Cookie Monster
+  void DoLoadCookies();
+  void CheckCookiePolicyAndLoad(const CookieList& cookie_list);
+  void OnCookiesLoaded(
+      const std::string& cookie_line,
+      const std::vector<CookieStore::CookieInfo>& cookie_infos);
+  void DoStartTransaction();
+
+  // See the implementation for a description of save_next_cookie_running and
+  // callback_pending.
+  void OnCookieSaved(scoped_refptr<SharedBoolean> save_next_cookie_running,
+                     scoped_refptr<SharedBoolean> callback_pending,
+                     bool cookie_status);
+
+  // Some servers send the body compressed, but specify the content length as
+  // the uncompressed size. If this is the case, we return true in order
+  // to request to work around this non-adherence to the HTTP standard.
+  // |rv| is the standard return value of a read function indicating the number
+  // of bytes read or, if negative, an error code.
+  bool ShouldFixMismatchedContentLength(int rv) const;
+
+  // Returns the effective response headers, considering that they may be
+  // overridden by |override_response_headers_|.
+  HttpResponseHeaders* GetResponseHeaders() const;
+
+  // Override of the private interface of URLRequestJob.
+  virtual void OnDetachRequest() OVERRIDE;
+
+  base::Time request_creation_time_;
+
+  // Data used for statistics gathering. This data is only used for histograms
+  // and is not required. It is only gathered if packet_timing_enabled_ == true.
+  //
+  // TODO(jar): improve the quality of the gathered info by gathering most times
+  // at a lower point in the network stack, assuring we have actual packet
+  // boundaries, rather than approximations.  Also note that input byte count
+  // as gathered here is post-SSL, and post-cache-fetch, and does not reflect
+  // true packet arrival times in such cases.
+
+  // Enable recording of packet arrival times for histogramming.
+  bool packet_timing_enabled_;
+  bool done_;  // True when we are done doing work.
+
+  // The number of bytes that have been accounted for in packets (where some of
+  // those packets may possibly have had their time of arrival recorded).
+  int64 bytes_observed_in_packets_;
+
+  // The request time may not be available when we are being destroyed, so we
+  // snapshot it early on.
+  base::Time request_time_snapshot_;
+
+  // Since we don't save all packet times in packet_times_, we save the
+  // last time for use in histograms.
+  base::Time final_packet_time_;
+
+  // The start time for the job, ignoring re-starts.
+  base::TimeTicks start_time_;
+
+  scoped_ptr<HttpFilterContext> filter_context_;
+  base::WeakPtrFactory<URLRequestHttpJob> weak_factory_;
+
+  CompletionCallback on_headers_received_callback_;
+
+  // We allow the network delegate to modify a copy of the response headers.
+  // This prevents modifications of headers that are shared with the underlying
+  // layers of the network stack.
+  scoped_refptr<HttpResponseHeaders> override_response_headers_;
+
+  // Flag used to verify that |this| is not deleted while we are awaiting
+  // a callback from the NetworkDelegate. Used as a fail-fast mechanism.
+  // True if we are waiting a callback and
+  // NetworkDelegate::NotifyURLRequestDestroyed has not been called, yet,
+  // to inform the NetworkDelegate that it may not call back.
+  bool awaiting_callback_;
+
+  scoped_ptr<HttpTransactionDelegateImpl> http_transaction_delegate_;
+
+  const HttpUserAgentSettings* http_user_agent_settings_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestHttpJob);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
diff --git a/src/net/url_request/url_request_job.cc b/src/net/url_request/url_request_job.cc
new file mode 100644
index 0000000..c929665
--- /dev/null
+++ b/src/net/url_request/url_request_job.cc
@@ -0,0 +1,711 @@
+// 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 "net/url_request/url_request_job.h"
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "net/base/auth.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/io_buffer.h"
+#include "net/base/load_states.h"
+#include "net/base/net_errors.h"
+#include "net/base/network_delegate.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_request.h"
+
+namespace net {
+
+URLRequestJob::URLRequestJob(URLRequest* request,
+                             NetworkDelegate* network_delegate)
+    : request_(request),
+      done_(false),
+      prefilter_bytes_read_(0),
+      postfilter_bytes_read_(0),
+      filter_input_byte_count_(0),
+      filter_needs_more_output_space_(false),
+      filtered_read_buffer_len_(0),
+      has_handled_response_(false),
+      expected_content_size_(-1),
+      deferred_redirect_status_code_(-1),
+      network_delegate_(network_delegate),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+  base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
+  if (system_monitor)
+    base::SystemMonitor::Get()->AddPowerObserver(this);
+}
+
+void URLRequestJob::SetUpload(UploadDataStream* upload) {
+}
+
+void URLRequestJob::SetExtraRequestHeaders(const HttpRequestHeaders& headers) {
+}
+
+void URLRequestJob::Kill() {
+  weak_factory_.InvalidateWeakPtrs();
+  // Make sure the request is notified that we are done.  We assume that the
+  // request took care of setting its error status before calling Kill.
+  if (request_)
+    NotifyCanceled();
+}
+
+void URLRequestJob::DetachRequest() {
+  request_ = NULL;
+  OnDetachRequest();
+}
+
+// This function calls ReadData to get stream data. If a filter exists, passes
+// the data to the attached filter. Then returns the output from filter back to
+// the caller.
+bool URLRequestJob::Read(IOBuffer* buf, int buf_size, int *bytes_read) {
+  bool rv = false;
+
+  DCHECK_LT(buf_size, 1000000);  // Sanity check.
+  DCHECK(buf);
+  DCHECK(bytes_read);
+  DCHECK(filtered_read_buffer_ == NULL);
+  DCHECK_EQ(0, filtered_read_buffer_len_);
+
+  *bytes_read = 0;
+
+  // Skip Filter if not present.
+  if (!filter_.get()) {
+    rv = ReadRawDataHelper(buf, buf_size, bytes_read);
+  } else {
+    // Save the caller's buffers while we do IO
+    // in the filter's buffers.
+    filtered_read_buffer_ = buf;
+    filtered_read_buffer_len_ = buf_size;
+
+    if (ReadFilteredData(bytes_read)) {
+      rv = true;   // We have data to return.
+
+      // It is fine to call DoneReading even if ReadFilteredData receives 0
+      // bytes from the net, but we avoid making that call if we know for
+      // sure that's the case (ReadRawDataHelper path).
+      if (*bytes_read == 0)
+        DoneReading();
+    } else {
+      rv = false;  // Error, or a new IO is pending.
+    }
+  }
+  if (rv && *bytes_read == 0)
+    NotifyDone(URLRequestStatus());
+  return rv;
+}
+
+void URLRequestJob::StopCaching() {
+  // Nothing to do here.
+}
+
+LoadState URLRequestJob::GetLoadState() const {
+  return LOAD_STATE_IDLE;
+}
+
+UploadProgress URLRequestJob::GetUploadProgress() const {
+  return UploadProgress();
+}
+
+bool URLRequestJob::GetCharset(std::string* charset) {
+  return false;
+}
+
+void URLRequestJob::GetResponseInfo(HttpResponseInfo* info) {
+}
+
+bool URLRequestJob::GetResponseCookies(std::vector<std::string>* cookies) {
+  return false;
+}
+
+Filter* URLRequestJob::SetupFilter() const {
+  return NULL;
+}
+
+bool URLRequestJob::IsRedirectResponse(GURL* location,
+                                       int* http_status_code) {
+  // For non-HTTP jobs, headers will be null.
+  HttpResponseHeaders* headers = request_->response_headers();
+  if (!headers)
+    return false;
+
+  std::string value;
+  if (!headers->IsRedirect(&value))
+    return false;
+
+  *location = request_->url().Resolve(value);
+  *http_status_code = headers->response_code();
+  return true;
+}
+
+bool URLRequestJob::IsSafeRedirect(const GURL& location) {
+  return true;
+}
+
+bool URLRequestJob::NeedsAuth() {
+  return false;
+}
+
+void URLRequestJob::GetAuthChallengeInfo(
+    scoped_refptr<AuthChallengeInfo>* auth_info) {
+  // This will only be called if NeedsAuth() returns true, in which
+  // case the derived class should implement this!
+  NOTREACHED();
+}
+
+void URLRequestJob::SetAuth(const AuthCredentials& credentials) {
+  // This will only be called if NeedsAuth() returns true, in which
+  // case the derived class should implement this!
+  NOTREACHED();
+}
+
+void URLRequestJob::CancelAuth() {
+  // This will only be called if NeedsAuth() returns true, in which
+  // case the derived class should implement this!
+  NOTREACHED();
+}
+
+void URLRequestJob::ContinueWithCertificate(
+    X509Certificate* client_cert) {
+  // The derived class should implement this!
+  NOTREACHED();
+}
+
+void URLRequestJob::ContinueDespiteLastError() {
+  // Implementations should know how to recover from errors they generate.
+  // If this code was reached, we are trying to recover from an error that
+  // we don't know how to recover from.
+  NOTREACHED();
+}
+
+void URLRequestJob::FollowDeferredRedirect() {
+  DCHECK(deferred_redirect_status_code_ != -1);
+
+  // NOTE: deferred_redirect_url_ may be invalid, and attempting to redirect to
+  // such an URL will fail inside FollowRedirect.  The DCHECK above asserts
+  // that we called OnReceivedRedirect.
+
+  // It is also possible that FollowRedirect will drop the last reference to
+  // this job, so we need to reset our members before calling it.
+
+  SetUnblockedOnDelegate();
+
+  GURL redirect_url = deferred_redirect_url_;
+  int redirect_status_code = deferred_redirect_status_code_;
+
+  deferred_redirect_url_ = GURL();
+  deferred_redirect_status_code_ = -1;
+
+  FollowRedirect(redirect_url, redirect_status_code);
+}
+
+bool URLRequestJob::GetMimeType(std::string* mime_type) const {
+  return false;
+}
+
+int URLRequestJob::GetResponseCode() const {
+  return -1;
+}
+
+HostPortPair URLRequestJob::GetSocketAddress() const {
+  return HostPortPair();
+}
+
+void URLRequestJob::OnSuspend() {
+  Kill();
+}
+
+void URLRequestJob::NotifyURLRequestDestroyed() {
+}
+
+URLRequestJob::~URLRequestJob() {
+  base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
+  if (system_monitor)
+    base::SystemMonitor::Get()->RemovePowerObserver(this);
+}
+
+void URLRequestJob::NotifyCertificateRequested(
+    SSLCertRequestInfo* cert_request_info) {
+  if (!request_)
+    return;  // The request was destroyed, so there is no more work to do.
+
+  request_->NotifyCertificateRequested(cert_request_info);
+}
+
+void URLRequestJob::NotifySSLCertificateError(const SSLInfo& ssl_info,
+                                              bool fatal) {
+  if (!request_)
+    return;  // The request was destroyed, so there is no more work to do.
+
+  request_->NotifySSLCertificateError(ssl_info, fatal);
+}
+
+bool URLRequestJob::CanGetCookies(const CookieList& cookie_list) const {
+  if (!request_)
+    return false;  // The request was destroyed, so there is no more work to do.
+
+  return request_->CanGetCookies(cookie_list);
+}
+
+bool URLRequestJob::CanSetCookie(const std::string& cookie_line,
+                                 CookieOptions* options) const {
+  if (!request_)
+    return false;  // The request was destroyed, so there is no more work to do.
+
+  return request_->CanSetCookie(cookie_line, options);
+}
+
+void URLRequestJob::NotifyHeadersComplete() {
+  if (!request_ || !request_->has_delegate())
+    return;  // The request was destroyed, so there is no more work to do.
+
+  if (has_handled_response_)
+    return;
+
+  DCHECK(!request_->status().is_io_pending());
+
+  // Initialize to the current time, and let the subclass optionally override
+  // the time stamps if it has that information.  The default request_time is
+  // set by URLRequest before it calls our Start method.
+  request_->response_info_.response_time = base::Time::Now();
+  GetResponseInfo(&request_->response_info_);
+
+  // When notifying the delegate, the delegate can release the request
+  // (and thus release 'this').  After calling to the delgate, we must
+  // check the request pointer to see if it still exists, and return
+  // immediately if it has been destroyed.  self_preservation ensures our
+  // survival until we can get out of this method.
+  scoped_refptr<URLRequestJob> self_preservation(this);
+
+  GURL new_location;
+  int http_status_code;
+  if (IsRedirectResponse(&new_location, &http_status_code)) {
+    const GURL& url = request_->url();
+
+    // Move the reference fragment of the old location to the new one if the
+    // new one has none. This duplicates mozilla's behavior.
+    if (url.is_valid() && url.has_ref() && !new_location.has_ref()) {
+      GURL::Replacements replacements;
+      // Reference the |ref| directly out of the original URL to avoid a
+      // malloc.
+      replacements.SetRef(url.spec().data(),
+                          url.parsed_for_possibly_invalid_spec().ref);
+      new_location = new_location.ReplaceComponents(replacements);
+    }
+
+    bool defer_redirect = false;
+    request_->NotifyReceivedRedirect(new_location, &defer_redirect);
+
+    // Ensure that the request wasn't detached or destroyed in
+    // NotifyReceivedRedirect
+    if (!request_ || !request_->has_delegate())
+      return;
+
+    // If we were not cancelled, then maybe follow the redirect.
+    if (request_->status().is_success()) {
+      if (defer_redirect) {
+        deferred_redirect_url_ = new_location;
+        deferred_redirect_status_code_ = http_status_code;
+        SetBlockedOnDelegate();
+      } else {
+        FollowRedirect(new_location, http_status_code);
+      }
+      return;
+    }
+  } else if (NeedsAuth()) {
+    scoped_refptr<AuthChallengeInfo> auth_info;
+    GetAuthChallengeInfo(&auth_info);
+    // Need to check for a NULL auth_info because the server may have failed
+    // to send a challenge with the 401 response.
+    if (auth_info) {
+      request_->NotifyAuthRequired(auth_info);
+      // Wait for SetAuth or CancelAuth to be called.
+      return;
+    }
+  }
+
+  has_handled_response_ = true;
+  if (request_->status().is_success())
+    filter_.reset(SetupFilter());
+
+  if (!filter_.get()) {
+    std::string content_length;
+    request_->GetResponseHeaderByName("content-length", &content_length);
+    if (!content_length.empty())
+      base::StringToInt64(content_length, &expected_content_size_);
+  }
+
+  request_->NotifyResponseStarted();
+}
+
+void URLRequestJob::NotifyReadComplete(int bytes_read) {
+  if (!request_ || !request_->has_delegate())
+    return;  // The request was destroyed, so there is no more work to do.
+
+  // TODO(darin): Bug 1004233. Re-enable this test once all of the chrome
+  // unit_tests have been fixed to not trip this.
+  //DCHECK(!request_->status().is_io_pending());
+
+  // The headers should be complete before reads complete
+  DCHECK(has_handled_response_);
+
+  OnRawReadComplete(bytes_read);
+
+  // Don't notify if we had an error.
+  if (!request_->status().is_success())
+    return;
+
+  // When notifying the delegate, the delegate can release the request
+  // (and thus release 'this').  After calling to the delegate, we must
+  // check the request pointer to see if it still exists, and return
+  // immediately if it has been destroyed.  self_preservation ensures our
+  // survival until we can get out of this method.
+  scoped_refptr<URLRequestJob> self_preservation(this);
+
+  if (filter_.get()) {
+    // Tell the filter that it has more data
+    FilteredDataRead(bytes_read);
+
+    // Filter the data.
+    int filter_bytes_read = 0;
+    if (ReadFilteredData(&filter_bytes_read)) {
+      if (!filter_bytes_read)
+        DoneReading();
+      request_->NotifyReadCompleted(filter_bytes_read);
+    }
+  } else {
+    request_->NotifyReadCompleted(bytes_read);
+  }
+  DVLOG(1) << __FUNCTION__ << "() "
+           << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+           << " pre bytes read = " << bytes_read
+           << " pre total = " << prefilter_bytes_read_
+           << " post total = " << postfilter_bytes_read_;
+}
+
+void URLRequestJob::NotifyStartError(const URLRequestStatus &status) {
+  DCHECK(!has_handled_response_);
+  has_handled_response_ = true;
+  if (request_) {
+    request_->set_status(status);
+    request_->NotifyResponseStarted();
+  }
+}
+
+void URLRequestJob::NotifyDone(const URLRequestStatus &status) {
+  DCHECK(!done_) << "Job sending done notification twice";
+  if (done_)
+    return;
+  done_ = true;
+
+  // Unless there was an error, we should have at least tried to handle
+  // the response before getting here.
+  DCHECK(has_handled_response_ || !status.is_success());
+
+  // As with NotifyReadComplete, we need to take care to notice if we were
+  // destroyed during a delegate callback.
+  if (request_) {
+    request_->set_is_pending(false);
+    // With async IO, it's quite possible to have a few outstanding
+    // requests.  We could receive a request to Cancel, followed shortly
+    // by a successful IO.  For tracking the status(), once there is
+    // an error, we do not change the status back to success.  To
+    // enforce this, only set the status if the job is so far
+    // successful.
+    if (request_->status().is_success()) {
+      if (status.status() == URLRequestStatus::FAILED) {
+        request_->net_log().AddEventWithNetErrorCode(NetLog::TYPE_FAILED,
+                                                     status.error());
+      }
+      request_->set_status(status);
+    }
+  }
+
+  // Complete this notification later.  This prevents us from re-entering the
+  // delegate if we're done because of a synchronous call.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestJob::CompleteNotifyDone,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void URLRequestJob::CompleteNotifyDone() {
+  // Check if we should notify the delegate that we're done because of an error.
+  if (request_ &&
+      !request_->status().is_success() &&
+      request_->has_delegate()) {
+    // We report the error differently depending on whether we've called
+    // OnResponseStarted yet.
+    if (has_handled_response_) {
+      // We signal the error by calling OnReadComplete with a bytes_read of -1.
+      request_->NotifyReadCompleted(-1);
+    } else {
+      has_handled_response_ = true;
+      request_->NotifyResponseStarted();
+    }
+  }
+}
+
+void URLRequestJob::NotifyCanceled() {
+  if (!done_) {
+    NotifyDone(URLRequestStatus(URLRequestStatus::CANCELED, ERR_ABORTED));
+  }
+}
+
+void URLRequestJob::NotifyRestartRequired() {
+  DCHECK(!has_handled_response_);
+  if (GetStatus().status() != URLRequestStatus::CANCELED)
+    request_->Restart();
+}
+
+void URLRequestJob::SetBlockedOnDelegate() {
+  request_->SetBlockedOnDelegate();
+}
+
+void URLRequestJob::SetUnblockedOnDelegate() {
+  request_->SetUnblockedOnDelegate();
+}
+
+bool URLRequestJob::ReadRawData(IOBuffer* buf, int buf_size,
+                                int *bytes_read) {
+  DCHECK(bytes_read);
+  *bytes_read = 0;
+  return true;
+}
+
+void URLRequestJob::DoneReading() {
+  // Do nothing.
+}
+
+void URLRequestJob::FilteredDataRead(int bytes_read) {
+  DCHECK(filter_.get());  // don't add data if there is no filter
+  filter_->FlushStreamBuffer(bytes_read);
+}
+
+bool URLRequestJob::ReadFilteredData(int* bytes_read) {
+  DCHECK(filter_.get());  // don't add data if there is no filter
+  DCHECK(filtered_read_buffer_ != NULL);  // we need to have a buffer to fill
+  DCHECK_GT(filtered_read_buffer_len_, 0);  // sanity check
+  DCHECK_LT(filtered_read_buffer_len_, 1000000);  // sanity check
+  DCHECK(raw_read_buffer_ == NULL);  // there should be no raw read buffer yet
+
+  bool rv = false;
+  *bytes_read = 0;
+
+  if (is_done())
+    return true;
+
+  if (!filter_needs_more_output_space_ && !filter_->stream_data_len()) {
+    // We don't have any raw data to work with, so
+    // read from the socket.
+    int filtered_data_read;
+    if (ReadRawDataForFilter(&filtered_data_read)) {
+      if (filtered_data_read > 0) {
+        filter_->FlushStreamBuffer(filtered_data_read);  // Give data to filter.
+      } else {
+        return true;  // EOF
+      }
+    } else {
+      return false;  // IO Pending (or error)
+    }
+  }
+
+  if ((filter_->stream_data_len() || filter_needs_more_output_space_)
+      && !is_done()) {
+    // Get filtered data.
+    int filtered_data_len = filtered_read_buffer_len_;
+    Filter::FilterStatus status;
+    int output_buffer_size = filtered_data_len;
+    status = filter_->ReadData(filtered_read_buffer_->data(),
+                               &filtered_data_len);
+
+    if (filter_needs_more_output_space_ && 0 == filtered_data_len) {
+      // filter_needs_more_output_space_ was mistaken... there are no more bytes
+      // and we should have at least tried to fill up the filter's input buffer.
+      // Correct the state, and try again.
+      filter_needs_more_output_space_ = false;
+      return ReadFilteredData(bytes_read);
+    }
+
+    switch (status) {
+      case Filter::FILTER_DONE: {
+        filter_needs_more_output_space_ = false;
+        *bytes_read = filtered_data_len;
+        postfilter_bytes_read_ += filtered_data_len;
+        rv = true;
+        break;
+      }
+      case Filter::FILTER_NEED_MORE_DATA: {
+        filter_needs_more_output_space_ =
+            (filtered_data_len == output_buffer_size);
+        // We have finished filtering all data currently in the buffer.
+        // There might be some space left in the output buffer. One can
+        // consider reading more data from the stream to feed the filter
+        // and filling up the output buffer. This leads to more complicated
+        // buffer management and data notification mechanisms.
+        // We can revisit this issue if there is a real perf need.
+        if (filtered_data_len > 0) {
+          *bytes_read = filtered_data_len;
+          postfilter_bytes_read_ += filtered_data_len;
+          rv = true;
+        } else {
+          // Read again since we haven't received enough data yet (e.g., we may
+          // not have a complete gzip header yet)
+          rv = ReadFilteredData(bytes_read);
+        }
+        break;
+      }
+      case Filter::FILTER_OK: {
+        filter_needs_more_output_space_ =
+            (filtered_data_len == output_buffer_size);
+        *bytes_read = filtered_data_len;
+        postfilter_bytes_read_ += filtered_data_len;
+        rv = true;
+        break;
+      }
+      case Filter::FILTER_ERROR: {
+        DVLOG(1) << __FUNCTION__ << "() "
+                 << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+                 << " Filter Error";
+        filter_needs_more_output_space_ = false;
+        NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+                   ERR_CONTENT_DECODING_FAILED));
+        rv = false;
+        break;
+      }
+      default: {
+        NOTREACHED();
+        filter_needs_more_output_space_ = false;
+        rv = false;
+        break;
+      }
+    }
+    DVLOG(2) << __FUNCTION__ << "() "
+             << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+             << " rv = " << rv
+             << " post bytes read = " << filtered_data_len
+             << " pre total = " << prefilter_bytes_read_
+             << " post total = "
+             << postfilter_bytes_read_;
+    // If logging all bytes is enabled, log the filtered bytes read.
+    if (rv && request() && request()->net_log().IsLoggingBytes() &&
+        filtered_data_len > 0) {
+      request()->net_log().AddByteTransferEvent(
+          NetLog::TYPE_URL_REQUEST_JOB_FILTERED_BYTES_READ,
+          filtered_data_len, filtered_read_buffer_->data());
+    }
+  } else {
+    // we are done, or there is no data left.
+    rv = true;
+  }
+
+  if (rv) {
+    // When we successfully finished a read, we no longer need to
+    // save the caller's buffers. Release our reference.
+    filtered_read_buffer_ = NULL;
+    filtered_read_buffer_len_ = 0;
+  }
+  return rv;
+}
+
+const URLRequestStatus URLRequestJob::GetStatus() {
+  if (request_)
+    return request_->status();
+  // If the request is gone, we must be cancelled.
+  return URLRequestStatus(URLRequestStatus::CANCELED,
+                          ERR_ABORTED);
+}
+
+void URLRequestJob::SetStatus(const URLRequestStatus &status) {
+  if (request_)
+    request_->set_status(status);
+}
+
+bool URLRequestJob::ReadRawDataForFilter(int* bytes_read) {
+  bool rv = false;
+
+  DCHECK(bytes_read);
+  DCHECK(filter_.get());
+
+  *bytes_read = 0;
+
+  // Get more pre-filtered data if needed.
+  // TODO(mbelshe): is it possible that the filter needs *MORE* data
+  //    when there is some data already in the buffer?
+  if (!filter_->stream_data_len() && !is_done()) {
+    IOBuffer* stream_buffer = filter_->stream_buffer();
+    int stream_buffer_size = filter_->stream_buffer_size();
+    rv = ReadRawDataHelper(stream_buffer, stream_buffer_size, bytes_read);
+  }
+  return rv;
+}
+
+bool URLRequestJob::ReadRawDataHelper(IOBuffer* buf, int buf_size,
+                                      int* bytes_read) {
+  DCHECK(!request_->status().is_io_pending());
+  DCHECK(raw_read_buffer_ == NULL);
+
+  // Keep a pointer to the read buffer, so we have access to it in the
+  // OnRawReadComplete() callback in the event that the read completes
+  // asynchronously.
+  raw_read_buffer_ = buf;
+  bool rv = ReadRawData(buf, buf_size, bytes_read);
+
+  if (!request_->status().is_io_pending()) {
+    // If |filter_| is NULL, and logging all bytes is enabled, log the raw
+    // bytes read.
+    if (!filter_.get() && request() && request()->net_log().IsLoggingBytes() &&
+        *bytes_read > 0) {
+      request()->net_log().AddByteTransferEvent(
+          NetLog::TYPE_URL_REQUEST_JOB_BYTES_READ,
+          *bytes_read, raw_read_buffer_->data());
+    }
+
+    // If the read completes synchronously, either success or failure,
+    // invoke the OnRawReadComplete callback so we can account for the
+    // completed read.
+    OnRawReadComplete(*bytes_read);
+  }
+  return rv;
+}
+
+void URLRequestJob::FollowRedirect(const GURL& location, int http_status_code) {
+  int rv = request_->Redirect(location, http_status_code);
+  if (rv != OK)
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
+}
+
+void URLRequestJob::OnRawReadComplete(int bytes_read) {
+  DCHECK(raw_read_buffer_);
+  if (bytes_read > 0) {
+    RecordBytesRead(bytes_read);
+  }
+  raw_read_buffer_ = NULL;
+}
+
+void URLRequestJob::RecordBytesRead(int bytes_read) {
+  filter_input_byte_count_ += bytes_read;
+  prefilter_bytes_read_ += bytes_read;
+  if (!filter_.get())
+    postfilter_bytes_read_ += bytes_read;
+  DVLOG(2) << __FUNCTION__ << "() "
+           << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+           << " pre bytes read = " << bytes_read
+           << " pre total = " << prefilter_bytes_read_
+           << " post total = " << postfilter_bytes_read_;
+  UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
+  if (network_delegate_)
+    network_delegate_->NotifyRawBytesRead(*request_, bytes_read);
+}
+
+bool URLRequestJob::FilterHasData() {
+    return filter_.get() && filter_->stream_data_len();
+}
+
+void URLRequestJob::UpdatePacketReadTimes() {
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_job.h b/src/net/url_request/url_request_job.h
new file mode 100644
index 0000000..3178285
--- /dev/null
+++ b/src/net/url_request/url_request_job.h
@@ -0,0 +1,388 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_JOB_H_
+
+#include <string>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/system_monitor/system_monitor.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/filter.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/load_states.h"
+#include "net/base/net_export.h"
+#include "net/base/upload_progress.h"
+#include "net/cookies/canonical_cookie.h"
+
+namespace net {
+
+class AuthChallengeInfo;
+class AuthCredentials;
+class CookieOptions;
+class HttpRequestHeaders;
+class HttpResponseInfo;
+class IOBuffer;
+class NetworkDelegate;
+class SSLCertRequestInfo;
+class SSLInfo;
+class URLRequest;
+class UploadDataStream;
+class URLRequestStatus;
+class X509Certificate;
+
+class NET_EXPORT URLRequestJob : public base::RefCounted<URLRequestJob>,
+                                 public base::SystemMonitor::PowerObserver {
+ public:
+  explicit URLRequestJob(URLRequest* request,
+                         NetworkDelegate* network_delegate);
+
+  // Returns the request that owns this job. THIS POINTER MAY BE NULL if the
+  // request was destroyed.
+  URLRequest* request() const {
+    return request_;
+  }
+
+  // Sets the upload data, most requests have no upload data, so this is a NOP.
+  // Job types supporting upload data will override this.
+  virtual void SetUpload(UploadDataStream* upload_data_stream);
+
+  // Sets extra request headers for Job types that support request headers.
+  virtual void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
+
+  // If any error occurs while starting the Job, NotifyStartError should be
+  // called.
+  // This helps ensure that all errors follow more similar notification code
+  // paths, which should simplify testing.
+  virtual void Start() = 0;
+
+  // This function MUST somehow call NotifyDone/NotifyCanceled or some requests
+  // will get leaked. Certain callers use that message to know when they can
+  // delete their URLRequest object, even when doing a cancel. The default
+  // Kill implementation calls NotifyCanceled, so it is recommended that
+  // subclasses call URLRequestJob::Kill() after doing any additional work.
+  //
+  // The job should endeavor to stop working as soon as is convenient, but must
+  // not send and complete notifications from inside this function. Instead,
+  // complete notifications (including "canceled") should be sent from a
+  // callback run from the message loop.
+  //
+  // The job is not obliged to immediately stop sending data in response to
+  // this call, nor is it obliged to fail with "canceled" unless not all data
+  // was sent as a result. A typical case would be where the job is almost
+  // complete and can succeed before the canceled notification can be
+  // dispatched (from the message loop).
+  //
+  // The job should be prepared to receive multiple calls to kill it, but only
+  // one notification must be issued.
+  virtual void Kill();
+
+  // Called to detach the request from this Job.  Results in the Job being
+  // killed off eventually. The job must not use the request pointer any more.
+  void DetachRequest();
+
+  // Called to read post-filtered data from this Job, returning the number of
+  // bytes read, 0 when there is no more data, or -1 if there was an error.
+  // This is just the backend for URLRequest::Read, see that function for
+  // more info.
+  bool Read(IOBuffer* buf, int buf_size, int* bytes_read);
+
+  // Stops further caching of this request, if any. For more info, see
+  // URLRequest::StopCaching().
+  virtual void StopCaching();
+
+  // Called to fetch the current load state for the job.
+  virtual LoadState GetLoadState() const;
+
+  // Called to get the upload progress in bytes.
+  virtual UploadProgress GetUploadProgress() const;
+
+  // Called to fetch the charset for this request.  Only makes sense for some
+  // types of requests. Returns true on success.  Calling this on a type that
+  // doesn't have a charset will return false.
+  virtual bool GetCharset(std::string* charset);
+
+  // Called to get response info.
+  virtual void GetResponseInfo(HttpResponseInfo* info);
+
+  // Returns the cookie values included in the response, if applicable.
+  // Returns true if applicable.
+  // NOTE: This removes the cookies from the job, so it will only return
+  //       useful results once per job.
+  virtual bool GetResponseCookies(std::vector<std::string>* cookies);
+
+  // Called to setup a stream filter for this request. An example of filter is
+  // content encoding/decoding.
+  // Subclasses should return the appropriate Filter, or NULL for no Filter.
+  // This class takes ownership of the returned Filter.
+  //
+  // The default implementation returns NULL.
+  virtual Filter* SetupFilter() const;
+
+  // Called to determine if this response is a redirect.  Only makes sense
+  // for some types of requests.  This method returns true if the response
+  // is a redirect, and fills in the location param with the URL of the
+  // redirect.  The HTTP status code (e.g., 302) is filled into
+  // |*http_status_code| to signify the type of redirect.
+  //
+  // The caller is responsible for following the redirect by setting up an
+  // appropriate replacement Job. Note that the redirected location may be
+  // invalid, the caller should be sure it can handle this.
+  //
+  // The default implementation inspects the response_info_.
+  virtual bool IsRedirectResponse(GURL* location, int* http_status_code);
+
+  // Called to determine if it is okay to redirect this job to the specified
+  // location.  This may be used to implement protocol-specific restrictions.
+  // If this function returns false, then the URLRequest will fail
+  // reporting ERR_UNSAFE_REDIRECT.
+  virtual bool IsSafeRedirect(const GURL& location);
+
+  // Called to determine if this response is asking for authentication.  Only
+  // makes sense for some types of requests.  The caller is responsible for
+  // obtaining the credentials passing them to SetAuth.
+  virtual bool NeedsAuth();
+
+  // Fills the authentication info with the server's response.
+  virtual void GetAuthChallengeInfo(
+      scoped_refptr<AuthChallengeInfo>* auth_info);
+
+  // Resend the request with authentication credentials.
+  virtual void SetAuth(const AuthCredentials& credentials);
+
+  // Display the error page without asking for credentials again.
+  virtual void CancelAuth();
+
+  virtual void ContinueWithCertificate(X509Certificate* client_cert);
+
+  // Continue processing the request ignoring the last error.
+  virtual void ContinueDespiteLastError();
+
+  void FollowDeferredRedirect();
+
+  // Returns true if the Job is done producing response data and has called
+  // NotifyDone on the request.
+  bool is_done() const { return done_; }
+
+  // Get/Set expected content size
+  int64 expected_content_size() const { return expected_content_size_; }
+  void set_expected_content_size(const int64& size) {
+    expected_content_size_ = size;
+  }
+
+  // Whether we have processed the response for that request yet.
+  bool has_response_started() const { return has_handled_response_; }
+
+  // These methods are not applicable to all connections.
+  virtual bool GetMimeType(std::string* mime_type) const;
+  virtual int GetResponseCode() const;
+
+  // Returns the socket address for the connection.
+  // See url_request.h for details.
+  virtual HostPortPair GetSocketAddress() const;
+
+  // base::SystemMonitor::PowerObserver methods:
+  // We invoke URLRequestJob::Kill on suspend (crbug.com/4606).
+  virtual void OnSuspend() OVERRIDE;
+
+  // Called after a NetworkDelegate has been informed that the URLRequest
+  // will be destroyed. This is used to track that no pending callbacks
+  // exist at destruction time of the URLRequestJob, unless they have been
+  // canceled by an explicit NetworkDelegate::NotifyURLRequestDestroyed() call.
+  virtual void NotifyURLRequestDestroyed();
+
+ protected:
+  friend class base::RefCounted<URLRequestJob>;
+  virtual ~URLRequestJob();
+
+  // Notifies the job that a certificate is requested.
+  void NotifyCertificateRequested(SSLCertRequestInfo* cert_request_info);
+
+  // Notifies the job about an SSL certificate error.
+  void NotifySSLCertificateError(const SSLInfo& ssl_info, bool fatal);
+
+  // Delegates to URLRequest::Delegate.
+  bool CanGetCookies(const CookieList& cookie_list) const;
+
+  // Delegates to URLRequest::Delegate.
+  bool CanSetCookie(const std::string& cookie_line,
+                    CookieOptions* options) const;
+
+  // Notifies the job that headers have been received.
+  void NotifyHeadersComplete();
+
+  // Notifies the request that the job has completed a Read operation.
+  void NotifyReadComplete(int bytes_read);
+
+  // Notifies the request that a start error has occurred.
+  void NotifyStartError(const URLRequestStatus& status);
+
+  // NotifyDone marks when we are done with a request.  It is really
+  // a glorified set_status, but also does internal state checking and
+  // job tracking.  It should be called once per request, when the job is
+  // finished doing all IO.
+  void NotifyDone(const URLRequestStatus& status);
+
+  // Some work performed by NotifyDone must be completed on a separate task
+  // so as to avoid re-entering the delegate.  This method exists to perform
+  // that work.
+  void CompleteNotifyDone();
+
+  // Used as an asynchronous callback for Kill to notify the URLRequest
+  // that we were canceled.
+  void NotifyCanceled();
+
+  // Notifies the job the request should be restarted.
+  // Should only be called if the job has not started a resposne.
+  void NotifyRestartRequired();
+
+  // Called when the network delegate blocks or unblocks this request when
+  // intercepting certain requests.
+  void SetBlockedOnDelegate();
+  void SetUnblockedOnDelegate();
+
+  // Called to read raw (pre-filtered) data from this Job.
+  // If returning true, data was read from the job.  buf will contain
+  // the data, and bytes_read will receive the number of bytes read.
+  // If returning true, and bytes_read is returned as 0, there is no
+  // additional data to be read.
+  // If returning false, an error occurred or an async IO is now pending.
+  // If async IO is pending, the status of the request will be
+  // URLRequestStatus::IO_PENDING, and buf must remain available until the
+  // operation is completed.  See comments on URLRequest::Read for more
+  // info.
+  virtual bool ReadRawData(IOBuffer* buf, int buf_size, int *bytes_read);
+
+  // Called to tell the job that a filter has successfully reached the end of
+  // the stream.
+  virtual void DoneReading();
+
+  // Informs the filter that data has been read into its buffer
+  void FilteredDataRead(int bytes_read);
+
+  // Reads filtered data from the request.  Returns true if successful,
+  // false otherwise.  Note, if there is not enough data received to
+  // return data, this call can issue a new async IO request under
+  // the hood.
+  bool ReadFilteredData(int *bytes_read);
+
+  // Whether the response is being filtered in this job.
+  // Only valid after NotifyHeadersComplete() has been called.
+  bool HasFilter() { return filter_ != NULL; }
+
+  // At or near destruction time, a derived class may request that the filters
+  // be destroyed so that statistics can be gathered while the derived class is
+  // still present to assist in calculations.  This is used by URLRequestHttpJob
+  // to get SDCH to emit stats.
+  void DestroyFilters() { filter_.reset(); }
+
+  // The status of the job.
+  const URLRequestStatus GetStatus();
+
+  // Set the status of the job.
+  void SetStatus(const URLRequestStatus& status);
+
+  // The number of bytes read before passing to the filter.
+  int prefilter_bytes_read() const { return prefilter_bytes_read_; }
+
+  // The number of bytes read after passing through the filter.
+  int postfilter_bytes_read() const { return postfilter_bytes_read_; }
+
+  // Total number of bytes read from network (or cache) and typically handed
+  // to filter to process.  Used to histogram compression ratios, and error
+  // recovery scenarios in filters.
+  int64 filter_input_byte_count() const { return filter_input_byte_count_; }
+
+  // The request that initiated this job. This value MAY BE NULL if the
+  // request was released by DetachRequest().
+  URLRequest* request_;
+
+ private:
+  // When data filtering is enabled, this function is used to read data
+  // for the filter.  Returns true if raw data was read.  Returns false if
+  // an error occurred (or we are waiting for IO to complete).
+  bool ReadRawDataForFilter(int *bytes_read);
+
+  // Invokes ReadRawData and records bytes read if the read completes
+  // synchronously.
+  bool ReadRawDataHelper(IOBuffer* buf, int buf_size, int* bytes_read);
+
+  // Called in response to a redirect that was not canceled to follow the
+  // redirect. The current job will be replaced with a new job loading the
+  // given redirect destination.
+  void FollowRedirect(const GURL& location, int http_status_code);
+
+  // Called after every raw read. If |bytes_read| is > 0, this indicates
+  // a successful read of |bytes_read| unfiltered bytes. If |bytes_read|
+  // is 0, this indicates that there is no additional data to read. If
+  // |bytes_read| is < 0, an error occurred and no bytes were read.
+  void OnRawReadComplete(int bytes_read);
+
+  // Updates the profiling info and notifies observers that an additional
+  // |bytes_read| unfiltered bytes have been read for this job.
+  void RecordBytesRead(int bytes_read);
+
+  // Called to query whether there is data available in the filter to be read
+  // out.
+  bool FilterHasData();
+
+  // Subclasses may implement this method to record packet arrival times.
+  // The default implementation does nothing.
+  virtual void UpdatePacketReadTimes();
+
+  // Custom handler for derived classes when the request is detached.
+  virtual void OnDetachRequest() {}
+
+  // Indicates that the job is done producing data, either it has completed
+  // all the data or an error has been encountered. Set exclusively by
+  // NotifyDone so that it is kept in sync with the request.
+  bool done_;
+
+  int prefilter_bytes_read_;
+  int postfilter_bytes_read_;
+  int64 filter_input_byte_count_;
+
+  // The data stream filter which is enabled on demand.
+  scoped_ptr<Filter> filter_;
+
+  // If the filter filled its output buffer, then there is a change that it
+  // still has internal data to emit, and this flag is set.
+  bool filter_needs_more_output_space_;
+
+  // When we filter data, we receive data into the filter buffers.  After
+  // processing the filtered data, we return the data in the caller's buffer.
+  // While the async IO is in progress, we save the user buffer here, and
+  // when the IO completes, we fill this in.
+  scoped_refptr<IOBuffer> filtered_read_buffer_;
+  int filtered_read_buffer_len_;
+
+  // We keep a pointer to the read buffer while asynchronous reads are
+  // in progress, so we are able to pass those bytes to job observers.
+  scoped_refptr<IOBuffer> raw_read_buffer_;
+
+  // Used by HandleResponseIfNecessary to track whether we've sent the
+  // OnResponseStarted callback and potentially redirect callbacks as well.
+  bool has_handled_response_;
+
+  // Expected content size
+  int64 expected_content_size_;
+
+  // Set when a redirect is deferred.
+  GURL deferred_redirect_url_;
+  int deferred_redirect_status_code_;
+
+  NetworkDelegate* network_delegate_;
+
+  base::WeakPtrFactory<URLRequestJob> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestJob);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_JOB_H_
diff --git a/src/net/url_request/url_request_job_factory.cc b/src/net/url_request/url_request_job_factory.cc
new file mode 100644
index 0000000..e07152a
--- /dev/null
+++ b/src/net/url_request/url_request_job_factory.cc
@@ -0,0 +1,22 @@
+// Copyright (c) 2011 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 "net/url_request/url_request_job_factory.h"
+
+namespace net {
+
+URLRequestJobFactory::ProtocolHandler::~ProtocolHandler() {}
+
+URLRequestJobFactory::Interceptor::~Interceptor() {}
+
+bool URLRequestJobFactory::Interceptor::WillHandleProtocol(
+    const std::string& protocol) const {
+  return false;
+}
+
+URLRequestJobFactory::URLRequestJobFactory() {}
+
+URLRequestJobFactory::~URLRequestJobFactory() {}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_job_factory.h b/src/net/url_request/url_request_job_factory.h
new file mode 100644
index 0000000..adff7f1
--- /dev/null
+++ b/src/net/url_request/url_request_job_factory.h
@@ -0,0 +1,117 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_JOB_FACTORY_H_
+#define NET_URL_REQUEST_URL_REQUEST_JOB_FACTORY_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/threading/non_thread_safe.h"
+#include "net/base/net_export.h"
+
+class GURL;
+
+namespace net {
+
+class NetworkDelegate;
+class URLRequest;
+class URLRequestJob;
+
+class NET_EXPORT URLRequestJobFactory
+    : NON_EXPORTED_BASE(public base::NonThreadSafe) {
+ public:
+  // TODO(shalev): Move this to URLRequestJobFactoryImpl.
+  class NET_EXPORT ProtocolHandler {
+   public:
+    virtual ~ProtocolHandler();
+
+    virtual URLRequestJob* MaybeCreateJob(
+        URLRequest* request, NetworkDelegate* network_delegate) const = 0;
+  };
+
+  // TODO(shalev): Move this to URLRequestJobFactoryImpl.
+  class NET_EXPORT Interceptor {
+   public:
+    virtual ~Interceptor();
+
+    // Called for every request made.  Should return a new job to handle the
+    // request if it should be intercepted, or NULL to allow the request to
+    // be handled in the normal manner.
+    virtual URLRequestJob* MaybeIntercept(
+        URLRequest* request, NetworkDelegate* network_delegate) const = 0;
+
+    // Called after having received a redirect response, but prior to the
+    // the request delegate being informed of the redirect. Can return a new
+    // job to replace the existing job if it should be intercepted, or NULL
+    // to allow the normal handling to continue. If a new job is provided,
+    // the delegate never sees the original redirect response, instead the
+    // response produced by the intercept job will be returned.
+    virtual URLRequestJob* MaybeInterceptRedirect(
+        const GURL& location,
+        URLRequest* request,
+        NetworkDelegate* network_delegate) const = 0;
+
+    // Called after having received a final response, but prior to the
+    // the request delegate being informed of the response. This is also
+    // called when there is no server response at all to allow interception
+    // on DNS or network errors. Can return a new job to replace the existing
+    // job if it should be intercepted, or NULL to allow the normal handling to
+    // continue. If a new job is provided, the delegate never sees the original
+    // response, instead the response produced by the intercept job will be
+    // returned.
+    virtual URLRequestJob* MaybeInterceptResponse(
+        URLRequest* request, NetworkDelegate* network_delegate) const = 0;
+
+    // Returns true if this interceptor handles requests for URLs with the
+    // given protocol. Returning false does not imply that this interceptor
+    // can't or won't handle requests with the given protocol.
+    virtual bool WillHandleProtocol(const std::string& protocol) const;
+  };
+
+  URLRequestJobFactory();
+  virtual ~URLRequestJobFactory();
+
+  // TODO(shalev): Remove this from the interface.
+  // Sets the ProtocolHandler for a scheme. Returns true on success, false on
+  // failure (a ProtocolHandler already exists for |scheme|). On success,
+  // URLRequestJobFactory takes ownership of |protocol_handler|.
+  virtual bool SetProtocolHandler(const std::string& scheme,
+                                  ProtocolHandler* protocol_handler) = 0;
+
+  // TODO(shalev): Remove this from the interface.
+  // Takes ownership of |interceptor|. Adds it to the end of the Interceptor
+  // list.
+  virtual void AddInterceptor(Interceptor* interceptor) = 0;
+
+  // TODO(shalev): Consolidate MaybeCreateJobWithInterceptor and
+  // MaybeCreateJobWithProtocolHandler into a single method.
+  virtual URLRequestJob* MaybeCreateJobWithInterceptor(
+      URLRequest* request, NetworkDelegate* network_delegate) const = 0;
+
+  virtual URLRequestJob* MaybeCreateJobWithProtocolHandler(
+      const std::string& scheme,
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const = 0;
+
+  virtual URLRequestJob* MaybeInterceptRedirect(
+      const GURL& location,
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const = 0;
+
+  virtual URLRequestJob* MaybeInterceptResponse(
+      URLRequest* request, NetworkDelegate* network_delegate) const = 0;
+
+  virtual bool IsHandledProtocol(const std::string& scheme) const = 0;
+
+  virtual bool IsHandledURL(const GURL& url) const = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(URLRequestJobFactory);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_JOB_FACTORY_H_
diff --git a/src/net/url_request/url_request_job_factory_impl.cc b/src/net/url_request/url_request_job_factory_impl.cc
new file mode 100644
index 0000000..aaeed79
--- /dev/null
+++ b/src/net/url_request/url_request_job_factory_impl.cc
@@ -0,0 +1,130 @@
+// Copyright (c) 2011 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 "net/url_request/url_request_job_factory_impl.h"
+
+#include "base/stl_util.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/load_flags.h"
+#include "net/url_request/url_request_job_manager.h"
+
+namespace net {
+
+URLRequestJobFactoryImpl::URLRequestJobFactoryImpl() {}
+
+URLRequestJobFactoryImpl::~URLRequestJobFactoryImpl() {
+  STLDeleteValues(&protocol_handler_map_);
+  STLDeleteElements(&interceptors_);
+}
+
+bool URLRequestJobFactoryImpl::SetProtocolHandler(
+    const std::string& scheme,
+    ProtocolHandler* protocol_handler) {
+  DCHECK(CalledOnValidThread());
+
+  if (!protocol_handler) {
+    ProtocolHandlerMap::iterator it = protocol_handler_map_.find(scheme);
+    if (it == protocol_handler_map_.end())
+      return false;
+
+    delete it->second;
+    protocol_handler_map_.erase(it);
+    return true;
+  }
+
+  if (ContainsKey(protocol_handler_map_, scheme))
+    return false;
+  protocol_handler_map_[scheme] = protocol_handler;
+  return true;
+}
+
+void URLRequestJobFactoryImpl::AddInterceptor(Interceptor* interceptor) {
+  DCHECK(CalledOnValidThread());
+  CHECK(interceptor);
+
+  interceptors_.push_back(interceptor);
+}
+
+URLRequestJob* URLRequestJobFactoryImpl::MaybeCreateJobWithInterceptor(
+    URLRequest* request, NetworkDelegate* network_delegate) const {
+  DCHECK(CalledOnValidThread());
+  URLRequestJob* job = NULL;
+
+  if (!(request->load_flags() & LOAD_DISABLE_INTERCEPT)) {
+    InterceptorList::const_iterator i;
+    for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
+      job = (*i)->MaybeIntercept(request, network_delegate);
+      if (job)
+        return job;
+    }
+  }
+  return NULL;
+}
+
+URLRequestJob* URLRequestJobFactoryImpl::MaybeCreateJobWithProtocolHandler(
+    const std::string& scheme,
+    URLRequest* request,
+    NetworkDelegate* network_delegate) const {
+  DCHECK(CalledOnValidThread());
+  ProtocolHandlerMap::const_iterator it = protocol_handler_map_.find(scheme);
+  if (it == protocol_handler_map_.end())
+    return NULL;
+  return it->second->MaybeCreateJob(request, network_delegate);
+}
+
+URLRequestJob* URLRequestJobFactoryImpl::MaybeInterceptRedirect(
+    const GURL& location,
+    URLRequest* request,
+    NetworkDelegate* network_delegate) const {
+  DCHECK(CalledOnValidThread());
+  URLRequestJob* job = NULL;
+
+  if (!(request->load_flags() & LOAD_DISABLE_INTERCEPT)) {
+    InterceptorList::const_iterator i;
+    for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
+      job = (*i)->MaybeInterceptRedirect(location, request, network_delegate);
+      if (job)
+        return job;
+    }
+  }
+  return NULL;
+}
+
+URLRequestJob* URLRequestJobFactoryImpl::MaybeInterceptResponse(
+    URLRequest* request, NetworkDelegate* network_delegate) const {
+  DCHECK(CalledOnValidThread());
+  URLRequestJob* job = NULL;
+
+  if (!(request->load_flags() & LOAD_DISABLE_INTERCEPT)) {
+    InterceptorList::const_iterator i;
+    for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
+      job = (*i)->MaybeInterceptResponse(request, network_delegate);
+      if (job)
+        return job;
+    }
+  }
+  return NULL;
+}
+
+bool URLRequestJobFactoryImpl::IsHandledProtocol(
+    const std::string& scheme) const {
+  DCHECK(CalledOnValidThread());
+  InterceptorList::const_iterator i;
+  for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
+    if ((*i)->WillHandleProtocol(scheme))
+      return true;
+  }
+  return ContainsKey(protocol_handler_map_, scheme) ||
+      URLRequestJobManager::GetInstance()->SupportsScheme(scheme);
+}
+
+bool URLRequestJobFactoryImpl::IsHandledURL(const GURL& url) const {
+  if (!url.is_valid()) {
+    // We handle error cases.
+    return true;
+  }
+  return IsHandledProtocol(url.scheme());
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_job_factory_impl.h b/src/net/url_request/url_request_job_factory_impl.h
new file mode 100644
index 0000000..ff27185
--- /dev/null
+++ b/src/net/url_request/url_request_job_factory_impl.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_JOB_FACTORY_IMPL_H_
+#define NET_URL_REQUEST_URL_REQUEST_JOB_FACTORY_IMPL_H_
+
+#include <map>
+#include <vector>
+#include "base/basictypes.h"
+#include "net/base/net_export.h"
+#include "net/url_request/url_request_job_factory.h"
+
+namespace net {
+
+class NET_EXPORT URLRequestJobFactoryImpl : public URLRequestJobFactory {
+ public:
+  URLRequestJobFactoryImpl();
+  virtual ~URLRequestJobFactoryImpl();
+
+  // URLRequestJobFactory implementation
+  virtual bool SetProtocolHandler(const std::string& scheme,
+                          ProtocolHandler* protocol_handler) OVERRIDE;
+  virtual void AddInterceptor(Interceptor* interceptor) OVERRIDE;
+  virtual URLRequestJob* MaybeCreateJobWithInterceptor(
+      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual URLRequestJob* MaybeCreateJobWithProtocolHandler(
+      const std::string& scheme,
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual URLRequestJob* MaybeInterceptRedirect(
+      const GURL& location,
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual URLRequestJob* MaybeInterceptResponse(
+      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
+  virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
+
+ private:
+  typedef std::map<std::string, ProtocolHandler*> ProtocolHandlerMap;
+  typedef std::vector<Interceptor*> InterceptorList;
+
+  ProtocolHandlerMap protocol_handler_map_;
+  InterceptorList interceptors_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestJobFactoryImpl);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_JOB_FACTORY_IMPL_H_
diff --git a/src/net/url_request/url_request_job_factory_impl_unittest.cc b/src/net/url_request/url_request_job_factory_impl_unittest.cc
new file mode 100644
index 0000000..232b21a
--- /dev/null
+++ b/src/net/url_request/url_request_job_factory_impl_unittest.cc
@@ -0,0 +1,218 @@
+// 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 "net/url_request/url_request_job_factory_impl.h"
+
+#include "base/bind.h"
+#include "base/memory/weak_ptr.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+class MockURLRequestJob : public URLRequestJob {
+ public:
+  MockURLRequestJob(URLRequest* request,
+                    NetworkDelegate* network_delegate,
+                    const URLRequestStatus& status)
+      : URLRequestJob(request, network_delegate),
+        status_(status),
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
+
+  virtual void Start() OVERRIDE {
+    // Start reading asynchronously so that all error reporting and data
+    // callbacks happen as they would for network requests.
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&MockURLRequestJob::StartAsync,
+                   weak_factory_.GetWeakPtr()));
+  }
+
+ protected:
+  virtual ~MockURLRequestJob() {}
+
+ private:
+  void StartAsync() {
+    SetStatus(status_);
+    NotifyHeadersComplete();
+  }
+
+  URLRequestStatus status_;
+  base::WeakPtrFactory<MockURLRequestJob> weak_factory_;
+};
+
+class DummyProtocolHandler : public URLRequestJobFactory::ProtocolHandler {
+ public:
+  virtual URLRequestJob* MaybeCreateJob(
+      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE {
+    return new MockURLRequestJob(
+        request,
+        network_delegate,
+        URLRequestStatus(URLRequestStatus::SUCCESS, OK));
+  }
+};
+
+class DummyInterceptor : public URLRequestJobFactory::Interceptor {
+ public:
+  DummyInterceptor()
+      : did_intercept_(false),
+        handle_all_protocols_(false) {
+  }
+
+  virtual URLRequestJob* MaybeIntercept(
+      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE {
+    did_intercept_ = true;
+    return new MockURLRequestJob(
+        request,
+        network_delegate,
+        URLRequestStatus(URLRequestStatus::FAILED, ERR_FAILED));
+  }
+
+  virtual URLRequestJob* MaybeInterceptRedirect(
+      const GURL&                       /* location */,
+      URLRequest*                       /* request */,
+      NetworkDelegate* network_delegate /* network delegate */) const OVERRIDE {
+    return NULL;
+  }
+
+  virtual URLRequestJob* MaybeInterceptResponse(
+      URLRequest*                       /* request */,
+      NetworkDelegate* network_delegate /* network delegate */) const OVERRIDE {
+    return NULL;
+  }
+
+  virtual bool WillHandleProtocol(
+      const std::string& /* protocol */) const OVERRIDE {
+    return handle_all_protocols_;
+  }
+
+  mutable bool did_intercept_;
+  mutable bool handle_all_protocols_;
+};
+
+TEST(URLRequestJobFactoryTest, NoProtocolHandler) {
+  TestDelegate delegate;
+  TestURLRequestContext request_context;
+  TestURLRequest request(GURL("foo://bar"), &delegate, &request_context);
+  request.Start();
+
+  MessageLoop::current()->Run();
+  EXPECT_EQ(URLRequestStatus::FAILED, request.status().status());
+  EXPECT_EQ(ERR_UNKNOWN_URL_SCHEME, request.status().error());
+}
+
+TEST(URLRequestJobFactoryTest, BasicProtocolHandler) {
+  TestDelegate delegate;
+  URLRequestJobFactoryImpl job_factory;
+  TestURLRequestContext request_context;
+  request_context.set_job_factory(&job_factory);
+  job_factory.SetProtocolHandler("foo", new DummyProtocolHandler);
+  TestURLRequest request(GURL("foo://bar"), &delegate, &request_context);
+  request.Start();
+
+  MessageLoop::current()->Run();
+  EXPECT_EQ(URLRequestStatus::SUCCESS, request.status().status());
+  EXPECT_EQ(OK, request.status().error());
+}
+
+TEST(URLRequestJobFactoryTest, DeleteProtocolHandler) {
+  URLRequestJobFactoryImpl job_factory;
+  TestURLRequestContext request_context;
+  request_context.set_job_factory(&job_factory);
+  job_factory.SetProtocolHandler("foo", new DummyProtocolHandler);
+  job_factory.SetProtocolHandler("foo", NULL);
+}
+
+TEST(URLRequestJobFactoryTest, BasicInterceptor) {
+  TestDelegate delegate;
+  URLRequestJobFactoryImpl job_factory;
+  TestURLRequestContext request_context;
+  request_context.set_job_factory(&job_factory);
+  job_factory.AddInterceptor(new DummyInterceptor);
+  TestURLRequest request(GURL("http://bar"), &delegate, &request_context);
+  request.Start();
+
+  MessageLoop::current()->Run();
+  EXPECT_EQ(URLRequestStatus::FAILED, request.status().status());
+  EXPECT_EQ(ERR_FAILED, request.status().error());
+}
+
+TEST(URLRequestJobFactoryTest, InterceptorNeedsValidSchemeStill) {
+  TestDelegate delegate;
+  URLRequestJobFactoryImpl job_factory;
+  TestURLRequestContext request_context;
+  request_context.set_job_factory(&job_factory);
+  job_factory.AddInterceptor(new DummyInterceptor);
+  TestURLRequest request(GURL("foo://bar"), &delegate, &request_context);
+  request.Start();
+
+  MessageLoop::current()->Run();
+  EXPECT_EQ(URLRequestStatus::FAILED, request.status().status());
+  EXPECT_EQ(ERR_UNKNOWN_URL_SCHEME, request.status().error());
+}
+
+TEST(URLRequestJobFactoryTest, InterceptorOverridesProtocolHandler) {
+  TestDelegate delegate;
+  URLRequestJobFactoryImpl job_factory;
+  TestURLRequestContext request_context;
+  request_context.set_job_factory(&job_factory);
+  job_factory.SetProtocolHandler("foo", new DummyProtocolHandler);
+  job_factory.AddInterceptor(new DummyInterceptor);
+  TestURLRequest request(GURL("foo://bar"), &delegate, &request_context);
+  request.Start();
+
+  MessageLoop::current()->Run();
+  EXPECT_EQ(URLRequestStatus::FAILED, request.status().status());
+  EXPECT_EQ(ERR_FAILED, request.status().error());
+}
+
+TEST(URLRequestJobFactoryTest, InterceptorDoesntInterceptUnknownProtocols) {
+  TestDelegate delegate;
+  URLRequestJobFactoryImpl job_factory;
+  TestURLRequestContext request_context;
+  request_context.set_job_factory(&job_factory);
+  DummyInterceptor* interceptor = new DummyInterceptor;
+  job_factory.AddInterceptor(interceptor);
+  TestURLRequest request(GURL("foo://bar"), &delegate, &request_context);
+  request.Start();
+
+  MessageLoop::current()->Run();
+  EXPECT_FALSE(interceptor->did_intercept_);
+}
+
+TEST(URLRequestJobFactoryTest, InterceptorInterceptsHandledUnknownProtocols) {
+  TestDelegate delegate;
+  URLRequestJobFactoryImpl job_factory;
+  TestURLRequestContext request_context;
+  request_context.set_job_factory(&job_factory);
+  DummyInterceptor* interceptor = new DummyInterceptor;
+  interceptor->handle_all_protocols_ = true;
+  job_factory.AddInterceptor(interceptor);
+  TestURLRequest request(GURL("foo://bar"), &delegate, &request_context);
+  request.Start();
+
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(interceptor->did_intercept_);
+  EXPECT_EQ(URLRequestStatus::FAILED, request.status().status());
+  EXPECT_EQ(ERR_FAILED, request.status().error());
+}
+
+TEST(URLRequestJobFactoryTest, InterceptorAffectsIsHandledProtocol) {
+  DummyInterceptor* interceptor = new DummyInterceptor;
+  URLRequestJobFactoryImpl job_factory;
+  job_factory.AddInterceptor(interceptor);
+  EXPECT_FALSE(interceptor->WillHandleProtocol("anything"));
+  EXPECT_FALSE(job_factory.IsHandledProtocol("anything"));
+  interceptor->handle_all_protocols_ = true;
+  EXPECT_TRUE(interceptor->WillHandleProtocol("anything"));
+  EXPECT_TRUE(job_factory.IsHandledProtocol("anything"));
+}
+
+}  // namespace
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_job_manager.cc b/src/net/url_request/url_request_job_manager.cc
new file mode 100644
index 0000000..a03e77c
--- /dev/null
+++ b/src/net/url_request/url_request_job_manager.cc
@@ -0,0 +1,290 @@
+// 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 "net/url_request/url_request_job_manager.h"
+
+#include <algorithm>
+
+#include "base/memory/singleton.h"
+#include "build/build_config.h"
+#include "base/string_util.h"
+#include "net/base/load_flags.h"
+#include "net/base/net_errors.h"
+#include "net/base/network_delegate.h"
+#include "net/url_request/url_request_about_job.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_data_job.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_file_job.h"
+#include "net/url_request/url_request_ftp_job.h"
+#include "net/url_request/url_request_http_job.h"
+#include "net/url_request/url_request_job_factory.h"
+
+namespace net {
+
+// The built-in set of protocol factories
+namespace {
+
+struct SchemeToFactory {
+  const char* scheme;
+  URLRequest::ProtocolFactory* factory;
+};
+
+}  // namespace
+
+#if defined(COBALT)
+static const SchemeToFactory kBuiltinFactories[] = {
+  {"https", URLRequestHttpJob::Factory},
+  {"data", URLRequestDataJob::Factory},
+#if !defined(COBALT_FORCE_HTTPS)
+  { "http", URLRequestHttpJob::Factory },
+#endif
+#if defined(COBALT_ENABLE_FILE_SCHEME)
+  { "file", URLRequestFileJob::Factory },
+#endif
+};
+#else
+static const SchemeToFactory kBuiltinFactories[] = {
+  { "http", URLRequestHttpJob::Factory },
+  { "https", URLRequestHttpJob::Factory },
+#if !defined(DISABLE_FTP_SUPPORT)
+  { "ftp", URLRequestFtpJob::Factory },
+#endif
+  { "file", URLRequestFileJob::Factory },
+  { "about", URLRequestAboutJob::Factory },
+  { "data", URLRequestDataJob::Factory },
+};
+#endif  // defined(COBALT)
+
+// static
+URLRequestJobManager* URLRequestJobManager::GetInstance() {
+  return Singleton<URLRequestJobManager>::get();
+}
+
+URLRequestJob* URLRequestJobManager::CreateJob(
+    URLRequest* request, NetworkDelegate* network_delegate) const {
+  DCHECK(IsAllowedThread());
+
+  // If we are given an invalid URL, then don't even try to inspect the scheme.
+  if (!request->url().is_valid())
+    return new URLRequestErrorJob(request, network_delegate, ERR_INVALID_URL);
+
+  // We do this here to avoid asking interceptors about unsupported schemes.
+  const URLRequestJobFactory* job_factory = NULL;
+  job_factory = request->context()->job_factory();
+
+  const std::string& scheme = request->url().scheme();  // already lowercase
+  if (job_factory) {
+    if (!job_factory->IsHandledProtocol(scheme)) {
+      return new URLRequestErrorJob(
+          request, network_delegate, ERR_UNKNOWN_URL_SCHEME);
+    }
+  } else if (!SupportsScheme(scheme)) {
+    return new URLRequestErrorJob(
+        request, network_delegate, ERR_UNKNOWN_URL_SCHEME);
+  }
+
+  // THREAD-SAFETY NOTICE:
+  //   We do not need to acquire the lock here since we are only reading our
+  //   data structures.  They should only be modified on the current thread.
+
+  // See if the request should be intercepted.
+  //
+
+  if (job_factory) {
+    URLRequestJob* job = job_factory->MaybeCreateJobWithInterceptor(
+        request, network_delegate);
+    if (job)
+      return job;
+  }
+
+  // TODO(willchan): Remove this in favor of URLRequestJobFactory::Interceptor.
+  if (!(request->load_flags() & LOAD_DISABLE_INTERCEPT)) {
+    InterceptorList::const_iterator i;
+    for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
+      URLRequestJob* job = (*i)->MaybeIntercept(request, network_delegate);
+      if (job)
+        return job;
+    }
+  }
+
+  if (job_factory) {
+    URLRequestJob* job = job_factory->MaybeCreateJobWithProtocolHandler(
+        scheme, request, network_delegate);
+    if (job)
+      return job;
+  }
+
+  // TODO(willchan): Remove this in favor of
+  // URLRequestJobFactory::ProtocolHandler.
+  // See if the request should be handled by a registered protocol factory.
+  // If the registered factory returns null, then we want to fall-back to the
+  // built-in protocol factory.
+  FactoryMap::const_iterator i = factories_.find(scheme);
+  if (i != factories_.end()) {
+    URLRequestJob* job = i->second(request, network_delegate, scheme);
+    if (job)
+      return job;
+  }
+
+  // See if the request should be handled by a built-in protocol factory.
+  for (size_t i = 0; i < arraysize(kBuiltinFactories); ++i) {
+    if (scheme == kBuiltinFactories[i].scheme) {
+      URLRequestJob* job = (kBuiltinFactories[i].factory)(
+          request, network_delegate, scheme);
+      DCHECK(job);  // The built-in factories are not expected to fail!
+      return job;
+    }
+  }
+
+  // If we reached here, then it means that a registered protocol factory
+  // wasn't interested in handling the URL.  That is fairly unexpected, and we
+  // don't have a specific error to report here :-(
+  LOG(WARNING) << "Failed to map: " << request->url().spec();
+  return new URLRequestErrorJob(request, network_delegate, ERR_FAILED);
+}
+
+URLRequestJob* URLRequestJobManager::MaybeInterceptRedirect(
+    URLRequest* request,
+    NetworkDelegate* network_delegate,
+    const GURL& location) const {
+  DCHECK(IsAllowedThread());
+  if (!request->url().is_valid() ||
+      request->load_flags() & LOAD_DISABLE_INTERCEPT ||
+      request->status().status() == URLRequestStatus::CANCELED) {
+    return NULL;
+  }
+
+  const URLRequestJobFactory* job_factory = NULL;
+  job_factory = request->context()->job_factory();
+
+  const std::string& scheme = request->url().scheme();  // already lowercase
+  if (job_factory) {
+    if (!job_factory->IsHandledProtocol(scheme)) {
+      return NULL;
+    }
+  } else if (!SupportsScheme(scheme)) {
+    return NULL;
+  }
+
+  URLRequestJob* job = NULL;
+  if (job_factory)
+    job = job_factory->MaybeInterceptRedirect(
+        location, request, network_delegate);
+  if (job)
+    return job;
+
+  InterceptorList::const_iterator i;
+  for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
+    job = (*i)->MaybeInterceptRedirect(request, network_delegate, location);
+    if (job)
+      return job;
+  }
+  return NULL;
+}
+
+URLRequestJob* URLRequestJobManager::MaybeInterceptResponse(
+    URLRequest* request, NetworkDelegate* network_delegate) const {
+  DCHECK(IsAllowedThread());
+  if (!request->url().is_valid() ||
+      request->load_flags() & LOAD_DISABLE_INTERCEPT ||
+      request->status().status() == URLRequestStatus::CANCELED) {
+    return NULL;
+  }
+
+  const URLRequestJobFactory* job_factory = NULL;
+  job_factory = request->context()->job_factory();
+
+  const std::string& scheme = request->url().scheme();  // already lowercase
+  if (job_factory) {
+    if (!job_factory->IsHandledProtocol(scheme)) {
+      return NULL;
+    }
+  } else if (!SupportsScheme(scheme)) {
+    return NULL;
+  }
+
+  URLRequestJob* job = NULL;
+  if (job_factory)
+    job = job_factory->MaybeInterceptResponse(request, network_delegate);
+  if (job)
+    return job;
+
+  InterceptorList::const_iterator i;
+  for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
+    job = (*i)->MaybeInterceptResponse(request, network_delegate);
+    if (job)
+      return job;
+  }
+  return NULL;
+}
+
+bool URLRequestJobManager::SupportsScheme(const std::string& scheme) const {
+  // The set of registered factories may change on another thread.
+  {
+    base::AutoLock locked(lock_);
+    if (factories_.find(scheme) != factories_.end())
+      return true;
+  }
+
+  for (size_t i = 0; i < arraysize(kBuiltinFactories); ++i)
+    if (LowerCaseEqualsASCII(scheme, kBuiltinFactories[i].scheme))
+      return true;
+
+  return false;
+}
+
+URLRequest::ProtocolFactory* URLRequestJobManager::RegisterProtocolFactory(
+    const std::string& scheme,
+    URLRequest::ProtocolFactory* factory) {
+  DCHECK(IsAllowedThread());
+
+  base::AutoLock locked(lock_);
+
+  URLRequest::ProtocolFactory* old_factory;
+  FactoryMap::iterator i = factories_.find(scheme);
+  if (i != factories_.end()) {
+    old_factory = i->second;
+  } else {
+    old_factory = NULL;
+  }
+  if (factory) {
+    factories_[scheme] = factory;
+  } else if (i != factories_.end()) {  // uninstall any old one
+    factories_.erase(i);
+  }
+  return old_factory;
+}
+
+void URLRequestJobManager::RegisterRequestInterceptor(
+    URLRequest::Interceptor* interceptor) {
+  DCHECK(IsAllowedThread());
+
+  base::AutoLock locked(lock_);
+
+  DCHECK(std::find(interceptors_.begin(), interceptors_.end(), interceptor) ==
+         interceptors_.end());
+  interceptors_.push_back(interceptor);
+}
+
+void URLRequestJobManager::UnregisterRequestInterceptor(
+    URLRequest::Interceptor* interceptor) {
+  DCHECK(IsAllowedThread());
+
+  base::AutoLock locked(lock_);
+
+  InterceptorList::iterator i =
+      std::find(interceptors_.begin(), interceptors_.end(), interceptor);
+  DCHECK(i != interceptors_.end());
+  interceptors_.erase(i);
+}
+
+URLRequestJobManager::URLRequestJobManager()
+    : allowed_thread_(0),
+      allowed_thread_initialized_(false) {
+}
+
+URLRequestJobManager::~URLRequestJobManager() {}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_job_manager.h b/src/net/url_request/url_request_job_manager.h
new file mode 100644
index 0000000..ea441be
--- /dev/null
+++ b/src/net/url_request/url_request_job_manager.h
@@ -0,0 +1,116 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_JOB_MANAGER_H_
+#define NET_URL_REQUEST_URL_REQUEST_JOB_MANAGER_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/synchronization/lock.h"
+#include "base/threading/platform_thread.h"
+#include "net/url_request/url_request.h"
+
+template <typename T> struct DefaultSingletonTraits;
+
+namespace net {
+
+// This class is responsible for managing the set of protocol factories and
+// request interceptors that determine how an URLRequestJob gets created to
+// handle an URLRequest.
+//
+// MULTI-THREADING NOTICE:
+//   URLRequest is designed to have all consumers on a single thread, and
+//   so no attempt is made to support ProtocolFactory or Interceptor instances
+//   being registered/unregistered or in any way poked on multiple threads.
+//   However, we do support checking for supported schemes FROM ANY THREAD
+//   (i.e., it is safe to call SupportsScheme on any thread).
+//
+class URLRequestJobManager {
+ public:
+  // Returns the singleton instance.
+  static URLRequestJobManager* GetInstance();
+
+  // Instantiate an URLRequestJob implementation based on the registered
+  // interceptors and protocol factories.  This will always succeed in
+  // returning a job unless we are--in the extreme case--out of memory.
+  URLRequestJob* CreateJob(URLRequest* request,
+                           NetworkDelegate* network_delegate) const;
+
+  // Allows interceptors to hijack the request after examining the new location
+  // of a redirect. Returns NULL if no interceptor intervenes.
+  URLRequestJob* MaybeInterceptRedirect(URLRequest* request,
+                                        NetworkDelegate* network_delegate,
+                                        const GURL& location) const;
+
+  // Allows interceptors to hijack the request after examining the response
+  // status and headers. This is also called when there is no server response
+  // at all to allow interception of failed requests due to network errors.
+  // Returns NULL if no interceptor intervenes.
+  URLRequestJob* MaybeInterceptResponse(
+      URLRequest* request, NetworkDelegate* network_delegate) const;
+
+  // Returns true if there is a protocol factory registered for the given
+  // scheme.  Note: also returns true if there is a built-in handler for the
+  // given scheme.
+  bool SupportsScheme(const std::string& scheme) const;
+
+  // Register a protocol factory associated with the given scheme.  The factory
+  // parameter may be null to clear any existing association.  Returns the
+  // previously registered protocol factory if any.
+  URLRequest::ProtocolFactory* RegisterProtocolFactory(
+      const std::string& scheme, URLRequest::ProtocolFactory* factory);
+
+  // Register/unregister a request interceptor.
+  void RegisterRequestInterceptor(URLRequest::Interceptor* interceptor);
+  void UnregisterRequestInterceptor(URLRequest::Interceptor* interceptor);
+
+ private:
+  typedef std::map<std::string, URLRequest::ProtocolFactory*> FactoryMap;
+  typedef std::vector<URLRequest::Interceptor*> InterceptorList;
+  friend struct DefaultSingletonTraits<URLRequestJobManager>;
+
+  URLRequestJobManager();
+  ~URLRequestJobManager();
+
+  // The first guy to call this function sets the allowed thread.  This way we
+  // avoid needing to define that thread externally.  Since we expect all
+  // callers to be on the same thread, we don't worry about threads racing to
+  // set the allowed thread.
+  bool IsAllowedThread() const {
+#if 0
+    if (!allowed_thread_initialized_) {
+      allowed_thread_ = base::PlatformThread::CurrentId();
+      allowed_thread_initialized_ = true;
+    }
+    return allowed_thread_ == base::PlatformThread::CurrentId();
+#else
+    // The previous version of this check used GetCurrentThread on Windows to
+    // get thread handles to compare. Unfortunately, GetCurrentThread returns
+    // a constant pseudo-handle (0xFFFFFFFE), and therefore IsAllowedThread
+    // always returned true. The above code that's turned off is the correct
+    // code, but causes the tree to turn red because some caller isn't
+    // respecting our thread requirements. We're turning off the check for now;
+    // bug http://b/issue?id=1338969 has been filed to fix things and turn the
+    // check back on.
+    return true;
+  }
+
+  // We use this to assert that CreateJob and the registration functions all
+  // run on the same thread.
+  mutable base::PlatformThreadId allowed_thread_;
+  mutable bool allowed_thread_initialized_;
+#endif
+
+  mutable base::Lock lock_;
+  FactoryMap factories_;
+  InterceptorList interceptors_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestJobManager);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_JOB_MANAGER_H_
diff --git a/src/net/url_request/url_request_job_unittest.cc b/src/net/url_request/url_request_job_unittest.cc
new file mode 100644
index 0000000..19c2395
--- /dev/null
+++ b/src/net/url_request/url_request_job_unittest.cc
@@ -0,0 +1,79 @@
+// 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 "net/url_request/url_request_job.h"
+
+#include "net/http/http_transaction_unittest.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// This is a header that signals the end of the data.
+const char kGzipGata[] = "\x1f\x08b\x08\0\0\0\0\0\0\3\3\0\0\0\0\0\0\0\0";
+
+void GZipServer(const net::HttpRequestInfo* request,
+                std::string* response_status, std::string* response_headers,
+                std::string* response_data) {
+  response_data->assign(kGzipGata, sizeof(kGzipGata));
+}
+
+const MockTransaction kGZip_Transaction = {
+  "http://www.google.com/gzyp",
+  "GET",
+  base::Time(),
+  "",
+  net::LOAD_NORMAL,
+  "HTTP/1.1 200 OK",
+  "Cache-Control: max-age=10000\n"
+  "Content-Encoding: gzip\n"
+  "Content-Length: 30\n",  // Intentionally wrong.
+  base::Time(),
+  "",
+  TEST_MODE_NORMAL,
+  &GZipServer,
+  0
+};
+
+}  // namespace
+
+TEST(URLRequestJob, TransactionNotifiedWhenDone) {
+  MockNetworkLayer network_layer;
+  net::TestURLRequestContext context;
+  context.set_http_transaction_factory(&network_layer);
+
+  net::TestDelegate d;
+  net::TestURLRequest req(GURL(kGZip_Transaction.url), &d, &context);
+  AddMockTransaction(&kGZip_Transaction);
+
+  req.set_method("GET");
+  req.Start();
+
+  MessageLoop::current()->Run();
+
+  EXPECT_TRUE(network_layer.done_reading_called());
+
+  RemoveMockTransaction(&kGZip_Transaction);
+}
+
+TEST(URLRequestJob, SyncTransactionNotifiedWhenDone) {
+  MockNetworkLayer network_layer;
+  net::TestURLRequestContext context;
+  context.set_http_transaction_factory(&network_layer);
+
+  net::TestDelegate d;
+  net::TestURLRequest req(GURL(kGZip_Transaction.url), &d, &context);
+  MockTransaction transaction(kGZip_Transaction);
+  transaction.test_mode = TEST_MODE_SYNC_ALL;
+  AddMockTransaction(&transaction);
+
+  req.set_method("GET");
+  req.Start();
+
+  MessageLoop::current()->Run();
+
+  EXPECT_TRUE(network_layer.done_reading_called());
+
+  RemoveMockTransaction(&transaction);
+}
diff --git a/src/net/url_request/url_request_netlog_params.cc b/src/net/url_request/url_request_netlog_params.cc
new file mode 100644
index 0000000..dbc5357
--- /dev/null
+++ b/src/net/url_request/url_request_netlog_params.cc
@@ -0,0 +1,40 @@
+// 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 "net/url_request/url_request_netlog_params.h"
+
+#include "base/string_number_conversions.h"
+#include "base/values.h"
+#include "googleurl/src/gurl.h"
+
+namespace net {
+
+Value* NetLogURLRequestStartCallback(const GURL* url,
+                                     const std::string* method,
+                                     int load_flags,
+                                     RequestPriority priority,
+                                     int64 upload_id,
+                                     NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("url", url->possibly_invalid_spec());
+  dict->SetString("method", *method);
+  dict->SetInteger("load_flags", load_flags);
+  dict->SetInteger("priority", static_cast<int>(priority));
+  if (upload_id > -1)
+    dict->SetString("upload_id", base::Int64ToString(upload_id));
+  return dict;
+}
+
+bool StartEventLoadFlagsFromEventParams(const Value* event_params,
+                                        int* load_flags) {
+  const DictionaryValue* dict;
+  if (!event_params->GetAsDictionary(&dict) ||
+      !dict->GetInteger("load_flags", load_flags)) {
+    *load_flags = 0;
+    return false;
+  }
+  return true;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_netlog_params.h b/src/net/url_request/url_request_netlog_params.h
new file mode 100644
index 0000000..f2e0dce
--- /dev/null
+++ b/src/net/url_request/url_request_netlog_params.h
@@ -0,0 +1,40 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_NETLOG_PARAMS_H_
+#define NET_URL_REQUEST_URL_REQUEST_NETLOG_PARAMS_H_
+
+#include <string>
+
+#include "net/base/net_export.h"
+#include "net/base/net_log.h"
+#include "net/base/request_priority.h"
+
+class GURL;
+
+namespace base {
+class Value;
+}
+
+namespace net {
+
+// Returns a Value containing NetLog parameters for starting a URLRequest.
+NET_EXPORT base::Value* NetLogURLRequestStartCallback(
+    const GURL* url,
+    const std::string* method,
+    int load_flags,
+    RequestPriority priority,
+    int64 upload_id,
+    NetLog::LogLevel /* log_level */);
+
+// Attempts to extract the load flags from a Value created by the above
+// function.  On success, sets |load_flags| accordingly and returns true.
+// On failure, sets |load_flags| to 0.
+NET_EXPORT bool StartEventLoadFlagsFromEventParams(
+    const base::Value* event_params,
+    int* load_flags);
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_NETLOG_PARAMS_H_
diff --git a/src/net/url_request/url_request_redirect_job.cc b/src/net/url_request/url_request_redirect_job.cc
new file mode 100644
index 0000000..e05377f
--- /dev/null
+++ b/src/net/url_request/url_request_redirect_job.cc
@@ -0,0 +1,42 @@
+// 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 "net/url_request/url_request_redirect_job.h"
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+
+namespace net {
+
+URLRequestRedirectJob::URLRequestRedirectJob(URLRequest* request,
+                                             NetworkDelegate* network_delegate,
+                                             const GURL& redirect_destination,
+                                             StatusCode http_status_code)
+    : URLRequestJob(request, network_delegate),
+      redirect_destination_(redirect_destination),
+      http_status_code_(http_status_code),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
+
+void URLRequestRedirectJob::Start() {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestRedirectJob::StartAsync,
+                 weak_factory_.GetWeakPtr()));
+}
+
+bool URLRequestRedirectJob::IsRedirectResponse(GURL* location,
+                                               int* http_status_code) {
+  *location = redirect_destination_;
+  *http_status_code = http_status_code_;
+  return true;
+}
+
+URLRequestRedirectJob::~URLRequestRedirectJob() {}
+
+void URLRequestRedirectJob::StartAsync() {
+  NotifyHeadersComplete();
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_redirect_job.h b/src/net/url_request/url_request_redirect_job.h
new file mode 100644
index 0000000..198ee76
--- /dev/null
+++ b/src/net/url_request/url_request_redirect_job.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_REDIRECT_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_REDIRECT_JOB_H_
+
+#include "base/memory/weak_ptr.h"
+#include "net/base/net_export.h"
+#include "net/url_request/url_request_job.h"
+
+class GURL;
+
+namespace net {
+
+// A URLRequestJob that will redirect the request to the specified
+// URL.  This is useful to restart a request at a different URL based
+// on the result of another job.
+class NET_EXPORT URLRequestRedirectJob : public URLRequestJob {
+ public:
+  // Valid status codes for the redirect job. Other 30x codes are theoretically
+  // valid, but unused so far.  Both 302 and 307 are temporary redirects, with
+  // the difference being that 302 converts POSTs to GETs and removes upload
+  // data.
+  enum StatusCode {
+    REDIRECT_302_FOUND = 302,
+    REDIRECT_307_TEMPORARY_REDIRECT = 307,
+  };
+
+  // Constructs a job that redirects to the specified URL.
+  URLRequestRedirectJob(URLRequest* request,
+                        NetworkDelegate* network_delegate,
+                        const GURL& redirect_destination,
+                        StatusCode http_status_code);
+
+  virtual void Start() OVERRIDE;
+  virtual bool IsRedirectResponse(GURL* location,
+                                  int* http_status_code) OVERRIDE;
+
+ private:
+  virtual ~URLRequestRedirectJob();
+
+  void StartAsync();
+
+  const GURL redirect_destination_;
+  const int http_status_code_;
+
+  base::WeakPtrFactory<URLRequestRedirectJob> weak_factory_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_REDIRECT_JOB_H_
diff --git a/src/net/url_request/url_request_simple_job.cc b/src/net/url_request/url_request_simple_job.cc
new file mode 100644
index 0000000..fda1012
--- /dev/null
+++ b/src/net/url_request/url_request_simple_job.cc
@@ -0,0 +1,75 @@
+// 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 "net/url_request/url_request_simple_job.h"
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/message_loop.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/url_request_status.h"
+
+namespace net {
+
+URLRequestSimpleJob::URLRequestSimpleJob(
+    URLRequest* request, NetworkDelegate* network_delegate)
+    : URLRequestJob(request, network_delegate),
+      data_offset_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
+
+void URLRequestSimpleJob::Start() {
+  // Start reading asynchronously so that all error reporting and data
+  // callbacks happen as they would for network requests.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestSimpleJob::StartAsync,
+                 weak_factory_.GetWeakPtr()));
+}
+
+bool URLRequestSimpleJob::GetMimeType(std::string* mime_type) const {
+  *mime_type = mime_type_;
+  return true;
+}
+
+bool URLRequestSimpleJob::GetCharset(std::string* charset) {
+  *charset = charset_;
+  return true;
+}
+
+URLRequestSimpleJob::~URLRequestSimpleJob() {}
+
+bool URLRequestSimpleJob::ReadRawData(IOBuffer* buf, int buf_size,
+                                      int* bytes_read) {
+  DCHECK(bytes_read);
+  int remaining = static_cast<int>(data_.size()) - data_offset_;
+  if (buf_size > remaining)
+    buf_size = remaining;
+  memcpy(buf->data(), data_.data() + data_offset_, buf_size);
+  data_offset_ += buf_size;
+  *bytes_read = buf_size;
+  return true;
+}
+
+void URLRequestSimpleJob::StartAsync() {
+  if (!request_)
+    return;
+
+  int result = GetData(&mime_type_, &charset_, &data_,
+                       base::Bind(&URLRequestSimpleJob::OnGetDataCompleted,
+                                  weak_factory_.GetWeakPtr()));
+  if (result != ERR_IO_PENDING)
+    OnGetDataCompleted(result);
+}
+
+void URLRequestSimpleJob::OnGetDataCompleted(int result) {
+  if (result == OK) {
+    // Notify that the headers are complete
+    NotifyHeadersComplete();
+  } else {
+    NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
+  }
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_simple_job.h b/src/net/url_request/url_request_simple_job.h
new file mode 100644
index 0000000..7577151
--- /dev/null
+++ b/src/net/url_request/url_request_simple_job.h
@@ -0,0 +1,63 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_SIMPLE_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_SIMPLE_JOB_H_
+
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_export.h"
+#include "net/url_request/url_request_job.h"
+
+namespace net {
+
+class URLRequest;
+
+class NET_EXPORT URLRequestSimpleJob : public URLRequestJob {
+ public:
+  URLRequestSimpleJob(URLRequest* request, NetworkDelegate* network_delegate);
+
+  virtual void Start() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual bool GetCharset(std::string* charset) OVERRIDE;
+
+ protected:
+  virtual ~URLRequestSimpleJob();
+
+  // Subclasses must override the way response data is determined.
+  // The return value should be:
+  //  - OK if data is obtained;
+  //  - ERR_IO_PENDING if async processing is needed to finish obtaining data.
+  //    This is the only case when |callback| should be called after
+  //    completion of the operation. In other situations |callback| should
+  //    never be called;
+  //  - any other ERR_* code to indicate an error. This code will be used
+  //    as the error code in the URLRequestStatus when the URLRequest
+  //    is finished.
+  virtual int GetData(std::string* mime_type,
+                      std::string* charset,
+                      std::string* data,
+                      const CompletionCallback& callback) const = 0;
+
+ protected:
+  void StartAsync();
+
+ private:
+  void OnGetDataCompleted(int result);
+
+  std::string mime_type_;
+  std::string charset_;
+  std::string data_;
+  int data_offset_;
+  base::WeakPtrFactory<URLRequestSimpleJob> weak_factory_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_SIMPLE_JOB_H_
diff --git a/src/net/url_request/url_request_status.h b/src/net/url_request/url_request_status.h
new file mode 100644
index 0000000..521a3d4
--- /dev/null
+++ b/src/net/url_request/url_request_status.h
@@ -0,0 +1,62 @@
+// Copyright (c) 2011 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.
+//
+// This file's dependencies should be kept to a minimum so that it can be
+// included in WebKit code that doesn't rely on much of common.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_STATUS_H_
+#define NET_URL_REQUEST_URL_REQUEST_STATUS_H_
+
+namespace net {
+
+// Represents the result of a URL request. It encodes errors and various
+// types of success.
+class URLRequestStatus {
+ public:
+  enum Status {
+    // Request succeeded, |error_| will be 0.
+    SUCCESS = 0,
+
+    // An IO request is pending, and the caller will be informed when it is
+    // completed.
+    IO_PENDING,
+
+    // Request was cancelled programatically.
+    CANCELED,
+
+    // The request failed for some reason. |error_| may have more information.
+    FAILED,
+  };
+
+  URLRequestStatus() : status_(SUCCESS), error_(0) {}
+  URLRequestStatus(Status s, int e) : status_(s), error_(e) {}
+
+  Status status() const { return status_; }
+  void set_status(Status s) { status_ = s; }
+
+  int error() const { return error_; }
+  void set_error(int e) { error_ = e; }
+
+  // Returns true if the status is success, which makes some calling code more
+  // convenient because this is the most common test.
+  bool is_success() const {
+    return status_ == SUCCESS || status_ == IO_PENDING;
+  }
+
+  // Returns true if the request is waiting for IO.
+  bool is_io_pending() const {
+    return status_ == IO_PENDING;
+  }
+
+ private:
+  // Application level status.
+  Status status_;
+
+  // Error code from the network layer if an error was encountered.
+  int error_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_STATUS_H_
diff --git a/src/net/url_request/url_request_test_job.cc b/src/net/url_request/url_request_test_job.cc
new file mode 100644
index 0000000..05b562b
--- /dev/null
+++ b/src/net/url_request/url_request_test_job.cc
@@ -0,0 +1,303 @@
+// 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 "net/url_request/url_request_test_job.h"
+
+#include <algorithm>
+#include <list>
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/lazy_instance.h"
+#include "base/message_loop.h"
+#include "base/string_util.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_response_headers.h"
+
+namespace net {
+
+namespace {
+
+typedef std::list<URLRequestTestJob*> URLRequestJobList;
+base::LazyInstance<URLRequestJobList>::Leaky
+    g_pending_jobs = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+// static getters for known URLs
+GURL URLRequestTestJob::test_url_1() {
+  return GURL("test:url1");
+}
+GURL URLRequestTestJob::test_url_2() {
+  return GURL("test:url2");
+}
+GURL URLRequestTestJob::test_url_3() {
+  return GURL("test:url3");
+}
+GURL URLRequestTestJob::test_url_error() {
+  return GURL("test:error");
+}
+
+// static getters for known URL responses
+std::string URLRequestTestJob::test_data_1() {
+  return std::string("<html><title>Test One</title></html>");
+}
+std::string URLRequestTestJob::test_data_2() {
+  return std::string("<html><title>Test Two Two</title></html>");
+}
+std::string URLRequestTestJob::test_data_3() {
+  return std::string("<html><title>Test Three Three Three</title></html>");
+}
+
+// static getter for simple response headers
+std::string URLRequestTestJob::test_headers() {
+  static const char kHeaders[] =
+      "HTTP/1.1 200 OK\0"
+      "Content-type: text/html\0"
+      "\0";
+  return std::string(kHeaders, arraysize(kHeaders));
+}
+
+// static getter for redirect response headers
+std::string URLRequestTestJob::test_redirect_headers() {
+  static const char kHeaders[] =
+      "HTTP/1.1 302 MOVED\0"
+      "Location: somewhere\0"
+      "\0";
+  return std::string(kHeaders, arraysize(kHeaders));
+}
+
+// static getter for error response headers
+std::string URLRequestTestJob::test_error_headers() {
+  static const char kHeaders[] =
+      "HTTP/1.1 500 BOO HOO\0"
+      "\0";
+  return std::string(kHeaders, arraysize(kHeaders));
+}
+
+// static
+URLRequestJob* URLRequestTestJob::Factory(URLRequest* request,
+                                          NetworkDelegate* network_delegate,
+                                          const std::string& scheme) {
+  return new URLRequestTestJob(request, network_delegate);
+}
+
+URLRequestTestJob::URLRequestTestJob(URLRequest* request,
+                                     NetworkDelegate* network_delegate)
+    : URLRequestJob(request, network_delegate),
+      auto_advance_(false),
+      stage_(WAITING),
+      offset_(0),
+      async_buf_(NULL),
+      async_buf_size_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+}
+
+URLRequestTestJob::URLRequestTestJob(URLRequest* request,
+                                     NetworkDelegate* network_delegate,
+                                     bool auto_advance)
+    : URLRequestJob(request, network_delegate),
+      auto_advance_(auto_advance),
+      stage_(WAITING),
+      offset_(0),
+      async_buf_(NULL),
+      async_buf_size_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+}
+
+URLRequestTestJob::URLRequestTestJob(URLRequest* request,
+                                     NetworkDelegate* network_delegate,
+                                     const std::string& response_headers,
+                                     const std::string& response_data,
+                                     bool auto_advance)
+    : URLRequestJob(request, network_delegate),
+      auto_advance_(auto_advance),
+      stage_(WAITING),
+      response_headers_(new HttpResponseHeaders(response_headers)),
+      response_data_(response_data),
+      offset_(0),
+      async_buf_(NULL),
+      async_buf_size_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+}
+
+URLRequestTestJob::~URLRequestTestJob() {
+  g_pending_jobs.Get().erase(
+      std::remove(
+          g_pending_jobs.Get().begin(), g_pending_jobs.Get().end(), this),
+      g_pending_jobs.Get().end());
+}
+
+bool URLRequestTestJob::GetMimeType(std::string* mime_type) const {
+  DCHECK(mime_type);
+  if (!response_headers_)
+    return false;
+  return response_headers_->GetMimeType(mime_type);
+}
+
+void URLRequestTestJob::Start() {
+  // Start reading asynchronously so that all error reporting and data
+  // callbacks happen as they would for network requests.
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&URLRequestTestJob::StartAsync,
+                            weak_factory_.GetWeakPtr()));
+}
+
+void URLRequestTestJob::StartAsync() {
+  if (!response_headers_) {
+    response_headers_ = new HttpResponseHeaders(test_headers());
+    if (request_->url().spec() == test_url_1().spec()) {
+      response_data_ = test_data_1();
+      stage_ = DATA_AVAILABLE;  // Simulate a synchronous response for this one.
+    } else if (request_->url().spec() == test_url_2().spec()) {
+      response_data_ = test_data_2();
+    } else if (request_->url().spec() == test_url_3().spec()) {
+      response_data_ = test_data_3();
+    } else {
+      AdvanceJob();
+
+      // unexpected url, return error
+      // FIXME(brettw) we may want to use WININET errors or have some more types
+      // of errors
+      NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+                                  ERR_INVALID_URL));
+      // FIXME(brettw): this should emulate a network error, and not just fail
+      // initiating a connection
+      return;
+    }
+  }
+
+  AdvanceJob();
+
+  this->NotifyHeadersComplete();
+}
+
+bool URLRequestTestJob::ReadRawData(IOBuffer* buf, int buf_size,
+                                    int *bytes_read) {
+  if (stage_ == WAITING) {
+    async_buf_ = buf;
+    async_buf_size_ = buf_size;
+    SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+    return false;
+  }
+
+  DCHECK(bytes_read);
+  *bytes_read = 0;
+
+  if (offset_ >= static_cast<int>(response_data_.length())) {
+    return true;  // done reading
+  }
+
+  int to_read = buf_size;
+  if (to_read + offset_ > static_cast<int>(response_data_.length()))
+    to_read = static_cast<int>(response_data_.length()) - offset_;
+
+  memcpy(buf->data(), &response_data_.c_str()[offset_], to_read);
+  offset_ += to_read;
+
+  *bytes_read = to_read;
+  return true;
+}
+
+void URLRequestTestJob::GetResponseInfo(HttpResponseInfo* info) {
+  if (response_headers_)
+    info->headers = response_headers_;
+}
+
+int URLRequestTestJob::GetResponseCode() const {
+  if (response_headers_)
+    return response_headers_->response_code();
+  return -1;
+}
+
+bool URLRequestTestJob::IsRedirectResponse(GURL* location,
+                                           int* http_status_code) {
+  if (!response_headers_)
+    return false;
+
+  std::string value;
+  if (!response_headers_->IsRedirect(&value))
+    return false;
+
+  *location = request_->url().Resolve(value);
+  *http_status_code = response_headers_->response_code();
+  return true;
+}
+
+
+void URLRequestTestJob::Kill() {
+  stage_ = DONE;
+  URLRequestJob::Kill();
+  weak_factory_.InvalidateWeakPtrs();
+  g_pending_jobs.Get().erase(
+      std::remove(
+          g_pending_jobs.Get().begin(), g_pending_jobs.Get().end(), this),
+      g_pending_jobs.Get().end());
+}
+
+void URLRequestTestJob::ProcessNextOperation() {
+  switch (stage_) {
+    case WAITING:
+      // Must call AdvanceJob() prior to NotifyReadComplete() since that may
+      // delete |this|.
+      AdvanceJob();
+      stage_ = DATA_AVAILABLE;
+      // OK if ReadRawData wasn't called yet.
+      if (async_buf_) {
+        int bytes_read;
+        if (!ReadRawData(async_buf_, async_buf_size_, &bytes_read))
+          NOTREACHED() << "This should not return false in DATA_AVAILABLE.";
+        SetStatus(URLRequestStatus());  // clear the io pending flag
+        if (NextReadAsync()) {
+          // Make all future reads return io pending until the next
+          // ProcessNextOperation().
+          stage_ = WAITING;
+        }
+        NotifyReadComplete(bytes_read);
+      }
+      break;
+    case DATA_AVAILABLE:
+      AdvanceJob();
+      stage_ = ALL_DATA;  // done sending data
+      break;
+    case ALL_DATA:
+      stage_ = DONE;
+      return;
+    case DONE:
+      return;
+    default:
+      NOTREACHED() << "Invalid stage";
+      return;
+  }
+}
+
+bool URLRequestTestJob::NextReadAsync() {
+  return false;
+}
+
+void URLRequestTestJob::AdvanceJob() {
+  if (auto_advance_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&URLRequestTestJob::ProcessNextOperation,
+                              weak_factory_.GetWeakPtr()));
+    return;
+  }
+  g_pending_jobs.Get().push_back(this);
+}
+
+// static
+bool URLRequestTestJob::ProcessOnePendingMessage() {
+  if (g_pending_jobs.Get().empty())
+    return false;
+
+  URLRequestTestJob* next_job(g_pending_jobs.Get().front());
+  g_pending_jobs.Get().pop_front();
+
+  DCHECK(!next_job->auto_advance());  // auto_advance jobs should be in this q
+  next_job->ProcessNextOperation();
+  return true;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_test_job.h b/src/net/url_request/url_request_test_job.h
new file mode 100644
index 0000000..0c46d1b
--- /dev/null
+++ b/src/net/url_request/url_request_test_job.h
@@ -0,0 +1,155 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_TEST_JOB_H_
+#define NET_URL_REQUEST_URL_REQUEST_TEST_JOB_H_
+
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_job.h"
+
+namespace net {
+
+// This job type is designed to help with simple unit tests. To use, you
+// probably want to inherit from it to set up the state you want. Then install
+// it as the protocol handler for the "test" scheme.
+//
+// It will respond to three URLs, which you can retrieve using the test_url*
+// getters, which will in turn respond with the corresponding responses returned
+// by test_data*. Any other URLs that begin with "test:" will return an error,
+// which might also be useful, you can use test_url_error() to retreive a
+// standard one.
+//
+// You can override the known URLs or the response data by overriding Start().
+//
+// Optionally, you can also construct test jobs to return a headers and data
+// provided to the contstructor in response to any request url.
+//
+// When a job is created, it gets put on a queue of pending test jobs. To
+// process jobs on this queue, use ProcessOnePendingMessage, which will process
+// one step of the next job. If the job is incomplete, it will be added to the
+// end of the queue.
+//
+// Optionally, you can also construct test jobs that advance automatically
+// without having to call ProcessOnePendingMessage.
+class NET_EXPORT_PRIVATE URLRequestTestJob : public URLRequestJob {
+ public:
+  // Constructs a job to return one of the canned responses depending on the
+  // request url, with auto advance disabled.
+  URLRequestTestJob(URLRequest* request, NetworkDelegate* network_delegate);
+
+  // Constructs a job to return one of the canned responses depending on the
+  // request url, optionally with auto advance enabled.
+  URLRequestTestJob(URLRequest* request,
+                    NetworkDelegate* network_delegate,
+                    bool auto_advance);
+
+  // Constructs a job to return the given response regardless of the request
+  // url. The headers should include the HTTP status line and be formatted as
+  // expected by HttpResponseHeaders.
+  URLRequestTestJob(URLRequest* request,
+                    net::NetworkDelegate* network_delegate,
+                    const std::string& response_headers,
+                    const std::string& response_data,
+                    bool auto_advance);
+
+  // The three canned URLs this handler will respond to without having been
+  // explicitly initialized with response headers and data.
+  // FIXME(brettw): we should probably also have a redirect one
+  static GURL test_url_1();
+  static GURL test_url_2();
+  static GURL test_url_3();
+  static GURL test_url_error();
+
+  // The data that corresponds to each of the URLs above
+  static std::string test_data_1();
+  static std::string test_data_2();
+  static std::string test_data_3();
+
+  // The headers that correspond to each of the URLs above
+  static std::string test_headers();
+
+  // The headers for a redirect response
+  static std::string test_redirect_headers();
+
+  // The headers for a server error response
+  static std::string test_error_headers();
+
+  // Processes one pending message from the stack, returning true if any
+  // message was processed, or false if there are no more pending request
+  // notifications to send. This is not applicable when using auto_advance.
+  static bool ProcessOnePendingMessage();
+
+  // With auto advance enabled, the job will advance thru the stages without
+  // the caller having to call ProcessOnePendingMessage. Auto advance depends
+  // on having a message loop running. The default is to not auto advance.
+  // Should not be altered after the job has started.
+  bool auto_advance() { return auto_advance_; }
+  void set_auto_advance(bool auto_advance) { auto_advance_ = auto_advance; }
+
+  // Factory method for protocol factory registration if callers don't subclass
+  static URLRequest::ProtocolFactory Factory;
+
+  // Job functions
+  virtual void Start() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+  virtual bool IsRedirectResponse(GURL* location,
+                                  int* http_status_code) OVERRIDE;
+
+ protected:
+  // Override to specify whether the next read done from this job will
+  // return IO pending.  This controls whether or not the WAITING state will
+  // transition back to WAITING or to DATA_AVAILABLE after an asynchronous
+  // read is processed.
+  virtual bool NextReadAsync();
+
+  // This is what operation we are going to do next when this job is handled.
+  // When the stage is DONE, this job will not be put on the queue.
+  enum Stage { WAITING, DATA_AVAILABLE, ALL_DATA, DONE };
+
+  virtual ~URLRequestTestJob();
+
+  // Call to process the next opeation, usually sending a notification, and
+  // advancing the stage if necessary. THIS MAY DELETE THE OBJECT.
+  void ProcessNextOperation();
+
+  // Call to move the job along to the next operation.
+  void AdvanceJob();
+
+  // Called via InvokeLater to cause callbacks to occur after Start() returns.
+  virtual void StartAsync();
+
+  bool auto_advance_;
+
+  Stage stage_;
+
+  // The headers the job should return, will be set in Start() if not provided
+  // in the explicit ctor.
+  scoped_refptr<HttpResponseHeaders> response_headers_;
+
+  // The data to send, will be set in Start() if not provided in the explicit
+  // ctor.
+  std::string response_data_;
+
+  // current offset within response_data_
+  int offset_;
+
+  // Holds the buffer for an asynchronous ReadRawData call
+  IOBuffer* async_buf_;
+  int async_buf_size_;
+
+  base::WeakPtrFactory<URLRequestTestJob> weak_factory_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_TEST_JOB_H_
diff --git a/src/net/url_request/url_request_test_util.cc b/src/net/url_request/url_request_test_util.cc
new file mode 100644
index 0000000..93c707d
--- /dev/null
+++ b/src/net/url_request/url_request_test_util.cc
@@ -0,0 +1,576 @@
+// 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 "net/url_request/url_request_test_util.h"
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/threading/thread.h"
+#include "base/threading/worker_pool.h"
+#include "net/base/cert_verifier.h"
+#include "net/base/default_server_bound_cert_store.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/mock_host_resolver.h"
+#include "net/base/server_bound_cert_service.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_server_properties_impl.h"
+#include "net/url_request/static_http_user_agent_settings.h"
+#include "net/url_request/url_request_job_factory_impl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+// These constants put the NetworkDelegate events of TestNetworkDelegate
+// into an order. They are used in conjunction with
+// |TestNetworkDelegate::next_states_| to check that we do not send
+// events in the wrong order.
+const int kStageBeforeURLRequest = 1 << 0;
+const int kStageBeforeSendHeaders = 1 << 1;
+const int kStageSendHeaders = 1 << 2;
+const int kStageHeadersReceived = 1 << 3;
+const int kStageAuthRequired = 1 << 4;
+const int kStageBeforeRedirect = 1 << 5;
+const int kStageResponseStarted = 1 << 6;
+const int kStageCompletedSuccess = 1 << 7;
+const int kStageCompletedError = 1 << 8;
+const int kStageURLRequestDestroyed = 1 << 9;
+const int kStageDestruction = 1 << 10;
+
+}  // namespace
+
+TestURLRequestContext::TestURLRequestContext()
+    : initialized_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(context_storage_(this)) {
+  Init();
+}
+
+TestURLRequestContext::TestURLRequestContext(bool delay_initialization)
+    : initialized_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(context_storage_(this)) {
+  if (!delay_initialization)
+    Init();
+}
+
+TestURLRequestContext::~TestURLRequestContext() {
+  DCHECK(initialized_);
+}
+
+void TestURLRequestContext::Init() {
+  DCHECK(!initialized_);
+  initialized_ = true;
+
+#if !__LB_ENABLE_NATIVE_HTTP_STACK__
+  if (!host_resolver())
+    context_storage_.set_host_resolver(
+        scoped_ptr<HostResolver>(new MockCachingHostResolver()));
+  if (!proxy_service())
+    context_storage_.set_proxy_service(ProxyService::CreateDirect());
+  if (!cert_verifier())
+    context_storage_.set_cert_verifier(CertVerifier::CreateDefault());
+  if (!ftp_transaction_factory()) {
+#if !defined(DISABLE_FTP_SUPPORT)
+    context_storage_.set_ftp_transaction_factory(
+        new FtpNetworkLayer(host_resolver()));
+#else
+    context_storage_.set_ftp_transaction_factory(NULL);
+#endif  // !defined(DISABLE_FTP_SUPPORT)
+  }
+  if (!ssl_config_service())
+    context_storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
+  if (!http_auth_handler_factory()) {
+    context_storage_.set_http_auth_handler_factory(
+        HttpAuthHandlerFactory::CreateDefault(host_resolver()));
+  }
+  if (!http_server_properties()) {
+    context_storage_.set_http_server_properties(
+        new HttpServerPropertiesImpl);
+  }
+  if (!transport_security_state()) {
+    context_storage_.set_transport_security_state(
+        new TransportSecurityState());
+  }
+#endif
+  HttpNetworkSession::Params params;
+  params.host_resolver = host_resolver();
+  params.cert_verifier = cert_verifier();
+  params.proxy_service = proxy_service();
+  params.ssl_config_service = ssl_config_service();
+  params.http_auth_handler_factory = http_auth_handler_factory();
+  params.network_delegate = network_delegate();
+  params.http_server_properties = http_server_properties();
+  params.net_log = net_log();
+
+#if !__LB_ENABLE_NATIVE_HTTP_STACK__
+  if (!http_transaction_factory()) {
+    context_storage_.set_http_transaction_factory(new HttpCache(
+        new HttpNetworkSession(params),
+        HttpCache::DefaultBackend::InMemory(0)));
+  }
+#endif
+  // In-memory cookie store.
+  if (!cookie_store())
+    context_storage_.set_cookie_store(new CookieMonster(NULL, NULL));
+  // In-memory origin bound cert service.
+  if (!server_bound_cert_service()) {
+    context_storage_.set_server_bound_cert_service(
+        new ServerBoundCertService(
+            new DefaultServerBoundCertStore(NULL),
+            base::WorkerPool::GetTaskRunner(true)));
+  }
+  if (!http_user_agent_settings()) {
+    context_storage_.set_http_user_agent_settings(
+        new StaticHttpUserAgentSettings(
+            "en-us,fr", "iso-8859-1,*,utf-8", EmptyString()));
+  }
+  if (!job_factory())
+    context_storage_.set_job_factory(new URLRequestJobFactoryImpl);
+}
+
+TestURLRequest::TestURLRequest(const GURL& url,
+                               Delegate* delegate,
+                               TestURLRequestContext* context)
+    : URLRequest(url, delegate, context) {
+}
+
+TestURLRequest::~TestURLRequest() {
+}
+
+TestURLRequestContextGetter::TestURLRequestContextGetter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner)
+    : network_task_runner_(network_task_runner) {
+  DCHECK(network_task_runner_);
+}
+
+TestURLRequestContextGetter::TestURLRequestContextGetter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
+    scoped_ptr<TestURLRequestContext> context)
+    : network_task_runner_(network_task_runner), context_(context.Pass()) {
+  DCHECK(network_task_runner_);
+}
+
+TestURLRequestContextGetter::~TestURLRequestContextGetter() {}
+
+TestURLRequestContext* TestURLRequestContextGetter::GetURLRequestContext() {
+  if (!context_.get())
+    context_.reset(new TestURLRequestContext);
+  return context_.get();
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+TestURLRequestContextGetter::GetNetworkTaskRunner() const {
+  return network_task_runner_;
+}
+
+TestDelegate::TestDelegate()
+    : cancel_in_rr_(false),
+      cancel_in_rs_(false),
+      cancel_in_rd_(false),
+      cancel_in_rd_pending_(false),
+      quit_on_complete_(true),
+      quit_on_redirect_(false),
+      allow_certificate_errors_(false),
+      response_started_count_(0),
+      received_bytes_count_(0),
+      received_redirect_count_(0),
+      received_data_before_response_(false),
+      request_failed_(false),
+      have_certificate_errors_(false),
+      certificate_errors_are_fatal_(false),
+      auth_required_(false),
+      buf_(new IOBuffer(kBufferSize)) {
+}
+
+TestDelegate::~TestDelegate() {}
+
+void TestDelegate::OnReceivedRedirect(URLRequest* request,
+                                      const GURL& new_url,
+                                      bool* defer_redirect) {
+  EXPECT_TRUE(request->is_redirecting());
+  received_redirect_count_++;
+  if (quit_on_redirect_) {
+    *defer_redirect = true;
+    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  } else if (cancel_in_rr_) {
+    request->Cancel();
+  }
+}
+
+void TestDelegate::OnAuthRequired(URLRequest* request,
+                                  AuthChallengeInfo* auth_info) {
+  auth_required_ = true;
+  if (!credentials_.Empty()) {
+    request->SetAuth(credentials_);
+  } else {
+    request->CancelAuth();
+  }
+}
+
+void TestDelegate::OnSSLCertificateError(URLRequest* request,
+                                         const SSLInfo& ssl_info,
+                                         bool fatal) {
+  // The caller can control whether it needs all SSL requests to go through,
+  // independent of any possible errors, or whether it wants SSL errors to
+  // cancel the request.
+  have_certificate_errors_ = true;
+  certificate_errors_are_fatal_ = fatal;
+  if (allow_certificate_errors_)
+    request->ContinueDespiteLastError();
+  else
+    request->Cancel();
+}
+
+void TestDelegate::OnResponseStarted(URLRequest* request) {
+  // It doesn't make sense for the request to have IO pending at this point.
+  DCHECK(!request->status().is_io_pending());
+  EXPECT_FALSE(request->is_redirecting());
+
+  response_started_count_++;
+  if (cancel_in_rs_) {
+    request->Cancel();
+    OnResponseCompleted(request);
+  } else if (!request->status().is_success()) {
+    DCHECK(request->status().status() == URLRequestStatus::FAILED ||
+           request->status().status() == URLRequestStatus::CANCELED);
+    request_failed_ = true;
+    OnResponseCompleted(request);
+  } else {
+    // Initiate the first read.
+    int bytes_read = 0;
+    if (request->Read(buf_, kBufferSize, &bytes_read))
+      OnReadCompleted(request, bytes_read);
+    else if (!request->status().is_io_pending())
+      OnResponseCompleted(request);
+  }
+}
+
+void TestDelegate::OnReadCompleted(URLRequest* request, int bytes_read) {
+  // It doesn't make sense for the request to have IO pending at this point.
+  DCHECK(!request->status().is_io_pending());
+
+  if (response_started_count_ == 0)
+    received_data_before_response_ = true;
+
+  if (cancel_in_rd_)
+    request->Cancel();
+
+  if (bytes_read >= 0) {
+    // There is data to read.
+    received_bytes_count_ += bytes_read;
+
+    // consume the data
+    data_received_.append(buf_->data(), bytes_read);
+  }
+
+  // If it was not end of stream, request to read more.
+  if (request->status().is_success() && bytes_read > 0) {
+    bytes_read = 0;
+    while (request->Read(buf_, kBufferSize, &bytes_read)) {
+      if (bytes_read > 0) {
+        data_received_.append(buf_->data(), bytes_read);
+        received_bytes_count_ += bytes_read;
+      } else {
+        break;
+      }
+    }
+  }
+  if (!request->status().is_io_pending())
+    OnResponseCompleted(request);
+  else if (cancel_in_rd_pending_)
+    request->Cancel();
+}
+
+void TestDelegate::OnResponseCompleted(URLRequest* request) {
+  if (quit_on_complete_)
+    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+}
+
+TestNetworkDelegate::TestNetworkDelegate()
+    : last_error_(0),
+      error_count_(0),
+      created_requests_(0),
+      destroyed_requests_(0),
+      completed_requests_(0),
+      cookie_options_bit_mask_(0),
+      blocked_get_cookies_count_(0),
+      blocked_set_cookie_count_(0),
+      set_cookie_count_(0) {
+}
+
+TestNetworkDelegate::~TestNetworkDelegate() {
+  for (std::map<int, int>::iterator i = next_states_.begin();
+       i != next_states_.end(); ++i) {
+    event_order_[i->first] += "~TestNetworkDelegate\n";
+    EXPECT_TRUE(i->second & kStageDestruction) << event_order_[i->first];
+  }
+}
+
+void TestNetworkDelegate::InitRequestStatesIfNew(int request_id) {
+  if (next_states_.find(request_id) == next_states_.end()) {
+    next_states_[request_id] = kStageBeforeURLRequest;
+    event_order_[request_id] = "";
+  }
+}
+
+int TestNetworkDelegate::OnBeforeURLRequest(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    GURL* new_url ) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnBeforeURLRequest\n";
+  EXPECT_TRUE(next_states_[req_id] & kStageBeforeURLRequest) <<
+      event_order_[req_id];
+  next_states_[req_id] =
+      kStageBeforeSendHeaders |
+      kStageResponseStarted |  // data: URLs do not trigger sending headers
+      kStageBeforeRedirect |  // a delegate can trigger a redirection
+      kStageCompletedError |  // request canceled by delegate
+      kStageAuthRequired;  // Auth can come next for FTP requests
+  created_requests_++;
+  return OK;
+}
+
+int TestNetworkDelegate::OnBeforeSendHeaders(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    HttpRequestHeaders* headers) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnBeforeSendHeaders\n";
+  EXPECT_TRUE(next_states_[req_id] & kStageBeforeSendHeaders) <<
+      event_order_[req_id];
+  next_states_[req_id] =
+      kStageSendHeaders |
+      kStageCompletedError;  // request canceled by delegate
+
+  return OK;
+}
+
+void TestNetworkDelegate::OnSendHeaders(
+    URLRequest* request,
+    const HttpRequestHeaders& headers) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnSendHeaders\n";
+  EXPECT_TRUE(next_states_[req_id] & kStageSendHeaders) <<
+      event_order_[req_id];
+  next_states_[req_id] =
+      kStageHeadersReceived |
+      kStageCompletedError;
+}
+
+int TestNetworkDelegate::OnHeadersReceived(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    const HttpResponseHeaders* original_response_headers,
+    scoped_refptr<HttpResponseHeaders>* override_response_headers) {
+  int req_id = request->identifier();
+  event_order_[req_id] += "OnHeadersReceived\n";
+  InitRequestStatesIfNew(req_id);
+  EXPECT_TRUE(next_states_[req_id] & kStageHeadersReceived) <<
+      event_order_[req_id];
+  next_states_[req_id] =
+      kStageBeforeRedirect |
+      kStageResponseStarted |
+      kStageAuthRequired |
+      kStageCompletedError;  // e.g. proxy resolution problem
+
+  // Basic authentication sends a second request from the URLRequestHttpJob
+  // layer before the URLRequest reports that a response has started.
+  next_states_[req_id] |= kStageBeforeSendHeaders;
+
+  return OK;
+}
+
+void TestNetworkDelegate::OnBeforeRedirect(URLRequest* request,
+                                           const GURL& new_location) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnBeforeRedirect\n";
+  EXPECT_TRUE(next_states_[req_id] & kStageBeforeRedirect) <<
+      event_order_[req_id];
+  next_states_[req_id] =
+      kStageBeforeURLRequest |  // HTTP redirects trigger this.
+      kStageBeforeSendHeaders |  // Redirects from the network delegate do not
+                                 // trigger onBeforeURLRequest.
+      kStageCompletedError;
+
+  // A redirect can lead to a file or a data URL. In this case, we do not send
+  // headers.
+  next_states_[req_id] |= kStageResponseStarted;
+}
+
+void TestNetworkDelegate::OnResponseStarted(URLRequest* request) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnResponseStarted\n";
+  EXPECT_TRUE(next_states_[req_id] & kStageResponseStarted) <<
+      event_order_[req_id];
+  next_states_[req_id] = kStageCompletedSuccess | kStageCompletedError;
+  if (request->status().status() == URLRequestStatus::FAILED) {
+    error_count_++;
+    last_error_ = request->status().error();
+  }
+}
+
+void TestNetworkDelegate::OnRawBytesRead(const URLRequest& request,
+                                         int bytes_read) {
+}
+
+void TestNetworkDelegate::OnCompleted(URLRequest* request, bool started) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnCompleted\n";
+  // Expect "Success -> (next_states_ & kStageCompletedSuccess)"
+  // is logically identical to
+  // Expect "!(Success) || (next_states_ & kStageCompletedSuccess)"
+  EXPECT_TRUE(!request->status().is_success() ||
+              (next_states_[req_id] & kStageCompletedSuccess)) <<
+      event_order_[req_id];
+  EXPECT_TRUE(request->status().is_success() ||
+              (next_states_[req_id] & kStageCompletedError)) <<
+      event_order_[req_id];
+  next_states_[req_id] = kStageURLRequestDestroyed;
+  completed_requests_++;
+  if (request->status().status() == URLRequestStatus::FAILED) {
+    error_count_++;
+    last_error_ = request->status().error();
+  }
+}
+
+void TestNetworkDelegate::OnURLRequestDestroyed(URLRequest* request) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnURLRequestDestroyed\n";
+  EXPECT_TRUE(next_states_[req_id] & kStageURLRequestDestroyed) <<
+      event_order_[req_id];
+  next_states_[req_id] = kStageDestruction;
+  destroyed_requests_++;
+}
+
+void TestNetworkDelegate::OnPACScriptError(int line_number,
+                                           const string16& error) {
+}
+
+NetworkDelegate::AuthRequiredResponse TestNetworkDelegate::OnAuthRequired(
+    URLRequest* request,
+    const AuthChallengeInfo& auth_info,
+    const AuthCallback& callback,
+    AuthCredentials* credentials) {
+  int req_id = request->identifier();
+  InitRequestStatesIfNew(req_id);
+  event_order_[req_id] += "OnAuthRequired\n";
+  EXPECT_TRUE(next_states_[req_id] & kStageAuthRequired) <<
+      event_order_[req_id];
+  next_states_[req_id] = kStageBeforeSendHeaders |
+      kStageHeadersReceived |  // Request canceled by delegate simulates empty
+                               // response.
+      kStageResponseStarted |  // data: URLs do not trigger sending headers
+      kStageBeforeRedirect |   // a delegate can trigger a redirection
+      kStageCompletedError;    // request cancelled before callback
+  return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+}
+
+bool TestNetworkDelegate::OnCanGetCookies(const URLRequest& request,
+                                          const CookieList& cookie_list) {
+  bool allow = true;
+  if (cookie_options_bit_mask_ & NO_GET_COOKIES)
+    allow = false;
+
+  if (!allow) {
+    blocked_get_cookies_count_++;
+  }
+
+  return allow;
+}
+
+bool TestNetworkDelegate::OnCanSetCookie(const URLRequest& request,
+                                         const std::string& cookie_line,
+                                         CookieOptions* options) {
+  bool allow = true;
+  if (cookie_options_bit_mask_ & NO_SET_COOKIE)
+    allow = false;
+
+  if (!allow) {
+    blocked_set_cookie_count_++;
+  } else {
+    set_cookie_count_++;
+  }
+
+  return allow;
+}
+
+bool TestNetworkDelegate::OnCanAccessFile(const URLRequest& request,
+                                          const FilePath& path) const {
+  return true;
+}
+
+bool TestNetworkDelegate::OnCanThrottleRequest(
+    const URLRequest& request) const {
+  return true;
+}
+
+int TestNetworkDelegate::OnBeforeSocketStreamConnect(
+    SocketStream* socket,
+    const CompletionCallback& callback) {
+  return OK;
+}
+
+void TestNetworkDelegate::OnRequestWaitStateChange(
+    const URLRequest& request,
+    RequestWaitState state) {
+}
+
+// static
+std::string ScopedCustomUrlRequestTestHttpHost::value_("127.0.0.1");
+
+ScopedCustomUrlRequestTestHttpHost::ScopedCustomUrlRequestTestHttpHost(
+  const std::string& new_value)
+    : old_value_(value_),
+      new_value_(new_value) {
+  value_ = new_value_;
+}
+
+ScopedCustomUrlRequestTestHttpHost::~ScopedCustomUrlRequestTestHttpHost() {
+  DCHECK_EQ(value_, new_value_);
+  value_ = old_value_;
+}
+
+// static
+const std::string& ScopedCustomUrlRequestTestHttpHost::value() {
+  return value_;
+}
+
+TestJobInterceptor::TestJobInterceptor() : main_intercept_job_(NULL) {
+}
+
+URLRequestJob* TestJobInterceptor::MaybeIntercept(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const {
+  URLRequestJob* job = main_intercept_job_;
+  main_intercept_job_ = NULL;
+  return job;
+}
+
+URLRequestJob* TestJobInterceptor::MaybeInterceptRedirect(
+      const GURL& location,
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const {
+  return NULL;
+}
+
+URLRequestJob* TestJobInterceptor::MaybeInterceptResponse(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const {
+  return NULL;
+}
+
+void TestJobInterceptor::set_main_intercept_job(URLRequestJob* job) {
+  main_intercept_job_ = job;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_test_util.h b/src/net/url_request/url_request_test_util.h
new file mode 100644
index 0000000..323efb2
--- /dev/null
+++ b/src/net/url_request/url_request_test_util.h
@@ -0,0 +1,326 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
+#define NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
+
+#include <stdlib.h>
+
+#include <map>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop_proxy.h"
+#include "base/path_service.h"
+#include "base/process_util.h"
+#include "base/string16.h"
+#include "base/string_util.h"
+#include "base/time.h"
+#include "base/utf_string_conversions.h"
+#include "googleurl/src/url_util.h"
+#include "net/base/cert_verifier.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/network_delegate.h"
+#include "net/base/ssl_config_service_defaults.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/ftp/ftp_network_layer.h"
+#include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_cache.h"
+#include "net/http/http_network_layer.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_context_storage.h"
+#include "net/url_request/url_request_job_factory.h"
+
+using base::TimeDelta;
+
+namespace net {
+
+//-----------------------------------------------------------------------------
+
+class TestURLRequestContext : public URLRequestContext {
+ public:
+  TestURLRequestContext();
+  // Default constructor like TestURLRequestContext() but does not call
+  // Init() in case |delay_initialization| is true. This allows modifying the
+  // URLRequestContext before it is constructed completely. If
+  // |delay_initialization| is true, Init() needs be be called manually.
+  explicit TestURLRequestContext(bool delay_initialization);
+  virtual ~TestURLRequestContext();
+
+  void Init();
+
+ private:
+  bool initialized_;
+
+ protected:
+  URLRequestContextStorage context_storage_;
+};
+
+//-----------------------------------------------------------------------------
+
+// Used to return a dummy context, which lives on the message loop
+// given in the constructor.
+class TestURLRequestContextGetter : public URLRequestContextGetter {
+ public:
+  // |network_task_runner| must not be NULL.
+  explicit TestURLRequestContextGetter(
+      const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner);
+
+  // Use to pass a pre-initialized |context|.
+  TestURLRequestContextGetter(
+      const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
+      scoped_ptr<TestURLRequestContext> context);
+
+  // URLRequestContextGetter implementation.
+  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE;
+  virtual scoped_refptr<base::SingleThreadTaskRunner>
+      GetNetworkTaskRunner() const OVERRIDE;
+
+ protected:
+  virtual ~TestURLRequestContextGetter();
+
+ private:
+  const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
+  scoped_ptr<TestURLRequestContext> context_;
+};
+
+//-----------------------------------------------------------------------------
+
+class TestURLRequest : public URLRequest {
+ public:
+  TestURLRequest(
+      const GURL& url, Delegate* delegate, TestURLRequestContext* context);
+  virtual ~TestURLRequest();
+};
+
+//-----------------------------------------------------------------------------
+
+class TestDelegate : public URLRequest::Delegate {
+ public:
+  TestDelegate();
+  virtual ~TestDelegate();
+
+  void set_cancel_in_received_redirect(bool val) { cancel_in_rr_ = val; }
+  void set_cancel_in_response_started(bool val) { cancel_in_rs_ = val; }
+  void set_cancel_in_received_data(bool val) { cancel_in_rd_ = val; }
+  void set_cancel_in_received_data_pending(bool val) {
+    cancel_in_rd_pending_ = val;
+  }
+  void set_quit_on_complete(bool val) { quit_on_complete_ = val; }
+  void set_quit_on_redirect(bool val) { quit_on_redirect_ = val; }
+  void set_allow_certificate_errors(bool val) {
+    allow_certificate_errors_ = val;
+  }
+  void set_credentials(const AuthCredentials& credentials) {
+    credentials_ = credentials;
+  }
+
+  // query state
+  const std::string& data_received() const { return data_received_; }
+  int bytes_received() const { return static_cast<int>(data_received_.size()); }
+  int response_started_count() const { return response_started_count_; }
+  int received_redirect_count() const { return received_redirect_count_; }
+  bool received_data_before_response() const {
+    return received_data_before_response_;
+  }
+  bool request_failed() const { return request_failed_; }
+  bool have_certificate_errors() const { return have_certificate_errors_; }
+  bool certificate_errors_are_fatal() const {
+    return certificate_errors_are_fatal_;
+  }
+  bool auth_required_called() const { return auth_required_; }
+
+  // URLRequest::Delegate:
+  virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url,
+                                  bool* defer_redirect) OVERRIDE;
+  virtual void OnAuthRequired(URLRequest* request,
+                              AuthChallengeInfo* auth_info) OVERRIDE;
+  // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true.
+  // (Unit tests use this as a post-condition.) But for policy, this method
+  // consults |allow_certificate_errors_|.
+  virtual void OnSSLCertificateError(URLRequest* request,
+                                     const SSLInfo& ssl_info,
+                                     bool fatal) OVERRIDE;
+  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+  virtual void OnReadCompleted(URLRequest* request,
+                               int bytes_read) OVERRIDE;
+
+ private:
+  static const int kBufferSize = 4096;
+
+  virtual void OnResponseCompleted(URLRequest* request);
+
+  // options for controlling behavior
+  bool cancel_in_rr_;
+  bool cancel_in_rs_;
+  bool cancel_in_rd_;
+  bool cancel_in_rd_pending_;
+  bool quit_on_complete_;
+  bool quit_on_redirect_;
+  bool allow_certificate_errors_;
+  AuthCredentials credentials_;
+
+  // tracks status of callbacks
+  int response_started_count_;
+  int received_bytes_count_;
+  int received_redirect_count_;
+  bool received_data_before_response_;
+  bool request_failed_;
+  bool have_certificate_errors_;
+  bool certificate_errors_are_fatal_;
+  bool auth_required_;
+  std::string data_received_;
+
+  // our read buffer
+  scoped_refptr<IOBuffer> buf_;
+};
+
+//-----------------------------------------------------------------------------
+
+class TestNetworkDelegate : public NetworkDelegate {
+ public:
+  enum Options {
+    NO_GET_COOKIES = 1 << 0,
+    NO_SET_COOKIE  = 1 << 1,
+  };
+
+  TestNetworkDelegate();
+  virtual ~TestNetworkDelegate();
+
+  void set_cookie_options(int o) {cookie_options_bit_mask_ = o; }
+
+  int last_error() const { return last_error_; }
+  int error_count() const { return error_count_; }
+  int created_requests() const { return created_requests_; }
+  int destroyed_requests() const { return destroyed_requests_; }
+  int completed_requests() const { return completed_requests_; }
+  int blocked_get_cookies_count() const { return blocked_get_cookies_count_; }
+  int blocked_set_cookie_count() const { return blocked_set_cookie_count_; }
+  int set_cookie_count() const { return set_cookie_count_; }
+
+ protected:
+  // NetworkDelegate:
+  virtual int OnBeforeURLRequest(URLRequest* request,
+                                 const CompletionCallback& callback,
+                                 GURL* new_url) OVERRIDE;
+  virtual int OnBeforeSendHeaders(URLRequest* request,
+                                  const CompletionCallback& callback,
+                                  HttpRequestHeaders* headers) OVERRIDE;
+  virtual void OnSendHeaders(URLRequest* request,
+                             const HttpRequestHeaders& headers) OVERRIDE;
+  virtual int OnHeadersReceived(
+      URLRequest* request,
+      const CompletionCallback& callback,
+      const HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers) OVERRIDE;
+  virtual void OnBeforeRedirect(URLRequest* request,
+                                const GURL& new_location) OVERRIDE;
+  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+  virtual void OnRawBytesRead(const URLRequest& request,
+                              int bytes_read) OVERRIDE;
+  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE;
+  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE;
+  virtual void OnPACScriptError(int line_number,
+                                const string16& error) OVERRIDE;
+  virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
+      URLRequest* request,
+      const AuthChallengeInfo& auth_info,
+      const AuthCallback& callback,
+      AuthCredentials* credentials) OVERRIDE;
+  virtual bool OnCanGetCookies(const URLRequest& request,
+                               const CookieList& cookie_list) OVERRIDE;
+  virtual bool OnCanSetCookie(const URLRequest& request,
+                              const std::string& cookie_line,
+                              CookieOptions* options) OVERRIDE;
+  virtual bool OnCanAccessFile(const URLRequest& request,
+                               const FilePath& path) const OVERRIDE;
+  virtual bool OnCanThrottleRequest(
+      const URLRequest& request) const OVERRIDE;
+  virtual int OnBeforeSocketStreamConnect(
+      SocketStream* stream,
+      const CompletionCallback& callback) OVERRIDE;
+  virtual void OnRequestWaitStateChange(const URLRequest& request,
+                                        RequestWaitState state) OVERRIDE;
+
+  void InitRequestStatesIfNew(int request_id);
+
+  int last_error_;
+  int error_count_;
+  int created_requests_;
+  int destroyed_requests_;
+  int completed_requests_;
+  int cookie_options_bit_mask_;
+  int blocked_get_cookies_count_;
+  int blocked_set_cookie_count_;
+  int set_cookie_count_;
+
+  // NetworkDelegate callbacks happen in a particular order (e.g.
+  // OnBeforeURLRequest is always called before OnBeforeSendHeaders).
+  // This bit-set indicates for each request id (key) what events may be sent
+  // next.
+  std::map<int, int> next_states_;
+
+  // A log that records for each request id (key) the order in which On...
+  // functions were called.
+  std::map<int, std::string> event_order_;
+};
+
+// Overrides the host used by the LocalHttpTestServer in
+// url_request_unittest.cc . This is used by the chrome_frame_net_tests due to
+// a mysterious bug when tests execute over the loopback adapter. See
+// http://crbug.com/114369 .
+class ScopedCustomUrlRequestTestHttpHost {
+ public:
+  // Sets the host name to be used. The previous hostname will be stored and
+  // restored upon destruction. Note that if the lifetimes of two or more
+  // instances of this class overlap, they must be strictly nested.
+  explicit ScopedCustomUrlRequestTestHttpHost(const std::string& new_value);
+
+  ~ScopedCustomUrlRequestTestHttpHost();
+
+  // Returns the current value to be used by HTTP tests in
+  // url_request_unittest.cc .
+  static const std::string& value();
+
+ private:
+  static std::string value_;
+  const std::string old_value_;
+  const std::string new_value_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedCustomUrlRequestTestHttpHost);
+};
+
+//-----------------------------------------------------------------------------
+
+// A simple Interceptor that returns a pre-built URLRequestJob only once.
+class TestJobInterceptor : public URLRequestJobFactory::Interceptor {
+ public:
+  TestJobInterceptor();
+
+  virtual URLRequestJob* MaybeIntercept(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual URLRequestJob* MaybeInterceptRedirect(
+      const GURL& location,
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual URLRequestJob* MaybeInterceptResponse(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  void set_main_intercept_job(URLRequestJob* job);
+
+ private:
+  mutable URLRequestJob* main_intercept_job_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
diff --git a/src/net/url_request/url_request_throttler_entry.cc b/src/net/url_request/url_request_throttler_entry.cc
new file mode 100644
index 0000000..0899ed4
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_entry.cc
@@ -0,0 +1,321 @@
+// 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 "net/url_request/url_request_throttler_entry.h"
+
+#include <cmath>
+
+#include "base/logging.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
+#include "base/rand_util.h"
+#include "base/string_number_conversions.h"
+#include "base/values.h"
+#include "net/base/load_flags.h"
+#include "net/base/net_log.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_throttler_header_interface.h"
+#include "net/url_request/url_request_throttler_manager.h"
+
+namespace net {
+
+const int URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs = 2000;
+const int URLRequestThrottlerEntry::kDefaultMaxSendThreshold = 20;
+
+// This set of back-off parameters will (at maximum values, i.e. without
+// the reduction caused by jitter) add 0-41% (distributed uniformly
+// in that range) to the "perceived downtime" of the remote server, once
+// exponential back-off kicks in and is throttling requests for more than
+// about a second at a time.  Once the maximum back-off is reached, the added
+// perceived downtime decreases rapidly, percentage-wise.
+//
+// Another way to put it is that the maximum additional perceived downtime
+// with these numbers is a couple of seconds shy of 15 minutes, and such
+// a delay would not occur until the remote server has been actually
+// unavailable at the end of each back-off period for a total of about
+// 48 minutes.
+//
+// Ignoring the first couple of errors is just a conservative measure to
+// avoid false positives.  It should help avoid back-off from kicking in e.g.
+// on flaky connections.
+const int URLRequestThrottlerEntry::kDefaultNumErrorsToIgnore = 2;
+const int URLRequestThrottlerEntry::kDefaultInitialDelayMs = 700;
+const double URLRequestThrottlerEntry::kDefaultMultiplyFactor = 1.4;
+const double URLRequestThrottlerEntry::kDefaultJitterFactor = 0.4;
+const int URLRequestThrottlerEntry::kDefaultMaximumBackoffMs = 15 * 60 * 1000;
+const int URLRequestThrottlerEntry::kDefaultEntryLifetimeMs = 2 * 60 * 1000;
+const char URLRequestThrottlerEntry::kExponentialThrottlingHeader[] =
+    "X-Chrome-Exponential-Throttling";
+const char URLRequestThrottlerEntry::kExponentialThrottlingDisableValue[] =
+    "disable";
+
+// Returns NetLog parameters when a request is rejected by throttling.
+Value* NetLogRejectedRequestCallback(const std::string* url_id,
+                                     int num_failures,
+                                     int release_after_ms,
+                                     NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("url", *url_id);
+  dict->SetInteger("num_failures", num_failures);
+  dict->SetInteger("release_after_ms", release_after_ms);
+  return dict;
+}
+
+URLRequestThrottlerEntry::URLRequestThrottlerEntry(
+    URLRequestThrottlerManager* manager,
+    const std::string& url_id)
+    : sliding_window_period_(
+          base::TimeDelta::FromMilliseconds(kDefaultSlidingWindowPeriodMs)),
+      max_send_threshold_(kDefaultMaxSendThreshold),
+      is_backoff_disabled_(false),
+      backoff_entry_(&backoff_policy_),
+      manager_(manager),
+      url_id_(url_id),
+      net_log_(BoundNetLog::Make(
+          manager->net_log(), NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING)) {
+  DCHECK(manager_);
+  Initialize();
+}
+
+URLRequestThrottlerEntry::URLRequestThrottlerEntry(
+    URLRequestThrottlerManager* manager,
+    const std::string& url_id,
+    int sliding_window_period_ms,
+    int max_send_threshold,
+    int initial_backoff_ms,
+    double multiply_factor,
+    double jitter_factor,
+    int maximum_backoff_ms)
+    : sliding_window_period_(
+          base::TimeDelta::FromMilliseconds(sliding_window_period_ms)),
+      max_send_threshold_(max_send_threshold),
+      is_backoff_disabled_(false),
+      backoff_entry_(&backoff_policy_),
+      manager_(manager),
+      url_id_(url_id) {
+  DCHECK_GT(sliding_window_period_ms, 0);
+  DCHECK_GT(max_send_threshold_, 0);
+  DCHECK_GE(initial_backoff_ms, 0);
+  DCHECK_GT(multiply_factor, 0);
+  DCHECK_GE(jitter_factor, 0.0);
+  DCHECK_LT(jitter_factor, 1.0);
+  DCHECK_GE(maximum_backoff_ms, 0);
+  DCHECK(manager_);
+
+  Initialize();
+  backoff_policy_.initial_delay_ms = initial_backoff_ms;
+  backoff_policy_.multiply_factor = multiply_factor;
+  backoff_policy_.jitter_factor = jitter_factor;
+  backoff_policy_.maximum_backoff_ms = maximum_backoff_ms;
+  backoff_policy_.entry_lifetime_ms = -1;
+  backoff_policy_.num_errors_to_ignore = 0;
+  backoff_policy_.always_use_initial_delay = false;
+}
+
+bool URLRequestThrottlerEntry::IsEntryOutdated() const {
+  // This function is called by the URLRequestThrottlerManager to determine
+  // whether entries should be discarded from its url_entries_ map.  We
+  // want to ensure that it does not remove entries from the map while there
+  // are clients (objects other than the manager) holding references to
+  // the entry, otherwise separate clients could end up holding separate
+  // entries for a request to the same URL, which is undesirable.  Therefore,
+  // if an entry has more than one reference (the map will always hold one),
+  // it should not be considered outdated.
+  //
+  // We considered whether to make URLRequestThrottlerEntry objects
+  // non-refcounted, but since any means of knowing whether they are
+  // currently in use by others than the manager would be more or less
+  // equivalent to a refcount, we kept them refcounted.
+  if (!HasOneRef())
+    return false;
+
+  // If there are send events in the sliding window period, we still need this
+  // entry.
+  if (!send_log_.empty() &&
+      send_log_.back() + sliding_window_period_ > ImplGetTimeNow()) {
+    return false;
+  }
+
+  return GetBackoffEntry()->CanDiscard();
+}
+
+void URLRequestThrottlerEntry::DisableBackoffThrottling() {
+  is_backoff_disabled_ = true;
+}
+
+void URLRequestThrottlerEntry::DetachManager() {
+  manager_ = NULL;
+}
+
+bool URLRequestThrottlerEntry::ShouldRejectRequest(
+    const URLRequest& request) const {
+  bool reject_request = false;
+  if (!is_backoff_disabled_ && !ExplicitUserRequest(request.load_flags()) &&
+      (!request.context()->network_delegate() ||
+       request.context()->network_delegate()->CanThrottleRequest(request)) &&
+      GetBackoffEntry()->ShouldRejectRequest()) {
+    int num_failures = GetBackoffEntry()->failure_count();
+    int release_after_ms =
+        GetBackoffEntry()->GetTimeUntilRelease().InMilliseconds();
+
+    net_log_.AddEvent(
+        NetLog::TYPE_THROTTLING_REJECTED_REQUEST,
+        base::Bind(&NetLogRejectedRequestCallback,
+                   &url_id_, num_failures, release_after_ms));
+
+    reject_request = true;
+  }
+
+  int reject_count = reject_request ? 1 : 0;
+  UMA_HISTOGRAM_ENUMERATION(
+      "Throttling.RequestThrottled", reject_count, 2);
+
+  return reject_request;
+}
+
+int64 URLRequestThrottlerEntry::ReserveSendingTimeForNextRequest(
+    const base::TimeTicks& earliest_time) {
+  base::TimeTicks now = ImplGetTimeNow();
+
+  // If a lot of requests were successfully made recently,
+  // sliding_window_release_time_ may be greater than
+  // exponential_backoff_release_time_.
+  base::TimeTicks recommended_sending_time =
+      std::max(std::max(now, earliest_time),
+               std::max(GetBackoffEntry()->GetReleaseTime(),
+                        sliding_window_release_time_));
+
+  DCHECK(send_log_.empty() ||
+         recommended_sending_time >= send_log_.back());
+  // Log the new send event.
+  send_log_.push(recommended_sending_time);
+
+  sliding_window_release_time_ = recommended_sending_time;
+
+  // Drop the out-of-date events in the event list.
+  // We don't need to worry that the queue may become empty during this
+  // operation, since the last element is sliding_window_release_time_.
+  while ((send_log_.front() + sliding_window_period_ <=
+          sliding_window_release_time_) ||
+         send_log_.size() > static_cast<unsigned>(max_send_threshold_)) {
+    send_log_.pop();
+  }
+
+  // Check if there are too many send events in recent time.
+  if (send_log_.size() == static_cast<unsigned>(max_send_threshold_))
+    sliding_window_release_time_ = send_log_.front() + sliding_window_period_;
+
+  return (recommended_sending_time - now).InMillisecondsRoundedUp();
+}
+
+base::TimeTicks
+    URLRequestThrottlerEntry::GetExponentialBackoffReleaseTime() const {
+  // If a site opts out, it's likely because they have problems that trigger
+  // the back-off mechanism when it shouldn't be triggered, in which case
+  // returning the calculated back-off release time would probably be the
+  // wrong thing to do (i.e. it would likely be too long).  Therefore, we
+  // return "now" so that retries are not delayed.
+  if (is_backoff_disabled_)
+    return ImplGetTimeNow();
+
+  return GetBackoffEntry()->GetReleaseTime();
+}
+
+void URLRequestThrottlerEntry::UpdateWithResponse(
+    const std::string& host,
+    const URLRequestThrottlerHeaderInterface* response) {
+  if (IsConsideredError(response->GetResponseCode())) {
+    GetBackoffEntry()->InformOfRequest(false);
+  } else {
+    GetBackoffEntry()->InformOfRequest(true);
+
+    std::string throttling_header = response->GetNormalizedValue(
+        kExponentialThrottlingHeader);
+    if (!throttling_header.empty())
+      HandleThrottlingHeader(throttling_header, host);
+  }
+}
+
+void URLRequestThrottlerEntry::ReceivedContentWasMalformed(int response_code) {
+  // A malformed body can only occur when the request to fetch a resource
+  // was successful.  Therefore, in such a situation, we will receive one
+  // call to ReceivedContentWasMalformed() and one call to
+  // UpdateWithResponse() with a response categorized as "good".  To end
+  // up counting one failure, we need to count two failures here against
+  // the one success in UpdateWithResponse().
+  //
+  // We do nothing for a response that is already being considered an error
+  // based on its status code (otherwise we would count 3 errors instead of 1).
+  if (!IsConsideredError(response_code)) {
+    GetBackoffEntry()->InformOfRequest(false);
+    GetBackoffEntry()->InformOfRequest(false);
+  }
+}
+
+URLRequestThrottlerEntry::~URLRequestThrottlerEntry() {
+}
+
+void URLRequestThrottlerEntry::Initialize() {
+  sliding_window_release_time_ = base::TimeTicks::Now();
+  backoff_policy_.num_errors_to_ignore = kDefaultNumErrorsToIgnore;
+  backoff_policy_.initial_delay_ms = kDefaultInitialDelayMs;
+  backoff_policy_.multiply_factor = kDefaultMultiplyFactor;
+  backoff_policy_.jitter_factor = kDefaultJitterFactor;
+  backoff_policy_.maximum_backoff_ms = kDefaultMaximumBackoffMs;
+  backoff_policy_.entry_lifetime_ms = kDefaultEntryLifetimeMs;
+  backoff_policy_.always_use_initial_delay = false;
+}
+
+bool URLRequestThrottlerEntry::IsConsideredError(int response_code) {
+  // We throttle only for the status codes most likely to indicate the server
+  // is failing because it is too busy or otherwise are likely to be
+  // because of DDoS.
+  //
+  // 500 is the generic error when no better message is suitable, and
+  //     as such does not necessarily indicate a temporary state, but
+  //     other status codes cover most of the permanent error states.
+  // 503 is explicitly documented as a temporary state where the server
+  //     is either overloaded or down for maintenance.
+  // 509 is the (non-standard but widely implemented) Bandwidth Limit Exceeded
+  //     status code, which might indicate DDoS.
+  //
+  // We do not back off on 502 or 504, which are reported by gateways
+  // (proxies) on timeouts or failures, because in many cases these requests
+  // have not made it to the destination server and so we do not actually
+  // know that it is down or busy.  One degenerate case could be a proxy on
+  // localhost, where you are not actually connected to the network.
+  return (response_code == 500 ||
+          response_code == 503 ||
+          response_code == 509);
+}
+
+base::TimeTicks URLRequestThrottlerEntry::ImplGetTimeNow() const {
+  return base::TimeTicks::Now();
+}
+
+void URLRequestThrottlerEntry::HandleThrottlingHeader(
+    const std::string& header_value,
+    const std::string& host) {
+  if (header_value == kExponentialThrottlingDisableValue) {
+    DisableBackoffThrottling();
+    if (manager_)
+      manager_->AddToOptOutList(host);
+  }
+}
+
+const BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() const {
+  return &backoff_entry_;
+}
+
+BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() {
+  return &backoff_entry_;
+}
+
+// static
+bool URLRequestThrottlerEntry::ExplicitUserRequest(const int load_flags) {
+  return (load_flags & LOAD_MAYBE_USER_GESTURE) != 0;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_throttler_entry.h b/src/net/url_request/url_request_throttler_entry.h
new file mode 100644
index 0000000..66a8ce9
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_entry.h
@@ -0,0 +1,175 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_THROTTLER_ENTRY_H_
+#define NET_URL_REQUEST_URL_REQUEST_THROTTLER_ENTRY_H_
+
+#include <queue>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/time.h"
+#include "net/base/backoff_entry.h"
+#include "net/base/net_log.h"
+#include "net/url_request/url_request_throttler_entry_interface.h"
+
+namespace net {
+
+class URLRequestThrottlerManager;
+
+// URLRequestThrottlerEntry represents an entry of URLRequestThrottlerManager.
+// It analyzes requests of a specific URL over some period of time, in order to
+// deduce the back-off time for every request.
+// The back-off algorithm consists of two parts. Firstly, exponential back-off
+// is used when receiving 5XX server errors or malformed response bodies.
+// The exponential back-off rule is enforced by URLRequestHttpJob. Any
+// request sent during the back-off period will be cancelled.
+// Secondly, a sliding window is used to count recent requests to a given
+// destination and provide guidance (to the application level only) on whether
+// too many requests have been sent and when a good time to send the next one
+// would be. This is never used to deny requests at the network level.
+class NET_EXPORT URLRequestThrottlerEntry
+    : public URLRequestThrottlerEntryInterface {
+ public:
+  // Sliding window period.
+  static const int kDefaultSlidingWindowPeriodMs;
+
+  // Maximum number of requests allowed in sliding window period.
+  static const int kDefaultMaxSendThreshold;
+
+  // Number of initial errors to ignore before starting exponential back-off.
+  static const int kDefaultNumErrorsToIgnore;
+
+  // Initial delay for exponential back-off.
+  static const int kDefaultInitialDelayMs;
+
+  // Factor by which the waiting time will be multiplied.
+  static const double kDefaultMultiplyFactor;
+
+  // Fuzzing percentage. ex: 10% will spread requests randomly
+  // between 90%-100% of the calculated time.
+  static const double kDefaultJitterFactor;
+
+  // Maximum amount of time we are willing to delay our request.
+  static const int kDefaultMaximumBackoffMs;
+
+  // Time after which the entry is considered outdated.
+  static const int kDefaultEntryLifetimeMs;
+
+  // Name of the header that sites can use to opt out of exponential back-off
+  // throttling.
+  static const char kExponentialThrottlingHeader[];
+
+  // Value for exponential throttling header that can be used to opt out of
+  // exponential back-off throttling.
+  static const char kExponentialThrottlingDisableValue[];
+
+  // The manager object's lifetime must enclose the lifetime of this object.
+  URLRequestThrottlerEntry(URLRequestThrottlerManager* manager,
+                           const std::string& url_id);
+
+  // The life span of instances created with this constructor is set to
+  // infinite, and the number of initial errors to ignore is set to 0.
+  // It is only used by unit tests.
+  URLRequestThrottlerEntry(URLRequestThrottlerManager* manager,
+                           const std::string& url_id,
+                           int sliding_window_period_ms,
+                           int max_send_threshold,
+                           int initial_backoff_ms,
+                           double multiply_factor,
+                           double jitter_factor,
+                           int maximum_backoff_ms);
+
+  // Used by the manager, returns true if the entry needs to be garbage
+  // collected.
+  bool IsEntryOutdated() const;
+
+  // Causes this entry to never reject requests due to back-off.
+  void DisableBackoffThrottling();
+
+  // Causes this entry to NULL its manager pointer.
+  void DetachManager();
+
+  // Implementation of URLRequestThrottlerEntryInterface.
+  virtual bool ShouldRejectRequest(const URLRequest& request) const OVERRIDE;
+  virtual int64 ReserveSendingTimeForNextRequest(
+      const base::TimeTicks& earliest_time) OVERRIDE;
+  virtual base::TimeTicks GetExponentialBackoffReleaseTime() const OVERRIDE;
+  virtual void UpdateWithResponse(
+      const std::string& host,
+      const URLRequestThrottlerHeaderInterface* response) OVERRIDE;
+  virtual void ReceivedContentWasMalformed(int response_code) OVERRIDE;
+
+ protected:
+  virtual ~URLRequestThrottlerEntry();
+
+  void Initialize();
+
+  // Returns true if the given response code is considered an error for
+  // throttling purposes.
+  bool IsConsideredError(int response_code);
+
+  // Equivalent to TimeTicks::Now(), virtual to be mockable for testing purpose.
+  virtual base::TimeTicks ImplGetTimeNow() const;
+
+  // Used internally to handle the opt-out header.
+  void HandleThrottlingHeader(const std::string& header_value,
+                              const std::string& host);
+
+  // Retrieves the back-off entry object we're using. Used to enable a
+  // unit testing seam for dependency injection in tests.
+  virtual const BackoffEntry* GetBackoffEntry() const;
+  virtual BackoffEntry* GetBackoffEntry();
+
+  // Returns true if |load_flags| contains a flag that indicates an
+  // explicit request by the user to load the resource. We never
+  // throttle requests with such load flags.
+  static bool ExplicitUserRequest(const int load_flags);
+
+  // Used by tests.
+  base::TimeTicks sliding_window_release_time() const {
+    return sliding_window_release_time_;
+  }
+
+  // Used by tests.
+  void set_sliding_window_release_time(const base::TimeTicks& release_time) {
+    sliding_window_release_time_ = release_time;
+  }
+
+  // Valid and immutable after construction time.
+  BackoffEntry::Policy backoff_policy_;
+
+ private:
+  // Timestamp calculated by the sliding window algorithm for when we advise
+  // clients the next request should be made, at the earliest. Advisory only,
+  // not used to deny requests.
+  base::TimeTicks sliding_window_release_time_;
+
+  // A list of the recent send events. We use them to decide whether there are
+  // too many requests sent in sliding window.
+  std::queue<base::TimeTicks> send_log_;
+
+  const base::TimeDelta sliding_window_period_;
+  const int max_send_threshold_;
+
+  // True if DisableBackoffThrottling() has been called on this object.
+  bool is_backoff_disabled_;
+
+  // Access it through GetBackoffEntry() to allow a unit test seam.
+  BackoffEntry backoff_entry_;
+
+  // Weak back-reference to the manager object managing us.
+  URLRequestThrottlerManager* manager_;
+
+  // Canonicalized URL string that this entry is for; used for logging only.
+  std::string url_id_;
+
+  BoundNetLog net_log_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestThrottlerEntry);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_THROTTLER_ENTRY_H_
diff --git a/src/net/url_request/url_request_throttler_entry_interface.h b/src/net/url_request/url_request_throttler_entry_interface.h
new file mode 100644
index 0000000..6d975f4
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_entry_interface.h
@@ -0,0 +1,73 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_THROTTLER_ENTRY_INTERFACE_H_
+#define NET_URL_REQUEST_URL_REQUEST_THROTTLER_ENTRY_INTERFACE_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "base/time.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+class URLRequest;
+class URLRequestThrottlerHeaderInterface;
+
+// Interface provided on entries of the URL request throttler manager.
+class NET_EXPORT URLRequestThrottlerEntryInterface
+    : public base::RefCountedThreadSafe<URLRequestThrottlerEntryInterface> {
+ public:
+  URLRequestThrottlerEntryInterface() {}
+
+  // Returns true when we have encountered server errors and are doing
+  // exponential back-off, unless the request has load flags that mean
+  // it is likely to be user-initiated, or the NetworkDelegate returns
+  // false for |CanThrottleRequest(request)|.
+  //
+  // URLRequestHttpJob checks this method prior to every request; it
+  // cancels requests if this method returns true.
+  virtual bool ShouldRejectRequest(const URLRequest& request) const = 0;
+
+  // Calculates a recommended sending time for the next request and reserves it.
+  // The sending time is not earlier than the current exponential back-off
+  // release time or |earliest_time|. Moreover, the previous results of
+  // the method are taken into account, in order to make sure they are spread
+  // properly over time.
+  // Returns the recommended delay before sending the next request, in
+  // milliseconds. The return value is always positive or 0.
+  // Although it is not mandatory, respecting the value returned by this method
+  // is helpful to avoid traffic overload.
+  virtual int64 ReserveSendingTimeForNextRequest(
+      const base::TimeTicks& earliest_time) = 0;
+
+  // Returns the time after which requests are allowed.
+  virtual base::TimeTicks GetExponentialBackoffReleaseTime() const = 0;
+
+  // This method needs to be called each time a response is received.
+  virtual void UpdateWithResponse(
+      const std::string& host,
+      const URLRequestThrottlerHeaderInterface* response) = 0;
+
+  // Lets higher-level modules, that know how to parse particular response
+  // bodies, notify of receiving malformed content for the given URL. This will
+  // be handled by the throttler as if an HTTP 503 response had been received to
+  // the request, i.e. it will count as a failure, unless the HTTP response code
+  // indicated is already one of those that will be counted as an error.
+  virtual void ReceivedContentWasMalformed(int response_code) = 0;
+
+ protected:
+  friend class base::RefCountedThreadSafe<URLRequestThrottlerEntryInterface>;
+  virtual ~URLRequestThrottlerEntryInterface() {}
+
+ private:
+  friend class base::RefCounted<URLRequestThrottlerEntryInterface>;
+  DISALLOW_COPY_AND_ASSIGN(URLRequestThrottlerEntryInterface);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_THROTTLER_ENTRY_INTERFACE_H_
diff --git a/src/net/url_request/url_request_throttler_header_adapter.cc b/src/net/url_request/url_request_throttler_header_adapter.cc
new file mode 100644
index 0000000..51bbc74
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_header_adapter.cc
@@ -0,0 +1,29 @@
+// Copyright (c) 2011 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 "net/url_request/url_request_throttler_header_adapter.h"
+
+#include "net/http/http_response_headers.h"
+
+namespace net {
+
+URLRequestThrottlerHeaderAdapter::URLRequestThrottlerHeaderAdapter(
+    HttpResponseHeaders* headers)
+    : response_header_(headers) {
+}
+
+URLRequestThrottlerHeaderAdapter::~URLRequestThrottlerHeaderAdapter() {}
+
+std::string URLRequestThrottlerHeaderAdapter::GetNormalizedValue(
+    const std::string& key) const {
+  std::string return_value;
+  response_header_->GetNormalizedHeader(key, &return_value);
+  return return_value;
+}
+
+int URLRequestThrottlerHeaderAdapter::GetResponseCode() const {
+  return response_header_->response_code();
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_throttler_header_adapter.h b/src/net/url_request/url_request_throttler_header_adapter.h
new file mode 100644
index 0000000..17a13a1
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_header_adapter.h
@@ -0,0 +1,35 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_THROTTLER_HEADER_ADAPTER_H_
+#define NET_URL_REQUEST_URL_REQUEST_THROTTLER_HEADER_ADAPTER_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "net/url_request/url_request_throttler_header_interface.h"
+
+namespace net {
+
+class HttpResponseHeaders;
+
+// Adapter for the HTTP header interface of the URL request throttler component.
+class URLRequestThrottlerHeaderAdapter
+    : public URLRequestThrottlerHeaderInterface {
+ public:
+  explicit URLRequestThrottlerHeaderAdapter(HttpResponseHeaders* headers);
+  virtual ~URLRequestThrottlerHeaderAdapter();
+
+  // Implementation of URLRequestThrottlerHeaderInterface
+  virtual std::string GetNormalizedValue(const std::string& key) const OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+
+ private:
+  const scoped_refptr<HttpResponseHeaders> response_header_;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_THROTTLER_HEADER_ADAPTER_H_
diff --git a/src/net/url_request/url_request_throttler_header_interface.h b/src/net/url_request/url_request_throttler_header_interface.h
new file mode 100644
index 0000000..c69d185
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_header_interface.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2010 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_THROTTLER_HEADER_INTERFACE_H_
+#define NET_URL_REQUEST_URL_REQUEST_THROTTLER_HEADER_INTERFACE_H_
+
+#include <string>
+
+namespace net {
+
+// Interface to an HTTP header to enforce we have the methods we need.
+class URLRequestThrottlerHeaderInterface {
+ public:
+  virtual ~URLRequestThrottlerHeaderInterface() {}
+
+  // Method that enables us to fetch the header value by its key.
+  // ex: location: www.example.com -> key = "location" value = "www.example.com"
+  // If the key does not exist, it returns an empty string.
+  virtual std::string GetNormalizedValue(const std::string& key) const = 0;
+
+  // Returns the HTTP response code associated with the request.
+  virtual int GetResponseCode() const = 0;
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_THROTTLER_HEADER_INTERFACE_H_
diff --git a/src/net/url_request/url_request_throttler_manager.cc b/src/net/url_request/url_request_throttler_manager.cc
new file mode 100644
index 0000000..fa04a00
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_manager.cc
@@ -0,0 +1,203 @@
+// 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 "net/url_request/url_request_throttler_manager.h"
+
+#include "base/logging.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
+#include "base/string_util.h"
+#include "net/base/net_log.h"
+#include "net/base/net_util.h"
+
+namespace net {
+
+const unsigned int URLRequestThrottlerManager::kMaximumNumberOfEntries = 1500;
+const unsigned int URLRequestThrottlerManager::kRequestsBetweenCollecting = 200;
+
+URLRequestThrottlerManager::URLRequestThrottlerManager()
+    : requests_since_last_gc_(0),
+      enable_thread_checks_(false),
+      logged_for_localhost_disabled_(false),
+      registered_from_thread_(base::kInvalidThreadId) {
+  url_id_replacements_.ClearPassword();
+  url_id_replacements_.ClearUsername();
+  url_id_replacements_.ClearQuery();
+  url_id_replacements_.ClearRef();
+
+  NetworkChangeNotifier::AddIPAddressObserver(this);
+  NetworkChangeNotifier::AddConnectionTypeObserver(this);
+}
+
+URLRequestThrottlerManager::~URLRequestThrottlerManager() {
+  NetworkChangeNotifier::RemoveIPAddressObserver(this);
+  NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
+
+  // Since the manager object might conceivably go away before the
+  // entries, detach the entries' back-pointer to the manager.
+  UrlEntryMap::iterator i = url_entries_.begin();
+  while (i != url_entries_.end()) {
+    if (i->second != NULL) {
+      i->second->DetachManager();
+    }
+    ++i;
+  }
+
+  // Delete all entries.
+  url_entries_.clear();
+}
+
+scoped_refptr<URLRequestThrottlerEntryInterface>
+    URLRequestThrottlerManager::RegisterRequestUrl(const GURL &url) {
+  DCHECK(!enable_thread_checks_ || CalledOnValidThread());
+
+  // Normalize the url.
+  std::string url_id = GetIdFromUrl(url);
+
+  // Periodically garbage collect old entries.
+  GarbageCollectEntriesIfNecessary();
+
+  // Find the entry in the map or create a new NULL entry.
+  scoped_refptr<URLRequestThrottlerEntry>& entry = url_entries_[url_id];
+
+  // If the entry exists but could be garbage collected at this point, we
+  // start with a fresh entry so that we possibly back off a bit less
+  // aggressively (i.e. this resets the error count when the entry's URL
+  // hasn't been requested in long enough).
+  if (entry.get() && entry->IsEntryOutdated()) {
+    entry = NULL;
+  }
+
+  // Create the entry if needed.
+  if (entry.get() == NULL) {
+    entry = new URLRequestThrottlerEntry(this, url_id);
+
+    // We only disable back-off throttling on an entry that we have
+    // just constructed.  This is to allow unit tests to explicitly override
+    // the entry for localhost URLs.  Given that we do not attempt to
+    // disable throttling for entries already handed out (see comment
+    // in AddToOptOutList), this is not a problem.
+    std::string host = url.host();
+    if (opt_out_hosts_.find(host) != opt_out_hosts_.end() ||
+        IsLocalhost(host)) {
+      if (!logged_for_localhost_disabled_ && IsLocalhost(host)) {
+        logged_for_localhost_disabled_ = true;
+        net_log_.AddEvent(NetLog::TYPE_THROTTLING_DISABLED_FOR_HOST,
+                          NetLog::StringCallback("host", &host));
+      }
+
+      // TODO(joi): Once sliding window is separate from back-off throttling,
+      // we can simply return a dummy implementation of
+      // URLRequestThrottlerEntryInterface here that never blocks anything (and
+      // not keep entries in url_entries_ for opted-out sites).
+      entry->DisableBackoffThrottling();
+    }
+  }
+
+  return entry;
+}
+
+void URLRequestThrottlerManager::AddToOptOutList(const std::string& host) {
+  // There is an edge case here that we are not handling, to keep things
+  // simple.  If a host starts adding the opt-out header to its responses
+  // after there are already one or more entries in url_entries_ for that
+  // host, the pre-existing entries may still perform back-off throttling.
+  // In practice, this would almost never occur.
+  if (opt_out_hosts_.find(host) == opt_out_hosts_.end()) {
+    UMA_HISTOGRAM_COUNTS("Throttling.SiteOptedOut", 1);
+
+    net_log_.EndEvent(NetLog::TYPE_THROTTLING_DISABLED_FOR_HOST,
+                      NetLog::StringCallback("host", &host));
+    opt_out_hosts_.insert(host);
+  }
+}
+
+void URLRequestThrottlerManager::OverrideEntryForTests(
+    const GURL& url,
+    URLRequestThrottlerEntry* entry) {
+  // Normalize the url.
+  std::string url_id = GetIdFromUrl(url);
+
+  // Periodically garbage collect old entries.
+  GarbageCollectEntriesIfNecessary();
+
+  url_entries_[url_id] = entry;
+}
+
+void URLRequestThrottlerManager::EraseEntryForTests(const GURL& url) {
+  // Normalize the url.
+  std::string url_id = GetIdFromUrl(url);
+  url_entries_.erase(url_id);
+}
+
+void URLRequestThrottlerManager::set_enable_thread_checks(bool enable) {
+  enable_thread_checks_ = enable;
+}
+
+bool URLRequestThrottlerManager::enable_thread_checks() const {
+  return enable_thread_checks_;
+}
+
+void URLRequestThrottlerManager::set_net_log(NetLog* net_log) {
+  DCHECK(net_log);
+  net_log_ = BoundNetLog::Make(net_log,
+                               NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING);
+}
+
+NetLog* URLRequestThrottlerManager::net_log() const {
+  return net_log_.net_log();
+}
+
+void URLRequestThrottlerManager::OnIPAddressChanged() {
+  OnNetworkChange();
+}
+
+void URLRequestThrottlerManager::OnConnectionTypeChanged(
+    NetworkChangeNotifier::ConnectionType type) {
+  OnNetworkChange();
+}
+
+std::string URLRequestThrottlerManager::GetIdFromUrl(const GURL& url) const {
+  if (!url.is_valid())
+    return url.possibly_invalid_spec();
+
+  GURL id = url.ReplaceComponents(url_id_replacements_);
+  return StringToLowerASCII(id.spec()).c_str();
+}
+
+void URLRequestThrottlerManager::GarbageCollectEntriesIfNecessary() {
+  requests_since_last_gc_++;
+  if (requests_since_last_gc_ < kRequestsBetweenCollecting)
+    return;
+  requests_since_last_gc_ = 0;
+
+  GarbageCollectEntries();
+}
+
+void URLRequestThrottlerManager::GarbageCollectEntries() {
+  UrlEntryMap::iterator i = url_entries_.begin();
+  while (i != url_entries_.end()) {
+    if ((i->second)->IsEntryOutdated()) {
+      url_entries_.erase(i++);
+    } else {
+      ++i;
+    }
+  }
+
+  // In case something broke we want to make sure not to grow indefinitely.
+  while (url_entries_.size() > kMaximumNumberOfEntries) {
+    url_entries_.erase(url_entries_.begin());
+  }
+}
+
+void URLRequestThrottlerManager::OnNetworkChange() {
+  // Remove all entries.  Any entries that in-flight requests have a reference
+  // to will live until those requests end, and these entries may be
+  // inconsistent with new entries for the same URLs, but since what we
+  // want is a clean slate for the new connection type, this is OK.
+  url_entries_.clear();
+  requests_since_last_gc_ = 0;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_throttler_manager.h b/src/net/url_request/url_request_throttler_manager.h
new file mode 100644
index 0000000..9623834
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_manager.h
@@ -0,0 +1,166 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_THROTTLER_MANAGER_H_
+#define NET_URL_REQUEST_URL_REQUEST_THROTTLER_MANAGER_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "base/threading/non_thread_safe.h"
+#include "base/threading/platform_thread.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/net_export.h"
+#include "net/base/network_change_notifier.h"
+#include "net/url_request/url_request_throttler_entry.h"
+
+namespace net {
+
+class BoundNetLog;
+class NetLog;
+
+// Class that registers URL request throttler entries for URLs being accessed
+// in order to supervise traffic. URL requests for HTTP contents should
+// register their URLs in this manager on each request.
+//
+// URLRequestThrottlerManager maintains a map of URL IDs to URL request
+// throttler entries. It creates URL request throttler entries when new URLs
+// are registered, and does garbage collection from time to time in order to
+// clean out outdated entries. URL ID consists of lowercased scheme, host, port
+// and path. All URLs converted to the same ID will share the same entry.
+class NET_EXPORT URLRequestThrottlerManager
+    : NON_EXPORTED_BASE(public base::NonThreadSafe),
+      public NetworkChangeNotifier::IPAddressObserver,
+      public NetworkChangeNotifier::ConnectionTypeObserver {
+ public:
+  URLRequestThrottlerManager();
+  virtual ~URLRequestThrottlerManager();
+
+  // Must be called for every request, returns the URL request throttler entry
+  // associated with the URL. The caller must inform this entry of some events.
+  // Please refer to url_request_throttler_entry_interface.h for further
+  // informations.
+  scoped_refptr<URLRequestThrottlerEntryInterface> RegisterRequestUrl(
+      const GURL& url);
+
+  // Adds the given host to a list of sites for which exponential back-off
+  // throttling will be disabled.  Subdomains are not included, so they
+  // must be added separately.
+  void AddToOptOutList(const std::string& host);
+
+  // Registers a new entry in this service and overrides the existing entry (if
+  // any) for the URL. The service will hold a reference to the entry.
+  // It is only used by unit tests.
+  void OverrideEntryForTests(const GURL& url, URLRequestThrottlerEntry* entry);
+
+  // Explicitly erases an entry.
+  // This is useful to remove those entries which have got infinite lifetime and
+  // thus won't be garbage collected.
+  // It is only used by unit tests.
+  void EraseEntryForTests(const GURL& url);
+
+  // Turns threading model verification on or off.  Any code that correctly
+  // uses the network stack should preferably call this function to enable
+  // verification of correct adherence to the network stack threading model.
+  void set_enable_thread_checks(bool enable);
+  bool enable_thread_checks() const;
+
+  // Whether throttling is enabled or not.
+  void set_enforce_throttling(bool enforce);
+  bool enforce_throttling();
+
+  // Sets the NetLog instance to use.
+  void set_net_log(NetLog* net_log);
+  NetLog* net_log() const;
+
+  // IPAddressObserver interface.
+  virtual void OnIPAddressChanged() OVERRIDE;
+
+  // ConnectionTypeObserver interface.
+  virtual void OnConnectionTypeChanged(
+      NetworkChangeNotifier::ConnectionType type) OVERRIDE;
+
+  // Method that allows us to transform a URL into an ID that can be used in our
+  // map. Resulting IDs will be lowercase and consist of the scheme, host, port
+  // and path (without query string, fragment, etc.).
+  // If the URL is invalid, the invalid spec will be returned, without any
+  // transformation.
+  std::string GetIdFromUrl(const GURL& url) const;
+
+  // Method that ensures the map gets cleaned from time to time. The period at
+  // which garbage collecting happens is adjustable with the
+  // kRequestBetweenCollecting constant.
+  void GarbageCollectEntriesIfNecessary();
+
+  // Method that does the actual work of garbage collecting.
+  void GarbageCollectEntries();
+
+  // When we switch from online to offline or change IP addresses, we
+  // clear all back-off history. This is a precaution in case the change in
+  // online state now lets us communicate without error with servers that
+  // we were previously getting 500 or 503 responses from (perhaps the
+  // responses are from a badly-written proxy that should have returned a
+  // 502 or 504 because it's upstream connection was down or it had no route
+  // to the server).
+  void OnNetworkChange();
+
+  // Used by tests.
+  int GetNumberOfEntriesForTests() const { return url_entries_.size(); }
+
+ private:
+  // From each URL we generate an ID composed of the scheme, host, port and path
+  // that allows us to uniquely map an entry to it.
+  typedef std::map<std::string, scoped_refptr<URLRequestThrottlerEntry> >
+      UrlEntryMap;
+
+  // We maintain a set of hosts that have opted out of exponential
+  // back-off throttling.
+  typedef std::set<std::string> OptOutHosts;
+
+  // Maximum number of entries that we are willing to collect in our map.
+  static const unsigned int kMaximumNumberOfEntries;
+  // Number of requests that will be made between garbage collection.
+  static const unsigned int kRequestsBetweenCollecting;
+
+  // Map that contains a list of URL ID and their matching
+  // URLRequestThrottlerEntry.
+  UrlEntryMap url_entries_;
+
+  // Set of hosts that have opted out.
+  OptOutHosts opt_out_hosts_;
+
+  // This keeps track of how many requests have been made. Used with
+  // GarbageCollectEntries.
+  unsigned int requests_since_last_gc_;
+
+  // Valid after construction.
+  GURL::Replacements url_id_replacements_;
+
+  // Certain tests do not obey the net component's threading policy, so we
+  // keep track of whether we're being used by tests, and turn off certain
+  // checks.
+  //
+  // TODO(joi): See if we can fix the offending unit tests and remove this
+  // workaround.
+  bool enable_thread_checks_;
+
+  // Initially false, switches to true once we have logged because of back-off
+  // being disabled for localhost.
+  bool logged_for_localhost_disabled_;
+
+  // NetLog to use, if configured.
+  BoundNetLog net_log_;
+
+  // Valid once we've registered for network notifications.
+  base::PlatformThreadId registered_from_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestThrottlerManager);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_THROTTLER_MANAGER_H_
diff --git a/src/net/url_request/url_request_throttler_simulation_unittest.cc b/src/net/url_request/url_request_throttler_simulation_unittest.cc
new file mode 100644
index 0000000..48b0319
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_simulation_unittest.cc
@@ -0,0 +1,757 @@
+// 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.
+
+// The tests in this file attempt to verify the following through simulation:
+// a) That a server experiencing overload will actually benefit from the
+//    anti-DDoS throttling logic, i.e. that its traffic spike will subside
+//    and be distributed over a longer period of time;
+// b) That "well-behaved" clients of a server under DDoS attack actually
+//    benefit from the anti-DDoS throttling logic; and
+// c) That the approximate increase in "perceived downtime" introduced by
+//    anti-DDoS throttling for various different actual downtimes is what
+//    we expect it to be.
+
+#include <cmath>
+#include <limits>
+#include <vector>
+
+#include "base/environment.h"
+#include "base/memory/scoped_vector.h"
+#include "base/rand_util.h"
+#include "base/time.h"
+#include "net/url_request/url_request_test_util.h"
+#include "net/url_request/url_request_throttler_manager.h"
+#include "net/url_request/url_request_throttler_test_support.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::TimeDelta;
+using base::TimeTicks;
+
+namespace net {
+namespace {
+
+// Set this variable in your environment if you want to see verbose results
+// of the simulation tests.
+const char kShowSimulationVariableName[] = "SHOW_SIMULATION_RESULTS";
+
+// Prints output only if a given environment variable is set. We use this
+// to not print any output for human evaluation when the test is run without
+// supervision.
+void VerboseOut(const char* format, ...) {
+  static bool have_checked_environment = false;
+  static bool should_print = false;
+  if (!have_checked_environment) {
+    have_checked_environment = true;
+    scoped_ptr<base::Environment> env(base::Environment::Create());
+    if (env->HasVar(kShowSimulationVariableName))
+      should_print = true;
+  }
+
+  if (should_print) {
+    va_list arglist;
+    va_start(arglist, format);
+    vprintf(format, arglist);
+    va_end(arglist);
+  }
+}
+
+// A simple two-phase discrete time simulation. Actors are added in the order
+// they should take action at every tick of the clock. Ticks of the clock
+// are two-phase:
+// - Phase 1 advances every actor's time to a new absolute time.
+// - Phase 2 asks each actor to perform their action.
+class DiscreteTimeSimulation {
+ public:
+  class Actor {
+   public:
+    virtual ~Actor() {}
+    virtual void AdvanceTime(const TimeTicks& absolute_time) = 0;
+    virtual void PerformAction() = 0;
+  };
+
+  DiscreteTimeSimulation() {}
+
+  // Adds an |actor| to the simulation. The client of the simulation maintains
+  // ownership of |actor| and must ensure its lifetime exceeds that of the
+  // simulation. Actors should be added in the order you wish for them to
+  // act at each tick of the simulation.
+  void AddActor(Actor* actor) {
+    actors_.push_back(actor);
+  }
+
+  // Runs the simulation for, pretending |time_between_ticks| passes from one
+  // tick to the next. The start time will be the current real time. The
+  // simulation will stop when the simulated duration is equal to or greater
+  // than |maximum_simulated_duration|.
+  void RunSimulation(const TimeDelta& maximum_simulated_duration,
+                     const TimeDelta& time_between_ticks) {
+    TimeTicks start_time = TimeTicks();
+    TimeTicks now = start_time;
+    while ((now - start_time) <= maximum_simulated_duration) {
+      for (std::vector<Actor*>::iterator it = actors_.begin();
+           it != actors_.end();
+           ++it) {
+        (*it)->AdvanceTime(now);
+      }
+
+      for (std::vector<Actor*>::iterator it = actors_.begin();
+           it != actors_.end();
+           ++it) {
+        (*it)->PerformAction();
+      }
+
+      now += time_between_ticks;
+    }
+  }
+
+ private:
+  std::vector<Actor*> actors_;
+
+  DISALLOW_COPY_AND_ASSIGN(DiscreteTimeSimulation);
+};
+
+// Represents a web server in a simulation of a server under attack by
+// a lot of clients. Must be added to the simulation's list of actors
+// after all |Requester| objects.
+class Server : public DiscreteTimeSimulation::Actor {
+ public:
+  Server(int max_queries_per_tick,
+         double request_drop_ratio)
+      : max_queries_per_tick_(max_queries_per_tick),
+        request_drop_ratio_(request_drop_ratio),
+        num_overloaded_ticks_remaining_(0),
+        num_current_tick_queries_(0),
+        num_overloaded_ticks_(0),
+        max_experienced_queries_per_tick_(0),
+        mock_request_(GURL(), NULL, &context_) {
+  }
+
+  void SetDowntime(const TimeTicks& start_time, const TimeDelta& duration) {
+    start_downtime_ = start_time;
+    end_downtime_ = start_time + duration;
+  }
+
+  virtual void AdvanceTime(const TimeTicks& absolute_time) OVERRIDE {
+    now_ = absolute_time;
+  }
+
+  virtual void PerformAction() OVERRIDE {
+    // We are inserted at the end of the actor's list, so all Requester
+    // instances have already done their bit.
+    if (num_current_tick_queries_ > max_experienced_queries_per_tick_)
+      max_experienced_queries_per_tick_ = num_current_tick_queries_;
+
+    if (num_current_tick_queries_ > max_queries_per_tick_) {
+      // We pretend the server fails for the next several ticks after it
+      // gets overloaded.
+      num_overloaded_ticks_remaining_ = 5;
+      ++num_overloaded_ticks_;
+    } else if (num_overloaded_ticks_remaining_ > 0) {
+      --num_overloaded_ticks_remaining_;
+    }
+
+    requests_per_tick_.push_back(num_current_tick_queries_);
+    num_current_tick_queries_ = 0;
+  }
+
+  // This is called by Requester. It returns the response code from
+  // the server.
+  int HandleRequest() {
+    ++num_current_tick_queries_;
+    if (!start_downtime_.is_null() &&
+        start_downtime_ < now_ && now_ < end_downtime_) {
+      // For the simulation measuring the increase in perceived
+      // downtime, it might be interesting to count separately the
+      // queries seen by the server (assuming a front-end reverse proxy
+      // is what actually serves up the 503s in this case) so that we could
+      // visualize the traffic spike seen by the server when it comes up,
+      // which would in many situations be ameliorated by the anti-DDoS
+      // throttling.
+      return 503;
+    }
+
+    if ((num_overloaded_ticks_remaining_ > 0 ||
+         num_current_tick_queries_ > max_queries_per_tick_) &&
+        base::RandDouble() < request_drop_ratio_) {
+      return 503;
+    }
+
+    return 200;
+  }
+
+  int num_overloaded_ticks() const {
+    return num_overloaded_ticks_;
+  }
+
+  int max_experienced_queries_per_tick() const {
+    return max_experienced_queries_per_tick_;
+  }
+
+  const URLRequest& mock_request() const {
+    return mock_request_;
+  }
+
+  std::string VisualizeASCII(int terminal_width) {
+    // Account for | characters we place at left of graph.
+    terminal_width -= 1;
+
+    VerboseOut("Overloaded for %d of %d ticks.\n",
+               num_overloaded_ticks_, requests_per_tick_.size());
+    VerboseOut("Got maximum of %d requests in a tick.\n\n",
+               max_experienced_queries_per_tick_);
+
+    VerboseOut("Traffic graph:\n\n");
+
+    // Printing the graph like this is a bit overkill, but was very useful
+    // while developing the various simulations to see if they were testing
+    // the corner cases we want to simulate.
+
+    // Find the smallest number of whole ticks we need to group into a
+    // column that will let all ticks fit into the column width we have.
+    int num_ticks = requests_per_tick_.size();
+    double ticks_per_column_exact =
+        static_cast<double>(num_ticks) / static_cast<double>(terminal_width);
+    int ticks_per_column = std::ceil(ticks_per_column_exact);
+    DCHECK_GE(ticks_per_column * terminal_width, num_ticks);
+
+    // Sum up the column values.
+    int num_columns = num_ticks / ticks_per_column;
+    if (num_ticks % ticks_per_column)
+      ++num_columns;
+    DCHECK_LE(num_columns, terminal_width);
+    scoped_array<int> columns(new int[num_columns]);
+    for (int tx = 0; tx < num_ticks; ++tx) {
+      int cx = tx / ticks_per_column;
+      if (tx % ticks_per_column == 0)
+        columns[cx] = 0;
+      columns[cx] += requests_per_tick_[tx];
+    }
+
+    // Find the lowest integer divisor that will let the column values
+    // be represented in a graph of maximum height 50.
+    int max_value = 0;
+    for (int cx = 0; cx < num_columns; ++cx)
+      max_value = std::max(max_value, columns[cx]);
+    const int kNumRows = 50;
+    double row_divisor_exact = max_value / static_cast<double>(kNumRows);
+    int row_divisor = std::ceil(row_divisor_exact);
+    DCHECK_GE(row_divisor * kNumRows, max_value);
+
+    // To show the overload line, we calculate the appropriate value.
+    int overload_value = max_queries_per_tick_ * ticks_per_column;
+
+    // When num_ticks is not a whole multiple of ticks_per_column, the last
+    // column includes fewer ticks than the others. In this case, don't
+    // print it so that we don't show an inconsistent value.
+    int num_printed_columns = num_columns;
+    if (num_ticks % ticks_per_column)
+      --num_printed_columns;
+
+    // This is a top-to-bottom traversal of rows, left-to-right per row.
+    std::string output;
+    for (int rx = 0; rx < kNumRows; ++rx) {
+      int range_min = (kNumRows - rx) * row_divisor;
+      int range_max = range_min + row_divisor;
+      if (range_min == 0)
+        range_min = -1;  // Make 0 values fit in the bottom range.
+      output.append("|");
+      for (int cx = 0; cx < num_printed_columns; ++cx) {
+        char block = ' ';
+        // Show the overload line.
+        if (range_min < overload_value && overload_value <= range_max)
+          block = '-';
+
+        // Preferentially, show the graph line.
+        if (range_min < columns[cx] && columns[cx] <= range_max)
+          block = '#';
+
+        output.append(1, block);
+      }
+      output.append("\n");
+    }
+    output.append("|");
+    output.append(num_printed_columns, '=');
+
+    return output;
+  }
+
+ private:
+  TimeTicks now_;
+  TimeTicks start_downtime_;  // Can be 0 to say "no downtime".
+  TimeTicks end_downtime_;
+  const int max_queries_per_tick_;
+  const double request_drop_ratio_;  // Ratio of requests to 503 when failing.
+  int num_overloaded_ticks_remaining_;
+  int num_current_tick_queries_;
+  int num_overloaded_ticks_;
+  int max_experienced_queries_per_tick_;
+  std::vector<int> requests_per_tick_;
+
+  TestURLRequestContext context_;
+  TestURLRequest mock_request_;
+
+  DISALLOW_COPY_AND_ASSIGN(Server);
+};
+
+// Mock throttler entry used by Requester class.
+class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
+ public:
+  explicit MockURLRequestThrottlerEntry(
+      URLRequestThrottlerManager* manager)
+      : URLRequestThrottlerEntry(manager, ""),
+        mock_backoff_entry_(&backoff_policy_) {
+  }
+
+  virtual const BackoffEntry* GetBackoffEntry() const OVERRIDE {
+    return &mock_backoff_entry_;
+  }
+
+  virtual BackoffEntry* GetBackoffEntry() OVERRIDE {
+    return &mock_backoff_entry_;
+  }
+
+  virtual TimeTicks ImplGetTimeNow() const OVERRIDE {
+    return fake_now_;
+  }
+
+  void SetFakeNow(const TimeTicks& fake_time) {
+    fake_now_ = fake_time;
+    mock_backoff_entry_.set_fake_now(fake_time);
+  }
+
+  TimeTicks fake_now() const {
+    return fake_now_;
+  }
+
+ protected:
+  virtual ~MockURLRequestThrottlerEntry() {}
+
+ private:
+  TimeTicks fake_now_;
+  MockBackoffEntry mock_backoff_entry_;
+};
+
+// Registry of results for a class of |Requester| objects (e.g. attackers vs.
+// regular clients).
+class RequesterResults {
+public:
+  RequesterResults()
+      : num_attempts_(0), num_successful_(0), num_failed_(0), num_blocked_(0) {
+  }
+
+  void AddSuccess() {
+    ++num_attempts_;
+    ++num_successful_;
+  }
+
+  void AddFailure() {
+    ++num_attempts_;
+    ++num_failed_;
+  }
+
+  void AddBlocked() {
+    ++num_attempts_;
+    ++num_blocked_;
+  }
+
+  int num_attempts() const { return num_attempts_; }
+  int num_successful() const { return num_successful_; }
+  int num_failed() const { return num_failed_; }
+  int num_blocked() const { return num_blocked_; }
+
+  double GetBlockedRatio() {
+    DCHECK(num_attempts_);
+    return static_cast<double>(num_blocked_) /
+        static_cast<double>(num_attempts_);
+  }
+
+  double GetSuccessRatio() {
+    DCHECK(num_attempts_);
+    return static_cast<double>(num_successful_) /
+        static_cast<double>(num_attempts_);
+  }
+
+  void PrintResults(const char* class_description) {
+    if (num_attempts_ == 0) {
+      VerboseOut("No data for %s\n", class_description);
+      return;
+    }
+
+    VerboseOut("Requester results for %s\n", class_description);
+    VerboseOut("  %d attempts\n", num_attempts_);
+    VerboseOut("  %d successes\n", num_successful_);
+    VerboseOut("  %d 5xx responses\n", num_failed_);
+    VerboseOut("  %d requests blocked\n", num_blocked_);
+    VerboseOut("  %.2f success ratio\n", GetSuccessRatio());
+    VerboseOut("  %.2f blocked ratio\n", GetBlockedRatio());
+    VerboseOut("\n");
+  }
+
+ private:
+  int num_attempts_;
+  int num_successful_;
+  int num_failed_;
+  int num_blocked_;
+};
+
+// Represents an Requester in a simulated DDoS situation, that periodically
+// requests a specific resource.
+class Requester : public DiscreteTimeSimulation::Actor {
+ public:
+  Requester(MockURLRequestThrottlerEntry* throttler_entry,
+            const TimeDelta& time_between_requests,
+            Server* server,
+            RequesterResults* results)
+      : throttler_entry_(throttler_entry),
+        time_between_requests_(time_between_requests),
+        last_attempt_was_failure_(false),
+        server_(server),
+        results_(results) {
+    DCHECK(server_);
+  }
+
+  void AdvanceTime(const TimeTicks& absolute_time) OVERRIDE {
+    if (time_of_last_success_.is_null())
+      time_of_last_success_ = absolute_time;
+
+    throttler_entry_->SetFakeNow(absolute_time);
+  }
+
+  void PerformAction() OVERRIDE {
+    TimeDelta effective_delay = time_between_requests_;
+    TimeDelta current_jitter = TimeDelta::FromMilliseconds(
+        request_jitter_.InMilliseconds() * base::RandDouble());
+    if (base::RandInt(0, 1)) {
+      effective_delay -= current_jitter;
+    } else {
+      effective_delay += current_jitter;
+    }
+
+    if (throttler_entry_->fake_now() - time_of_last_attempt_ >
+        effective_delay) {
+      if (!throttler_entry_->ShouldRejectRequest(server_->mock_request())) {
+        int status_code = server_->HandleRequest();
+        MockURLRequestThrottlerHeaderAdapter response_headers(status_code);
+        throttler_entry_->UpdateWithResponse("", &response_headers);
+
+        if (status_code == 200) {
+          if (results_)
+            results_->AddSuccess();
+
+          if (last_attempt_was_failure_) {
+            last_downtime_duration_ =
+                throttler_entry_->fake_now() - time_of_last_success_;
+          }
+
+          time_of_last_success_ = throttler_entry_->fake_now();
+          last_attempt_was_failure_ = false;
+        } else {
+          if (results_)
+            results_->AddFailure();
+          last_attempt_was_failure_ = true;
+        }
+      } else {
+        if (results_)
+          results_->AddBlocked();
+        last_attempt_was_failure_ = true;
+      }
+
+      time_of_last_attempt_ = throttler_entry_->fake_now();
+    }
+  }
+
+  // Adds a delay until the first request, equal to a uniformly distributed
+  // value between now and now + max_delay.
+  void SetStartupJitter(const TimeDelta& max_delay) {
+    int delay_ms = base::RandInt(0, max_delay.InMilliseconds());
+    time_of_last_attempt_ = TimeTicks() +
+        TimeDelta::FromMilliseconds(delay_ms) - time_between_requests_;
+  }
+
+  void SetRequestJitter(const TimeDelta& request_jitter) {
+    request_jitter_ = request_jitter;
+  }
+
+  TimeDelta last_downtime_duration() const { return last_downtime_duration_; }
+
+ private:
+  scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry_;
+  const TimeDelta time_between_requests_;
+  TimeDelta request_jitter_;
+  TimeTicks time_of_last_attempt_;
+  TimeTicks time_of_last_success_;
+  bool last_attempt_was_failure_;
+  TimeDelta last_downtime_duration_;
+  Server* const server_;
+  RequesterResults* const results_;  // May be NULL.
+
+  DISALLOW_COPY_AND_ASSIGN(Requester);
+};
+
+void SimulateAttack(Server* server,
+                    RequesterResults* attacker_results,
+                    RequesterResults* client_results,
+                    bool enable_throttling) {
+  const size_t kNumAttackers = 50;
+  const size_t kNumClients = 50;
+  DiscreteTimeSimulation simulation;
+  URLRequestThrottlerManager manager;
+  ScopedVector<Requester> requesters;
+  for (size_t i = 0; i < kNumAttackers; ++i) {
+    // Use a tiny time_between_requests so the attackers will ping the
+    // server at every tick of the simulation.
+    scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
+        new MockURLRequestThrottlerEntry(&manager));
+    if (!enable_throttling)
+      throttler_entry->DisableBackoffThrottling();
+
+      Requester* attacker = new Requester(throttler_entry.get(),
+                                        TimeDelta::FromMilliseconds(1),
+                                        server,
+                                        attacker_results);
+    attacker->SetStartupJitter(TimeDelta::FromSeconds(120));
+    requesters.push_back(attacker);
+    simulation.AddActor(attacker);
+  }
+  for (size_t i = 0; i < kNumClients; ++i) {
+    // Normal clients only make requests every 2 minutes, plus/minus 1 minute.
+    scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
+        new MockURLRequestThrottlerEntry(&manager));
+    if (!enable_throttling)
+      throttler_entry->DisableBackoffThrottling();
+
+    Requester* client = new Requester(throttler_entry.get(),
+                                      TimeDelta::FromMinutes(2),
+                                      server,
+                                      client_results);
+    client->SetStartupJitter(TimeDelta::FromSeconds(120));
+    client->SetRequestJitter(TimeDelta::FromMinutes(1));
+    requesters.push_back(client);
+    simulation.AddActor(client);
+  }
+  simulation.AddActor(server);
+
+  simulation.RunSimulation(TimeDelta::FromMinutes(6),
+                           TimeDelta::FromSeconds(1));
+}
+
+TEST(URLRequestThrottlerSimulation, HelpsInAttack) {
+  Server unprotected_server(30, 1.0);
+  RequesterResults unprotected_attacker_results;
+  RequesterResults unprotected_client_results;
+  Server protected_server(30, 1.0);
+  RequesterResults protected_attacker_results;
+  RequesterResults protected_client_results;
+  SimulateAttack(&unprotected_server,
+                 &unprotected_attacker_results,
+                 &unprotected_client_results,
+                 false);
+  SimulateAttack(&protected_server,
+                 &protected_attacker_results,
+                 &protected_client_results,
+                 true);
+
+  // These assert that the DDoS protection actually benefits the
+  // server. Manual inspection of the traffic graphs will show this
+  // even more clearly.
+  EXPECT_GT(unprotected_server.num_overloaded_ticks(),
+            protected_server.num_overloaded_ticks());
+  EXPECT_GT(unprotected_server.max_experienced_queries_per_tick(),
+            protected_server.max_experienced_queries_per_tick());
+
+  // These assert that the DDoS protection actually benefits non-malicious
+  // (and non-degenerate/accidentally DDoSing) users.
+  EXPECT_LT(protected_client_results.GetBlockedRatio(),
+            protected_attacker_results.GetBlockedRatio());
+  EXPECT_GT(protected_client_results.GetSuccessRatio(),
+            unprotected_client_results.GetSuccessRatio());
+
+  // The rest is just for optional manual evaluation of the results;
+  // in particular the traffic pattern is interesting.
+
+  VerboseOut("\nUnprotected server's results:\n\n");
+  VerboseOut(unprotected_server.VisualizeASCII(132).c_str());
+  VerboseOut("\n\n");
+  VerboseOut("Protected server's results:\n\n");
+  VerboseOut(protected_server.VisualizeASCII(132).c_str());
+  VerboseOut("\n\n");
+
+  unprotected_attacker_results.PrintResults(
+      "attackers attacking unprotected server.");
+  unprotected_client_results.PrintResults(
+      "normal clients making requests to unprotected server.");
+  protected_attacker_results.PrintResults(
+      "attackers attacking protected server.");
+  protected_client_results.PrintResults(
+      "normal clients making requests to protected server.");
+}
+
+// Returns the downtime perceived by the client, as a ratio of the
+// actual downtime.
+double SimulateDowntime(const TimeDelta& duration,
+                        const TimeDelta& average_client_interval,
+                        bool enable_throttling) {
+  TimeDelta time_between_ticks = duration / 200;
+  TimeTicks start_downtime = TimeTicks() + (duration / 2);
+
+  // A server that never rejects requests, but will go down for maintenance.
+  Server server(std::numeric_limits<int>::max(), 1.0);
+  server.SetDowntime(start_downtime, duration);
+
+  URLRequestThrottlerManager manager;
+  scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
+      new MockURLRequestThrottlerEntry(&manager));
+  if (!enable_throttling)
+    throttler_entry->DisableBackoffThrottling();
+
+  Requester requester(
+      throttler_entry.get(), average_client_interval, &server, NULL);
+  requester.SetStartupJitter(duration / 3);
+  requester.SetRequestJitter(average_client_interval);
+
+  DiscreteTimeSimulation simulation;
+  simulation.AddActor(&requester);
+  simulation.AddActor(&server);
+
+  simulation.RunSimulation(duration * 2, time_between_ticks);
+
+  return static_cast<double>(
+      requester.last_downtime_duration().InMilliseconds()) /
+      static_cast<double>(duration.InMilliseconds());
+}
+
+TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
+  struct Stats {
+    // Expected interval that we expect the ratio of downtime when anti-DDoS
+    // is enabled and downtime when anti-DDoS is not enabled to fall within.
+    //
+    // The expected interval depends on two things:  The exponential back-off
+    // policy encoded in URLRequestThrottlerEntry, and the test or set of
+    // tests that the Stats object is tracking (e.g. a test where the client
+    // retries very rapidly on a very long downtime will tend to increase the
+    // number).
+    //
+    // To determine an appropriate new interval when parameters have changed,
+    // run the test a few times (you may have to Ctrl-C out of it after a few
+    // seconds) and choose an interval that the test converges quickly and
+    // reliably to.  Then set the new interval, and run the test e.g. 20 times
+    // in succession to make sure it never takes an obscenely long time to
+    // converge to this interval.
+    double expected_min_increase;
+    double expected_max_increase;
+
+    size_t num_runs;
+    double total_ratio_unprotected;
+    double total_ratio_protected;
+
+    bool DidConverge(double* increase_ratio_out) {
+      double unprotected_ratio = total_ratio_unprotected / num_runs;
+      double protected_ratio = total_ratio_protected / num_runs;
+      double increase_ratio = protected_ratio / unprotected_ratio;
+      if (increase_ratio_out)
+        *increase_ratio_out = increase_ratio;
+      return expected_min_increase <= increase_ratio &&
+          increase_ratio <= expected_max_increase;
+    }
+
+    void ReportTrialResult(double increase_ratio) {
+      VerboseOut(
+          "  Perceived downtime with throttling is %.4f times without.\n",
+          increase_ratio);
+      VerboseOut("  Test result after %d trials.\n", num_runs);
+    }
+  };
+
+  Stats global_stats = { 1.08, 1.15 };
+
+  struct Trial {
+    TimeDelta duration;
+    TimeDelta average_client_interval;
+    Stats stats;
+
+    void PrintTrialDescription() {
+      double duration_minutes =
+          static_cast<double>(duration.InSeconds()) / 60.0;
+      double interval_minutes =
+          static_cast<double>(average_client_interval.InSeconds()) / 60.0;
+      VerboseOut("Trial with %.2f min downtime, avg. interval %.2f min.\n",
+                 duration_minutes, interval_minutes);
+    }
+  };
+
+  // We don't set or check expected ratio intervals on individual
+  // experiments as this might make the test too fragile, but we
+  // print them out at the end for manual evaluation (we want to be
+  // able to make claims about the expected ratios depending on the
+  // type of behavior of the client and the downtime, e.g. the difference
+  // in behavior between a client making requests every few minutes vs.
+  // one that makes a request every 15 seconds).
+  Trial trials[] = {
+    { TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(3) },
+    { TimeDelta::FromSeconds(30), TimeDelta::FromSeconds(7) },
+    { TimeDelta::FromMinutes(5), TimeDelta::FromSeconds(30) },
+    { TimeDelta::FromMinutes(10), TimeDelta::FromSeconds(20) },
+    { TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(15) },
+    { TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(50) },
+    { TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(2) },
+    { TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(5) },
+    { TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(7) },
+    { TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(2) },
+    { TimeDelta::FromMinutes(40), TimeDelta::FromSeconds(15) },
+    { TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(7) },
+    { TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(2) },
+    { TimeDelta::FromMinutes(60), TimeDelta::FromSeconds(15) },
+    { TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(20) },
+    { TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(3) },
+    { TimeDelta::FromMinutes(80), TimeDelta::FromSeconds(15) },
+
+    // Most brutal?
+    { TimeDelta::FromMinutes(45), TimeDelta::FromMilliseconds(500) },
+  };
+
+  // If things don't converge by the time we've done 100K trials, then
+  // clearly one or more of the expected intervals are wrong.
+  while (global_stats.num_runs < 100000) {
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(trials); ++i) {
+      ++global_stats.num_runs;
+      ++trials[i].stats.num_runs;
+      double ratio_unprotected = SimulateDowntime(
+          trials[i].duration, trials[i].average_client_interval, false);
+      double ratio_protected = SimulateDowntime(
+          trials[i].duration, trials[i].average_client_interval, true);
+      global_stats.total_ratio_unprotected += ratio_unprotected;
+      global_stats.total_ratio_protected += ratio_protected;
+      trials[i].stats.total_ratio_unprotected += ratio_unprotected;
+      trials[i].stats.total_ratio_protected += ratio_protected;
+    }
+
+    double increase_ratio;
+    if (global_stats.DidConverge(&increase_ratio))
+      break;
+
+    if (global_stats.num_runs > 200) {
+      VerboseOut("Test has not yet converged on expected interval.\n");
+      global_stats.ReportTrialResult(increase_ratio);
+    }
+  }
+
+  double average_increase_ratio;
+  EXPECT_TRUE(global_stats.DidConverge(&average_increase_ratio));
+
+  // Print individual trial results for optional manual evaluation.
+  double max_increase_ratio = 0.0;
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(trials); ++i) {
+    double increase_ratio;
+    trials[i].stats.DidConverge(&increase_ratio);
+    max_increase_ratio = std::max(max_increase_ratio, increase_ratio);
+    trials[i].PrintTrialDescription();
+    trials[i].stats.ReportTrialResult(increase_ratio);
+  }
+
+  VerboseOut("Average increase ratio was %.4f\n", average_increase_ratio);
+  VerboseOut("Maximum increase ratio was %.4f\n", max_increase_ratio);
+}
+
+}  // namespace
+}  // namespace net
diff --git a/src/net/url_request/url_request_throttler_test_support.cc b/src/net/url_request/url_request_throttler_test_support.cc
new file mode 100644
index 0000000..b6088ec
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_test_support.cc
@@ -0,0 +1,58 @@
+// 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 "net/url_request/url_request_throttler_test_support.h"
+
+#include "net/url_request/url_request_throttler_entry.h"
+
+namespace net {
+
+MockBackoffEntry::MockBackoffEntry(const BackoffEntry::Policy* const policy)
+    : BackoffEntry(policy) {
+}
+
+MockBackoffEntry::~MockBackoffEntry() {
+}
+
+base::TimeTicks MockBackoffEntry::ImplGetTimeNow() const {
+  return fake_now_;
+}
+
+void MockBackoffEntry::set_fake_now(const base::TimeTicks& now) {
+  fake_now_ = now;
+}
+
+MockURLRequestThrottlerHeaderAdapter::MockURLRequestThrottlerHeaderAdapter(
+    int response_code)
+    : fake_response_code_(response_code) {
+}
+
+MockURLRequestThrottlerHeaderAdapter::MockURLRequestThrottlerHeaderAdapter(
+    const std::string& retry_value,
+    const std::string& opt_out_value,
+    int response_code)
+    : fake_retry_value_(retry_value),
+      fake_opt_out_value_(opt_out_value),
+      fake_response_code_(response_code) {
+}
+
+MockURLRequestThrottlerHeaderAdapter::~MockURLRequestThrottlerHeaderAdapter() {
+}
+
+std::string MockURLRequestThrottlerHeaderAdapter::GetNormalizedValue(
+    const std::string& key) const {
+  if (key ==
+      URLRequestThrottlerEntry::kExponentialThrottlingHeader &&
+      !fake_opt_out_value_.empty()) {
+    return fake_opt_out_value_;
+  }
+
+  return "";
+}
+
+int MockURLRequestThrottlerHeaderAdapter::GetResponseCode() const {
+  return fake_response_code_;
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_throttler_test_support.h b/src/net/url_request/url_request_throttler_test_support.h
new file mode 100644
index 0000000..cad041c
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_test_support.h
@@ -0,0 +1,61 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_URL_REQUEST_URL_REQUEST_THROTTLER_TEST_SUPPORT_H_
+#define NET_URL_REQUEST_URL_REQUEST_THROTTLER_TEST_SUPPORT_H_
+
+#include <string>
+
+#include "base/time.h"
+#include "net/base/backoff_entry.h"
+#include "net/url_request/url_request_throttler_header_interface.h"
+
+namespace net {
+
+class MockBackoffEntry : public BackoffEntry {
+ public:
+  explicit MockBackoffEntry(const BackoffEntry::Policy* const policy);
+  virtual ~MockBackoffEntry();
+
+  // BackoffEntry overrides.
+  virtual base::TimeTicks ImplGetTimeNow() const OVERRIDE;
+
+  void set_fake_now(const base::TimeTicks& now);
+
+ private:
+  base::TimeTicks fake_now_;
+};
+
+// Mocks the URLRequestThrottlerHeaderInterface, allowing testing code to
+// pass arbitrary fake headers to the throttling code.
+class MockURLRequestThrottlerHeaderAdapter
+    : public URLRequestThrottlerHeaderInterface {
+ public:
+  // Constructs mock response headers with the given |response_code| and no
+  // custom response header fields.
+  explicit MockURLRequestThrottlerHeaderAdapter(int response_code);
+
+  // Constructs mock response headers with the given |response_code| and
+  // with a custom-retry header value |retry_value| if it is non-empty, and
+  // a custom opt-out header value |opt_out_value| if it is non-empty.
+  MockURLRequestThrottlerHeaderAdapter(const std::string& retry_value,
+                                       const std::string& opt_out_value,
+                                       int response_code);
+  virtual ~MockURLRequestThrottlerHeaderAdapter();
+
+  // URLRequestThrottlerHeaderInterface overrides.
+  virtual std::string GetNormalizedValue(const std::string& key) const OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+
+ private:
+  std::string fake_retry_value_;
+  std::string fake_opt_out_value_;
+  int fake_response_code_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockURLRequestThrottlerHeaderAdapter);
+};
+
+}  // namespace net
+
+#endif  // NET_URL_REQUEST_URL_REQUEST_THROTTLER_TEST_SUPPORT_H_
diff --git a/src/net/url_request/url_request_throttler_unittest.cc b/src/net/url_request/url_request_throttler_unittest.cc
new file mode 100644
index 0000000..221d0c8
--- /dev/null
+++ b/src/net/url_request/url_request_throttler_unittest.cc
@@ -0,0 +1,563 @@
+// 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 "net/url_request/url_request_throttler_manager.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_samples.h"
+#include "base/metrics/statistics_recorder.h"
+#include "base/pickle.h"
+#include "base/stl_util.h"
+#include "base/stringprintf.h"
+#include "base/string_number_conversions.h"
+#include "base/time.h"
+#include "net/base/load_flags.h"
+#include "net/base/test_completion_callback.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_test_util.h"
+#include "net/url_request/url_request_throttler_header_interface.h"
+#include "net/url_request/url_request_throttler_test_support.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::TimeDelta;
+using base::TimeTicks;
+
+namespace net {
+
+namespace {
+
+using base::Histogram;
+using base::HistogramSamples;
+using base::StatisticsRecorder;
+
+class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
+ public:
+  explicit MockURLRequestThrottlerEntry(
+      net::URLRequestThrottlerManager* manager)
+      : net::URLRequestThrottlerEntry(manager, ""),
+        mock_backoff_entry_(&backoff_policy_) {
+    InitPolicy();
+  }
+  MockURLRequestThrottlerEntry(
+      net::URLRequestThrottlerManager* manager,
+      const TimeTicks& exponential_backoff_release_time,
+      const TimeTicks& sliding_window_release_time,
+      const TimeTicks& fake_now)
+      : net::URLRequestThrottlerEntry(manager, ""),
+        fake_time_now_(fake_now),
+        mock_backoff_entry_(&backoff_policy_) {
+    InitPolicy();
+
+    mock_backoff_entry_.set_fake_now(fake_now);
+    set_exponential_backoff_release_time(exponential_backoff_release_time);
+    set_sliding_window_release_time(sliding_window_release_time);
+  }
+
+  void InitPolicy() {
+    // Some tests become flaky if we have jitter.
+    backoff_policy_.jitter_factor = 0.0;
+
+    // This lets us avoid having to make multiple failures initially (this
+    // logic is already tested in the BackoffEntry unit tests).
+    backoff_policy_.num_errors_to_ignore = 0;
+  }
+
+  const BackoffEntry* GetBackoffEntry() const {
+    return &mock_backoff_entry_;
+  }
+
+  BackoffEntry* GetBackoffEntry() {
+    return &mock_backoff_entry_;
+  }
+
+  static bool ExplicitUserRequest(int load_flags) {
+    return URLRequestThrottlerEntry::ExplicitUserRequest(load_flags);
+  }
+
+  void ResetToBlank(const TimeTicks& time_now) {
+    fake_time_now_ = time_now;
+    mock_backoff_entry_.set_fake_now(time_now);
+
+    GetBackoffEntry()->Reset();
+    GetBackoffEntry()->SetCustomReleaseTime(time_now);
+    set_sliding_window_release_time(time_now);
+  }
+
+  // Overridden for tests.
+  virtual TimeTicks ImplGetTimeNow() const OVERRIDE { return fake_time_now_; }
+
+  void set_exponential_backoff_release_time(
+      const base::TimeTicks& release_time) {
+    GetBackoffEntry()->SetCustomReleaseTime(release_time);
+  }
+
+  base::TimeTicks sliding_window_release_time() const {
+    return URLRequestThrottlerEntry::sliding_window_release_time();
+  }
+
+  void set_sliding_window_release_time(
+      const base::TimeTicks& release_time) {
+    URLRequestThrottlerEntry::set_sliding_window_release_time(
+        release_time);
+  }
+
+  TimeTicks fake_time_now_;
+  MockBackoffEntry mock_backoff_entry_;
+
+ protected:
+  virtual ~MockURLRequestThrottlerEntry() {}
+};
+
+class MockURLRequestThrottlerManager : public URLRequestThrottlerManager {
+ public:
+  MockURLRequestThrottlerManager() : create_entry_index_(0) {}
+
+  // Method to process the URL using URLRequestThrottlerManager protected
+  // method.
+  std::string DoGetUrlIdFromUrl(const GURL& url) { return GetIdFromUrl(url); }
+
+  // Method to use the garbage collecting method of URLRequestThrottlerManager.
+  void DoGarbageCollectEntries() { GarbageCollectEntries(); }
+
+  // Returns the number of entries in the map.
+  int GetNumberOfEntries() const { return GetNumberOfEntriesForTests(); }
+
+  void CreateEntry(bool is_outdated) {
+    TimeTicks time = TimeTicks::Now();
+    if (is_outdated) {
+      time -= TimeDelta::FromMilliseconds(
+          MockURLRequestThrottlerEntry::kDefaultEntryLifetimeMs + 1000);
+    }
+    std::string fake_url_string("http://www.fakeurl.com/");
+    fake_url_string.append(base::IntToString(create_entry_index_++));
+    GURL fake_url(fake_url_string);
+    OverrideEntryForTests(
+        fake_url,
+        new MockURLRequestThrottlerEntry(this, time, TimeTicks::Now(),
+                                         TimeTicks::Now()));
+  }
+
+ private:
+  int create_entry_index_;
+};
+
+struct TimeAndBool {
+  TimeAndBool(const TimeTicks& time_value, bool expected, int line_num) {
+    time = time_value;
+    result = expected;
+    line = line_num;
+  }
+  TimeTicks time;
+  bool result;
+  int line;
+};
+
+struct GurlAndString {
+  GurlAndString(const GURL& url_value,
+                const std::string& expected,
+                int line_num) {
+    url = url_value;
+    result = expected;
+    line = line_num;
+  }
+  GURL url;
+  std::string result;
+  int line;
+};
+
+}  // namespace
+
+class URLRequestThrottlerEntryTest : public testing::Test {
+ protected:
+  URLRequestThrottlerEntryTest() : request_(GURL(), NULL, &context_) {
+  }
+
+  virtual void SetUp();
+  virtual void TearDown();
+
+  // After calling this function, histogram snapshots in |samples_| contain
+  // only the delta caused by the test case currently running.
+  void CalculateHistogramDeltas();
+
+  TimeTicks now_;
+  MockURLRequestThrottlerManager manager_;  // Dummy object, not used.
+  scoped_refptr<MockURLRequestThrottlerEntry> entry_;
+
+  std::map<std::string, HistogramSamples*> original_samples_;
+  std::map<std::string, HistogramSamples*> samples_;
+
+  TestURLRequestContext context_;
+  TestURLRequest request_;
+};
+
+// List of all histograms we care about in these unit tests.
+const char* kHistogramNames[] = {
+  "Throttling.FailureCountAtSuccess",
+  "Throttling.PerceivedDowntime",
+  "Throttling.RequestThrottled",
+  "Throttling.SiteOptedOut",
+};
+
+void URLRequestThrottlerEntryTest::SetUp() {
+  request_.set_load_flags(0);
+
+  now_ = TimeTicks::Now();
+  entry_ = new MockURLRequestThrottlerEntry(&manager_);
+  entry_->ResetToBlank(now_);
+
+  for (size_t i = 0; i < arraysize(kHistogramNames); ++i) {
+    // Must retrieve original samples for each histogram for comparison
+    // as other tests may affect them.
+    const char* name = kHistogramNames[i];
+    Histogram* histogram = StatisticsRecorder::FindHistogram(name);
+    if (histogram) {
+      original_samples_[name] = histogram->SnapshotSamples().release();
+    } else {
+      original_samples_[name] = NULL;
+    }
+  }
+}
+
+void URLRequestThrottlerEntryTest::TearDown() {
+  STLDeleteValues(&original_samples_);
+  STLDeleteValues(&samples_);
+}
+
+void URLRequestThrottlerEntryTest::CalculateHistogramDeltas() {
+  for (size_t i = 0; i < arraysize(kHistogramNames); ++i) {
+    const char* name = kHistogramNames[i];
+    HistogramSamples* original = original_samples_[name];
+
+    Histogram* histogram = StatisticsRecorder::FindHistogram(name);
+    if (histogram) {
+      ASSERT_EQ(Histogram::kUmaTargetedHistogramFlag, histogram->flags());
+
+      scoped_ptr<HistogramSamples> samples(histogram->SnapshotSamples());
+      if (original)
+        samples->Subtract(*original);
+      samples_[name] = samples.release();
+    }
+  }
+
+  // Ensure we don't accidentally use the originals in our tests.
+  STLDeleteValues(&original_samples_);
+  original_samples_.clear();
+}
+
+std::ostream& operator<<(std::ostream& out, const base::TimeTicks& time) {
+  return out << time.ToInternalValue();
+}
+
+TEST_F(URLRequestThrottlerEntryTest, InterfaceDuringExponentialBackoff) {
+  entry_->set_exponential_backoff_release_time(
+      entry_->fake_time_now_ + TimeDelta::FromMilliseconds(1));
+  EXPECT_TRUE(entry_->ShouldRejectRequest(request_));
+
+  // Also end-to-end test the load flags exceptions.
+  request_.set_load_flags(LOAD_MAYBE_USER_GESTURE);
+  EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
+
+  CalculateHistogramDeltas();
+  ASSERT_EQ(1, samples_["Throttling.RequestThrottled"]->GetCount(0));
+  ASSERT_EQ(1, samples_["Throttling.RequestThrottled"]->GetCount(1));
+}
+
+TEST_F(URLRequestThrottlerEntryTest, InterfaceNotDuringExponentialBackoff) {
+  entry_->set_exponential_backoff_release_time(entry_->fake_time_now_);
+  EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
+  entry_->set_exponential_backoff_release_time(
+      entry_->fake_time_now_ - TimeDelta::FromMilliseconds(1));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
+
+  CalculateHistogramDeltas();
+  ASSERT_EQ(2, samples_["Throttling.RequestThrottled"]->GetCount(0));
+  ASSERT_EQ(0, samples_["Throttling.RequestThrottled"]->GetCount(1));
+}
+
+TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) {
+  MockURLRequestThrottlerHeaderAdapter failure_response(503);
+  entry_->UpdateWithResponse("", &failure_response);
+  EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
+      << "A failure should increase the release_time";
+}
+
+TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccess) {
+  MockURLRequestThrottlerHeaderAdapter success_response(200);
+  entry_->UpdateWithResponse("", &success_response);
+  EXPECT_EQ(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
+      << "A success should not add any delay";
+}
+
+TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccessThenFailure) {
+  MockURLRequestThrottlerHeaderAdapter failure_response(503);
+  MockURLRequestThrottlerHeaderAdapter success_response(200);
+  entry_->UpdateWithResponse("", &success_response);
+  entry_->UpdateWithResponse("", &failure_response);
+  EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
+      << "This scenario should add delay";
+  entry_->UpdateWithResponse("", &success_response);
+}
+
+TEST_F(URLRequestThrottlerEntryTest, IsEntryReallyOutdated) {
+  TimeDelta lifetime = TimeDelta::FromMilliseconds(
+      MockURLRequestThrottlerEntry::kDefaultEntryLifetimeMs);
+  const TimeDelta kFiveMs = TimeDelta::FromMilliseconds(5);
+
+  TimeAndBool test_values[] = {
+      TimeAndBool(now_, false, __LINE__),
+      TimeAndBool(now_ - kFiveMs, false, __LINE__),
+      TimeAndBool(now_ + kFiveMs, false, __LINE__),
+      TimeAndBool(now_ - (lifetime - kFiveMs), false, __LINE__),
+      TimeAndBool(now_ - lifetime, true, __LINE__),
+      TimeAndBool(now_ - (lifetime + kFiveMs), true, __LINE__)};
+
+  for (unsigned int i = 0; i < arraysize(test_values); ++i) {
+    entry_->set_exponential_backoff_release_time(test_values[i].time);
+    EXPECT_EQ(entry_->IsEntryOutdated(), test_values[i].result) <<
+        "Test case #" << i << " line " << test_values[i].line << " failed";
+  }
+}
+
+TEST_F(URLRequestThrottlerEntryTest, MaxAllowedBackoff) {
+  for (int i = 0; i < 30; ++i) {
+    MockURLRequestThrottlerHeaderAdapter response_adapter(503);
+    entry_->UpdateWithResponse("", &response_adapter);
+  }
+
+  TimeDelta delay = entry_->GetExponentialBackoffReleaseTime() - now_;
+  EXPECT_EQ(delay.InMilliseconds(),
+            MockURLRequestThrottlerEntry::kDefaultMaximumBackoffMs);
+}
+
+TEST_F(URLRequestThrottlerEntryTest, MalformedContent) {
+  MockURLRequestThrottlerHeaderAdapter response_adapter(503);
+  for (int i = 0; i < 5; ++i)
+    entry_->UpdateWithResponse("", &response_adapter);
+
+  TimeTicks release_after_failures = entry_->GetExponentialBackoffReleaseTime();
+
+  // Inform the entry that a response body was malformed, which is supposed to
+  // increase the back-off time.  Note that we also submit a successful
+  // UpdateWithResponse to pair with ReceivedContentWasMalformed() since that
+  // is what happens in practice (if a body is received, then a non-500
+  // response must also have been received).
+  entry_->ReceivedContentWasMalformed(200);
+  MockURLRequestThrottlerHeaderAdapter success_adapter(200);
+  entry_->UpdateWithResponse("", &success_adapter);
+  EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), release_after_failures);
+}
+
+TEST_F(URLRequestThrottlerEntryTest, SlidingWindow) {
+  int max_send = URLRequestThrottlerEntry::kDefaultMaxSendThreshold;
+  int sliding_window =
+      URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs;
+
+  TimeTicks time_1 = entry_->fake_time_now_ +
+      TimeDelta::FromMilliseconds(sliding_window / 3);
+  TimeTicks time_2 = entry_->fake_time_now_ +
+      TimeDelta::FromMilliseconds(2 * sliding_window / 3);
+  TimeTicks time_3 = entry_->fake_time_now_ +
+      TimeDelta::FromMilliseconds(sliding_window);
+  TimeTicks time_4 = entry_->fake_time_now_ +
+      TimeDelta::FromMilliseconds(sliding_window + 2 * sliding_window / 3);
+
+  entry_->set_exponential_backoff_release_time(time_1);
+
+  for (int i = 0; i < max_send / 2; ++i) {
+    EXPECT_EQ(2 * sliding_window / 3,
+              entry_->ReserveSendingTimeForNextRequest(time_2));
+  }
+  EXPECT_EQ(time_2, entry_->sliding_window_release_time());
+
+  entry_->fake_time_now_ = time_3;
+
+  for (int i = 0; i < (max_send + 1) / 2; ++i)
+    EXPECT_EQ(0, entry_->ReserveSendingTimeForNextRequest(TimeTicks()));
+
+  EXPECT_EQ(time_4, entry_->sliding_window_release_time());
+}
+
+TEST_F(URLRequestThrottlerEntryTest, ExplicitUserRequest) {
+  ASSERT_FALSE(MockURLRequestThrottlerEntry::ExplicitUserRequest(0));
+  ASSERT_TRUE(MockURLRequestThrottlerEntry::ExplicitUserRequest(
+      LOAD_MAYBE_USER_GESTURE));
+  ASSERT_FALSE(MockURLRequestThrottlerEntry::ExplicitUserRequest(
+      ~LOAD_MAYBE_USER_GESTURE));
+}
+
+class URLRequestThrottlerManagerTest : public testing::Test {
+ protected:
+  URLRequestThrottlerManagerTest()
+      : request_(GURL(), NULL, &context_) {
+  }
+
+  virtual void SetUp() {
+    request_.set_load_flags(0);
+  }
+
+  // context_ must be declared before request_.
+  TestURLRequestContext context_;
+  TestURLRequest request_;
+};
+
+TEST_F(URLRequestThrottlerManagerTest, IsUrlStandardised) {
+  MockURLRequestThrottlerManager manager;
+  GurlAndString test_values[] = {
+      GurlAndString(GURL("http://www.example.com"),
+                    std::string("http://www.example.com/"),
+                    __LINE__),
+      GurlAndString(GURL("http://www.Example.com"),
+                    std::string("http://www.example.com/"),
+                    __LINE__),
+      GurlAndString(GURL("http://www.ex4mple.com/Pr4c71c41"),
+                    std::string("http://www.ex4mple.com/pr4c71c41"),
+                    __LINE__),
+      GurlAndString(GURL("http://www.example.com/0/token/false"),
+                    std::string("http://www.example.com/0/token/false"),
+                    __LINE__),
+      GurlAndString(GURL("http://www.example.com/index.php?code=javascript"),
+                    std::string("http://www.example.com/index.php"),
+                    __LINE__),
+      GurlAndString(GURL("http://www.example.com/index.php?code=1#superEntry"),
+                    std::string("http://www.example.com/index.php"),
+                    __LINE__),
+      GurlAndString(GURL("http://www.example.com/index.php#superEntry"),
+                    std::string("http://www.example.com/index.php"),
+                    __LINE__),
+      GurlAndString(GURL("http://www.example.com:1234/"),
+                    std::string("http://www.example.com:1234/"),
+                    __LINE__)};
+
+  for (unsigned int i = 0; i < arraysize(test_values); ++i) {
+    std::string temp = manager.DoGetUrlIdFromUrl(test_values[i].url);
+    EXPECT_EQ(temp, test_values[i].result) <<
+        "Test case #" << i << " line " << test_values[i].line << " failed";
+  }
+}
+
+TEST_F(URLRequestThrottlerManagerTest, AreEntriesBeingCollected) {
+  MockURLRequestThrottlerManager manager;
+
+  manager.CreateEntry(true);  // true = Entry is outdated.
+  manager.CreateEntry(true);
+  manager.CreateEntry(true);
+  manager.DoGarbageCollectEntries();
+  EXPECT_EQ(0, manager.GetNumberOfEntries());
+
+  manager.CreateEntry(false);
+  manager.CreateEntry(false);
+  manager.CreateEntry(false);
+  manager.CreateEntry(true);
+  manager.DoGarbageCollectEntries();
+  EXPECT_EQ(3, manager.GetNumberOfEntries());
+}
+
+TEST_F(URLRequestThrottlerManagerTest, IsHostBeingRegistered) {
+  MockURLRequestThrottlerManager manager;
+
+  manager.RegisterRequestUrl(GURL("http://www.example.com/"));
+  manager.RegisterRequestUrl(GURL("http://www.google.com/"));
+  manager.RegisterRequestUrl(GURL("http://www.google.com/index/0"));
+  manager.RegisterRequestUrl(GURL("http://www.google.com/index/0?code=1"));
+  manager.RegisterRequestUrl(GURL("http://www.google.com/index/0#lolsaure"));
+
+  EXPECT_EQ(3, manager.GetNumberOfEntries());
+}
+
+void ExpectEntryAllowsAllOnErrorIfOptedOut(
+    net::URLRequestThrottlerEntryInterface* entry,
+    bool opted_out,
+    const URLRequest& request) {
+  EXPECT_FALSE(entry->ShouldRejectRequest(request));
+  MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
+  for (int i = 0; i < 10; ++i) {
+    // Host doesn't really matter in this scenario so we skip it.
+    entry->UpdateWithResponse("", &failure_adapter);
+  }
+  EXPECT_NE(opted_out, entry->ShouldRejectRequest(request));
+
+  if (opted_out) {
+    // We're not mocking out GetTimeNow() in this scenario
+    // so add a 100 ms buffer to avoid flakiness (that should always
+    // give enough time to get from the TimeTicks::Now() call here
+    // to the TimeTicks::Now() call in the entry class).
+    EXPECT_GT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
+              entry->GetExponentialBackoffReleaseTime());
+  } else {
+    // As above, add 100 ms.
+    EXPECT_LT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
+              entry->GetExponentialBackoffReleaseTime());
+  }
+}
+
+TEST_F(URLRequestThrottlerManagerTest, OptOutHeader) {
+  MockURLRequestThrottlerManager manager;
+  scoped_refptr<net::URLRequestThrottlerEntryInterface> entry =
+      manager.RegisterRequestUrl(GURL("http://www.google.com/yodude"));
+
+  // Fake a response with the opt-out header.
+  MockURLRequestThrottlerHeaderAdapter response_adapter(
+      "",
+      MockURLRequestThrottlerEntry::kExponentialThrottlingDisableValue,
+      200);
+  entry->UpdateWithResponse("www.google.com", &response_adapter);
+
+  // Ensure that the same entry on error always allows everything.
+  ExpectEntryAllowsAllOnErrorIfOptedOut(entry, true, request_);
+
+  // Ensure that a freshly created entry (for a different URL on an
+  // already opted-out host) also gets "always allow" behavior.
+  scoped_refptr<net::URLRequestThrottlerEntryInterface> other_entry =
+      manager.RegisterRequestUrl(GURL("http://www.google.com/bingobob"));
+  ExpectEntryAllowsAllOnErrorIfOptedOut(other_entry, true, request_);
+
+  // Fake a response with the opt-out header incorrectly specified.
+  scoped_refptr<net::URLRequestThrottlerEntryInterface> no_opt_out_entry =
+      manager.RegisterRequestUrl(GURL("http://www.nike.com/justdoit"));
+  MockURLRequestThrottlerHeaderAdapter wrong_adapter("", "yesplease", 200);
+  no_opt_out_entry->UpdateWithResponse("www.nike.com", &wrong_adapter);
+  ExpectEntryAllowsAllOnErrorIfOptedOut(no_opt_out_entry, false, request_);
+
+  // A localhost entry should always be opted out.
+  scoped_refptr<net::URLRequestThrottlerEntryInterface> localhost_entry =
+      manager.RegisterRequestUrl(GURL("http://localhost/hello"));
+  ExpectEntryAllowsAllOnErrorIfOptedOut(localhost_entry, true, request_);
+}
+
+TEST_F(URLRequestThrottlerManagerTest, ClearOnNetworkChange) {
+  for (int i = 0; i < 3; ++i) {
+    MockURLRequestThrottlerManager manager;
+    scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_before =
+        manager.RegisterRequestUrl(GURL("http://www.example.com/"));
+    MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
+    for (int j = 0; j < 10; ++j) {
+      // Host doesn't really matter in this scenario so we skip it.
+      entry_before->UpdateWithResponse("", &failure_adapter);
+    }
+    EXPECT_TRUE(entry_before->ShouldRejectRequest(request_));
+
+    switch (i) {
+      case 0:
+        manager.OnIPAddressChanged();
+        break;
+      case 1:
+        manager.OnConnectionTypeChanged(
+            net::NetworkChangeNotifier::CONNECTION_UNKNOWN);
+        break;
+      case 2:
+        manager.OnConnectionTypeChanged(
+            net::NetworkChangeNotifier::CONNECTION_NONE);
+        break;
+      default:
+        FAIL();
+    }
+
+    scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_after =
+        manager.RegisterRequestUrl(GURL("http://www.example.com/"));
+    EXPECT_FALSE(entry_after->ShouldRejectRequest(request_));
+  }
+}
+
+}  // namespace net
diff --git a/src/net/url_request/url_request_unittest.cc b/src/net/url_request/url_request_unittest.cc
new file mode 100644
index 0000000..fb17ec9
--- /dev/null
+++ b/src/net/url_request/url_request_unittest.cc
@@ -0,0 +1,5197 @@
+// 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 "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#include <shlobj.h>
+#endif
+
+#include <algorithm>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/file_util.h"
+#include "base/format_macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop.h"
+#include "base/path_service.h"
+#include "base/process_util.h"
+#include "base/string_number_conversions.h"
+#include "base/string_piece.h"
+#include "base/string_split.h"
+#include "base/string_util.h"
+#include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
+#include "net/base/cert_test_util.h"
+#include "net/base/ev_root_ca_metadata.h"
+#include "net/base/load_flags.h"
+#include "net/base/mock_host_resolver.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_log.h"
+#include "net/base/net_log_unittest.h"
+#include "net/base/net_module.h"
+#include "net/base/net_util.h"
+#include "net/base/ssl_connection_status_flags.h"
+#include "net/base/test_data_directory.h"
+#include "net/base/test_root_certs.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_data_stream.h"
+#include "net/base/upload_file_element_reader.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/cookies/cookie_store_test_helpers.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/ftp/ftp_network_layer.h"
+#include "net/http/http_cache.h"
+#include "net/http/http_network_layer.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
+#include "net/ocsp/nss_ocsp.h"
+#include "net/proxy/proxy_service.h"
+#include "net/socket/ssl_client_socket.h"
+#include "net/test/test_server.h"
+#include "net/url_request/ftp_protocol_handler.h"
+#include "net/url_request/static_http_user_agent_settings.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_file_dir_job.h"
+#include "net/url_request/url_request_http_job.h"
+#include "net/url_request/url_request_job_factory_impl.h"
+#include "net/url_request/url_request_redirect_job.h"
+#include "net/url_request/url_request_test_job.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+#if defined(OS_WIN)
+#include "base/win/scoped_com_initializer.h"
+#include "base/win/windows_version.h"
+#endif
+
+using base::Time;
+
+namespace net {
+
+namespace {
+
+const string16 kChrome(ASCIIToUTF16("chrome"));
+const string16 kSecret(ASCIIToUTF16("secret"));
+const string16 kUser(ASCIIToUTF16("user"));
+
+base::StringPiece TestNetResourceProvider(int key) {
+  return "header";
+}
+
+// Do a case-insensitive search through |haystack| for |needle|.
+bool ContainsString(const std::string& haystack, const char* needle) {
+  std::string::const_iterator it =
+      std::search(haystack.begin(),
+                  haystack.end(),
+                  needle,
+                  needle + strlen(needle),
+                  base::CaseInsensitiveCompare<char>());
+  return it != haystack.end();
+}
+
+void FillBuffer(char* buffer, size_t len) {
+  static bool called = false;
+  if (!called) {
+    called = true;
+    int seed = static_cast<int>(Time::Now().ToInternalValue());
+    srand(seed);
+  }
+
+  for (size_t i = 0; i < len; i++) {
+    buffer[i] = static_cast<char>(rand());
+    if (!buffer[i])
+      buffer[i] = 'g';
+  }
+}
+
+UploadDataStream* CreateSimpleUploadData(const char* data) {
+  scoped_ptr<UploadElementReader> reader(
+      new UploadBytesElementReader(data, strlen(data)));
+  return UploadDataStream::CreateWithReader(reader.Pass(), 0);
+}
+
+// Verify that the SSLInfo of a successful SSL connection has valid values.
+void CheckSSLInfo(const SSLInfo& ssl_info) {
+  // Allow ChromeFrame fake SSLInfo to get through.
+  if (ssl_info.cert.get() &&
+      ssl_info.cert.get()->issuer().GetDisplayName() == "Chrome Internal") {
+    // -1 means unknown.
+    EXPECT_EQ(ssl_info.security_bits, -1);
+    return;
+  }
+
+  // -1 means unknown.  0 means no encryption.
+  EXPECT_GT(ssl_info.security_bits, 0);
+
+  // The cipher suite TLS_NULL_WITH_NULL_NULL (0) must not be negotiated.
+  int cipher_suite = SSLConnectionStatusToCipherSuite(
+      ssl_info.connection_status);
+  EXPECT_NE(0, cipher_suite);
+}
+
+bool FingerprintsEqual(const HashValueVector& a, const HashValueVector& b) {
+  size_t size = a.size();
+
+  if (size != b.size())
+    return false;
+
+  for (size_t i = 0; i < size; ++i) {
+    if (!a[i].Equals(b[i]))
+      return false;
+  }
+
+  return true;
+}
+
+// A network delegate that allows the user to choose a subset of request stages
+// to block in. When blocking, the delegate can do one of the following:
+//  * synchronously return a pre-specified error code, or
+//  * asynchronously return that value via an automatically called callback,
+//    or
+//  * block and wait for the user to do a callback.
+// Additionally, the user may also specify a redirect URL -- then each request
+// with the current URL different from the redirect target will be redirected
+// to that target, in the on-before-URL-request stage, independent of whether
+// the delegate blocks in ON_BEFORE_URL_REQUEST or not.
+class BlockingNetworkDelegate : public TestNetworkDelegate {
+ public:
+  // Stages in which the delegate can block.
+  enum Stage {
+    NOT_BLOCKED = 0,
+    ON_BEFORE_URL_REQUEST = 1 << 0,
+    ON_BEFORE_SEND_HEADERS = 1 << 1,
+    ON_HEADERS_RECEIVED = 1 << 2,
+    ON_AUTH_REQUIRED = 1 << 3
+  };
+
+  // Behavior during blocked stages.  During other stages, just
+  // returns net::OK or NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION.
+  enum BlockMode {
+    SYNCHRONOUS,    // No callback, returns specified return values.
+    AUTO_CALLBACK,  // |this| posts a task to run the callback using the
+                    // specified return codes.
+    USER_CALLBACK,  // User takes care of doing a callback.  |retval_| and
+                    // |auth_retval_| are ignored. In every blocking stage the
+                    // message loop is quit.
+  };
+
+  // Creates a delegate which does not block at all.
+  explicit BlockingNetworkDelegate(BlockMode block_mode);
+
+  // For users to trigger a callback returning |response|.
+  // Side-effects: resets |stage_blocked_for_callback_| and stored callbacks.
+  // Only call if |block_mode_| == USER_CALLBACK.
+  void DoCallback(int response);
+  void DoAuthCallback(NetworkDelegate::AuthRequiredResponse response);
+
+  // Setters.
+  void set_retval(int retval) {
+    ASSERT_NE(USER_CALLBACK, block_mode_);
+    ASSERT_NE(ERR_IO_PENDING, retval);
+    ASSERT_NE(OK, retval);
+    retval_ = retval;
+  }
+
+  // If |auth_retval| == AUTH_REQUIRED_RESPONSE_SET_AUTH, then
+  // |auth_credentials_| will be passed with the response.
+  void set_auth_retval(AuthRequiredResponse auth_retval) {
+    ASSERT_NE(USER_CALLBACK, block_mode_);
+    ASSERT_NE(AUTH_REQUIRED_RESPONSE_IO_PENDING, auth_retval);
+    auth_retval_ = auth_retval;
+  }
+  void set_auth_credentials(const AuthCredentials& auth_credentials) {
+    auth_credentials_ = auth_credentials;
+  }
+
+  void set_redirect_url(const GURL& url) {
+    redirect_url_ = url;
+  }
+
+  void set_block_on(int block_on) {
+    block_on_ = block_on;
+  }
+
+  // Allows the user to check in which state did we block.
+  Stage stage_blocked_for_callback() const {
+    EXPECT_EQ(USER_CALLBACK, block_mode_);
+    return stage_blocked_for_callback_;
+  }
+
+ private:
+  void RunCallback(int response, const CompletionCallback& callback);
+  void RunAuthCallback(AuthRequiredResponse response,
+                       const AuthCallback& callback);
+
+  // TestNetworkDelegate implementation.
+  virtual int OnBeforeURLRequest(URLRequest* request,
+                                 const CompletionCallback& callback,
+                                 GURL* new_url) OVERRIDE;
+
+  virtual int OnBeforeSendHeaders(URLRequest* request,
+                                  const CompletionCallback& callback,
+                                  HttpRequestHeaders* headers) OVERRIDE;
+
+  virtual int OnHeadersReceived(
+      URLRequest* request,
+      const CompletionCallback& callback,
+      const HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers) OVERRIDE;
+
+  virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
+      URLRequest* request,
+      const AuthChallengeInfo& auth_info,
+      const AuthCallback& callback,
+      AuthCredentials* credentials) OVERRIDE;
+
+  // Resets the callbacks and |stage_blocked_for_callback_|.
+  void Reset();
+
+  // Checks whether we should block in |stage|. If yes, returns an error code
+  // and optionally sets up callback based on |block_mode_|. If no, returns OK.
+  int MaybeBlockStage(Stage stage, const CompletionCallback& callback);
+
+  // Configuration parameters, can be adjusted by public methods:
+  const BlockMode block_mode_;
+
+  // Values returned on blocking stages when mode is SYNCHRONOUS or
+  // AUTO_CALLBACK. For USER_CALLBACK these are set automatically to IO_PENDING.
+  int retval_;  // To be returned in non-auth stages.
+  AuthRequiredResponse auth_retval_;
+
+  GURL redirect_url_;  // Used if non-empty.
+  int block_on_;  // Bit mask: in which stages to block.
+
+  // |auth_credentials_| will be copied to |*target_auth_credential_| on
+  // callback.
+  AuthCredentials auth_credentials_;
+  AuthCredentials* target_auth_credentials_;
+
+  // Internal variables, not set by not the user:
+  // Last blocked stage waiting for user callback (unused if |block_mode_| !=
+  // USER_CALLBACK).
+  Stage stage_blocked_for_callback_;
+
+  // Callback objects stored during blocking stages.
+  CompletionCallback callback_;
+  AuthCallback auth_callback_;
+
+  base::WeakPtrFactory<BlockingNetworkDelegate> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlockingNetworkDelegate);
+};
+
+BlockingNetworkDelegate::BlockingNetworkDelegate(BlockMode block_mode)
+    : block_mode_(block_mode),
+      retval_(OK),
+      auth_retval_(AUTH_REQUIRED_RESPONSE_NO_ACTION),
+      block_on_(0),
+      target_auth_credentials_(NULL),
+      stage_blocked_for_callback_(NOT_BLOCKED),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+}
+
+void BlockingNetworkDelegate::DoCallback(int response) {
+  ASSERT_EQ(USER_CALLBACK, block_mode_);
+  ASSERT_NE(NOT_BLOCKED, stage_blocked_for_callback_);
+  ASSERT_NE(ON_AUTH_REQUIRED, stage_blocked_for_callback_);
+  CompletionCallback callback = callback_;
+  Reset();
+  RunCallback(response, callback);
+}
+
+void BlockingNetworkDelegate::DoAuthCallback(
+    NetworkDelegate::AuthRequiredResponse response) {
+  ASSERT_EQ(USER_CALLBACK, block_mode_);
+  ASSERT_EQ(ON_AUTH_REQUIRED, stage_blocked_for_callback_);
+  AuthCallback auth_callback = auth_callback_;
+  Reset();
+  RunAuthCallback(response, auth_callback);
+}
+
+void BlockingNetworkDelegate::RunCallback(int response,
+                                          const CompletionCallback& callback) {
+  callback.Run(response);
+}
+
+void BlockingNetworkDelegate::RunAuthCallback(AuthRequiredResponse response,
+                                              const AuthCallback& callback) {
+  if (auth_retval_ == AUTH_REQUIRED_RESPONSE_SET_AUTH) {
+    ASSERT_TRUE(target_auth_credentials_ != NULL);
+    *target_auth_credentials_ = auth_credentials_;
+  }
+  callback.Run(response);
+}
+
+int BlockingNetworkDelegate::OnBeforeURLRequest(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    GURL* new_url) {
+  if (redirect_url_ == request->url())
+    return OK;  // We've already seen this request and redirected elsewhere.
+
+  TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
+
+  if (!redirect_url_.is_empty())
+    *new_url = redirect_url_;
+
+  return MaybeBlockStage(ON_BEFORE_URL_REQUEST, callback);
+}
+
+int BlockingNetworkDelegate::OnBeforeSendHeaders(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    HttpRequestHeaders* headers) {
+  TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers);
+
+  return MaybeBlockStage(ON_BEFORE_SEND_HEADERS, callback);
+}
+
+int BlockingNetworkDelegate::OnHeadersReceived(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    const HttpResponseHeaders* original_response_headers,
+    scoped_refptr<HttpResponseHeaders>* override_response_headers) {
+  TestNetworkDelegate::OnHeadersReceived(
+      request, callback, original_response_headers,
+      override_response_headers);
+
+  return MaybeBlockStage(ON_HEADERS_RECEIVED, callback);
+}
+
+NetworkDelegate::AuthRequiredResponse BlockingNetworkDelegate::OnAuthRequired(
+    URLRequest* request,
+    const AuthChallengeInfo& auth_info,
+    const AuthCallback& callback,
+    AuthCredentials* credentials) {
+  TestNetworkDelegate::OnAuthRequired(request, auth_info, callback,
+                                      credentials);
+  // Check that the user has provided callback for the previous blocked stage.
+  EXPECT_EQ(NOT_BLOCKED, stage_blocked_for_callback_);
+
+  if ((block_on_ & ON_AUTH_REQUIRED) == 0) {
+    return AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  }
+
+  target_auth_credentials_ = credentials;
+
+  switch (block_mode_) {
+    case SYNCHRONOUS:
+      if (auth_retval_ == AUTH_REQUIRED_RESPONSE_SET_AUTH)
+        *target_auth_credentials_ = auth_credentials_;
+      return auth_retval_;
+
+    case AUTO_CALLBACK:
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&BlockingNetworkDelegate::RunAuthCallback,
+                     weak_factory_.GetWeakPtr(), auth_retval_, callback));
+      return AUTH_REQUIRED_RESPONSE_IO_PENDING;
+
+    case USER_CALLBACK:
+      auth_callback_ = callback;
+      stage_blocked_for_callback_ = ON_AUTH_REQUIRED;
+      MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+      return AUTH_REQUIRED_RESPONSE_IO_PENDING;
+  }
+  NOTREACHED();
+  return AUTH_REQUIRED_RESPONSE_NO_ACTION;  // Dummy value.
+}
+
+void BlockingNetworkDelegate::Reset() {
+  EXPECT_NE(NOT_BLOCKED, stage_blocked_for_callback_);
+  stage_blocked_for_callback_ = NOT_BLOCKED;
+  callback_.Reset();
+  auth_callback_.Reset();
+}
+
+int BlockingNetworkDelegate::MaybeBlockStage(
+    BlockingNetworkDelegate::Stage stage,
+    const CompletionCallback& callback) {
+  // Check that the user has provided callback for the previous blocked stage.
+  EXPECT_EQ(NOT_BLOCKED, stage_blocked_for_callback_);
+
+  if ((block_on_ & stage) == 0) {
+    return OK;
+  }
+
+  switch (block_mode_) {
+    case SYNCHRONOUS:
+      EXPECT_NE(OK, retval_);
+      return retval_;
+
+    case AUTO_CALLBACK:
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&BlockingNetworkDelegate::RunCallback,
+                     weak_factory_.GetWeakPtr(), retval_, callback));
+      return ERR_IO_PENDING;
+
+    case USER_CALLBACK:
+      callback_ = callback;
+      stage_blocked_for_callback_ = stage;
+      MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+      return ERR_IO_PENDING;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+class TestURLRequestContextWithProxy : public TestURLRequestContext {
+ public:
+  // Does not own |delegate|.
+  TestURLRequestContextWithProxy(const std::string& proxy,
+                                 NetworkDelegate* delegate)
+      : TestURLRequestContext(true) {
+    context_storage_.set_proxy_service(ProxyService::CreateFixed(proxy));
+    set_network_delegate(delegate);
+    Init();
+  }
+  virtual ~TestURLRequestContextWithProxy() {}
+};
+
+}  // namespace
+
+// Inherit PlatformTest since we require the autorelease pool on Mac OS X.
+class URLRequestTest : public PlatformTest {
+ public:
+  URLRequestTest() : default_context_(true) {
+    default_context_.set_network_delegate(&default_network_delegate_);
+    default_context_.Init();
+  }
+
+  // Adds the TestJobInterceptor to the default context.
+  TestJobInterceptor* AddTestInterceptor() {
+    TestJobInterceptor* interceptor = new TestJobInterceptor();
+    default_context_.set_job_factory(&job_factory_);
+    job_factory_.AddInterceptor(interceptor);
+    return interceptor;
+  }
+
+ protected:
+  TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
+  URLRequestJobFactoryImpl job_factory_;
+  TestURLRequestContext default_context_;
+};
+
+TEST_F(URLRequestTest, AboutBlankTest) {
+  TestDelegate d;
+  {
+    URLRequest r(GURL("about:blank"), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(!r.is_pending());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), 0);
+    EXPECT_EQ("", r.GetSocketAddress().host());
+    EXPECT_EQ(0, r.GetSocketAddress().port());
+  }
+}
+
+TEST_F(URLRequestTest, DataURLImageTest) {
+  TestDelegate d;
+  {
+    // Use our nice little Chrome logo.
+    URLRequest r(GURL(
+        "data:image/png;base64,"
+        "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAADVklEQVQ4jX2TfUwUBBjG3"
+        "w1y+HGcd9dxhXR8T4awOccJGgOSWclHImznLkTlSw0DDQXkrmgYgbUYnlQTqQxIEVxitD"
+        "5UMCATRA1CEEg+Qjw3bWDxIauJv/5oumqs39/P827vnucRmYN0gyF01GI5MpCVdW0gO7t"
+        "vNC+vqSEtbZefk5NuLv1jdJ46p/zw0HeH4+PHr3h7c1mjoV2t5rKzMx1+fg9bAgK6zHq9"
+        "cU5z+LpA3xOtx34+vTeT21onRuzssC3zxbbSwC13d/pFuC7CkIMDxQpF7r/MWq12UctI1"
+        "dWWm99ypqSYmRUBdKem8MkrO/kgaTt1O7YzlpzE5GIVd0WYUqt57yWf2McHTObYPbVD+Z"
+        "wbtlLTVMZ3BW+TnLyXLaWtmEq6WJVbT3HBh3Svj2HQQcm43XwmtoYM6vVKleh0uoWvnzW"
+        "3v3MpidruPTQPf0bia7sJOtBM0ufTWNvus/nkDFHF9ZS+uYVjRUasMeHUmyLYtcklTvzW"
+        "GFZnNOXczThvpKIzjcahSqIzkvDLayDq6D3eOjtBbNUEIZYyqsvj4V4wY92eNJ4IoyhTb"
+        "xXX1T5xsV9tm9r4TQwHLiZw/pdDZJea8TKmsmR/K0uLh/GwnCHghTja6lPhphezPfO5/5"
+        "MrVvMzNaI3+ERHfrFzPKQukrQGI4d/3EFD/3E2mVNYvi4at7CXWREaxZGD+3hg28zD3gV"
+        "Md6q5c8GdosynKmSeRuGzpjyl1/9UDGtPR5HeaKT8Wjo17WXk579BXVUhN64ehF9fhRtq"
+        "/uxxZKzNiZFGD0wRC3NFROZ5mwIPL/96K/rKMMLrIzF9uhHr+/sYH7DAbwlgC4J+R2Z7F"
+        "Ux1qLnV7MGF40smVSoJ/jvHRfYhQeUJd/SnYtGWhPHR0Sz+GE2F2yth0B36Vcz2KpnufB"
+        "JbsysjjW4kblBUiIjiURUWqJY65zxbnTy57GQyH58zgy0QBtTQv5gH15XMdKkYu+TGaJM"
+        "nlm2O34uI4b9tflqp1+QEFGzoW/ulmcofcpkZCYJhDfSpme7QcrHa+Xfji8paEQkTkSfm"
+        "moRWRNZr/F1KfVMjW+IKEnv2FwZfKdzt0BQR6lClcZR0EfEXEfv/G6W9iLiIyCoReV5En"
+        "hORIBHx+ufPj/gLB/zGI/G4Bk0AAAAASUVORK5CYII="),
+        &d,
+        &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(!r.is_pending());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), 911);
+    EXPECT_EQ("", r.GetSocketAddress().host());
+    EXPECT_EQ(0, r.GetSocketAddress().port());
+  }
+}
+
+TEST_F(URLRequestTest, FileTest) {
+  FilePath app_path;
+  PathService::Get(base::FILE_EXE, &app_path);
+  GURL app_url = FilePathToFileURL(app_path);
+
+  TestDelegate d;
+  {
+    URLRequest r(app_url, &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = -1;
+    EXPECT_TRUE(file_util::GetFileSize(app_path, &file_size));
+
+    EXPECT_TRUE(!r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ("", r.GetSocketAddress().host());
+    EXPECT_EQ(0, r.GetSocketAddress().port());
+  }
+}
+
+TEST_F(URLRequestTest, FileTestCancel) {
+  FilePath app_path;
+  PathService::Get(base::FILE_EXE, &app_path);
+  GURL app_url = FilePathToFileURL(app_path);
+
+  TestDelegate d;
+  {
+    URLRequest r(app_url, &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+    r.Cancel();
+  }
+  // Async cancelation should be safe even when URLRequest has been already
+  // destroyed.
+  MessageLoop::current()->RunUntilIdle();
+}
+
+TEST_F(URLRequestTest, FileTestFullSpecifiedRange) {
+  const size_t buffer_size = 4000;
+  scoped_array<char> buffer(new char[buffer_size]);
+  FillBuffer(buffer.get(), buffer_size);
+
+  FilePath temp_path;
+  EXPECT_TRUE(file_util::CreateTemporaryFile(&temp_path));
+  GURL temp_url = FilePathToFileURL(temp_path);
+  EXPECT_TRUE(file_util::WriteFile(temp_path, buffer.get(), buffer_size));
+
+  int64 file_size;
+  EXPECT_TRUE(file_util::GetFileSize(temp_path, &file_size));
+
+  const size_t first_byte_position = 500;
+  const size_t last_byte_position = buffer_size - first_byte_position;
+  const size_t content_length = last_byte_position - first_byte_position + 1;
+  std::string partial_buffer_string(buffer.get() + first_byte_position,
+                                    buffer.get() + last_byte_position + 1);
+
+  TestDelegate d;
+  {
+    URLRequest r(temp_url, &d, &default_context_);
+
+    HttpRequestHeaders headers;
+    headers.SetHeader(HttpRequestHeaders::kRange,
+                      base::StringPrintf(
+                           "bytes=%" PRIuS "-%" PRIuS,
+                           first_byte_position, last_byte_position));
+    r.SetExtraRequestHeaders(headers);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+    EXPECT_TRUE(!r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
+    // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed.
+    EXPECT_TRUE(partial_buffer_string == d.data_received());
+  }
+
+  EXPECT_TRUE(file_util::Delete(temp_path, false));
+}
+
+TEST_F(URLRequestTest, FileTestHalfSpecifiedRange) {
+  const size_t buffer_size = 4000;
+  scoped_array<char> buffer(new char[buffer_size]);
+  FillBuffer(buffer.get(), buffer_size);
+
+  FilePath temp_path;
+  EXPECT_TRUE(file_util::CreateTemporaryFile(&temp_path));
+  GURL temp_url = FilePathToFileURL(temp_path);
+  EXPECT_TRUE(file_util::WriteFile(temp_path, buffer.get(), buffer_size));
+
+  int64 file_size;
+  EXPECT_TRUE(file_util::GetFileSize(temp_path, &file_size));
+
+  const size_t first_byte_position = 500;
+  const size_t last_byte_position = buffer_size - 1;
+  const size_t content_length = last_byte_position - first_byte_position + 1;
+  std::string partial_buffer_string(buffer.get() + first_byte_position,
+                                    buffer.get() + last_byte_position + 1);
+
+  TestDelegate d;
+  {
+    URLRequest r(temp_url, &d, &default_context_);
+
+    HttpRequestHeaders headers;
+    headers.SetHeader(HttpRequestHeaders::kRange,
+                      base::StringPrintf("bytes=%" PRIuS "-",
+                                         first_byte_position));
+    r.SetExtraRequestHeaders(headers);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+    EXPECT_TRUE(!r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
+    // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed.
+    EXPECT_TRUE(partial_buffer_string == d.data_received());
+  }
+
+  EXPECT_TRUE(file_util::Delete(temp_path, false));
+}
+
+TEST_F(URLRequestTest, FileTestMultipleRanges) {
+  const size_t buffer_size = 400000;
+  scoped_array<char> buffer(new char[buffer_size]);
+  FillBuffer(buffer.get(), buffer_size);
+
+  FilePath temp_path;
+  EXPECT_TRUE(file_util::CreateTemporaryFile(&temp_path));
+  GURL temp_url = FilePathToFileURL(temp_path);
+  EXPECT_TRUE(file_util::WriteFile(temp_path, buffer.get(), buffer_size));
+
+  int64 file_size;
+  EXPECT_TRUE(file_util::GetFileSize(temp_path, &file_size));
+
+  TestDelegate d;
+  {
+    URLRequest r(temp_url, &d, &default_context_);
+
+    HttpRequestHeaders headers;
+    headers.SetHeader(HttpRequestHeaders::kRange,
+                      "bytes=0-0,10-200,200-300");
+    r.SetExtraRequestHeaders(headers);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+    EXPECT_TRUE(d.request_failed());
+  }
+
+  EXPECT_TRUE(file_util::Delete(temp_path, false));
+}
+
+TEST_F(URLRequestTest, InvalidUrlTest) {
+  TestDelegate d;
+  {
+    URLRequest r(GURL("invalid url"), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+    EXPECT_TRUE(d.request_failed());
+  }
+}
+
+#if defined(OS_WIN)
+TEST_F(URLRequestTest, ResolveShortcutTest) {
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("net");
+  app_path = app_path.AppendASCII("data");
+  app_path = app_path.AppendASCII("url_request_unittest");
+  app_path = app_path.AppendASCII("with-headers.html");
+
+  std::wstring lnk_path = app_path.value() + L".lnk";
+
+  base::win::ScopedCOMInitializer com_initializer;
+
+  // Temporarily create a shortcut for test
+  IShellLink* shell = NULL;
+  ASSERT_TRUE(SUCCEEDED(CoCreateInstance(
+      CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink,
+      reinterpret_cast<LPVOID*>(&shell))));
+  IPersistFile* persist = NULL;
+  ASSERT_TRUE(SUCCEEDED(shell->QueryInterface(
+      IID_IPersistFile, reinterpret_cast<LPVOID*>(&persist))));
+  EXPECT_TRUE(SUCCEEDED(shell->SetPath(app_path.value().c_str())));
+  EXPECT_TRUE(SUCCEEDED(shell->SetDescription(L"ResolveShortcutTest")));
+  EXPECT_TRUE(SUCCEEDED(persist->Save(lnk_path.c_str(), TRUE)));
+  if (persist)
+    persist->Release();
+  if (shell)
+    shell->Release();
+
+  TestDelegate d;
+  {
+    URLRequest r(FilePathToFileURL(FilePath(lnk_path)), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    WIN32_FILE_ATTRIBUTE_DATA data;
+    GetFileAttributesEx(app_path.value().c_str(),
+                        GetFileExInfoStandard, &data);
+    HANDLE file = CreateFile(app_path.value().c_str(), GENERIC_READ,
+                             FILE_SHARE_READ, NULL, OPEN_EXISTING,
+                             FILE_ATTRIBUTE_NORMAL, NULL);
+    EXPECT_NE(INVALID_HANDLE_VALUE, file);
+    scoped_array<char> buffer(new char[data.nFileSizeLow]);
+    DWORD read_size;
+    BOOL result;
+    result = ReadFile(file, buffer.get(), data.nFileSizeLow,
+                      &read_size, NULL);
+    std::string content(buffer.get(), read_size);
+    CloseHandle(file);
+
+    EXPECT_TRUE(!r.is_pending());
+    EXPECT_EQ(1, d.received_redirect_count());
+    EXPECT_EQ(content, d.data_received());
+  }
+
+  // Clean the shortcut
+  DeleteFile(lnk_path.c_str());
+}
+#endif  // defined(OS_WIN)
+
+TEST_F(URLRequestTest, FileDirCancelTest) {
+  // Put in mock resource provider.
+  NetModule::SetResourceProvider(TestNetResourceProvider);
+
+  TestDelegate d;
+  {
+    FilePath file_path;
+    PathService::Get(base::DIR_SOURCE_ROOT, &file_path);
+    file_path = file_path.Append(FILE_PATH_LITERAL("net"));
+    file_path = file_path.Append(FILE_PATH_LITERAL("data"));
+
+    URLRequest req(FilePathToFileURL(file_path), &d, &default_context_);
+    req.Start();
+    EXPECT_TRUE(req.is_pending());
+
+    d.set_cancel_in_received_data_pending(true);
+
+    MessageLoop::current()->Run();
+  }
+
+  // Take out mock resource provider.
+  NetModule::SetResourceProvider(NULL);
+}
+
+TEST_F(URLRequestTest, FileDirRedirectNoCrash) {
+  // There is an implicit redirect when loading a file path that matches a
+  // directory and does not end with a slash.  Ensure that following such
+  // redirects does not crash.  See http://crbug.com/18686.
+
+  FilePath path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &path);
+  path = path.Append(FILE_PATH_LITERAL("net"));
+  path = path.Append(FILE_PATH_LITERAL("data"));
+  path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+
+  TestDelegate d;
+  URLRequest req(FilePathToFileURL(path), &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  ASSERT_EQ(1, d.received_redirect_count());
+  ASSERT_LT(0, d.bytes_received());
+  ASSERT_FALSE(d.request_failed());
+  ASSERT_TRUE(req.status().is_success());
+}
+
+#if defined(OS_WIN)
+// Don't accept the url "file:///" on windows. See http://crbug.com/1474.
+TEST_F(URLRequestTest, FileDirRedirectSingleSlash) {
+  TestDelegate d;
+  URLRequest req(GURL("file:///"), &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  ASSERT_EQ(1, d.received_redirect_count());
+  ASSERT_FALSE(req.status().is_success());
+}
+#endif
+
+// Custom URLRequestJobs for use with interceptor tests
+class RestartTestJob : public URLRequestTestJob {
+ public:
+  RestartTestJob(URLRequest* request, NetworkDelegate* network_delegate)
+    : URLRequestTestJob(request, network_delegate, true) {}
+ protected:
+  virtual void StartAsync() {
+    this->NotifyRestartRequired();
+  }
+ private:
+  ~RestartTestJob() {}
+};
+
+class CancelTestJob : public URLRequestTestJob {
+ public:
+  explicit CancelTestJob(URLRequest* request, NetworkDelegate* network_delegate)
+    : URLRequestTestJob(request, network_delegate, true) {}
+ protected:
+  virtual void StartAsync() {
+    request_->Cancel();
+  }
+ private:
+  ~CancelTestJob() {}
+};
+
+class CancelThenRestartTestJob : public URLRequestTestJob {
+ public:
+  explicit CancelThenRestartTestJob(URLRequest* request,
+                                    NetworkDelegate* network_delegate)
+      : URLRequestTestJob(request, network_delegate, true) {
+  }
+ protected:
+  virtual void StartAsync() {
+    request_->Cancel();
+    this->NotifyRestartRequired();
+  }
+ private:
+  ~CancelThenRestartTestJob() {}
+};
+
+// An Interceptor for use with interceptor tests
+class TestInterceptor : URLRequest::Interceptor {
+ public:
+  TestInterceptor()
+      : intercept_main_request_(false), restart_main_request_(false),
+        cancel_main_request_(false), cancel_then_restart_main_request_(false),
+        simulate_main_network_error_(false),
+        intercept_redirect_(false), cancel_redirect_request_(false),
+        intercept_final_response_(false), cancel_final_request_(false),
+        did_intercept_main_(false), did_restart_main_(false),
+        did_cancel_main_(false), did_cancel_then_restart_main_(false),
+        did_simulate_error_main_(false),
+        did_intercept_redirect_(false), did_cancel_redirect_(false),
+        did_intercept_final_(false), did_cancel_final_(false) {
+    URLRequest::Deprecated::RegisterRequestInterceptor(this);
+  }
+
+  ~TestInterceptor() {
+    URLRequest::Deprecated::UnregisterRequestInterceptor(this);
+  }
+
+  virtual URLRequestJob* MaybeIntercept(URLRequest* request,
+                                        NetworkDelegate* network_delegate) {
+    if (restart_main_request_) {
+      restart_main_request_ = false;
+      did_restart_main_ = true;
+      return new RestartTestJob(request, network_delegate);
+    }
+    if (cancel_main_request_) {
+      cancel_main_request_ = false;
+      did_cancel_main_ = true;
+      return new CancelTestJob(request, network_delegate);
+    }
+    if (cancel_then_restart_main_request_) {
+      cancel_then_restart_main_request_ = false;
+      did_cancel_then_restart_main_ = true;
+      return new CancelThenRestartTestJob(request, network_delegate);
+    }
+    if (simulate_main_network_error_) {
+      simulate_main_network_error_ = false;
+      did_simulate_error_main_ = true;
+      // will error since the requeted url is not one of its canned urls
+      return new URLRequestTestJob(request, network_delegate, true);
+    }
+    if (!intercept_main_request_)
+      return NULL;
+    intercept_main_request_ = false;
+    did_intercept_main_ = true;
+    return new URLRequestTestJob(request,
+                                 network_delegate,
+                                 main_headers_,
+                                 main_data_,
+                                 true);
+  }
+
+  virtual URLRequestJob* MaybeInterceptRedirect(
+      URLRequest* request,
+      NetworkDelegate* network_delegate,
+      const GURL& location) {
+    if (cancel_redirect_request_) {
+      cancel_redirect_request_ = false;
+      did_cancel_redirect_ = true;
+      return new CancelTestJob(request, network_delegate);
+    }
+    if (!intercept_redirect_)
+      return NULL;
+    intercept_redirect_ = false;
+    did_intercept_redirect_ = true;
+    return new URLRequestTestJob(request,
+                                 network_delegate,
+                                 redirect_headers_,
+                                 redirect_data_,
+                                 true);
+  }
+
+  virtual URLRequestJob* MaybeInterceptResponse(
+      URLRequest* request, NetworkDelegate* network_delegate) {
+    if (cancel_final_request_) {
+      cancel_final_request_ = false;
+      did_cancel_final_ = true;
+      return new CancelTestJob(request, network_delegate);
+    }
+    if (!intercept_final_response_)
+      return NULL;
+    intercept_final_response_ = false;
+    did_intercept_final_ = true;
+    return new URLRequestTestJob(request,
+                                 network_delegate,
+                                 final_headers_,
+                                 final_data_,
+                                 true);
+  }
+
+  // Whether to intercept the main request, and if so the response to return.
+  bool intercept_main_request_;
+  std::string main_headers_;
+  std::string main_data_;
+
+  // Other actions we take at MaybeIntercept time
+  bool restart_main_request_;
+  bool cancel_main_request_;
+  bool cancel_then_restart_main_request_;
+  bool simulate_main_network_error_;
+
+  // Whether to intercept redirects, and if so the response to return.
+  bool intercept_redirect_;
+  std::string redirect_headers_;
+  std::string redirect_data_;
+
+  // Other actions we can take at MaybeInterceptRedirect time
+  bool cancel_redirect_request_;
+
+  // Whether to intercept final response, and if so the response to return.
+  bool intercept_final_response_;
+  std::string final_headers_;
+  std::string final_data_;
+
+  // Other actions we can take at MaybeInterceptResponse time
+  bool cancel_final_request_;
+
+  // If we did something or not
+  bool did_intercept_main_;
+  bool did_restart_main_;
+  bool did_cancel_main_;
+  bool did_cancel_then_restart_main_;
+  bool did_simulate_error_main_;
+  bool did_intercept_redirect_;
+  bool did_cancel_redirect_;
+  bool did_intercept_final_;
+  bool did_cancel_final_;
+
+  // Static getters for canned response header and data strings
+
+  static std::string ok_data() {
+    return URLRequestTestJob::test_data_1();
+  }
+
+  static std::string ok_headers() {
+    return URLRequestTestJob::test_headers();
+  }
+
+  static std::string redirect_data() {
+    return std::string();
+  }
+
+  static std::string redirect_headers() {
+    return URLRequestTestJob::test_redirect_headers();
+  }
+
+  static std::string error_data() {
+    return std::string("ohhh nooooo mr. bill!");
+  }
+
+  static std::string error_headers() {
+    return URLRequestTestJob::test_error_headers();
+  }
+};
+
+TEST_F(URLRequestTest, Intercept) {
+  TestInterceptor interceptor;
+
+  // intercept the main request and respond with a simple response
+  interceptor.intercept_main_request_ = true;
+  interceptor.main_headers_ = TestInterceptor::ok_headers();
+  interceptor.main_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  base::SupportsUserData::Data* user_data0 = new base::SupportsUserData::Data();
+  base::SupportsUserData::Data* user_data1 = new base::SupportsUserData::Data();
+  base::SupportsUserData::Data* user_data2 = new base::SupportsUserData::Data();
+  req.SetUserData(NULL, user_data0);
+  req.SetUserData(&user_data1, user_data1);
+  req.SetUserData(&user_data2, user_data2);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Make sure we can retrieve our specific user data
+  EXPECT_EQ(user_data0, req.GetUserData(NULL));
+  EXPECT_EQ(user_data1, req.GetUserData(&user_data1));
+  EXPECT_EQ(user_data2, req.GetUserData(&user_data2));
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_intercept_main_);
+
+  // Check we got one good response
+  EXPECT_TRUE(req.status().is_success());
+  EXPECT_EQ(200, req.response_headers()->response_code());
+  EXPECT_EQ(TestInterceptor::ok_data(), d.data_received());
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_EQ(0, d.received_redirect_count());
+}
+
+TEST_F(URLRequestTest, InterceptRedirect) {
+  TestInterceptor interceptor;
+
+  // intercept the main request and respond with a redirect
+  interceptor.intercept_main_request_ = true;
+  interceptor.main_headers_ = TestInterceptor::redirect_headers();
+  interceptor.main_data_ = TestInterceptor::redirect_data();
+
+  // intercept that redirect and respond a final OK response
+  interceptor.intercept_redirect_ = true;
+  interceptor.redirect_headers_ =  TestInterceptor::ok_headers();
+  interceptor.redirect_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_intercept_main_);
+  EXPECT_TRUE(interceptor.did_intercept_redirect_);
+
+  // Check we got one good response
+  EXPECT_TRUE(req.status().is_success());
+  if (req.status().is_success()) {
+    EXPECT_EQ(200, req.response_headers()->response_code());
+  }
+  EXPECT_EQ(TestInterceptor::ok_data(), d.data_received());
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_EQ(0, d.received_redirect_count());
+}
+
+TEST_F(URLRequestTest, InterceptServerError) {
+  TestInterceptor interceptor;
+
+  // intercept the main request to generate a server error response
+  interceptor.intercept_main_request_ = true;
+  interceptor.main_headers_ = TestInterceptor::error_headers();
+  interceptor.main_data_ = TestInterceptor::error_data();
+
+  // intercept that error and respond with an OK response
+  interceptor.intercept_final_response_ = true;
+  interceptor.final_headers_ = TestInterceptor::ok_headers();
+  interceptor.final_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_intercept_main_);
+  EXPECT_TRUE(interceptor.did_intercept_final_);
+
+  // Check we got one good response
+  EXPECT_TRUE(req.status().is_success());
+  EXPECT_EQ(200, req.response_headers()->response_code());
+  EXPECT_EQ(TestInterceptor::ok_data(), d.data_received());
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_EQ(0, d.received_redirect_count());
+}
+
+TEST_F(URLRequestTest, InterceptNetworkError) {
+  TestInterceptor interceptor;
+
+  // intercept the main request to simulate a network error
+  interceptor.simulate_main_network_error_ = true;
+
+  // intercept that error and respond with an OK response
+  interceptor.intercept_final_response_ = true;
+  interceptor.final_headers_ = TestInterceptor::ok_headers();
+  interceptor.final_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_simulate_error_main_);
+  EXPECT_TRUE(interceptor.did_intercept_final_);
+
+  // Check we received one good response
+  EXPECT_TRUE(req.status().is_success());
+  EXPECT_EQ(200, req.response_headers()->response_code());
+  EXPECT_EQ(TestInterceptor::ok_data(), d.data_received());
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_EQ(0, d.received_redirect_count());
+}
+
+TEST_F(URLRequestTest, InterceptRestartRequired) {
+  TestInterceptor interceptor;
+
+  // restart the main request
+  interceptor.restart_main_request_ = true;
+
+  // then intercept the new main request and respond with an OK response
+  interceptor.intercept_main_request_ = true;
+  interceptor.main_headers_ = TestInterceptor::ok_headers();
+  interceptor.main_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_restart_main_);
+  EXPECT_TRUE(interceptor.did_intercept_main_);
+
+  // Check we received one good response
+  EXPECT_TRUE(req.status().is_success());
+  if (req.status().is_success()) {
+    EXPECT_EQ(200, req.response_headers()->response_code());
+  }
+  EXPECT_EQ(TestInterceptor::ok_data(), d.data_received());
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_EQ(0, d.received_redirect_count());
+}
+
+TEST_F(URLRequestTest, InterceptRespectsCancelMain) {
+  TestInterceptor interceptor;
+
+  // intercept the main request and cancel from within the restarted job
+  interceptor.cancel_main_request_ = true;
+
+  // setup to intercept final response and override it with an OK response
+  interceptor.intercept_final_response_ = true;
+  interceptor.final_headers_ = TestInterceptor::ok_headers();
+  interceptor.final_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_cancel_main_);
+  EXPECT_FALSE(interceptor.did_intercept_final_);
+
+  // Check we see a canceled request
+  EXPECT_FALSE(req.status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
+}
+
+TEST_F(URLRequestTest, InterceptRespectsCancelRedirect) {
+  TestInterceptor interceptor;
+
+  // intercept the main request and respond with a redirect
+  interceptor.intercept_main_request_ = true;
+  interceptor.main_headers_ = TestInterceptor::redirect_headers();
+  interceptor.main_data_ = TestInterceptor::redirect_data();
+
+  // intercept the redirect and cancel from within that job
+  interceptor.cancel_redirect_request_ = true;
+
+  // setup to intercept final response and override it with an OK response
+  interceptor.intercept_final_response_ = true;
+  interceptor.final_headers_ = TestInterceptor::ok_headers();
+  interceptor.final_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_intercept_main_);
+  EXPECT_TRUE(interceptor.did_cancel_redirect_);
+  EXPECT_FALSE(interceptor.did_intercept_final_);
+
+  // Check we see a canceled request
+  EXPECT_FALSE(req.status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
+}
+
+TEST_F(URLRequestTest, InterceptRespectsCancelFinal) {
+  TestInterceptor interceptor;
+
+  // intercept the main request to simulate a network error
+  interceptor.simulate_main_network_error_ = true;
+
+  // setup to intercept final response and cancel from within that job
+  interceptor.cancel_final_request_ = true;
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_simulate_error_main_);
+  EXPECT_TRUE(interceptor.did_cancel_final_);
+
+  // Check we see a canceled request
+  EXPECT_FALSE(req.status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
+}
+
+TEST_F(URLRequestTest, InterceptRespectsCancelInRestart) {
+  TestInterceptor interceptor;
+
+  // intercept the main request and cancel then restart from within that job
+  interceptor.cancel_then_restart_main_request_ = true;
+
+  // setup to intercept final response and override it with an OK response
+  interceptor.intercept_final_response_ = true;
+  interceptor.final_headers_ = TestInterceptor::ok_headers();
+  interceptor.final_data_ = TestInterceptor::ok_data();
+
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  req.set_method("GET");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check the interceptor got called as expected
+  EXPECT_TRUE(interceptor.did_cancel_then_restart_main_);
+  EXPECT_FALSE(interceptor.did_intercept_final_);
+
+  // Check we see a canceled request
+  EXPECT_FALSE(req.status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
+}
+
+// Check that two different URL requests have different identifiers.
+TEST_F(URLRequestTest, Identifiers) {
+  TestDelegate d;
+  TestURLRequestContext context;
+  TestURLRequest req(GURL("http://example.com"), &d, &context);
+  TestURLRequest other_req(GURL("http://example.com"), &d, &context);
+
+  ASSERT_NE(req.identifier(), other_req.identifier());
+}
+
+// Check that a failure to connect to the proxy is reported to the network
+// delegate.
+TEST_F(URLRequestTest, NetworkDelegateProxyError) {
+  MockHostResolver host_resolver;
+  host_resolver.rules()->AddSimulatedFailure("*");
+
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
+  TestURLRequestContextWithProxy context("myproxy:70", &network_delegate);
+
+  TestDelegate d;
+  URLRequest req(GURL("http://example.com"), &d, &context);
+  req.set_method("GET");
+
+  req.Start();
+  MessageLoop::current()->Run();
+
+  // Check we see a failed request.
+  EXPECT_FALSE(req.status().is_success());
+  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
+  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req.status().error());
+
+  EXPECT_EQ(1, network_delegate.error_count());
+  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_error());
+  EXPECT_EQ(1, network_delegate.completed_requests());
+}
+
+// Make sure that net::NetworkDelegate::NotifyCompleted is called if
+// content is empty.
+TEST_F(URLRequestTest, RequestCompletionForEmptyResponse) {
+  TestDelegate d;
+  URLRequest req(GURL("data:,"), &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("", d.data_received());
+  EXPECT_EQ(1, default_network_delegate_.completed_requests());
+}
+
+// TODO(droger): Support TestServer on iOS (see http://crbug.com/148666).
+#if !defined(OS_IOS)
+// A subclass of TestServer that uses a statically-configured hostname. This is
+// to work around mysterious failures in chrome_frame_net_tests. See:
+// http://crbug.com/114369
+class LocalHttpTestServer : public TestServer {
+ public:
+  explicit LocalHttpTestServer(const FilePath& document_root)
+      : TestServer(TestServer::TYPE_HTTP,
+                   ScopedCustomUrlRequestTestHttpHost::value(),
+                   document_root) {}
+  LocalHttpTestServer()
+      : TestServer(TestServer::TYPE_HTTP,
+                   ScopedCustomUrlRequestTestHttpHost::value(),
+                   FilePath()) {}
+};
+
+TEST_F(URLRequestTest, FLAKY_DelayedCookieCallback) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  TestURLRequestContext context;
+  scoped_refptr<DelayedCookieMonster> delayed_cm =
+      new DelayedCookieMonster();
+  scoped_refptr<CookieStore> cookie_store = delayed_cm;
+  context.set_cookie_store(delayed_cm);
+
+  // Set up a cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    context.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("set-cookie?CookieToNotSend=1"), &d, &context);
+    req.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+    EXPECT_EQ(1, network_delegate.set_cookie_count());
+  }
+
+  // Verify that the cookie is set.
+  {
+    TestNetworkDelegate network_delegate;
+    context.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("echoheader?Cookie"), &d, &context);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
+                != std::string::npos);
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+}
+
+TEST_F(URLRequestTest, DoNotSendCookies) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up a cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"),
+                   &d,
+                   &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify that the cookie is set.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
+                != std::string::npos);
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify that the cookie isn't sent when LOAD_DO_NOT_SEND_COOKIES is set.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.set_load_flags(LOAD_DO_NOT_SEND_COOKIES);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
+                == std::string::npos);
+
+    // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies.
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+}
+
+TEST_F(URLRequestTest, DoNotSaveCookies) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up a cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
+                   &d,
+                   &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+    EXPECT_EQ(1, network_delegate.set_cookie_count());
+  }
+
+  // Try to set-up another cookie and update the previous cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
+        &d,
+        &default_context_);
+    req.set_load_flags(LOAD_DO_NOT_SAVE_COOKIES);
+    req.Start();
+
+    MessageLoop::current()->Run();
+
+    // LOAD_DO_NOT_SAVE_COOKIES does not trigger OnSetCookie.
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+    EXPECT_EQ(0, network_delegate.set_cookie_count());
+  }
+
+  // Verify the cookies weren't saved or updated.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
+                == std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
+                != std::string::npos);
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+    EXPECT_EQ(0, network_delegate.set_cookie_count());
+  }
+}
+
+TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up a cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"),
+                   &d,
+                   &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify that the cookie is set.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
+                != std::string::npos);
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify that the cookie isn't sent.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
+                == std::string::npos);
+
+    EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+}
+
+TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up a cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
+                   &d,
+                   &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Try to set-up another cookie and update the previous cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE);
+    URLRequest req(
+        test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
+        &d,
+        &default_context_);
+    req.Start();
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(2, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify the cookies weren't saved or updated.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
+                == std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
+                != std::string::npos);
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+}
+
+TEST_F(URLRequestTest, DoNotSaveEmptyCookies) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up an empty cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("set-cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+    EXPECT_EQ(0, network_delegate.set_cookie_count());
+  }
+}
+
+TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up a cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"),
+                   &d,
+                   &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify that the cookie is set.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
+                != std::string::npos);
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify that the cookie isn't sent.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
+                == std::string::npos);
+
+    EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+}
+
+TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up a cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
+                   &d,
+                   &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Try to set-up another cookie and update the previous cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE);
+    URLRequest req(
+        test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
+        &d,
+        &default_context_);
+    req.Start();
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(2, network_delegate.blocked_set_cookie_count());
+  }
+
+  // Verify the cookies weren't saved or updated.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
+                == std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
+                != std::string::npos);
+
+    EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
+    EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
+  }
+}
+
+// FixedDateNetworkDelegate swaps out the server's HTTP Date response header
+// value for the |fixed_date| argument given to the constructor.
+class FixedDateNetworkDelegate : public TestNetworkDelegate {
+ public:
+  explicit FixedDateNetworkDelegate(const std::string& fixed_date)
+      : fixed_date_(fixed_date) {}
+  virtual ~FixedDateNetworkDelegate() {}
+
+  // net::NetworkDelegate implementation
+  virtual int OnHeadersReceived(
+      net::URLRequest* request,
+      const net::CompletionCallback& callback,
+      const net::HttpResponseHeaders* original_response_headers,
+      scoped_refptr<net::HttpResponseHeaders>* override_response_headers)
+      OVERRIDE;
+
+ private:
+  std::string fixed_date_;
+
+  DISALLOW_COPY_AND_ASSIGN(FixedDateNetworkDelegate);
+};
+
+int FixedDateNetworkDelegate::OnHeadersReceived(
+    net::URLRequest* request,
+    const net::CompletionCallback& callback,
+    const net::HttpResponseHeaders* original_response_headers,
+    scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
+  net::HttpResponseHeaders* new_response_headers =
+      new net::HttpResponseHeaders(original_response_headers->raw_headers());
+
+  new_response_headers->RemoveHeader("Date");
+  new_response_headers->AddHeader("Date: " + fixed_date_);
+
+  *override_response_headers = new_response_headers;
+  return TestNetworkDelegate::OnHeadersReceived(request,
+                                                callback,
+                                                original_response_headers,
+                                                override_response_headers);
+}
+
+// Test that cookie expiration times are adjusted for server/client clock
+// skew and that we handle incorrect timezone specifier "UTC" in HTTP Date
+// headers by defaulting to GMT. (crbug.com/135131)
+TEST_F(URLRequestTest, AcceptClockSkewCookieWithWrongDateTimezone) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // Set up an expired cookie.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL(
+        "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
+        &d,
+        &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+  }
+  // Verify that the cookie is not set.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("StillGood=1") == std::string::npos);
+  }
+  // Set up a cookie with clock skew and "UTC" HTTP Date timezone specifier.
+  {
+    FixedDateNetworkDelegate network_delegate("18-Apr-1977 22:49:13 UTC");
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(test_server.GetURL(
+        "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
+        &d,
+        &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+  }
+  // Verify that the cookie is set.
+  {
+    TestNetworkDelegate network_delegate;
+    default_context_.set_network_delegate(&network_delegate);
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("StillGood=1") != std::string::npos);
+  }
+}
+
+
+// Check that it is impossible to change the referrer in the extra headers of
+// an URLRequest.
+TEST_F(URLRequestTest, DoNotOverrideReferrer) {
+  LocalHttpTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
+
+  // If extra headers contain referer and the request contains a referer,
+  // only the latter shall be respected.
+  {
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Referer"), &d, &default_context_);
+    req.set_referrer("http://foo.com/");
+
+    HttpRequestHeaders headers;
+    headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
+    req.SetExtraRequestHeaders(headers);
+
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ("http://foo.com/", d.data_received());
+  }
+
+  // If extra headers contain a referer but the request does not, no referer
+  // shall be sent in the header.
+  {
+    TestDelegate d;
+    URLRequest req(
+        test_server.GetURL("echoheader?Referer"), &d, &default_context_);
+
+    HttpRequestHeaders headers;
+    headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
+    req.SetExtraRequestHeaders(headers);
+    req.set_load_flags(LOAD_VALIDATE_CACHE);
+
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ("None", d.data_received());
+  }
+}
+
+class URLRequestTestHTTP : public URLRequestTest {
+ public:
+  URLRequestTestHTTP()
+      : test_server_(FilePath(FILE_PATH_LITERAL(
+                                  "net/data/url_request_unittest"))) {
+  }
+
+ protected:
+  // Requests |redirect_url|, which must return a HTTP 3xx redirect.
+  // |request_method| is the method to use for the initial request.
+  // |redirect_method| is the method that is expected to be used for the second
+  // request, after redirection.
+  // If |include_data| is true, data is uploaded with the request.  The
+  // response body is expected to match it exactly, if and only if
+  // |request_method| == |redirect_method|.
+  void HTTPRedirectMethodTest(const GURL& redirect_url,
+                              const std::string& request_method,
+                              const std::string& redirect_method,
+                              bool include_data) {
+    static const char kData[] = "hello world";
+    TestDelegate d;
+    URLRequest req(redirect_url, &d, &default_context_);
+    req.set_method(request_method);
+    if (include_data) {
+      req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+      HttpRequestHeaders headers;
+      headers.SetHeader(HttpRequestHeaders::kContentLength,
+                        base::UintToString(arraysize(kData) - 1));
+      req.SetExtraRequestHeaders(headers);
+    }
+    req.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(redirect_method, req.method());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+    EXPECT_EQ(OK, req.status().error());
+    if (include_data) {
+      if (request_method == redirect_method) {
+        EXPECT_EQ(kData, d.data_received());
+      } else {
+        EXPECT_NE(kData, d.data_received());
+      }
+    }
+    if (HasFailure())
+      LOG(WARNING) << "Request method was: " << request_method;
+  }
+
+  void HTTPUploadDataOperationTest(const std::string& method) {
+    const int kMsgSize = 20000;  // multiple of 10
+    const int kIterations = 50;
+    char* uploadBytes = new char[kMsgSize+1];
+    char* ptr = uploadBytes;
+    char marker = 'a';
+    for (int idx = 0; idx < kMsgSize/10; idx++) {
+      memcpy(ptr, "----------", 10);
+      ptr += 10;
+      if (idx % 100 == 0) {
+        ptr--;
+        *ptr++ = marker;
+        if (++marker > 'z')
+          marker = 'a';
+      }
+    }
+    uploadBytes[kMsgSize] = '\0';
+
+    for (int i = 0; i < kIterations; ++i) {
+      TestDelegate d;
+      URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
+      r.set_method(method.c_str());
+
+      r.set_upload(make_scoped_ptr(CreateSimpleUploadData(uploadBytes)));
+
+      r.Start();
+      EXPECT_TRUE(r.is_pending());
+
+      MessageLoop::current()->Run();
+
+      ASSERT_EQ(1, d.response_started_count())
+          << "request failed: " << r.status().status()
+          << ", os error: " << r.status().error();
+
+      EXPECT_FALSE(d.received_data_before_response());
+      EXPECT_EQ(uploadBytes, d.data_received());
+    }
+    delete[] uploadBytes;
+  }
+
+  void AddChunksToUpload(URLRequest* r) {
+    r->AppendChunkToUpload("a", 1, false);
+    r->AppendChunkToUpload("bcd", 3, false);
+    r->AppendChunkToUpload("this is a longer chunk than before.", 35, false);
+    r->AppendChunkToUpload("\r\n\r\n", 4, false);
+    r->AppendChunkToUpload("0", 1, false);
+    r->AppendChunkToUpload("2323", 4, true);
+  }
+
+  void VerifyReceivedDataMatchesChunks(URLRequest* r, TestDelegate* d) {
+    // This should match the chunks sent by AddChunksToUpload().
+    const std::string expected_data =
+        "abcdthis is a longer chunk than before.\r\n\r\n02323";
+
+    ASSERT_EQ(1, d->response_started_count())
+        << "request failed: " << r->status().status()
+        << ", os error: " << r->status().error();
+
+    EXPECT_FALSE(d->received_data_before_response());
+
+    EXPECT_EQ(expected_data.size(), static_cast<size_t>(d->bytes_received()));
+    EXPECT_EQ(expected_data, d->data_received());
+  }
+
+  bool DoManyCookiesRequest(int num_cookies) {
+    TestDelegate d;
+    URLRequest r(test_server_.GetURL("set-many-cookies?" +
+                                     base::IntToString(num_cookies)),
+                                     &d,
+                                     &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    bool is_success = r.status().is_success();
+
+    if (!is_success) {
+      // Requests handled by ChromeFrame send a less precise error message,
+      // ERR_CONNECTION_ABORTED.
+      EXPECT_TRUE(r.status().error() == ERR_RESPONSE_HEADERS_TOO_BIG ||
+                  r.status().error() == ERR_CONNECTION_ABORTED);
+      // The test server appears to be unable to handle subsequent requests
+      // after this error is triggered. Force it to restart.
+      EXPECT_TRUE(test_server_.Stop());
+      EXPECT_TRUE(test_server_.Start());
+    }
+
+    return is_success;
+  }
+
+  LocalHttpTestServer test_server_;
+};
+
+// In this unit test, we're using the HTTPTestServer as a proxy server and
+// issuing a CONNECT request with the magic host name "www.redirect.com".
+// The HTTPTestServer will return a 302 response, which we should not
+// follow.
+// flaky: crbug.com/96594
+TEST_F(URLRequestTestHTTP, FLAKY_ProxyTunnelRedirectTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+  TestURLRequestContextWithProxy context(
+      test_server_.host_port_pair().ToString(),
+      &network_delegate);
+
+  TestDelegate d;
+  {
+    URLRequest r(GURL("https://www.redirect.com/"), &d, &context);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
+    EXPECT_EQ(1, d.response_started_count());
+    // We should not have followed the redirect.
+    EXPECT_EQ(0, d.received_redirect_count());
+  }
+}
+
+// This is the same as the previous test, but checks that the network delegate
+// registers the error.
+// This test was disabled because it made chrome_frame_net_tests hang
+// (see bug 102991).
+TEST_F(URLRequestTestHTTP, DISABLED_NetworkDelegateTunnelConnectionFailed) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+  TestURLRequestContextWithProxy context(
+      test_server_.host_port_pair().ToString(),
+      &network_delegate);
+
+  TestDelegate d;
+  {
+    URLRequest r(GURL("https://www.redirect.com/"), &d, &context);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
+    EXPECT_EQ(1, d.response_started_count());
+    // We should not have followed the redirect.
+    EXPECT_EQ(0, d.received_redirect_count());
+
+    EXPECT_EQ(1, network_delegate.error_count());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_error());
+  }
+}
+
+// Tests that we can block and asynchronously return OK in various stages.
+TEST_F(URLRequestTestHTTP, NetworkDelegateBlockAsynchronously) {
+  static const BlockingNetworkDelegate::Stage blocking_stages[] = {
+    BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
+    BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
+    BlockingNetworkDelegate::ON_HEADERS_RECEIVED
+  };
+  static const size_t blocking_stages_length = arraysize(blocking_stages);
+
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::USER_CALLBACK);
+  network_delegate.set_block_on(
+      BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST |
+      BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS |
+      BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    URLRequest r(test_server_.GetURL("empty.html"), &d, &context);
+
+    r.Start();
+    for (size_t i = 0; i < blocking_stages_length; ++i) {
+      MessageLoop::current()->Run();
+      EXPECT_EQ(blocking_stages[i],
+                network_delegate.stage_blocked_for_callback());
+      network_delegate.DoCallback(OK);
+    }
+    MessageLoop::current()->Run();
+    EXPECT_EQ(200, r.GetResponseCode());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can block and cancel a request.
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::AUTO_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
+  network_delegate.set_retval(ERR_EMPTY_RESPONSE);
+
+  TestURLRequestContextWithProxy context(
+      test_server_.host_port_pair().ToString(),
+      &network_delegate);
+
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().error());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Helper function for NetworkDelegateCancelRequestAsynchronously and
+// NetworkDelegateCancelRequestSynchronously. Sets up a blocking network
+// delegate operating in |block_mode| and a request for |url|. It blocks the
+// request in |stage| and cancels it with ERR_BLOCKED_BY_CLIENT.
+void NetworkDelegateCancelRequest(BlockingNetworkDelegate::BlockMode block_mode,
+                                  BlockingNetworkDelegate::Stage stage,
+                                  const GURL& url) {
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(block_mode);
+  network_delegate.set_retval(ERR_BLOCKED_BY_CLIENT);
+  network_delegate.set_block_on(stage);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    URLRequest r(url, &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(ERR_BLOCKED_BY_CLIENT, r.status().error());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// The following 3 tests check that the network delegate can cancel a request
+// synchronously in various stages of the request.
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) {
+  ASSERT_TRUE(test_server_.Start());
+  NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
+                               BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
+                               test_server_.GetURL(""));
+}
+
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously2) {
+  ASSERT_TRUE(test_server_.Start());
+  NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
+                               BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
+                               test_server_.GetURL(""));
+}
+
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously3) {
+  ASSERT_TRUE(test_server_.Start());
+  NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
+                               BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
+                               test_server_.GetURL(""));
+}
+
+// The following 3 tests check that the network delegate can cancel a request
+// asynchronously in various stages of the request.
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously1) {
+  ASSERT_TRUE(test_server_.Start());
+  NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
+                               BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
+                               test_server_.GetURL(""));
+}
+
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously2) {
+  ASSERT_TRUE(test_server_.Start());
+  NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
+                               BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
+                               test_server_.GetURL(""));
+}
+
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously3) {
+  ASSERT_TRUE(test_server_.Start());
+  NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
+                               BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
+                               test_server_.GetURL(""));
+}
+
+// Tests that the network delegate can block and redirect a request to a new
+// URL.
+TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::AUTO_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
+  GURL redirect_url(test_server_.GetURL("simple.html"));
+  network_delegate.set_redirect_url(redirect_url);
+
+  TestURLRequestContextWithProxy context(
+      test_server_.host_port_pair().ToString(),
+      &network_delegate);
+
+  {
+    GURL original_url(test_server_.GetURL("empty.html"));
+    URLRequest r(original_url, &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(0, r.status().error());
+    EXPECT_EQ(redirect_url, r.url());
+    EXPECT_EQ(original_url, r.original_url());
+    EXPECT_EQ(2U, r.url_chain().size());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can block and redirect a request to a new
+// URL by setting a redirect_url and returning in OnBeforeURLRequest directly.
+TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestSynchronously) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::SYNCHRONOUS);
+  GURL redirect_url(test_server_.GetURL("simple.html"));
+  network_delegate.set_redirect_url(redirect_url);
+
+  TestURLRequestContextWithProxy context(
+      test_server_.host_port_pair().ToString(),
+      &network_delegate);
+
+  {
+    GURL original_url(test_server_.GetURL("empty.html"));
+    URLRequest r(original_url, &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(0, r.status().error());
+    EXPECT_EQ(redirect_url, r.url());
+    EXPECT_EQ(original_url, r.original_url());
+    EXPECT_EQ(2U, r.url_chain().size());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that redirects caused by the network delegate preserve POST data.
+TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestPost) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const char kData[] = "hello world";
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::AUTO_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
+  GURL redirect_url(test_server_.GetURL("echo"));
+  network_delegate.set_redirect_url(redirect_url);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    GURL original_url(test_server_.GetURL("empty.html"));
+    URLRequest r(original_url, &d, &context);
+    r.set_method("POST");
+    r.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+    HttpRequestHeaders headers;
+    headers.SetHeader(HttpRequestHeaders::kContentLength,
+                      base::UintToString(arraysize(kData) - 1));
+    r.SetExtraRequestHeaders(headers);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(0, r.status().error());
+    EXPECT_EQ(redirect_url, r.url());
+    EXPECT_EQ(original_url, r.original_url());
+    EXPECT_EQ(2U, r.url_chain().size());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+    EXPECT_EQ("POST", r.method());
+    EXPECT_EQ(kData, d.data_received());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can synchronously complete OnAuthRequired
+// by taking no action. This indicates that the NetworkDelegate does not want to
+// handle the challenge, and is passing the buck along to the
+// URLRequest::Delegate.
+TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncNoAction) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::SYNCHRONOUS);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  d.set_credentials(AuthCredentials(kUser, kSecret));
+
+  {
+    GURL url(test_server_.GetURL("auth-basic"));
+    URLRequest r(url, &d, &context);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(0, r.status().error());
+    EXPECT_EQ(200, r.GetResponseCode());
+    EXPECT_TRUE(d.auth_required_called());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can synchronously complete OnAuthRequired
+// by setting credentials.
+TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncSetAuth) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::SYNCHRONOUS);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
+  network_delegate.set_auth_retval(
+      NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
+
+  network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret));
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    GURL url(test_server_.GetURL("auth-basic"));
+    URLRequest r(url, &d, &context);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(0, r.status().error());
+    EXPECT_EQ(200, r.GetResponseCode());
+    EXPECT_FALSE(d.auth_required_called());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can synchronously complete OnAuthRequired
+// by cancelling authentication.
+TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncCancel) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::SYNCHRONOUS);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
+  network_delegate.set_auth_retval(
+      NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    GURL url(test_server_.GetURL("auth-basic"));
+    URLRequest r(url, &d, &context);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(OK, r.status().error());
+    EXPECT_EQ(401, r.GetResponseCode());
+    EXPECT_FALSE(d.auth_required_called());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can asynchronously complete OnAuthRequired
+// by taking no action. This indicates that the NetworkDelegate does not want
+// to handle the challenge, and is passing the buck along to the
+// URLRequest::Delegate.
+TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncNoAction) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::AUTO_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  d.set_credentials(AuthCredentials(kUser, kSecret));
+
+  {
+    GURL url(test_server_.GetURL("auth-basic"));
+    URLRequest r(url, &d, &context);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(0, r.status().error());
+    EXPECT_EQ(200, r.GetResponseCode());
+    EXPECT_TRUE(d.auth_required_called());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can asynchronously complete OnAuthRequired
+// by setting credentials.
+TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncSetAuth) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::AUTO_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
+  network_delegate.set_auth_retval(
+      NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
+
+  AuthCredentials auth_credentials(kUser, kSecret);
+  network_delegate.set_auth_credentials(auth_credentials);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    GURL url(test_server_.GetURL("auth-basic"));
+    URLRequest r(url, &d, &context);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(0, r.status().error());
+
+    EXPECT_EQ(200, r.GetResponseCode());
+    EXPECT_FALSE(d.auth_required_called());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that the network delegate can asynchronously complete OnAuthRequired
+// by cancelling authentication.
+TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncCancel) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::AUTO_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
+  network_delegate.set_auth_retval(
+      NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    GURL url(test_server_.GetURL("auth-basic"));
+    URLRequest r(url, &d, &context);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(OK, r.status().error());
+    EXPECT_EQ(401, r.GetResponseCode());
+    EXPECT_FALSE(d.auth_required_called());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that we can handle when a network request was canceled while we were
+// waiting for the network delegate.
+// Part 1: Request is cancelled while waiting for OnBeforeURLRequest callback.
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting1) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::USER_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
+              network_delegate.stage_blocked_for_callback());
+    EXPECT_EQ(0, network_delegate.completed_requests());
+    // Cancel before callback.
+    r.Cancel();
+    // Ensure that network delegate is notified.
+    EXPECT_EQ(1, network_delegate.completed_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+    EXPECT_EQ(ERR_ABORTED, r.status().error());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that we can handle when a network request was canceled while we were
+// waiting for the network delegate.
+// Part 2: Request is cancelled while waiting for OnBeforeSendHeaders callback.
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting2) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::USER_CALLBACK);
+  network_delegate.set_block_on(
+      BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
+              network_delegate.stage_blocked_for_callback());
+    EXPECT_EQ(0, network_delegate.completed_requests());
+    // Cancel before callback.
+    r.Cancel();
+    // Ensure that network delegate is notified.
+    EXPECT_EQ(1, network_delegate.completed_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+    EXPECT_EQ(ERR_ABORTED, r.status().error());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that we can handle when a network request was canceled while we were
+// waiting for the network delegate.
+// Part 3: Request is cancelled while waiting for OnHeadersReceived callback.
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::USER_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
+              network_delegate.stage_blocked_for_callback());
+    EXPECT_EQ(0, network_delegate.completed_requests());
+    // Cancel before callback.
+    r.Cancel();
+    // Ensure that network delegate is notified.
+    EXPECT_EQ(1, network_delegate.completed_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+    EXPECT_EQ(ERR_ABORTED, r.status().error());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// Tests that we can handle when a network request was canceled while we were
+// waiting for the network delegate.
+// Part 4: Request is cancelled while waiting for OnAuthRequired callback.
+TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting4) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  BlockingNetworkDelegate network_delegate(
+      BlockingNetworkDelegate::USER_CALLBACK);
+  network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
+
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  {
+    URLRequest r(test_server_.GetURL("auth-basic"), &d, &context);
+
+    r.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(BlockingNetworkDelegate::ON_AUTH_REQUIRED,
+              network_delegate.stage_blocked_for_callback());
+    EXPECT_EQ(0, network_delegate.completed_requests());
+    // Cancel before callback.
+    r.Cancel();
+    // Ensure that network delegate is notified.
+    EXPECT_EQ(1, network_delegate.completed_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+    EXPECT_EQ(ERR_ABORTED, r.status().error());
+    EXPECT_EQ(1, network_delegate.created_requests());
+    EXPECT_EQ(0, network_delegate.destroyed_requests());
+  }
+  EXPECT_EQ(1, network_delegate.destroyed_requests());
+}
+
+// In this unit test, we're using the HTTPTestServer as a proxy server and
+// issuing a CONNECT request with the magic host name "www.server-auth.com".
+// The HTTPTestServer will return a 401 response, which we should balk at.
+TEST_F(URLRequestTestHTTP, UnexpectedServerAuthTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+  TestURLRequestContextWithProxy context(
+      test_server_.host_port_pair().ToString(),
+      &network_delegate);
+
+  TestDelegate d;
+  {
+    URLRequest r(GURL("https://www.server-auth.com/"), &d, &context);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, GetTest_NoCache) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_NE(0, d.bytes_received());
+    EXPECT_EQ(test_server_.host_port_pair().host(),
+              r.GetSocketAddress().host());
+    EXPECT_EQ(test_server_.host_port_pair().port(),
+              r.GetSocketAddress().port());
+
+    // TODO(eroman): Add back the NetLog tests...
+  }
+}
+
+// This test has the server send a large number of cookies to the client.
+// To ensure that no number of cookies causes a crash, a galloping binary
+// search is used to estimate that maximum number of cookies that are accepted
+// by the browser. Beyond the maximum number, the request will fail with
+// ERR_RESPONSE_HEADERS_TOO_BIG.
+TEST_F(URLRequestTestHTTP, GetTest_ManyCookies) {
+  ASSERT_TRUE(test_server_.Start());
+
+  int lower_bound = 0;
+  int upper_bound = 1;
+
+  // Double the number of cookies until the response header limits are
+  // exceeded.
+  while (DoManyCookiesRequest(upper_bound)) {
+    lower_bound = upper_bound;
+    upper_bound *= 2;
+    ASSERT_LT(upper_bound, 1000000);
+  }
+
+  int tolerance = upper_bound * 0.005;
+  if (tolerance < 2)
+    tolerance = 2;
+
+  // Perform a binary search to find the highest possible number of cookies,
+  // within the desired tolerance.
+  while (upper_bound - lower_bound >= tolerance) {
+    int num_cookies = (lower_bound + upper_bound) / 2;
+
+    if (DoManyCookiesRequest(num_cookies))
+      lower_bound = num_cookies;
+    else
+      upper_bound = num_cookies;
+  }
+  // Success: the test did not crash.
+}
+
+TEST_F(URLRequestTestHTTP, GetTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_NE(0, d.bytes_received());
+    EXPECT_EQ(test_server_.host_port_pair().host(),
+              r.GetSocketAddress().host());
+    EXPECT_EQ(test_server_.host_port_pair().port(),
+              r.GetSocketAddress().port());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, GetZippedTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  // Parameter that specifies the Content-Length field in the response:
+  // C - Compressed length.
+  // U - Uncompressed length.
+  // L - Large length (larger than both C & U).
+  // M - Medium length (between C & U).
+  // S - Small length (smaller than both C & U).
+  const char test_parameters[] = "CULMS";
+  const int num_tests = arraysize(test_parameters)- 1;  // Skip NULL.
+  // C & U should be OK.
+  // L & M are larger than the data sent, and show an error.
+  // S has too little data, but we seem to accept it.
+  const bool test_expect_success[num_tests] =
+      { true, true, false, false, true };
+
+  for (int i = 0; i < num_tests ; i++) {
+    TestDelegate d;
+    {
+      std::string test_file =
+          base::StringPrintf("compressedfiles/BullRunSpeech.txt?%c",
+                             test_parameters[i]);
+
+      TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+      TestURLRequestContext context(true);
+      context.set_network_delegate(&network_delegate);
+      context.Init();
+
+      URLRequest r(test_server_.GetURL(test_file), &d, &context);
+      r.Start();
+      EXPECT_TRUE(r.is_pending());
+
+      MessageLoop::current()->Run();
+
+      EXPECT_EQ(1, d.response_started_count());
+      EXPECT_FALSE(d.received_data_before_response());
+      VLOG(1) << " Received " << d.bytes_received() << " bytes"
+              << " status = " << r.status().status()
+              << " error = " << r.status().error();
+      if (test_expect_success[i]) {
+        EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status())
+            << " Parameter = \"" << test_file << "\"";
+      } else {
+        EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+        EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, r.status().error())
+            << " Parameter = \"" << test_file << "\"";
+      }
+    }
+  }
+}
+
+// This test was disabled because it made chrome_frame_net_tests hang
+// (see bug 102991).
+TEST_F(URLRequestTestHTTP, DISABLED_HTTPSToHTTPRedirectNoRefererTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestServer https_test_server(TestServer::TYPE_HTTPS,
+                               TestServer::kLocalhost,
+                               FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(https_test_server.Start());
+
+  // An https server is sent a request with an https referer,
+  // and responds with a redirect to an http url. The http
+  // server should not be sent the referer.
+  GURL http_destination = test_server_.GetURL("");
+  TestDelegate d;
+  URLRequest req(https_test_server.GetURL(
+      "server-redirect?" + http_destination.spec()), &d, &default_context_);
+  req.set_referrer("https://www.referrer.com/");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_EQ(1, d.received_redirect_count());
+  EXPECT_EQ(http_destination, req.url());
+  EXPECT_EQ(std::string(), req.referrer());
+}
+
+TEST_F(URLRequestTestHTTP, MultipleRedirectTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  GURL destination_url = test_server_.GetURL("");
+  GURL middle_redirect_url = test_server_.GetURL(
+      "server-redirect?" + destination_url.spec());
+  GURL original_url = test_server_.GetURL(
+      "server-redirect?" + middle_redirect_url.spec());
+  TestDelegate d;
+  URLRequest req(original_url, &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_EQ(2, d.received_redirect_count());
+  EXPECT_EQ(destination_url, req.url());
+  EXPECT_EQ(original_url, req.original_url());
+  ASSERT_EQ(3U, req.url_chain().size());
+  EXPECT_EQ(original_url, req.url_chain()[0]);
+  EXPECT_EQ(middle_redirect_url, req.url_chain()[1]);
+  EXPECT_EQ(destination_url, req.url_chain()[2]);
+}
+
+namespace {
+
+const char kExtraHeader[] = "Allow-Snafu";
+const char kExtraValue[] = "fubar";
+
+class RedirectWithAdditionalHeadersDelegate : public TestDelegate {
+  void OnReceivedRedirect(net::URLRequest* request,
+                          const GURL& new_url,
+                          bool* defer_redirect) {
+    TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
+    request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
+  }
+};
+
+}  // namespace
+
+TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  GURL destination_url = test_server_.GetURL(
+      "echoheader?" + std::string(kExtraHeader));
+  GURL original_url = test_server_.GetURL(
+      "server-redirect?" + destination_url.spec());
+  RedirectWithAdditionalHeadersDelegate d;
+  URLRequest req(original_url, &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  std::string value;
+  const HttpRequestHeaders& headers = req.extra_request_headers();
+  EXPECT_TRUE(headers.GetHeader(kExtraHeader, &value));
+  EXPECT_EQ(kExtraValue, value);
+  EXPECT_FALSE(req.is_pending());
+  EXPECT_FALSE(req.is_redirecting());
+  EXPECT_EQ(kExtraValue, d.data_received());
+}
+
+namespace {
+
+const char kExtraHeaderToRemove[] = "To-Be-Removed";
+
+class RedirectWithHeaderRemovalDelegate : public TestDelegate {
+  void OnReceivedRedirect(net::URLRequest* request,
+                          const GURL& new_url,
+                          bool* defer_redirect) {
+    TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
+    request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
+  }
+};
+
+}  // namespace
+
+TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  GURL destination_url = test_server_.GetURL(
+      "echoheader?" + std::string(kExtraHeaderToRemove));
+  GURL original_url = test_server_.GetURL(
+      "server-redirect?" + destination_url.spec());
+  RedirectWithHeaderRemovalDelegate d;
+  URLRequest req(original_url, &d, &default_context_);
+  req.SetExtraRequestHeaderByName(kExtraHeaderToRemove, "dummy", false);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  std::string value;
+  const HttpRequestHeaders& headers = req.extra_request_headers();
+  EXPECT_FALSE(headers.GetHeader(kExtraHeaderToRemove, &value));
+  EXPECT_FALSE(req.is_pending());
+  EXPECT_FALSE(req.is_redirecting());
+  EXPECT_EQ("None", d.data_received());
+}
+
+TEST_F(URLRequestTestHTTP, CancelTest) {
+  TestDelegate d;
+  {
+    URLRequest r(GURL("http://www.google.com/"), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    r.Cancel();
+
+    MessageLoop::current()->Run();
+
+    // We expect to receive OnResponseStarted even though the request has been
+    // cancelled.
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_EQ(0, d.bytes_received());
+    EXPECT_FALSE(d.received_data_before_response());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, CancelTest2) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &default_context_);
+
+    d.set_cancel_in_response_started(true);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_EQ(0, d.bytes_received());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, CancelTest3) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &default_context_);
+
+    d.set_cancel_in_received_data(true);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    // There is no guarantee about how much data was received
+    // before the cancel was issued.  It could have been 0 bytes,
+    // or it could have been all the bytes.
+    // EXPECT_EQ(0, d.bytes_received());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, CancelTest4) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL(""), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    // The request will be implicitly canceled when it is destroyed. The
+    // test delegate must not post a quit message when this happens because
+    // this test doesn't actually have a message loop. The quit message would
+    // get put on this thread's message queue and the next test would exit
+    // early, causing problems.
+    d.set_quit_on_complete(false);
+  }
+  // expect things to just cleanup properly.
+
+  // we won't actually get a received reponse here because we've never run the
+  // message loop
+  EXPECT_FALSE(d.received_data_before_response());
+  EXPECT_EQ(0, d.bytes_received());
+}
+
+TEST_F(URLRequestTestHTTP, CancelTest5) {
+  ASSERT_TRUE(test_server_.Start());
+
+  // populate cache
+  {
+    TestDelegate d;
+    URLRequest r(test_server_.GetURL("cachetime"), &d, &default_context_);
+    r.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+  }
+
+  // cancel read from cache (see bug 990242)
+  {
+    TestDelegate d;
+    URLRequest r(test_server_.GetURL("cachetime"), &d, &default_context_);
+    r.Start();
+    r.Cancel();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_EQ(0, d.bytes_received());
+    EXPECT_FALSE(d.received_data_before_response());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, PostTest) {
+  ASSERT_TRUE(test_server_.Start());
+  HTTPUploadDataOperationTest("POST");
+}
+
+TEST_F(URLRequestTestHTTP, PutTest) {
+  ASSERT_TRUE(test_server_.Start());
+  HTTPUploadDataOperationTest("PUT");
+}
+
+TEST_F(URLRequestTestHTTP, PostEmptyTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
+    r.set_method("POST");
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    ASSERT_EQ(1, d.response_started_count())
+        << "request failed: " << r.status().status()
+        << ", error: " << r.status().error();
+
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_TRUE(d.data_received().empty());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, PostFileTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
+    r.set_method("POST");
+
+#if !defined(OS_STARBOARD)
+    FilePath dir;
+    PathService::Get(base::DIR_EXE, &dir);
+    file_util::SetCurrentDirectory(dir);
+#endif
+
+    ScopedVector<UploadElementReader> element_readers;
+
+    FilePath path;
+    PathService::Get(base::DIR_SOURCE_ROOT, &path);
+    path = path.Append(FILE_PATH_LITERAL("net"));
+    path = path.Append(FILE_PATH_LITERAL("data"));
+    path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+    path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
+    element_readers.push_back(new UploadFileElementReader(
+        path, 0, kuint64max, base::Time()));
+
+    // This file should just be ignored in the upload stream.
+    element_readers.push_back(new UploadFileElementReader(
+        FilePath(FILE_PATH_LITERAL(
+            "c:\\path\\to\\non\\existant\\file.randomness.12345")),
+        0, kuint64max, base::Time()));
+    r.set_upload(make_scoped_ptr(new UploadDataStream(&element_readers, 0)));
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 size = 0;
+    ASSERT_EQ(true, file_util::GetFileSize(path, &size));
+    scoped_array<char> buf(new char[size]);
+
+    ASSERT_EQ(size, file_util::ReadFile(path, buf.get(), size));
+
+    ASSERT_EQ(1, d.response_started_count())
+        << "request failed: " << r.status().status()
+        << ", error: " << r.status().error();
+
+    EXPECT_FALSE(d.received_data_before_response());
+
+    EXPECT_EQ(size, d.bytes_received());
+    EXPECT_EQ(std::string(&buf[0], size), d.data_received());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
+    r.EnableChunkedUpload();
+    r.set_method("POST");
+    AddChunksToUpload(&r);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    VerifyReceivedDataMatchesChunks(&r, &d);
+  }
+}
+
+TEST_F(URLRequestTestHTTP, TestPostChunkedDataJustAfterStart) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
+    r.EnableChunkedUpload();
+    r.set_method("POST");
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+    AddChunksToUpload(&r);
+    MessageLoop::current()->Run();
+
+    VerifyReceivedDataMatchesChunks(&r, &d);
+  }
+}
+
+TEST_F(URLRequestTestHTTP, TestPostChunkedDataAfterStart) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
+    r.EnableChunkedUpload();
+    r.set_method("POST");
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->RunUntilIdle();
+    AddChunksToUpload(&r);
+    MessageLoop::current()->Run();
+
+    VerifyReceivedDataMatchesChunks(&r, &d);
+  }
+}
+
+TEST_F(URLRequestTestHTTP, ResponseHeadersTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(
+      test_server_.GetURL("files/with-headers.html"), &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  const HttpResponseHeaders* headers = req.response_headers();
+
+  // Simple sanity check that response_info() accesses the same data.
+  EXPECT_EQ(headers, req.response_info().headers.get());
+
+  std::string header;
+  EXPECT_TRUE(headers->GetNormalizedHeader("cache-control", &header));
+  EXPECT_EQ("private", header);
+
+  header.clear();
+  EXPECT_TRUE(headers->GetNormalizedHeader("content-type", &header));
+  EXPECT_EQ("text/html; charset=ISO-8859-1", header);
+
+  // The response has two "X-Multiple-Entries" headers.
+  // This verfies our output has them concatenated together.
+  header.clear();
+  EXPECT_TRUE(headers->GetNormalizedHeader("x-multiple-entries", &header));
+  EXPECT_EQ("a, b", header);
+}
+
+TEST_F(URLRequestTestHTTP, ProcessSTS) {
+  TestServer::SSLOptions ssl_options;
+  TestServer https_test_server(
+      TestServer::TYPE_HTTPS,
+      ssl_options,
+      FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  ASSERT_TRUE(https_test_server.Start());
+
+  TestDelegate d;
+  URLRequest request(
+      https_test_server.GetURL("files/hsts-headers.html"),
+      &d,
+      &default_context_);
+  request.Start();
+  MessageLoop::current()->Run();
+
+  TransportSecurityState* security_state =
+      default_context_.transport_security_state();
+  bool sni_available = true;
+  TransportSecurityState::DomainState domain_state;
+  EXPECT_TRUE(security_state->GetDomainState(
+      TestServer::kLocalhost, sni_available, &domain_state));
+  EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
+            domain_state.upgrade_mode);
+  EXPECT_TRUE(domain_state.include_subdomains);
+}
+
+TEST_F(URLRequestTestHTTP, ProcessSTSOnce) {
+  TestServer::SSLOptions ssl_options;
+  TestServer https_test_server(
+      TestServer::TYPE_HTTPS,
+      ssl_options,
+      FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  ASSERT_TRUE(https_test_server.Start());
+
+  TestDelegate d;
+  URLRequest request(
+      https_test_server.GetURL("files/hsts-multiple-headers.html"),
+      &d,
+      &default_context_);
+  request.Start();
+  MessageLoop::current()->Run();
+
+  // We should have set parameters from the first header, not the second.
+  TransportSecurityState* security_state =
+      default_context_.transport_security_state();
+  bool sni_available = true;
+  TransportSecurityState::DomainState domain_state;
+  EXPECT_TRUE(security_state->GetDomainState(
+      TestServer::kLocalhost, sni_available, &domain_state));
+  EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
+            domain_state.upgrade_mode);
+  EXPECT_FALSE(domain_state.include_subdomains);
+}
+
+TEST_F(URLRequestTestHTTP, ContentTypeNormalizationTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL(
+      "files/content-type-normalization.html"), &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  std::string mime_type;
+  req.GetMimeType(&mime_type);
+  EXPECT_EQ("text/html", mime_type);
+
+  std::string charset;
+  req.GetCharset(&charset);
+  EXPECT_EQ("utf-8", charset);
+  req.Cancel();
+}
+
+TEST_F(URLRequestTestHTTP, RestrictRedirects) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL(
+      "files/redirect-to-file.html"), &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
+  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req.status().error());
+}
+
+TEST_F(URLRequestTestHTTP, RedirectToInvalidURL) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL(
+      "files/redirect-to-invalid-url.html"), &d, &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
+  EXPECT_EQ(ERR_INVALID_URL, req.status().error());
+}
+
+TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(
+      test_server_.GetURL("echoheader?Referer"), &d, &default_context_);
+  req.set_referrer("http://user:pass@foo.com/");
+  req.Start();
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(std::string("http://foo.com/"), d.data_received());
+}
+
+TEST_F(URLRequestTestHTTP, CancelRedirect) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    d.set_cancel_in_received_redirect(true);
+    URLRequest req(
+        test_server_.GetURL("files/redirect-test.html"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_EQ(0, d.bytes_received());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, DeferredRedirect) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    d.set_quit_on_redirect(true);
+    URLRequest req(
+        test_server_.GetURL("files/redirect-test.html"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.received_redirect_count());
+
+    req.FollowDeferredRedirect();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+
+    FilePath path;
+    PathService::Get(base::DIR_SOURCE_ROOT, &path);
+    path = path.Append(FILE_PATH_LITERAL("net"));
+    path = path.Append(FILE_PATH_LITERAL("data"));
+    path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+    path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
+
+    std::string contents;
+    EXPECT_TRUE(file_util::ReadFileToString(path, &contents));
+    EXPECT_EQ(contents, d.data_received());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, CancelDeferredRedirect) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    d.set_quit_on_redirect(true);
+    URLRequest req(
+        test_server_.GetURL("files/redirect-test.html"), &d, &default_context_);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.received_redirect_count());
+
+    req.Cancel();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_EQ(0, d.bytes_received());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, VaryHeader) {
+  ASSERT_TRUE(test_server_.Start());
+
+  // populate the cache
+  {
+    TestDelegate d;
+    URLRequest req(
+        test_server_.GetURL("echoheadercache?foo"), &d, &default_context_);
+    HttpRequestHeaders headers;
+    headers.SetHeader("foo", "1");
+    req.SetExtraRequestHeaders(headers);
+    req.Start();
+    MessageLoop::current()->Run();
+  }
+
+  // expect a cache hit
+  {
+    TestDelegate d;
+    URLRequest req(
+        test_server_.GetURL("echoheadercache?foo"), &d, &default_context_);
+    HttpRequestHeaders headers;
+    headers.SetHeader("foo", "1");
+    req.SetExtraRequestHeaders(headers);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(req.was_cached());
+  }
+
+  // expect a cache miss
+  {
+    TestDelegate d;
+    URLRequest req(
+        test_server_.GetURL("echoheadercache?foo"), &d, &default_context_);
+    HttpRequestHeaders headers;
+    headers.SetHeader("foo", "2");
+    req.SetExtraRequestHeaders(headers);
+    req.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_FALSE(req.was_cached());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, BasicAuth) {
+  ASSERT_TRUE(test_server_.Start());
+
+  // populate the cache
+  {
+    TestDelegate d;
+    d.set_credentials(AuthCredentials(kUser, kSecret));
+
+    URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_);
+    r.Start();
+
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
+  }
+
+  // repeat request with end-to-end validation.  since auth-basic results in a
+  // cachable page, we expect this test to result in a 304.  in which case, the
+  // response should be fetched from the cache.
+  {
+    TestDelegate d;
+    d.set_credentials(AuthCredentials(kUser, kSecret));
+
+    URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_);
+    r.set_load_flags(LOAD_VALIDATE_CACHE);
+    r.Start();
+
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
+
+    // Should be the same cached document.
+    EXPECT_TRUE(r.was_cached());
+  }
+}
+
+// Check that Set-Cookie headers in 401 responses are respected.
+// http://crbug.com/6450
+TEST_F(URLRequestTestHTTP, BasicAuthWithCookies) {
+  ASSERT_TRUE(test_server_.Start());
+
+  GURL url_requiring_auth =
+      test_server_.GetURL("auth-basic?set-cookie-if-challenged");
+
+  // Request a page that will give a 401 containing a Set-Cookie header.
+  // Verify that when the transaction is restarted, it includes the new cookie.
+  {
+    TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+    TestURLRequestContext context(true);
+    context.set_network_delegate(&network_delegate);
+    context.Init();
+
+    TestDelegate d;
+    d.set_credentials(AuthCredentials(kUser, kSecret));
+
+    URLRequest r(url_requiring_auth, &d, &context);
+    r.Start();
+
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
+
+    // Make sure we sent the cookie in the restarted transaction.
+    EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
+        != std::string::npos);
+  }
+
+  // Same test as above, except this time the restart is initiated earlier
+  // (without user intervention since identity is embedded in the URL).
+  {
+    TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+    TestURLRequestContext context(true);
+    context.set_network_delegate(&network_delegate);
+    context.Init();
+
+    TestDelegate d;
+
+    GURL::Replacements replacements;
+    std::string username("user2");
+    std::string password("secret");
+    replacements.SetUsernameStr(username);
+    replacements.SetPasswordStr(password);
+    GURL url_with_identity = url_requiring_auth.ReplaceComponents(replacements);
+
+    URLRequest r(url_with_identity, &d, &context);
+    r.Start();
+
+    MessageLoop::current()->Run();
+
+    EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos);
+
+    // Make sure we sent the cookie in the restarted transaction.
+    EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
+        != std::string::npos);
+  }
+}
+
+// In this test, we do a POST which the server will 302 redirect.
+// The subsequent transaction should use GET, and should not send the
+// Content-Type header.
+// http://code.google.com/p/chromium/issues/detail?id=843
+TEST_F(URLRequestTestHTTP, Post302RedirectGet) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const char kData[] = "hello world";
+
+  TestDelegate d;
+  URLRequest req(
+      test_server_.GetURL("files/redirect-to-echoall"), &d, &default_context_);
+  req.set_method("POST");
+  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+
+  // Set headers (some of which are specific to the POST).
+  HttpRequestHeaders headers;
+  headers.AddHeadersFromString(
+    "Content-Type: multipart/form-data; "
+    "boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n"
+    "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,"
+    "text/plain;q=0.8,image/png,*/*;q=0.5\r\n"
+    "Accept-Language: en-US,en\r\n"
+    "Accept-Charset: ISO-8859-1,*,utf-8\r\n"
+    "Content-Length: 11\r\n"
+    "Origin: http://localhost:1337/");
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+
+  std::string mime_type;
+  req.GetMimeType(&mime_type);
+  EXPECT_EQ("text/html", mime_type);
+
+  const std::string& data = d.data_received();
+
+  // Check that the post-specific headers were stripped:
+  EXPECT_FALSE(ContainsString(data, "Content-Length:"));
+  EXPECT_FALSE(ContainsString(data, "Content-Type:"));
+  EXPECT_FALSE(ContainsString(data, "Origin:"));
+
+  // These extra request headers should not have been stripped.
+  EXPECT_TRUE(ContainsString(data, "Accept:"));
+  EXPECT_TRUE(ContainsString(data, "Accept-Language:"));
+  EXPECT_TRUE(ContainsString(data, "Accept-Charset:"));
+}
+
+// The following tests check that we handle mutating the request method for
+// HTTP redirects as expected.
+// See http://crbug.com/56373 and http://crbug.com/102130.
+
+TEST_F(URLRequestTestHTTP, Redirect301Tests) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const GURL url = test_server_.GetURL("files/redirect301-to-echo");
+
+  HTTPRedirectMethodTest(url, "POST", "GET", true);
+  HTTPRedirectMethodTest(url, "PUT", "PUT", true);
+  HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
+}
+
+TEST_F(URLRequestTestHTTP, Redirect302Tests) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const GURL url = test_server_.GetURL("files/redirect302-to-echo");
+
+  HTTPRedirectMethodTest(url, "POST", "GET", true);
+  HTTPRedirectMethodTest(url, "PUT", "PUT", true);
+  HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
+}
+
+TEST_F(URLRequestTestHTTP, Redirect303Tests) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const GURL url = test_server_.GetURL("files/redirect303-to-echo");
+
+  HTTPRedirectMethodTest(url, "POST", "GET", true);
+  HTTPRedirectMethodTest(url, "PUT", "GET", true);
+  HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
+}
+
+TEST_F(URLRequestTestHTTP, Redirect307Tests) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const GURL url = test_server_.GetURL("files/redirect307-to-echo");
+
+  HTTPRedirectMethodTest(url, "POST", "POST", true);
+  HTTPRedirectMethodTest(url, "PUT", "PUT", true);
+  HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
+}
+
+TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const char kData[] = "hello world";
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_);
+  req.set_method("POST");
+  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  HttpRequestHeaders headers;
+  headers.SetHeader(HttpRequestHeaders::kContentLength,
+                    base::UintToString(arraysize(kData) - 1));
+  req.SetExtraRequestHeaders(headers);
+
+  URLRequestRedirectJob* job = new URLRequestRedirectJob(
+      &req, default_context_.network_delegate(), test_server_.GetURL("echo"),
+      URLRequestRedirectJob::REDIRECT_302_FOUND);
+  AddTestInterceptor()->set_main_intercept_job(job);
+
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("GET", req.method());
+}
+
+TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) {
+  ASSERT_TRUE(test_server_.Start());
+
+  const char kData[] = "hello world";
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_);
+  req.set_method("POST");
+  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  HttpRequestHeaders headers;
+  headers.SetHeader(HttpRequestHeaders::kContentLength,
+                    base::UintToString(arraysize(kData) - 1));
+  req.SetExtraRequestHeaders(headers);
+
+  URLRequestRedirectJob* job = new URLRequestRedirectJob(
+      &req, default_context_.network_delegate(), test_server_.GetURL("echo"),
+      URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT);
+  AddTestInterceptor()->set_main_intercept_job(job);
+
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("POST", req.method());
+  EXPECT_EQ(kData, d.data_received());
+}
+
+// Check that default A-L header is sent.
+TEST_F(URLRequestTestHTTP, DefaultAcceptLanguage) {
+  ASSERT_TRUE(test_server_.Start());
+
+  StaticHttpUserAgentSettings settings("en", EmptyString(), EmptyString());
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.set_http_user_agent_settings(&settings);
+  context.Init();
+
+  TestDelegate d;
+  URLRequest req(
+      test_server_.GetURL("echoheader?Accept-Language"), &d, &context);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("en", d.data_received());
+}
+
+// Check that an empty A-L header is not sent. http://crbug.com/77365.
+TEST_F(URLRequestTestHTTP, EmptyAcceptLanguage) {
+  ASSERT_TRUE(test_server_.Start());
+
+  StaticHttpUserAgentSettings settings(
+      EmptyString(), EmptyString(), EmptyString());
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+  // We override the language after initialization because empty entries
+  // get overridden by Init().
+  context.set_http_user_agent_settings(&settings);
+
+  TestDelegate d;
+  URLRequest req(
+      test_server_.GetURL("echoheader?Accept-Language"), &d, &context);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("None", d.data_received());
+}
+
+// Check that if request overrides the A-L header, the default is not appended.
+// See http://crbug.com/20894
+TEST_F(URLRequestTestHTTP, OverrideAcceptLanguage) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?Accept-Language"),
+                 &d,
+                 &default_context_);
+  HttpRequestHeaders headers;
+  headers.SetHeader(HttpRequestHeaders::kAcceptLanguage, "ru");
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ(std::string("ru"), d.data_received());
+}
+
+// Check that default A-E header is sent.
+TEST_F(URLRequestTestHTTP, DefaultAcceptEncoding) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?Accept-Encoding"),
+                 &d,
+                 &default_context_);
+  HttpRequestHeaders headers;
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(ContainsString(d.data_received(), "gzip"));
+}
+
+// Check that if request overrides the A-E header, the default is not appended.
+// See http://crbug.com/47381
+TEST_F(URLRequestTestHTTP, OverrideAcceptEncoding) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?Accept-Encoding"),
+                 &d,
+                 &default_context_);
+  HttpRequestHeaders headers;
+  headers.SetHeader(HttpRequestHeaders::kAcceptEncoding, "identity");
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_FALSE(ContainsString(d.data_received(), "gzip"));
+  EXPECT_TRUE(ContainsString(d.data_received(), "identity"));
+}
+
+// Check that default A-C header is sent.
+TEST_F(URLRequestTestHTTP, DefaultAcceptCharset) {
+  ASSERT_TRUE(test_server_.Start());
+
+  StaticHttpUserAgentSettings settings(EmptyString(), "en", EmptyString());
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.set_http_user_agent_settings(&settings);
+  context.Init();
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?Accept-Charset"),
+                 &d,
+                 &context);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("en", d.data_received());
+}
+
+// Check that an empty A-C header is not sent. http://crbug.com/77365.
+TEST_F(URLRequestTestHTTP, EmptyAcceptCharset) {
+  ASSERT_TRUE(test_server_.Start());
+
+  StaticHttpUserAgentSettings settings(
+      EmptyString(), EmptyString(), EmptyString());
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+  // We override the accepted charset after initialization because empty
+  // entries get overridden otherwise.
+  context.set_http_user_agent_settings(&settings);
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?Accept-Charset"),
+                 &d,
+                 &context);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ("None", d.data_received());
+}
+
+// Check that if request overrides the A-C header, the default is not appended.
+// See http://crbug.com/20894
+TEST_F(URLRequestTestHTTP, OverrideAcceptCharset) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?Accept-Charset"),
+                 &d,
+                 &default_context_);
+  HttpRequestHeaders headers;
+  headers.SetHeader(HttpRequestHeaders::kAcceptCharset, "koi-8r");
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ(std::string("koi-8r"), d.data_received());
+}
+
+// Check that default User-Agent header is sent.
+TEST_F(URLRequestTestHTTP, DefaultUserAgent) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?User-Agent"),
+                 &d,
+                 &default_context_);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_EQ(req.context()->GetUserAgent(req.url()), d.data_received());
+}
+
+// Check that if request overrides the User-Agent header,
+// the default is not appended.
+TEST_F(URLRequestTestHTTP, OverrideUserAgent) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  URLRequest req(test_server_.GetURL("echoheader?User-Agent"),
+                 &d,
+                 &default_context_);
+  HttpRequestHeaders headers;
+  headers.SetHeader(HttpRequestHeaders::kUserAgent, "Lynx (textmode)");
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+  // If the net tests are being run with ChromeFrame then we need to allow for
+  // the 'chromeframe' suffix which is added to the user agent before the
+  // closing parentheses.
+  EXPECT_TRUE(StartsWithASCII(d.data_received(), "Lynx (textmode", true));
+}
+
+// Check that a NULL HttpUserAgentSettings causes the corresponding empty
+// User-Agent header to be sent but does not send the Accept-Language and
+// Accept-Charset headers.
+TEST_F(URLRequestTestHTTP, EmptyHttpUserAgentSettings) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+  // We override the HttpUserAgentSettings after initialization because empty
+  // entries get overridden by Init().
+  context.set_http_user_agent_settings(NULL);
+
+  struct {
+    const char* request;
+    const char* expected_response;
+  } tests[] = { { "echoheader?Accept-Language", "None" },
+                { "echoheader?Accept-Charset", "None" },
+                { "echoheader?User-Agent", "" } };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
+    TestDelegate d;
+    URLRequest req(test_server_.GetURL(tests[i].request), &d, &context);
+    req.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(tests[i].expected_response, d.data_received())
+        << " Request = \"" << tests[i].request << "\"";
+  }
+}
+
+class HTTPSRequestTest : public testing::Test {
+ public:
+  HTTPSRequestTest() : default_context_(true) {
+    default_context_.set_network_delegate(&default_network_delegate_);
+    default_context_.Init();
+  }
+  virtual ~HTTPSRequestTest() {}
+
+ protected:
+  TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
+  TestURLRequestContext default_context_;
+};
+
+// This test was disabled because it made chrome_frame_net_tests hang
+// (see bug 102991).
+TEST_F(HTTPSRequestTest, DISABLED_HTTPSGetTest) {
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         TestServer::kLocalhost,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server.GetURL(""), &d, &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_NE(0, d.bytes_received());
+    CheckSSLInfo(r.ssl_info());
+    EXPECT_EQ(test_server.host_port_pair().host(),
+              r.GetSocketAddress().host());
+    EXPECT_EQ(test_server.host_port_pair().port(),
+              r.GetSocketAddress().port());
+  }
+}
+
+TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) {
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_MISMATCHED_NAME);
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  bool err_allowed = true;
+  for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
+    TestDelegate d;
+    {
+      d.set_allow_certificate_errors(err_allowed);
+      URLRequest r(test_server.GetURL(""), &d, &default_context_);
+
+      r.Start();
+      EXPECT_TRUE(r.is_pending());
+
+      MessageLoop::current()->Run();
+
+      EXPECT_EQ(1, d.response_started_count());
+      EXPECT_FALSE(d.received_data_before_response());
+      EXPECT_TRUE(d.have_certificate_errors());
+      if (err_allowed) {
+        EXPECT_NE(0, d.bytes_received());
+        CheckSSLInfo(r.ssl_info());
+      } else {
+        EXPECT_EQ(0, d.bytes_received());
+      }
+    }
+  }
+}
+
+TEST_F(HTTPSRequestTest, HTTPSExpiredTest) {
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_EXPIRED);
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  // Iterate from false to true, just so that we do the opposite of the
+  // previous test in order to increase test coverage.
+  bool err_allowed = false;
+  for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
+    TestDelegate d;
+    {
+      d.set_allow_certificate_errors(err_allowed);
+      URLRequest r(test_server.GetURL(""), &d, &default_context_);
+
+      r.Start();
+      EXPECT_TRUE(r.is_pending());
+
+      MessageLoop::current()->Run();
+
+      EXPECT_EQ(1, d.response_started_count());
+      EXPECT_FALSE(d.received_data_before_response());
+      EXPECT_TRUE(d.have_certificate_errors());
+      if (err_allowed) {
+        EXPECT_NE(0, d.bytes_received());
+        CheckSSLInfo(r.ssl_info());
+      } else {
+        EXPECT_EQ(0, d.bytes_received());
+      }
+    }
+  }
+}
+
+// Tests TLSv1.1 -> TLSv1 fallback. Verifies that we don't fall back more
+// than necessary.
+TEST_F(HTTPSRequestTest, TLSv1Fallback) {
+  uint16 default_version_max = SSLConfigService::default_version_max();
+  // The OpenSSL library in use may not support TLS 1.1.
+#if !defined(USE_OPENSSL)
+  EXPECT_GT(default_version_max, SSL_PROTOCOL_VERSION_TLS1);
+#endif
+  if (default_version_max <= SSL_PROTOCOL_VERSION_TLS1)
+    return;
+
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_OK);
+  ssl_options.tls_intolerant =
+      TestServer::SSLOptions::TLS_INTOLERANT_TLS1_1;
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  TestDelegate d;
+  TestURLRequestContext context(true);
+  context.Init();
+  d.set_allow_certificate_errors(true);
+  URLRequest r(test_server.GetURL(""), &d, &context);
+  r.Start();
+
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_NE(0, d.bytes_received());
+  EXPECT_EQ(static_cast<int>(SSL_CONNECTION_VERSION_TLS1),
+            SSLConnectionStatusToVersion(r.ssl_info().connection_status));
+  EXPECT_TRUE(r.ssl_info().connection_status & SSL_CONNECTION_VERSION_FALLBACK);
+}
+
+// This tests that a load of www.google.com with a certificate error sets
+// the |certificate_errors_are_fatal| flag correctly. This flag will cause
+// the interstitial to be fatal.
+TEST_F(HTTPSRequestTest, HTTPSPreloadedHSTSTest) {
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_MISMATCHED_NAME);
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  // We require that the URL be www.google.com in order to pick up the
+  // preloaded HSTS entries in the TransportSecurityState. This means that we
+  // have to use a MockHostResolver in order to direct www.google.com to the
+  // testserver. By default, MockHostResolver maps all hosts to 127.0.0.1.
+
+  MockHostResolver host_resolver;
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.set_host_resolver(&host_resolver);
+  TransportSecurityState transport_security_state;
+  context.set_transport_security_state(&transport_security_state);
+  context.Init();
+
+  TestDelegate d;
+  URLRequest r(GURL(StringPrintf("https://www.google.com:%d",
+                                 test_server.host_port_pair().port())),
+               &d,
+               &context);
+
+  r.Start();
+  EXPECT_TRUE(r.is_pending());
+
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_FALSE(d.received_data_before_response());
+  EXPECT_TRUE(d.have_certificate_errors());
+  EXPECT_TRUE(d.certificate_errors_are_fatal());
+}
+
+// This tests that cached HTTPS page loads do not cause any updates to the
+// TransportSecurityState.
+TEST_F(HTTPSRequestTest, HTTPSErrorsNoClobberTSSTest) {
+  // The actual problem -- CERT_MISMATCHED_NAME in this case -- doesn't
+  // matter. It just has to be any error.
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_MISMATCHED_NAME);
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  // We require that the URL be www.google.com in order to pick up the
+  // preloaded and dynamic HSTS and public key pin entries in the
+  // TransportSecurityState. This means that we have to use a
+  // MockHostResolver in order to direct www.google.com to the testserver.
+  // By default, MockHostResolver maps all hosts to 127.0.0.1.
+
+  MockHostResolver host_resolver;
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+  TestURLRequestContext context(true);
+  context.set_network_delegate(&network_delegate);
+  context.set_host_resolver(&host_resolver);
+  TransportSecurityState transport_security_state;
+  TransportSecurityState::DomainState domain_state;
+  EXPECT_TRUE(transport_security_state.GetDomainState("www.google.com", true,
+                                                      &domain_state));
+  context.set_transport_security_state(&transport_security_state);
+  context.Init();
+
+  TestDelegate d;
+  URLRequest r(GURL(StringPrintf("https://www.google.com:%d",
+                                 test_server.host_port_pair().port())),
+               &d,
+               &context);
+
+  r.Start();
+  EXPECT_TRUE(r.is_pending());
+
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_FALSE(d.received_data_before_response());
+  EXPECT_TRUE(d.have_certificate_errors());
+  EXPECT_TRUE(d.certificate_errors_are_fatal());
+
+  // Get a fresh copy of the state, and check that it hasn't been updated.
+  TransportSecurityState::DomainState new_domain_state;
+  EXPECT_TRUE(transport_security_state.GetDomainState("www.google.com", true,
+                                                      &new_domain_state));
+  EXPECT_EQ(new_domain_state.upgrade_mode, domain_state.upgrade_mode);
+  EXPECT_EQ(new_domain_state.include_subdomains,
+            domain_state.include_subdomains);
+  EXPECT_TRUE(FingerprintsEqual(new_domain_state.static_spki_hashes,
+                                domain_state.static_spki_hashes));
+  EXPECT_TRUE(FingerprintsEqual(new_domain_state.dynamic_spki_hashes,
+                                domain_state.dynamic_spki_hashes));
+  EXPECT_TRUE(FingerprintsEqual(new_domain_state.bad_static_spki_hashes,
+                                domain_state.bad_static_spki_hashes));
+}
+
+// Make sure HSTS preserves a POST request's method and body.
+TEST_F(HTTPSRequestTest, HSTSPreservesPosts) {
+  static const char kData[] = "hello world";
+
+  TestServer::SSLOptions ssl_options(TestServer::SSLOptions::CERT_OK);
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+
+  // Per spec, TransportSecurityState expects a domain name, rather than an IP
+  // address, so a MockHostResolver is needed to redirect www.somewhere.com to
+  // the TestServer.  By default, MockHostResolver maps all hosts to 127.0.0.1.
+  MockHostResolver host_resolver;
+
+  // Force https for www.somewhere.com.
+  TransportSecurityState transport_security_state;
+  net::TransportSecurityState::DomainState domain_state;
+  domain_state.upgrade_expiry =
+      domain_state.created + base::TimeDelta::FromDays(1000);
+  transport_security_state.EnableHost("www.somewhere.com", domain_state);
+
+  TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
+
+  TestURLRequestContext context(true);
+  context.set_host_resolver(&host_resolver);
+  context.set_transport_security_state(&transport_security_state);
+  context.set_network_delegate(&network_delegate);
+  context.Init();
+
+  TestDelegate d;
+  // Navigating to https://www.somewhere.com instead of https://127.0.0.1 will
+  // cause a certificate error.  Ignore the error.
+  d.set_allow_certificate_errors(true);
+
+  URLRequest req(GURL(StringPrintf("http://www.somewhere.com:%d/echo",
+                                   test_server.host_port_pair().port())),
+                 &d,
+                 &context);
+  req.set_method("POST");
+  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+
+  req.Start();
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ("https", req.url().scheme());
+  EXPECT_EQ("POST", req.method());
+  EXPECT_EQ(kData, d.data_received());
+}
+
+TEST_F(HTTPSRequestTest, SSLv3Fallback) {
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_OK);
+  ssl_options.tls_intolerant = TestServer::SSLOptions::TLS_INTOLERANT_ALL;
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  TestDelegate d;
+  TestURLRequestContext context(true);
+  context.Init();
+  d.set_allow_certificate_errors(true);
+  URLRequest r(test_server.GetURL(""), &d, &context);
+  r.Start();
+
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(1, d.response_started_count());
+  EXPECT_NE(0, d.bytes_received());
+  EXPECT_EQ(static_cast<int>(SSL_CONNECTION_VERSION_SSL3),
+            SSLConnectionStatusToVersion(r.ssl_info().connection_status));
+  EXPECT_TRUE(r.ssl_info().connection_status & SSL_CONNECTION_VERSION_FALLBACK);
+}
+
+namespace {
+
+class SSLClientAuthTestDelegate : public TestDelegate {
+ public:
+  SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) {
+  }
+  virtual void OnCertificateRequested(
+      URLRequest* request,
+      SSLCertRequestInfo* cert_request_info) {
+    on_certificate_requested_count_++;
+    MessageLoop::current()->Quit();
+  }
+  int on_certificate_requested_count() {
+    return on_certificate_requested_count_;
+  }
+ private:
+  int on_certificate_requested_count_;
+};
+
+}  // namespace
+
+// TODO(davidben): Test the rest of the code. Specifically,
+// - Filtering which certificates to select.
+// - Sending a certificate back.
+// - Getting a certificate request in an SSL renegotiation sending the
+//   HTTP request.
+TEST_F(HTTPSRequestTest, ClientAuthTest) {
+  TestServer::SSLOptions ssl_options;
+  ssl_options.request_client_certificate = true;
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  SSLClientAuthTestDelegate d;
+  {
+    URLRequest r(test_server.GetURL(""), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.on_certificate_requested_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(0, d.bytes_received());
+
+    // Send no certificate.
+    // TODO(davidben): Get temporary client cert import (with keys) working on
+    // all platforms so we can test sending a cert as well.
+    r.ContinueWithCertificate(NULL);
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_NE(0, d.bytes_received());
+  }
+}
+
+TEST_F(HTTPSRequestTest, ResumeTest) {
+  // Test that we attempt a session resume when making two connections to the
+  // same host.
+  TestServer::SSLOptions ssl_options;
+  ssl_options.record_resume = true;
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  SSLClientSocket::ClearSessionCache();
+
+  {
+    TestDelegate d;
+    URLRequest r(
+        test_server.GetURL("ssl-session-cache"), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+  }
+
+  reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())->
+    CloseAllConnections();
+
+  {
+    TestDelegate d;
+    URLRequest r(
+        test_server.GetURL("ssl-session-cache"), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    // The response will look like;
+    //   insert abc
+    //   lookup abc
+    //   insert xyz
+    //
+    // With a newline at the end which makes the split think that there are
+    // four lines.
+
+    EXPECT_EQ(1, d.response_started_count());
+    std::vector<std::string> lines;
+    base::SplitString(d.data_received(), '\n', &lines);
+    ASSERT_EQ(4u, lines.size()) << d.data_received();
+
+    std::string session_id;
+
+    for (size_t i = 0; i < 2; i++) {
+      std::vector<std::string> parts;
+      base::SplitString(lines[i], '\t', &parts);
+      ASSERT_EQ(2u, parts.size());
+      if (i == 0) {
+        EXPECT_EQ("insert", parts[0]);
+        session_id = parts[1];
+      } else {
+        EXPECT_EQ("lookup", parts[0]);
+        EXPECT_EQ(session_id, parts[1]);
+      }
+    }
+  }
+}
+
+TEST_F(HTTPSRequestTest, SSLSessionCacheShardTest) {
+  // Test that sessions aren't resumed when the value of ssl_session_cache_shard
+  // differs.
+  TestServer::SSLOptions ssl_options;
+  ssl_options.record_resume = true;
+  TestServer test_server(TestServer::TYPE_HTTPS,
+                         ssl_options,
+                         FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  SSLClientSocket::ClearSessionCache();
+
+  {
+    TestDelegate d;
+    URLRequest r(
+        test_server.GetURL("ssl-session-cache"), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+  }
+
+  // Now create a new HttpCache with a different ssl_session_cache_shard value.
+  HttpNetworkSession::Params params;
+  params.host_resolver = default_context_.host_resolver();
+  params.cert_verifier = default_context_.cert_verifier();
+  params.proxy_service = default_context_.proxy_service();
+  params.ssl_config_service = default_context_.ssl_config_service();
+  params.http_auth_handler_factory =
+      default_context_.http_auth_handler_factory();
+  params.network_delegate = default_context_.network_delegate();
+  params.http_server_properties = default_context_.http_server_properties();
+  params.ssl_session_cache_shard = "alternate";
+
+  scoped_ptr<net::HttpCache> cache(new net::HttpCache(
+      new net::HttpNetworkSession(params),
+      net::HttpCache::DefaultBackend::InMemory(0)));
+
+  default_context_.set_http_transaction_factory(cache.get());
+
+  {
+    TestDelegate d;
+    URLRequest r(
+        test_server.GetURL("ssl-session-cache"), &d, &default_context_);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    // The response will look like;
+    //   insert abc
+    //   insert xyz
+    //
+    // With a newline at the end which makes the split think that there are
+    // three lines.
+
+    EXPECT_EQ(1, d.response_started_count());
+    std::vector<std::string> lines;
+    base::SplitString(d.data_received(), '\n', &lines);
+    ASSERT_EQ(3u, lines.size());
+
+    std::string session_id;
+    for (size_t i = 0; i < 2; i++) {
+      std::vector<std::string> parts;
+      base::SplitString(lines[i], '\t', &parts);
+      ASSERT_EQ(2u, parts.size());
+      EXPECT_EQ("insert", parts[0]);
+      if (i == 0) {
+        session_id = parts[1];
+      } else {
+        EXPECT_NE(session_id, parts[1]);
+      }
+    }
+  }
+}
+
+class TestSSLConfigService : public SSLConfigService {
+ public:
+  TestSSLConfigService(bool ev_enabled, bool online_rev_checking)
+      : ev_enabled_(ev_enabled),
+        online_rev_checking_(online_rev_checking) {
+  }
+
+  // SSLConfigService:
+  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {
+    *config = SSLConfig();
+    config->rev_checking_enabled = online_rev_checking_;
+    config->verify_ev_cert = ev_enabled_;
+  }
+
+ protected:
+  virtual ~TestSSLConfigService() {}
+
+ private:
+  const bool ev_enabled_;
+  const bool online_rev_checking_;
+};
+
+// This the fingerprint of the "Testing CA" certificate used by the testserver.
+// See net/data/ssl/certificates/ocsp-test-root.pem.
+static const SHA1HashValue kOCSPTestCertFingerprint =
+  { { 0xf1, 0xad, 0xf6, 0xce, 0x42, 0xac, 0xe7, 0xb4, 0xf4, 0x24,
+      0xdb, 0x1a, 0xf7, 0xa0, 0x9f, 0x09, 0xa1, 0xea, 0xf1, 0x5c } };
+
+// This is the policy OID contained in the certificates that testserver
+// generates.
+static const char kOCSPTestCertPolicy[] = "1.3.6.1.4.1.11129.2.4.1";
+
+class HTTPSOCSPTest : public HTTPSRequestTest {
+ public:
+  HTTPSOCSPTest()
+      : context_(true),
+        ev_test_policy_(
+            new ScopedTestEVPolicy(EVRootCAMetadata::GetInstance(),
+                                   kOCSPTestCertFingerprint,
+                                   kOCSPTestCertPolicy)) {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    SetupContext(&context_);
+    context_.Init();
+
+    scoped_refptr<net::X509Certificate> root_cert =
+      ImportCertFromFile(GetTestCertsDirectory(), "ocsp-test-root.pem");
+    CHECK_NE(static_cast<X509Certificate*>(NULL), root_cert);
+    test_root_.reset(new ScopedTestRoot(root_cert));
+
+#if defined(USE_NSS) || defined(OS_IOS)
+    SetURLRequestContextForNSSHttpIO(&context_);
+    EnsureNSSHttpIOInit();
+#endif
+  }
+
+  void DoConnection(const TestServer::SSLOptions& ssl_options,
+                    CertStatus* out_cert_status) {
+    // We always overwrite out_cert_status.
+    *out_cert_status = 0;
+    TestServer test_server(TestServer::TYPE_HTTPS,
+                           ssl_options,
+                           FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+    ASSERT_TRUE(test_server.Start());
+
+    TestDelegate d;
+    d.set_allow_certificate_errors(true);
+    URLRequest r(test_server.GetURL(""), &d, &context_);
+    r.Start();
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    *out_cert_status = r.ssl_info().cert_status;
+  }
+
+  ~HTTPSOCSPTest() {
+#if defined(USE_NSS) || defined(OS_IOS)
+    ShutdownNSSHttpIO();
+#endif
+  }
+
+ protected:
+  // SetupContext configures the URLRequestContext that will be used for making
+  // connetions to testserver. This can be overridden in test subclasses for
+  // different behaviour.
+  virtual void SetupContext(URLRequestContext* context) {
+    context->set_ssl_config_service(
+        new TestSSLConfigService(true /* check for EV */,
+                                 true /* online revocation checking */));
+  }
+
+  scoped_ptr<ScopedTestRoot> test_root_;
+  TestURLRequestContext context_;
+  scoped_ptr<ScopedTestEVPolicy> ev_test_policy_;
+};
+
+static CertStatus ExpectedCertStatusForFailedOnlineRevocationCheck() {
+#if defined(OS_WIN)
+  // Windows can return CERT_STATUS_UNABLE_TO_CHECK_REVOCATION but we don't
+  // have that ability on other platforms.
+  return CERT_STATUS_UNABLE_TO_CHECK_REVOCATION;
+#else
+  return 0;
+#endif
+}
+
+// SystemUsesChromiumEVMetadata returns true iff the current operating system
+// uses Chromium's EV metadata (i.e. EVRootCAMetadata). If it does not, then
+// several tests are effected because our testing EV certificate won't be
+// recognised as EV.
+static bool SystemUsesChromiumEVMetadata() {
+#if defined(USE_OPENSSL)
+  // http://crbug.com/117478 - OpenSSL does not support EV validation.
+  return false;
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+  // On OS X, we use the system to tell us whether a certificate is EV or not
+  // and the system won't recognise our testing root.
+  return false;
+#else
+  return true;
+#endif
+}
+
+static bool SystemSupportsOCSP() {
+#if defined(USE_OPENSSL)
+  // http://crbug.com/117478 - OpenSSL does not support OCSP.
+  return false;
+#elif defined(OS_WIN)
+  return base::win::GetVersion() >= base::win::VERSION_VISTA;
+#elif defined(OS_ANDROID)
+  // TODO(jnd): http://crbug.com/117478 - EV verification is not yet supported.
+  return false;
+#else
+  return true;
+#endif
+}
+
+TEST_F(HTTPSOCSPTest, Valid) {
+  if (!SystemSupportsOCSP()) {
+    LOG(WARNING) << "Skipping test because system doesn't support OCSP";
+    return;
+  }
+
+  TestServer::SSLOptions ssl_options(TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_OK;
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
+
+  EXPECT_EQ(SystemUsesChromiumEVMetadata(),
+            static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
+
+  EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
+}
+
+TEST_F(HTTPSOCSPTest, Revoked) {
+  if (!SystemSupportsOCSP()) {
+    LOG(WARNING) << "Skipping test because system doesn't support OCSP";
+    return;
+  }
+
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_REVOKED;
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+#if !(defined(OS_MACOSX) && !defined(OS_IOS))
+  // Doesn't pass on OS X yet for reasons that need to be investigated.
+  EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
+#endif
+  EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
+  EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
+}
+
+TEST_F(HTTPSOCSPTest, Invalid) {
+  if (!SystemSupportsOCSP()) {
+    LOG(WARNING) << "Skipping test because system doesn't support OCSP";
+    return;
+  }
+
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_INVALID;
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
+            cert_status & CERT_STATUS_ALL_ERRORS);
+
+  // Without a positive OCSP response, we shouldn't show the EV status.
+  EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
+  EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
+}
+
+class HTTPSEVCRLSetTest : public HTTPSOCSPTest {
+ protected:
+  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+    context->set_ssl_config_service(
+        new TestSSLConfigService(true /* check for EV */,
+                                 false /* online revocation checking */));
+  }
+};
+
+TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndInvalidOCSP) {
+  if (!SystemSupportsOCSP()) {
+    LOG(WARNING) << "Skipping test because system doesn't support OCSP";
+    return;
+  }
+
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_INVALID;
+  SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>());
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
+            cert_status & CERT_STATUS_ALL_ERRORS);
+
+  EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
+  EXPECT_EQ(SystemUsesChromiumEVMetadata(),
+            static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
+}
+
+TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndGoodOCSP) {
+  if (!SystemSupportsOCSP()) {
+    LOG(WARNING) << "Skipping test because system doesn't support OCSP";
+    return;
+  }
+
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_OK;
+  SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>());
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
+
+  EXPECT_EQ(SystemUsesChromiumEVMetadata(),
+            static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
+  EXPECT_EQ(SystemUsesChromiumEVMetadata(),
+            static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
+}
+
+TEST_F(HTTPSEVCRLSetTest, ExpiredCRLSet) {
+  if (!SystemSupportsOCSP()) {
+    LOG(WARNING) << "Skipping test because system doesn't support OCSP";
+    return;
+  }
+
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_INVALID;
+  SSLConfigService::SetCRLSet(
+      scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting()));
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
+            cert_status & CERT_STATUS_ALL_ERRORS);
+
+  EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
+  EXPECT_EQ(SystemUsesChromiumEVMetadata(),
+            static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
+}
+
+TEST_F(HTTPSEVCRLSetTest, FreshCRLSet) {
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_INVALID;
+  SSLConfigService::SetCRLSet(
+      scoped_refptr<CRLSet>(CRLSet::EmptyCRLSetForTesting()));
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  // With a valid, fresh CRLSet the bad OCSP response shouldn't matter because
+  // we wont check it.
+  EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
+
+  EXPECT_EQ(SystemUsesChromiumEVMetadata(),
+            static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
+
+  EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
+}
+
+TEST_F(HTTPSEVCRLSetTest, ExpiredCRLSetAndRevokedNonEVCert) {
+  // Test that when EV verification is requested, but online revocation
+  // checking is disabled, and the leaf certificate is not in fact EV, that
+  // no revocation checking actually happens.
+  if (!SystemSupportsOCSP()) {
+    LOG(WARNING) << "Skipping test because system doesn't support OCSP";
+    return;
+  }
+
+  // Unmark the certificate's OID as EV, which should disable revocation
+  // checking (as per the user preference)
+  ev_test_policy_.reset();
+
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_REVOKED;
+  SSLConfigService::SetCRLSet(
+      scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting()));
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
+
+  EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
+  EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
+}
+
+class HTTPSCRLSetTest : public HTTPSOCSPTest {
+ protected:
+  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+    context->set_ssl_config_service(
+        new TestSSLConfigService(false /* check for EV */,
+                                 false /* online revocation checking */));
+  }
+};
+
+TEST_F(HTTPSCRLSetTest, ExpiredCRLSet) {
+  TestServer::SSLOptions ssl_options(
+      TestServer::SSLOptions::CERT_AUTO);
+  ssl_options.ocsp_status = TestServer::SSLOptions::OCSP_INVALID;
+  SSLConfigService::SetCRLSet(
+      scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting()));
+
+  CertStatus cert_status;
+  DoConnection(ssl_options, &cert_status);
+
+  // If we're not trying EV verification then, even if the CRLSet has expired,
+  // we don't fall back to online revocation checks.
+  EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
+  EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
+  EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
+}
+#endif  // !defined(OS_IOS)
+
+#if !defined(DISABLE_FTP_SUPPORT)
+class URLRequestTestFTP : public URLRequestTest {
+ public:
+  URLRequestTestFTP()
+      : test_server_(TestServer::TYPE_FTP, TestServer::kLocalhost, FilePath()) {
+  }
+
+ protected:
+  TestServer test_server_;
+};
+
+// Make sure an FTP request using an unsafe ports fails.
+TEST_F(URLRequestTestFTP, FLAKY_UnsafePort) {
+  ASSERT_TRUE(test_server_.Start());
+
+  URLRequestJobFactoryImpl job_factory;
+
+  GURL url("ftp://127.0.0.1:7");
+  FtpProtocolHandler ftp_protocol_handler(
+      default_context_.ftp_transaction_factory(),
+      default_context_.ftp_auth_cache());
+  job_factory.SetProtocolHandler(
+      "ftp",
+      new FtpProtocolHandler(default_context_.ftp_transaction_factory(),
+                             default_context_.ftp_auth_cache()));
+  default_context_.set_job_factory(&job_factory);
+
+  TestDelegate d;
+  {
+    URLRequest r(url, &d, &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(ERR_UNSAFE_PORT, r.status().error());
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPDirectoryListing) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL("/"), &d, &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_LT(0, d.bytes_received());
+    EXPECT_EQ(test_server_.host_port_pair().host(),
+              r.GetSocketAddress().host());
+    EXPECT_EQ(test_server_.host_port_pair().port(),
+              r.GetSocketAddress().port());
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPGetTestAnonymous) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+  TestDelegate d;
+  {
+    URLRequest r(test_server_.GetURL("/LICENSE"), &d, &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(test_server_.host_port_pair().host(),
+              r.GetSocketAddress().host());
+    EXPECT_EQ(test_server_.host_port_pair().port(),
+              r.GetSocketAddress().port());
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPGetTest) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+  TestDelegate d;
+  {
+    URLRequest r(
+        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome", "chrome"),
+        &d,
+        &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(test_server_.host_port_pair().host(),
+              r.GetSocketAddress().host());
+    EXPECT_EQ(test_server_.host_port_pair().port(),
+              r.GetSocketAddress().port());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPassword) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+  TestDelegate d;
+  {
+    URLRequest r(
+        test_server_.GetURLWithUserAndPassword("/LICENSE",
+                                               "chrome",
+                                               "wrong_password"),
+        &d,
+        &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), 0);
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPasswordRestart) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+  TestDelegate d;
+  // Set correct login credentials. The delegate will be asked for them when
+  // the initial login with wrong credentials will fail.
+  d.set_credentials(AuthCredentials(kChrome, kChrome));
+  {
+    URLRequest r(
+        test_server_.GetURLWithUserAndPassword("/LICENSE",
+                                               "chrome",
+                                               "wrong_password"),
+        &d,
+        &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongUser) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+  TestDelegate d;
+  {
+    URLRequest r(
+        test_server_.GetURLWithUserAndPassword("/LICENSE",
+                                               "wrong_user",
+                                               "chrome"),
+        &d,
+        &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), 0);
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongUserRestart) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+  TestDelegate d;
+  // Set correct login credentials. The delegate will be asked for them when
+  // the initial login with wrong credentials will fail.
+  d.set_credentials(AuthCredentials(kChrome, kChrome));
+  {
+    URLRequest r(
+        test_server_.GetURLWithUserAndPassword("/LICENSE",
+                                               "wrong_user",
+                                               "chrome"),
+        &d,
+        &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPCacheURLCredentials) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+
+  scoped_ptr<TestDelegate> d(new TestDelegate);
+  {
+    // Pass correct login identity in the URL.
+    URLRequest r(
+        test_server_.GetURLWithUserAndPassword("/LICENSE",
+                                               "chrome",
+                                               "chrome"),
+        d.get(),
+        &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d->response_started_count());
+    EXPECT_FALSE(d->received_data_before_response());
+    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+  }
+
+  d.reset(new TestDelegate);
+  {
+    // This request should use cached identity from previous request.
+    URLRequest r(test_server_.GetURL("/LICENSE"), d.get(), &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d->response_started_count());
+    EXPECT_FALSE(d->received_data_before_response());
+    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+  }
+}
+
+// Flaky, see http://crbug.com/25045.
+TEST_F(URLRequestTestFTP, DISABLED_FTPCacheLoginBoxCredentials) {
+  ASSERT_TRUE(test_server_.Start());
+
+  FilePath app_path;
+  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
+  app_path = app_path.AppendASCII("LICENSE");
+
+  scoped_ptr<TestDelegate> d(new TestDelegate);
+  // Set correct login credentials. The delegate will be asked for them when
+  // the initial login with wrong credentials will fail.
+  d->set_credentials(AuthCredentials(kChrome, kChrome));
+  {
+    URLRequest r(
+        test_server_.GetURLWithUserAndPassword("/LICENSE",
+                                               "chrome",
+                                               "wrong_password"),
+        d.get(),
+        &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d->response_started_count());
+    EXPECT_FALSE(d->received_data_before_response());
+    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+  }
+
+  // Use a new delegate without explicit credentials. The cached ones should be
+  // used.
+  d.reset(new TestDelegate);
+  {
+    // Don't pass wrong credentials in the URL, they would override valid cached
+    // ones.
+    URLRequest r(test_server_.GetURL("/LICENSE"), d.get(), &default_context_);
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    int64 file_size = 0;
+    file_util::GetFileSize(app_path, &file_size);
+
+    EXPECT_FALSE(r.is_pending());
+    EXPECT_EQ(1, d->response_started_count());
+    EXPECT_FALSE(d->received_data_before_response());
+    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+  }
+}
+#endif  // !defined(DISABLE_FTP_SUPPORT)
+
+}  // namespace net
diff --git a/src/net/url_request/view_cache_helper.cc b/src/net/url_request/view_cache_helper.cc
new file mode 100644
index 0000000..d468075
--- /dev/null
+++ b/src/net/url_request/view_cache_helper.cc
@@ -0,0 +1,360 @@
+// 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 "net/url_request/view_cache_helper.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/stringprintf.h"
+#include "net/base/escape.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/http/http_cache.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_response_info.h"
+#include "net/url_request/url_request_context.h"
+
+#define VIEW_CACHE_HEAD \
+  "<html><meta charset=\"utf-8\">" \
+  "<meta http-equiv=\"Content-Security-Policy\" " \
+  "  content=\"object-src 'none'; script-src 'none' 'unsafe-eval'\">" \
+  "<body><table>"
+
+#define VIEW_CACHE_TAIL \
+  "</table></body></html>"
+
+namespace net {
+
+namespace {
+
+std::string FormatEntryInfo(disk_cache::Entry* entry,
+                            const std::string& url_prefix) {
+  std::string key = entry->GetKey();
+  GURL url = GURL(url_prefix + key);
+  std::string row =
+      "<tr><td><a href=\"" + url.spec() + "\">" + EscapeForHTML(key) +
+      "</a></td></tr>";
+  return row;
+}
+
+}  // namespace.
+
+ViewCacheHelper::ViewCacheHelper()
+    : context_(NULL),
+      disk_cache_(NULL),
+      entry_(NULL),
+      iter_(NULL),
+      buf_len_(0),
+      index_(0),
+      data_(NULL),
+      next_state_(STATE_NONE),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+}
+
+ViewCacheHelper::~ViewCacheHelper() {
+  if (entry_)
+    entry_->Close();
+}
+
+int ViewCacheHelper::GetEntryInfoHTML(const std::string& key,
+                                      const URLRequestContext* context,
+                                      std::string* out,
+                                      const CompletionCallback& callback) {
+  return GetInfoHTML(key, context, std::string(), out, callback);
+}
+
+int ViewCacheHelper::GetContentsHTML(const URLRequestContext* context,
+                                     const std::string& url_prefix,
+                                     std::string* out,
+                                     const CompletionCallback& callback) {
+  return GetInfoHTML(std::string(), context, url_prefix, out, callback);
+}
+
+// static
+void ViewCacheHelper::HexDump(const char *buf, size_t buf_len,
+                              std::string* result) {
+  const size_t kMaxRows = 16;
+  int offset = 0;
+
+  const unsigned char *p;
+  while (buf_len) {
+    base::StringAppendF(result, "%08x:  ", offset);
+    offset += kMaxRows;
+
+    p = (const unsigned char *) buf;
+
+    size_t i;
+    size_t row_max = std::min(kMaxRows, buf_len);
+
+    // print hex codes:
+    for (i = 0; i < row_max; ++i)
+      base::StringAppendF(result, "%02x  ", *p++);
+    for (i = row_max; i < kMaxRows; ++i)
+      result->append("    ");
+
+    // print ASCII glyphs if possible:
+    p = (const unsigned char *) buf;
+    for (i = 0; i < row_max; ++i, ++p) {
+      if (*p < 0x7F && *p > 0x1F) {
+        AppendEscapedCharForHTML(*p, result);
+      } else {
+        result->push_back('.');
+      }
+    }
+
+    result->push_back('\n');
+
+    buf += row_max;
+    buf_len -= row_max;
+  }
+}
+
+//-----------------------------------------------------------------------------
+
+int ViewCacheHelper::GetInfoHTML(const std::string& key,
+                                 const URLRequestContext* context,
+                                 const std::string& url_prefix,
+                                 std::string* out,
+                                 const CompletionCallback& callback) {
+  DCHECK(callback_.is_null());
+  DCHECK(context);
+  key_ = key;
+  context_ = context;
+  url_prefix_ = url_prefix;
+  data_ = out;
+  next_state_ = STATE_GET_BACKEND;
+  int rv = DoLoop(OK);
+
+  if (rv == ERR_IO_PENDING)
+    callback_ = callback;
+
+  return rv;
+}
+
+void ViewCacheHelper::DoCallback(int rv) {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  DCHECK(!callback_.is_null());
+
+  callback_.Run(rv);
+  callback_.Reset();
+}
+
+void ViewCacheHelper::HandleResult(int rv) {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  DCHECK_NE(ERR_FAILED, rv);
+  context_ = NULL;
+  if (!callback_.is_null())
+    DoCallback(rv);
+}
+
+int ViewCacheHelper::DoLoop(int result) {
+  DCHECK(next_state_ != STATE_NONE);
+
+  int rv = result;
+  do {
+    State state = next_state_;
+    next_state_ = STATE_NONE;
+    switch (state) {
+      case STATE_GET_BACKEND:
+        DCHECK_EQ(OK, rv);
+        rv = DoGetBackend();
+        break;
+      case STATE_GET_BACKEND_COMPLETE:
+        rv = DoGetBackendComplete(rv);
+        break;
+      case STATE_OPEN_NEXT_ENTRY:
+        DCHECK_EQ(OK, rv);
+        rv = DoOpenNextEntry();
+        break;
+      case STATE_OPEN_NEXT_ENTRY_COMPLETE:
+        rv = DoOpenNextEntryComplete(rv);
+        break;
+      case STATE_OPEN_ENTRY:
+        DCHECK_EQ(OK, rv);
+        rv = DoOpenEntry();
+        break;
+      case STATE_OPEN_ENTRY_COMPLETE:
+        rv = DoOpenEntryComplete(rv);
+        break;
+      case STATE_READ_RESPONSE:
+        DCHECK_EQ(OK, rv);
+        rv = DoReadResponse();
+        break;
+      case STATE_READ_RESPONSE_COMPLETE:
+        rv = DoReadResponseComplete(rv);
+        break;
+      case STATE_READ_DATA:
+        DCHECK_EQ(OK, rv);
+        rv = DoReadData();
+        break;
+      case STATE_READ_DATA_COMPLETE:
+        rv = DoReadDataComplete(rv);
+        break;
+
+      default:
+        NOTREACHED() << "bad state";
+        rv = ERR_FAILED;
+        break;
+    }
+  } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
+
+  if (rv != ERR_IO_PENDING)
+    HandleResult(rv);
+
+  return rv;
+}
+
+int ViewCacheHelper::DoGetBackend() {
+  next_state_ = STATE_GET_BACKEND_COMPLETE;
+
+  if (!context_->http_transaction_factory())
+    return ERR_FAILED;
+
+  HttpCache* http_cache = context_->http_transaction_factory()->GetCache();
+  if (!http_cache)
+    return ERR_FAILED;
+
+  return http_cache->GetBackend(
+      &disk_cache_, base::Bind(&ViewCacheHelper::OnIOComplete,
+                               base::Unretained(this)));
+}
+
+int ViewCacheHelper::DoGetBackendComplete(int result) {
+  if (result == ERR_FAILED) {
+    data_->append("no disk cache");
+    return OK;
+  }
+
+  DCHECK_EQ(OK, result);
+  if (key_.empty()) {
+    data_->assign(VIEW_CACHE_HEAD);
+    DCHECK(!iter_);
+    next_state_ = STATE_OPEN_NEXT_ENTRY;
+    return OK;
+  }
+
+  next_state_ = STATE_OPEN_ENTRY;
+  return OK;
+}
+
+int ViewCacheHelper::DoOpenNextEntry() {
+  next_state_ = STATE_OPEN_NEXT_ENTRY_COMPLETE;
+  return disk_cache_->OpenNextEntry(
+      &iter_, &entry_,
+      base::Bind(&ViewCacheHelper::OnIOComplete, base::Unretained(this)));
+}
+
+int ViewCacheHelper::DoOpenNextEntryComplete(int result) {
+  if (result == ERR_FAILED) {
+    data_->append(VIEW_CACHE_TAIL);
+    return OK;
+  }
+
+  DCHECK_EQ(OK, result);
+  data_->append(FormatEntryInfo(entry_, url_prefix_));
+  entry_->Close();
+  entry_ = NULL;
+
+  next_state_ = STATE_OPEN_NEXT_ENTRY;
+  return OK;
+}
+
+int ViewCacheHelper::DoOpenEntry() {
+  next_state_ = STATE_OPEN_ENTRY_COMPLETE;
+  return disk_cache_->OpenEntry(
+      key_, &entry_,
+      base::Bind(&ViewCacheHelper::OnIOComplete, base::Unretained(this)));
+}
+
+int ViewCacheHelper::DoOpenEntryComplete(int result) {
+  if (result == ERR_FAILED) {
+    data_->append("no matching cache entry for: " + EscapeForHTML(key_));
+    return OK;
+  }
+
+  data_->assign(VIEW_CACHE_HEAD);
+  data_->append(EscapeForHTML(entry_->GetKey()));
+  next_state_ = STATE_READ_RESPONSE;
+  return OK;
+}
+
+int ViewCacheHelper::DoReadResponse() {
+  next_state_ = STATE_READ_RESPONSE_COMPLETE;
+  buf_len_ = entry_->GetDataSize(0);
+  if (!buf_len_)
+    return buf_len_;
+
+  buf_ = new IOBuffer(buf_len_);
+  return entry_->ReadData(
+      0, 0, buf_, buf_len_,
+      base::Bind(&ViewCacheHelper::OnIOComplete, weak_factory_.GetWeakPtr()));
+}
+
+int ViewCacheHelper::DoReadResponseComplete(int result) {
+  if (result && result == buf_len_) {
+    HttpResponseInfo response;
+    bool truncated;
+    if (HttpCache::ParseResponseInfo(buf_->data(), buf_len_, &response,
+                                          &truncated) &&
+        response.headers) {
+      if (truncated)
+        data_->append("<pre>RESPONSE_INFO_TRUNCATED</pre>");
+
+      data_->append("<hr><pre>");
+      data_->append(EscapeForHTML(response.headers->GetStatusLine()));
+      data_->push_back('\n');
+
+      void* iter = NULL;
+      std::string name, value;
+      while (response.headers->EnumerateHeaderLines(&iter, &name, &value)) {
+        data_->append(EscapeForHTML(name));
+        data_->append(": ");
+        data_->append(EscapeForHTML(value));
+        data_->push_back('\n');
+      }
+      data_->append("</pre>");
+    }
+  }
+
+  index_ = 0;
+  next_state_ = STATE_READ_DATA;
+  return OK;
+}
+
+int ViewCacheHelper::DoReadData() {
+  data_->append("<hr><pre>");
+
+  next_state_ = STATE_READ_DATA_COMPLETE;
+  buf_len_ = entry_->GetDataSize(index_);
+  if (!buf_len_)
+    return buf_len_;
+
+  buf_ = new IOBuffer(buf_len_);
+  return entry_->ReadData(
+      index_, 0, buf_, buf_len_,
+      base::Bind(&ViewCacheHelper::OnIOComplete, weak_factory_.GetWeakPtr()));
+}
+
+int ViewCacheHelper::DoReadDataComplete(int result) {
+  if (result && result == buf_len_) {
+    HexDump(buf_->data(), buf_len_, data_);
+  }
+  data_->append("</pre>");
+  index_++;
+  if (index_ < HttpCache::kNumCacheEntryDataIndices) {
+    next_state_ = STATE_READ_DATA;
+  } else {
+    data_->append(VIEW_CACHE_TAIL);
+    entry_->Close();
+    entry_ = NULL;
+  }
+  return OK;
+}
+
+void ViewCacheHelper::OnIOComplete(int result) {
+  DoLoop(result);
+}
+
+}  // namespace net.
diff --git a/src/net/url_request/view_cache_helper.h b/src/net/url_request/view_cache_helper.h
new file mode 100644
index 0000000..d5a7c42
--- /dev/null
+++ b/src/net/url_request/view_cache_helper.h
@@ -0,0 +1,124 @@
+// 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.
+
+#ifndef NET_URL_REQUEST_VIEW_CACHE_HELPER_H_
+#define NET_URL_REQUEST_VIEW_CACHE_HELPER_H_
+
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "net/base/completion_callback.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_export.h"
+
+namespace disk_cache {
+class Backend;
+class Entry;
+}  // namespace disk_cache
+
+namespace net {
+
+class URLRequestContext;
+
+class NET_EXPORT ViewCacheHelper {
+ public:
+  ViewCacheHelper();
+  ~ViewCacheHelper();
+
+  // Formats the cache information for |key| as HTML. Returns a net error code.
+  // If this method returns ERR_IO_PENDING, |callback| will be notified when the
+  // operation completes. |out| must remain valid until this operation completes
+  // or the object is destroyed.
+  int GetEntryInfoHTML(const std::string& key,
+                       const URLRequestContext* context,
+                       std::string* out,
+                       const CompletionCallback& callback);
+
+  // Formats the cache contents as HTML. Returns a net error code.
+  // If this method returns ERR_IO_PENDING, |callback| will be notified when the
+  // operation completes. |out| must remain valid until this operation completes
+  // or the object is destroyed. |url_prefix| will be prepended to each entry
+  // key as a link to the entry.
+  int GetContentsHTML(const URLRequestContext* context,
+                      const std::string& url_prefix,
+                      std::string* out,
+                      const CompletionCallback& callback);
+
+  // Lower-level helper to produce a textual representation of binary data.
+  // The results are appended to |result| and can be used in HTML pages
+  // provided the dump is contained within <pre></pre> tags.
+  static void HexDump(const char *buf, size_t buf_len, std::string* result);
+
+ private:
+  enum State {
+    STATE_NONE,
+    STATE_GET_BACKEND,
+    STATE_GET_BACKEND_COMPLETE,
+    STATE_OPEN_NEXT_ENTRY,
+    STATE_OPEN_NEXT_ENTRY_COMPLETE,
+    STATE_OPEN_ENTRY,
+    STATE_OPEN_ENTRY_COMPLETE,
+    STATE_READ_RESPONSE,
+    STATE_READ_RESPONSE_COMPLETE,
+    STATE_READ_DATA,
+    STATE_READ_DATA_COMPLETE
+  };
+
+  // Implements GetEntryInfoHTML and GetContentsHTML.
+  int GetInfoHTML(const std::string& key,
+                  const URLRequestContext* context,
+                  const std::string& url_prefix,
+                  std::string* out,
+                  const CompletionCallback& callback);
+
+  // This is a helper function used to trigger a completion callback. It may
+  // only be called if callback_ is non-null.
+  void DoCallback(int rv);
+
+  // This will trigger the completion callback if appropriate.
+  void HandleResult(int rv);
+
+  // Runs the state transition loop.
+  int DoLoop(int result);
+
+  // Each of these methods corresponds to a State value. If there is an
+  // argument, the value corresponds to the return of the previous state or
+  // corresponding callback.
+  int DoGetBackend();
+  int DoGetBackendComplete(int result);
+  int DoOpenNextEntry();
+  int DoOpenNextEntryComplete(int result);
+  int DoOpenEntry();
+  int DoOpenEntryComplete(int result);
+  int DoReadResponse();
+  int DoReadResponseComplete(int result);
+  int DoReadData();
+  int DoReadDataComplete(int result);
+
+  // Called to signal completion of asynchronous IO.
+  void OnIOComplete(int result);
+
+  const URLRequestContext* context_;
+  disk_cache::Backend* disk_cache_;
+  disk_cache::Entry* entry_;
+  void* iter_;
+  scoped_refptr<IOBuffer> buf_;
+  int buf_len_;
+  int index_;
+
+  std::string key_;
+  std::string url_prefix_;
+  std::string* data_;
+  CompletionCallback callback_;
+
+  State next_state_;
+
+  base::WeakPtrFactory<ViewCacheHelper> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ViewCacheHelper);
+};
+
+}  // namespace net.
+
+#endif  // NET_URL_REQUEST_VIEW_CACHE_HELPER_H_
diff --git a/src/net/url_request/view_cache_helper_unittest.cc b/src/net/url_request/view_cache_helper_unittest.cc
new file mode 100644
index 0000000..9fda85b
--- /dev/null
+++ b/src/net/url_request/view_cache_helper_unittest.cc
@@ -0,0 +1,225 @@
+// 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 "net/url_request/view_cache_helper.h"
+
+#include "base/pickle.h"
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/http/http_cache.h"
+#include "net/url_request/url_request_context.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+// Disk cache is turned off in lb_shell (http_cache.cc:CreateBackend())
+// The following cases which are using backend cache should be disabled:
+// ListContents, DumpEntry, Prefix, and TruncatedFlag
+#if defined(__LB_SHELL__) || defined(COBALT)
+#define MAYBE_ListContents DISABLED_ListContents
+#define MAYBE_DumpEntry DISABLED_DumpEntry
+#define MAYBE_Prefix DISABLED_Prefix
+#define MAYBE_TruncatedFlag DISABLED_TruncatedFlag
+#else
+#define MAYBE_ListContents ListContents
+#define MAYBE_DumpEntry DumpEntry
+#define MAYBE_Prefix Prefix
+#define MAYBE_TruncatedFlag TruncatedFlag
+#endif
+
+class TestURLRequestContext : public URLRequestContext {
+ public:
+  TestURLRequestContext();
+  virtual ~TestURLRequestContext() {}
+
+  // Gets a pointer to the cache backend.
+  disk_cache::Backend* GetBackend();
+
+ private:
+  HttpCache cache_;
+};
+
+TestURLRequestContext::TestURLRequestContext()
+    : cache_(reinterpret_cast<HttpTransactionFactory*>(NULL), NULL,
+             HttpCache::DefaultBackend::InMemory(0)) {
+  set_http_transaction_factory(&cache_);
+}
+
+void WriteHeaders(disk_cache::Entry* entry, int flags, const std::string data) {
+  if (data.empty())
+    return;
+
+  Pickle pickle;
+  pickle.WriteInt(flags | 1);  // Version 1.
+  pickle.WriteInt64(0);
+  pickle.WriteInt64(0);
+  pickle.WriteString(data);
+
+  scoped_refptr<WrappedIOBuffer> buf(new WrappedIOBuffer(
+      reinterpret_cast<const char*>(pickle.data())));
+  int len = static_cast<int>(pickle.size());
+
+  net::TestCompletionCallback cb;
+  int rv = entry->WriteData(0, 0, buf, len, cb.callback(), true);
+  ASSERT_EQ(len, cb.GetResult(rv));
+}
+
+void WriteData(disk_cache::Entry* entry, int index, const std::string data) {
+  if (data.empty())
+    return;
+
+  int len = data.length();
+  scoped_refptr<IOBuffer> buf(new IOBuffer(len));
+  memcpy(buf->data(), data.data(), data.length());
+
+  net::TestCompletionCallback cb;
+  int rv = entry->WriteData(index, 0, buf, len, cb.callback(), true);
+  ASSERT_EQ(len, cb.GetResult(rv));
+}
+
+void WriteToEntry(disk_cache::Backend* cache, const std::string key,
+                  const std::string data0, const std::string data1,
+                  const std::string data2) {
+  net::TestCompletionCallback cb;
+  disk_cache::Entry* entry;
+  int rv = cache->CreateEntry(key, &entry, cb.callback());
+  rv = cb.GetResult(rv);
+  if (rv != OK) {
+    rv = cache->OpenEntry(key, &entry, cb.callback());
+    ASSERT_EQ(OK, cb.GetResult(rv));
+  }
+
+  WriteHeaders(entry, 0, data0);
+  WriteData(entry, 1, data1);
+  WriteData(entry, 2, data2);
+
+  entry->Close();
+}
+
+void FillCache(URLRequestContext* context) {
+  net::TestCompletionCallback cb;
+  disk_cache::Backend* cache;
+  int rv =
+      context->http_transaction_factory()->GetCache()->GetBackend(
+          &cache, cb.callback());
+  ASSERT_EQ(OK, cb.GetResult(rv));
+
+  std::string empty;
+  WriteToEntry(cache, "first", "some", empty, empty);
+  WriteToEntry(cache, "second", "only hex_dumped", "same", "kind");
+  WriteToEntry(cache, "third", empty, "another", "thing");
+}
+
+}  // namespace.
+
+TEST(ViewCacheHelper, EmptyCache) {
+  TestURLRequestContext context;
+  ViewCacheHelper helper;
+
+  TestCompletionCallback cb;
+  std::string prefix, data;
+  int rv = helper.GetContentsHTML(&context, prefix, &data, cb.callback());
+  EXPECT_EQ(OK, cb.GetResult(rv));
+  EXPECT_FALSE(data.empty());
+}
+
+TEST(ViewCacheHelper, MAYBE_ListContents) {
+  TestURLRequestContext context;
+  ViewCacheHelper helper;
+
+  FillCache(&context);
+
+  std::string prefix, data;
+  TestCompletionCallback cb;
+  int rv = helper.GetContentsHTML(&context, prefix, &data, cb.callback());
+  EXPECT_EQ(OK, cb.GetResult(rv));
+
+  EXPECT_EQ(0U, data.find("<html>"));
+  EXPECT_NE(std::string::npos, data.find("</html>"));
+  EXPECT_NE(std::string::npos, data.find("first"));
+  EXPECT_NE(std::string::npos, data.find("second"));
+  EXPECT_NE(std::string::npos, data.find("third"));
+
+  EXPECT_EQ(std::string::npos, data.find("some"));
+  EXPECT_EQ(std::string::npos, data.find("same"));
+  EXPECT_EQ(std::string::npos, data.find("thing"));
+}
+
+TEST(ViewCacheHelper, MAYBE_DumpEntry) {
+  TestURLRequestContext context;
+  ViewCacheHelper helper;
+
+  FillCache(&context);
+
+  std::string data;
+  TestCompletionCallback cb;
+  int rv = helper.GetEntryInfoHTML("second", &context, &data, cb.callback());
+  EXPECT_EQ(OK, cb.GetResult(rv));
+
+  EXPECT_EQ(0U, data.find("<html>"));
+  EXPECT_NE(std::string::npos, data.find("</html>"));
+
+  EXPECT_NE(std::string::npos, data.find("hex_dumped"));
+  EXPECT_NE(std::string::npos, data.find("same"));
+  EXPECT_NE(std::string::npos, data.find("kind"));
+
+  EXPECT_EQ(std::string::npos, data.find("first"));
+  EXPECT_EQ(std::string::npos, data.find("third"));
+  EXPECT_EQ(std::string::npos, data.find("some"));
+  EXPECT_EQ(std::string::npos, data.find("another"));
+}
+
+// Makes sure the links are correct.
+TEST(ViewCacheHelper, MAYBE_Prefix) {
+  TestURLRequestContext context;
+  ViewCacheHelper helper;
+
+  FillCache(&context);
+
+  std::string key, data;
+  std::string prefix("prefix:");
+  TestCompletionCallback cb;
+  int rv = helper.GetContentsHTML(&context, prefix, &data, cb.callback());
+  EXPECT_EQ(OK, cb.GetResult(rv));
+
+  EXPECT_EQ(0U, data.find("<html>"));
+  EXPECT_NE(std::string::npos, data.find("</html>"));
+  EXPECT_NE(std::string::npos, data.find("<a href=\"prefix:first\">"));
+  EXPECT_NE(std::string::npos, data.find("<a href=\"prefix:second\">"));
+  EXPECT_NE(std::string::npos, data.find("<a href=\"prefix:third\">"));
+}
+
+TEST(ViewCacheHelper, MAYBE_TruncatedFlag) {
+  TestURLRequestContext context;
+  ViewCacheHelper helper;
+
+  net::TestCompletionCallback cb;
+  disk_cache::Backend* cache;
+  int rv =
+      context.http_transaction_factory()->GetCache()->GetBackend(
+          &cache, cb.callback());
+  ASSERT_EQ(OK, cb.GetResult(rv));
+
+  std::string key("the key");
+  disk_cache::Entry* entry;
+  rv = cache->CreateEntry(key, &entry, cb.callback());
+  ASSERT_EQ(OK, cb.GetResult(rv));
+
+  // RESPONSE_INFO_TRUNCATED defined on response_info.cc
+  int flags = 1 << 12;
+  WriteHeaders(entry, flags, "something");
+  entry->Close();
+
+  std::string data;
+  TestCompletionCallback cb1;
+  rv = helper.GetEntryInfoHTML(key, &context, &data, cb1.callback());
+  EXPECT_EQ(OK, cb1.GetResult(rv));
+
+  EXPECT_NE(std::string::npos, data.find("RESPONSE_INFO_TRUNCATED"));
+}
+
+}  // namespace net