Make FeatureList override state be plumbed to renderer processes.

base/feature_list.cc

 // Copyright 2015 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 "base/feature_list.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 31 matching lines @@
 }
 
 bool FeatureList::IsFeatureOverriddenFromCommandLine(
     const std::string& feature_name,
     OverrideState state) const {
   auto it = overrides_.find(feature_name);
   return it != overrides_.end() && it->second.overridden_state == state &&
          !it->second.overridden_by_field_trial;
 }
 
-void FeatureList::RegisterFieldTrialOverride(const std::string& feature_name,
-                                             OverrideState override_state,
-                                             FieldTrial* field_trial) {
-  DCHECK(field_trial);
-  DCHECK(!ContainsKey(overrides_, feature_name) ||
-         !overrides_.find(feature_name)->second.field_trial)
-      << "Feature " << feature_name
-      << " has conflicting field trial overrides: "
-      << overrides_.find(feature_name)->second.field_trial->trial_name()
-      << " / " << field_trial->trial_name();
-
-  RegisterOverride(feature_name, override_state, field_trial);
-}
-
 void FeatureList::AssociateReportingFieldTrial(
     const std::string& feature_name,
     OverrideState for_overridden_state,
     FieldTrial* field_trial) {
   DCHECK(
       IsFeatureOverriddenFromCommandLine(feature_name, for_overridden_state));
 
   // Only one associated field trial is supported per feature. This is generally
   // enforced server-side.
   OverrideEntry* entry = &overrides_.find(feature_name)->second;
   if (entry->field_trial) {
     NOTREACHED() << "Feature " << feature_name
                  << " already has trial: " << entry->field_trial->trial_name()
                  << ", associating trial: " << field_trial->trial_name();
     return;
   }
 
   entry->field_trial = field_trial;
 }
 
+void FeatureList::RegisterFieldTrialOverride(const std::string& feature_name,
+                                             OverrideState override_state,
+                                             FieldTrial* field_trial) {
+  DCHECK(field_trial);
+  DCHECK(!ContainsKey(overrides_, feature_name) ||
+         !overrides_.find(feature_name)->second.field_trial)
+      << "Feature " << feature_name
+      << " has conflicting field trial overrides: "
+      << overrides_.find(feature_name)->second.field_trial->trial_name()
+      << " / " << field_trial->trial_name();
+
+  RegisterOverride(feature_name, override_state, field_trial);
+}
+
+void FeatureList::GetFeatureOverrides(std::string* enable_overrides,
+                                      std::string* disable_overrides) {
+  DCHECK(initialized_);
+
+  enable_overrides->clear();
+  disable_overrides->clear();
+
+  for (const auto& entry : overrides_) {
+    switch (entry.second.overridden_state) {
+      case OVERRIDE_ENABLE_FEATURE:
+        if (!enable_overrides->empty())
+          enable_overrides->push_back(',');
+        enable_overrides->append(entry.first);
+        break;
+      case OVERRIDE_DISABLE_FEATURE:
+        if (!disable_overrides->empty())
+          disable_overrides->push_back(',');
+        disable_overrides->append(entry.first);
+        break;
+    }
+  }
+}
+
 // static
 bool FeatureList::IsEnabled(const Feature& feature) {
   return GetInstance()->IsFeatureEnabled(feature);
 }
 
 // static
 std::vector<std::string> FeatureList::SplitFeatureListString(
     const std::string& input) {
   return SplitString(input, ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
 }
@@ skipping 73 matching lines @@
   return it->second == &feature;
 }
 
 FeatureList::OverrideEntry::OverrideEntry(OverrideState overridden_state,
                                           FieldTrial* field_trial)
     : overridden_state(overridden_state),
       field_trial(field_trial),
       overridden_by_field_trial(field_trial != nullptr) {}
 
 }  // namespace base