Introduce subresource_filter::Configuration.

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 "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
@@ skipping 440 matching lines @@
 
     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 = GetPerformanceMeasurementRate();
+    const double rate = GetActiveConfiguration().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::TestRulesetCreator test_ruleset_creator_;
   testing::TestRulesetPair test_ruleset_pair_;
 
   // Owned by the factory.
   MockSubresourceFilterClient* client_;
@@ skipping 40 matching lines @@
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        ActivateForFrameHostDisabledFeature) {
   // Activation scope is set to NONE => no activation should happen even if URL
   // which is visited was a SB hit.
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_DISABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeAllSites,
       kActivationListSocialEngineeringAdsInterstitial);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
   const GURL url(kExampleUrlWithParams);
   NavigateAndExpectActivation({true}, {url}, NO_REDIRECTS_HIT,
                               ActivationDecision::ACTIVATION_DISABLED);
   factory()->AddHostOfURLToWhitelistSet(url);
   NavigateAndExpectActivation({true}, {url}, NO_REDIRECTS_HIT,
                               ActivationDecision::ACTIVATION_DISABLED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, NoActivationWhenNoMatch) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeActivationList,
       kActivationListSocialEngineeringAdsInterstitial);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
   NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
                               ActivationDecision::ACTIVATION_LIST_NOT_MATCHED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SpecialCaseNavigationAllSitesEnabled) {
   // Check that when the experiment is enabled for all site, the activation
   // signal is always sent.
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeAllSites);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
   EmulateInPageNavigation({false}, EMPTY, ActivationDecision::ACTIVATED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SpecialCaseNavigationActivationListEnabled) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeActivationList,
       kActivationListSocialEngineeringAdsInterstitial);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
   EmulateInPageNavigation({true}, NO_REDIRECTS_HIT,
                           ActivationDecision::ACTIVATED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SpecialCaseNavigationActivationListEnabledWithPerformanceMeasurement) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeActivationList,
       kActivationListSocialEngineeringAdsInterstitial,
       "1" /* performance_measurement_rate */);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
   EmulateInPageNavigation({true}, NO_REDIRECTS_HIT,
                           ActivationDecision::ACTIVATED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, FailedNavigation) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeAllSites);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
   const GURL url(kExampleUrl);
   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) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeActivationList,
       kActivationListSocialEngineeringAdsInterstitial);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
   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},
@@ skipping 73 matching lines @@
         ActivationDecision::ACTIVATION_LIST_NOT_MATCHED);
 #endif
   }
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, NotificationVisibility) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeAllSites);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
 
   NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
                               ActivationDecision::ACTIVATED);
   EXPECT_CALL(*client(), ToggleNotificationVisibility(true)).Times(1);
   NavigateSubframeAndExpectCheckResult(GURL(kDisallowedUrl),
                                        true /* expect_cancelled */);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        SuppressNotificationVisibility) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeAllSites, "" /* activation_lists */,
       "" /* performance_measurement_rate */,
       "true" /* suppress_notifications */);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
 
   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 22 matching lines @@
     SCOPED_TRACE(::testing::Message("referrer = \"")
                  << test_case.referrer.url << "\""
                  << " transition = \"" << test_case.transition << "\"");
 
     base::FieldTrialList field_trial_list(nullptr);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
         kActivationScopeAllSites, "" /* activation_lists */,
         "" /* performance_measurement_rate */, "" /* suppress_notifications */,
         "true" /* whitelist_site_on_reload */);
+    factory()->set_configuration_for_testing(GetActiveConfiguration());
 
     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_P(ContentSubresourceFilterDriverFactoryActivationLevelTest,
        ActivateForFrameState) {
   const ActivationLevelTestData& test_data = GetParam();
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, test_data.activation_level,
       kActivationScopeActivationList,
       kActivationListSocialEngineeringAdsInterstitial);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
 
   const GURL url(kExampleUrlWithParams);
   NavigateAndExpectActivation({true}, {url}, NO_REDIRECTS_HIT,
                               test_data.expected_activation_decision);
   factory()->AddHostOfURLToWhitelistSet(url);
   NavigateAndExpectActivation(
       {true}, {GURL(kExampleUrlWithParams)}, NO_REDIRECTS_HIT,
-      GetMaximumActivationLevel() == ActivationLevel::DISABLED
+      GetActiveConfiguration().activation_level == ActivationLevel::DISABLED
           ? ActivationDecision::ACTIVATION_DISABLED
           : 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();
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeActivationList, test_data.activation_list);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
 
   const GURL test_url("https://example.com/nonsoceng?q=engsocnon");
   std::vector<GURL> navigation_chain;
 
   ActivationList effective_list = GetListForThreatTypeAndMetadata(
       test_data.threat_type, test_data.threat_type_metadata);
   NavigateAndExpectActivation(
       {false, false, false, true},
       {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC), test_url}, test_data.threat_type,
       test_data.threat_type_metadata, content::Referrer(),
       ui::PAGE_TRANSITION_LINK,
       effective_list != ActivationList::NONE ? F0M0L1 : EMPTY,
       test_data.expected_activation_decision);
 };
 
 TEST_P(ContentSubresourceFilterDriverFactoryActivationScopeTest,
        ActivateForScopeType) {
   const ActivationScopeTestData& test_data = GetParam();
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       test_data.activation_scope,
       kActivationListSocialEngineeringAdsInterstitial);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
 
   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()->AddHostOfURLToWhitelistSet(test_url);
     NavigateAndExpectActivation(
         {test_data.url_matches_activation_list}, {GURL(kExampleUrlWithParams)},
         expected_pattern,
-        GetCurrentActivationScope() == ActivationScope::NO_SITES
+        GetActiveConfiguration().activation_scope == ActivationScope::NO_SITES
             ? ActivationDecision::ACTIVATION_DISABLED
             : ActivationDecision::URL_WHITELISTED);
   }
 };
 
 // Only main frames with http/https schemes should activate, unless the
 // activation scope is for all sites.
 TEST_P(ContentSubresourceFilterDriverFactoryActivationScopeTest,
        ActivateForSupportedUrlScheme) {
   const ActivationScopeTestData& test_data = GetParam();
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       test_data.activation_scope,
       kActivationListSocialEngineeringAdsInterstitial);
+  factory()->set_configuration_for_testing(GetActiveConfiguration());
 
   // 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,
-        GetCurrentActivationScope() == ActivationScope::NO_SITES
+        GetActiveConfiguration().activation_scope == ActivationScope::NO_SITES
             ? ActivationDecision::ACTIVATION_DISABLED
             : 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