Make URLRequestThrottlerManager a member of URLRequestContext.

chrome/service/cloud_print/cloud_print_url_fetcher_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 "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
@@ skipping 12 matching lines @@
 
 namespace {
 
 const FilePath::CharType kDocRoot[] = FILE_PATH_LITERAL("chrome/test/data");
 
 int g_request_context_getter_instances = 0;
 class TrackingTestURLRequestContextGetter
     : public TestURLRequestContextGetter {
  public:
   explicit TrackingTestURLRequestContextGetter(
-      base::MessageLoopProxy* io_message_loop_proxy)
-          : TestURLRequestContextGetter(io_message_loop_proxy) {
+      base::MessageLoopProxy* io_message_loop_proxy,
+      net::URLRequestThrottlerManager* throttler_manager)
+      : TestURLRequestContextGetter(io_message_loop_proxy),
+        throttler_manager_(throttler_manager),
+        context_(NULL) {
     g_request_context_getter_instances++;
   }
+
+  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
+    if (!context_) {
+      context_ = new TestURLRequestContext(true);
+      context_->set_throttler_manager(throttler_manager_);
+      context_->Init();
+    }
+    return context_.get();
+  }
+
  protected:
   virtual ~TrackingTestURLRequestContextGetter() {
     g_request_context_getter_instances--;
   }
+
+ private:
+  // Not owned here.
+  net::URLRequestThrottlerManager* throttler_manager_;
+  scoped_refptr<TestURLRequestContext> context_;
 };
 
 class TestCloudPrintURLFetcher : public CloudPrintURLFetcher {
  public:
   explicit TestCloudPrintURLFetcher(
-      base::MessageLoopProxy* io_message_loop_proxy)
-          : io_message_loop_proxy_(io_message_loop_proxy) {
+      base::MessageLoopProxy* io_message_loop_proxy,
+      net::URLRequestThrottlerManager* throttler_manager)
+      : io_message_loop_proxy_(io_message_loop_proxy),
+        throttler_manager_(throttler_manager) {
   }
 
   virtual net::URLRequestContextGetter* GetRequestContextGetter() {
     return new TrackingTestURLRequestContextGetter(
-        io_message_loop_proxy_.get());
+        io_message_loop_proxy_.get(), throttler_manager_);
   }
  private:
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+
+  // Not owned here.
+  net::URLRequestThrottlerManager* throttler_manager_;
 };
 
 class CloudPrintURLFetcherTest : public testing::Test,
                                  public CloudPrintURLFetcherDelegate {
  public:
   CloudPrintURLFetcherTest() : max_retries_(0), fetcher_(NULL) { }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url, int max_retries);
 
@@ skipping 12 matching lines @@
   }
 
   virtual std::string GetAuthHeader() {
     return std::string();
   }
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy() {
     return io_message_loop_proxy_;
   }
 
+  net::URLRequestThrottlerManager* throttler_manager() {
+    return &throttler_manager_;
+  }
+
  protected:
   virtual void SetUp() {
     testing::Test::SetUp();
 
     io_message_loop_proxy_ = base::MessageLoopProxy::current();
   }
 
   virtual void TearDown() {
     fetcher_ = NULL;
     // Deleting the fetcher causes a task to be posted to the IO thread to
     // release references to the URLRequestContextGetter. We need to run all
     // pending tasks to execute that (this is the IO thread).
     MessageLoop::current()->RunAllPending();
     EXPECT_EQ(0, g_request_context_getter_instances);
   }
 
   // URLFetcher is designed to run on the main UI thread, but in our tests
   // we assume that the current thread is the IO thread where the URLFetcher
   // dispatches its requests to.  When we wish to simulate being used from
   // a UI thread, we dispatch a worker thread to do so.
   MessageLoopForIO io_loop_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
   int max_retries_;
   Time start_time_;
   scoped_refptr<CloudPrintURLFetcher> fetcher_;
+
+  // We set this as the throttler manager for the
+  // TestURLRequestContext we create.
+  net::URLRequestThrottlerManager throttler_manager_;

[eroman, 2012/04/24 19:05:57]

I wonder if it wouldn't be better to declare this higher up so it outlives the
fetcher_ member.

Actually hmm, fetcher_ is refcounted making it hard to guarantee anything about
the lifetimes... how about making this be owned by TestCloudPrintURLFetcher?
I'll leave this up to the OWNER for this test.

[Jói, 2012/04/27 13:20:26]

Made it a member of the TestCloudPrintURLFetcher.

 };
 
 class CloudPrintURLFetcherBasicTest : public CloudPrintURLFetcherTest {
  public:
   CloudPrintURLFetcherBasicTest()
       : handle_raw_response_(false), handle_raw_data_(false) { }
   // CloudPrintURLFetcher::Delegate
   virtual CloudPrintURLFetcher::ResponseAction HandleRawResponse(
       const content::URLFetcher* source,
       const GURL& url,
@@ skipping 53 matching lines @@
       const std::string& data);
 
   virtual void OnRequestGiveUp();
 
  private:
   int response_count_;
 };
 
 
 void CloudPrintURLFetcherTest::CreateFetcher(const GURL& url, int max_retries) {
-  fetcher_ = new TestCloudPrintURLFetcher(io_message_loop_proxy());
+  fetcher_ = new TestCloudPrintURLFetcher(io_message_loop_proxy(),
+                                          throttler_manager());
   max_retries_ = max_retries;
   start_time_ = Time::Now();
   fetcher_->StartGetRequest(url, this, max_retries_, std::string());
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintURLFetcherTest::HandleRawResponse(
     const content::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
@@ skipping 119 matching lines @@
 TEST_F(CloudPrintURLFetcherOverloadTest, Protect) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP,
                               net::TestServer::kLocalhost,
                               FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("defaultresponse"));
 
   // Registers an entry for test url. It only allows 3 requests to be sent
   // in 200 milliseconds.
-  net::URLRequestThrottlerManager* manager =
-      net::URLRequestThrottlerManager::GetInstance();
   scoped_refptr<net::URLRequestThrottlerEntry> entry(
-      new net::URLRequestThrottlerEntry(manager, "", 200, 3, 1, 2.0, 0.0, 256));
-  manager->OverrideEntryForTests(url, entry);
+      new net::URLRequestThrottlerEntry(
+          throttler_manager(), "", 200, 3, 1, 2.0, 0.0, 256));
+  throttler_manager()->OverrideEntryForTests(url, entry);
 
   CreateFetcher(url, 11);
 
   MessageLoop::current()->Run();
-
-  net::URLRequestThrottlerManager::GetInstance()->EraseEntryForTests(url);
 }
 
 // http://code.google.com/p/chromium/issues/detail?id=60426
 TEST_F(CloudPrintURLFetcherRetryBackoffTest, DISABLED_GiveUp) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP,
                               net::TestServer::kLocalhost,
                               FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("defaultresponse"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 256 milliseconds.
   // Maximum retries allowed is set to 11.
-  net::URLRequestThrottlerManager* manager =
-      net::URLRequestThrottlerManager::GetInstance();
   scoped_refptr<net::URLRequestThrottlerEntry> entry(
-      new net::URLRequestThrottlerEntry(manager, "", 200, 3, 1, 2.0, 0.0, 256));
-  manager->OverrideEntryForTests(url, entry);
+      new net::URLRequestThrottlerEntry(
+          throttler_manager(), "", 200, 3, 1, 2.0, 0.0, 256));
+  throttler_manager()->OverrideEntryForTests(url, entry);
 
   CreateFetcher(url, 11);
 
   MessageLoop::current()->Run();
-
-  net::URLRequestThrottlerManager::GetInstance()->EraseEntryForTests(url);
 }
 
 }  // namespace.