Allow URLRequests from one context to have different NetworkDelegates.

components/data_reduction_proxy/browser/data_reduction_proxy_protocol_unittest.cc

 // Copyright 2014 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 "components/data_reduction_proxy/browser/data_reduction_proxy_protocol.h"
 
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 179 matching lines @@
   // Starts a request with the given |method| and checks that the response
   // contains |content| and the the header |header|: |value|, if |header| is
   // non-empty. Verifies that the request's URL chain is the right length
   // depending on whether or not a retry was expected (|expected_retry|).
   void ExecuteRequestExpectingContentAndHeader(const std::string& method,
                                                const std::string& content,
                                                const std::string& header,
                                                const std::string& value,
                                                bool expected_retry) {
     TestDelegate d;
-    URLRequest r(GURL("http://www.google.com/"),
-                 net::DEFAULT_PRIORITY,
-                 &d,
-                 context_.get());
-    r.set_method(method);
-    r.SetLoadFlags(net::LOAD_NORMAL);
+    scoped_ptr<URLRequest> r(context_->CreateRequest(
+        GURL("http://www.google.com/"),
+        net::DEFAULT_PRIORITY,
+        &d,
+        NULL));
+    r->set_method(method);
+    r->SetLoadFlags(net::LOAD_NORMAL);
 
-    r.Start();
+    r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
+    EXPECT_EQ(net::URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(net::OK, r->status().error());
     if (expected_retry)
-      EXPECT_EQ(2U, r.url_chain().size());
+      EXPECT_EQ(2U, r->url_chain().size());
     else
-      EXPECT_EQ(1U, r.url_chain().size());
+      EXPECT_EQ(1U, r->url_chain().size());
 
     if (!header.empty()) {
       // We also have a server header here that isn't set by the proxy.
-      EXPECT_TRUE(r.response_headers()->HasHeaderValue(header, value));
+      EXPECT_TRUE(r->response_headers()->HasHeaderValue(header, value));
     }
 
     EXPECT_EQ(content, d.data_received());
   }
 
   // Returns the key to the |ProxyRetryInfoMap|.
   std::string GetProxyKey(std::string proxy) {
     GURL gurl(proxy);
     std::string host_port = HostPortPair::FromURL(GURL(proxy)).ToString();
     if (gurl.SchemeIs("https"))
@@ skipping 10 matching lines @@
                       const std::string& bad_proxy,
                       const std::string& bad_proxy2) {
     const ProxyRetryInfoMap& retry_info = proxy_service_->proxy_retry_info();
     ASSERT_EQ(expected_num_bad_proxies, retry_info.size());
 
     base::TimeDelta expected_min_duration;
     base::TimeDelta expected_max_duration;
     if (duration_seconds == 0) {
       expected_min_duration = base::TimeDelta::FromMinutes(1);
       expected_max_duration = base::TimeDelta::FromMinutes(5);
-    }
-    else {
+    } else {
       expected_min_duration = base::TimeDelta::FromSeconds(duration_seconds);
       expected_max_duration = base::TimeDelta::FromSeconds(duration_seconds);
     }
 
     if (expected_num_bad_proxies >= 1u) {
       ProxyRetryInfoMap::const_iterator i =
           retry_info.find(GetProxyKey(bad_proxy));
       ASSERT_TRUE(i != retry_info.end());
       EXPECT_TRUE(expected_min_duration <= (*i).second.current_delay);
       EXPECT_TRUE((*i).second.current_delay <= expected_max_duration);
@@ skipping 484 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "User-Agent:\r\n"
               "Accept-Encoding: gzip,deflate\r\n\r\n"),
   };
   StaticSocketDataProvider data1(data_reads, arraysize(data_reads),
                                  data_writes, arraysize(data_writes));
   mock_socket_factory_.AddSocketDataProvider(&data1);
 
   TestDelegate d;
-  URLRequest r(GURL("http://www.google.com/"),
-               net::DEFAULT_PRIORITY,
-               &d,
-               context_.get());
-   r.set_method("GET");
-   r.SetLoadFlags(net::LOAD_NORMAL);
+  scoped_ptr<URLRequest> r(context_->CreateRequest(
+      GURL("http://www.google.com/"),
+      net::DEFAULT_PRIORITY,
+      &d,
+      NULL));
+  r->set_method("GET");
+  r->SetLoadFlags(net::LOAD_NORMAL);
 
-   r.Start();
-   base::RunLoop().Run();
+  r->Start();
+  base::RunLoop().Run();
 
-   EXPECT_EQ(net::URLRequestStatus::SUCCESS, r.status().status());
-   EXPECT_EQ(net::OK, r.status().error());
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, r->status().status());
+  EXPECT_EQ(net::OK, r->status().error());
 
   EXPECT_EQ("Bypass message", d.data_received());
 
   // We should have no entries in our bad proxy list.
   TestBadProxies(0, -1, "", "");
 }
 
 class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
  public:
   virtual ~BadEntropyProvider() {}
@@ skipping 134 matching lines @@
                         &other_proxy_info);
   EXPECT_FALSE(other_proxy_info.is_direct());
 
   OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
                         empty_proxy_retry_info, &test_params,
                         &data_reduction_proxy_info);
   EXPECT_TRUE(data_reduction_proxy_info.is_direct());
 }
 
 }  // namespace data_reduction_proxy