[subresource_filter] Remove some state from the driver factory

components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.h

 // 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.
 
 #ifndef COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_THROTTLE_MANAGER_H_
 #define COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_THROTTLE_MANAGER_H_
 
 #include <memory>
 #include <unordered_map>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "components/subresource_filter/content/browser/verified_ruleset_dealer.h"
+#include "components/subresource_filter/core/common/activation_decision.h"
 #include "components/subresource_filter/core/common/activation_state.h"
 #include "content/public/browser/web_contents_observer.h"
 
 namespace content {
 class NavigationHandle;
 class NavigationThrottle;
 class RenderFrameHost;
 }  // namespace content
 
 namespace IPC {
@@ skipping 46 matching lines @@
 
   // Sets the desired page-level |activation_state| for the currently ongoing
   // page load, identified by its main-frame |navigation_handle|. To be called
   // by the embedder at the latest in the WillProcessResponse stage from a
   // NavigationThrottle that was registered before the throttles created by this
   // manager in MaybeAppendNavigationThrottles(). If this method is not called
   // for a main-frame navigation, the default behavior is no activation for that
   // page load.
   void NotifyPageActivationComputed(
       content::NavigationHandle* navigation_handle,
-      const ActivationState& activation_state);
+      const ActivationState& activation_state,
+      ActivationDecision activation_decision);
 
   // This method inspects |navigation_handle| and attaches navigation throttles
   // appropriately, based on the current state of frame activation.
   //
   // 1. Subframe navigation filtering throttles are appended if the parent
   // frame is activated.
   // 2. Activation state computing throttles are appended if either the
   // navigation is a main frame navigation, or if the parent frame is activated.
   //
   // Note that there is currently no constraints on the ordering of throttles.
   void MaybeAppendNavigationThrottles(
       content::NavigationHandle* navigation_handle,
       std::vector<std::unique_ptr<content::NavigationThrottle>>* throttles);
 
   // Returns whether or not the current WebContents is allowed to create a new
   // window.
   bool ShouldDisallowNewWindow();
 
   VerifiedRuleset::Handle* ruleset_handle_for_testing() {
     return ruleset_handle_.get();
   }
 
+  // Returns the |ActivationDecision| for the current main frame document.
+  ActivationDecision GetActivationDecisionForLastCommittedPageLoad() const {
+    return activation_decision_;
+  }
+
  protected:
   // content::WebContentsObserver:
   void RenderFrameDeleted(content::RenderFrameHost* frame_host) override;
   void ReadyToCommitNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidFinishNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidFinishLoad(content::RenderFrameHost* render_frame_host,
                      const GURL& validated_url) override;
   bool OnMessageReceived(const IPC::Message& message,
@@ skipping 39 matching lines @@
   // RenderFrameHosts (i.e. activated_frame_hosts_ is empty).
   std::unique_ptr<VerifiedRuleset::Handle> ruleset_handle_;
 
   std::unique_ptr<PageLoadStatistics> statistics_;
 
   // True if the current committed main frame load in this WebContents has
   // notified the delegate that a subresource was disallowed. The callback
   // should only be called at most once per main frame load.
   bool current_committed_load_has_notified_disallowed_load_ = false;
 
+  // The activation decision for the last committed main frame navigation.
+  ActivationDecision activation_decision_ = ActivationDecision::UNKNOWN;
+
   // These members outlive this class.
   VerifiedRulesetDealer::Handle* dealer_handle_;
   Delegate* delegate_;
 
   base::WeakPtrFactory<ContentSubresourceFilterThrottleManager>
       weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterThrottleManager);
 };
 
 }  // namespace subresource_filter
 
 #endif  // COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_THROTTLE_MANAGER_H_