Allow overriding variation parameter via 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>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/flags_ui/feature_entry.h"
 #include "components/flags_ui/flags_ui_pref_names.h"
 #include "components/flags_ui/flags_ui_switches.h"
 #include "components/flags_ui/pref_service_flags_storage.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/testing_pref_service.h"
+#include "components/variations/variations_associated_data.h"
 #include "grit/components_strings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace flags_ui {
 
 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 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 kTestParamValue1[] = "value1";
+const char kTestParamValue2[] = "value2";
+
+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}};
+
+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;
 }
 
 }  // namespace
 
 const FeatureEntry::Choice kMultiChoices[] = {
     {kDummyDescriptionId, "", ""},
     {kDummyDescriptionId, kMultiSwitch1, ""},
     {kDummyDescriptionId, kMultiSwitch2, kValueForMultiSwitch2},
 };
 
-const base::Feature kTestFeature{"FeatureName",
-                                 base::FEATURE_ENABLED_BY_DEFAULT};
-
 // The entries that are set for these tests. The 3rd entry is not supported on
 // the current platform, all others are.
 static FeatureEntry kEntries[] = {
     {kFlags1, kDummyNameId, kDummyDescriptionId,
      0,  // Ends up being mapped to the current platform.
-     FeatureEntry::SINGLE_VALUE, kSwitch1, "", nullptr, nullptr, nullptr,
-     nullptr, 0},
+     FeatureEntry::SINGLE_VALUE, kSwitch1, "", nullptr, nullptr, nullptr, 0,
+     nullptr, nullptr, nullptr},
     {kFlags2, kDummyNameId, kDummyDescriptionId,
      0,  // Ends up being mapped to the current platform.
      FeatureEntry::SINGLE_VALUE, kSwitch2, kValueForSwitch2, nullptr, nullptr,
-     nullptr, nullptr, 0},
+     nullptr, 0, nullptr, nullptr, nullptr},
     {kFlags3, kDummyNameId, kDummyDescriptionId,
      0,  // This ends up enabling for an OS other than the current.
-     FeatureEntry::SINGLE_VALUE, kSwitch3, "", nullptr, nullptr, nullptr,
-     nullptr, 0},
+     FeatureEntry::SINGLE_VALUE, kSwitch3, "", nullptr, nullptr, nullptr, 0,
+     nullptr, nullptr, nullptr},
     {kFlags4, kDummyNameId, kDummyDescriptionId,
      0,  // Ends up being mapped to the current platform.
-     FeatureEntry::MULTI_VALUE, "", "", "", "", nullptr, kMultiChoices,
-     arraysize(kMultiChoices)},
+     FeatureEntry::MULTI_VALUE, "", "", "", "", nullptr,
+     arraysize(kMultiChoices), kMultiChoices, nullptr, nullptr},
     {kFlags5, kDummyNameId, kDummyDescriptionId,
      0,  // Ends up being mapped to the current platform.
      FeatureEntry::ENABLE_DISABLE_VALUE, kSwitch1, kEnableDisableValue1,
-     kSwitch2, kEnableDisableValue2, nullptr, nullptr, 3},
+     kSwitch2, kEnableDisableValue2, nullptr, 3, nullptr, nullptr, nullptr},
     {kFlags6, kDummyNameId, kDummyDescriptionId, 0,
      FeatureEntry::SINGLE_DISABLE_VALUE, kSwitch6, "", nullptr, nullptr,
-     nullptr, nullptr, 0},
+     nullptr, 0, nullptr, nullptr, nullptr},
     {kFlags7, kDummyNameId, kDummyDescriptionId,
      0,  // Ends up being mapped to the current platform.
      FeatureEntry::FEATURE_VALUE, nullptr, nullptr, nullptr, nullptr,
-     &kTestFeature, nullptr, 3},
+     &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},
 };
 
 class FlagsStateTest : public ::testing::Test {
  protected:
-  FlagsStateTest() : flags_storage_(&prefs_) {
+  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();
 
     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)));
   }
 
   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());
 
   // kFlags6 is enabled by default, so enabling should not require a restart.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags6, true);
   EXPECT_FALSE(flags_state_->IsRestartNeededToCommitChanges());
@@ skipping 10 matching lines @@
   EXPECT_FALSE(flags_state_->IsRestartNeededToCommitChanges());
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags6, false);
   EXPECT_TRUE(flags_state_->IsRestartNeededToCommitChanges());
 }
 
 TEST_F(FlagsStateTest, MultiFlagChangeNeedsRestart) {
   const FeatureEntry& entry = kEntries[3];
   ASSERT_EQ(kFlags4, entry.internal_name);
   EXPECT_FALSE(flags_state_->IsRestartNeededToCommitChanges());
   // Enable the 2nd choice of the multi-value.
-  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForChoice(2),
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(2),
                                        true);
   EXPECT_TRUE(flags_state_->IsRestartNeededToCommitChanges());
   flags_state_->Reset();
   EXPECT_FALSE(flags_state_->IsRestartNeededToCommitChanges());
   // Enable the default choice now.
-  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForChoice(0),
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(0),
                                        true);
   EXPECT_TRUE(flags_state_->IsRestartNeededToCommitChanges());
 }
 
 TEST_F(FlagsStateTest, AddTwoFlagsRemoveOne) {
   // Add two entries, check they're there.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags1, true);
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags2, true);
 
   const base::ListValue* entries_list =
@@ skipping 57 matching lines @@
 
   flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line2,
                                        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.
+  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.
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(1),
+                                       true);
+
+  flags_state_->RegisterAllFeatureVariationParameters(&flags_storage_);
+  // The value should be associated.
+  EXPECT_EQ(kTestParamValue1,
+            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.
+  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,
+            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 88 matching lines @@
     int enabled_choice;  // 0: default, 1: enabled, 2: disabled.
     const char* existing_enable_features;
     const char* existing_disable_features;
     const char* expected_enable_features;
     const char* expected_disable_features;
   } cases[] = {
       // Default value: Should not affect existing flags.
       {0, nullptr, nullptr, nullptr, nullptr},
       {0, "A,B", "C", "A,B", "C"},
       // "Enable" option: should only affect enabled list.
-      {1, nullptr, nullptr, "FeatureName", nullptr},
-      {1, "A,B", "C", "A,B,FeatureName", "C"},
+      {1, nullptr, nullptr, "FeatureName1", nullptr},
+      {1, "A,B", "C", "A,B,FeatureName1", "C"},
       // "Disable" option: should only affect disabled list.
-      {2, nullptr, nullptr, nullptr, "FeatureName"},
-      {2, "A,B", "C", "A,B", "C,FeatureName"},
+      {2, nullptr, nullptr, nullptr, "FeatureName1"},
+      {2, "A,B", "C", "A,B", "C,FeatureName1"},
   };
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(base::StringPrintf(
         "Test[%" PRIuS "]: %d [%s] [%s]", i, cases[i].enabled_choice,
         cases[i].existing_enable_features ? cases[i].existing_enable_features
                                           : "null",
         cases[i].existing_disable_features ? cases[i].existing_disable_features
                                            : "null"));
 
@@ skipping 141 matching lines @@
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 
   // Enable the 2nd choice of the multi-value.
-  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForChoice(2),
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(2),
                                        true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_TRUE(command_line.HasSwitch(kMultiSwitch2));
     EXPECT_EQ(std::string(kValueForMultiSwitch2),
               command_line.GetSwitchValueASCII(kMultiSwitch2));
   }
 
   // Disable the multi-value entry.
-  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForChoice(0),
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(0),
                                        true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 }
@@ skipping 38 matching lines @@
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
   }
 
   // "Enable" option selected.
-  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForChoice(1),
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(1),
                                        true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
     EXPECT_EQ(kEnableDisableValue1, command_line.GetSwitchValueASCII(kSwitch1));
   }
 
   // "Disable" option selected.
-  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForChoice(2),
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(2),
                                        true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
     EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
     EXPECT_EQ(kEnableDisableValue2, command_line.GetSwitchValueASCII(kSwitch2));
   }
 
   // "Default" option selected, same as nothing selected.
-  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForChoice(0),
+  flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry.NameForOption(0),
                                        true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 }
 
 TEST_F(FlagsStateTest, FeatureValues) {
   const FeatureEntry& entry = kEntries[6];
   ASSERT_EQ(kFlags7, entry.internal_name);
 
   struct {
     int enabled_choice;
     const char* existing_enable_features;
     const char* existing_disable_features;
     const char* expected_enable_features;
     const char* expected_disable_features;
   } cases[] = {
       // Nothing selected.
       {-1, nullptr, nullptr, "", ""},
       // "Default" option selected, same as nothing selected.
       {0, nullptr, nullptr, "", ""},
       // "Enable" option selected.
-      {1, nullptr, nullptr, "FeatureName", ""},
+      {1, nullptr, nullptr, "FeatureName1", ""},
       // "Disable" option selected.
-      {2, nullptr, nullptr, "", "FeatureName"},
+      {2, nullptr, nullptr, "", "FeatureName1"},
       // "Enable" option should get added to the existing list.
-      {1, "Foo,Bar", nullptr, "Foo,Bar,FeatureName", ""},
+      {1, "Foo,Bar", nullptr, "Foo,Bar,FeatureName1", ""},
       // "Disable" option should get added to the existing list.
-      {2, nullptr, "Foo,Bar", "", "Foo,Bar,FeatureName"},
+      {2, nullptr, "Foo,Bar", "", "Foo,Bar,FeatureName1"},
   };
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(base::StringPrintf(
         "Test[%" PRIuS "]: %d [%s] [%s]", i, cases[i].enabled_choice,
         cases[i].existing_enable_features ? cases[i].existing_enable_features
                                           : "null",
         cases[i].existing_disable_features ? cases[i].existing_disable_features
                                            : "null"));
 
     if (cases[i].enabled_choice != -1) {
       flags_state_->SetFeatureEntryEnabled(
-          &flags_storage_, entry.NameForChoice(cases[i].enabled_choice), true);
+          &flags_storage_, entry.NameForOption(cases[i].enabled_choice), true);
     }
 
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     if (cases[i].existing_enable_features) {
       command_line.AppendSwitchASCII(kEnableFeatures,
                                      cases[i].existing_enable_features);
     }
     if (cases[i].existing_disable_features) {
       command_line.AppendSwitchASCII(kDisableFeatures,
                                      cases[i].existing_disable_features);
     }
 
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     EXPECT_EQ(cases[i].expected_enable_features,
               command_line.GetSwitchValueASCII(kEnableFeatures));
     EXPECT_EQ(cases[i].expected_disable_features,
               command_line.GetSwitchValueASCII(kDisableFeatures));
   }
 }
 
 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(6u, supported_entries.GetSize());
+  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