Clean up terminology used in about_flags.

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 37 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/display/display_switches.h"
 #include "ui/events/event_switches.h"
 #include "ui/gfx/switches.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "ui/native_theme/native_theme_switches.h"
 #include "ui/views/views_switches.h"
 
-#if defined(OS_ANDROID)
-#include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
-#else
+#if !defined(OS_ANDROID)
 #include "ui/message_center/message_center_switches.h"
 #endif
 
 #if defined(USE_ASH)
 #include "ash/ash_switches.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/chromeos_switches.h"
 #include "third_party/cros_system_api/switches/chrome_switches.h"
 #endif
 
 #if defined(ENABLE_APP_LIST)
 #include "ui/app_list/app_list_switches.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/common/switches.h"
 #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, \
+    FeatureEntry::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 SINGLE_DISABLE_VALUE_TYPE_AND_VALUE(command_line_switch, switch_value) \
-    Experiment::SINGLE_DISABLE_VALUE, \
+    FeatureEntry::SINGLE_DISABLE_VALUE, \
     command_line_switch, switch_value, NULL, NULL, NULL, 0
 #define SINGLE_DISABLE_VALUE_TYPE(command_line_switch) \
     SINGLE_DISABLE_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, \
+    FeatureEntry::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)
+    FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 FeatureEntry::Choice kTouchTextSelectionStrategyChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_TOUCH_SELECTION_STRATEGY_CHARACTER,
     switches::kTouchTextSelectionStrategy,
     "character" },
   { IDS_TOUCH_SELECTION_STRATEGY_DIRECTION,
     switches::kTouchTextSelectionStrategy,
     "direction" }
 };
 
-const Experiment::Choice kTraceUploadURL[] = {
+const FeatureEntry::Choice kTraceUploadURL[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED, "", "" },
   { IDS_TRACE_UPLOAD_URL_CHOICE_OTHER, switches::kTraceUploadURL,
     "https://performance-insights.appspot.com/upload?tags=flags,Other"},
   { IDS_TRACE_UPLOAD_URL_CHOICE_EMLOADING, switches::kTraceUploadURL,
     "https://performance-insights.appspot.com/upload?tags=flags,emloading" },
   { IDS_TRACE_UPLOAD_URL_CHOICE_QA, switches::kTraceUploadURL,
     "https://performance-insights.appspot.com/upload?tags=flags,QA" },
   { IDS_TRACE_UPLOAD_URL_CHOICE_TESTING, switches::kTraceUploadURL,
     "https://performance-insights.appspot.com/upload?tags=flags,TestingTeam" }
 };
 
 #if !defined(DISABLE_NACL)
-const Experiment::Choice kNaClDebugMaskChoices[] = {
+const FeatureEntry::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 FeatureEntry::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}
 };
 
-const Experiment::Choice kDataReductionProxyLoFiChoices[] = {
+const FeatureEntry::Choice kDataReductionProxyLoFiChoices[] = {
     { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
     { IDS_FLAGS_DATA_REDUCTION_PROXY_LO_FI_ALWAYS_ON,
         data_reduction_proxy::switches::kDataReductionProxyLoFi,
         data_reduction_proxy::switches::kDataReductionProxyLoFiValueAlwaysOn},
     { IDS_FLAGS_DATA_REDUCTION_PROXY_LO_FI_CELLULAR_ONLY,
         data_reduction_proxy::switches::kDataReductionProxyLoFi,
         data_reduction_proxy::switches::
             kDataReductionProxyLoFiValueCellularOnly},
     { IDS_FLAGS_DATA_REDUCTION_PROXY_LO_FI_DISABLED,
         data_reduction_proxy::switches::kDataReductionProxyLoFi,
         data_reduction_proxy::switches::kDataReductionProxyLoFiValueDisabled},
     { IDS_FLAGS_DATA_REDUCTION_PROXY_LO_FI_SLOW_CONNECTIONS_ONLY,
         data_reduction_proxy::switches::kDataReductionProxyLoFi,
         data_reduction_proxy::switches::
             kDataReductionProxyLoFiValueSlowConnectionsOnly}
 };
 
-const Experiment::Choice kShowSavedCopyChoices[] = {
+const FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 kReaderModeHeuristicsChoices[] = {
+const FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 FeatureEntry::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 },
 };
 
-const Experiment::Choice kAutofillSyncCredentialChoices[] = {
+const FeatureEntry::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 kFillOnAccountSelectChoices[] = {
+const FeatureEntry::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(ENABLE_TOPCHROME_MD)
-const Experiment::Choice kTopChromeMaterialDesignChoices[] = {
+const FeatureEntry::Choice kTopChromeMaterialDesignChoices[] = {
     {IDS_FLAGS_TOP_CHROME_MD_NON_MATERIAL, "", ""},
     {IDS_FLAGS_TOP_CHROME_MD_MATERIAL,
      switches::kTopChromeMD,
      switches::kTopChromeMDMaterial},
     {IDS_FLAGS_TOP_CHROME_MD_MATERIAL_HYBRID,
      switches::kTopChromeMD,
      switches::kTopChromeMDMaterialHybrid}};
 #endif
 
 #if defined(OS_CHROMEOS)
-const Experiment::Choice kAshMaterialDesignInkDropAnimationSpeed[] = {
+const FeatureEntry::Choice kAshMaterialDesignInkDropAnimationSpeed[] = {
     {IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", ""},
     {IDS_FLAGS_MATERIAL_DESIGN_INK_DROP_ANIMATION_FAST,
      switches::kMaterialDesignInkDropAnimationSpeed,
      switches::kMaterialDesignInkDropAnimationSpeedFast},
     {IDS_FLAGS_MATERIAL_DESIGN_INK_DROP_ANIMATION_SLOW,
      switches::kMaterialDesignInkDropAnimationSpeed,
      switches::kMaterialDesignInkDropAnimationSpeedSlow}};
 
-const Experiment::Choice kDataSaverPromptChoices[] = {
+const FeatureEntry::Choice kDataSaverPromptChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     chromeos::switches::kEnableDataSaverPrompt, "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     chromeos::switches::kDisableDataSaverPrompt, "" },
   { IDS_FLAGS_DATASAVER_PROMPT_DEMO_MODE,
     chromeos::switches::kEnableDataSaverPrompt,
     chromeos::switches::kDataSaverPromptDemoMode },
 };
 
-const Experiment::Choice kFloatingVirtualKeyboardChoices[] = {
+const FeatureEntry::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 kSmartVirtualKeyboardChoices[] = {
+const FeatureEntry::Choice kSmartVirtualKeyboardChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     keyboard::switches::kSmartVirtualKeyboard,
     keyboard::switches::kSmartVirtualKeyboardDisabled},
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     keyboard::switches::kSmartVirtualKeyboard,
     keyboard::switches::kSmartVirtualKeyboardEnabled},
 };
 
-const Experiment::Choice kGestureTypingChoices[] = {
+const FeatureEntry::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 FeatureEntry::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},
 };
 
-const Experiment::Choice kDownloadNotificationChoices[] = {
+const FeatureEntry::Choice kDownloadNotificationChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED,
     switches::kEnableDownloadNotification,
     "enabled" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     switches::kEnableDownloadNotification,
     "disabled" }
 };
 #endif
 
-const Experiment::Choice kSupervisedUserSafeSitesChoices[] = {
+const FeatureEntry::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" }
 };
 
-const Experiment::Choice kV8CacheOptionsChoices[] = {
+const FeatureEntry::Choice kV8CacheOptionsChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED, switches::kV8CacheOptions, "none" },
   { IDS_FLAGS_V8_CACHE_OPTIONS_PARSE, switches::kV8CacheOptions, "parse" },
   { IDS_FLAGS_V8_CACHE_OPTIONS_CODE, switches::kV8CacheOptions, "code" },
 };
 
 #if defined(OS_ANDROID)
-const Experiment::Choice kProgressBarAnimationChoices[] = {
+const FeatureEntry::Choice kProgressBarAnimationChoices[] = {
   { IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", "" },
   { IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
       switches::kProgressBarAnimation, "disabled" },
   { IDS_FLAGS_PROGRESS_BAR_ANIMATION_LINEAR,
         switches::kProgressBarAnimation, "linear" },
   { IDS_FLAGS_PROGRESS_BAR_ANIMATION_SMOOTH,
       switches::kProgressBarAnimation, "smooth" },
   { IDS_FLAGS_PROGRESS_BAR_ANIMATION_FAST_START,
       switches::kProgressBarAnimation, "fast-start" },
 };
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_CHROMEOS)
-const Experiment::Choice kCrosRegionsModeChoices[] = {
+const FeatureEntry::Choice kCrosRegionsModeChoices[] = {
   { IDS_FLAGS_CROS_REGIONS_MODE_DEFAULT, "", "" },
   { IDS_FLAGS_CROS_REGIONS_MODE_OVERRIDE, chromeos::switches::kCrosRegionsMode,
         chromeos::switches::kCrosRegionsModeOverride },
   { IDS_FLAGS_CROS_REGIONS_MODE_HIDE, chromeos::switches::kCrosRegionsMode,
         chromeos::switches::kCrosRegionsModeHide },
 };
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_WIN)
-const Experiment::Choice kPpapiWin32kLockdown[] = {
+const FeatureEntry::Choice kPpapiWin32kLockdown[] = {
     {IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT, "", ""},
     {IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
      switches::kEnableWin32kLockDownMimeTypes, ""},
     {IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_FLASH_ONLY,
      switches::kEnableWin32kLockDownMimeTypes,
      "application/x-shockwave-flash,application/futuresplash"},
     {IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_PDF_ONLY,
      switches::kEnableWin32kLockDownMimeTypes,
      "application/x-google-chrome-pdf,application/pdf"},
     {IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_FLASH_AND_PDF,
      switches::kEnableWin32kLockDownMimeTypes,
      "application/x-shockwave-flash,application/futuresplash,"
      "application/x-google-chrome-pdf,application/pdf"},
     {IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_ALL,
      switches::kEnableWin32kLockDownMimeTypes, "*"},
 };
 #endif  // defined(OS_WIN)
 
 // 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 kFeatureEntries. 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 FeatureEntry 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 FeatureEntry kFeatureEntries[] = {
     {"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",
      IDS_FLAGS_DISABLE_DIRECT_WRITE_NAME,
      IDS_FLAGS_DISABLE_DIRECT_WRITE_DESCRIPTION,
      kOsWin,
@@ skipping 1495 matching lines @@
     {"enable-ppapi-win32k-lockdown",
      IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_NAME,
      IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_DESCRIPTION, kOsWin,
      MULTI_VALUE_TYPE(kPpapiWin32kLockdown)},
 #endif  // defined(OS_WIN)
     // 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 FeatureEntry* g_entries = kFeatureEntries;
+size_t g_num_entries = arraysize(kFeatureEntries);
 
 // Stores and encapsulates the little state that about:flags has.
 class FlagsState {
  public:
   FlagsState() : needs_restart_(false) {}
   void ConvertFlagsToSwitches(flags_ui::FlagsStorage* flags_storage,
                               base::CommandLine* command_line,
                               SentinelsMode sentinels);
   bool IsRestartNeededToCommitChanges();
-  void SetExperimentEnabled(flags_ui::FlagsStorage* flags_storage,
+  void SetFeatureEntryEnabled(flags_ui::FlagsStorage* flags_storage,
                             const std::string& internal_name,
                             bool enable);
   void RemoveFlagsSwitches(
       std::map<std::string, base::CommandLine::StringType>* switch_list);
   void ResetAllFlags(flags_ui::FlagsStorage* flags_storage);
   void reset();
 
   // Returns the singleton instance of this class
   static FlagsState* GetInstance() {
     return base::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 ||
-      e.type == Experiment::SINGLE_DISABLE_VALUE) {
+// Adds the internal names for the specified entry to |names|.
+void AddInternalName(const FeatureEntry& e, std::set<std::string>* names) {
+  if (e.type == FeatureEntry::SINGLE_VALUE ||
+      e.type == FeatureEntry::SINGLE_DISABLE_VALUE) {
     names->insert(e.internal_name);
   } else {
-    DCHECK(e.type == Experiment::MULTI_VALUE ||
-           e.type == Experiment::ENABLE_DISABLE_VALUE);
+    DCHECK(e.type == FeatureEntry::MULTI_VALUE ||
+           e.type == FeatureEntry::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
+// Confirms that an entry is valid, used in a DCHECK in
 // SanitizeList below.
-bool ValidateExperiment(const Experiment& e) {
+bool ValidateFeatureEntry(const FeatureEntry& e) {
   switch (e.type) {
-    case Experiment::SINGLE_VALUE:
-    case Experiment::SINGLE_DISABLE_VALUE:
+    case FeatureEntry::SINGLE_VALUE:
+    case FeatureEntry::SINGLE_DISABLE_VALUE:
       DCHECK_EQ(0, e.num_choices);
       DCHECK(!e.choices);
       break;
-    case Experiment::MULTI_VALUE:
+    case FeatureEntry::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 FeatureEntry::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
+// 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(flags_ui::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 < g_num_entries; ++i) {
+    DCHECK(ValidateFeatureEntry(g_entries[i]));
+    AddInternalName(g_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(flags_ui::FlagsStorage* flags_storage,
                               std::set<std::string>* result) {
   SanitizeList(flags_storage);
   *result = flags_storage->GetFlags();
 }
 
-bool SkipConditionalExperiment(const Experiment& experiment) {
+bool SkipConditionalFeatureEntry(const FeatureEntry& entry) {
   version_info::Channel channel = chrome::GetChannel();
 
 #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 != version_info::Channel::BETA &&
       channel != version_info::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 != version_info::Channel::DEV) {
     return true;
   }
   // enable-data-reduction-proxy-carrier-test is only available for Chromium
   // builds and the Canary/Dev channel.
   if (!strcmp("enable-data-reduction-proxy-carrier-test",
-              experiment.internal_name) &&
+              entry.internal_name) &&
       channel != version_info::Channel::DEV &&
       channel != version_info::Channel::CANARY &&
       channel != version_info::Channel::UNKNOWN) {
     return true;
   }
 #endif
 
   // data-reduction-proxy-lo-fi is only available for Chromium builds and
   // the Canary/Dev/Beta channels.
-  if (!strcmp("data-reduction-proxy-lo-fi", experiment.internal_name) &&
+  if (!strcmp("data-reduction-proxy-lo-fi", entry.internal_name) &&
       channel != version_info::Channel::BETA &&
       channel != version_info::Channel::DEV &&
       channel != version_info::Channel::CANARY &&
       channel != version_info::Channel::UNKNOWN) {
     return true;
   }
 
   // enable-data-reduction-proxy-config-client is only available for Chromium
   // builds and the Canary/Dev channels.
   if (!strcmp("enable-data-reduction-proxy-config-client",
-              experiment.internal_name) &&
+              entry.internal_name) &&
       channel != version_info::Channel::DEV &&
       channel != version_info::Channel::CANARY &&
       channel != version_info::Channel::UNKNOWN) {
     return true;
   }
 
 #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 != version_info::Channel::UNKNOWN &&
       channel != version_info::Channel::CANARY &&
       channel != version_info::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(
     flags_ui::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 < g_num_entries; ++i) {
+    const FeatureEntry& entry = g_entries[i];
+    if (entry.supported_platforms & current_platform)
+      AddInternalName(entry, &platform_entries);
 #if defined(OS_CHROMEOS)
-    if (experiments[i].supported_platforms & kOsCrOSOwnerOnly)
-      AddInternalName(experiments[i], &platform_experiments);
+    if (g_entries[i].supported_platforms & kOsCrOSOwnerOnly)
+      AddInternalName(entry, &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 true if none of this experiment's options have been enabled.
+// Returns true if none of this entry's options have been enabled.
 bool IsDefaultValue(
-    const Experiment& experiment,
-    const std::set<std::string>& enabled_experiments) {
-  switch (experiment.type) {
-    case Experiment::SINGLE_VALUE:
-    case Experiment::SINGLE_DISABLE_VALUE:
-      return enabled_experiments.count(experiment.internal_name) == 0;
-    case Experiment::MULTI_VALUE:
-    case Experiment::ENABLE_DISABLE_VALUE:
-      for (int i = 0; i < experiment.num_choices; ++i) {
-        if (enabled_experiments.count(experiment.NameForChoice(i)) > 0)
+    const FeatureEntry& entry,
+    const std::set<std::string>& enabled_entries) {
+  switch (entry.type) {
+    case FeatureEntry::SINGLE_VALUE:
+    case FeatureEntry::SINGLE_DISABLE_VALUE:
+      return enabled_entries.count(entry.internal_name) == 0;
+    case FeatureEntry::MULTI_VALUE:
+    case FeatureEntry::ENABLE_DISABLE_VALUE:
+      for (int i = 0; i < entry.num_choices; ++i) {
+        if (enabled_entries.count(entry.NameForChoice(i)) > 0)
           return false;
       }
       break;
     default:
       NOTREACHED();
   }
   return true;
 }
 
-// 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 FeatureEntry& entry,
+    const std::set<std::string>& enabled_entries) {
+  DCHECK(entry.type == FeatureEntry::MULTI_VALUE ||
+         entry.type == FeatureEntry::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 FeatureEntry::NameForChoice(int index) const {
+  DCHECK(type == FeatureEntry::MULTI_VALUE ||
+         type == FeatureEntry::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 FeatureEntry::DescriptionForChoice(int index) const {
+  DCHECK(type == FeatureEntry::MULTI_VALUE ||
+         type == FeatureEntry::ENABLE_DISABLE_VALUE);
   DCHECK_LT(index, num_choices);
   int description_id;
-  if (type == Experiment::ENABLE_DISABLE_VALUE) {
+  if (type == FeatureEntry::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(flags_ui::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 GetFlagFeatureEntries(flags_ui::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))
+  for (size_t i = 0; i < g_num_entries; ++i) {
+    const FeatureEntry& entry = g_entries[i];
+    if (SkipConditionalFeatureEntry(entry))
       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));
+                        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);
     // True if the switch is not currently passed.
-    bool is_default_value = IsDefaultValue(experiment, enabled_experiments);
+    bool is_default_value = IsDefaultValue(entry, enabled_entries);
     data->SetBoolean("is_default", is_default_value);
 
-    switch (experiment.type) {
-      case Experiment::SINGLE_VALUE:
-      case Experiment::SINGLE_DISABLE_VALUE:
+    switch (entry.type) {
+      case FeatureEntry::SINGLE_VALUE:
+      case FeatureEntry::SINGLE_DISABLE_VALUE:
         data->SetBoolean(
             "enabled",
             (!is_default_value &&
-             experiment.type == Experiment::SINGLE_VALUE) ||
+             entry.type == FeatureEntry::SINGLE_VALUE) ||
             (is_default_value &&
-             experiment.type == Experiment::SINGLE_DISABLE_VALUE));
+             entry.type == FeatureEntry::SINGLE_DISABLE_VALUE));
         break;
-      case Experiment::MULTI_VALUE:
-      case Experiment::ENABLE_DISABLE_VALUE:
-        data->Set("choices", CreateChoiceData(experiment, enabled_experiments));
+      case FeatureEntry::MULTI_VALUE:
+      case FeatureEntry::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(flags_ui::FlagsStorage* flags_storage,
+void SetFeatureEntryEnabled(flags_ui::FlagsStorage* flags_storage,
                           const std::string& internal_name,
                           bool enable) {
-  FlagsState::GetInstance()->SetExperimentEnabled(flags_storage,
+  FlagsState::GetInstance()->SetFeatureEntryEnabled(flags_storage,
                                                   internal_name, enable);
 }
 
 void RemoveFlagsSwitches(
     std::map<std::string, base::CommandLine::StringType>* switch_list) {
   FlagsState::GetInstance()->RemoveFlagsSwitches(switch_list);
 }
 
 void ResetAllFlags(flags_ui::FlagsStorage* flags_storage) {
   FlagsState::GetInstance()->ResetAllFlags(flags_storage);
@@ skipping 76 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(flags_ui::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 ||
-        e.type == Experiment::SINGLE_DISABLE_VALUE) {
+  for (size_t i = 0; i < g_num_entries; ++i) {
+    const FeatureEntry& e = g_entries[i];
+    if (e.type == FeatureEntry::SINGLE_VALUE ||
+        e.type == FeatureEntry::SINGLE_DISABLE_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 == FeatureEntry::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, FeatureEntry::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(flags_ui::FlagsStorage* flags_storage,
-                                      const std::string& internal_name,
-                                      bool enable) {
+void FlagsState::SetFeatureEntryEnabled(flags_ui::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
+    // 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);
+    SetFeatureEntryEnabled(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 FeatureEntry* e = NULL;
+  for (size_t i = 0; i < g_num_entries; ++i) {
+    if (g_entries[i].internal_name == internal_name) {
+      e = g_entries + i;
       break;
     }
   }
   DCHECK(e);
 
-  if (e->type == Experiment::SINGLE_VALUE) {
+  if (e->type == FeatureEntry::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);
-  } else if (e->type == Experiment::SINGLE_DISABLE_VALUE) {
+      needs_restart_ |= (enabled_entries.erase(internal_name) > 0);
+  } else if (e->type == FeatureEntry::SINGLE_DISABLE_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);
+          enabled_entries.erase(choice_name);
           // Continue on just in case there's a bug and more than one
-          // experiment for this choice was enabled.
+          // 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(flags_ui::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) {
-  if (!e) {
-    experiments = kExperiments;
-    num_experiments = arraysize(kExperiments);
+void SetFeatureEntries(const FeatureEntry* entries, size_t count) {
+  if (!entries) {
+    g_entries = kFeatureEntries;
+    g_num_entries = arraysize(kFeatureEntries);
   } else {
-    experiments = e;
-    num_experiments = count;
+    g_entries = entries;
+    g_num_entries = count;
   }
 }
 
-const Experiment* GetExperiments(size_t* count) {
-  *count = num_experiments;
-  return experiments;
+const FeatureEntry* GetFeatureEntries(size_t* count) {
+  *count = g_num_entries;
+  return g_entries;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags