Create NavigationHandles for interstitials if needed

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/navigator.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/loader/navigation_resource_handler.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/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 "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;
+
 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));
 }
 
+// Returns the NavigationHandle to use for a navigation in the frame specified
+// by |render_process_id| and |render_frame_host_id|. If not found, |callback|
+// will be invoked to cancel the request.
+//
+// Note: in unit test |callback| may be invoked with a value of proceed if no
+// handle is found. This happens when
+// NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing is
+// called with a value of true.
+NavigationHandleImpl* FindNavigationHandle(
+    int render_process_id,
+    int render_frame_host_id,
+    const UIChecksPerformedCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (g_ui_checks_always_succeed) {
+    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+    return nullptr;
+  }
+
+  RenderFrameHostImpl* render_frame_host =
+      RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
+  if (!render_frame_host) {
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
+    return nullptr;
+  }
+
+  NavigationHandleImpl* navigation_handle =
+      render_frame_host->frame_tree_node()
+          ->navigator()
+          ->GetNavigationHandleForFrameHost(render_frame_host);
+  if (!navigation_handle) {
+    SendCheckResultToIOThread(callback, NavigationThrottle::CANCEL);
+    return nullptr;
+  }
+  return navigation_handle;
+}
+
 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 (!render_frame_host) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+  NavigationHandleImpl* navigation_handle =
+      FindNavigationHandle(render_process_id, render_frame_host_id, callback);
+  if (!navigation_handle)
     return;
-  }
-
-  NavigationHandleImpl* navigation_handle =
-      render_frame_host->navigation_handle();
-  if (!navigation_handle) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
-    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 (!render_frame_host) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+  NavigationHandleImpl* navigation_handle =
+      FindNavigationHandle(render_process_id, render_frame_host_id, callback);
+  if (!navigation_handle)
     return;
-  }
-
-  NavigationHandleImpl* navigation_handle =
-      render_frame_host->navigation_handle();
-  if (!navigation_handle) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
-    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,
     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 (!render_frame_host) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
+  NavigationHandleImpl* navigation_handle =
+      FindNavigationHandle(render_process_id, render_frame_host_id, callback);
+  if (!navigation_handle)
     return;
-  }
-
-  NavigationHandleImpl* navigation_handle =
-      render_frame_host->navigation_handle();
-  if (!navigation_handle) {
-    SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
-    return;
-  }
 
   if (navigation_data)
     navigation_handle->set_navigation_data(std::move(navigation_data));
 
+  RenderFrameHostImpl* render_frame_host =
+      RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
+  DCHECK(render_frame_host);
   navigation_handle->WillProcessResponse(
       render_frame_host, headers, ssl_status,
       base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 }  // namespace
 
 NavigationResourceThrottle::NavigationResourceThrottle(
     net::URLRequest* request,
     ResourceDispatcherHostDelegate* resource_dispatcher_host_delegate,
@@ skipping 121 matching lines @@
       base::Bind(&WillProcessResponseOnUIThread, callback, render_process_id,
                  render_frame_id, response_headers, ssl_status,
                  base::Passed(&cloned_data)));
   *defer = true;
 }
 
 const char* NavigationResourceThrottle::GetNameForLogging() const {
   return "NavigationResourceThrottle";
 }
 
+void NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(
+    bool ui_checks_always_succeed) {
+  g_ui_checks_always_succeed = ui_checks_always_succeed;
+}
+
 void NavigationResourceThrottle::OnUIChecksPerformed(
     NavigationThrottle::ThrottleCheckResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   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();
   }
 }
 
 }  // namespace content