Switch nomenclature in about_flags.cc to not use "Experiments".

chrome/browser/about_flags_unittest.cc

 // Copyright (c) 2011 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 "chrome/browser/about_flags.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 170 matching lines @@
 #if defined(OS_WIN)
   return base::UTF16ToUTF8(path);
 #else
   return path;
 #endif
 }
 
 std::set<std::string> GetAllSwitchesForTesting() {
   std::set<std::string> result;
 
-  size_t num_experiments = 0;
-  const Experiment* experiments =
-      testing::GetExperiments(&num_experiments);
+  size_t num_entries = 0;
+  const Entry* entries = testing::GetEntries(&num_entries);
 
-  for (size_t i = 0; i < num_experiments; ++i) {
-    const Experiment& experiment = experiments[i];
-    if (experiment.type == Experiment::SINGLE_VALUE) {
-      result.insert(experiment.command_line_switch);
-    } else if (experiment.type == Experiment::MULTI_VALUE) {
-      for (int j = 0; j < experiment.num_choices; ++j) {
-        result.insert(experiment.choices[j].command_line_switch);
+  for (size_t i = 0; i < num_entries; ++i) {
+    const Entry& entry = entries[i];
+    if (entry.type == Entry::SINGLE_VALUE) {
+      result.insert(entry.command_line_switch);
+    } else if (entry.type == Entry::MULTI_VALUE) {
+      for (int j = 0; j < entry.num_choices; ++j) {
+        result.insert(entry.choices[j].command_line_switch);
       }
     } else {
-      DCHECK_EQ(experiment.type, Experiment::ENABLE_DISABLE_VALUE);
-      result.insert(experiment.command_line_switch);
-      result.insert(experiment.disable_command_line_switch);
+      DCHECK_EQ(entry.type, Entry::ENABLE_DISABLE_VALUE);
+      result.insert(entry.command_line_switch);
+      result.insert(entry.disable_command_line_switch);
     }
   }
   return result;
 }
 
 }  // anonymous namespace
 
-const Experiment::Choice kMultiChoices[] = {
+const Entry::Choice kMultiChoices[] = {
   { IDS_PRODUCT_NAME, "", "" },
   { IDS_PRODUCT_NAME, kMultiSwitch1, "" },
   { IDS_PRODUCT_NAME, kMultiSwitch2, kValueForMultiSwitch2 },
 };
 
-// The experiments that are set for these tests. The 3rd experiment is not
-// supported on the current platform, all others are.
-static Experiment kExperiments[] = {
+// The entries that are set for these tests. The 3rd entry is not supported on
+// the current platform, all others are.
+static Entry kEntries[] = {
   {
     kFlags1,
     IDS_PRODUCT_NAME,
     IDS_PRODUCT_NAME,
     0,  // Ends up being mapped to the current platform.
-    Experiment::SINGLE_VALUE,
+    Entry::SINGLE_VALUE,
     kSwitch1,
     "",
     NULL,
     NULL,
     NULL,
     0
   },
   {
     kFlags2,
     IDS_PRODUCT_NAME,
     IDS_PRODUCT_NAME,
     0,  // Ends up being mapped to the current platform.
-    Experiment::SINGLE_VALUE,
+    Entry::SINGLE_VALUE,
     kSwitch2,
     kValueForSwitch2,
     NULL,
     NULL,
     NULL,
     0
   },
   {
     kFlags3,
     IDS_PRODUCT_NAME,
     IDS_PRODUCT_NAME,
     0,  // This ends up enabling for an OS other than the current.
-    Experiment::SINGLE_VALUE,
+    Entry::SINGLE_VALUE,
     kSwitch3,
     "",
     NULL,
     NULL,
     NULL,
     0
   },
   {
     kFlags4,
     IDS_PRODUCT_NAME,
     IDS_PRODUCT_NAME,
     0,  // Ends up being mapped to the current platform.
-    Experiment::MULTI_VALUE,
+    Entry::MULTI_VALUE,
     "",
     "",
     "",
     "",
     kMultiChoices,
     arraysize(kMultiChoices)
   },
   {
     kFlags5,
     IDS_PRODUCT_NAME,
     IDS_PRODUCT_NAME,
     0,  // Ends up being mapped to the current platform.
-    Experiment::ENABLE_DISABLE_VALUE,
+    Entry::ENABLE_DISABLE_VALUE,
     kSwitch1,
     kEnableDisableValue1,
     kSwitch2,
     kEnableDisableValue2,
     NULL,
     3
   },
 };
 
 class AboutFlagsTest : public ::testing::Test {
  protected:
   AboutFlagsTest() : flags_storage_(&prefs_) {
     prefs_.registry()->RegisterListPref(prefs::kEnabledLabsExperiments);
     testing::ClearState();
   }
 
   void SetUp() override {
-    for (size_t i = 0; i < arraysize(kExperiments); ++i)
-      kExperiments[i].supported_platforms = GetCurrentPlatform();
+    for (size_t i = 0; i < arraysize(kEntries); ++i)
+      kEntries[i].supported_platforms = GetCurrentPlatform();
 
     int os_other_than_current = 1;
     while (os_other_than_current == GetCurrentPlatform())
       os_other_than_current <<= 1;
-    kExperiments[2].supported_platforms = os_other_than_current;
+    kEntries[2].supported_platforms = os_other_than_current;
 
-    testing::SetExperiments(kExperiments, arraysize(kExperiments));
+    testing::SetEntries(kEntries, arraysize(kEntries));
   }
 
-  void TearDown() override { testing::SetExperiments(NULL, 0); }
+  void TearDown() override { testing::SetEntries(NULL, 0); }
 
   TestingPrefServiceSimple prefs_;
   PrefServiceFlagsStorage flags_storage_;
 };
 
 
 TEST_F(AboutFlagsTest, NoChangeNoRestart) {
   EXPECT_FALSE(IsRestartNeededToCommitChanges());
-  SetExperimentEnabled(&flags_storage_, kFlags1, false);
+  SetEntryEnabled(&flags_storage_, kFlags1, false);
   EXPECT_FALSE(IsRestartNeededToCommitChanges());
 }
 
 TEST_F(AboutFlagsTest, ChangeNeedsRestart) {
   EXPECT_FALSE(IsRestartNeededToCommitChanges());
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
   EXPECT_TRUE(IsRestartNeededToCommitChanges());
 }
 
 TEST_F(AboutFlagsTest, MultiFlagChangeNeedsRestart) {
-  const Experiment& experiment = kExperiments[3];
-  ASSERT_EQ(kFlags4, experiment.internal_name);
+  const Entry& entry = kEntries[3];
+  ASSERT_EQ(kFlags4, entry.internal_name);
   EXPECT_FALSE(IsRestartNeededToCommitChanges());
   // Enable the 2nd choice of the multi-value.
-  SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
+  SetEntryEnabled(&flags_storage_, entry.NameForChoice(2), true);
   EXPECT_TRUE(IsRestartNeededToCommitChanges());
   testing::ClearState();
   EXPECT_FALSE(IsRestartNeededToCommitChanges());
   // Enable the default choice now.
-  SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
+  SetEntryEnabled(&flags_storage_, entry.NameForChoice(0), true);
   EXPECT_TRUE(IsRestartNeededToCommitChanges());
 }
 
 TEST_F(AboutFlagsTest, AddTwoFlagsRemoveOne) {
-  // Add two experiments, check they're there.
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
-  SetExperimentEnabled(&flags_storage_, kFlags2, true);
+  // Add two entries, check they're there.
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags2, true);
 
-  const base::ListValue* experiments_list = prefs_.GetList(
+  const base::ListValue* entry_list = prefs_.GetList(
       prefs::kEnabledLabsExperiments);
-  ASSERT_TRUE(experiments_list != NULL);
+  ASSERT_TRUE(entry_list != NULL);
 
-  ASSERT_EQ(2u, experiments_list->GetSize());
+  ASSERT_EQ(2u, entry_list->GetSize());
 
   std::string s0;
-  ASSERT_TRUE(experiments_list->GetString(0, &s0));
+  ASSERT_TRUE(entry_list->GetString(0, &s0));
   std::string s1;
-  ASSERT_TRUE(experiments_list->GetString(1, &s1));
+  ASSERT_TRUE(entry_list->GetString(1, &s1));
 
   EXPECT_TRUE(s0 == kFlags1 || s1 == kFlags1);
   EXPECT_TRUE(s0 == kFlags2 || s1 == kFlags2);
 
-  // Remove one experiment, check the other's still around.
-  SetExperimentEnabled(&flags_storage_, kFlags2, false);
+  // Remove one entry, check the other's still around.
+  SetEntryEnabled(&flags_storage_, kFlags2, false);
 
-  experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
-  ASSERT_TRUE(experiments_list != NULL);
-  ASSERT_EQ(1u, experiments_list->GetSize());
-  ASSERT_TRUE(experiments_list->GetString(0, &s0));
+  entry_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
+  ASSERT_TRUE(entry_list != NULL);
+  ASSERT_EQ(1u, entry_list->GetSize());
+  ASSERT_TRUE(entry_list->GetString(0, &s0));
   EXPECT_TRUE(s0 == kFlags1);
 }
 
 TEST_F(AboutFlagsTest, AddTwoFlagsRemoveBoth) {
-  // Add two experiments, check the pref exists.
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
-  SetExperimentEnabled(&flags_storage_, kFlags2, true);
-  const base::ListValue* experiments_list = prefs_.GetList(
+  // Add two entries, check the pref exists.
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags2, true);
+  const base::ListValue* entry_list = prefs_.GetList(
       prefs::kEnabledLabsExperiments);
-  ASSERT_TRUE(experiments_list != NULL);
+  ASSERT_TRUE(entry_list != NULL);
 
   // Remove both, the pref should have been removed completely.
-  SetExperimentEnabled(&flags_storage_, kFlags1, false);
-  SetExperimentEnabled(&flags_storage_, kFlags2, false);
-  experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
-  EXPECT_TRUE(experiments_list == NULL || experiments_list->GetSize() == 0);
+  SetEntryEnabled(&flags_storage_, kFlags1, false);
+  SetEntryEnabled(&flags_storage_, kFlags2, false);
+  entry_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
+  EXPECT_TRUE(entry_list == NULL || entry_list->GetSize() == 0);
 }
 
 TEST_F(AboutFlagsTest, ConvertFlagsToSwitches) {
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
 
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch("foo");
 
   EXPECT_TRUE(command_line.HasSwitch("foo"));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
 
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 
   EXPECT_TRUE(command_line.HasSwitch("foo"));
@@ skipping 12 matching lines @@
 
 base::CommandLine::StringType CreateSwitch(const std::string& value) {
 #if defined(OS_WIN)
   return base::ASCIIToUTF16(value);
 #else
   return value;
 #endif
 }
 
 TEST_F(AboutFlagsTest, CompareSwitchesToCurrentCommandLine) {
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
 
   const std::string kDoubleDash("--");
 
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch("foo");
 
   base::CommandLine new_command_line(base::CommandLine::NO_PROGRAM);
   ConvertFlagsToSwitches(&flags_storage_, &new_command_line, kAddSentinels);
 
   EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
@@ skipping 11 matching lines @@
   EXPECT_TRUE(AreSwitchesIdenticalToCurrentCommandLine(
       new_command_line, command_line, NULL));
   {
     std::set<base::CommandLine::StringType> difference;
     EXPECT_TRUE(AreSwitchesIdenticalToCurrentCommandLine(
         new_command_line, command_line, &difference));
     EXPECT_TRUE(difference.empty());
   }
 
   // Now both have flags but different.
-  SetExperimentEnabled(&flags_storage_, kFlags1, false);
-  SetExperimentEnabled(&flags_storage_, kFlags2, true);
+  SetEntryEnabled(&flags_storage_, kFlags1, false);
+  SetEntryEnabled(&flags_storage_, kFlags2, true);
 
   base::CommandLine another_command_line(base::CommandLine::NO_PROGRAM);
   ConvertFlagsToSwitches(&flags_storage_, &another_command_line, kAddSentinels);
 
   EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
       new_command_line, another_command_line, NULL));
   {
     std::set<base::CommandLine::StringType> difference;
     EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
         new_command_line, another_command_line, &difference));
     EXPECT_EQ(2U, difference.size());
     EXPECT_EQ(1U, difference.count(CreateSwitch(kDoubleDash + kSwitch1)));
     EXPECT_EQ(1U,
               difference.count(CreateSwitch(kDoubleDash + kSwitch2 + "=" +
                                             kValueForSwitch2)));
   }
 }
 
 TEST_F(AboutFlagsTest, RemoveFlagSwitches) {
   std::map<std::string, base::CommandLine::StringType> switch_list;
   switch_list[kSwitch1] = base::CommandLine::StringType();
   switch_list[switches::kFlagSwitchesBegin] = base::CommandLine::StringType();
   switch_list[switches::kFlagSwitchesEnd] = base::CommandLine::StringType();
   switch_list["foo"] = base::CommandLine::StringType();
 
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
 
   // This shouldn't do anything before ConvertFlagsToSwitches() wasn't called.
   RemoveFlagsSwitches(&switch_list);
   ASSERT_EQ(4u, switch_list.size());
   EXPECT_TRUE(switch_list.find(kSwitch1) != switch_list.end());
   EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesBegin) !=
               switch_list.end());
   EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesEnd) !=
               switch_list.end());
   EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
 
   // Call ConvertFlagsToSwitches(), then RemoveFlagsSwitches() again.
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch("foo");
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
   RemoveFlagsSwitches(&switch_list);
 
   // Now the about:flags-related switch should have been removed.
   ASSERT_EQ(1u, switch_list.size());
   EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
 }
 
 // Tests enabling experiments that aren't supported on the current platform.
 TEST_F(AboutFlagsTest, PersistAndPrune) {
   // Enable experiments 1 and 3.
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
-  SetExperimentEnabled(&flags_storage_, kFlags3, true);
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags3, true);
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
 
-  // Convert the flags to switches. Experiment 3 shouldn't be among the switches
+  // Convert the flags to switches. Entry 3 shouldn't be among the switches
   // as it is not applicable to the current platform.
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
 
-  // Experiment 3 should show still be persisted in preferences though.
-  const base::ListValue* experiments_list =
+  // Entry 3 should show still be persisted in preferences though.
+  const base::ListValue* entry_list =
       prefs_.GetList(prefs::kEnabledLabsExperiments);
-  ASSERT_TRUE(experiments_list);
-  EXPECT_EQ(2U, experiments_list->GetSize());
+  ASSERT_TRUE(entry_list);
+  EXPECT_EQ(2U, entry_list->GetSize());
   std::string s0;
-  ASSERT_TRUE(experiments_list->GetString(0, &s0));
+  ASSERT_TRUE(entry_list->GetString(0, &s0));
   EXPECT_EQ(kFlags1, s0);
   std::string s1;
-  ASSERT_TRUE(experiments_list->GetString(1, &s1));
+  ASSERT_TRUE(entry_list->GetString(1, &s1));
   EXPECT_EQ(kFlags3, s1);
 }
 
 // Tests that switches which should have values get them in the command
 // line.
 TEST_F(AboutFlagsTest, CheckValues) {
   // Enable experiments 1 and 2.
-  SetExperimentEnabled(&flags_storage_, kFlags1, true);
-  SetExperimentEnabled(&flags_storage_, kFlags2, true);
+  SetEntryEnabled(&flags_storage_, kFlags1, true);
+  SetEntryEnabled(&flags_storage_, kFlags2, true);
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
 
   // Convert the flags to switches.
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
   EXPECT_EQ(std::string(), command_line.GetSwitchValueASCII(kSwitch1));
   EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
   EXPECT_EQ(std::string(kValueForSwitch2),
@@ skipping 19 matching lines @@
 #if defined(OS_WIN)
   EXPECT_NE(base::string16::npos,
             command_line.GetCommandLineString().find(
                 base::ASCIIToUTF16(switch2_with_equals)));
 #else
   EXPECT_NE(std::string::npos,
             command_line.GetCommandLineString().find(switch2_with_equals));
 #endif
 
   // And it should persist.
-  const base::ListValue* experiments_list =
+  const base::ListValue* entry_list =
       prefs_.GetList(prefs::kEnabledLabsExperiments);
-  ASSERT_TRUE(experiments_list);
-  EXPECT_EQ(2U, experiments_list->GetSize());
+  ASSERT_TRUE(entry_list);
+  EXPECT_EQ(2U, entry_list->GetSize());
   std::string s0;
-  ASSERT_TRUE(experiments_list->GetString(0, &s0));
+  ASSERT_TRUE(entry_list->GetString(0, &s0));
   EXPECT_EQ(kFlags1, s0);
   std::string s1;
-  ASSERT_TRUE(experiments_list->GetString(1, &s1));
+  ASSERT_TRUE(entry_list->GetString(1, &s1));
   EXPECT_EQ(kFlags2, s1);
 }
 
 // Tests multi-value type experiments.
 TEST_F(AboutFlagsTest, MultiValues) {
-  const Experiment& experiment = kExperiments[3];
-  ASSERT_EQ(kFlags4, experiment.internal_name);
+  const Entry& entry = kEntries[3];
+  ASSERT_EQ(kFlags4, entry.internal_name);
 
   // Initially, the first "deactivated" option of the multi experiment should
   // be set.
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 
   // Enable the 2nd choice of the multi-value.
-  SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
+  SetEntryEnabled(&flags_storage_, entry.NameForChoice(2), true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     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 experiment.
-  SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
+  // Disable the multi-value entry.
+  SetEntryEnabled(&flags_storage_, entry.NameForChoice(0), true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 }
 
 TEST_F(AboutFlagsTest, EnableDisableValues) {
-  const Experiment& experiment = kExperiments[4];
-  ASSERT_EQ(kFlags5, experiment.internal_name);
+  const Entry& entry = kEntries[4];
+  ASSERT_EQ(kFlags5, entry.internal_name);
 
   // Nothing selected.
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
   }
 
   // "Enable" option selected.
-  SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(1), true);
+  SetEntryEnabled(&flags_storage_, entry.NameForChoice(1), true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
     EXPECT_EQ(kEnableDisableValue1, command_line.GetSwitchValueASCII(kSwitch1));
   }
 
   // "Disable" option selected.
-  SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
+  SetEntryEnabled(&flags_storage_, entry.NameForChoice(2), true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     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.
-  SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
+  SetEntryEnabled(&flags_storage_, entry.NameForChoice(0), true);
   {
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 }
 
 // Makes sure there are no separators in any of the experiment names.
 TEST_F(AboutFlagsTest, NoSeparators) {
-  testing::SetExperiments(NULL, 0);
+  testing::SetEntries(NULL, 0);
   size_t count;
-  const Experiment* experiments = testing::GetExperiments(&count);
-    for (size_t i = 0; i < count; ++i) {
-    std::string name = experiments->internal_name;
+  const Entry* entries = testing::GetEntries(&count);
+  for (size_t i = 0; i < count; ++i) {
+    std::string name = entries[i].internal_name;
     EXPECT_EQ(std::string::npos, name.find(testing::kMultiSeparator)) << i;
   }
 }
 
 class AboutFlagsHistogramTest : public ::testing::Test {
  protected:
   // This is a helper function to check that all IDs in enum LoginCustomFlags in
   // histograms.xml are unique.
   void SetSwitchToHistogramIdMapping(const std::string& switch_name,
                                      const Sample switch_histogram_id,
@@ skipping 80 matching lines @@
     EXPECT_TRUE(enum_entry != histograms_xml_switches_ids.end() &&
                 enum_entry->first == flag)
         << "histograms.xml enum LoginCustomFlags doesn't contain switch '"
         << flag << "' (value=" << uma_id
         << " expected). Consider adding entry:\n"
         << "  " << GetHistogramEnumEntryText(flag, uma_id);
   }
 }
 
 }  // namespace about_flags