Allow URLRequests from one context to have different NetworkDelegates.

net/url_request/url_request_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 616 matching lines @@
  protected:
   CapturingNetLog net_log_;
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   URLRequestJobFactoryImpl job_factory_;
   TestURLRequestContext default_context_;
 };
 
 TEST_F(URLRequestTest, AboutBlankTest) {
   TestDelegate d;
   {
-    URLRequest r(GURL("about:blank"), DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        GURL("about:blank"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_TRUE(!r.is_pending());
+    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());
+    EXPECT_EQ("", r->GetSocketAddress().host());
+    EXPECT_EQ(0, r->GetSocketAddress().port());
 
     HttpRequestHeaders headers;
-    EXPECT_FALSE(r.GetFullRequestHeaders(&headers));
+    EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
   }
 }
 
 TEST_F(URLRequestTest, DataURLImageTest) {
   TestDelegate d;
   {
     // Use our nice little Chrome logo.
-    URLRequest r(
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
         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="),
-        DEFAULT_PRIORITY,
-        &d,
-        &default_context_);
+        DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_TRUE(!r.is_pending());
+    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());
+    EXPECT_EQ("", r->GetSocketAddress().host());
+    EXPECT_EQ(0, r->GetSocketAddress().port());
 
     HttpRequestHeaders headers;
-    EXPECT_FALSE(r.GetFullRequestHeaders(&headers));
+    EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
   }
 }
 
 #if !defined(DISABLE_FILE_SUPPORT)
 TEST_F(URLRequestTest, FileTest) {
   base::FilePath app_path;
   PathService::Get(base::FILE_EXE, &app_path);
   GURL app_url = FilePathToFileURL(app_path);
 
   TestDelegate d;
   {
-    URLRequest r(app_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        app_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = -1;
     EXPECT_TRUE(base::GetFileSize(app_path, &file_size));
 
-    EXPECT_TRUE(!r.is_pending());
+    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());
+    EXPECT_EQ("", r->GetSocketAddress().host());
+    EXPECT_EQ(0, r->GetSocketAddress().port());
 
     HttpRequestHeaders headers;
-    EXPECT_FALSE(r.GetFullRequestHeaders(&headers));
+    EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
   }
 }
 
 TEST_F(URLRequestTest, FileTestCancel) {
   base::FilePath app_path;
   PathService::Get(base::FILE_EXE, &app_path);
   GURL app_url = FilePathToFileURL(app_path);
 
   TestDelegate d;
   {
-    URLRequest r(app_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        app_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
-    r.Cancel();
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
+    r->Cancel();
   }
   // Async cancellation should be safe even when URLRequest has been already
   // destroyed.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(URLRequestTest, FileTestFullSpecifiedRange) {
   const size_t buffer_size = 4000;
   scoped_ptr<char[]> buffer(new char[buffer_size]);
   FillBuffer(buffer.get(), buffer_size);
 
   base::FilePath temp_path;
   EXPECT_TRUE(base::CreateTemporaryFile(&temp_path));
   GURL temp_url = FilePathToFileURL(temp_path);
   EXPECT_TRUE(base::WriteFile(temp_path, buffer.get(), buffer_size));
 
   int64 file_size;
   EXPECT_TRUE(base::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, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        temp_url, DEFAULT_PRIORITY, &d, NULL));
 
     HttpRequestHeaders headers;
     headers.SetHeader(
         HttpRequestHeaders::kRange,
         net::HttpByteRange::Bounded(
             first_byte_position, last_byte_position).GetHeaderValue());
-    r.SetExtraRequestHeaders(headers);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->SetExtraRequestHeaders(headers);
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
-    EXPECT_TRUE(!r.is_pending());
+    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(base::DeleteFile(temp_path, false));
 }
 
@@ skipping 11 matching lines @@
   EXPECT_TRUE(base::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, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        temp_url, DEFAULT_PRIORITY, &d, NULL));
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kRange,
                       net::HttpByteRange::RightUnbounded(
                           first_byte_position).GetHeaderValue());
-    r.SetExtraRequestHeaders(headers);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->SetExtraRequestHeaders(headers);
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
-    EXPECT_TRUE(!r.is_pending());
+    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(base::DeleteFile(temp_path, false));
 }
 
 TEST_F(URLRequestTest, FileTestMultipleRanges) {
   const size_t buffer_size = 400000;
   scoped_ptr<char[]> buffer(new char[buffer_size]);
   FillBuffer(buffer.get(), buffer_size);
 
   base::FilePath temp_path;
   EXPECT_TRUE(base::CreateTemporaryFile(&temp_path));
   GURL temp_url = FilePathToFileURL(temp_path);
   EXPECT_TRUE(base::WriteFile(temp_path, buffer.get(), buffer_size));
 
   int64 file_size;
   EXPECT_TRUE(base::GetFileSize(temp_path, &file_size));
 
   TestDelegate d;
   {
-    URLRequest r(temp_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        temp_url, DEFAULT_PRIORITY, &d, NULL));
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kRange, "bytes=0-0,10-200,200-300");
-    r.SetExtraRequestHeaders(headers);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->SetExtraRequestHeaders(headers);
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
     EXPECT_TRUE(d.request_failed());
   }
 
   EXPECT_TRUE(base::DeleteFile(temp_path, false));
 }
 
 TEST_F(URLRequestTest, AllowFileURLs) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath test_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &test_file));
   std::string test_data("monkey");
   base::WriteFile(test_file, test_data.data(), test_data.size());
   GURL test_file_url = net::FilePathToFileURL(test_file);
 
   {
     TestDelegate d;
     TestNetworkDelegate network_delegate;
     network_delegate.set_can_access_files(true);
     default_context_.set_network_delegate(&network_delegate);
-    URLRequest r(test_file_url, DEFAULT_PRIORITY, &d, &default_context_);
-    r.Start();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_file_url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
     EXPECT_FALSE(d.request_failed());
     EXPECT_EQ(test_data, d.data_received());
   }
 
   {
     TestDelegate d;
     TestNetworkDelegate network_delegate;
     network_delegate.set_can_access_files(false);
     default_context_.set_network_delegate(&network_delegate);
-    URLRequest r(test_file_url, DEFAULT_PRIORITY, &d, &default_context_);
-    r.Start();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_file_url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
     EXPECT_TRUE(d.request_failed());
     EXPECT_EQ("", d.data_received());
   }
 }
 
 
 TEST_F(URLRequestTest, FileDirCancelTest) {
   // Put in mock resource provider.
   NetModule::SetResourceProvider(TestNetResourceProvider);
 
   TestDelegate d;
   {
     base::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), DEFAULT_PRIORITY, &d, &default_context_);
-    req.Start();
-    EXPECT_TRUE(req.is_pending());
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        FilePathToFileURL(file_path), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
+    EXPECT_TRUE(req->is_pending());
 
     d.set_cancel_in_received_data_pending(true);
 
     base::RunLoop().Run();
   }
 
   // Take out mock resource provider.
   NetModule::SetResourceProvider(NULL);
 }
 
 TEST_F(URLRequestTest, FileDirOutputSanity) {
   // Verify the general sanity of the the output of the file:
   // directory lister by checking for the output of a known existing
   // file.
   const char sentinel_name[] = "filedir-sentinel";
 
   base::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), DEFAULT_PRIORITY, &d, &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      FilePathToFileURL(path), DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   // Generate entry for the sentinel file.
   base::FilePath sentinel_path = path.AppendASCII(sentinel_name);
   base::File::Info info;
   EXPECT_TRUE(base::GetFileInfo(sentinel_path, &info));
   EXPECT_GT(info.size, 0);
   std::string sentinel_output = GetDirectoryListingEntry(
       base::string16(sentinel_name, sentinel_name + strlen(sentinel_name)),
       std::string(sentinel_name),
       false /* is_dir */,
       info.size,
       info.last_modified);
 
   ASSERT_LT(0, d.bytes_received());
   ASSERT_FALSE(d.request_failed());
-  ASSERT_TRUE(req.status().is_success());
+  ASSERT_TRUE(req->status().is_success());
   // Check for the entry generated for the "sentinel" file.
   const std::string& data = d.data_received();
   ASSERT_NE(data.find(sentinel_output), std::string::npos);
 }
 
 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.
 
   base::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), DEFAULT_PRIORITY, &d, &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      FilePathToFileURL(path), DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().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());
+  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:///"), DEFAULT_PRIORITY, &d, &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("file:///"), DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   ASSERT_EQ(1, d.received_redirect_count());
-  ASSERT_FALSE(req.status().is_success());
+  ASSERT_FALSE(req->status().is_success());
 }
 #endif  // defined(OS_WIN)
 
 #endif  // !defined(DISABLE_FILE_SUPPORT)
 
 TEST_F(URLRequestTest, InvalidUrlTest) {
   TestDelegate d;
   {
-    URLRequest r(GURL("invalid url"), DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        GURL("invalid url"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
     EXPECT_TRUE(d.request_failed());
   }
 }
 
 #if defined(OS_WIN)
 TEST_F(URLRequestTest, ResolveShortcutTest) {
   base::FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
@@ skipping 13 matching lines @@
                                                CLSCTX_INPROC_SERVER)));
     base::win::ScopedComPtr<IPersistFile> persist;
     ASSERT_TRUE(SUCCEEDED(shell.QueryInterface(persist.Receive())));
     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)));
   }
 
   TestDelegate d;
   {
-    URLRequest r(FilePathToFileURL(base::FilePath(lnk_path)),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        FilePathToFileURL(base::FilePath(lnk_path)), DEFAULT_PRIORITY, &d,
+        NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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_ptr<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_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)
 
 // Custom URLRequestJobs for use with interceptor tests
@@ skipping 201 matching lines @@
 
 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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
   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();
+  req->SetUserData(NULL, user_data0);
+  req->SetUserData(&user_data1, user_data1);
+  req->SetUserData(&user_data2, user_data2);
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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));
+  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_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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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_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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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_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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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_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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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_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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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());
+  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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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());
+  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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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());
+  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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("GET");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
+  req->Start();
   base::RunLoop().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());
+  EXPECT_FALSE(req->status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
 }
 
 LoadTimingInfo RunLoadTimingTest(const LoadTimingInfo& job_load_timing,
                                  URLRequestContext* context) {
   TestInterceptor interceptor;
   interceptor.intercept_main_request_ = true;
   interceptor.main_request_load_timing_info_ = job_load_timing;
   TestDelegate d;
-  URLRequest req(
-      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, context);
-  req.Start();
+  scoped_ptr<URLRequest> req(context->CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   LoadTimingInfo resulting_load_timing;
-  req.GetLoadTimingInfo(&resulting_load_timing);
+  req->GetLoadTimingInfo(&resulting_load_timing);
 
   // None of these should be modified by the URLRequest.
   EXPECT_EQ(job_load_timing.socket_reused, resulting_load_timing.socket_reused);
   EXPECT_EQ(job_load_timing.socket_log_id, resulting_load_timing.socket_log_id);
   EXPECT_EQ(job_load_timing.send_start, resulting_load_timing.send_start);
   EXPECT_EQ(job_load_timing.send_end, resulting_load_timing.send_end);
   EXPECT_EQ(job_load_timing.receive_headers_end,
             resulting_load_timing.receive_headers_end);
 
   return resulting_load_timing;
@@ skipping 251 matching lines @@
 // 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"), DEFAULT_PRIORITY, &d, &context);
-  req.set_method("GET");
+  scoped_ptr<URLRequest> req(context.CreateRequest(
+      GURL("http://example.com"), DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("GET");
 
-  req.Start();
+  req->Start();
   base::RunLoop().Run();
 
   // Check we see a failed request.
-  EXPECT_FALSE(req.status().is_success());
+  EXPECT_FALSE(req->status().is_success());
   // The proxy server is not set before failure.
-  EXPECT_TRUE(req.proxy_server().IsEmpty());
-  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req.status().error());
+  EXPECT_TRUE(req->proxy_server().IsEmpty());
+  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:,"), DEFAULT_PRIORITY, &d, &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("data:,"), DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
   EXPECT_EQ("", d.data_received());
   EXPECT_EQ(1, default_network_delegate_.completed_requests());
 }
 
 // Make sure that SetPriority actually sets the URLRequest's priority
 // correctly, both before and after start.
 TEST_F(URLRequestTest, SetPriorityBasic) {
   TestDelegate d;
-  URLRequest req(GURL("http://test_intercept/foo"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  EXPECT_EQ(DEFAULT_PRIORITY, req.priority());
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
 
-  req.SetPriority(LOW);
-  EXPECT_EQ(LOW, req.priority());
+  req->SetPriority(LOW);
+  EXPECT_EQ(LOW, req->priority());
 
-  req.Start();
-  EXPECT_EQ(LOW, req.priority());
+  req->Start();
+  EXPECT_EQ(LOW, req->priority());
 
-  req.SetPriority(MEDIUM);
-  EXPECT_EQ(MEDIUM, req.priority());
+  req->SetPriority(MEDIUM);
+  EXPECT_EQ(MEDIUM, req->priority());
 }
 
 // Make sure that URLRequest calls SetPriority on a job before calling
 // Start on it.
 TEST_F(URLRequestTest, SetJobPriorityBeforeJobStart) {
   TestDelegate d;
-  URLRequest req(GURL("http://test_intercept/foo"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  EXPECT_EQ(DEFAULT_PRIORITY, req.priority());
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
+  EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
 
   scoped_refptr<URLRequestTestJob> job =
-      new URLRequestTestJob(&req, &default_network_delegate_);
+      new URLRequestTestJob(req.get(), &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
   EXPECT_EQ(DEFAULT_PRIORITY, job->priority());
 
-  req.SetPriority(LOW);
+  req->SetPriority(LOW);
 
-  req.Start();
+  req->Start();
   EXPECT_EQ(LOW, job->priority());
 }
 
 // Make sure that URLRequest passes on its priority updates to its
 // job.
 TEST_F(URLRequestTest, SetJobPriority) {
   TestDelegate d;
-  URLRequest req(GURL("http://test_intercept/foo"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d, NULL));
 
   scoped_refptr<URLRequestTestJob> job =
-      new URLRequestTestJob(&req, &default_network_delegate_);
+      new URLRequestTestJob(req.get(), &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
 
-  req.SetPriority(LOW);
-  req.Start();
+  req->SetPriority(LOW);
+  req->Start();
   EXPECT_EQ(LOW, job->priority());
 
-  req.SetPriority(MEDIUM);
-  EXPECT_EQ(MEDIUM, req.priority());
+  req->SetPriority(MEDIUM);
+  EXPECT_EQ(MEDIUM, req->priority());
   EXPECT_EQ(MEDIUM, job->priority());
 }
 
 // Setting the IGNORE_LIMITS load flag should be okay if the priority
 // is MAXIMUM_PRIORITY.
 TEST_F(URLRequestTest, PriorityIgnoreLimits) {
   TestDelegate d;
-  URLRequest req(GURL("http://test_intercept/foo"),
-                 MAXIMUM_PRIORITY,
-                 &d,
-                 &default_context_);
-  EXPECT_EQ(MAXIMUM_PRIORITY, req.priority());
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      GURL("http://test_intercept/foo"), MAXIMUM_PRIORITY, &d, NULL));
+  EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
   scoped_refptr<URLRequestTestJob> job =
-      new URLRequestTestJob(&req, &default_network_delegate_);
+      new URLRequestTestJob(req.get(), &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
 
-  req.SetLoadFlags(LOAD_IGNORE_LIMITS);
-  EXPECT_EQ(MAXIMUM_PRIORITY, req.priority());
+  req->SetLoadFlags(LOAD_IGNORE_LIMITS);
+  EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
-  req.SetPriority(MAXIMUM_PRIORITY);
-  EXPECT_EQ(MAXIMUM_PRIORITY, req.priority());
+  req->SetPriority(MAXIMUM_PRIORITY);
+  EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
-  req.Start();
-  EXPECT_EQ(MAXIMUM_PRIORITY, req.priority());
+  req->Start();
+  EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
   EXPECT_EQ(MAXIMUM_PRIORITY, job->priority());
 }
 
 // TODO(droger): Support SpawnedTestServer on iOS (see http://crbug.com/148666).
 #if !defined(OS_IOS)
 // A subclass of SpawnedTestServer that uses a statically-configured hostname.
 // This is to work around mysterious failures in chrome_frame_net_tests. See:
 // http://crbug.com/114369
 // TODO(erikwright): remove or update as needed; see http://crbug.com/334634.
 class LocalHttpTestServer : public SpawnedTestServer {
@@ skipping 16 matching lines @@
   scoped_refptr<DelayedCookieMonster> delayed_cm =
       new DelayedCookieMonster();
   scoped_refptr<CookieStore> cookie_store = delayed_cm;
   context.set_cookie_store(delayed_cm.get());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     context.set_network_delegate(&network_delegate);
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &context);
-    req.Start();
+    scoped_ptr<URLRequest> req(context.CreateRequest(
+        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &context);
-    req.Start();
+    scoped_ptr<URLRequest> req(context.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES);
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
+        &d, NULL));
+    req->Start();
     base::RunLoop().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(
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
-        DEFAULT_PRIORITY,
-        &d,
-        &default_context_);
-    req.SetLoadFlags(LOAD_DO_NOT_SAVE_COOKIES);
-    req.Start();
+        DEFAULT_PRIORITY, &d, NULL));
+    req->SetLoadFlags(LOAD_DO_NOT_SAVE_COOKIES);
+    req->Start();
 
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
+        &d, NULL));
+    req->Start();
     base::RunLoop().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(
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
-        DEFAULT_PRIORITY,
-        &d,
-        &default_context_);
-    req.Start();
+        DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
 
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("set-cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
+        &d, NULL));
+    req->Start();
     base::RunLoop().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(
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
-        DEFAULT_PRIORITY,
-        &d,
-        &default_context_);
-    req.Start();
+        DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
 
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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());
   }
@@ skipping 46 matching lines @@
 // 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(
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL(
             "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
-        DEFAULT_PRIORITY,
-        &d,
-        &default_context_);
-    req.Start();
+        DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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(
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL(
             "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
-        DEFAULT_PRIORITY,
-        &d,
-        &default_context_);
-    req.Start();
+        DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.SetReferrer("http://foo.com/");
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d, NULL));
+    req->SetReferrer("http://foo.com/");
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
-    req.SetExtraRequestHeaders(headers);
+    req->SetExtraRequestHeaders(headers);
 
-    req.Start();
+    req->Start();
     base::RunLoop().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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d, NULL));
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
-    req.SetExtraRequestHeaders(headers);
-    req.SetLoadFlags(LOAD_VALIDATE_CACHE);
+    req->SetExtraRequestHeaders(headers);
+    req->SetLoadFlags(LOAD_VALIDATE_CACHE);
 
-    req.Start();
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ("None", d.data_received());
   }
 }
 
 class URLRequestTestHTTP : public URLRequestTest {
  public:
   URLRequestTestHTTP()
       : test_server_(base::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, DEFAULT_PRIORITY, &d, &default_context_);
-    req.set_method(request_method);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        redirect_url, DEFAULT_PRIORITY, &d, NULL));
+    req->set_method(request_method);
     if (include_data) {
-      req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+      req->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
       HttpRequestHeaders headers;
       headers.SetHeader(HttpRequestHeaders::kContentLength,
                         base::UintToString(arraysize(kData) - 1));
-      req.SetExtraRequestHeaders(headers);
+      req->SetExtraRequestHeaders(headers);
     }
-    req.Start();
+    req->Start();
     base::RunLoop().Run();
-    EXPECT_EQ(redirect_method, req.method());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
-    EXPECT_EQ(OK, req.status().error());
+    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;
   }
@@ skipping 11 matching lines @@
         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"), DEFAULT_PRIORITY, &d, &default_context_);
-      r.set_method(method.c_str());
+      scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+          test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
+      r->set_method(method.c_str());
 
-      r.set_upload(make_scoped_ptr(CreateSimpleUploadData(uploadBytes)));
+      r->set_upload(make_scoped_ptr(CreateSimpleUploadData(uploadBytes)));
 
-      r.Start();
-      EXPECT_TRUE(r.is_pending());
+      r->Start();
+      EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().Run();
 
       ASSERT_EQ(1, d.response_started_count())
-          << "request failed: " << r.status().status()
-          << ", os error: " << r.status().error();
+          << "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);
@@ skipping 13 matching lines @@
         << ", 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)),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("set-many-cookies?" +
+                                base::IntToString(num_cookies)),
+        DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    bool is_success = r.status().is_success();
+    bool is_success = r->status().is_success();
 
     if (!is_success) {
-      EXPECT_TRUE(r.status().error() == ERR_RESPONSE_HEADERS_TOO_BIG);
+      EXPECT_TRUE(r->status().error() == ERR_RESPONSE_HEADERS_TOO_BIG);
       // 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.
 TEST_F(URLRequestTestHTTP, 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/"), DEFAULT_PRIORITY, &d, &context);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
-    EXPECT_TRUE(r.proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
+    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    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.
 TEST_F(URLRequestTestHTTP, 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/"), DEFAULT_PRIORITY, &d, &context);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
-    EXPECT_TRUE(r.proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
+    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    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.
@@ skipping 13 matching lines @@
   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"), DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     for (size_t i = 0; i < blocking_stages_length; ++i) {
       base::RunLoop().Run();
       EXPECT_EQ(blocking_stages[i],
                 network_delegate.stage_blocked_for_callback());
       network_delegate.DoCallback(OK);
     }
     base::RunLoop().Run();
-    EXPECT_EQ(200, r.GetResponseCode());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    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(std::string()), DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before cancellation.
-    EXPECT_TRUE(r.proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().error());
+    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    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, DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before cancellation.
-    EXPECT_TRUE(r.proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_BLOCKED_BY_CLIENT, r.status().error());
+    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    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());
@@ skipping 49 matching lines @@
       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, DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_TRUE(r.proxy_server().Equals(test_server_.host_port_pair()));
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
     EXPECT_EQ(
         1, network_delegate.observed_before_proxy_headers_sent_callbacks());
     EXPECT_TRUE(
         network_delegate.last_observed_proxy().Equals(
             test_server_.host_port_pair()));
 
-    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(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, DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_TRUE(r.proxy_server().Equals(test_server_.host_port_pair()));
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
     EXPECT_EQ(
         1, network_delegate.observed_before_proxy_headers_sent_callbacks());
     EXPECT_TRUE(
         network_delegate.last_observed_proxy().Equals(
             test_server_.host_port_pair()));
-    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(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, DEFAULT_PRIORITY, &d, &context);
-    r.set_method("POST");
-    r.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
+    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();
+    r->SetExtraRequestHeaders(headers);
+    r->Start();
     base::RunLoop().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(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("POST", r->method());
     EXPECT_EQ(kData, d.data_received());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can block and redirect a request to a new
 // URL during OnHeadersReceived.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestOnHeadersReceived) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
   GURL redirect_url(test_server_.GetURL("simple.html"));
   network_delegate.set_redirect_on_headers_received_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, DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_TRUE(r.proxy_server().Equals(test_server_.host_port_pair()));
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
     EXPECT_EQ(
         2, network_delegate.observed_before_proxy_headers_sent_callbacks());
     EXPECT_TRUE(
         network_delegate.last_observed_proxy().Equals(
             test_server_.host_port_pair()));
-    EXPECT_EQ(net::OK, 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(net::OK, 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(2, 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 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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(0, r.status().error());
-    EXPECT_EQ(200, r.GetResponseCode());
+    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());
 }
 
 TEST_F(URLRequestTestHTTP,
     NetworkDelegateOnAuthRequiredSyncNoAction_GetFullRequestHeaders) {
   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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
 
     {
       HttpRequestHeaders headers;
-      EXPECT_TRUE(r.GetFullRequestHeaders(&headers));
+      EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
       EXPECT_FALSE(headers.HasHeader("Authorization"));
     }
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(0, r.status().error());
-    EXPECT_EQ(200, r.GetResponseCode());
+    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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(0, r.status().error());
-    EXPECT_EQ(200, r.GetResponseCode());
+    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());
 }
 
 // Same as above, but also tests that GetFullRequestHeaders returns the proper
 // headers (for the first or second request) when called at the proper times.
 TEST_F(URLRequestTestHTTP,
     NetworkDelegateOnAuthRequiredSyncSetAuth_GetFullRequestHeaders) {
   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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(0, r.status().error());
-    EXPECT_EQ(200, r.GetResponseCode());
+    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());
 
     {
       HttpRequestHeaders headers;
-      EXPECT_TRUE(r.GetFullRequestHeaders(&headers));
+      EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
       EXPECT_TRUE(headers.HasHeader("Authorization"));
     }
   }
   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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(OK, r.status().error());
-    EXPECT_EQ(401, r.GetResponseCode());
+    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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(0, r.status().error());
-    EXPECT_EQ(200, r.GetResponseCode());
+    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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(0, r.status().error());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(0, r->status().error());
 
-    EXPECT_EQ(200, r.GetResponseCode());
+    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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(OK, r.status().error());
-    EXPECT_EQ(401, r.GetResponseCode());
+    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(std::string()), DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().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();
+    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(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(std::string()), DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().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();
+    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(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(std::string()), DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().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();
+    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(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"), DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().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();
+    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(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/"), DEFAULT_PRIORITY, &d, &context);
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        GURL("https://www.server-auth.com/"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
-    EXPECT_TRUE(r.proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
+    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    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(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
-              r.GetSocketAddress().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.
@@ skipping 32 matching lines @@
       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(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
-              r.GetSocketAddress().port());
+              r->GetSocketAddress().port());
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTest_GetFullRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     GURL test_url(test_server_.GetURL(std::string()));
-    URLRequest r(test_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_url, DEFAULT_PRIORITY, &d, NULL));
 
     HttpRequestHeaders headers;
-    EXPECT_FALSE(r.GetFullRequestHeaders(&headers));
+    EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
-              r.GetSocketAddress().port());
+              r->GetSocketAddress().port());
 
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), test_url);
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTestLoadTiming) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(test_server_.GetURL(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     LoadTimingInfo load_timing_info;
-    r.GetLoadTimingInfo(&load_timing_info);
+    r->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
 
     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());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
-              r.GetSocketAddress().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).
@@ skipping 12 matching lines @@
     {
       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), DEFAULT_PRIORITY, &d, &context);
-      r.Start();
-      EXPECT_TRUE(r.is_pending());
+      scoped_ptr<URLRequest> r(context.CreateRequest(
+          test_server_.GetURL(test_file), DEFAULT_PRIORITY, &d, NULL));
+      r->Start();
+      EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().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();
+              << " status = " << r->status().status()
+              << " error = " << r->status().error();
       if (test_expect_success[i]) {
-        EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status())
+        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())
+        EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+        EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, r->status().error())
             << " Parameter = \"" << test_file << "\"";
       }
     }
   }
 }
 
 TEST_F(URLRequestTestHTTP, HTTPSToHTTPRedirectNoRefererTest) {
   ASSERT_TRUE(test_server_.Start());
 
   SpawnedTestServer https_test_server(
       SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
       base::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(std::string());
   TestDelegate d;
-  URLRequest req(
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
       https_test_server.GetURL("server-redirect?" + http_destination.spec()),
-      DEFAULT_PRIORITY,
-      &d,
-      &default_context_);
-  req.SetReferrer("https://www.referrer.com/");
-  req.Start();
+      DEFAULT_PRIORITY, &d, NULL));
+  req->SetReferrer("https://www.referrer.com/");
+  req->Start();
   base::RunLoop().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());
+  EXPECT_EQ(http_destination, req->url());
+  EXPECT_EQ(std::string(), req->referrer());
 }
 
 TEST_F(URLRequestTestHTTP, RedirectLoadTiming) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL destination_url = test_server_.GetURL(std::string());
   GURL original_url =
       test_server_.GetURL("server-redirect?" + destination_url.spec());
   TestDelegate d;
-  URLRequest req(original_url, DEFAULT_PRIORITY, &d, &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      original_url, DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(1, d.received_redirect_count());
-  EXPECT_EQ(destination_url, req.url());
-  EXPECT_EQ(original_url, req.original_url());
-  ASSERT_EQ(2U, req.url_chain().size());
-  EXPECT_EQ(original_url, req.url_chain()[0]);
-  EXPECT_EQ(destination_url, req.url_chain()[1]);
+  EXPECT_EQ(destination_url, req->url());
+  EXPECT_EQ(original_url, req->original_url());
+  ASSERT_EQ(2U, req->url_chain().size());
+  EXPECT_EQ(original_url, req->url_chain()[0]);
+  EXPECT_EQ(destination_url, req->url_chain()[1]);
 
   LoadTimingInfo load_timing_info_before_redirect;
   EXPECT_TRUE(default_network_delegate_.GetLoadTimingInfoBeforeRedirect(
       &load_timing_info_before_redirect));
   TestLoadTimingNotReused(load_timing_info_before_redirect,
                           CONNECT_TIMING_HAS_DNS_TIMES);
 
   LoadTimingInfo load_timing_info;
-  req.GetLoadTimingInfo(&load_timing_info);
+  req->GetLoadTimingInfo(&load_timing_info);
   TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
 
   // Check that a new socket was used on redirect, since the server does not
   // supposed keep-alive sockets, and that the times before the redirect are
   // before the ones recorded for the second request.
   EXPECT_NE(load_timing_info_before_redirect.socket_log_id,
             load_timing_info.socket_log_id);
   EXPECT_LE(load_timing_info_before_redirect.receive_headers_end,
             load_timing_info.connect_timing.connect_start);
 }
 
 TEST_F(URLRequestTestHTTP, MultipleRedirectTest) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL destination_url = test_server_.GetURL(std::string());
   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, DEFAULT_PRIORITY, &d, &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      original_url, DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().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]);
+  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]);
 }
 
 // First and second pieces of information logged by delegates to URLRequests.
 const char kFirstDelegateInfo[] = "Wonderful delegate";
 const char kSecondDelegateInfo[] = "Exciting delegate";
 
 // Logs delegate information to a URLRequest.  The first string is logged
 // synchronously on Start(), using DELEGATE_INFO_DEBUG_ONLY.  The second is
 // logged asynchronously, using DELEGATE_INFO_DISPLAY_TO_USER.  Then
 // another asynchronous call is used to clear the delegate information
@@ skipping 299 matching lines @@
 TEST_F(URLRequestTestHTTP, DelegateInfoBeforeStart) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate request_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(NULL);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
-    URLRequest r(test_server_.GetURL("empty.html"),
-                 DEFAULT_PRIORITY,
-                 &request_delegate,
-                 &context);
-    LoadStateWithParam load_state = r.GetLoadState();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &request_delegate,
+        NULL));
+    LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     AsyncDelegateLogger::Run(
-        &r,
+        r.get(),
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_IDLE,
-        base::Bind(&URLRequest::Start, base::Unretained(&r)));
+        base::Bind(&URLRequest::Start, base::Unretained(r.get())));
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(200, r.GetResponseCode());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(200, r->GetResponseCode());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   size_t log_position = ExpectLogContainsSomewhereAfter(
       entries,
       0,
       NetLog::TYPE_DELEGATE_INFO,
       NetLog::PHASE_BEGIN);
 
   log_position = AsyncDelegateLogger::CheckDelegateInfo(entries, log_position);
 
   // Nothing else should add any delegate info to the request.
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
 }
 
 // Tests handling of delegate info from a network delegate.
 TEST_F(URLRequestTestHTTP, NetworkDelegateInfo) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate request_delegate;
   AsyncLoggingNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
-    URLRequest r(test_server_.GetURL("simple.html"),
-                 DEFAULT_PRIORITY,
-                 &request_delegate,
-                 &context);
-    LoadStateWithParam load_state = r.GetLoadState();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("simple.html"), DEFAULT_PRIORITY, &request_delegate,
+        NULL));
+    LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(200, r.GetResponseCode());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    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());
 
   size_t log_position = 0;
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   for (size_t i = 0; i < 3; ++i) {
     log_position = ExpectLogContainsSomewhereAfter(
@@ skipping 25 matching lines @@
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate request_delegate;
   AsyncLoggingNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
-    URLRequest r(test_server_.GetURL("server-redirect?simple.html"),
-                 DEFAULT_PRIORITY,
-                 &request_delegate,
-                 &context);
-    LoadStateWithParam load_state = r.GetLoadState();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
+        &request_delegate, NULL));
+    LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(200, r.GetResponseCode());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(200, r->GetResponseCode());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(2, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 
   size_t log_position = 0;
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   // The NetworkDelegate logged information in OnBeforeURLRequest,
   // OnBeforeSendHeaders, and OnHeadersReceived.
@@ skipping 50 matching lines @@
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate request_delegate;
   AsyncLoggingNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
-    URLRequest r(test_server_.GetURL("auth-basic"),
-                 DEFAULT_PRIORITY,
-                 &request_delegate,
-                 &context);
-    LoadStateWithParam load_state = r.GetLoadState();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &request_delegate,
+        NULL));
+    LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(200, r.GetResponseCode());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    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());
 
   size_t log_position = 0;
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   // The NetworkDelegate should have logged information in OnBeforeURLRequest,
   // OnBeforeSendHeaders, OnHeadersReceived, OnAuthRequired, and then again in
@@ skipping 32 matching lines @@
   context.set_network_delegate(NULL);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
     // A chunked response with delays between chunks is used to make sure that
     // attempts by the URLRequest delegate to log information while reading the
     // body are ignored.  Since they are ignored, this test is robust against
     // the possibility of multiple reads being combined in the unlikely event
     // that it occurs.
-    URLRequest r(test_server_.GetURL("chunked?waitBetweenChunks=20"),
-                 DEFAULT_PRIORITY,
-                 &request_delegate,
-                 &context);
-    LoadStateWithParam load_state = r.GetLoadState();
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("chunked?waitBetweenChunks=20"), DEFAULT_PRIORITY,
+        &request_delegate, NULL));
+    LoadStateWithParam load_state = r->GetLoadState();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(200, r.GetResponseCode());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(200, r->GetResponseCode());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
 
   size_t log_position = 0;
 
   log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
       entries, log_position);
 
@@ skipping 24 matching lines @@
   ASSERT_TRUE(test_server_.Start());
 
   AsyncLoggingUrlRequestDelegate request_delegate(
       AsyncLoggingUrlRequestDelegate::NO_CANCEL);
   TestURLRequestContext context(true);
   context.set_network_delegate(NULL);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
-    URLRequest r(test_server_.GetURL("server-redirect?simple.html"),
-                 DEFAULT_PRIORITY,
-                 &request_delegate,
-                 &context);
-    LoadStateWithParam load_state = r.GetLoadState();
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
+        &request_delegate, NULL));
+    LoadStateWithParam load_state = r->GetLoadState();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(200, r.GetResponseCode());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(200, r->GetResponseCode());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
 
   // Delegate info should only have been logged in OnReceivedRedirect and
   // OnResponseStarted.
   size_t log_position = 0;
   for (int i = 0; i < 2; ++i) {
     if (i == 0) {
@@ skipping 35 matching lines @@
   for (size_t test_case = 0; test_case < arraysize(kCancelStages);
        ++test_case) {
     AsyncLoggingUrlRequestDelegate request_delegate(kCancelStages[test_case]);
     TestURLRequestContext context(true);
     CapturingNetLog net_log;
     context.set_network_delegate(NULL);
     context.set_net_log(&net_log);
     context.Init();
 
     {
-      URLRequest r(test_server_.GetURL("server-redirect?simple.html"),
-                   DEFAULT_PRIORITY,
-                   &request_delegate,
-                   &context);
-      LoadStateWithParam load_state = r.GetLoadState();
-      r.Start();
+      scoped_ptr<URLRequest> r(context.CreateRequest(
+          test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
+          &request_delegate, NULL));
+      LoadStateWithParam load_state = r->GetLoadState();
+      r->Start();
       base::RunLoop().Run();
-      EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+      EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     }
 
     CapturingNetLog::CapturedEntryList entries;
     net_log.GetEntries(&entries);
 
     // Delegate info is always logged in both OnReceivedRedirect and
     // OnResponseStarted.  In the CANCEL_ON_RECEIVED_REDIRECT, the
     // OnResponseStarted delegate call is after cancellation, but logging is
     // still currently supported in that call.
     size_t log_position = 0;
@@ skipping 41 matching lines @@
 }  // 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, DEFAULT_PRIORITY, &d, &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      original_url, DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   std::string value;
-  const HttpRequestHeaders& headers = req.extra_request_headers();
+  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_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 {
   virtual void OnReceivedRedirect(net::URLRequest* request,
                           const GURL& new_url,
                           bool* defer_redirect) OVERRIDE {
     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, DEFAULT_PRIORITY, &d, &default_context_);
-  req.SetExtraRequestHeaderByName(kExtraHeaderToRemove, "dummy", false);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      original_url, DEFAULT_PRIORITY, &d, NULL));
+  req->SetExtraRequestHeaderByName(kExtraHeaderToRemove, "dummy", false);
+  req->Start();
   base::RunLoop().Run();
 
   std::string value;
-  const HttpRequestHeaders& headers = req.extra_request_headers();
+  const HttpRequestHeaders& headers = req->extra_request_headers();
   EXPECT_FALSE(headers.GetHeader(kExtraHeaderToRemove, &value));
-  EXPECT_FALSE(req.is_pending());
-  EXPECT_FALSE(req.is_redirecting());
+  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/"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        GURL("http://www.google.com/"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
-    r.Cancel();
+    r->Cancel();
 
     base::RunLoop().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(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
     d.set_cancel_in_response_started(true);
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest3) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(test_server_.GetURL(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
     d.set_cancel_in_received_data(true);
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest4) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(test_server_.GetURL(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
     base::RunLoop().Run();
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   // cancel read from cache (see bug 990242)
   {
     TestDelegate d;
-    URLRequest r(test_server_.GetURL("cachetime"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
-    r.Cancel();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    r->Cancel();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
+    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"), DEFAULT_PRIORITY, &d, &default_context_);
-    r.set_method("POST");
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
+    r->set_method("POST");
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     ASSERT_EQ(1, d.response_started_count())
-        << "request failed: " << r.status().status()
-        << ", error: " << r.status().error();
+        << "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"), DEFAULT_PRIORITY, &d, &default_context_);
-    r.set_method("POST");
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
+    r->set_method("POST");
 
     base::FilePath dir;
     PathService::Get(base::DIR_EXE, &dir);
     base::SetCurrentDirectory(dir);
 
     ScopedVector<UploadElementReader> element_readers;
 
     base::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(base::MessageLoopProxy::current().get(),
                                     path,
                                     0,
                                     kuint64max,
                                     base::Time()));
-    r.set_upload(make_scoped_ptr(
+    r->set_upload(make_scoped_ptr(
         new UploadDataStream(element_readers.Pass(), 0)));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 size = 0;
     ASSERT_EQ(true, base::GetFileSize(path, &size));
     scoped_ptr<char[]> buf(new char[size]);
 
     ASSERT_EQ(size, base::ReadFile(path, buf.get(), size));
 
     ASSERT_EQ(1, d.response_started_count())
-        << "request failed: " << r.status().status()
-        << ", error: " << r.status().error();
+        << "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, PostUnreadableFileTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(test_server_.GetURL("echo"), DEFAULT_PRIORITY,
-                 &d, &default_context_);
-    r.set_method("POST");
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
+    r->set_method("POST");
 
     ScopedVector<UploadElementReader> element_readers;
 
     element_readers.push_back(new UploadFileElementReader(
         base::MessageLoopProxy::current().get(),
         base::FilePath(FILE_PATH_LITERAL(
             "c:\\path\\to\\non\\existant\\file.randomness.12345")),
         0,
         kuint64max,
         base::Time()));
-    r.set_upload(make_scoped_ptr(
+    r->set_upload(make_scoped_ptr(
         new UploadDataStream(element_readers.Pass(), 0)));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.request_failed());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(0, d.bytes_received());
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_FILE_NOT_FOUND, r.status().error());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+    EXPECT_EQ(ERR_FILE_NOT_FOUND, r->status().error());
   }
 }
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, &default_context_);
-    r.EnableChunkedUpload();
-    r.set_method("POST");
-    AddChunksToUpload(&r);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
+    r->EnableChunkedUpload();
+    r->set_method("POST");
+    AddChunksToUpload(r.get());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    VerifyReceivedDataMatchesChunks(&r, &d);
+    VerifyReceivedDataMatchesChunks(r.get(), &d);
   }
 }
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataJustAfterStart) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, &default_context_);
-    r.EnableChunkedUpload();
-    r.set_method("POST");
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
-    AddChunksToUpload(&r);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
+    r->EnableChunkedUpload();
+    r->set_method("POST");
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
+    AddChunksToUpload(r.get());
     base::RunLoop().Run();
 
-    VerifyReceivedDataMatchesChunks(&r, &d);
+    VerifyReceivedDataMatchesChunks(r.get(), &d);
   }
 }
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataAfterStart) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, &default_context_);
-    r.EnableChunkedUpload();
-    r.set_method("POST");
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
+    r->EnableChunkedUpload();
+    r->set_method("POST");
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().RunUntilIdle();
-    AddChunksToUpload(&r);
+    AddChunksToUpload(r.get());
     base::RunLoop().Run();
 
-    VerifyReceivedDataMatchesChunks(&r, &d);
+    VerifyReceivedDataMatchesChunks(r.get(), &d);
   }
 }
 
 TEST_F(URLRequestTestHTTP, ResponseHeadersTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("files/with-headers.html"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("files/with-headers.html"), DEFAULT_PRIORITY, &d,
+      NULL));
+  req->Start();
   base::RunLoop().Run();
 
-  const HttpResponseHeaders* headers = req.response_headers();
+  const HttpResponseHeaders* headers = req->response_headers();
 
   // Simple sanity check that response_info() accesses the same data.
-  EXPECT_EQ(headers, req.response_info().headers.get());
+  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) {
   SpawnedTestServer::SSLOptions ssl_options;
   SpawnedTestServer https_test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::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"),
-                     DEFAULT_PRIORITY,
-                     &d,
-                     &default_context_);
-  request.Start();
+  scoped_ptr<URLRequest> request(default_context_.CreateRequest(
+      https_test_server.GetURL("files/hsts-headers.html"), DEFAULT_PRIORITY, &d,
+      NULL));
+  request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(
       SpawnedTestServer::kLocalhost, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.sts.upgrade_mode);
   EXPECT_TRUE(domain_state.sts.include_subdomains);
@@ skipping 18 matching lines @@
 // validity/expiration.
 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKP) {
   SpawnedTestServer::SSLOptions ssl_options;
   SpawnedTestServer https_test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
   ASSERT_TRUE(https_test_server.Start());
 
   TestDelegate d;
-  URLRequest request(https_test_server.GetURL("files/hpkp-headers.html"),
-                     DEFAULT_PRIORITY,
-                     &d,
-                     &default_context_);
-  request.Start();
+  scoped_ptr<URLRequest> request(default_context_.CreateRequest(
+      https_test_server.GetURL("files/hpkp-headers.html"), DEFAULT_PRIORITY, &d,
+      NULL));
+  request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(
       SpawnedTestServer::kLocalhost, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_DEFAULT,
             domain_state.sts.upgrade_mode);
   EXPECT_FALSE(domain_state.sts.include_subdomains);
   EXPECT_FALSE(domain_state.pkp.include_subdomains);
   EXPECT_TRUE(domain_state.HasPublicKeyPins());
   EXPECT_NE(domain_state.sts.expiry, domain_state.pkp.expiry);
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTSOnce) {
   SpawnedTestServer::SSLOptions ssl_options;
   SpawnedTestServer https_test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
   ASSERT_TRUE(https_test_server.Start());
 
   TestDelegate d;
-  URLRequest request(
+  scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-multiple-headers.html"),
-      DEFAULT_PRIORITY,
-      &d,
-      &default_context_);
-  request.Start();
+      DEFAULT_PRIORITY, &d, NULL));
+  request->Start();
   base::RunLoop().Run();
 
   // We should have set parameters from the first header, not the second.
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(
       SpawnedTestServer::kLocalhost, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.sts.upgrade_mode);
   EXPECT_FALSE(domain_state.sts.include_subdomains);
   EXPECT_FALSE(domain_state.pkp.include_subdomains);
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP) {
   SpawnedTestServer::SSLOptions ssl_options;
   SpawnedTestServer https_test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
   ASSERT_TRUE(https_test_server.Start());
 
   TestDelegate d;
-  URLRequest request(
+  scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-and-hpkp-headers.html"),
-      DEFAULT_PRIORITY,
-      &d,
-      &default_context_);
-  request.Start();
+      DEFAULT_PRIORITY, &d, NULL));
+  request->Start();
   base::RunLoop().Run();
 
   // We should have set parameters from the first header, not the second.
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(
       SpawnedTestServer::kLocalhost, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.sts.upgrade_mode);
@@ skipping 15 matching lines @@
 // policies, that only the first such policy is processed.
 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP2) {
   SpawnedTestServer::SSLOptions ssl_options;
   SpawnedTestServer https_test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
   ASSERT_TRUE(https_test_server.Start());
 
   TestDelegate d;
-  URLRequest request(
+  scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-and-hpkp-headers2.html"),
-      DEFAULT_PRIORITY,
-      &d,
-      &default_context_);
-  request.Start();
+      DEFAULT_PRIORITY, &d, NULL));
+  request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(
       SpawnedTestServer::kLocalhost, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.sts.upgrade_mode);
 #if defined(OS_ANDROID)
   // Android's CertVerifyProc does not (yet) handle pins.
 #else
   EXPECT_TRUE(domain_state.HasPublicKeyPins());
 #endif
   EXPECT_NE(domain_state.sts.expiry, domain_state.pkp.expiry);
 
   EXPECT_TRUE(domain_state.sts.include_subdomains);
   EXPECT_FALSE(domain_state.pkp.include_subdomains);
 }
 
 TEST_F(URLRequestTestHTTP, ContentTypeNormalizationTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("files/content-type-normalization.html"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("files/content-type-normalization.html"),
+      DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   std::string mime_type;
-  req.GetMimeType(&mime_type);
+  req->GetMimeType(&mime_type);
   EXPECT_EQ("text/html", mime_type);
 
   std::string charset;
-  req.GetCharset(&charset);
+  req->GetCharset(&charset);
   EXPECT_EQ("utf-8", charset);
-  req.Cancel();
+  req->Cancel();
 }
 
 TEST_F(URLRequestTestHTTP, ProtocolHandlerAndFactoryRestrictDataRedirects) {
   // Test URLRequestJobFactory::ProtocolHandler::IsSafeRedirectTarget().
   GURL data_url("data:,foo");
   DataProtocolHandler data_protocol_handler;
   EXPECT_FALSE(data_protocol_handler.IsSafeRedirectTarget(data_url));
 
   // Test URLRequestJobFactoryImpl::IsSafeRedirectTarget().
   EXPECT_FALSE(job_factory_.IsSafeRedirectTarget(data_url));
 }
 
 #if !defined(DISABLE_FILE_SUPPORT)
 TEST_F(URLRequestTestHTTP, ProtocolHandlerAndFactoryRestrictFileRedirects) {
   // Test URLRequestJobFactory::ProtocolHandler::IsSafeRedirectTarget().
   GURL file_url("file:///foo.txt");
   FileProtocolHandler file_protocol_handler(base::MessageLoopProxy::current());
   EXPECT_FALSE(file_protocol_handler.IsSafeRedirectTarget(file_url));
 
   // Test URLRequestJobFactoryImpl::IsSafeRedirectTarget().
   EXPECT_FALSE(job_factory_.IsSafeRedirectTarget(file_url));
 }
 
 TEST_F(URLRequestTestHTTP, RestrictFileRedirects) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("files/redirect-to-file.html"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("files/redirect-to-file.html"), DEFAULT_PRIORITY, &d,
+      NULL));
+  req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req.status().error());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req->status().error());
 }
 #endif  // !defined(DISABLE_FILE_SUPPORT)
 
 TEST_F(URLRequestTestHTTP, RestrictDataRedirects) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("files/redirect-to-data.html"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("files/redirect-to-data.html"), DEFAULT_PRIORITY, &d,
+      NULL));
+  req->Start();
   base::MessageLoop::current()->Run();
 
-  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req.status().error());
+  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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("files/redirect-to-invalid-url.html"),
+      DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_INVALID_URL, req.status().error());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_EQ(ERR_INVALID_URL, req->status().error());
 }
 
 // Make sure redirects are cached, despite not reading their bodies.
 TEST_F(URLRequestTestHTTP, CacheRedirect) {
   ASSERT_TRUE(test_server_.Start());
   GURL redirect_url =
       test_server_.GetURL("files/redirect302-to-echo-cacheable");
 
   {
     TestDelegate d;
-    URLRequest req(redirect_url, DEFAULT_PRIORITY, &d, &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        redirect_url, DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().Run();
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_EQ(1, d.received_redirect_count());
-    EXPECT_EQ(test_server_.GetURL("echo"), req.url());
+    EXPECT_EQ(test_server_.GetURL("echo"), req->url());
   }
 
   {
     TestDelegate d;
     d.set_quit_on_redirect(true);
-    URLRequest req(redirect_url, DEFAULT_PRIORITY, &d, &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        redirect_url, DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(0, d.response_started_count());
-    EXPECT_TRUE(req.was_cached());
+    EXPECT_TRUE(req->was_cached());
 
-    req.FollowDeferredRedirect();
+    req->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(1, d.response_started_count());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
-    EXPECT_EQ(test_server_.GetURL("echo"), req.url());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
+    EXPECT_EQ(test_server_.GetURL("echo"), req->url());
   }
 }
 
 // Make sure a request isn't cached when a NetworkDelegate forces a redirect
 // when the headers are read, since the body won't have been read.
 TEST_F(URLRequestTestHTTP, NoCacheOnNetworkDelegateRedirect) {
   ASSERT_TRUE(test_server_.Start());
   // URL that is normally cached.
   GURL initial_url = test_server_.GetURL("cachetime");
 
   {
     // Set up the TestNetworkDelegate tp force a redirect.
     GURL redirect_to_url = test_server_.GetURL("echo");
     default_network_delegate_.set_redirect_on_headers_received_url(
         redirect_to_url);
 
     TestDelegate d;
-    URLRequest req(initial_url, DEFAULT_PRIORITY, &d, &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        initial_url, DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().Run();
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_EQ(1, d.received_redirect_count());
-    EXPECT_EQ(redirect_to_url, req.url());
+    EXPECT_EQ(redirect_to_url, req->url());
   }
 
   {
     TestDelegate d;
-    URLRequest req(initial_url, DEFAULT_PRIORITY, &d, &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        initial_url, DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
-    EXPECT_FALSE(req.was_cached());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
+    EXPECT_FALSE(req->was_cached());
     EXPECT_EQ(0, d.received_redirect_count());
-    EXPECT_EQ(initial_url, req.url());
+    EXPECT_EQ(initial_url, req->url());
   }
 }
 
 // Tests that redirection to an unsafe URL is allowed when it has been marked as
 // safe.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectToWhitelistedUnsafeURL) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL unsafe_url("data:text/html,this-is-considered-an-unsafe-url");
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
-    URLRequest r(test_server_.GetURL("whatever"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("whatever"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
 
-    EXPECT_EQ(2U, r.url_chain().size());
-    EXPECT_EQ(net::OK, r.status().error());
-    EXPECT_EQ(unsafe_url, r.url());
+    EXPECT_EQ(2U, r->url_chain().size());
+    EXPECT_EQ(net::OK, r->status().error());
+    EXPECT_EQ(unsafe_url, r->url());
     EXPECT_EQ("this-is-considered-an-unsafe-url", d.data_received());
   }
 }
 
 // Tests that a redirect to a different unsafe URL is blocked, even after adding
 // some other URL to the whitelist.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectToDifferentUnsafeURL) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL unsafe_url("data:text/html,something");
   GURL different_unsafe_url("data:text/html,something-else");
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(
       different_unsafe_url);
 
   TestDelegate d;
   {
-    URLRequest r(test_server_.GetURL("whatever"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("whatever"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_UNSAFE_REDIRECT, r.status().error());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+    EXPECT_EQ(ERR_UNSAFE_REDIRECT, r->status().error());
   }
 }
 
 // Redirects from an URL with fragment to an unsafe URL with fragment should
 // be allowed, and the reference fragment of the target URL should be preserved.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectWithDifferentReferenceFragment) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#fragment1"));
   GURL unsafe_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
   GURL expected_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
 
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
-    URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(2U, r.url_chain().size());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
-    EXPECT_EQ(original_url, r.original_url());
-    EXPECT_EQ(expected_url, r.url());
+    EXPECT_EQ(2U, r->url_chain().size());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(net::OK, r->status().error());
+    EXPECT_EQ(original_url, r->original_url());
+    EXPECT_EQ(expected_url, r->url());
   }
 }
 
 // When a delegate has specified a safe redirect URL, but it does not match the
 // redirect target, then do not prevent the reference fragment from being added.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragmentAndUnrelatedUnsafeUrl) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#expected-fragment"));
   GURL unsafe_url("data:text/html,this-url-does-not-match-redirect-url");
   GURL redirect_url(test_server_.GetURL("target"));
   GURL expected_redirect_url(test_server_.GetURL("target#expected-fragment"));
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
-    URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(2U, r.url_chain().size());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
-    EXPECT_EQ(original_url, r.original_url());
-    EXPECT_EQ(expected_redirect_url, r.url());
+    EXPECT_EQ(2U, r->url_chain().size());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(net::OK, r->status().error());
+    EXPECT_EQ(original_url, r->original_url());
+    EXPECT_EQ(expected_redirect_url, r->url());
   }
 }
 
 // When a delegate has specified a safe redirect URL, assume that the redirect
 // URL should not be changed. In particular, the reference fragment should not
 // be modified.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragment) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
   GURL redirect_url("data:text/html,expect-no-reference-fragment");
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(redirect_url);
 
   TestDelegate d;
   {
-    URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(2U, r.url_chain().size());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
-    EXPECT_EQ(original_url, r.original_url());
-    EXPECT_EQ(redirect_url, r.url());
+    EXPECT_EQ(2U, r->url_chain().size());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(net::OK, r->status().error());
+    EXPECT_EQ(original_url, r->original_url());
+    EXPECT_EQ(redirect_url, r->url());
   }
 }
 
 // When a URLRequestRedirectJob is created, the redirection must be followed and
 // the reference fragment of the target URL must not be modified.
 TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
   GURL redirect_url(test_server_.GetURL("echo"));
 
   TestDelegate d;
-  URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
+  scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+      original_url, DEFAULT_PRIORITY, &d, NULL));
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      &r, &default_network_delegate_, redirect_url,
+      r.get(), &default_network_delegate_, redirect_url,
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
-  r.Start();
+  r->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-  EXPECT_EQ(net::OK, r.status().error());
-  EXPECT_EQ(original_url, r.original_url());
-  EXPECT_EQ(redirect_url, r.url());
+  EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+  EXPECT_EQ(net::OK, r->status().error());
+  EXPECT_EQ(original_url, r->original_url());
+  EXPECT_EQ(redirect_url, r->url());
 }
 
 TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("echoheader?Referer"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.SetReferrer("http://user:pass@foo.com/");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d, NULL));
+  req->SetReferrer("http://user:pass@foo.com/");
+  req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(std::string("http://foo.com/"), d.data_received());
 }
 
 TEST_F(URLRequestTestHTTP, NoFragmentInReferrer) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("echoheader?Referer"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.SetReferrer("http://foo.com/test#fragment");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d, NULL));
+  req->SetReferrer("http://foo.com/test#fragment");
+  req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(std::string("http://foo.com/test"), d.data_received());
 }
 
 TEST_F(URLRequestTestHTTP, EmptyReferrerAfterValidReferrer) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("echoheader?Referer"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.SetReferrer("http://foo.com/test#fragment");
-  req.SetReferrer("");
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d, NULL));
+  req->SetReferrer("http://foo.com/test#fragment");
+  req->SetReferrer("");
+  req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(std::string("None"), d.data_received());
 }
 
 // Defer network start and then resume, checking that the request was a success
 // and bytes were received.
 TEST_F(URLRequestTestHTTP, DeferredBeforeNetworkStart) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     d.set_quit_on_network_start(true);
     GURL test_url(test_server_.GetURL("echo"));
-    URLRequest req(test_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_url, DEFAULT_PRIORITY, &d, NULL));
 
-    req.Start();
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_before_network_start_count());
     EXPECT_EQ(0, d.response_started_count());
 
-    req.ResumeNetworkStart();
+    req->ResumeNetworkStart();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_NE(0, d.bytes_received());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   }
 }
 
 // Check that OnBeforeNetworkStart is only called once even if there is a
 // redirect.
 TEST_F(URLRequestTestHTTP, BeforeNetworkStartCalledOnce) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
     d.set_quit_on_network_start(true);
-    URLRequest req(test_server_.GetURL("server-redirect?echo"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server_.GetURL("server-redirect?echo"), DEFAULT_PRIORITY, &d,
+        NULL));
 
-    req.Start();
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_before_network_start_count());
     EXPECT_EQ(0, d.response_started_count());
     EXPECT_EQ(0, d.received_redirect_count());
 
-    req.ResumeNetworkStart();
+    req->ResumeNetworkStart();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
-    req.FollowDeferredRedirect();
+    req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     // Check that the redirect's new network transaction does not get propagated
     // to a second OnBeforeNetworkStart() notification.
     EXPECT_EQ(1, d.received_before_network_start_count());
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_NE(0, d.bytes_received());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   }
 }
 
 // Cancel the request after learning that the request would use the network.
 TEST_F(URLRequestTestHTTP, CancelOnBeforeNetworkStart) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     d.set_quit_on_network_start(true);
     GURL test_url(test_server_.GetURL("echo"));
-    URLRequest req(test_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_url, DEFAULT_PRIORITY, &d, NULL));
 
-    req.Start();
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_before_network_start_count());
     EXPECT_EQ(0, d.response_started_count());
 
-    req.Cancel();
+    req->Cancel();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
-    EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
+    EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   }
 }
 
 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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server_.GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d,
+        NULL));
+    req->Start();
     base::RunLoop().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());
+    EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, DeferredRedirect) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
     GURL test_url(test_server_.GetURL("files/redirect-test.html"));
-    URLRequest req(test_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_url, DEFAULT_PRIORITY, &d, NULL));
 
-    req.Start();
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
-    req.FollowDeferredRedirect();
+    req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::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(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, DeferredRedirect_GetFullRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
     GURL test_url(test_server_.GetURL("files/redirect-test.html"));
-    URLRequest req(test_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_url, DEFAULT_PRIORITY, &d, NULL));
 
     EXPECT_FALSE(d.have_full_request_headers());
 
-    req.Start();
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), test_url);
     d.ClearFullRequestHeaders();
 
-    req.FollowDeferredRedirect();
+    req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     GURL target_url(test_server_.GetURL("files/with-headers.html"));
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), target_url);
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::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(base::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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
-    req.Start();
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server_.GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d,
+        NULL));
+    req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
-    req.Cancel();
+    req->Cancel();
     base::RunLoop().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());
+    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"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d,
+        NULL));
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
-    req.SetExtraRequestHeaders(headers);
-    req.Start();
+    req->SetExtraRequestHeaders(headers);
+    req->Start();
     base::RunLoop().Run();
 
     LoadTimingInfo load_timing_info;
-    req.GetLoadTimingInfo(&load_timing_info);
+    req->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 
   // Expect a cache hit.
   {
     TestDelegate d;
-    URLRequest req(test_server_.GetURL("echoheadercache?foo"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d,
+        NULL));
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
-    req.SetExtraRequestHeaders(headers);
-    req.Start();
+    req->SetExtraRequestHeaders(headers);
+    req->Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(req.was_cached());
+    EXPECT_TRUE(req->was_cached());
 
     LoadTimingInfo load_timing_info;
-    req.GetLoadTimingInfo(&load_timing_info);
+    req->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingCacheHitNoNetwork(load_timing_info);
   }
 
   // Expect a cache miss.
   {
     TestDelegate d;
-    URLRequest req(test_server_.GetURL("echoheadercache?foo"),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
+    scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+        test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d,
+        NULL));
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "2");
-    req.SetExtraRequestHeaders(headers);
-    req.Start();
+    req->SetExtraRequestHeaders(headers);
+    req->Start();
     base::RunLoop().Run();
 
-    EXPECT_FALSE(req.was_cached());
+    EXPECT_FALSE(req->was_cached());
 
     LoadTimingInfo load_timing_info;
-    req.GetLoadTimingInfo(&load_timing_info);
+    req->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 }
 
 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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
 
     base::RunLoop().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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.SetLoadFlags(LOAD_VALIDATE_CACHE);
-    r.Start();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d, NULL));
+    r->SetLoadFlags(LOAD_VALIDATE_CACHE);
+    r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
-    EXPECT_TRUE(r.was_cached());
+    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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url_requiring_auth, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
 
     base::RunLoop().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, DEFAULT_PRIORITY, &d, &context);
-    r.Start();
+    scoped_ptr<URLRequest> r(context.CreateRequest(
+        url_with_identity, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
 
     base::RunLoop().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);
   }
 }
 
 // Tests that load timing works as expected with auth and the cache.
 TEST_F(URLRequestTestHTTP, BasicAuthLoadTiming) {
   ASSERT_TRUE(test_server_.Start());
 
   // populate the cache
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
-    URLRequest r(test_server_.GetURL("auth-basic"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     LoadTimingInfo load_timing_info_before_auth;
     EXPECT_TRUE(default_network_delegate_.GetLoadTimingInfoBeforeAuth(
         &load_timing_info_before_auth));
     TestLoadTimingNotReused(load_timing_info_before_auth,
                             CONNECT_TIMING_HAS_DNS_TIMES);
 
     LoadTimingInfo load_timing_info;
-    r.GetLoadTimingInfo(&load_timing_info);
+    r->GetLoadTimingInfo(&load_timing_info);
     // The test server does not support keep alive sockets, so the second
     // request with auth should use a new socket.
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
     EXPECT_NE(load_timing_info_before_auth.socket_log_id,
               load_timing_info.socket_log_id);
     EXPECT_LE(load_timing_info_before_auth.receive_headers_end,
               load_timing_info.connect_timing.connect_start);
   }
 
   // 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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.SetLoadFlags(LOAD_VALIDATE_CACHE);
-    r.Start();
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d, NULL));
+    r->SetLoadFlags(LOAD_VALIDATE_CACHE);
+    r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
-    EXPECT_TRUE(r.was_cached());
+    EXPECT_TRUE(r->was_cached());
 
     // Since there was a request that went over the wire, the load timing
     // information should include connection times.
     LoadTimingInfo load_timing_info;
-    r.GetLoadTimingInfo(&load_timing_info);
+    r->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 }
 
 // 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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("POST");
-  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("files/redirect-to-echoall"), DEFAULT_PRIORITY, &d,
+      NULL));
+  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();
+  req->SetExtraRequestHeaders(headers);
+  req->Start();
   base::RunLoop().Run();
 
   std::string mime_type;
-  req.GetMimeType(&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.
@@ skipping 58 matching lines @@
 
 // Make sure that 308 responses without bodies are not treated as redirects.
 // Certain legacy apis that pre-date the response code expect this behavior
 // (Like Google Drive).
 TEST_F(URLRequestTestHTTP, NoRedirectOn308WithoutLocationHeader) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   const GURL url = test_server_.GetURL("files/308-without-location-header");
 
-  URLRequest request(url, DEFAULT_PRIORITY, &d, &default_context_);
+  scoped_ptr<URLRequest> request(default_context_.CreateRequest(
+      url, DEFAULT_PRIORITY, &d, NULL));
 
-  request.Start();
+  request->Start();
   base::RunLoop().Run();
-  EXPECT_EQ(URLRequestStatus::SUCCESS, request.status().status());
-  EXPECT_EQ(OK, request.status().error());
+  EXPECT_EQ(URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_EQ(OK, request->status().error());
   EXPECT_EQ(0, d.received_redirect_count());
-  EXPECT_EQ(308, request.response_headers()->response_code());
+  EXPECT_EQ(308, request->response_headers()->response_code());
   EXPECT_EQ("This is not a redirect.", d.data_received());
 }
 
 TEST_F(URLRequestTestHTTP, Redirect302PreserveReferenceFragment) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("files/redirect302-to-echo#fragment"));
   GURL expected_url(test_server_.GetURL("echo#fragment"));
 
   TestDelegate d;
   {
-    URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        original_url, DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(2U, r.url_chain().size());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
-    EXPECT_EQ(original_url, r.original_url());
-    EXPECT_EQ(expected_url, r.url());
+    EXPECT_EQ(2U, r->url_chain().size());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(net::OK, r->status().error());
+    EXPECT_EQ(original_url, r->original_url());
+    EXPECT_EQ(expected_url, r->url());
   }
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) {
   ASSERT_TRUE(test_server_.Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("empty.html"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("POST");
-  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d, NULL));
+  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);
+  req->SetExtraRequestHeaders(headers);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      &req, &default_network_delegate_, test_server_.GetURL("echo"),
+      req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
-  req.Start();
+  req->Start();
   base::RunLoop().Run();
-  EXPECT_EQ("GET", req.method());
+  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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.set_method("POST");
-  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d, NULL));
+  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);
+  req->SetExtraRequestHeaders(headers);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      &req, &default_network_delegate_, test_server_.GetURL("echo"),
+      req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
       "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
-  req.Start();
+  req->Start();
   base::RunLoop().Run();
-  EXPECT_EQ("POST", req.method());
+  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", std::string());
   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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &context);
-  req.Start();
+  scoped_ptr<URLRequest> req(context.CreateRequest(
+      test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d,
+      NULL));
+  req->Start();
   base::RunLoop().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());
 
   std::string empty_string;  // Avoid most vexing parse on line below.
   StaticHttpUserAgentSettings settings(empty_string, empty_string);
   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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &context);
-  req.Start();
+  scoped_ptr<URLRequest> req(context.CreateRequest(
+      test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d,
+      NULL));
+  req->Start();
   base::RunLoop().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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d,
+      NULL));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kAcceptLanguage, "ru");
-  req.SetExtraRequestHeaders(headers);
-  req.Start();
+  req->SetExtraRequestHeaders(headers);
+  req->Start();
   base::RunLoop().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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?Accept-Encoding"), DEFAULT_PRIORITY, &d,
+      NULL));
   HttpRequestHeaders headers;
-  req.SetExtraRequestHeaders(headers);
-  req.Start();
+  req->SetExtraRequestHeaders(headers);
+  req->Start();
   base::RunLoop().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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?Accept-Encoding"), DEFAULT_PRIORITY, &d,
+      NULL));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kAcceptEncoding, "identity");
-  req.SetExtraRequestHeaders(headers);
-  req.Start();
+  req->SetExtraRequestHeaders(headers);
+  req->Start();
   base::RunLoop().Run();
   EXPECT_FALSE(ContainsString(d.data_received(), "gzip"));
   EXPECT_TRUE(ContainsString(d.data_received(), "identity"));
 }
 
 // Check that setting the A-C header sends the proper header.
 TEST_F(URLRequestTestHTTP, SetAcceptCharset) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("echoheader?Accept-Charset"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?Accept-Charset"), DEFAULT_PRIORITY, &d,
+      NULL));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kAcceptCharset, "koi-8r");
-  req.SetExtraRequestHeaders(headers);
-  req.Start();
+  req->SetExtraRequestHeaders(headers);
+  req->Start();
   base::RunLoop().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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  req.Start();
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?User-Agent"), DEFAULT_PRIORITY, &d,
+      NULL));
+  req->Start();
   base::RunLoop().Run();
-  EXPECT_EQ(req.context()->http_user_agent_settings()->GetUserAgent(),
+  EXPECT_EQ(default_context_.http_user_agent_settings()->GetUserAgent(),
             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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("echoheader?User-Agent"), DEFAULT_PRIORITY, &d,
+      NULL));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kUserAgent, "Lynx (textmode)");
-  req.SetExtraRequestHeaders(headers);
-  req.Start();
+  req->SetExtraRequestHeaders(headers);
+  req->Start();
   base::RunLoop().Run();
   EXPECT_EQ(std::string("Lynx (textmode)"), d.data_received());
 }
 
 // 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), DEFAULT_PRIORITY, &d, &context);
-    req.Start();
+    scoped_ptr<URLRequest> req(context.CreateRequest(
+        test_server_.GetURL(tests[i].request), DEFAULT_PRIORITY, &d, NULL));
+    req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(tests[i].expected_response, d.data_received())
         << " Request = \"" << tests[i].request << "\"";
   }
 }
 
 // Make sure that URLRequest passes on its priority updates to
 // newly-created jobs after the first one.
 TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
-  URLRequest req(test_server_.GetURL("empty.html"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-  EXPECT_EQ(DEFAULT_PRIORITY, req.priority());
+  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
+      test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d, NULL));
+  EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
 
   scoped_refptr<URLRequestRedirectJob> redirect_job =
       new URLRequestRedirectJob(
-          &req, &default_network_delegate_, test_server_.GetURL("echo"),
+          req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
           URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(redirect_job.get());
 
-  req.SetPriority(LOW);
-  req.Start();
-  EXPECT_TRUE(req.is_pending());
+  req->SetPriority(LOW);
+  req->Start();
+  EXPECT_TRUE(req->is_pending());
 
   scoped_refptr<URLRequestTestJob> job =
-      new URLRequestTestJob(&req, &default_network_delegate_);
+      new URLRequestTestJob(req.get(), &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
 
   // Should trigger |job| to be started.
   base::RunLoop().Run();
   EXPECT_EQ(LOW, job->priority());
 }
 
 // Check that creating a network request while entering/exiting suspend mode
 // fails as it should.  This is the only case where an HttpTransactionFactory
 // does not return an HttpTransaction.
@@ skipping 14 matching lines @@
   network_layer->OnSuspend();
 
   HttpCache http_cache(network_layer.release(), default_context_.net_log(),
                        HttpCache::DefaultBackend::InMemory(0));
 
   TestURLRequestContext context(true);
   context.set_http_transaction_factory(&http_cache);
   context.Init();
 
   TestDelegate d;
-  URLRequest req(GURL("http://127.0.0.1/"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &context);
-  req.Start();
+  scoped_ptr<URLRequest> req(context.CreateRequest(
+      GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.request_failed());
-  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req.status().error());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req->status().error());
 }
 
 // Check that creating a network request while entering/exiting suspend mode
 // fails as it should in the case there is no cache.  This is the only case
 // where an HttpTransactionFactory does not return an HttpTransaction.
 TEST_F(URLRequestTestHTTP, NetworkSuspendTestNoCache) {
   // Create a new HttpNetworkLayer that thinks it's suspended.
   HttpNetworkSession::Params params;
   params.host_resolver = default_context_.host_resolver();
   params.cert_verifier = default_context_.cert_verifier();
   params.transport_security_state = default_context_.transport_security_state();
   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_network_delegate_;
   params.http_server_properties = default_context_.http_server_properties();
   HttpNetworkLayer network_layer(new HttpNetworkSession(params));
   network_layer.OnSuspend();
 
   TestURLRequestContext context(true);
   context.set_http_transaction_factory(&network_layer);
   context.Init();
 
   TestDelegate d;
-  URLRequest req(GURL("http://127.0.0.1/"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &context);
-  req.Start();
+  scoped_ptr<URLRequest> req(context.CreateRequest(
+      GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d, NULL));
+  req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.request_failed());
-  EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req.status().error());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req->status().error());
 }
 
 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_;
 };
 
 TEST_F(HTTPSRequestTest, HTTPSGetTest) {
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   TestDelegate d;
   {
-    URLRequest r(test_server.GetURL(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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());
+    CheckSSLInfo(r->ssl_info());
     EXPECT_EQ(test_server.host_port_pair().host(),
-              r.GetSocketAddress().host());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server.host_port_pair().port(),
-              r.GetSocketAddress().port());
+              r->GetSocketAddress().port());
   }
 }
 
 TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::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(std::string()),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
+      scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+          test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-      r.Start();
-      EXPECT_TRUE(r.is_pending());
+      r->Start();
+      EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().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());
+        CheckSSLInfo(r->ssl_info());
       } else {
         EXPECT_EQ(0, d.bytes_received());
       }
     }
   }
 }
 
 TEST_F(HTTPSRequestTest, HTTPSExpiredTest) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_EXPIRED);
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::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(std::string()),
-                   DEFAULT_PRIORITY,
-                   &d,
-                   &default_context_);
+      scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+          test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-      r.Start();
-      EXPECT_TRUE(r.is_pending());
+      r->Start();
+      EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().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());
+        CheckSSLInfo(r->ssl_info());
       } else {
         EXPECT_EQ(0, d.bytes_received());
       }
     }
   }
 }
 
 // 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.
@@ skipping 14 matching lines @@
   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(base::StringPrintf("https://www.google.com:%d",
-                                       test_server.host_port_pair().port())),
-               DEFAULT_PRIORITY,
-               &d,
-               &context);
+  scoped_ptr<URLRequest> r(context.CreateRequest(
+      GURL(base::StringPrintf("https://www.google.com:%d",
+                                  test_server.host_port_pair().port())),
+      DEFAULT_PRIORITY, &d, NULL));
 
-  r.Start();
-  EXPECT_TRUE(r.is_pending());
+  r->Start();
+  EXPECT_TRUE(r->is_pending());
 
   base::RunLoop().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
@@ skipping 25 matching lines @@
   EXPECT_TRUE(transport_security_state.GetStaticDomainState(
       "www.google.com", true, &static_domain_state));
   context.set_transport_security_state(&transport_security_state);
   context.Init();
 
   TransportSecurityState::DomainState dynamic_domain_state;
   EXPECT_FALSE(transport_security_state.GetDynamicDomainState(
       "www.google.com", &dynamic_domain_state));
 
   TestDelegate d;
-  URLRequest r(GURL(base::StringPrintf("https://www.google.com:%d",
-                                       test_server.host_port_pair().port())),
-               DEFAULT_PRIORITY,
-               &d,
-               &context);
+  scoped_ptr<URLRequest> r(context.CreateRequest(
+      GURL(base::StringPrintf("https://www.google.com:%d",
+                                  test_server.host_port_pair().port())),
+      DEFAULT_PRIORITY, &d, NULL));
 
-  r.Start();
-  EXPECT_TRUE(r.is_pending());
+  r->Start();
+  EXPECT_TRUE(r->is_pending());
 
   base::RunLoop().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 states, and check that they haven't changed.
   TransportSecurityState::DomainState new_static_domain_state;
@@ skipping 47 matching lines @@
   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(base::StringPrintf("http://www.somewhere.com:%d/echo",
-                                         test_server.host_port_pair().port())),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &context);
-  req.set_method("POST");
-  req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  scoped_ptr<URLRequest> req(context.CreateRequest(
+      GURL(base::StringPrintf("http://www.somewhere.com:%d/echo",
+                                  test_server.host_port_pair().port())),
+      DEFAULT_PRIORITY, &d, NULL));
+  req->set_method("POST");
+  req->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
 
-  req.Start();
+  req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ("https", req.url().scheme());
-  EXPECT_EQ("POST", req.method());
+  EXPECT_EQ("https", req->url().scheme());
+  EXPECT_EQ("POST", req->method());
   EXPECT_EQ(kData, d.data_received());
 
   LoadTimingInfo load_timing_info;
   network_delegate.GetLoadTimingInfoBeforeRedirect(&load_timing_info);
   // LoadTimingInfo of HSTS redirects is similar to that of network cache hits
   TestLoadTimingCacheHitNoNetwork(load_timing_info);
 }
 
 namespace {
 
@@ skipping 25 matching lines @@
   SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientAuthTestDelegate d;
   {
-    URLRequest r(test_server.GetURL(std::string()),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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);
+    r->ContinueWithCertificate(NULL);
 
     base::RunLoop().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.
   SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.record_resume = true;
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientSocket::ClearSessionCache();
 
   {
     TestDelegate d;
-    URLRequest r(test_server.GetURL("ssl-session-cache"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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.
@@ skipping 28 matching lines @@
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientSocket::ClearSessionCache();
 
   {
     TestDelegate d;
-    URLRequest r(test_server.GetURL("ssl-session-cache"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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.transport_security_state = default_context_.transport_security_state();
   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_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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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.
 
@@ skipping 27 matching lines @@
 
  protected:
   void DoFallbackTest(const SpawnedTestServer::SSLOptions& ssl_options) {
     DCHECK(!request_);
     SpawnedTestServer test_server(
         SpawnedTestServer::TYPE_HTTPS,
         ssl_options,
         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
     ASSERT_TRUE(test_server.Start());
 
-    request_.reset(new URLRequest(
-        test_server.GetURL(std::string()), DEFAULT_PRIORITY,
-        &delegate_, &context_));
+    request_ = context_.CreateRequest(
+        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &delegate_, NULL);
     request_->Start();
 
     base::RunLoop().Run();
   }
 
   void ExpectConnection(int version) {
     EXPECT_EQ(1, delegate_.response_started_count());
     EXPECT_NE(0, delegate_.bytes_received());
     EXPECT_EQ(version, SSLConnectionStatusToVersion(
         request_->ssl_info().connection_status));
@@ skipping 162 matching lines @@
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientSocket::ClearSessionCache();
 
   // Simulate the certificate being expired and attempt a connection.
   cert_verifier_.set_default_result(net::ERR_CERT_DATE_INVALID);
   {
     TestDelegate d;
-    URLRequest r(test_server.GetURL("ssl-session-cache"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
   }
 
   reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())->
     CloseAllConnections();
 
   // Now change the certificate to be acceptable (so that the response is
   // loaded), and ensure that no session id is presented to the peer.
   cert_verifier_.set_default_result(net::OK);
   {
     TestDelegate d;
-    URLRequest r(test_server.GetURL("ssl-session-cache"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d, NULL));
 
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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.
     //
@@ skipping 100 matching lines @@
     // We always overwrite out_cert_status.
     *out_cert_status = 0;
     SpawnedTestServer test_server(
         SpawnedTestServer::TYPE_HTTPS,
         ssl_options,
         base::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(std::string()), DEFAULT_PRIORITY, &d, &context_);
-    r.Start();
+    scoped_ptr<URLRequest> r(context_.CreateRequest(
+        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
-    *out_cert_status = r.ssl_info().cert_status;
+    *out_cert_status = r->ssl_info().cert_status;
   }
 
   virtual ~HTTPSOCSPTest() {
 #if defined(USE_NSS) || defined(OS_IOS)
     ShutdownNSSHttpIO();
 #endif
   }
 
  protected:
   // SetupContext configures the URLRequestContext that will be used for making
@@ skipping 428 matching lines @@
   FtpNetworkLayer ftp_transaction_factory(default_context_.host_resolver());
 
   GURL url("ftp://127.0.0.1:7");
   job_factory.SetProtocolHandler(
       "ftp",
       new FtpProtocolHandler(&ftp_transaction_factory));
   default_context_.set_job_factory(&job_factory);
 
   TestDelegate d;
   {
-    URLRequest r(url, DEFAULT_PRIORITY, &d, &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        url, DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_FALSE(r.is_pending());
-    EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_UNSAFE_PORT, r.status().error());
+    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("/"), DEFAULT_PRIORITY, &d, &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("/"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_FALSE(r.is_pending());
+    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());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
-              r.GetSocketAddress().port());
+              r->GetSocketAddress().port());
   }
 }
 
 // Flaky, see http://crbug.com/25045.
 TEST_F(URLRequestTestFTP, DISABLED_FTPGetTestAnonymous) {
   ASSERT_TRUE(test_server_.Start());
 
   base::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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("/LICENSE"), DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
-              r.GetSocketAddress().port());
+              r->GetSocketAddress().port());
   }
 }
 
 // Flaky, see http://crbug.com/25045.
 TEST_F(URLRequestTestFTP, DISABLED_FTPGetTest) {
   ASSERT_TRUE(test_server_.Start());
 
   base::FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
   app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
-    URLRequest r(
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
         test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome", "chrome"),
-        DEFAULT_PRIORITY,
-        &d,
-        &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+        DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(test_server_.host_port_pair().host(),
-              r.GetSocketAddress().host());
+              r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
-              r.GetSocketAddress().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));
 
     LoadTimingInfo load_timing_info;
-    r.GetLoadTimingInfo(&load_timing_info);
+    r->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNoHttpResponse(load_timing_info);
   }
 }
 
 // Flaky, see http://crbug.com/25045.
 TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPassword) {
   ASSERT_TRUE(test_server_.Start());
 
   base::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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome",
+                                               "wrong_password"),
+        DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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());
 
   base::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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome",
+                                               "wrong_password"),
+        DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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());
 
   base::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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURLWithUserAndPassword("/LICENSE", "wrong_user",
+                                               "chrome"),
+        DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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());
 
   base::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"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURLWithUserAndPassword("/LICENSE", "wrong_user",
+                                               "chrome"),
+        DEFAULT_PRIORITY, &d, NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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());
 
   base::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(
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
         test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome", "chrome"),
-        DEFAULT_PRIORITY,
-        d.get(),
-        &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+        DEFAULT_PRIORITY, d.get(), NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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"),
-                 DEFAULT_PRIORITY,
-                 d.get(),
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("/LICENSE"), DEFAULT_PRIORITY, d.get(), NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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());
 
   base::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"),
-                 DEFAULT_PRIORITY,
-                 d.get(),
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome",
+                                               "wrong_password"),
+        DEFAULT_PRIORITY, d.get(), NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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"),
-                 DEFAULT_PRIORITY,
-                 d.get(),
-                 &default_context_);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURL("/LICENSE"), DEFAULT_PRIORITY, d.get(), NULL));
+    r->Start();
+    EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     int64 file_size = 0;
     base::GetFileSize(app_path, &file_size);
 
-    EXPECT_FALSE(r.is_pending());
+    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