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 39 matching lines @@
 #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_loader.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/resource_scheduler.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/upload_data_stream.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cookies/cookie_monster.h"
@@ skipping 116 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 219 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 365 matching lines @@
   }
   for (const auto& routing_id : ids) {
     CancelBlockedRequestsForRoute(routing_id);
   }
 
   scheduler_.reset();
 }
 
 bool ResourceDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& message,
-    ResourceMessageFilter* filter) {
+    const ResourceRequesterInfo* requester_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  filter_ = filter;
+
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ResourceDispatcherHostImpl, message)
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(ResourceDispatcherHostImpl, message,
+                                   requester_info)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ResourceHostMsg_SyncLoad, OnSyncLoad)
+    IPC_MESSAGE_HANDLER_WITH_PARAM_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;
   return handled;
 }
 
 void ResourceDispatcherHostImpl::OnRequestResource(
+    const ResourceRequesterInfo* requester_info,
     int routing_id,
     int request_id,
     const ResourceRequest& request_data) {
-  OnRequestResourceInternal(routing_id, request_id, request_data, nullptr,
-                            nullptr);
+  OnRequestResourceInternal(requester_info, routing_id, request_id,
+                            request_data, nullptr, nullptr);
 }
 
 void ResourceDispatcherHostImpl::OnRequestResourceInternal(
+    const ResourceRequesterInfo* requester_info,
     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));
+  BeginRequest(requester_info, 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)));
-  BeginRequest(request_id, request_data, callback, sync_result->routing_id(),
-               nullptr, nullptr);
+void ResourceDispatcherHostImpl::OnSyncLoad(
+    const ResourceRequesterInfo* requester_info,
+    int request_id,
+    const ResourceRequest& request_data,
+    IPC::Message* sync_result) {
+  SyncLoadResultCallback callback =
+      base::Bind(&HandleSyncLoadResult, requester_info->filter()->GetWeakPtr(),
+                 base::Passed(WrapUnique(sync_result)));
+  BeginRequest(requester_info, 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,
+    const ResourceRequesterInfo* requester_info,
     int route_id,
     int request_id,
     const ResourceRequest& request_data,
     LoaderMap::iterator iter) {
+  DCHECK(requester_info->IsRenderer());
+  const int child_id = requester_info->child_id();
   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);
 
   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(
+    const ResourceRequesterInfo* requester_info,
     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,
-                           request_data, it);
+  UpdateRequestForTransfer(requester_info, route_id, request_id, request_data,
+                           it);
   pending_loader->CompleteTransfer();
 }
 
 void ResourceDispatcherHostImpl::BeginRequest(
+    const ResourceRequesterInfo* requester_info,
     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
-       && !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);
+    CompleteTransfer(requester_info, 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,
+                            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()) {
       HeaderInterceptorInfo& interceptor_info = index->second;
 
       bool call_interceptor = true;
       if (!interceptor_info.starts_with.empty()) {
         call_interceptor =
             base::StartsWith(it.value(), interceptor_info.starts_with,
                              base::CompareCase::INSENSITIVE_ASCII);
       }
       if (call_interceptor) {
         interceptor_info.interceptor.Run(
             it.name(), it.value(), child_id, resource_context,
             base::Bind(&ResourceDispatcherHostImpl::ContinuePendingBeginRequest,
-                       base::Unretained(this), request_id, request_data,
-                       sync_result_handler, route_id, headers,
+                       base::Unretained(this),
+                       base::Passed(requester_info->clone()), request_id,
+                       request_data, sync_result_handler, route_id, headers,
                        base::Passed(std::move(mojo_request)),
                        base::Passed(std::move(url_loader_client))));
         return;
       }
     }
   }
-  ContinuePendingBeginRequest(request_id, request_data, sync_result_handler,
-                              route_id, headers, std::move(mojo_request),
+  ContinuePendingBeginRequest(requester_info->clone(), request_id, request_data,

[mmenke, 2016/11/17 16:27:19]

Should we make requester_info refcounted, and pass it around as a
scoped_refptr<const RequestorInfo>?  In general, I'm against refcounting, but
given that this is an effectively constant class, seems reasonable.  Doesn't
save us a huGe amount, though it does mean we don't need clone() calls.

[horo, 2016/11/17 17:50:27]

Done.

+                              sync_result_handler, route_id, headers,
+                              std::move(mojo_request),
                               std::move(url_loader_client), true, 0);
 }
 
 void ResourceDispatcherHostImpl::ContinuePendingBeginRequest(
+    std::unique_ptr<ResourceRequesterInfo> requester_info,
     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,
+      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,
+      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)));
+      requester_info.get(), 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(
+    const ResourceRequesterInfo* requester_info,
     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 57 matching lines @@
       std::move(handler), this, plugin_service, intercepting_handler, request,
       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);
+void ResourceDispatcherHostImpl::OnReleaseDownloadedFile(
+    const ResourceRequesterInfo* requester_info,
+    int request_id) {
+  UnregisterDownloadedTempFile(requester_info->child_id(), request_id);
 }
 
 void ResourceDispatcherHostImpl::OnDidChangePriority(
+    const ResourceRequesterInfo* requester_info,
     int request_id,
     net::RequestPriority new_priority,
     int intra_priority_value) {
-  ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
+  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 30 matching lines @@
 
   // Note that we don't remove the security bits here. This will be done
   // when all file refs are deleted (see RegisterDownloadedTempFile).
 }
 
 bool ResourceDispatcherHostImpl::Send(IPC::Message* message) {
   delete message;
   return false;
 }
 
-void ResourceDispatcherHostImpl::OnCancelRequest(int request_id) {
-  CancelRequestFromRenderer(GlobalRequestID(filter_->child_id(), request_id));
+void ResourceDispatcherHostImpl::OnCancelRequest(
+    const ResourceRequesterInfo* requester_info,
+    int request_id) {
+  CancelRequestFromRenderer(
+      GlobalRequestID(requester_info->child_id(), request_id));
 }
 
 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 35 matching lines @@
     LoaderDelegate* loader_delegate) {
   loader_delegate_ = loader_delegate;
 }
 
 void ResourceDispatcherHostImpl::OnRenderFrameDeleted(
     const GlobalFrameRoutingId& global_routing_id) {
   CancelRequestsForRoute(global_routing_id);
 }
 
 void ResourceDispatcherHostImpl::OnRequestResourceWithMojo(
+    const ResourceRequesterInfo* requester_info,
     int routing_id,
     int request_id,
     const ResourceRequest& request,
     mojom::URLLoaderAssociatedRequest mojo_request,
-    mojom::URLLoaderClientAssociatedPtr url_loader_client,
-    ResourceMessageFilter* filter) {
-  filter_ = filter;
-  OnRequestResourceInternal(routing_id, request_id, request,
+    mojom::URLLoaderClientAssociatedPtr url_loader_client) {
+  OnRequestResourceInternal(requester_info, routing_id, request_id, request,
                             std::move(mojo_request),
                             std::move(url_loader_client));
-  filter_ = nullptr;
 }
 
 void ResourceDispatcherHostImpl::OnSyncLoadWithMojo(
+    const ResourceRequesterInfo* requester_info,
     int routing_id,
     int request_id,
     const ResourceRequest& request_data,
-    ResourceMessageFilter* filter,
     const SyncLoadResultCallback& result_handler) {
-  filter_ = filter;
-  BeginRequest(request_id, request_data, result_handler, routing_id,
-               nullptr, nullptr);
-  filter_ = nullptr;
+  BeginRequest(requester_info, request_id, request_data, result_handler,
+               routing_id, nullptr, nullptr);
 }
 
 // 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 = 0;
   for (net::HttpRequestHeaders::Iterator it(request->extra_request_headers());
@@ skipping 378 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,
+    const 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