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

content/browser/loader/navigation_resource_throttle.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/loader/navigation_resource_throttle.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/navigation_data.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/ssl_status.h"
 #include "content/public/common/referrer.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory.h"
+#include "third_party/WebKit/public/platform/WebMixedContentContextType.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 
 namespace {
 
 // Used in unit tests to make UI thread checks succeed even if there is no
 // NavigationHandle.
 bool g_ui_checks_always_succeed = false;
 
@@ skipping 50 matching lines @@
     UIChecksPerformedCallback callback,
     int render_process_id,
     int render_frame_host_id,
     const std::string& method,
     const scoped_refptr<content::ResourceRequestBodyImpl>&
         resource_request_body,
     const Referrer& sanitized_referrer,
     bool has_user_gesture,
     ui::PageTransition transition,
     bool is_external_protocol,
-    RequestContextType request_context_type) {
+    RequestContextType request_context_type,
+    blink::WebMixedContentContextType mixed_content_context_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NavigationHandleImpl* navigation_handle =
       FindNavigationHandle(render_process_id, render_frame_host_id, callback);
   if (!navigation_handle)
     return;
 
   navigation_handle->WillStartRequest(
       method, resource_request_body, sanitized_referrer, has_user_gesture,
       transition, is_external_protocol, request_context_type,
+      mixed_content_context_type,
       base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 void CheckWillRedirectRequestOnUIThread(
     UIChecksPerformedCallback callback,
     int render_process_id,
     int render_frame_host_id,
     const GURL& new_url,
     const std::string& new_method,
     const GURL& new_referrer_url,
@@ skipping 49 matching lines @@
       render_frame_host, headers, connection_info, ssl_status, request_id,
       should_replace_current_entry, is_download, is_stream, transfer_callback,
       base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 }  // namespace
 
 NavigationResourceThrottle::NavigationResourceThrottle(
     net::URLRequest* request,
     ResourceDispatcherHostDelegate* resource_dispatcher_host_delegate,
-    RequestContextType request_context_type)
+    RequestContextType request_context_type,
+    blink::WebMixedContentContextType mixed_content_context_type)
     : request_(request),
       resource_dispatcher_host_delegate_(resource_dispatcher_host_delegate),
       request_context_type_(request_context_type),
+      mixed_content_context_type_(mixed_content_context_type),
       in_cross_site_transition_(false),
       on_transfer_done_result_(NavigationThrottle::DEFER),
       weak_ptr_factory_(this) {}
 
 NavigationResourceThrottle::~NavigationResourceThrottle() {}
 
 void NavigationResourceThrottle::WillStartRequest(bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
@@ skipping 12 matching lines @@
                  weak_ptr_factory_.GetWeakPtr());
   DCHECK(request_->method() == "POST" || request_->method() == "GET");
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CheckWillStartRequestOnUIThread, callback, render_process_id,
                  render_frame_id, request_->method(), info->body(),
                  Referrer::SanitizeForRequest(
                      request_->url(), Referrer(GURL(request_->referrer()),
                                                info->GetReferrerPolicy())),
                  info->HasUserGesture(), info->GetPageTransition(),
-                 is_external_protocol, request_context_type_));
+                 is_external_protocol, request_context_type_,
+                 mixed_content_context_type_));
   *defer = true;
 }
 
 void NavigationResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request_);
   if (!info)
     return;
@@ skipping 150 matching lines @@
 
   // If the results of the checks on the UI thread are known, unblock the
   // navigation. Otherwise, wait until the callback has executed.
   if (on_transfer_done_result_ != NavigationThrottle::DEFER) {
     OnUIChecksPerformed(on_transfer_done_result_);
     on_transfer_done_result_ = NavigationThrottle::DEFER;
   }
 }
 
 }  // namespace content