Introduce ResourceRequesterInfo to abstract the requester of resource request

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 <stddef.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 84 matching lines @@
 
   // The first messages should be received response.
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
   base::PickleIterator iter(messages[0]);
   int request_id;
   ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, response_head));
 }
 
-void GenerateIPCMessage(scoped_refptr<ResourceMessageFilter> filter,
-                        std::unique_ptr<IPC::Message> message) {
-  ResourceDispatcherHostImpl::Get()->OnMessageReceived(
-      *message, filter.get());
+void GenerateIPCMessage(
+    scoped_refptr<const ResourceRequesterInfo> requester_info,
+    std::unique_ptr<IPC::Message> message) {
+  ResourceDispatcherHostImpl::Get()->OnMessageReceived(*message,
+                                                       requester_info.get());
 }
 
 // On Windows, ResourceMsg_SetDataBuffer supplies a HANDLE which is not
 // automatically released.
 //
 // See ResourceDispatcher::ReleaseResourcesInDataMessage.
 //
 // TODO(davidben): It would be nice if the behavior for base::SharedMemoryHandle
 // were more like it is in POSIX where the received fds are tracked in a
 // ref-counted core that closes them if not extracted.
@@ skipping 127 matching lines @@
   return nullptr;
 }
 
 // This is used to create a filter matching a specified child id.
 class TestFilterSpecifyingChild : public ResourceMessageFilter {
  public:
   explicit TestFilterSpecifyingChild(ResourceContext* resource_context,
                                      int process_id)
       : ResourceMessageFilter(
             process_id,
-            PROCESS_TYPE_RENDERER,
             NULL,
             NULL,
             NULL,
             NULL,
             base::Bind(&TestFilterSpecifyingChild::GetContexts,
                        base::Unretained(this))),
         resource_context_(resource_context),
         canceled_(false),
         received_after_canceled_(0) {
+    InitializeOnIOThread();
     set_peer_process_for_testing(base::Process::Current());
   }
 
   void set_canceled(bool canceled) { canceled_ = canceled; }
   int received_after_canceled() const { return received_after_canceled_; }
 
   // ResourceMessageFilter override
   bool Send(IPC::Message* msg) override {
     // No messages should be received when the process has been canceled.
     if (canceled_)
@@ skipping 720 matching lines @@
   void MakeTestRequestWithPriorityAndRenderFrame(int render_view_id,
                                                  int render_frame_id,
                                                  int request_id,
                                                  net::RequestPriority priority);
 
   void MakeWebContentsAssociatedDownloadRequest(int request_id,
                                                 const GURL& url);
 
   void CancelRequest(int request_id);
   void RendererCancelRequest(int request_id) {
-    ResourceMessageFilter* old_filter = SetFilter(filter_.get());
-    host_.OnCancelRequest(request_id);
-    SetFilter(old_filter);
+    filter_->OnMessageReceived(ResourceHostMsg_CancelRequest(request_id));
   }
 
   void CompleteStartRequest(int request_id);
   void CompleteStartRequest(ResourceMessageFilter* filter, int request_id);
 
   net::TestNetworkDelegate* network_delegate() { return &network_delegate_; }
 
   void EnsureSchemeIsAllowed(const std::string& scheme) {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
@@ skipping 30 matching lines @@
   void GenerateDataReceivedACK(const IPC::Message& msg) {
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msg.type());
 
     int request_id = -1;
     bool result = base::PickleIterator(msg).ReadInt(&request_id);
     DCHECK(result);
     std::unique_ptr<IPC::Message> ack(
         new ResourceHostMsg_DataReceived_ACK(request_id));
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&GenerateIPCMessage, filter_, base::Passed(&ack)));
-  }
-
-  // Setting filters for testing renderer messages.
-  // Returns the previous filter.
-  ResourceMessageFilter* SetFilter(ResourceMessageFilter* new_filter) {
-    ResourceMessageFilter* old_filter = host_.filter_;
-    host_.filter_ = new_filter;
-    return old_filter;
+        FROM_HERE, base::Bind(&GenerateIPCMessage, filter_->requester_info(),
+                              base::Passed(&ack)));
   }
 
   void WaitForRequestComplete() {
     DCHECK(!wait_for_request_complete_loop_);
     wait_for_request_complete_loop_.reset(new base::RunLoop);
     wait_for_request_complete_loop_->Run();
     wait_for_request_complete_loop_.reset();
   }
 
   void DeleteRenderFrame(const GlobalFrameRoutingId& global_routing_id) {
@@ skipping 42 matching lines @@
 
     // We should have gotten one RequestComplete message.
     ASSERT_EQ(1U, msgs.size());
     ASSERT_EQ(1U, msgs[0].size());
     EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
     // The RequestComplete message should have had the expected error code.
     CheckRequestCompleteErrorCode(msgs[0][0], expected_error_code);
   }
 
+  void OnMessageReceived(const IPC::Message& message,
+                         ResourceMessageFilter* filter) {
+    host_.OnMessageReceived(message, filter->requester_info());
+  }
+
+  const ResourceRequesterInfo* GetResourceRequesterInfo(
+      ResourceMessageFilter* filter) {
+    return filter->requester_info();
+  }
+
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<TestBrowserContext> browser_context_;
   std::unique_ptr<TestURLRequestJobFactory> job_factory_;
   std::unique_ptr<WebContents> web_contents_;
   std::unique_ptr<TestWebContentsObserver> web_contents_observer_;
   scoped_refptr<ForwardingFilter> filter_;
   scoped_refptr<TestFilterSpecifyingChild> web_contents_filter_;
   net::TestNetworkDelegate network_delegate_;
   LoaderDelegateImpl loader_delegate_;
   ResourceDispatcherHostImpl host_;
@@ skipping 19 matching lines @@
 
 void ResourceDispatcherHostTest::MakeTestRequestWithRenderFrame(
     int render_view_id,
     int render_frame_id,
     int request_id,
     const GURL& url,
     ResourceType type) {
   ResourceRequest request = CreateResourceRequest("GET", type, url);
   request.render_frame_id = render_frame_id;
   ResourceHostMsg_RequestResource msg(render_view_id, request_id, request);
-  host_.OnMessageReceived(msg, filter_.get());
+  OnMessageReceived(msg, filter_.get());
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::MakeTestRequestWithResourceType(
     ResourceMessageFilter* filter,
     int render_view_id,
     int request_id,
     const GURL& url,
     ResourceType type) {
   ResourceRequest request = CreateResourceRequest("GET", type, url);
   ResourceHostMsg_RequestResource msg(render_view_id, request_id, request);
-  host_.OnMessageReceived(msg, filter);
+  OnMessageReceived(msg, filter);
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::MakeWebContentsAssociatedTestRequest(
     int request_id,
     const GURL& url) {
   MakeWebContentsAssociatedTestRequestWithResourceType(
       request_id, url, RESOURCE_TYPE_SUB_RESOURCE);
 }
 
 void ResourceDispatcherHostTest::
     MakeWebContentsAssociatedTestRequestWithResourceType(int request_id,
                                                          const GURL& url,
                                                          ResourceType type) {
   ResourceRequest request = CreateResourceRequest("GET", type, url);
   request.origin_pid = web_contents_->GetRenderProcessHost()->GetID();
   request.render_frame_id = web_contents_->GetMainFrame()->GetRoutingID();
   ResourceHostMsg_RequestResource msg(web_contents_->GetRoutingID(), request_id,
                                       request);
-  host_.OnMessageReceived(msg, web_contents_filter_.get());
+  OnMessageReceived(msg, web_contents_filter_.get());
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::MakeTestRequestWithPriority(
     int render_view_id,
     int request_id,
     net::RequestPriority priority) {
   MakeTestRequestWithPriorityAndRenderFrame(render_view_id, -1, request_id,
                                             priority);
 }
 
 void ResourceDispatcherHostTest::MakeTestRequestWithPriorityAndRenderFrame(
     int render_view_id,
     int render_frame_id,
     int request_id,
     net::RequestPriority priority) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_SUB_RESOURCE, GURL("http://example.com/priority"));
   request.render_frame_id = render_frame_id;
   request.priority = priority;
   ResourceHostMsg_RequestResource msg(render_view_id, request_id, request);
-  host_.OnMessageReceived(msg, filter_.get());
+  OnMessageReceived(msg, filter_.get());
 }
 
 void ResourceDispatcherHostTest::MakeWebContentsAssociatedDownloadRequest(
     int request_id,
     const GURL& url) {
   net::URLRequestContext* request_context =
       browser_context_->GetResourceContext()->GetRequestContext();
   std::unique_ptr<net::URLRequest> request(
       request_context->CreateRequest(url, net::DEFAULT_PRIORITY, NULL));
   DownloadManagerImpl::BeginDownloadRequest(
@@ skipping 165 matching lines @@
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
   MakeTestRequestWithResourceType(filter_.get(), 0, 4,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   MakeTestRequest(0, 5, net::URLRequestTestJob::test_url_redirect_to_url_2());
 
   // Finish the redirection
   ResourceHostMsg_FollowRedirect redirect_msg(5);
-  host_.OnMessageReceived(redirect_msg, filter_.get());
+  OnMessageReceived(redirect_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // sorts out all the messages we saw by request
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // there are five requests, so we should have gotten them classified as such
@@ skipping 63 matching lines @@
 
 TEST_P(ResourceDispatcherHostTest, DownloadToNetworkCache) {
   // Normal request.
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_2());
 
   // Cache-only request.
   ResourceRequest request_to_cache = CreateResourceRequest(
       "GET", RESOURCE_TYPE_IMAGE, net::URLRequestTestJob::test_url_3());
   request_to_cache.download_to_network_cache_only = true;
   ResourceHostMsg_RequestResource msg_to_cache(0, 2, request_to_cache);
-  host_.OnMessageReceived(msg_to_cache, filter_.get());
+  OnMessageReceived(msg_to_cache, filter_.get());
 
   KickOffRequest();
 
   // The handler for the cache-only request should have been detached now.
   GlobalRequestID global_request_id(filter_->child_id(), 2);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler()->is_detached());
 
   // Flush all the pending requests.
@@ skipping 66 matching lines @@
 }
 
 TEST_P(ResourceDispatcherHostTest, SyncLoadSuccess) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Successful sync load.
   std::tuple<SyncLoadResult> result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &std::get<0>(result));
-  host_.OnMessageReceived(sync_load_msg, filter_.get());
+  OnMessageReceived(sync_load_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
 
   ASSERT_TRUE(ResourceHostMsg_SyncLoad::ReadReplyParam(reply, &result));
   EXPECT_EQ(net::OK, std::get<0>(result).error_code);
 }
 
 TEST_P(ResourceDispatcherHostTest, SyncLoadError) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Failued sync load.
   std::tuple<SyncLoadResult> result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &std::get<0>(result));
-  host_.OnMessageReceived(sync_load_msg, filter_.get());
+  OnMessageReceived(sync_load_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
 
   ASSERT_TRUE(ResourceHostMsg_SyncLoad::ReadReplyParam(reply, &result));
   EXPECT_EQ(net::ERR_INVALID_URL, std::get<0>(result).error_code);
 }
 
 TEST_P(ResourceDispatcherHostTest, SyncLoadCancel) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Cancelled sync load.
   SyncLoadResult result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &result);
 
-  host_.OnMessageReceived(sync_load_msg, filter_.get());
+  OnMessageReceived(sync_load_msg, filter_.get());
   host_.CancelRequestsForProcess(filter_->child_id());
   base::RunLoop().RunUntilIdle();
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
   ASSERT_TRUE(reply->is_reply_error());
 }
 
 // If the filter has disappeared then detachable resources should continue to
 // load.
 TEST_P(ResourceDispatcherHostTest, DeletedFilterDetached) {
   // test_url_1's data is available synchronously, so use 2 and 3.
   ResourceRequest request_prefetch = CreateResourceRequest(
       "GET", RESOURCE_TYPE_PREFETCH, net::URLRequestTestJob::test_url_2());
   ResourceRequest request_ping = CreateResourceRequest(
       "GET", RESOURCE_TYPE_PING, net::URLRequestTestJob::test_url_3());
 
   ResourceHostMsg_RequestResource msg_prefetch(0, 1, request_prefetch);
-  host_.OnMessageReceived(msg_prefetch, filter_.get());
+  OnMessageReceived(msg_prefetch, filter_.get());
   ResourceHostMsg_RequestResource msg_ping(0, 2, request_ping);
-  host_.OnMessageReceived(msg_ping, filter_.get());
+  OnMessageReceived(msg_ping, filter_.get());
 
   // Remove the filter before processing the requests by simulating channel
   // closure.
   ResourceRequestInfoImpl* info_prefetch = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(GlobalRequestID(filter_->child_id(), 1)));
   ResourceRequestInfoImpl* info_ping = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(GlobalRequestID(filter_->child_id(), 2)));
-  DCHECK_EQ(filter_.get(), info_prefetch->filter());
-  DCHECK_EQ(filter_.get(), info_ping->filter());
+  DCHECK_EQ(filter_.get(), info_prefetch->requester_info().filter());
+  DCHECK_EQ(filter_.get(), info_ping->requester_info().filter());
   filter_->OnChannelClosing();
-  info_prefetch->filter_.reset();
-  info_ping->filter_.reset();
 
   // From the renderer's perspective, the requests were cancelled.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(2U, msgs.size());
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED);
   CheckRequestCompleteErrorCode(msgs[1][0], net::ERR_ABORTED);
 
   // But it continues detached.
   EXPECT_EQ(2, host_.pending_requests());
@@ skipping 15 matching lines @@
 }
 
 // If the filter has disappeared (original process dies) then detachable
 // resources should continue to load, even when redirected.
 TEST_P(ResourceDispatcherHostTest, DeletedFilterDetachedRedirect) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_PREFETCH,
       net::URLRequestTestJob::test_url_redirect_to_url_2());
 
   ResourceHostMsg_RequestResource msg(0, 1, request);
-  host_.OnMessageReceived(msg, filter_.get());
+  OnMessageReceived(msg, filter_.get());
 
   // Remove the filter before processing the request by simulating channel
   // closure.
   GlobalRequestID global_request_id(filter_->child_id(), 1);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
-  info->filter_->OnChannelClosing();
-  info->filter_.reset();
+  info->requester_info().filter()->OnChannelClosing();
 
   // From the renderer's perspective, the request was cancelled.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED);
 
   // But it continues detached.
   EXPECT_EQ(1, host_.pending_requests());
   EXPECT_TRUE(info->detachable_handler()->is_detached());
@@ skipping 892 matching lines @@
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_MAIN_FRAME);
   // Return some data so that the request is identified as a download
   // and the proper resource handlers are created.
   EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
   base::RunLoop().RunUntilIdle();
 
   // And now simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
-  host_.OnMessageReceived(msg, filter_.get());
+  OnMessageReceived(msg, filter_.get());
 
   // Since the request had already started processing as a download,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 }
 
@@ skipping 55 matching lines @@
     MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                     download_url, RESOURCE_TYPE_MAIN_FRAME);
 
     // Return some data so that the request is identified as a download
     // and the proper resource handlers are created.
     EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
     base::RunLoop().RunUntilIdle();
 
     // And now simulate a cancellation coming from the renderer.
     ResourceHostMsg_CancelRequest msg(request_id);
-    host_.OnMessageReceived(msg, filter_.get());
+    OnMessageReceived(msg, filter_.get());
 
     // Since the request had already started processing as a download,
     // the cancellation above should have been ignored and the request
     // should still be alive.
     EXPECT_EQ(1, host_.pending_requests());
 
     // Cancelling by other methods shouldn't work either.
     host_.CancelRequestsForProcess(render_view_id);
     EXPECT_EQ(1, host_.pending_requests());
 
@@ skipping 56 matching lines @@
 
   MakeWebContentsAssociatedTestRequestWithResourceType(
       request_id, GURL("http://example.com/blah"), RESOURCE_TYPE_MAIN_FRAME);
 
   GlobalRequestID global_request_id(web_contents_filter_->child_id(),
                                     request_id);
   host_.MarkAsTransferredNavigation(global_request_id, base::Closure());
 
   // And now simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
-  host_.OnMessageReceived(msg, web_contents_filter_.get());
+  OnMessageReceived(msg, web_contents_filter_.get());
 
   // Since the request is marked as being transferred,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   // Cancelling by other methods shouldn't work either.
   host_.CancelRequestsForProcess(web_contents_->GetRoutingID());
   EXPECT_EQ(1, host_.pending_requests());
 
@@ skipping 28 matching lines @@
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_MAIN_FRAME);
 
   // Now that we're blocked on the redirect, update the response and unblock by
   // telling the AsyncResourceHandler to follow the redirect.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/html\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg(request_id);
-  host_.OnMessageReceived(redirect_msg, filter_.get());
+  OnMessageReceived(redirect_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
-  host_.OnMessageReceived(transfer_request_msg, second_filter.get());
+  OnMessageReceived(transfer_request_msg, second_filter.get());
   base::RunLoop().RunUntilIdle();
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
@@ skipping 48 matching lines @@
   // Transfer the first request.
   int new_render_view_id = 1;
   int new_request_id = 5;
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://example.com/blah"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
-  host_.OnMessageReceived(transfer_request_msg, second_filter.get());
+  OnMessageReceived(transfer_request_msg, second_filter.get());
   base::RunLoop().RunUntilIdle();
 
   // Transfer the second request.
   int new_second_request_id = 6;
   ResourceRequest second_request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://example.com/foo"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = second_request_id;
 
   ResourceHostMsg_RequestResource second_transfer_request_msg(
       new_render_view_id, new_second_request_id, second_request);
-  host_.OnMessageReceived(second_transfer_request_msg, second_filter.get());
+  OnMessageReceived(second_transfer_request_msg, second_filter.get());
   base::RunLoop().RunUntilIdle();
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   CheckSuccessfulRequest(msgs[0], kResponseBody);
 
   second_filter->OnChannelClosing();
@@ skipping 28 matching lines @@
 
   // Now that we're blocked on the redirect, update the response and unblock by
   // telling the AsyncResourceHandler to follow the redirect.  Use a text/plain
   // MIME type, which causes MimeTypeResourceHandler to buffer it before the
   // transfer occurs.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg(request_id);
-  host_.OnMessageReceived(redirect_msg, filter_.get());
+  OnMessageReceived(redirect_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
-  host_.OnMessageReceived(transfer_request_msg, second_filter.get());
+  OnMessageReceived(transfer_request_msg, second_filter.get());
   base::RunLoop().RunUntilIdle();
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
@@ skipping 25 matching lines @@
   // Create a first filter that can be deleted before the second one starts.
   {
     scoped_refptr<ForwardingFilter> first_filter = MakeForwardingFilter();
     first_child_id = first_filter->child_id();
 
     ResourceRequest first_request = CreateResourceRequest(
         "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://example.com/blah"));
 
     ResourceHostMsg_RequestResource first_request_msg(
         render_view_id, request_id, first_request);
-    host_.OnMessageReceived(first_request_msg, first_filter.get());
+    OnMessageReceived(first_request_msg, first_filter.get());
     base::RunLoop().RunUntilIdle();
 
     // Now that we're blocked on the redirect, update the response and unblock
     // by telling the AsyncResourceHandler to follow the redirect.
     SetResponse("HTTP/1.1 200 OK\n"
                 "Content-Type: text/html\n\n",
                 kResponseBody);
     ResourceHostMsg_FollowRedirect redirect_msg(request_id);
-    host_.OnMessageReceived(redirect_msg, first_filter.get());
+    OnMessageReceived(redirect_msg, first_filter.get());
     base::RunLoop().RunUntilIdle();
 
     // Flush all the pending requests to get the response through the
     // MimeTypeResourceHandler.
     while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
     first_filter->OnChannelClosing();
   }
   // The first filter is now deleted, as if the child process died.
 
   // Make sure we don't hold onto the ResourceMessageFilter after it is deleted.
   GlobalRequestID first_global_request_id(first_child_id, request_id);
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = first_child_id;
   request.transferred_request_request_id = request_id;
 
   // For cleanup.
   child_ids_.insert(second_filter->child_id());
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
-  host_.OnMessageReceived(transfer_request_msg, second_filter.get());
+  OnMessageReceived(transfer_request_msg, second_filter.get());
   base::RunLoop().RunUntilIdle();
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
@@ skipping 21 matching lines @@
   HandleScheme("http");
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_MAIN_FRAME);
 
   // Now that we're blocked on the redirect, simulate hitting another redirect.
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blerg\n\n");
   ResourceHostMsg_FollowRedirect redirect_msg(request_id);
-  host_.OnMessageReceived(redirect_msg, filter_.get());
+  OnMessageReceived(redirect_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   // Now that we're blocked on the second redirect, update the response and
   // unblock by telling the AsyncResourceHandler to follow the redirect.
   // Again, use text/plain to force MimeTypeResourceHandler to buffer before
   // the transfer.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg2(request_id);
-  host_.OnMessageReceived(redirect_msg2, filter_.get());
+  OnMessageReceived(redirect_msg2, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   // For cleanup.
   child_ids_.insert(second_filter->child_id());
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
-  host_.OnMessageReceived(transfer_request_msg, second_filter.get());
+  OnMessageReceived(transfer_request_msg, second_filter.get());
 
   // Verify that we update the ResourceRequestInfo.
   GlobalRequestID global_request_id(second_filter->child_id(), new_request_id);
   const ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   EXPECT_EQ(second_filter->child_id(), info->GetChildID());
   EXPECT_EQ(new_render_view_id, info->GetRouteID());
   EXPECT_EQ(new_request_id, info->GetRequestID());
-  EXPECT_EQ(second_filter.get(), info->filter());
+  EXPECT_EQ(second_filter.get(), info->requester_info().filter());
 
   // Let request complete.
   base::RunLoop().RunUntilIdle();
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
@@ skipping 60 matching lines @@
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_PREFETCH);
 
   // Get a bit of data before cancelling.
   EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
 
   // Simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
-  host_.OnMessageReceived(msg, filter_.get());
+  OnMessageReceived(msg, filter_.get());
 
   EXPECT_EQ(1, host_.pending_requests());
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   EXPECT_EQ(4U, msgs[0].size());
@@ skipping 44 matching lines @@
   while (!complete) {
     for (size_t i = 0; i < msgs[0].size(); ++i) {
       if (msgs[0][i].type() == ResourceMsg_RequestComplete::ID) {
         complete = true;
         break;
       }
 
       EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
 
       ResourceHostMsg_DataReceived_ACK msg(1);
-      host_.OnMessageReceived(msg, filter_.get());
+      OnMessageReceived(msg, filter_.get());
     }
 
     base::RunLoop().RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 // Flakyness of this test might indicate memory corruption issues with
@@ skipping 15 matching lines @@
   EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
   for (size_t i = 2; i < msgs[0].size(); ++i)
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
 
   // NOTE: If we fail the above checks then it means that we probably didn't
   // load a big enough response to trigger the delay mechanism.
 
   // Send some unexpected ACKs.
   for (size_t i = 0; i < 128; ++i) {
     ResourceHostMsg_DataReceived_ACK msg(1);
-    host_.OnMessageReceived(msg, filter_.get());
+    OnMessageReceived(msg, filter_.get());
   }
 
   msgs[0].erase(msgs[0].begin());
   msgs[0].erase(msgs[0].begin());
 
   // ACK all DataReceived messages until we find a RequestComplete message.
   bool complete = false;
   while (!complete) {
     for (size_t i = 0; i < msgs[0].size(); ++i) {
       if (msgs[0][i].type() == ResourceMsg_RequestComplete::ID) {
         complete = true;
         break;
       }
 
       EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
 
       ResourceHostMsg_DataReceived_ACK msg(1);
-      host_.OnMessageReceived(msg, filter_.get());
+      OnMessageReceived(msg, filter_.get());
     }
 
     base::RunLoop().RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 // Tests the dispatcher host's temporary file management.
@@ skipping 14 matching lines @@
 
   // Register it for a resource request.
   host_.RegisterDownloadedTempFile(filter_->child_id(), kRequestID, file_path);
 
   // Should be readable now.
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // The child releases from the request.
   ResourceHostMsg_ReleaseDownloadedFile release_msg(kRequestID);
-  host_.OnMessageReceived(release_msg, filter_.get());
+  OnMessageReceived(release_msg, filter_.get());
 
   // Still readable because there is another reference to the file. (The child
   // may take additional blob references.)
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // Release extra references and wait for the file to be deleted. (This relies
   // on the delete happening on the FILE thread which is mapped to main thread
   // in this test.)
   deletable_file = NULL;
@@ skipping 35 matching lines @@
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 TEST_P(ResourceDispatcherHostTest, DownloadToFile) {
   // Make a request which downloads to file.
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_SUB_RESOURCE, net::URLRequestTestJob::test_url_1());
   request.download_to_file = true;
   ResourceHostMsg_RequestResource request_msg(0, 1, request);
-  host_.OnMessageReceived(request_msg, filter_.get());
+  OnMessageReceived(request_msg, filter_.get());
 
   // Running the message loop until idle does not work because
   // RedirectToFileResourceHandler posts things to base::WorkerPool. Instead,
   // wait for the ResourceMsg_RequestComplete to go out. Then run the event loop
   // until idle so the loader is gone.
   WaitForRequestComplete();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, host_.pending_requests());
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
@@ skipping 34 matching lines @@
   EXPECT_EQ(net::URLRequestTestJob::test_data_1(), contents);
 
   // The file should be readable by the child.
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), response_head.download_file_path));
 
   // When the renderer releases the file, it should be deleted. Again,
   // RunUntilIdle doesn't work because base::WorkerPool is involved.
   ShareableFileReleaseWaiter waiter(response_head.download_file_path);
   ResourceHostMsg_ReleaseDownloadedFile release_msg(1);
-  host_.OnMessageReceived(release_msg, filter_.get());
+  OnMessageReceived(release_msg, filter_.get());
   waiter.Wait();
   // The release callback runs before the delete is scheduled, so pump the
   // message loop for the delete itself. (This relies on the delete happening on
   // the FILE thread which is mapped to main thread in this test.)
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(base::PathExists(response_head.download_file_path));
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), response_head.download_file_path));
 }
@@ skipping 205 matching lines @@
   MakeTestRequestWithPriority(0, 2, net::IDLE);
   MakeTestRequestWithPriority(0, 3, net::IDLE);
 
   KickOffRequest();
 
   EXPECT_EQ(2, job_factory_->url_request_jobs_created_count());
 
   // Increase the priority of the second idle priority request. It was
   // scheduled later, so it is not currently running.
   ResourceHostMsg_DidChangePriority priority_msg(3, net::MAXIMUM_PRIORITY, 0);
-  host_.OnMessageReceived(priority_msg, filter_.get());
+  OnMessageReceived(priority_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(3, job_factory_->url_request_jobs_created_count());
 
   // Cleanup.
   host_.OnRenderViewHostDeleted(filter_->child_id(),  // child_id
                                 0);                   // route_id
 }
 
 // Confirm that resource response started notifications for downloads are not
@@ skipping 68 matching lines @@
 } // namespace
 
 TEST_P(ResourceDispatcherHostTest, SyncLoadWithMojoSuccess) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
-  host_.OnSyncLoadWithMojo(0, 1, request, filter_.get(),
-                           base::Bind(&StoreSyncLoadResult,
-                                      &called, &was_null, &result));
+  host_.OnSyncLoadWithMojo(
+      GetResourceRequesterInfo(filter_.get()), 0, 1, request,
+      base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   EXPECT_FALSE(was_null);
   EXPECT_EQ(net::OK, result.error_code);
 }
 
 TEST_P(ResourceDispatcherHostTest, SyncLoadWithMojoError) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
-  host_.OnSyncLoadWithMojo(0, 1, request, filter_.get(),
-                           base::Bind(&StoreSyncLoadResult,
-                                      &called, &was_null, &result));
+  host_.OnSyncLoadWithMojo(
+      GetResourceRequesterInfo(filter_.get()), 0, 1, request,
+      base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   EXPECT_FALSE(was_null);
   EXPECT_EQ(net::ERR_INVALID_URL, result.error_code);
 }
 
 TEST_P(ResourceDispatcherHostTest, SyncLoadWithMojoCancel) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
-  host_.OnSyncLoadWithMojo(0, 1, request, filter_.get(),
-                           base::Bind(&StoreSyncLoadResult,
-                                      &called, &was_null, &result));
+  host_.OnSyncLoadWithMojo(
+      GetResourceRequesterInfo(filter_.get()), 0, 1, request,
+      base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
   host_.CancelRequestsForProcess(filter_->child_id());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   EXPECT_TRUE(was_null);
 }
 
 // A URLRequestTestJob that sets a test certificate on the |ssl_info|
 // field of the response.
 class TestHTTPSURLRequestJob : public net::URLRequestTestJob {
  public:
@@ skipping 76 matching lines @@
   return nullptr;
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceDispatcherHostTests,
     ResourceDispatcherHostTest,
     testing::Values(TestConfig::kDefault,
                     TestConfig::kOptimizeIPCForSmallResourceEnabled));
 
 }  // namespace content