Migrate about:flags messages to const char*

chrome/browser/flags_descriptions.cc

Index: chrome/browser/flags_descriptions.cc
diff --git a/chrome/browser/flags_descriptions.cc b/chrome/browser/flags_descriptions.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b564fc22dd4f3f5f663635e0ec6145968508b1c6
--- /dev/null
+++ b/chrome/browser/flags_descriptions.cc
@@ -0,0 +1,3308 @@
+// Copyright 2017 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/flags_descriptions.h"
+
+namespace flags_descriptions {

[agrieve, 2017/03/27 15:43:24]

likewise for name nit: flag_descriptions

[vabr (Chromium), 2017/03/27 18:12:33]

Done.

+
+//  Material Design version of chrome://bookmarks
+
+const char kEnableMaterialDesignBookmarksName[] =
+    R"*(Enable Material Design bookmarks)*";

[Alexei Svitkine (slow), 2017/03/27 16:37:28]

I don't think we should be prefixing all of these with R. It just adds extra
noise to vast majority of these. Suggest adding R (in your script) only if the
content has something that needs it - e.g. an escape character \ or inner "'s

[vabr (Chromium), 2017/03/27 18:12:33]

Done.

+
+const char kEnableMaterialDesignBookmarksDescription[] =
+    R"*(If enabled, the chrome://bookmarks/ URL loads the Material Design)*"
+    R"*(bookmarks page.)*";
+
+//  Material Design version of chrome://policy
+
+const char kEnableMaterialDesignPolicyPageName[] =
+    R"*(Enable Material Design policy page)*";
+
+const char kEnableMaterialDesignPolicyPageDescription[] =
+    R"*(If enabled, the chrome://md-policy URL loads the Material Design)*"
+    R"*(policy page.)*";
+
+//  Material Design version of chrome://history
+
+const char kEnableMaterialDesignHistoryName[] =
+    R"*(Enable Material Design history)*";
+
+const char kEnableMaterialDesignHistoryDescription[] =
+    R"*(If enabled, the chrome://history/ URL loads the Material Design)*"
+    R"*(history page.)*";
+
+//  Material Design version of chrome://settings
+
+const char kEnableMaterialDesignSettingsName[] =
+    R"*(Enable Material Design settings)*";
+
+const char kEnableMaterialDesignSettingsDescription[] =
+    R"*(If enabled, the chrome://settings/ URL loads the Material Design)*"
+    R"*(settings page.)*";
+
+//  Material Design version of chrome://extensions
+
+const char kEnableMaterialDesignExtensionsName[] =
+    R"*(Enable Material Design extensions)*";
+
+const char kEnableMaterialDesignExtensionsDescription[] =
+    R"*(If enabled, the chrome://extensions/ URL loads the Material)*"
+    R"*(Design extensions page.)*";
+
+//  Material Design version of feedback form
+
+const char kEnableMaterialDesignFeedbackName[] =
+    R"*(Enable Material Design feedback)*";
+
+const char kEnableMaterialDesignFeedbackDescription[] =
+    R"*(If enabled, reporting an issue will load the Material Design)*"
+    R"*(feedback UI.)*";
+
+//  Report URL to SafeSearch
+
+const char kSafeSearchUrlReportingName[] =
+    R"*(SafeSearch URLs reporting.)*";
+
+const char kSafeSearchUrlReportingDescription[] =
+    R"*(If enabled, inappropriate URLs can be reported back to)*"
+    R"*(SafeSearch.)*";
+
+//  Device scale factor change in content crbug.com/485650.
+
+const char kEnableUseZoomForDsfName[] =
+    R"*(Use Blink's zoom for device scale factor.)*";
+
+const char kEnableUseZoomForDsfDescription[] =
+    R"*(If enabled, Blink uses its zooming mechanism to scale content for)*"
+    R"*(device scale factor.)*";
+
+const char kEnableUseZoomForDsfChoiceDefault[] =
+    R"*(Default)*";
+
+const char kEnableUseZoomForDsfChoiceEnabled[] =
+    R"*(Enabled)*";
+
+const char kEnableUseZoomForDsfChoiceDisabled[] =
+    R"*(Disabled)*";
+
+const char kNostatePrefetch[] =
+    R"*(No-State Prefetch)*";
+
+const char kNostatePrefetchDescription[] =
+    R"*("No-State Prefetch" pre-downloads resources to improve load)*"
+    R"*(times. "Prerender" does a full pre-rendering of the page, to)*"
+    R"*(improve load times even more. "Simple Load" does nothing and is)*"
+    R"*(similar to disabling the feature, but collects more metrics for)*"
+    R"*(comparison purposes.)*";
+
+const char kSpeculativePrefetchName[] =
+    R"*(Speculative Prefetch)*";
+
+const char kSpeculativePrefetchDescription[] =
+    R"*("Speculative Prefetch" fetches likely resources early to improve)*"
+    R"*(load times, based on a local database (see chrome://predictors).)*"
+    R"*("Learning" means that only the database construction is enabled,)*"
+    R"*("Prefetching" that learning and prefetching are enabled.)*";
+
+//  Force Tablet Mode
+
+const char kForceTabletModeName[] =
+    R"*(Force Tablet Mode)*";
+
+const char kForceTabletModeDescription[] =
+    R"*(This flag can be used to force a certain mode on to a chromebook,)*"
+    R"*(despite its current orientation. "TouchView" means that the)*"
+    R"*(chromebook will act as if it were in touch view mode. "Clamshell")*"
+    R"*(means that the chromebook will act as if it were in clamshell)*"
+    R"*(mode . "Auto" means that the chromebook will alternate between)*"
+    R"*(the two, based on its orientation.)*";
+
+const char kForceTabletModeTouchview[] =
+    R"*(TouchView)*";
+
+const char kForceTabletModeClamshell[] =
+    R"*(Clamshell)*";
+
+const char kForceTabletModeAuto[] =
+    R"*(Auto (default))*";
+
+//  Print Preview features
+
+const char kPrintPdfAsImageName[] =
+    R"*(Print Pdf as Image)*";
+
+const char kPrintPdfAsImageDescription[] =
+    R"*(If enabled, an option to print PDF files as images will be)*"
+    R"*(available in print preview.)*";
+
+const char kPrintScalingName[] =
+    R"*(Print Scaling.)*";
+
+const char kPrintScalingDescription[] =
+    R"*(If enabled, an option to scale documents will be available in)*"
+    R"*(print preview.)*";
+
+const char kNaclName[] =
+    R"*(Native Client)*";
+
+#if defined(OS_ANDROID)
+
+const char kNaclDescription[] =
+    R"*(Enable support for Native Client.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if !defined(OS_ANDROID)
+
+const char kNaclDescription[] =
+    R"*(Support Native Client for all web applications, even those that)*"
+    R"*(were not installed from the Chrome Web Store.)*";
+
+#endif  // !defined(OS_ANDROID)
+
+const char kNaclDebugName[] =
+    R"*(Native Client GDB-based debugging)*";
+
+const char kNaclDebugDescription[] =
+    R"*(Enable GDB debug stub. This will stop a Native Client application)*"
+    R"*(on startup and wait for nacl-gdb (from the NaCl SDK) to attach to)*"
+    R"*(it.)*";
+
+#if !defined(OS_ANDROID)
+
+const char kPnaclSubzeroName[] =
+    R"*(Force PNaCl Subzero)*";
+
+const char kPnaclSubzeroDescription[] =
+    R"*(Force the use of PNaCl's fast Subzero translator for all pexe)*"
+    R"*(files.)*";
+
+#endif  // !defined(OS_ANDROID)
+
+const char kNaclDebugMaskName[] =
+    R"*(Restrict Native Client GDB-based debugging by pattern)*";
+
+const char kNaclDebugMaskDescription[] =
+    R"*(Restricts Native Client application GDB-based debugging by URL of)*"
+    R"*(manifest file. Native Client GDB-based debugging must be enabled)*"
+    R"*(for this option to work.)*";
+
+const char kNaclDebugMaskChoiceDebugAll[] =
+    R"*(Debug everything.)*";
+
+const char kNaclDebugMaskChoiceExcludeUtilsPnacl[] =
+    R"*(Debug everything except secure shell and the PNaCl translator.)*";
+
+const char kNaclDebugMaskChoiceIncludeDebug[] =
+    R"*(Debug only if manifest URL ends with debug.nmf.)*";
+
+const char kEnableHttpFormWarningName[] =
+    R"*(Show in-form warnings for sensitive fields when the top-level)*"
+    R"*(page is not HTTPS)*";
+
+const char kEnableHttpFormWarningDescription[] =
+    R"*(Attaches a warning UI to any password or credit card fields)*"
+    R"*(detected when the top-level page is not HTTPS)*";
+
+const char kMarkHttpAsName[] =
+    R"*(Mark non-secure origins as non-secure)*";
+
+const char kMarkHttpAsDescription[] =
+    R"*(Change the UI treatment for HTTP pages)*";
+
+const char kMarkHttpAsDangerous[] =
+    R"*(Always mark HTTP as actively dangerous)*";
+
+const char kSavePageAsMhtmlName[] =
+    R"*(Save Page as MHTML)*";
+
+const char kSavePageAsMhtmlDescription[] =
+    R"*(Enables saving pages as MHTML: a single text file containing HTML)*"
+    R"*(and all sub-resources.)*";
+
+//  Flag and values for MHTML Geenrator options lab.
+
+const char kMhtmlGeneratorOptionName[] =
+    R"*(MHTML Generation Option)*";
+
+const char kMhtmlGeneratorOptionDescription[] =
+    R"*(Provides experimental options for MHTML file generator.)*";
+
+const char kMhtmlSkipNostoreMain[] =
+    R"*(Skips no-store main frame.)*";
+
+const char kMhtmlSkipNostoreAll[] =
+    R"*(Skips all no-store resources.)*";
+
+const char kDeviceDiscoveryNotificationsName[] =
+    R"*(Device Discovery Notifications)*";
+
+const char kDeviceDiscoveryNotificationsDescription[] =
+    R"*(Device discovery notifications on local network.)*";
+
+#if defined(OS_WIN)
+
+const char kCloudPrintXpsName[] =
+    R"*(XPS in Google Cloud Print)*";
+
+const char kCloudPrintXpsDescription[] =
+    R"*(XPS enables advanced options for classic printers connected to)*"
+    R"*(the Cloud Print with Chrome. Printers must be re-connected after)*"
+    R"*(changing this flag.)*";
+
+#endif  // defined(OS_WIN)
+
+const char kLoadMediaRouterComponentExtensionName[] =
+    R"*(Load Media Router Component Extension)*";
+
+const char kLoadMediaRouterComponentExtensionDescription[] =
+    R"*(Loads the Media Router component extension at startup.)*";
+
+const char kPrintPreviewRegisterPromosName[] =
+    R"*(Print Preview Registration Promos)*";
+
+const char kPrintPreviewRegisterPromosDescription[] =
+    R"*(Enable registering unregistered cloud printers from print)*"
+    R"*(preview.)*";
+
+const char kScrollPredictionName[] =
+    R"*(Scroll prediction)*";
+
+const char kTopChromeMd[] =
+    R"*(UI Layout for the browser's top chrome)*";
+
+const char kTopChromeMdDescription[] =
+    R"*(Toggles between normal and touch (formerly "hybrid") layouts.)*";
+
+const char kTopChromeMdMaterial[] =
+    R"*(Normal)*";
+
+const char kTopChromeMdMaterialHybrid[] =
+    R"*(Touch)*";
+
+const char kSiteSettings[] =
+    R"*(Site settings with All sites and Site details)*";
+
+const char kSiteSettingsDescription[] =
+    R"*(Adds new ways of viewing Site settings.)*";
+
+const char kSecondaryUiMd[] =
+    R"*(Material Design in the rest of the browser's native UI)*";
+
+const char kSecondaryUiMdDescription[] =
+    R"*(Extends the --top-chrome-md setting to secondary UI (bubbles,)*"
+    R"*(dialogs, etc.). On Mac, this enables MacViews, which uses)*"
+    R"*(toolkit-views for native browser dialogs.)*";
+
+const char kScrollPredictionDescription[] =
+    R"*(Predicts the finger's future position during scrolls allowing)*"
+    R"*(time to render the frame before the finger is there.)*";
+
+const char kAddToShelfName[] =
+    R"*(Add to shelf)*";
+
+const char kAddToShelfDescription[] =
+    R"*(Enable the display of add to shelf banners, which prompt a user)*"
+    R"*(to add a web app to their shelf, or other platform-specific)*"
+    R"*(equivalent.)*";
+
+const char kBypassAppBannerEngagementChecksName[] =
+    R"*(Bypass user engagement checks)*";
+
+const char kBypassAppBannerEngagementChecksDescription[] =
+    R"*(Bypasses user engagement checks for displaying app banners, such)*"
+    R"*(as requiring that users have visited the site before and that the)*"
+    R"*(banner hasn't been shown recently. This allows developers to test)*"
+    R"*(that other eligibility requirements for showing app banners, such)*"
+    R"*(as having a manifest, are met.)*";
+
+#if defined(OS_ANDROID)
+
+const char kAccessibilityTabSwitcherName[] =
+    R"*(Accessibility Tab Switcher)*";
+
+const char kAccessibilityTabSwitcherDescription[] =
+    R"*(Enable the accessibility tab switcher for Android.)*";
+
+const char kEnablePhysicalWebName[] =
+    R"*(Enable the Physical Web.)*";
+
+const char kEnablePhysicalWebDescription[] =
+    R"*(Enable scanning for URLs from Physical Web objects.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kTouchEventsName[] =
+    R"*(Touch Events API)*";
+
+const char kTouchEventsDescription[] =
+    R"*(Force Touch Events API feature detection to always be enabled or)*"
+    R"*(disabled, or to be enabled when a touchscreen is detected on)*"
+    R"*(startup (Automatic, the default).)*";
+
+const char kTouchAdjustmentName[] =
+    R"*(Touch adjustment)*";
+
+const char kTouchAdjustmentDescription[] =
+    R"*(Refine the position of a touch gesture in order to compensate for)*"
+    R"*(touches having poor resolution compared to a mouse.)*";
+
+const char kCompositedLayerBorders[] =
+    R"*(Composited render layer borders)*";
+
+const char kCompositedLayerBordersDescription[] =
+    R"*(Renders a border around composited Render Layers to help debug)*"
+    R"*(and study layer compositing.)*";
+
+const char kGlCompositedTextureQuadBorders[] =
+    R"*(GL composited texture quad borders)*";
+
+const char kGlCompositedTextureQuadBordersDescription[] =
+    R"*(Renders a border around GL composited texture quads to help debug)*"
+    R"*(and study overlay support.)*";
+
+const char kShowOverdrawFeedback[] =
+    R"*(Show overdraw feedback)*";
+
+const char kShowOverdrawFeedbackDescription[] =
+    R"*(Visualize overdraw by color-coding elements based on if they have)*"
+    R"*(other elements drawn underneath.)*";
+
+const char kUiPartialSwapName[] =
+    R"*(Partial swap)*";
+
+const char kUiPartialSwapDescription[] =
+    R"*(Sets partial swap behavior.)*";
+
+const char kDebugShortcutsName[] =
+    R"*(Debugging keyboard shortcuts)*";
+
+const char kIgnoreGpuBlacklistName[] =
+    R"*(Override software rendering list)*";
+
+const char kIgnoreGpuBlacklistDescription[] =
+    R"*(Overrides the built-in software rendering list and enables)*"
+    R"*(GPU-acceleration on unsupported system configurations.)*";
+
+const char kInertVisualViewportName[] =
+    R"*(Inert visual viewport.)*";
+
+const char kInertVisualViewportDescription[] =
+    R"*(Experiment to have all APIs reflect the layout viewport. This)*"
+    R"*(will make window.scroll properties relative to the layout)*"
+    R"*(viewport.)*";
+
+const char kExperimentalCanvasFeaturesName[] =
+    R"*(Experimental canvas features)*";
+
+const char kExperimentalCanvasFeaturesDescription[] =
+    R"*(Enables the use of experimental canvas features which are still)*"
+    R"*(in development.)*";
+
+const char kAccelerated2dCanvasName[] =
+    R"*(Accelerated 2D canvas)*";
+
+const char kAccelerated2dCanvasDescription[] =
+    R"*(Enables the use of the GPU to perform 2d canvas rendering instead)*"
+    R"*(of using software rendering.)*";
+
+const char kDisplayList2dCanvasName[] =
+    R"*(Display list 2D canvas)*";
+
+const char kDisplayList2dCanvasDescription[] =
+    R"*(Enables the use of display lists to record 2D canvas commands.)*"
+    R"*(This allows 2D canvas rasterization to be performed on separate)*"
+    R"*(thread.)*";
+
+const char kEnable2dCanvasDynamicRenderingModeSwitchingName[] =
+    R"*(Enable 2D canvas dynamic rendering mode switching.)*";
+
+const char kEnable2dCanvasDynamicRenderingModeSwitchingDescription[] =
+    R"*(There are multiple implementations of the graphics rendering)*"
+    R"*(pipeline for the 2D canvas. These different implementations have)*"
+    R"*(different performance characteristics. Turning on this flag)*"
+    R"*(allows canvas 2D contexts to switch between these implementations)*"
+    R"*(on the fly based on how the canvas is used in order to increase)*"
+    R"*(performance. For example, going from an implementation that uses)*"
+    R"*(the GPU to one that doesn't.)*";
+
+const char kExperimentalExtensionApisName[] =
+    R"*(Experimental Extension APIs)*";
+
+const char kExperimentalExtensionApisDescription[] =
+    R"*(Enables experimental extension APIs. Note that the extension)*"
+    R"*(gallery doesn't allow you to upload extensions that use)*"
+    R"*(experimental APIs.)*";
+
+const char kExtensionsOnChromeUrlsName[] =
+    R"*(Extensions on chrome:// URLs)*";
+
+const char kExtensionsOnChromeUrlsDescription[] =
+    R"*(Enables running extensions on chrome:// URLs, where extensions)*"
+    R"*(explicitly request this permission.)*";
+
+const char kFastUnloadName[] =
+    R"*(Fast tab/window close)*";
+
+const char kFastUnloadDescription[] =
+    R"*(Enables fast tab/window closing - runs a tab's onunload js)*"
+    R"*(handler independently of the GUI.)*";
+
+const char kUserConsentForExtensionScriptsName[] =
+    R"*(User consent for extension scripts)*";
+
+const char kUserConsentForExtensionScriptsDescription[] =
+    R"*(Require user consent for an extension running a script on the)*"
+    R"*(page, if the extension requested permission to run on all urls.)*";
+
+const char kHistoryRequiresUserGestureName[] =
+    R"*(New history entries require a user gesture.)*";
+
+const char kHistoryRequiresUserGestureDescription[] =
+    R"*(Require a user gesture to add a history entry.)*";
+
+const char kHyperlinkAuditingName[] =
+    R"*(Hyperlink auditing)*";
+
+const char kHyperlinkAuditingDescription[] =
+    R"*(Sends hyperlink auditing pings.)*";
+
+#if defined(OS_ANDROID)
+
+const char kContextualSearch[] =
+    R"*(Contextual Search)*";
+
+const char kContextualSearchDescription[] =
+    R"*(Whether or not Contextual Search is enabled.)*";
+
+const char kContextualSearchContextualCardsBarIntegration[] =
+    R"*(Contextual Search - Contextual Cards Integration)*";
+
+const char kContextualSearchContextualCardsBarIntegrationDescription[] =
+    R"*(Whether or not integration of Contextual Cards data in the)*"
+    R"*(Contextual Search Bar is enabled.)*";
+
+const char kContextualSearchSingleActions[] =
+    R"*(Contextual Search - Single Actions)*";
+
+const char kContextualSearchSingleActionsDescription[] =
+    R"*(Whether or not single actions using Contextual Cards data in the)*"
+    R"*(Contextual Search Bar is enabled.)*";
+
+const char kContextualSearchUrlActions[] =
+    R"*(Contextual Search - URL Actions)*";
+
+const char kContextualSearchUrlActionsDescription[] =
+    R"*(Whether or not URL actions using Contextual Cards data in the)*"
+    R"*(Contextual Search Bar is enabled.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kSmoothScrollingName[] =
+    R"*(Smooth Scrolling)*";
+
+const char kSmoothScrollingDescription[] =
+    R"*(Animate smoothly when scrolling page content.)*";
+
+const char kOverlayScrollbarsName[] =
+    R"*(Overlay Scrollbars)*";
+
+const char kOverlayScrollbarsDescription[] =
+    R"*(Enable the experimental overlay scrollbars implementation. You)*"
+    R"*(must also enable threaded compositing to have the scrollbars)*"
+    R"*(animate.)*";
+
+const char kShowAutofillTypePredictionsName[] =
+    R"*(Show Autofill predictions)*";
+
+const char kShowAutofillTypePredictionsDescription[] =
+    R"*(Annotates web forms with Autofill field type predictions as)*"
+    R"*(placeholder text.)*";
+
+const char kTcpFastOpenName[] =
+    R"*(TCP Fast Open)*";
+
+const char kTcpFastOpenDescription[] =
+    R"*(Enable the option to send extra authentication information in the)*"
+    R"*(initial SYN packet for a previously connected client, allowing)*"
+    R"*(faster data send start.)*";
+
+const char kTouchDragDropName[] =
+    R"*(Touch initiated drag and drop)*";
+
+const char kTouchDragDropDescription[] =
+    R"*(Touch drag and drop can be initiated through long press on a)*"
+    R"*(draggable element.)*";
+
+const char kTouchSelectionStrategyName[] =
+    R"*(Touch text selection strategy)*";
+
+const char kTouchSelectionStrategyDescription[] =
+    R"*(Controls how text selection granularity changes when touch text)*"
+    R"*(selection handles are dragged. Non-default behavior is)*"
+    R"*(experimental.)*";
+
+const char kTouchSelectionStrategyCharacter[] =
+    R"*(Character)*";
+
+const char kTouchSelectionStrategyDirection[] =
+    R"*(Direction)*";
+
+const char kWalletServiceUseSandboxName[] =
+    R"*(Use Google Payments sandbox servers)*";
+
+const char kWalletServiceUseSandboxDescription[] =
+    R"*(For developers: use the sandbox service for Google Payments API)*"
+    R"*(calls.)*";
+
+const char kOverscrollHistoryNavigationName[] =
+    R"*(Overscroll history navigation)*";
+
+const char kOverscrollHistoryNavigationDescription[] =
+    R"*(Experimental history navigation in response to horizontal)*"
+    R"*(overscroll.)*";
+
+const char kOverscrollHistoryNavigationSimpleUi[] =
+    R"*(Simple)*";
+
+const char kOverscrollStartThresholdName[] =
+    R"*(Overscroll start threshold)*";
+
+const char kOverscrollStartThresholdDescription[] =
+    R"*(Changes overscroll start threshold relative to the default)*"
+    R"*(value.)*";
+
+const char kOverscrollStartThreshold133Percent[] =
+    R"*(133%)*";
+
+const char kOverscrollStartThreshold166Percent[] =
+    R"*(166%)*";
+
+const char kOverscrollStartThreshold200Percent[] =
+    R"*(200%)*";
+
+const char kScrollEndEffectName[] =
+    R"*(Scroll end effect)*";
+
+const char kScrollEndEffectDescription[] =
+    R"*(Experimental scroll end effect in response to vertical)*"
+    R"*(overscroll.)*";
+
+const char kWebgl2Name[] =
+    R"*(WebGL 2.0)*";
+
+const char kWebgl2Description[] =
+    R"*(Allow web applications to access WebGL 2.0.)*";
+
+const char kWebglDraftExtensionsName[] =
+    R"*(WebGL Draft Extensions)*";
+
+const char kWebglDraftExtensionsDescription[] =
+    R"*(Enabling this option allows web applications to access the WebGL)*"
+    R"*(Extensions that are still in draft status.)*";
+
+const char kWebrtcHwDecodingName[] =
+    R"*(WebRTC hardware video decoding)*";
+
+const char kWebrtcHwDecodingDescription[] =
+    R"*(Support in WebRTC for decoding video streams using platform)*"
+    R"*(hardware.)*";
+
+const char kWebrtcHwEncodingName[] =
+    R"*(WebRTC hardware video encoding)*";
+
+const char kWebrtcHwEncodingDescription[] =
+    R"*(Support in WebRTC for encoding video streams using platform)*"
+    R"*(hardware.)*";
+
+const char kWebrtcHwH264EncodingName[] =
+    R"*(WebRTC hardware h264 video encoding)*";
+
+const char kWebrtcHwH264EncodingDescription[] =
+    R"*(Support in WebRTC for encoding h264 video streams using platform)*"
+    R"*(hardware.)*";
+
+const char kWebrtcSrtpAesGcmName[] =
+    R"*(Negotiation with GCM cipher suites for SRTP in WebRTC)*";
+
+const char kWebrtcSrtpAesGcmDescription[] =
+    R"*(When enabled, WebRTC will try to negotiate GCM cipher suites for)*"
+    R"*(SRTP.)*";
+
+const char kWebrtcStunOriginName[] =
+    R"*(WebRTC Stun origin header)*";
+
+const char kWebrtcStunOriginDescription[] =
+    R"*(When enabled, Stun messages generated by WebRTC will contain the)*"
+    R"*(Origin header.)*";
+
+const char kWebrtcEchoCanceller3Name[] =
+    R"*(WebRTC Echo Canceller 3.)*";
+
+const char kWebrtcEchoCanceller3Description[] =
+    R"*(Experimental WebRTC echo canceller (AEC3).)*";
+
+#if defined(OS_ANDROID)
+
+const char kMediaScreenCaptureName[] =
+    R"*(Experimental ScreenCapture.)*";
+
+const char kMediaScreenCaptureDescription[] =
+    R"*(Enable this option for experimental ScreenCapture feature on)*"
+    R"*(Android.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if BUILDFLAG(ENABLE_WEBRTC)
+
+const char kWebrtcH264WithOpenh264FfmpegName[] =
+    R"*(WebRTC H.264 software video encoder/decoder)*";
+
+const char kWebrtcH264WithOpenh264FfmpegDescription[] =
+    R"*(When enabled, an H.264 software video encoder/decoder pair is)*"
+    R"*(included. If a hardware encoder/decoder is also available it may)*"
+    R"*(be used instead of this encoder/decoder.)*";
+
+#endif  // BUILDFLAG(ENABLE_WEBRTC)
+
+const char kWebvrName[] =
+    R"*(WebVR)*";
+
+const char kWebvrDescription[] =
+    R"*(Enabling this option allows web applications to access)*"
+    R"*(experimental Virtual Reality APIs.)*";
+
+const char kWebvrExperimentalRenderingName[] =
+    R"*(WebVR experimental rendering optimizations)*";
+
+const char kWebvrExperimentalRenderingDescription[] =
+    R"*(Enabling this option activates experimental rendering path)*"
+    R"*(optimizations for WebVR.)*";
+
+const char kGamepadExtensionsName[] =
+    R"*(Gamepad Extensions)*";
+
+const char kGamepadExtensionsDescription[] =
+    R"*(Enabling this option allows web applications to access)*"
+    R"*(experimental extensions to the Gamepad APIs.)*";
+
+#if defined(OS_ANDROID)
+
+const char kNewPhotoPickerName[] =
+    R"*(Enable new Photopicker)*";
+
+const char kNewPhotoPickerDescription[] =
+    R"*(Activates the new picker for selecting photos.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_ANDROID)
+
+const char kEnableOskOverscrollName[] =
+    R"*(Enable OSK Overscroll)*";
+
+const char kEnableOskOverscrollDescription[] =
+    R"*(Enable OSK overscroll support. With this flag on, the OSK will)*"
+    R"*(only resize the visual viewport.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kQuicName[] =
+    R"*(Experimental QUIC protocol)*";
+
+const char kQuicDescription[] =
+    R"*(Enable experimental QUIC protocol support.)*";
+
+const char kSslVersionMaxName[] =
+    R"*(Maximum TLS version enabled.)*";
+
+const char kSslVersionMaxDescription[] =
+    R"*(Set maximum enabled TLS version.)*";
+
+const char kSslVersionMaxTls12[] =
+    R"*(TLS 1.2)*";
+
+const char kSslVersionMaxTls13[] =
+    R"*(TLS 1.3)*";
+
+const char kEnableTokenBindingName[] =
+    R"*(Token Binding.)*";
+
+const char kEnableTokenBindingDescription[] =
+    R"*(Enable Token Binding support.)*";
+
+const char kGestureRequirementForMediaPlaybackName[] =
+    R"*(Gesture requirement for media playback)*";
+
+const char kGestureRequirementForMediaPlaybackDescription[] =
+    R"*(User gesture requirement for playing media elements. Disabling)*"
+    R"*(this will allow autoplay to work.)*";
+
+#if !defined(OS_ANDROID)
+
+const char kCrossOriginMediaPlaybackRequiresUserGestureName[] =
+    R"*(Media playback in cross-origin iframes requires user gesture)*";
+
+const char kCrossOriginMediaPlaybackRequiresUserGestureDescription[] =
+    R"*(Playing media elements in cross-origin iframes requires user)*"
+    R"*(gesture. Disabling this will allow autoplay in cross-origin)*"
+    R"*(iframes to work.)*";
+
+#endif  // !defined(OS_ANDROID)
+
+const char kPassiveDocumentEventListenersDescription[] =
+    R"*(Forces touchstart, and touchmove event listeners on document)*"
+    R"*(level targets (which haven't requested otherwise) to be treated)*"
+    R"*(as passive.)*";
+
+const char kPassiveDocumentEventListenersName[] =
+    R"*(Document Level Event Listeners Passive Default)*";
+
+const char kPassiveEventListenersDueToFlingDescription[] =
+    R"*(Forces touchstart, and first touchmove per scroll event listeners)*"
+    R"*(during fling to be treated as passive.)*";
+
+const char kPassiveEventListenersDueToFlingName[] =
+    R"*(Touch Event Listeners Passive Default During Fling)*";
+
+const char kPassiveEventListenerTrue[] =
+    R"*(True (when unspecified))*";
+
+const char kPassiveEventListenerForceAllTrue[] =
+    R"*(Force All True)*";
+
+const char kPassiveEventListenerDefaultName[] =
+    R"*(Passive Event Listener Override)*";
+
+const char kPassiveEventListenerDefaultDescription[] =
+    R"*(Forces touchstart, touchmove, mousewheel and wheel event)*"
+    R"*(listeners (which haven't requested otherwise) to be treated as)*"
+    R"*(passive. This will break touch/wheel behavior on some websites)*"
+    R"*(but is useful for demonstrating the potential performance)*"
+    R"*(benefits of adopting passive event listeners.)*";
+
+#if defined(OS_ANDROID)
+
+const char kImportantSitesInCbdName[] =
+    R"*(Important sites options in clear browsing data dialog)*";
+
+const char kImportantSitesInCbdDescription[] =
+    R"*(Include the option to whitelist important sites in the clear)*"
+    R"*(browsing data dialog.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(USE_ASH)
+
+const char kAshShelfColor[] =
+    R"*(Shelf Color in Chrome OS system UI)*";
+
+const char kAshShelfColorDescription[] =
+    R"*(Specify the Shelf Color scheme in Chrome OS system UI)*";
+
+const char kAshShelfColorLightVibrant[] =
+    R"*(Light & Vibrant)*";
+
+const char kAshShelfColorNormalVibrant[] =
+    R"*(Normal & Vibrant)*";
+
+const char kAshShelfColorDarkVibrant[] =
+    R"*(Dark & Vibrant)*";
+
+const char kAshShelfColorLightMuted[] =
+    R"*(Light & Muted)*";
+
+const char kAshShelfColorNormalMuted[] =
+    R"*(Normal & Muted)*";
+
+const char kAshShelfColorDarkMuted[] =
+    R"*(Dark & Muted)*";
+
+const char kAshMaximizeModeWindowBackdropName[] =
+    R"*(Window backdrops in TouchView)*";
+
+const char kAshMaximizeModeWindowBackdropDescription[] =
+    R"*(Show grey window backdrops used in TouchView (maximize mode))*"
+    R"*(behind windows which cannot be maximized.)*";
+
+const char kAshScreenOrientationLockName[] =
+    R"*(Screen Orientation locking)*";
+
+const char kAshScreenOrientationLockDescription[] =
+    R"*(Allows javascript to lock the screen orienation.)*";
+
+const char kAshEnableMirroredScreenName[] =
+    R"*(Enable mirrored screen mode.)*";
+
+const char kAshEnableMirroredScreenDescription[] =
+    R"*(Enable the mirrored screen mode. This mode flips the screen image)*"
+    R"*(horizontally.)*";
+
+const char kMaterialDesignInkDropAnimationFast[] =
+    R"*(Fast)*";
+
+const char kMaterialDesignInkDropAnimationSlow[] =
+    R"*(Slow)*";
+
+const char kMaterialDesignInkDropAnimationSpeedName[] =
+    R"*(Material Design Ink Drop Animation Speed)*";
+
+const char kMaterialDesignInkDropAnimationSpeedDescription[] =
+    R"*(Sets the speed of the experimental visual feedback animations for)*"
+    R"*(material design.)*";
+
+const char kUiSlowAnimationsName[] =
+    R"*(Slow UI animations)*";
+
+const char kUiSlowAnimationsDescription[] =
+    R"*(Makes all UI animations slow.)*";
+
+#endif  // defined(USE_ASH)
+
+const char kJavascriptHarmonyShippingName[] =
+    R"*(Latest stable JavaScript features)*";
+
+const char kJavascriptHarmonyShippingDescription[] =
+    R"*(Some web pages use legacy or non-standard JavaScript extensions)*"
+    R"*(that may conflict with the latest JavaScript features. This flag)*"
+    R"*(allows disabling support of those features for compatibility with)*"
+    R"*(such pages.)*";
+
+const char kJavascriptHarmonyName[] =
+    R"*(Experimental JavaScript)*";
+
+const char kJavascriptHarmonyDescription[] =
+    R"*(Enable web pages to use experimental JavaScript features.)*";
+
+const char kV8FutureName[] =
+    R"*(Experimental Features in V8 JavaScript execution)*";
+
+const char kV8FutureDescription[] =
+    R"*(Enable experimental features in V8 for JavaScript execution.)*";
+
+const char kV8DisableIgnitionTurboName[] =
+    R"*(Disable the new JavaScript Compilation Pipeline)*";
+
+const char kV8DisableIgnitionTurboDescription[] =
+    R"*(Disable V8's new Ignition interpreter and TurboFan compiler for)*"
+    R"*(JavaScript execution.)*";
+
+const char kEnableAsmWasmName[] =
+    R"*(Experimental Validate Asm.js and convert to WebAssembly when)*"
+    R"*(valid.)*";
+
+const char kEnableAsmWasmDescription[] =
+    R"*(Validate Asm.js when "use asm" is present and then convert to)*"
+    R"*(WebAssembly.)*";
+
+const char kEnableSharedArrayBufferName[] =
+    R"*(Experimental enabled SharedArrayBuffer support in JavaScript.)*";
+
+const char kEnableSharedArrayBufferDescription[] =
+    R"*(Enable SharedArrayBuffer support in JavaScript.)*";
+
+const char kEnableWasmName[] =
+    R"*(WebAssembly structured cloning support.)*";
+
+const char kEnableWasmDescription[] =
+    R"*(Enable web pages to use WebAssembly structured cloning.)*";
+
+#if defined(OS_ANDROID)
+
+const char kMediaDocumentDownloadButtonName[] =
+    R"*(Download button when opening a page with media url.)*";
+
+const char kMediaDocumentDownloadButtonDescription[] =
+    R"*(Allow a download button to show up when opening a page with media)*"
+    R"*(url.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kSoftwareRasterizerName[] =
+    R"*(3D software rasterizer)*";
+
+const char kSoftwareRasterizerDescription[] =
+    R"*(Fall back to a 3D software rasterizer when the GPU cannot be)*"
+    R"*(used.)*";
+
+const char kGpuRasterizationName[] =
+    R"*(GPU rasterization)*";
+
+const char kGpuRasterizationDescription[] =
+    R"*(Use GPU to rasterize web content. Requires impl-side painting.)*";
+
+const char kForceGpuRasterization[] =
+    R"*(Force-enabled for all layers)*";
+
+const char kGpuRasterizationMsaaSampleCountName[] =
+    R"*(GPU rasterization MSAA sample count.)*";
+
+const char kGpuRasterizationMsaaSampleCountDescription[] =
+    R"*(Specify the number of MSAA samples for GPU rasterization.)*";
+
+const char kGpuRasterizationMsaaSampleCountZero[] =
+    R"*(0)*";
+
+const char kGpuRasterizationMsaaSampleCountTwo[] =
+    R"*(2)*";
+
+const char kGpuRasterizationMsaaSampleCountFour[] =
+    R"*(4)*";
+
+const char kGpuRasterizationMsaaSampleCountEight[] =
+    R"*(8)*";
+
+const char kGpuRasterizationMsaaSampleCountSixteen[] =
+    R"*(16)*";
+
+const char kSlimmingPaintInvalidationName[] =
+    R"*(Slimming paint invalidation.)*";
+
+const char kSlimmingPaintInvalidationDescription[] =
+    R"*(Whether to enable a new paint invalidation system.)*";
+
+const char kExperimentalSecurityFeaturesName[] =
+    R"*(Potentially annoying security features)*";
+
+const char kExperimentalSecurityFeaturesDescription[] =
+    R"*(Enables several security features that will likely break one or)*"
+    R"*(more pages that you visit on a daily basis. Strict mixed content)*"
+    R"*(checking, for example. And locking powerful features to secure)*"
+    R"*(contexts. This flag will probably annoy you.)*";
+
+const char kExperimentalWebPlatformFeaturesName[] =
+    R"*(Experimental Web Platform features)*";
+
+const char kExperimentalWebPlatformFeaturesDescription[] =
+    R"*(Enables experimental Web Platform features that are in)*"
+    R"*(development.)*";
+
+const char kExperimentalPointerEventName[] =
+    R"*(Pointer Events)*";
+
+const char kExperimentalPointerEventDescription[] =
+    R"*(Enables support for the Pointer Events API. This is intended only)*"
+    R"*(for testing by web developers.)*";
+
+const char kOriginTrialsName[] =
+    R"*(Origin Trials)*";
+
+const char kOriginTrialsDescription[] =
+    R"*(Enables origin trials for controlling access to feature/API)*"
+    R"*(experiments.)*";
+
+const char kBleAdvertisingInExtensionsName[] =
+    R"*(BLE Advertising in Chrome Apps)*";
+
+const char kBleAdvertisingInExtensionsDescription[] =
+    R"*(Enables BLE Advertising in Chrome Apps. BLE Advertising might)*"
+    R"*(interfere with regular use of Bluetooth Low Energy features.)*";
+
+const char kDevtoolsExperimentsName[] =
+    R"*(Developer Tools experiments)*";
+
+const char kDevtoolsExperimentsDescription[] =
+    R"*(Enables Developer Tools experiments. Use Settings panel in)*"
+    R"*(Developer Tools to toggle individual experiments.)*";
+
+const char kSilentDebuggerExtensionApiName[] =
+    R"*(Silent Debugging)*";
+
+const char kSilentDebuggerExtensionApiDescription[] =
+    R"*(Do not show the infobar when an extension attaches to a page via)*"
+    R"*(chrome.debugger API. This is required to debug extension)*"
+    R"*(background pages.)*";
+
+const char kShowTouchHudName[] =
+    R"*(Show HUD for touch points)*";
+
+const char kShowTouchHudDescription[] =
+    R"*(Enables a heads-up display at the top-left corner of the screen)*"
+    R"*(that lists information about the touch-points on the screen.)*";
+
+const char kPreferHtmlOverPluginsName[] =
+    R"*(Prefer HTML over Flash)*";
+
+const char kPreferHtmlOverPluginsDescription[] =
+    R"*(Prefer HTML content by hiding Flash from the list of plugins.)*";
+
+const char kAllowNaclSocketApiName[] =
+    R"*(NaCl Socket API.)*";
+
+const char kAllowNaclSocketApiDescription[] =
+    R"*(Allows applications to use NaCl Socket API. Use only to test NaCl)*"
+    R"*(plugins.)*";
+
+const char kRunAllFlashInAllowModeName[] =
+    R"*(Run all Flash content when Flash setting is set to "allow")*";
+
+const char kRunAllFlashInAllowModeDescription[] =
+    R"*(For sites that have been set to "allow" Flash content, run all)*"
+    R"*(content including any that has been deemed unimportant.)*";
+
+const char kPinchScaleName[] =
+    R"*(Pinch scale)*";
+
+const char kPinchScaleDescription[] =
+    R"*(Enables experimental support for scale using pinch.)*";
+
+const char kCredentialManagerApiName[] =
+    R"*(Experimental Credential Manager API)*";
+
+const char kCredentialManagerApiDescription[] =
+    R"*(Enables an experimental implementation of the Credential Manager)*"
+    R"*(API. Don't enable this unless you know what you're doing.)*";
+
+const char kReducedReferrerGranularityName[] =
+    R"*(Reduce default 'referer' header granularity.)*";
+
+const char kReducedReferrerGranularityDescription[] =
+    R"*(If a page hasn't set an explicit referrer policy, setting this)*"
+    R"*(flag will reduce the amount of information in the 'referer')*"
+    R"*(header for cross-origin requests.)*";
+
+#if defined(OS_CHROMEOS)
+
+const char kUseMashName[] =
+    R"*(Mojo UI Service (mus).)*";
+
+const char kUseMashDescription[] =
+    R"*(Enable mus, mash etc.)*";
+
+const char kAllowTouchpadThreeFingerClickName[] =
+    R"*(Touchpad three-finger-click)*";
+
+const char kAllowTouchpadThreeFingerClickDescription[] =
+    R"*(Enables touchpad three-finger-click as middle button.)*";
+
+const char kAshEnableUnifiedDesktopName[] =
+    R"*(Unified desktop mode)*";
+
+const char kAshEnableUnifiedDesktopDescription[] =
+    R"*(Enable unified desktop mode which allows a window to span)*"
+    R"*(multiple displays.)*";
+
+const char kBootAnimation[] =
+    R"*(Boot animation)*";
+
+const char kBootAnimationDescription[] =
+    R"*(Wallpaper boot animation (except for OOBE case).)*";
+
+#endif  // defined(OS_CHROMEOS)
+
+const char kAcceleratedVideoDecodeName[] =
+    R"*(Hardware-accelerated video decode)*";
+
+const char kAcceleratedVideoDecodeDescription[] =
+    R"*(Hardware-accelerated video decode where available.)*";
+
+const char kCloudImport[] =
+    R"*(Cloud Import)*";
+
+const char kCloudImportDescription[] =
+    R"*(Allows the cloud-import feature.)*";
+
+const char kRequestTabletSiteName[] =
+    R"*(Request tablet site option in the settings menu)*";
+
+const char kRequestTabletSiteDescription[] =
+    R"*(Allows the user to request tablet site. Web content is often)*"
+    R"*(optimized for tablet devices. When this option is selected the)*"
+    R"*(user agent string is changed to indicate a tablet device. Web)*"
+    R"*(content optimized for tablets is received there after for the)*"
+    R"*(current tab.)*";
+
+const char kDebugPackedAppName[] =
+    R"*(Debugging for packed apps)*";
+
+const char kDebugPackedAppDescription[] =
+    R"*(Enables debugging context menu options such as Inspect Element)*"
+    R"*(for packed applications.)*";
+
+const char kDropSyncCredentialName[] =
+    R"*(Drop sync credentials from password manager)*";
+
+const char kDropSyncCredentialDescription[] =
+    R"*(The password manager will not offer to save the credential used)*"
+    R"*(to sync.)*";
+
+const char kPasswordGenerationName[] =
+    R"*(Password generation)*";
+
+const char kPasswordGenerationDescription[] =
+    R"*(Allow the user to have Chrome generate passwords when it detects)*"
+    R"*(account creation pages.)*";
+
+const char kPasswordForceSavingName[] =
+    R"*(Force-saving of passwords)*";
+
+const char kPasswordForceSavingDescription[] =
+    R"*(Allow the user to manually enforce password saving instead of)*"
+    R"*(relying on password manager's heuristics.)*";
+
+const char kManualPasswordGenerationName[] =
+    R"*(Manual password generation.)*";
+
+const char kManualPasswordGenerationDescription[] =
+    R"*(Show a 'Generate Password' option on the context menu for all)*"
+    R"*(password fields.)*";
+
+const char kShowAutofillSignatures[] =
+    R"*(Show autofill signatures.)*";
+
+const char kShowAutofillSignaturesDescription[] =
+    R"*(Annotates web forms with Autofill signatures as HTML attributes.)*";
+
+const char kSuggestionsWithSubStringMatchName[] =
+    R"*(Substring matching for Autofill suggestions)*";
+
+const char kSuggestionsWithSubStringMatchDescription[] =
+    R"*(Match Autofill suggestions based on substrings (token prefixes))*"
+    R"*(rather than just prefixes.)*";
+
+const char kAffiliationBasedMatchingName[] =
+    R"*(Affiliation based matching in password manager)*";
+
+const char kAffiliationBasedMatchingDescription[] =
+    R"*(Allow credentials stored for Android applications to be filled)*"
+    R"*(into corresponding websites.)*";
+
+const char kProtectSyncCredentialName[] =
+    R"*(Autofill sync credential)*";
+
+const char kProtectSyncCredentialDescription[] =
+    R"*(How the password manager handles autofill for the sync)*"
+    R"*(credential.)*";
+
+const char kPasswordImportExportName[] =
+    R"*(Password import and export)*";
+
+const char kPasswordImportExportDescription[] =
+    R"*(Import and Export functionality in password settings.)*";
+
+const char kProtectSyncCredentialOnReauthName[] =
+    R"*(Autofill sync credential only for transactional reauth pages)*";
+
+const char kProtectSyncCredentialOnReauthDescription[] =
+    R"*(How the password manager handles autofill for the sync credential)*"
+    R"*(only for transactional reauth pages.)*";
+
+const char kIconNtpName[] =
+    R"*(Large icons on the New Tab page)*";
+
+const char kIconNtpDescription[] =
+    R"*(Enable the experimental New Tab page using large icons.)*";
+
+const char kPushApiBackgroundModeName[] =
+    R"*(Enable Push API background mode)*";
+
+const char kPushApiBackgroundModeDescription[] =
+    R"*(Enable background mode for the Push API. This allows Chrome to)*"
+    R"*(continue running after the last window is closed, and to launch)*"
+    R"*(at OS startup, if the Push API needs it.)*";
+
+const char kEnableNavigationTracing[] =
+    R"*(Enable navigation tracing)*";
+
+const char kEnableNavigationTracingDescription[] =
+    R"*(This is to be used in conjunction with the trace-upload-url flag.)*"
+    R"*(WARNING: When enabled, Chrome will record performance data for)*"
+    R"*(every navigation and upload it to the URL specified by the)*"
+    R"*(trace-upload-url flag. The trace may include personally)*"
+    R"*(identifiable information (PII) such as the titles and URLs of)*"
+    R"*(websites you visit.)*";
+
+const char kTraceUploadUrl[] =
+    R"*(Trace label for navigation tracing)*";
+
+const char kTraceUploadUrlDescription[] =
+    R"*(This is to be used in conjunction with the)*"
+    R"*(enable-navigation-tracing flag. Please select the label that best)*"
+    R"*(describes the recorded traces. This will choose the destination)*"
+    R"*(the traces are uploaded to. If you are not sure, select other. If)*"
+    R"*(left empty, no traces will be uploaded.)*";
+
+const char kDisableAudioForDesktopShare[] =
+    R"*(Disable Audio For Desktop Share)*";
+
+const char kDisableAudioForDesktopShareDescription[] =
+    R"*(With this flag on, desktop share picker window will not let the)*"
+    R"*(user choose whether to share audio.)*";
+
+const char kDisableTabForDesktopShare[] =
+    R"*(Disable Desktop Share with tab source)*";
+
+const char kDisableTabForDesktopShareDescription[] =
+    R"*(This flag controls whether users can choose a tab for desktop)*"
+    R"*(share.)*";
+
+const char kTraceUploadUrlChoiceOther[] =
+    R"*(Other)*";
+
+const char kTraceUploadUrlChoiceEmloading[] =
+    R"*(emloading)*";
+
+const char kTraceUploadUrlChoiceQa[] =
+    R"*(QA)*";
+
+const char kTraceUploadUrlChoiceTesting[] =
+    R"*(Testing)*";
+
+const char kSupervisedUserManagedBookmarksFolderName[] =
+    R"*(Managed bookmarks for supervised users)*";
+
+const char kSupervisedUserManagedBookmarksFolderDescription[] =
+    R"*(Enable the managed bookmarks folder for supervised users.)*";
+
+const char kSyncAppListName[] =
+    R"*(App Launcher sync)*";
+
+const char kSyncAppListDescription[] =
+    R"*(Enable App Launcher sync. This also enables Folders where)*"
+    R"*(available (non OSX).)*";
+
+const char kDriveSearchInChromeLauncher[] =
+    R"*(Drive Search in Chrome App Launcher)*";
+
+const char kDriveSearchInChromeLauncherDescription[] =
+    R"*(Files from Drive will show up when searching the Chrome App)*"
+    R"*(Launcher.)*";
+
+const char kV8CacheOptionsName[] =
+    R"*(V8 caching mode.)*";
+
+const char kV8CacheOptionsDescription[] =
+    R"*(Caching mode for the V8 JavaScript engine.)*";
+
+const char kV8CacheOptionsParse[] =
+    R"*(Cache V8 parser data.)*";
+
+const char kV8CacheOptionsCode[] =
+    R"*(Cache V8 compiler data.)*";
+
+const char kV8CacheStrategiesForCacheStorageName[] =
+    R"*(V8 caching strategy for CacheStorage.)*";
+
+const char kV8CacheStrategiesForCacheStorageDescription[] =
+    R"*(Caching strategy of scripts in CacheStorage for the V8 JavaScript)*"
+    R"*(engine.)*";
+
+const char kV8CacheStrategiesForCacheStorageNormal[] =
+    R"*(Normal)*";
+
+const char kV8CacheStrategiesForCacheStorageAggressive[] =
+    R"*(Aggressive)*";
+
+const char kSpeculativeLaunchServiceWorkerName[] =
+    R"*(Speculative launch of service workers.)*";
+
+const char kSpeculativeLaunchServiceWorkerDescription[] =
+    R"*(Speculatively launch service workers using touch and mouse)*"
+    R"*(events.)*";
+
+const char kMemoryCoordinatorName[] =
+    R"*(Memory coordinator)*";
+
+const char kMemoryCoordinatorDescription[] =
+    R"*(Enable memory coordinator instead of memory pressure listeners.)*";
+
+const char kServiceWorkerNavigationPreloadName[] =
+    R"*(Service worker navigation preload.)*";
+
+const char kServiceWorkerNavigationPreloadDescription[] =
+    R"*(Enable web pages to use the experimental service worker)*"
+    R"*(navigation preload API.)*";
+
+#if defined(OS_ANDROID)
+
+const char kUploadCrashReportsUsingJobSchedulerName[] =
+    R"*(Upload crash reports using JobScheduler API.)*";
+
+const char kUploadCrashReportsUsingJobSchedulerDescription[] =
+    R"*(Use the JobScheduler API to upload crash reports. This does not)*"
+    R"*(affect whether or not crash reports will be uploaded. Rather,)*"
+    R"*(*if* a crash report is going to be uploaded, this flag affects)*"
+    R"*(*how* it is uploaded.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Data Reduction Proxy
+
+const char kDataReductionProxyLoFiName[] =
+    R"*(Data Saver Lo-Fi mode)*";
+
+const char kDataReductionProxyLoFiDescription[] =
+    R"*(Forces Data Saver Lo-Fi mode to be always enabled, enabled only)*"
+    R"*(on cellular connections, or disabled. Data Saver must be enabled)*"
+    R"*(for Lo-Fi mode to be used.)*";
+
+const char kDataReductionProxyLoFiAlwaysOn[] =
+    R"*(Always on)*";
+
+const char kDataReductionProxyLoFiCellularOnly[] =
+    R"*(Cellular only)*";
+
+const char kDataReductionProxyLoFiDisabled[] =
+    R"*(Disable)*";
+
+const char kDataReductionProxyLoFiSlowConnectionsOnly[] =
+    R"*(Slow connections only)*";
+
+const char kEnableDataReductionProxyLitePageName[] =
+    R"*(Lite pages for Data Saver Lo-Fi mode)*";
+
+const char kEnableDataReductionProxyLitePageDescription[] =
+    R"*(Enable lite pages in Data Saver Lo-Fi mode. Previews of pages)*"
+    R"*(will be shown instead of image placeholders when Lo-Fi is on.)*"
+    R"*(Data Saver and Lo-Fi must be enabled for lite pages to be shown.)*";
+
+const char kDataReductionProxyCarrierTestName[] =
+    R"*(Enable a carrier-specific Data Reduction Proxy for testing.)*";
+
+const char kDataReductionProxyCarrierTestDescription[] =
+    R"*(Use a carrier-specific Data Reduction Proxy for testing.)*";
+
+const char kEnableDataReductionProxySavingsPromoName[] =
+    R"*(Data Saver 1 MB Savings Promo)*";
+
+const char kEnableDataReductionProxySavingsPromoDescription[] =
+    R"*(Enable a Data Saver promo for 1 MB of savings. If Data Saver has)*"
+    R"*(already saved 1 MB of data, then the promo will not be shown.)*"
+    R"*(Data Saver must be enabled for the promo to be shown.)*";
+
+const char kLcdTextName[] =
+    R"*(LCD text antialiasing)*";
+
+const char kLcdTextDescription[] =
+    R"*(If disabled, text is rendered with grayscale antialiasing instead)*"
+    R"*(of LCD (subpixel) when doing accelerated compositing.)*";
+
+const char kDistanceFieldTextName[] =
+    R"*(Distance field text)*";
+
+const char kDistanceFieldTextDescription[] =
+    R"*(Text is rendered with signed distance fields rather than bitmap)*"
+    R"*(alpha masks.)*";
+
+const char kZeroCopyName[] =
+    R"*(Zero-copy rasterizer)*";
+
+const char kZeroCopyDescription[] =
+    R"*(Raster threads write directly to GPU memory associated with)*"
+    R"*(tiles.)*";
+
+const char kHideInactiveStackedTabCloseButtonsName[] =
+    R"*(Hiding close buttons on inactive tabs when stacked)*";
+
+const char kHideInactiveStackedTabCloseButtonsDescription[] =
+    R"*(Hides the close buttons of inactive tabs when the tabstrip is in)*"
+    R"*(stacked mode.)*";
+
+const char kDefaultTileWidthName[] =
+    R"*(Default tile width)*";
+
+const char kDefaultTileWidthDescription[] =
+    R"*(Specify the default tile width.)*";
+
+const char kDefaultTileWidthShort[] =
+    R"*(128)*";
+
+const char kDefaultTileWidthTall[] =
+    R"*(256)*";
+
+const char kDefaultTileWidthGrande[] =
+    R"*(512)*";
+
+const char kDefaultTileWidthVenti[] =
+    R"*(1024)*";
+
+const char kDefaultTileHeightName[] =
+    R"*(Default tile height)*";
+
+const char kDefaultTileHeightDescription[] =
+    R"*(Specify the default tile height.)*";
+
+const char kDefaultTileHeightShort[] =
+    R"*(128)*";
+
+const char kDefaultTileHeightTall[] =
+    R"*(256)*";
+
+const char kDefaultTileHeightGrande[] =
+    R"*(512)*";
+
+const char kDefaultTileHeightVenti[] =
+    R"*(1024)*";
+
+const char kNumRasterThreadsName[] =
+    R"*(Number of raster threads)*";
+
+const char kNumRasterThreadsDescription[] =
+    R"*(Specify the number of raster threads.)*";
+
+const char kNumRasterThreadsOne[] =
+    R"*(1)*";
+
+const char kNumRasterThreadsTwo[] =
+    R"*(2)*";
+
+const char kNumRasterThreadsThree[] =
+    R"*(3)*";
+
+const char kNumRasterThreadsFour[] =
+    R"*(4)*";
+
+const char kResetAppListInstallStateName[] =
+    R"*(Reset the App Launcher install state on every restart.)*";
+
+const char kResetAppListInstallStateDescription[] =
+    R"*(Reset the App Launcher install state on every restart. While this)*"
+    R"*(flag is set, Chrome will forget the launcher has been installed)*"
+    R"*(each time it starts. This is used for testing the App Launcher)*"
+    R"*(install flow.)*";
+
+#if defined(OS_CHROMEOS)
+
+const char kFirstRunUiTransitionsName[] =
+    R"*(Animated transitions in the first-run tutorial)*";
+
+const char kFirstRunUiTransitionsDescription[] =
+    R"*(Transitions during first-run tutorial are animated.)*";
+
+#endif  // defined(OS_CHROMEOS)
+
+const char kNewBookmarkAppsName[] =
+    R"*(The new bookmark app system)*";
+
+const char kNewBookmarkAppsDescription[] =
+    R"*(Enables the new system for creating bookmark apps.)*";
+
+#if defined(OS_MACOSX)
+
+const char kHostedAppsInWindowsName[] =
+    R"*(Allow hosted apps to be opened in windows)*";
+
+const char kHostedAppsInWindowsDescription[] =
+    R"*(Allows hosted apps to be opened in windows instead of being)*"
+    R"*(limited to tabs.)*";
+
+const char kTabDetachingInFullscreenName[] =
+    R"*(Allow tab detaching in fullscreen)*";
+
+const char kTabDetachingInFullscreenDescription[] =
+    R"*(Allow tabs to detach from the tabstrip when in fullscreen mode on)*"
+    R"*(Mac.)*";
+
+const char kFullscreenToolbarRevealName[] =
+    R"*(Enables the toolbar in fullscreen to reveal itself.)*";
+
+const char kFullscreenToolbarRevealDescription[] =
+    R"*(Reveal the toolbar in fullscreen for a short period when the tab)*"
+    R"*(strip has changed.)*";
+
+const char kTabStripKeyboardFocusName[] =
+    R"*(Tab Strip Keyboard Focus)*";
+
+const char kTabStripKeyboardFocusDescription[] =
+    R"*(Enable keyboard focus for the tabs in the tab strip.)*";
+
+#endif  // defined(OS_MACOSX)
+
+const char kHostedAppShimCreationName[] =
+    R"*(Creation of app shims for hosted apps on Mac)*";
+
+const char kHostedAppShimCreationDescription[] =
+    R"*(Create app shims on Mac when creating a hosted app.)*";
+
+const char kHostedAppQuitNotificationName[] =
+    R"*(Quit notification for hosted apps)*";
+
+const char kHostedAppQuitNotificationDescription[] =
+    R"*(Display a notification when quitting Chrome if hosted apps are)*"
+    R"*(currently running.)*";
+
+#if defined(OS_ANDROID)
+
+const char kPullToRefreshEffectName[] =
+    R"*(The pull-to-refresh effect)*";
+
+const char kPullToRefreshEffectDescription[] =
+    R"*(Page reloads triggered by vertically overscrolling content.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_MACOSX)
+
+const char kTranslateNewUxName[] =
+    R"*(New Translate UX)*";
+
+const char kTranslateNewUxDescription[] =
+    R"*(Enable the new Translate bubble UX is offered instead of the)*"
+    R"*(infobar.)*";
+
+#endif  // defined(OS_MACOSX)
+
+const char kTranslate2016q2UiName[] =
+    R"*(Translate 2016Q2 UI)*";
+
+const char kTranslate2016q2UiDescription[] =
+    R"*(Improved triggering logic and look for Translate Bubble UI)*";
+
+const char kTranslateLanguageByUlpName[] =
+    R"*(Translate Language by ULP)*";
+
+const char kTranslateLanguageByUlpDescription[] =
+    R"*(Improved translate target language and triggering logic by)*"
+    R"*(considering information from User Language Profile (ULP).)*";
+
+const char kViewsRectBasedTargetingName[] =
+    R"*(Rect-based targeting in views)*";
+
+const char kViewsRectBasedTargetingDescription[] =
+    R"*(Rect-based targeting uses a heuristic to determine the most)*"
+    R"*(probable target of a gesture, where the touch region is)*"
+    R"*(represented by a rectangle.)*";
+
+const char kPermissionActionReportingName[] =
+    R"*(Permission Action Reporting)*";
+
+const char kPermissionActionReportingDescription[] =
+    R"*(Enables permission action reporting to Safe Browsing servers for)*"
+    R"*(opted in users.)*";
+
+const char kPermissionsBlacklistName[] =
+    R"*(Permissions Blacklist)*";
+
+const char kPermissionsBlacklistDescription[] =
+    R"*(Enables the Permissions Blacklist, which blocks permissions for)*"
+    R"*(blacklisted sites for Safe Browsing users.)*";
+
+const char kThreadedScrollingName[] =
+    R"*(Threaded scrolling)*";
+
+const char kThreadedScrollingDescription[] =
+    R"*(Threaded handling of scroll-related input events. Disabling this)*"
+    R"*(will force all such scroll events to be handled on the main)*"
+    R"*(thread. Note that this can dramatically hurt scrolling)*"
+    R"*(performance of most websites and is intended for testing purposes)*"
+    R"*(only.)*";
+
+const char kHarfbuzzRendertextName[] =
+    R"*(HarfBuzz for UI text)*";
+
+const char kHarfbuzzRendertextDescription[] =
+    R"*(Enable cross-platform HarfBuzz layout engine for UI text. Doesn't)*"
+    R"*(affect web content.)*";
+
+const char kEmbeddedExtensionOptionsName[] =
+    R"*(Embedded extension options)*";
+
+const char kEmbeddedExtensionOptionsDescription[] =
+    R"*(Display extension options as an embedded element in)*"
+    R"*(chrome://extensions rather than opening a new tab.)*";
+
+const char kTabAudioMutingName[] =
+    R"*(Tab audio muting UI control)*";
+
+const char kTabAudioMutingDescription[] =
+    R"*(When enabled, the audio indicators in the tab strip double as tab)*"
+    R"*(audio mute controls. This also adds commands in the tab context)*"
+    R"*(menu for quickly muting multiple selected tabs.)*";
+
+const char kEasyUnlockBluetoothLowEnergyDiscoveryName[] =
+    R"*(Smart Lock Bluetooth Low Energy Discovery)*";
+
+const char kEasyUnlockBluetoothLowEnergyDiscoveryDescription[] =
+    R"*(Enables a Smart Lock setting that allows Chromebook to discover)*"
+    R"*(phones over Bluetooth Low Energy in order to unlock the)*"
+    R"*(Chromebook when the phone is in its proximity.)*";
+
+const char kEasyUnlockProximityDetectionName[] =
+    R"*(Smart Lock proximity detection)*";
+
+const char kEasyUnlockProximityDetectionDescription[] =
+    R"*(Enables a Smart Lock setting that restricts unlocking to only)*"
+    R"*(work when your phone is very close to (roughly, within an arm's)*"
+    R"*(length of) the Chrome device.)*";
+
+const char kWifiCredentialSyncName[] =
+    R"*(WiFi credential sync)*";
+
+const char kWifiCredentialSyncDescription[] =
+    R"*(Enables synchronizing WiFi network settings across devices. When)*"
+    R"*(enabled, the WiFi credential datatype is registered with Chrome)*"
+    R"*(Sync, and WiFi credentials are synchronized subject to user)*"
+    R"*(preferences. (See also, chrome://settings/syncSetup.))*";
+
+const char kSyncSandboxName[] =
+    R"*(Use Chrome Sync sandbox)*";
+
+const char kSyncSandboxDescription[] =
+    R"*(Connects to the testing server for Chrome Sync.)*";
+
+const char kDatasaverPromptName[] =
+    R"*(Cellular Data Saver Prompt)*";
+
+const char kDatasaverPromptDescription[] =
+    R"*(Enables a prompt, which appears when a cellular network)*"
+    R"*(connection is detected, to take the user to the Data Saver)*"
+    R"*(extension page on Chrome Web Store.)*";
+
+const char kDatasaverPromptDemoMode[] =
+    R"*(Demo mode)*";
+
+const char kDisableUnifiedMediaPipelineDescription[] =
+    R"*(Disables the unified (Android and desktop) media pipeline on)*"
+    R"*(Android.)*";
+
+const char kTrySupportedChannelLayoutsName[] =
+    R"*(Causes audio output streams to check if channel layouts other)*"
+    R"*(than the default hardware layout are available.)*";
+
+const char kTrySupportedChannelLayoutsDescription[] =
+    R"*(Causes audio output streams to check if channel layouts other)*"
+    R"*(than the default hardware layout are available. Turning this on)*"
+    R"*(will allow the OS to do stereo to surround expansion if)*"
+    R"*(supported. May expose third party driver bugs, use with caution.)*";
+
+#if defined(OS_MACOSX)
+
+const char kAppInfoDialogName[] =
+    R"*(Toolkit-Views App Info Dialog.)*";
+
+const char kAppInfoDialogDescription[] =
+    R"*(Makes the Toolkit-Views based App Info dialog accessible from)*"
+    R"*(chrome://apps or chrome://extensions in place of the native)*"
+    R"*(extension permissions dialog, or the details link (which is a)*"
+    R"*(link to the Web Store).)*";
+
+const char kMacViewsNativeAppWindowsName[] =
+    R"*(Toolkit-Views App Windows.)*";
+
+const char kMacViewsNativeAppWindowsDescription[] =
+    R"*(Controls whether to use Toolkit-Views based Chrome App windows.)*";
+
+const char kMacViewsTaskManagerName[] =
+    R"*(Toolkit-Views Task Manager.)*";
+
+const char kMacViewsTaskManagerDescription[] =
+    R"*(Controls whether to use the Toolkit-Views based Task Manager.)*";
+
+const char kAppWindowCyclingName[] =
+    R"*(Custom Window Cycling for Chrome Apps.)*";
+
+const char kAppWindowCyclingDescription[] =
+    R"*(Changes the behavior of Cmd+` when a Chrome App becomes active.)*"
+    R"*(When enabled, Chrome Apps will not be cycled when Cmd+` is)*"
+    R"*(pressed from a browser window, and browser windows will not be)*"
+    R"*(cycled when a Chrome App is active.)*";
+
+#endif  // defined(OS_MACOSX)
+
+#if defined(OS_CHROMEOS)
+
+const char kAcceleratedMjpegDecodeName[] =
+    R"*(Hardware-accelerated mjpeg decode for captured frame)*";
+
+const char kAcceleratedMjpegDecodeDescription[] =
+    R"*(Enable hardware-accelerated mjpeg decode for captured frame where)*"
+    R"*(available.)*";
+
+#endif  // defined(OS_CHROMEOS)
+
+const char kSimplifiedFullscreenUiName[] =
+    R"*(Simplified full screen / mouse lock UI.)*";
+
+const char kSimplifiedFullscreenUiDescription[] =
+    R"*(A simplified new user experience when entering page-triggered)*"
+    R"*(full screen or mouse pointer lock states.)*";
+
+const char kExperimentalKeyboardLockUiName[] =
+    R"*(Experimental keyboard lock UI.)*";
+
+const char kExperimentalKeyboardLockUiDescription[] =
+    R"*(An experimental full screen with keyboard lock mode requiring)*"
+    R"*(users to hold Esc to exit.)*";
+
+#if defined(OS_ANDROID)
+
+const char kProgressBarAnimationName[] =
+    R"*(Android phone page loading progress bar animation)*";
+
+const char kProgressBarAnimationDescription[] =
+    R"*(Configures Android phone page loading progress bar animation.)*";
+
+const char kProgressBarAnimationLinear[] =
+    R"*(Linear)*";
+
+const char kProgressBarAnimationSmooth[] =
+    R"*(Smooth)*";
+
+const char kProgressBarAnimationSmoothIndeterminate[] =
+    R"*(Smooth indeterminate)*";
+
+const char kProgressBarAnimationFastStart[] =
+    R"*(Fast start)*";
+
+const char kProgressBarCompletionName[] =
+    R"*(Android phone page load progress bar completion time.)*";
+
+const char kProgressBarCompletionDescription[] =
+    R"*(Configures Android phone page loading progress bar completion)*"
+    R"*(time.)*";
+
+const char kProgressBarCompletionLoadEvent[] =
+    R"*(Top loading frame's onload event ("everything" is done in the)*"
+    R"*(page, historical behavior).)*";
+
+const char kProgressBarCompletionResourcesBeforeDcl[] =
+    R"*(Main frame's domContentLoaded and all resources loads started)*"
+    R"*(before domContentLoaded (iframes ignored).)*";
+
+const char kProgressBarCompletionDomContentLoaded[] =
+    R"*(Main frame's domContentLoaded (iframes ignored).)*";
+
+const char kProgressBarCompletionResourcesBeforeDclAndSameOriginIframes[] =
+    R"*(domContentLoaded and all resources loads started before)*"
+    R"*(domContentLoaded (main frame and same origin iframes).)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kDisallowDocWrittenScriptsUiName[] =
+    R"*(Block scripts loaded via document.write)*";
+
+const char kDisallowDocWrittenScriptsUiDescription[] =
+    R"*(Disallows fetches for third-party parser-blocking scripts)*"
+    R"*(inserted into the main frame via document.write.)*";
+
+#if defined(OS_WIN)
+
+const char kEnableAppcontainerName[] =
+    R"*(Enable AppContainer Lockdown.)*";
+
+const char kEnableAppcontainerDescription[] =
+    R"*(Enables the use of an AppContainer on sandboxed processes to)*"
+    R"*(improve security.)*";
+
+#endif  // defined(OS_WIN)
+
+#if defined(TOOLKIT_VIEWS) || defined(OS_ANDROID)
+
+const char kAutofillCreditCardUploadName[] =
+    R"*(Enable offering upload of Autofilled credit cards)*";
+
+const char kAutofillCreditCardUploadDescription[] =
+    R"*(Enables a new option to upload credit cards to Google Payments)*"
+    R"*(for sync to all Chrome devices.)*";
+
+#endif  // defined(TOOLKIT_VIEWS) || defined(OS_ANDROID)
+
+const char kForceUiDirectionName[] =
+    R"*(Force UI direction)*";
+
+const char kForceUiDirectionDescription[] =
+    R"*(Explicitly force the UI to left-to-right (LTR) or right-to-left)*"
+    R"*((RTL) mode, overriding the default direction of the UI language.)*";
+
+const char kForceUiDirectionLtr[] =
+    R"*(Left-to-right)*";
+
+const char kForceUiDirectionRtl[] =
+    R"*(Right-to-left)*";
+
+#if defined(OS_WIN) || defined(OS_LINUX)
+
+const char kEnableInputImeApiName[] =
+    R"*(Enable Input IME API)*";
+
+const char kEnableInputImeApiDescription[] =
+    R"*(Enable the use of chrome.input.ime API.)*";
+
+#endif  // defined(OS_WIN) || defined(OS_LINUX)
+
+const char kEnableGroupedHistoryName[] =
+    R"*(Group history by domain)*";
+
+const char kEnableGroupedHistoryDescription[] =
+    R"*(Group history by website domain (i.e. google.com) on)*"
+    R"*(chrome://history.)*";
+
+const char kSecurityChipDefault[] =
+    R"*(Default)*";
+
+const char kSecurityChipShowNonsecureOnly[] =
+    R"*(Show non-secure only)*";
+
+const char kSecurityChipShowAll[] =
+    R"*(Show all)*";
+
+const char kSecurityChipAnimationDefault[] =
+    R"*(Default)*";
+
+const char kSecurityChipAnimationNone[] =
+    R"*(No animation)*";
+
+const char kSecurityChipAnimationNonsecureOnly[] =
+    R"*(Animate non-secure only)*";
+
+const char kSecurityChipAnimationAll[] =
+    R"*(Animate all)*";
+
+const char kSaveasMenuLabelExperimentName[] =
+    R"*(Switch 'Save as' menu labels to 'Download')*";
+
+const char kSaveasMenuLabelExperimentDescription[] =
+    R"*(Enables an experiment to switch menu labels that use 'Save as...')*"
+    R"*(to 'Download'.)*";
+
+const char kEnableEnumeratingAudioDevicesName[] =
+    R"*(Experimentally enable enumerating audio devices.)*";
+
+const char kEnableEnumeratingAudioDevicesDescription[] =
+    R"*(Experimentally enable the use of enumerating audio devices.)*";
+
+const char kNewUsbBackendName[] =
+    R"*(Enable new USB backend)*";
+
+const char kNewUsbBackendDescription[] =
+    R"*(Enables the new experimental USB backend for Windows.)*";
+
+const char kNewOmniboxAnswerTypesName[] =
+    R"*(New omnibox answers in suggest types)*";
+
+const char kNewOmniboxAnswerTypesDescription[] =
+    R"*(Enables new types of answers in the omnibox suggest drop-down:)*"
+    R"*(currency conversions, dictionary definitions, sports scores,)*"
+    R"*(translations, and when is.)*";
+
+const char kEnableZeroSuggestRedirectToChromeName[] =
+    R"*(Experimental contextual omnibox suggestion)*";
+
+const char kEnableZeroSuggestRedirectToChromeDescription[] =
+    R"*(Change omnibox contextual suggestions to an experimental source.)*"
+    R"*(Note that this is not an on/off switch for contextual omnibox and)*"
+    R"*(it only applies to suggestions provided before the user starts)*"
+    R"*(typing a URL or a search query (i.e. zero suggest).)*";
+
+const char kFillOnAccountSelectName[] =
+    R"*(Fill passwords on account selection)*";
+
+const char kFillOnAccountSelectDescription[] =
+    R"*(Filling of passwords when an account is explicitly selected by)*"
+    R"*(the user rather than autofilling credentials on page load.)*";
+
+const char kEnableClearBrowsingDataCountersName[] =
+    R"*(Enable Clear browsing data counters.)*";
+
+const char kEnableClearBrowsingDataCountersDescription[] =
+    R"*(Shows data volume counters in the Clear browsing data dialog.)*";
+
+#if defined(OS_ANDROID)
+
+const char kTabsInCbdName[] =
+    R"*(Enable tabs for the Clear Browsing Data dialog.)*";
+
+const char kTabsInCbdDescription[] =
+    R"*(Enables a basic and an advanced tab for the Clear Browsing Data)*"
+    R"*(dialog.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kNotificationsNativeFlag[] =
+    R"*(Enable native notifications.)*";
+
+const char kNotificationsNativeFlagDescription[] =
+    R"*(Enable support for using the native notification toasts and)*"
+    R"*(notification center on platforms where these are available.)*";
+
+#if defined(OS_ANDROID)
+
+const char kEnableAndroidSpellcheckerDescription[] =
+    R"*(Enables use of the Android spellchecker.)*";
+
+const char kEnableAndroidSpellcheckerName[] =
+    R"*(Enable spell checking)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kEnableWebNotificationCustomLayoutsName[] =
+    R"*(Enable custom layouts for Web Notifications.)*";
+
+const char kEnableWebNotificationCustomLayoutsDescription[] =
+    R"*(Enable custom layouts for Web Notifications. They will have)*"
+    R"*(subtle layout improvements that are otherwise not possible.)*";
+
+const char kAccountConsistencyName[] =
+    R"*(Identity consistency between browser and cookie jar)*";
+
+const char kAccountConsistencyDescription[] =
+    R"*(When enabled, the browser manages signing in and out of Google)*"
+    R"*(accounts.)*";
+
+const char kEnablePasswordSeparatedSigninFlowName[] =
+    R"*(Enable new gaia password-separated sign in flow)*";
+
+const char kEnablePasswordSeparatedSigninFlowDescription[] =
+    R"*(When enabled, signing in to the browser will use a new gaia)*"
+    R"*(password-separated sign in flow.)*";
+
+const char kGoogleProfileInfoName[] =
+    R"*(Google profile name and icon)*";
+
+const char kGoogleProfileInfoDescription[] =
+    R"*(Enables using Google information to populate the profile name and)*"
+    R"*(icon in the avatar menu.)*";
+
+const char kOfferStoreUnmaskedWalletCards[] =
+    R"*(Google Payments card saving checkbox)*";
+
+const char kOfferStoreUnmaskedWalletCardsDescription[] =
+    R"*(Show the checkbox to offer local saving of a credit card)*"
+    R"*(downloaded from the server.)*";
+
+const char kOfflineAutoReloadName[] =
+    R"*(Offline Auto-Reload Mode)*";
+
+const char kOfflineAutoReloadDescription[] =
+    R"*(Pages that fail to load while the browser is offline will be)*"
+    R"*(auto-reloaded when the browser is online again.)*";
+
+const char kOfflineAutoReloadVisibleOnlyName[] =
+    R"*(Only Auto-Reload Visible Tabs)*";
+
+const char kOfflineAutoReloadVisibleOnlyDescription[] =
+    R"*(Pages that fail to load while the browser is offline will only be)*"
+    R"*(auto-reloaded if their tab is visible.)*";
+
+const char kShowSavedCopyName[] =
+    R"*(Show Saved Copy Button)*";
+
+const char kShowSavedCopyDescription[] =
+    R"*(When a page fails to load, if a stale copy of the page exists in)*"
+    R"*(the browser cache, a button will be presented to allow the user)*"
+    R"*(to load that stale copy. The primary enabling choice puts the)*"
+    R"*(button in the most salient position on the error page; the)*"
+    R"*(secondary enabling choice puts it secondary to the reload)*"
+    R"*(button.)*";
+
+const char kEnableShowSavedCopyPrimary[] =
+    R"*(Enable: Primary)*";
+
+const char kEnableShowSavedCopySecondary[] =
+    R"*(Enable: Secondary)*";
+
+const char kDisableShowSavedCopy[] =
+    R"*(Disable)*";
+
+#if defined(OS_CHROMEOS)
+
+const char kSmartVirtualKeyboardName[] =
+    R"*(Smart Deployment of the Virtual Keyboard)*";
+
+const char kSmartVirtualKeyboardDescription[] =
+    R"*(Enable/Disable smart deployment of the virtual keyboard.)*";
+
+const char kVirtualKeyboardName[] =
+    R"*(Virtual Keyboard)*";
+
+const char kVirtualKeyboardDescription[] =
+    R"*(Enable virtual keyboard support.)*";
+
+const char kVirtualKeyboardOverscrollName[] =
+    R"*(Virtual Keyboard Overscroll)*";
+
+const char kVirtualKeyboardOverscrollDescription[] =
+    R"*(Enables virtual keyboard overscroll support.)*";
+
+const char kInputViewName[] =
+    R"*(Input views)*";
+
+const char kInputViewDescription[] =
+    R"*(Enable IME extensions to supply custom views for user input such)*"
+    R"*(as virtual keyboards.)*";
+
+const char kNewKoreanImeName[] =
+    R"*(New Korean IME)*";
+
+const char kNewKoreanImeDescription[] =
+    R"*(New Korean IME, which is based on Google Input Tools' HMM)*"
+    R"*(engine.)*";
+
+const char kPhysicalKeyboardAutocorrectName[] =
+    R"*(Physical keyboard autocorrect)*";
+
+const char kPhysicalKeyboardAutocorrectDescription[] =
+    R"*(Enable physical keyboard autocorrect for US keyboard, which can)*"
+    R"*(provide suggestions as typing on physical keyboard.)*";
+
+const char kVoiceInputName[] =
+    R"*(Voice input on virtual keyboard)*";
+
+const char kVoiceInputDescription[] =
+    R"*(Enables voice input on virtual keyboard.)*";
+
+const char kExperimentalInputViewFeaturesName[] =
+    R"*(Experimental input view features)*";
+
+const char kExperimentalInputViewFeaturesDescription[] =
+    R"*(Enable experimental features for IME input views.)*";
+
+const char kFloatingVirtualKeyboardName[] =
+    R"*(Floating virtual keyboard.)*";
+
+const char kFloatingVirtualKeyboardDescription[] =
+    R"*(Enable/Disable floating virtual keyboard.)*";
+
+const char kGestureTypingName[] =
+    R"*(Gesture typing for the virtual keyboard.)*";
+
+const char kGestureTypingDescription[] =
+    R"*(Enable/Disable gesture typing option in the settings page for the)*"
+    R"*(virtual keyboard.)*";
+
+const char kGestureEditingName[] =
+    R"*(Gesture editing for the virtual keyboard.)*";
+
+const char kGestureEditingDescription[] =
+    R"*(Enable/Disable gesture editing option in the settings page for)*"
+    R"*(the virtual keyboard.)*";
+
+const char kCaptivePortalBypassProxyName[] =
+    R"*(Bypass proxy for Captive Portal Authorization)*";
+
+const char kCaptivePortalBypassProxyDescription[] =
+    R"*(If proxy is configured, it usually prevents from authorization on)*"
+    R"*(different captive portals. This enables opening captive portal)*"
+    R"*(authorization dialog in a separate window, which ignores proxy)*"
+    R"*(settings.)*";
+
+const char kTouchscreenCalibrationName[] =
+    R"*(Enable/disable touchscreen calibration option in material design)*"
+    R"*(settings)*";
+
+const char kTouchscreenCalibrationDescription[] =
+    R"*(If enabled, the user can calibrate the touch screen displays in)*"
+    R"*(chrome://md-settings/display.)*";
+
+#endif  // defined(OS_CHROMEOS)
+
+//  Strings for controlling credit card assist feature in about:flags.
+
+const char kCreditCardAssistName[] =
+    R"*(Credit Card Assisted Filling)*";
+
+const char kCreditCardAssistDescription[] =
+    R"*(Enable assisted credit card filling on certain sites.)*";
+
+//  Strings for controlling credit card scanning feature in about:flags.
+
+//  Simple Cache Backend experiment.
+
+const char kSimpleCacheBackendName[] =
+    R"*(Simple Cache for HTTP)*";
+
+const char kSimpleCacheBackendDescription[] =
+    R"*(The Simple Cache for HTTP is a new cache. It relies on the)*"
+    R"*(filesystem for disk space allocation.)*";
+
+//  Spelling feedback field trial.
+
+const char kSpellingFeedbackFieldTrialName[] =
+    R"*(Spelling Feedback Field Trial)*";
+
+const char kSpellingFeedbackFieldTrialDescription[] =
+    R"*(Enable the field trial for sending user feedback to spelling)*"
+    R"*(service.)*";
+
+//  Web MIDI API.
+
+const char kWebMidiName[] =
+    R"*(Web MIDI API)*";
+
+const char kWebMidiDescription[] =
+    R"*(Enable Web MIDI API experimental support.)*";
+
+//  Site per process mode
+
+const char kSitePerProcessName[] =
+    R"*(Out of process iframes)*";
+
+const char kSitePerProcessDescription[] =
+    R"*(Highly experimental support for rendering cross-site iframes in)*"
+    R"*(separate processes. In this mode, documents will share a renderer)*"
+    R"*(process only if they are from the same web site.)*";
+
+//  Top document isolation mode
+
+const char kTopDocumentIsolationName[] =
+    R"*(Top document isolation)*";
+
+const char kTopDocumentIsolationDescription[] =
+    R"*(Highly experimental performance mode where cross-site iframes are)*"
+    R"*(kept in a separate process from the top document. In this mode,)*"
+    R"*(iframes from different third-party sites will be allowed to share)*"
+    R"*(a process.)*";
+
+//  Cross process guest frames isolation mode
+
+const char kCrossProcessGuestViewIsolationName[] =
+    R"*(Cross process frames for guests)*";
+
+const char kCrossProcessGuestViewIsolationDescription[] =
+    R"*(Highly experimental where guests such as <webview> are)*"
+    R"*(implemented on the out-of-process iframe infrastructure.)*";
+
+//  Task Scheduler
+
+const char kBrowserTaskSchedulerName[] =
+    R"*(Task Scheduler)*";
+
+const char kBrowserTaskSchedulerDescription[] =
+    R"*(Enables redirection of some task posting APIs to the task)*"
+    R"*(scheduler.)*";
+
+//  Arc authorization
+
+#if defined(OS_CHROMEOS)
+
+const char kArcUseAuthEndpointName[] =
+    R"*(Android apps authorization point)*";
+
+const char kArcUseAuthEndpointDescription[] =
+    R"*(Enable Android apps authorization point to automatic sign-in in)*"
+    R"*(OptIn flow.)*";
+
+#endif  // defined(OS_CHROMEOS)
+
+//  Autofill experiment flags
+
+const char kSingleClickAutofillName[] =
+    R"*(Single-click autofill)*";
+
+const char kSingleClickAutofillDescription[] =
+    R"*(Make autofill suggestions on initial mouse click on a form)*"
+    R"*(element.)*";
+
+#if defined(OS_ANDROID)
+
+const char kAutofillAccessoryViewName[] =
+    R"*(Autofill suggestions as keyboard accessory view)*";
+
+const char kAutofillAccessoryViewDescription[] =
+    R"*(Shows Autofill suggestions on top of the keyboard rather than in)*"
+    R"*(a dropdown.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Reader mode experiment flags
+
+#if defined(OS_ANDROID)
+
+const char kReaderModeHeuristicsName[] =
+    R"*(Reader Mode triggering)*";
+
+const char kReaderModeHeuristicsDescription[] =
+    R"*(Determines what pages the Reader Mode button is shown on.)*";
+
+const char kReaderModeHeuristicsMarkup[] =
+    R"*(With article structured markup)*";
+
+const char kReaderModeHeuristicsAdaboost[] =
+    R"*(Appears to be an article)*";
+
+const char kReaderModeHeuristicsAlwaysOff[] =
+    R"*(Never)*";
+
+const char kReaderModeHeuristicsAlwaysOn[] =
+    R"*(Always)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Chrome home flags
+
+#if defined(OS_ANDROID)
+
+const char kChromeHomeName[] =
+    R"*(Chrome Home)*";
+
+const char kChromeHomeDescription[] =
+    R"*(Enables Chrome Home on Android.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Settings window flags
+
+const char kSettingsWindowName[] =
+    R"*(Show settings in a window)*";
+
+const char kSettingsWindowDescription[] =
+    R"*(Settings will be shown in a dedicated window instead of as a)*"
+    R"*(browser tab.)*";
+
+//  Mixed content issue workaround flags
+
+#if defined(OS_ANDROID)
+
+//  Flag strings for seccomp-bpf sandbox flag.
+
+const char kSeccompFilterSandboxAndroidName[] =
+    R"*(Seccomp-bpf renderer sandbox)*";
+
+const char kSeccompFilterSandboxAndroidDescription[] =
+    R"*(Renderers will have a second-layer sandbox provided by)*"
+    R"*(seccomp-bpf. This requires kernel features only available on)*"
+    R"*(select Android versions.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Extension Content Verification
+
+const char kExtensionContentVerificationName[] =
+    R"*(Extension Content Verification)*";
+
+const char kExtensionContentVerificationDescription[] =
+    R"*(This flag can be used to turn on verification that the contents)*"
+    R"*(of the files on disk for extensions from the webstore match what)*"
+    R"*(they're expected to be. This can be used to turn on this feature)*"
+    R"*(if it would not otherwise have been turned on, but cannot be used)*"
+    R"*(to turn it off (because this setting can be tampered with by)*"
+    R"*(malware).)*";
+
+const char kExtensionContentVerificationBootstrap[] =
+    R"*(Bootstrap (get expected hashes, but do not enforce them))*";
+
+const char kExtensionContentVerificationEnforce[] =
+    R"*(Enforce (try to get hashes, and enforce them if successful))*";
+
+const char kExtensionContentVerificationEnforceStrict[] =
+    R"*(Enforce strict (hard fail if we can't get hashes))*";
+
+//  Built-in hotword detection display strings
+
+const char kExperimentalHotwordHardwareName[] =
+    R"*(Simulated hardware 'Ok Google' features)*";
+
+const char kExperimentalHotwordHardwareDescription[] =
+    R"*(Enables an experimental version of 'Ok Google' hotword detection)*"
+    R"*(features that have a hardware dependency.)*";
+
+//  Message center strings
+
+const char kMessageCenterAlwaysScrollUpUponRemovalName[] =
+    R"*(Experiments that message center always scroll up upon)*"
+    R"*(notification removal)*";
+
+const char kMessageCenterAlwaysScrollUpUponRemovalDescription[] =
+    R"*(Enables experiment that message center always scroll up when a)*"
+    R"*(notification is removed.)*";
+
+const char kCastStreamingHwEncodingName[] =
+    R"*(Cast Streaming hardware video encoding)*";
+
+const char kCastStreamingHwEncodingDescription[] =
+    R"*(This option enables support in Cast Streaming for encoding video)*"
+    R"*(streams using platform hardware.)*";
+
+const char kAllowInsecureLocalhost[] =
+    R"*(Allow invalid certificates for resources loaded from localhost.)*";
+
+const char kAllowInsecureLocalhostDescription[] =
+    R"*(Allows requests to localhost over HTTPS even when an invalid)*"
+    R"*(certificate is presented.)*";
+
+#if defined(OS_WIN) || defined(OS_MACOSX)
+
+//  Tab discarding
+
+const char kAutomaticTabDiscardingName[] =
+    R"*(Automatic tab discarding)*";
+
+const char kAutomaticTabDiscardingDescription[] =
+    R"*(If enabled, tabs get automatically discarded from memory when the)*"
+    R"*(system memory is low. Discarded tabs are still visible on the tab)*"
+    R"*(strip and get reloaded when clicked on. Info about discarded tabs)*"
+    R"*(can be found at chrome://discards.)*";
+
+#endif  // defined(OS_WIN) || defined(OS_MACOSX)
+
+#if defined(OS_ANDROID)
+
+const char kOfflineBookmarksName[] =
+    R"*(Enable offline bookmarks)*";
+
+const char kOfflineBookmarksDescription[] =
+    R"*(Enable saving bookmarked pages for offline viewing.)*";
+
+const char kNtpOfflinePagesName[] =
+    R"*(Enable NTP offline pages)*";
+
+const char kNtpOfflinePagesDescription[] =
+    R"*(Enables badging of offline pages on the New Tab page. Only)*"
+    R"*(relevant if offline pages are enabled.)*";
+
+const char kOfflinePagesAsyncDownloadName[] =
+    R"*(Enables showing "DOWNLOAD PAGE LATER" button in error pages.)*";
+
+const char kOfflinePagesAsyncDownloadDescription[] =
+    R"*(Enables showing "DOWNLOAD PAGE LATER" button in error pages such)*"
+    R"*(that the user can click on it to download the page later.)*";
+
+const char kOfflinePagesSvelteConcurrentLoadingName[] =
+    R"*(Enables concurrent background loading on svelte.)*";
+
+const char kOfflinePagesSvelteConcurrentLoadingDescription[] =
+    R"*(Enables concurrent background loading (or downloading) of pages)*"
+    R"*(on Android svelte (512MB RAM) devices. Otherwise, background)*"
+    R"*(loading will happen when the svelte device is idle.)*";
+
+const char kOfflinePagesPrefetchingName[] =
+    R"*(Enables suggested offline pages to be prefetched.)*";
+
+const char kOfflinePagesPrefetchingDescription[] =
+    R"*(Enables suggested offline pages to be prefetched, so useful)*"
+    R"*(content is available while offline.)*";
+
+const char kOfflinePagesSharingName[] =
+    R"*(Enables offline pages to be shared.)*";
+
+const char kOfflinePagesSharingDescription[] =
+    R"*(Enables the saved offline pages to be shared via other)*"
+    R"*(applications.)*";
+
+const char kBackgroundLoaderForDownloadsName[] =
+    R"*(Enables background downloading of pages.)*";
+
+const char kBackgroundLoaderForDownloadsDescription[] =
+    R"*(Enables downloading pages in the background in case page is not)*"
+    R"*(yet loaded in current tab.)*";
+
+const char kNewBackgroundLoaderName[] =
+    R"*(Use background loader instead of prerenderer to load pages.)*";
+
+const char kNewBackgroundLoaderDescription[] =
+    R"*(Use background loader instead of prerenderer to asynchronously)*"
+    R"*(download pages.)*";
+
+const char kNtpPopularSitesName[] =
+    R"*(Show popular sites on the New Tab page)*";
+
+const char kNtpPopularSitesDescription[] =
+    R"*(Pre-populate the New Tab page with popular sites.)*";
+
+const char kNtpSwitchToExistingTabName[] =
+    R"*(Switch to an existing tab for New Tab Page suggestions.)*";
+
+const char kNtpSwitchToExistingTabDescription[] =
+    R"*(When opening a suggested webpage from the New Tab Page, if a tab)*"
+    R"*(is already open for the suggestion, switch to that one instead of)*"
+    R"*(loading the suggestion in the new tab.)*";
+
+const char kNtpSwitchToExistingTabMatchUrl[] =
+    R"*(Match by URL)*";
+
+const char kNtpSwitchToExistingTabMatchHost[] =
+    R"*(Match by Hostname)*";
+
+const char kUseAndroidMidiApiName[] =
+    R"*(Use Android Midi API)*";
+
+const char kUseAndroidMidiApiDescription[] =
+    R"*(Use Android Midi API for WebMIDI (effective only with Android M+)*"
+    R"*(devices).)*";
+
+const char kWebPaymentsModifiersName[] =
+    R"*(Enable web payment modifiers)*";
+
+const char kWebPaymentsModifiersDescription[] =
+    R"*(If the website provides modifiers in the payment request, show)*"
+    R"*(the custom total for each payment instrument, update the shopping)*"
+    R"*(cart when instruments are switched, and send modified payment)*"
+    R"*(method specific data to the payment app.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_WIN)
+
+//  Exporting tracing events to ETW
+
+const char kTraceExportEventsToEtwName[] =
+    R"*(Enable exporting of tracing events to ETW.)*";
+
+const char kTraceExportEventsToEtwDesription[] =
+    R"*(If enabled, trace events will be exported to the Event Tracing)*"
+    R"*(for Windows (ETW) and can then be captured by tools such as)*"
+    R"*(UIForETW or Xperf.)*";
+
+const char kMergeKeyCharEventsName[] =
+    R"*(Enable or disable merging merging the key event (WM_KEY*) with)*"
+    R"*(char event (WM_CHAR).)*";
+
+const char kMergeKeyCharEventsDescription[] =
+    R"*(If disabled, Chrome will handle WM_KEY* and WM_CHAR separatedly.)*";
+
+const char kUseWinrtMidiApiName[] =
+    R"*(Use Windows Runtime MIDI API)*";
+
+const char kUseWinrtMidiApiDescription[] =
+    R"*(Use Windows Runtime MIDI API for WebMIDI (effective only on)*"
+    R"*(Windows 10 or later).)*";
+
+#endif  // defined(OS_WIN)
+
+#if defined(OS_ANDROID)
+
+//  Data Use
+
+//  Update Menu Item Flags
+
+const char kUpdateMenuItemName[] =
+    R"*(Force show update menu item)*";
+
+const char kUpdateMenuItemDescription[] =
+    R"*(When enabled, an "Update Chrome" item will be shown in the app)*"
+    R"*(menu.)*";
+
+const char kUpdateMenuItemSummaryName[] =
+    R"*(Update menu item summary)*";
+
+const char kUpdateMenuItemSummaryDescription[] =
+    R"*(When this flag and the force show update menu item flag are)*"
+    R"*(enabled, a summary will be displayed below the update menu item.)*";
+
+const char kUpdateMenuItemNoSummary[] =
+    R"*(No summary)*";
+
+const char kUpdateMenuItemDefaultSummary[] =
+    R"*(Default summary)*";
+
+const char kUpdateMenuItemNewFeaturesSummary[] =
+    R"*(New features summary)*";
+
+const char kUpdateMenuItemCustomSummary[] =
+    R"*(Custom summary)*";
+
+const char kUpdateMenuBadgeName[] =
+    R"*(Force show update menu badge)*";
+
+const char kUpdateMenuBadgeDescription[] =
+    R"*(When enabled, an update badge will be shown on the app menu)*"
+    R"*(button.)*";
+
+const char kSetMarketUrlForTestingName[] =
+    R"*(Set market URL for testing)*";
+
+const char kSetMarketUrlForTestingDescription[] =
+    R"*(When enabled, sets the market URL for use in testing the update)*"
+    R"*(menu item.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_ANDROID)
+
+const char kHerbPrototypeChoicesName[] =
+    R"*(Switch preferred flavor of Herb)*";
+
+const char kHerbPrototypeChoicesDescription[] =
+    R"*(Switching this option changes which tab management prototype is)*"
+    R"*(being tested.)*";
+
+const char kHerbPrototypeFlavorElderberry[] =
+    R"*(ELDERBERRY: All View Intents in CCT v2)*";
+
+const char kEnableSpecialLocaleName[] =
+    R"*(Enable custom logic for special locales.)*";
+
+const char kEnableSpecialLocaleDescription[] =
+    R"*(Enable custom logic for special locales. In this mode, Chrome)*"
+    R"*(might behave differently in some locales.)*";
+
+//  WebApks
+
+const char kEnableWebapk[] =
+    R"*(Enable improved add to Home screen)*";
+
+const char kEnableWebapkDescription[] =
+    R"*(Packages "Progressive Web Apps" so that they can integrate more)*"
+    R"*(deeply with Android. A Chrome server is used to package sites. In)*"
+    R"*(Chrome Canary and Chrome Dev, this requires “Untrusted)*"
+    R"*(sources” to be enabled in Android security settings.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kEnableBrotliName[] =
+    R"*(Brotli Content-Encoding.)*";
+
+const char kEnableBrotliDescription[] =
+    R"*(Enable Brotli Content-Encoding support.)*";
+
+const char kEnableWebfontsInterventionName[] =
+    R"*(New version of User Agent Intervention for WebFonts loading.)*";
+
+const char kEnableWebfontsInterventionDescription[] =
+    R"*(Enable New version of User Agent Intervention for WebFonts)*"
+    R"*(loading.)*";
+
+const char kEnableWebfontsInterventionV2ChoiceDefault[] =
+    R"*(Default)*";
+
+const char kEnableWebfontsInterventionV2ChoiceEnabledWith2g[] =
+    R"*(Enabled: 2G)*";
+
+const char kEnableWebfontsInterventionV2ChoiceEnabledWith3g[] =
+    R"*(Enabled: 3G)*";
+
+const char kEnableWebfontsInterventionV2ChoiceEnabledWithSlow2g[] =
+    R"*(Enabled: Slow 2G)*";
+
+const char kEnableWebfontsInterventionV2ChoiceDisabled[] =
+    R"*(Disabled)*";
+
+const char kEnableWebfontsInterventionTriggerName[] =
+    R"*(Trigger User Agent Intervention for WebFonts loading always.)*";
+
+const char kEnableWebfontsInterventionTriggerDescription[] =
+    R"*(Enable to trigger User Agent Intervention for WebFonts loading)*"
+    R"*(always. This flag affects only when the intervention is enabled.)*";
+
+const char kEnableScrollAnchoringName[] =
+    R"*(Scroll Anchoring)*";
+
+const char kEnableScrollAnchoringDescription[] =
+    R"*(Adjusts scroll position to prevent visible jumps when offscreen)*"
+    R"*(content changes.)*";
+
+#if defined(OS_CHROMEOS)
+
+const char kEnableNativeCupsName[] =
+    R"*(Native CUPS)*";
+
+const char kEnableNativeCupsDescription[] =
+    R"*(Enables the use of the native CUPS printing backend.)*";
+
+const char kEnableAndroidWallpapersAppName[] =
+    R"*(Android Wallpapers App)*";
+
+const char kEnableAndroidWallpapersAppDescription[] =
+    R"*(Enables the Android Wallpapers App as the default Wallpaper App)*"
+    R"*(on Chrome OS.)*";
+
+const char kEnableTouchSupportForScreenMagnifierName[] =
+    R"*(Touch support for screen magnifier)*";
+
+const char kEnableTouchSupportForScreenMagnifierDescription[] =
+    R"*(Enables touch support for screen magnifier)*";
+
+#endif  // defined(OS_CHROMEOS)
+
+#if defined(OS_ANDROID)
+
+const char kContentSuggestionsCategoryOrderName[] =
+    R"*(Default content suggestions category order (e.g. on NTP))*";
+
+const char kContentSuggestionsCategoryOrderDescription[] =
+    R"*(Set default order of content suggestion categories (e.g. on the)*"
+    R"*(NTP).)*";
+
+const char kContentSuggestionsCategoryRankerName[] =
+    R"*(Content suggestions category ranker (e.g. on NTP))*";
+
+const char kContentSuggestionsCategoryRankerDescription[] =
+    R"*(Set category ranker to order categories of content suggestions)*"
+    R"*((e.g. on the NTP).)*";
+
+const char kEnableNtpSnippetsVisibilityName[] =
+    R"*(Make New Tab Page Snippets more visible.)*";
+
+const char kEnableNtpSnippetsVisibilityDescription[] =
+    R"*(If enabled, the NTP snippets will become more discoverable with a)*"
+    R"*(larger portion of the first card above the fold.)*";
+
+const char kEnableNtpRemoteSuggestionsName[] =
+    R"*(Show server-side suggestions on the New Tab page)*";
+
+const char kEnableNtpRemoteSuggestionsDescription[] =
+    R"*(If enabled, the list of content suggestions on the New Tab page)*"
+    R"*((see #enable-ntp-snippets) will contain server-side suggestions)*"
+    R"*((e.g., Articles for you). Furthermore, it allows to override the)*"
+    R"*(source used to retrieve these server-side suggestions.)*";
+
+const char kEnableNtpRecentOfflineTabSuggestionsName[] =
+    R"*(Show recent offline tabs on the New Tab page)*";
+
+const char kEnableNtpRecentOfflineTabSuggestionsDescription[] =
+    R"*(If enabled, the list of content suggestions on the New Tab page)*"
+    R"*((see #enable-ntp-snippets) will contain pages that were captured)*"
+    R"*(offline during browsing (see #offlining-recent-pages))*";
+
+const char kEnableNtpSaveToOfflineName[] =
+    R"*(Show option to save to offline in Snippets context menu.)*";
+
+const char kEnableNtpSaveToOfflineDescription[] =
+    R"*(If enabled, the Snippets context menu (see #enable-ntp-snippets))*"
+    R"*(will contain the option to save linked page for offline viewing.)*";
+
+const char kEnableNtpOfflineBadgeName[] =
+    R"*(Show offline badge for offline available snippets on the ntp.)*";
+
+const char kEnableNtpOfflineBadgeDescription[] =
+    R"*(If enabled, Snippets that are available offline will have an)*"
+    R"*(offline badge.)*";
+
+const char kEnableNtpAssetDownloadSuggestionsName[] =
+    R"*(Show asset downloads on the New Tab page)*";
+
+const char kEnableNtpAssetDownloadSuggestionsDescription[] =
+    R"*(If enabled, the list of content suggestions on the New Tab page)*"
+    R"*((see #enable-ntp-snippets) will contain assets (e.g. books,)*"
+    R"*(pictures, audio) that the user downloaded for later use.)*";
+
+const char kEnableNtpOfflinePageDownloadSuggestionsName[] =
+    R"*(Show offline page downloads on the New Tab page)*";
+
+const char kEnableNtpOfflinePageDownloadSuggestionsDescription[] =
+    R"*(If enabled, the list of content suggestions on the New Tab page)*"
+    R"*((see #enable-ntp-snippets) will contain pages that the user)*"
+    R"*(downloaded for later use.)*";
+
+const char kEnableNtpBookmarkSuggestionsName[] =
+    R"*(Show recently visited bookmarks on the New Tab page)*";
+
+const char kEnableNtpBookmarkSuggestionsDescription[] =
+    R"*(If enabled, the list of content suggestions on the New Tab page)*"
+    R"*((see #enable-ntp-snippets) will contain recently visited)*"
+    R"*(bookmarks.)*";
+
+const char kEnableNtpPhysicalWebPageSuggestionsName[] =
+    R"*(Show Physical Web pages on the New Tab page)*";
+
+const char kEnableNtpPhysicalWebPageSuggestionsDescription[] =
+    R"*(If enabled, the list of content suggestions on the New Tab page)*"
+    R"*((see #enable-ntp-snippets) will contain pages that are available)*"
+    R"*(through Physical Web (see #enable-physical-web))*";
+
+const char kEnableNtpForeignSessionsSuggestionsName[] =
+    R"*(Show recent foreign tabs on the New Tab page)*";
+
+const char kEnableNtpForeignSessionsSuggestionsDescription[] =
+    R"*(If enabled, the list of content suggestions on the New Tab page)*"
+    R"*((see #enable-ntp-snippets) will contain recent foreign tabs.)*";
+
+const char kEnableNtpSuggestionsNotificationsName[] =
+    R"*(Notify about new content suggestions available at the New Tab)*"
+    R"*(page)*";
+
+const char kEnableNtpSuggestionsNotificationsDescription[] =
+    R"*(If enabled, notifications will inform about new content)*"
+    R"*(suggestions on the New Tab page (see #enable-ntp-snippets).)*";
+
+const char kNtpCondensedLayoutName[] =
+    R"*(Condensed NTP layout)*";
+
+const char kNtpCondensedLayoutDescription[] =
+    R"*(Show a condensed layout on the New Tab Page.)*";
+
+const char kNtpCondensedTileLayoutName[] =
+    R"*(Condensed NTP tile layout)*";
+
+const char kNtpCondensedTileLayoutDescription[] =
+    R"*(Show a condensed tile layout on the New Tab Page.)*";
+
+const char kNtpGoogleGInOmniboxName[] =
+    R"*(Google G in New Tab Page omnibox)*";
+
+const char kNtpGoogleGInOmniboxDescription[] =
+    R"*(Show a Google G in the omnibox on the New Tab Page.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_ANDROID)
+
+const char kOffliningRecentPagesName[] =
+    R"*(Enable offlining of recently visited pages)*";
+
+const char kOffliningRecentPagesDescription[] =
+    R"*(Enable storing recently visited pages locally for offline use.)*"
+    R"*(Requires Offline Pages to be enabled.)*";
+
+const char kOfflinePagesCtName[] =
+    R"*(Enable Offline Pages CT features.)*";
+
+const char kOfflinePagesCtDescription[] =
+    R"*(Enable Offline Pages CT features.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_ANDROID)
+
+const char kEnableExpandedAutofillCreditCardPopupLayout[] =
+    R"*(Use expanded autofill credit card popup layout.)*";
+
+const char kEnableExpandedAutofillCreditCardPopupLayoutDescription[] =
+    R"*(If enabled, displays autofill credit card popup using expanded)*"
+    R"*(layout.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kEnableAutofillCreditCardLastUsedDateDisplay[] =
+    R"*(Display the last used date of a credit card in autofill.)*";
+
+const char kEnableAutofillCreditCardLastUsedDateDisplayDescription[] =
+    R"*(If enabled, display the last used date of a credit card in)*"
+    R"*(autofill.)*";
+
+#if !defined(OS_ANDROID) && defined(GOOGLE_CHROME_BUILD)
+
+const char kGoogleBrandedContextMenuName[] =
+    R"*(Google branding in the context menu)*";
+
+const char kGoogleBrandedContextMenuDescription[] =
+    R"*(Shows a Google icon next to context menu items powered by Google)*"
+    R"*(services.)*";
+
+#endif  // !defined(OS_ANDROID) && defined(GOOGLE_CHROME_BUILD)
+
+const char kEnableWebUsbName[] =
+    R"*(WebUSB)*";
+
+const char kEnableWebUsbDescription[] =
+    R"*(Enable WebUSB support.)*";
+
+const char kEnableGenericSensorName[] =
+    R"*(Generic Sensor)*";
+
+const char kEnableGenericSensorDescription[] =
+    R"*(Enable sensor APIs based on Generic Sensor API.)*";
+
+const char kFontCacheScalingName[] =
+    R"*(FontCache scaling)*";
+
+const char kFontCacheScalingDescription[] =
+    R"*(Reuse a cached font in the renderer to serve different sizes of)*"
+    R"*(font for faster layout.)*";
+
+const char kFramebustingName[] =
+    R"*(Framebusting requires same-origin or a user gesture)*";
+
+const char kFramebustingDescription[] =
+    R"*(Don't permit an iframe to navigate the top level browsing context)*"
+    R"*(unless they are same-origin or the iframe is processing a user)*"
+    R"*(gesture.)*";
+
+#if defined(OS_ANDROID)
+
+const char kEnableVrShellName[] =
+    R"*(Enable Chrome VR.)*";
+
+const char kEnableVrShellDescription[] =
+    R"*(Allow browsing with a VR headset if available for this device.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Web payments
+
+const char kWebPaymentsName[] =
+    R"*(Web Payments)*";
+
+const char kWebPaymentsDescription[] =
+    R"*(Enable Web Payments API integration, a JavaScript API for)*"
+    R"*(merchants.)*";
+
+#if defined(OS_ANDROID)
+
+const char kEnableAndroidPayIntegrationV1Name[] =
+    R"*(Enable Android Pay v1)*";
+
+const char kEnableAndroidPayIntegrationV1Description[] =
+    R"*(Enable integration with Android Pay using the first version of)*"
+    R"*(the API)*";
+
+const char kEnableAndroidPayIntegrationV2Name[] =
+    R"*(Enable Android Pay v2)*";
+
+const char kEnableAndroidPayIntegrationV2Description[] =
+    R"*(Enable integration with Android Pay using the second version of)*"
+    R"*(the API)*";
+
+const char kEnableWebPaymentsSingleAppUiSkipName[] =
+    R"*(Enable Web Payments single app UI skip)*";
+
+const char kEnableWebPaymentsSingleAppUiSkipDescription[] =
+    R"*(Enable Web Payments to skip showing its UI if the developer)*"
+    R"*(specifies a single app.)*";
+
+const char kAndroidPaymentAppsName[] =
+    R"*(Android payment apps)*";
+
+const char kAndroidPaymentAppsDescription[] =
+    R"*(Enable third party Android apps to integrate as payment apps)*";
+
+const char kAndroidPaymentAppsFilterTitle[] =
+    R"*(Android payment apps filter)*";
+
+const char kAndroidPaymentAppsFilterDescription[] =
+    R"*(Enable filtering out third party Android apps that can not be)*"
+    R"*(shown in settings)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kFeaturePolicyName[] =
+    R"*(Feature Policy)*";
+
+const char kFeaturePolicyDescription[] =
+    R"*(Enables granting and removing access to features through the)*"
+    R"*(Feature-Policy HTTP header.)*";
+
+//  Audio rendering mixing experiment strings.
+
+const char kNewAudioRenderingMixingStrategyName[] =
+    R"*(New audio rendering mixing strategy)*";
+
+const char kNewAudioRenderingMixingStrategyDescription[] =
+    R"*(Use the new audio rendering mixing strategy.)*";
+
+//  Background video track disabling experiment strings.
+
+const char kBackgroundVideoTrackOptimizationName[] =
+    R"*(Optimize background video playback.)*";
+
+const char kBackgroundVideoTrackOptimizationDescription[] =
+    R"*(Disable video tracks when the video is played in the background)*"
+    R"*(to optimize performance.)*";
+
+//  Video fullscreen with orientation lock experiment strings.
+
+const char kVideoFullscreenOrientationLockName[] =
+    R"*(Lock screen orientation when playing a video fullscreen.)*";
+
+const char kVideoFullscreenOrientationLockDescription[] =
+    R"*(Lock the screen orientation of the device to match video)*"
+    R"*(orientation when a video goes fullscreen. Only on phones.)*";
+
+//  Expensive background timer throttling flag
+
+const char kExpensiveBackgroundTimerThrottlingName[] =
+    R"*(Throttle expensive background timers)*";
+
+const char kExpensiveBackgroundTimerThrottlingDescription[] =
+    R"*(Enables intervention to limit CPU usage of background timers to)*"
+    R"*(1%.)*";
+
+//  Enable default MediaSession flag
+
+#if !defined(OS_ANDROID)
+
+const char kEnableDefaultMediaSessionName[] =
+    R"*(Manage audio focus across tabs)*";
+
+const char kEnableDefaultMediaSessionDescription[] =
+    R"*(Manage audio focus across tabs to improve the audio mixing.)*";
+
+const char kEnableDefaultMediaSessionDisabled[] =
+    R"*(Disabled)*";
+
+const char kEnableDefaultMediaSessionEnabled[] =
+    R"*(Enabled)*";
+
+const char kEnableDefaultMediaSessionEnabledDuckFlash[] =
+    R"*(Enabled (Flash lowers volume when interrupted by other sound,)*"
+    R"*(experimental))*";
+
+#endif  // !defined(OS_ANDROID)
+
+#if defined(OS_WIN)
+
+const char kGdiTextPrinting[] =
+    R"*(GDI Text Printing)*";
+
+const char kGdiTextPrintingDescription[] =
+    R"*(Use GDI to print text as simply text)*";
+
+#endif  // defined(OS_WIN)
+
+#if defined(OS_ANDROID)
+
+const char kModalPermissionPromptsName[] =
+    R"*(Modal Permission Prompts)*";
+
+const char kModalPermissionPromptsDescription[] =
+    R"*(Whether to use permission dialogs in place of permission)*"
+    R"*(infobars.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if !defined(OS_MACOSX)
+
+const char kPermissionPromptPersistenceToggleName[] =
+    R"*(Persistence Toggle in Permission Prompts)*";
+
+const char kPermissionPromptPersistenceToggleDescription[] =
+    R"*(Whether to display a persistence toggle in permission prompts.)*";
+
+#endif  // !defined(OS_MACOSX)
+
+#if defined(OS_ANDROID)
+
+const char kNoCreditCardAbort[] =
+    R"*(No Credit Card Abort)*";
+
+const char kNoCreditCardAbortDescription[] =
+    R"*(Whether or not the No Credit Card Abort is enabled.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Consistent omnibox geolocation
+
+#if defined(OS_ANDROID)
+
+const char kEnableConsistentOmniboxGeolocationName[] =
+    R"*(Have consistent omnibox geolocation access.)*";
+
+const char kEnableConsistentOmniboxGeolocationDescription[] =
+    R"*(Have consistent geolocation access between the omnibox and)*"
+    R"*(default search engine.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Media Remoting chrome://flags strings
+
+const char kMediaRemotingName[] =
+    R"*(Media Remoting during Cast Tab Mirroring)*";
+
+const char kMediaRemotingDescription[] =
+    R"*(When Casting a tab to a remote device, enabling this turns on an)*"
+    R"*(optimization that forwards the content bitstream directly to the)*"
+    R"*(remote device when a video is fullscreened.)*";
+
+const char kMediaRemotingEncryptedName[] =
+    R"*(Media Remoting during Cast Tab Mirroring: Encrypted content too)*";
+
+const char kMediaRemotingEncryptedDescription[] =
+    R"*(When Media Remoting is enabled, this flag must be enabled to)*"
+    R"*(allow the remoting of encrypted content. When disabled, only)*"
+    R"*(non-encrypted content can be remoted.)*";
+
+//  Chrome OS component updates chrome://flags strings
+
+const char kCrosCompUpdatesName[] =
+    R"*(Chrome OS Flash Component Updates)*";
+
+const char kCrosCompUpdatesDescription[] =
+    R"*(Enable Flash component updates for Chrome OS.)*";
+
+//  Native Android History chrome://flags strings
+
+#if defined(OS_ANDROID)
+
+const char kNativeAndroidHistoryManager[] =
+    R"*(Native Android History)*";
+
+const char kNativeAndroidHistoryManagerDescription[] =
+    R"*(Show the native Android UI for browsing history.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Play Services LSD permission prompt chrome://flags strings
+
+#if defined(OS_ANDROID)
+
+const char kLsdPermissionPromptName[] =
+    R"*(Location Settings Dialog Permission Prompt)*";
+
+const char kLsdPermissionPromptDescription[] =
+    R"*(Whether to use the Google Play Services Location Settings Dialog)*"
+    R"*(permission dialog.)*";
+
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_WIN)
+
+//  Custom draw the Windows 10 titlebar. crbug.com/505013
+
+const char kWindows10CustomTitlebarName[] =
+    R"*(Custom-drawn Windows 10 Titlebar)*";
+
+const char kWindows10CustomTitlebarDescription[] =
+    R"*(If enabled, Chrome will draw the titlebar and caption buttons)*"
+    R"*(instead of deferring to Windows.)*";
+
+#endif  // defined(OS_WIN)
+
+#if defined(OS_WIN)
+
+const char kPostscriptPrinting[] =
+    R"*(PostScript Printing)*";
+
+const char kPostscriptPrintingDescription[] =
+    R"*(Enable postscript generation in place of emf generation when)*"
+    R"*(printing to postscript capable printers.)*";
+
+#endif  // defined(OS_WIN)
+
+#if defined(OS_ANDROID)
+
+const char kAiaFetchingName[] =
+    R"*(Intermediate Certificate Fetching)*";
+
+const char kAiaFetchingDescription[] =
+    R"*(Enable intermediate certificate fetching when a server does not)*"
+    R"*(provide sufficient certificates to build a chain to a trusted)*"
+    R"*(root.)*";
+
+#endif  // defined(OS_ANDROID)
+
+//  Web MIDI supports MIDIManager dynamic instantiation chrome://flags strings
+
+const char kEnableMidiManagerDynamicInstantiationName[] =
+    R"*(MIDIManager dynamic instantiation for Web MIDI.)*";
+
+const char kEnableMidiManagerDynamicInstantiationDescription[] =
+    R"*(Enable MIDIManager dynamic instantiation for Web MIDI.)*";
+
+//  Desktop iOS promotion chrome://flags strings
+
+#if defined(OS_WIN)
+
+const char kEnableDesktopIosPromotionsName[] =
+    R"*(Desktop to iOS promotions.)*";
+
+const char kEnableDesktopIosPromotionsDescription[] =
+    R"*(Enable Desktop to iOS promotions, and allow users to see them if)*"
+    R"*(they are eligible.)*";
+
+#endif  // defined(OS_WIN)
+
+#if defined(OS_ANDROID)
+
+const char kEnableCustomFeedbackUiName[] =
+    R"*(Enable Custom Feedback UI)*";
+
+const char kEnableCustomFeedbackUiDescription[] =
+    R"*(Enables a custom feedback UI when submitting feedback through)*"
+    R"*(Google Feedback. Works with Google Play Services v10.2+)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kEnableAdjustableLargeCursorName[] =
+    R"*(Enable adjustable large cursor)*";
+
+const char kEnableAdjustableLargeCursorDescription[] =
+    R"*(Make size of accessibility large cursor adjustable.)*";
+
+#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_MACOSX) || \
+    defined(OS_WIN)
+
+const char kOmniboxEntitySuggestionsName[] =
+    R"*(Omnibox entity suggestions)*";
+
+const char kOmniboxEntitySuggestionsDescription[] =
+    R"*(Enable receiving entity suggestions in Omnibox.)*";
+
+#endif  // defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_MACOSX) ||
+        // defined(OS_WIN)
+
+#if defined(OS_CHROMEOS)
+
+const char kEnableChromevoxArcSupportName[] =
+    R"*(ChromeVox ARC support)*";
+
+const char kEnableChromevoxArcSupportDescription[] =
+    R"*(Enable ChromeVox screen reader features in ARC)*";
+
+#endif  // defined(OS_CHROMEOS)
+
+const char kMojoLoadingName[] =
+    R"*(Use Mojo IPC for resource loading)*";
+
+const char kMojoLoadingDescription[] =
+    R"*(Use Mojo IPC instead of traditional Chrome IPC for resource)*"
+    R"*(loading.)*";
+
+#if defined(OS_ANDROID)
+
+const char kUseNewDoodleApiName[] =
+    R"*(Use new Doodle API)*";
+
+const char kUseNewDoodleApiDescription[] =
+    R"*(Enables the new API to fetch Doodles for the NTP.)*";
+
+#endif  // defined(OS_ANDROID)
+
+const char kDelayNavigationName[] =
+    R"*(Delay navigations)*";
+
+const char kDelayNavigationDescription[] =
+    R"*(Add a fixed delay to main frame navigations.)*";
+
+const char kDebugShortcutsDescription[] =
+    R"*(Enables additional keyboard shortcuts that are useful for)*"
+    R"*(debugging Ash.)*";
+
+#if defined(OS_CHROMEOS)
+
+//  File Manager
+
+const char kVideoPlayerChromecastSupportName[] =
+    R"*(Experimental Chromecast support for Video Player)*";
+
+const char kVideoPlayerChromecastSupportDescription[] =
+    R"*(This option enables experimental Chromecast support for Video)*"
+    R"*(Player app on ChromeOS.)*";
+
+const char kNewZipUnpackerName[] =
+    R"*(New ZIP unpacker)*";
+
+const char kNewZipUnpackerDescription[] =
+    R"*(New ZIP unpacker flow, based on the File System Provider API.)*";
+
+const char kShowArcFilesAppName[] =
+    R"*(Show Android Files app)*";
+
+const char kShowArcFilesAppDescription[] =
+    R"*(Show Android Files app in Chrome OS launcher. This is only)*"
+    R"*(effective on a device with access to Play Store.)*";
+
+const char kOfficeEditingComponentAppName[] =
+    R"*(Office Editing for Docs, Sheets & Slides)*";
+
+const char kOfficeEditingComponentAppDescription[] =
+    R"*(Office Editing for Docs, Sheets & Slides for testing purposes.)*";
+
+const char kDisplayColorCalibrationName[] =
+    R"*(Color calibration of the display)*";
+
+const char kDisplayColorCalibrationDescription[] =
+    R"*(Allow color calibration of the display if the display supports)*"
+    R"*(the feature.)*";
+
+const char kMemoryPressureThresholdName[] =
+    R"*(Memory discard strategy for advanced pressure handling)*";
+
+const char kMemoryPressureThresholdDescription[] =
+    R"*(Memory discarding strategy to use)*";
+
+const char kConservativeThresholds[] =
+    R"*(Conservative memory pressure release strategy)*";
+
+const char kAggressiveCacheDiscardThresholds[] =
+    R"*(Aggressive cache release strategy)*";
+
+const char kAggressiveTabDiscardThresholds[] =
+    R"*(Aggressive tab release strategy)*";
+
+const char kAggressiveThresholds[] =
+    R"*(Aggressive tab and cache release strategy)*";
+
+const char kWakeOnPacketsName[] =
+    R"*(Wake On Packets)*";
+
+const char kWakeOnPacketsDescription[] =
+    R"*(Enables waking the device based on the receipt of some network)*"
+    R"*(packets.)*";
+
+const char kQuickUnlockPin[] =
+    R"*(Quick Unlock (PIN))*";
+
+const char kQuickUnlockPinDescription[] =
+    R"*(Enabling PIN quick unlock allows you to use a PIN to unlock your)*"
+    R"*(Chromebook on the lock screen after you have signed into your)*"
+    R"*(device.)*";
+
+const char kQuickUnlockFingerprint[] =
+    R"*(Quick Unlock (Fingerprint))*";
+
+const char kQuickUnlockFingerprintDescription[] =
+    R"*(Enabling fingerprint quick unlock allows you to setup and use a)*"
+    R"*(fingerprint to unlock your Chromebook on the lock screen after)*"
+    R"*(you have signed into your device.)*";
+
+const char kExperimentalAccessibilityFeaturesName[] =
+    R"*(Experimental accessibility features)*";
+
+const char kExperimentalAccessibilityFeaturesDescription[] =
+    R"*(Enable additional accessibility features in the Settings page.)*";
+
+const char kDisableSystemTimezoneAutomaticDetectionName[] =
+    R"*(SystemTimezoneAutomaticDetection policy support)*";
+
+const char kDisableSystemTimezoneAutomaticDetectionDescription[] =
+    R"*(Disable system timezone automatic detection device policy.)*";
+
+const char kEolNotificationName[] =
+    R"*(Disable Device End of Life notification.)*";
+
+const char kEolNotificationDescription[] =
+    R"*(Disable Notifcation when Device is End of Life.)*";
+
+//  Stylus strings
+
+const char kForceEnableStylusToolsName[] =
+    R"*(Force enable stylus features)*";
+
+const char kForceEnableStylusToolsDescription[] =
+    R"*(Forces display of the stylus tools menu in the shelf and the)*"
+    R"*(stylus section in settings, even if there is no attached stylus)*"
+    R"*(device.)*";
+
+//  Network portal notification
+
+const char kNetworkPortalNotificationName[] =
+    R"*(Notifications about captive portals)*";
+
+const char kNetworkPortalNotificationDescription[] =
+    R"*(If enabled, notification is displayed when device is connected to)*"
+    R"*(a network behind captive portal.)*";
+
+const char kMtpWriteSupportName[] =
+    R"*(MTP write support)*";
+
+const char kMtpWriteSupportDescription[] =
+    R"*(MTP write support in File System API (and file manager). In-place)*"
+    R"*(editing operations are not supported.)*";
+
+const char kCrosRegionsModeName[] =
+    R"*(Cros-regions load mode)*";
+
+const char kCrosRegionsModeDescription[] =
+    R"*(This flag controls cros-regions load mode)*";
+
+const char kCrosRegionsModeDefault[] =
+    R"*(Default)*";
+
+const char kCrosRegionsModeOverride[] =
+    R"*(Override VPD values.)*";
+
+const char kCrosRegionsModeHide[] =
+    R"*(Hide VPD values.)*";
+
+const char kPrinterProviderSearchAppName[] =
+    R"*(Chrome Web Store Gallery app for printer drivers)*";
+
+const char kPrinterProviderSearchAppDescription[] =
+    R"*(Enables Chrome Web Store Gallery app for printer drivers. The app)*"
+    R"*(searches Chrome Web Store for extensions that support printing to)*"
+    R"*(a USB printer with specific USB ID.)*";
+
+const char kArcBootCompleted[] =
+    R"*(Load Android apps automatically)*";
+
+const char kArcBootCompletedDescription[] =
+    R"*(Allow Android apps to start automatically after signing in.)*";
+
+const char kEnableImeMenuName[] =
+    R"*(Enable opt-in IME menu)*";
+
+const char kEnableImeMenuDescription[] =
+    R"*(Enable access to the new IME menu in the Language Settings page.)*";
+
+const char kEnableEhvInputName[] =
+    R"*(Emoji, handwriting and voice input on opt-in IME menu)*";
+
+const char kEnableEhvInputDescription[] =
+    R"*(Enable access to emoji, handwriting and voice input form opt-in)*"
+    R"*(IME menu.)*";
+
+#endif  // #if defined(OS_CHROMEOS)
+
+}  // namespace flags_descriptions