Clean-up the code for default variations in chrome://flags.

components/flags_ui/flags_state_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 "components/flags_ui/flags_state.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 44 matching lines @@
 const char kValueForMultiSwitch2[] = "value_for_multi_switch2";
 
 const char kEnableDisableValue1[] = "value1";
 const char kEnableDisableValue2[] = "value2";
 
 const char kEnableFeatures[] = "dummy-enable-features";
 const char kDisableFeatures[] = "dummy-disable-features";
 
 const char kTestTrial[] = "TestTrial";
 const char kTestParam[] = "param";
-const char kTestParamValue1[] = "value1";
-const char kTestParamValue2[] = "value2";
+const char kTestParamValue[] = "value";
 
 const base::Feature kTestFeature1{"FeatureName1",
                                   base::FEATURE_ENABLED_BY_DEFAULT};
 const base::Feature kTestFeature2{"FeatureName2",
                                   base::FEATURE_ENABLED_BY_DEFAULT};
 
-const FeatureEntry::FeatureParam kTestVariationDefault[] = {
-    {kTestParam, kTestParamValue1}};
-
 const FeatureEntry::FeatureParam kTestVariationOther[] = {
-    {kTestParam, kTestParamValue2}};
+    {kTestParam, kTestParamValue}};
 
 const FeatureEntry::FeatureVariation kTestVariations[] = {
-    {"", kTestVariationDefault, 1},
     {"dummy description", kTestVariationOther, 1}};
 
 // Those have to be valid ids for the translation system but the value are
 // never used, so pick one at random from the current component.
 const int kDummyNameId = IDS_FLAGS_UI_WARNING_HEADER;
 const int kDummyDescriptionId = IDS_FLAGS_UI_WARNING_TEXT;
 
 bool SkipFeatureEntry(const FeatureEntry& feature_entry) {
   return false;
 }
@@ skipping 50 matching lines @@
     for (size_t i = 0; i < arraysize(kEntries); ++i)
       kEntries[i].supported_platforms = FlagsState::GetCurrentPlatform();
 
     int os_other_than_current = 1;
     while (os_other_than_current == FlagsState::GetCurrentPlatform())
       os_other_than_current <<= 1;
     kEntries[2].supported_platforms = os_other_than_current;
     flags_state_.reset(new FlagsState(kEntries, arraysize(kEntries)));
   }
 
+  ~FlagsStateTest() override {
+    variations::testing::ClearAllVariationParams();
+  }
+
   TestingPrefServiceSimple prefs_;
   PrefServiceFlagsStorage flags_storage_;
   std::unique_ptr<FlagsState> flags_state_;
   base::FieldTrialList trial_list_;
 };
 
 TEST_F(FlagsStateTest, NoChangeNoRestart) {
   EXPECT_FALSE(flags_state_->IsRestartNeededToCommitChanges());
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags1, false);
   EXPECT_FALSE(flags_state_->IsRestartNeededToCommitChanges());
@@ skipping 100 matching lines @@
                                        kNoSentinels, kEnableFeatures,
                                        kDisableFeatures);
 
   EXPECT_TRUE(command_line2.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesBegin));
   EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesEnd));
 }
 
 TEST_F(FlagsStateTest, RegisterAllFeatureVariationParameters) {
   const FeatureEntry& entry = kEntries[7];
-  // Select the "Disabled" variation.
+  // Select the "Default" variation.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(0),
                                        true);
   flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_);
   // No value should be associated.
   EXPECT_EQ("", variations::GetVariationParamValue(kTestTrial, kTestParam));
   // The trial should not be created.
   base::FieldTrial* trial = base::FieldTrialList::Find(kTestTrial);
   EXPECT_EQ(nullptr, trial);
 
-  // Select the first "Enabled" variation.
+  // Select the default "Enabled" variation.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(1),
                                        true);
 
   flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_);
-  // The value should be associated.
-  EXPECT_EQ(kTestParamValue1,
+  // No value should be associated as this is the default option.
+  EXPECT_EQ("",
             variations::GetVariationParamValue(kTestTrial, kTestParam));
 
   // The trial should be created.
   trial = base::FieldTrialList::Find(kTestTrial);
   EXPECT_NE(nullptr, trial);
   // The about:flags group should be selected for the trial.
   EXPECT_EQ(internal::kTrialGroupAboutFlags, trial->group_name());
 
-  // Select the second "Enabled" variation.
+  // Select the only one variation.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(2),
                                        true);
   flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_);
   // Associating for the second time should not change the value.
-  EXPECT_EQ(kTestParamValue1,
+  EXPECT_EQ("",
             variations::GetVariationParamValue(kTestTrial, kTestParam));
 }
 
+TEST_F(FlagsStateTest, RegisterAllFeatureVariationParametersNonDefault) {
+  const FeatureEntry& entry = kEntries[7];
+  // Select the only one variation.
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(2),
+                                       true);
+  flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_);
+  // The param should have the value predefined in this variation.
+  EXPECT_EQ(kTestParamValue,
+            variations::GetVariationParamValue(kTestTrial, kTestParam));
+}
+
 base::CommandLine::StringType CreateSwitch(const std::string& value) {
 #if defined(OS_WIN)
   return base::ASCIIToUTF16(value);
 #else
   return value;
 #endif
 }
 
 TEST_F(FlagsStateTest, CompareSwitchesToCurrentCommandLine) {
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags1, true);
@@ skipping 437 matching lines @@
                                       &supported_entries, &unsupported_entries,
                                       base::Bind(&SkipFeatureEntry));
   // All |kEntries| except for |kFlags3| should be supported.
   EXPECT_EQ(7u, supported_entries.GetSize());
   EXPECT_EQ(1u, unsupported_entries.GetSize());
   EXPECT_EQ(arraysize(kEntries),
             supported_entries.GetSize() + unsupported_entries.GetSize());
 }
 
 }  // namespace flags_ui