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

chrome/browser/about_flags.cc

 // Copyright (c) 2012 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 <iterator>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 59 matching lines @@
 #endif
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_switches.h"
 #endif
 
 namespace about_flags {
 
 // Macros to simplify specifying the type.
 #define SINGLE_VALUE_TYPE_AND_VALUE(command_line_switch, switch_value) \
-    Experiment::SINGLE_VALUE, \
+    Entry::SINGLE_VALUE, \
     command_line_switch, switch_value, NULL, NULL, NULL, 0
 #define SINGLE_VALUE_TYPE(command_line_switch) \
     SINGLE_VALUE_TYPE_AND_VALUE(command_line_switch, "")
 #define ENABLE_DISABLE_VALUE_TYPE_AND_VALUE(enable_switch, enable_value, \
                                             disable_switch, disable_value) \
-    Experiment::ENABLE_DISABLE_VALUE, enable_switch, enable_value, \
+    Entry::ENABLE_DISABLE_VALUE, enable_switch, enable_value, \
     disable_switch, disable_value, NULL, 3
 #define ENABLE_DISABLE_VALUE_TYPE(enable_switch, disable_switch) \
     ENABLE_DISABLE_VALUE_TYPE_AND_VALUE(enable_switch, "", disable_switch, "")
 #define MULTI_VALUE_TYPE(choices) \
-    Experiment::MULTI_VALUE, NULL, NULL, NULL, NULL, choices, arraysize(choices)
+    Entry::MULTI_VALUE, NULL, NULL, NULL, NULL, choices, arraysize(choices)
 
 namespace {
 
 // Enumeration of OSs.
 enum {
   kOsMac = 1 << 0,
   kOsWin = 1 << 1,
   kOsLinux = 1 << 2,
   kOsCrOS = 1 << 3,
   kOsAndroid = 1 << 4,
   kOsCrOSOwnerOnly = 1 << 5
 };
 
 const unsigned kOsAll = kOsMac | kOsWin | kOsLinux | kOsCrOS | kOsAndroid;
 const unsigned kOsDesktop = kOsMac | kOsWin | kOsLinux | kOsCrOS;
 
 // Adds a |StringValue| to |list| for each platform where |bitmask| indicates
-// whether the experiment is available on that platform.
+// whether the entry is available on that platform.
 void AddOsStrings(unsigned bitmask, base::ListValue* list) {
   struct {
     unsigned bit;
     const char* const name;
   } kBitsToOs[] = {
     {kOsMac, "Mac"},
     {kOsWin, "Windows"},
     {kOsLinux, "Linux"},
     {kOsCrOS, "Chrome OS"},
     {kOsAndroid, "Android"},
@@ skipping 31 matching lines @@
   first = std::find(cmdline.argv().begin(), cmdline.argv().end(),
                     GetSwitchString(chromeos::switches::kPolicySwitchesBegin));
   last = std::find(cmdline.argv().begin(), cmdline.argv().end(),
                    GetSwitchString(chromeos::switches::kPolicySwitchesEnd));
   if (first != cmdline.argv().end() && last != cmdline.argv().end())
     flags.insert(first + 1, last);
 #endif
   return flags;
 }
 
-const Experiment::Choice kTouchEventsChoices[] = {
+const Entry::Choice kTouchEventsChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_AUTOMATIC, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     switches::kTouchEvents,
     switches::kTouchEventsEnabled },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kTouchEvents,
     switches::kTouchEventsDisabled }
 };
 
 #if defined(USE_AURA)
-const Experiment::Choice kOverscrollHistoryNavigationChoices[] = {
+const Entry::Choice kOverscrollHistoryNavigationChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kOverscrollHistoryNavigation,
     "0" },
   { IDS_OVERSCROLL_HISTORY_NAVIGATION_SIMPLE_UI,
     switches::kOverscrollHistoryNavigation,
     "2" }
 };
 #endif
 
-const Experiment::Choice kTouchTextSelectionStrategyChoices[] = {
+const Entry::Choice kTouchTextSelectionStrategyChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_TOUCH_SELECTION_STRATEGY_CHARACTER,
     switches::kTouchTextSelectionStrategy,
     "character" },
   { IDS_TOUCH_SELECTION_STRATEGY_DIRECTION,
     switches::kTouchTextSelectionStrategy,
     "direction" }
 };
 
 #if !defined(DISABLE_NACL)
-const Experiment::Choice kNaClDebugMaskChoices[] = {
+const Entry::Choice kNaClDebugMaskChoices[] = {
   // Secure shell can be used on ChromeOS for forwarding the TCP port opened by
   // debug stub to a remote machine. Since secure shell uses NaCl, we usually
   // want to avoid debugging that. The PNaCl translator is also a NaCl module,
   // so by default we want to avoid debugging that.
   // NOTE: As the default value must be the empty string, the mask excluding
   // the PNaCl translator and secure shell is substituted elsewhere.
   { IDS_NACL_DEBUG_MASK_CHOICE_EXCLUDE_UTILS_PNACL, "", "" },
   { IDS_NACL_DEBUG_MASK_CHOICE_DEBUG_ALL, switches::kNaClDebugMask, "*://*" },
   { IDS_NACL_DEBUG_MASK_CHOICE_INCLUDE_DEBUG,
       switches::kNaClDebugMask, "*://*/*debug.nmf" }
 };
 #endif
 
-const Experiment::Choice kMarkNonSecureAsChoices[] = {
+const Entry::Choice kMarkNonSecureAsChoices[] = {
     { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
     { IDS_MARK_NON_SECURE_AS_NEUTRAL,
         switches::kMarkNonSecureAs, switches::kMarkNonSecureAsNeutral},
     { IDS_MARK_NON_SECURE_AS_NON_SECURE,
         switches::kMarkNonSecureAs, switches::kMarkNonSecureAsNonSecure},
     { IDS_MARK_NON_SECURE_AS_DUBIOUS,
         switches::kMarkNonSecureAs, switches::kMarkNonSecureAsDubious}
 };
 
-const Experiment::Choice kShowSavedCopyChoices[] = {
+const Entry::Choice kShowSavedCopyChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_ENABLE_SHOW_SAVED_COPY_PRIMARY,
     switches::kShowSavedCopy, switches::kEnableShowSavedCopyPrimary },
   { IDS_FLAGS_ENABLE_SHOW_SAVED_COPY_SECONDARY,
     switches::kShowSavedCopy, switches::kEnableShowSavedCopySecondary },
   { IDS_FLAGS_DISABLE_SHOW_SAVED_COPY,
     switches::kShowSavedCopy, switches::kDisableShowSavedCopy }
 };
 
-const Experiment::Choice kDefaultTileWidthChoices[] = {
+const Entry::Choice kDefaultTileWidthChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_DEFAULT_TILE_WIDTH_SHORT,
     switches::kDefaultTileWidth, "128"},
   { IDS_FLAGS_DEFAULT_TILE_WIDTH_TALL,
     switches::kDefaultTileWidth, "256"},
   { IDS_FLAGS_DEFAULT_TILE_WIDTH_GRANDE,
     switches::kDefaultTileWidth, "512"},
   { IDS_FLAGS_DEFAULT_TILE_WIDTH_VENTI,
     switches::kDefaultTileWidth, "1024"}
 };
 
-const Experiment::Choice kDefaultTileHeightChoices[] = {
+const Entry::Choice kDefaultTileHeightChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_DEFAULT_TILE_HEIGHT_SHORT,
     switches::kDefaultTileHeight, "128"},
   { IDS_FLAGS_DEFAULT_TILE_HEIGHT_TALL,
     switches::kDefaultTileHeight, "256"},
   { IDS_FLAGS_DEFAULT_TILE_HEIGHT_GRANDE,
     switches::kDefaultTileHeight, "512"},
   { IDS_FLAGS_DEFAULT_TILE_HEIGHT_VENTI,
     switches::kDefaultTileHeight, "1024"}
 };
 
-const Experiment::Choice kSimpleCacheBackendChoices[] = {
+const Entry::Choice kSimpleCacheBackendChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kUseSimpleCacheBackend, "off" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     switches::kUseSimpleCacheBackend, "on"}
 };
 
 #if defined(USE_AURA)
-const Experiment::Choice kTabCaptureUpscaleQualityChoices[] = {
+const Entry::Choice kTabCaptureUpscaleQualityChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_TAB_CAPTURE_SCALE_QUALITY_FAST,
     switches::kTabCaptureUpscaleQuality, "fast" },
   { IDS_FLAGS_TAB_CAPTURE_SCALE_QUALITY_GOOD,
     switches::kTabCaptureUpscaleQuality, "good" },
   { IDS_FLAGS_TAB_CAPTURE_SCALE_QUALITY_BEST,
     switches::kTabCaptureUpscaleQuality, "best" },
 };
 
-const Experiment::Choice kTabCaptureDownscaleQualityChoices[] = {
+const Entry::Choice kTabCaptureDownscaleQualityChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_TAB_CAPTURE_SCALE_QUALITY_FAST,
     switches::kTabCaptureDownscaleQuality, "fast" },
   { IDS_FLAGS_TAB_CAPTURE_SCALE_QUALITY_GOOD,
     switches::kTabCaptureDownscaleQuality, "good" },
   { IDS_FLAGS_TAB_CAPTURE_SCALE_QUALITY_BEST,
     switches::kTabCaptureDownscaleQuality, "best" },
 };
 #endif
 
 #if defined(OS_ANDROID)
-const Experiment::Choice kZeroSuggestExperimentsChoices[] = {
+const Entry::Choice kZeroSuggestExperimentsChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_ZERO_SUGGEST_MOST_VISITED,
     switches::kEnableZeroSuggestMostVisited, ""},
   { IDS_FLAGS_ZERO_SUGGEST_MOST_VISITED_WITHOUT_SERP,
     switches::kEnableZeroSuggestMostVisitedWithoutSerp, ""},
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kDisableZeroSuggest, ""}
 };
 
-const Experiment::Choice kReaderModeHeuristicsChoices[] = {
+const Entry::Choice kReaderModeHeuristicsChoices[] = {
     { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", ""},
     { IDS_FLAGS_READER_MODE_HEURISTICS_MARKUP,
       switches::kReaderModeHeuristics,
       switches::reader_mode_heuristics::kOGArticle },
     { IDS_FLAGS_READER_MODE_HEURISTICS_ADABOOST,
       switches::kReaderModeHeuristics,
       switches::reader_mode_heuristics::kAdaBoost },
     { IDS_FLAGS_READER_MODE_HEURISTICS_ALWAYS_ON,
       switches::kReaderModeHeuristics,
       switches::reader_mode_heuristics::kAlwaysTrue },
     { IDS_FLAGS_READER_MODE_HEURISTICS_ALWAYS_OFF,
       switches::kReaderModeHeuristics,
       switches::reader_mode_heuristics::kNone },
 };
 #endif
 
-const Experiment::Choice kNumRasterThreadsChoices[] = {
+const Entry::Choice kNumRasterThreadsChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_NUM_RASTER_THREADS_ONE, switches::kNumRasterThreads, "1" },
   { IDS_FLAGS_NUM_RASTER_THREADS_TWO, switches::kNumRasterThreads, "2" },
   { IDS_FLAGS_NUM_RASTER_THREADS_THREE, switches::kNumRasterThreads, "3" },
   { IDS_FLAGS_NUM_RASTER_THREADS_FOUR, switches::kNumRasterThreads, "4" }
 };
 
-const Experiment::Choice kGpuRasterizationMSAASampleCountChoices[] = {
+const Entry::Choice kGpuRasterizationMSAASampleCountChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT,
     "",
     "" },
   { IDS_FLAGS_GPU_RASTERIZATION_MSAA_SAMPLE_COUNT_ZERO,
     switches::kGpuRasterizationMSAASampleCount, "0" },
   { IDS_FLAGS_GPU_RASTERIZATION_MSAA_SAMPLE_COUNT_TWO,
     switches::kGpuRasterizationMSAASampleCount, "2" },
   { IDS_FLAGS_GPU_RASTERIZATION_MSAA_SAMPLE_COUNT_FOUR,
     switches::kGpuRasterizationMSAASampleCount, "4" },
   { IDS_FLAGS_GPU_RASTERIZATION_MSAA_SAMPLE_COUNT_EIGHT,
     switches::kGpuRasterizationMSAASampleCount, "8" },
   { IDS_FLAGS_GPU_RASTERIZATION_MSAA_SAMPLE_COUNT_SIXTEEN,
     switches::kGpuRasterizationMSAASampleCount, "16" },
 };
 
-const Experiment::Choice kEnableGpuRasterizationChoices[] = {
+const Entry::Choice kEnableGpuRasterizationChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     switches::kEnableGpuRasterization, "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kDisableGpuRasterization, "" },
   { IDS_FLAGS_FORCE_GPU_RASTERIZATION,
     switches::kForceGpuRasterization, "" },
 };
 
 #if defined(OS_CHROMEOS)
-const Experiment::Choice kMemoryPressureThresholdChoices[] = {
+const Entry::Choice kMemoryPressureThresholdChoices[] = {
     { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
     { IDS_FLAGS_CONSERVATIVE_THRESHOLDS,
       chromeos::switches::kMemoryPressureThresholds,
       chromeos::switches::kConservativeThreshold },
     { IDS_FLAGS_AGGRESSIVE_CACHE_DISCARD_THRESHOLDS,
       chromeos::switches::kMemoryPressureThresholds,
       chromeos::switches::kAggressiveCacheDiscardThreshold },
     { IDS_FLAGS_AGGRESSIVE_TAB_DISCARD_THRESHOLDS,
       chromeos::switches::kMemoryPressureThresholds,
       chromeos::switches::kAggressiveTabDiscardThreshold },
     { IDS_FLAGS_AGGRESSIVE_THRESHOLDS,
       chromeos::switches::kMemoryPressureThresholds,
       chromeos::switches::kAggressiveThreshold },
 };
 #endif
 
-const Experiment::Choice kExtensionContentVerificationChoices[] = {
+const Entry::Choice kExtensionContentVerificationChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_FLAGS_EXTENSION_CONTENT_VERIFICATION_BOOTSTRAP,
     switches::kExtensionContentVerification,
     switches::kExtensionContentVerificationBootstrap },
   { IDS_FLAGS_EXTENSION_CONTENT_VERIFICATION_ENFORCE,
     switches::kExtensionContentVerification,
     switches::kExtensionContentVerificationEnforce },
   { IDS_FLAGS_EXTENSION_CONTENT_VERIFICATION_ENFORCE_STRICT,
     switches::kExtensionContentVerification,
     switches::kExtensionContentVerificationEnforceStrict },
 };
 
 // Note that the value is specified in seconds (where 0 is equivalent to
 // disabled).
-const Experiment::Choice kRememberCertificateErrorDecisionsChoices[] = {
+const Entry::Choice kRememberCertificateErrorDecisionsChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kRememberCertErrorDecisions,
     "-1" },
   { IDS_REMEMBER_CERTIFICATE_ERROR_DECISION_CHOICE_ONE_DAY,
     switches::kRememberCertErrorDecisions,
     "86400" },
   { IDS_REMEMBER_CERTIFICATE_ERROR_DECISION_CHOICE_THREE_DAYS,
     switches::kRememberCertErrorDecisions,
     "259200" },
   { IDS_REMEMBER_CERTIFICATE_ERROR_DECISION_CHOICE_ONE_WEEK,
     switches::kRememberCertErrorDecisions,
     "604800" },
   { IDS_REMEMBER_CERTIFICATE_ERROR_DECISION_CHOICE_ONE_MONTH,
     switches::kRememberCertErrorDecisions,
     "2592000" },
   { IDS_REMEMBER_CERTIFICATE_ERROR_DECISION_CHOICE_THREE_MONTHS,
     switches::kRememberCertErrorDecisions,
     "7776000" },
 };
 
-const Experiment::Choice kAutofillSyncCredentialChoices[] = {
+const Entry::Choice kAutofillSyncCredentialChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", ""},
   { IDS_ALLOW_AUTOFILL_SYNC_CREDENTIAL,
     password_manager::switches::kAllowAutofillSyncCredential, ""},
   { IDS_DISALLOW_AUTOFILL_SYNC_CREDENTIAL_FOR_REAUTH,
     password_manager::switches::kDisallowAutofillSyncCredentialForReauth, ""},
   { IDS_DISALLOW_AUTOFILL_SYNC_CREDENTIAL,
     password_manager::switches::kDisallowAutofillSyncCredential, ""},
 };
 
-const Experiment::Choice kSSLVersionMinChoices[] = {
+const Entry::Choice kSSLVersionMinChoices[] = {
   { IDS_FLAGS_SSL_VERSION_DEFAULT, "", "" },
   { IDS_FLAGS_SSL_VERSION_TLSV1, switches::kSSLVersionMin,
     switches::kSSLVersionTLSv1 },
   { IDS_FLAGS_SSL_VERSION_TLSV11, switches::kSSLVersionMin,
     switches::kSSLVersionTLSv11 },
   { IDS_FLAGS_SSL_VERSION_TLSV12, switches::kSSLVersionMin,
     switches::kSSLVersionTLSv12 },
 };
 
-const Experiment::Choice kFillOnAccountSelectChoices[] = {
+const Entry::Choice kFillOnAccountSelectChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     autofill::switches::kDisableFillOnAccountSelect, "" },
   { IDS_FLAGS_FILL_ON_ACCOUNT_SELECT_ENABLE_HIGHLIGHTING,
     autofill::switches::kEnableFillOnAccountSelect, "" },
   { IDS_FLAGS_FILL_ON_ACCOUNT_SELECT_ENABLE_NO_HIGHLIGHTING,
     autofill::switches::kEnableFillOnAccountSelectNoHighlighting, "" },
 };
 
 #if defined(USE_ASH)
-const Experiment::Choice kAshScreenRotationAnimationChoices[] = {
+const Entry::Choice kAshScreenRotationAnimationChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     ash::switches::kAshEnableScreenRotationAnimation,
     "none" },
   { IDS_ASH_SCREEN_ROTATION_ANIMATION_PARTIAL_ROTATION,
     ash::switches::kAshEnableScreenRotationAnimation,
     "partial-rotation" },
   { IDS_ASH_SCREEN_ROTATION_ANIMATION_FULL_ROTATION,
     ash::switches::kAshEnableScreenRotationAnimation,
     "full-rotation" }
 };
 #endif
 
 #if defined(OS_CHROMEOS)
-const Experiment::Choice kDataSaverPromptChoices[] = {
+const Entry::Choice kDataSaverPromptChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     chromeos::switches::kDisableDataSaverPrompt, "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     chromeos::switches::kEnableDataSaverPrompt, "" },
   { IDS_FLAGS_DATASAVER_PROMPT_DEMO_MODE,
     chromeos::switches::kEnableDataSaverPrompt,
     chromeos::switches::kDataSaverPromptDemoMode },
 };
 
-const Experiment::Choice kFloatingVirtualKeyboardChoices[] = {
+const Entry::Choice kFloatingVirtualKeyboardChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     keyboard::switches::kFloatingVirtualKeyboard,
     keyboard::switches::kFloatingVirtualKeyboardDisabled},
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     keyboard::switches::kFloatingVirtualKeyboard,
     keyboard::switches::kFloatingVirtualKeyboardEnabled},
 };
 
-const Experiment::Choice kGestureTypingChoices[] = {
+const Entry::Choice kGestureTypingChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     keyboard::switches::kGestureTyping,
     keyboard::switches::kGestureTypingDisabled},
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     keyboard::switches::kGestureTyping,
     keyboard::switches::kGestureTypingEnabled},
 };
 
-const Experiment::Choice kGestureEditingChoices[] = {
+const Entry::Choice kGestureEditingChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     keyboard::switches::kGestureEditing,
     keyboard::switches::kGestureEditingDisabled},
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     keyboard::switches::kGestureEditing,
     keyboard::switches::kGestureEditingEnabled},
 };
 #endif
 
-const Experiment::Choice kSupervisedUserSafeSitesChoices[] = {
+const Entry::Choice kSupervisedUserSafeSitesChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     switches::kSupervisedUserSafeSites,
     "enabled" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kSupervisedUserSafeSites,
     "disabled" },
   { IDS_SUPERVISED_USER_SAFESITES_BLACKLIST_ONLY,
     switches::kSupervisedUserSafeSites,
     "blacklist-only" },
   { IDS_SUPERVISED_USER_SAFESITES_ONLINE_CHECK_ONLY,
     switches::kSupervisedUserSafeSites,
     "online-check-only" }
 };
 
 // RECORDING USER METRICS FOR FLAGS:
 // -----------------------------------------------------------------------------
-// The first line of the experiment is the internal name. If you'd like to
-// gather statistics about the usage of your flag, you should append a marker
-// comment to the end of the feature name, like so:
+// The first line of the entry is the internal name. If you'd like to gather
+// statistics about the usage of your flag, you should append a marker comment
+// to the end of the feature name, like so:
 //   "my-special-feature",  // FLAGS:RECORD_UMA
 //
 // After doing that, run
 //   tools/metrics/actions/extract_actions.py
 // to add the metric to actions.xml (which will enable UMA to record your
 // feature flag), then update the <owner>s and <description> sections. Make sure
 // to include the actions.xml file when you upload your code for review!
 //
 // After your feature has shipped under a flag, you can locate the metrics under
 // the action name AboutFlags_internal-action-name. Actions are recorded once
 // per startup, so you should divide this number by AboutFlags_StartupTick to
 // get a sense of usage. Note that this will not be the same as number of users
 // with a given feature enabled because users can quit and relaunch the
 // application multiple times over a given time interval. The dashboard also
 // shows you how many (metrics reporting) users have enabled the flag over the
 // last seven days. However, note that this is not the same as the number of
 // users who have the flag enabled, since enabling the flag happens once,
 // whereas running with the flag enabled happens until the user flips the flag
 // again.
 
-// To add a new experiment add to the end of kExperiments. There are two
-// distinct types of experiments:
-// . SINGLE_VALUE: experiment is either on or off. Use the SINGLE_VALUE_TYPE
+// To add a new entry, add to the end of kEntries. There are two
+// distinct types of entries:
+// . SINGLE_VALUE: entry is either on or off. Use the SINGLE_VALUE_TYPE
 //   macro for this type supplying the command line to the macro.
 // . MULTI_VALUE: a list of choices, the first of which should correspond to a
 //   deactivated state for this lab (i.e. no command line option).  To specify
-//   this type of experiment use the macro MULTI_VALUE_TYPE supplying it the
+//   this type of entry use the macro MULTI_VALUE_TYPE supplying it the
 //   array of choices.
-// See the documentation of Experiment for details on the fields.
+// See the documentation of Entry for details on the fields.
 //
 // Command-line switches must have entries in enum "LoginCustomFlags" in
 // histograms.xml. See note in histograms.xml and don't forget to run
 // AboutFlagsHistogramTest unit test to calculate and verify checksum.
 //
 // When adding a new choice, add it to the end of the list.
-const Experiment kExperiments[] = {
+const Entry kEntries[] = {
   {
     "ignore-gpu-blacklist",
     IDS_FLAGS_IGNORE_GPU_BLACKLIST_NAME,
     IDS_FLAGS_IGNORE_GPU_BLACKLIST_DESCRIPTION,
     kOsAll,
     SINGLE_VALUE_TYPE(switches::kIgnoreGpuBlacklist)
   },
 #if defined(OS_WIN)
   {
     "disable-direct-write",
@@ skipping 1896 matching lines @@
     IDS_FLAGS_EMPHASIZE_TITLES_IN_OMNIBOX_DROPDOWN_NAME,
     IDS_FLAGS_EMPHASIZE_TITLES_IN_OMNIBOX_DROPDOWN_DESCRIPTION,
     kOsAll,
     SINGLE_VALUE_TYPE(switches::kEmphasizeTitlesInOmniboxDropdown)
   },
   // NOTE: Adding new command-line switches requires adding corresponding
   // entries to enum "LoginCustomFlags" in histograms.xml. See note in
   // histograms.xml and don't forget to run AboutFlagsHistogramTest unit test.
 };
 
-const Experiment* experiments = kExperiments;
-size_t num_experiments = arraysize(kExperiments);
+const Entry* entries = kEntries;
+size_t num_entries = arraysize(kEntries);
 
 // Stores and encapsulates the little state that about:flags has.
 class FlagsState {
  public:
   FlagsState() : needs_restart_(false) {}
   void ConvertFlagsToSwitches(FlagsStorage* flags_storage,
                               base::CommandLine* command_line,
                               SentinelsMode sentinels);
   bool IsRestartNeededToCommitChanges();
-  void SetExperimentEnabled(
+  void SetEntryEnabled(
       FlagsStorage* flags_storage,
       const std::string& internal_name,
       bool enable);
   void RemoveFlagsSwitches(
       std::map<std::string, base::CommandLine::StringType>* switch_list);
   void ResetAllFlags(FlagsStorage* flags_storage);
   void reset();
 
   // Returns the singleton instance of this class
   static FlagsState* GetInstance() {
     return Singleton<FlagsState>::get();
   }
 
  private:
   bool needs_restart_;
   std::map<std::string, std::string> flags_switches_;
 
   DISALLOW_COPY_AND_ASSIGN(FlagsState);
 };
 
-// Adds the internal names for the specified experiment to |names|.
-void AddInternalName(const Experiment& e, std::set<std::string>* names) {
-  if (e.type == Experiment::SINGLE_VALUE) {
+// Adds the internal names for the specified entry to |names|.
+void AddInternalName(const Entry& e, std::set<std::string>* names) {
+  if (e.type == Entry::SINGLE_VALUE) {
     names->insert(e.internal_name);
   } else {
-    DCHECK(e.type == Experiment::MULTI_VALUE ||
-           e.type == Experiment::ENABLE_DISABLE_VALUE);
+    DCHECK(e.type == Entry::MULTI_VALUE ||
+           e.type == Entry::ENABLE_DISABLE_VALUE);
     for (int i = 0; i < e.num_choices; ++i)
       names->insert(e.NameForChoice(i));
   }
 }
 
-// Confirms that an experiment is valid, used in a DCHECK in
-// SanitizeList below.
-bool ValidateExperiment(const Experiment& e) {
+// Confirms that an entry is valid, used in a DCHECK in SanitizeList below.
+bool ValidateEntry(const Entry& e) {
   switch (e.type) {
-    case Experiment::SINGLE_VALUE:
+    case Entry::SINGLE_VALUE:
       DCHECK_EQ(0, e.num_choices);
       DCHECK(!e.choices);
       break;
-    case Experiment::MULTI_VALUE:
+    case Entry::MULTI_VALUE:
       DCHECK_GT(e.num_choices, 0);
       DCHECK(e.choices);
       DCHECK(e.choices[0].command_line_switch);
       DCHECK_EQ('\0', e.choices[0].command_line_switch[0]);
       break;
-    case Experiment::ENABLE_DISABLE_VALUE:
+    case Entry::ENABLE_DISABLE_VALUE:
       DCHECK_EQ(3, e.num_choices);
       DCHECK(!e.choices);
       DCHECK(e.command_line_switch);
       DCHECK(e.command_line_value);
       DCHECK(e.disable_command_line_switch);
       DCHECK(e.disable_command_line_value);
       break;
     default:
       NOTREACHED();
   }
   return true;
 }
 
-// Removes all experiments from prefs::kEnabledLabsExperiments that are
-// unknown, to prevent this list to become very long as experiments are added
-// and removed.
+// Removes all entries from prefs::kEnabledLabsExperiments that are unknown, to
+// prevent this list to become very long as entries are added and removed.
 void SanitizeList(FlagsStorage* flags_storage) {
-  std::set<std::string> known_experiments;
-  for (size_t i = 0; i < num_experiments; ++i) {
-    DCHECK(ValidateExperiment(experiments[i]));
-    AddInternalName(experiments[i], &known_experiments);
+  std::set<std::string> known_entries;
+  for (size_t i = 0; i < num_entries; ++i) {
+    DCHECK(ValidateEntry(entries[i]));
+    AddInternalName(entries[i], &known_entries);
   }
 
-  std::set<std::string> enabled_experiments = flags_storage->GetFlags();
+  std::set<std::string> enabled_entries = flags_storage->GetFlags();
 
-  std::set<std::string> new_enabled_experiments =
+  std::set<std::string> new_enabled_entries =
       base::STLSetIntersection<std::set<std::string> >(
-          known_experiments, enabled_experiments);
+          known_entries, enabled_entries);
 
-  if (new_enabled_experiments != enabled_experiments)
-    flags_storage->SetFlags(new_enabled_experiments);
+  if (new_enabled_entries != enabled_entries)
+    flags_storage->SetFlags(new_enabled_entries);
 }
 
-void GetSanitizedEnabledFlags(
-    FlagsStorage* flags_storage, std::set<std::string>* result) {
+void GetSanitizedEnabledFlags(FlagsStorage* flags_storage,
+                              std::set<std::string>* result) {
   SanitizeList(flags_storage);
   *result = flags_storage->GetFlags();
 }
 
-bool SkipConditionalExperiment(const Experiment& experiment,
-                               FlagsStorage* flags_storage) {
+bool SkipConditionalEntry(const Entry& entry, FlagsStorage* flags_storage) {
 #if defined(OS_ANDROID) || defined(ENABLE_DATA_REDUCTION_PROXY_DEBUGGING)
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
 #endif
 
 #if defined(OS_ANDROID)
   // enable-data-reduction-proxy-dev is only available for the Dev/Beta channel.
-  if (!strcmp("enable-data-reduction-proxy-dev", experiment.internal_name) &&
+  if (!strcmp("enable-data-reduction-proxy-dev", entry.internal_name) &&
       channel != chrome::VersionInfo::CHANNEL_BETA &&
       channel != chrome::VersionInfo::CHANNEL_DEV) {
     return true;
   }
   // enable-data-reduction-proxy-alt is only available for the Dev channel.
-  if (!strcmp("enable-data-reduction-proxy-alt", experiment.internal_name) &&
+  if (!strcmp("enable-data-reduction-proxy-alt", entry.internal_name) &&
       channel != chrome::VersionInfo::CHANNEL_DEV) {
     return true;
   }
   // enable-data-reduction-proxy-lo-fi is only available for Chromium builds and
   // the Canary/Dev channel.
-  if (!strcmp("enable-data-reduction-proxy-lo-fi", experiment.internal_name) &&
+  if (!strcmp("enable-data-reduction-proxy-lo-fi", entry.internal_name) &&
       channel != chrome::VersionInfo::CHANNEL_DEV &&
       channel != chrome::VersionInfo::CHANNEL_CANARY &&
       channel != chrome::VersionInfo::CHANNEL_UNKNOWN) {
     return true;
   }
 #endif
 
 #if defined(ENABLE_DATA_REDUCTION_PROXY_DEBUGGING)
   // enable-data-reduction-proxy-bypass-warning is only available for Chromium
   // builds and Canary/Dev channel.
   if (!strcmp("enable-data-reduction-proxy-bypass-warnings",
-              experiment.internal_name) &&
+              entry.internal_name) &&
       channel != chrome::VersionInfo::CHANNEL_UNKNOWN &&
       channel != chrome::VersionInfo::CHANNEL_CANARY &&
       channel != chrome::VersionInfo::CHANNEL_DEV) {
     return true;
   }
 #endif
 
   return false;
 }
 
 
 // Variant of GetSanitizedEnabledFlags that also removes any flags that aren't
 // enabled on the current platform.
 void GetSanitizedEnabledFlagsForCurrentPlatform(
     FlagsStorage* flags_storage, std::set<std::string>* result) {
   GetSanitizedEnabledFlags(flags_storage, result);
 
-  // Filter out any experiments that aren't enabled on the current platform.  We
+  // Filter out any entries that aren't enabled on the current platform.  We
   // don't remove these from prefs else syncing to a platform with a different
-  // set of experiments would be lossy.
-  std::set<std::string> platform_experiments;
+  // set of entries would be lossy.
+  std::set<std::string> platform_entries;
   int current_platform = GetCurrentPlatform();
-  for (size_t i = 0; i < num_experiments; ++i) {
-    if (experiments[i].supported_platforms & current_platform)
-      AddInternalName(experiments[i], &platform_experiments);
+  for (size_t i = 0; i < num_entries; ++i) {
+    if (entries[i].supported_platforms & current_platform)
+      AddInternalName(entries[i], &platform_entries);
 #if defined(OS_CHROMEOS)
-    if (experiments[i].supported_platforms & kOsCrOSOwnerOnly)
-      AddInternalName(experiments[i], &platform_experiments);
+    if (entries[i].supported_platforms & kOsCrOSOwnerOnly)
+      AddInternalName(entries[i], &platform_entries);
 #endif
   }
 
-  std::set<std::string> new_enabled_experiments =
+  std::set<std::string> new_enabled_entries =
       base::STLSetIntersection<std::set<std::string> >(
-          platform_experiments, *result);
+          platform_entries, *result);
 
-  result->swap(new_enabled_experiments);
+  result->swap(new_enabled_entries);
 }
 
-// Returns the Value representing the choice data in the specified experiment.
+// Returns the Value representing the choice data in the specified entry.
 base::Value* CreateChoiceData(
-    const Experiment& experiment,
-    const std::set<std::string>& enabled_experiments) {
-  DCHECK(experiment.type == Experiment::MULTI_VALUE ||
-         experiment.type == Experiment::ENABLE_DISABLE_VALUE);
+    const Entry& entry,
+    const std::set<std::string>& enabled_entries) {
+  DCHECK(entry.type == Entry::MULTI_VALUE ||
+         entry.type == Entry::ENABLE_DISABLE_VALUE);
   base::ListValue* result = new base::ListValue;
-  for (int i = 0; i < experiment.num_choices; ++i) {
+  for (int i = 0; i < entry.num_choices; ++i) {
     base::DictionaryValue* value = new base::DictionaryValue;
-    const std::string name = experiment.NameForChoice(i);
+    const std::string name = entry.NameForChoice(i);
     value->SetString("internal_name", name);
-    value->SetString("description", experiment.DescriptionForChoice(i));
-    value->SetBoolean("selected", enabled_experiments.count(name) > 0);
+    value->SetString("description", entry.DescriptionForChoice(i));
+    value->SetBoolean("selected", enabled_entries.count(name) > 0);
     result->Append(value);
   }
   return result;
 }
 
 }  // namespace
 
-std::string Experiment::NameForChoice(int index) const {
-  DCHECK(type == Experiment::MULTI_VALUE ||
-         type == Experiment::ENABLE_DISABLE_VALUE);
+std::string Entry::NameForChoice(int index) const {
+  DCHECK(type == Entry::MULTI_VALUE ||
+         type == Entry::ENABLE_DISABLE_VALUE);
   DCHECK_LT(index, num_choices);
   return std::string(internal_name) + testing::kMultiSeparator +
          base::IntToString(index);
 }
 
-base::string16 Experiment::DescriptionForChoice(int index) const {
-  DCHECK(type == Experiment::MULTI_VALUE ||
-         type == Experiment::ENABLE_DISABLE_VALUE);
+base::string16 Entry::DescriptionForChoice(int index) const {
+  DCHECK(type == Entry::MULTI_VALUE ||
+         type == Entry::ENABLE_DISABLE_VALUE);
   DCHECK_LT(index, num_choices);
   int description_id;
-  if (type == Experiment::ENABLE_DISABLE_VALUE) {
+  if (type == Entry::ENABLE_DISABLE_VALUE) {
     const int kEnableDisableDescriptionIds[] = {
       IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT,
       IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
       IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     };
     description_id = kEnableDisableDescriptionIds[index];
   } else {
     description_id = choices[index].description_id;
   }
   return l10n_util::GetStringUTF16(description_id);
@@ skipping 28 matching lines @@
         new_flags.begin(),
         new_flags.end(),
         active_flags.begin(),
         active_flags.end(),
         std::inserter(*out_difference, out_difference->begin()));
   }
 
   return result;
 }
 
-void GetFlagsExperimentsData(FlagsStorage* flags_storage,
-                             FlagAccess access,
-                             base::ListValue* supported_experiments,
-                             base::ListValue* unsupported_experiments) {
-  std::set<std::string> enabled_experiments;
-  GetSanitizedEnabledFlags(flags_storage, &enabled_experiments);
+void GetFlagsEntryData(FlagsStorage* flags_storage,
+                       FlagAccess access,
+                       base::ListValue* supported_entries,
+                       base::ListValue* unsupported_entries) {
+  std::set<std::string> enabled_entries;
+  GetSanitizedEnabledFlags(flags_storage, &enabled_entries);
 
   int current_platform = GetCurrentPlatform();
 
-  for (size_t i = 0; i < num_experiments; ++i) {
-    const Experiment& experiment = experiments[i];
-    if (SkipConditionalExperiment(experiment, flags_storage))
+  for (size_t i = 0; i < num_entries; ++i) {
+    const Entry& entry = entries[i];
+    if (SkipConditionalEntry(entry, flags_storage))
       continue;
 
     base::DictionaryValue* data = new base::DictionaryValue();
-    data->SetString("internal_name", experiment.internal_name);
+    data->SetString("internal_name", entry.internal_name);
     data->SetString("name",
-                    l10n_util::GetStringUTF16(experiment.visible_name_id));
+                    l10n_util::GetStringUTF16(entry.visible_name_id));
     data->SetString("description",
-                    l10n_util::GetStringUTF16(
-                        experiment.visible_description_id));
+                    l10n_util::GetStringUTF16(entry.visible_description_id));
 
     base::ListValue* supported_platforms = new base::ListValue();
-    AddOsStrings(experiment.supported_platforms, supported_platforms);
+    AddOsStrings(entry.supported_platforms, supported_platforms);
     data->Set("supported_platforms", supported_platforms);
 
-    switch (experiment.type) {
-      case Experiment::SINGLE_VALUE:
-        data->SetBoolean(
-            "enabled",
-            enabled_experiments.count(experiment.internal_name) > 0);
+    switch (entry.type) {
+      case Entry::SINGLE_VALUE:
+        data->SetBoolean("enabled",
+                         enabled_entries.count(entry.internal_name) > 0);
         break;
-      case Experiment::MULTI_VALUE:
-      case Experiment::ENABLE_DISABLE_VALUE:
-        data->Set("choices", CreateChoiceData(experiment, enabled_experiments));
+      case Entry::MULTI_VALUE:
+      case Entry::ENABLE_DISABLE_VALUE:
+        data->Set("choices", CreateChoiceData(entry, enabled_entries));
         break;
       default:
         NOTREACHED();
     }
 
-    bool supported = (experiment.supported_platforms & current_platform) != 0;
+    bool supported = (entry.supported_platforms & current_platform) != 0;
 #if defined(OS_CHROMEOS)
     if (access == kOwnerAccessToFlags &&
-        (experiment.supported_platforms & kOsCrOSOwnerOnly) != 0) {
+        (entry.supported_platforms & kOsCrOSOwnerOnly) != 0) {
       supported = true;
     }
 #endif
     if (supported)
-      supported_experiments->Append(data);
+      supported_entries->Append(data);
     else
-      unsupported_experiments->Append(data);
+      unsupported_entries->Append(data);
   }
 }
 
 bool IsRestartNeededToCommitChanges() {
   return FlagsState::GetInstance()->IsRestartNeededToCommitChanges();
 }
 
-void SetExperimentEnabled(FlagsStorage* flags_storage,
-                          const std::string& internal_name,
-                          bool enable) {
-  FlagsState::GetInstance()->SetExperimentEnabled(flags_storage,
-                                                  internal_name, enable);
+void SetEntryEnabled(FlagsStorage* flags_storage,
+                     const std::string& internal_name,
+                     bool enable) {
+  FlagsState::GetInstance()->SetEntryEnabled(flags_storage, internal_name,
+                                             enable);
 }
 
 void RemoveFlagsSwitches(
     std::map<std::string, base::CommandLine::StringType>* switch_list) {
   FlagsState::GetInstance()->RemoveFlagsSwitches(switch_list);
 }
 
 void ResetAllFlags(FlagsStorage* flags_storage) {
   FlagsState::GetInstance()->ResetAllFlags(flags_storage);
 }
@@ skipping 75 matching lines @@
   DCHECK(name_to_switch_map->end() == name_to_switch_map->find(key));
   (*name_to_switch_map)[key] = std::make_pair(switch_name, switch_value);
 }
 
 void FlagsState::ConvertFlagsToSwitches(FlagsStorage* flags_storage,
                                         base::CommandLine* command_line,
                                         SentinelsMode sentinels) {
   if (command_line->HasSwitch(switches::kNoExperiments))
     return;
 
-  std::set<std::string> enabled_experiments;
+  std::set<std::string> enabled_entries;
 
   GetSanitizedEnabledFlagsForCurrentPlatform(flags_storage,
-                                             &enabled_experiments);
+                                             &enabled_entries);
 
   NameToSwitchAndValueMap name_to_switch_map;
-  for (size_t i = 0; i < num_experiments; ++i) {
-    const Experiment& e = experiments[i];
-    if (e.type == Experiment::SINGLE_VALUE) {
+  for (size_t i = 0; i < num_entries; ++i) {
+    const Entry& e = entries[i];
+    if (e.type == Entry::SINGLE_VALUE) {
       SetFlagToSwitchMapping(e.internal_name, e.command_line_switch,
                              e.command_line_value, &name_to_switch_map);
-    } else if (e.type == Experiment::MULTI_VALUE) {
+    } else if (e.type == Entry::MULTI_VALUE) {
       for (int j = 0; j < e.num_choices; ++j) {
         SetFlagToSwitchMapping(e.NameForChoice(j),
                                e.choices[j].command_line_switch,
                                e.choices[j].command_line_value,
                                &name_to_switch_map);
       }
     } else {
-      DCHECK_EQ(e.type, Experiment::ENABLE_DISABLE_VALUE);
+      DCHECK_EQ(e.type, Entry::ENABLE_DISABLE_VALUE);
       SetFlagToSwitchMapping(e.NameForChoice(0), std::string(), std::string(),
                              &name_to_switch_map);
       SetFlagToSwitchMapping(e.NameForChoice(1), e.command_line_switch,
                              e.command_line_value, &name_to_switch_map);
       SetFlagToSwitchMapping(e.NameForChoice(2), e.disable_command_line_switch,
                              e.disable_command_line_value, &name_to_switch_map);
     }
   }
 
   if (sentinels == kAddSentinels) {
     command_line->AppendSwitch(switches::kFlagSwitchesBegin);
     flags_switches_.insert(
         std::pair<std::string, std::string>(switches::kFlagSwitchesBegin,
                                             std::string()));
   }
-  for (const std::string& experiment_name : enabled_experiments) {
+  for (const std::string& entry_name : enabled_entries) {
     NameToSwitchAndValueMap::const_iterator name_to_switch_it =
-        name_to_switch_map.find(experiment_name);
+        name_to_switch_map.find(entry_name);
     if (name_to_switch_it == name_to_switch_map.end()) {
       NOTREACHED();
       continue;
     }
 
     const std::pair<std::string, std::string>&
         switch_and_value_pair = name_to_switch_it->second;
 
     CHECK(!switch_and_value_pair.first.empty());
     command_line->AppendSwitchASCII(switch_and_value_pair.first,
                                     switch_and_value_pair.second);
     flags_switches_[switch_and_value_pair.first] = switch_and_value_pair.second;
   }
   if (sentinels == kAddSentinels) {
     command_line->AppendSwitch(switches::kFlagSwitchesEnd);
     flags_switches_.insert(
         std::pair<std::string, std::string>(switches::kFlagSwitchesEnd,
                                             std::string()));
   }
 }
 
 bool FlagsState::IsRestartNeededToCommitChanges() {
   return needs_restart_;
 }
 
-void FlagsState::SetExperimentEnabled(FlagsStorage* flags_storage,
-                                      const std::string& internal_name,
-                                      bool enable) {
+void FlagsState::SetEntryEnabled(FlagsStorage* flags_storage,
+                                 const std::string& internal_name,
+                                 bool enable) {
   size_t at_index = internal_name.find(testing::kMultiSeparator);
   if (at_index != std::string::npos) {
     DCHECK(enable);
-    // We're being asked to enable a multi-choice experiment. Disable the
-    // currently selected choice.
+    // We're being asked to enable a multi-choice entry. Disable the currently
+    // selected choice.
     DCHECK_NE(at_index, 0u);
-    const std::string experiment_name = internal_name.substr(0, at_index);
-    SetExperimentEnabled(flags_storage, experiment_name, false);
+    const std::string entry_name = internal_name.substr(0, at_index);
+    SetEntryEnabled(flags_storage, entry_name, false);
 
     // And enable the new choice, if it is not the default first choice.
-    if (internal_name != experiment_name + "@0") {
-      std::set<std::string> enabled_experiments;
-      GetSanitizedEnabledFlags(flags_storage, &enabled_experiments);
-      needs_restart_ |= enabled_experiments.insert(internal_name).second;
-      flags_storage->SetFlags(enabled_experiments);
+    if (internal_name != entry_name + "@0") {
+      std::set<std::string> enabled_entries;
+      GetSanitizedEnabledFlags(flags_storage, &enabled_entries);
+      needs_restart_ |= enabled_entries.insert(internal_name).second;
+      flags_storage->SetFlags(enabled_entries);
     }
     return;
   }
 
-  std::set<std::string> enabled_experiments;
-  GetSanitizedEnabledFlags(flags_storage, &enabled_experiments);
+  std::set<std::string> enabled_entries;
+  GetSanitizedEnabledFlags(flags_storage, &enabled_entries);
 
-  const Experiment* e = NULL;
-  for (size_t i = 0; i < num_experiments; ++i) {
-    if (experiments[i].internal_name == internal_name) {
-      e = experiments + i;
+  const Entry* e = NULL;
+  for (size_t i = 0; i < num_entries; ++i) {
+    if (entries[i].internal_name == internal_name) {
+      e = entries + i;
       break;
     }
   }
   DCHECK(e);
 
-  if (e->type == Experiment::SINGLE_VALUE) {
+  if (e->type == Entry::SINGLE_VALUE) {
     if (enable)
-      needs_restart_ |= enabled_experiments.insert(internal_name).second;
+      needs_restart_ |= enabled_entries.insert(internal_name).second;
     else
-      needs_restart_ |= (enabled_experiments.erase(internal_name) > 0);
+      needs_restart_ |= (enabled_entries.erase(internal_name) > 0);
   } else {
     if (enable) {
       // Enable the first choice.
-      needs_restart_ |= enabled_experiments.insert(e->NameForChoice(0)).second;
+      needs_restart_ |= enabled_entries.insert(e->NameForChoice(0)).second;
     } else {
       // Find the currently enabled choice and disable it.
       for (int i = 0; i < e->num_choices; ++i) {
         std::string choice_name = e->NameForChoice(i);
-        if (enabled_experiments.find(choice_name) !=
-            enabled_experiments.end()) {
+        if (enabled_entries.find(choice_name) != enabled_entries.end()) {
           needs_restart_ = true;
-          enabled_experiments.erase(choice_name);
-          // Continue on just in case there's a bug and more than one
-          // experiment for this choice was enabled.
+          enabled_entries.erase(choice_name);
+          // Continue on just in case there's a bug and more than one entry for
+          // this choice was enabled.
         }
       }
     }
   }
 
-  flags_storage->SetFlags(enabled_experiments);
+  flags_storage->SetFlags(enabled_entries);
 }
 
 void FlagsState::RemoveFlagsSwitches(
     std::map<std::string, base::CommandLine::StringType>* switch_list) {
   for (const auto& entry : flags_switches_)
     switch_list->erase(entry.first);
 }
 
 void FlagsState::ResetAllFlags(FlagsStorage* flags_storage) {
   needs_restart_ = true;
 
-  std::set<std::string> no_experiments;
-  flags_storage->SetFlags(no_experiments);
+  std::set<std::string> no_entries;
+  flags_storage->SetFlags(no_entries);
 }
 
 void FlagsState::reset() {
   needs_restart_ = false;
   flags_switches_.clear();
 }
 
 }  // namespace
 
 namespace testing {
 
 // WARNING: '@' is also used in the html file. If you update this constant you
 // also need to update the html file.
 const char kMultiSeparator[] = "@";
 
 const base::HistogramBase::Sample kBadSwitchFormatHistogramId = 0;
 
 void ClearState() {
   FlagsState::GetInstance()->reset();
 }
 
-void SetExperiments(const Experiment* e, size_t count) {
+void SetEntries(const Entry* e, size_t count) {
   if (!e) {
-    experiments = kExperiments;
-    num_experiments = arraysize(kExperiments);
+    entries = kEntries;
+    num_entries = arraysize(kEntries);
   } else {
-    experiments = e;
-    num_experiments = count;
+    entries = e;
+    num_entries = count;
   }
 }
 
-const Experiment* GetExperiments(size_t* count) {
-  *count = num_experiments;
-  return experiments;
+const Entry* GetEntries(size_t* count) {
+  *count = num_entries;
+  return entries;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags