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 checks succeed even if there is no

[nasko, 2016/09/23 17:41:35]

nit: UI thread

[clamy, 2016/09/26 11:37:27]

Done.

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

[nasko, 2016/09/23 17:41:35]

nit: Combine with next line.

[clamy, 2016/09/26 11:37:27]

Done.

+// |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::SetUIChecksAlwaysSucceedForTesting is called with
+// a vlue of true.

[nasko, 2016/09/23 17:41:35]

nit: value

[clamy, 2016/09/26 11:37:27]

Done.

+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) {

[nasko, 2016/09/23 17:43:14]

In what case are we going to reach this? DCHECK maybe?

[clamy, 2016/09/26 11:37:27]

I think it could be possible to reach it in race conditions where we delete a
RFH that has an ongoing navigation. One case I'm thinking about is that it's
possible to delete the WebContents directly on Android without going through the
proper close sequence. This would also delete RFHs before they have time to
cancel their ongoing navigations.

+    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::SetUIChecksAlwaysSucceedForTesting(

[nasko, 2016/09/23 17:41:35]

nit: Why the CamelCase when this is a simple setter?

[clamy, 2016/09/26 11:37:27]

Done.

+    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