blob: fa71d0171d049583b5808f0201d3c91308a8428d [file] [log] [blame]
// 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 <memory>
#include <set>
#include <utility>
#include "ash/public/cpp/app_list/app_list_features.h"
#include "ash/public/cpp/app_list/app_list_switches.h"
#include "ash/public/cpp/ash_features.h"
#include "ash/public/cpp/keyboard/keyboard_switches.h"
#include "base/base_switches.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/i18n/base_i18n_switches.h"
#include "base/memory/singleton.h"
#include "base/metrics/histogram_functions.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "build/branding_buildflags.h"
#include "build/build_config.h"
#include "cc/base/features.h"
#include "cc/base/switches.h"
#include "chrome/browser/browser_features.h"
#include "chrome/browser/chromeos/android_sms/android_sms_switches.h"
#include "chrome/browser/flag_descriptions.h"
#include "chrome/browser/lite_video/lite_video_switches.h"
#include "chrome/browser/navigation_predictor/search_engine_preconnector.h"
#include "chrome/browser/net/stub_resolver_config_reader.h"
#include "chrome/browser/net/system_network_context_manager.h"
#include "chrome/browser/notifications/scheduler/public/features.h"
#include "chrome/browser/performance_hints/performance_hints_features.h"
#include "chrome/browser/performance_manager/policies/policy_features.h"
#include "chrome/browser/permissions/quiet_notification_permission_ui_config.h"
#include "chrome/browser/predictors/loading_predictor_config.h"
#include "chrome/browser/prerender/isolated/isolated_prerender_features.h"
#include "chrome/browser/prerender/isolated/isolated_prerender_params.h"
#include "chrome/browser/resource_coordinator/tab_manager_features.h"
#include "chrome/browser/search/ntp_features.h"
#include "chrome/browser/sharing/click_to_call/feature.h"
#include "chrome/browser/sharing/features.h"
#include "chrome/browser/sharing/shared_clipboard/feature_flags.h"
#include "chrome/browser/sharing/sms/sms_flags.h"
#include "chrome/browser/sharing/webrtc/webrtc_flags.h"
#include "chrome/browser/signin/signin_features.h"
#include "chrome/browser/ui/ui_features.h"
#include "chrome/browser/unexpire_flags.h"
#include "chrome/browser/unexpire_flags_gen.h"
#include "chrome/common/buildflags.h"
#include "chrome/common/channel_info.h"
#include "chrome/common/chrome_content_client.h"
#include "chrome/common/chrome_features.h"
#include "chrome/common/chrome_switches.h"
#include "components/assist_ranker/predictor_config_definitions.h"
#include "components/autofill/core/browser/autofill_experiments.h"
#include "components/autofill/core/common/autofill_features.h"
#include "components/autofill/core/common/autofill_payments_features.h"
#include "components/autofill/core/common/autofill_switches.h"
#include "components/autofill/core/common/autofill_util.h"
#include "components/autofill_assistant/browser/features.h"
#include "components/browser_sync/browser_sync_switches.h"
#include "components/browsing_data/core/features.h"
#include "components/cloud_devices/common/cloud_devices_switches.h"
#include "components/contextual_search/core/browser/public.h"
#include "components/data_reduction_proxy/core/common/data_reduction_proxy_features.h"
#include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
#include "components/dom_distiller/core/dom_distiller_features.h"
#include "components/dom_distiller/core/dom_distiller_switches.h"
#include "components/download/public/common/download_features.h"
#include "components/error_page/common/error_page_switches.h"
#include "components/feature_engagement/public/feature_constants.h"
#include "components/feature_engagement/public/feature_list.h"
#include "components/feed/feed_feature_list.h"
#include "components/flags_ui/feature_entry.h"
#include "components/flags_ui/feature_entry_macros.h"
#include "components/flags_ui/flags_state.h"
#include "components/flags_ui/flags_storage.h"
#include "components/flags_ui/flags_ui_metrics.h"
#include "components/flags_ui/flags_ui_switches.h"
#include "components/games/core/games_features.h"
#include "components/invalidation/impl/invalidation_switches.h"
#include "components/language/core/common/language_experiments.h"
#include "components/lookalikes/core/features.h"
#include "components/nacl/common/buildflags.h"
#include "components/nacl/common/nacl_switches.h"
#include "components/network_session_configurator/common/network_features.h"
#include "components/network_session_configurator/common/network_switches.h"
#include "components/ntp_snippets/features.h"
#include "components/ntp_snippets/ntp_snippets_constants.h"
#include "components/ntp_tiles/features.h"
#include "components/offline_pages/core/offline_page_feature.h"
#include "components/omnibox/browser/omnibox_field_trial.h"
#include "components/omnibox/common/omnibox_features.h"
#include "components/page_info/android/features.h"
#include "components/paint_preview/buildflags/buildflags.h"
#include "components/paint_preview/features/features.h"
#include "components/password_manager/core/common/password_manager_features.h"
#include "components/payments/core/features.h"
#include "components/policy/core/common/features.h"
#include "components/prerender/browser/prerender_field_trial.h"
#include "components/previews/core/previews_features.h"
#include "components/previews/core/previews_switches.h"
#include "components/query_tiles/switches.h"
#include "components/safe_browsing/core/features.h"
#include "components/security_interstitials/content/stateful_ssl_host_state_delegate.h"
#include "components/security_interstitials/core/features.h"
#include "components/security_state/core/features.h"
#include "components/security_state/core/security_state.h"
#include "components/send_tab_to_self/features.h"
#include "components/services/heap_profiling/public/cpp/switches.h"
#include "components/signin/core/browser/dice_account_reconcilor_delegate.h"
#include "components/signin/public/base/signin_buildflags.h"
#include "components/signin/public/base/signin_switches.h"
#include "components/site_isolation/features.h"
#include "components/spellcheck/common/spellcheck_features.h"
#include "components/spellcheck/spellcheck_buildflags.h"
#include "components/sync/base/sync_base_switches.h"
#include "components/sync/driver/sync_driver_switches.h"
#include "components/sync/engine/sync_engine_switches.h"
#include "components/tracing/common/tracing_switches.h"
#include "components/translate/core/browser/translate_prefs.h"
#include "components/translate/core/browser/translate_ranker_impl.h"
#include "components/translate/core/common/translate_util.h"
#include "components/ui_devtools/switches.h"
#include "components/version_info/version_info.h"
#include "components/viz/common/features.h"
#include "components/viz/common/switches.h"
#include "content/public/common/content_features.h"
#include "content/public/common/content_switches.h"
#include "device/base/features.h"
#include "device/fido/features.h"
#include "device/gamepad/public/cpp/gamepad_features.h"
#include "device/vr/buildflags/buildflags.h"
#include "extensions/buildflags/buildflags.h"
#include "gpu/config/gpu_finch_features.h"
#include "gpu/config/gpu_switches.h"
#include "media/audio/audio_features.h"
#include "media/base/media_switches.h"
#include "media/capture/capture_switches.h"
#include "media/media_buildflags.h"
#include "media/midi/midi_switches.h"
#include "media/webrtc/webrtc_switches.h"
#include "net/base/features.h"
#include "net/net_buildflags.h"
#include "net/nqe/effective_connection_type.h"
#include "net/nqe/network_quality_estimator_params.h"
#include "net/websockets/websocket_basic_handshake_stream.h"
#include "pdf/buildflags.h"
#include "ppapi/buildflags/buildflags.h"
#include "printing/buildflags/buildflags.h"
#include "sandbox/policy/features.h"
#include "sandbox/policy/switches.h"
#include "services/device/public/cpp/device_features.h"
#include "services/device/public/cpp/serial/serial_switches.h"
#include "services/media_session/public/cpp/features.h"
#include "services/network/public/cpp/features.h"
#include "services/network/public/cpp/network_switches.h"
#include "storage/browser/quota/quota_features.h"
#include "third_party/blink/public/common/experiments/memory_ablation_experiment.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/common/forcedark/forcedark_switches.h"
#include "third_party/blink/public/common/switches.h"
#include "third_party/leveldatabase/leveldb_features.h"
#include "ui/accessibility/accessibility_features.h"
#include "ui/accessibility/accessibility_switches.h"
#include "ui/base/ui_base_features.h"
#include "ui/base/ui_base_switches.h"
#include "ui/compositor/compositor_switches.h"
#include "ui/display/display_features.h"
#include "ui/display/display_switches.h"
#include "ui/events/blink/blink_features.h"
#include "ui/events/event_switches.h"
#include "ui/gfx/switches.h"
#include "ui/gl/buildflags.h"
#include "ui/gl/gl_switches.h"
#include "ui/native_theme/native_theme_features.h"
#if defined(OS_LINUX)
#include "base/allocator/buildflags.h"
#endif
#if defined(OS_ANDROID)
#include "chrome/browser/android/explore_sites/explore_sites_feature.h"
#include "chrome/browser/flags/android/chrome_feature_list.h"
#include "chrome/browser/notifications/chime/android/features.h"
#include "components/browser_ui/site_settings/android/features.h"
#include "components/external_intents/android/external_intents_feature_list.h"
#else // OS_ANDROID
#include "chrome/browser/media/router/media_router_feature.h"
#endif // OS_ANDROID
#if defined(OS_CHROMEOS)
#include "ash/public/cpp/ash_switches.h"
#include "chromeos/constants/chromeos_features.h"
#include "chromeos/constants/chromeos_switches.h"
#include "chromeos/services/assistant/public/cpp/features.h"
#include "components/arc/arc_features.h"
#include "media/capture/video/chromeos/video_capture_features_chromeos.h"
#include "third_party/cros_system_api/switches/chrome_switches.h"
#include "ui/events/ozone/features.h"
#endif // OS_CHROMEOS
#if defined(OS_MAC)
#include "chrome/browser/ui/browser_dialogs.h"
#endif // OS_MAC
#if BUILDFLAG(ENABLE_EXTENSIONS)
#include "extensions/common/extension_features.h"
#include "extensions/common/switches.h"
#endif // ENABLE_EXTENSIONS
#if BUILDFLAG(ENABLE_PDF)
#include "pdf/pdf_features.h"
#endif
#if BUILDFLAG(ENABLE_PRINTING)
#include "printing/printing_features.h"
#endif
#if defined(USE_OZONE)
#include "ui/ozone/public/ozone_switches.h"
#endif // USE_OZONE
#if defined(OS_WIN)
#include "base/win/windows_version.h"
#include "chrome/browser/win/titlebar_config.h"
#endif // OS_WIN
#if defined(TOOLKIT_VIEWS)
#include "ui/views/animation/installable_ink_drop.h"
#include "ui/views/views_features.h"
#include "ui/views/views_switches.h"
#endif // defined(TOOLKIT_VIEWS)
using flags_ui::FeatureEntry;
using flags_ui::kDeprecated;
using flags_ui::kOsAndroid;
using flags_ui::kOsCrOS;
using flags_ui::kOsCrOSOwnerOnly;
using flags_ui::kOsLinux;
using flags_ui::kOsMac;
using flags_ui::kOsWin;
namespace about_flags {
namespace {
const unsigned kOsAll = kOsMac | kOsWin | kOsLinux | kOsCrOS | kOsAndroid;
const unsigned kOsDesktop = kOsMac | kOsWin | kOsLinux | kOsCrOS;
#if defined(USE_AURA) || defined(OS_ANDROID)
const unsigned kOsAura = kOsWin | kOsLinux | kOsCrOS;
#endif // USE_AURA || OS_ANDROID
const FeatureEntry::Choice kTouchEventFeatureDetectionChoices[] = {
{flags_ui::kGenericExperimentChoiceDisabled, "", ""},
{flags_ui::kGenericExperimentChoiceEnabled,
switches::kTouchEventFeatureDetection,
switches::kTouchEventFeatureDetectionEnabled},
{flags_ui::kGenericExperimentChoiceAutomatic,
switches::kTouchEventFeatureDetection,
switches::kTouchEventFeatureDetectionAuto}};
#if defined(USE_AURA)
const FeatureEntry::Choice kPullToRefreshChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flags_ui::kGenericExperimentChoiceDisabled, switches::kPullToRefresh, "0"},
{flags_ui::kGenericExperimentChoiceEnabled, switches::kPullToRefresh, "1"},
{flag_descriptions::kPullToRefreshEnabledTouchscreen,
switches::kPullToRefresh, "2"}};
#endif // USE_AURA
const FeatureEntry::Choice kOverlayStrategiesChoices[] = {
{flag_descriptions::kOverlayStrategiesDefault, "", ""},
{flag_descriptions::kOverlayStrategiesNone,
switches::kEnableHardwareOverlays, ""},
{flag_descriptions::kOverlayStrategiesUnoccludedFullscreen,
switches::kEnableHardwareOverlays, "single-fullscreen"},
{flag_descriptions::kOverlayStrategiesUnoccluded,
switches::kEnableHardwareOverlays, "single-fullscreen,single-on-top"},
{flag_descriptions::kOverlayStrategiesOccludedAndUnoccluded,
switches::kEnableHardwareOverlays,
"single-fullscreen,single-on-top,underlay"},
};
const FeatureEntry::Choice kTouchTextSelectionStrategyChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kTouchSelectionStrategyCharacter,
switches::kTouchTextSelectionStrategy, "character"},
{flag_descriptions::kTouchSelectionStrategyDirection,
switches::kTouchTextSelectionStrategy, "direction"}};
const FeatureEntry::Choice kTraceUploadURL[] = {
{flags_ui::kGenericExperimentChoiceDisabled, "", ""},
{flag_descriptions::kTraceUploadUrlChoiceOther, switches::kTraceUploadURL,
"https://performance-insights.appspot.com/upload?tags=flags,Other"},
{flag_descriptions::kTraceUploadUrlChoiceEmloading,
switches::kTraceUploadURL,
"https://performance-insights.appspot.com/upload?tags=flags,emloading"},
{flag_descriptions::kTraceUploadUrlChoiceQa, switches::kTraceUploadURL,
"https://performance-insights.appspot.com/upload?tags=flags,QA"},
{flag_descriptions::kTraceUploadUrlChoiceTesting, switches::kTraceUploadURL,
"https://performance-insights.appspot.com/upload?tags=flags,TestingTeam"}};
const FeatureEntry::Choice kPassiveListenersChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kPassiveEventListenerTrue,
switches::kPassiveListenersDefault, "true"},
{flag_descriptions::kPassiveEventListenerForceAllTrue,
switches::kPassiveListenersDefault, "forcealltrue"},
};
const FeatureEntry::Choice kDataReductionProxyServerExperiment[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kDataReductionProxyServerAlternative1,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative1},
{flag_descriptions::kDataReductionProxyServerAlternative2,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative2},
{flag_descriptions::kDataReductionProxyServerAlternative3,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative3},
{flag_descriptions::kDataReductionProxyServerAlternative4,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative4},
{flag_descriptions::kDataReductionProxyServerAlternative5,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative5},
{flag_descriptions::kDataReductionProxyServerAlternative6,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative6},
{flag_descriptions::kDataReductionProxyServerAlternative7,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative7},
{flag_descriptions::kDataReductionProxyServerAlternative8,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative8},
{flag_descriptions::kDataReductionProxyServerAlternative9,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative9},
{flag_descriptions::kDataReductionProxyServerAlternative10,
data_reduction_proxy::switches::kDataReductionProxyExperiment,
data_reduction_proxy::switches::kDataReductionProxyServerAlternative10}};
const FeatureEntry::Choice kLiteVideoDefaultDownlinkBandwidthKbps[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{"100", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"100"},
{"150", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"150"},
{"200", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"200"},
{"250", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"250"},
{"300", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"300"},
{"350", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"350"},
{"400", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"400"},
{"450", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"450"},
{"500", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"500"},
{"600", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"600"},
{"700", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"700"},
{"800", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"800"},
{"900", lite_video::switches::kLiteVideoDefaultDownlinkBandwidthKbps,
"900"}};
#if defined(OS_WIN)
const FeatureEntry::Choice kUseAngleChoices[] = {
{flag_descriptions::kUseAngleDefault, "", ""},
{flag_descriptions::kUseAngleGL, switches::kUseANGLE,
gl::kANGLEImplementationOpenGLName},
{flag_descriptions::kUseAngleD3D11, switches::kUseANGLE,
gl::kANGLEImplementationD3D11Name},
{flag_descriptions::kUseAngleD3D9, switches::kUseANGLE,
gl::kANGLEImplementationD3D9Name},
{flag_descriptions::kUseAngleD3D11on12, switches::kUseANGLE,
gl::kANGLEImplementationD3D11on12Name}};
#endif
#if BUILDFLAG(ENABLE_VR)
const FeatureEntry::Choice kWebXrForceRuntimeChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kWebXrRuntimeChoiceNone, switches::kWebXrForceRuntime,
switches::kWebXrRuntimeNone},
#if BUILDFLAG(ENABLE_OPENXR)
{flag_descriptions::kWebXrRuntimeChoiceOpenXR, switches::kWebXrForceRuntime,
switches::kWebXrRuntimeOpenXr},
#endif // ENABLE_OPENXR
#if BUILDFLAG(ENABLE_WINDOWS_MR)
{flag_descriptions::kWebXrRuntimeChoiceWindowsMixedReality,
switches::kWebXrForceRuntime, switches::kWebXrRuntimeWMR},
#endif // ENABLE_WINDOWS_MR
};
#endif // ENABLE_VR
#if defined(OS_ANDROID)
const FeatureEntry::Choice kReaderModeHeuristicsChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kReaderModeHeuristicsMarkup,
switches::kReaderModeHeuristics,
switches::reader_mode_heuristics::kOGArticle},
{flag_descriptions::kReaderModeHeuristicsAdaboost,
switches::kReaderModeHeuristics,
switches::reader_mode_heuristics::kAdaBoost},
{flag_descriptions::kReaderModeHeuristicsAlwaysOn,
switches::kReaderModeHeuristics,
switches::reader_mode_heuristics::kAlwaysTrue},
{flag_descriptions::kReaderModeHeuristicsAlwaysOff,
switches::kReaderModeHeuristics, switches::reader_mode_heuristics::kNone},
{flag_descriptions::kReaderModeHeuristicsAllArticles,
switches::kReaderModeHeuristics,
switches::reader_mode_heuristics::kAllArticles},
};
const FeatureEntry::Choice kForceUpdateMenuTypeChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kUpdateMenuTypeNone, switches::kForceUpdateMenuType,
"none"},
{flag_descriptions::kUpdateMenuTypeUpdateAvailable,
switches::kForceUpdateMenuType, "update_available"},
{flag_descriptions::kUpdateMenuTypeUnsupportedOSVersion,
switches::kForceUpdateMenuType, "unsupported_os_version"},
{flag_descriptions::kUpdateMenuTypeInlineUpdateSuccess,
switches::kForceUpdateMenuType, "inline_update_success"},
{flag_descriptions::kUpdateMenuTypeInlineUpdateDialogCanceled,
switches::kForceUpdateMenuType, "inline_update_dialog_canceled"},
{flag_descriptions::kUpdateMenuTypeInlineUpdateDialogFailed,
switches::kForceUpdateMenuType, "inline_update_dialog_failed"},
{flag_descriptions::kUpdateMenuTypeInlineUpdateDownloadFailed,
switches::kForceUpdateMenuType, "inline_update_download_failed"},
{flag_descriptions::kUpdateMenuTypeInlineUpdateDownloadCanceled,
switches::kForceUpdateMenuType, "inline_update_download_canceled"},
{flag_descriptions::kUpdateMenuTypeInlineUpdateInstallFailed,
switches::kForceUpdateMenuType, "inline_update_install_failed"},
};
#else // !defined(OS_ANDROID)
const FeatureEntry::FeatureParam kReaderModeOfferInSettings[] = {
{switches::kReaderModeDiscoverabilityParamName,
switches::kReaderModeOfferInSettings}};
const FeatureEntry::FeatureVariation kReaderModeDiscoverabilityVariations[] = {
{"available in settings", kReaderModeOfferInSettings,
base::size(kReaderModeOfferInSettings), nullptr}};
#endif // OS_ANDROID
#if !defined(OS_CHROMEOS)
const FeatureEntry::FeatureParam kForceDark_SimpleHsl[] = {
{"inversion_method", "hsl_based"},
{"image_behavior", "none"},
{"text_lightness_threshold", "256"},
{"background_lightness_threshold", "0"}};
const FeatureEntry::FeatureParam kForceDark_SimpleCielab[] = {
{"inversion_method", "cielab_based"},
{"image_behavior", "none"},
{"text_lightness_threshold", "256"},
{"background_lightness_threshold", "0"}};
const FeatureEntry::FeatureParam kForceDark_SimpleRgb[] = {
{"inversion_method", "rgb_based"},
{"image_behavior", "none"},
{"text_lightness_threshold", "256"},
{"background_lightness_threshold", "0"}};
const FeatureEntry::FeatureParam kForceDark_SelectiveImageInversion[] = {
{"inversion_method", "cielab_based"},
{"image_behavior", "selective"},
{"text_lightness_threshold", "256"},
{"background_lightness_threshold", "0"}};
const FeatureEntry::FeatureParam kForceDark_SelectiveElementInversion[] = {
{"inversion_method", "cielab_based"},
{"image_behavior", "none"},
{"text_lightness_threshold", "150"},
{"background_lightness_threshold", "205"}};
const FeatureEntry::FeatureParam kForceDark_SelectiveGeneralInversion[] = {
{"inversion_method", "cielab_based"},
{"image_behavior", "selective"},
{"text_lightness_threshold", "150"},
{"background_lightness_threshold", "205"}};
const FeatureEntry::FeatureVariation kForceDarkVariations[] = {
{"with simple HSL-based inversion", kForceDark_SimpleHsl,
base::size(kForceDark_SimpleHsl), nullptr},
{"with simple CIELAB-based inversion", kForceDark_SimpleCielab,
base::size(kForceDark_SimpleCielab), nullptr},
{"with simple RGB-based inversion", kForceDark_SimpleRgb,
base::size(kForceDark_SimpleRgb), nullptr},
{"with selective image inversion", kForceDark_SelectiveImageInversion,
base::size(kForceDark_SelectiveImageInversion), nullptr},
{"with selective inversion of non-image elements",
kForceDark_SelectiveElementInversion,
base::size(kForceDark_SelectiveElementInversion), nullptr},
{"with selective inversion of everything",
kForceDark_SelectiveGeneralInversion,
base::size(kForceDark_SelectiveGeneralInversion), nullptr}};
#endif // !OS_CHROMEOS
const FeatureEntry::FeatureParam kDelayAsyncScriptExecutionFinishedParsing[] = {
{"delay_type", "finished_parsing"}};
const FeatureEntry::FeatureParam
kDelayAsyncScriptExecutionFirstPaintOrFinishedParsing[] = {
{"delay_type", "first_paint_or_finished_parsing"}};
const FeatureEntry::FeatureVariation
kDelayAsyncScriptExecutionFeatureVariations[] = {
{"with delay until finished parsing document",
kDelayAsyncScriptExecutionFinishedParsing,
base::size(kDelayAsyncScriptExecutionFinishedParsing), nullptr},
{"with delay until first paint or finished parsing document",
kDelayAsyncScriptExecutionFirstPaintOrFinishedParsing,
base::size(kDelayAsyncScriptExecutionFirstPaintOrFinishedParsing),
nullptr}};
const FeatureEntry::FeatureParam kIntensiveWakeUpThrottlingImmediate[] = {
{blink::features::kIntensiveWakeUpThrottling_GracePeriodSeconds_Name, "0"}};
const FeatureEntry::FeatureVariation kIntensiveWakeUpThrottlingVariations[] = {
{"immediately when a tab is hidden (facilitates testing)",
kIntensiveWakeUpThrottlingImmediate,
base::size(kIntensiveWakeUpThrottlingImmediate), nullptr},
};
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kCloseTabSuggestionsStale_Immediate[] = {
{"baseline_tab_suggestions", "true"},
{"baseline_close_tab_suggestions", "true"}};
const FeatureEntry::FeatureParam kCloseTabSuggestionsStale_4Hours[] = {
{"close_tab_suggestions_stale_time_ms", "14400000"}};
const FeatureEntry::FeatureParam kCloseTabSuggestionsStale_8Hours[] = {
{"close_tab_suggestions_stale_time_ms", "28800000"}};
const FeatureEntry::FeatureParam kCloseTabSuggestionsStale_7Days[] = {
{"close_tab_suggestions_stale_time_ms", "604800000"}};
const FeatureEntry::FeatureParam kCloseTabSuggestionsTimeSiteEngagement[] = {
{"close_tab_min_num_tabs", "5"},
{"close_tab_features_time_last_used_enabled", "true"},
{"close_tab_features_time_last_used_transform", "MEAN_VARIANCE"},
{"close_tab_features_time_last_used_threshold", "0.5"},
{"close_tab_features_site_engagement_enabled", "true"},
{"close_tab_features_site_engagement_threshold", "90.0"},
};
const FeatureEntry::FeatureParam kGroupAndCloseTabSuggestions_Immediate[] = {
{"baseline_tab_suggestions", "true"},
{"baseline_group_tab_suggestions", "true"},
{"baseline_close_tab_suggestions", "true"}};
const FeatureEntry::FeatureVariation kCloseTabSuggestionsStaleVariations[] = {
{"Close Immediate", kCloseTabSuggestionsStale_Immediate,
base::size(kCloseTabSuggestionsStale_Immediate), nullptr},
{"Group+Close Immediate", kGroupAndCloseTabSuggestions_Immediate,
base::size(kGroupAndCloseTabSuggestions_Immediate), nullptr},
{"4 hours", kCloseTabSuggestionsStale_4Hours,
base::size(kCloseTabSuggestionsStale_4Hours), nullptr},
{"8 hours", kCloseTabSuggestionsStale_8Hours,
base::size(kCloseTabSuggestionsStale_8Hours), nullptr},
{"7 days", kCloseTabSuggestionsStale_7Days,
base::size(kCloseTabSuggestionsStale_7Days), nullptr},
{"Time & Site Engagement", kCloseTabSuggestionsTimeSiteEngagement,
base::size(kCloseTabSuggestionsTimeSiteEngagement), nullptr},
};
#endif // OS_ANDROID
const FeatureEntry::Choice kEnableGpuRasterizationChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flags_ui::kGenericExperimentChoiceEnabled,
switches::kEnableGpuRasterization, ""},
{flags_ui::kGenericExperimentChoiceDisabled,
switches::kDisableGpuRasterization, ""},
};
const FeatureEntry::Choice kEnableOopRasterizationChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flags_ui::kGenericExperimentChoiceEnabled,
switches::kEnableOopRasterization, ""},
{flags_ui::kGenericExperimentChoiceDisabled,
switches::kDisableOopRasterization, ""},
};
const FeatureEntry::Choice kExtensionContentVerificationChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kExtensionContentVerificationBootstrap,
switches::kExtensionContentVerification,
switches::kExtensionContentVerificationBootstrap},
{flag_descriptions::kExtensionContentVerificationEnforce,
switches::kExtensionContentVerification,
switches::kExtensionContentVerificationEnforce},
{flag_descriptions::kExtensionContentVerificationEnforceStrict,
switches::kExtensionContentVerification,
switches::kExtensionContentVerificationEnforceStrict},
};
const FeatureEntry::Choice kTopChromeTouchUiChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flags_ui::kGenericExperimentChoiceAutomatic, switches::kTopChromeTouchUi,
switches::kTopChromeTouchUiAuto},
{flags_ui::kGenericExperimentChoiceDisabled, switches::kTopChromeTouchUi,
switches::kTopChromeTouchUiDisabled},
{flags_ui::kGenericExperimentChoiceEnabled, switches::kTopChromeTouchUi,
switches::kTopChromeTouchUiEnabled}};
#if defined(OS_CHROMEOS)
const char kLacrosSupportInternalName[] = "lacros-support";
const FeatureEntry::Choice kUiShowCompositedLayerBordersChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kUiShowCompositedLayerBordersRenderPass,
cc::switches::kUIShowCompositedLayerBorders,
cc::switches::kCompositedRenderPassBorders},
{flag_descriptions::kUiShowCompositedLayerBordersSurface,
cc::switches::kUIShowCompositedLayerBorders,
cc::switches::kCompositedSurfaceBorders},
{flag_descriptions::kUiShowCompositedLayerBordersLayer,
cc::switches::kUIShowCompositedLayerBorders,
cc::switches::kCompositedLayerBorders},
{flag_descriptions::kUiShowCompositedLayerBordersAll,
cc::switches::kUIShowCompositedLayerBorders, ""}};
#endif // OS_CHROMEOS
#if defined(OS_CHROMEOS)
const FeatureEntry::Choice kCrosRegionsModeChoices[] = {
{flag_descriptions::kCrosRegionsModeDefault, "", ""},
{flag_descriptions::kCrosRegionsModeOverride,
chromeos::switches::kCrosRegionsMode,
chromeos::switches::kCrosRegionsModeOverride},
{flag_descriptions::kCrosRegionsModeHide,
chromeos::switches::kCrosRegionsMode,
chromeos::switches::kCrosRegionsModeHide},
};
#endif // OS_CHROMEOS
const FeatureEntry::Choice kForceUIDirectionChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kForceDirectionLtr, switches::kForceUIDirection,
switches::kForceDirectionLTR},
{flag_descriptions::kForceDirectionRtl, switches::kForceUIDirection,
switches::kForceDirectionRTL},
};
const FeatureEntry::Choice kForceTextDirectionChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kForceDirectionLtr, switches::kForceTextDirection,
switches::kForceDirectionLTR},
{flag_descriptions::kForceDirectionRtl, switches::kForceTextDirection,
switches::kForceDirectionRTL},
};
#if defined(OS_CHROMEOS)
const FeatureEntry::Choice kSchedulerConfigurationChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kSchedulerConfigurationConservative,
switches::kSchedulerConfiguration,
switches::kSchedulerConfigurationConservative},
{flag_descriptions::kSchedulerConfigurationPerformance,
switches::kSchedulerConfiguration,
switches::kSchedulerConfigurationPerformance},
};
#endif // OS_CHROMEOS
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kCompactSuggestions_SemicompactVariant[] = {
{"omnibox_compact_suggestions_variant", "semi-compact"}};
const FeatureEntry::FeatureVariation kCompactSuggestionsVariations[] = {
{"- Semi-compact", kCompactSuggestions_SemicompactVariant,
base::size(kCompactSuggestions_SemicompactVariant), nullptr},
};
#endif // OS_ANDROID
const FeatureEntry::Choice kEnableUseZoomForDSFChoices[] = {
{flag_descriptions::kEnableUseZoomForDsfChoiceDefault, "", ""},
{flag_descriptions::kEnableUseZoomForDsfChoiceEnabled,
switches::kEnableUseZoomForDSF, "true"},
{flag_descriptions::kEnableUseZoomForDsfChoiceDisabled,
switches::kEnableUseZoomForDSF, "false"},
};
const FeatureEntry::Choice kSiteIsolationOptOutChoices[] = {
{flag_descriptions::kSiteIsolationOptOutChoiceDefault, "", ""},
{flag_descriptions::kSiteIsolationOptOutChoiceOptOut,
switches::kDisableSiteIsolation, ""},
};
const FeatureEntry::Choice kForceColorProfileChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kForceColorProfileSRGB,
switches::kForceDisplayColorProfile, "srgb"},
{flag_descriptions::kForceColorProfileP3,
switches::kForceDisplayColorProfile, "display-p3-d65"},
{flag_descriptions::kForceColorProfileColorSpin,
switches::kForceDisplayColorProfile, "color-spin-gamma24"},
{flag_descriptions::kForceColorProfileSCRGBLinear,
switches::kForceDisplayColorProfile, "scrgb-linear"},
{flag_descriptions::kForceColorProfileHDR10,
switches::kForceDisplayColorProfile, "hdr10"},
};
const FeatureEntry::Choice kForceEffectiveConnectionTypeChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kEffectiveConnectionTypeUnknownDescription,
network::switches::kForceEffectiveConnectionType,
net::kEffectiveConnectionTypeUnknown},
{flag_descriptions::kEffectiveConnectionTypeOfflineDescription,
network::switches::kForceEffectiveConnectionType,
net::kEffectiveConnectionTypeOffline},
{flag_descriptions::kEffectiveConnectionTypeSlow2GDescription,
network::switches::kForceEffectiveConnectionType,
net::kEffectiveConnectionTypeSlow2G},
{flag_descriptions::kEffectiveConnectionTypeSlow2GOnCellularDescription,
network::switches::kForceEffectiveConnectionType,
net::kEffectiveConnectionTypeSlow2GOnCellular},
{flag_descriptions::kEffectiveConnectionType2GDescription,
network::switches::kForceEffectiveConnectionType,
net::kEffectiveConnectionType2G},
{flag_descriptions::kEffectiveConnectionType3GDescription,
network::switches::kForceEffectiveConnectionType,
net::kEffectiveConnectionType3G},
{flag_descriptions::kEffectiveConnectionType4GDescription,
network::switches::kForceEffectiveConnectionType,
net::kEffectiveConnectionType4G},
};
// Ensure that all effective connection types returned by Network Quality
// Estimator (NQE) are also exposed via flags.
static_assert(net::EFFECTIVE_CONNECTION_TYPE_LAST + 2 ==
base::size(kForceEffectiveConnectionTypeChoices),
"ECT enum value is not handled.");
static_assert(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN == 0,
"ECT enum value is not handled.");
static_assert(net::EFFECTIVE_CONNECTION_TYPE_4G + 1 ==
net::EFFECTIVE_CONNECTION_TYPE_LAST,
"ECT enum value is not handled.");
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitNone[] = {
{"max_srp_prefetches", "-1"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitZero[] = {
{"max_srp_prefetches", "0"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitOne[] = {
{"max_srp_prefetches", "1"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitTwo[] = {
{"max_srp_prefetches", "2"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitThree[] = {
{"max_srp_prefetches", "3"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitFour[] = {
{"max_srp_prefetches", "4"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitFive[] = {
{"max_srp_prefetches", "5"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitTen[] = {
{"max_srp_prefetches", "10"}};
const FeatureEntry::FeatureParam kIsolatedPrerenderPrefetchLimitFifteen[] = {
{"max_srp_prefetches", "15"}};
const FeatureEntry::FeatureVariation
kIsolatedPrerenderFeatureWithPrefetchLimit[] = {
{"Unlimited Prefetches", kIsolatedPrerenderPrefetchLimitNone,
base::size(kIsolatedPrerenderPrefetchLimitNone), nullptr},
{"Zero Prefetches", kIsolatedPrerenderPrefetchLimitZero,
base::size(kIsolatedPrerenderPrefetchLimitZero), nullptr},
{"One Prefetch", kIsolatedPrerenderPrefetchLimitOne,
base::size(kIsolatedPrerenderPrefetchLimitOne), nullptr},
{"Two Prefetches", kIsolatedPrerenderPrefetchLimitTwo,
base::size(kIsolatedPrerenderPrefetchLimitTwo), nullptr},
{"Three Prefetches", kIsolatedPrerenderPrefetchLimitThree,
base::size(kIsolatedPrerenderPrefetchLimitThree), nullptr},
{"Four Prefetches", kIsolatedPrerenderPrefetchLimitFour,
base::size(kIsolatedPrerenderPrefetchLimitFour), nullptr},
{"Five Prefetches", kIsolatedPrerenderPrefetchLimitFive,
base::size(kIsolatedPrerenderPrefetchLimitFive), nullptr},
{"Ten Prefetches", kIsolatedPrerenderPrefetchLimitTen,
base::size(kIsolatedPrerenderPrefetchLimitTen), nullptr},
{"Fifteen Prefetches", kIsolatedPrerenderPrefetchLimitFifteen,
base::size(kIsolatedPrerenderPrefetchLimitFifteen), nullptr},
};
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam
kAutofillKeyboardAccessoryFeatureVariationAnimationDuration[] = {
{autofill::kAutofillKeyboardAccessoryAnimationDurationKey, "1000"}};
const FeatureEntry::FeatureParam
kAutofillKeyboardAccessoryFeatureVariationLimitLabelWidth[] = {
{autofill::kAutofillKeyboardAccessoryLimitLabelWidthKey, "true"}};
const FeatureEntry::FeatureParam
kAutofillKeyboardAccessoryFeatureVariationShowHint[] = {
{autofill::kAutofillKeyboardAccessoryHintKey, "true"}};
const FeatureEntry::FeatureParam
kAutofillKeyboardAccessoryFeatureVariationAnimateWithHint[] = {
{autofill::kAutofillKeyboardAccessoryAnimationDurationKey, "1000"},
{autofill::kAutofillKeyboardAccessoryHintKey, "true"}};
const FeatureEntry::FeatureVariation
kAutofillKeyboardAccessoryFeatureVariations[] = {
{"Animate", kAutofillKeyboardAccessoryFeatureVariationAnimationDuration,
base::size(
kAutofillKeyboardAccessoryFeatureVariationAnimationDuration),
nullptr},
{"Limit label width",
kAutofillKeyboardAccessoryFeatureVariationLimitLabelWidth,
base::size(kAutofillKeyboardAccessoryFeatureVariationLimitLabelWidth),
nullptr},
{"Show hint", kAutofillKeyboardAccessoryFeatureVariationShowHint,
base::size(kAutofillKeyboardAccessoryFeatureVariationShowHint),
nullptr},
{"Animate with hint",
kAutofillKeyboardAccessoryFeatureVariationAnimateWithHint,
base::size(kAutofillKeyboardAccessoryFeatureVariationAnimateWithHint),
nullptr}};
#endif // OS_ANDROID
const FeatureEntry::Choice kMemlogModeChoices[] = {
{flags_ui::kGenericExperimentChoiceDisabled, "", ""},
{flag_descriptions::kMemlogModeMinimal, heap_profiling::kMemlogMode,
heap_profiling::kMemlogModeMinimal},
{flag_descriptions::kMemlogModeAll, heap_profiling::kMemlogMode,
heap_profiling::kMemlogModeAll},
{flag_descriptions::kMemlogModeBrowser, heap_profiling::kMemlogMode,
heap_profiling::kMemlogModeBrowser},
{flag_descriptions::kMemlogModeGpu, heap_profiling::kMemlogMode,
heap_profiling::kMemlogModeGpu},
{flag_descriptions::kMemlogModeAllRenderers, heap_profiling::kMemlogMode,
heap_profiling::kMemlogModeAllRenderers},
{flag_descriptions::kMemlogModeRendererSampling,
heap_profiling::kMemlogMode, heap_profiling::kMemlogModeRendererSampling},
};
const FeatureEntry::Choice kMemlogStackModeChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kMemlogStackModeNative,
heap_profiling::kMemlogStackMode, heap_profiling::kMemlogStackModeNative},
{flag_descriptions::kMemlogStackModeNativeWithThreadNames,
heap_profiling::kMemlogStackMode,
heap_profiling::kMemlogStackModeNativeWithThreadNames},
{flag_descriptions::kMemlogStackModePseudo,
heap_profiling::kMemlogStackMode, heap_profiling::kMemlogStackModePseudo},
{flag_descriptions::kMemlogStackModeMixed, heap_profiling::kMemlogStackMode,
heap_profiling::kMemlogStackModeMixed},
};
const FeatureEntry::Choice kMemlogSamplingRateChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kMemlogSamplingRate10KB,
heap_profiling::kMemlogSamplingRate,
heap_profiling::kMemlogSamplingRate10KB},
{flag_descriptions::kMemlogSamplingRate50KB,
heap_profiling::kMemlogSamplingRate,
heap_profiling::kMemlogSamplingRate50KB},
{flag_descriptions::kMemlogSamplingRate100KB,
heap_profiling::kMemlogSamplingRate,
heap_profiling::kMemlogSamplingRate100KB},
{flag_descriptions::kMemlogSamplingRate500KB,
heap_profiling::kMemlogSamplingRate,
heap_profiling::kMemlogSamplingRate500KB},
{flag_descriptions::kMemlogSamplingRate1MB,
heap_profiling::kMemlogSamplingRate,
heap_profiling::kMemlogSamplingRate1MB},
{flag_descriptions::kMemlogSamplingRate5MB,
heap_profiling::kMemlogSamplingRate,
heap_profiling::kMemlogSamplingRate5MB},
};
#if defined(OS_LINUX) || defined(OS_MAC) || defined(OS_WIN)
const FeatureEntry::FeatureParam kOmniboxDocumentProviderServerScoring[] = {
{"DocumentUseServerScore", "true"},
{"DocumentUseClientScore", "false"},
{"DocumentCapScorePerRank", "false"},
{"DocumentBoostOwned", "false"},
};
const FeatureEntry::FeatureParam
kOmniboxDocumentProviderServerScoringCappedByRank[] = {
{"DocumentUseServerScore", "true"},
{"DocumentUseClientScore", "false"},
{"DocumentCapScorePerRank", "true"},
{"DocumentBoostOwned", "true"},
};
const FeatureEntry::FeatureParam kOmniboxDocumentProviderClientScoring[] = {
{"DocumentUseServerScore", "false"},
{"DocumentUseClientScore", "true"},
{"DocumentCapScorePerRank", "false"},
{"DocumentBoostOwned", "false"},
};
const FeatureEntry::FeatureParam
kOmniboxDocumentProviderServerAndClientScoring[] = {
{"DocumentUseServerScore", "true"},
{"DocumentUseClientScore", "true"},
{"DocumentCapScorePerRank", "false"},
{"DocumentBoostOwned", "false"},
};
const FeatureEntry::FeatureVariation kOmniboxDocumentProviderVariations[] = {
{"server scores", kOmniboxDocumentProviderServerScoring,
base::size(kOmniboxDocumentProviderServerScoring), nullptr},
{"server scores capped by rank",
kOmniboxDocumentProviderServerScoringCappedByRank,
base::size(kOmniboxDocumentProviderServerScoringCappedByRank), nullptr},
{"client scores", kOmniboxDocumentProviderClientScoring,
base::size(kOmniboxDocumentProviderClientScoring), nullptr},
{"server and client scores", kOmniboxDocumentProviderServerAndClientScoring,
base::size(kOmniboxDocumentProviderServerAndClientScoring), nullptr}};
// The variations include 13 of the 16 possible permutations of "Title UI",
// "2-Line UI", "Title AC", and "Non-Prefix AC". The remaining 3 permutations
// would effectively be no-ops.
// - Title UI: Displays suggestion titles in the omnibox.
// E.g. en.wikipe | [dia.org/wiki/Space_Shuttle] (Space Shuttle - Wikipedia)
// - 2-Line UI: Stretches the omnibox vertically to fit 2 lines and displays
// titles on a 2nd line
// E.g. en.wikipe | [dia.org/wiki/Space_Shuttle]
// Space Shuttle - Wikipedia
// - Title AC: Autocompletes suggestions when the input matches the title.
// E.g. Space Sh | [ttle - Wikipedia] (en.wikipedia.org/wiki/Space_Shuttle)
// - Non-Prefix AC: Autocompletes suggestions when the input is not necessarily
// a prefix.
// E.g. [en.wikipe dia.org/] wiki/Spac | [e_Shuttle] (Space Shuttle -
// Wikipedia)
const FeatureEntry::FeatureVariation kOmniboxRichAutocompletionVariations[] = {
{
"Title UI",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionShowTitles", "true"}},
1,
nullptr,
},
// Skipping "2-Line UI" as that would be a no-op
{
"Title UI & 2-Line UI",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionShowTitles", "true"},
{"RichAutocompletionTwoLineOmnibox", "true"}},
2,
nullptr,
},
{
"Title AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitles", "true"}},
1,
nullptr,
},
{
"Title UI & Title AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionShowTitles", "true"},
{"RichAutocompletionAutocompleteTitles", "true"}},
2,
nullptr,
},
{
"2-Line UI & Title AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionTwoLineOmnibox", "true"},
{"RichAutocompletionAutocompleteTitles", "true"}},
2,
nullptr,
},
{
"Title UI , 2-Line UI, & Title AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionShowTitles", "true"},
{"RichAutocompletionAutocompleteTitles", "true"},
{"RichAutocompletionTwoLineOmnibox", "true"}},
3,
nullptr,
},
{
"Non-Prefix AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteNonPrefix", "true"}},
1,
nullptr,
},
{
"Title UI & Non-Prefix AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionShowTitles", "true"},
{"RichAutocompletionAutocompleteNonPrefix", "true"}},
2,
nullptr,
},
// Skipping "2-Line UI & Non-Prefix AC" as that would be a no-op
{
"Title UI, 2-Line UI, & Non-Prefix AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionShowTitles", "true"},
{"RichAutocompletionTwoLineOmnibox", "true"},
{"RichAutocompletionAutocompleteNonPrefix", "true"}},
3,
nullptr,
},
{
"Title AC & Non-Prefix AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitles", "true"},
{"RichAutocompletionAutocompleteNonPrefix", "true"}},
2,
nullptr,
},
{
"Title UI, Title AC, & Non-Prefix AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionShowTitles", "true"},
{"RichAutocompletionAutocompleteTitles", "true"},
{"RichAutocompletionAutocompleteNonPrefix", "true"}},
3,
nullptr,
},
{
"2-Line UI, Title AC, & Non-Prefix AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionTwoLineOmnibox", "true"},
{"RichAutocompletionAutocompleteTitles", "true"},
{"RichAutocompletionAutocompleteNonPrefix", "true"}},
3,
nullptr,
},
{
"Title UI, 2-Line UI, Title AC, & Non-Prefix AC",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteNonPrefix", "true"},
{"RichAutocompletionShowTitles", "true"},
{"RichAutocompletionAutocompleteTitles", "true"},
{"RichAutocompletionTwoLineOmnibox", "true"}},
4,
nullptr,
}};
const FeatureEntry::FeatureVariation
kOmniboxRichAutocompletionMinCharVariations[] = {
{
"Title 0 / Non Prefix 0",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitlesMinChar", "0"},
{"RichAutocompletionAutocompleteNonPrefixMinChar", "0"}},
2,
nullptr,
},
{
"Title 0 / Non Prefix 3",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitlesMinChar", "0"},
{"RichAutocompletionAutocompleteNonPrefixMinChar", "3"}},
2,
nullptr,
},
{
"Title 0 / Non Prefix 5",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitlesMinChar", "0"},
{"RichAutocompletionAutocompleteNonPrefixMinChar", "5"}},
2,
nullptr,
},
{
"Title 3 / Non Prefix 3",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitlesMinChar", "3"},
{"RichAutocompletionAutocompleteNonPrefixMinChar", "3"}},
2,
nullptr,
},
{
"Title 3 / Non Prefix 5",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitlesMinChar", "3"},
{"RichAutocompletionAutocompleteNonPrefixMinChar", "5"}},
2,
nullptr,
},
{
"Title 5 / Non Prefix 5",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteTitlesMinChar", "5"},
{"RichAutocompletionAutocompleteNonPrefixMinChar", "5"}},
2,
nullptr,
}};
const FeatureEntry::FeatureVariation
kOmniboxRichAutocompletionShowAdditionalTextVariations[] = {
{
"Show Additional Text",
(FeatureEntry::FeatureParam[]){},
0,
nullptr,
},
{
"Hide Additional Text",
(FeatureEntry::FeatureParam[]){
{"RichAutocompletionAutocompleteShowAdditionalText", "false"}},
1,
nullptr,
}};
#endif // defined(OS_LINUX) || defined(OS_MAC) || defined(OS_WIN)
const FeatureEntry::FeatureParam kOmniboxOnFocusSuggestionsParamSERP[] = {
{"ZeroSuggestVariant:6:*", "RemoteSendUrl"},
{"ZeroSuggestVariant:9:*", "RemoteSendUrl"}};
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kOmniboxNTPZPSLocal[] = {
{"ZeroSuggestVariant:1:*", "Local"},
{"ZeroSuggestVariant:7:*", "Local"},
{"ZeroSuggestVariant:8:*", "Local"}};
const FeatureEntry::FeatureParam kOmniboxNTPZPSRemote[] = {
{"ZeroSuggestVariant:1:*", "RemoteNoUrl"},
{"ZeroSuggestVariant:7:*", "RemoteNoUrl"},
{"ZeroSuggestVariant:8:*", "RemoteNoUrl"}};
const FeatureEntry::FeatureParam kOmniboxNTPZPSRemoteLocal[] = {
{"ZeroSuggestVariant:1:*", "RemoteNoUrl,Local"},
{"ZeroSuggestVariant:7:*", "RemoteNoUrl,Local"},
{"ZeroSuggestVariant:8:*", "RemoteNoUrl,Local"}};
#else // !defined(OS_ANDROID)
const FeatureEntry::FeatureParam kNTPOmniboxZPSRemoteLocal[] = {
{"ZeroSuggestVariant:1:*", "RemoteNoUrl,Local"},
{"ZeroSuggestVariant:7:*", "RemoteNoUrl,Local"}};
const FeatureEntry::FeatureParam kNTPOmniboxRealboxZPSRemoteLocal[] = {
{"ZeroSuggestVariant:1:*", "RemoteNoUrl,Local"},
{"ZeroSuggestVariant:7:*", "RemoteNoUrl,Local"},
{"ZeroSuggestVariant:15:*", "RemoteNoUrl,Local"}};
#endif // defined(OS_ANDROID)
const FeatureEntry::FeatureVariation kOmniboxOnFocusSuggestionsVariations[] = {
{"SERP - RemoteSendURL", kOmniboxOnFocusSuggestionsParamSERP,
base::size(kOmniboxOnFocusSuggestionsParamSERP),
"t3315869" /* variation_id */},
#if defined(OS_ANDROID)
{"ZPS on NTP: Local History", kOmniboxNTPZPSLocal,
base::size(kOmniboxNTPZPSLocal), nullptr},
{"ZPS on NTP: Remote History", kOmniboxNTPZPSRemote,
base::size(kOmniboxNTPZPSRemote), /* variation_id */ "t3314248"},
{"ZPS on NTP: Extended Remote History", kOmniboxNTPZPSRemote,
base::size(kOmniboxNTPZPSRemote), /* variation_id */ "t3317456"},
{"ZPS on NTP: Onboarding", kOmniboxNTPZPSRemote,
base::size(kOmniboxNTPZPSRemote), /* variation_id */ "t3316638"},
{"ZPS on NTP: PZPS, Remote, Local", kOmniboxNTPZPSRemoteLocal,
base::size(kOmniboxNTPZPSRemoteLocal), /* variation_id */ "t3317569"},
{"Contextual Web", kOmniboxNTPZPSRemoteLocal,
base::size(kOmniboxNTPZPSRemoteLocal), /* variation_id */ "t3317605"},
#else // !defined(OS_ANDROID)
{"NTP Omnibox - Remote History, Local History", kNTPOmniboxZPSRemoteLocal,
base::size(kNTPOmniboxZPSRemoteLocal), nullptr /* variation_id */},
{"NTP Omnibox - Remote History + PZPS, Local History",
kNTPOmniboxZPSRemoteLocal, base::size(kNTPOmniboxZPSRemoteLocal),
"t3317462" /* variation_id */},
{"NTP Omnibox/Realbox - Remote History, Local History",
kNTPOmniboxRealboxZPSRemoteLocal,
base::size(kNTPOmniboxRealboxZPSRemoteLocal), nullptr /* variation_id */},
{"NTP Omnibox/Realbox - Remote History + PZPS, Local History",
kNTPOmniboxRealboxZPSRemoteLocal,
base::size(kNTPOmniboxRealboxZPSRemoteLocal),
"t3317462" /* variation_id */},
#endif // defined(OS_ANDROID)
};
const FeatureEntry::FeatureVariation kMaxZeroSuggestMatchesVariations[] = {
{
"5",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "5"}},
1,
nullptr,
},
{
"6",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "6"}},
1,
nullptr,
},
{
"7",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "7"}},
1,
nullptr,
},
{
"8",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "8"}},
1,
nullptr,
},
{
"9",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "9"}},
1,
nullptr,
},
{
"10",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "10"}},
1,
nullptr,
},
{
"11",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "11"}},
1,
nullptr,
},
{
"12",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "12"}},
1,
nullptr,
},
{
"13",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "13"}},
1,
nullptr,
},
{
"14",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "14"}},
1,
nullptr,
},
{
"15",
(FeatureEntry::FeatureParam[]){{"MaxZeroSuggestMatches", "15"}},
1,
nullptr,
},
};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches3[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "3"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches4[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "4"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches5[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "5"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches6[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "6"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches7[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "7"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches8[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "8"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches9[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "9"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches10[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "10"}};
const FeatureEntry::FeatureParam kOmniboxUIMaxAutocompleteMatches12[] = {
{OmniboxFieldTrial::kUIMaxAutocompleteMatchesParam, "12"}};
const FeatureEntry::FeatureVariation
kOmniboxUIMaxAutocompleteMatchesVariations[] = {
{"3 matches", kOmniboxUIMaxAutocompleteMatches3,
base::size(kOmniboxUIMaxAutocompleteMatches3), nullptr},
{"4 matches", kOmniboxUIMaxAutocompleteMatches4,
base::size(kOmniboxUIMaxAutocompleteMatches4), nullptr},
{"5 matches", kOmniboxUIMaxAutocompleteMatches5,
base::size(kOmniboxUIMaxAutocompleteMatches5), nullptr},
{"6 matches", kOmniboxUIMaxAutocompleteMatches6,
base::size(kOmniboxUIMaxAutocompleteMatches6), nullptr},
{"7 matches", kOmniboxUIMaxAutocompleteMatches7,
base::size(kOmniboxUIMaxAutocompleteMatches7), nullptr},
{"8 matches", kOmniboxUIMaxAutocompleteMatches8,
base::size(kOmniboxUIMaxAutocompleteMatches8), nullptr},
{"9 matches", kOmniboxUIMaxAutocompleteMatches9,
base::size(kOmniboxUIMaxAutocompleteMatches9), nullptr},
{"10 matches", kOmniboxUIMaxAutocompleteMatches10,
base::size(kOmniboxUIMaxAutocompleteMatches10), nullptr},
{"12 matches", kOmniboxUIMaxAutocompleteMatches12,
base::size(kOmniboxUIMaxAutocompleteMatches12), nullptr}};
const FeatureEntry::FeatureParam kOmniboxMaxURLMatches2[] = {
{OmniboxFieldTrial::kOmniboxMaxURLMatchesParam, "2"}};
const FeatureEntry::FeatureParam kOmniboxMaxURLMatches3[] = {
{OmniboxFieldTrial::kOmniboxMaxURLMatchesParam, "3"}};
const FeatureEntry::FeatureParam kOmniboxMaxURLMatches4[] = {
{OmniboxFieldTrial::kOmniboxMaxURLMatchesParam, "4"}};
const FeatureEntry::FeatureParam kOmniboxMaxURLMatches5[] = {
{OmniboxFieldTrial::kOmniboxMaxURLMatchesParam, "5"}};
const FeatureEntry::FeatureParam kOmniboxMaxURLMatches6[] = {
{OmniboxFieldTrial::kOmniboxMaxURLMatchesParam, "6"}};
const FeatureEntry::FeatureVariation kOmniboxMaxURLMatchesVariations[] = {
{"2 matches", kOmniboxMaxURLMatches2, base::size(kOmniboxMaxURLMatches2),
nullptr},
{"3 matches", kOmniboxMaxURLMatches3, base::size(kOmniboxMaxURLMatches3),
nullptr},
{"4 matches", kOmniboxMaxURLMatches4, base::size(kOmniboxMaxURLMatches4),
nullptr},
{"5 matches", kOmniboxMaxURLMatches5, base::size(kOmniboxMaxURLMatches5),
nullptr},
{"6 matches", kOmniboxMaxURLMatches6, base::size(kOmniboxMaxURLMatches6),
nullptr}};
const FeatureEntry::FeatureVariation kDynamicMaxAutocompleteVariations[] = {
{
"9 suggestions if 0 or less URLs",
(FeatureEntry::FeatureParam[]){
{"OmniboxDynamicMaxAutocompleteUrlCutoff", "0"},
{"OmniboxDynamicMaxAutocompleteIncreasedLimit", "9"}},
2,
nullptr,
},
{
"9 suggestions if 1 or less URLs",
(FeatureEntry::FeatureParam[]){
{"OmniboxDynamicMaxAutocompleteUrlCutoff", "1"},
{"OmniboxDynamicMaxAutocompleteIncreasedLimit", "9"}},
2,
nullptr,
},
{
"9 suggestions if 2 or less URLs",
(FeatureEntry::FeatureParam[]){
{"OmniboxDynamicMaxAutocompleteUrlCutoff", "2"},
{"OmniboxDynamicMaxAutocompleteIncreasedLimit", "9"}},
2,
nullptr,
},
{
"10 suggestions if 0 or less URLs",
(FeatureEntry::FeatureParam[]){
{"OmniboxDynamicMaxAutocompleteUrlCutoff", "0"},
{"OmniboxDynamicMaxAutocompleteIncreasedLimit", "10"}},
2,
nullptr,
},
{
"10 suggestions if 1 or less URLs",
(FeatureEntry::FeatureParam[]){
{"OmniboxDynamicMaxAutocompleteUrlCutoff", "1"},
{"OmniboxDynamicMaxAutocompleteIncreasedLimit", "10"}},
2,
nullptr,
},
{
"10 suggestions if 2 or less URLs",
(FeatureEntry::FeatureParam[]){
{"OmniboxDynamicMaxAutocompleteUrlCutoff", "2"},
{"OmniboxDynamicMaxAutocompleteIncreasedLimit", "10"}},
2,
nullptr,
}};
const FeatureEntry::FeatureParam kMarkHttpAsDangerous[] = {
{security_state::features::kMarkHttpAsFeatureParameterName,
security_state::features::kMarkHttpAsParameterDangerous}};
const FeatureEntry::FeatureParam kMarkHttpAsWarningAndDangerousOnFormEdits[] = {
{security_state::features::kMarkHttpAsFeatureParameterName,
security_state::features::
kMarkHttpAsParameterWarningAndDangerousOnFormEdits}};
const FeatureEntry::FeatureParam kMarkHttpAsDangerWarning[] = {
{security_state::features::kMarkHttpAsFeatureParameterName,
security_state::features::kMarkHttpAsParameterDangerWarning}};
// The "Enabled" state for this feature is "0" and representing setting A.
const FeatureEntry::FeatureParam kTabHoverCardsSettingB[] = {
{features::kTabHoverCardsFeatureParameterName, "1"}};
const FeatureEntry::FeatureParam kTabHoverCardsSettingC[] = {
{features::kTabHoverCardsFeatureParameterName, "2"}};
const FeatureEntry::FeatureVariation kTabHoverCardsFeatureVariations[] = {
{"B", kTabHoverCardsSettingB, base::size(kTabHoverCardsSettingB), nullptr},
{"C", kTabHoverCardsSettingC, base::size(kTabHoverCardsSettingC), nullptr}};
const FeatureEntry::FeatureVariation kMarkHttpAsFeatureVariations[] = {
{"(mark as actively dangerous)", kMarkHttpAsDangerous,
base::size(kMarkHttpAsDangerous), nullptr},
{"(mark with a Not Secure warning and dangerous on form edits)",
kMarkHttpAsWarningAndDangerousOnFormEdits,
base::size(kMarkHttpAsWarningAndDangerousOnFormEdits), nullptr},
{"(mark with a grey triangle icon)", kMarkHttpAsDangerWarning,
base::size(kMarkHttpAsDangerWarning), nullptr}};
const FeatureEntry::FeatureParam kPromoBrowserCommandUnknownCommandParam[] = {
{features::kPromoBrowserCommandIdParam, "0"}};
const FeatureEntry::FeatureVariation kPromoBrowserCommandsVariations[] = {
{"- Unknown Command", kPromoBrowserCommandUnknownCommandParam,
base::size(kPromoBrowserCommandUnknownCommandParam),
"t4237555" /* variation_id */}};
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kTranslateForceTriggerOnEnglishHeuristic[] = {
{language::kOverrideModelKey, language::kOverrideModelHeuristicValue},
{language::kEnforceRankerKey, "false"}};
const FeatureEntry::FeatureParam kTranslateForceTriggerOnEnglishGeo[] = {
{language::kOverrideModelKey, language::kOverrideModelGeoValue},
{language::kEnforceRankerKey, "false"}};
const FeatureEntry::FeatureParam kTranslateForceTriggerOnEnglishBackoff[] = {
{language::kOverrideModelKey, language::kOverrideModelDefaultValue},
{language::kEnforceRankerKey, "false"},
{language::kBackoffThresholdKey, "0"}};
const FeatureEntry::FeatureVariation
kTranslateForceTriggerOnEnglishVariations[] = {
{"(Heuristic model without Ranker)",
kTranslateForceTriggerOnEnglishHeuristic,
base::size(kTranslateForceTriggerOnEnglishHeuristic), nullptr},
{"(Geo model without Ranker)", kTranslateForceTriggerOnEnglishGeo,
base::size(kTranslateForceTriggerOnEnglishGeo), nullptr},
{"(Zero threshold)", kTranslateForceTriggerOnEnglishBackoff,
base::size(kTranslateForceTriggerOnEnglishBackoff), nullptr}};
const FeatureEntry::FeatureParam kOverscrollHistoryNavigationBottomSheet[] = {
{"overscroll_history_navigation_bottom_sheet", "true"}};
const FeatureEntry::FeatureVariation kOverscrollHistoryNavigationVariations[] =
{{"Navigation sheet", kOverscrollHistoryNavigationBottomSheet,
base::size(kOverscrollHistoryNavigationBottomSheet), nullptr}};
#endif // defined(OS_ANDROID)
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kExploreSitesExperimental = {
chrome::android::explore_sites::kExploreSitesVariationParameterName,
chrome::android::explore_sites::kExploreSitesVariationExperimental};
const FeatureEntry::FeatureParam kExploreSitesDenseTitleBottom[] = {
{chrome::android::explore_sites::kExploreSitesDenseVariationParameterName,
chrome::android::explore_sites::
kExploreSitesDenseVariationDenseTitleBottom},
};
const FeatureEntry::FeatureParam kExploreSitesDenseTitleRight[] = {
{chrome::android::explore_sites::kExploreSitesDenseVariationParameterName,
chrome::android::explore_sites::
kExploreSitesDenseVariationDenseTitleRight},
};
const FeatureEntry::FeatureVariation kExploreSitesVariations[] = {
{"Experimental", &kExploreSitesExperimental, 1, nullptr},
{"Dense Title Bottom", kExploreSitesDenseTitleBottom,
base::size(kExploreSitesDenseTitleBottom), nullptr},
{"Dense Title Right", kExploreSitesDenseTitleRight,
base::size(kExploreSitesDenseTitleRight), nullptr}};
const FeatureEntry::FeatureParam kLongpressResolvePreserveTap = {
contextual_search::kLongpressResolveParamName,
contextual_search::kLongpressResolvePreserveTap};
const FeatureEntry::FeatureVariation kLongpressResolveVariations[] = {
{"and preserve Tap behavior", &kLongpressResolvePreserveTap, 1, nullptr},
};
#endif // defined(OS_ANDROID)
const FeatureEntry::FeatureParam kResamplingInputEventsLSQEnabled[] = {
{"predictor", features::kPredictorNameLsq}};
const FeatureEntry::FeatureParam kResamplingInputEventsKalmanEnabled[] = {
{"predictor", features::kPredictorNameKalman}};
const FeatureEntry::FeatureParam kResamplingInputEventsLinearFirstEnabled[] = {
{"predictor", features::kPredictorNameLinearFirst}};
const FeatureEntry::FeatureParam kResamplingInputEventsLinearSecondEnabled[] = {
{"predictor", features::kPredictorNameLinearSecond}};
const FeatureEntry::FeatureParam
kResamplingInputEventsLinearResamplingEnabled[] = {
{"predictor", features::kPredictorNameLinearResampling}};
const FeatureEntry::FeatureVariation kResamplingInputEventsFeatureVariations[] =
{{features::kPredictorNameLsq, kResamplingInputEventsLSQEnabled,
base::size(kResamplingInputEventsLSQEnabled), nullptr},
{features::kPredictorNameKalman, kResamplingInputEventsKalmanEnabled,
base::size(kResamplingInputEventsKalmanEnabled), nullptr},
{features::kPredictorNameLinearFirst,
kResamplingInputEventsLinearFirstEnabled,
base::size(kResamplingInputEventsLinearFirstEnabled), nullptr},
{features::kPredictorNameLinearSecond,
kResamplingInputEventsLinearSecondEnabled,
base::size(kResamplingInputEventsLinearSecondEnabled), nullptr},
{features::kPredictorNameLinearResampling,
kResamplingInputEventsLinearResamplingEnabled,
base::size(kResamplingInputEventsLinearResamplingEnabled), nullptr}};
const FeatureEntry::FeatureParam kFilteringPredictionEmptyFilterEnabled[] = {
{"filter", features::kFilterNameEmpty}};
const FeatureEntry::FeatureParam kFilteringPredictionOneEuroFilterEnabled[] = {
{"filter", features::kFilterNameOneEuro}};
const FeatureEntry::FeatureVariation kFilteringPredictionFeatureVariations[] = {
{features::kFilterNameEmpty, kFilteringPredictionEmptyFilterEnabled,
base::size(kFilteringPredictionEmptyFilterEnabled), nullptr},
{features::kFilterNameOneEuro, kFilteringPredictionOneEuroFilterEnabled,
base::size(kFilteringPredictionOneEuroFilterEnabled), nullptr}};
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kBottomOfflineIndicatorEnabled[] = {
{"bottom_offline_indicator", "true"}};
const FeatureEntry::FeatureVariation kOfflineIndicatorFeatureVariations[] = {
{"(bottom)", kBottomOfflineIndicatorEnabled,
base::size(kBottomOfflineIndicatorEnabled), nullptr}};
#endif // OS_ANDROID
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kTabSwitcherOnReturn_Immediate[] = {
{"tab_switcher_on_return_time_ms", "0"}};
const FeatureEntry::FeatureParam kTabSwitcherOnReturn_1Minute[] = {
{"tab_switcher_on_return_time_ms", "60000"}};
const FeatureEntry::FeatureParam kTabSwitcherOnReturn_30Minutes[] = {
{"tab_switcher_on_return_time_ms", "1800000"}};
const FeatureEntry::FeatureParam kTabSwitcherOnReturn_60Minutes[] = {
{"tab_switcher_on_return_time_ms", "3600000"}};
const FeatureEntry::FeatureVariation kTabSwitcherOnReturnVariations[] = {
{"Immediate", kTabSwitcherOnReturn_Immediate,
base::size(kTabSwitcherOnReturn_30Minutes), nullptr},
{"1 minute", kTabSwitcherOnReturn_1Minute,
base::size(kTabSwitcherOnReturn_30Minutes), nullptr},
{"30 minutes", kTabSwitcherOnReturn_30Minutes,
base::size(kTabSwitcherOnReturn_30Minutes), nullptr},
{"60 minutes", kTabSwitcherOnReturn_60Minutes,
base::size(kTabSwitcherOnReturn_60Minutes), nullptr},
};
#endif // OS_ANDROID
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kChromeDuet_HomeSearchTabSwitcher[] = {
{"chrome_duet_variation", "HomeSearchTabSwitcher"}};
const FeatureEntry::FeatureParam kChromeDuet_HomeSearchShare[] = {
{"chrome_duet_variation", "HomeSearchShare"}};
const FeatureEntry::FeatureParam kChromeDuet_NewTabSearchShare[] = {
{"chrome_duet_variation", "NewTabSearchShare"}};
const FeatureEntry::FeatureVariation kChromeDuetVariations[] = {
{"Home-Search-TabSwitcher Variation", kChromeDuet_HomeSearchTabSwitcher,
base::size(kChromeDuet_HomeSearchTabSwitcher), nullptr},
{"Home-Search-Share Variation", kChromeDuet_HomeSearchShare,
base::size(kChromeDuet_HomeSearchShare), nullptr},
{"NewTab-Search-Share Variation", kChromeDuet_NewTabSearchShare,
base::size(kChromeDuet_NewTabSearchShare), nullptr},
};
const FeatureEntry::FeatureParam kTabGridLayoutAndroid_NewTabVariation[] = {
{"tab_grid_layout_android_new_tab", "NewTabVariation"},
{"allow_to_refetch", "true"}};
const FeatureEntry::FeatureParam kTabGridLayoutAndroid_NewTabTile[] = {
{"tab_grid_layout_android_new_tab_tile", "NewTabTile"}};
const FeatureEntry::FeatureParam
kTabGridLayoutAndroid_ThumbnailAspectRatio_2[] = {
{"thumbnail_aspect_ratio", "2.0"},
{"allow_to_refetch", "true"}};
const FeatureEntry::FeatureParam
kTabGridLayoutAndroid_ThumbnailAspectRatio_three_quarter[] = {
{"thumbnail_aspect_ratio", "0.75"},
{"allow_to_refetch", "true"}};
const FeatureEntry::FeatureParam
kTabGridLayoutAndroid_ThumbnailAspectRatio_half[] = {
{"thumbnail_aspect_ratio", "0.5"},
{"allow_to_refetch", "true"}};
const FeatureEntry::FeatureParam kTabGridLayoutAndroid_DisableRefetch[] = {
{"allow_to_refetch", "false"}};
const FeatureEntry::FeatureParam kTabGridLayoutAndroid_SearchChip[] = {
{"enable_search_term_chip", "true"}};
const FeatureEntry::FeatureVariation kTabGridLayoutAndroidVariations[] = {
{"New Tab Variation", kTabGridLayoutAndroid_NewTabVariation,
base::size(kTabGridLayoutAndroid_NewTabVariation), nullptr},
{"New Tab Tile", kTabGridLayoutAndroid_NewTabTile,
base::size(kTabGridLayoutAndroid_NewTabTile), nullptr},
{"thumbnail aspect ratio - 2:1",
kTabGridLayoutAndroid_ThumbnailAspectRatio_2,
base::size(kTabGridLayoutAndroid_ThumbnailAspectRatio_2), nullptr},
{"thumbnail aspect ratio - 1:2",
kTabGridLayoutAndroid_ThumbnailAspectRatio_half,
base::size(kTabGridLayoutAndroid_ThumbnailAspectRatio_half), nullptr},
{"thumbnail aspect ratio - 3:4",
kTabGridLayoutAndroid_ThumbnailAspectRatio_three_quarter,
base::size(kTabGridLayoutAndroid_ThumbnailAspectRatio_three_quarter),
nullptr},
{"Disable refetch", kTabGridLayoutAndroid_DisableRefetch,
base::size(kTabGridLayoutAndroid_DisableRefetch), nullptr},
{"Search term chip", kTabGridLayoutAndroid_SearchChip,
base::size(kTabGridLayoutAndroid_SearchChip), nullptr},
};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_SingleSurface[] = {
{"start_surface_variation", "single"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_SingleSurface_V2[] = {
{"start_surface_variation", "single"},
{"show_last_active_tab_only", "true"},
{"exclude_mv_tiles", "true"},
{"show_stack_tab_switcher", "true"},
{"open_ntp_instead_of_start", "true"}};
const FeatureEntry::FeatureParam
kStartSurfaceAndroid_SingleSurfaceWithoutMvTiles[] = {
{"start_surface_variation", "single"},
{"exclude_mv_tiles", "true"},
{"hide_switch_when_no_incognito_tabs", "true"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_SingleSurfaceSingleTab[] =
{{"start_surface_variation", "single"},
{"show_last_active_tab_only", "true"},
{"hide_switch_when_no_incognito_tabs", "true"}};
const FeatureEntry::FeatureParam
kStartSurfaceAndroid_SingleSurfaceSingleTabStack[] = {
{"start_surface_variation", "single"},
{"show_last_active_tab_only", "true"},
{"show_stack_tab_switcher", "true"}};
const FeatureEntry::FeatureParam
kStartSurfaceAndroid_SingleSurfaceSingleTabWithoutMvTiles[] = {
{"start_surface_variation", "single"},
{"show_last_active_tab_only", "true"},
{"exclude_mv_tiles", "true"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_TwoPanesSurface[] = {
{"start_surface_variation", "twopanes"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_TasksOnly[] = {
{"start_surface_variation", "tasksonly"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_OmniboxOnly[] = {
{"start_surface_variation", "omniboxonly"},
{"hide_switch_when_no_incognito_tabs", "true"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_OmniboxOnly_Quick[] = {
{"start_surface_variation", "omniboxonly"},
{"omnibox_scroll_mode", "quick"},
{"hide_switch_when_no_incognito_tabs", "true"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_OmniboxOnly_Pinned[] = {
{"start_surface_variation", "omniboxonly"},
{"omnibox_scroll_mode", "pinned"},
{"hide_switch_when_no_incognito_tabs", "true"}};
const FeatureEntry::FeatureParam kStartSurfaceAndroid_TrendyTerms[] = {
{"start_surface_variation", "trendyterms"},
{"trendy_enabled", "true"},
{"trendy_success_min_period_ms", "30000"},
{"trendy_failure_min_period_ms", "10000"},
{"omnibox_scroll_mode", "quick"},
{"hide_switch_when_no_incognito_tabs", "true"}};
const FeatureEntry::FeatureVariation kStartSurfaceAndroidVariations[] = {
{"Single Surface", kStartSurfaceAndroid_SingleSurface,
base::size(kStartSurfaceAndroid_SingleSurface), nullptr},
{"Single Surface V2", kStartSurfaceAndroid_SingleSurface_V2,
base::size(kStartSurfaceAndroid_SingleSurface_V2), nullptr},
{"Single Surface without MV Tiles",
kStartSurfaceAndroid_SingleSurfaceWithoutMvTiles,
base::size(kStartSurfaceAndroid_SingleSurfaceWithoutMvTiles), nullptr},
{"Single Surface + Single Tab", kStartSurfaceAndroid_SingleSurfaceSingleTab,
base::size(kStartSurfaceAndroid_SingleSurfaceSingleTab), nullptr},
{"Single Surface + Single Tab + Tabs Stack",
kStartSurfaceAndroid_SingleSurfaceSingleTabStack,
base::size(kStartSurfaceAndroid_SingleSurfaceSingleTabStack), nullptr},
{"Single Surface + Single Tab without MV Tiles",
kStartSurfaceAndroid_SingleSurfaceSingleTabWithoutMvTiles,
base::size(kStartSurfaceAndroid_SingleSurfaceSingleTabWithoutMvTiles),
nullptr},
{"Two Panes Surface", kStartSurfaceAndroid_TwoPanesSurface,
base::size(kStartSurfaceAndroid_TwoPanesSurface), nullptr},
{"Tasks Only", kStartSurfaceAndroid_TasksOnly,
base::size(kStartSurfaceAndroid_TasksOnly), nullptr},
{"Omnibox Only", kStartSurfaceAndroid_OmniboxOnly,
base::size(kStartSurfaceAndroid_OmniboxOnly), nullptr},
{"Omnibox Only, Quick", kStartSurfaceAndroid_OmniboxOnly_Quick,
base::size(kStartSurfaceAndroid_OmniboxOnly_Quick), nullptr},
{"Omnibox Only, Pinned", kStartSurfaceAndroid_OmniboxOnly_Pinned,
base::size(kStartSurfaceAndroid_OmniboxOnly_Pinned), nullptr},
{"Trendy Terms, Quick", kStartSurfaceAndroid_TrendyTerms,
base::size(kStartSurfaceAndroid_TrendyTerms), nullptr}};
const FeatureEntry::FeatureParam kConditionalTabStripAndroid_Immediate[] = {
{"conditional_tab_strip_session_time_ms", "0"}};
const FeatureEntry::FeatureParam kConditionalTabStripAndroid_60Minutes[] = {
{"conditional_tab_strip_session_time_ms", "3600000"}};
const FeatureEntry::FeatureVariation kConditionalTabStripAndroidVariations[] = {
{"Immediate", kConditionalTabStripAndroid_Immediate,
base::size(kConditionalTabStripAndroid_Immediate), nullptr},
{"60 minutes", kConditionalTabStripAndroid_60Minutes,
base::size(kConditionalTabStripAndroid_60Minutes), nullptr},
};
#endif // OS_ANDROID
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam
kAutofillUseMobileLabelDisambiguationShowAll[] = {
{autofill::features::kAutofillUseMobileLabelDisambiguationParameterName,
autofill::features::
kAutofillUseMobileLabelDisambiguationParameterShowAll}};
const FeatureEntry::FeatureParam
kAutofillUseMobileLabelDisambiguationShowOne[] = {
{autofill::features::kAutofillUseMobileLabelDisambiguationParameterName,
autofill::features::
kAutofillUseMobileLabelDisambiguationParameterShowOne}};
const FeatureEntry::FeatureVariation
kAutofillUseMobileLabelDisambiguationVariations[] = {
{"(show all)", kAutofillUseMobileLabelDisambiguationShowAll,
base::size(kAutofillUseMobileLabelDisambiguationShowAll), nullptr},
{"(show one)", kAutofillUseMobileLabelDisambiguationShowOne,
base::size(kAutofillUseMobileLabelDisambiguationShowOne), nullptr}};
#endif // defined(OS_ANDROID)
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kHomepagePromoCardLarge[] = {
{"promo-card-variation", "Large"}};
const FeatureEntry::FeatureParam kHomepagePromoCardCompact[] = {
{"promo-card-variation", "Compact"}};
const FeatureEntry::FeatureParam kHomepagePromoCardSlim[] = {
{"promo-card-variation", "Slim"}};
const FeatureEntry::FeatureParam kHomepagePromoCardSuppressing[] = {
{"promo-card-variation", "Compact"},
{"suppressing_sign_in_promo", "true"}};
const FeatureEntry::FeatureVariation kHomepagePromoCardVariations[] = {
{"Large", kHomepagePromoCardLarge, base::size(kHomepagePromoCardLarge),
nullptr},
{"Compact", kHomepagePromoCardCompact,
base::size(kHomepagePromoCardCompact), nullptr},
{"Slim", kHomepagePromoCardSlim, base::size(kHomepagePromoCardSlim),
nullptr},
{"Compact_SuppressingSignInPromo", kHomepagePromoCardSuppressing,
base::size(kHomepagePromoCardSuppressing), nullptr}};
#endif // defined(OS_ANDROID)
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kContextMenuShopSimilarProducts[] = {
{"lensShopVariation", "ShopSimilarProducts"}};
const FeatureEntry::FeatureParam kContextMenuShopImageWithGoogleLens[] = {
{"lensShopVariation", "ShopImageWithGoogleLens"}};
const FeatureEntry::FeatureParam kContextMenuSearchSimilarProducts[] = {
{"lensShopVariation", "SearchSimilarProducts"}};
const FeatureEntry::FeatureVariation
kContextMenuShopWithGoogleLensShopVariations[] = {
{"ShopSimilarProducts", kContextMenuShopSimilarProducts,
base::size(kContextMenuShopSimilarProducts), nullptr},
{"ShopImageWithGoogleLens", kContextMenuShopImageWithGoogleLens,
base::size(kContextMenuShopImageWithGoogleLens), nullptr},
{"SearchSimilarProducts", kContextMenuSearchSimilarProducts,
base::size(kContextMenuSearchSimilarProducts), nullptr}};
#endif // defined(OS_ANDROID)
const FeatureEntry::FeatureParam kLazyFrameLoadingAutomatic[] = {
{"automatic-lazy-load-frames-enabled", "true"},
{"restrict-lazy-load-frames-to-data-saver-only", "false"},
};
const FeatureEntry::FeatureVariation kLazyFrameLoadingVariations[] = {
{"(Automatically lazily load where safe even if not marked "
"'loading=lazy')",
kLazyFrameLoadingAutomatic, base::size(kLazyFrameLoadingAutomatic),
nullptr}};
const FeatureEntry::FeatureParam kLazyImageLoadingAutomatic[] = {
{"automatic-lazy-load-images-enabled", "true"},
{"restrict-lazy-load-images-to-data-saver-only", "false"},
};
const FeatureEntry::FeatureVariation kLazyImageLoadingVariations[] = {
{"(Automatically lazily load where safe even if not marked "
"'loading=lazy')",
kLazyImageLoadingAutomatic, base::size(kLazyImageLoadingAutomatic),
nullptr}};
const FeatureEntry::Choice kNotificationSchedulerChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::
kNotificationSchedulerImmediateBackgroundTaskDescription,
notifications::switches::kNotificationSchedulerImmediateBackgroundTask,
""},
};
#if defined(OS_ANDROID)
const FeatureEntry::FeatureParam kOmniboxAssistantVoiceSearchGreyMic[] = {
{"min_agsa_version", "10.95"},
{"min_android_sdk", "21"},
{"min_memory_mb", "1024"},
{"enabled_locales", ""},
{"colorful_mic", "false"}};
const FeatureEntry::FeatureParam kOmniboxAssistantVoiceSearchColorfulMic[] = {
{"min_agsa_version", "10.95"},
{"min_android_sdk", "21"},
{"min_memory_mb", "1024"},
{"enabled_locales", ""},
{"colorful_mic", "true"}};
const FeatureEntry::FeatureVariation kOmniboxAssistantVoiceSearchVariations[] =
{
{"(grey mic)", kOmniboxAssistantVoiceSearchGreyMic,
base::size(kOmniboxAssistantVoiceSearchGreyMic), nullptr},
{"(colorful mic)", kOmniboxAssistantVoiceSearchColorfulMic,
base::size(kOmniboxAssistantVoiceSearchColorfulMic), nullptr},
};
const FeatureEntry::FeatureParam
kOmniboxSearchEngineLogoRoundedEdgesVariationConstant[] = {
{"rounded_edges", "true"}};
const FeatureEntry::FeatureParam
kOmniboxSearchEngineLogoLoupeEverywhereVariationConstant[] = {
{"loupe_everywhere", "true"}};
const FeatureEntry::FeatureVariation
kOmniboxSearchEngineLogoFeatureVariations[] = {
{"(rounded edges)",
kOmniboxSearchEngineLogoRoundedEdgesVariationConstant,
base::size(kOmniboxSearchEngineLogoRoundedEdgesVariationConstant),
nullptr},
{"(loupe everywhere)",
kOmniboxSearchEngineLogoLoupeEverywhereVariationConstant,
base::size(kOmniboxSearchEngineLogoLoupeEverywhereVariationConstant),
nullptr}};
const FeatureEntry::FeatureParam
kOmniboxImageSearchSuggestionThumbnailVariationConstant[] = {
{"ImageSearchSuggestionThumbnail", "true"}};
const FeatureEntry::FeatureVariation
kOmniboxImageSearchSuggestionThumbnailVariation[] = {
{"(with thumbnail)",
kOmniboxImageSearchSuggestionThumbnailVariationConstant,
base::size(kOmniboxImageSearchSuggestionThumbnailVariationConstant),
nullptr}};
#endif // OS_ANDROID
const FeatureEntry::FeatureVariation
kOmniboxOnDeviceHeadSuggestIncognitoExperimentVariations[] = {{
"relevance-1000",
(FeatureEntry::FeatureParam[]){
{OmniboxFieldTrial::kOnDeviceHeadSuggestMaxScoreForNonUrlInput,
"1000"}},
1,
nullptr,
}};
const FeatureEntry::FeatureVariation
kOmniboxOnDeviceHeadSuggestNonIncognitoExperimentVariations[] = {
{
"relevance-1000",
(FeatureEntry::FeatureParam[]){
{OmniboxFieldTrial::kOnDeviceHeadSuggestMaxScoreForNonUrlInput,
"1000"},
{OmniboxFieldTrial::kOnDeviceHeadSuggestDemoteMode,
"decrease-relevances"}},
2,
nullptr,
},
{
"request-delay-100ms",
(FeatureEntry::FeatureParam[]){
{OmniboxFieldTrial::kOnDeviceHeadSuggestDelaySuggestRequestMs,
"100"}},
1,
nullptr,
},
{
"delay-100ms-relevance-1000",
(FeatureEntry::FeatureParam[]){
{OmniboxFieldTrial::kOnDeviceHeadSuggestDelaySuggestRequestMs,
"100"},
{OmniboxFieldTrial::kOnDeviceHeadSuggestMaxScoreForNonUrlInput,
"1000"},
{OmniboxFieldTrial::kOnDeviceHeadSuggestDemoteMode,
"decrease-relevances"}},
3,
nullptr,
},
{
"request-delay-200ms",
(FeatureEntry::FeatureParam[]){
{OmniboxFieldTrial::kOnDeviceHeadSuggestDelaySuggestRequestMs,
"200"}},
1,
nullptr,
},
{
"delay-200ms-relevance-1000",
(FeatureEntry::FeatureParam[]){
{OmniboxFieldTrial::kOnDeviceHeadSuggestDelaySuggestRequestMs,
"200"},
{OmniboxFieldTrial::kOnDeviceHeadSuggestMaxScoreForNonUrlInput,
"1000"},
{OmniboxFieldTrial::kOnDeviceHeadSuggestDemoteMode,
"decrease-relevances"}},
3,
nullptr,
}};
const FeatureEntry::FeatureParam
kQuietNotificationPromptsWithAdaptiveActivation[] = {
{QuietNotificationPermissionUiConfig::kEnableAdaptiveActivation,
"true"},
{QuietNotificationPermissionUiConfig::kEnableAbusiveRequestBlocking,
"true"},
{QuietNotificationPermissionUiConfig::kEnableAbusiveRequestWarning,
"true"},
{QuietNotificationPermissionUiConfig::kEnableCrowdDenyTriggering,
"true"},
{QuietNotificationPermissionUiConfig::kCrowdDenyHoldBackChance, "0"}};
// The default "Enabled" option has the semantics of showing the quiet UI
// (animated location bar indicator on Desktop, and mini-infobars on Android),
// but only when the user directly turns it on in Settings. In addition to that,
// expose an option to also enable adaptively turning on the quiet UI after
// three consecutive denies or based on crowd deny verdicts.
const FeatureEntry::FeatureVariation kQuietNotificationPromptsVariations[] = {
{"(with adaptive activation)",
kQuietNotificationPromptsWithAdaptiveActivation,
base::size(kQuietNotificationPromptsWithAdaptiveActivation), nullptr},
};
#if BUILDFLAG(ENABLE_EXTENSIONS)
const FeatureEntry::FeatureParam kExtensionsCheckup_Startup_Performance[] = {
{extensions_features::kExtensionsCheckupBannerMessageParameter,
extensions_features::kPerformanceMessage},
{extensions_features::kExtensionsCheckupEntryPointParameter,
extensions_features::kStartupEntryPoint}};
const FeatureEntry::FeatureParam kExtensionsCheckup_Startup_Privacy[] = {
{extensions_features::kExtensionsCheckupBannerMessageParameter,
extensions_features::kPrivacyMessage},
{extensions_features::kExtensionsCheckupEntryPointParameter,
extensions_features::kStartupEntryPoint}};
const FeatureEntry::FeatureParam kExtensionsCheckup_Startup_Neutral[] = {
{extensions_features::kExtensionsCheckupBannerMessageParameter,
extensions_features::kNeutralMessage},
{extensions_features::kExtensionsCheckupEntryPointParameter,
extensions_features::kStartupEntryPoint}};
const FeatureEntry::FeatureParam kExtensionsCheckup_Promo_Performance[] = {
{extensions_features::kExtensionsCheckupBannerMessageParameter,
extensions_features::kPerformanceMessage},
{extensions_features::kExtensionsCheckupEntryPointParameter,
extensions_features::kNtpPromoEntryPoint}};
const FeatureEntry::FeatureParam kExtensionsCheckup_Promo_Privacy[] = {
{extensions_features::kExtensionsCheckupBannerMessageParameter,
extensions_features::kPrivacyMessage},
{extensions_features::kExtensionsCheckupEntryPointParameter,
extensions_features::kNtpPromoEntryPoint}};
const FeatureEntry::FeatureParam kExtensionsCheckup_Promo_Neutral[] = {
{extensions_features::kExtensionsCheckupBannerMessageParameter,
extensions_features::kNeutralMessage},
{extensions_features::kExtensionsCheckupEntryPointParameter,
extensions_features::kNtpPromoEntryPoint}};
const FeatureEntry::FeatureVariation kExtensionsCheckupVariations[] = {
{"On Startup - Performance Focused Message",
kExtensionsCheckup_Startup_Performance,
base::size(kExtensionsCheckup_Startup_Performance), nullptr},
{"On Startup - Privacy Focused Message", kExtensionsCheckup_Startup_Privacy,
base::size(kExtensionsCheckup_Startup_Privacy), nullptr},
{"On Startup - Neutral Focused Message", kExtensionsCheckup_Startup_Neutral,
base::size(kExtensionsCheckup_Startup_Neutral), nullptr},
{"NTP Promo - Performance Focused Message",
kExtensionsCheckup_Promo_Performance,
base::size(kExtensionsCheckup_Promo_Performance), nullptr},
{"NTP Promo - Privacy Focused Message", kExtensionsCheckup_Promo_Privacy,
base::size(kExtensionsCheckup_Promo_Privacy), nullptr},
{"NTP Promo - Neutral Focused Message", kExtensionsCheckup_Promo_Neutral,
base::size(kExtensionsCheckup_Promo_Neutral), nullptr}};
#endif // ENABLE_EXTENSIONS
// TODO(crbug.com/991082,1015377): Remove after proper support for back-forward
// cache is implemented.
const FeatureEntry::FeatureParam kBackForwardCache_ForceCaching[] = {
{"TimeToLiveInBackForwardCacheInSeconds", "300"},
{"should_ignore_blocklists", "true"},
{"enable_same_site", "true"}};
// With this, back-forward cache will be enabled on eligible pages when doing
// same-site navigations (instead of only cross-site navigations).
const FeatureEntry::FeatureParam kBackForwardCache_SameSite[] = {
{"enable_same_site", "true"}};
const FeatureEntry::FeatureVariation kBackForwardCacheVariations[] = {
{"same-site support (experimental)", kBackForwardCache_SameSite,
base::size(kBackForwardCache_SameSite), nullptr},
{"force caching all pages (experimental)", kBackForwardCache_ForceCaching,
base::size(kBackForwardCache_ForceCaching), nullptr},
};
const FeatureEntry::FeatureParam kSharingDeviceExpirationHours_0[] = {
{"SharingDeviceExpirationHours", "0"}};
const FeatureEntry::FeatureParam kSharingDeviceExpirationHours_12[] = {
{"SharingDeviceExpirationHours", "12"}};
const FeatureEntry::FeatureParam kSharingDeviceExpirationHours_24[] = {
{"SharingDeviceExpirationHours", "24"}};
const FeatureEntry::FeatureParam kSharingDeviceExpirationHours_48[] = {
{"SharingDeviceExpirationHours", "48"}};
const FeatureEntry::FeatureParam kSharingDeviceExpirationHours_96[] = {
{"SharingDeviceExpirationHours", "96"}};
const FeatureEntry::FeatureParam kSharingDeviceExpirationHours_240[] = {
{"SharingDeviceExpirationHours", "240"}};
const FeatureEntry::FeatureVariation kSharingDeviceExpirationVariations[] = {
{"0 hours", kSharingDeviceExpirationHours_0,
base::size(kSharingDeviceExpirationHours_0), nullptr},
{"12 hours", kSharingDeviceExpirationHours_12,
base::size(kSharingDeviceExpirationHours_12), nullptr},
{"1 day", kSharingDeviceExpirationHours_24,
base::size(kSharingDeviceExpirationHours_24), nullptr},
{"2 days", kSharingDeviceExpirationHours_48,
base::size(kSharingDeviceExpirationHours_48), nullptr},
{"4 days", kSharingDeviceExpirationHours_96,
base::size(kSharingDeviceExpirationHours_96), nullptr},
{"10 days", kSharingDeviceExpirationHours_240,
base::size(kSharingDeviceExpirationHours_240), nullptr},
};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure2250[] = {
{"lcp-limit-in-ms", "2250"},
{"intervention-mode", "failure"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure2000[] = {
{"lcp-limit-in-ms", "2000"},
{"intervention-mode", "failure"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1750[] = {
{"lcp-limit-in-ms", "1750"},
{"intervention-mode", "failure"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1500[] = {
{"lcp-limit-in-ms", "1500"},
{"intervention-mode", "failure"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1250[] = {
{"lcp-limit-in-ms", "1250"},
{"intervention-mode", "failure"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1000[] = {
{"lcp-limit-in-ms", "1000"},
{"intervention-mode", "failure"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap2250[] = {
{"lcp-limit-in-ms", "2250"},
{"intervention-mode", "swap"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap2000[] = {
{"lcp-limit-in-ms", "2000"},
{"intervention-mode", "swap"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1750[] = {
{"lcp-limit-in-ms", "1750"},
{"intervention-mode", "swap"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1500[] = {
{"lcp-limit-in-ms", "1500"},
{"intervention-mode", "swap"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1250[] = {
{"lcp-limit-in-ms", "1250"},
{"intervention-mode", "swap"}};
const FeatureEntry::FeatureParam
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1000[] = {
{"lcp-limit-in-ms", "1000"},
{"intervention-mode", "swap"}};
const FeatureEntry::FeatureVariation
kAlignFontDisplayAutoTimeoutWithLCPGoalVariations[] = {
{"switch to failure after 2250ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure2250,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalFailure2250),
nullptr},
{"switch to failure after 2000ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure2000,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalFailure2000),
nullptr},
{"switch to failure after 1750ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1750,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1750),
nullptr},
{"switch to failure after 1500ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1500,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1500),
nullptr},
{"switch to failure after 1250ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1250,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1250),
nullptr},
{"switch to failure after 1000ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1000,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalFailure1000),
nullptr},
{"switch to swap after 2250ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap2250,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalSwap2250), nullptr},
{"switch to swap after 2000ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap2000,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalSwap2000), nullptr},
{"switch to swap after 1750ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1750,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1750), nullptr},
{"switch to swap after 1500ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1500,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1500), nullptr},
{"switch to swap after 1250ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1250,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1250), nullptr},
{"switch to swap after 1000ms since navigation",
kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1000,
base::size(kAlignFontDisplayAutoTimeoutWithLCPGoalSwap1000), nullptr},
};
#if defined(OS_CHROMEOS)
const FeatureEntry::Choice kEnableCrOSActionRecorderChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{ash::switches::kCrOSActionRecorderWithHash,
ash::switches::kEnableCrOSActionRecorder,
ash::switches::kCrOSActionRecorderWithHash},
{ash::switches::kCrOSActionRecorderWithoutHash,
ash::switches::kEnableCrOSActionRecorder,
ash::switches::kCrOSActionRecorderWithoutHash},
{ash::switches::kCrOSActionRecorderCopyToDownloadDir,
ash::switches::kEnableCrOSActionRecorder,
ash::switches::kCrOSActionRecorderCopyToDownloadDir},
{ash::switches::kCrOSActionRecorderDisabled,
ash::switches::kEnableCrOSActionRecorder,
ash::switches::kCrOSActionRecorderDisabled},
{ash::switches::kCrOSActionRecorderStructuredDisabled,
ash::switches::kEnableCrOSActionRecorder,
ash::switches::kCrOSActionRecorderStructuredDisabled},
};
#endif // defined(OS_CHROMEOS)
#if defined(OS_ANDROID)
const FeatureEntry::Choice kWebOtpBackendChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kWebOtpBackendSmsVerification, switches::kWebOtpBackend,
switches::kWebOtpBackendSmsVerification},
{flag_descriptions::kWebOtpBackendUserConsent, switches::kWebOtpBackend,
switches::kWebOtpBackendUserConsent},
};
const FeatureEntry::Choice kQueryTilesCountryChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flag_descriptions::kQueryTilesCountryCodeUS,
query_tiles::switches::kQueryTilesCountryCode, "US"},
{flag_descriptions::kQueryTilesCountryCodeIndia,
query_tiles::switches::kQueryTilesCountryCode, "IN"},
{flag_descriptions::kQueryTilesCountryCodeBrazil,
query_tiles::switches::kQueryTilesCountryCode, "BR"},
{flag_descriptions::kQueryTilesCountryCodeNigeria,
query_tiles::switches::kQueryTilesCountryCode, "NG"},
{flag_descriptions::kQueryTilesCountryCodeIndonesia,
query_tiles::switches::kQueryTilesCountryCode, "ID"},
};
#endif // defined(OS_ANDROID)
// The choices for --enable-experimental-cookie-features. This really should
// just be a SINGLE_VALUE_TYPE, but it is misleading to have the choices be
// labeled "Disabled"/"Enabled". So instead this is made to be a
// MULTI_VALUE_TYPE with choices "Default"/"Enabled".
const FeatureEntry::Choice kEnableExperimentalCookieFeaturesChoices[] = {
{flags_ui::kGenericExperimentChoiceDefault, "", ""},
{flags_ui::kGenericExperimentChoiceEnabled,
switches::kEnableExperimentalCookieFeatures, ""},
};
#if defined(OS_CHROMEOS)
const FeatureEntry::Choice kFrameThrottleFpsChoices[] = {
{flag_descriptions::kFrameThrottleFpsDefault, "", ""},
{flag_descriptions::kFrameThrottleFps5, ash::switches::kFrameThrottleFps,
"5"},
{flag_descriptions::kFrameThrottleFps10, ash::switches::kFrameThrottleFps,
"10"},
{flag_descriptions::kFrameThrottleFps15, ash::switches::kFrameThrottleFps,
"15"},
{flag_descriptions::kFrameThrottleFps20, ash::switches::kFrameThrottleFps,
"20"},
{flag_descriptions::kFrameThrottleFps25, ash::switches::kFrameThrottleFps,
"25"},
{flag_descriptions::kFrameThrottleFps30, ash::switches::kFrameThrottleFps,
"30"}};
#endif // defined(OS_CHROMEOS)
#if defined(OS_ANDROID)
// The variations of --password-change-in-settings.
const FeatureEntry::FeatureParam
kPasswordChangeInSettingsVariationWithForcedWarningForEverySite[] = {
{password_manager::features::
kPasswordChangeInSettingsWithForcedWarningForEverySite,
"true"}};
const FeatureEntry::FeatureVariation
kPasswordChangeInSettingsFeatureVariations[] = {
{"Force leak warnings for every site in settings.",
kPasswordChangeInSettingsVariationWithForcedWarningForEverySite,
base::size(
kPasswordChangeInSettingsVariationWithForcedWarningForEverySite),
nullptr}};
// The variations of --password-change-support.
const FeatureEntry::FeatureParam
kPasswordChangeVariationWithForcedDialogAfterEverySuccessfulSubmission[] = {
{password_manager::features::
kPasswordChangeWithForcedDialogAfterEverySuccessfulSubmission,
"true"}};
const FeatureEntry::FeatureVariation kPasswordChangeFeatureVariations[] = {
{"Force dialog after every successful form submission.",
kPasswordChangeVariationWithForcedDialogAfterEverySuccessfulSubmission,
base::size(
kPasswordChangeVariationWithForcedDialogAfterEverySuccessfulSubmission),
nullptr}};
#endif // defined(OS_ANDROID)
#if defined(OS_CHROMEOS)
constexpr char kAssistantBetterOnboardingInternalName[] =
"enable-assistant-better-onboarding";
constexpr char kAssistantTimersV2InternalName[] = "enable-assistant-timers-v2";
#endif // OS_CHROMEOS
// RECORDING USER METRICS FOR FLAGS:
// -----------------------------------------------------------------------------
// The first line of the entry is the internal name.
//
// 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 entry use the macro MULTI_VALUE_TYPE supplying it the
// array of choices.
// See the documentation of FeatureEntry for details on the fields.
//
// Usage of about:flags is logged on startup via the "Launch.FlagsAtStartup"
// UMA histogram. This histogram shows the number of startups with a given flag
// enabled. If you'd like to see user counts instead, make sure to switch to
// "count users" view on the dashboard. When adding new entries, the enum
// "LoginCustomFlags" must be updated in histograms/enums.xml. See note in
// enums.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 FeatureEntry kFeatureEntries[] = {
// Include generated flags for flag unexpiry; see //docs/flag_expiry.md and
// //tools/flags/generate_unexpire_flags.py.
#include "chrome/browser/unexpire_flags_gen.inc"
{"ignore-gpu-blocklist", flag_descriptions::kIgnoreGpuBlocklistName,
flag_descriptions::kIgnoreGpuBlocklistDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kIgnoreGpuBlocklist)},
{"disable-accelerated-2d-canvas",
flag_descriptions::kAccelerated2dCanvasName,
flag_descriptions::kAccelerated2dCanvasDescription, kOsAll,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableAccelerated2dCanvas)},
{"composited-layer-borders", flag_descriptions::kCompositedLayerBordersName,
flag_descriptions::kCompositedLayerBordersDescription, kOsAll,
SINGLE_VALUE_TYPE(cc::switches::kShowCompositedLayerBorders)},
{"overlay-strategies", flag_descriptions::kOverlayStrategiesName,
flag_descriptions::kOverlayStrategiesDescription, kOsAll,
MULTI_VALUE_TYPE(kOverlayStrategiesChoices)},
{"tint-composited-content", flag_descriptions::kTintCompositedContentName,
flag_descriptions::kTintCompositedContentDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kTintCompositedContent)},
{"show-overdraw-feedback", flag_descriptions::kShowOverdrawFeedbackName,
flag_descriptions::kShowOverdrawFeedbackDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kShowOverdrawFeedback)},
{"ui-disable-partial-swap", flag_descriptions::kUiPartialSwapName,
flag_descriptions::kUiPartialSwapDescription, kOsAll,
SINGLE_DISABLE_VALUE_TYPE(switches::kUIDisablePartialSwap)},
{"enable-webrtc-capture-multi-channel-audio-processing",
flag_descriptions::kWebrtcCaptureMultiChannelApmName,
flag_descriptions::kWebrtcCaptureMultiChannelApmDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kWebRtcEnableCaptureMultiChannelApm)},
{"disable-webrtc-hw-decoding", flag_descriptions::kWebrtcHwDecodingName,
flag_descriptions::kWebrtcHwDecodingDescription, kOsAndroid | kOsCrOS,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableWebRtcHWDecoding)},
{"disable-webrtc-hw-encoding", flag_descriptions::kWebrtcHwEncodingName,
flag_descriptions::kWebrtcHwEncodingDescription, kOsAndroid | kOsCrOS,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableWebRtcHWEncoding)},
#if !defined(OS_ANDROID)
{"enable-reader-mode", flag_descriptions::kEnableReaderModeName,
flag_descriptions::kEnableReaderModeDescription, kOsDesktop,
FEATURE_WITH_PARAMS_VALUE_TYPE(dom_distiller::kReaderMode,
kReaderModeDiscoverabilityVariations,
"ReaderMode")},
#endif // !defined(OS_ANDROID)
#if defined(WEBRTC_USE_PIPEWIRE)
{"enable-webrtc-pipewire-capturer",
flag_descriptions::kWebrtcPipeWireCapturerName,
flag_descriptions::kWebrtcPipeWireCapturerDescription, kOsLinux,
FEATURE_VALUE_TYPE(features::kWebRtcPipeWireCapturer)},
#endif // defined(WEBRTC_USE_PIPEWIRE)
#if !defined(OS_ANDROID)
{"enable-webrtc-remote-event-log",
flag_descriptions::kWebRtcRemoteEventLogName,
flag_descriptions::kWebRtcRemoteEventLogDescription, kOsDesktop,
FEATURE_VALUE_TYPE(features::kWebRtcRemoteEventLog)},
#endif
{"enable-webrtc-srtp-aes-gcm", flag_descriptions::kWebrtcSrtpAesGcmName,
flag_descriptions::kWebrtcSrtpAesGcmDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kEnableWebRtcSrtpAesGcm)},
{"enable-webrtc-stun-origin", flag_descriptions::kWebrtcStunOriginName,
flag_descriptions::kWebrtcStunOriginDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kEnableWebRtcStunOrigin)},
{"enable-webrtc-hybrid-agc", flag_descriptions::kWebrtcHybridAgcName,
flag_descriptions::kWebrtcHybridAgcDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kWebRtcHybridAgc)},
{"enable-webrtc-new-encode-cpu-load-estimator",
flag_descriptions::kWebrtcNewEncodeCpuLoadEstimatorName,
flag_descriptions::kWebrtcNewEncodeCpuLoadEstimatorDescription, kOsAll,
FEATURE_VALUE_TYPE(media::kNewEncodeCpuLoadEstimator)},
{"enable-webrtc-hide-local-ips-with-mdns",
flag_descriptions::kWebrtcHideLocalIpsWithMdnsName,
flag_descriptions::kWebrtcHideLocalIpsWithMdnsDecription, kOsDesktop,
FEATURE_VALUE_TYPE(blink::features::kWebRtcHideLocalIpsWithMdns)},
{"enable-webrtc-use-min-max-vea-dimensions",
flag_descriptions::kWebrtcUseMinMaxVEADimensionsName,
flag_descriptions::kWebrtcUseMinMaxVEADimensionsDescription, kOsAll,
FEATURE_VALUE_TYPE(blink::features::kWebRtcUseMinMaxVEADimensions)},
#if defined(OS_ANDROID)
{"clear-old-browsing-data", flag_descriptions::kClearOldBrowsingDataName,
flag_descriptions::kClearOldBrowsingDataDescription, kOsAndroid,
FEATURE_VALUE_TYPE(features::kClearOldBrowsingData)},
#endif // OS_ANDROID
#if BUILDFLAG(ENABLE_NACL)
{"enable-nacl", flag_descriptions::kNaclName,
flag_descriptions::kNaclDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kEnableNaCl)},
#endif // ENABLE_NACL
#if BUILDFLAG(ENABLE_EXTENSIONS)
{"extension-apis", flag_descriptions::kExperimentalExtensionApisName,
flag_descriptions::kExperimentalExtensionApisDescription, kOsDesktop,
SINGLE_VALUE_TYPE(extensions::switches::kEnableExperimentalExtensionApis)},
{"extension-checkup", flag_descriptions::kExtensionsCheckupName,
flag_descriptions::kExtensionsCheckupDescription, kOsDesktop,
FEATURE_WITH_PARAMS_VALUE_TYPE(extensions_features::kExtensionsCheckup,
kExtensionsCheckupVariations,
"ExtensionsCheckup")},
{"extensions-toolbar-menu", flag_descriptions::kExtensionsToolbarMenuName,
flag_descriptions::kExtensionsToolbarMenuDescription, kOsDesktop,
FEATURE_VALUE_TYPE(features::kExtensionsToolbarMenu)},
{"extensions-on-chrome-urls",
flag_descriptions::kExtensionsOnChromeUrlsName,
flag_descriptions::kExtensionsOnChromeUrlsDescription, kOsAll,
SINGLE_VALUE_TYPE(extensions::switches::kExtensionsOnChromeURLs)},
#endif // ENABLE_EXTENSIONS
{"enable-history-manipulation-intervention",
flag_descriptions::kHistoryManipulationIntervention,
flag_descriptions::kHistoryManipulationInterventionDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kHistoryManipulationIntervention)},
#if defined(OS_ANDROID)
{"contextual-search-debug", flag_descriptions::kContextualSearchDebugName,
flag_descriptions::kContextualSearchDebugDescription, kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kContextualSearchDebug)},
{"contextual-search-definitions",
flag_descriptions::kContextualSearchDefinitionsName,
flag_descriptions::kContextualSearchDefinitionsDescription, kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kContextualSearchDefinitions)},
{"contextual-search-longpress-resolve",
flag_descriptions::kContextualSearchLongpressResolveName,
flag_descriptions::kContextualSearchLongpressResolveDescription,
kOsAndroid,
FEATURE_WITH_PARAMS_VALUE_TYPE(
chrome::android::kContextualSearchLongpressResolve,
kLongpressResolveVariations,
"ContextualSearchLongpressResolve")},
{"contextual-search-ml-tap-suppression",
flag_descriptions::kContextualSearchMlTapSuppressionName,
flag_descriptions::kContextualSearchMlTapSuppressionDescription,
kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kContextualSearchMlTapSuppression)},
{"contextual-search-ranker-query",
flag_descriptions::kContextualSearchRankerQueryName,
flag_descriptions::kContextualSearchRankerQueryDescription, kOsAndroid,
FEATURE_VALUE_TYPE(assist_ranker::kContextualSearchRankerQuery)},
{"contextual-search-second-tap",
flag_descriptions::kContextualSearchSecondTapName,
flag_descriptions::kContextualSearchSecondTapDescription, kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kContextualSearchSecondTap)},
{"contextual-search-translations",
flag_descriptions::kContextualSearchTranslationsName,
flag_descriptions::kContextualSearchTranslationsDescription, kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kContextualSearchTranslations)},
{"direct-actions", flag_descriptions::kDirectActionsName,
flag_descriptions::kDirectActionsDescription, kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kDirectActions)},
{"explore-sites", flag_descriptions::kExploreSitesName,
flag_descriptions::kExploreSitesDescription, kOsAndroid,
FEATURE_WITH_PARAMS_VALUE_TYPE(chrome::android::kExploreSites,
kExploreSitesVariations,
"ExploreSites InitialCountries")},
{"related-searches", flag_descriptions::kRelatedSearchesName,
flag_descriptions::kRelatedSearchesDescription, kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kRelatedSearches)},
{"bento-offline", flag_descriptions::kBentoOfflineName,
flag_descriptions::kBentoOfflineDescription, kOsAndroid,
FEATURE_VALUE_TYPE(chrome::android::kBentoOffline)},
#endif // OS_ANDROID
{"show-autofill-type-predictions",
flag_descriptions::kShowAutofillTypePredictionsName,
flag_descriptions::kShowAutofillTypePredictionsDescription, kOsAll,
FEATURE_VALUE_TYPE(autofill::features::kAutofillShowTypePredictions)},
{"smooth-scrolling", flag_descriptions::kSmoothScrollingName,
flag_descriptions::kSmoothScrollingDescription,
// Mac has a separate implementation with its own setting to disable.
kOsLinux | kOsCrOS | kOsWin | kOsAndroid,
ENABLE_DISABLE_VALUE_TYPE(switches::kEnableSmoothScrolling,
switches::kDisableSmoothScrolling)},
{"sms-receiver-cross-device",
flag_descriptions::kSmsReceiverCrossDeviceName,
flag_descriptions::kSmsReceiverCrossDeviceDescription, kOsAll,
FEATURE_VALUE_TYPE(kSmsReceiverCrossDevice)},
{"fractional-scroll-offsets",
flag_descriptions::kFractionalScrollOffsetsName,
flag_descriptions::kFractionalScrollOffsetsDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kFractionalScrollOffsets)},
#if defined(USE_AURA)
{"overlay-scrollbars", flag_descriptions::kOverlayScrollbarsName,
flag_descriptions::kOverlayScrollbarsDescription,
// Uses the system preference on Mac (a different implementation).
// On Android, this is always enabled.
kOsAura, FEATURE_VALUE_TYPE(features::kOverlayScrollbar)},
{"overlay-scrollbars-flash-after-scroll-update",
flag_descriptions::kOverlayScrollbarsFlashAfterAnyScrollUpdateName,
flag_descriptions::kOverlayScrollbarsFlashAfterAnyScrollUpdateDescription,
kOsAura,
FEATURE_VALUE_TYPE(features::kOverlayScrollbarFlashAfterAnyScrollUpdate)},
{"overlay-scrollbars-flash-when-mouse-enter",
flag_descriptions::kOverlayScrollbarsFlashWhenMouseEnterName,
flag_descriptions::kOverlayScrollbarsFlashWhenMouseEnterDescription,
kOsAura,
FEATURE_VALUE_TYPE(features::kOverlayScrollbarFlashWhenMouseEnter)},
#endif // USE_AURA
{"enable-quic", flag_descriptions::kQuicName,
flag_descriptions::kQuicDescription, kOsAll,
ENABLE_DISABLE_VALUE_TYPE(switches::kEnableQuic, switches::kDisableQuic)},
{"disable-javascript-harmony-shipping",
flag_descriptions::kJavascriptHarmonyShippingName,
flag_descriptions::kJavascriptHarmonyShippingDescription, kOsAll,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableJavaScriptHarmonyShipping)},
{"enable-javascript-harmony", flag_descriptions::kJavascriptHarmonyName,
flag_descriptions::kJavascriptHarmonyDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kJavaScriptHarmony)},
{"enable-experimental-webassembly-features",
flag_descriptions::kExperimentalWebAssemblyFeaturesName,
flag_descriptions::kExperimentalWebAssemblyFeaturesDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kEnableExperimentalWebAssemblyFeatures)},
{"enable-webassembly-baseline", flag_descriptions::kEnableWasmBaselineName,
flag_descriptions::kEnableWasmBaselineDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kWebAssemblyBaseline)},
{"enable-webassembly-lazy-compilation",
flag_descriptions::kEnableWasmLazyCompilationName,
flag_descriptions::kEnableWasmLazyCompilationDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kWebAssemblyLazyCompilation)},
{"enable-webassembly-simd", flag_descriptions::kEnableWasmSimdName,
flag_descriptions::kEnableWasmSimdDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kWebAssemblySimd)},
{"enable-webassembly-threads", flag_descriptions::kEnableWasmThreadsName,
flag_descriptions::kEnableWasmThreadsDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kWebAssemblyThreads)},
{"enable-webassembly-tiering", flag_descriptions::kEnableWasmTieringName,
flag_descriptions::kEnableWasmTieringDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kWebAssemblyTiering)},
{"enable-future-v8-vm-features", flag_descriptions::kV8VmFutureName,
flag_descriptions::kV8VmFutureDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kV8VmFuture)},
{"enable-gpu-rasterization", flag_descriptions::kGpuRasterizationName,
flag_descriptions::kGpuRasterizationDescription, kOsAll,
MULTI_VALUE_TYPE(kEnableGpuRasterizationChoices)},
{"enable-oop-rasterization", flag_descriptions::kOopRasterizationName,
flag_descriptions::kOopRasterizationDescription, kOsAll,
MULTI_VALUE_TYPE(kEnableOopRasterizationChoices)},
{"enable-oop-rasterization-ddl",
flag_descriptions::kOopRasterizationDDLName,
flag_descriptions::kOopRasterizationDDLDescription, kOsAll,
FEATURE_VALUE_TYPE(features::kOopRasterizationDDL)},
{"enable-experimental-web-platform-features",
flag_descriptions::kExperimentalWebPlatformFeaturesName,
flag_descriptions::kExperimentalWebPlatformFeaturesDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kEnableExperimentalWebPlatformFeatures)},
#if defined(OS_ANDROID)
{"enable-app-notification-status-messaging",
flag_descriptions::kAppNotificationStatusMessagingName,
flag_descriptions::kAppNotificationStatusMessagingDescription, kOsAndroid,
FEATURE_VALUE_TYPE(browser_ui::kAppNotificationStatusMessaging)},
#endif // OS_ANDROID
{"silent-debugger-extension-api",
flag_descriptions::kSilentDebuggerExtensionApiName,
flag_descriptions::kSilentDebuggerExtensionApiDescription, kOsDesktop,
SINGLE_VALUE_TYPE(switches::kSilentDebuggerExtensionAPI)},
#if BUILDFLAG(ENABLE_SPELLCHECK) && defined(OS_ANDROID)
{"enable-android-spellchecker",
flag_descriptions::kEnableAndroidSpellcheckerDescription,
flag_descriptions::kEnableAndroidSpellcheckerDescription, kOsAndroid,
FEATURE_VALUE_TYPE(spellcheck::kAndroidSpellCheckerNonLowEnd)},
#endif // ENABLE_SPELLCHECK && OS_ANDROID
{"top-chrome-touch-ui", flag_descriptions::kTopChromeTouchUiName,
flag_descriptions::kTopChromeTouchUiDescription, kOsDesktop,
MULTI_VALUE_TYPE(kTopChromeTouchUiChoices)},
#if BUILDFLAG(ENABLE_WEBUI_TAB_STRIP)
{"webui-tab-strip", flag_descriptions::kWebUITabStripName,
flag_descriptions::kWebUITabStripDescription, kOsDesktop,
FEATURE_VALUE_TYPE(features::kWebUITabStrip)},
#endif // BUILDFLAG(ENABLE_WEBUI_TAB_STRIP)
#if BUILDFLAG(ENABLE_WEBUI_TAB_STRIP) && defined(OS_CHROMEOS)
{
"webui-tab-strip-tab-drag-integration",
flag_descriptions::kWebUITabStripTabDragIntegrationName,
flag_descriptions::kWebUITabStripTabDragIntegrationDescription,
kOsCrOS,
FEATURE_VALUE_TYPE(ash::features::kWebUITabStripTabDragIntegration),
},
#endif // BUILDFLAG(ENABLE_WEBUI_TAB_STRIP) && defined(OS_CHROMEOS)
{"focus-mode", flag_descriptions::kFocusMode,
flag_descriptions::kFocusModeDescription, kOsDesktop,
FEATURE_VALUE_TYPE(features::kFocusMode)},
{"touch-events", flag_descriptions::kTouchEventsName,
flag_descriptions::kTouchEventsDescription, kOsDesktop,
MULTI_VALUE_TYPE(kTouchEventFeatureDetectionChoices)},
{"disable-touch-adjustment", flag_descriptions::kTouchAdjustmentName,
flag_descriptions::kTouchAdjustmentDescription,
kOsWin | kOsLinux | kOsCrOS | kOsAndroid,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableTouchAdjustment)},
#if defined(OS_CHROMEOS)
{"disable-explicit-dma-fences",
flag_descriptions::kDisableExplicitDmaFencesName,
flag_descriptions::kDisableExplicitDmaFencesDescription, kOsCrOS,
SINGLE_VALUE_TYPE(switches::kDisableExplicitDmaFences)},
// TODO(crbug.com/1012846): Remove this flag and provision when HDR is fully
// supported on ChromeOS.
{"use-hdr-transfer-function",
flag_descriptions::kUseHDRTransferFunctionName,
flag_descriptions::kUseHDRTransferFunctionDescription, kOsCrOS,
FEATURE_VALUE_TYPE(display::features::kUseHDRTransferFunction)},
#endif // OS_CHROMEOS
#if defined(OS_CHROMEOS)
{"ash-limit-alt-tab-to-active-desk",
flag_descriptions::kLimitAltTabToActiveDeskName,
flag_descriptions::kLimitAltTabToActiveDeskDescription, kOsCrOS,
FEATURE_VALUE_TYPE(ash::features::kLimitAltTabToActiveDesk)},
{"ash-limit-shelf-items-to-active-desk",
flag_descriptions::kLimitShelfItemsToActiveDeskName,
flag_descriptions::kLimitShelfItemsToActiveDeskDescription, kOsCrOS,
FEATURE_VALUE_TYPE(ash::features::kPerDeskShelf)},
{"ash-enable-unified-desktop",
flag_descriptions::kAshEnableUnifiedDesktopName,
flag_descriptions::kAshEnableUnifiedDesktopDescription, kOsCrOS,
SINGLE_VALUE_TYPE(switches::kEnableUnifiedDesktop)},
{"bluetooth-aggressive-appearance-filter",
flag_descriptions::kBluetoothAggressiveAppearanceFilterName,
flag_descriptions::kBluetoothAggressiveAppearanceFilterDescription,
kOsCrOS,
FEATURE_VALUE_TYPE(
chromeos::features::kBluetoothAggressiveAppearanceFilter)},
{"bluetooth-fix-a2dp-packet-size",
flag_descriptions::kBluetoothFixA2dpPacketSizeName,
flag_descriptions::kBluetoothFixA2dpPacketSizeDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kBluetoothFixA2dpPacketSize)},
{"bluetooth-next-handsfree-profile",
flag_descriptions::kBluetoothNextHandsfreeProfileName,
flag_descriptions::kBluetoothNextHandsfreeProfileDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kBluetoothNextHandsfreeProfile)},
{"cryptauth-v2-device-activity-status",
flag_descriptions::kCryptAuthV2DeviceActivityStatusName,
flag_descriptions::kCryptAuthV2DeviceActivityStatusDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kCryptAuthV2DeviceActivityStatus)},
{"cryptauth-v2-devicesync", flag_descriptions::kCryptAuthV2DeviceSyncName,
flag_descriptions::kCryptAuthV2DeviceSyncDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kCryptAuthV2DeviceSync)},
{"cryptauth-v2-enrollment", flag_descriptions::kCryptAuthV2EnrollmentName,
flag_descriptions::kCryptAuthV2EnrollmentDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kCryptAuthV2Enrollment)},
{"disable-cryptauth-v1-devicesync",
flag_descriptions::kDisableCryptAuthV1DeviceSyncName,
flag_descriptions::kDisableCryptAuthV1DeviceSyncDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kDisableCryptAuthV1DeviceSync)},
{"disable-office-editing-component-app",
flag_descriptions::kDisableOfficeEditingComponentAppName,
flag_descriptions::kDisableOfficeEditingComponentAppDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kDisableOfficeEditingComponentApp)},
{"updated_cellular_activation_ui",
flag_descriptions::kUpdatedCellularActivationUiName,
flag_descriptions::kUpdatedCellularActivationUiDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kUpdatedCellularActivationUi)},
{"use_messages_staging_url", flag_descriptions::kUseMessagesStagingUrlName,
flag_descriptions::kUseMessagesStagingUrlDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kUseMessagesStagingUrl)},
{"use-custom-messages-domain",
flag_descriptions::kUseCustomMessagesDomainName,
flag_descriptions::kUseCustomMessagesDomainDescription, kOsCrOS,
ORIGIN_LIST_VALUE_TYPE(switches::kCustomAndroidMessagesDomain, "")},
{"disable-cancel-all-touches",
flag_descriptions::kDisableCancelAllTouchesName,
flag_descriptions::kDisableCancelAllTouchesDescription, kOsCrOS,
SINGLE_VALUE_TYPE(switches::kDisableCancelAllTouches)},
{
"enable-background-blur",
flag_descriptions::kEnableBackgroundBlurName,
flag_descriptions::kEnableBackgroundBlurDescription,
kOsCrOS,
FEATURE_VALUE_TYPE(ash::features::kEnableBackgroundBlur),
},
{"enable-notification-indicator",
flag_descriptions::kNotificationIndicatorName,
flag_descriptions::kNotificationIndicatorDescription, kOsCrOS,
FEATURE_VALUE_TYPE(features::kNotificationIndicator)},
{"enable-app-list-search-autocomplete",
flag_descriptions::kEnableAppListSearchAutocompleteName,
flag_descriptions::kEnableAppListSearchAutocompleteDescription, kOsCrOS,
FEATURE_VALUE_TYPE(app_list_features::kEnableAppListSearchAutocomplete)},
{kLacrosSupportInternalName, flag_descriptions::kLacrosSupportName,
flag_descriptions::kLacrosSupportDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kLacrosSupport)},
{"list-all-display-modes", flag_descriptions::kListAllDisplayModesName,
flag_descriptions::kListAllDisplayModesDescription, kOsCrOS,
FEATURE_VALUE_TYPE(display::features::kListAllDisplayModes)},
{"instant-tethering", flag_descriptions::kTetherName,
flag_descriptions::kTetherDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kInstantTethering)},
{
"new-shortcut-mapping",
flag_descriptions::kEnableNewShortcutMappingName,
flag_descriptions::kEnableNewShortcutMappingDescription,
kOsCrOS,
FEATURE_VALUE_TYPE(features::kNewShortcutMapping),
},
{"shelf-hide-buttons-in-tablet",
flag_descriptions::kHideShelfControlsInTabletModeName,
flag_descriptions::kHideShelfControlsInTabletModeDescription, kOsCrOS,
FEATURE_VALUE_TYPE(ash::features::kHideShelfControlsInTabletMode)},
{"shelf-app-scaling", flag_descriptions::kShelfAppScalingName,
flag_descriptions::kShelfAppScalingDescription, kOsCrOS,
FEATURE_VALUE_TYPE(ash::features::kShelfAppScaling)},
{"shelf-hotseat", flag_descriptions::kShelfHotseatName,
flag_descriptions::kShelfHotseatDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kShelfHotseat)},
{"shelf-hover-previews", flag_descriptions::kShelfHoverPreviewsName,
flag_descriptions::kShelfHoverPreviewsDescription, kOsCrOS,
SINGLE_VALUE_TYPE(chromeos::switches::kShelfHoverPreviews)},
{"show-bluetooth-debug-log-toggle",
flag_descriptions::kShowBluetoothDebugLogToggleName,
flag_descriptions::kShowBluetoothDebugLogToggleDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kShowBluetoothDebugLogToggle)},
{"show-bluetooth-device-battery",
flag_descriptions::kShowBluetoothDeviceBatteryName,
flag_descriptions::kShowBluetoothDeviceBatteryDescription, kOsCrOS,
FEATURE_VALUE_TYPE(chromeos::features::kShowBluetoothDeviceBattery)},
{"show-taps", flag_descriptions::kShowTapsName,
flag_descriptions::kShowTapsDescription, kOsCrOS,
SINGLE_VALUE_TYPE(ash::switches::kShowTaps)},
{"show-touch-hud", flag_descriptions::kShowTouchHudName,
flag_descriptions::kShowTouchHudDescription, kOsCrOS,
SINGLE_VALUE_TYPE(ash::switches::kAshTouchHud)},
{"trim-on-memory-pressure", flag_descriptions::kTrimOnMemoryPressureName,
flag_descriptions::kTrimOnMemoryPressureDescription, kOsCrOS,
FEATURE_VALUE_TYPE(performance_manager::features::kTrimOnMemoryPressure)},
{"system-tray-mic-gain", flag_descriptions::kSystemTrayMicGainName,
flag_descriptions::kSystemTrayMicGainDescription, kOsCrOS,
FEATURE_VALUE_TYPE(ash::features::kSystemTrayMicGainSetting)},
#endif // OS_CHROMEOS
{
"disable-accelerated-video-decode",
flag_descriptions::kAcceleratedVideoDecodeName,
flag_descriptions::kAcceleratedVideoDecodeDescription,
kOsMac | kOsWin | kOsCrOS | kOsAndroid,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableAcceleratedVideoDecode),
},
{
"disable-accelerated-video-encode",
flag_descriptions::kAcceleratedVideoEncodeName,
flag_descriptions::kAcceleratedVideoEncodeDescription,
kOsMac | kOsWin | kOsCrOS | kOsAndroid,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableAcceleratedVideoEncode),
},
#if defined(OS_CHROMEOS)
{
"zero-copy-video-capture",
flag_descriptions::kZeroCopyVideoCaptureName,
flag_descriptions::kZeroCopyVideoCaptureDescription,
kOsCrOS,
ENABLE_DISABLE_VALUE_TYPE_AND_VALUE(
switches::kVideoCaptureUseGpuMemoryBuffer,
"1",
switches::kDisableVideoCaptureUseGpuMemoryBuffer,
"1"),
},
{
"ash-debug-shortcuts",
flag_descriptions::kDebugShortcutsName,
flag_descriptions::kDebugShortcutsDescription,
kOsAll,
SINGLE_VALUE_TYPE(ash::switches::kAshDebugShortcuts),
},
{"ui-slow-animations", flag_descriptions::kUiSlowAnimationsName,
flag_descriptions::kUiSlowAnimationsDescription, kOsCrOS,
SINGLE_VALUE_TYPE(switches::kUISlowAnimations)},
{"ui-show-composited-layer-borders",
flag_descriptions::kUiShowCompositedLayerBordersName,
flag_descriptions::kUiShowCompositedLayerBordersDescription, kOsCrOS,
MULTI_VALUE_TYPE(kUiShowCompositedLayerBordersChoices)},
{"enable-request-tablet-site", flag_descriptions::kRequestTabletSiteName,
flag_descriptions::kRequestTabletSiteDescription, kOsCrOS,
SINGLE_VALUE_TYPE(chromeos::switches::kEnableRequestTabletSite)},
#endif // OS_CHROMEOS
{"debug-packed-apps", flag_descriptions::kDebugPackedAppName,
flag_descriptions::kDebugPackedAppDescription, kOsDesktop,
SINGLE_VALUE_TYPE(switches::kDebugPackedApps)},
{"use-lookalikes-for-navigation-suggestions",
flag_descriptions::kUseLookalikesForNavigationSuggestionsName,
flag_descriptions::kUseLookalikesForNavigationSuggestionsDescription,
kOsAll,
FEATURE_VALUE_TYPE(net::features::kUseLookalikesForNavigationSuggestions)},
{"username-first-flow", flag_descriptions::kUsernameFirstFlowName,
flag_descriptions::kUsernameFirstFlowDescription, kOsAll,
FEATURE_VALUE_TYPE(password_manager::features::kUsernameFirstFlow)},
{"enable-show-autofill-signatures",
flag_descriptions::kShowAutofillSignaturesName,
flag_descriptions::kShowAutofillSignaturesDescription, kOsAll,
SINGLE_VALUE_TYPE(autofill::switches::kShowAutofillSignatures)},
{"wallet-service-use-sandbox",
flag_descriptions::kWalletServiceUseSandboxName,
flag_descriptions::kWalletServiceUseSandboxDescription,
kOsAndroid | kOsDesktop,
ENABLE_DISABLE_VALUE_TYPE_AND_VALUE(
autofill::switches::kWalletServiceUseSandbox,
"1",
autofill::switches::kWalletServiceUseSandbox,
"0")},
{"enable-web-bluetooth-new-permissions-backend",
flag_descriptions::kWebBluetoothNewPermissionsBackendName,
flag_descriptions::kWebBluetoothNewPermissionsBackendDescription,
kOsAndroid | kOsDesktop,
FEATURE_VALUE_TYPE(features::kWebBluetoothNewPermissionsBackend)},
#if defined(USE_AURA) || defined(OS_ANDROID)
{"overscroll-history-navigation",
flag_descriptions::kOverscrollHistoryNavigationName,
flag_descriptions::kOverscrollHistoryNavigationDescription,
kOsAura | kOsAndroid,
#if defined(OS_ANDROID)
FEATURE_WITH_PARAMS_VALUE_TYPE(features::kOverscrollHistoryNavigation,
kOverscrollHistoryNavigationVariations,
"OverscrollNavigation")},
#else
FEATURE_VALUE_TYPE(features::kOverscrollHistoryNavigation)},
{"pull-to-refresh", flag_descriptions::kPullToRefreshName,
flag_descriptions::kPullToRefreshDescription, kOsAura,
MULTI_VALUE_TYPE(kPullToRefreshChoices)},
#endif // OS_ANDROID
#endif // USE_AURA || OS_ANDROID
{"enable-touch-drag-drop", flag_descriptions::kTouchDragDropName,
flag_descriptions::kTouchDragDropDescription, kOsWin | kOsCrOS,
ENABLE_DISABLE_VALUE_TYPE(switches::kEnableTouchDragDrop,
switches::kDisableTouchDragDrop)},
{"touch-selection-strategy", flag_descriptions::kTouchSelectionStrategyName,
flag_descriptions::kTouchSelectionStrategyDescription,
kOsAndroid, // TODO(mfomitchev): Add CrOS/Win/Linux support soon.
MULTI_VALUE_TYPE(kTouchTextSelectionStrategyChoices)},
{"trace-upload-url", flag_descriptions::kTraceUploadUrlName,
flag_descriptions::kTraceUploadUrlDescription, kOsAll,
MULTI_VALUE_TYPE(kTraceUploadURL)},
{"enable-suggestions-with-substring-match",
flag_descriptions::kSuggestionsWithSubStringMatchName,
flag_descriptions::kSuggestionsWithSubStringMatchDescription, kOsAll,
FEATURE_VALUE_TYPE(autofill::features::kAutofillTokenPrefixMatching)},
{"enable-offer-store-unmasked-wallet-cards",
flag_descriptions::kOfferStoreUnmaskedWalletCardsName,
flag_descriptions::kOfferStoreUnmaskedWalletCardsDescription, kOsAll,
ENABLE_DISABLE_VALUE_TYPE(
autofill::switches::kEnableOfferStoreUnmaskedWalletCards,
autofill::switches::kDisableOfferStoreUnmaskedWalletCards)},
#if defined(OS_CHROMEOS)
{"enable-virtual-keyboard", flag_descriptions::kVirtualKeyboardName,
flag_descriptions::kVirtualKeyboardDescription, kOsCrOS,
SINGLE_VALUE_TYPE(keyboard::switches::kEnableVirtualKeyboard)},
#endif // OS_CHROMEOS
#if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
{"device-discovery-notifications",
flag_descriptions::kDeviceDiscoveryNotificationsName,
flag_descriptions::kDeviceDiscoveryNotificationsDescription, kOsDesktop,
ENABLE_DISABLE_VALUE_TYPE(switches::kEnableDeviceDiscoveryNotifications,
switches::kDisableDeviceDiscoveryNotifications)},
#endif // BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS)
{"enable-webgl2-compute-context",
flag_descriptions::kWebGL2ComputeContextName,
flag_descriptions::kWebGL2ComputeContextDescription,
kOsWin | kOsLinux | kOsCrOS,
SINGLE_VALUE_TYPE(switches::kEnableWebGL2ComputeContext)},
#endif // defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS)
{"enable-webgl-draft-extensions",
flag_descriptions::kWebglDraftExtensionsName,
flag_descriptions::kWebglDraftExtensionsDescription, kOsAll,
SINGLE_VALUE_TYPE(switches::kEnableWebGLDraftExtensions)},
#if defined(OS_ANDROID)
{"enable-android-autofill-accessibility",
flag_descriptions::kAndroidAutofillAccessibilityName,
flag_descriptions::kAndroidAutofillAccessibilityDescription, kOsAndroid,
FEATURE_VALUE_TYPE(features::kAndroidAutofillAccessibility)},
#endif // OS_ANDROID
{"enable-zero-copy", flag_descriptions::kZeroCopyName,
flag_descriptions::kZeroCopyDescription, kOsAll,
ENABLE_DISABLE_VALUE_TYPE(blink::switches::kEnableZeroCopy,
blink::switches::kDisableZeroCopy)},
{"enable-vulkan", flag_descriptions::kEnableVulkanName,
flag_descriptions::kEnableVulkanDescription,
kOsWin | kOsLinux | kOsAndroid, FEATURE_VALUE_TYPE(features::kVulkan)},
#if defined(OS_MAC)
{"disable-hosted-app-shim-creation",
flag_descriptions::kHostedAppShimCreationName,
flag_descriptions::kHostedAppShimCreationDescription, kOsMac,
SINGLE_DISABLE_VALUE_TYPE(switches::kDisableHostedAppShimCreation)},
{"enable-hosted-app-quit-notification",
flag_descriptions::kHostedAppQuitNotificationName,
flag_descriptions::kHostedAppQuitNotificationDescription, kOsMac,
SINGLE_VALUE_TYPE(switches::kHostedAppQuitNotification)},
#endif // OS_MAC
#if defined(OS_ANDROID)
{"translate-force-trigger-on-english",
flag_descriptions::kTranslateForceTriggerOnEnglishName,
flag_descriptions::kTranslateForceTriggerOnEnglishDescription, kOsAndroid,
FEATURE_WITH_PARAMS_VALUE_TYPE(language::kOverrideTranslateTriggerInIndia,
kTranslateForceTriggerOnEnglishVariations,
"OverrideTranslateTriggerInIndia")},
#endif // OS_ANDROID
#if BUILDFLAG(ENABLE_NATIVE_NOTIFICATIONS) && !defined(OS_CHROMEOS)
{"enable-native-notifications",
flag_descriptions::kNotificationsNativeFlagName,
flag_descriptions::kNotificationsNativeFlagDescription,
kOsMac | kOsLinux | kOsWin,
FEATURE_VALUE_TYPE(features::kNativeNotifications)},
#endif // ENABLE_NATIVE_NOTIFICATIONS
#if defined(OS_ANDROID)
{"reader-mode-heuristics", flag_descriptions::kReaderModeHeuristicsName,
flag_descriptions::kReaderModeHeuristicsDescription, kOsAndroid,