Remove getters for HTML5 related objects from the ResourceContext interface. Half of them weren't u…

content/browser/renderer_host/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 "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/mock_resource_context.h"
 #include "content/browser/renderer_host/dummy_resource_handler.h"
 #include "content/browser/renderer_host/layered_resource_handler.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/common/resource_response.h"
+#include "content/test/test_browser_context.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_test_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache_interfaces.h"
 
-namespace content {
-class DownloadManager;
-}  // namespace content
-
+using content::BrowserContext;
 using content::BrowserThread;
 using content::BrowserThreadImpl;
 using content::ChildProcessHostImpl;
-using content::DownloadManager;
 using content::GlobalRequestID;
 
 // TODO(eroman): Write unit tests for SafeBrowsing that exercise
 //               SafeBrowsingResourceHandler.
 
 namespace {
 
 // Returns the resource response header structure for this request.
 void GetResponseHead(const std::vector<IPC::Message>& messages,
                      content::ResourceResponseHead* response_head) {
@@ skipping 106 matching lines @@
  private:
   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::Message::Sender* dest)
+  explicit ForwardingFilter(IPC::Message::Sender* dest,
+                            content::ResourceContext* resource_context)
     : ResourceMessageFilter(
         ChildProcessHostImpl::GenerateChildProcessUniqueId(),
         content::PROCESS_TYPE_RENDERER,
-        content::MockResourceContext::GetInstance(),
+        resource_context,
         new MockURLRequestContextSelector(
             content::MockResourceContext::GetInstance()->GetRequestContext())),
       dest_(dest) {
     OnChannelConnected(base::GetCurrentProcId());
   }
 
   // ResourceMessageFilter override
   virtual bool Send(IPC::Message* msg) {
     if (!dest_)
       return false;
@@ skipping 140 matching lines @@
  private:
   bool defer_start_;
   scoped_ptr<base::SupportsUserData::Data> user_data_;
 };
 
 class ResourceDispatcherHostTest : public testing::Test,
                                    public IPC::Message::Sender {
  public:
   ResourceDispatcherHostTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
+        file_thread_(BrowserThread::FILE_USER_BLOCKING, &message_loop_),
+        cache_thread_(BrowserThread::CACHE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
-        ALLOW_THIS_IN_INITIALIZER_LIST(filter_(new ForwardingFilter(this))),
         old_factory_(NULL),
         resource_type_(ResourceType::SUB_RESOURCE) {
+    BrowserContext::EnsureResourceContextInitialized(&browser_context_);
+    filter_ = new ForwardingFilter(this, browser_context_.GetResourceContext());
   }
   // IPC::Message::Sender implementation
   virtual bool Send(IPC::Message* msg) {
     accum_.AddMessage(*msg);
     delete msg;
     return true;
   }
 
  protected:
   // testing::Test
@@ skipping 99 matching lines @@
       }
     }
   }
 
   void SetDelayedStartJobGeneration(bool delay_job_start) {
     delay_start_ = delay_job_start;
   }
 
   MessageLoopForIO message_loop_;
   BrowserThreadImpl ui_thread_;
+  BrowserThreadImpl file_thread_;
+  BrowserThreadImpl cache_thread_;
   BrowserThreadImpl io_thread_;
+  TestBrowserContext browser_context_;
   scoped_refptr<ForwardingFilter> filter_;
   ResourceDispatcherHost host_;
   ResourceIPCAccumulator accum_;
   std::string response_headers_;
   std::string response_data_;
   std::string scheme_;
   net::URLRequest::ProtocolFactory* old_factory_;
   ResourceType::Type resource_type_;
   static ResourceDispatcherHostTest* test_fixture_;
   static bool delay_start_;
@@ skipping 220 matching lines @@
   ASSERT_TRUE(IPC::ReadParam(&msgs[0][1], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&msgs[0][1], &iter, &status));
 
   EXPECT_EQ(net::URLRequestStatus::CANCELED, status.status());
 }
 
 // The host delegate acts as a second one so we can have some requests
 // pending and some canceled.
 class TestFilter : public ForwardingFilter {
  public:
-  TestFilter()
-      : ForwardingFilter(NULL),
+  explicit TestFilter(content::ResourceContext* resource_context)
+      : ForwardingFilter(NULL, resource_context),
         has_canceled_(false),
         received_after_canceled_(0) {
   }
 
   // ForwardingFilter override
   virtual bool Send(IPC::Message* msg) {
     // 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_;
 };
 
 // Tests CancelRequestsForProcess
 TEST_F(ResourceDispatcherHostTest, TestProcessCancel) {
-  scoped_refptr<TestFilter> test_filter = new TestFilter();
+  scoped_refptr<TestFilter> test_filter = new TestFilter(
+      browser_context_.GetResourceContext());
 
   // request 1 goes to the test delegate
   ResourceHostMsg_Request request = CreateResourceRequest(
       "GET", ResourceType::SUB_RESOURCE, net::URLRequestTestJob::test_url_1());
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   MakeTestRequest(test_filter.get(), 0, 1,
                   net::URLRequestTestJob::test_url_1());
 
@@ skipping 132 matching lines @@
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
   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);
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
+      this, browser_context_.GetResourceContext());
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
   EXPECT_EQ(0,
             host_.GetOutstandingRequestsMemoryCost(second_filter->child_id()));
 
   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());
@@ skipping 23 matching lines @@
 
   EXPECT_TRUE(host_.blocked_requests_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);
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
+      this, browser_context_.GetResourceContext());
 
   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 70 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);
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
+      this, browser_context_.GetResourceContext());
 
   // 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 356 matching lines @@
   net::URLRequestStatus status;
 
   void* iter = NULL;
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &status));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(net::URLRequestStatus::FAILED, status.status());
   EXPECT_EQ(net::ERR_UNKNOWN_URL_SCHEME, status.error());
 }