Revert of [subresource_filter] Remove Forwarding NavigationThrottles

components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.cc

 // Copyright 2017 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 "components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "components/subresource_filter/content/browser/activation_state_computing_navigation_throttle.h"
 #include "components/subresource_filter/content/browser/async_document_subresource_filter.h"
 #include "components/subresource_filter/content/browser/page_load_statistics.h"
 #include "components/subresource_filter/content/browser/subframe_navigation_filtering_throttle.h"
 #include "components/subresource_filter/content/common/subresource_filter_messages.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/navigation_throttle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/net_errors.h"
 
 namespace subresource_filter {
 
+namespace {
+
+// Used to forward calls to WillProcessResonse to the driver.
+// TODO(https://crbug.com/708181): Remove this once the safe browsing navigation
+// throttle is responsible for all activation decisions.
+class ForwardingNavigationThrottle : public content::NavigationThrottle {
+ public:
+  ForwardingNavigationThrottle(
+      content::NavigationHandle* handle,
+      ContentSubresourceFilterThrottleManager::Delegate* delegate)
+      : content::NavigationThrottle(handle), delegate_(delegate) {}
+  ~ForwardingNavigationThrottle() override {}
+
+  // content::NavigationThrottle:
+  content::NavigationThrottle::ThrottleCheckResult WillProcessResponse()
+      override {
+    delegate_->WillProcessResponse(navigation_handle());
+    return content::NavigationThrottle::PROCEED;
+  }
+  const char* GetNameForLogging() override {
+    return "ForwardingNavigationThrottle";
+  }
+
+ private:
+  ContentSubresourceFilterThrottleManager::Delegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(ForwardingNavigationThrottle);
+};
+
+}  // namespace
+
 ContentSubresourceFilterThrottleManager::
     ContentSubresourceFilterThrottleManager(
         Delegate* delegate,
         VerifiedRulesetDealer::Handle* dealer_handle,
         content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       dealer_handle_(dealer_handle),
       delegate_(delegate),
       weak_ptr_factory_(this) {}
 
@@ skipping 103 matching lines @@
                         OnDocumentLoadStatistics)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ContentSubresourceFilterThrottleManager::MaybeAppendNavigationThrottles(
     content::NavigationHandle* navigation_handle,
     std::vector<std::unique_ptr<content::NavigationThrottle>>* throttles) {
   DCHECK(!navigation_handle->IsSameDocument());
+  if (navigation_handle->IsInMainFrame()) {
+    throttles->push_back(base::MakeUnique<ForwardingNavigationThrottle>(
+        navigation_handle, delegate_));
+  }
   if (!dealer_handle_)
     return;
   if (auto filtering_throttle =
           MaybeCreateSubframeNavigationFilteringThrottle(navigation_handle)) {
     throttles->push_back(std::move(filtering_throttle));
   }
   if (auto activation_throttle =
           MaybeCreateActivationStateComputingThrottle(navigation_handle)) {
     ongoing_activation_throttles_[navigation_handle] =
         activation_throttle.get();
@@ skipping 79 matching lines @@
   }
 }
 
 void ContentSubresourceFilterThrottleManager::OnDocumentLoadStatistics(
     const DocumentLoadStatistics& statistics) {
   if (statistics_)
     statistics_->OnDocumentLoadStatistics(statistics);
 }
 
 }  // namespace subresource_filter