Introduce SubframeNavigationFilteringThrottle

content/browser/frame_host/navigation_handle_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_FRAME_HOST_NAVIGATION_HANDLE_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_NAVIGATION_HANDLE_IMPL_H_
 
 #include "content/public/browser/navigation_handle.h"
 
 #include <stddef.h>
@@ skipping 113 matching lines @@
   void Resume() override;
   void CancelDeferredNavigation(
       NavigationThrottle::ThrottleCheckResult result) override;
   void RegisterThrottleForTesting(
       std::unique_ptr<NavigationThrottle> navigation_throttle) override;
   NavigationThrottle::ThrottleCheckResult CallWillStartRequestForTesting(
       bool is_post,
       const Referrer& sanitized_referrer,
       bool has_user_gesture,
       ui::PageTransition transition,
-      bool is_external_protocol) override;
+      bool is_external_protocol,
+      const ThrottleChecksFinishedCallback& complete_callback) override;
   NavigationThrottle::ThrottleCheckResult CallWillRedirectRequestForTesting(
       const GURL& new_url,
       bool new_method_is_post,
       const GURL& new_referrer_url,
-      bool new_is_external_protocol) override;
+      bool new_is_external_protocol,
+      const ThrottleChecksFinishedCallback& complete_callback) override;
   NavigationThrottle::ThrottleCheckResult CallWillProcessResponseForTesting(
       RenderFrameHost* render_frame_host,
-      const std::string& raw_response_header) override;
+      const std::string& raw_response_header,
+      const ThrottleChecksFinishedCallback& complete_callback) override;
   void CallDidCommitNavigationForTesting(const GURL& url) override;
   bool WasStartedFromContextMenu() const override;
   const GURL& GetSearchableFormURL() override;
   const std::string& GetSearchableFormEncoding() override;
   ReloadType GetReloadType() override;
   const GlobalRequestID& GetGlobalRequestID() override;
-
   NavigationData* GetNavigationData() override;
 
   // The NavigatorDelegate to notify/query for various navigation events.
   // Normally this is the WebContents, except if this NavigationHandle was
   // created during a navigation to an interstitial page. In this case it will
   // be the InterstitialPage itself.
   //
   // Note: due to the interstitial navigation case, all calls that can possibly
   // expose the NavigationHandle to code outside of content/ MUST go though the
   // NavigatorDelegate. In particular, the ContentBrowserClient should not be
@@ skipping 56 matching lines @@
   ServiceWorkerNavigationHandle* service_worker_handle() const {
     return service_worker_handle_.get();
   }
 
   // PlzNavigate
   void InitAppCacheHandle(ChromeAppCacheService* appcache_service);
   AppCacheNavigationHandle* appcache_handle() const {
     return appcache_handle_.get();
   }
 
-  typedef base::Callback<void(NavigationThrottle::ThrottleCheckResult)>
-      ThrottleChecksFinishedCallback;
-
   // Called when the URLRequest will start in the network stack.  |callback|
   // will be called when all throttle checks have completed. This will allow
   // the caller to cancel the navigation or let it proceed.
-  void WillStartRequest(
+  // Returns the synchronous throttle check result, or DEFER if it is being
+  // calculated asynchronously.
+  NavigationThrottle::ThrottleCheckResult WillStartRequest(

[clamy, 2017/02/15 16:37:22]

I'm don't really like having the result be returned in two different ways, 1)
directly and 2) via the callback being run. It looks confusing to me.

[Charlie Harrison, 2017/02/15 16:42:12]

What would you prefer? One idea is to have the callback run only in async cases,
 but keep everything else as-is. I.e. we know the callback will be run later if
the method returns DEFER.

[clamy, 2017/02/16 14:10:43]

I really don't want to be modifying the semantic of the callback right now. We
will do it in the future though, where either NavigationHandle will be merged in
the NavigationRequest or NavigationRequest methods will be called directly by
NavigationHandle. This will result in the callback disappearing.

So thinking about this future direction, I see the following possible solutions:

1) pass a pointer (possibly weak ptr) to a ThrottleCheckResult that will be
updated when we are done with the checks. We can internally bind the callback to
update this pointer in tests.
2) add new functions ProcessAll*Checks that will only return when all checks are
done. It need not be on the handler (can be a RFH function or something), or be
added to the NavigationSimulator I'm adding in that patch:
https://codereview.chromium.org/2682313002/.

       const std::string& method,
       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,
       blink::WebMixedContentContextType mixed_content_context_type,
       const ThrottleChecksFinishedCallback& callback);
 
   // Called when the URLRequest will be redirected in the network stack.
   // |callback| will be called when all throttles check have completed. This
   // will allow the caller to cancel the navigation or let it proceed.
   // This will also inform the delegate that the request was redirected.
-  void WillRedirectRequest(
+  // Returns the synchronous throttle check result, or DEFER if it is being
+  // calculated asynchronously.
+  NavigationThrottle::ThrottleCheckResult WillRedirectRequest(
       const GURL& new_url,
       const std::string& new_method,
       const GURL& new_referrer_url,
       bool new_is_external_protocol,
       scoped_refptr<net::HttpResponseHeaders> response_headers,
       net::HttpResponseInfo::ConnectionInfo connection_info,
       const ThrottleChecksFinishedCallback& callback);
 
   // Called when the URLRequest has delivered response headers and metadata.
   // |callback| will be called when all throttle checks have completed,
   // allowing the caller to cancel the navigation or let it proceed.
   // NavigationHandle will not call |callback| with a result of DEFER.
   // If the result is PROCEED, then 'ReadyToCommitNavigation' will be called
   // with |render_frame_host| and |response_headers| just before calling
   // |callback|. Should a transfer navigation happen, |transfer_callback| will
   // be run on the IO thread.
+  // Returns the synchronous throttle check result, or DEFER if it is being
+  // calculated asynchronously.
   // PlzNavigate: transfer navigations are not possible.
-  void WillProcessResponse(
+  NavigationThrottle::ThrottleCheckResult WillProcessResponse(
       RenderFrameHostImpl* render_frame_host,
       scoped_refptr<net::HttpResponseHeaders> response_headers,
       net::HttpResponseInfo::ConnectionInfo connection_info,
       const SSLStatus& ssl_status,
       const GlobalRequestID& request_id,
       bool should_replace_current_entry,
       bool is_download,
       bool is_stream,
       const base::Closure& transfer_callback,
       const ThrottleChecksFinishedCallback& callback);
@@ skipping 215 matching lines @@
   NavigationType navigation_type_;
 
   base::WeakPtrFactory<NavigationHandleImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationHandleImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_NAVIGATION_HANDLE_IMPL_H_