Make URLRequest's constructor private, and make URLRequestContext a friend class.

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"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
+#include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_header_interface.h"
 #include "net/url_request/url_request_throttler_test_support.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
@@ skipping 135 matching lines @@
   GURL url;
   std::string result;
   int line;
 };
 
 }  // namespace
 
 class URLRequestThrottlerEntryTest : public testing::Test {
  protected:
   URLRequestThrottlerEntryTest()
-      : request_(GURL(), DEFAULT_PRIORITY, NULL, &context_) {}
+      : request_(context_.CreateRequest(GURL(), DEFAULT_PRIORITY, NULL, NULL)) {
+  }
 
   virtual void SetUp();
 
   TimeTicks now_;
   MockURLRequestThrottlerManager manager_;  // Dummy object, not used.
   scoped_refptr<MockURLRequestThrottlerEntry> entry_;
 
   TestURLRequestContext context_;
-  TestURLRequest request_;
+  scoped_ptr<URLRequest> request_;
 };
 
 void URLRequestThrottlerEntryTest::SetUp() {
-  request_.SetLoadFlags(0);
+  request_->SetLoadFlags(0);
 
   now_ = TimeTicks::Now();
   entry_ = new MockURLRequestThrottlerEntry(&manager_);
   entry_->ResetToBlank(now_);
 }
 
 std::ostream& operator<<(std::ostream& out, const base::TimeTicks& time) {
   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::HistogramTester histogram_tester;
   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_,
+  request_->SetLoadFlags(LOAD_MAYBE_USER_GESTURE);
+  EXPECT_FALSE(entry_->ShouldRejectRequest(*request_,
                                            context_.network_delegate()));
 
   histogram_tester.ExpectBucketCount(kRequestThrottledHistogramName, 0, 1);
   histogram_tester.ExpectBucketCount(kRequestThrottledHistogramName, 1, 1);
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceNotDuringExponentialBackoff) {
   base::HistogramTester histogram_tester;
   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()));
 
   histogram_tester.ExpectBucketCount(kRequestThrottledHistogramName, 0, 2);
   histogram_tester.ExpectBucketCount(kRequestThrottledHistogramName, 1, 0);
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) {
   MockURLRequestThrottlerHeaderAdapter failure_response(503);
   entry_->UpdateWithResponse(std::string(), &failure_response);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
@@ skipping 100 matching lines @@
   ASSERT_FALSE(MockURLRequestThrottlerEntry::ExplicitUserRequest(0));
   ASSERT_TRUE(MockURLRequestThrottlerEntry::ExplicitUserRequest(
       LOAD_MAYBE_USER_GESTURE));
   ASSERT_FALSE(MockURLRequestThrottlerEntry::ExplicitUserRequest(
       ~LOAD_MAYBE_USER_GESTURE));
 }
 
 class URLRequestThrottlerManagerTest : public testing::Test {
  protected:
   URLRequestThrottlerManagerTest()
-      : request_(GURL(), DEFAULT_PRIORITY, NULL, &context_) {}
+      : request_(context_.CreateRequest(GURL(), DEFAULT_PRIORITY, NULL, NULL)) {
+  }
 
   virtual void SetUp() {
-    request_.SetLoadFlags(0);
+    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) {
@@ skipping 12 matching lines @@
                 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_;
+  scoped_ptr<URLRequest> request_;
 };
 
 TEST_F(URLRequestThrottlerManagerTest, IsUrlStandardised) {
   MockURLRequestThrottlerManager manager;
   GurlAndString test_values[] = {
       GurlAndString(GURL("http://www.example.com"),
                     std::string("http://www.example.com/"),
                     __LINE__),
       GurlAndString(GURL("http://www.Example.com"),
                     std::string("http://www.example.com/"),
@@ skipping 59 matching lines @@
       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_);
+  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<URLRequestThrottlerEntryInterface> other_entry =
       manager.RegisterRequestUrl(GURL("http://www.google.com/bingobob"));
-  ExpectEntryAllowsAllOnErrorIfOptedOut(other_entry.get(), true, request_);
+  ExpectEntryAllowsAllOnErrorIfOptedOut(other_entry.get(), true, *request_);
 
   // Fake a response with the opt-out header incorrectly specified.
   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_);
+      no_opt_out_entry.get(), false, *request_);
 
   // A localhost entry should always be opted out.
   scoped_refptr<URLRequestThrottlerEntryInterface> localhost_entry =
       manager.RegisterRequestUrl(GURL("http://localhost/hello"));
-  ExpectEntryAllowsAllOnErrorIfOptedOut(localhost_entry.get(), true, request_);
+  ExpectEntryAllowsAllOnErrorIfOptedOut(localhost_entry.get(), true, *request_);
 }
 
 TEST_F(URLRequestThrottlerManagerTest, ClearOnNetworkChange) {
   for (int i = 0; i < 3; ++i) {
     MockURLRequestThrottlerManager manager;
     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(
             NetworkChangeNotifier::CONNECTION_UNKNOWN);
         break;
       case 2:
         manager.OnConnectionTypeChanged(NetworkChangeNotifier::CONNECTION_NONE);
         break;
       default:
         FAIL();
     }
 
     scoped_refptr<URLRequestThrottlerEntryInterface> entry_after =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
     EXPECT_FALSE(entry_after->ShouldRejectRequest(
-                     request_, context_.network_delegate()));
+                     *request_, context_.network_delegate()));
   }
 }
 
 }  // namespace net