Remove the Extensions URLRequestContext

content/browser/loader/resource_dispatcher_host_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 <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 15 matching lines @@
 #include "content/public/common/process_type.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/test/test_content_browser_client.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/url_request_test_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/common/appcache/appcache_interfaces.h"
 
 // TODO(eroman): Write unit tests for SafeBrowsing that exercise
 //               SafeBrowsingResourceHandler.
 
 namespace content {
@@ skipping 129 matching lines @@
   net::URLRequestContext* const request_context_;
 };
 
 // This class forwards the incoming messages to the ResourceDispatcherHostTest.
 // This is used to emulate different sub-processes, since this filter will
 // have a different ID than the original. For the test, we want all the incoming
 // messages to go to the same place, which is why this forwards.
 class ForwardingFilter : public ResourceMessageFilter {
  public:
   explicit ForwardingFilter(IPC::Sender* dest,
-                            ResourceContext* resource_context)
+                            ResourceContext* resource_context,
+                            net::URLRequestContextGetter* request_context)
     : ResourceMessageFilter(
         ChildProcessHostImpl::GenerateChildProcessUniqueId(),
         PROCESS_TYPE_RENDERER,
         resource_context, NULL, NULL, NULL,
         new MockURLRequestContextSelector(
-            resource_context->GetRequestContext())),
+            request_context->GetURLRequestContext())),
       dest_(dest) {
     OnChannelConnected(base::GetCurrentProcId());
   }
 
   // ResourceMessageFilter override
   virtual bool Send(IPC::Message* msg) OVERRIDE {
     if (!dest_)
       return false;
     return dest_->Send(msg);
   }
@@ skipping 324 matching lines @@
         file_thread_(BrowserThread::FILE_USER_BLOCKING, &message_loop_),
         cache_thread_(BrowserThread::CACHE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         old_factory_(NULL),
         resource_type_(ResourceType::SUB_RESOURCE),
         send_data_received_acks_(false) {
     browser_context_.reset(new TestBrowserContext());
     BrowserContext::EnsureResourceContextInitialized(browser_context_.get());
     message_loop_.RunUntilIdle();
     filter_ = new ForwardingFilter(
-        this, browser_context_->GetResourceContext());
+        this, browser_context_->GetResourceContext(),
+        browser_context_->GetRequestContext());
   }
 
   virtual ~ResourceDispatcherHostTest() {
     for (std::set<int>::iterator it = child_ids_.begin();
          it != child_ids_.end(); ++it) {
       host_.CancelRequestsForProcess(*it);
     }
   }
 
   // IPC::Sender implementation
@@ skipping 496 matching lines @@
   ASSERT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &error_code));
 
   EXPECT_EQ(net::ERR_ACCESS_DENIED, error_code);
 }
 
 // The host delegate acts as a second one so we can have some requests
 // pending and some canceled.
 class TestFilter : public ForwardingFilter {
  public:
-  explicit TestFilter(ResourceContext* resource_context)
-      : ForwardingFilter(NULL, resource_context),
+  explicit TestFilter(ResourceContext* resource_context,
+                      net::URLRequestContextGetter* url_request_context)
+      : ForwardingFilter(NULL, resource_context, url_request_context),
         has_canceled_(false),
         received_after_canceled_(0) {
   }
 
   // ForwardingFilter override
   virtual bool Send(IPC::Message* msg) OVERRIDE {
     // no messages should be received when the process has been canceled
     if (has_canceled_)
       received_after_canceled_++;
     delete msg;
     return true;
   }
 
   bool has_canceled_;
   int received_after_canceled_;
 
  private:
   virtual ~TestFilter() {}
 };
 
 // Tests CancelRequestsForProcess
 TEST_F(ResourceDispatcherHostTest, TestProcessCancel) {
   scoped_refptr<TestFilter> test_filter = new TestFilter(
-      browser_context_->GetResourceContext());
+      browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
 
   // request 1 goes to the test delegate
   ResourceHostMsg_Request request = CreateResourceRequest(
       "GET", ResourceType::SUB_RESOURCE, net::URLRequestTestJob::test_url_1());
 
   MakeTestRequest(test_filter.get(), 0, 1,
                   net::URLRequestTestJob::test_url_1());
 
   // request 2 goes to us
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
@@ skipping 122 matching lines @@
 
   msgs.clear();
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(0U, msgs.size());
 }
 
 // Tests that blocked requests are canceled if their associated process dies.
 TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies) {
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
-      this, browser_context_->GetResourceContext());
+      this, browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
 
   host_.BlockRequestsForRoute(second_filter->child_id(), 0);
 
   MakeTestRequest(filter_.get(), 0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(second_filter.get(), 0, 2,
                   net::URLRequestTestJob::test_url_2());
   MakeTestRequest(filter_.get(), 0, 3, net::URLRequestTestJob::test_url_3());
   MakeTestRequest(second_filter.get(), 0, 4,
                   net::URLRequestTestJob::test_url_1());
 
@@ skipping 16 matching lines @@
   EXPECT_TRUE(host_.blocked_loaders_map_.empty());
 }
 
 // Tests that blocked requests don't leak when the ResourceDispatcherHost goes
 // away.  Note that we rely on Purify for finding the leaks if any.
 // If this test turns the Purify bot red, check the ResourceDispatcherHost
 // destructor to make sure the blocked requests are deleted.
 TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsDontLeak) {
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
-      this, browser_context_->GetResourceContext());
+      this, browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
 
   host_.BlockRequestsForRoute(filter_->child_id(), 1);
   host_.BlockRequestsForRoute(filter_->child_id(), 2);
   host_.BlockRequestsForRoute(second_filter->child_id(), 1);
 
   MakeTestRequest(filter_.get(), 0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(filter_.get(), 1, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(filter_.get(), 0, 3, net::URLRequestTestJob::test_url_3());
   MakeTestRequest(second_filter.get(), 1, 4,
                   net::URLRequestTestJob::test_url_1());
@@ skipping 46 matching lines @@
   // Tighten the bound on the ResourceDispatcherHost, to speed things up.
   int kMaxCostPerProcess = 440000;
   host_.set_max_outstanding_requests_cost_per_process(kMaxCostPerProcess);
 
   // Determine how many instance of test_url_2() we can request before
   // throttling kicks in.
   size_t kMaxRequests = kMaxCostPerProcess / kMemoryCostOfTest2Req;
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
-      this, browser_context_->GetResourceContext());
+      this, browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
 
   // Saturate the number of outstanding requests for our process.
   for (size_t i = 0; i < kMaxRequests; ++i) {
     MakeTestRequest(filter_.get(), 0, i + 1,
                     net::URLRequestTestJob::test_url_2());
   }
 
   // Issue two more requests for our process -- these should fail immediately.
   MakeTestRequest(filter_.get(), 0, kMaxRequests + 1,
                   net::URLRequestTestJob::test_url_2());
@@ skipping 43 matching lines @@
 // that the global limit is honored.
 TEST_F(ResourceDispatcherHostTest, TooManyOutstandingRequests) {
   // Tighten the bound on the ResourceDispatcherHost, to speed things up.
   const size_t kMaxRequestsPerProcess = 2;
   host_.set_max_num_in_flight_requests_per_process(kMaxRequestsPerProcess);
   const size_t kMaxRequests = 3;
   host_.set_max_num_in_flight_requests(kMaxRequests);
 
   // Needed to emulate additional processes.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
-      this, browser_context_->GetResourceContext());
+      this, browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
   scoped_refptr<ForwardingFilter> third_filter = new ForwardingFilter(
-      this, browser_context_->GetResourceContext());
+      this, browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
 
   // Saturate the number of outstanding requests for our process.
   for (size_t i = 0; i < kMaxRequestsPerProcess; ++i) {
     MakeTestRequest(filter_.get(), 0, i + 1,
                     net::URLRequestTestJob::test_url_2());
   }
 
   // Issue another request for our process -- this should fail immediately.
   MakeTestRequest(filter_.get(), 0, kMaxRequestsPerProcess + 1,
                   net::URLRequestTestJob::test_url_2());
@@ skipping 319 matching lines @@
   TransfersAllNavigationsContentBrowserClient new_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client);
 
   MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
 
   // Restore.
   SetBrowserClientForTesting(old_client);
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
-      this, browser_context_->GetResourceContext());
+      this, browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
 
   ResourceHostMsg_Request request =
@@ skipping 40 matching lines @@
   TransfersAllNavigationsContentBrowserClient new_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client);
 
   MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
 
   // Restore.
   SetBrowserClientForTesting(old_client);
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
-      this, browser_context_->GetResourceContext());
+      this, browser_context_->GetResourceContext(),
+      browser_context_->GetRequestContext());
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   // Delay the start of the next request so that we can setup the response for
   // the next URL.
   SetDelayedStartJobGeneration(true);
 
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blerg\n\n");
@@ skipping 195 matching lines @@
     }
 
     base::MessageLoop::current()->RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content