Plumb trial association without overriding a feature to subprocesses.

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 <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 12 matching lines @@
 // have more control over initialization timing. Leaky.
 FeatureList* g_instance = nullptr;
 
 // Some characters are not allowed to appear in feature names or the associated
 // field trial names, as they are used as special characters for command-line
 // serialization. This function checks that the strings are ASCII (since they
 // are used in command-line API functions that require ASCII) and whether there
 // are any reserved characters present, returning true if the string is valid.
 // Only called in DCHECKs.
 bool IsValidFeatureOrFieldTrialName(const std::string& name) {
-  return IsStringASCII(name) && name.find_first_of(",<") == std::string::npos;
+  return IsStringASCII(name) && name.find_first_of(",<*") == std::string::npos;
 }
 
 }  // namespace
 
 FeatureList::FeatureList() : initialized_(false) {}
 
 FeatureList::~FeatureList() {}
 
 void FeatureList::InitializeFromCommandLine(
     const std::string& enable_features,
@@ skipping 48 matching lines @@
   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();
 
+  // Note: Since |overrides_| is a std::map, iteration will be in alphabetical
+  // order. This not guaranteed to users of this function, but is useful for
+  // tests to assume the order.
   for (const auto& entry : overrides_) {
     std::string* target_list = nullptr;
     switch (entry.second.overridden_state) {
+      case OVERRIDE_USE_DEFAULT:
       case OVERRIDE_ENABLE_FEATURE:
         target_list = enable_overrides;
         break;
       case OVERRIDE_DISABLE_FEATURE:
         target_list = disable_overrides;
         break;
-      case OVERRIDE_USE_DEFAULT:
-        continue;
     }
 
     if (!target_list->empty())
       target_list->push_back(',');
+    if (entry.second.overridden_state == OVERRIDE_USE_DEFAULT)
+      target_list->push_back('*');
     target_list->append(entry.first);
     if (entry.second.field_trial) {
       target_list->push_back('<');
       target_list->append(entry.second.field_trial->trial_name());
     }
   }
 }
 
 // static
 bool FeatureList::IsEnabled(const Feature& feature) {
@@ skipping 81 matching lines @@
 }
 
 void FeatureList::RegisterOverride(StringPiece feature_name,
                                    OverrideState overridden_state,
                                    FieldTrial* field_trial) {
   DCHECK(!initialized_);
   if (field_trial) {
     DCHECK(IsValidFeatureOrFieldTrialName(field_trial->trial_name()))
         << field_trial->trial_name();
   }
+  if (feature_name.starts_with("*")) {
+    feature_name = feature_name.substr(1);
+    overridden_state = OVERRIDE_USE_DEFAULT;
+  }
 
   // Note: The semantics of insert() is that it does not overwrite the entry if
   // one already exists for the key. Thus, only the first override for a given
   // feature name takes effect.
   overrides_.insert(std::make_pair(
       feature_name.as_string(), OverrideEntry(overridden_state, field_trial)));
 }
 
 bool FeatureList::CheckFeatureIdentity(const Feature& feature) {
   AutoLock auto_lock(feature_identity_tracker_lock_);
 
   auto it = feature_identity_tracker_.find(feature.name);
   if (it == feature_identity_tracker_.end()) {
     // If it's not tracked yet, register it.
     feature_identity_tracker_[feature.name] = &feature;
     return true;
   }
   // Compare address of |feature| to the existing tracked entry.
   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