Add support for multiple simultaneous subresource_filter::Configurations.

components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h

 // Copyright 2016 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_DRIVER_FACTORY_H_
 #define COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_DRIVER_FACTORY_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/supports_user_data.h"
 #include "base/time/time.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.h"
+#include "components/subresource_filter/core/browser/subresource_filter_features.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "ui/base/page_transition_types.h"
 #include "url/gurl.h"
 
 namespace content {
 class WebContents;
 }  // namespace content
 
 namespace safe_browsing {
 class SafeBrowsingServiceTest;
@@ skipping 88 matching lines @@
   ContentSubresourceFilterThrottleManager* throttle_manager() {
     return throttle_manager_.get();
   }
 
   SubresourceFilterClient* client() { return client_.get(); }
 
  private:
   friend class ContentSubresourceFilterDriverFactoryTest;
   friend class safe_browsing::SafeBrowsingServiceTest;
 
-  void ResetActivationState();
-
   // content::WebContentsObserver:
   void DidStartNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidRedirectNavigation(
       content::NavigationHandle* navigation_handle) override;
+  void DidFinishNavigation(
+      content::NavigationHandle* navigation_handle) override;
 
   // Checks base on the value of |url| and current activation scope if
   // activation signal should be sent.
-  ActivationDecision ComputeActivationDecisionForMainFrameNavigation(
-      content::NavigationHandle* navigation_handle) const;
+  void ComputeActivationForMainFrameNavigation(
+      content::NavigationHandle* navigation_handle);
+  ActivationDecision ComputePerConfigActivationDecisionForMainFrameNavigation(
+      content::NavigationHandle* navigation_handle,
+      const Configuration& configuration) const;
 
   bool DidURLMatchActivationList(const GURL& url,
                                  ActivationList activation_list) const;
 
   void AddActivationListMatch(const GURL& url, ActivationList match_type);
   int CalculateHitPatternForActivationList(
       ActivationList activation_list) const;
   void RecordRedirectChainMatchPattern() const;
 
   void RecordRedirectChainMatchPatternForList(
       ActivationList activation_list) const;
 
   std::unique_ptr<SubresourceFilterClient> client_;
 
   std::unique_ptr<ContentSubresourceFilterThrottleManager> throttle_manager_;
 
-  ActivationLevel activation_level_;
-  ActivationDecision activation_decision_;
-  bool measure_performance_;
+  // The activation decision corresponding to the most recently _started_

[Charlie Harrison, 2017/05/03 14:52:17]

Optional:

Since driver factory is going away this is unfortunate. I wonder if we can
reduce the churn here by encapsulating this logic in a helper class (something
like ScopedPageActivationDecision). If we can plug something like that into the
SB throttle (and maybe move it into the throttle manager / filter client) it
would be pretty cool.

I think the only state necessary in this helper would be a pointer to the
client?

[engedy, 2017/05/05 12:25:41]

We discussed offline that due to subtle timing constraints, this is complicated.
But what did we agree on in the end?

[Charlie Harrison, 2017/05/05 13:12:52]

I think keeping as-is is ok, and we'll rethink once the PageActivation is all in
one place (the throttle).

+  // non-same-document navigation in the main frame.
+  //
+  // The value is reset to ActivationDecision::UNKNOWN at the start of each such
+  // navigation, and will not be assigned until the navigation successfully
+  // reaches the WillProcessResponse stage (or successfully finishes if
+  // throttles are not invoked). This means that after a cancelled or otherwise
+  // unsuccessful navigation, the value will be left at UNKNOWN indefinitely.
+  ActivationDecision activation_decision_ =
+      ActivationDecision::ACTIVATION_DISABLED;
+
+  // The activation options corresponding to the most recently _committed_
+  // non-same-document navigation in the main frame.
+  //
+  // The value corresponding to the previous such navigation will be retained,
+  // and the new value not assigned until a subsequent navigation successfully
+  // reaches the WillProcessResponse stage (or successfully finishes if
+  // throttles are not invoked).
+  Configuration::ActivationOptions activation_options_;
 
   // The URLs in the navigation chain.
   std::vector<GURL> navigation_chain_;
 
   URLToActivationListsMap activation_list_matches_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterDriverFactory);
 };
 
 }  // namespace subresource_filter
 
 #endif  // COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_DRIVER_FACTORY_H_