Allow URLRequests from one context to have different NetworkDelegates.

net/url_request/url_request_throttler_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_throttler_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
@@ skipping 15 matching lines @@
 
 namespace net {
 
 namespace {
 
 const char kRequestThrottledHistogramName[] = "Throttling.RequestThrottled";
 
 class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
  public:
   explicit MockURLRequestThrottlerEntry(
-      net::URLRequestThrottlerManager* manager)
-      : net::URLRequestThrottlerEntry(manager, std::string()),
+      URLRequestThrottlerManager* manager)
+      : URLRequestThrottlerEntry(manager, std::string()),
         mock_backoff_entry_(&backoff_policy_) {
     InitPolicy();
   }
   MockURLRequestThrottlerEntry(
-      net::URLRequestThrottlerManager* manager,
+      URLRequestThrottlerManager* manager,
       const TimeTicks& exponential_backoff_release_time,
       const TimeTicks& sliding_window_release_time,
       const TimeTicks& fake_now)
-      : net::URLRequestThrottlerEntry(manager, std::string()),
+      : URLRequestThrottlerEntry(manager, std::string()),
         fake_time_now_(fake_now),
         mock_backoff_entry_(&backoff_policy_) {
     InitPolicy();
 
     mock_backoff_entry_.set_fake_now(fake_now);
     set_exponential_backoff_release_time(exponential_backoff_release_time);
     set_sliding_window_release_time(sliding_window_release_time);
   }
 
   void InitPolicy() {
@@ skipping 137 matching lines @@
   return out << time.ToInternalValue();
 }
 
 TEST_F(URLRequestThrottlerEntryTest, CanThrottleRequest) {
   TestNetworkDelegate d;
   context_.set_network_delegate(&d);
   entry_->set_exponential_backoff_release_time(
       entry_->fake_time_now_ + TimeDelta::FromMilliseconds(1));
 
   d.set_can_throttle_requests(false);
-  EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(request_,
+                                           context_.network_delegate()));
   d.set_can_throttle_requests(true);
-  EXPECT_TRUE(entry_->ShouldRejectRequest(request_));
+  EXPECT_TRUE(entry_->ShouldRejectRequest(request_,
+                                          context_.network_delegate()));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceDuringExponentialBackoff) {
   base::StatisticsDeltaReader statistics_delta_reader;
   entry_->set_exponential_backoff_release_time(
       entry_->fake_time_now_ + TimeDelta::FromMilliseconds(1));
-  EXPECT_TRUE(entry_->ShouldRejectRequest(request_));
+  EXPECT_TRUE(entry_->ShouldRejectRequest(request_,
+                                          context_.network_delegate()));
 
   // Also end-to-end test the load flags exceptions.
   request_.SetLoadFlags(LOAD_MAYBE_USER_GESTURE);
-  EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(request_,
+                                           context_.network_delegate()));
 
   scoped_ptr<base::HistogramSamples> samples(
       statistics_delta_reader.GetHistogramSamplesSinceCreation(
           kRequestThrottledHistogramName));
   ASSERT_EQ(1, samples->GetCount(0));
   ASSERT_EQ(1, samples->GetCount(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceNotDuringExponentialBackoff) {
   base::StatisticsDeltaReader statistics_delta_reader;
   entry_->set_exponential_backoff_release_time(entry_->fake_time_now_);
-  EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(request_,
+                                           context_.network_delegate()));
   entry_->set_exponential_backoff_release_time(
       entry_->fake_time_now_ - TimeDelta::FromMilliseconds(1));
-  EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(request_,
+                                           context_.network_delegate()));
 
   scoped_ptr<base::HistogramSamples> samples(
       statistics_delta_reader.GetHistogramSamplesSinceCreation(
           kRequestThrottledHistogramName));
   ASSERT_EQ(2, samples->GetCount(0));
   ASSERT_EQ(0, samples->GetCount(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) {
   MockURLRequestThrottlerHeaderAdapter failure_response(503);
@@ skipping 108 matching lines @@
 
 class URLRequestThrottlerManagerTest : public testing::Test {
  protected:
   URLRequestThrottlerManagerTest()
       : request_(GURL(), DEFAULT_PRIORITY, NULL, &context_) {}
 
   virtual void SetUp() {
     request_.SetLoadFlags(0);
   }
 
+  void ExpectEntryAllowsAllOnErrorIfOptedOut(
+      URLRequestThrottlerEntryInterface* entry,
+      bool opted_out,
+      const URLRequest& request) {
+    EXPECT_FALSE(entry->ShouldRejectRequest(request,
+                                            context_.network_delegate()));
+    MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
+    for (int i = 0; i < 10; ++i) {
+      // Host doesn't really matter in this scenario so we skip it.
+      entry->UpdateWithResponse(std::string(), &failure_adapter);
+    }
+    EXPECT_NE(opted_out, entry->ShouldRejectRequest(
+                  request, context_.network_delegate()));
+
+    if (opted_out) {
+      // We're not mocking out GetTimeNow() in this scenario
+      // so add a 100 ms buffer to avoid flakiness (that should always
+      // give enough time to get from the TimeTicks::Now() call here
+      // to the TimeTicks::Now() call in the entry class).
+      EXPECT_GT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
+                entry->GetExponentialBackoffReleaseTime());
+    } else {
+      // As above, add 100 ms.
+      EXPECT_LT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
+                entry->GetExponentialBackoffReleaseTime());
+    }
+  }
+
   // context_ must be declared before request_.
   TestURLRequestContext context_;
   TestURLRequest request_;
 };
 
 TEST_F(URLRequestThrottlerManagerTest, IsUrlStandardised) {
   MockURLRequestThrottlerManager manager;
   GurlAndString test_values[] = {
       GurlAndString(GURL("http://www.example.com"),
                     std::string("http://www.example.com/"),
@@ skipping 49 matching lines @@
 
   manager.RegisterRequestUrl(GURL("http://www.example.com/"));
   manager.RegisterRequestUrl(GURL("http://www.google.com/"));
   manager.RegisterRequestUrl(GURL("http://www.google.com/index/0"));
   manager.RegisterRequestUrl(GURL("http://www.google.com/index/0?code=1"));
   manager.RegisterRequestUrl(GURL("http://www.google.com/index/0#lolsaure"));
 
   EXPECT_EQ(3, manager.GetNumberOfEntries());
 }
 
-void ExpectEntryAllowsAllOnErrorIfOptedOut(
-    net::URLRequestThrottlerEntryInterface* entry,
-    bool opted_out,
-    const URLRequest& request) {
-  EXPECT_FALSE(entry->ShouldRejectRequest(request));
-  MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
-  for (int i = 0; i < 10; ++i) {
-    // Host doesn't really matter in this scenario so we skip it.
-    entry->UpdateWithResponse(std::string(), &failure_adapter);
-  }
-  EXPECT_NE(opted_out, entry->ShouldRejectRequest(request));
-
-  if (opted_out) {
-    // We're not mocking out GetTimeNow() in this scenario
-    // so add a 100 ms buffer to avoid flakiness (that should always
-    // give enough time to get from the TimeTicks::Now() call here
-    // to the TimeTicks::Now() call in the entry class).
-    EXPECT_GT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
-              entry->GetExponentialBackoffReleaseTime());
-  } else {
-    // As above, add 100 ms.
-    EXPECT_LT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
-              entry->GetExponentialBackoffReleaseTime());
-  }
-}
-
 TEST_F(URLRequestThrottlerManagerTest, OptOutHeader) {
   MockURLRequestThrottlerManager manager;
-  scoped_refptr<net::URLRequestThrottlerEntryInterface> entry =
+  scoped_refptr<URLRequestThrottlerEntryInterface> entry =
       manager.RegisterRequestUrl(GURL("http://www.google.com/yodude"));
 
   // Fake a response with the opt-out header.
   MockURLRequestThrottlerHeaderAdapter response_adapter(
       std::string(),
       MockURLRequestThrottlerEntry::kExponentialThrottlingDisableValue,
       200);
   entry->UpdateWithResponse("www.google.com", &response_adapter);
 
   // Ensure that the same entry on error always allows everything.
   ExpectEntryAllowsAllOnErrorIfOptedOut(entry.get(), true, request_);
 
   // Ensure that a freshly created entry (for a different URL on an
   // already opted-out host) also gets "always allow" behavior.
-  scoped_refptr<net::URLRequestThrottlerEntryInterface> other_entry =
+  scoped_refptr<URLRequestThrottlerEntryInterface> other_entry =
       manager.RegisterRequestUrl(GURL("http://www.google.com/bingobob"));
   ExpectEntryAllowsAllOnErrorIfOptedOut(other_entry.get(), true, request_);
 
   // Fake a response with the opt-out header incorrectly specified.
-  scoped_refptr<net::URLRequestThrottlerEntryInterface> no_opt_out_entry =
+  scoped_refptr<URLRequestThrottlerEntryInterface> no_opt_out_entry =
       manager.RegisterRequestUrl(GURL("http://www.nike.com/justdoit"));
   MockURLRequestThrottlerHeaderAdapter wrong_adapter(
       std::string(), "yesplease", 200);
   no_opt_out_entry->UpdateWithResponse("www.nike.com", &wrong_adapter);
   ExpectEntryAllowsAllOnErrorIfOptedOut(
       no_opt_out_entry.get(), false, request_);
 
   // A localhost entry should always be opted out.
-  scoped_refptr<net::URLRequestThrottlerEntryInterface> localhost_entry =
+  scoped_refptr<URLRequestThrottlerEntryInterface> localhost_entry =
       manager.RegisterRequestUrl(GURL("http://localhost/hello"));
   ExpectEntryAllowsAllOnErrorIfOptedOut(localhost_entry.get(), true, request_);
 }
 
 TEST_F(URLRequestThrottlerManagerTest, ClearOnNetworkChange) {
   for (int i = 0; i < 3; ++i) {
     MockURLRequestThrottlerManager manager;
-    scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_before =
+    scoped_refptr<URLRequestThrottlerEntryInterface> entry_before =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
     MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
     for (int j = 0; j < 10; ++j) {
       // Host doesn't really matter in this scenario so we skip it.
       entry_before->UpdateWithResponse(std::string(), &failure_adapter);
     }
-    EXPECT_TRUE(entry_before->ShouldRejectRequest(request_));
+    EXPECT_TRUE(entry_before->ShouldRejectRequest(request_,
+                                                  context_.network_delegate()));
 
     switch (i) {
       case 0:
         manager.OnIPAddressChanged();
         break;
       case 1:
         manager.OnConnectionTypeChanged(
-            net::NetworkChangeNotifier::CONNECTION_UNKNOWN);
+            NetworkChangeNotifier::CONNECTION_UNKNOWN);
         break;
       case 2:
-        manager.OnConnectionTypeChanged(
-            net::NetworkChangeNotifier::CONNECTION_NONE);
+        manager.OnConnectionTypeChanged(NetworkChangeNotifier::CONNECTION_NONE);
         break;
       default:
         FAIL();
     }
 
-    scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_after =
+    scoped_refptr<URLRequestThrottlerEntryInterface> entry_after =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
-    EXPECT_FALSE(entry_after->ShouldRejectRequest(request_));
+    EXPECT_FALSE(entry_after->ShouldRejectRequest(
+                     request_, context_.network_delegate()));
   }
 }
 
 }  // namespace net