{
  // Defines properties which are available on the Settings object.
  //
  // Please think carefully before adding a new Setting.  Some questions to
  // consider are:
  // - Should this be a RuntimeEnabledFeature instead? Settings are for things
  //   which we support either values of at runtime.  Features are set at renderer
  //   process startup and are never changed. Features also tend to be set to a
  //   value based on the platform or the stability of the code in question, where
  //   as settings both codepaths need to be stable.
  // - How will you ensure test coverage of all relevant values of your setting?
  // - Is the default value appropriate for other platforms or ports which may
  //   not be aware of your setting?
  // - Can your setting result in behavior differences observable to web
  //   developers?
  // - Should this setting ideally be removed in the future?  If so please file
  //   a bug and reference it in the comments for your setting.
  //
  // One reason to add a Setting is to manage the risk associated with adding a
  // new feature.  For example, we may choose to ship a new UI behavior or
  // performance optimization to ChromeOS users first (in order to gather feedback
  // and metrics on its use from the wild) before attempting to ship it to
  // Windows.
  //
  // FIXME: Add support for global settings.
  // FIXME: Add support for custom getters/setters.

  // Valid parameters for data entries below.
  parameters: {
    type: {
      default: "bool"
    },
    initial: {},
    invalidate: {},
  },

  data: [
    {
      name: "defaultTextEncodingName",
      type: "String",
    },

    // Do not hide chars typed in password fields immediately, but let the last char stay
    // visible for N seconds, configured by the passwordEchoDurationInSeconds setting
    // FIXME: Enable automatically if passwordEchoDurationInSeconds is set to a positive value.
    {
      name: "passwordEchoEnabled",
      initial: false,
    },

    // Configure how long the last char should say visible in seconds.
    {
      name: "passwordEchoDurationInSeconds",
      initial: 1,
      type: "double",
    },

    // Sets the magnification value for validation message timer.  If the
    // magnification value is N, a validation message disappears automatically after
    // <message length> * N / 1000 seconds.  If N is equal to or less than 0, a
    // validation message doesn't disappears automaticaly.
    {
      name: "validationMessageTimerMagnification",
      initial: 50,
      type: "int",
    },

    // Number of pixels below which 2D canvas is rendered in software
    // even if hardware acceleration is enabled.
    // Hardware acceleration is useful for large canvases where it can avoid the
    // pixel bandwidth between the CPU and GPU. But GPU acceleration comes at
    // a price - extra back-buffer and texture copy. Small canvases are also
    // widely used for stylized fonts. Anti-aliasing text in hardware at that
    // scale is generally slower. So below a certain size it is better to
    // draw canvas in software.
    {
      name: "minimumAccelerated2dCanvasSize",
      initial: "257*256",
      type: "int",
    },

    {
      name: "minimumFontSize",
      initial: 0,
      invalidate: "Style",
      type: "int",
    },
    {
      name: "minimumLogicalFontSize",
      initial: 0,
      invalidate: "Style",
      type: "int",
    },
    {
      name: "defaultFontSize",
      initial: 0,
      invalidate: "Style",
      type: "int",
    },
    {
      name: "defaultFixedFontSize",
      initial: 0,
      invalidate: "Style",
      type: "int",
    },

    {
      name: "editingBehaviorType",
      initial: "EditingBehaviorTypeForPlatform()",
      type: "EditingBehaviorType",
    },

    {
      name: "localStorageEnabled",
      initial: false,
    },
    {
      name: "allowUniversalAccessFromFileURLs",
      initial: true,
    },
    {
      name: "allowFileAccessFromFileURLs",
      initial: true,
    },
    {
      name: "supportsMultipleWindows",
      initial: true,
    },
    {
      name: "javaScriptCanAccessClipboard",
      initial: false,
    },
    {
      name: "shouldPrintBackgrounds",
      initial: false,
    },
    {
      name: "shouldClearDocumentBackground",
      initial: true,
    },

    {
      name: "textAreasAreResizable",
      initial: false,
      invalidate: "Style",
    },
    {
      name: "acceleratedCompositingEnabled",
      initial: true,
      invalidate: "AcceleratedCompositing",
    },

    {
      name: "offlineWebApplicationCacheEnabled",
      initial: true,
    },
    {
      name: "allowScriptsToCloseWindows",
      initial: false,
    },

    // FIXME: This should really be disabled by default as it makes platforms that
    // don't support the feature download files they can't use by.
    // Leaving enabled for now to not change existing behavior.
    {
      name: "downloadableBinaryFontsEnabled",
      initial: true,
    },

    {
      name: "xssAuditorEnabled",
      initial: false,
    },

    {
      name: "preferCompositingToLCDTextEnabled",
      initial: false,
      invalidate: "AcceleratedCompositing",
    },

    // 3D canvas (WebGL) support.
    {
      name: "webGLEnabled",
      initial: false,
    },

    {
      name: "webGLErrorsToConsoleEnabled",
      initial: true,
    },
    {
      name: "antialiased2dCanvasEnabled",
      initial: true,
    },
    {
      name: "antialiasedClips2dCanvasEnabled",
      initial: true,
    },
    {
      name: "accelerated2dCanvasMSAASampleCount",
      initial: 0,
      type: "int",
    },

    {
      name: "hyperlinkAuditingEnabled",
      initial: false,
    },
    {
      name: "allowRunningOfInsecureContent",
      initial: true,
    },

    {
      name: "mediaPlaybackGestureWhitelistScope",
      type: "String",
    },

    {
      name: "presentationRequiresUserGesture",
      initial: true,
    },

    {
      name: "embeddedMediaExperienceEnabled",
      initial: false,
    },

    // This is used when page popups should not be presented at all from time
    // to time in the life of a renderer. This is different than the runtime
    // enabled feature to enable page popups which remains fixed for the
    // lifetime of a render and semantically means that an alternative UI
    // should be shown. An example of when this might be used is in an
    // embedder than cannot render these popups (in VR mode, say).
    {
      name: "pagePopupsSuppressed",
      initial: false,
    },

    {
      name: "scrollAnimatorEnabled",
      initial: true,
    },

    // Used to disable threaded, compositor scrolling for testing purposes.
    // crbug.com/410974 tracks removal once alternative solutions for selective
    // main thread scrolling are supported.
    {
      name: "threadedScrollingEnabled",
      initial: true,
      invalidate: "Style",
    },

    // Used in layout tests for gesture tap highlights. Makes the highlights square
    // (rather than rounded) to make it possible to reftest the results.
    {
      name: "mockGestureTapHighlightsEnabled",
      initial: false,
    },

    {
      name: "shouldRespectImageOrientation",
      initial: false,
    },

    // Limited use by features which behave differently depending on the input
    // devices available.  For example, the pointer and hover media queries.
    // Note that we need to be careful when basing behavior or UI on this -
    // just because a device is present doesn't mean the user cares about it
    // or uses it (i.e. Chromebook Pixel users generally don't want to give up
    // screen real estate just because they happen to have a touchscreen).
    {
      name: "deviceSupportsTouch",
      initial: false,
    },

    // This value indicates the number of simultaneous multi-touch points supported
    // by the currently connected screen/digitizer that supports the most points.
    // From Pointer Events spec:
    //   http://www.w3.org/TR/pointerevents///widl-Navigator-maxTouchPoints
    {
      name: "maxTouchPoints",
      initial: 0,
      type: "int",
    },

    // Whether touch gestures should be "fuzzed" to nearest touch targets.
    // It's expected that this is enabled everywhere by default, but it may be
    // disabled for testing purposes as the algorithm is not yet perfect.
    // crbug.com/304895 tracks removal once we're satisfied with the algorithm.
    {
      name: "touchAdjustmentEnabled",
      initial: true,
    },

    // Determines whether WebViewClient::didTapMultipleTargets will be used for
    // touch disambiguation.
    {
      name: "multiTargetTapNotificationEnabled",
      initial: true,
    },

    {
      name: "syncXHRInDocumentsEnabled",
      initial: true,
    },
    {
      name: "cookieEnabled",
      initial: true,
    },
    {
      name: "navigateOnDragDrop",
      initial: true,
    },
    {
      name: "DOMPasteAllowed",
      initial: false,
    },

    {
      name: "allowCustomScrollbarInMainFrame",
      initial: true,
    },
    {
      name: "webSecurityEnabled",
      initial: true,
    },

    // Special keyboard navigation mode intented for platforms with no
    // proper mouse or touch support, such as a TV controller with a remote.
    {
      name: "spatialNavigationEnabled",
      initial: false,
    },

    // This setting adds a means to enable/disable touch initiated drag & drop. If
    // enabled, the user can initiate drag using long press.
    // crbug.com/304894 tracks removal once it's been enabled on all platforms.
    {
      name: "touchDragDropEnabled",
      initial: false,
    },

    // Some apps could have a default video poster if it is not set.
    {
      name: "defaultVideoPosterURL",
      type: "String",
    },

    {
      name: "smartInsertDeleteEnabled",
      initial: false,
    },
    {
      name: "selectTrailingWhitespaceEnabled",
      initial: "kDefaultSelectTrailingWhitespaceEnabled",
    },

    {
      name: "selectionIncludesAltImageText",
      initial: false,
    },

    {
      name: "selectionStrategy",
      initial: "SelectionStrategy::kCharacter",
      type: "SelectionStrategy",
    },

    //////////////// Settings used by Android WebView below ////////////////

    {
      name: "useLegacyBackgroundSizeShorthandBehavior",
      initial: false,
    },

    // This quirk is to maintain compatibility with Android apps built on
    // the Android SDK prior to and including version 18.
    // Presumably, this can be removed any time after 2015.
    // See http://crbug.com/282130.
    {
      name: "viewportMetaZeroValuesQuirk",
      initial: false,
    },

    // Another Android SDK <= 18 quirk, removable 2015.
    // See http://crbug.com/295287
    {
      name: "ignoreMainFrameOverflowHiddenQuirk",
      initial: false,
    },

    // Yet another Android SDK <= 18 quirk, removable 2015.
    // See http://crbug.com/305236
    {
      name: "reportScreenSizeInPhysicalPixelsQuirk",
      initial: false,
    },

    // One more Android SDK <= 18 quirk, removable 2015.
    // See http://crbug.com/306548
    {
      name: "viewportMetaMergeContentQuirk",
      initial: false,
    },

    // This quirk is to maintain compatibility with Android apps.
    // It will be possible to remove it once WebSettings.{get|set}UseWideViewPort
    // API function will be removed.
    // See http://crbug.com/288037.
    {
      name: "wideViewportQuirkEnabled",
      initial: false,
    },

    // Used by the android_webview to support a horizontal height auto-sizing
    // mode.
    {
      name: "forceZeroLayoutHeight",
      initial: false,
      invalidate: "ViewportDescription",
    },

    {
      name: "mainFrameClipsContent",
      initial: true,
    },

    // For android.webkit.WebSettings.setUseWideViewport()
    // http://developer.android.com/reference/android/webkit/WebSettings.html//setUseWideViewPort(boolean)
    {
      name: "useWideViewport",
      initial: true,
      invalidate: "ViewportDescription",
    },

    // For android.webkit.WebSettings.setLoadWithOverviewMode()
    // http://developer.android.com/reference/android/webkit/WebSettings.html//setLoadWithOverviewMode(boolean)
    {
      name: "loadWithOverviewMode",
      initial: true,
      invalidate: "ViewportDescription",
    },

    // Used by android_webview to support legacy apps that inject script into a top-level initial empty
    // document and expect it to persist on navigation, even though the origin is unique. Note that this
    // behavior violates the requirements described by [Initialising a new Document object] in
    // https://html.spec.whatwg.org/multipage/browsers.html//navigating-across-documents.
    {
      name: "shouldReuseGlobalForUnownedMainFrame",
      initial: false,
    },

    //////////////// End of settings used by Android WebView ////////////////


    // Touch based text selection and editing on desktop.
    // crbug.com/304873 tracks removal once it's been enabled on all platforms.
    {
      name: "touchEditingEnabled",
      initial: false,
    },

    // If true, scrollers will use overlay scrollbars.  These do not take up any
    // layout width, are drawn using solid color quads by the compositor, and fade away
    // after a timeout.
    {
      name: "useSolidColorScrollbars",
      initial: false,
    },

    // Setting to have all APIs reflect the layout viewport.
    // crbug.com/489206 tracks the reason for this flag's existence.
    {
      name: "inertVisualViewport",
      initial: true,
    },

    // The rubber-band overscroll effect is implemented in Blink and is being moved
    // to the compositor thread. This will be set to true and eventually removed.
    // crbug.com/133097
    {
      name: "rubberBandingOnCompositorThread",
      initial: false,
    },

    // Font scale factor for accessibility, applied as part of text autosizing.
    {
      name: "accessibilityFontScaleFactor",
      initial: "1.0",
      invalidate: "TextAutosizing",
      type: "double",
    },

    // Only used by Layout Tests and inspector emulation.
    {
      name: "mediaTypeOverride",
      initial: "\"\"",
      invalidate: "MediaQuery",
      type: "String",
    },
    {
      name: "displayModeOverride",
      initial: "kWebDisplayModeUndefined",
      invalidate: "MediaQuery",
      type: "WebDisplayMode",
    },

    // loadsImagesAutomatically only suppresses the network load of
    // the image URL. A cached image will still be rendered if requested.
    {
      name: "loadsImagesAutomatically",
      initial: false,
      invalidate: "ImageLoading",
    },
    {
      name: "imagesEnabled",
      initial: true,
      invalidate: "ImageLoading",
    },
    {
      name: "imageAnimationPolicy",
      initial: "kImageAnimationPolicyAllowed",
      type: "ImageAnimationPolicy",
    },

    // Number of outstanding and pending tokens allowed in the background HTML
    // parser. A value of 0 indicates the parser should use its default value.
    {
      name: "backgroundHtmlParserOutstandingTokenLimit",
      initial: 0,
      type: "unsigned",
    },
    {
      name: "backgroundHtmlParserPendingTokenLimit",
      initial: 0,
      type: "unsigned",
    },

    // Html preload scanning is a fast, early scan of HTML documents to find loadable
    // resources before the parser advances to them. If it is disabled, resources will
    // be loaded later.
    {
      name: "doHtmlPreloadScanning",
      initial: true,
    },

    {
      name: "pluginsEnabled",
      initial: false,
      invalidate: "Plugins",
    },

    {
      name: "encryptedMediaEnabled",
      initial: true,
    },

    {
      name: "viewportEnabled",
      initial: false,
      invalidate: "ViewportDescription",
    },
    {
      name: "viewportMetaEnabled",
      initial: false,
      invalidate: "ViewportDescription",
    },

    {
      name: "dnsPrefetchingEnabled",
      initial: false,
      invalidate: "DNSPrefetching",
    },

    {
      name: "dataSaverEnabled",
      initial: false,
    },

    // Clients that execute script should call ExecutionContext::canExecuteScripts()
    // instead of this function. ExecutionContext::canExecuteScripts() checks the
    // HTML sandbox, plugin sandboxing, and other important details.
    {
      name: "scriptEnabled",
      initial: false,
    },

    // Forces initialization of main world, even if no scripts will be executed.
    // Used by inspector to report all contexts.
    {
      name: "forceMainWorldInitialization",
      initial: false,
      invalidate: "DOMWorlds",
    },

    // Compensates for poor text legibility on mobile devices. This value is
    // multiplied by the font scale factor when performing text autosizing of
    // websites that do not set an explicit viewport description.
    {
      name: "deviceScaleAdjustment",
      initial: "1.0",
      invalidate: "TextAutosizing",
      type: "double",
    },

    // This value indicates the maximum number of bytes a document is allowed to
    // transmit in Beacons (via navigator.sendBeacon()) -- Beacons are intended to be
    // smaller payloads transmitted as a page is unloading, not a general (one-way)
    // network transmission API. The spec <https://w3c.github.io/beacon/> does not
    // proscribe an upper limit, but allows for it -- the underlying API will return
    // 'false' in that case. If the value is set to a negative value, no limit
    // will be imposed.
    {
      name: "maxBeaconTransmission",
      initial: 65536,
      type: "int",
    },

    // This value is set to false if the platform does not support fullscreen.
    // When set to false all the requests to enter fullscreen will return an error
    // (fullscreenerror or webkitfullscreenerror) as specified in the standard:
    // http://fullscreen.spec.whatwg.org///dom-element-requestfullscreen
    {
      name: "fullscreenSupported",
      initial: true,
    },

    // V8 supports different types of caching. Used by V8 bindings.
    {
      name: "v8CacheOptions",
      initial: "kV8CacheOptionsDefault",
      type: "V8CacheOptions",
    },

    // V8 code cache for CacheStorage supports three types of strategies (none, normal and aggressive).
    {
      name: "v8CacheStrategiesForCacheStorage",
      initial: "V8CacheStrategiesForCacheStorage::kDefault",
      type: "V8CacheStrategiesForCacheStorage",
    },

    // These values are bit fields for the properties of available pointing devices
    // and may take on multiple values (e.g. laptop with touchpad and touchscreen
    // has pointerType coarse *and* fine).
    {
      name: "availablePointerTypes",
      initial: "kPointerTypeNone",
      invalidate: "MediaQuery",
      type: "int",
    },
    {
      name: "availableHoverTypes",
      initial: "kHoverTypeNone",
      invalidate: "MediaQuery",
      type: "int",
    },

    // These values specify properties of the user's primary pointing device only.
    {
      name: "primaryPointerType",
      initial: "kPointerTypeNone",
      invalidate: "MediaQuery",
      type: "PointerType",
    },
    {
      name: "primaryHoverType",
      initial: "kHoverTypeNone",
      invalidate: "MediaQuery",
      type: "HoverType",
    },

    // Whether accessibility support is enabled at all.
    {
      name: "accessibilityEnabled",
      initial: false,
      invalidate: "AccessibilityState",
    },

    // If true, the value in password fields is exposed to assistive technologies.
    {
      name: "accessibilityPasswordValuesEnabled",
      initial: false,
    },

    // If true, static text nodes expose inline text box children.
    {
      name: "inlineTextBoxAccessibilityEnabled",
      initial: false,
    },

    // If true, context menu will be shown on mouse up instead of mouse down.
    // Typically enabled on Windows to match platform convention.
    {
      name: "showContextMenuOnMouseUp",
      initial: false,
    },

    // If true, context menu will be shown on any long press event.
    // Used on Android to prevent a context menu from being shown in certain situations
    // (i.e. long pressing an empty div)
    {
      name: "alwaysShowContextMenuOnTouch",
      initial: true,
    },

    {
      name: "disableReadingFromCanvas",
      initial: false,
    },
    {
      name: "strictMixedContentChecking",
      initial: false,
    },
    {
      name: "strictMixedContentCheckingForPlugin",
      initial: false,
    },
    {
      name: "strictPowerfulFeatureRestrictions",
      initial: false,
    },
    {
      name: "strictlyBlockBlockableMixedContent",
      initial: false,
    },
    {
      name: "allowGeolocationOnInsecureOrigins",
      initial: false,
    },
    {
      name: "logDnsPrefetchAndPreconnect",
      initial: false,
    },
    {
      name: "logPreload",
      initial: false,
    },

    // These values specify the UA intial viewport style.
    // It is dynamically set by the inspector for mobile emulation and can be
    // used by content embedders to specify custom style on certain platforms.
    {
      name: "viewportStyle",
      initial: "WebViewportStyle::kDefault",
      invalidate: "ViewportRule",
      type: "WebViewportStyle",
    },

    // Automatic track selection is performed based on user preference for track kind specified
    // by this setting.
    {
      name: "textTrackKindUserPreference",
      initial: "TextTrackKindUserPreference::kDefault",
      invalidate: "TextTrackKindUserPreference",
      type: "TextTrackKindUserPreference",
    },

    // User style overrides for captions and subtitles
    {
      name: "textTrackBackgroundColor",
      type: "String",
    },
    {
      name: "textTrackFontFamily",
      type: "String",
    },
    {
      name: "textTrackFontStyle",
      type: "String",
    },
    {
      name: "textTrackFontVariant",
      type: "String",
    },
    {
      name: "textTrackTextColor",
      type: "String",
    },
    {
      name: "textTrackTextShadow",
      type: "String",
    },
    {
      name: "textTrackTextSize",
      type: "String",
    },

    // Margin for title-safe placement of cues with overscan, gives top and bottom margin size as
    // percentage of video element height (for horizontal text) into which cues will not be placed.
    {
      name: "textTrackMarginPercentage",
      initial: 0,
      type: "double",
    },

    {
      name: "progressBarCompletion",
      initial: "ProgressBarCompletion::kLoadEvent",
      type: "ProgressBarCompletion",
    },

    {
      name: "historyEntryRequiresUserGesture",
      initial: false,
    },

    // Do we want to try to save screen real estate in the media player by hiding
    // the volume slider / mute button?
    {
      name: "preferHiddenVolumeControls",
      initial: false,
    },

    // Whether to disallow network fetches for parser blocking scripts in the main
    // frame inserted via document.write, for users on 2G or connections that are
    // effectively 2G.
    {
      name: "disallowFetchForDocWrittenScriptsInMainFrameIfEffectively2G",
      initial: false,
    },

    // Whether to disallow network fetches for parser blocking scripts in the main
    // frame inserted via document.write, for users on slow connections.
    {
      name: "disallowFetchForDocWrittenScriptsInMainFrameOnSlowConnections",
      initial: false,
    },

    // Whether to disallow network fetches for parser blocking scripts in the main
    // frame inserted via document.write, regardless of connection type.
    {
      name: "disallowFetchForDocWrittenScriptsInMainFrame",
      initial: false,
    },

    // Whether to invalidate device-dependent media queries and restore scroll positions
    // on frame resize assuming device rotation.
    {
      name: "mainFrameResizesAreOrientationChanges",
      initial: false,
    },

    // Ability to override the default 'passive' value in AddEventListenerOptions. This
    // is useful to demonstrate the power of passive event listeners. This can be removed
    // when there is greater adoption, interventions to force it on and associated devtools
    // to enable it have been shipped.
    {
      name: "passiveListenerDefault",
      initial: "PassiveListenerDefault::kFalse",
      type: "PassiveListenerDefault",
    },

    // Use default interpolation quality to scale bitmap images if quality is not determined
    // in other ways. This can help us writing reftests containing scaled images.
    {
      name: "useDefaultImageInterpolationQuality",
      initial: false,
    },

    // Whether the CSSPreloadScanner is used for externally CSS preloads. NoPreload
    // indicates that the scanner will be used, but no preloads issued.
    {
      name: "cssExternalScannerNoPreload",
      initial: false,
    },
    {
      name: "cssExternalScannerPreload",
      initial: false,
    },

    {
      name: "browserSideNavigationEnabled",
      initial: false,
    },

    // Some platforms have media subsystems which are too buggy to allow preloading
    // of content by default. See http://crbug.com/612909 for details.
    {
      name: "forcePreloadNoneForMediaElements",
      initial: false,
    },

    {
      name: "hideScrollbars",
      initial: false,
    },

    // Spellchecking is enabled by default for elements that do not specify it explicitly
    // using the "spellcheck" attribute.
    {
      name: "spellCheckEnabledByDefault",
      initial: true,
    },

    // Whether download UI should be hidden for the current page content.
    {
      name: "hideDownloadUI",
      initial: false,
    },

    // Whether or not to issue range requests for images and show placeholders.
    {
      name: "fetchImagePlaceholders",
      initial: false,
    },

    // Whether the frame is a presentation receiver and should expose
    // `navigator.presentation.receiver`.
    {
      name: "presentationReceiver",
      initial: false,
    },

    // Whether Blink should show media controls when `controls` attribute is used.
    {
      name: "mediaControlsEnabled",
      initial: true,
      invalidate: "MediaControls",
    },

    // Whether we should not update selection attributes when mutating selection range.
    // TODO(changwan): remove this flag when we no longer support Android M.
    {
      name: "doNotUpdateSelectionOnMutatingSelectionRange",
      initial: false,
    },

    // Defines the autoplay policy to use.
    {
      name: "autoplayPolicy",
      type: "AutoplayPolicy::Type",
      initial: "AutoplayPolicy::Type::kNoUserGestureRequired",
    },

    //
    // High contrast mode
    //
    {
      name: "highContrastMode",
      initial: "HighContrastMode::kOff",
      type: "HighContrastMode",
    },
    {
      name: "highContrastGrayscale",
      initial: false,
    },
    {
      name: "highContrastContrast",
      initial: 0,
      type: "double",
    },
    {
      name: "highContrastImagePolicy",
      initial: "HighContrastImagePolicy::kFilterAll",
      type: "HighContrastImagePolicy",
    }
  ],
}