Merge CrossSiteResourceHandler and NavigationResourceThrottle

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"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_loader.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_data.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/ssl_status.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 "ui/base/page_transition_types.h"
 
 namespace content {
 
 namespace {
+
+// Used in unit tests to make UI checks succeed even if there is no
+// NavigationHandle and to transfer all navigations.
+bool g_ui_checks_always_succeed = false;
+bool g_force_transfer = false;
+
 typedef base::Callback<void(NavigationThrottle::ThrottleCheckResult)>
     UIChecksPerformedCallback;
 
 void SendCheckResultToIOThread(UIChecksPerformedCallback callback,
                                NavigationThrottle::ThrottleCheckResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_NE(result, NavigationThrottle::DEFER);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, result));
 }
 
 void CheckWillStartRequestOnUIThread(
     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) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
+  if (g_ui_checks_always_succeed) {
+    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    return;
+  }
+
   if (!render_frame_host) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
     return;
   }
 
   NavigationHandleImpl* navigation_handle =
       render_frame_host->navigation_handle();
   if (!navigation_handle) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
     return;
   }
 
   navigation_handle->WillStartRequest(
       method, resource_request_body, sanitized_referrer, has_user_gesture,
       transition, is_external_protocol, request_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,
     bool new_is_external_protocol,
     scoped_refptr<net::HttpResponseHeaders> headers) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
+  if (g_ui_checks_always_succeed) {
+    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    return;
+  }
+
   if (!render_frame_host) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
     return;
   }
 
   NavigationHandleImpl* navigation_handle =
       render_frame_host->navigation_handle();
   if (!navigation_handle) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
     return;
   }
 
   GURL new_validated_url(new_url);
   RenderProcessHost::FromID(render_process_id)
       ->FilterURL(false, &new_validated_url);
   navigation_handle->WillRedirectRequest(
       new_validated_url, new_method, new_referrer_url, new_is_external_protocol,
       headers, base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 void WillProcessResponseOnUIThread(
     UIChecksPerformedCallback callback,
     int render_process_id,
     int render_frame_host_id,
     scoped_refptr<net::HttpResponseHeaders> headers,
     const SSLStatus& ssl_status,
+    const GlobalRequestID& request_id,
+    bool should_replace_current_entry,
+    bool is_download,
+    bool is_stream,
+    const base::Closure& transfer_callback,
     std::unique_ptr<NavigationData> navigation_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
+  if (g_force_transfer) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, transfer_callback);
+  }
+
+  if (g_ui_checks_always_succeed) {
+    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    return;
+  }
+
   if (!render_frame_host) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
     return;
   }
 
   NavigationHandleImpl* navigation_handle =
       render_frame_host->navigation_handle();
   if (!navigation_handle) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
     return;
   }
 
   if (navigation_data)
     navigation_handle->set_navigation_data(std::move(navigation_data));
 
   navigation_handle->WillProcessResponse(
-      render_frame_host, headers, ssl_status,
+      render_frame_host, headers, 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)
     : request_(request),
       resource_dispatcher_host_delegate_(resource_dispatcher_host_delegate),
       request_context_type_(request_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_);
   if (!info)
     return;
@@ skipping 58 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CheckWillRedirectRequestOnUIThread, callback,
                  render_process_id, render_frame_id, redirect_info.new_url,
                  redirect_info.new_method, GURL(redirect_info.new_referrer),
                  new_is_external_protocol, response_headers));
   *defer = true;
 }
 
 void NavigationResourceThrottle::WillProcessResponse(bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
+  const ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(request_);
   if (!info)
     return;
 
   int render_process_id, render_frame_id;
   if (!info->GetAssociatedRenderFrame(&render_process_id, &render_frame_id))
     return;
 
   // Send a copy of the response headers to the NavigationHandle on the UI
   // thread.
   scoped_refptr<net::HttpResponseHeaders> response_headers;
   if (request_->response_headers()) {
     response_headers = new net::HttpResponseHeaders(
         request_->response_headers()->raw_headers());
   }
 
   std::unique_ptr<NavigationData> cloned_data;
   if (resource_dispatcher_host_delegate_) {
     // Ask the embedder for a NavigationData instance.
     NavigationData* navigation_data =
         resource_dispatcher_host_delegate_->GetNavigationData(request_);
 
     // Clone the embedder's NavigationData before moving it to the UI thread.
     if (navigation_data)
       cloned_data = navigation_data->Clone();
   }
 
   UIChecksPerformedCallback callback =
       base::Bind(&NavigationResourceThrottle::OnUIChecksPerformed,
                  weak_ptr_factory_.GetWeakPtr());
+  base::Closure transfer_callback =
+      base::Bind(&NavigationResourceThrottle::InitiateTransfer,
+                 weak_ptr_factory_.GetWeakPtr());
 
   SSLStatus ssl_status;
   if (request_->ssl_info().cert.get()) {
     ResourceLoader::GetSSLStatusForRequest(
         request_->url(), request_->ssl_info(), info->GetChildID(), &ssl_status);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WillProcessResponseOnUIThread, callback, render_process_id,
                  render_frame_id, response_headers, ssl_status,
+                 info->GetGlobalRequestID(),
+                 info->should_replace_current_entry(), info->IsDownload(),
+                 info->is_stream(), transfer_callback,
                  base::Passed(&cloned_data)));
   *defer = true;
 }
 
 const char* NavigationResourceThrottle::GetNameForLogging() const {
   return "NavigationResourceThrottle";
 }
 
+void NavigationResourceThrottle::SetUIChecksAlwaysSuccedForTesting(
+    bool ui_checks_always_succeed) {
+  g_ui_checks_always_succeed = ui_checks_always_succeed;
+}
+
+void NavigationResourceThrottle::SetForceTransferForTesting(
+    bool force_transfer) {
+  g_force_transfer = force_transfer;
+}
+
 void NavigationResourceThrottle::OnUIChecksPerformed(
     NavigationThrottle::ThrottleCheckResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_NE(NavigationThrottle::DEFER, result);
+  if (in_cross_site_transition_) {
+    on_transfer_done_result_ = result;
+    return;
+  }
+
   if (result == NavigationThrottle::CANCEL_AND_IGNORE) {
     controller()->CancelAndIgnore();
   } else if (result == NavigationThrottle::CANCEL) {
     controller()->Cancel();
   } else if (result == NavigationThrottle::BLOCK_REQUEST) {
     controller()->CancelWithError(net::ERR_BLOCKED_BY_CLIENT);
   } else {
     controller()->Resume();
   }
 }
 
+void NavigationResourceThrottle::InitiateTransfer() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  in_cross_site_transition_ = true;
+  ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(request_);
+  ResourceDispatcherHostImpl::Get()->MarkAsTransferredNavigation(
+      info->GetGlobalRequestID(),
+      base::Bind(&NavigationResourceThrottle::OnTransferComplete,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void NavigationResourceThrottle::OnTransferComplete() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(in_cross_site_transition_);
+  in_cross_site_transition_ = false;
+
+  // If the results of the checks on the UI thread are known, unblock the

[nasko, 2016/09/09 23:30:27]

Is it guaranteed that the result from the UI thread will never be DEFER?

[clamy, 2016/09/12 15:31:37]

Yes. See the DCHECK line 331 (UI thread binds OnUIChecksPerformed directly).

+  // 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