Expand FeatureList to support FieldTrial association.

base/feature_list_unittest.cc

Index: base/feature_list_unittest.cc
diff --git a/base/feature_list_unittest.cc b/base/feature_list_unittest.cc
index c9423ce776a7a00773dd0a2535e91a7603b95170..384d4bbf1fff4478e9da1219363721ae7987f3b8 100644
--- a/base/feature_list_unittest.cc
+++ b/base/feature_list_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "base/feature_list.h"
 
+#include "base/metrics/field_trial.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
@@ -20,6 +21,18 @@ struct Feature kFeatureOffByDefault {
   kFeatureOffByDefaultName, FEATURE_DISABLED_BY_DEFAULT
 };
 
+// Tests whether a field trial is active (i.e. group() has been called on it),
+// using public FieldTrial API (which doesn't expose this state on the object).
+bool IsFieldTrialActive(FieldTrial* trial) {
+  base::FieldTrial::ActiveGroups active_groups;
+  base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
+  for (size_t i = 0; i < active_groups.size(); ++i) {
+    if (active_groups[i].trial_name == trial->trial_name())
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 class FeatureListTest : public testing::Test {
@@ -105,4 +118,127 @@ TEST_F(FeatureListTest, CheckFeatureIdentity) {
   EXPECT_FALSE(feature_list()->CheckFeatureIdentity(kFeatureOnByDefault2));
 }
 
+TEST_F(FeatureListTest, FieldTrialOverrides) {
+  struct {
+    FeatureList::OverrideState trial1_state;
+    FeatureList::OverrideState trial2_state;
+  } test_cases[] = {
+      {FeatureList::OVERRIDE_DISABLE_FEATURE,
+       FeatureList::OVERRIDE_DISABLE_FEATURE},
+      {FeatureList::OVERRIDE_DISABLE_FEATURE,
+       FeatureList::OVERRIDE_ENABLE_FEATURE},
+      {FeatureList::OVERRIDE_ENABLE_FEATURE,
+       FeatureList::OVERRIDE_DISABLE_FEATURE},
+      {FeatureList::OVERRIDE_ENABLE_FEATURE,
+       FeatureList::OVERRIDE_ENABLE_FEATURE},
+  };
+
+  FieldTrial::ActiveGroup active_group;
+  for (size_t i = 0; i < arraysize(test_cases); i++) {
+    const auto& test_case = test_cases[i];
+
+    ClearFeatureListInstance();
+
+    FieldTrialList field_trial_list(nullptr);
+    scoped_ptr<FeatureList> feature_list(new FeatureList);
+
+    FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A");
+    FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B");
+    feature_list->RegisterFieldTrialOverride(kFeatureOnByDefaultName,
+                                             test_case.trial1_state, trial1);
+    feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName,
+                                             test_case.trial2_state, trial2);
+    RegisterFeatureListInstance(feature_list.Pass());
+
+    // Initially, neither trial should be active.
+    EXPECT_FALSE(IsFieldTrialActive(trial1));
+    EXPECT_FALSE(IsFieldTrialActive(trial2));
+
+    const bool expected_enabled_1 =
+        (test_case.trial1_state == FeatureList::OVERRIDE_ENABLE_FEATURE);
+    EXPECT_EQ(expected_enabled_1, FeatureList::IsEnabled(kFeatureOnByDefault));
+    // The above should have activated |trial1|.
+    EXPECT_TRUE(IsFieldTrialActive(trial1));
+    EXPECT_FALSE(IsFieldTrialActive(trial2));
+
+    const bool expected_enabled_2 =
+        (test_case.trial2_state == FeatureList::OVERRIDE_ENABLE_FEATURE);
+    EXPECT_EQ(expected_enabled_2, FeatureList::IsEnabled(kFeatureOffByDefault));
+    // The above should have activated |trial2|.
+    EXPECT_TRUE(IsFieldTrialActive(trial1));
+    EXPECT_TRUE(IsFieldTrialActive(trial2));
+  }
+}
+
+TEST_F(FeatureListTest, CommandLineTakesPrecedenceOverFieldTrial) {
+  ClearFeatureListInstance();
+
+  FieldTrialList field_trial_list(nullptr);
+  scoped_ptr<FeatureList> feature_list(new FeatureList);
+
+  // The feature is explicitly enabled on the command-line.
+  feature_list->InitializeFromCommandLine(kFeatureOffByDefaultName, "");
+
+  // But the FieldTrial would set the feature to disabled.
+  FieldTrial* trial = FieldTrialList::CreateFieldTrial("TrialExample2", "A");
+  feature_list->RegisterFieldTrialOverride(
+      kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE, trial);
+  RegisterFeatureListInstance(feature_list.Pass());
+
+  EXPECT_FALSE(IsFieldTrialActive(trial));
+  // Command-line should take precedence.
+  EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
+  // Since the feature is on due to the command-line, and not as a result of the
+  // field trial, the field trial should not be activated (since the Associate*
+  // API wasn't used.)
+  EXPECT_FALSE(IsFieldTrialActive(trial));
+}
+
+TEST_F(FeatureListTest, AssociateReportingFieldTrial) {
+  struct {
+    const char* enable_features;
+    const char* disable_features;
+    bool expected_trial1;
+    bool expected_trial2;
+  } test_cases[] = {

[rkaplow, 2015/09/14 21:20:12]

comment on what these different elements are for

[Alexei Svitkine (slow), 2015/09/14 22:03:43]

Done. Also tweaked the test body to give some more meaningful names to the two
trials.

+      {"", "", false, false},
+      {kFeatureOffByDefaultName, "", false, true},
+      {"", kFeatureOffByDefaultName, true, false},
+  };
+
+  for (size_t i = 0; i < arraysize(test_cases); i++) {
+    const auto& test_case = test_cases[i];
+
+    ClearFeatureListInstance();
+
+    FieldTrialList field_trial_list(nullptr);
+    scoped_ptr<FeatureList> feature_list(new FeatureList);
+    feature_list->InitializeFromCommandLine(test_case.enable_features,
+                                            test_case.disable_features);
+
+    const std::string trial_name = "ForcingTrial";
+    FieldTrial* trial1 = feature_list->AssociateReportingFieldTrial(
+        kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE,
+        trial_name, "ForcedOff");
+    EXPECT_EQ(test_case.expected_trial1, trial1 != nullptr);
+    FieldTrial* trial2 = feature_list->AssociateReportingFieldTrial(
+        kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE,
+        trial_name, "ForcedOn");
+    EXPECT_EQ(test_case.expected_trial2, trial2 != nullptr);
+    RegisterFeatureListInstance(feature_list.Pass());
+
+    if (trial1) {
+      EXPECT_FALSE(IsFieldTrialActive(trial1));
+      EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
+      EXPECT_TRUE(IsFieldTrialActive(trial1));
+      EXPECT_EQ("ForcedOff", trial1->group_name());
+    } else if (trial2) {
+      EXPECT_FALSE(IsFieldTrialActive(trial2));
+      EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
+      EXPECT_TRUE(IsFieldTrialActive(trial2));
+      EXPECT_EQ("ForcedOn", trial2->group_name());
+    }
+  }
+}
+
 }  // namespace base