Create a content::ResourceContext.

content/browser/renderer_host/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2011 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/file_path.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/child_process_security_policy.h"
+#include "content/browser/mock_resource_context.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_handler.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_response.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"
@@ skipping 100 matching lines @@
 
 // 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)
     : ResourceMessageFilter(ChildProcessInfo::GenerateChildProcessUniqueId(),
                             ChildProcessInfo::RENDER_PROCESS,
+                            content::MockResourceContext::GetInstance(),
                             NULL),
       dest_(dest) {
     OnChannelConnected(base::GetCurrentProcId());
   }
 
   // ResourceMessageFilter override
   virtual bool Send(IPC::Message* msg) {
     if (!dest_)
       return false;
     return dest_->Send(msg);
   }
 
  private:
   IPC::Message::Sender* dest_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingFilter);
 };
 
 class ResourceDispatcherHostTest : public testing::Test,
                                    public IPC::Message::Sender {
  public:
   ResourceDispatcherHostTest()
-      : ALLOW_THIS_IN_INITIALIZER_LIST(filter_(new ForwardingFilter(this))),
-        ui_thread_(BrowserThread::UI, &message_loop_),
+      : ui_thread_(BrowserThread::UI, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
+        ALLOW_THIS_IN_INITIALIZER_LIST(filter_(new ForwardingFilter(this))),
         host_(ResourceQueue::DelegateSet()),
         old_factory_(NULL),
         resource_type_(ResourceType::SUB_RESOURCE) {
   }
   // IPC::Message::Sender implementation
   virtual bool Send(IPC::Message* msg) {
     accum_.AddMessage(*msg);
     delete msg;
     return true;
   }
@@ skipping 77 matching lines @@
     if (test_fixture_->response_headers_.empty()) {
       return new net::URLRequestTestJob(request);
     } else {
       return new net::URLRequestTestJob(request,
                                         test_fixture_->response_headers_,
                                         test_fixture_->response_data_,
                                         false);
     }
   }
 
-  scoped_refptr<ForwardingFilter> filter_;
   MessageLoopForIO message_loop_;
   BrowserThread ui_thread_;
   BrowserThread io_thread_;
+  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.
@@ skipping 735 matching lines @@
     const net::URLRequestStatus& status,
     const std::string& info) {
     return true;
   }
 
   void OnRequestClosed() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DummyResourceHandler);
 };