Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/loader/async_resource_handler_unittest.cc

 // Copyright 2016 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/loader/async_resource_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <string>
@@ skipping 15 matching lines @@
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_loader.h"
 #include "content/browser/loader/resource_loader_delegate.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_features.h"
-#include "content/public/common/process_type.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
@@ skipping 38 matching lines @@
   size_t response_data_size_;
 };
 
 // A subclass of ResourceMessageFilter that records IPC messages that are sent.
 class RecordingResourceMessageFilter : public ResourceMessageFilter {
  public:
   RecordingResourceMessageFilter(ResourceContext* resource_context,
                                  net::URLRequestContext* request_context)
       : ResourceMessageFilter(
             0,
-            PROCESS_TYPE_RENDERER,
             nullptr,
             nullptr,
             nullptr,
             nullptr,
             base::Bind(&RecordingResourceMessageFilter::GetContexts,
                        base::Unretained(this))),
         resource_context_(resource_context),
         request_context_(request_context) {
+    OnFilterAdded(nullptr);

[kinuko, 2016/11/18 01:29:21]

Needing to OnFilterAdded even with nullptr in unittests is not obvious, could we
have a comment about that in resource_message_filter.h?  (Or having a static
method like CreateForTesting which initializes all storage contexts with nullptr
and call OnFilterAdded might be helpful?)

[horo, 2016/11/18 02:02:51]

Done.

     set_peer_process_for_testing(base::Process::Current());
   }
 
   const std::vector<std::unique_ptr<IPC::Message>>& messages() const {
     return messages_;
   }
 
   // IPC::Sender implementation:
   bool Send(IPC::Message* message) override {
     // Unpickle the base::SharedMemoryHandle to avoid warnings about
@@ skipping 14 matching lines @@
                    net::URLRequestContext** request_context) {
     *resource_context = resource_context_;
     *request_context = request_context_;
   }
 
   ResourceContext* const resource_context_;
   net::URLRequestContext* const request_context_;
   std::vector<std::unique_ptr<IPC::Message>> messages_;
 };
 
+}  // namespace
+
 class AsyncResourceHandlerTest : public ::testing::Test,
                                  public ResourceLoaderDelegate {
  protected:
   AsyncResourceHandlerTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP), context_(true) {}
 
   void TearDown() override {
     if (filter_)
       filter_->OnChannelClosing();
     // Prevent memory leaks.
     filter_ = nullptr;
     rdh_.Shutdown();
     base::RunLoop().RunUntilIdle();
   }
 
   void CreateRequestWithResponseDataSize(size_t response_data_size) {
     test_job_factory_.SetProtocolHandler(
         "test", base::MakeUnique<TestProtocolHandler>(response_data_size));
     context_.set_job_factory(&test_job_factory_);
     context_.Init();
     std::unique_ptr<net::URLRequest> request = context_.CreateRequest(
         GURL("test:test"), net::DEFAULT_PRIORITY, nullptr);
     resource_context_ = base::MakeUnique<MockResourceContext>(&context_);
     filter_ =
         new RecordingResourceMessageFilter(resource_context_.get(), &context_);
     ResourceRequestInfoImpl* info = new ResourceRequestInfoImpl(
-        PROCESS_TYPE_RENDERER,                 // process_type
-        0,                                     // child_id
+        filter_->requester_info(),
         0,                                     // route_id
         -1,                                    // frame_tree_node_id
         0,                                     // origin_pid
         0,                                     // request_id
         0,                                     // render_frame_id
         false,                                 // is_main_frame
         false,                                 // parent_is_main_frame
         RESOURCE_TYPE_IMAGE,                   // resource_type
         ui::PAGE_TRANSITION_LINK,              // transition_type
         false,                                 // should_replace_current_entry
         false,                                 // is_download
         false,                                 // is_stream
         false,                                 // allow_download
         false,                                 // has_user_gesture
         false,                                 // enable load timing
         false,                                 // enable upload progress
         false,                                 // do_not_prompt_for_login
         blink::WebReferrerPolicyDefault,       // referrer_policy
         blink::WebPageVisibilityStateVisible,  // visibility_state
         resource_context_.get(),               // context
-        filter_->GetWeakPtr(),                 // filter
         false,                                 // report_raw_headers
         true,                                  // is_async
         false,                                 // is_using_lofi
         std::string(),                         // original_headers
         nullptr,                               // body
         false);                                // initiated_in_secure_context
     info->AssociateWithRequest(request.get());
     std::unique_ptr<AsyncResourceHandler> handler =
         base::MakeUnique<AsyncResourceHandler>(request.get(), &rdh_);
     loader_ = base::MakeUnique<ResourceLoader>(
@@ skipping 101 matching lines @@
 
   ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[3]->type());
   ResourceMsg_DataReceived::Read(messages[3].get(), &params);
 
   encoded_data_length = std::get<3>(params);
   EXPECT_EQ(32768, encoded_data_length);
   encoded_body_length = std::get<4>(params);
   EXPECT_EQ(32768, encoded_body_length);
 }
 
-}  // namespace
-
 }  // namespace content