Introduce subresource_filter::Configuration.

components/subresource_filter/core/browser/subresource_filter_features_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/core/browser/subresource_filter_features.h"
 
 #include <string>
 
 #include "base/metrics/field_trial.h"
 #include "components/subresource_filter/core/browser/subresource_filter_features_test_support.h"
@@ skipping 24 matching lines @@
     SCOPED_TRACE(::testing::Message("Enabled = ") << test_case.feature_enabled);
     SCOPED_TRACE(::testing::Message("ActivationLevelParam = \"")
                  << test_case.activation_level_param << "\"");
 
     base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         test_case.feature_enabled ? base::FeatureList::OVERRIDE_ENABLE_FEATURE
                                   : base::FeatureList::OVERRIDE_USE_DEFAULT,
         test_case.activation_level_param, kActivationScopeNoSites);
 
-    EXPECT_EQ(test_case.expected_activation_level, GetMaximumActivationLevel());
-    EXPECT_EQ(ActivationScope::NO_SITES, GetCurrentActivationScope());
+    Configuration actual_configuration = GetActiveConfiguration();
+    EXPECT_EQ(test_case.expected_activation_level,
+              actual_configuration.activation_level);
+    EXPECT_EQ(ActivationScope::NO_SITES, actual_configuration.activation_scope);
   }
 }
 
 TEST(SubresourceFilterFeaturesTest, ActivationScope) {
   const struct {
     bool feature_enabled;
     const char* activation_scope_param;
     ActivationScope expected_activation_scope;
   } kTestCases[] = {
       {false, "", ActivationScope::NO_SITES},
@@ skipping 13 matching lines @@
     SCOPED_TRACE(::testing::Message("Enabled = ") << test_case.feature_enabled);
     SCOPED_TRACE(::testing::Message("ActivationScopeParam = \"")
                  << test_case.activation_scope_param << "\"");
 
     base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         test_case.feature_enabled ? base::FeatureList::OVERRIDE_ENABLE_FEATURE
                                   : base::FeatureList::OVERRIDE_USE_DEFAULT,
         kActivationLevelDisabled, test_case.activation_scope_param);
 
-    EXPECT_EQ(ActivationLevel::DISABLED, GetMaximumActivationLevel());
-    EXPECT_EQ(test_case.expected_activation_scope, GetCurrentActivationScope());
+    Configuration actual_configuration = GetActiveConfiguration();
+    EXPECT_EQ(ActivationLevel::DISABLED, actual_configuration.activation_level);
+    EXPECT_EQ(test_case.expected_activation_scope,
+              actual_configuration.activation_scope);
   }
 }
 
 TEST(SubresourceFilterFeaturesTest, ActivationLevelAndScope) {
   const struct {
     bool feature_enabled;
     const char* activation_level_param;
     ActivationLevel expected_activation_level;
     const char* activation_scope_param;
     ActivationScope expected_activation_scope;
@@ skipping 27 matching lines @@
       {false, kActivationLevelEnabled, ActivationLevel::DISABLED,
        kActivationScopeAllSites, ActivationScope::NO_SITES}};
 
   for (const auto& test_case : kTestCases) {
     base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         test_case.feature_enabled ? base::FeatureList::OVERRIDE_ENABLE_FEATURE
                                   : base::FeatureList::OVERRIDE_USE_DEFAULT,
         test_case.activation_level_param, test_case.activation_scope_param);
 
-    EXPECT_EQ(test_case.expected_activation_scope, GetCurrentActivationScope());
-    EXPECT_EQ(test_case.expected_activation_level, GetMaximumActivationLevel());
+    Configuration actual_configuration = GetActiveConfiguration();
+    EXPECT_EQ(test_case.expected_activation_level,
+              actual_configuration.activation_level);
+    EXPECT_EQ(test_case.expected_activation_scope,
+              actual_configuration.activation_scope);
   }
 }
 
 TEST(SubresourceFilterFeaturesTest, ActivationList) {
   const std::string activation_soc_eng(
       kActivationListSocialEngineeringAdsInterstitial);
   const std::string activation_phishing(kActivationListPhishingInterstitial);
   const std::string socEngPhising = activation_soc_eng + activation_phishing;
   const std::string socEngCommaPhising =
       activation_soc_eng + "," + activation_phishing;
@@ skipping 31 matching lines @@
     SCOPED_TRACE(::testing::Message("ActivationListParam = \"")
                  << test_case.activation_list_param << "\"");
 
     base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         test_case.feature_enabled ? base::FeatureList::OVERRIDE_ENABLE_FEATURE
                                   : base::FeatureList::OVERRIDE_USE_DEFAULT,
         kActivationLevelDisabled, kActivationScopeNoSites,
         test_case.activation_list_param);
 
-    EXPECT_EQ(test_case.expected_activation_list, GetCurrentActivationList());
+    Configuration actual_configuration = GetActiveConfiguration();
+    EXPECT_EQ(test_case.expected_activation_list,
+              actual_configuration.activation_list);
   }
 }
 
 TEST(SubresourceFilterFeaturesTest, PerfMeasurementRate) {
   const struct {
     bool feature_enabled;
     const char* perf_measurement_param;
     double expected_perf_measurement_rate;
   } kTestCases[] = {{false, "not_a_number", 0},
                     {false, "0", 0},
@@ skipping 14 matching lines @@
     SCOPED_TRACE(::testing::Message("PerfMeasurementParam = \"")
                  << test_case.perf_measurement_param << "\"");
 
     base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         test_case.feature_enabled ? base::FeatureList::OVERRIDE_ENABLE_FEATURE
                                   : base::FeatureList::OVERRIDE_USE_DEFAULT,
         {{kPerformanceMeasurementRateParameterName,
           test_case.perf_measurement_param}});
 
+    Configuration actual_configuration = GetActiveConfiguration();
     EXPECT_EQ(test_case.expected_perf_measurement_rate,
-              GetPerformanceMeasurementRate());
+              actual_configuration.performance_measurement_rate);
   }
 }
 
 TEST(SubresourceFilterFeaturesTest, SuppressNotifications) {
   const struct {
     bool feature_enabled;
     const char* suppress_notifications_param;
     bool expected_suppress_notifications_value;
   } kTestCases[] = {{false, "", false},
                     {false, "true", false},
                     {false, "false", false},
                     {false, "invalid value", false},
                     {true, "", false},
                     {true, "false", false},
                     {true, "invalid value", false},
-                    {true, "True", false},
-                    {true, "TRUE", false},
+                    {true, "True", true},
+                    {true, "TRUE", true},
                     {true, "true", true}};
 
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(::testing::Message("Enabled = ") << test_case.feature_enabled);
     SCOPED_TRACE(::testing::Message("SuppressNotificationsParam = \"")
                  << test_case.suppress_notifications_param << "\"");
 
     base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         test_case.feature_enabled ? base::FeatureList::OVERRIDE_ENABLE_FEATURE
                                   : base::FeatureList::OVERRIDE_USE_DEFAULT,
         {{kSuppressNotificationsParameterName,
           test_case.suppress_notifications_param}});
 
+    Configuration actual_configuration = GetActiveConfiguration();
     EXPECT_EQ(test_case.expected_suppress_notifications_value,
-              ShouldSuppressNotifications());
+              actual_configuration.should_suppress_notifications);
   }
 }
 
 TEST(SubresourceFilterFeaturesTest, WhitelistSiteOnReload) {
   const struct {
     bool feature_enabled;
     const char* whitelist_site_on_reload_param;
     bool expected_whitelist_site_on_reload_value;
   } kTestCases[] = {{false, "", false},
                     {false, "true", false},
                     {false, "false", false},
                     {false, "invalid value", false},
                     {true, "", false},
                     {true, "false", false},
                     {true, "invalid value", false},
-                    {true, "True", false},
-                    {true, "TRUE", false},
+                    {true, "True", true},
+                    {true, "TRUE", true},
                     {true, "true", true}};
 
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(::testing::Message("Enabled = ") << test_case.feature_enabled);
     SCOPED_TRACE(::testing::Message("WhitelistSiteOnReloadParam = \"")
                  << test_case.whitelist_site_on_reload_param << "\"");
 
     base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         test_case.feature_enabled ? base::FeatureList::OVERRIDE_ENABLE_FEATURE
                                   : base::FeatureList::OVERRIDE_USE_DEFAULT,
         {{kWhitelistSiteOnReloadParameterName,
           test_case.whitelist_site_on_reload_param}});
 
+    Configuration actual_configuration = GetActiveConfiguration();
     EXPECT_EQ(test_case.expected_whitelist_site_on_reload_value,
-              ShouldWhitelistSiteOnReload());
+              actual_configuration.should_whitelist_site_on_reload);
   }
 }
 
 }  // namespace subresource_filter