Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 135 insertions, 0 deletions

diff --git a/dom/webidl/FuzzingFunctions.webidl b/dom/webidl/FuzzingFunctions.webidl
new file mode 100644
index 0000000000..adbd19649e
--- /dev/null
+++ b/dom/webidl/FuzzingFunctions.webidl
@@ -0,0 +1,135 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/*
+ * Various functions useful for automated fuzzing that are enabled
+ * only in --enable-fuzzing builds, because they may be dangerous to
+ * enable on untrusted pages.
+*/
+
+[Pref="fuzzing.enabled",
+ Exposed=Window]
+interface FuzzingFunctions {
+  /**
+   * Synchronously perform a garbage collection.
+   */
+  static undefined garbageCollect();
+
+  /**
+   * Synchronously perform a compacting garbage collection.
+   */
+  static undefined garbageCollectCompacting();
+
+  /**
+   * Trigger a forced crash.
+   */
+  static undefined crash(optional DOMString reason = "");
+
+  /**
+   * Synchronously perform a cycle collection.
+   */
+  static undefined cycleCollect();
+
+  /**
+   * Send a memory pressure event, causes shrinking GC, cycle collection and
+   * other actions.
+   */
+  static undefined memoryPressure();
+
+  /**
+   * Enable accessibility.
+   */
+  [Throws]
+  static undefined enableAccessibility();
+
+  /**
+   * Send IPC fuzzing ready event to parent.
+   */
+  static undefined signalIPCReady();
+
+  /**
+   * synthesizeKeyboardEvents() synthesizes a set of "keydown",
+   * "keypress" (only when it's necessary) and "keyup" events in top DOM window
+   * in current process (and the synthesized events will be retargeted to
+   * focused window/document/element).  I.e, this is currently not dispatched
+   * via the main process if you call this in a content process.  Therefore, in
+   * the case, some default action handlers which are only in the main process
+   * will never run.  Note that this does not allow to synthesize keyboard
+   * events if this is called from a keyboard event or composition event
+   * listener.
+   *
+   * @param aKeyValue          If you want to synthesize non-printable key
+   *                           events, you need to set one of key values
+   *                           defined by "UI Events KeyboardEvent key Values".
+   *                           You can check our current support values in
+   *                           dom/events/KeyNameList.h
+   *                           If you want to synthesize printable key events,
+   *                           you can set any string value including empty
+   *                           string.
+   *                           Note that |key| value in aDictionary is always
+   *                           ignored.
+   * @param aDictionary        If you want to synthesize simple key press
+   *                           without any modifiers, you can omit this.
+   *                           Otherwise, specify this with proper values.
+   *                           If |code| is omitted or empty string, this
+   *                           guesses proper code value in US-English
+   *                           keyboard.  Otherwise, the value must be empty
+   *                           string or known code value defined by "UI Events
+   *                           KeyboardEvent code Values".  You can check our
+   *                           current support values in
+   *                           dom/events/PhysicalKeyCodeNameList.h.
+   *                           If |keyCode| is omitted or 0, this guesses
+   *                           proper keyCode value in US-English keyboard.
+   *                           If |location| is omitted or 0, this assumes
+   *                           that left modifier key is pressed if aKeyValue
+   *                           is one of such modifier keys.
+   *                           |key|, |isComposing|, |charCode| and |which|
+   *                           are always ignored.
+   *                           Modifier states like |shiftKey|, |altKey|,
+   *                           |modifierAltGraph|, |modifierCapsLock| and
+   *                           |modifierNumLock| are not adjusted for
+   *                           aKeyValue.  Please specify them manually if
+   *                           necessary.
+   *                           Note that this API does not allow to dispatch
+   *                           known key events with empty |code| value and
+   *                           0 |keyCode| value since it's unsual situation
+   *                           especially 0 |keyCode| value with known key.
+   *                           Note that when you specify only one of |code|
+   *                           and |keyCode| value, the other will be guessed
+   *                           from US-English keyboard layout.  So, if you
+   *                           want to emulate key press with another keyboard
+   *                           layout, you should specify both values.
+   *
+   * For example:
+   *   // Synthesize "Tab" key events.
+   *   synthesizeKeyboardEvents("Tab");
+   *   // Synthesize Shift + Tab key events.
+   *   synthesizeKeyboardEvents("Tab", { shiftKey: true });
+   *   // Synthesize Control + A key events.
+   *   synthesizeKeyboardEvents("a", { controlKey: true });
+   *   // Synthesize Control + Shift + A key events.
+   *   synthesizeKeyboardEvents("A", { controlKey: true,
+   *                                   shitKey: true });
+   *   // Synthesize "Enter" key on numpad.
+   *   synthesizeKeyboardEvents("Enter", { code: "NumpadEnter" });
+   *   // Synthesize right "Shift" key.
+   *   synthesizeKeyboardEvents("Shift", { code: "ShiftRight" });
+   *   // Synthesize "1" on numpad.
+   *   synthesizeKeyboardEvents("1", { code: "Numpad1",
+   *                                   modifierNumLock: true });
+   *   // Synthesize "End" on numpad.
+   *   synthesizeKeyboardEvents("End", { code: "Numpad1" });
+   *   // Synthesize "%" key of US-English keyboard layout.
+   *   synthesizeKeyboardEvents("%", { shiftKey: true });
+   *   // Synthesize "*" key of Japanese keyboard layout.
+   *   synthesizeKeyboardEvents("*", { code: "Quote",
+   *                                   shiftKey: true,
+   *                                   keyCode: KeyboardEvent.DOM_VK_COLON });
+   */
+  [Throws]
+  static undefined synthesizeKeyboardEvents(DOMString aKeyValue,
+                                            optional KeyboardEventInit aDictionary = {});
+};