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 221 matching lines @@
   }
 }
 
 // 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) {
     set_peer_process_for_testing(base::Process::Current());
@@ skipping 724 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);
+    host_.OnCancelRequest(filter_.get(), 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 34 matching lines @@
     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;
-  }
-
   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) {
     host_.OnRenderFrameDeleted(global_routing_id);
   }
@@ skipping 502 matching lines @@
   host_.OnMessageReceived(msg_prefetch, filter_.get());
   ResourceHostMsg_RequestResource msg_ping(0, 2, request_ping);
   host_.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 22 matching lines @@
       net::URLRequestTestJob::test_url_redirect_to_url_2());
 
   ResourceHostMsg_RequestResource msg(0, 1, request);
   host_.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 1418 matching lines @@
       new_render_view_id, new_request_id, request);
   host_.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 638 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(
+      0, 1, request,
+      ResourceRequesterInfo::CreateForRenderer(filter_->GetWeakPtr()),
+      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(
+      0, 1, request,
+      ResourceRequesterInfo::CreateForRenderer(filter_->GetWeakPtr()),
+      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(
+      0, 1, request,
+      ResourceRequesterInfo::CreateForRenderer(filter_->GetWeakPtr()),
+      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