Add a ScopedFeatureList class for testing and start using it.

components/variations/variations_seed_processor_unittest.cc

 // Copyright 2013 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 "components/variations/variations_seed_processor.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/mock_entropy_provider.h"
+#include "base/test/scoped_feature_list.h"
 #include "components/variations/processed_study.h"
 #include "components/variations/study_filtering.h"
 #include "components/variations/variations_associated_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace variations {
 
 namespace {
 
 // Converts |time| to Study proto format.
@@ skipping 76 matching lines @@
 class VariationsSeedProcessorTest : public ::testing::Test {
  public:
   VariationsSeedProcessorTest() {
   }
 
   ~VariationsSeedProcessorTest() override {
     // Ensure that the maps are cleared between tests, since they are stored as
     // process singletons.
     testing::ClearAllVariationIDs();
     testing::ClearAllVariationParams();
-
-    base::FeatureList::ClearInstanceForTesting();
   }
 
   bool CreateTrialFromStudy(const Study& study) {
     return CreateTrialFromStudyWithFeatureListAndEntropyOverride(
         study, nullptr, &feature_list_);
   }
 
   bool CreateTrialFromStudyWithEntropyOverride(
       const Study& study,
       const base::FieldTrial::EntropyProvider* override_entropy_provider) {
@@ skipping 482 matching lines @@
       {kFeatureOffByDefault.name, nullptr, true, true},
       {nullptr, kFeatureOnByDefault.name, false, false},
       {nullptr, kFeatureOffByDefault.name, false, true},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     const auto& test_case = test_cases[i];
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i));
 
     base::FieldTrialList field_trial_list(nullptr);
-    base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
 
     Study study;
     study.set_name("Study1");
     study.set_default_experiment_name("B");
     AddExperiment("B", 0, &study);
 
     Study_Experiment* experiment = AddExperiment("A", 1, &study);
     Study_Experiment_FeatureAssociation* association =
         experiment->mutable_feature_association();
     if (test_case.enable_feature)
       association->add_enable_feature(test_case.enable_feature);
     else if (test_case.disable_feature)
       association->add_disable_feature(test_case.disable_feature);
 
     EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
-    base::FeatureList::SetInstance(std::move(feature_list));
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitWithFeatureList(std::move(feature_list));
 
     // |kUnrelatedFeature| should not be affected.
     EXPECT_FALSE(base::FeatureList::IsEnabled(kUnrelatedFeature));
 
     // Before the associated feature is queried, the trial shouldn't be active.
     EXPECT_FALSE(base::FieldTrialList::IsTrialActive(study.name()));
 
     EXPECT_EQ(test_case.expected_feature_off_state,
               base::FeatureList::IsEnabled(kFeatureOffByDefault));
     EXPECT_EQ(test_case.expected_feature_on_state,
@@ skipping 85 matching lines @@
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     const auto& test_case = test_cases[i];
     const int group = test_case.one_hundred_percent_group;
     SCOPED_TRACE(base::StringPrintf(
         "Test[%" PRIuS "]: %s [%s] [%s] %d", i, test_case.feature.name,
         test_case.enable_features_command_line,
         test_case.disable_features_command_line, static_cast<int>(group)));
 
     base::FieldTrialList field_trial_list(nullptr);
-    base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->InitializeFromCommandLine(
         test_case.enable_features_command_line,
         test_case.disable_features_command_line);
 
     Study study;
     study.set_name("Study1");
     study.set_default_experiment_name(kDefaultGroup);
     AddExperiment(kDefaultGroup, group == DEFAULT_GROUP ? 1 : 0, &study);
 
     Study_Experiment* feature_enable =
         AddExperiment(kEnabledGroup, group == ENABLE_GROUP ? 1 : 0, &study);
     feature_enable->mutable_feature_association()->add_enable_feature(
         test_case.feature.name);
 
     Study_Experiment* feature_disable =
         AddExperiment(kDisabledGroup, group == DISABLE_GROUP ? 1 : 0, &study);
     feature_disable->mutable_feature_association()->add_disable_feature(
         test_case.feature.name);
 
     AddExperiment(kForcedOnGroup, 0, &study)
         ->mutable_feature_association()
         ->set_forcing_feature_on(test_case.feature.name);
     AddExperiment(kForcedOffGroup, 0, &study)
         ->mutable_feature_association()
         ->set_forcing_feature_off(test_case.feature.name);
 
     EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
-    base::FeatureList::SetInstance(std::move(feature_list));
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitWithFeatureList(std::move(feature_list));
 
     // Trial should not be activated initially, but later might get activated
     // depending on the expected values.
     EXPECT_FALSE(base::FieldTrialList::IsTrialActive(study.name()));
     EXPECT_EQ(test_case.expected_feature_state,
               base::FeatureList::IsEnabled(test_case.feature));
     EXPECT_EQ(test_case.expected_trial_activated,
               base::FieldTrialList::IsTrialActive(study.name()));
   }
 }
@@ skipping 20 matching lines @@
       {kEnabledFeature, false, year_ago, true},
       {kEnabledFeature, false, year_later, false},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     const auto& test_case = test_cases[i];
     SCOPED_TRACE(
         base::StringPrintf("Test[%" PRIuS "]: %s", i, test_case.feature.name));
 
     base::FieldTrialList field_trial_list(nullptr);
-    base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->InitializeFromCommandLine(std::string(), std::string());
 
     // Expired study with a 100% feature group and a default group that has no
     // feature association.
     Study study;
     study.set_name("Study1");
     study.set_default_experiment_name("Default");
 
     study.set_expiry_date(TimeToProtoTime(test_case.expiry_date));
 
     AddExperiment("Default", 0, &study);
     Study_Experiment* feature_experiment = AddExperiment("Feature", 1, &study);
     if (test_case.study_force_feature_state) {
       feature_experiment->mutable_feature_association()->add_enable_feature(
           test_case.feature.name);
     } else {
       feature_experiment->mutable_feature_association()->add_disable_feature(
           test_case.feature.name);
     }
 
     EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
-    base::FeatureList::SetInstance(std::move(feature_list));
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitWithFeatureList(std::move(feature_list));
 
     // Tthe feature should not be enabled, because the study is expired.
     EXPECT_EQ(test_case.expected_feature_enabled,
               base::FeatureList::IsEnabled(test_case.feature));
   }
 }
 
 TEST_F(VariationsSeedProcessorTest, LowEntropyStudyTest) {
   const std::string kTrial1Name = "A";
   const std::string kTrial2Name = "B";
@@ skipping 36 matching lines @@
   // Since no experiment in study1 sends experiment IDs, it will use the high
   // entropy provider, which selects the non-default group.
   EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrial1Name));
 
   // Since an experiment in study2 has google_web_experiment_id set, it will use
   // the low entropy provider, which selects the default group.
   EXPECT_EQ(kDefaultName, base::FieldTrialList::FindFullName(kTrial2Name));
 }
 
 }  // namespace variations