From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- modules/libpref/init/StaticPrefList.yaml | 16000 ++++++++++++++++++++ modules/libpref/init/StaticPrefListBegin.h | 50 + modules/libpref/init/StaticPrefListEnd.h | 20 + modules/libpref/init/__init__.py | 0 modules/libpref/init/all.js | 4039 +++++ modules/libpref/init/generate_static_pref_list.py | 472 + modules/libpref/init/static_prefs/Cargo.toml | 12 + modules/libpref/init/static_prefs/src/lib.rs | 11 + 8 files changed, 20604 insertions(+) create mode 100644 modules/libpref/init/StaticPrefList.yaml create mode 100644 modules/libpref/init/StaticPrefListBegin.h create mode 100644 modules/libpref/init/StaticPrefListEnd.h create mode 100644 modules/libpref/init/__init__.py create mode 100644 modules/libpref/init/all.js create mode 100644 modules/libpref/init/generate_static_pref_list.py create mode 100644 modules/libpref/init/static_prefs/Cargo.toml create mode 100644 modules/libpref/init/static_prefs/src/lib.rs (limited to 'modules/libpref/init') diff --git a/modules/libpref/init/StaticPrefList.yaml b/modules/libpref/init/StaticPrefList.yaml new file mode 100644 index 0000000000..82a2582c8a --- /dev/null +++ b/modules/libpref/init/StaticPrefList.yaml @@ -0,0 +1,16000 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +# This file defines static prefs, i.e. those that are defined at startup and +# used entirely or mostly from C++ and/or Rust code. +# +# The file is separated into sections, where each section contains a group of +# prefs that all share the same first segment of their name -- all the "gfx.*" +# prefs are together, all the "network.*" prefs are together, etc. Sections +# must be kept in alphabetical order, but prefs within sections need not be. +# +# Basics +# ------ +# Any pref defined in one of the files included here should *not* be defined +# in a data file such as all.js; that would just be useless duplication. +# +# (Except under unusual circumstances where the value defined here must be +# overridden, e.g. for some Thunderbird prefs. In those cases the default +# value from the data file will override the static default value defined +# here.) +# +# Please follow the existing prefs naming convention when considering adding a +# new pref, and don't create a new pref group unless it's appropriate and there +# are likely to be multiple prefs within that group. (If you do, you'll need to +# update the `pref_groups` variable in modules/libpref/moz.build.) +# +# Definitions +# ----------- +# A pref definition looks like this: +# +# - name: # mandatory +# type: # mandatory +# value: # mandatory +# mirror: # mandatory +# do_not_use_directly: # optional +# include: # optional +# rust: # optional +# set_spidermonkey_pref: # optional +# +# - `name` is the name of the pref, without double-quotes, as it appears +# in about:config. It is used in most libpref API functions (from both C++ +# and JS code). +# +# - `type` is one of `bool`, `int32_t`, `uint32_t`, `float`, an atomic version +# of one of those, `String` or `DataMutexString`. Note that float prefs are +# stored internally as strings. The C++ preprocessor doesn't like template +# syntax in a macro argument, so use the typedefs defined in +# StaticPrefsBase.h; for example, use `RelaxedAtomicBool` instead of +# `Atomic`. +# +# - `value` is the default value. Its type should be appropriate for +# , otherwise the generated code will fail to compile. A complex +# C++ numeric expressions like `60 * 60` (which the YAML parser cannot treat +# as an integer or float) is treated as a string and passed through without +# change, which is useful. +# +# - `mirror` indicates how the pref value is mirrored into a C++ variable. +# +# * `never`: There is no C++ mirror variable. The pref value can only be +# accessed via the standard libpref API functions. +# +# * `once`: The pref value is mirrored into a variable at startup; the +# mirror variable is left unchanged after that. (The exact point at which +# all `once` mirror variables are set is when the first `once` mirror +# variable is accessed, via its getter function.) This is mostly useful for +# graphics prefs where we often don't want a new pref value to apply until +# restart. Otherwise, this update policy is best avoided because its +# behaviour can cause confusion and bugs. +# +# * `always`: The mirror variable is always kept in sync with the pref value. +# This is the most common choice. +# +# When a mirror variable is present, a getter will be created that can access +# it. Using the getter function to read the pref's value has the two +# following advantages over the normal API functions. +# +# * A direct variable access is faster than a hash table lookup. +# +# * A mirror variable can be accessed off the main thread. If a pref *is* +# accessed off the main thread, it should have an atomic type. Assertions +# enforce this. +# +# Note that Rust code must access the mirror variable directly, rather than +# via the getter function. +# +# - `do_not_use_directly` indicates if `_DoNotUseDirectly` should be appended to +# the name of the getter function. This is simply a naming convention +# indicating that there is some other wrapper getter function that should be +# used in preference to the normal static pref getter. Defaults to `false` if +# not present. Cannot be used with a `never` mirror value, because there is +# no getter function in that case. +# +# - `include` names a header file that must be included for the pref value to +# compile correctly, e.g. because it refers to a code constant. System +# headers should be surrounded with angle brackets, e.g. ``. +# +# - `rust` indicates if the mirror variable is used by Rust code. If so, it +# will be usable via the `static_prefs::pref!` macro, e.g. +# `static_prefs::pref!("layout.css.cross-fade.enabled")`. +# +# - `set_spidermonkey_pref` indicates whether SpiderMonkey boilerplate code +# should be generated for this pref. If this is set to 'startup', the +# pref on the SpiderMonkey side is only set during process startup. If set to +# 'always', the SpiderMonkey pref value is also updated when this pref is +# changed at runtime. +# This option is only valid for javascript.options.* prefs. +# +# The getter function's base name is the same as the pref's name, but with +# '.' or '-' chars converted to '_', to make a valid identifier. For example, +# the getter for `foo.bar_baz` is `foo_bar_baz()`. This is ugly but clear, +# and you can search for both the pref name and the getter using the regexp +# /foo.bar.baz/. Suffixes are added as follows: +# +# - If the `mirror` value is `once`, `_AtStartup` is appended, to indicate the +# value was obtained at startup. +# +# - If the `do_not_use_directly` value is true, `_DoNotUseDirectly` is +# appended. +# +# Preprocessor +# ------------ +# Note finally that this file is preprocessed by preprocessor.py, not the C++ +# preprocessor. As a result, the following things may be surprising. +# +# - YAML comments start with a '#', so putting a comment on the same line as a +# preprocessor directive is dubious. E.g. avoid lines like `#define X 3 # +# three` because the ` # three` will be part of `X`. +# +# - '@' use is required for substitutions to occur. E.g. with `#define FOO 1`, +# `FOO` won't be replaced with `1` unless it has '@' chars around it. +# +# - Spaces aren't permitted between the leading '#' and the name of a +# directive, e.g. `#ifdef XYZ` works but `# ifdef XYZ` does not. +# +# Please indent all prefs defined within #ifdef/#ifndef conditions. This +# improves readability, particular for conditional blocks that exceed a single +# screen. But note that the leading '-' in a definition must remain in the +# first column for it to be valid YAML. + +#ifdef RELEASE_OR_BETA +#define IS_NOT_RELEASE_OR_BETA false +#else +#define IS_NOT_RELEASE_OR_BETA true +#endif + +#ifdef NIGHTLY_BUILD +#define IS_NIGHTLY_BUILD true +#define IS_NOT_NIGHTLY_BUILD false +#else +#define IS_NIGHTLY_BUILD false +#define IS_NOT_NIGHTLY_BUILD true +#endif + +#if defined(NIGHTLY_BUILD) || defined(MOZ_DEV_EDITION) +#define IS_NIGHTLY_OR_DEV_EDITION true +#else +#define IS_NIGHTLY_OR_DEV_EDITION false +#endif + +#ifdef MOZILLA_OFFICIAL +#define IS_NOT_MOZILLA_OFFICIAL false +#else +#define IS_NOT_MOZILLA_OFFICIAL true +#endif + +#ifdef EARLY_BETA_OR_EARLIER +#define IS_EARLY_BETA_OR_EARLIER true +#define IS_NOT_EARLY_BETA_OR_EARLIER false +#else +#define IS_EARLY_BETA_OR_EARLIER false +#define IS_NOT_EARLY_BETA_OR_EARLIER true +#endif + +#ifdef ANDROID +#define IS_ANDROID true +#define IS_NOT_ANDROID false +#else +#define IS_ANDROID false +#define IS_NOT_ANDROID true +#endif + +#ifdef XP_WIN +#define IS_XP_WIN true +#define IS_NOT_XP_WIN false +#else +#define IS_XP_WIN false +#define IS_NOT_XP_WIN true +#endif + +#ifdef XP_MACOSX +#define IS_XP_MACOSX true +#define IS_NOT_XP_MACOSX false +#else +#define IS_XP_MACOSX false +#define IS_NOT_XP_MACOSX true +#endif + +#--------------------------------------------------------------------------- +# Prefs starting with "accessibility." +#--------------------------------------------------------------------------- + +- name: accessibility.accesskeycausesactivation + type: bool + value: true + mirror: always + +- name: accessibility.monoaudio.enable + type: RelaxedAtomicBool + value: false + mirror: always + +- name: accessibility.browsewithcaret + type: RelaxedAtomicBool + value: false + mirror: always + +- name: accessibility.AOM.enabled + type: bool + value: false + mirror: always + +- name: accessibility.ARIAReflection.enabled + type: bool + value: true + mirror: always + +# Whether form controls and images should be focusable with mouse, in content +# documents. +# +# This matches historical macOS / Safari behavior. +# +# * 0: never +# * 1: always +# * 2: on content documents +- name: accessibility.mouse_focuses_formcontrol + type: int32_t +#ifdef XP_MACOSX + value: 2 +#else + value: 1 +#endif + mirror: always + +# Whether to avoid accessibility activation on Windows shortly after clipboard +# copy. +# +# Possible values are: +# * 0: never +# * 1: always +# * 2 (or others): when needed +- name: accessibility.windows.suppress-after-clipboard-copy + type: uint32_t + value: 2 + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "alerts." +#--------------------------------------------------------------------------- + +# Whether to use platform-specific backends for showing desktop notifications. +# If no such backend is available, or if the pref is false, then XUL +# notifications are used. +- name: alerts.useSystemBackend + type: bool + value: true + mirror: always + +#if defined(XP_WIN) + # On Windows, a COM Surrogate notification server receives notification events + # and can relaunch the application after it has been closed. +- name: alerts.useSystemBackend.windows.notificationserver.enabled + type: bool + value: true + mirror: never +#endif + +#ifdef ANDROID + #--------------------------------------------------------------------------- + # Prefs starting with "android." + #--------------------------------------------------------------------------- + + # On Android, we want an opaque background to be visible under the page, + # so layout should not force a default background. +- name: android.widget_paints_background + type: RelaxedAtomicBool + value: true + mirror: always + +- name: android.touch_resampling.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +#endif + +#--------------------------------------------------------------------------- +# Prefs starting with "apz." +# The apz prefs are explained in AsyncPanZoomController.cpp +#--------------------------------------------------------------------------- + +# amount we zoom in for a double tap gesture if we couldn't find any content +# based rect to zoom to +- name: apz.doubletapzoom.defaultzoomin + type: AtomicFloat + value: 1.2f + mirror: always + +- name: apz.scrollbarbuttonrepeat.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# After a user has executed a pan gesture, we may receive momentum phase pan +# gestures from the OS. This specifies how long we should wait following the +# pan end gesture for possible momentum phase pan gestures before sending the +# TransformEnd notification. +- name: apz.scrollend-event.content.delay_ms + type: RelaxedAtomicInt32 + value: 100 + mirror: always + +- name: apz.wr.activate_all_scroll_frames + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.wr.activate_all_scroll_frames_when_fission + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.prefer_jank_minimal_displayports + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.allow_double_tap_zooming + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.mac.enable_double_tap_zoom_touchpad_gesture + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.allow_immediate_handoff + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.allow_zooming + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.max_zoom + type: AtomicFloat + value: 10.0f + mirror: always + +- name: apz.min_zoom + type: AtomicFloat + value: 0.25f + mirror: always + +- name: apz.allow_zooming_out + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.android.chrome_fling_physics.friction + type: AtomicFloat + value: 0.015f + mirror: always + +- name: apz.android.chrome_fling_physics.inflexion + type: AtomicFloat + value: 0.35f + mirror: always + +- name: apz.android.chrome_fling_physics.stop_threshold + type: AtomicFloat + value: 0.1f + mirror: always + +- name: apz.autoscroll.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.axis_lock.breakout_angle + type: AtomicFloat + value: float(M_PI / 8.0) # 22.5 degrees + mirror: always + include: + +- name: apz.axis_lock.breakout_threshold + type: AtomicFloat + value: 1.0f / 32.0f + mirror: always + +- name: apz.axis_lock.direct_pan_angle + type: AtomicFloat + value: float(M_PI / 3.0) # 60 degrees + mirror: always + include: + +- name: apz.axis_lock.lock_angle + type: AtomicFloat + value: float(M_PI / 6.0) # 30 degrees + mirror: always + include: + +# Whether to lock touch scrolling to one axis at a time. When a new +# axis lock mode is added, the APZCAxisLockCompatTester GTest shoud +# be updated to include the lock mode value. +# 0 = FREE (No locking at all) +# 1 = STANDARD (Once locked, remain locked until scrolling ends) +# 2 = STICKY (Allow lock to be broken, with hysteresis) +# 3 = DOMINANT_AXIS (Only allow movement on one axis at a time, only +# applies to touchpad scrolling) +- name: apz.axis_lock.mode + type: RelaxedAtomicInt32 +#if defined(XP_MACOSX) + value: 3 +#else + value: 2 +#endif + mirror: always + +- name: apz.content_response_timeout + type: RelaxedAtomicInt32 + value: 400 + mirror: always + +- name: apz.danger_zone_x + type: RelaxedAtomicInt32 + value: 50 + mirror: always + +- name: apz.danger_zone_y + type: RelaxedAtomicInt32 + value: 100 + mirror: always + +- name: apz.disable_for_scroll_linked_effects + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.displayport_expiry_ms + type: RelaxedAtomicUint32 + value: 15000 + mirror: always + +- name: apz.drag.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.drag.initial.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.drag.touch.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.enlarge_displayport_when_clipped + type: RelaxedAtomicBool + value: @IS_ANDROID@ + mirror: always + +# Test only. +- name: apz.fixed-margin-override.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Test only. +- name: apz.fixed-margin-override.bottom + type: RelaxedAtomicInt32 + value: 0 + mirror: always + +# Test only. +- name: apz.fixed-margin-override.top + type: RelaxedAtomicInt32 + value: 0 + mirror: always + +- name: apz.fling_accel_base_mult + type: AtomicFloat + value: 1.0f + mirror: always + +- name: apz.fling_accel_supplemental_mult + type: AtomicFloat + value: 1.0f + mirror: always + +- name: apz.fling_accel_min_fling_velocity + type: AtomicFloat + value: 1.5f + mirror: always + +- name: apz.fling_accel_min_pan_velocity + type: AtomicFloat + value: 0.8f + mirror: always + +- name: apz.fling_accel_max_pause_interval_ms + type: RelaxedAtomicInt32 + value: 50 + mirror: always + +- name: apz.fling_curve_function_x1 + type: float + value: 0.0f + mirror: once + +- name: apz.fling_curve_function_x2 + type: float + value: 1.0f + mirror: once + +- name: apz.fling_curve_function_y1 + type: float + value: 0.0f + mirror: once + +- name: apz.fling_curve_function_y2 + type: float + value: 1.0f + mirror: once + +- name: apz.fling_curve_threshold_inches_per_ms + type: AtomicFloat + value: -1.0f + mirror: always + +- name: apz.fling_friction + type: AtomicFloat + value: 0.002f + mirror: always + +- name: apz.fling_min_velocity_threshold + type: AtomicFloat + value: 0.5f + mirror: always + +- name: apz.fling_stop_on_tap_threshold + type: AtomicFloat + value: 0.05f + mirror: always + +- name: apz.fling_stopped_threshold + type: AtomicFloat + value: 0.01f + mirror: always + +- name: apz.touch_acceleration_factor_x + type: float + value: 1.0f + mirror: always + +- name: apz.touch_acceleration_factor_y + type: float + value: 1.0f + mirror: always + +# new scrollbar code for desktop zooming +- name: apz.force_disable_desktop_zooming_scrollbars + type: RelaxedAtomicBool + value: false + mirror: always + +#ifdef MOZ_WIDGET_GTK +- name: apz.gtk.kinetic_scroll.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.gtk.pangesture.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Mode to use when receiving pan gesture input. +# +# * 0: Auto mode (uses the default behavior, subject to change). +# * 1: Page mode: Uses gtk deltas as a percentage of the page size to scroll. This mode matches: +# +# https://gitlab.gnome.org/GNOME/gtk/blob/c734c7e9188b56f56c3a504abee05fa40c5475ac/gtk/gtkrange.c#L3063-3074 +# +# * 2: Pixel mode: Uses gtk deltas as a fixed pixel multiplier. This mode matches e.g. GNOME web. +# +# https://webkit-search.igalia.com/webkit/rev/215039ef09d6bfd6e088175bfe30788d95b9705d/Source/WebKit/Shared/gtk/WebEventFactory.cpp#265-296 +# (multiplied then by pixelsPerLineStep which in GNOME-web is 40). +- name: apz.gtk.pangesture.delta_mode + type: uint32_t + value: 0 + mirror: always + +- name: apz.gtk.pangesture.page_delta_mode_multiplier + type: float + value: 1.0f + mirror: always + +- name: apz.gtk.pangesture.pixel_delta_mode_multiplier + type: float + value: 40.0f + mirror: always + +- name: apz.gtk.touchpad_pinch.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.gtk.touchpad_pinch.three_fingers.enabled + type: RelaxedAtomicBool + value: false + mirror: always +#endif + +- name: apz.keyboard.enabled + type: bool + value: @IS_NOT_ANDROID@ + mirror: once + +- name: apz.keyboard.passive-listeners + type: RelaxedAtomicBool + value: @IS_NOT_ANDROID@ + mirror: always + +- name: apz.max_tap_time + type: RelaxedAtomicInt32 + value: 300 + mirror: always + +- name: apz.max_velocity_inches_per_ms + type: AtomicFloat + value: -1.0f + mirror: always + +- name: apz.max_velocity_queue_size + type: uint32_t + value: 5 + mirror: once + +- name: apz.min_skate_speed + type: AtomicFloat + value: 1.0f + mirror: always + +- name: apz.minimap.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.mvm.force-enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.one_touch_pinch.enabled + type: RelaxedAtomicBool + value: @IS_ANDROID@ + mirror: always + +- name: apz.overscroll.enabled + type: RelaxedAtomicBool +#if defined(XP_MACOSX) || defined(XP_WIN) + value: true +#else + value: false +#endif + mirror: always + +# The "test async scroll offset" (used via reftest-async-scroll +# or nsIDOMWindowUtils.setAsyncScrollOffset()) can be used to +# trigger overscroll. Used for tests only. +- name: apz.overscroll.test_async_scroll_offset.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.overscroll.min_pan_distance_ratio + type: AtomicFloat + value: 1.0f + mirror: always + +- name: apz.overscroll.stop_distance_threshold + type: AtomicFloat + value: 5.0f + mirror: always + +- name: apz.overscroll.spring_stiffness + type: AtomicFloat + value: 200 + mirror: always + +- name: apz.overscroll.damping + type: AtomicFloat + value: 1.1 + mirror: always + +- name: apz.overscroll.max_velocity + type: AtomicFloat + value: 10 + mirror: always + +- name: apz.paint_skipping.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Fetch displayport updates early from the message queue. +- name: apz.pinch_lock.mode + type: RelaxedAtomicInt32 + value: 2 + mirror: always + +- name: apz.pinch_lock.scroll_lock_threshold + type: AtomicFloat + value: 1.0f / 16.0f # 1/16 inches + mirror: always + +- name: apz.pinch_lock.span_breakout_threshold + type: AtomicFloat + value: 1.0f / 32.0f # 1/32 inches + mirror: always + +- name: apz.pinch_lock.span_lock_threshold + type: AtomicFloat + value: 1.0f / 32.0f # 1/32 inches + mirror: always + +- name: apz.pinch_lock.buffer_max_age + type: int32_t + value: 80 # milliseconds + mirror: once + +- name: apz.popups.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Whether to print the APZC tree for debugging. +- name: apz.printtree + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.record_checkerboarding + type: RelaxedAtomicBool + value: @IS_NIGHTLY_BUILD@ + mirror: always + +- name: apz.second_tap_tolerance + type: AtomicFloat + value: 0.5f + mirror: always + +# If this is true, APZ fully recalculates the scroll thumb size and +# position in the compositor. This leads to the size and position +# being more accurate in scenarios such as async zooming. +- name: apz.scrollthumb.recalc + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.test.fails_with_native_injection + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.test.logging_enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.touch_move_tolerance + type: AtomicFloat + value: 0.1f + mirror: always + +- name: apz.touch_start_tolerance + type: AtomicFloat + value: 0.1f + mirror: always + +- name: apz.velocity_bias + type: AtomicFloat + value: 0.0f + mirror: always + +- name: apz.velocity_relevance_time_ms + type: RelaxedAtomicUint32 + value: 100 + mirror: always + +- name: apz.windows.force_disable_direct_manipulation + type: RelaxedAtomicBool + value: false + mirror: always + +- name: apz.windows.use_direct_manipulation + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.windows.check_for_pan_gesture_conversion + type: RelaxedAtomicBool + value: true + mirror: always + +- name: apz.x_skate_highmem_adjust + type: AtomicFloat + value: 0.0f + mirror: always + +- name: apz.x_skate_size_multiplier + type: AtomicFloat + value: 1.25f + mirror: always + +- name: apz.x_stationary_size_multiplier + type: AtomicFloat + value: 1.5f + mirror: always + +- name: apz.y_skate_highmem_adjust + type: AtomicFloat + value: 0.0f + mirror: always + +- name: apz.y_skate_size_multiplier + type: AtomicFloat +#if defined(MOZ_WIDGET_ANDROID) + value: 1.5f +#else + value: 3.5f +#endif + mirror: always + +- name: apz.y_stationary_size_multiplier + type: AtomicFloat +#if defined(MOZ_WIDGET_ANDROID) + value: 1.5f +#else + value: 3.5f +#endif + mirror: always + +- name: apz.zoom_animation_duration_ms + type: RelaxedAtomicInt32 +#if defined(MOZ_WIDGET_ANDROID) + value: 250 +#else + value: 350 +#endif + mirror: always + +- name: apz.scale_repaint_delay_ms + type: RelaxedAtomicInt32 + value: 500 + mirror: always + +# Whether to use rounded external scroll offsets. +- name: apz.rounded_external_scroll_offset + type: bool + value: false + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "beacon." +#--------------------------------------------------------------------------- + +# Is support for Navigator.sendBeacon enabled? +- name: beacon.enabled + type: bool + value: true + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "bidi." +#--------------------------------------------------------------------------- + +# Whether delete and backspace should immediately delete characters not +# visually adjacent to the caret, or adjust the visual position of the caret +# on the first keypress and delete the character on a second keypress +- name: bidi.edit.delete_immediately + type: bool + value: true + mirror: always + +# Bidi caret movement style: +# 0 = logical +# 1 = visual +# 2 = visual, but logical during selection +- name: bidi.edit.caret_movement_style + type: int32_t +#if !defined(XP_LINUX) && defined(NIGHTLY_BUILD) + value: 1 +#else + value: 2 # See Bug 1638240 +#endif + mirror: always + +# Bidi numeral style: +# 0 = nominalnumeralBidi * +# 1 = regularcontextnumeralBidi +# 2 = hindicontextnumeralBidi +# 3 = arabicnumeralBidi +# 4 = hindinumeralBidi +# 5 = persiancontextnumeralBidi +# 6 = persiannumeralBidi +- name: bidi.numeral + type: RelaxedAtomicUint32 + value: 0 + mirror: always + +# Bidi text type +# 1 = charsettexttypeBidi * +# 2 = logicaltexttypeBidi +# 3 = visualtexttypeBidi +- name: bidi.texttype + type: RelaxedAtomicUint32 + value: 1 + mirror: always + +# Bidi direction +# 1 = directionLTRBidi * +# 2 = directionRTLBidi +- name: bidi.direction + type: RelaxedAtomicUint32 + value: 1 + mirror: always + +# Setting this pref to |true| forces Bidi UI menu items and keyboard shortcuts +# to be exposed, and enables the directional caret hook. By default, only +# expose it for bidi-associated system locales. +- name: bidi.browser.ui + type: bool + value: false + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "browser." +#--------------------------------------------------------------------------- + +- name: browser.active_color + type: String + value: "#EE0000" + mirror: never + +- name: browser.active_color.dark + type: String + value: "#FF6666" + mirror: never + +- name: browser.anchor_color + type: String + value: "#0000EE" + mirror: never + +# If you change this, you probably also want to change +# nsXPLookAndFeel::GenericDarkColor for MozNativehyperlinktext. +- name: browser.anchor_color.dark + type: String + value: "#8C8CFF" + mirror: never + +# See http://dev.w3.org/html5/spec/forms.html#attr-fe-autofocus +- name: browser.autofocus + type: bool + value: true + mirror: always + +- name: browser.cache.disk.enable + type: RelaxedAtomicBool + value: true + mirror: always + +- name: browser.cache.memory.enable + type: RelaxedAtomicBool + value: true + mirror: always + +# Limit of recent metadata we keep in memory for faster access, in KB. +- name: browser.cache.disk.metadata_memory_limit + type: RelaxedAtomicUint32 + value: 250 # 0.25 MB + mirror: always + +# Does the user want smart-sizing? +- name: browser.cache.disk.smart_size.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Disk cache capacity in kilobytes. It's used only when +# browser.cache.disk.smart_size.enabled == false +- name: browser.cache.disk.capacity + type: RelaxedAtomicUint32 + value: 256000 + mirror: always + +# -1 = determine dynamically, 0 = none, n = memory capacity in kilobytes. +- name: browser.cache.memory.capacity + type: RelaxedAtomicInt32 + value: -1 + mirror: always + +# When smartsizing is disabled we could potentially fill all disk space by +# cache data when the disk capacity is not set correctly. To avoid that we +# check the free space every time we write some data to the cache. The free +# space is checked against two limits. Once the soft limit is reached we start +# evicting the least useful entries, when we reach the hard limit writing to +# the entry fails. +- name: browser.cache.disk.free_space_soft_limit + type: RelaxedAtomicUint32 + value: 5 * 1024 # 5MB + mirror: always + +- name: browser.cache.disk.free_space_hard_limit + type: RelaxedAtomicUint32 + value: 1024 # 1MB + mirror: always + +# The number of chunks we preload ahead of read. One chunk currently has +# 256kB. +- name: browser.cache.disk.preload_chunk_count + type: RelaxedAtomicUint32 + value: 4 # 1 MB of read ahead + mirror: always + +# Max-size (in KB) for entries in disk cache. Set to -1 for no limit. +# (Note: entries bigger than 1/8 of disk-cache are never cached) +- name: browser.cache.disk.max_entry_size + type: RelaxedAtomicUint32 + value: 50 * 1024 # 50 MB + mirror: always + +# Max-size (in KB) for entries in memory cache. Set to -1 for no limit. +# (Note: entries bigger than than 90% of the mem-cache are never cached.) +- name: browser.cache.memory.max_entry_size + type: RelaxedAtomicInt32 + value: 5 * 1024 + mirror: always + +# Memory limit (in kB) for new cache data not yet written to disk. Writes to +# the cache are buffered and written to disk on background with low priority. +# With a slow persistent storage these buffers may grow when data is coming +# fast from the network. When the amount of unwritten data is exceeded, new +# writes will simply fail. We have two buckets, one for important data +# (priority) like html, css, fonts and js, and one for other data like images, +# video, etc. +# Note: 0 means no limit. +- name: browser.cache.disk.max_chunks_memory_usage + type: RelaxedAtomicUint32 + value: 40 * 1024 + mirror: always +- name: browser.cache.disk.max_priority_chunks_memory_usage + type: RelaxedAtomicUint32 + value: 40 * 1024 + mirror: always + + +# Number of seconds the cache spends writing pending data and closing files +# after shutdown has been signalled. Past that time data is not written and +# files are left open for the OS to clean up. +- name: browser.cache.max_shutdown_io_lag + type: RelaxedAtomicUint32 + value: 2 + mirror: always + +# After the max_shutdown_io_lag has passed, we will attempt to cancel +# blocking IO (on windows). The CacheIOThread may pick up more blocking +# tasks so we want to cancel those too. The main thread will be woken +# up every shutdown_io_time_between_cancellations_ms to cancel the IO +# on the other thread. +- name: browser.cache.shutdown_io_time_between_cancellations_ms + type: RelaxedAtomicUint32 + value: 5 + mirror: always + +# A percentage limit for media content type in the disk cache. When some entries +# need to be evicted and media is over the limit, it's evicted first. +- name: browser.cache.disk.content_type_media_limit + type: RelaxedAtomicInt32 + value: 50 + mirror: always + +# How often to validate document in cache +# 0 = once-per-session, +# 1 = each-time, +# 2 = never, +# 3 = when-appropriate/automatically +- name: browser.cache.check_doc_frequency + type: RelaxedAtomicUint32 + value: 3 + mirror: always + +# Compression level for cached JavaScript bytecode +# 0 = do not compress, +# 1 = minimal compression, +# 9 = maximal compression +- name: browser.cache.jsbc_compression_level + type: RelaxedAtomicUint32 + value: 0 + mirror: always + +# Whether tooltips are enabled. +- name: browser.chrome.toolbar_tips + type: bool + value: true + mirror: always + +# Whether tooltips are hidden on keydown. +# 0: never +# 1: always +# 2: only on non-modifier keys +- name: browser.chrome.toolbar_tips.hide_on_keydown + type: uint32_t +#if defined(XP_WIN) + value: 0 +#else + value: 2 +#endif + mirror: always + +# Content analysis by external applications, e.g. data-loss prevention apps +- name: browser.contentanalysis.enabled + type: bool + value: false + mirror: never + +# Whether content analysis should allow content if there is a problem communicating +# with the agent. +- name: browser.contentanalysis.default_allow + type: bool + value: false + mirror: never + +# Is the IPC pipe to the DLP tool specific to the user or to the system? +- name: browser.contentanalysis.is_per_user + type: bool + value: true + mirror: never + +# Path name of pipe used to connect to a configured DLP agent. +- name: browser.contentanalysis.pipe_path_name + type: String + value: "path_user" + mirror: never + +# Should CA ignore the system setting and use silent notifications? +- name: browser.contentanalysis.silent_notifications + type: bool + value: false + mirror: always + +# Content blocking for Enhanced Tracking Protection +- name: browser.contentblocking.database.enabled + type: bool + value: false + mirror: always + +# How many recent block/unblock actions per origins we remember in the +# Content Blocking log for each top-level window. +- name: browser.contentblocking.originlog.length + type: uint32_t + value: 32 + mirror: always + +# Min font device pixel size at which to turn on high quality. +- name: browser.display.auto_quality_min_font_size + type: RelaxedAtomicUint32 + value: 20 + mirror: always + +- name: browser.display.background_color + type: String + value: "#FFFFFF" + mirror: never + +- name: browser.display.background_color.dark + type: String + value: "#1C1B22" + mirror: never + +# This preference is a bit confusing because we use the opposite +# string value in the colors dialog to indicate to users how FF HCM +# will behave. +# With resect to document colors, these values mean: +# 0 = "default" = always, except in high contrast mode +# 1 = "always" +# 2 = "never" +# +# On windows, we set this to 0, which means FF HCM will mirror OS HCM. +# Everywhere else, we set this to 1, disabling FF HCM. +- name: browser.display.document_color_use + type: RelaxedAtomicUint32 +#if defined(XP_WIN) + value: 0 +#else + value: 1 +#endif + mirror: always + rust: true + +# 0 = always native +# 1 = never native +# other = default +- name: browser.display.windows.non_native_menus + type: RelaxedAtomicUint32 + value: 2 + mirror: always + rust: true + +# This pref dictates whether or not backplates and background images +# are to be drawn, when in high-contrast mode: +# false: do not draw backplates or render background images +# true: render background images and draw backplates +# This condition is only considered when high-contrast mode is enabled +# in Firefox, ie. when the user has: +# (1) mUseAccessibilityMode set to true (Widows high-contrast mode is on) +# AND browser.display.document_color_use set to 0 +# (only with high-contrast themes) OR +# (2) browser.display.document_color_use set to 2 (always) +- name: browser.display.permit_backplate + type: RelaxedAtomicBool + value: true + mirror: always + rust: true + +# Whether we should suppress the background-image of the canvas (the root +# frame) if we're in forced colors mode. +# +# This is important because some sites use background-image with a plain color +# and it causes undesirable results in high-contrast mode. +# +# See bug 1614921 for example. +- name: browser.display.suppress_canvas_background_image_on_forced_colors + type: bool + value: true + mirror: always + +- name: browser.display.foreground_color + type: String + value: "#000000" + mirror: never + +- name: browser.display.foreground_color.dark + type: String + value: "#FBFBFE" + mirror: never + +# Determines the behavior of OS zoom settings. +# +# 0: doesn't affect rendering at all +# 1: affects full zoom (dpi, effectively). +# 2: affects text zoom. +# +# Default is (1): Historical behavior on Linux, matches other browsers on +# Windows, and generally creates more consistent rendering. +- name: browser.display.os-zoom-behavior + type: RelaxedAtomicInt32 + value: 1 + mirror: always + rust: true + +# Whether focus rings are always shown by default. +# +# This is the initial value of nsWindowRoot::mShowFocusRings, but it can be +# overridden by system preferences. +- name: browser.display.show_focus_rings + type: bool + value: false + mirror: always + +# Enable showing image placeholders while image is loading or when image is broken. +- name: browser.display.show_image_placeholders + type: bool + value: true + mirror: always + +# Whether we should always enable focus rings after focus was moved by keyboard. +# +# This behavior matches both historical and GTK / Windows focus behavior. +# +# :focus-visible is intended to provide better heuristics than this. +- name: browser.display.always_show_rings_after_key_focus + type: bool + value: false + mirror: always + +# In theory: 0 = never, 1 = quick, 2 = always, though we always just use it as +# a bool! +- name: browser.display.use_document_fonts + type: RelaxedAtomicInt32 + value: 1 + mirror: always + rust: true + +# font-family names for which we'll override use_document_fonts=0, and always +# use the specified font. +# This is to support ligature-icon fonts, which render literal strings like +# "arrow_drop_down" with an icon, even when use_document_fonts is disabled. +# If an author provides & uses such a font, and we decline to use it, we'll end +# up rendering these literal strings where the author intended an icon, which +# can cause all sorts of overlapping/unreadable content. +- name: browser.display.use_document_fonts.icon_font_allowlist + type: String + value: >- + Material Icons, + Material Icons Extended, + Material Icons Outlined, + Material Icons Round, + Material Icons Sharp, + Material Icons Two Tone, + Google Material Icons, + Material Symbols Outlined, + Material Symbols Round, + Material Symbols Rounded, + Material Symbols Sharp + mirror: never + +- name: browser.display.use_system_colors + type: RelaxedAtomicBool +#ifdef XP_WIN + value: true +#else + value: false +#endif + mirror: always + +- name: browser.dom.window.dump.enabled + type: RelaxedAtomicBool + value: @IS_NOT_MOZILLA_OFFICIAL@ + mirror: always + +# See bug 1738574 +- name: browser.download.start_downloads_in_tmp_dir + type: bool + value: false + mirror: always + +# See bug 1747343 +- name: browser.download.always_ask_before_handling_new_types + type: bool + value: false + mirror: always + +# See bug 1731668 +- name: browser.download.enable_spam_prevention + type: bool + value: false + mirror: always + +# See bug 1772569 +- name: browser.download.open_pdf_attachments_inline + type: bool + value: false + mirror: always + +# See bug 1811830 +- name: browser.download.force_save_internally_handled_attachments + type: bool + value: false + mirror: always + +- name: browser.download.sanitize_non_media_extensions + type: bool + value: true + mirror: always + +# Image document's automatic image sizing. +- name: browser.enable_automatic_image_resizing + type: bool + value: true + mirror: always + +# Image document's click-to-resize. +- name: browser.enable_click_image_resizing + type: bool + value: @IS_NOT_ANDROID@ + mirror: always + +- name: browser.find.ignore_ruby_annotations + type: bool + value: true + mirror: always + +#if defined(XP_MACOSX) +# Whether pressing Esc will exit fullscreen. +- name: browser.fullscreen.exit_on_escape + type: bool + value: true + mirror: always +#endif + +# The max url length we'll store in history. +# +# The default value is mostly a guess based on various facts: +# +# * IE didn't support urls longer than 2083 chars +# * Sitemaps protocol used to support a maximum of 2048 chars +# * Various SEO guides suggest to not go over 2000 chars +# * Various apps/services are known to have issues over 2000 chars +# * RFC 2616 - HTTP/1.1 suggests being cautious about depending +# on URI lengths above 255 bytes +# +- name: browser.history.maxUrlLength + type: uint32_t + value: 2000 + mirror: always + +# Max size of push/replaceState data parameter +- name: browser.history.maxStateObjectSize + type: int32_t + value: 16777216 + mirror: always + +# True to collect wireframes upon navigations / pushState +- name: browser.history.collectWireframes + type: bool + value: false + mirror: always + +# The minimum area for a rect to be included in a wireframe, in CSS pixels. +# +# The current value of 50 is pretty arbitrary, and will be tuned as we refine +# and test the wireframing capability. +- name: browser.history.wireframeAreaThreshold + type: uint32_t + value: 50 + mirror: always + +#if defined(XP_WIN) || defined(XP_LINUX) + # Notify TabUnloader or send the memory pressure if the memory resource + # notification is signaled AND the available commit space is lower than + # this value. +- name: browser.low_commit_space_threshold_mb + type: RelaxedAtomicUint32 + value: 200 + mirror: always +#endif + +#ifdef XP_LINUX + # On Linux we also check available memory in comparison to total memory, + # and use this percent value (out of 100) to determine if we are in a + # low memory scenario. +- name: browser.low_commit_space_threshold_percent + type: RelaxedAtomicUint32 + value: 5 + mirror: always +#endif + +# Render animations and videos as a solid color +- name: browser.measurement.render_anims_and_video_solid + type: RelaxedAtomicBool + value: false + mirror: always + +- name: browser.navigation.requireUserInteraction + type: bool + value: false + mirror: always + +# Indicates if about:newtab shows content (enabled) or just blank. +- name: browser.newtabpage.enabled + type: bool + value: true + mirror: always + +# Open PDFs in Edge with the --app flag if it is the default. +- name: browser.pdf.launchDefaultEdgeAsApp + type: bool + value: true + mirror: always + +# Maximium delay between keystrokes that will be considered typing (milliseconds). +- name: browser.places.interactions.typing_timeout_ms + type: RelaxedAtomicUint32 + value: 3000 + mirror: always + +# Maximum delay between scroll input events that will be considered a scrolling interaction (milliseconds). +- name: browser.places.interactions.scrolling_timeout_ms + type: RelaxedAtomicUint32 + value: 5000 + mirror: always + +# Number of seconds till the sponsored session is timeout. +- name: browser.places.sponsoredSession.timeoutSecs + type: RelaxedAtomicUint32 + value: 3600 + mirror: always + +# Whether to start the private browsing mode at application startup +- name: browser.privatebrowsing.autostart + type: bool + value: false + mirror: always + +# Force usage of in-memory (rather than file on disk) media cache for video streaming when private browsing +- name: browser.privatebrowsing.forceMediaMemoryCache + type: bool + value: false + mirror: always + +# Communicates the toolbar color to platform (for e.g., prefers-color-scheme). +# +# Returns whether the toolbar is dark (0), light (1), or system (2). The +# theming code overrides it if appropriate. +- name: browser.theme.toolbar-theme + type: RelaxedAtomicUint32 + value: 2 + mirror: always + +# Communicates the preferred content theme color to platform (for e.g., +# prefers-color-scheme). +# +# dark (0), light (1), system (2), or toolbar (3). +# +# Default to "toolbar", the theming code sets it appropriately. +- name: browser.theme.content-theme + type: RelaxedAtomicUint32 + value: 2 + mirror: always + rust: true + +# Whether the firefox titlebar respects the +# -moz-windows-accent-color-in-titlebar setting on the tab strip. +- name: browser.theme.windows.accent-color-in-tabs.enabled + type: RelaxedAtomicBool + value: false + mirror: always + rust: true + +# Blocked plugin content +- name: browser.safebrowsing.blockedURIs.enabled + type: bool + value: true + mirror: always + +# Malware protection +- name: browser.safebrowsing.malware.enabled + type: bool + value: true + mirror: always + +# Phishing protection +- name: browser.safebrowsing.phishing.enabled + type: bool + value: true + mirror: always + +# Maximum size for an array to store the safebrowsing prefixset. +- name: browser.safebrowsing.prefixset_max_array_size + type: RelaxedAtomicUint32 + value: 512*1024 + mirror: always + +# SessionStore prefs +# Maximum number of bytes of DOMSessionStorage data we collect per origin. +- name: browser.sessionstore.dom_storage_limit + type: uint32_t + value: 2048 + mirror: always + +# Maximum number of characters of form field data per field we collect. +- name: browser.sessionstore.dom_form_limit + type: uint32_t + value: 1024*1024*2 + mirror: always + +# Maximum number of characters of form data we collect per origin. +- name: browser.sessionstore.dom_form_max_limit + type: uint32_t + value: 1024*1024*50 + mirror: always + +# Minimal interval between two save operations in milliseconds (while the user is active). +- name: browser.sessionstore.interval + type: RelaxedAtomicUint32 + value: 15000 + mirror: always + +# Platform collection of data for session store +- name: browser.sessionstore.platform_collection + type: bool +#if defined(ANDROID) || defined(MOZ_THUNDERBIRD) + value: false +#else + value: true +#endif + mirror: once + +# Platform collection of session storage data for session store +- name: browser.sessionstore.collect_session_storage + type: bool + value: @IS_NOT_ANDROID@ + mirror: once + +# Platform collection of zoom data for session store +- name: browser.sessionstore.collect_zoom + type: bool + value: @IS_NOT_ANDROID@ + mirror: once + +# Causes SessionStore to ignore non-final update messages from +# browser tabs that were not caused by a flush from the parent. +# This is a testing flag and should not be used by end-users. +- name: browser.sessionstore.debug.no_auto_updates + type: RelaxedAtomicBool + value: false + mirror: always + +# Whether we should draw the tabs on top of the titlebar. +# +# no (0), yes (1), or default (2), which is true everywhere except Linux. +- name: browser.tabs.inTitlebar + type: int32_t + value: 2 + mirror: always + +# If set, use DocumentChannel to directly initiate loads entirely +# from parent-process BrowsingContexts +- name: browser.tabs.documentchannel.parent-controlled + type: bool + value: false + mirror: always + +# Testing-only pref which makes data: URIs be loaded in a "web" content process +# instead of within a process based on the URI's loader. +- name: browser.tabs.remote.dataUriInDefaultWebProcess + type: bool + value: false + mirror: always + +# Testing-only pref to force system-triggered about:blank loads to not change +# content processes. This is used for performance tests which load an +# about:blank document between navigations for historical reasons to avoid +# unnecessary process switches. +- name: browser.tabs.remote.systemTriggeredAboutBlankAnywhere + type: bool + value: false + mirror: always + +# Testing-only pref to cause PBrowser creation for a specific BrowsingContext to +# fail, to test the errored codepath. +- name: browser.tabs.remote.testOnly.failPBrowserCreation.enabled + type: bool + value: false + mirror: always + +- name: browser.tabs.remote.force-paint + type: bool + value: true + mirror: always + +# When this pref is enabled document loads with a mismatched +# Cross-Origin-Embedder-Policy header will fail to load +- name: browser.tabs.remote.useCrossOriginEmbedderPolicy + type: RelaxedAtomicBool + value: true + mirror: always + +# This pref makes `credentialless` a valid value for +# Cross-Origin-Embedder-Policy header +- name: browser.tabs.remote.coep.credentialless + type: RelaxedAtomicBool +#if defined(ANDROID) + value: @IS_NIGHTLY_BUILD@ +#else + value: true +#endif + mirror: always + do_not_use_directly: true + +# When this pref is enabled top level loads with a mismatched +# Cross-Origin-Opener-Policy header will be loaded in a separate process. +- name: browser.tabs.remote.useCrossOriginOpenerPolicy + type: RelaxedAtomicBool + value: true + mirror: always + +# When this pref is enabled then we use a separate content process for +# top-level load of file:// URIs +- name: browser.tabs.remote.separateFileUriProcess + type: RelaxedAtomicBool +#if !defined(ANDROID) + value: true +#else + value: false +#endif + mirror: always + +# Pref to control whether we use a separate privileged content process +# for certain mozilla webpages (which are listed in the pref +# browser.tabs.remote.separatedMozillaDomains). +- name: browser.tabs.remote.separatePrivilegedMozillaWebContentProcess + type: bool + value: false + mirror: always + +# Whether or not process selection for subframes will prefer re-using an +# existing content process over creating a new one. Enabling this pref should +# reduce the number of processes allocated for non-first-party domains if +# dom.ipc.processCount.webIsolated > 1. +- name: browser.tabs.remote.subframesPreferUsed + type: bool + value: true + mirror: always + +# When this pref is enabled, opaque response is only allowed to enter the +# content process if it's a response for media (audio, image, video), CSS, or +# JavaScript. +- name: browser.opaqueResponseBlocking + type: RelaxedAtomicBool +#if defined(ANDROID) + value: false +#else + value: true +#endif + mirror: always + +# When this pref is enabled, the JS validator will be enabled for +# ORB. +- name: browser.opaqueResponseBlocking.javascriptValidator + type: bool + value: true + mirror: always + +# This pref controls how filtering of opaque responses for calls to `Window.fetch`. +# (and similar) is performed in the parent process. This is intended to make sure +# that data that would be filtered in a content process never actually reaches that +# content process. +# See https://fetch.spec.whatwg.org/#concept-filtered-response-opaque +# 0) Don't filter in the parent process at all, and let content processes handle +# opaque filtering. Regardless of if ORB is enabled or not. N.B. that if ORB +# is enabled opaque responses will be blocked. +# 1) If ORB is enabled, in the parent process, filter the responses that ORB allows. +# N.B. any responses ORB doesn't allow will not send data to a content process +# since they will return a NetworkError. If the request is allowed by ORB, the +# internal response will be intact and sent to the content process as is. +# 2) If ORB is enabled, in the parent process, filter the responses that ORB blocks, +# when they were issued by `Window.fetch` (and similar). +# 3) Filter all responses in the parent, regardless of if ORB is enabled or not. +# This means that opaque responses coming from `Window.fetch` won't even be +# considered for being blocked by ORB. +- name: browser.opaqueResponseBlocking.filterFetchResponse + type: uint32_t + value: 2 + mirror: always + do_not_use_directly: true + +# This pref controls how exceptions to opaque response blocking for the media MIME types +# `audio/*` and `video/*` are handled. This is because step 8 in the spec that performs +# audio or video type pattern matching cannot handle certain MIME types (yet). +# See https://whatpr.org/fetch/1442.html#orb-algorithm +# 0) No exceptions +# 1) Some exceptions, explicitly hard coded in `IsOpaqueSafeListedSpecBreakingMIMEType` +# 2) Allow all MIME types beginning with `audio/*` or `video/*`. +- name: browser.opaqueResponseBlocking.mediaExceptionsStrategy + type: uint32_t + value: 1 + mirror: always + do_not_use_directly: true + +# When true, zooming will be enabled on all sites, even ones that declare +# user-scalable=no. +- name: browser.ui.zoom.force-user-scalable + type: RelaxedAtomicBool + value: false + mirror: always + +- name: browser.viewport.desktopWidth + type: RelaxedAtomicInt32 + value: 980 + mirror: always + +- name: browser.visited_color + type: String + value: "#551A8B" + mirror: never + +# If you change this, you probably also want to change +# nsXPLookAndFeel::GenericDarkColor for MozNativevisitedhyperlinktext. +- name: browser.visited_color.dark + type: String + value: "#FFADFF" + mirror: never + +# When true, soft reloads (including location.reload()) +# will only froce validate the top level document, subresources will +# be loaded normally as-if users normally navigated to the page. +- name: browser.soft_reload.only_force_validate_top_level_document + type: bool + value: true + mirror: always + +# Whether or not to save and restore zoom levels on a per-site basis. +- name: browser.zoom.siteSpecific + type: bool + value: @IS_NOT_ANDROID@ + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "channelclassifier." +#--------------------------------------------------------------------------- + +- name: channelclassifier.allowlist_example + type: bool + value: false + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "clipboard." +#--------------------------------------------------------------------------- + +# Clipboard behavior. +- name: clipboard.autocopy + type: bool +#if !defined(ANDROID) && !defined(XP_MACOSX) && defined(XP_UNIX) + value: true +#else + value: false +#endif + mirror: always + +#ifdef XP_WIN + # allow to copy clipboard data to Clipboard History/Cloud + # (used on sensitive data in about:logins and Private Browsing) +- name: clipboard.copyPrivateDataToClipboardCloudOrHistory + type: bool + value: false + mirror: always + + # Whether to put a file promise onto the clipboard when copying images on Windows +- name: clipboard.imageAsFile.enabled + type: bool + value: @IS_NOT_EARLY_BETA_OR_EARLIER@ + mirror: always +#endif + +#--------------------------------------------------------------------------- +# Prefs starting with "consoleservice." +#--------------------------------------------------------------------------- + +#if defined(ANDROID) + # Disable sending console to logcat on release builds. +- name: consoleservice.logcat + type: RelaxedAtomicBool + value: @IS_NOT_RELEASE_OR_BETA@ + mirror: always +#endif + +#--------------------------------------------------------------------------- +# Prefs starting with "content." +#--------------------------------------------------------------------------- + +- name: content.cors.disable + type: bool + value: false + mirror: always + +# Back off timer notification after count. +# -1 means never. +- name: content.notify.backoffcount + type: int32_t + value: -1 + mirror: always + +# Notification interval in microseconds. +# The notification interval has a dramatic effect on how long it takes to +# initially display content for slow connections. The current value +# provides good incremental display of content without causing an increase +# in page load time. If this value is set below 1/10 of a second it starts +# to impact page load performance. +# See bugzilla bug 72138 for more info. +- name: content.notify.interval + type: int32_t + value: 120000 + mirror: always + +# Do we notify based on time? +- name: content.notify.ontimer + type: bool + value: true + mirror: always + +# How many times to deflect in interactive mode. +- name: content.sink.interactive_deflect_count + type: int32_t + value: 0 + mirror: always + +# How many times to deflect in perf mode. +- name: content.sink.perf_deflect_count + type: int32_t + value: 200 + mirror: always + +# Parse mode for handling pending events. +# 0 = don't check for pending events +# 1 = don't deflect if there are pending events +# 2 = bail if there are pending events +- name: content.sink.pending_event_mode + type: int32_t +#ifdef XP_WIN + value: 1 +#else + value: 0 +#endif + mirror: always + +# How often to probe for pending events. 1 = every token. +- name: content.sink.event_probe_rate + type: int32_t + value: 1 + mirror: always + +# How long to stay off the event loop in interactive mode (microseconds). +- name: content.sink.interactive_parse_time + type: int32_t + value: 3000 + mirror: always + +# How long to stay off the event loop in perf mode. +- name: content.sink.perf_parse_time + type: int32_t + value: 30000 + mirror: always + +# How long to be in interactive mode after an event. +- name: content.sink.interactive_time + type: uint32_t + value: 750000 + mirror: always + +# How long to stay in perf mode after initial loading. +- name: content.sink.initial_perf_time + type: uint32_t + value: 2000000 + mirror: always + +# Should we switch between perf-mode and interactive-mode? +# 0 = Switch +# 1 = Interactive mode +# 2 = Perf mode +- name: content.sink.enable_perf_mode + type: int32_t + value: 0 + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "converter." +#--------------------------------------------------------------------------- + +# Whether we include ruby annotation in the text despite whether it +# is requested. This was true because we didn't explicitly strip out +# annotations. Set false by default to provide a better behavior, but +# we want to be able to pref-off it if user doesn't like it. +- name: converter.html2txt.always_include_ruby + type: bool + value: false + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "cookiebanners." +#--------------------------------------------------------------------------- + +# Controls the cookie banner handling mode in normal browsing. +# 0: Disables all cookie banner handling. +# 1: Reject-all if possible, otherwise do nothing. +# 2: Reject-all if possible, otherwise accept-all. +- name: cookiebanners.service.mode + type: uint32_t + value: 0 + mirror: always + +# When set to true, cookie banners are detected and detection events are +# dispatched, but they will not be handled. Requires the service to be enabled +# for the desired mode via pref cookiebanners.service.mode* +- name: cookiebanners.service.detectOnly + type: bool + value: false + mirror: always + +# Controls the cookie banner handling mode in private browsing. Same mode +# options as the normal browsing pref above. +- name: cookiebanners.service.mode.privateBrowsing + type: uint32_t + value: 0 + mirror: always + +# Enables use of global CookieBannerRules, which apply to all sites. This is +# used for click rules that can handle common Consent Management Providers +# (CMP). +# Enabling this (when the cookie handling feature is enabled) may negatively +# impact site performance since it requires us to run rule-defined query +# selectors for every page. +- name: cookiebanners.service.enableGlobalRules + type: bool + value: true + mirror: always + +# Whether global rules are allowed to run in sub-frames. Running query selectors +# in every sub-frame may negatively impact performance, but is required for some +# CMPs. +- name: cookiebanners.service.enableGlobalRules.subFrames + type: bool + value: true + mirror: always + +# Enables the cookie banner cookie injector. The cookie banner cookie injector +# depends on the `cookiebanners.service.mode` pref above. +- name: cookiebanners.cookieInjector.enabled + type: bool + value: true + mirror: always + +# By default, how many seconds in the future cookies should expire after they +# have been injected. Defaults to 12 months. Individual cookie rules may +# override this. +- name: cookiebanners.cookieInjector.defaultExpiryRelative + type: uint32_t + value: 31536000 + mirror: always + +# How many times per site and site load to check for cookie banners after which +# the mechanism is considered on cooldown for the site in the current browsing +# session. If the threshold is set to zero, banner clicking won't be considered +# as being on cooldown regardless of how many times the site is loaded. The +# maximum value for the retry is 255, any value over than that will be capped. +- name: cookiebanners.bannerClicking.maxTriesPerSiteAndSession + type: uint32_t + value: 3 + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "datareporting." +#--------------------------------------------------------------------------- + +- name: datareporting.healthreport.uploadEnabled + type: RelaxedAtomicBool + value: false + mirror: always + rust: true + +#--------------------------------------------------------------------------- +# Prefs starting with "device." +#--------------------------------------------------------------------------- + +# Is support for the device sensors API enabled? +- name: device.sensors.enabled + type: bool + value: true + mirror: always + +# KaiOS-only, see https://bugzilla.mozilla.org/show_bug.cgi?id=1699707#c10 +- name: device.sensors.ambientLight.enabled + type: bool + value: false + mirror: always + +- name: device.sensors.motion.enabled + type: bool + value: true + mirror: always + +- name: device.sensors.orientation.enabled + type: bool + value: true + mirror: always + +# KaiOS-only, see https://bugzilla.mozilla.org/show_bug.cgi?id=1699707#c10 +- name: device.sensors.proximity.enabled + type: bool + value: false + mirror: always + +- name: device.sensors.test.events + type: bool + value: false + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "devtools." +#--------------------------------------------------------------------------- + +- name: devtools.console.stdout.chrome + type: RelaxedAtomicBool + value: @IS_NOT_MOZILLA_OFFICIAL@ + mirror: always + +- name: devtools.console.stdout.content + type: RelaxedAtomicBool + value: false + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "docshell." +#--------------------------------------------------------------------------- + +# Used to indicate whether session history listeners should be notified +# about content viewer eviction. Used only for testing. +- name: docshell.shistory.testing.bfevict + type: bool + value: false + mirror: always + +# If true, pages with an opener won't be bfcached. +- name: docshell.shistory.bfcache.require_no_opener + type: bool + value: @IS_ANDROID@ + mirror: always + +# If true, page with beforeunload or unload event listeners can be bfcached. +- name: docshell.shistory.bfcache.allow_unload_listeners + type: bool + value: @IS_ANDROID@ + mirror: always + +# If true, page with beforeunload event listeners can be bfcached. +# This only works when sessionHistoryInParent is enabled. +- name: docshell.shistory.bfcache.ship_allow_beforeunload_listeners + type: bool + value: true + mirror: always + +#--------------------------------------------------------------------------- +# Prefs starting with "dom." +#--------------------------------------------------------------------------- + +# Allow cut/copy +- name: dom.allow_cut_copy + type: bool + value: true + mirror: always + +# Checks if offscreen animation throttling is enabled. +- name: dom.animations.offscreen-throttling + type: bool + value: true + mirror: always + +# Is support for composite operations from the Web Animations API enabled? +- name: dom.animations-api.compositing.enabled + type: bool + value: true + mirror: always + +# Is support for timelines from the Web Animations API enabled? +- name: dom.animations-api.timelines.enabled + type: bool + value: true + mirror: always + +# Is support for Navigator.getBattery enabled? +- name: dom.battery.enabled + type: bool + value: true + mirror: always + +# Block multiple external protocol URLs in iframes per single event. +- name: dom.block_external_protocol_in_iframes + type: bool + value: true + mirror: always + +# Block sandboxed BrowsingContexts from navigating to external protocols. +- name: dom.block_external_protocol_navigation_from_sandbox + type: bool + value: true + mirror: always + +# Block Insecure downloads from Secure Origins +- name: dom.block_download_insecure + type: bool + value: true + mirror: always + +# Block multiple window.open() per single event. +- name: dom.block_multiple_popups + type: bool + value: true + mirror: always + +# The maximum number of popup that is allowed to be opened. Set to -1 for no +# limit. +- name: dom.popup_maximum + type: int32_t + value: 20 + mirror: always + +# Whether window.location.reload() and window.history.go(0) should be blocked +# when called directly from a window resize event handler. +# +# This used to be necessary long ago to prevent terrible UX when using stuff +# like TypeAheadFind (bug 258917), but it also causes compat issues on mobile +# (bug 1570566). +- name: dom.block_reload_from_resize_event_handler + type: bool + value: false + mirror: always + + # Enable CacheAPI in private browsing mode with encryption +- name: dom.cache.privateBrowsing.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Exposes window.caches and skips SecureContext check. +# dom.serviceWorkers.testing.enabled also includes the same effect. +- name: dom.caches.testing.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Disable capture attribute for input elements; only supported on GeckoView. +- name: dom.capture.enabled + type: bool + value: false + mirror: always + +# HTML specification says the level should be 5 +# https://html.spec.whatwg.org/#timer-initialisation-steps +- name: dom.clamp.timeout.nesting.level + type: uint32_t + value: 5 + mirror: once + +# Disable custom highlight API; implementation pending. +- name: dom.customHighlightAPI.enabled + type: RelaxedAtomicBool + value: @IS_NIGHTLY_BUILD@ + mirror: always + rust: true + +# Allow control characters appear in composition string. +# When this is false, control characters except +# CHARACTER TABULATION (horizontal tab) are removed from +# both composition string and data attribute of compositionupdate +# and compositionend events. +- name: dom.compositionevent.allow_control_characters + type: bool + value: false + mirror: always + +# Compression Streams (CompressionStream/DecompressionStream) +- name: dom.compression_streams.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Is support for CSSPseudoElement enabled? +- name: dom.css_pseudo_element.enabled + type: bool + value: false + mirror: always + +# After how many seconds we allow external protocol URLs in iframe when not in +# single events +- name: dom.delay.block_external_protocol_in_iframes + type: uint32_t + value: 10 # in seconds + mirror: always + +# Whether the above pref has any effect at all. +# Make sure cases like bug 1795380 work before trying to turn this off. See +# bug 1680721 for some other context that might be relevant. +- name: dom.delay.block_external_protocol_in_iframes.enabled + type: bool + value: true + mirror: always + +# Only propagate the open window click permission if the setTimeout() is equal +# to or less than this value. +- name: dom.disable_open_click_delay + type: int32_t + value: 1000 + mirror: always + +- name: dom.disable_open_during_load + type: bool + value: false + mirror: always + +- name: dom.disable_beforeunload + type: bool + value: false + mirror: always + +- name: dom.require_user_interaction_for_beforeunload + type: bool + value: true + mirror: always + +# Enable/disable Gecko specific edit commands +- name: dom.document.edit_command.contentReadOnly.enabled + type: bool + value: @IS_NOT_EARLY_BETA_OR_EARLIER@ + mirror: always + +- name: dom.document.edit_command.insertBrOnReturn.enabled + type: bool + value: @IS_NOT_EARLY_BETA_OR_EARLIER@ + mirror: always + +# If set this to true, `Document.execCommand` may be performed nestedly. +# Otherwise, nested calls just return false. +- name: dom.document.exec_command.nested_calls_allowed + type: bool + value: false + mirror: always + +- name: dom.domrequest.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Only intended for fuzzing purposes, this will break mozPrintCallback, etc. +- name: dom.window_print.fuzzing.block_while_printing + type: bool + value: false + mirror: always + +- name: dom.element.transform-getters.enabled + type: bool + value: false + mirror: always + +# Whether the popover attribute implementation is enabled, +# see https://html.spec.whatwg.org/#the-popover-attribute +- name: dom.element.popover.enabled + type: RelaxedAtomicBool + value: @IS_NIGHTLY_BUILD@ + mirror: always + rust: true + +# Whether the blocking attribute implementation is enabled, +# see https://html.spec.whatwg.org/#blocking-attributes +- name: dom.element.blocking.enabled + type: bool + value: false + mirror: always + +# Whether CustomStateSet is enabled +- name: dom.element.customstateset.enabled + type: RelaxedAtomicBool + value: false + mirror: always + rust: true + +# Whether the invoketarget attribute implementation is enabled +- name: dom.element.invokers.enabled + type: bool + value: false + mirror: always + +- name: dom.mouse_capture.enabled + type: bool + value: true + mirror: always + +# Is support for Performance.mozMemory enabled? +- name: dom.enable_memory_stats + type: bool + value: false + mirror: always + +# Enable Performance API +# Whether nonzero values can be returned from performance.timing.* +- name: dom.enable_performance + type: RelaxedAtomicBool + value: true + mirror: always + +# Enable Performance Observer API +- name: dom.enable_performance_observer + type: RelaxedAtomicBool + value: true + mirror: always + +# Whether resource timing will be gathered and returned by performance.GetEntries* +- name: dom.enable_resource_timing + type: bool + value: true + mirror: always + +# Whether event timing will be gathered and returned by performance observer* +- name: dom.enable_event_timing + type: RelaxedAtomicBool + value: true + mirror: always + +# Whether the LargestContentfulPaint API will be gathered and returned by performance observer* +- name: dom.enable_largest_contentful_paint + type: RelaxedAtomicBool + value: true + mirror: always + +# Whether performance.GetEntries* will contain an entry for the active document +- name: dom.enable_performance_navigation_timing + type: bool + value: true + mirror: always + +# Whether the scheduler interface will be exposed +- name: dom.enable_web_task_scheduling + type: RelaxedAtomicBool + value: @IS_NIGHTLY_BUILD@ + mirror: always + +# If this is true, it's allowed to fire "cut", "copy" and "paste" events. +# Additionally, "input" events may expose clipboard content when inputType +# is "insertFromPaste" or something. +- name: dom.event.clipboardevents.enabled + type: bool + value: true + mirror: always + +# Whether Shift+Right click force-opens the context menu +- name: dom.event.contextmenu.shift_suppresses_event + type: bool + value: true + mirror: always + +- name: dom.event.dragexit.enabled + type: bool + value: @IS_NOT_NIGHTLY_BUILD@ + mirror: always + +# If this pref is set to true, typing a surrogate pair causes one `keypress` +# event whose `charCode` stores the unicode code point over 0xFFFF. This is +# compatible with Safari and Chrome in non-Windows platforms. +# Otherwise, typing a surrogate pair causes two `keypress` events. This is +# compatible with legacy web apps which does +# `String.fromCharCode(event.charCode)`. +- name: dom.event.keypress.dispatch_once_per_surrogate_pair + type: bool + value: false + mirror: always + +# This is meaningful only when `dispatch_once_per_surrogate_pair` is false. +# If this pref is set to true, `.key` of the first `keypress` is set to the +# high-surrogate and `.key` of the other is set to the low-surrogate. +# Therefore, setting this exposing ill-formed UTF-16 string with `.key`. +# (And also `InputEvent.data` if pressed in an editable element.) +# Otherwise, `.key` of the first `keypress` is set to the surrogate pair, and +# `.key` of the second `keypress` is set to the empty string. +- name: dom.event.keypress.key.allow_lone_surrogate + type: bool + value: @IS_NOT_EARLY_BETA_OR_EARLIER@ + mirror: always + +# Whether wheel event target's should be grouped. When enabled, all wheel +# events that occur in a given wheel transaction have the same event target. +- name: dom.event.wheel-event-groups.enabled + type: bool + value: true + mirror: always + +# Whether WheelEvent should return pixels instead of lines for +# WheelEvent.deltaX/Y/Z, when deltaMode hasn't been checked. +# +# Other browsers don't use line deltas and websites forget to check for it, see +# bug 1392460. +- name: dom.event.wheel-deltaMode-lines.disabled + type: bool + value: true + mirror: always + +# Mostly for debugging. Whether we should do the same as +# dom.event.wheel-deltaMode-lines.disabled, but unconditionally rather than +# only when deltaMode hasn't been checked. +- name: dom.event.wheel-deltaMode-lines.always-disabled + type: bool + value: false + mirror: always + +# A blocklist (list of domains) for the +# dom.event.wheel-deltaMode-lines.disabled behavior, in case potential +# unforeseen problems with it arrive. +- name: dom.event.wheel-deltaMode-lines.always-enabled + type: String + value: "" + mirror: never + +#if defined(XP_MACOSX) +# Whether to disable treating ctrl click as right click +- name: dom.event.treat_ctrl_click_as_right_click.disabled + type: bool + value: @IS_NIGHTLY_BUILD@ + mirror: always +#endif + +# Whether Gecko keeps store or forgets the last deepest "enter" event target for +# the next "enter" or "leave" event dispatching when the last "over" event +# target is removed from the DOM tree. +- name: dom.events.mouse-pointer-boundary.keep-enter-targets-after-over-target-removed + type: bool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + +# Whether .offset{X,Y} for events targeted at SVG nodes returns bounds relative +# to the outer SVG. +- name: dom.events.offset-in-svg-relative-to-svg-root + type: bool + value: true + mirror: always + +# Control whether clipboard.read(), clipboard.write() and ClipboardItem are exposed +# to content. +- name: dom.events.asyncClipboard.clipboardItem + type: bool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + +# Skips checking permission and user activation when accessing the clipboard. +# Should only be enabled in tests. +# Access with Clipboard::IsTestingPrefEnabled(). +- name: dom.events.testing.asyncClipboard + type: bool + value: false + mirror: always + do_not_use_directly: true + +# Control whether `navigator.clipboard.readText()` is exposed to content. +- name: dom.events.asyncClipboard.readText + type: bool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + do_not_use_directly: true + +# This pref controls whether or not the `protected` dataTransfer state is +# enabled. If the `protected` dataTransfer stae is disabled, then the +# DataTransfer will be read-only whenever it should be protected, and will not +# be disconnected after a drag event is completed. +- name: dom.events.dataTransfer.protected.enabled + type: bool + value: false + mirror: always + +# Whether to hide normal files (i.e. non-images) in dataTransfer inside +# the content process. +- name: dom.events.dataTransfer.mozFile.enabled + type: bool + value: true + mirror: always + +- name: dom.events.dataTransfer.imageAsFile.enabled + type: bool + value: false + mirror: always + +# User interaction timer interval, in ms +- name: dom.events.user_interaction_interval + type: uint32_t + value: 5000 + mirror: always + +# Whether to try to compress touchmove events on IPC layer. +- name: dom.events.compress.touchmove + type: bool + value: true + mirror: always + +# In addition to the above IPC layer compresison, allow touchmove +# events to be further coalesced in the child side after they +# are sent. +- name: dom.events.coalesce.touchmove + type: bool + value: true + mirror: always + +# Allow mousemove events to be coalesced in the child side after they are sent. +- name: dom.events.coalesce.mousemove + type: bool + value: true + mirror: always + +# Whether to expose test interfaces of various sorts +- name: dom.expose_test_interfaces + type: bool + value: false + mirror: always + +- name: dom.fetchObserver.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Allow the content process to create a File from a path. This is allowed just +# on parent process, on 'file' Content process, or for testing. +- name: dom.file.createInChild + type: RelaxedAtomicBool + value: false + mirror: always + +# Support @autocomplete values for form autofill feature. +- name: dom.forms.autocomplete.formautofill + type: bool + value: false + mirror: always + +# Only trusted submit event could trigger form submission. +- name: dom.forms.submit.trusted_event_only + type: bool + value: false + mirror: always + +# This pref just controls whether we format the number with grouping separator +# characters when the internal value is set or updated. It does not stop the +# user from typing in a number and using grouping separators. +- name: dom.forms.number.grouping + type: bool + value: false + mirror: always + +# Whether the Gamepad API is enabled +- name: dom.gamepad.enabled + type: bool + value: true + mirror: always + +# Is Gamepad Extension API enabled? +- name: dom.gamepad.extensions.enabled + type: bool + value: true + mirror: always + +# Is LightIndicator API enabled in Gamepad Extension API? +- name: dom.gamepad.extensions.lightindicator + type: bool + value: false + mirror: always + +# Is MultiTouch API enabled in Gamepad Extension API? +- name: dom.gamepad.extensions.multitouch + type: bool + value: false + mirror: always + +# Is Gamepad vibrate haptic feedback function enabled? +- name: dom.gamepad.haptic_feedback.enabled + type: bool + value: true + mirror: always + +- name: dom.gamepad.non_standard_events.enabled + type: bool + value: @IS_NOT_RELEASE_OR_BETA@ + mirror: always + +- name: dom.gamepad.test.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# W3C draft ImageCapture API +- name: dom.imagecapture.enabled + type: bool + value: false + mirror: always + +# The root margin for image lazy loading, defined as four (value, percentage) +# pairs. +- name: dom.image-lazy-loading.root-margin.top + type: float + value: 600 + mirror: always + +- name: dom.image-lazy-loading.root-margin.top.percentage + type: bool + value: false + mirror: always + +- name: dom.image-lazy-loading.root-margin.bottom + type: float + value: 600 + mirror: always + +- name: dom.image-lazy-loading.root-margin.bottom.percentage + type: bool + value: false + mirror: always + +- name: dom.image-lazy-loading.root-margin.left + type: float + value: 600 + mirror: always + +- name: dom.image-lazy-loading.root-margin.left.percentage + type: bool + value: false + mirror: always + +- name: dom.image-lazy-loading.root-margin.right + type: float + value: 600 + mirror: always + +- name: dom.image-lazy-loading.root-margin.right.percentage + type: bool + value: false + mirror: always + +# Enable indexedDB in private browsing mode with encryption +- name: dom.indexedDB.privateBrowsing.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Whether or not indexedDB test mode is enabled. +- name: dom.indexedDB.testing + type: RelaxedAtomicBool + value: false + mirror: always + +# Whether or not indexedDB experimental features are enabled. +- name: dom.indexedDB.experimental + type: RelaxedAtomicBool + value: false + mirror: always + +# Whether or not indexedDB preprocessing is enabled. +- name: dom.indexedDB.preprocessing + type: RelaxedAtomicBool + value: false + mirror: always + +# Whether innerWidth / innerHeight return rounded or fractional sizes. +# +# NOTE(emilio): Fractional sizes are not web-compatible, see the regressions +# from bug 1676843, but we want to expose the fractional sizes (probably in +# another API) one way or another, see [1], so we're keeping the code for the +# time being. +# +# [1]: https://github.com/w3c/csswg-drafts/issues/5260 +- name: dom.innerSize.rounded + type: bool + value: true + mirror: always + +# Whether we conform to Input Events Level 1 or Input Events Level 2. +# true: conforming to Level 1 +# false: conforming to Level 2 +- name: dom.input_events.conform_to_level_1 + type: bool + value: true + mirror: always + +# Whether we allow BrowsingContextGroup to suspend input events +- name: dom.input_events.canSuspendInBCG.enabled + type: bool + value: false + mirror: always + +# The minimum number of ticks after page navigation +# that need to occur before user input events are allowed to be handled. +- name: dom.input_events.security.minNumTicks + type: uint32_t + value: 3 + mirror: always + +# The minimum elapsed time (in milliseconds) after page navigation +# for user input events are allowed to be handled. +- name: dom.input_events.security.minTimeElapsedInMS + type: uint32_t + value: 100 + mirror: always + +# By default user input handling delay is disabled (mostly) for testing , +# this is used for forcefully enable it for certain tests. +- name: dom.input_events.security.isUserInputHandlingDelayTest + type: bool + value: false + mirror: always + +# The maximum time (milliseconds) we reserve for handling input events in each +# frame. +- name: dom.input_event_queue.duration.max + type: uint32_t + value: 8 + mirror: always + +# Enable not moving the cursor to end when a text input or textarea has .value +# set to the value it already has. By default, enabled. +- name: dom.input.skip_cursor_move_for_same_value_set + type: bool + value: true + mirror: always + +# How often to check for CPOW timeouts (ms). CPOWs are only timed +# out by the hang monitor. +- name: dom.ipc.cpow.timeout + type: uint32_t + value: 500 + mirror: always + +#ifdef MOZ_ENABLE_FORKSERVER +- name: dom.ipc.forkserver.enable + type: bool + value: false + mirror: once +#endif + +#ifdef MOZ_WIDGET_GTK +# +# Avoid the use of GTK in content processes if possible, by running +# them in headless mode, to conserve resources (e.g., connections to +# the X server). See the usage in `ContentParent.cpp` for the full +# definition of "if possible". +# +# This does not affect sandbox policies; content processes may still +# dynamically connect to the display server for, e.g., WebGL. +- name: dom.ipc.avoid-gtk + type: bool + value: true + mirror: always +#endif + +# Whether or not to collect a paired minidump when force-killing a +# content process. +- name: dom.ipc.tabs.createKillHardCrashReports + type: bool + value: @IS_NOT_RELEASE_OR_BETA@ + mirror: once + +# Enable e10s hang monitoring (slow script checking and plugin hang detection). +- name: dom.ipc.processHangMonitor + type: bool + value: true + mirror: once + +# Whether we report such process hangs +- name: dom.ipc.reportProcessHangs + type: RelaxedAtomicBool +# Don't report hangs in DEBUG builds. They're too slow and often a +# debugger is attached. +#ifdef DEBUG + value: false +#else + value: true +#endif + mirror: always + +# Process launch delay (in milliseconds). +- name: dom.ipc.processPrelaunch.delayMs + type: uint32_t +# This number is fairly arbitrary ... the intention is to put off +# launching another app process until the last one has finished +# loading its content, to reduce CPU/memory/IO contention. + value: 1000 + mirror: always + +- name: dom.ipc.processPrelaunch.startupDelayMs + type: uint32_t +# delay starting content processes for a short time after browser start +# to provide time for the UI to come up + value: 1000 + mirror: always + +# Process preallocation cache +# Only used in fission; in e10s we use 1 always +- name: dom.ipc.processPrelaunch.fission.number + type: uint32_t + value: 3 + mirror: always + +# Limit preallocated processes below this memory size (in MB) +- name: dom.ipc.processPrelaunch.lowmem_mb + type: uint32_t + value: 4096 + mirror: always + +- name: dom.ipc.processPriorityManager.enabled + type: bool + value: true + mirror: always + +- name: dom.ipc.processPriorityManager.testMode + type: bool + value: false + mirror: always + +- name: dom.ipc.processPriorityManager.backgroundPerceivableGracePeriodMS + type: uint32_t +#if defined(MOZ_WIDGET_ANDROID) && defined(NIGHTLY_BUILD) + value: 3000 +#else + value: 0 +#endif + mirror: always + +- name: dom.ipc.processPriorityManager.backgroundGracePeriodMS + type: uint32_t +#if defined(MOZ_WIDGET_ANDROID) && defined(NIGHTLY_BUILD) + value: 3000 +#else + value: 0 +#endif + mirror: always + +#ifdef XP_WIN +- name: dom.ipc.processPriorityManager.backgroundUsesEcoQoS + type: bool + value: false + mirror: always +#endif + +# Support for input type=month, type=week. By default, disabled. +- name: dom.forms.datetime.others + type: bool + value: @IS_ANDROID@ + mirror: always + +- name: dom.forms.always_allow_pointer_events.enabled + type: bool + value: true + mirror: always + +# Is support for key events and focus events on disabled elements enabled? +- name: dom.forms.always_allow_key_and_focus_events.enabled + type: bool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + +# Whether to disable only the descendants or the parent fieldset element too +# Note that this still allows it to be selected by `:disable`. +- name: dom.forms.fieldset_disable_only_descendants.enabled + type: bool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + +# Whether to allow or disallow web apps to cancel `beforeinput` events caused +# by MozEditableElement#setUserInput() which is used by autocomplete, autofill +# and password manager. +- name: dom.input_event.allow_to_cancel_set_user_input + type: bool + value: false + mirror: always + +# How long a content process can take before closing its IPC channel +# after shutdown is initiated. If the process exceeds the timeout, +# we fear the worst and kill it. +- name: dom.ipc.tabs.shutdownTimeoutSecs + type: RelaxedAtomicUint32 +#if !defined(DEBUG) && !defined(MOZ_ASAN) && !defined(MOZ_VALGRIND) && !defined(MOZ_TSAN) + value: 20 +#else + value: 0 +#endif + mirror: always + +# Whether a native event loop should be used in the content process. +- name: dom.ipc.useNativeEventProcessing.content + type: RelaxedAtomicBool +#if defined(XP_WIN) || defined(XP_MACOSX) + value: false +#else + value: true +#endif + mirror: always + +# If this is true, TextEventDispatcher dispatches keydown and keyup events +# even during composition (keypress events are never fired during composition +# even if this is true). +- name: dom.keyboardevent.dispatch_during_composition + type: bool + value: true + mirror: always + +# Enable/disable KeyboardEvent.initKeyEvent function +- name: dom.keyboardevent.init_key_event.enabled + type: bool + value: false + mirror: always + +# Enable/disable KeyboardEvent.initKeyEvent function in addons even if it's +# disabled. +- name: dom.keyboardevent.init_key_event.enabled_in_addons + type: bool + value: @IS_NOT_NIGHTLY_BUILD@ + mirror: always + +# If this is true, keypress events for non-printable keys are dispatched only +# for event listeners of the system event group in web content. +- name: dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content + type: bool + value: true + mirror: always + +# If this is true, "keypress" event's keyCode value and charCode value always +# become same if the event is not created/initialized by JS. +- name: dom.keyboardevent.keypress.set_keycode_and_charcode_to_same_value + type: bool + value: true + mirror: always + +# Whether "W3C Web Manifest" processing is enabled +- name: dom.manifest.enabled + type: bool + value: true + mirror: always + +# Enable mapped array buffer by default. +- name: dom.mapped_arraybuffer.enabled + type: bool + value: true + mirror: always + +# Autoplay Policy Detection https://w3c.github.io/autoplay/ +- name: dom.media.autoplay-policy-detection.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# WebCodecs API +- name: dom.media.webcodecs.enabled + type: RelaxedAtomicBool + value: @IS_NIGHTLY_BUILD@ + mirror: always + +- name: dom.media.webcodecs.force-osx-h264-enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Number of seconds of very quiet or silent audio before considering the audio +# inaudible. +- name: dom.media.silence_duration_for_audibility + type: AtomicFloat + value: 2.0f + mirror: always + +# Inform mozjemalloc that the foreground content processes can keep more dirty +# pages in memory. +- name: dom.memory.foreground_content_processes_have_larger_page_cache + type: bool + value: true + mirror: always + +# Enable meta-viewport support in remote APZ-enabled frames. +- name: dom.meta-viewport.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Timeout clamp in ms for timeouts we clamp. +- name: dom.min_timeout_value + type: RelaxedAtomicInt32 + value: 4 + mirror: always + +# Timeout clamp in ms for background windows. +- name: dom.min_background_timeout_value + type: int32_t + value: 1000 + mirror: always + +# Timeout clamp in ms for background windows when throttling isn't enabled. +- name: dom.min_background_timeout_value_without_budget_throttling + type: int32_t + value: 1000 + mirror: always + +# Are missing-property use counters for certain DOM attributes enabled? +- name: dom.missing_prop_counters.enabled + type: bool + value: true + mirror: always + +# Whether we disable triggering mutation events for changes to style +# attribute via CSSOM. +# NOTE: This preference is used in unit tests. If it is removed or its default +# value changes, please update test_sharedMap_static_prefs.js accordingly. +- name: dom.mutation-events.cssom.disabled + type: bool + value: true + mirror: always + +# Limit of location change caused by content scripts in a time span per +# BrowsingContext. This includes calls to History and Location APIs. +- name: dom.navigation.locationChangeRateLimit.count + type: uint32_t + value: 200 + mirror: always + +# Time span in seconds for location change rate limit. +- name: dom.navigation.locationChangeRateLimit.timespan + type: uint32_t + value: 10 + mirror: always + +# Network Information API +# This feature is not available on Firefox desktop. It exposes too much +# user information. Let's be consistent and disable it on Android. +# But let's keep it around in case it becomes necessary for webcompat +# reasons +# https://bugzilla.mozilla.org/show_bug.cgi?id=1637922 +- name: dom.netinfo.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Whether we should open noopener links in a new process. +- name: dom.noopener.newprocess.enabled + type: bool + value: true + mirror: always + +# Whether we shouldn't show an error page for unknown protocols (and should +# show a console warning instead). +- name: dom.no_unknown_protocol_error.enabled + type: bool + value: true + mirror: always + +# Whether origin trials are enabled. +- name: dom.origin-trials.enabled + type: bool + value: true + mirror: always + +# Whether we use the test key to verify tokens. +- name: dom.origin-trials.test-key.enabled + type: bool + value: false + mirror: always + +# Origin trial state for "TestTrial". +# 0: normal, 1: always-enabled, 2: always-disabled +- name: dom.origin-trials.test-trial.state + type: RelaxedAtomicInt32 + value: 0 + mirror: always + +# Origin trial state for COEP: Credentialless. +# 0: normal, 1: always-enabled, 2: always-disabled +- name: dom.origin-trials.coep-credentialless.state + type: RelaxedAtomicInt32 + value: 0 + mirror: always + +# Is support for Window.paintWorklet enabled? +- name: dom.paintWorklet.enabled + type: bool + value: false + mirror: always + +# Enable/disable the PaymentRequest API +- name: dom.payments.request.enabled + type: bool + value: false + mirror: always + +# Whether a user gesture is required to call PaymentRequest.prototype.show(). +- name: dom.payments.request.user_interaction_required + type: bool + value: true + mirror: always + +# Time in milliseconds for PaymentResponse to wait for +# the Web page to call complete(). +- name: dom.payments.response.timeout + type: uint32_t + value: 5000 + mirror: always + +# Enable printing performance marks/measures to log +- name: dom.performance.enable_user_timing_logging + type: RelaxedAtomicBool + value: false + mirror: always + +# Enable notification of performance timing +- name: dom.performance.enable_notify_performance_timing + type: bool + value: false + mirror: always + +# Is support for PerformanceTiming.timeToContentfulPaint enabled? +- name: dom.performance.time_to_contentful_paint.enabled + type: bool + value: false + mirror: always + +# Is support for PerformanceTiming.timeToDOMContentFlushed enabled? +- name: dom.performance.time_to_dom_content_flushed.enabled + type: bool + value: false + mirror: always + +# Is support for PerformanceTiming.timeToFirstInteractive enabled? +- name: dom.performance.time_to_first_interactive.enabled + type: bool + value: false + mirror: always + +# Is support for PerformanceTiming.timeToNonBlankPaint enabled? +- name: dom.performance.time_to_non_blank_paint.enabled + type: bool + value: false + mirror: always + +# Is support for Permissions.revoke enabled? +- name: dom.permissions.revoke.enable + type: bool + value: false + mirror: always + +# Is support for Element.requestPointerLock enabled? +# This is added for accessibility purpose. When user has no way to exit +# pointer lock (e.g. no keyboard available), they can use this pref to +# disable the Pointer Lock API altogether. +- name: dom.pointer-lock.enabled + type: bool + value: true + mirror: always + +# re-SAB: Whether to allow postMessage of a SharedArrayBuffer if various +# preconditions related to COOP and COEP are met +- name: dom.postMessage.sharedArrayBuffer.withCOOP_COEP + type: bool + value: true + mirror: once + +# Overridden in all.js on RELEASE_OR_BETA in order to add the locked attribute. +- name: dom.postMessage.sharedArrayBuffer.bypassCOOP_COEP.insecure.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# This currently only affects XHTML. For XUL the cache is always allowed. +- name: dom.prototype_document_cache.enabled + type: bool + value: true + mirror: always + +# Push +- name: dom.push.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# This enables the SVGPathSeg APIs +- name: dom.svg.pathSeg.enabled + type: bool + value: false + mirror: always + +# Preference that is primarily used for testing of problematic file paths. +# It can also be used for switching between different storage directories, but +# such feature is not officially supported. +- name: dom.quotaManager.storageName + type: String + value: "storage" + mirror: never + +# An upper limit for the "age" of an origin. Any origin which is older than the +# threshold is considered as unaccessed. That doesn't necessarily mean that +# such origins will be immediatelly archived. They will be archived only when +# dom.quotaManager.checkQuotaInfoLoadTime is true and loading of quota info +# takes a long time (dom.quotaManager.longQuotaInfoLoadTimeThresholdMs is used +# to decide what is a long quota info load time). +- name: dom.quotaManager.unaccessedForLongTimeThresholdSec + type: RelaxedAtomicUint32 + value: 33696000 # 13 months + mirror: always + +# Should we try to load origin information from the cache? +# See bug 1563023 for more details. +- name: dom.quotaManager.loadQuotaFromCache + type: RelaxedAtomicBool + value: true + mirror: always + +# Should we check build ID as part of the cache validation? +# When enabled, the cache is invalidated on any upgrade (or downgrade), +# ensuring that changes in how quota usage is calculated can't cause +# inconsistencies at the cost of a slower initialization. Currently, this +# should only be set to false in tests using a packaged profile that inherently +# includes a build id different from the building running the tests. In the +# future this may be set to false if we are confident that we have sufficiently +# thorough schema versioning. +- name: dom.quotaManager.caching.checkBuildId + type: RelaxedAtomicBool + value: true + mirror: always + +# Should we check quota info load time and eventually archive some unaccessed +# origins if loading of quota info takes a long time ? +- name: dom.quotaManager.checkQuotaInfoLoadTime + type: RelaxedAtomicBool + value: true + mirror: always + +# An upper limit for quota info load time, anything which takes longer than the +# threshold is considered as long quota info load time. +- name: dom.quotaManager.longQuotaInfoLoadTimeThresholdMs + type: RelaxedAtomicUint32 + value: 21000 # 21 seconds + mirror: always + +# Preference that users can set to override temporary storage smart limit +# calculation. +- name: dom.quotaManager.temporaryStorage.fixedLimit + type: RelaxedAtomicInt32 + value: -1 + mirror: always + +# A pref that is used to enable testing features. +- name: dom.quotaManager.testing + type: SequentiallyConsistentAtomicBool + value: false + mirror: always + +#if defined(XP_WIN) + # Preference that is used to set nsILocalFileWin::useDOSDevicePathSyntax + # attribute for all local file instances created by QuotaManager and its + # clients. The value of this preference is cached so changing the preference + # during runtime has no effect. + # See bug 1626846 for setting this to false by default. +- name: dom.quotaManager.useDOSDevicePathSyntax + type: RelaxedAtomicBool + value: true + mirror: always + do_not_use_directly: true + + # Preference that is used to enable the hack for overrriding xFullPathname in + # QuotaVFS. +- name: dom.quotaManager.overrideXFullPathname + type: RelaxedAtomicBool + value: true + mirror: always +#elif defined(XP_UNIX) + # Preference that is used to enable the overriding of Unix xFullPathname + # implementation in QuotaVFS. +- name: dom.quotaManager.overrideXFullPathnameUnix + type: RelaxedAtomicBool + value: true + mirror: always +#endif + +# How many times we should retry directory removal or renaming if access was +# denied? +- name: dom.quotaManager.directoryRemovalOrRenaming.maxRetries + type: RelaxedAtomicUint32 +#ifdef XP_WIN + value: 10 +#else + value: 0 +#endif + mirror: always + +# How long we should wait between retries (in milliseconds)? +- name: dom.quotaManager.directoryRemovalOrRenaming.delayMs + type: RelaxedAtomicUint32 + value: 200 + mirror: always + +#ifdef MOZ_BACKGROUNDTASKS +# Use a Background Task to delete files at shutdown. +- name: dom.quotaManager.backgroundTask.enabled + type: bool +#ifdef XP_MACOSX +# Needs to figure out how to prevent bug 1827486. + value: false +#else + value: true +#endif + mirror: never +#endif + +# Use to control to dump CheckedUnsafePtr creation stack and assignment stacks. +- name: dom.checkedUnsafePtr.dumpStacks.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Determines within what distance of a tick mark, in pixels, dragging an input +# range range will snap the range's value to that tick mark. By default, this is +# half the default width of the range thumb. +- name: dom.range_element.magnet_effect_threshold + type: float + value: 10.0f + mirror: always + +# Reporting API. +- name: dom.reporting.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.reporting.testing.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.reporting.featurePolicy.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.reporting.crash.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.reporting.header.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# In seconds. The timeout to remove not-active report-to endpoints. +- name: dom.reporting.cleanup.timeout + type: uint32_t + value: 3600 + mirror: always + +# Any X seconds the reports are dispatched to endpoints. +- name: dom.reporting.delivering.timeout + type: uint32_t + value: 5 + mirror: always + +# How many times the delivering of a report should be tried. +- name: dom.reporting.delivering.maxFailures + type: uint32_t + value: 3 + mirror: always + +# How many reports should be stored in the report queue before being delivered. +- name: dom.reporting.delivering.maxReports + type: uint32_t + value: 100 + mirror: always + +# Enable Screen Orientation lock +- name: dom.screenorientation.allow-lock + type: bool + value: @IS_NIGHTLY_BUILD@ + mirror: always + +# Enable Screen Wake Lock API +- name: dom.screenwakelock.enabled + type: bool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + +# Whether to enable the JavaScript start-up cache. This causes one of the first +# execution to record the bytecode of the JavaScript function used, and save it +# in the existing cache entry. On the following loads of the same script, the +# bytecode would be loaded from the cache instead of being generated once more. +- name: dom.script_loader.bytecode_cache.enabled + type: bool + value: true + mirror: always + +# Ignore the heuristics of the bytecode cache, and always record on the first +# visit. (used for testing purposes). + +# Choose one strategy to use to decide when the bytecode should be encoded and +# saved. The following strategies are available right now: +# * -2 : (reader mode) The bytecode cache would be read, but it would never +# be saved. +# * -1 : (eager mode) The bytecode would be saved as soon as the script is +# seen for the first time, independently of the size or last access +# time. +# * 0 : (default) The bytecode would be saved in order to minimize the +# page-load time. +# +# Other values might lead to experimental strategies. For more details, have a +# look at: ScriptLoader::ShouldCacheBytecode function. +- name: dom.script_loader.bytecode_cache.strategy + type: int32_t + value: 0 + mirror: always + +# Select which parse/delazification strategy should be used while parsing +# scripts off-main-thread. (see CompileOptions.h, DelazificationOption enum) +# +# 0: On-demand only. Delazification will be triggered only on the main thread +# before the execution of the function. +# +# 1: Compare on-demand delazification (= 0) with concurrent depth-first +# delazification (= 2). +# +# 2: Depth-first. Delazify all functions off-thread in the order of appearance +# in the source. +# +# 3: Large-first. Delazify all functions off-thread starting with the largest +# functions first, and the smallest as the last one to be delazified, where +# the size of function is measured in bytes between the start to the end of +# the function. +# +# 255: Parse everything eagerly, from the first parse. All functions are parsed +# at the same time as the top-level of a file. +- name: dom.script_loader.delazification.strategy + type: uint32_t + value: 255 + mirror: always + +# Maximum total size after which the delazification strategy, specified by +# `dom.script_loader.delazification.strategy`, is no longer applied, and the +# on-demand strategy is used by default. +# +# -1 disable the threshold, and delazification strategy is applied to all +# scripts. +# +# Default value is 10MB for utf8 scripts. +- name: dom.script_loader.delazification.max_size + type: int32_t + value: 10485760 + mirror: always + +# Minimum memory, in GB, required to enable delazification strategy, specified +# by `dom.script_loader.delazification.strategy`. Otherwise, the on-demand +# delazification strategy is used. +- name: dom.script_loader.delazification.min_mem + type: int32_t + value: 2 + mirror: always + +# Enable speculative off main thread parsing of external scripts as +# soon as they are fetched. +- name: dom.script_loader.external_scripts.speculative_omt_parse.enabled + type: bool + value: true + mirror: always + +# Speculatively compile non parser inserted scripts +- name: dom.script_loader.external_scripts.speculate_non_parser_inserted.enabled + type: bool + value: false + mirror: always + +# Speculatively compile async scripts +- name: dom.script_loader.external_scripts.speculate_async.enabled + type: bool + value: false + mirror: always + +# Speculatively compile link preload scripts +- name: dom.script_loader.external_scripts.speculate_link_preload.enabled + type: bool + value: false + mirror: always + +- name: dom.securecontext.allowlist_onions + type: bool + value: false + mirror: always + +# This pref enables the featurePolicy header support. +- name: dom.security.featurePolicy.header.enabled + type: bool + value: false + mirror: always + +- name: dom.security.featurePolicy.experimental.enabled + type: bool + value: false + mirror: always + +# Expose the 'featurePolicy' attribute in document and HTMLIFrameElement +- name: dom.security.featurePolicy.webidl.enabled + type: bool + value: false + mirror: always + +# Perform IPC based Principal vetting in ContentParent +- name: dom.security.enforceIPCBasedPrincipalVetting + type: RelaxedAtomicBool + value: true + mirror: always + +# For testing purposes only: Flipping this pref to true allows +# to skip the allowlist for about: pages and do not ship with a +# CSP and NS_ASSERT right away. +- name: dom.security.skip_about_page_csp_allowlist_and_assert + type: RelaxedAtomicBool + value: false + mirror: always + +# For testing purposes only: Flipping this pref to true allows +# to skip the assertion that every about page ships with a CSP. +- name: dom.security.skip_about_page_has_csp_assert + type: RelaxedAtomicBool + value: false + mirror: always + +# For testing purposes only: Flipping this pref to true allows +# to skip the assertion that HTML fragments (e.g. innerHTML) can +# not be used within chrome code or about: pages. +- name: dom.security.skip_html_fragment_assertion + type: RelaxedAtomicBool + value: false + mirror: always + +# For testing purposes only; Flipping this pref to true allows +# to skip the assertion that remote scripts can not be loaded +# in system privileged contexts. +- name: dom.security.skip_remote_script_assertion_in_system_priv_context + type: RelaxedAtomicBool + value: false + mirror: always + +# If true, all content requests will get upgraded to HTTPS:// +# (some Firefox functionality requests, like OCSP will not be affected) +- name: dom.security.https_only_mode + type: RelaxedAtomicBool + value: false + mirror: always + +# If true, all content requests in Private Browsing Mode will get +# upgraded to HTTPS://. (If dom.security.https_only_mode is set +# to true then this pref has no effect) +- name: dom.security.https_only_mode_pbm + type: RelaxedAtomicBool + value: false + mirror: always + +# If true, sends http background request for top-level sites to +# counter long timeouts. +- name: dom.security.https_only_mode_send_http_background_request + type: RelaxedAtomicBool + value: true + mirror: always + +# Time limit, in milliseconds, before sending the http background +# request for HTTPS-Only and HTTPS-First +- name: dom.security.https_only_fire_http_request_background_timer_ms + type: RelaxedAtomicUint32 + value: 3000 + mirror: always + +# If true, tries to break upgrade downgrade cycles where https-only tries +# to upgrad ethe connection, but the website tries to downgrade again. +- name: dom.security.https_only_mode_break_upgrade_downgrade_endless_loop + type: RelaxedAtomicBool + value: true + mirror: always + +# If true, when checking if it's upgrade downgrade cycles, the URI path will be +# also checked. +- name: dom.security.https_only_check_path_upgrade_downgrade_endless_loop + type: RelaxedAtomicBool + value: true + mirror: always + +# If true and HTTPS-only mode is enabled, requests +# to local IP addresses are also upgraded +- name: dom.security.https_only_mode.upgrade_local + type: RelaxedAtomicBool + value: false + mirror: always + +# If true and HTTPS-only mode is enabled, requests +# to .onion hosts are also upgraded +- name: dom.security.https_only_mode.upgrade_onion + type: RelaxedAtomicBool + value: false + mirror: always + +# WARNING: Don't ever update that pref manually! It is only used +# for telemetry purposes and allows to reason about retention of +# the pref dom.security.https_only_mode from above. +- name: dom.security.https_only_mode_ever_enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# WARNING: Don't ever update that pref manually! It is only used +# for telemetry purposes and allows to reason about retention of +# the pref dom.security.https_only_mode_pbm from above. +- name: dom.security.https_only_mode_ever_enabled_pbm + type: RelaxedAtomicBool + value: false + mirror: always + +# If true checks for secure www connections when https fails +# and gives the user suggestions on the error page +- name: dom.security.https_only_mode_error_page_user_suggestions + type: RelaxedAtomicBool + value: false + mirror: always + +# If true, top-level request will get upgraded to HTTPS and +# downgraded again if the request failed. +- name: dom.security.https_first + type: RelaxedAtomicBool + value: false + mirror: always + +# If true, top-level requests in Private Browsing Mode will get +# upgraded to HTTPS. (If dom.security.https_first +# is set to true then this pref has no effect) +- name: dom.security.https_first_pbm + type: RelaxedAtomicBool + value: true + mirror: always + +# If true, top-level requests that are initiated from the address +# bar and with an empty scheme get upgraded to HTTPS +# with a fallback +- name: dom.security.https_first_schemeless + type: RelaxedAtomicBool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + +- name: dom.security.unexpected_system_load_telemetry_enabled + type: bool + value: true + mirror: always + +# pref controls `Sanitizer` API being exposed +# https://wicg.github.io/sanitizer-api/ +- name: dom.security.sanitizer.enabled + type: bool + value: false + mirror: always + +# Pref that controls the Element.setHTML API idenpendetly of the sanitizer +# API. +- name: dom.security.setHTML.enabled + type: bool + value: false + mirror: always + +# Logs elements and attributes removed by the Sanitizer API to the console. +- name: dom.security.sanitizer.logging + type: bool + value: false + mirror: always + +# pref controls `identity` credentials being exposed +- name: dom.security.credentialmanagement.identity.enabled + type: bool + value: false + mirror: always + +# pref controls `identity` credential UI for testing. When true, UI is not shown and +# the first option in the account and provider lists are chosen +- name: dom.security.credentialmanagement.identity.select_first_in_ui_lists + type: bool + value: false + mirror: always + +# pref controls `identity` credential platform behavior for testing. When true, +# the .well-known file check is not performed. +- name: dom.security.credentialmanagement.identity.test_ignore_well_known + type: bool + value: false + mirror: always + +# pref controls whether we should delay identity credential rejections at all +- name: dom.security.credentialmanagement.identity.reject_delay.enabled + type: bool + value: true + mirror: always + +# pref controls how long we should delay identity credential rejections if enabled +- name: dom.security.credentialmanagement.identity.reject_delay.duration_ms + type: uint32_t + value: 120000 + mirror: always + +# SetDocumentURI security option, enforces origin check +- name: dom.security.setdocumenturi + type: bool + value: @IS_EARLY_BETA_OR_EARLIER@ + mirror: always + +# Whether or not selection events on text controls are enabled. +- name: dom.select_events.textcontrols.selectionchange.enabled + type: bool + value: true + mirror: always + +- name: dom.select_events.textcontrols.selectstart.enabled + type: bool + value: false + mirror: always + +- name: dom.select.showPicker.enabled + type: bool + value: true + mirror: always + +- name: dom.send_after_paint_to_content + type: bool + value: false + mirror: always + +- name: dom.separate_event_queue_for_post_message.enabled + type: bool + value: true + mirror: always + +- name: dom.arena_allocator.enabled + type: bool + value: true + mirror: once + +- name: dom.serviceWorkers.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.serviceWorkers.navigationPreload.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Mitigates ServiceWorker navigation faults by bypassing the ServiceWorker on +# navigation faults. This is more extensive than just resetting interception +# because we also mark the page as uncontrolled so that subresources will not +# go to the ServiceWorker either. +- name: dom.serviceWorkers.mitigations.bypass_on_fault + type: bool + value: true + mirror: always + +# Additional ServiceWorker navigation mitigation control to unregister the +# ServiceWorker after multiple faults are encountered. The mitigation is +# disabled when this is set to zero, otherwise this is the number of faults that +# need to occur for a specific ServiceWorker before it will be unregistered. +- name: dom.serviceWorkers.mitigations.navigation_fault_threshold + type: uint32_t + value: 3 + mirror: always + +# This is the group usage head room for service workers. +# The quota usage mitigation algorithm uses this preference to determine if the +# origin or also group data should be cleared or not. +# The default value is 400 MiB. +- name: dom.serviceWorkers.mitigations.group_usage_headroom_kb + type: uint32_t + value: 400 * 1024 + mirror: always + +- name: dom.serviceWorkers.testing.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Whether ServiceWorkerManager should persist the service worker +# registered by temporary installed extension (only meant to be used +# for testing purpose, to make it easier to test some particular scenario +# with a temporary installed addon, which doesn't need to be signed to be +# installed on release channel builds). +- name: dom.serviceWorkers.testing.persistTemporarilyInstalledAddons + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.storage.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# ReadableStream.from(asyncIterable) +- name: dom.streams.from.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.workers.pFetch.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.workers.importScripts.enforceStrictMimeType + type: RelaxedAtomicBool + value: true + mirror: always + +# Is support for modules (new Worker(..., {type: "module"})) enabled for workers? +- name: dom.workers.modules.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.workers.serialized-sab-access + type: RelaxedAtomicBool + value: false + mirror: always + +# Enable stronger diagnostics on worker shutdown. +# If this is true, we will potentially run an extra GCCC when a worker should +# exit its DoRunLoop but holds any WorkerRef and we will MOZ_DIAGNOSTIC_ASSERT +# when during that extra GCCC such a WorkerRef is freed. +- name: dom.workers.GCCC_on_potentially_last_event + type: RelaxedAtomicBool +#if defined(FUZZING) || defined(DEBUG) + value: true +#else + value: false +#endif + mirror: always + +- name: dom.sitepermsaddon-provider.enabled + type: bool + value: @IS_NOT_ANDROID@ + mirror: always + +# Whether automatic storage access granting heuristics should be turned on. +- name: dom.storage_access.auto_grants + type: bool + value: true + mirror: always + +- name: dom.storage_access.auto_grants.delayed + type: bool + value: true + mirror: always + +# Storage-access API. +- name: dom.storage_access.enabled + type: bool + value: true + mirror: always + +# Forward-Declared Storage-access API. +- name: dom.storage_access.forward_declared.enabled + type: bool + value: false + mirror: always + +# How long the Forward-Declared Storage-access API allows between pair requests +# in seconds +- name: dom.storage_access.forward_declared.lifetime + type: uint32_t + value: 15 * 60 + mirror: always + +# The maximum number of origins that a given third-party tracker is allowed +# to have concurrent access to before the user is presented with a storage +# access prompt. Only effective when the auto_grants pref is turned on. +- name: dom.storage_access.max_concurrent_auto_grants + type: int32_t + value: 5 + mirror: always + +- name: dom.storage_access.frame_only + type: bool + value: true + mirror: always + +# Only grant storage access to secure contexts. +- name: dom.storage_access.dont_grant_insecure_contexts + type: RelaxedAtomicBool + value: true + mirror: always + +# Whether the File System API is enabled +- name: dom.fs.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Whether the WritableFileStream is enabled or disabled. +- name: dom.fs.writable_file_stream.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# LocalStorage data limit as determined by summing up the lengths of all string +# keys and values. This is consistent with the legacy implementation and other +# browser engines. This value should really only ever change in unit testing +# where being able to lower it makes it easier for us to test certain edge +# cases. Measured in KiBs. +- name: dom.storage.default_quota + type: RelaxedAtomicUint32 + # Only allow relatively small amounts of data since performance of the + # synchronous IO is very bad. We are enforcing simple per-origin quota only. + value: 5 * 1024 + mirror: always + +# Per-site quota for legacy LocalStorage implementation. +- name: dom.storage.default_site_quota + type: RelaxedAtomicUint32 + value: 25 * 1024 + mirror: always + +# Whether or not the unsupported legacy implemenation should be enabled. Please +# don't advertise this pref as a way for disabling LSNG. This pref is intended +# for internal testing only and will be removed in near future. Accidental +# disabling of LSNG can lead to a data loss in a combination with disabled +# shadow writes. Disabling of shadow writes is the initial step towards +# removing legacy implementation and will be done soon. +- name: dom.storage.enable_unsupported_legacy_implementation + type: RelaxedAtomicBool + value: false + mirror: always + do_not_use_directly: true + +# The amount of snapshot peak usage which is attempted to be pre-incremented +# during snapshot creation. +- name: dom.storage.snapshot_peak_usage.initial_preincrement + type: RelaxedAtomicUint32 + value: 16384 + mirror: always + +# The amount of snapshot peak usage which is attempted to be pre-incremented +# during snapshot creation if the LocalStorage usage was already close to the +# limit (a fallback for dom.storage.snapshot_peak_usage.initial_preincrement). +- name: dom.storage.snapshot_peak_usage.reduced_initial_preincrement + type: RelaxedAtomicUint32 + value: 4096 + mirror: always + +# The amount of snapshot peak usage which is attempted to be pre-incremented +# beyond the specific values which are subsequently requested after snapshot +# creation. +- name: dom.storage.snapshot_peak_usage.gradual_preincrement + type: RelaxedAtomicUint32 + value: 4096 + mirror: always + +# The amount of snapshot peak usage which is attempted to be pre-incremented +# beyond the specific values which are subsequently requested after snapshot +# creation if the LocalStorage total usage was already close to the limit +# (a fallback for dom.storage.snapshot_peak_usage.gradual_preincrement). +- name: dom.storage.snapshot_peak_usage.reduced_gradual_preincrement + type: RelaxedAtomicUint32 + value: 1024 + mirror: always + +# How long between a snapshot becomes idle and when we actually finish the +# snapshot. This preference is only used when "dom.storage.snapshot_reusing" +# is true. +- name: dom.storage.snapshot_idle_timeout_ms + type: uint32_t + value: 5000 + mirror: always + +# Is support for Storage test APIs enabled? +- name: dom.storage.testing + type: bool + value: false + mirror: always + +# For area and anchor elements with target=_blank and no rel set to +# opener/noopener. +- name: dom.targetBlankNoOpener.enabled + type: bool + value: true + mirror: always + +# Is support for Selection.GetRangesForInterval enabled? +- name: dom.testing.selection.GetRangesForInterval + type: bool + value: false + mirror: always + +- name: dom.testing.structuredclonetester.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.testing.sync-content-blocking-notifications + type: bool + value: false + mirror: always + +# To enable TestUtils interface on WPT +- name: dom.testing.testutils.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.textMetrics.actualBoundingBox.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.textMetrics.baselines.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.textMetrics.emHeight.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.textMetrics.fontBoundingBox.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Time (in ms) that it takes to regenerate 1ms. +- name: dom.timeout.background_budget_regeneration_rate + type: int32_t + value: 100 + mirror: always + +# Time (in ms) that it takes to regenerate 1ms. +- name: dom.timeout.foreground_budget_regeneration_rate + type: int32_t + value: 1 + mirror: always + +# Maximum value (in ms) for the background budget. Only valid for +# values greater than 0. +- name: dom.timeout.background_throttling_max_budget + type: int32_t + value: 50 + mirror: always + +# Maximum value (in ms) for the foreground budget. Only valid for +# values greater than 0. +- name: dom.timeout.foreground_throttling_max_budget + type: int32_t + value: -1 + mirror: always + +# The maximum amount a timeout can be delayed by budget throttling. +- name: dom.timeout.budget_throttling_max_delay + type: int32_t + value: 15000 + mirror: always + +# Turn on budget throttling by default. +- name: dom.timeout.enable_budget_timer_throttling + type: bool + value: true + mirror: always + +# Should we defer timeouts and intervals while loading a page. Released +# on Idle or when the page is loaded. +- name: dom.timeout.defer_during_load + type: bool + value: true + mirror: always + +# Maximum amount of time in milliseconds consecutive setTimeout()/setInterval() +# callback are allowed to run before yielding the event loop. +- name: dom.timeout.max_consecutive_callbacks_ms + type: uint32_t + value: 4 + mirror: always + +# Maximum deferral time for setTimeout/Interval in milliseconds +- name: dom.timeout.max_idle_defer_ms + type: uint32_t + value: 10*1000 + mirror: always + +# Delay in ms from document load until we start throttling background timeouts. +- name: dom.timeout.throttling_delay + type: int32_t + value: 30000 + mirror: always + +# UDPSocket API +- name: dom.udpsocket.enabled + type: bool + value: false + mirror: always + +# Whether to dump worker use counters +- name: dom.use_counters.dump.worker + type: RelaxedAtomicBool + value: false + mirror: always + +# Whether to dump document use counters +- name: dom.use_counters.dump.document + type: bool + value: false + mirror: always + +# Whether to dump page use counters +- name: dom.use_counters.dump.page + type: bool + value: false + mirror: always + +# Time limit, in milliseconds, for user gesture transient activation. +- name: dom.user_activation.transient.timeout + type: uint32_t + value: 5000 + mirror: always + +# Whether to treat the clicks on scrollbars as user interaction with web content. +- name: dom.user_activation.ignore_scrollbars + type: bool + value: true + mirror: always + +# Whether to shim a Components object on untrusted windows. +- name: dom.use_components_shim + type: bool + value: @IS_NOT_NIGHTLY_BUILD@ + mirror: always + +- name: dom.vibrator.enabled + type: bool + value: true + mirror: always + +- name: dom.vibrator.max_vibrate_ms + type: RelaxedAtomicUint32 + value: 10000 + mirror: always + +- name: dom.vibrator.max_vibrate_list_len + type: RelaxedAtomicUint32 + value: 128 + mirror: always + +# Is support for WebVR APIs enabled? +# Disabled everywhere, but not removed. +- name: dom.vr.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Should VR sessions always be reported as supported, without first +# checking for VR runtimes? This will prevent permission prompts +# from being suppressed on machines without VR runtimes and cause +# navigator.xr.isSessionSupported to always report that immersive-vr +# is supported. +- name: dom.vr.always_support_vr + type: RelaxedAtomicBool + value: false + mirror: always + +# Should AR sessions always be reported as supported, without first +# checking for AR runtimes? This will prevent permission prompts +# from being suppressed on machines without AR runtimes and cause +# navigator.xr.isSessionSupported to always report that immersive-ar +# is supported. +- name: dom.vr.always_support_ar + type: RelaxedAtomicBool + value: false + mirror: always + +# It is often desirable to automatically start vr presentation when +# a user puts on the VR headset. This is done by emitting the +# Window.vrdisplayactivate event when the headset's sensors detect it +# being worn. This can result in WebVR content taking over the headset +# when the user is using it outside the browser or inadvertent start of +# presentation due to the high sensitivity of the proximity sensor in some +# headsets, so it is off by default. +- name: dom.vr.autoactivate.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Minimum number of milliseconds that the browser will wait before +# attempting to poll again for connected VR controllers. The browser +# will not attempt to poll for VR controllers until it needs to use them. +- name: dom.vr.controller.enumerate.interval + type: RelaxedAtomicInt32 + value: 1000 + mirror: always + +# The threshold value of trigger inputs for VR controllers. +- name: dom.vr.controller_trigger_threshold + type: AtomicFloat + value: 0.1f + mirror: always + +# Minimum number of milliseconds that the browser will wait before +# attempting to poll again for connected VR displays. The browser +# will not attempt to poll for VR displays until it needs to use +# them, such as when detecting a WebVR site. +- name: dom.vr.display.enumerate.interval + type: RelaxedAtomicInt32 + value: 5000 + mirror: always + +# The number of milliseconds since last frame start before triggering a new +# frame. When content is failing to submit frames on time or the lower level +# VR platform APIs are rejecting frames, it determines the rate at which RAF +# callbacks will be called. +- name: dom.vr.display.rafMaxDuration + type: RelaxedAtomicUint32 + value: 50 + mirror: always + +# Minimum number of milliseconds the browser will wait before attempting +# to re-start the VR service after an enumeration returned no devices. +- name: dom.vr.external.notdetected.timeout + type: RelaxedAtomicInt32 + value: 60000 + mirror: always + +# Minimum number of milliseconds the browser will wait before attempting +# to re-start the VR service after a VR API (eg, OpenVR or Oculus) +# requests that we shutdown and unload its libraries. +# To ensure that we don't interfere with VR runtime software auto-updates, +# we will not attempt to re-load the service until this timeout has elapsed. +- name: dom.vr.external.quit.timeout + type: RelaxedAtomicInt32 + value: 10000 + mirror: always + +# Minimum number of milliseconds that the VR session will be kept +# alive after the browser and content no longer are using the +# hardware. If a VR multitasking environment, this should be set +# very low or set to 0. +- name: dom.vr.inactive.timeout + type: RelaxedAtomicInt32 + value: 5000 + mirror: always + +# Maximum number of milliseconds the browser will wait for content to call +# VRDisplay.requestPresent after emitting vrdisplayactivate during VR +# link traversal. This prevents a long running event handler for +# vrdisplayactivate from later calling VRDisplay.requestPresent, which would +# result in a non-responsive browser in the VR headset. +- name: dom.vr.navigation.timeout + type: RelaxedAtomicInt32 + value: 5000 + mirror: always + +# Oculus device +- name: dom.vr.oculus.enabled + type: RelaxedAtomicBool +#if defined(HAVE_64BIT_BUILD) && !defined(ANDROID) + # We are only enabling WebVR by default on 64-bit builds (Bug 1384459). + value: true +#else + # On Android, this pref is irrelevant. + value: false +#endif + mirror: always + +# When enabled, Oculus sessions may be created with the ovrInit_Invisible +# flag if a page is using tracking but not presenting. When a page +# begins presenting VR frames, the session will be re-initialized without +# the flag. This eliminates the "Firefox not responding" warnings in +# the headset, but might not be compatible with all versions of the Oculus +# runtime. +- name: dom.vr.oculus.invisible.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Minimum number of milliseconds after content has stopped VR presentation +# before the Oculus session is re-initialized to an invisible / tracking +# only mode. If this value is too high, users will need to wait longer +# after stopping WebVR presentation before automatically returning to the +# Oculus home interface. (They can immediately return to the Oculus Home +# interface through the Oculus HUD without waiting this duration) +# If this value is too low, the Oculus Home interface may be visible +# momentarily during VR link navigation. +- name: dom.vr.oculus.present.timeout + type: RelaxedAtomicInt32 + value: 500 + mirror: always + +# OpenVR device +- name: dom.vr.openvr.enabled + type: RelaxedAtomicBool +#if !defined(HAVE_64BIT_BUILD) && !defined(ANDROID) + # We are only enabling WebVR by default on 64-bit builds (Bug 1384459). + value: false +#elif defined(XP_WIN) || defined(XP_MACOSX) + # We enable OpenVR by default for Windows and macOS. + value: true +#else + # See Bug 1310663 (Linux). On Android, this pref is irrelevant. + value: false +#endif + mirror: always + +# OSVR device +- name: dom.vr.osvr.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Pose prediction reduces latency effects by returning future predicted HMD +# poses to callers of the WebVR API. This currently only has an effect for +# Oculus Rift on SDK 0.8 or greater. +- name: dom.vr.poseprediction.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +# Enable a separate process for VR module. +- name: dom.vr.process.enabled + type: bool +#if defined(XP_WIN) + value: true +#else + value: false +#endif + mirror: once + +- name: dom.vr.process.startup_timeout_ms + type: int32_t + value: 5000 + mirror: once + +# Puppet device, used for simulating VR hardware within tests and dev tools. +- name: dom.vr.puppet.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Starting VR presentation is only allowed within a user gesture or event such +# as VRDisplayActivate triggered by the system. dom.vr.require-gesture allows +# this requirement to be disabled for special cases such as during automated +# tests or in a headless kiosk system. +- name: dom.vr.require-gesture + type: RelaxedAtomicBool + value: true + mirror: always + +# Is support for WebXR APIs enabled? +- name: dom.vr.webxr.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Points in the native bounds geometry are required to be quantized +# sufficiently to prevent fingerprinting. The WebXR spec suggests +# quantizing to the nearest 5 centimeters. +- name: dom.vr.webxr.quantization + type: AtomicFloat + value: 0.05f + mirror: always + +#ifdef XP_WIN + # Control firing WidgetMouseEvent by handling Windows pointer messages or + # mouse messages. +- name: dom.w3c_pointer_events.dispatch_by_pointer_messages + type: bool + value: true + mirror: always + +- name: dom.w3c_pointer_events.scroll_by_pen.enabled + type: bool + value: true + mirror: always +#endif + +# If the value is >= 0, it will be used for max touch points in child processes. +- name: dom.maxtouchpoints.testing.value + type: int32_t + value: -1 + mirror: always + +# Maximum value of navigator.hardwareConcurrency. +- name: dom.maxHardwareConcurrency + type: RelaxedAtomicUint32 +#ifdef NIGHTLY_BUILD + value: 128 +#else + value: 16 +#endif + mirror: always + +# W3C pointer events draft. +- name: dom.w3c_pointer_events.implicit_capture + type: bool + value: true + mirror: always + +- name: dom.w3c_pointer_events.getcoalescedevents_only_in_securecontext + type: bool + value: @IS_NIGHTLY_BUILD@ + mirror: always + +# In case Touch API is enabled, this pref controls whether to support +# ontouch* event handlers, document.createTouch, document.createTouchList and +# document.createEvent("TouchEvent"). +- name: dom.w3c_touch_events.legacy_apis.enabled + type: bool + value: @IS_ANDROID@ + mirror: always + +# W3C touch events +# 0 - disabled, 1 - enabled, 2 - autodetect +# Autodetection is currently only supported on Windows and GTK3 (and assumed on +# Android). +- name: dom.w3c_touch_events.enabled + type: int32_t +#if defined(XP_MACOSX) + value: 0 +#else + value: 2 +#endif + mirror: always + +# Is support for the Web Audio API enabled? +- name: dom.webaudio.enabled + type: bool + value: true + mirror: always + +- name: dom.webkitBlink.dirPicker.enabled + type: RelaxedAtomicBool + value: @IS_NOT_ANDROID@ + mirror: always + +# NOTE: This preference is used in unit tests. If it is removed or its default +# value changes, please update test_sharedMap_static_prefs.js accordingly. +- name: dom.webcomponents.shadowdom.report_usage + type: bool + value: false + mirror: always + +# Is support for Declarative ShadowDOM enabled? +- name: dom.webcomponents.shadowdom.declarative.enabled + type: bool + value: true + mirror: always + +# Is support for the Web GPU API enabled? +- name: dom.webgpu.enabled + type: RelaxedAtomicBool + value: @IS_NIGHTLY_BUILD@ + mirror: always + +# Is support for the Web GPU API enabled on DOM workers? +- name: dom.webgpu.workers.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Are WebGPU indirect draws/dispatches enabled? +- name: dom.webgpu.indirect-dispatch.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# Comma-separated list of wgpu backend names to permit in WebGPU adapters. +# +# If non-empty, this is parsed by `wgpu_core::instance::parse_backends_from_comma_list` to +# produce a `wgpu_types::Backends` bitset used to create a `wgpu_core::hub::Global`. As of +# 2023-3-22, recognized names are: +# +# "vulkan" | "vk" => Backends::VULKAN, +# "dx12" | "d3d12" => Backends::DX12, +# "dx11" | "d3d11" => Backends::DX11, +# "metal" | "mtl" => Backends::METAL, +# "opengl" | "gles" | "gl" => Backends::GL, +# "webgpu" => Backends::BROWSER_WEBGPU, +- name: dom.webgpu.wgpu-backend + type: DataMutexString + value: "" + mirror: always + rust: true + +- name: dom.webgpu.swap-chain.external-texture-dx12 + type: RelaxedAtomicBool + value: false + mirror: always + rust: true + +# For testing purposes, crash if we don't get a hardware adapter. +- name: dom.webgpu.testing.assert-hardware-adapter + type: RelaxedAtomicBool + value: false + mirror: always + rust: true + +# Whether to pass labels to the hardware abstraction layer. This is only useful when +# inspecting a WebGPU workload in a GPU debugging tool like renderdoc. Enabling it +# exposes poorly tested driver API surfaces so it should not be enabled by default. +- name: dom.webgpu.hal-labels + type: bool + value: false + mirror: once + rust: true + +# Is support for HTMLInputElement.webkitEntries enabled? +- name: dom.webkitBlink.filesystem.enabled + type: bool + value: @IS_NOT_ANDROID@ + mirror: always + +# Whether the WebMIDI API is enabled +- name: dom.webmidi.enabled + type: bool + value: @IS_NOT_ANDROID@ + mirror: always + +# midi permission is addon-gated +- name: dom.webmidi.gated + type: bool + value: true + mirror: always + +- name: dom.webnotifications.allowcrossoriginiframe + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.webnotifications.enabled + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.webnotifications.privateBrowsing.enableDespiteLimitations + type: RelaxedAtomicBool + value: false + mirror: always + +- name: dom.webnotifications.requireuserinteraction + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.webnotifications.requireinteraction.enabled + type: RelaxedAtomicBool +#if defined(XP_WIN) + value: true +#else + value: @IS_NIGHTLY_BUILD@ +#endif + mirror: always + +- name: dom.webnotifications.silent.enabled + type: RelaxedAtomicBool + value: @IS_NIGHTLY_BUILD@ + mirror: always + +- name: dom.webnotifications.vibrate.enabled + type: RelaxedAtomicBool +#if defined(MOZ_WIDGET_ANDROID) + value: @IS_NIGHTLY_BUILD@ +#else + value: false +#endif + mirror: always + +# Is support for Window.event enabled? +- name: dom.window.event.enabled + type: bool + value: true + mirror: always + +- name: dom.window.clientinformation.enabled + type: bool + value: true + mirror: always + +# Whether Window.sizeToContent() is enabled. +- name: dom.window.sizeToContent.enabled + type: bool + value: false + mirror: always + +- name: dom.worker.canceling.timeoutMilliseconds + type: RelaxedAtomicUint32 + value: 30000 # 30 seconds + mirror: always + +- name: dom.worker.use_medium_high_event_queue + type: RelaxedAtomicBool + value: true + mirror: always + +# Enables the dispatching of console log events from worker threads to the +# main-thread. +- name: dom.worker.console.dispatch_events_to_main_thread + type: RelaxedAtomicBool + value: true + mirror: always + +- name: dom.workers.testing.enabled + type: RelaxedAtomicBool + value: false + mirror: always + +# WebIDL test prefs. +- name: dom.webidl.test1 + type: bool + value: true + mirror: always +- name: dom.webidl.test2 + type: bool + value: true + mirror: always + +# WebShare API - exposes navigator.share() +- name: dom.webshare.enabled + type: bool +#ifdef XP_WIN + value: @IS_EARLY_BETA_OR_EARLIER@ +#else + value: false +#endif + mirror: always + +# WebShare API - allows WebShare without user interaction (for tests only). +- name: dom.webshare.requireinteraction + type: bool + value: true + mirror: always + +# Hide the confirm dialog when a POST request is reloaded. +- name: dom.confirm_repost.testing.always_accept + type: bool + value: false + mirror: always + +# Whether we should suspend inactive tabs or not +- name: dom.suspend_inactive.enabled + type: bool + value: @IS_ANDROID@ + mirror: always + +# The following three prefs control the maximum script run time before slow +# script warning. + +# Controls the time that a content script can run before showing a +# notification. +- name: dom.max_script_run_time + type: int32_t + value: 10 + mirror: always + +# Controls whether we want to wait for user input before surfacing notifying +# the parent process about a long-running script. +- name: dom.max_script_run_time.require_critical_input + type: bool +# On desktop, we don't want to annoy the user with a notification if they're +# not interacting with the browser. On Android however, we automatically +# terminate long-running scripts, so we want to make sure we don't get in the +# way of that by waiting for input. +#if defined(MOZ_WIDGET_ANDROID) + value: false +#else + value: true +#endif + mirror: always + +# Controls if a content script will be aborted on child process shutdown. +- name: dom.abort_script_on_child_shutdown + type: bool + value: true + mirror: always + +- name: dom.max_chrome_script_run_time + type: int32_t + value: 0 + mirror: always + +- name: dom.max_ext_content_script_run_time + type: int32_t + value: 5 + mirror: always + +# Let Resize Observer report the size of all fragments, and not just the +# first one, as per CSSWG resolution: +# https://github.com/w3c/csswg-drafts/issues/3673#issuecomment-467221565 +- name: dom.resize_observer.support_fragments + type: bool + value: false + mirror: always + +#