Split the ScopedSubresourceFilterFeatureToggle into two helper classes.

components/subresource_filter/core/browser/subresource_filter_features.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_CORE_BROWSER_SUBRESOURCE_FILTER_FEATURES_H_
 #define COMPONENTS_SUBRESOURCE_FILTER_CORE_BROWSER_SUBRESOURCE_FILTER_FEATURES_H_
 
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "components/subresource_filter/core/common/activation_level.h"
 #include "components/subresource_filter/core/common/activation_list.h"
 #include "components/subresource_filter/core/common/activation_scope.h"
 
 namespace subresource_filter {
 
 // Encapsulates all parameters that define how the subresource filter feature
 // should operate.
 struct Configuration {
   Configuration();
+  Configuration(ActivationLevel activation_level,
+                ActivationScope activation_scope,
+                ActivationList activation_list = ActivationList::NONE);
+  Configuration(Configuration&&);
   ~Configuration();
-  Configuration(Configuration&&);
   Configuration& operator=(Configuration&&);
 
   // The maximum degree to which subresource filtering should be activated on
   // any RenderFrame. This will be ActivationLevel::DISABLED unless the feature
   // is enabled and variation parameters prescribe a higher activation level.
   ActivationLevel activation_level = ActivationLevel::DISABLED;
 
   // The activation scope. That is, the subset of page loads where subresource
   // filtering should be activated. This will be ActivationScope::NO_SITES
   // unless the feature is =enabled and variation parameters prescribe a wider
   // activation scope.
   ActivationScope activation_scope = ActivationScope::NO_SITES;
 
   // The activation list to use when the |activation_scope| is ACTIVATION_LIST.
   // This will be ActivationList::NONE unless variation parameters prescribe a
   // recognized list.
   ActivationList activation_list = ActivationList::NONE;
 
   // A number in the range [0, 1], indicating the fraction of page loads that
   // should have extended performance measurements enabled. The rate will
   // be 0 unless a greater frequency is specified by variation parameters.
   double performance_measurement_rate = 0.0;
 
   // Whether notifications indicating that a subresource was disallowed should
   // be suppressed in the UI.
   bool should_suppress_notifications = false;
 
-  // The ruleset flavor to download through the component updater, or the empty
-  // string if the default ruleset should be used.
+  // The ruleset flavor to download through the component updater. This or the
+  // empty string if the default ruleset should be used.
   std::string ruleset_flavor;
 
   // Whether to whitelist a site when a page loaded from that site is reloaded.
   bool should_whitelist_site_on_reload = false;
 };
 
 // TODO(engedy): Make this an actual list once all call sites are prepared to
 // handle multiple simultaneous configurations.
 class ConfigurationList : public base::RefCountedThreadSafe<ConfigurationList> {
  public:
   explicit ConfigurationList(Configuration config);
 
   const Configuration& the_one_and_only() const { return config_; }
 
  private:
   friend class base::RefCountedThreadSafe<ConfigurationList>;
   ~ConfigurationList();
 
   const Configuration config_;
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurationList);
 };
 
 // Retrieves all currently enabled subresource filtering configurations. The
 // configurations are parsed on first access and then the result is cached.
 //
-// In tests, however, the config may change in-between navigations, so callers
-// should not hold on to the result for long.
+// In tests, however, the config may be altered in-between navigations, so
+// callers should not hold on to the result for long.
 scoped_refptr<ConfigurationList> GetActiveConfigurations();
 
 namespace testing {
 
-// Clears the cached active ConfigurationList so that it will be recomputed on
-// next access. Used in tests when the variation parameters are altered.
-void ClearCachedActiveConfigurations();
+// Returns the currently cached active ConfigurationList, if any, and replaces
+// it with |configs|, which may be nullptr to clear the cache.
+scoped_refptr<ConfigurationList> ReplaceCachedActiveConfigurations(

[Charlie Harrison, 2017/04/25 19:36:21]

This is like a get-and-set right? Maybe
GetAndSetActiveConfigurations(scoped_refptr<ConfigurationList> new_configs)?

[engedy, 2017/04/25 20:13:24]

Done.

+    scoped_refptr<ConfigurationList> configs);
 
 }  // namespace testing
 
 // Feature and variation parameter definitions -------------------------------
 
 // The master toggle to enable/disable the Safe Browsing Subresource Filter.
 extern const base::Feature kSafeBrowsingSubresourceFilter;
 
 // Enables the new experimental UI for the Subresource Filter.
 extern const base::Feature kSafeBrowsingSubresourceFilterExperimentalUI;
@@ skipping 18 matching lines @@
 
 extern const char kPerformanceMeasurementRateParameterName[];
 
 extern const char kSuppressNotificationsParameterName[];
 
 extern const char kWhitelistSiteOnReloadParameterName[];
 
 }  // namespace subresource_filter
 
 #endif  // COMPONENTS_SUBRESOURCE_FILTER_CORE_BROWSER_SUBRESOURCE_FILTER_FEATURES_H_