Merge CrossSiteResourceHandler and NavigationResourceThrottle

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 27 matching lines @@
 #include "content/browser/bad_message.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/cert_store_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/loader/async_resource_handler.h"
 #include "content/browser/loader/async_revalidation_manager.h"
-#include "content/browser/loader/cross_site_resource_handler.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/intercepting_resource_handler.h"
 #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"
@@ skipping 1084 matching lines @@
 
   // 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,
                           request_data.origin_pid, request_id,
                           filter_->GetWeakPtr());
 
   // If a certificate is stored with the ResourceResponse, it has to be
   // updated to be associated with the new process.
-  if (loader->transferring_response()) {
-    UpdateResponseCertificateForTransfer(loader->transferring_response(),
+  if (loader->response()) {
+    UpdateResponseCertificateForTransfer(loader->response(),
                                          loader->request(),
                                          info);
   }
 
   // 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);
@@ skipping 30 matching lines @@
       ServiceWorkerRequestHandler::GetHandler(loader_ptr->request());
   if (handler) {
     if (!handler->SanityCheckIsSameContext(filter_->service_worker_context())) {
       bad_message::ReceivedBadMessage(
           filter_, bad_message::RDHI_WRONG_STORAGE_PARTITION);
     } else {
       handler->CompleteCrossSiteTransfer(
           child_id, request_data.service_worker_provider_id);
     }
   }
-
-  // We should have a CrossSiteResourceHandler to finish the transfer.
-  DCHECK(info->cross_site_handler());
 }
 
 void ResourceDispatcherHostImpl::BeginRequest(
     int request_id,
     const ResourceRequest& request_data,
     IPC::Message* sync_result,  // only valid for sync
     int route_id,
     mojo::InterfaceRequest<mojom::URLLoader> mojo_request,
     mojom::URLLoaderClientPtr url_loader_client) {
   int process_type = filter_->process_type();
@@ skipping 370 matching lines @@
   }
 
   // Prefetches and <a ping> requests outlive their child process.
   if (!sync_result && IsDetachableResourceType(request_data.resource_type)) {
     handler.reset(new DetachableResourceHandler(
         request,
         base::TimeDelta::FromMilliseconds(kDefaultDetachableCancelDelayMs),
         std::move(handler)));
   }
 
-  // PlzNavigate: If using --enable-browser-side-navigation, the
-  // CrossSiteResourceHandler is not needed. This codepath is not used for the
-  // actual navigation request, but only the subsequent blob URL load. This does
-  // not require request transfers.
-  if (!IsBrowserSideNavigationEnabled()) {
-    // Install a CrossSiteResourceHandler for all main frame requests. This will
-    // check whether a transfer is required and, if so, pause for the UI thread
-    // to drive the transfer.
-    bool is_swappable_navigation =
-        request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME;
-    // If out-of-process iframes are possible, then all subframe requests need
-    // to go through the CrossSiteResourceHandler to enforce the site isolation
-    // policy.
-    if (!is_swappable_navigation &&
-        SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
-      is_swappable_navigation =
-          request_data.resource_type == RESOURCE_TYPE_SUB_FRAME;
-    }
-    if (is_swappable_navigation && process_type == PROCESS_TYPE_RENDERER)
-      handler.reset(new CrossSiteResourceHandler(std::move(handler), request));
-  }
-
   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));
 }
 
 std::unique_ptr<ResourceHandler>
 ResourceDispatcherHostImpl::AddStandardHandlers(
     net::URLRequest* request,
     ResourceType resource_type,
@@ skipping 224 matching lines @@
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostSetIsLoading(int child_id,
                                                               int route_id,
                                                               bool is_loading) {
   scheduler_->OnLoadingStateChanged(child_id, route_id, !is_loading);
 }
 
 void ResourceDispatcherHostImpl::MarkAsTransferredNavigation(
     const GlobalRequestID& id,
-    const scoped_refptr<ResourceResponse>& response) {
-  GetLoader(id)->MarkAsTransferring(response);
+    const base::Closure& on_transfer_complete_callback) {
+  GetLoader(id)->MarkAsTransferring(on_transfer_complete_callback);
 }
 
 void ResourceDispatcherHostImpl::CancelTransferringNavigation(
     const GlobalRequestID& id) {
   // Request should still exist and be in the middle of a transfer.
   DCHECK(IsTransferredNavigation(id));
   RemovePendingRequest(id.child_id, id.request_id);
 }
 
 void ResourceDispatcherHostImpl::ResumeDeferredNavigation(
@@ skipping 861 matching lines @@
         request_info->GetRouteID(), is_content_initiated, true, &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content