Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 661 insertions, 0 deletions

diff --git a/js/src/tests/browser.js b/js/src/tests/browser.js
new file mode 100644
index 0000000000..a67da99e46
--- /dev/null
+++ b/js/src/tests/browser.js
@@ -0,0 +1,661 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 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/. */
+
+// NOTE: If you're adding new test harness functionality to this file -- first,
+//       should you at all?  Most stuff is better in specific tests, or in
+//       nested shell.js/browser.js.  Second, can you instead add it to
+//       shell.js?  Our goal is to unify these two files for readability, and
+//       the plan is to empty out this file into that one over time.  Third,
+//       supposing you must add to this file, please add it to this IIFE for
+//       better modularity/resilience against tests that must do particularly
+//       bizarre things that might break the harness.
+
+(function initializeUtilityExports(global, parent) {
+  "use strict";
+
+  /**********************************************************************
+   * CACHED PRIMORDIAL FUNCTIONALITY (before a test might overwrite it) *
+   **********************************************************************/
+
+  var Error = global.Error;
+  var String = global.String;
+  var GlobalEval = global.eval;
+  var ReflectApply = global.Reflect.apply;
+  var FunctionToString = global.Function.prototype.toString;
+  var ObjectDefineProperty = global.Object.defineProperty;
+
+  // BEWARE: ObjectGetOwnPropertyDescriptor is only safe to use if its result
+  //         is inspected using own-property-examining functionality.  Directly
+  //         accessing properties on a returned descriptor without first
+  //         verifying the property's existence can invoke user-modifiable
+  //         behavior.
+  var ObjectGetOwnPropertyDescriptor = global.Object.getOwnPropertyDescriptor;
+
+  var {get: ArrayBufferByteLength} =
+    ObjectGetOwnPropertyDescriptor(global.ArrayBuffer.prototype, "byteLength");
+
+  var Worker = global.Worker;
+  var Blob = global.Blob;
+  var URL = global.URL;
+
+  var document = global.document;
+  var documentDocumentElement = global.document.documentElement;
+  var DocumentCreateElement = global.document.createElement;
+
+  var DocumentPrototypeAllGetter = ObjectGetOwnPropertyDescriptor(global.Document.prototype, "all").get;
+  var EventTargetPrototypeAddEventListener = global.EventTarget.prototype.addEventListener;
+  var HTMLElementPrototypeStyleSetter =
+    ObjectGetOwnPropertyDescriptor(global.HTMLElement.prototype, "style").set;
+  var HTMLIFramePrototypeContentWindowGetter =
+    ObjectGetOwnPropertyDescriptor(global.HTMLIFrameElement.prototype, "contentWindow").get;
+  var HTMLScriptElementTextSetter =
+    ObjectGetOwnPropertyDescriptor(global.HTMLScriptElement.prototype, "text").set;
+  var NodePrototypeAppendChild = global.Node.prototype.appendChild;
+  var NodePrototypeRemoveChild = global.Node.prototype.removeChild;
+  var {get: WindowOnErrorGetter, set: WindowOnErrorSetter} =
+    ObjectGetOwnPropertyDescriptor(global, "onerror");
+  var WorkerPrototypePostMessage = Worker.prototype.postMessage;
+  var URLCreateObjectURL = URL.createObjectURL;
+
+  // List of saved window.onerror handlers.
+  var savedGlobalOnError = [];
+
+  // Set |newOnError| as the current window.onerror handler.
+  function setGlobalOnError(newOnError) {
+    var currentOnError = ReflectApply(WindowOnErrorGetter, global, []);
+    ArrayPush(savedGlobalOnError, currentOnError);
+    ReflectApply(WindowOnErrorSetter, global, [newOnError]);
+  }
+
+  // Restore the previous window.onerror handler.
+  function restoreGlobalOnError() {
+    var previousOnError = ArrayPop(savedGlobalOnError);
+    ReflectApply(WindowOnErrorSetter, global, [previousOnError]);
+  }
+
+  /****************************
+   * GENERAL HELPER FUNCTIONS *
+   ****************************/
+
+  function ArrayPush(array, value) {
+    ReflectApply(ObjectDefineProperty, null, [
+      array, array.length,
+      {__proto__: null, value, writable: true, enumerable: true, configurable: true}
+    ]);
+  }
+
+  function ArrayPop(array) {
+    if (array.length) {
+      var item = array[array.length - 1];
+      array.length -= 1;
+      return item;
+    }
+  }
+
+  function AppendChild(elt, kid) {
+    ReflectApply(NodePrototypeAppendChild, elt, [kid]);
+  }
+
+  function CreateElement(name) {
+    return ReflectApply(DocumentCreateElement, document, [name]);
+  }
+
+  function RemoveChild(elt, kid) {
+    ReflectApply(NodePrototypeRemoveChild, elt, [kid]);
+  }
+
+  function CreateWorker(script) {
+    var blob = new Blob([script], {__proto__: null, type: "text/javascript"});
+    return new Worker(URLCreateObjectURL(blob));
+  }
+
+  /****************************
+   * UTILITY FUNCTION EXPORTS *
+   ****************************/
+
+  var evaluate = global.evaluate;
+  if (typeof evaluate !== "function") {
+    // Shim in "evaluate".
+    evaluate = function evaluate(code) {
+      if (typeof code !== "string")
+        throw Error("Expected string argument for evaluate()");
+
+      return GlobalEval(code);
+    };
+
+    global.evaluate = evaluate;
+  }
+
+  var evaluateScript = global.evaluateScript;
+  if (typeof evaluateScript !== "function") {
+    evaluateScript = function evaluateScript(code) {
+      code = String(code);
+      var script = CreateElement("script");
+
+      // Temporarily install a new onerror handler to catch script errors.
+      var hasUncaughtError = false;
+      var uncaughtError;
+      var eventOptions = {__proto__: null, once: true};
+      ReflectApply(EventTargetPrototypeAddEventListener, script, [
+        "beforescriptexecute", function() {
+          setGlobalOnError(function(messageOrEvent, source, lineno, colno, error) {
+            hasUncaughtError = true;
+            uncaughtError = error;
+            return true;
+          });
+        }, eventOptions
+      ]);
+      ReflectApply(EventTargetPrototypeAddEventListener, script, [
+        "afterscriptexecute", function() {
+          restoreGlobalOnError();
+        }, eventOptions
+      ]);
+
+      ReflectApply(HTMLScriptElementTextSetter, script, [code]);
+      AppendChild(documentDocumentElement, script);
+      RemoveChild(documentDocumentElement, script);
+
+      if (hasUncaughtError)
+        throw uncaughtError;
+    };
+
+    global.evaluateScript = evaluateScript;
+  }
+
+  var newGlobal = global.newGlobal;
+  if (typeof newGlobal !== "function") {
+    // Reuse the parent's newGlobal to ensure iframes can be added to the DOM.
+    newGlobal = parent ? parent.newGlobal : function newGlobal() {
+      var iframe = CreateElement("iframe");
+      AppendChild(documentDocumentElement, iframe);
+      var win =
+        ReflectApply(HTMLIFramePrototypeContentWindowGetter, iframe, []);
+
+      // Removing the iframe breaks evaluateScript() and detachArrayBuffer().
+      ReflectApply(HTMLElementPrototypeStyleSetter, iframe, ["display:none"]);
+
+      // Create utility functions in the new global object.
+      var initFunction = ReflectApply(FunctionToString, initializeUtilityExports, []);
+      win.Function("parent", initFunction + "; initializeUtilityExports(this, parent);")(global);
+
+      return win;
+    };
+
+    global.newGlobal = newGlobal;
+  }
+
+  var detachArrayBuffer = global.detachArrayBuffer;
+  if (typeof detachArrayBuffer !== "function") {
+    var worker = null;
+    detachArrayBuffer = function detachArrayBuffer(arrayBuffer) {
+      if (worker === null) {
+        worker = CreateWorker("/* black hole */");
+      }
+      try {
+        ReflectApply(WorkerPrototypePostMessage, worker, ["detach", [arrayBuffer]]);
+      } catch (e) {
+        // postMessage throws an error if the array buffer was already detached.
+        // Test for this condition by checking if the byte length is zero.
+        if (ReflectApply(ArrayBufferByteLength, arrayBuffer, []) !== 0) {
+          throw e;
+        }
+      }
+    };
+
+    global.detachArrayBuffer = detachArrayBuffer;
+  }
+
+  var createIsHTMLDDA = global.createIsHTMLDDA;
+  if (typeof createIsHTMLDDA !== "function") {
+    createIsHTMLDDA = function() {
+      return ReflectApply(DocumentPrototypeAllGetter, document, []);
+    };
+
+    global.createIsHTMLDDA = createIsHTMLDDA;
+  }
+})(this);
+
+(function(global) {
+  "use strict";
+
+  /**********************************************************************
+   * CACHED PRIMORDIAL FUNCTIONALITY (before a test might overwrite it) *
+   **********************************************************************/
+
+  var undefined; // sigh
+
+  var Error = global.Error;
+  var Number = global.Number;
+  var Object = global.Object;
+  var String = global.String;
+
+  var decodeURIComponent = global.decodeURIComponent;
+  var ReflectApply = global.Reflect.apply;
+  var ObjectDefineProperty = Object.defineProperty;
+  var ObjectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty;
+  var ObjectPrototypeIsPrototypeOf = Object.prototype.isPrototypeOf;
+
+  // BEWARE: ObjectGetOwnPropertyDescriptor is only safe to use if its result
+  //         is inspected using own-property-examining functionality.  Directly
+  //         accessing properties on a returned descriptor without first
+  //         verifying the property's existence can invoke user-modifiable
+  //         behavior.
+  var ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+  var window = global.window;
+  var document = global.document;
+  var documentDocumentElement = document.documentElement;
+  var DocumentCreateElement = document.createElement;
+  var ElementSetClassName =
+    ObjectGetOwnPropertyDescriptor(global.Element.prototype, "className").set;
+  var NodePrototypeAppendChild = global.Node.prototype.appendChild;
+  var NodePrototypeTextContentSetter =
+    ObjectGetOwnPropertyDescriptor(global.Node.prototype, "textContent").set;
+  var setTimeout = global.setTimeout;
+
+  // Saved harness functions.
+  var dump = global.dump;
+  var gczeal = global.gczeal;
+  var print = global.print;
+  var reportFailure = global.reportFailure;
+  var TestCase = global.TestCase;
+
+  var SpecialPowers = global.SpecialPowers;
+  var SpecialPowersCu = SpecialPowers.Cu;
+  var SpecialPowersForceGC = SpecialPowers.forceGC;
+  var TestingFunctions = SpecialPowers.Cu.getJSTestingFunctions();
+  var ClearKeptObjects = TestingFunctions.clearKeptObjects;
+
+  // Cached DOM nodes used by the test harness itself.  (We assume the test
+  // doesn't misbehave in a way that actively interferes with what the test
+  // harness runner observes, e.g. navigating the page to a different location.
+  // Short of running every test in a worker -- which has its own problems --
+  // there's no way to isolate a test from the page to that extent.)
+  var printOutputContainer =
+    global.document.getElementById("jsreftest-print-output-container");
+
+  /****************************
+   * GENERAL HELPER FUNCTIONS *
+   ****************************/
+
+  function ArrayPush(array, value) {
+    ReflectApply(ObjectDefineProperty, null, [
+      array, array.length,
+      {__proto__: null, value, writable: true, enumerable: true, configurable: true}
+    ]);
+  }
+
+  function ArrayPop(array) {
+    if (array.length) {
+      var item = array[array.length - 1];
+      array.length -= 1;
+      return item;
+    }
+  }
+
+  function HasOwnProperty(object, property) {
+    return ReflectApply(ObjectPrototypeHasOwnProperty, object, [property]);
+  }
+
+  function AppendChild(elt, kid) {
+    ReflectApply(NodePrototypeAppendChild, elt, [kid]);
+  }
+
+  function CreateElement(name) {
+    return ReflectApply(DocumentCreateElement, document, [name]);
+  }
+
+  function SetTextContent(element, text) {
+    ReflectApply(NodePrototypeTextContentSetter, element, [text]);
+  }
+
+  // Object containing the set options.
+  var currentOptions;
+
+  // browser.js version of shell.js' |shellOptionsClear| function.
+  function browserOptionsClear() {
+    for (var optionName in currentOptions) {
+      delete currentOptions[optionName];
+      SpecialPowersCu[optionName] = false;
+    }
+  }
+
+  // This function is *only* used by shell.js's for-browsers |print()| function!
+  // It's only defined/exported here because it needs CreateElement and friends,
+  // only defined here, and we're not yet ready to move them to shell.js.
+  function AddPrintOutput(s) {
+    var msgDiv = CreateElement("div");
+    SetTextContent(msgDiv, s);
+    AppendChild(printOutputContainer, msgDiv);
+  }
+  global.AddPrintOutput = AddPrintOutput;
+
+  /*************************************************************************
+   * HARNESS-CENTRIC EXPORTS (we should generally work to eliminate these) *
+   *************************************************************************/
+
+  // This overwrites shell.js's version that merely prints the given string.
+  function writeHeaderToLog(string) {
+    string = String(string);
+
+    // First dump to the console.
+    dump(string + "\n");
+
+    // Then output to the page.
+    var h2 = CreateElement("h2");
+    SetTextContent(h2, string);
+    AppendChild(printOutputContainer, h2);
+  }
+  global.writeHeaderToLog = writeHeaderToLog;
+
+  /*************************
+   * GLOBAL ERROR HANDLING *
+   *************************/
+
+  // Possible values:
+  // - "Unknown" if no error is expected,
+  // - "error" if no specific error type is expected,
+  // - otherwise the error name, e.g. "TypeError" or "RangeError".
+  var expectedError;
+
+  window.onerror = function (msg, page, line, column, error) {
+    // Unset all options even when the test finished with an error.
+    browserOptionsClear();
+
+    if (DESCRIPTION === undefined) {
+      DESCRIPTION = "Unknown";
+    }
+
+    var actual = "error";
+    var expected = expectedError;
+    if (expected !== "error" && expected !== "Unknown") {
+      // Check the error type when an actual Error object is available.
+      // NB: The |error| parameter of the onerror handler is not required to
+      // be an Error instance.
+      if (ReflectApply(ObjectPrototypeIsPrototypeOf, Error.prototype, [error])) {
+        actual = error.constructor.name;
+      } else {
+        expected = "error";
+      }
+    }
+
+    var reason = `${page}:${line}: ${msg}`;
+    new TestCase(DESCRIPTION, expected, actual, reason);
+
+    reportFailure(msg);
+  };
+
+  /**********************************************
+   * BROWSER IMPLEMENTATION FOR SHELL FUNCTIONS *
+   **********************************************/
+
+  function gc() {
+    try {
+      SpecialPowersForceGC();
+    } catch (ex) {
+      print("gc: " + ex);
+    }
+  }
+  global.gc = gc;
+
+  global.clearKeptObjects = ClearKeptObjects;
+
+  function options(aOptionName) {
+    // return value of options() is a comma delimited list
+    // of the previously set values
+
+    var value = "";
+    for (var optionName in currentOptions) {
+      if (value)
+        value += ",";
+      value += optionName;
+    }
+
+    if (aOptionName) {
+      if (!HasOwnProperty(SpecialPowersCu, aOptionName)) {
+        // This test is trying to flip an unsupported option, so it's
+        // likely no longer testing what it was supposed to.  Fail it
+        // hard.
+        throw "Unsupported JSContext option '" + aOptionName + "'";
+      }
+
+      if (aOptionName in currentOptions) {
+        // option is set, toggle it to unset
+        delete currentOptions[aOptionName];
+        SpecialPowersCu[aOptionName] = false;
+      } else {
+        // option is not set, toggle it to set
+        currentOptions[aOptionName] = true;
+        SpecialPowersCu[aOptionName] = true;
+      }
+    }
+
+    return value;
+  }
+  global.options = options;
+
+  /****************************************
+   * HARNESS SETUP AND TEARDOWN FUNCTIONS *
+   ****************************************/
+
+  function jsTestDriverBrowserInit() {
+    // Initialize with an empty set, because we just turned off all options.
+    currentOptions = Object.create(null);
+
+    if (document.location.search.indexOf("?") !== 0) {
+      // not called with a query string
+      return;
+    }
+
+    var properties = Object.create(null);
+    var fields = document.location.search.slice(1).split(";");
+    for (var i = 0; i < fields.length; i++) {
+      var propertycaptures = /^([^=]+)=(.*)$/.exec(fields[i]);
+      if (propertycaptures === null) {
+        properties[fields[i]] = true;
+      } else {
+        properties[propertycaptures[1]] = decodeURIComponent(propertycaptures[2]);
+      }
+    }
+
+    // The test path may contain \ separators for the path.
+    // Bug 1877606: use / consistently
+    properties.test = properties.test.replace(/\\/g, "/");
+
+    global.gTestPath = properties.test;
+
+    var testpathparts = properties.test.split("/");
+    if (testpathparts.length < 2) {
+      // must have at least suitepath/testcase.js
+      return;
+    }
+
+    var testFileName = testpathparts[testpathparts.length - 1];
+
+    if (testFileName.endsWith("-n.js")) {
+      // Negative test without a specific error type.
+      expectedError = "error";
+    } else if (properties.error) {
+      // Negative test which expects a specific error type.
+      expectedError = properties.error;
+    } else {
+      // No error is expected.
+      expectedError = "Unknown";
+    }
+
+    if (properties.gczeal) {
+      gczeal(Number(properties.gczeal));
+    }
+
+    // Display the test path in the title.
+    document.title = properties.test;
+
+    // Output script tags for shell.js, then browser.js, at each level of the
+    // test path hierarchy.
+    var prepath = "";
+    var scripts = [];
+    for (var i = 0; i < testpathparts.length - 1; i++) {
+      prepath += testpathparts[i] + "/";
+
+      if (properties["test262-raw"]) {
+        // Skip running test harness files (shell.js and browser.js) if the
+        // test has the raw flag.
+        continue;
+      }
+
+      scripts.push({src: prepath + "shell.js", module: false});
+      scripts.push({src: prepath + "browser.js", module: false});
+    }
+
+    // Output the test script itself.
+    var moduleTest = !!properties.module;
+    scripts.push({src: prepath + testFileName, module: moduleTest});
+
+    // Finally output the driver-end script to advance to the next test.
+    scripts.push({src: "js-test-driver-end.js", module: false});
+
+    if (properties.async) {
+      gDelayTestDriverEnd = true;
+    }
+
+    if (!moduleTest) {
+      for (var i = 0; i < scripts.length; i++) {
+        var src = scripts[i].src;
+        document.write(`<script src="${src}" charset="utf-8"><\/script>`);
+      }
+    } else {
+      // Modules are loaded asynchronously by default, but for the test harness
+      // we need to execute all scripts and modules one after the other.
+
+      // Appends the next script element to the DOM.
+      function appendScript(index) {
+        var script = scriptElements[index];
+        scriptElements[index] = null;
+        if (script !== null) {
+          ReflectApply(NodePrototypeAppendChild, documentDocumentElement, [script]);
+        }
+      }
+
+      // Create all script elements upfront, so we don't need to worry about
+      // modified built-ins.
+      var scriptElements = [];
+      for (var i = 0; i < scripts.length; i++) {
+        var spec = scripts[i];
+
+        var script = document.createElement("script");
+        script.charset = "utf-8";
+        if (spec.module) {
+          script.type = "module";
+        }
+        script.src = spec.src;
+
+        let nextScriptIndex = i + 1;
+        if (nextScriptIndex < scripts.length) {
+          var callNextAppend = () => appendScript(nextScriptIndex);
+          script.addEventListener("afterscriptexecute", callNextAppend, {once: true});
+
+          // Module scripts don't fire the "afterscriptexecute" event when there
+          // was an error, instead the "error" event is emitted. So listen for
+          // both events when creating module scripts.
+          if (spec.module) {
+            script.addEventListener("error", callNextAppend, {once: true});
+          }
+        }
+
+        scriptElements[i] = script;
+      }
+
+      // Append the first script.
+      appendScript(0);
+    }
+  }
+
+  global.gDelayTestDriverEnd = false;
+
+  function jsTestDriverEnd() {
+    // gDelayTestDriverEnd is used to delay collection of the test result and
+    // signal to Spider so that tests can continue to run after page load has
+    // fired. They are responsible for setting gDelayTestDriverEnd = true then
+    // when completed, setting gDelayTestDriverEnd = false then calling
+    // jsTestDriverEnd()
+
+    if (gDelayTestDriverEnd) {
+      return;
+    }
+
+    window.onerror = null;
+
+    // Unset all options when the test has finished.
+    browserOptionsClear();
+
+    if (window.opener && window.opener.runNextTest) {
+      if (window.opener.reportCallBack) {
+        window.opener.reportCallBack(window.opener.gWindow);
+      }
+
+      setTimeout("window.opener.runNextTest()", 250);
+    } else {
+      // tell reftest the test is complete.
+      ReflectApply(ElementSetClassName, documentDocumentElement, [""]);
+      // tell Spider page is complete
+      gPageCompleted = true;
+    }
+  }
+  global.jsTestDriverEnd = jsTestDriverEnd;
+
+  /***************************************************************************
+   * DIALOG CLOSER, PRESUMABLY TO CLOSE SLOW SCRIPT DIALOGS AND OTHER POPUPS *
+   ***************************************************************************/
+
+  // dialog closer from http://bclary.com/projects/spider/spider/chrome/content/spider/dialog-closer.js
+
+  // Use an array to handle the case where multiple dialogs appear at one time.
+  var dialogCloserSubjects = [];
+  var dialogCloser = SpecialPowers
+                     .Cc["@mozilla.org/embedcomp/window-watcher;1"]
+                     .getService(SpecialPowers.Ci.nsIWindowWatcher);
+  var dialogCloserObserver = {
+    observe(subject, topic, data) {
+      if (topic === "domwindowopened" && subject.isChromeWindow) {
+        ArrayPush(dialogCloserSubjects, subject);
+
+        // Timeout of 0 needed when running under reftest framework.
+        subject.setTimeout(closeDialog, 0);
+      }
+    }
+  };
+
+  function closeDialog() {
+    while (dialogCloserSubjects.length > 0) {
+      var subject = ArrayPop(dialogCloserSubjects);
+      subject.close();
+    }
+  }
+
+  function unregisterDialogCloser() {
+    gczeal(0);
+
+    if (!dialogCloserObserver || !dialogCloser) {
+      return;
+    }
+
+    dialogCloser.unregisterNotification(dialogCloserObserver);
+
+    dialogCloserObserver = null;
+    dialogCloser = null;
+  }
+
+  dialogCloser.registerNotification(dialogCloserObserver);
+  window.addEventListener("unload", unregisterDialogCloser, true);
+
+  /*******************************************
+   * RUN ONCE CODE TO SETUP ADDITIONAL STATE *
+   *******************************************/
+
+  jsTestDriverBrowserInit();
+
+})(this);
+
+var gPageCompleted;