Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/loader/resource_dispatcher_host_impl.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 38 matching lines @@
 #include "content/browser/loader/loader_delegate.h"
 #include "content/browser/loader/mime_sniffing_resource_handler.h"
 #include "content/browser/loader/mojo_async_resource_handler.h"
 #include "content/browser/loader/navigation_resource_handler.h"
 #include "content/browser/loader/navigation_resource_throttle.h"
 #include "content/browser/loader/navigation_url_loader_impl_core.h"
 #include "content/browser/loader/power_save_block_resource_throttle.h"
 #include "content/browser/loader/redirect_to_file_resource_handler.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
+#include "content/browser/loader/resource_requester_info.h"
 #include "content/browser/loader/stream_resource_handler.h"
 #include "content/browser/loader/sync_resource_handler.h"
 #include "content/browser/loader/throttling_resource_handler.h"
 #include "content/browser/loader/upload_data_stream_builder.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/service_worker/foreign_fetch_request_handler.h"
 #include "content/browser/service_worker/link_header_support.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "content/browser/streams/stream.h"
 #include "content/browser/streams/stream_context.h"
 #include "content/browser/streams/stream_registry.h"
 #include "content/common/navigation_params.h"
 #include "content/common/net/url_request_service_worker_data.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/navigation_ui_data.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/browser/stream_info.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
-#include "content/public/common/process_type.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_message_start.h"
 #include "net/base/auth.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_data_stream.h"
 #include "net/cert/cert_status_flags.h"
@@ skipping 115 matching lines @@
     case RESOURCE_TYPE_PING:
     case RESOURCE_TYPE_CSP_REPORT:
       return true;
     default:
       return false;
   }
 }
 
 // Aborts a request before an URLRequest has actually been created.
 void AbortRequestBeforeItStarts(
-    ResourceMessageFilter* filter,
+    BrowserMessageFilter* filter,
     const SyncLoadResultCallback& sync_result_handler,
     int request_id,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
   if (sync_result_handler) {
     SyncLoadResult result;
     result.error_code = net::ERR_ABORTED;
     sync_result_handler.Run(&result);
   } else {
     // Tell the renderer that this request was disallowed.
     ResourceRequestCompletionStatus request_complete_data;
@@ skipping 177 matching lines @@
     if (pending_frame_host)
       routing_ids->insert(pending_frame_host->GetGlobalFrameRoutingId());
   }
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&NotifyForRouteSetOnIO, frame_callback,
                                      base::Passed(std::move(routing_ids))));
 }
 
 // Sends back the result of a synchronous loading result to the renderer through
 // Chrome IPC.
-void HandleSyncLoadResult(base::WeakPtr<ResourceMessageFilter> filter,
+void HandleSyncLoadResult(std::unique_ptr<ResourceRequesterInfo> requester_info,
                           std::unique_ptr<IPC::Message> sync_result,
                           const SyncLoadResult* result) {
-  if (!filter)
+  DCHECK(requester_info->IsRenderer());
+  if (!requester_info->filter())
     return;
 
   if (result) {
     ResourceHostMsg_SyncLoad::WriteReplyParams(sync_result.get(), *result);
   } else {
     sync_result->set_reply_error();
   }
-  filter->Send(sync_result.release());
+  requester_info->filter()->Send(sync_result.release());
 }
 
 }  // namespace
 
 ResourceDispatcherHostImpl::LoadInfo::LoadInfo() {}
 ResourceDispatcherHostImpl::LoadInfo::LoadInfo(const LoadInfo& other) = default;
 ResourceDispatcherHostImpl::LoadInfo::~LoadInfo() {}
 
 ResourceDispatcherHostImpl::HeaderInterceptorInfo::HeaderInterceptorInfo() {}
 
@@ skipping 10 matching lines @@
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl(
     CreateDownloadHandlerIntercept download_handler_intercept)
     : request_id_(-1),
       is_shutdown_(false),
       num_in_flight_requests_(0),
       max_num_in_flight_requests_(base::SharedMemory::GetHandleLimit()),
       max_num_in_flight_requests_per_process_(static_cast<int>(
           max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
-      filter_(nullptr),
       delegate_(nullptr),
       loader_delegate_(nullptr),
       allow_cross_origin_auth_prompt_(false),
       create_download_handler_intercept_(download_handler_intercept) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
@@ skipping 129 matching lines @@
   }
 
 #ifndef NDEBUG
   for (const auto& loader : loaders_to_cancel) {
     // There is no strict requirement that this be the case, but currently
     // downloads, streams, detachable requests, transferred requests, and
     // browser-owned requests are the only requests that aren't cancelled when
     // the associated processes go away. It may be OK for this invariant to
     // change in the future, but if this assertion fires without the invariant
     // changing, then it's indicative of a leak.
-    DCHECK(loader->GetRequestInfo()->IsDownload() ||
-           loader->GetRequestInfo()->is_stream() ||
-           (loader->GetRequestInfo()->detachable_handler() &&
-            loader->GetRequestInfo()->detachable_handler()->is_detached()) ||
-           loader->GetRequestInfo()->GetProcessType() == PROCESS_TYPE_BROWSER ||
-           loader->is_transferring());
+    DCHECK(
+        loader->GetRequestInfo()->IsDownload() ||
+        loader->GetRequestInfo()->is_stream() ||
+        (loader->GetRequestInfo()->detachable_handler() &&
+         loader->GetRequestInfo()->detachable_handler()->is_detached()) ||
+        loader->GetRequestInfo()->requester_info().IsBrowserSideNavigation() ||
+        loader->is_transferring());
   }
 #endif
 
   loaders_to_cancel.clear();
 
   if (async_revalidation_manager_) {
     // Cancelling async revalidations should not result in the creation of new
     // requests. Do it before the CHECKs to ensure this does not happen.
     async_revalidation_manager_->CancelAsyncRevalidationsForResourceContext(
         context);
@@ skipping 367 matching lines @@
     CancelBlockedRequestsForRoute(routing_id);
   }
 
   scheduler_.reset();
 }
 
 bool ResourceDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& message,
     ResourceMessageFilter* filter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  filter_ = filter;
+  requester_info_ =
+      ResourceRequesterInfo::CreateForRenderer(filter->GetWeakPtr());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ResourceDispatcherHostImpl, message)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ResourceHostMsg_SyncLoad, OnSyncLoad)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_ReleaseDownloadedFile,
                         OnReleaseDownloadedFile)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_CancelRequest, OnCancelRequest)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_DidChangePriority, OnDidChangePriority)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!handled && IPC_MESSAGE_ID_CLASS(message.type()) == ResourceMsgStart) {
     base::PickleIterator iter(message);
     int request_id = -1;
     bool ok = iter.ReadInt(&request_id);
     DCHECK(ok);
-    GlobalRequestID id(filter_->child_id(), request_id);
+    GlobalRequestID id(requester_info_->child_id(), request_id);
     DelegateMap::iterator it = delegate_map_.find(id);
     if (it != delegate_map_.end()) {
       for (auto& delegate : *it->second) {
         if (delegate.OnMessageReceived(message)) {
           handled = true;
           break;
         }
       }
     }
 
     // As the unhandled resource message effectively has no consumer, mark it as
     // handled to prevent needless propagation through the filter pipeline.
     handled = true;
   }
 
-  filter_ = NULL;
+  requester_info_.reset();
   return handled;
 }
 
 void ResourceDispatcherHostImpl::OnRequestResource(
     int routing_id,
     int request_id,
     const ResourceRequest& request_data) {
   OnRequestResourceInternal(routing_id, request_id, request_data, nullptr,
                             nullptr);
 }
 
 void ResourceDispatcherHostImpl::OnRequestResourceInternal(
     int routing_id,
     int request_id,
     const ResourceRequest& request_data,
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
+  DCHECK(requester_info_->IsRenderer());
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 ResourceDispatcherHostImpl::OnRequestResource"));
   // When logging time-to-network only care about main frame and non-transfer
   // navigations.
   // PlzNavigate: this log happens from NavigationRequest::OnRequestStarted
   // instead.
   if (request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME &&
       request_data.transferred_request_request_id == -1 &&
       !IsBrowserSideNavigationEnabled()) {
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&LogResourceRequestTimeOnUI,
-                   TimeTicks::Now(),
-                   filter_->child_id(),
-                   request_data.render_frame_id,
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&LogResourceRequestTimeOnUI, TimeTicks::Now(),
+                   requester_info_->child_id(), request_data.render_frame_id,
                    request_data.url));
   }
   BeginRequest(request_id, request_data, SyncLoadResultCallback(), routing_id,
                std::move(mojo_request), std::move(url_loader_client));
 }
 
 // Begins a resource request with the given params on behalf of the specified
 // child process.  Responses will be dispatched through the given receiver. The
 // process ID is used to lookup WebContentsImpl from routing_id's in the case of
 // a request from a renderer.  request_context is the cookie/cache context to be
 // used for this request.
 //
 // If sync_result is non-null, then a SyncLoad reply will be generated, else
 // a normal asynchronous set of response messages will be generated.
 void ResourceDispatcherHostImpl::OnSyncLoad(int request_id,
                                             const ResourceRequest& request_data,
                                             IPC::Message* sync_result) {
-  SyncLoadResultCallback callback = base::Bind(
-      &HandleSyncLoadResult, filter_->GetWeakPtr(),
-      base::Passed(WrapUnique(sync_result)));
+  DCHECK(requester_info_->IsRenderer());
+  SyncLoadResultCallback callback =
+      base::Bind(&HandleSyncLoadResult, base::Passed(requester_info_->clone()),
+                 base::Passed(WrapUnique(sync_result)));
   BeginRequest(request_id, request_data, callback, sync_result->routing_id(),
                nullptr, nullptr);
 }
 
 bool ResourceDispatcherHostImpl::IsRequestIDInUse(
     const GlobalRequestID& id) const {
   if (pending_loaders_.find(id) != pending_loaders_.end())
     return true;
   for (const auto& blocked_loaders : blocked_loaders_map_) {
     for (const auto& loader : *blocked_loaders.second.get()) {
       ResourceRequestInfoImpl* info = loader->GetRequestInfo();
       if (info->GetGlobalRequestID() == id)
         return true;
     }
   }
   return false;
 }
 
 void ResourceDispatcherHostImpl::UpdateRequestForTransfer(
     int child_id,
     int route_id,
     int request_id,
     const ResourceRequest& request_data,
     LoaderMap::iterator iter) {
+  DCHECK(requester_info_->IsRenderer());
   ResourceRequestInfoImpl* info = iter->second->GetRequestInfo();
   GlobalFrameRoutingId old_routing_id(request_data.transferred_request_child_id,
                                       info->GetRenderFrameID());
   GlobalRequestID old_request_id(request_data.transferred_request_child_id,
                                  request_data.transferred_request_request_id);
   GlobalFrameRoutingId new_routing_id(child_id, request_data.render_frame_id);
   GlobalRequestID new_request_id(child_id, request_id);
 
   // Clear out data that depends on |info| before updating it.
   // We always need to move the memory stats to the new process.  In contrast,
   // stats.num_requests is only tracked for some requests (those that require
   // file descriptors for their shared memory buffer).
   IncrementOutstandingRequestsMemory(-1, *info);
   bool should_update_count = info->counted_as_in_flight_request();
   if (should_update_count)
     IncrementOutstandingRequestsCount(-1, info);
 
   DCHECK(pending_loaders_.find(old_request_id) == iter);
   std::unique_ptr<ResourceLoader> loader = std::move(iter->second);
   ResourceLoader* loader_ptr = loader.get();
   pending_loaders_.erase(iter);
 
   // ResourceHandlers should always get state related to the request from the
   // ResourceRequestInfo rather than caching it locally.  This lets us update
   // the info object when a transfer occurs.
-  info->UpdateForTransfer(child_id, route_id, request_data.render_frame_id,
+  info->UpdateForTransfer(route_id, request_data.render_frame_id,
                           request_data.origin_pid, request_id,
-                          filter_->GetWeakPtr());
+                          requester_info_->clone());
 
   // Update maps that used the old IDs, if necessary.  Some transfers in tests
   // do not actually use a different ID, so not all maps need to be updated.
   pending_loaders_[new_request_id] = std::move(loader);
   IncrementOutstandingRequestsMemory(1, *info);
   if (should_update_count)
     IncrementOutstandingRequestsCount(1, info);
   if (old_routing_id != new_routing_id) {
     if (blocked_loaders_map_.find(old_routing_id) !=
             blocked_loaders_map_.end()) {
       blocked_loaders_map_[new_routing_id] =
           std::move(blocked_loaders_map_[old_routing_id]);
       blocked_loaders_map_.erase(old_routing_id);
     }
   }
   if (old_request_id != new_request_id) {
     DelegateMap::iterator it = delegate_map_.find(old_request_id);
     if (it != delegate_map_.end()) {
       // Tell each delegate that the request ID has changed.
       for (auto& delegate : *it->second)
         delegate.set_request_id(new_request_id);
       // Now store the observer list under the new request ID.
       delegate_map_[new_request_id] = delegate_map_[old_request_id];
       delegate_map_.erase(old_request_id);
     }
   }
 
   AppCacheInterceptor::CompleteCrossSiteTransfer(
-      loader_ptr->request(),
-      child_id,
-      request_data.appcache_host_id,
-      filter_);
+      loader_ptr->request(), child_id, request_data.appcache_host_id,
+      requester_info_.get());
 
   ServiceWorkerRequestHandler* handler =
       ServiceWorkerRequestHandler::GetHandler(loader_ptr->request());
   if (handler) {
-    if (!handler->SanityCheckIsSameContext(filter_->service_worker_context())) {
+    if (!handler->SanityCheckIsSameContext(
+            requester_info_->service_worker_context())) {
       bad_message::ReceivedBadMessage(
-          filter_, bad_message::RDHI_WRONG_STORAGE_PARTITION);
+          requester_info_->filter(), bad_message::RDHI_WRONG_STORAGE_PARTITION);
     } else {
       handler->CompleteCrossSiteTransfer(
           child_id, request_data.service_worker_provider_id);
     }
   }
 }
 
 void ResourceDispatcherHostImpl::CompleteTransfer(
     int request_id,
     const ResourceRequest& request_data,
     int route_id) {
+  DCHECK(requester_info_->IsRenderer());
   // Caller should ensure that |request_data| is associated with a transfer.
   DCHECK(request_data.transferred_request_child_id != -1 ||
          request_data.transferred_request_request_id != -1);
 
   bool is_navigational_request =
       request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME ||
       request_data.resource_type == RESOURCE_TYPE_SUB_FRAME;
   if (!is_navigational_request) {
     // Transfers apply only to navigational requests - the renderer seems to
     // have sent bogus IPC data.
     bad_message::ReceivedBadMessage(
-        filter_, bad_message::RDH_TRANSFERRING_NONNAVIGATIONAL_REQUEST);
+        requester_info_->filter(),
+        bad_message::RDH_TRANSFERRING_NONNAVIGATIONAL_REQUEST);
     return;
   }
 
   // Attempt to find a loader associated with the deferred transfer request.
   LoaderMap::iterator it = pending_loaders_.find(
       GlobalRequestID(request_data.transferred_request_child_id,
                       request_data.transferred_request_request_id));
   if (it == pending_loaders_.end()) {
     // Renderer sent transferred_request_request_id and/or
     // transferred_request_child_id that doesn't have a corresponding entry on
     // the browser side.
     // TODO(lukasza): https://crbug.com/659613: Need to understand the scenario
     // that can lead here (and then attempt to reintroduce a renderer kill
     // below).
     return;
   }
   ResourceLoader* pending_loader = it->second.get();
 
   if (!pending_loader->is_transferring()) {
     // Renderer sent transferred_request_request_id and/or
     // transferred_request_child_id that doesn't correspond to an actually
     // transferring loader on the browser side.
     base::debug::Alias(pending_loader);
-    bad_message::ReceivedBadMessage(filter_,
+    bad_message::ReceivedBadMessage(requester_info_->filter(),
                                     bad_message::RDH_REQUEST_NOT_TRANSFERRING);
     return;
   }
 
   // If the request is transferring to a new process, we can update our
   // state and let it resume with its existing ResourceHandlers.
-  UpdateRequestForTransfer(filter_->child_id(), route_id, request_id,
+  UpdateRequestForTransfer(requester_info_->child_id(), route_id, request_id,
                            request_data, it);
   pending_loader->CompleteTransfer();
 }
 
 void ResourceDispatcherHostImpl::BeginRequest(
     int request_id,
     const ResourceRequest& request_data,
     const SyncLoadResultCallback& sync_result_handler,  // only valid for sync
     int route_id,
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
-  int process_type = filter_->process_type();
-  int child_id = filter_->child_id();
+  DCHECK(requester_info_->IsRenderer());
+  int child_id = requester_info_->child_id();
 
   // Reject request id that's currently in use.
   if (IsRequestIDInUse(GlobalRequestID(child_id, request_id))) {
-    bad_message::ReceivedBadMessage(filter_,
+    bad_message::ReceivedBadMessage(requester_info_->filter(),
                                     bad_message::RDH_INVALID_REQUEST_ID);
     return;
   }
 
   // PlzNavigate: reject invalid renderer main resource request.
   bool is_navigation_stream_request =
       IsBrowserSideNavigationEnabled() &&
       IsResourceTypeFrame(request_data.resource_type);
-  // The process_type check is to ensure that unittests are not blocked from
-  // issuing http requests.
-  if ((process_type == PROCESS_TYPE_RENDERER) && is_navigation_stream_request

[yhirano, 2016/11/10 06:42:29]

Does this change mean this |process_type| check is completely redundant? Ditto
for other places calling ResourceMessageFilter::process_type().

[horo, 2016/11/10 14:46:33]

These checks were added by this change
https://codereview.chromium.org/2283473002 to fix URLLoaderFactoryImplTest with
PlzNavigate enabled.

The test failed with PlzNavigate because:
 - The test fetches frame type requests with mojom::URLLoader.
 - But frame type requests which URL is not blob scheme is blocked when
PlzNavigate is enabled.
So the cl (2283473002) introduced this check and changed the process type in the
test to PROCESS_TYPE_UNKNOWN.

We can remove these checks by just changing URLLoaderFactoryImplTest not to
fetch frame type requests. And I think this is better approach.

-       && !request_data.resource_body_stream_url.SchemeIs(url::kBlobScheme)) {
-    bad_message::ReceivedBadMessage(filter_, bad_message::RDH_INVALID_URL);
+  if (is_navigation_stream_request &&
+      !request_data.resource_body_stream_url.SchemeIs(url::kBlobScheme)) {
+    bad_message::ReceivedBadMessage(requester_info_->filter(),
+                                    bad_message::RDH_INVALID_URL);
     return;
   }
 
   // Reject invalid priority.
   if (request_data.priority < net::MINIMUM_PRIORITY ||
       request_data.priority > net::MAXIMUM_PRIORITY) {
-    bad_message::ReceivedBadMessage(filter_, bad_message::RDH_INVALID_PRIORITY);
+    bad_message::ReceivedBadMessage(requester_info_->filter(),
+                                    bad_message::RDH_INVALID_PRIORITY);
     return;
   }
 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/91398
   char url_buf[128];
   base::strlcpy(url_buf, request_data.url.spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   // If the request that's coming in is being transferred from another process,
   // we want to reuse and resume the old loader rather than start a new one.
   if (request_data.transferred_request_child_id != -1 ||
       request_data.transferred_request_request_id != -1) {
     // TODO(yhirano): Make mojo work for this case.
     DCHECK(!url_loader_client);
 
     CompleteTransfer(request_id, request_data, route_id);
     return;
   }
 
   ResourceContext* resource_context = NULL;
   net::URLRequestContext* request_context = NULL;
-  filter_->GetContexts(request_data.resource_type, &resource_context,
-                       &request_context);
+  requester_info_->GetContexts(request_data.resource_type, &resource_context,
+                               &request_context);
 
   // Parse the headers before calling ShouldServiceRequest, so that they are
   // available to be validated.
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(request_data.headers);
 
   if (is_shutdown_ ||
-      !ShouldServiceRequest(process_type, child_id, request_data, headers,
-                            filter_, resource_context)) {
-    AbortRequestBeforeItStarts(filter_, sync_result_handler, request_id,
-                               std::move(url_loader_client));
+      !ShouldServiceRequest(child_id, request_data, headers,
+                            requester_info_.get(), resource_context)) {
+    AbortRequestBeforeItStarts(requester_info_->filter(), sync_result_handler,
+                               request_id, std::move(url_loader_client));
     return;
   }
   // Check if we have a registered interceptor for the headers passed in. If
   // yes then we need to mark the current request as pending and wait for the
   // interceptor to invoke the callback with a status code indicating whether
   // the request needs to be aborted or continued.
   for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();) {
     HeaderInterceptorMap::iterator index =
         http_header_interceptor_map_.find(it.name());
     if (index != http_header_interceptor_map_.end()) {
@@ skipping 25 matching lines @@
 void ResourceDispatcherHostImpl::ContinuePendingBeginRequest(
     int request_id,
     const ResourceRequest& request_data,
     const SyncLoadResultCallback& sync_result_handler,  // only valid for sync
     int route_id,
     const net::HttpRequestHeaders& headers,
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client,
     bool continue_request,
     int error_code) {
+  DCHECK(requester_info_->IsRenderer());
   if (!continue_request) {
     // TODO(ananta): Find a way to specify the right error code here.  Passing
     // in a non-content error code is not safe.
-    bad_message::ReceivedBadMessage(filter_, bad_message::RDH_ILLEGAL_ORIGIN);
-    AbortRequestBeforeItStarts(filter_, sync_result_handler, request_id,
-                               std::move(url_loader_client));
+    bad_message::ReceivedBadMessage(requester_info_->filter(),
+                                    bad_message::RDH_ILLEGAL_ORIGIN);
+    AbortRequestBeforeItStarts(requester_info_->filter(), sync_result_handler,
+                               request_id, std::move(url_loader_client));
     return;
   }
-
-  int process_type = filter_->process_type();
-  int child_id = filter_->child_id();
+  int child_id = requester_info_->child_id();
 
   bool is_navigation_stream_request =
       IsBrowserSideNavigationEnabled() &&
-      IsResourceTypeFrame(request_data.resource_type) &&
-      process_type == PROCESS_TYPE_RENDERER;
+      IsResourceTypeFrame(request_data.resource_type);
 
   ResourceContext* resource_context = NULL;
   net::URLRequestContext* request_context = NULL;
-  filter_->GetContexts(request_data.resource_type, &resource_context,
-                       &request_context);
+  requester_info_->GetContexts(request_data.resource_type, &resource_context,
+                               &request_context);
 
   // Allow the observer to block/handle the request.
   if (delegate_ && !delegate_->ShouldBeginRequest(request_data.method,
                                                   request_data.url,
                                                   request_data.resource_type,
                                                   resource_context)) {
-    AbortRequestBeforeItStarts(filter_, sync_result_handler, request_id,
-                               std::move(url_loader_client));
+    AbortRequestBeforeItStarts(requester_info_->filter(), sync_result_handler,
+                               request_id, std::move(url_loader_client));
     return;
   }
 
   // Construct the request.
   std::unique_ptr<net::URLRequest> new_request = request_context->CreateRequest(
       is_navigation_stream_request ? request_data.resource_body_stream_url
                                    : request_data.url,
       request_data.priority, nullptr);
 
   // PlzNavigate: Always set the method to GET when gaining access to the
@@ skipping 34 matching lines @@
   // ComputeReferrerForRedirect).
   if (!is_navigation_stream_request) {
     const Referrer referrer(
         request_data.referrer, request_data.referrer_policy);
     SetReferrerForRequest(new_request.get(), referrer);
   }
 
   new_request->SetExtraRequestHeaders(headers);
 
   storage::BlobStorageContext* blob_context =
-      GetBlobStorageContext(filter_->blob_storage_context());
+      GetBlobStorageContext(requester_info_->blob_storage_context());
   // Resolve elements from request_body and prepare upload data.
   if (request_data.request_body.get()) {
     // |blob_context| could be null when the request is from the plugins because
     // ResourceMessageFilters created in PluginProcessHost don't have the blob
     // context.
     if (blob_context) {
       // Attaches the BlobDataHandles to request_body not to free the blobs and
       // any attached shareable files until upload completion. These data will
       // be used in UploadDataStream and ServiceWorkerURLRequestJob.
       AttachRequestBodyBlobDataHandles(
           request_data.request_body.get(),
           blob_context);
     }
     new_request->set_upload(UploadDataStreamBuilder::Build(
         request_data.request_body.get(), blob_context,
-        filter_->file_system_context(),
+        requester_info_->file_system_context(),
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get()));
   }
 
   bool allow_download = request_data.allow_download &&
       IsResourceTypeFrame(request_data.resource_type);
   bool do_not_prompt_for_login = request_data.do_not_prompt_for_login;
   bool is_sync_load = !!sync_result_handler;
 
   // Raw headers are sensitive, as they include Cookie/Set-Cookie, so only
   // allow requesting them if requester has ReadRawCookies permission.
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
   bool report_raw_headers = request_data.report_raw_headers;
   if (report_raw_headers && !policy->CanReadRawCookies(child_id)) {
     // TODO: crbug.com/523063 can we call bad_message::ReceivedBadMessage here?
     VLOG(1) << "Denied unauthorized request for raw headers";
     report_raw_headers = false;
   }
-  int load_flags =
-      BuildLoadFlagsForRequest(request_data, child_id, is_sync_load);
+  int load_flags = BuildLoadFlagsForRequest(request_data, is_sync_load);
   if (request_data.resource_type == RESOURCE_TYPE_PREFETCH ||
       request_data.resource_type == RESOURCE_TYPE_FAVICON) {
     do_not_prompt_for_login = true;
   }
   if (request_data.resource_type == RESOURCE_TYPE_IMAGE &&
       HTTP_AUTH_RELATION_BLOCKED_CROSS ==
           HttpAuthRelationTypeOf(request_data.url,
                                  request_data.first_party_for_cookies)) {
     // Prevent third-party image content from prompting for login, as this
     // is often a scam to extract credentials for another domain from the user.
@@ skipping 19 matching lines @@
   if (is_sync_load) {
     DCHECK_EQ(request_data.priority, net::MAXIMUM_PRIORITY);
     DCHECK_NE(load_flags & net::LOAD_IGNORE_LIMITS, 0);
   } else {
     DCHECK_EQ(load_flags & net::LOAD_IGNORE_LIMITS, 0);
   }
   new_request->SetLoadFlags(load_flags);
 
   // Make extra info and read footer (contains request ID).
   ResourceRequestInfoImpl* extra_info = new ResourceRequestInfoImpl(
-      process_type, child_id, route_id,
+      requester_info_->clone(), route_id,
       -1,  // frame_tree_node_id
       request_data.origin_pid, request_id, request_data.render_frame_id,
       request_data.is_main_frame, request_data.parent_is_main_frame,
       request_data.resource_type, request_data.transition_type,
       request_data.should_replace_current_entry,
       false,  // is download
       false,  // is stream
       allow_download, request_data.has_user_gesture,
       request_data.enable_load_timing, request_data.enable_upload_progress,
       do_not_prompt_for_login, request_data.referrer_policy,
-      request_data.visibility_state, resource_context, filter_->GetWeakPtr(),
-      report_raw_headers, !is_sync_load,
+      request_data.visibility_state, resource_context, report_raw_headers,
+      !is_sync_load,
       IsUsingLoFi(request_data.lofi_state, delegate_, *new_request,
                   resource_context,
                   request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME),
       support_async_revalidation ? request_data.headers : std::string(),
       request_data.request_body, request_data.initiated_in_secure_context);
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
 
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
-        new_request.get(),
-        filter_->blob_storage_context()->context()->GetBlobDataFromPublicURL(
-            new_request->url()));
+        new_request.get(), requester_info_->blob_storage_context()
+                               ->context()
+                               ->GetBlobDataFromPublicURL(new_request->url()));
   }
 
   // Initialize the service worker handler for the request. We don't use
   // ServiceWorker for synchronous loads to avoid renderer deadlocks.
   const SkipServiceWorker should_skip_service_worker =
       is_sync_load ? SkipServiceWorker::ALL : request_data.skip_service_worker;
   ServiceWorkerRequestHandler::InitializeHandler(
-      new_request.get(), filter_->service_worker_context(), blob_context,
-      child_id, request_data.service_worker_provider_id,
+      new_request.get(), requester_info_->service_worker_context(),
+      blob_context, child_id, request_data.service_worker_provider_id,
       should_skip_service_worker != SkipServiceWorker::NONE,
       request_data.fetch_request_mode, request_data.fetch_credentials_mode,
       request_data.fetch_redirect_mode, request_data.resource_type,
       request_data.fetch_request_context_type, request_data.fetch_frame_type,
       request_data.request_body);
 
   ForeignFetchRequestHandler::InitializeHandler(
-      new_request.get(), filter_->service_worker_context(), blob_context,
-      child_id, request_data.service_worker_provider_id,
+      new_request.get(), requester_info_->service_worker_context(),
+      blob_context, child_id, request_data.service_worker_provider_id,
       should_skip_service_worker, request_data.fetch_request_mode,
       request_data.fetch_credentials_mode, request_data.fetch_redirect_mode,
       request_data.resource_type, request_data.fetch_request_context_type,
       request_data.fetch_frame_type, request_data.request_body,
       request_data.initiated_in_secure_context);
 
   // Have the appcache associate its extra info with the request.
   AppCacheInterceptor::SetExtraRequestInfo(
-      new_request.get(), filter_->appcache_service(), child_id,
+      new_request.get(), requester_info_->appcache_service(), child_id,
       request_data.appcache_host_id, request_data.resource_type,
       request_data.should_reset_appcache);
 
   std::unique_ptr<ResourceHandler> handler(CreateResourceHandler(
-      new_request.get(), request_data, sync_result_handler, route_id,
-      process_type, child_id, resource_context, std::move(mojo_request),
-      std::move(url_loader_client)));
+      new_request.get(), request_data, sync_result_handler, route_id, child_id,
+      resource_context, std::move(mojo_request), std::move(url_loader_client)));
 
   if (handler)
     BeginRequestInternal(std::move(new_request), std::move(handler));
 }
 
 std::unique_ptr<ResourceHandler>
 ResourceDispatcherHostImpl::CreateResourceHandler(
     net::URLRequest* request,
     const ResourceRequest& request_data,
     const SyncLoadResultCallback& sync_result_handler,
     int route_id,
-    int process_type,
     int child_id,
     ResourceContext* resource_context,
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
+  DCHECK(requester_info_->IsRenderer());
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/456331 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "456331 ResourceDispatcherHostImpl::CreateResourceHandler"));
   // Construct the IPC resource handler.
   std::unique_ptr<ResourceHandler> handler;
   if (sync_result_handler) {
     // download_to_file is not supported for synchronous requests.
     if (request_data.download_to_file) {
-      bad_message::ReceivedBadMessage(filter_, bad_message::RDH_BAD_DOWNLOAD);
+      bad_message::ReceivedBadMessage(requester_info_->filter(),
+                                      bad_message::RDH_BAD_DOWNLOAD);
       return std::unique_ptr<ResourceHandler>();
     }
 
     DCHECK(!mojo_request.is_pending());
     DCHECK(!url_loader_client);
     handler.reset(new SyncResourceHandler(request, sync_result_handler, this));
   } else {
     if (mojo_request.is_pending()) {
       handler.reset(new MojoAsyncResourceHandler(request, this,
                                                  std::move(mojo_request),
@@ skipping 18 matching lines @@
     std::unique_ptr<DetachableResourceHandler> detachable_handler =
         base::MakeUnique<DetachableResourceHandler>(
             request,
             base::TimeDelta::FromMilliseconds(kDefaultDetachableCancelDelayMs),
             std::move(handler));
     if (start_detached)
       detachable_handler->Detach();
     handler = std::move(detachable_handler);
   }
 
-  return AddStandardHandlers(
-      request, request_data.resource_type, resource_context,
-      request_data.fetch_request_context_type, filter_->appcache_service(),
-      child_id, route_id, std::move(handler));
+  // PlzNavigate: do not add ResourceThrottles for main resource requests from
+  // the renderer.  Decisions about the navigation should have been done in the
+  // initial request.
+  if (IsBrowserSideNavigationEnabled() &&
+      IsResourceTypeFrame(request_data.resource_type)) {
+    DCHECK(request->url().SchemeIs(url::kBlobScheme));
+    return handler;
+  }
+
+  return AddStandardHandlers(request, request_data.resource_type,
+                             resource_context,
+                             request_data.fetch_request_context_type,
+                             requester_info_->appcache_service(), child_id,
+                             route_id, std::move(handler));
 }
 
 std::unique_ptr<ResourceHandler>
 ResourceDispatcherHostImpl::AddStandardHandlers(
     net::URLRequest* request,
     ResourceType resource_type,
     ResourceContext* resource_context,
     RequestContextType fetch_request_context_type,
     AppCacheService* appcache_service,
     int child_id,
     int route_id,
     std::unique_ptr<ResourceHandler> handler) {
-  // PlzNavigate: do not add ResourceThrottles for main resource requests from
-  // the renderer.  Decisions about the navigation should have been done in the
-  // initial request.
-  bool is_renderer =
-      filter_ ? (filter_->process_type() == PROCESS_TYPE_RENDERER) : false;
-  if (is_renderer && IsBrowserSideNavigationEnabled() &&
-      IsResourceTypeFrame(resource_type)) {
-    DCHECK(request->url().SchemeIs(url::kBlobScheme));
-    return handler;
-  }
-
   // The InterceptingResourceHandler will replace its next handler with an
   // appropriate one based on the MIME type of the response if needed. It
   // should be placed at the end of the chain, just before |handler|.
   handler.reset(new InterceptingResourceHandler(std::move(handler), request));
   InterceptingResourceHandler* intercepting_handler =
       static_cast<InterceptingResourceHandler*>(handler.get());
 
   ScopedVector<ResourceThrottle> throttles;
 
   // Add a NavigationResourceThrottle for navigations.
@@ skipping 58 matching lines @@
       fetch_request_context_type));
 
   // Add the pre mime sniffing throttles.
   handler.reset(new ThrottlingResourceHandler(
       std::move(handler), request, std::move(pre_mime_sniffing_throttles)));
 
   return handler;
 }
 
 void ResourceDispatcherHostImpl::OnReleaseDownloadedFile(int request_id) {
-  UnregisterDownloadedTempFile(filter_->child_id(), request_id);
+  DCHECK(requester_info_->IsRenderer());
+  UnregisterDownloadedTempFile(requester_info_->child_id(), request_id);
 }
 
 void ResourceDispatcherHostImpl::OnDidChangePriority(
     int request_id,
     net::RequestPriority new_priority,
     int intra_priority_value) {
-  ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
+  DCHECK(requester_info_->IsRenderer());
+  ResourceLoader* loader = GetLoader(requester_info_->child_id(), request_id);
   // The request may go away before processing this message, so |loader| can
   // legitimately be null.
   if (!loader)
     return;
 
   scheduler_->ReprioritizeRequest(loader->request(), new_priority,
                                   intra_priority_value);
 }
 
 void ResourceDispatcherHostImpl::RegisterDownloadedTempFile(
@@ skipping 33 matching lines @@
 }
 
 bool ResourceDispatcherHostImpl::Send(IPC::Message* message) {
   delete message;
   return false;
 }
 
 // Note that this cancel is subtly different from the other
 // CancelRequest methods in this file, which also tear down the loader.
 void ResourceDispatcherHostImpl::OnCancelRequest(int request_id) {
-  int child_id = filter_->child_id();
+  DCHECK(requester_info_->IsRenderer());
+  int child_id = requester_info_->child_id();
 
   // When the old renderer dies, it sends a message to us to cancel its
   // requests.
   if (IsTransferredNavigation(GlobalRequestID(child_id, request_id)))
     return;
 
   ResourceLoader* loader = GetLoader(child_id, request_id);
 
   // It is possible that the request has been completed and removed from the
   // loader queue but the client has not processed the request completed message
   // before issuing a cancel. This happens frequently for beacons which are
   // canceled in the response received handler.
   if (!loader)
     return;
 
   loader->CancelRequest(true);
 }
 
 ResourceRequestInfoImpl* ResourceDispatcherHostImpl::CreateRequestInfo(
     int child_id,
     int render_view_route_id,
     int render_frame_route_id,
     bool download,
     ResourceContext* context) {
   return new ResourceRequestInfoImpl(
-      PROCESS_TYPE_RENDERER, child_id, render_view_route_id,
+      ResourceRequesterInfo::CreateForDownloadOrPageSave(child_id),
+      render_view_route_id,
       -1,  // frame_tree_node_id
       0, MakeRequestID(), render_frame_route_id,
       false,  // is_main_frame
       false,  // parent_is_main_frame
       RESOURCE_TYPE_SUB_RESOURCE, ui::PAGE_TRANSITION_LINK,
       false,     // should_replace_current_entry
       download,  // is_download
       false,     // is_stream
       download,  // allow_download
       false,     // has_user_gesture
       false,     // enable_load_timing
       false,     // enable_upload_progress
       false,     // do_not_prompt_for_login
       blink::WebReferrerPolicyDefault, blink::WebPageVisibilityStateVisible,
       context,
-      base::WeakPtr<ResourceMessageFilter>(),  // filter
-      false,                                   // report_raw_headers
-      true,                                    // is_async
-      false,                                   // is_using_lofi
-      std::string(),                           // original_headers
-      nullptr,                                 // body
-      false);                                  // initiated_in_secure_context
+      false,          // report_raw_headers
+      true,           // is_async
+      false,          // is_using_lofi
+      std::string(),  // original_headers
+      nullptr,        // body
+      false);         // initiated_in_secure_context
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostCreated(int child_id,
                                                          int route_id) {
   scheduler_->OnClientCreated(child_id, route_id);
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostDeleted(int child_id,
                                                          int route_id) {
   scheduler_->OnClientDeleted(child_id, route_id);
@@ skipping 319 matching lines @@
         body, blob_context,
         nullptr,  // file_system_context
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get()));
   }
 
   // Make extra info and read footer (contains request ID).
   //
   // TODO(davidben): Associate the request with the FrameTreeNode and/or tab so
   // that IO thread -> UI thread hops will work.
   ResourceRequestInfoImpl* extra_info = new ResourceRequestInfoImpl(
-      PROCESS_TYPE_BROWSER,
-      -1,  // child_id
+      ResourceRequesterInfo::CreateForBrowserSideNavigation(
+          service_worker_handle_core
+              ? service_worker_handle_core->context_wrapper()
+              : scoped_refptr<ServiceWorkerContextWrapper>()),
       -1,  // route_id
       info.frame_tree_node_id,
       -1,  // request_data.origin_pid,
       MakeRequestID(),
       -1,  // request_data.render_frame_id,
       info.is_main_frame, info.parent_is_main_frame, resource_type,
       info.common_params.transition,
       // should_replace_current_entry. This was only maintained at layer for
       // request transfers and isn't needed for browser-side navigations.
       false,
       false,  // is download
       false,  // is stream
       info.common_params.allow_download, info.begin_params.has_user_gesture,
       true,   // enable_load_timing
       false,  // enable_upload_progress
       false,  // do_not_prompt_for_login
       info.common_params.referrer.policy,
       // TODO(davidben): This is only used for prerenders. Replace
       // is_showing with something for that. Or maybe it just comes from the
       // same mechanism as the cookie one.
       blink::WebPageVisibilityStateVisible, resource_context,
-      base::WeakPtr<ResourceMessageFilter>(),  // filter
       info.report_raw_headers,
-      true,   // is_async
+      true,  // is_async
       IsUsingLoFi(info.common_params.lofi_state, delegate_, *new_request,
                   resource_context, info.is_main_frame),
       // The original_headers field is for stale-while-revalidate but the
       // feature doesn't work with PlzNavigate, so it's just a placeholder
       // here.
       // TODO(ricea): Make the feature work with stale-while-revalidate
       // and clean this up.
       std::string(),  // original_headers
       info.common_params.post_data,
       // TODO(mek): Currently initiated_in_secure_context is only used for
       // subresource requests, so it doesn't matter what value it gets here.
       // If in the future this changes this should be updated to somehow get a
       // meaningful value.
       false);  // initiated_in_secure_context
   extra_info->set_navigation_ui_data(std::move(navigation_ui_data));
 
-  if (service_worker_handle_core) {
-    extra_info->set_service_worker_context(
-        service_worker_handle_core->context_wrapper());
-  }
-
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
 
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(),
         blob_context->GetBlobDataFromPublicURL(new_request->url()));
   }
@@ skipping 40 matching lines @@
     const GlobalFrameRoutingId& global_routing_id) {
   CancelRequestsForRoute(global_routing_id);
 }
 
 void ResourceDispatcherHostImpl::OnRequestResourceWithMojo(
     int routing_id,
     int request_id,
     const ResourceRequest& request,
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client,
-    ResourceMessageFilter* filter) {
-  filter_ = filter;
+    std::unique_ptr<ResourceRequesterInfo> requester_info) {
+  requester_info_ = std::move(requester_info);
   OnRequestResourceInternal(routing_id, request_id, request,
                             std::move(mojo_request),
                             std::move(url_loader_client));
-  filter_ = nullptr;
+  requester_info_.reset();
 }
 
 void ResourceDispatcherHostImpl::OnSyncLoadWithMojo(
     int routing_id,
     int request_id,
     const ResourceRequest& request_data,
-    ResourceMessageFilter* filter,
+    std::unique_ptr<ResourceRequesterInfo> requester_info,
     const SyncLoadResultCallback& result_handler) {
-  filter_ = filter;
+  requester_info_ = std::move(requester_info);
   BeginRequest(request_id, request_data, result_handler, routing_id,
                nullptr, nullptr);
-  filter_ = nullptr;
+  requester_info_.reset();
 }
 
 // static
 int ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
     net::URLRequest* request) {
   // The following fields should be a minor size contribution (experimentally
   // on the order of 100). However since they are variable length, it could
   // in theory be a sizeable contribution.
   int strings_cost = request->extra_request_headers().ToString().size() +
                      request->original_url().spec().size() +
@@ skipping 355 matching lines @@
   DCHECK(it->second->HasObserver(delegate));
   it->second->RemoveObserver(delegate);
   if (!it->second->might_have_observers()) {
     delete it->second;
     delegate_map_.erase(it);
   }
 }
 
 int ResourceDispatcherHostImpl::BuildLoadFlagsForRequest(
     const ResourceRequest& request_data,
-    int child_id,
     bool is_sync_load) {
   int load_flags = request_data.load_flags;
 
   // Although EV status is irrelevant to sub-frames and sub-resources, we have
   // to perform EV certificate verification on all resources because an HTTP
   // keep-alive connection created to load a sub-frame or a sub-resource could
   // be reused to load a main frame.
   load_flags |= net::LOAD_VERIFY_EV_CERT;
   if (request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME) {
     load_flags |= net::LOAD_MAIN_FRAME_DEPRECATED;
   } else if (request_data.resource_type == RESOURCE_TYPE_PREFETCH) {
     load_flags |= net::LOAD_PREFETCH;
   }
 
   if (is_sync_load)
     load_flags |= net::LOAD_IGNORE_LIMITS;
 
   return load_flags;
 }
 
 bool ResourceDispatcherHostImpl::ShouldServiceRequest(
-    int process_type,
     int child_id,
     const ResourceRequest& request_data,
     const net::HttpRequestHeaders& headers,
-    ResourceMessageFilter* filter,
+    ResourceRequesterInfo* requester_info,
     ResourceContext* resource_context) {
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
   // Check if the renderer is permitted to request the requested URL.
   if (!policy->CanRequestURL(child_id, request_data.url)) {
     VLOG(1) << "Denied unauthorized request for "
             << request_data.url.possibly_invalid_spec();
     return false;
   }
 
   // Check if the renderer is using an illegal Origin header.  If so, kill it.
   std::string origin_string;
   bool has_origin =
       headers.GetHeader("Origin", &origin_string) && origin_string != "null";
   if (has_origin) {
     GURL origin(origin_string);
     if (!policy->CanSetAsOriginHeader(child_id, origin)) {
       VLOG(1) << "Killed renderer for illegal origin: " << origin_string;
-      bad_message::ReceivedBadMessage(filter, bad_message::RDH_ILLEGAL_ORIGIN);
+      bad_message::ReceivedBadMessage(requester_info->filter(),
+                                      bad_message::RDH_ILLEGAL_ORIGIN);
       return false;
     }
   }
 
   // Check if the renderer is permitted to upload the requested files.
   if (request_data.request_body.get()) {
     const std::vector<ResourceRequestBodyImpl::Element>* uploads =
         request_data.request_body->elements();
     std::vector<ResourceRequestBodyImpl::Element>::const_iterator iter;
     for (iter = uploads->begin(); iter != uploads->end(); ++iter) {
       if (iter->type() == ResourceRequestBodyImpl::Element::TYPE_FILE &&
           !policy->CanReadFile(child_id, iter->path())) {
         NOTREACHED() << "Denied unauthorized upload of "
                      << iter->path().value();
         return false;
       }
       if (iter->type() ==
           ResourceRequestBodyImpl::Element::TYPE_FILE_FILESYSTEM) {
         storage::FileSystemURL url =
-            filter->file_system_context()->CrackURL(iter->filesystem_url());
+            requester_info->file_system_context()->CrackURL(
+                iter->filesystem_url());
         if (!policy->CanReadFileSystemFile(child_id, url)) {
           NOTREACHED() << "Denied unauthorized upload of "
                        << iter->filesystem_url().spec();
           return false;
         }
       }
     }
   }
   return true;
 }
@@ skipping 14 matching lines @@
                                  &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content