Expand FeatureList to support FieldTrial association.

base/feature_list_unittest.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 "base/metrics/field_trial.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 const char kFeatureOnByDefaultName[] = "OnByDefault";
 struct Feature kFeatureOnByDefault {
   kFeatureOnByDefaultName, FEATURE_ENABLED_BY_DEFAULT
 };
 
 const char kFeatureOffByDefaultName[] = "OffByDefault";
 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 {
  public:
   FeatureListTest() : feature_list_(nullptr) {
     RegisterFeatureListInstance(make_scoped_ptr(new FeatureList));
   }
   ~FeatureListTest() override { ClearFeatureListInstance(); }
 
   void RegisterFeatureListInstance(scoped_ptr<FeatureList> feature_list) {
@@ skipping 65 matching lines @@
   EXPECT_TRUE(feature_list()->CheckFeatureIdentity(kFeatureOffByDefault));
 
   // Now, call it with a distinct struct for |kFeatureOnByDefaultName|, which
   // should return false.
   struct Feature kFeatureOnByDefault2 {
     kFeatureOnByDefaultName, FEATURE_ENABLED_BY_DEFAULT
   };
   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