Add support for multiple simultaneous subresource_filter::Configurations.

components/subresource_filter/core/browser/subresource_filter_features.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 <algorithm>
 #include <string>
+#include <tuple>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "components/variations/variations_associated_data.h"
@@ skipping 87 matching lines @@
   configuration.ruleset_flavor =
       TakeVariationParamOrReturnEmpty(&params, kRulesetFlavorParameterName);
 
   configuration.should_whitelist_site_on_reload =
       ParseBool(TakeVariationParamOrReturnEmpty(
           &params, kWhitelistSiteOnReloadParameterName));
 
   return configuration;
 }
 
+std::vector<Configuration> MakeConfigVector(Configuration config) {
+  std::vector<Configuration> configs;
+  configs.push_back(std::move(config));
+  return configs;
+}
+
+size_t GetActivationLevelPriority(ActivationLevel activation_level) {
+  constexpr ActivationLevel kValuesInIncreasingOrderOfPriority[] = {

[Charlie Harrison, 2017/04/26 21:28:11]

I see the appeal here but maybe it would just be easier to implement these as
switch/case statements?

You get the compile time checking for free without static asserts, you don't
need to use std::find, and I don't think updating them will be too big a hassle.

[engedy, 2017/05/03 12:04:45]

Done.

+      ActivationLevel::DISABLED, ActivationLevel::DRYRUN,
+      ActivationLevel::ENABLED};
+  static_assert(ActivationLevel::LAST == ActivationLevel::ENABLED,
+                "Priority not defined for ActivationLevel.");
+  const auto* const it =
+      std::find(std::begin(kValuesInIncreasingOrderOfPriority),
+                std::end(kValuesInIncreasingOrderOfPriority), activation_level);
+  DCHECK(it < std::end(kValuesInIncreasingOrderOfPriority));
+  return it - std::begin(kValuesInIncreasingOrderOfPriority);
+}
+
+size_t GetActivationScopePriority(ActivationScope activation_scope) {
+  // The more specific ACTIVATION_LIST trumps the blanket scopes.
+  constexpr ActivationScope kValuesInIncreasingOrderOfPriority[] = {
+      ActivationScope::NO_SITES, ActivationScope::ALL_SITES,
+      ActivationScope::ACTIVATION_LIST};
+  static_assert(ActivationScope::LAST == ActivationScope::ALL_SITES,
+                "Priority not defined for ActivationScope.");
+  const auto* const it =
+      std::find(std::begin(kValuesInIncreasingOrderOfPriority),
+                std::end(kValuesInIncreasingOrderOfPriority), activation_scope);
+  DCHECK(it < std::end(kValuesInIncreasingOrderOfPriority));
+  return it - std::begin(kValuesInIncreasingOrderOfPriority);
+}
+
+// Returns the priority of the |configuration|, where a greater value indicates
+// higher priority.
+std::tuple<size_t, size_t, size_t> GetConfigurationPriority(
+    const Configuration& configuration) {
+  return std::make_tuple(
+      GetActivationLevelPriority(configuration.activation_level),
+      GetActivationScopePriority(configuration.activation_scope),
+      static_cast<size_t>(configuration.activation_list));
+}
+
+std::vector<Configuration> SortConfigsByDecreasingPriority(
+    std::vector<Configuration> configs) {
+  std::sort(configs.begin(), configs.end(),
+            [](const Configuration& a, const Configuration& b) {
+              return GetConfigurationPriority(a) > GetConfigurationPriority(b);

[Charlie Harrison, 2017/04/26 21:28:11]

How does this operator work (can you include a comment)? I assume it compares by
the first elt and goes on to the next elt in case of a tie?

[engedy, 2017/05/03 12:04:45]

Yep, added comment.

+            });
+  return configs;
+}
+
 base::LazyInstance<base::Lock>::Leaky g_active_configurations_lock =
     LAZY_INSTANCE_INITIALIZER;
 
 base::LazyInstance<scoped_refptr<ConfigurationList>>::Leaky
     g_active_configurations = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 const base::Feature kSafeBrowsingSubresourceFilter{
     "SubresourceFilter", base::FEATURE_DISABLED_BY_DEFAULT};
@@ skipping 31 matching lines @@
 Configuration::Configuration(ActivationLevel activation_level,
                              ActivationScope activation_scope,
                              ActivationList activation_list)
     : activation_level(activation_level),
       activation_scope(activation_scope),
       activation_list(activation_list) {}
 Configuration::Configuration(Configuration&&) = default;
 Configuration::~Configuration() = default;
 Configuration& Configuration::operator=(Configuration&&) = default;
 
+ConfigurationList::ConfigurationList(std::vector<Configuration> configs)
+    : ordered_configs_(SortConfigsByDecreasingPriority(std::move(configs))) {}
 ConfigurationList::ConfigurationList(Configuration config)
-    : config_(std::move(config)) {}
+    : ConfigurationList(MakeConfigVector(std::move(config))) {}
 ConfigurationList::~ConfigurationList() = default;
 
+std::string ConfigurationList::GetMostSpecificRulesetFlavor() const {

[Charlie Harrison, 2017/04/26 21:28:11]

Please comment what "most specific" means and how you've implemented it. I don't
readily see how the comparator yields the most specific.

[engedy, 2017/05/03 12:04:45]

Documented in the header, and cleaned up the implementation.

+  if (ordered_configs_.empty())
+    return std::string();
+  const auto it_max = std::max_element(
+      ordered_configs_.begin(), ordered_configs_.end(),
+      [](const Configuration& a, const Configuration& b) {
+        if (a.ruleset_flavor.size() == b.ruleset_flavor.size())
+          return a.ruleset_flavor < b.ruleset_flavor;
+        return a.ruleset_flavor.size() < b.ruleset_flavor.size();
+      });
+  DCHECK(it_max != ordered_configs_.end());
+  return it_max->ruleset_flavor;
+}
+
 scoped_refptr<ConfigurationList> GetActiveConfigurations() {
   base::AutoLock lock(g_active_configurations_lock.Get());
   if (!g_active_configurations.Get()) {
     g_active_configurations.Get() =
         base::MakeShared<ConfigurationList>(ParseFieldTrialConfiguration());
   }
   return g_active_configurations.Get();
 }
 
 namespace testing {
 
 scoped_refptr<ConfigurationList> GetAndSetActivateConfigurations(
     scoped_refptr<ConfigurationList> new_configs) {
   base::AutoLock lock(g_active_configurations_lock.Get());
   auto old_configs = std::move(g_active_configurations.Get());
   g_active_configurations.Get() = std::move(new_configs);
   return old_configs;
 }
 
 }  // namespace testing
 
 }  // namespace subresource_filter