[chrome://flags] Let features override params in the same trial

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 26 matching lines @@
 namespace {
 
 const char kFlags1[] = "flag1";
 const char kFlags2[] = "flag2";
 const char kFlags3[] = "flag3";
 const char kFlags4[] = "flag4";
 const char kFlags5[] = "flag5";
 const char kFlags6[] = "flag6";
 const char kFlags7[] = "flag7";
 const char kFlags8[] = "flag8";
+const char kFlags9[] = "flag9";
+const char kFlags10[] = "flag10";
 
 const char kSwitch1[] = "switch";
 const char kSwitch2[] = "switch2";
 const char kSwitch3[] = "switch3";
 const char kSwitch6[] = "switch6";
 const char kValueForSwitch2[] = "value_for_switch2";
 
 const char kMultiSwitch1[] = "multi_switch1";
 const char kMultiSwitch2[] = "multi_switch2";
 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 kTestParam1[] = "param1";
+const char kTestParam2[] = "param2";
 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 kTestVariationOther[] = {
-    {kTestParam, kTestParamValue}};
+const FeatureEntry::FeatureParam kTestVariationOther1[] = {
+    {kTestParam1, kTestParamValue}};
+const FeatureEntry::FeatureParam kTestVariationOther2[] = {
+    {kTestParam2, kTestParamValue}};
 
-const FeatureEntry::FeatureVariation kTestVariations[] = {
-    {"dummy description", kTestVariationOther, 1, nullptr}};
+const FeatureEntry::FeatureVariation kTestVariations1[] = {
+    {"dummy description 1", kTestVariationOther1, 1, nullptr}};
+const FeatureEntry::FeatureVariation kTestVariations2[] = {
+    {"dummy description 2", kTestVariationOther2, 1, nullptr}};
 
 // 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 31 matching lines @@
     {kFlags6, kDummyNameId, kDummyDescriptionId, 0,
      FeatureEntry::SINGLE_DISABLE_VALUE, kSwitch6, "", nullptr, nullptr,
      nullptr, 0, nullptr, nullptr, nullptr},
     {kFlags7, kDummyNameId, kDummyDescriptionId,
      0,  // Ends up being mapped to the current platform.
      FeatureEntry::FEATURE_VALUE, nullptr, nullptr, nullptr, nullptr,
      &kTestFeature1, 3, nullptr, nullptr, nullptr},
     {kFlags8, kDummyNameId, kDummyDescriptionId,
      0,  // Ends up being mapped to the current platform.
      FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE, nullptr, nullptr, nullptr,
-     nullptr, &kTestFeature2, 4, nullptr, kTestVariations, kTestTrial},
+     nullptr, &kTestFeature1, 4, nullptr, kTestVariations1, kTestTrial},
+    {kFlags9, kDummyNameId, kDummyDescriptionId,
+     0,  // Ends up being mapped to the current platform.
+     FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE, nullptr, nullptr, nullptr,
+     nullptr, &kTestFeature1, 4, nullptr, kTestVariations1, kTestTrial},
+    {kFlags10, kDummyNameId, kDummyDescriptionId,
+     0,  // Ends up being mapped to the current platform.
+     FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE, nullptr, nullptr, nullptr,
+     nullptr, &kTestFeature2, 4, nullptr, kTestVariations2, kTestTrial},
 };
 
 class FlagsStateTest : public ::testing::Test {
  protected:
   FlagsStateTest() : flags_storage_(&prefs_), trial_list_(nullptr) {
     prefs_.registry()->RegisterListPref(prefs::kEnabledLabsExperiments);
 
     for (size_t i = 0; i < arraysize(kEntries); ++i)
       kEntries[i].supported_platforms = FlagsState::GetCurrentPlatform();
 
@@ skipping 129 matching lines @@
 TEST_F(FlagsStateTest, RegisterAllFeatureVariationParameters) {
   const FeatureEntry& entry = kEntries[7];
   std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
 
   // Select the "Default" variation.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(0),
                                        true);
   flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_,
                                                       feature_list.get());
   // No value should be associated.
-  EXPECT_EQ("", variations::GetVariationParamValue(kTestTrial, kTestParam));
+  EXPECT_EQ("", variations::GetVariationParamValue(kTestTrial, kTestParam1));
   // The trial should not be created.
   base::FieldTrial* trial = base::FieldTrialList::Find(kTestTrial);
   EXPECT_EQ(nullptr, trial);
 
   // Select the default "Enabled" variation.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(1),
                                        true);
 
   flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_,
                                                       feature_list.get());
   // No value should be associated as this is the default option.
-  EXPECT_EQ("",
-            variations::GetVariationParamValue(kTestTrial, kTestParam));
+  EXPECT_EQ("", variations::GetVariationParamValue(kTestTrial, kTestParam1));
 
   // 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 only one variation.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(2),
                                        true);
   flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_,
                                                       feature_list.get());
   // Associating for the second time should not change the value.
-  EXPECT_EQ("",
-            variations::GetVariationParamValue(kTestTrial, kTestParam));
+  EXPECT_EQ("", variations::GetVariationParamValue(kTestTrial, kTestParam1));
 }
 
 TEST_F(FlagsStateTest, RegisterAllFeatureVariationParametersNonDefault) {
   const FeatureEntry& entry = kEntries[7];
   std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
 
   // Select the only one variation.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(2),
                                        true);
   flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_,
                                                       feature_list.get());
 
   // Set the feature_list as the main instance so that
   // variations::GetVariationParamValueByFeature below works.
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitWithFeatureList(std::move(feature_list));
 
   // The param should have the value predefined in this variation.
   EXPECT_EQ(kTestParamValue,
-            variations::GetVariationParamValue(kTestTrial, kTestParam));
+            variations::GetVariationParamValue(kTestTrial, kTestParam1));
 
   // The value should be associated also via the name of the feature.
   EXPECT_EQ(kTestParamValue, variations::GetVariationParamValueByFeature(
-                                  kTestFeature2, kTestParam));
+                                 kTestFeature1, kTestParam1));
+}
+
+TEST_F(FlagsStateTest, RegisterAllFeatureVariationParametersWithDefaultTrials) {
+  const FeatureEntry& entry1 = kEntries[8];
+  const FeatureEntry& entry2 = kEntries[9];
+  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+
+  // Select the only one variation for each FeatureEntry.
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry1.NameForOption(2),
+                                       true);
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry2.NameForOption(2),
+                                       true);
+  flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_,
+                                                      feature_list.get());
+
+  // Set the feature_list as the main instance so that
+  // variations::GetVariationParamValueByFeature below works.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitWithFeatureList(std::move(feature_list));
+
+  // The params should have the values predefined in these variations
+  // (accessible via the names of the features).
+  EXPECT_EQ(kTestParamValue, variations::GetVariationParamValueByFeature(
+                                 kTestFeature1, kTestParam1));
+  EXPECT_EQ(kTestParamValue, variations::GetVariationParamValueByFeature(
+                                 kTestFeature2, kTestParam2));
+  // The params are registered in the same trial.
+  EXPECT_EQ(kTestParamValue,
+            variations::GetVariationParamValue(kTestTrial, kTestParam1));
+  EXPECT_EQ(kTestParamValue,
+            variations::GetVariationParamValue(kTestTrial, kTestParam2));
 }
 
 base::CommandLine::StringType CreateSwitch(const std::string& value) {
 #if defined(OS_WIN)
   return base::ASCIIToUTF16(value);
 #else
   return value;
 #endif
 }
 
@@ skipping 432 matching lines @@
   }
 }
 
 TEST_F(FlagsStateTest, GetFlagFeatureEntries) {
   base::ListValue supported_entries;
   base::ListValue unsupported_entries;
   flags_state_->GetFlagFeatureEntries(&flags_storage_, kGeneralAccessFlagsOnly,
                                       &supported_entries, &unsupported_entries,
                                       base::Bind(&SkipFeatureEntry));
   // All |kEntries| except for |kFlags3| should be supported.
-  EXPECT_EQ(7u, supported_entries.GetSize());
+  EXPECT_EQ(9u, supported_entries.GetSize());
   EXPECT_EQ(1u, unsupported_entries.GetSize());
   EXPECT_EQ(arraysize(kEntries),
             supported_entries.GetSize() + unsupported_entries.GetSize());
 }
 
 }  // namespace flags_ui