PlzNavigate: Move navigation-level mixed content checks to the browser.

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 1615 matching lines @@
     // 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, filter_->appcache_service(),
-                             child_id, route_id, std::move(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));
 }
 
 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.
   if (IsBrowserSideNavigationEnabled() && IsResourceTypeFrame(resource_type) &&
       child_id != -1) {
     DCHECK(request->url().SchemeIs(url::kBlobScheme));
     return handler;
   }
 
   PluginService* plugin_service = nullptr;
 #if defined(ENABLE_PLUGINS)
   plugin_service = PluginService::GetInstance();
 #endif
   // Insert a buffered event handler before the actual one.
   handler.reset(new MimeTypeResourceHandler(std::move(handler), this,
                                             plugin_service, request));
 
   ScopedVector<ResourceThrottle> throttles;
 
   // Add a NavigationResourceThrottle for navigations.
   // PlzNavigate: the throttle is unnecessary as communication with the UI
   // thread is handled by the NavigationURLloader.
-  if (!IsBrowserSideNavigationEnabled() && IsResourceTypeFrame(resource_type))
-    throttles.push_back(new NavigationResourceThrottle(request, delegate()));
+  if (!IsBrowserSideNavigationEnabled() && IsResourceTypeFrame(resource_type)) {
+    throttles.push_back(new NavigationResourceThrottle(
+        request, delegate(), fetch_request_context_type));
+  }
 
   if (delegate_) {
     delegate_->RequestBeginning(request,
                                 resource_context,
                                 appcache_service,
                                 resource_type,
                                 &throttles);
   }
 
   if (request->has_upload()) {
@@ skipping 562 matching lines @@
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(),
         blob_context->GetBlobDataFromPublicURL(new_request->url()));
   }
 
   // TODO(davidben): Attach AppCacheInterceptor.
 
   std::unique_ptr<ResourceHandler> handler(
       new NavigationResourceHandler(new_request.get(), loader, delegate()));
 
+  // TODO(carlosk): set the RequestContextType in a more correct way, if needed.
+  // Source of inspiration: determineRequestContextFromNavigationType in
+  // FrameLoader.cpp.
   // TODO(davidben): Pass in the appropriate appcache_service. Also fix the
   // dependency on child_id/route_id. Those are used by the ResourceScheduler;
   // currently it's a no-op.
-  handler =
-      AddStandardHandlers(new_request.get(), resource_type, resource_context,
-                          nullptr,  // appcache_service
-                          -1,       // child_id
-                          -1,       // route_id
-                          std::move(handler));
+  handler = AddStandardHandlers(new_request.get(), resource_type,
+                                resource_context, REQUEST_CONTEXT_TYPE_LOCATION,
+                                nullptr,  // appcache_service
+                                -1,       // child_id
+                                -1,       // route_id
+                                std::move(handler));
 
   BeginRequestInternal(std::move(new_request), std::move(handler));
 }
 
 void ResourceDispatcherHostImpl::EnableStaleWhileRevalidateForTesting() {
   if (!async_revalidation_manager_)
     async_revalidation_manager_.reset(new AsyncRevalidationManager);
 }
 
 void ResourceDispatcherHostImpl::SetLoaderDelegate(
@@ skipping 321 matching lines @@
   ssl.cert_id = GetCertStore()->StoreCert(ssl_info.cert.get(), child_id);
   response->head.security_info = SerializeSecurityInfo(ssl);
 }
 
 CertStore* ResourceDispatcherHostImpl::GetCertStore() {
   return cert_store_for_testing_ ? cert_store_for_testing_
                                  : CertStore::GetInstance();
 }
 
 }  // namespace content