Allow URLRequests from one context to have different NetworkDelegates.

net/url_request/url_request_ftp_job_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 "net/url_request/url_request_ftp_job.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "net/base/host_port_pair.h"
@@ skipping 250 matching lines @@
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 2, "Content-Length: 9\r\n\r\n"),
     MockRead(ASYNC, 3, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
-  ASSERT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY,
+      &request_delegate, NULL));
+  url_request->Start();
+  ASSERT_TRUE(url_request->is_pending());
   socket_data(0)->RunFor(4);
 
-  EXPECT_TRUE(url_request.status().is_success());
-  EXPECT_TRUE(url_request.proxy_server().Equals(
+  EXPECT_TRUE(url_request->status().is_success());
+  EXPECT_TRUE(url_request->proxy_server().Equals(
       net::HostPortPair::FromString("localhost:80")));
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate.auth_required_called());
   EXPECT_EQ("test.html", request_delegate.data_received());
 }
 
 // Regression test for http://crbug.com/237526 .
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestOrphanJob) {
   // Use a PAC URL so that URLRequestFtpJob's |pac_request_| field is non-NULL.
   request_context()->set_proxy_service(
       new ProxyService(
           new ProxyConfigServiceFixed(
               ProxyConfig::CreateFromCustomPacURL(GURL("http://foo"))),
           new MockAsyncProxyResolver, NULL));
 
   TestDelegate request_delegate;
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      NULL));
+  url_request->Start();
 
   // Now |url_request| will be deleted before its completion,
   // resulting in it being orphaned. It should not crash.
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestNeedProxyAuthNoCredentials) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
     // No credentials.
     MockRead(ASYNC, 1, "HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead(ASYNC, 2, "Proxy-Authenticate: Basic "
              "realm=\"MyRealm1\"\r\n"),
     MockRead(ASYNC, 3, "Content-Length: 9\r\n\r\n"),
     MockRead(ASYNC, 4, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
-  ASSERT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      NULL));
+  url_request->Start();
+  ASSERT_TRUE(url_request->is_pending());
   socket_data(0)->RunFor(5);
 
-  EXPECT_TRUE(url_request.status().is_success());
-  EXPECT_TRUE(url_request.proxy_server().Equals(
+  EXPECT_TRUE(url_request->status().is_success());
+  EXPECT_TRUE(url_request->proxy_server().Equals(
       net::HostPortPair::FromString("localhost:80")));
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
   EXPECT_EQ("test.html", request_delegate.data_received());
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestNeedProxyAuthWithCredentials) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
@@ skipping 16 matching lines @@
     MockRead(ASYNC, 6, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 7, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 8, "test2.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   request_delegate.set_credentials(
       AuthCredentials(ASCIIToUTF16("myuser"), ASCIIToUTF16("mypass")));
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
-  ASSERT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      NULL));
+  url_request->Start();
+  ASSERT_TRUE(url_request->is_pending());
   socket_data(0)->RunFor(9);
 
-  EXPECT_TRUE(url_request.status().is_success());
+  EXPECT_TRUE(url_request->status().is_success());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate.data_received());
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestNeedServerAuthNoCredentials) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
     // No credentials.
     MockRead(ASYNC, 1, "HTTP/1.1 401 Unauthorized\r\n"),
     MockRead(ASYNC, 2, "WWW-Authenticate: Basic "
              "realm=\"MyRealm1\"\r\n"),
     MockRead(ASYNC, 3, "Content-Length: 9\r\n\r\n"),
     MockRead(ASYNC, 4, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
-  ASSERT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      NULL));
+  url_request->Start();
+  ASSERT_TRUE(url_request->is_pending());
   socket_data(0)->RunFor(5);
 
-  EXPECT_TRUE(url_request.status().is_success());
+  EXPECT_TRUE(url_request->status().is_success());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
   EXPECT_EQ("test.html", request_delegate.data_received());
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestNeedServerAuthWithCredentials) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
@@ skipping 15 matching lines @@
     MockRead(ASYNC, 6, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 7, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 8, "test2.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   request_delegate.set_credentials(
       AuthCredentials(ASCIIToUTF16("myuser"), ASCIIToUTF16("mypass")));
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
-  ASSERT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      NULL));
+  url_request->Start();
+  ASSERT_TRUE(url_request->is_pending());
   socket_data(0)->RunFor(9);
 
-  EXPECT_TRUE(url_request.status().is_success());
+  EXPECT_TRUE(url_request->status().is_success());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate.data_received());
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestNeedProxyAndServerAuth) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
@@ skipping 37 matching lines @@
 
   // Make sure cached FTP credentials are not used for proxy authentication.
   request_context()->GetFtpAuthCache()->Add(
       url.GetOrigin(),
       AuthCredentials(ASCIIToUTF16("userdonotuse"),
                       ASCIIToUTF16("passworddonotuse")));
 
   TestDelegate request_delegate;
   request_delegate.set_credentials(
       AuthCredentials(ASCIIToUTF16("proxyuser"), ASCIIToUTF16("proxypass")));
-  URLRequest url_request(
-      url, DEFAULT_PRIORITY, &request_delegate, request_context());
-  url_request.Start();
-  ASSERT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      url, DEFAULT_PRIORITY, &request_delegate, NULL));
+  url_request->Start();
+  ASSERT_TRUE(url_request->is_pending());
   socket_data(0)->RunFor(5);
 
   request_delegate.set_credentials(
       AuthCredentials(ASCIIToUTF16("myuser"), ASCIIToUTF16("mypass")));
   socket_data(0)->RunFor(9);
 
-  EXPECT_TRUE(url_request.status().is_success());
+  EXPECT_TRUE(url_request->status().is_success());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate.data_received());
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestDoNotSaveCookies) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 2, "Content-Length: 9\r\n"),
     MockRead(ASYNC, 3, "Set-Cookie: name=value\r\n\r\n"),
     MockRead(ASYNC, 4, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
-  ASSERT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      NULL));
+  url_request->Start();
+  ASSERT_TRUE(url_request->is_pending());
 
   socket_data(0)->RunFor(5);
 
-  EXPECT_TRUE(url_request.status().is_success());
+  EXPECT_TRUE(url_request->status().is_success());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 
   // Make sure we do not accept cookies.
   EXPECT_EQ(0, network_delegate()->set_cookie_count());
 
   EXPECT_FALSE(request_delegate.auth_required_called());
   EXPECT_EQ("test.html", request_delegate.data_received());
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestDoNotFollowRedirects) {
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 302 Found\r\n"),
     MockRead(ASYNC, 2, "Location: http://other.example.com/\r\n\r\n"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
-  URLRequest url_request(GURL("ftp://ftp.example.com/"),
-                         DEFAULT_PRIORITY,
-                         &request_delegate,
-                         request_context());
-  url_request.Start();
-  EXPECT_TRUE(url_request.is_pending());
+  scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      NULL));
+  url_request->Start();
+  EXPECT_TRUE(url_request->is_pending());
 
   base::MessageLoop::current()->RunUntilIdle();
 
-  EXPECT_TRUE(url_request.is_pending());
+  EXPECT_TRUE(url_request->is_pending());
   EXPECT_EQ(0, request_delegate.response_started_count());
   EXPECT_EQ(0, network_delegate()->error_count());
-  ASSERT_TRUE(url_request.status().is_success());
+  ASSERT_TRUE(url_request->status().is_success());
 
   socket_data(0)->RunFor(1);
 
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(1, network_delegate()->error_count());
-  EXPECT_FALSE(url_request.status().is_success());
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, url_request.status().error());
+  EXPECT_FALSE(url_request->status().is_success());
+  EXPECT_EQ(ERR_UNSAFE_REDIRECT, url_request->status().error());
 }
 
 // We should re-use socket for requests using the same scheme, host, and port.
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestReuseSocket) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/first HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
     MockWrite(ASYNC, 4, "GET ftp://ftp.example.com/second HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 2, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 3, "test1.html"),
     MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 6, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 7, "test2.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate1;
-  URLRequest url_request1(GURL("ftp://ftp.example.com/first"),
-                          DEFAULT_PRIORITY,
-                          &request_delegate1,
-                          request_context());
-  url_request1.Start();
-  ASSERT_TRUE(url_request1.is_pending());
+
+  scoped_ptr<URLRequest> url_request1(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/first"), DEFAULT_PRIORITY, &request_delegate1,
+      NULL));
+  url_request1->Start();
+  ASSERT_TRUE(url_request1->is_pending());
   socket_data(0)->RunFor(4);
 
-  EXPECT_TRUE(url_request1.status().is_success());
-  EXPECT_TRUE(url_request1.proxy_server().Equals(
+  EXPECT_TRUE(url_request1->status().is_success());
+  EXPECT_TRUE(url_request1->proxy_server().Equals(
       net::HostPortPair::FromString("localhost:80")));
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate1.auth_required_called());
   EXPECT_EQ("test1.html", request_delegate1.data_received());
 
   TestDelegate request_delegate2;
-  URLRequest url_request2(GURL("ftp://ftp.example.com/second"),
-                          DEFAULT_PRIORITY,
-                          &request_delegate2,
-                          request_context());
-  url_request2.Start();
-  ASSERT_TRUE(url_request2.is_pending());
+  scoped_ptr<URLRequest> url_request2(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/second"), DEFAULT_PRIORITY,
+      &request_delegate2, NULL));
+  url_request2->Start();
+  ASSERT_TRUE(url_request2->is_pending());
   socket_data(0)->RunFor(4);
 
-  EXPECT_TRUE(url_request2.status().is_success());
+  EXPECT_TRUE(url_request2->status().is_success());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate2.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate2.data_received());
 }
 
 // We should not re-use socket when there are two requests to the same host,
 // but one is FTP and the other is HTTP.
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestDoNotReuseSocket) {
   MockWrite writes1[] = {
@@ skipping 17 matching lines @@
   MockRead reads2[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 2, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 3, "test2.html"),
   };
 
   AddSocket(reads1, arraysize(reads1), writes1, arraysize(writes1));
   AddSocket(reads2, arraysize(reads2), writes2, arraysize(writes2));
 
   TestDelegate request_delegate1;
-  URLRequest url_request1(GURL("ftp://ftp.example.com/first"),
-                          DEFAULT_PRIORITY,
-                          &request_delegate1,
-                          request_context());
-  url_request1.Start();
-  ASSERT_TRUE(url_request1.is_pending());
+  scoped_ptr<URLRequest> url_request1(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/first"), DEFAULT_PRIORITY,
+      &request_delegate1, NULL));
+  url_request1->Start();
+  ASSERT_TRUE(url_request1->is_pending());
   socket_data(0)->RunFor(4);
 
-  EXPECT_TRUE(url_request1.status().is_success());
+  EXPECT_TRUE(url_request1->status().is_success());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate1.auth_required_called());
   EXPECT_EQ("test1.html", request_delegate1.data_received());
 
   TestDelegate request_delegate2;
-  URLRequest url_request2(GURL("http://ftp.example.com/second"),
-                          DEFAULT_PRIORITY,
-                          &request_delegate2,
-                          request_context());
-  url_request2.Start();
-  ASSERT_TRUE(url_request2.is_pending());
+  scoped_ptr<URLRequest> url_request2(request_context()->CreateRequest(
+      GURL("http://ftp.example.com/second"), DEFAULT_PRIORITY,
+      &request_delegate2, NULL));
+  url_request2->Start();
+  ASSERT_TRUE(url_request2->is_pending());
   socket_data(1)->RunFor(4);
 
-  EXPECT_TRUE(url_request2.status().is_success());
+  EXPECT_TRUE(url_request2->status().is_success());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate2.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate2.data_received());
 }
 
 }  // namespace
 
 }  // namespace net