Add support for multiple simultaneous subresource_filter::Configurations.

components/subresource_filter/content/browser/content_subresource_filter_driver_factory.cc

 // 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.
 
 #include "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
@@ skipping 66 matching lines @@
 
 ContentSubresourceFilterDriverFactory::ContentSubresourceFilterDriverFactory(
     content::WebContents* web_contents,
     SubresourceFilterClient* client)
     : content::WebContentsObserver(web_contents),
       client_(client),
       throttle_manager_(
           base::MakeUnique<ContentSubresourceFilterThrottleManager>(
               this,
               client_->GetRulesetDealer(),
-              web_contents)),
-      activation_level_(ActivationLevel::DISABLED),
-      activation_decision_(ActivationDecision::UNKNOWN),
-      measure_performance_(false) {}
+              web_contents)) {}
 
 ContentSubresourceFilterDriverFactory::
     ~ContentSubresourceFilterDriverFactory() {}
 
 void ContentSubresourceFilterDriverFactory::
     OnMainResourceMatchedSafeBrowsingBlacklist(
         const GURL& url,
         const std::vector<GURL>& redirect_urls,
         safe_browsing::SBThreatType threat_type,
         safe_browsing::ThreatPatternType threat_type_metadata) {
   AddActivationListMatch(
       url, GetListForThreatTypeAndMetadata(threat_type, threat_type_metadata));
 }
 
-ContentSubresourceFilterDriverFactory::ActivationDecision
-ContentSubresourceFilterDriverFactory::
-    ComputeActivationDecisionForMainFrameNavigation(
-        content::NavigationHandle* navigation_handle) const {
+void ContentSubresourceFilterDriverFactory::
+    ComputeActivationForMainFrameNavigation(
+        content::NavigationHandle* navigation_handle) {
   const GURL& url(navigation_handle->GetURL());
 
-  const auto configurations = GetActiveConfigurations();
-  if (configurations->the_one_and_only().activation_level ==
-      ActivationLevel::DISABLED)
-    return ActivationDecision::ACTIVATION_DISABLED;
+  if (!url.SchemeIsHTTPOrHTTPS()) {

[Bryan McQuade, 2017/05/17 13:55:48]

looking at this now, does this mean that if the system is disabled but the URL
isn't a valid scheme, behavior change from ACTIVATION_DISABLED to
UNSUPPORTED_SCHEME? from a metrics tracking standpoint i find that a little odd
- we shouldn't even be evaluating / applying policy if the system is disabled.
is this change in behavior important to other code? would it be possible for us
to restore the original order?

[engedy, 2017/05/17 14:21:40]

Unfortunately, it would make the code here less clear. Do we really need this
enum value? Can we just obsolete this and record ACTIVATION_CONDITIONS_NOT_MET
in these cases?

Otherwise, DoesMainFrameURLSatisfyActivationConditions would have to return 2
configs: a matching, and another one that is non-matching only because of the
wrong scheme (which would cause UNSUPPORTED_SCHEME to be reported for ALL_SITES
and ACTIVATION_LIST scopes, but not for NO_SITES).

+    activation_decision_ = ActivationDecision::UNSUPPORTED_SCHEME;
+    activation_options_ = Configuration::ActivationOptions();
+    return;
+  }
 
-  if (configurations->the_one_and_only().activation_scope ==
-      ActivationScope::NO_SITES)
-    return ActivationDecision::ACTIVATION_DISABLED;
+  const auto config_list = GetEnabledConfigurations();
+  const auto highest_priority_activated_config =
+      std::find_if(config_list->configs_by_decreasing_priority().begin(),
+                   config_list->configs_by_decreasing_priority().end(),
+                   [&url, this](const Configuration& config) {
+                     return DoesMainFrameURLSatisfyActivationConditions(
+                         url, config.activation_conditions);
+                   });
 
-  if (!url.SchemeIsHTTPOrHTTPS())
-    return ActivationDecision::UNSUPPORTED_SCHEME;
+  if (highest_priority_activated_config ==
+      config_list->configs_by_decreasing_priority().end()) {
+    activation_decision_ = ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET;
+    activation_options_ = Configuration::ActivationOptions();
+    return;
+  }
+
   // TODO(csharrison): The throttle manager also performs this check. Remove
   // this one when the activation decision is sent directly to the throttle
   // manager.
-  if (client_->ShouldSuppressActivation(navigation_handle))
-    return ActivationDecision::URL_WHITELISTED;
+  if (client_->ShouldSuppressActivation(navigation_handle)) {
+    activation_decision_ = ActivationDecision::URL_WHITELISTED;
+    activation_options_ = Configuration::ActivationOptions();
+    return;
+  }
 
-  switch (configurations->the_one_and_only().activation_scope) {
+  activation_options_ = highest_priority_activated_config->activation_options;
+  activation_decision_ =
+      activation_options_.activation_level == ActivationLevel::DISABLED
+          ? ActivationDecision::ACTIVATION_DISABLED
+          : ActivationDecision::ACTIVATED;
+}
+
+bool ContentSubresourceFilterDriverFactory::
+    DoesMainFrameURLSatisfyActivationConditions(
+        const GURL& url,
+        const Configuration::ActivationConditions& conditions) const {
+  switch (conditions.activation_scope) {
     case ActivationScope::ALL_SITES:
-      return ActivationDecision::ACTIVATED;
-    case ActivationScope::ACTIVATION_LIST: {
-      // The logic to ensure only http/https URLs are activated lives in
-      // AddActivationListMatch to ensure the activation list only has relevant
-      // entries.
-      DCHECK(url.SchemeIsHTTPOrHTTPS() ||
-             !DidURLMatchActivationList(
-                 url, configurations->the_one_and_only().activation_list));
-      bool should_activate = DidURLMatchActivationList(
-          url, configurations->the_one_and_only().activation_list);
-      if (configurations->the_one_and_only().activation_list ==
-          ActivationList::PHISHING_INTERSTITIAL) {
+      return true;
+    case ActivationScope::ACTIVATION_LIST:
+      if (DidURLMatchActivationList(url, conditions.activation_list))
+        return true;
+      if (conditions.activation_list == ActivationList::PHISHING_INTERSTITIAL &&
+          DidURLMatchActivationList(
+              url, ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL)) {
         // Handling special case, where activation on the phishing sites also
         // mean the activation on the sites with social engineering metadata.
-        should_activate |= DidURLMatchActivationList(
-            url, ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL);
+        return true;
       }
-      return should_activate ? ActivationDecision::ACTIVATED
-                             : ActivationDecision::ACTIVATION_LIST_NOT_MATCHED;
-    }
-    default:
-      return ActivationDecision::ACTIVATION_DISABLED;
+      return false;
+    case ActivationScope::NO_SITES:
+      return false;
   }
+  NOTREACHED();
+  return false;
 }
 
 void ContentSubresourceFilterDriverFactory::OnReloadRequested() {
   UMA_HISTOGRAM_BOOLEAN("SubresourceFilter.Prompt.NumReloads", true);
   const GURL& whitelist_url = web_contents()->GetLastCommittedURL();
 
   // Only whitelist via content settings when using the experimental UI,
   // otherwise could get into a situation where content settings cannot be
   // adjusted.
   if (base::FeatureList::IsEnabled(
@@ skipping 12 matching lines @@
       navigation_handle->GetNetErrorCode() != net::OK) {
     return;
   }
 
   const GURL& url = navigation_handle->GetURL();
   const content::Referrer& referrer = navigation_handle->GetReferrer();
   ui::PageTransition transition = navigation_handle->GetPageTransition();
 
   RecordRedirectChainMatchPattern();
 
-  const auto configurations = GetActiveConfigurations();
-  if (configurations->the_one_and_only().should_whitelist_site_on_reload &&
+  if (activation_options_.should_whitelist_site_on_reload &&
       NavigationIsPageReload(url, referrer, transition)) {
     // Whitelist this host for the current as well as subsequent navigations.
     client_->WhitelistInCurrentWebContents(url);
   }
 
-  activation_decision_ =
-      ComputeActivationDecisionForMainFrameNavigation(navigation_handle);
-  DCHECK(activation_decision_ != ActivationDecision::UNKNOWN);
+  ComputeActivationForMainFrameNavigation(navigation_handle);
+  DCHECK_NE(activation_decision_, ActivationDecision::UNKNOWN);
   if (activation_decision_ != ActivationDecision::ACTIVATED) {
-    ResetActivationState();
+    DCHECK_EQ(activation_options_.activation_level, ActivationLevel::DISABLED);
     return;
   }
 
-  activation_level_ = configurations->the_one_and_only().activation_level;
-  measure_performance_ =
-      activation_level_ != ActivationLevel::DISABLED &&
-      ShouldMeasurePerformanceForPageLoad(
-          configurations->the_one_and_only().performance_measurement_rate);
-  ActivationState state = ActivationState(activation_level_);
-  state.measure_performance = measure_performance_;
+  DCHECK_NE(activation_options_.activation_level, ActivationLevel::DISABLED);
+  ActivationState state = ActivationState(activation_options_.activation_level);
+  state.measure_performance = ShouldMeasurePerformanceForPageLoad(
+      activation_options_.performance_measurement_rate);
   // TODO(csharrison): Set state.enable_logging based on metadata returns from
   // the safe browsing filter, when it is available. Add tests for this
   // behavior.
   throttle_manager_->NotifyPageActivationComputed(navigation_handle, state);
 }
 
 void ContentSubresourceFilterDriverFactory::OnFirstSubresourceLoadDisallowed() {
-  const auto configurations = GetActiveConfigurations();
-  if (configurations->the_one_and_only().should_suppress_notifications)
+  if (activation_options_.should_suppress_notifications)
     return;
-
-  client_->ToggleNotificationVisibility(activation_level_ ==
+  client_->ToggleNotificationVisibility(activation_options_.activation_level ==
                                         ActivationLevel::ENABLED);
 }
 
 bool ContentSubresourceFilterDriverFactory::ShouldSuppressActivation(
     content::NavigationHandle* navigation_handle) {
   return client_->ShouldSuppressActivation(navigation_handle);
 }
 
-void ContentSubresourceFilterDriverFactory::ResetActivationState() {
-  navigation_chain_.clear();
-  activation_list_matches_.clear();
-  activation_level_ = ActivationLevel::DISABLED;
-  measure_performance_ = false;
-}
-
 void ContentSubresourceFilterDriverFactory::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (navigation_handle->IsInMainFrame() &&
       !navigation_handle->IsSameDocument()) {
     activation_decision_ = ActivationDecision::UNKNOWN;
-    ResetActivationState();
-    navigation_chain_.push_back(navigation_handle->GetURL());
+    activation_list_matches_.clear();
+    navigation_chain_ = {navigation_handle->GetURL()};
     client_->ToggleNotificationVisibility(false);
   }
 }
 
 void ContentSubresourceFilterDriverFactory::DidRedirectNavigation(
     content::NavigationHandle* navigation_handle) {
   DCHECK(!navigation_handle->IsSameDocument());
   if (navigation_handle->IsInMainFrame())
     navigation_chain_.push_back(navigation_handle->GetURL());
 }
 
+void ContentSubresourceFilterDriverFactory::DidFinishNavigation(
+    content::NavigationHandle* navigation_handle) {
+  if (navigation_handle->IsInMainFrame() &&
+      !navigation_handle->IsSameDocument() &&
+      activation_decision_ == ActivationDecision::UNKNOWN &&
+      navigation_handle->HasCommitted()) {
+    activation_decision_ = ActivationDecision::ACTIVATION_DISABLED;
+    activation_options_ = Configuration::ActivationOptions();
+  }
+}
+
 bool ContentSubresourceFilterDriverFactory::DidURLMatchActivationList(
     const GURL& url,
     ActivationList activation_list) const {
   auto match_types =
       activation_list_matches_.find(DistillURLToHostAndPath(url));
   return match_types != activation_list_matches_.end() &&
          match_types->second.find(activation_list) != match_types->second.end();
 }
 
 void ContentSubresourceFilterDriverFactory::AddActivationListMatch(
@@ skipping 62 matching lines @@
       REPORT_REDIRECT_PATTERN_FOR_SUFFIX("SubresourceFilterOnly", hits_pattern,
                                          chain_size);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace subresource_filter