Expand FeatureList to support FieldTrial association.

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 <vector>
 
 #include "base/logging.h"
+#include "base/metrics/field_trial.h"
 #include "base/strings/string_split.h"
 
 namespace base {
 
 namespace {
 
 // Pointer to the FeatureList instance singleton that was set via
 // FeatureList::SetInstance(). Does not use base/memory/singleton.h in order to
 // have more control over initialization timing. Leaky.
 FeatureList* g_instance = nullptr;
@@ skipping 10 matching lines @@
 FeatureList::~FeatureList() {}
 
 void FeatureList::InitializeFromCommandLine(
     const std::string& enable_features,
     const std::string& disable_features) {
   DCHECK(!initialized_);
 
   // Process disabled features first, so that disabled ones take precedence over
   // enabled ones (since RegisterOverride() uses insert()).
   for (const auto& feature_name : SplitFeatureListString(disable_features)) {
-    RegisterOverride(feature_name, OVERRIDE_DISABLE_FEATURE);
+    RegisterOverride(feature_name, OVERRIDE_DISABLE_FEATURE, nullptr);
   }
   for (const auto& feature_name : SplitFeatureListString(enable_features)) {
-    RegisterOverride(feature_name, OVERRIDE_ENABLE_FEATURE);
+    RegisterOverride(feature_name, OVERRIDE_ENABLE_FEATURE, nullptr);
   }
 }
 
+void FeatureList::RegisterFieldTrialOverride(const std::string& feature_name,
+                                             OverrideState override_state,
+                                             FieldTrial* field_trial) {
+  DCHECK(field_trial);
+  const auto& result =
+      RegisterOverride(feature_name, override_state, field_trial);
+  // The call above should either succeed or if it failed, it should be because
+  // of an override that doesn't have a field trial (i.e. a command-line based
+  // one). It's not valid for two field trials to try to override the state of
+  // the same feature.
+  if (!result.second && result.first.field_trial) {
+    NOTREACHED() << "Feature " << feature_name
+                 << " has conflicting field trial overrides: "
+                 << result.first.field_trial->trial_name() << " / "
+                 << field_trial->trial_name();
+  }

[Ilya Sherman, 2015/09/24 01:11:32]

I think that rather than returning a pair from RegisterOverride(), it might be
simpler to write this method as something like

  // It's not valid for two field trials to try to override the state of the
  // same feature.
  DCHECK(!ContainsKey(overrides_, feature_name) ||
         !overrides_[feature_name].field_trial)
      << "Feature " << feature_name
      << " has conflicting field trial overrides: "
      << result.first.field_trial->trial_name() << " / "
      << field_trial->trial_name();

  RegisterOverride(feature_name, override_state, field_trial);

[Alexei Svitkine (slow), 2015/09/24 20:49:21]

Thanks, that does simplify things a lot! Done.

+}
+
+FieldTrial* FeatureList::AssociateReportingFieldTrial(
+    const std::string& feature_name,
+    OverrideState for_overridden_state,
+    const std::string& field_trial_name,
+    const std::string& group_name) {
+  auto it = overrides_.find(feature_name);
+  // No association if there's no override entry or its state doesn't match
+  // |for_overridden_state|.
+  if (it == overrides_.end() ||
+      it->second.overridden_state != for_overridden_state) {
+    return nullptr;
+  }
+
+  // Only one associated field trial is supported per feature. This is generally
+  // enforced server-side.
+  if (it->second.field_trial) {
+    NOTREACHED() << "Feature = " << feature_name
+                 << ", has trial = " << it->second.field_trial->trial_name()
+                 << ", associating trial = " << field_trial_name;
+    return nullptr;
+  }
+  it->second.field_trial =
+      FieldTrialList::CreateFieldTrial(field_trial_name, group_name);
+  return it->second.field_trial;
+}
+
 // static
 bool FeatureList::IsEnabled(const Feature& feature) {
   return GetInstance()->IsFeatureEnabled(feature);
 }
 
 // static
 FeatureList* FeatureList::GetInstance() {
   return g_instance;
 }
 
@@ skipping 17 matching lines @@
   initialized_ = true;
 }
 
 bool FeatureList::IsFeatureEnabled(const Feature& feature) {
   DCHECK(initialized_);
   DCHECK(CheckFeatureIdentity(feature)) << feature.name;
 
   auto it = overrides_.find(feature.name);
   if (it != overrides_.end()) {
     const OverrideEntry& entry = it->second;
+
+    // Activate the corresponding field trial, if necessary.
+    if (entry.field_trial)
+      entry.field_trial->group();
+
     // TODO(asvitkine) Expand this section as more support is added.
     return entry.overridden_state == OVERRIDE_ENABLE_FEATURE;
   }
   // Otherwise, return the default state.
   return feature.default_state == FEATURE_ENABLED_BY_DEFAULT;
 }
 
-void FeatureList::RegisterOverride(const std::string& feature_name,
-                                   OverrideState overridden_state) {
+std::pair<const FeatureList::OverrideEntry&, bool>
+FeatureList::RegisterOverride(const std::string& feature_name,
+                              OverrideState overridden_state,
+                              FieldTrial* field_trial) {
   DCHECK(!initialized_);
-  overrides_.insert(make_pair(feature_name, OverrideEntry(overridden_state)));
+  // 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.
+  const auto& result = overrides_.insert(std::make_pair(
+      feature_name, OverrideEntry(overridden_state, field_trial)));
+  return std::make_pair(result.first->second, result.second);
 }
 
 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)
-    : overridden_state(overridden_state) {}
+FeatureList::OverrideEntry::OverrideEntry(OverrideState overridden_state,
+                                          FieldTrial* field_trial)
+    : overridden_state(overridden_state), field_trial(field_trial) {}
 
 }  // namespace base