Add support for multiple simultaneous subresource_filter::Configurations.

components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.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 <set>
 #include <string>
 
 #include "base/macros.h"
@@ skipping 77 matching lines @@
 }
 
 struct ActivationListTestData {
   ActivationDecision expected_activation_decision;
   ActivationList activation_list;
   safe_browsing::SBThreatType threat_type;
   safe_browsing::ThreatPatternType threat_type_metadata;
 };
 
 const ActivationListTestData kActivationListTestData[] = {
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED, ActivationList::NONE,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET, ActivationList::NONE,
      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
      safe_browsing::ThreatPatternType::NONE},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
      safe_browsing::ThreatPatternType::MALWARE_LANDING},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
      safe_browsing::ThreatPatternType::MALWARE_DISTRIBUTION},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_API_ABUSE,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_BLACKLISTED_RESOURCE,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_BINARY_MALWARE_URL,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_UNWANTED,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_MALWARE,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      ActivationList::PHISHING_INTERSTITIAL, safe_browsing::SB_THREAT_TYPE_SAFE,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
     {ActivationDecision::ACTIVATED, ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
      safe_browsing::ThreatPatternType::NONE},
     {ActivationDecision::ACTIVATED, ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
     {ActivationDecision::ACTIVATED, ActivationList::PHISHING_INTERSTITIAL,
      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
 };
 
 struct ActivationScopeTestData {
   ActivationDecision expected_activation_decision;
   bool url_matches_activation_list;
   ActivationScope activation_scope;
 };
 
 const ActivationScopeTestData kActivationScopeTestData[] = {
     {ActivationDecision::ACTIVATED, false /* url_matches_activation_list */,
      ActivationScope::ALL_SITES},
     {ActivationDecision::ACTIVATED, true /* url_matches_activation_list */,
      ActivationScope::ALL_SITES},
-    {ActivationDecision::ACTIVATION_DISABLED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      true /* url_matches_activation_list */, ActivationScope::NO_SITES},
     {ActivationDecision::ACTIVATED, true /* url_matches_activation_list */,
      ActivationScope::ACTIVATION_LIST},
-    {ActivationDecision::ACTIVATION_LIST_NOT_MATCHED,
+    {ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
      false /* url_matches_activation_list */, ActivationScope::ACTIVATION_LIST},
 };
 
 struct ActivationLevelTestData {
   ActivationDecision expected_activation_decision;
   ActivationLevel activation_level;
 };
 
 const ActivationLevelTestData kActivationLevelTestData[] = {
     {ActivationDecision::ACTIVATED, ActivationLevel::DRYRUN},
@@ skipping 52 matching lines @@
     ASSERT_NO_FATAL_FAILURE(test_ruleset_creator_.CreateRulesetWithRules(
         rules, &test_ruleset_pair_));
     ruleset_dealer_ = base::MakeUnique<VerifiedRulesetDealer::Handle>(
         base::MessageLoop::current()->task_runner());
     ruleset_dealer_->SetRulesetFile(
         testing::TestRuleset::Open(test_ruleset_pair_.indexed));
     client_ =
         base::MakeUnique<MockSubresourceFilterClient>(ruleset_dealer_.get());
     ContentSubresourceFilterDriverFactory::CreateForWebContents(
         RenderViewHostTestHarness::web_contents(), client());
-    ResetConfigurationToEnableFilteringOnSocialEngineeringSites();
+    ResetConfigurationToEnableFilteringOnPhishingSites();
 
     // Add a subframe.
     content::RenderFrameHostTester* rfh_tester =
         content::RenderFrameHostTester::For(main_rfh());
     rfh_tester->InitializeRenderFrameIfNeeded();
     rfh_tester->AppendChild(kSubframeName);
 
     Observe(content::RenderViewHostTestHarness::web_contents());
   }
 
   void TearDown() override {
     ruleset_dealer_.reset();
     base::RunLoop().RunUntilIdle();
     RenderViewHostTestHarness::TearDown();
   }
 
   void ResetConfiguration(Configuration config) {
     scoped_configuration_.ResetConfiguration(std::move(config));
   }
 
+  void ResetConfiguration(std::vector<Configuration> config) {
+    scoped_configuration_.ResetConfiguration(std::move(config));
+  }
+
   void ResetConfigurationToEnableFilteringOnAllSites() {
     ResetConfiguration(
         Configuration(ActivationLevel::ENABLED, ActivationScope::ALL_SITES));
   }
 
-  void ResetConfigurationToEnableFilteringOnSocialEngineeringSites() {
-    ResetConfiguration(Configuration(
-        ActivationLevel::ENABLED, ActivationScope::ACTIVATION_LIST,
-        ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL));
+  void ResetConfigurationToEnableFilteringOnPhishingSites() {
+    ResetConfiguration(Configuration::MakePresetForLiveRunOnPhishingSites());
+  }
+
+  void GetExactlyOneEnabledConfig(Configuration* config) {
+    const auto config_list = GetEnabledConfigurations();
+    ASSERT_EQ(1u, config_list->configs_by_decreasing_priority().size());
+    *config = config_list->configs_by_decreasing_priority().front();
   }
 
   ContentSubresourceFilterDriverFactory* factory() {
     return ContentSubresourceFilterDriverFactory::FromWebContents(
         RenderViewHostTestHarness::web_contents());
   }
 
   MockSubresourceFilterClient* client() { return client_.get(); }
 
   content::RenderFrameHost* GetSubframeRFH() {
@@ skipping 191 matching lines @@
       return;
 
     std::vector<std::unique_ptr<content::NavigationThrottle>> throttles;
     factory()->throttle_manager()->MaybeAppendNavigationThrottles(
         navigation_handle, &throttles);
     for (auto& it : throttles)
       navigation_handle->RegisterThrottleForTesting(std::move(it));
   }
 
  private:
-  static bool expected_measure_performance() {
-    const double rate = GetActiveConfigurations()
-                            ->the_one_and_only()
-                            .performance_measurement_rate;
-    // Note: The case when 0 < rate < 1 is not deterministic, don't test it.
-    EXPECT_TRUE(rate == 0 || rate == 1);
-    return rate == 1;
-  }
-
   testing::ScopedSubresourceFilterConfigurator scoped_configuration_;
   testing::TestRulesetCreator test_ruleset_creator_;
   testing::TestRulesetPair test_ruleset_pair_;
 
   std::unique_ptr<MockSubresourceFilterClient> client_;
   std::unique_ptr<VerifiedRulesetDealer::Handle> ruleset_dealer_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterDriverFactoryTest);
 };
 
@@ skipping 30 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(
       ContentSubresourceFilterDriverFactoryActivationLevelTest);
 };
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        NoActivationWhenActivationLevelIsDisabled) {
   Configuration config(ActivationLevel::DISABLED,
                        ActivationScope::ACTIVATION_LIST,
                        ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL);
-  config.activation_level = ActivationLevel::DISABLED;
+  config.activation_options.activation_level = ActivationLevel::DISABLED;
   ResetConfiguration(std::move(config));
 
+  NavigateAndExpectActivation(
+      {false}, {GURL(kExampleLoginUrl)}, EMPTY,
+      ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET);
+
   const GURL url(kExampleUrlWithParams);
   NavigateAndExpectActivation({true}, {url}, NO_REDIRECTS_HIT,
                               ActivationDecision::ACTIVATION_DISABLED);
+
   factory()->client()->WhitelistInCurrentWebContents(url);
   NavigateAndExpectActivation({true}, {url}, NO_REDIRECTS_HIT,
-                              ActivationDecision::ACTIVATION_DISABLED);
+                              ActivationDecision::URL_WHITELISTED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, NoActivationWhenNoMatch) {
-  NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
-                              ActivationDecision::ACTIVATION_LIST_NOT_MATCHED);
+  NavigateAndExpectActivation(
+      {false}, {GURL(kExampleUrl)}, EMPTY,
+      ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SpecialCaseNavigationAllSitesEnabled) {
   // Check that when the experiment is enabled for all site, the activation
   // signal is always sent.
   ResetConfigurationToEnableFilteringOnAllSites();
   EmulateInPageNavigation({false}, EMPTY, ActivationDecision::ACTIVATED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SpecialCaseNavigationActivationListEnabled) {
   EmulateInPageNavigation({true}, NO_REDIRECTS_HIT,
                           ActivationDecision::ACTIVATED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SpecialCaseNavigationActivationListEnabledWithPerformanceMeasurement) {
   Configuration config(ActivationLevel::ENABLED,
                        ActivationScope::ACTIVATION_LIST,
                        ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL);
-  config.performance_measurement_rate = 1.0;
+  config.activation_options.performance_measurement_rate = 1.0;
   ResetConfiguration(std::move(config));
 
   EmulateInPageNavigation({true}, NO_REDIRECTS_HIT,
                           ActivationDecision::ACTIVATED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, FailedNavigation) {
   const GURL url(kExampleUrl);
   ResetConfigurationToEnableFilteringOnAllSites();
   NavigateAndExpectActivation({false}, {url}, EMPTY,
                               ActivationDecision::ACTIVATED);
   EmulateFailedNavigationAndExpectNoActivation(url);
 }
 
 // TODO(melandory): refactor the test so it no longer require the current
 // activation list to be matching.
 TEST_F(ContentSubresourceFilterDriverFactoryTest, RedirectPatternTest) {
   struct RedirectRedirectChainMatchPatternTestData {
     std::vector<bool> blacklisted_urls;
     std::vector<GURL> navigation_chain;
     RedirectChainMatchPattern hit_expected_pattern;
     ActivationDecision expected_activation_decision;
   } kRedirectRedirectChainMatchPatternTestData[] = {
       {{false},
        {GURL(kUrlA)},
        EMPTY,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
       {{true}, {GURL(kUrlA)}, NO_REDIRECTS_HIT, ActivationDecision::ACTIVATED},
       {{false, false},
        {GURL(kUrlA), GURL(kUrlB)},
        EMPTY,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
       {{false, true},
        {GURL(kUrlA), GURL(kUrlB)},
        F0M0L1,
        ActivationDecision::ACTIVATED},
       {{true, false},
        {GURL(kUrlA), GURL(kUrlB)},
        F1M0L0,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
       {{true, true},
        {GURL(kUrlA), GURL(kUrlB)},
        F1M0L1,
        ActivationDecision::ACTIVATED},
       {{false, false, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        EMPTY,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
       {{false, false, true},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F0M0L1,
        ActivationDecision::ACTIVATED},
       {{false, true, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F0M1L0,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
       {{false, true, true},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F0M1L1,
        ActivationDecision::ACTIVATED},
       {{true, false, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F1M0L0,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
       {{true, false, true},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F1M0L1,
        ActivationDecision::ACTIVATED},
       {{true, true, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F1M1L0,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
       {{true, true, true},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F1M1L1,
        ActivationDecision::ACTIVATED},
       {{false, true, false, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC), GURL(kUrlD)},
        F0M1L0,
-       ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
+       ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET},
   };
 
   for (size_t i = 0U; i < arraysize(kRedirectRedirectChainMatchPatternTestData);
        ++i) {
     auto test_data = kRedirectRedirectChainMatchPatternTestData[i];
     NavigateAndExpectActivation(
         test_data.blacklisted_urls, test_data.navigation_chain,
         safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
         safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,
         content::Referrer(), ui::PAGE_TRANSITION_LINK,
         test_data.hit_expected_pattern, test_data.expected_activation_decision);
     NavigateAndExpectActivation(
         {false}, {GURL("https://dummy.com")}, EMPTY,
-        ActivationDecision::ACTIVATION_LIST_NOT_MATCHED);
+        ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET);
 #if defined(GOOGLE_CHROME_BUILD)
     NavigateAndExpectActivation(
         test_data.blacklisted_urls, test_data.navigation_chain,
         safe_browsing::SB_THREAT_TYPE_SUBRESOURCE_FILTER,
         safe_browsing::ThreatPatternType::NONE, content::Referrer(),
         ui::PAGE_TRANSITION_LINK, test_data.hit_expected_pattern,
-        ActivationDecision::ACTIVATION_LIST_NOT_MATCHED);
+        ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET);
 #endif
   }
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, NotificationVisibility) {
   ResetConfigurationToEnableFilteringOnAllSites();
   NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
                               ActivationDecision::ACTIVATED);
   EXPECT_CALL(*client(), ToggleNotificationVisibility(true)).Times(1);
   NavigateSubframeAndExpectCheckResult(GURL(kDisallowedUrl),
                                        true /* expect_cancelled */);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SuppressNotificationVisibility) {
   Configuration config(ActivationLevel::ENABLED, ActivationScope::ALL_SITES);
-  config.should_suppress_notifications = true;
+  config.activation_options.should_suppress_notifications = true;
   ResetConfiguration(std::move(config));
   NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
                               ActivationDecision::ACTIVATED);
   EXPECT_CALL(*client(), ToggleNotificationVisibility(::testing::_)).Times(0);
   NavigateSubframeAndExpectCheckResult(GURL(kDisallowedUrl),
                                        true /* expect_cancelled */);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        InactiveMainFrame_SubframeNotFiltered) {
@@ skipping 13 matching lines @@
   } kTestCases[] = {
       {content::Referrer(), ui::PAGE_TRANSITION_LINK,
        ActivationDecision::ACTIVATED},
       {content::Referrer(GURL(kUrlA), blink::kWebReferrerPolicyDefault),
        ui::PAGE_TRANSITION_LINK, ActivationDecision::ACTIVATED},
       {content::Referrer(GURL(kExampleUrl), blink::kWebReferrerPolicyDefault),
        ui::PAGE_TRANSITION_LINK, ActivationDecision::URL_WHITELISTED},
       {content::Referrer(), ui::PAGE_TRANSITION_RELOAD,
        ActivationDecision::URL_WHITELISTED}};
 
+  Configuration config(ActivationLevel::ENABLED, ActivationScope::ALL_SITES);
+  config.activation_options.should_whitelist_site_on_reload = true;
+  ResetConfiguration(std::move(config));
+
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(::testing::Message("referrer = \"")
                  << test_case.referrer.url << "\""
                  << " transition = \"" << test_case.transition << "\"");
 
-    Configuration config(ActivationLevel::ENABLED, ActivationScope::ALL_SITES);
-    config.should_whitelist_site_on_reload = true;
-    ResetConfiguration(std::move(config));
-
     NavigateAndExpectActivation(
         {false}, {GURL(kExampleUrl)},
         safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
         safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,
         test_case.referrer, test_case.transition, EMPTY,
         test_case.expected_activation_decision);
     // Verify that if the first URL failed to activate, subsequent same-origin
     // navigations also fail to activate.
     NavigateAndExpectActivation({false}, {GURL(kExampleUrlWithParams)}, EMPTY,
                                 test_case.expected_activation_decision);
   }
 }
 
+TEST_F(ContentSubresourceFilterDriverFactoryTest, NoConfigs) {
+  ResetConfiguration(std::vector<Configuration>());
+  NavigateAndExpectActivation(
+      {true}, {GURL(kExampleUrl)}, NO_REDIRECTS_HIT,
+      ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET);
+}
+
+TEST_F(ContentSubresourceFilterDriverFactoryTest, MultipleSimultaneousConfigs) {
+  Configuration config1(ActivationLevel::DRYRUN, ActivationScope::NO_SITES);
+  config1.activation_conditions.priority = 2;
+
+  Configuration config2(ActivationLevel::DISABLED,
+                        ActivationScope::ACTIVATION_LIST,
+                        ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL);
+  config2.activation_conditions.priority = 1;
+
+  Configuration config3(ActivationLevel::ENABLED, ActivationScope::ALL_SITES);
+  config3.activation_options.should_whitelist_site_on_reload = true;
+  config3.activation_conditions.priority = 0;
+
+  ResetConfiguration({config1, config2, config3});
+
+  // Should match |config2| and |config3|, the former with the higher priority.
+  NavigateAndExpectActivation({true}, {GURL(kExampleUrl)}, NO_REDIRECTS_HIT,
+                              ActivationDecision::ACTIVATION_DISABLED);
+
+  // Should match |config3|.
+  NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
+                              ActivationDecision::ACTIVATED);
+
+  // Should match |config3|, but a reload, so this should get whitelisted.
+  NavigateAndExpectActivation(
+      {false}, {GURL(kExampleUrl)}, safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
+      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,
+      content::Referrer(), ui::PAGE_TRANSITION_RELOAD, EMPTY,
+      ActivationDecision::URL_WHITELISTED);
+}
+
 TEST_P(ContentSubresourceFilterDriverFactoryActivationLevelTest,
        ActivateForFrameState) {
   const ActivationLevelTestData& test_data = GetParam();
   ResetConfiguration(Configuration(
       test_data.activation_level, ActivationScope::ACTIVATION_LIST,
       ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL));
 
   const GURL url(kExampleUrlWithParams);
   NavigateAndExpectActivation({true}, {url}, NO_REDIRECTS_HIT,
                               test_data.expected_activation_decision);
   factory()->client()->WhitelistInCurrentWebContents(url);
-  NavigateAndExpectActivation(
-      {true}, {GURL(kExampleUrlWithParams)}, NO_REDIRECTS_HIT,
-      GetActiveConfigurations()->the_one_and_only().activation_level ==
-              ActivationLevel::DISABLED
-          ? ActivationDecision::ACTIVATION_DISABLED
-          : ActivationDecision::URL_WHITELISTED);
+  NavigateAndExpectActivation({true}, {GURL(kExampleUrlWithParams)},
+                              NO_REDIRECTS_HIT,
+                              ActivationDecision::URL_WHITELISTED);
 }
 
 TEST_P(ContentSubresourceFilterDriverFactoryThreatTypeTest,
        ActivateForTheListType) {
   // Sets up the experiment in a way that the activation decision depends on the
   // list for which the Safe Browsing hit has happened.
   const ActivationListTestData& test_data = GetParam();
   ResetConfiguration(Configuration(ActivationLevel::ENABLED,
                                    ActivationScope::ACTIVATION_LIST,
                                    test_data.activation_list));
@@ skipping 21 matching lines @@
 
   const GURL test_url(kExampleUrlWithParams);
 
   RedirectChainMatchPattern expected_pattern =
       test_data.url_matches_activation_list ? NO_REDIRECTS_HIT : EMPTY;
   NavigateAndExpectActivation({test_data.url_matches_activation_list},
                               {test_url}, expected_pattern,
                               test_data.expected_activation_decision);
   if (test_data.url_matches_activation_list) {
     factory()->client()->WhitelistInCurrentWebContents(test_url);
-    NavigateAndExpectActivation(
-        {test_data.url_matches_activation_list}, {GURL(kExampleUrlWithParams)},
-        expected_pattern,
-        GetActiveConfigurations()->the_one_and_only().activation_scope ==
-                ActivationScope::NO_SITES
-            ? ActivationDecision::ACTIVATION_DISABLED
-            : ActivationDecision::URL_WHITELISTED);
+    ActivationDecision expected_decision =
+        test_data.expected_activation_decision;
+    if (expected_decision == ActivationDecision::ACTIVATED)
+      expected_decision = ActivationDecision::URL_WHITELISTED;
+    NavigateAndExpectActivation({test_data.url_matches_activation_list},
+                                {GURL(kExampleUrlWithParams)}, expected_pattern,
+                                expected_decision);
   }
 };
 
-// Only main frames with http/https schemes should activate, unless the
-// activation scope is for all sites.
+// Only main frames with http/https schemes should activate.
 TEST_P(ContentSubresourceFilterDriverFactoryActivationScopeTest,
        ActivateForSupportedUrlScheme) {
   const ActivationScopeTestData& test_data = GetParam();
   ResetConfiguration(
       Configuration(ActivationLevel::ENABLED, test_data.activation_scope,
                     ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL));
 
   // data URLs are also not supported, but not listed here, as it's not possible
   // for a page to redirect to them after https://crbug.com/594215 is fixed.
   const char* unsupported_urls[] = {"ftp://example.com/", "chrome://settings",
                                     "chrome-extension://some-extension",
                                     "file:///var/www/index.html"};
   const char* supported_urls[] = {"http://example.test",
                                   "https://example.test"};
   for (auto* url : unsupported_urls) {
     SCOPED_TRACE(url);
     RedirectChainMatchPattern expected_pattern = EMPTY;
-    NavigateAndExpectActivation(
-        {test_data.url_matches_activation_list}, {GURL(url)}, expected_pattern,
-        GetActiveConfigurations()->the_one_and_only().activation_scope ==
-                ActivationScope::NO_SITES
-            ? ActivationDecision::ACTIVATION_DISABLED
-            : ActivationDecision::UNSUPPORTED_SCHEME);
+    NavigateAndExpectActivation({test_data.url_matches_activation_list},
+                                {GURL(url)}, expected_pattern,
+                                ActivationDecision::UNSUPPORTED_SCHEME);
   }
   for (auto* url : supported_urls) {
     SCOPED_TRACE(url);
     RedirectChainMatchPattern expected_pattern =
         test_data.url_matches_activation_list ? NO_REDIRECTS_HIT : EMPTY;
     NavigateAndExpectActivation({test_data.url_matches_activation_list},
                                 {GURL(url)}, expected_pattern,
                                 test_data.expected_activation_decision);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(NoSocEngHit,
                         ContentSubresourceFilterDriverFactoryThreatTypeTest,
                         ::testing::ValuesIn(kActivationListTestData));
 
 INSTANTIATE_TEST_CASE_P(
     ActivationScopeTest,
     ContentSubresourceFilterDriverFactoryActivationScopeTest,
     ::testing::ValuesIn(kActivationScopeTestData));
 
 INSTANTIATE_TEST_CASE_P(
     ActivationLevelTest,
     ContentSubresourceFilterDriverFactoryActivationLevelTest,
     ::testing::ValuesIn(kActivationLevelTestData));
 
 }  // namespace subresource_filter