Merge mozilla-central to autoland. a=merge CLOSED TREE
authorNoemi Erli <nerli@mozilla.com>
Tue, 16 Oct 2018 01:21:28 +0300
changeset 489702 336f795d5b2621dd2d693649f815ad65182f5c17
parent 489701 32e5d5e6c9804247b0f82f931dc875fdc838f750 (current diff)
parent 489659 4c11ab0cd98950983cfc957f579ace6c3e918a43 (diff)
child 489703 5622861eb245cc20b3a121ffb73f1b58c9745934
push id247
push userfmarier@mozilla.com
push dateSat, 27 Oct 2018 01:06:44 +0000
reviewersmerge
milestone64.0a1
Merge mozilla-central to autoland. a=merge CLOSED TREE
security/sandbox/chromium-shim/patches/with_update/mingw_disable_one_try.patch
testing/web-platform/meta/dom/events/EventListener-addEventListener.sub.window.js.ini
testing/web-platform/meta/dom/events/EventListener-incumbent-global-1.sub.html.ini
--- a/.hgtags
+++ b/.hgtags
@@ -142,8 +142,13 @@ 5faab9e619901b1513fd4ca137747231be550def
 e33efdb3e1517d521deb949de3fcd6d9946ea440 FIREFOX_BETA_60_BASE
 fdd1a0082c71673239fc2f3a6a93de889c07a1be FIREFOX_NIGHTLY_60_END
 ccfd7b716a91241ddbc084cb7116ec561e56d5d1 FIREFOX_BETA_61_BASE
 93443d36d4bd53dba004f7b73430879f96daa681 FIREFOX_NIGHTLY_61_END
 9b74b9f2939a7ae3a0ea6e711dc32ed5203e03ff FIREFOX_BETA_62_BASE
 4f6e597104dabedfecfafa2ab63dc79fd7f8bc7a FIREFOX_NIGHTLY_62_END
 190b827aaa2b5e6fb9af7a0defb238ccc35f8b9e FIREFOX_BETA_63_BASE
 034c5ef24e98b0ce85fa849face079f568eb397c FIREFOX_NIGHTLY_63_END
+4a230b07f0cbf48e87dcb4265ea2d00893bb1b62 FIREFOX_BETA_64_BASE
+4a230b07f0cbf48e87dcb4265ea2d00893bb1b62 FIREFOX_BETA_64_BASE
+224715760a637bc37c14794839468a954f1f2695 FIREFOX_BETA_64_BASE
+224715760a637bc37c14794839468a954f1f2695 FIREFOX_BETA_64_BASE
+ad179a6fc14cbd41d10a018ac4a3822db119de3b FIREFOX_BETA_64_BASE
--- a/build/moz.configure/android-ndk.configure
+++ b/build/moz.configure/android-ndk.configure
@@ -314,30 +314,30 @@ def android_toolchain_prefix(prefix_base
 
 imply_option('--with-toolchain-prefix', android_toolchain_prefix,
              reason='--with-android-ndk')
 
 
 @depends(extra_toolchain_flags, android_toolchain,
          android_toolchain_prefix_base, '--help')
 @imports(_from='os.path', _import='isdir')
-def bindgen_cflags_defaults(toolchain_flags, toolchain, toolchain_prefix, _):
+def bindgen_cflags_android(toolchain_flags, toolchain, toolchain_prefix, _):
     if not toolchain_flags:
         return
 
     gcc_include = os.path.join(
         toolchain, 'lib', 'gcc', toolchain_prefix, '4.9.x')
     if not isdir(gcc_include):
         gcc_include = os.path.join(
             toolchain, 'lib', 'gcc', toolchain_prefix, '4.9')
 
-    cflags_format = "%s -I%s -I%s"
-    return cflags_format % (' '.join(toolchain_flags),
-                            os.path.join(gcc_include, 'include'),
-                            os.path.join(gcc_include, 'include-fixed'))
+    return toolchain_flags + [
+        '-I%s' % os.path.join(gcc_include, 'include'),
+        '-I%s' % os.path.join(gcc_include, 'include-fixed'),
+    ]
 
 
 @depends(host, ndk)
 @imports(_from='os.path', _import='exists')
 @imports(_from='os.path', _import='isdir')
 def android_clang_compiler(host, ndk):
     if not ndk:
         return
--- a/build/moz.configure/bindgen.configure
+++ b/build/moz.configure/bindgen.configure
@@ -207,8 +207,136 @@ def bindgen_config_paths(llvm_config, li
 
     return namespace(
         libclang_path=libclang_path,
         clang_path=clang_resolved,
     )
 
 set_config('MOZ_LIBCLANG_PATH', bindgen_config_paths.libclang_path)
 set_config('MOZ_CLANG_PATH', bindgen_config_paths.clang_path)
+
+
+@depends(host, target, target_is_unix, c_compiler, bindgen_cflags_android)
+def basic_bindgen_cflags(host, target, is_unix, compiler_info, android_cflags):
+    args = [
+        '-x', 'c++', '-std=gnu++14', '-fno-sized-deallocation',
+        '-DTRACING=1', '-DIMPL_LIBXUL', '-DMOZILLA_INTERNAL_API',
+        '-DRUST_BINDGEN'
+    ]
+
+    if is_unix:
+        args += ['-DOS_POSIX=1']
+
+    if target.os == 'Android':
+        args += android_cflags
+
+    def handle_cpu(obj):
+        if 'cpu' in obj and target.cpu in obj['cpu']:
+            return obj['cpu'][target.cpu]
+        return []
+
+    if target.os == 'WINNT' and host.raw_os.startswith('gnu'):
+        args += handle_cpu({
+            'cpu': {
+                'x86': ['--target=i686-pc-mingw32'],
+                'x86_64': ['--target=x86_64-w64-mingw32'],
+            },
+        })
+
+    os_dict = {
+        'Android': {
+            'default': ['-DOS_ANDROID=1'],
+            'cpu': {
+                'aarch64': ['--target=aarch64-linux-android'],
+                'arm': ['--target=armv7-linux-androideabi'],
+                'x86': ['--target=i686-linux-android'],
+                'x86_64': ['--target=x86_64-linux-android'],
+            },
+        },
+        'DragonFly': {
+            'default': ['-DOS_BSD=1', '-DOS_DRAGONFLY=1'],
+        },
+        'FreeBSD': {
+            'default': ['-DOS_BSD=1', '-DOS_FREEBSD=1'],
+        },
+        'GNU': {
+            'default': ['-DOS_LINUX=1'],
+            'cpu': {
+                'x86': ['-m32'],
+                'x86_64': ['-m64'],
+            },
+        },
+        'NetBSD': {
+            'default': ['-DOS_BSD=1', '-DOS_NETBSD=1'],
+        },
+        'OpenBSD': {
+            'default': ['-DOS_BSD=1', '-DOS_OPENBSD=1'],
+        },
+        'OSX': {
+            'default': [
+                '-DOS_MACOSX=1',
+                '-stdlib=libc++',
+                # To disable the fixup bindgen applies which adds search
+                # paths from clang command line in order to avoid potential
+                # conflict with -stdlib=libc++.
+                '--target=x86_64-apple-darwin',
+            ],
+        },
+        'SunOS': {
+            'default': ['-DOS_SOLARIS=1'],
+        },
+        'WINNT': {
+            'default': [
+                '-DOS_WIN=1',
+                '-DWIN32=1',
+            ],
+            'compiler': {
+                'msvc': {
+                    'default': [
+                        # For compatibility with MSVC 2015
+                        '-fms-compatibility-version=19',
+                        # To enable the builtin __builtin_offsetof so that CRT wouldn't
+                        # use reinterpret_cast in offsetof() which is not allowed inside
+                        # static_assert().
+                        '-D_CRT_USE_BUILTIN_OFFSETOF',
+                        # Enable hidden attribute (which is not supported by MSVC and
+                        # thus not enabled by default with a MSVC-compatibile build)
+                        # to exclude hidden symbols from the generated file.
+                        '-DHAVE_VISIBILITY_HIDDEN_ATTRIBUTE=1',
+                    ],
+                    'cpu': {
+                        'x86': ['--target=i686-pc-win32'],
+                        'x86_64': ['--target=x86_64-pc-win32'],
+                        'aarch64': ['--target=aarch64-pc-windows-msvc'],
+                    },
+                },
+            },
+        },
+    }.get(target.os, {})
+
+    if 'default' in os_dict:
+        args += os_dict['default']
+
+    args += handle_cpu(os_dict)
+    if 'compiler' in os_dict and compiler_info and compiler_info in os_dict['compiler']:
+        compiler_dict = os_dict['compiler'].get(compiler_info)
+        if 'default' in compiler_dict:
+            args += compiler_dict['default']
+        args += handle_cpu(compiler_dict)
+
+    return args
+
+
+js_option(env='BINDGEN_CFLAGS',
+          nargs=1,
+          help='Options bindgen should pass to the C/C++ parser')
+
+
+@depends(basic_bindgen_cflags, 'BINDGEN_CFLAGS')
+@checking('bindgen cflags', lambda s: s if s else 'no')
+def bindgen_cflags(base_flags, extra_flags):
+    flags = base_flags
+    if extra_flags and len(extra_flags):
+        flags += extra_flags[0].split()
+    return ' '.join(flags)
+
+
+add_old_configure_assignment('_BINDGEN_CFLAGS', bindgen_cflags)
--- a/build/moz.configure/toolchain.configure
+++ b/build/moz.configure/toolchain.configure
@@ -1121,32 +1121,16 @@ include('compile-checks.configure')
          try_compile(body='static_assert(sizeof(void *) == 8, "")',
                      check_msg='for 64-bit OS'))
 def check_have_64_bit(have_64_bit, compiler_have_64_bit):
     if have_64_bit != compiler_have_64_bit:
         configure_error('The target compiler does not agree with configure '
                         'about the target bitness.')
 
 
-js_option(env='BINDGEN_CFLAGS',
-          nargs=1,
-          default=bindgen_cflags_defaults,
-          help='Options bindgen should pass to the C/C++ parser')
-
-
-@depends('BINDGEN_CFLAGS')
-@checking('bindgen cflags', lambda s: s if s else 'no')
-def bindgen_cflags(value):
-    if value and len(value):
-        return value[0].split()
-
-
-add_old_configure_assignment('_BINDGEN_CFLAGS', bindgen_cflags)
-
-
 @depends(c_compiler)
 def default_debug_flags(compiler_info):
     # Debug info is ON by default.
     if compiler_info.type in ('msvc', 'clang-cl'):
         return '-Zi'
     return '-g'
 
 
--- a/devtools/client/locales/en-US/memory.properties
+++ b/devtools/client/locales/en-US/memory.properties
@@ -22,17 +22,17 @@ snapshot.io.delete=Delete
 # displayed when saving a snapshot to disk.
 snapshot.io.save.window=Save Snapshot
 
 # LOCALIZATION NOTE (snapshot.io.import.window): The title for the window
 # displayed when importing a snapshot form disk.
 snapshot.io.import.window=Import Snapshot
 
 # LOCALIZATION NOTE (snapshot.io.filter): The title for the filter used to
-# filter file types (*.fxsnapshot.gz)
+# filter file types (*.fxsnapshot)
 snapshot.io.filter=Firefox Snapshots
 
 # LOCALIZATION NOTE (aggregate.mb): The label annotating the number of bytes (in
 # megabytes) in a snapshot. %S represents the value, rounded to 2 decimal
 # points.
 aggregate.mb=%S MB
 
 # LOCALIZATION NOTE (snapshot-title.loading): The title for a snapshot before
--- a/devtools/client/memory/actions/io.js
+++ b/devtools/client/memory/actions/io.js
@@ -14,18 +14,17 @@ const {
 } = require("./snapshot");
 const VALID_EXPORT_STATES = [states.SAVED, states.READ];
 
 exports.pickFileAndExportSnapshot = function(snapshot) {
   return async function(dispatch, getState) {
     const outputFile = await openFilePicker({
       title: L10N.getFormatStr("snapshot.io.save.window"),
       defaultName: OS.Path.basename(snapshot.path),
-      filters: [[L10N.getFormatStr("snapshot.io.filter"),
-                 "*.fxsnapshot; *.fxsnapshot.gz"]],
+      filters: [[L10N.getFormatStr("snapshot.io.filter"), "*.fxsnapshot"]],
       mode: "save",
     });
 
     if (!outputFile) {
       return;
     }
 
     await dispatch(exportSnapshot(snapshot, outputFile.path));
@@ -49,18 +48,17 @@ const exportSnapshot = exports.exportSna
     dispatch({ type: actions.EXPORT_SNAPSHOT_END, snapshot });
   };
 };
 
 exports.pickFileAndImportSnapshotAndCensus = function(heapWorker) {
   return async function(dispatch, getState) {
     const input = await openFilePicker({
       title: L10N.getFormatStr("snapshot.io.import.window"),
-      filters: [[L10N.getFormatStr("snapshot.io.filter"),
-                 "*.fxsnapshot; *.fxsnapshot.gz"]],
+      filters: [[L10N.getFormatStr("snapshot.io.filter"), "*.fxsnapshot"]],
       mode: "open",
     });
 
     if (!input) {
       return;
     }
 
     await dispatch(importSnapshotAndCensus(heapWorker, input.path));
--- a/devtools/client/memory/test/unit/head.js
+++ b/devtools/client/memory/test/unit/head.js
@@ -121,15 +121,15 @@ function waitUntilCensusState(store, get
                     (census && census.state === state);
            });
   };
   info(`Waiting for snapshots' censuses to be of state: ${expected}`);
   return waitUntilState(store, predicate);
 }
 
 async function createTempFile() {
-  const file = FileUtils.getFile("TmpD", ["tmp.fxsnapshot.gz"]);
+  const file = FileUtils.getFile("TmpD", ["tmp.fxsnapshot"]);
   file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
   const destPath = file.path;
   const stat = await OS.File.stat(destPath);
   ok(stat.size === 0, "new file is 0 bytes at start");
   return destPath;
 }
--- a/devtools/client/memory/utils.js
+++ b/devtools/client/memory/utils.js
@@ -37,19 +37,18 @@ const {
  * @return {String}
  */
 exports.getSnapshotTitle = function(snapshot) {
   if (!snapshot.creationTime) {
     return L10N.getStr("snapshot-title.loading");
   }
 
   if (snapshot.imported) {
-    // Strip out the extension if it's the expected ".fxsnapshot.gz"
-    // (".gz" optional)
-    return OS.Path.basename(snapshot.path.replace(/\.fxsnapshot(?:\.gz)?$/, ""));
+    // Strip out the extension if it's the expected ".fxsnapshot"
+    return OS.Path.basename(snapshot.path.replace(/\.fxsnapshot$/, ""));
   }
 
   const date = new Date(snapshot.creationTime / 1000);
   return date.toLocaleTimeString(void 0, {
     year: "2-digit",
     month: "2-digit",
     day: "2-digit",
     hour12: false
--- a/devtools/client/netmonitor/src/components/ParamsPanel.js
+++ b/devtools/client/netmonitor/src/components/ParamsPanel.js
@@ -77,17 +77,17 @@ class ParamsPanel extends Component {
    * results in unexpected order of params. See bug 1469533
    *
    * @param {Object[]} arr - key-value pair array like query or form params
    * @returns {Object} Rep compatible object
    */
   getProperties(arr) {
     return arr.reduce((map, obj) => {
       const value = map[obj.name];
-      if (value) {
+      if (value || value === "") {
         if (typeof value !== "object") {
           map[obj.name] = [value];
         }
         map[obj.name].push(obj.value);
       } else {
         map[obj.name] = obj.value;
       }
       return map;
--- a/devtools/client/netmonitor/src/utils/filter-predicates.js
+++ b/devtools/client/netmonitor/src/utils/filter-predicates.js
@@ -53,17 +53,19 @@ function isImage({ mimeType }) {
   return mimeType && mimeType.includes("image/");
 }
 
 function isMedia({ mimeType }) {
   // Not including images.
   return mimeType && (
     mimeType.includes("audio/") ||
     mimeType.includes("video/") ||
-    mimeType.includes("model/"));
+    mimeType.includes("model/") ||
+    mimeType === "application/vnd.apple.mpegurl" ||
+    mimeType === "application/x-mpegurl");
 }
 
 function isWS({ requestHeaders, responseHeaders }) {
   // Detect a websocket upgrade if request has an Upgrade header with value 'websocket'
   if (!requestHeaders || !Array.isArray(requestHeaders.headers)) {
     return false;
   }
 
--- a/devtools/client/netmonitor/test/browser_net_complex-params.js
+++ b/devtools/client/netmonitor/test/browser_net_complex-params.js
@@ -14,17 +14,17 @@ add_task(async function() {
 
   const { document, store, windowRequire } = monitor.panelWin;
   const Actions = windowRequire("devtools/client/netmonitor/src/actions/index");
   const { L10N } = windowRequire("devtools/client/netmonitor/src/utils/l10n");
 
   store.dispatch(Actions.batchEnable(false));
 
   // Execute requests.
-  await performRequests(monitor, tab, 10);
+  await performRequests(monitor, tab, 12);
 
   wait = waitForDOM(document, "#params-panel .tree-section", 2);
   EventUtils.sendMouseEvent({ type: "mousedown" },
     document.querySelectorAll(".request-list-item")[0]);
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector("#params-tab"));
   await wait;
   testParamsTab1("a", "", '{ "foo": "bar" }', "");
@@ -80,16 +80,33 @@ add_task(async function() {
   wait = waitForDOM(document, "#params-panel .tree-section", 1);
   EventUtils.sendMouseEvent({ type: "mousedown" },
     document.querySelectorAll(".request-list-item")[9]);
   await wait;
   testParamsTabGetWithArgs(new Map([
     ["species", "in=(52,60)"],
   ]));
 
+  wait = waitForDOM(document, "#params-panel .tree-section", 1);
+  EventUtils.sendMouseEvent({ type: "mousedown" },
+    document.querySelectorAll(".request-list-item")[10]);
+  await wait;
+  testParamsTabGetWithArgs(new Map([
+    ["a", ["", "b"]],
+  ]));
+
+  wait = waitForDOM(document, "#params-panel .tree-section", 1);
+  EventUtils.sendMouseEvent({ type: "mousedown" },
+    document.querySelectorAll(".request-list-item")[11]);
+  await wait;
+  testParamsTabGetWithArgs(new Map([
+    ["a", ["b", "c"]],
+    ["d", "1"]
+  ]));
+
   await teardown(monitor);
 
   function testParamsTab1(queryStringParamName, queryStringParamValue,
                           formDataParamName, formDataParamValue) {
     const tabpanel = document.querySelector("#params-panel");
 
     is(tabpanel.querySelectorAll(".tree-section").length, 2,
       "The number of param tree sections displayed in this tabpanel is incorrect.");
@@ -193,25 +210,32 @@ add_task(async function() {
 
     ok(!tabpanel.querySelector(".treeTable"),
       "The request params box should be hidden.");
     ok(!tabpanel.querySelector(".CodeMirror-code"),
       "The request post data editor should be hidden.");
   }
 
   /**
-   * @param {Map} expectedParams A map of expected parameter keys and values
-   * as Strings.
+   * @param {Map} expectedParams A map of expected parameter keys, and values
+   * as Strings or an array of Strings if the parameter key has multiple
+   * values
    */
   function testParamsTabGetWithArgs(expectedParams) {
     const tabpanel = document.querySelector("#params-panel");
 
+    let numParamRows = 0;
+    expectedParams.forEach((v, k, m) => {
+      numParamRows += (typeof v === "object" ? v.length + 1 : 1);
+    });
+
     is(tabpanel.querySelectorAll(".tree-section").length, 1,
       "Check the number of param tree sections displayed in this tabpanel.");
-    is(tabpanel.querySelectorAll("tr:not(.tree-section).treeRow").length, 1,
+    is(tabpanel.querySelectorAll("tr:not(.tree-section).treeRow").length,
+      numParamRows,
       "Check the number of param rows displayed in this tabpanel.");
     ok(!tabpanel.querySelector(".empty-notice"),
       "The empty notice should not be displayed in this tabpanel.");
 
     ok(tabpanel.querySelector(".treeTable"),
       "The request params box should be shown.");
     ok(!tabpanel.querySelector(".CodeMirror-code"),
       "The request post data editor should be hidden.");
@@ -224,15 +248,33 @@ add_task(async function() {
 
     is(treeSections[0].querySelector(".treeLabel").textContent,
       L10N.getStr("paramsQueryString"),
       "Check the displayed params section title.");
 
     const labelsIter = labels.values();
     const valuesIter = values.values();
     for (const [expKey, expValue] of expectedParams) {
-      const label = labelsIter.next().value;
-      const value = valuesIter.next().value;
-      is(label.textContent, expKey, "Check that parameter name matches.");
-      is(value.textContent, expValue, "Check that parameter value matches.");
+      let label = labelsIter.next().value;
+      let value = valuesIter.next().value;
+
+      if (typeof expValue === "object") {
+        // multiple values for one parameter
+        is(label.textContent, expKey, "Check that parameter name matches.");
+        is(value.textContent, "[\u2026]", // horizontal ellipsis
+          "Check that parameter value indicates multiple.");
+
+        for (let i = 0; i < expValue.length; i++) {
+          label = labelsIter.next().value;
+          value = valuesIter.next().value;
+          is(label.textContent, i + "",
+            "Check that multi-value parameter index matches.");
+          is(value.textContent, expValue[i],
+            "Check that multi-value parameter value matches.");
+          is(label.dataset.level, 2, "Check that parameter is nested.");
+        }
+      } else {
+        is(label.textContent, expKey, "Check that parameter name matches.");
+        is(value.textContent, expValue, "Check that parameter value matches.");
+      }
     }
   }
 });
--- a/devtools/client/netmonitor/test/browser_net_filter-01.js
+++ b/devtools/client/netmonitor/test/browser_net_filter-01.js
@@ -23,16 +23,18 @@ const BASIC_REQUESTS = [
   { url: `sjs_content-type-test-server.sjs?fmt=js&text=${ENCODED_CHARS_IN_URI_COMP}` },
 ];
 
 const REQUESTS_WITH_MEDIA = BASIC_REQUESTS.concat([
   { url: getSjsURLInUnicodeIdn() + "?fmt=font" },
   { url: "sjs_content-type-test-server.sjs?fmt=image" },
   { url: "sjs_content-type-test-server.sjs?fmt=audio" },
   { url: "sjs_content-type-test-server.sjs?fmt=video" },
+  { url: "sjs_content-type-test-server.sjs?fmt=hls-m3u8" },
+  { url: "sjs_content-type-test-server.sjs?fmt=hls-m3u8-alt-mime-type" },
 ]);
 
 const REQUESTS_WITH_MEDIA_AND_FLASH = REQUESTS_WITH_MEDIA.concat([
   { url: "sjs_content-type-test-server.sjs?fmt=flash" },
 ]);
 
 const REQUESTS_WITH_MEDIA_AND_FLASH_AND_WS = REQUESTS_WITH_MEDIA_AND_FLASH.concat([
   /* "Upgrade" is a reserved header and can not be set on XMLHttpRequest */
@@ -147,16 +149,38 @@ const EXPECTED_REQUESTS = [
       status: 200,
       statusText: "OK",
       type: "webm",
       fullMimeType: "video/webm"
     },
   },
   {
     method: "GET",
+    url: CONTENT_TYPE_SJS + "?fmt=hls-m3u8",
+    data: {
+      fuzzyUrl: true,
+      status: 200,
+      statusText: "OK",
+      type: "x-mpegurl",
+      fullMimeType: "application/x-mpegurl"
+    },
+  },
+  {
+    method: "GET",
+    url: CONTENT_TYPE_SJS + "?fmt=hls-m3u8-alt-mime-type",
+    data: {
+      fuzzyUrl: true,
+      status: 200,
+      statusText: "OK",
+      type: "vnd.apple.mpegurl",
+      fullMimeType: "application/vnd.apple.mpegurl"
+    },
+  },
+  {
+    method: "GET",
     url: CONTENT_TYPE_SJS + "?fmt=flash",
     data: {
       fuzzyUrl: true,
       status: 200,
       statusText: "OK",
       type: "x-shockwave-flash",
       fullMimeType: "application/x-shockwave-flash"
     }
@@ -203,174 +227,174 @@ add_task(async function() {
     "There should be a selected item in the requests menu.");
   is(getSelectedIndex(store.getState()), 0,
     "The first item should be selected in the requests menu.");
   is(!!document.querySelector(".network-details-panel"), true,
     "The network details panel should render correctly.");
 
   // First test with single filters...
   testFilterButtons(monitor, "all");
-  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
+  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-html-button"));
   testFilterButtons(monitor, "html");
-  await testContents([1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // Reset filters
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-css-button"));
   testFilterButtons(monitor, "css");
-  await testContents([0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-js-button"));
   testFilterButtons(monitor, "js");
-  await testContents([0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0]);
+  await testContents([0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-xhr-button"));
   testFilterButtons(monitor, "xhr");
-  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]);
+  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   EventUtils.sendMouseEvent({ type: "click" },
      document.querySelector(".requests-list-filter-fonts-button"));
   testFilterButtons(monitor, "fonts");
-  await testContents([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]);
+  await testContents([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-images-button"));
   testFilterButtons(monitor, "images");
-  await testContents([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]);
+  await testContents([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-media-button"));
   testFilterButtons(monitor, "media");
-  await testContents([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]);
+  await testContents([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-ws-button"));
   testFilterButtons(monitor, "ws");
-  await testContents([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
+  await testContents([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
 
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
 
   testFilterButtons(monitor, "all");
-  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
+  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
 
   // Text in filter box that matches nothing should hide all.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter("foobar");
-  await testContents([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // ASCII text in filter box that matches should filter out everything else.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter("sample");
-  await testContents([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // ASCII text in filter box that matches should filter out everything else.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter("SAMPLE");
-  await testContents([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // Test negative filtering ASCII text(only show unmatched items)
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter("-sample");
-  await testContents([0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
+  await testContents([0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
 
   // Unicode text in filter box that matches should filter out everything else.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter(UNICODE_IN_URI_COMPONENT);
-  await testContents([0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0]);
+  await testContents([0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // Ditto, except the above is for a Unicode URI component, and this one is for
   // a Unicode domain name.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter(UNICODE_IN_IDN);
-  await testContents([1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]);
+  await testContents([1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]);
 
   // Test negative filtering Unicode text(only show unmatched items)
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter(`-${UNICODE_IN_URI_COMPONENT}`);
-  await testContents([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1]);
+  await testContents([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]);
 
   // Ditto, except the above is for a Unicode URI component, and this one is for
   // a Unicode domain name.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   setFreetextFilter(`-${UNICODE_IN_IDN}`);
-  await testContents([0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1]);
+  await testContents([0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1]);
 
   // ...then combine multiple filters together.
 
   // Enable filtering for html and css; should show request of both type.
   setFreetextFilter("");
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-html-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-css-button"));
   testFilterButtonsCustom(monitor, [0, 1, 1, 0, 0, 0, 0, 0, 0, 0]);
-  await testContents([1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // Html and css filter enabled and text filter should show just the html and css match.
   // Should not show both the items matching the button plus the items matching the text.
   setFreetextFilter("sample");
-  await testContents([1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
   setFreetextFilter(UNICODE_IN_URI_COMPONENT);
-  await testContents([0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
   setFreetextFilter("");
   testFilterButtonsCustom(monitor, [0, 1, 1, 0, 0, 0, 0, 0, 0, 0]);
-  await testContents([1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // Disable some filters. Only one left active.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-css-button"));
   testFilterButtons(monitor, "html");
-  await testContents([1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]);
+  await testContents([1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
   // Disable last active filter. Should toggle to all.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-html-button"));
   testFilterButtons(monitor, "all");
-  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
+  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
 
   // Enable few filters and click on all. Only "all" should be checked.
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-html-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-css-button"));
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-ws-button"));
   testFilterButtonsCustom(monitor, [0, 1, 1, 0, 0, 0, 0, 0, 1, 0]);
   EventUtils.sendMouseEvent({ type: "click" },
     document.querySelector(".requests-list-filter-all-button"));
   testFilterButtons(monitor, "all");
-  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
+  await testContents([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
 
   await teardown(monitor);
 
   function getSelectedIndex(state) {
     if (!state.requests.selectedId) {
       return -1;
     }
     return getSortedRequests(state).findIndex(r => r.id === state.requests.selectedId);
--- a/devtools/client/netmonitor/test/html_params-test-page.html
+++ b/devtools/client/netmonitor/test/html_params-test-page.html
@@ -64,13 +64,15 @@
         await post("baz", "?a=b", urlencoded, "?foo=bar");
         await post("baz", "?a", undefined, '{ "foo": "bar" }');
         await post("baz", "?a=b", undefined, '{ "foo": "bar" }');
         await post("baz", "?a=b", undefined, "?foo=bar");
         await get("baz", "");
         await patch("baz", "?a=b", urlencoded, '{ "foo": "bar" }');
         await put("baz", "?a=b", urlencoded, '{ "foo": "bar" }');
         await get("baz", "?species=in=(52,60)");
+        await get("baz", "?a=&a=b");
+        await get("baz", "?a=b&a=c&d=1");
       }
     </script>
   </body>
 
 </html>
--- a/devtools/client/netmonitor/test/sjs_content-type-test-server.sjs
+++ b/devtools/client/netmonitor/test/sjs_content-type-test-server.sjs
@@ -261,16 +261,24 @@ function handleRequest(request, response
       case "hls-m3u8": {
         response.setStatusLine(request.httpVersion, status, "OK");
         response.setHeader("Content-Type", "application/x-mpegurl", false);
         setCacheHeaders();
         response.write("#EXTM3U\n");
         response.finish();
         break;
       }
+      case "hls-m3u8-alt-mime-type": {
+        response.setStatusLine(request.httpVersion, status, "OK");
+        response.setHeader("Content-Type", "application/vnd.apple.mpegurl", false);
+        setCacheHeaders();
+        response.write("#EXTM3U\n");
+        response.finish();
+        break;
+      }
       case "mpeg-dash": {
         response.setStatusLine(request.httpVersion, status, "OK");
         response.setHeader("Content-Type", "video/vnd.mpeg.dash.mpd", false);
         setCacheHeaders();
         response.write('<?xml version="1.0" encoding="UTF-8"?>\n');
         response.write('<MPD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"></MPD>\n');
         response.finish();
         break;
--- a/devtools/shared/heapsnapshot/HeapSnapshot.cpp
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.cpp
@@ -1444,32 +1444,32 @@ HeapSnapshot::CreateUniqueCoreDumpFile(E
     return nullptr;
 
   nsAutoString tempPath;
   rv = file->GetPath(tempPath);
   if (NS_WARN_IF(rv.Failed()))
     return nullptr;
 
   auto ms = msSinceProcessCreation(now);
-  rv = file->AppendNative(nsPrintfCString("%lu.fxsnapshot.gz", ms));
+  rv = file->AppendNative(nsPrintfCString("%lu.fxsnapshot", ms));
   if (NS_WARN_IF(rv.Failed()))
     return nullptr;
 
   rv = file->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0666);
   if (NS_WARN_IF(rv.Failed()))
     return nullptr;
 
   rv = file->GetPath(outFilePath);
   if (NS_WARN_IF(rv.Failed()))
       return nullptr;
 
   // The snapshot ID must be computed in the process that created the
   // temp file, because TmpD may not be the same in all processes.
   outSnapshotId.Assign(Substring(outFilePath, tempPath.Length() + 1,
-                                 outFilePath.Length() - tempPath.Length() - sizeof(".fxsnapshot.gz")));
+                                 outFilePath.Length() - tempPath.Length() - sizeof(".fxsnapshot")));
 
   return file.forget();
 }
 
 // Deletion policy for cleaning up PHeapSnapshotTempFileHelperChild pointers.
 class DeleteHeapSnapshotTempFileHelperChild
 {
 public:
--- a/devtools/shared/heapsnapshot/HeapSnapshot.h
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.h
@@ -111,17 +111,17 @@ public:
   // core dump. Do NOT take ownership of the buffer, only borrow it for the
   // duration of the call.
   static already_AddRefed<HeapSnapshot> Create(JSContext* cx,
                                                dom::GlobalObject& global,
                                                const uint8_t* buffer,
                                                uint32_t size,
                                                ErrorResult& rv);
 
-  // Creates the `$TEMP_DIR/XXXXXX-XXX.fxsnapshot.gz` core dump file that heap
+  // Creates the `$TEMP_DIR/XXXXXX-XXX.fxsnapshot` core dump file that heap
   // snapshots are serialized into.
   static already_AddRefed<nsIFile> CreateUniqueCoreDumpFile(ErrorResult& rv,
                                                             const TimeStamp& now,
                                                             nsAString& outFilePath,
                                                             nsAString& outSnapshotId);
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(HeapSnapshot)
--- a/devtools/shared/heapsnapshot/HeapSnapshotFileUtils.js
+++ b/devtools/shared/heapsnapshot/HeapSnapshotFileUtils.js
@@ -10,30 +10,30 @@
 // attempting to open heap snapshot files and not `~/.ssh/id_rsa`, for
 // example. Therefore, the RDP only talks about snapshot ids, or transfering the
 // bulk file data. A file path can be recovered from a snapshot id, which allows
 // one to check for the presence of the heap snapshot file on the local file
 // system, but we don't have to worry about opening arbitrary files.
 //
 // The heap snapshot file path conventions permits the following forms:
 //
-//     $TEMP_DIRECTORY/XXXXXXXXXX.fxsnapshot.gz
-//     $TEMP_DIRECTORY/XXXXXXXXXX-XXXXX.fxsnapshot.gz
+//     $TEMP_DIRECTORY/XXXXXXXXXX.fxsnapshot
+//     $TEMP_DIRECTORY/XXXXXXXXXX-XXXXX.fxsnapshot
 //
 // Where the strings of "X" are zero or more digits.
 
 "use strict";
 
 const { Ci } = require("chrome");
 loader.lazyRequireGetter(this, "FileUtils",
                          "resource://gre/modules/FileUtils.jsm", true);
 loader.lazyRequireGetter(this, "OS", "resource://gre/modules/osfile.jsm", true);
 
 function getHeapSnapshotFileTemplate() {
-  return OS.Path.join(OS.Constants.Path.tmpDir, `${Date.now()}.fxsnapshot.gz`);
+  return OS.Path.join(OS.Constants.Path.tmpDir, `${Date.now()}.fxsnapshot`);
 }
 
 /**
  * Get a unique temp file path for a new heap snapshot. The file is guaranteed
  * not to exist before this call.
  *
  * @returns String
  */
@@ -58,17 +58,17 @@ function isValidSnapshotFileId(snapshotI
  * @returns String | null
  */
 exports.getHeapSnapshotTempFilePath = function(snapshotId) {
   // Don't want anyone sneaking "../../../.." strings into the snapshot id and
   // trying to make us open arbitrary files.
   if (!isValidSnapshotFileId(snapshotId)) {
     return null;
   }
-  return OS.Path.join(OS.Constants.Path.tmpDir, snapshotId + ".fxsnapshot.gz");
+  return OS.Path.join(OS.Constants.Path.tmpDir, snapshotId + ".fxsnapshot");
 };
 
 /**
  * Return true if we have the heap snapshot file for the given snapshot id on
  * the local file system. False is returned otherwise.
  *
  * @returns Promise<Boolean>
  */
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -1750,17 +1750,16 @@ nsContentUtils::IsHTMLBlock(nsIContent* 
                                        nsGkAtoms::h5,
                                        nsGkAtoms::h6,
                                        nsGkAtoms::header,
                                        nsGkAtoms::hgroup,
                                        nsGkAtoms::hr,
                                        nsGkAtoms::li,
                                        nsGkAtoms::listing,
                                        nsGkAtoms::menu,
-                                       nsGkAtoms::multicol, // XXX get rid of this one?
                                        nsGkAtoms::nav,
                                        nsGkAtoms::ol,
                                        nsGkAtoms::p,
                                        nsGkAtoms::pre,
                                        nsGkAtoms::section,
                                        nsGkAtoms::table,
                                        nsGkAtoms::ul,
                                        nsGkAtoms::xmp);
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -2132,16 +2132,21 @@ nsDocument::Init()
   // via some events.
   nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(xpc::PrivilegedJunkScope());
   NS_ENSURE_TRUE(global, NS_ERROR_FAILURE);
   mScopeObject = do_GetWeakReference(global);
   MOZ_ASSERT(mScopeObject);
 
   mScriptLoader = new dom::ScriptLoader(this);
 
+  // we need to create a policy here so getting the policy within
+  // ::Policy() can *always* return a non null policy
+  mFeaturePolicy = new FeaturePolicy(this);
+  mFeaturePolicy->SetDefaultOrigin(NodePrincipal());
+
   mozilla::HoldJSObjects(this);
 
   return NS_OK;
 }
 
 void
 nsIDocument::DeleteAllProperties()
 {
@@ -3007,21 +3012,19 @@ nsIDocument::InitCSP(nsIChannel* aChanne
   }
   ApplySettingsFromCSP(false);
   return NS_OK;
 }
 
 nsresult
 nsIDocument::InitFeaturePolicy(nsIChannel* aChannel)
 {
-  MOZ_ASSERT(!mFeaturePolicy, "we should only call init once");
-
-  // we need to create a policy here so getting the policy within
-  // ::Policy() can *always* return a non null policy
-  mFeaturePolicy = new FeaturePolicy(this);
+  MOZ_ASSERT(mFeaturePolicy, "we should only call init once");
+
+  mFeaturePolicy->ResetDeclaredPolicy();
 
   if (!StaticPrefs::dom_security_featurePolicy_enabled()) {
     return NS_OK;
   }
 
   mFeaturePolicy->SetDefaultOrigin(NodePrincipal());
 
   RefPtr<FeaturePolicy> parentPolicy = nullptr;
--- a/dom/chrome-webidl/ChromeUtils.webidl
+++ b/dom/chrome-webidl/ChromeUtils.webidl
@@ -31,27 +31,27 @@ namespace ChromeUtils {
    * Serialize a snapshot of the heap graph, as seen by |JS::ubi::Node| and
    * restricted by |boundaries|, and write it to the provided file path.
    *
    * @param boundaries        The portion of the heap graph to write.
    *
    * @returns                 The path to the file the heap snapshot was written
    *                          to. This is guaranteed to be within the temp
    *                          directory and its file name will match the regexp
-   *                          `\d+(\-\d+)?\.fxsnapshot.gz`.
+   *                          `\d+(\-\d+)?\.fxsnapshot`.
    */
   [Throws]
   DOMString saveHeapSnapshot(optional HeapSnapshotBoundaries boundaries);
 
   /**
    * This is the same as saveHeapSnapshot, but with a different return value.
    *
    * @returns                 The snapshot ID of the file. This is the file name
    *                          without the temp directory or the trailing
-   *                          `.fxsnapshot.gz`.
+   *                          `.fxsnapshot`.
    */
   [Throws]
   DOMString saveHeapSnapshotGetId(optional HeapSnapshotBoundaries boundaries);
 
   /**
    * Deserialize a core dump into a HeapSnapshot.
    *
    * @param filePath          The file path to read the heap snapshot from.
--- a/dom/media/ReaderProxy.cpp
+++ b/dom/media/ReaderProxy.cpp
@@ -57,19 +57,18 @@ RefPtr<ReaderProxy::AudioDataPromise>
 ReaderProxy::OnAudioDataRequestCompleted(RefPtr<AudioData> aAudio)
 {
   MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
 
   // Subtract the start time and add the looping-offset time.
   int64_t offset =
     StartTime().ToMicroseconds() - mLoopingOffset.ToMicroseconds();
   aAudio->AdjustForStartTime(offset);
-  if (aAudio->mTime.IsValid() && aAudio->GetEndTime().IsValid() &&
-      CorrectTimeOfAudioDataIfNeeded(aAudio)) {
-    UpdateLastAudioEndTime(aAudio);
+  if (aAudio->mTime.IsValid()) {
+    mLastAudioEndTime = aAudio->mTime;
     return AudioDataPromise::CreateAndResolve(aAudio.forget(), __func__);
   }
   return AudioDataPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_OVERFLOW_ERR,
                                            __func__);
 }
 
 RefPtr<ReaderProxy::AudioDataPromise>
 ReaderProxy::OnAudioDataRequestFailed(const MediaResult& aError)
@@ -110,38 +109,16 @@ ReaderProxy::OnAudioDataRequestFailed(co
            [self](RefPtr<AudioData> aAudio) {
              return self->OnAudioDataRequestCompleted(aAudio.forget());
            },
            [](const MediaResult& aError) {
              return AudioDataPromise::CreateAndReject(aError, __func__);
            });
 }
 
-bool
-ReaderProxy::CorrectTimeOfAudioDataIfNeeded(const RefPtr<AudioData>& aAudio)
-{
-  MOZ_ASSERT(aAudio->mTime.IsValid() && mLastAudioEndTime.IsValid());
-  // The start time of the current audio data should be greater than the end
-  // time of the previous audio data.
-  if (aAudio->mTime < mLastAudioEndTime) {
-    aAudio->mTime = mLastAudioEndTime;
-  }
-  return aAudio->GetEndTime().IsValid();
-}
-
-void
-ReaderProxy::UpdateLastAudioEndTime(const AudioData* aAudio)
-{
-  MOZ_ASSERT(aAudio);
-  MOZ_ASSERT(aAudio->GetEndTime().IsValid() && mLastAudioEndTime.IsValid());
-  // Make sure the end time of the audio data are non-decreasing.
-  MOZ_ASSERT(aAudio->GetEndTime() >= mLastAudioEndTime);
-  mLastAudioEndTime = aAudio->GetEndTime();
-}
-
 RefPtr<ReaderProxy::AudioDataPromise>
 ReaderProxy::RequestAudioData()
 {
   MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
   MOZ_ASSERT(!mShutdown);
 
   mSeamlessLoopingBlocked = false;
   return InvokeAsync(mReader->OwnerThread(),
--- a/dom/media/ReaderProxy.h
+++ b/dom/media/ReaderProxy.h
@@ -95,22 +95,16 @@ private:
   void UpdateDuration();
   RefPtr<SeekPromise> SeekInternal(const SeekTarget& aTarget);
 
   RefPtr<ReaderProxy::AudioDataPromise> OnAudioDataRequestCompleted(
     RefPtr<AudioData> aAudio);
   RefPtr<ReaderProxy::AudioDataPromise> OnAudioDataRequestFailed(
     const MediaResult& aError);
 
-  // Make sure the timestamp of the audio data increase monotonically by
-  // adjusting it according to mLastAudioEndTime. Returns true if the
-  // endtime is valid after correction and false otherwise.
-  bool CorrectTimeOfAudioDataIfNeeded(const RefPtr<AudioData>& aAudio);
-  void UpdateLastAudioEndTime(const AudioData* aAudio);
-
   const RefPtr<AbstractThread> mOwnerThread;
   const RefPtr<MediaFormatReader> mReader;
 
   bool mShutdown = false;
   Maybe<media::TimeUnit> mStartTime;
 
   // State-watching manager.
   WatchManager<ReaderProxy> mWatchManager;
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -640,17 +640,17 @@ CompositorBridgeParent::RecvFlushRenderi
 
   return RecvFlushRendering();
 }
 
 mozilla::ipc::IPCResult
 CompositorBridgeParent::RecvForcePresent()
 {
   if (mWrBridge) {
-    mWrBridge->ScheduleGenerateFrame();
+    mWrBridge->ScheduleForcedGenerateFrame();
   }
   // During the shutdown sequence mLayerManager may be null
   if (mLayerManager) {
     mLayerManager->ForcePresent();
   }
   return IPC_OK();
 }
 
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -1385,27 +1385,32 @@ WebRenderBridgeParent::UpdateWebRender(C
   mAsyncImageManager->AddPipeline(mPipelineId);
 
   return GetNextWrEpoch(); // Update webrender epoch
 }
 
 mozilla::ipc::IPCResult
 WebRenderBridgeParent::RecvScheduleComposite()
 {
+  ScheduleGenerateFrame();
+  return IPC_OK();
+}
+
+void
+WebRenderBridgeParent::ScheduleForcedGenerateFrame()
+{
   if (mDestroyed) {
-    return IPC_OK();
+    return;
   }
 
-  // Force frame rendering during next frame generation.
   wr::TransactionBuilder fastTxn(/* aUseSceneBuilderThread */ false);
   fastTxn.InvalidateRenderedFrame();
   mApi->SendTransaction(fastTxn);
 
   ScheduleGenerateFrame();
-  return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 WebRenderBridgeParent::RecvCapture()
 {
   if (!mDestroyed) {
     mApi->Capture();
   }
--- a/gfx/layers/wr/WebRenderBridgeParent.h
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -181,16 +181,24 @@ public:
    * to generate frame. If we need to generate new frame at next composite timing,
    * call this method.
    *
    * Call CompositorVsyncScheduler::ScheduleComposition() directly, if we just
    * want to trigger AsyncImagePipelines update checks.
    */
   void ScheduleGenerateFrame();
 
+  /**
+   * Schedule forced frame rendering at next composite timing.
+   *
+   * WebRender could skip frame rendering if there is no update.
+   * This function is used to force rendering even when there is not update.
+   */
+  void ScheduleForcedGenerateFrame();
+
   wr::Epoch UpdateWebRender(CompositorVsyncScheduler* aScheduler,
                             wr::WebRenderAPI* aApi,
                             AsyncImagePipelineManager* aImageMgr,
                             CompositorAnimationStorage* aAnimStorage,
                             const TextureFactoryIdentifier& aTextureFactoryIdentifier);
 
   void RemoveEpochDataPriorTo(const wr::Epoch& aRenderedEpoch);
 
--- a/js/src/frontend/BinSource-auto.cpp
+++ b/js/src/frontend/BinSource-auto.cpp
@@ -68,27 +68,23 @@ BinASTParser<Tok>::parseAssertedMaybePos
 template<typename Tok> JS::Result<Ok>
 BinASTParser<Tok>::parseSumAssertedMaybePositionalParameterName(const size_t start, const BinKind kind, const BinFields& fields,
         AssertedScopeKind scopeKind,
         MutableHandle<GCVector<JSAtom*>> positionalParams)
 {
     Ok result;
     switch (kind) {
       case BinKind::AssertedParameterName:
-        MOZ_TRY_VAR(result, parseInterfaceAssertedParameterName(start, kind, fields,
-            scopeKind, positionalParams));
-        break;
+        return raiseError("FIXME: Not implemented yet in this preview release (AssertedParameterName)");
       case BinKind::AssertedPositionalParameterName:
         MOZ_TRY_VAR(result, parseInterfaceAssertedPositionalParameterName(start, kind, fields,
             scopeKind, positionalParams));
         break;
       case BinKind::AssertedRestParameterName:
-        MOZ_TRY_VAR(result, parseInterfaceAssertedRestParameterName(start, kind, fields,
-            scopeKind, positionalParams));
-        break;
+        return raiseError("FIXME: Not implemented yet in this preview release (AssertedRestParameterName)");
       default:
         return raiseInvalidKind("AssertedMaybePositionalParameterName", kind);
     }
     return result;
 }
 
 /*
 AssignmentTarget ::= ArrayAssignmentTarget
@@ -1930,23 +1926,23 @@ BinASTParser<Tok>::parseSumVariableDecla
 
 
 
 // ----- Interfaces (autogenerated, by lexicographical order)
 // When fields have a non-trivial type, implementation is deanonymized and delegated to another parser.
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceArrayAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ArrayAssignmentTarget)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ArrayAssignmentTarget)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceArrayBinding(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ArrayBinding)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ArrayBinding)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceArrayExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ArrayExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -1989,17 +1985,17 @@ BinASTParser<Tok>::parseArrowExpressionC
     MOZ_TRY(guard.done());
 
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceArrowExpressionContentsWithExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ArrowExpressionContentsWithExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ArrowExpressionContentsWithExpression)");
 }
 
 
 /*
  interface ArrowExpressionContentsWithFunctionBody : Node {
     AssertedParameterScope parameterScope;
     FormalParameters params;
     AssertedVarScope bodyScope;
@@ -2022,17 +2018,17 @@ BinASTParser<Tok>::parseArrowExpressionC
     MOZ_TRY(guard.done());
 
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceArrowExpressionContentsWithFunctionBody(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ArrowExpressionContentsWithFunctionBody)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ArrowExpressionContentsWithFunctionBody)");
 }
 
 
 /*
  interface AssertedBlockScope : Node {
     FrozenArray<AssertedDeclaredName> declaredNames;
     bool hasDirectEval;
  }
@@ -2238,39 +2234,20 @@ BinASTParser<Tok>::parseInterfaceAsserte
     ParseContext::Scope* scope;
     DeclarationKind declKind;
     MOZ_TRY(getDeclaredScope(scopeKind, kind_, scope, declKind));
     MOZ_TRY(addScopeName(scopeKind, name, scope, declKind, isCaptured));
     auto result = Ok();
     return result;
 }
 
-template<typename Tok> JS::Result<Ok>
-BinASTParser<Tok>::parseInterfaceAssertedParameterName(const size_t start, const BinKind kind, const BinFields& fields,
-        AssertedScopeKind scopeKind,
-        MutableHandle<GCVector<JSAtom*>> positionalParams)
-{
-    MOZ_ASSERT(kind == BinKind::AssertedParameterName);
-    BINJS_TRY(CheckRecursionLimit(cx_));
-
-#if defined(DEBUG)
-    const BinField expected_fields[2] = { BinField::Name, BinField::IsCaptured };
-    MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
-#endif // defined(DEBUG)
-
-    RootedAtom name(cx_);
-    MOZ_TRY_VAR(name, tokenizer_->readIdentifierName());
-
-    BINJS_MOZ_TRY_DECL(isCaptured, tokenizer_->readBool());
-    ParseContext::Scope* scope;
-    DeclarationKind declKind;
-    MOZ_TRY(getBoundScope(scopeKind, scope, declKind));
-    MOZ_TRY(addScopeName(scopeKind, name, scope, declKind, isCaptured));
-    auto result = Ok();
-    return result;
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceAssertedParameterName(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    return raiseError("FIXME: Not implemented yet in this preview release (AssertedParameterName)");
 }
 
 
 /*
  interface AssertedParameterScope : Node {
     FrozenArray<AssertedMaybePositionalParameterName> paramNames;
     bool hasDirectEval;
     bool isSimpleParameterList;
@@ -2340,58 +2317,50 @@ BinASTParser<Tok>::parseInterfaceAsserte
     const BinField expected_fields[3] = { BinField::Index, BinField::Name, BinField::IsCaptured };
     MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
 #endif // defined(DEBUG)
 
     BINJS_MOZ_TRY_DECL(index, tokenizer_->readUnsignedLong());
 
     RootedAtom name(cx_);
     MOZ_TRY_VAR(name, tokenizer_->readIdentifierName());
-    // FIXME: The following checks should be performed inside
-    // checkPositionalParameterIndices to match the spec's order
-    // (bug 1490976).
-    if (index >= positionalParams.get().length()) {
-        return raiseError("AssertedPositionalParameterName.length out of range");
+    // `positionalParams` vector can be shorter than the actual
+    // parameter length. Resize on demand.
+    // (see also ListOfAssertedMaybePositionalParameterName)
+    size_t prevLength = positionalParams.get().length();
+    if (index >= prevLength) {
+        // This is implementation limit, which is not in the spec.
+        size_t newLength = index + 1;
+        if (newLength >= ARGNO_LIMIT) {
+            return raiseError("AssertedPositionalParameterName.index is too big");
+        }
+
+        BINJS_TRY(positionalParams.get().resize(newLength));
+        for (uint32_t i = prevLength; i < newLength; i++) {
+            positionalParams.get()[i] = nullptr;
+        }
     }
+
     if (positionalParams.get()[index]) {
         return raiseError("AssertedPositionalParameterName has duplicate entry for the same index");
     }
     positionalParams.get()[index] = name;
     BINJS_MOZ_TRY_DECL(isCaptured, tokenizer_->readBool());
     ParseContext::Scope* scope;
     DeclarationKind declKind;
     MOZ_TRY(getBoundScope(scopeKind, scope, declKind));
     MOZ_TRY(addScopeName(scopeKind, name, scope, declKind, isCaptured));
     auto result = Ok();
     return result;
 }
 
-template<typename Tok> JS::Result<Ok>
-BinASTParser<Tok>::parseInterfaceAssertedRestParameterName(const size_t start, const BinKind kind, const BinFields& fields,
-        AssertedScopeKind scopeKind,
-        MutableHandle<GCVector<JSAtom*>> positionalParams)
-{
-    MOZ_ASSERT(kind == BinKind::AssertedRestParameterName);
-    BINJS_TRY(CheckRecursionLimit(cx_));
-
-#if defined(DEBUG)
-    const BinField expected_fields[2] = { BinField::Name, BinField::IsCaptured };
-    MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
-#endif // defined(DEBUG)
-
-    RootedAtom name(cx_);
-    MOZ_TRY_VAR(name, tokenizer_->readIdentifierName());
-
-    BINJS_MOZ_TRY_DECL(isCaptured, tokenizer_->readBool());
-    ParseContext::Scope* scope;
-    DeclarationKind declKind;
-    MOZ_TRY(getBoundScope(scopeKind, scope, declKind));
-    MOZ_TRY(addScopeName(scopeKind, name, scope, declKind, isCaptured));
-    auto result = Ok();
-    return result;
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceAssertedRestParameterName(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    return raiseError("FIXME: Not implemented yet in this preview release (AssertedRestParameterName)");
 }
 
 
 /*
  interface AssertedScriptGlobalScope : Node {
     FrozenArray<AssertedDeclaredName> declaredNames;
     bool hasDirectEval;
  }
@@ -2560,35 +2529,35 @@ BinASTParser<Tok>::parseInterfaceAssignm
     BINJS_TRY(usedNames_.noteUse(cx_, name, parseContext_->scriptId(), parseContext_->innermostScope()->id()));
     BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceAssignmentTargetPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (AssignmentTargetPropertyIdentifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (AssignmentTargetPropertyIdentifier)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceAssignmentTargetPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (AssignmentTargetPropertyProperty)");
+    return raiseError("FIXME: Not implemented yet in this preview release (AssignmentTargetPropertyProperty)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (AssignmentTargetWithInitializer)");
+    return raiseError("FIXME: Not implemented yet in this preview release (AssignmentTargetWithInitializer)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceAwaitExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (AwaitExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (AwaitExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceBinaryExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::BinaryExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -2742,29 +2711,29 @@ BinASTParser<Tok>::parseInterfaceBinding
     }
     BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceBindingPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (BindingPropertyIdentifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (BindingPropertyIdentifier)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceBindingPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (BindingPropertyProperty)");
+    return raiseError("FIXME: Not implemented yet in this preview release (BindingPropertyProperty)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (BindingWithInitializer)");
+    return raiseError("FIXME: Not implemented yet in this preview release (BindingWithInitializer)");
 }
 
 
 /*
  interface Block : Node {
     AssertedBlockScope scope;
     FrozenArray<Statement> statements;
  }
@@ -2941,17 +2910,17 @@ BinASTParser<Tok>::parseInterfaceCatchCl
     BINJS_TRY_DECL(result, factory_.newLexicalScope(*bindings, body));
     BINJS_TRY(factory_.setupCatchScope(result, binding, body));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceClassDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ClassDeclaration)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ClassDeclaration)");
 }
 
 
 /*
  interface ClassElement : Node {
     bool isStatic;
     MethodDefinition method;
  }
@@ -2972,23 +2941,23 @@ BinASTParser<Tok>::parseClassElement()
     MOZ_TRY(guard.done());
 
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceClassElement(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ClassElement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ClassElement)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceClassExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ClassExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ClassExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceCompoundAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::CompoundAssignmentExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -3082,17 +3051,17 @@ BinASTParser<Tok>::parseInterfaceCompute
 
     BINJS_TRY_DECL(result, factory_.newPropertyByValue(object, expression, tokenizer_->offset()));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceComputedPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ComputedPropertyName)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ComputedPropertyName)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceConditionalExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ConditionalExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -3165,17 +3134,17 @@ BinASTParser<Tok>::parseInterfaceDataPro
 
     BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceDebuggerStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (DebuggerStatement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (DebuggerStatement)");
 }
 
 
 /*
  interface Directive : Node {
     string rawValue;
  }
 */
@@ -3234,23 +3203,23 @@ BinASTParser<Tok>::parseInterfaceDoWhile
 
     BINJS_TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start)));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceEagerArrowExpressionWithExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (EagerArrowExpressionWithExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (EagerArrowExpressionWithExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceEagerArrowExpressionWithFunctionBody(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (EagerArrowExpressionWithFunctionBody)");
+    return raiseError("FIXME: Not implemented yet in this preview release (EagerArrowExpressionWithFunctionBody)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceEagerFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::EagerFunctionDeclaration);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -3512,35 +3481,35 @@ MOZ_TRY(tokenizer_->checkFields0(kind, f
 
     BINJS_TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start)));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExport(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (Export)");
+    return raiseError("FIXME: Not implemented yet in this preview release (Export)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExportAllFrom(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ExportAllFrom)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ExportAllFrom)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExportDefault(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ExportDefault)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ExportDefault)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExportFrom(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ExportFrom)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ExportFrom)");
 }
 
 
 /*
  interface ExportFromSpecifier : Node {
     [IdentifierName] string name;
     [IdentifierName] string? exportedName;
  }
@@ -3561,17 +3530,17 @@ BinASTParser<Tok>::parseExportFromSpecif
     MOZ_TRY(guard.done());
 
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExportFromSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ExportFromSpecifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ExportFromSpecifier)");
 }
 
 
 /*
  interface ExportLocalSpecifier : Node {
     IdentifierExpression name;
     [PropertyKey] string? exportedName;
  }
@@ -3592,23 +3561,23 @@ BinASTParser<Tok>::parseExportLocalSpeci
     MOZ_TRY(guard.done());
 
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExportLocalSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ExportLocalSpecifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ExportLocalSpecifier)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExportLocals(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ExportLocals)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ExportLocals)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceExpressionStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ExpressionStatement);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -3684,17 +3653,17 @@ BinASTParser<Tok>::parseInterfaceForInSt
         BINJS_TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
     }
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceForOfStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ForOfStatement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ForOfStatement)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceForStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ForStatement);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -3766,18 +3735,17 @@ BinASTParser<Tok>::parseInterfaceFormalP
 #endif // defined(DEBUG)
 
     BINJS_MOZ_TRY_DECL(items, parseListOfParameter());
 
     BINJS_MOZ_TRY_DECL(rest, parseOptionalBinding());
 
     auto result = items;
     if (rest) {
-        BINJS_TRY_DECL(spread, factory_.newSpread(start, rest));
-        factory_.addList(result, spread);
+        return raiseError("Rest parameter is not supported in this preview release");
     }
     return result;
 }
 
 
 /*
  interface FunctionExpressionContents : Node {
     bool isFunctionNameCaptured;
@@ -4042,23 +4010,23 @@ BinASTParser<Tok>::parseInterfaceIfState
 
     BINJS_TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceImport(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (Import)");
+    return raiseError("FIXME: Not implemented yet in this preview release (Import)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceImportNamespace(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ImportNamespace)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ImportNamespace)");
 }
 
 
 /*
  interface ImportSpecifier : Node {
     [PropertyKey] string? name;
     BindingIdentifier binding;
  }
@@ -4079,17 +4047,17 @@ BinASTParser<Tok>::parseImportSpecifier(
     MOZ_TRY(guard.done());
 
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceImportSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ImportSpecifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ImportSpecifier)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLabelledStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::LabelledStatement);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -4108,23 +4076,23 @@ BinASTParser<Tok>::parseInterfaceLabelle
 
     BINJS_TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLazyArrowExpressionWithExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (LazyArrowExpressionWithExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (LazyArrowExpressionWithExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLazyArrowExpressionWithFunctionBody(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (LazyArrowExpressionWithFunctionBody)");
+    return raiseError("FIXME: Not implemented yet in this preview release (LazyArrowExpressionWithFunctionBody)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLazyFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::LazyFunctionDeclaration);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -4228,29 +4196,29 @@ BinASTParser<Tok>::parseInterfaceLazyFun
 
     BINJS_MOZ_TRY_DECL(result, makeEmptyFunctionNode(skipStart, kind, funbox));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLazyGetter(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (LazyGetter)");
+    return raiseError("FIXME: Not implemented yet in this preview release (LazyGetter)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLazyMethod(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (LazyMethod)");
+    return raiseError("FIXME: Not implemented yet in this preview release (LazyMethod)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLazySetter(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (LazySetter)");
+    return raiseError("FIXME: Not implemented yet in this preview release (LazySetter)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLiteralBooleanExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::LiteralBooleanExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -4263,17 +4231,17 @@ BinASTParser<Tok>::parseInterfaceLiteral
 
     BINJS_TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start)));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLiteralInfinityExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (LiteralInfinityExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (LiteralInfinityExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceLiteralNullExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::LiteralNullExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 MOZ_TRY(tokenizer_->checkFields0(kind, fields));
@@ -4384,17 +4352,17 @@ BinASTParser<Tok>::parseInterfaceLiteral
 
     BINJS_TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start)));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceModule(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (Module)");
+    return raiseError("FIXME: Not implemented yet in this preview release (Module)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceNewExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::NewExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -4409,29 +4377,29 @@ BinASTParser<Tok>::parseInterfaceNewExpr
 
     BINJS_TRY_DECL(result, factory_.newNewExpression(tokenizer_->pos(start).begin, callee, arguments));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceNewTargetExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (NewTargetExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (NewTargetExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceObjectAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ObjectAssignmentTarget)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ObjectAssignmentTarget)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceObjectBinding(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (ObjectBinding)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ObjectBinding)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceObjectExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ObjectExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -4576,17 +4544,17 @@ BinASTParser<Tok>::parseInterfaceShortha
 
     BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceSpreadElement(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (SpreadElement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (SpreadElement)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceStaticMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::StaticMemberAssignmentTarget);
     BINJS_TRY(CheckRecursionLimit(cx_));
 
@@ -4632,17 +4600,17 @@ BinASTParser<Tok>::parseInterfaceStaticM
     BINJS_TRY_DECL(name, factory_.newPropertyName(property->asPropertyName(), tokenizer_->pos(nameStart)));
     BINJS_TRY_DECL(result, factory_.newPropertyAccess(object, name));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceSuper(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (Super)");
+    return raiseError("FIXME: Not implemented yet in this preview release (Super)");
 }
 
 
 /*
  interface SwitchCase : Node {
     Expression test;
     FrozenArray<Statement> consequent;
  }
@@ -4776,23 +4744,23 @@ BinASTParser<Tok>::parseInterfaceSwitchS
     BINJS_TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases));
     BINJS_TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope, true));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceTemplateElement(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (TemplateElement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (TemplateElement)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceTemplateExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (TemplateExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (TemplateExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceThisExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ThisExpression);
     BINJS_TRY(CheckRecursionLimit(cx_));
 MOZ_TRY(tokenizer_->checkFields0(kind, fields));
@@ -5120,23 +5088,23 @@ BinASTParser<Tok>::parseInterfaceWithSta
 
     BINJS_TRY_DECL(result, factory_.newWithStatement(start, object, body));
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceYieldExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (YieldExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (YieldExpression)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseInterfaceYieldStarExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
-    return raiseError("FIXME: Not implemented yet (YieldStarExpression)");
+    return raiseError("FIXME: Not implemented yet in this preview release (YieldStarExpression)");
 }
 
 
 
 // ----- String enums (autogenerated, by lexicographical order)
 /*
 enum AssertedDeclaredKind {
     "var",
@@ -5476,56 +5444,57 @@ BinASTParser<Tok>::parseListOfAssertedMa
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
     MOZ_TRY(tokenizer_->enterList(length, guard));
     (void) start;
     auto result = Ok();
-    if (length >= ARGNO_LIMIT) {
-        return raiseError("Too many function parameters");
-    }
-    BINJS_TRY(positionalParams.get().resize(length));
-    for (uint32_t i = 0; i < length; i++) {
-        positionalParams.get()[i] = nullptr;
-    }
+    // This list contains also destructuring parameters, and the number of
+    // list items can be greater than the actual parameters, or more than
+    // ARGNO_LIMIT even if the number of parameters fits into ARGNO_LIMIT.
+    // Also, the number of parameters can be greater than this list's length
+    // if one of destructuring parameter is empty.
+    //
+    // We resize `positionalParams` vector on demand, to keep the vector
+    // length match to the known maximum positional parameter index + 1.
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY(parseAssertedMaybePositionalParameterName(
             scopeKind, positionalParams));
         // Nothing to do here.
     }
 
     MOZ_TRY(guard.done());
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfAssignmentTargetOrAssignmentTargetWithInitializer()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfAssignmentTargetOrAssignmentTargetWithInitializer)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfAssignmentTargetOrAssignmentTargetWithInitializer)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfAssignmentTargetProperty()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfAssignmentTargetProperty)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfAssignmentTargetProperty)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfBindingProperty()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfBindingProperty)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfBindingProperty)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfClassElement()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfClassElement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfClassElement)");
 }
 
 template<typename Tok> JS::Result<ListNode*>
 BinASTParser<Tok>::parseListOfDirective()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
@@ -5540,41 +5509,41 @@ BinASTParser<Tok>::parseListOfDirective(
 
     MOZ_TRY(guard.done());
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfExportFromSpecifier()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfExportFromSpecifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfExportFromSpecifier)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfExportLocalSpecifier()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfExportLocalSpecifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfExportLocalSpecifier)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfExpressionOrTemplateElement()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfExpressionOrTemplateElement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfExpressionOrTemplateElement)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfImportDeclarationOrExportDeclarationOrStatement()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfImportDeclarationOrExportDeclarationOrStatement)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfImportDeclarationOrExportDeclarationOrStatement)");
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfImportSpecifier()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfImportSpecifier)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfImportSpecifier)");
 }
 
 template<typename Tok> JS::Result<ListNode*>
 BinASTParser<Tok>::parseListOfObjectProperty()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
@@ -5591,17 +5560,17 @@ BinASTParser<Tok>::parseListOfObjectProp
 
     MOZ_TRY(guard.done());
     return result;
 }
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseListOfOptionalBindingOrBindingWithInitializer()
 {
-    return raiseError("FIXME: Not implemented yet (ListOfOptionalBindingOrBindingWithInitializer)");
+    return raiseError("FIXME: Not implemented yet in this preview release (ListOfOptionalBindingOrBindingWithInitializer)");
 }
 
 template<typename Tok> JS::Result<ListNode*>
 BinASTParser<Tok>::parseListOfOptionalSpreadElementOrExpression()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
--- a/js/src/frontend/BinSource-auto.h
+++ b/js/src/frontend/BinSource-auto.h
@@ -191,27 +191,23 @@ JS::Result<ParseNode*> parseInterfaceArr
 JS::Result<ParseNode*> parseInterfaceArrowExpressionContentsWithExpression(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<ParseNode*> parseInterfaceArrowExpressionContentsWithFunctionBody(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<Ok> parseInterfaceAssertedBlockScope(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<Ok> parseInterfaceAssertedBoundName(const size_t start, const BinKind kind, const BinFields& fields,
     AssertedScopeKind scopeKind);
 JS::Result<Ok> parseInterfaceAssertedBoundNamesScope(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<Ok> parseInterfaceAssertedDeclaredName(const size_t start, const BinKind kind, const BinFields& fields,
     AssertedScopeKind scopeKind);
-JS::Result<Ok> parseInterfaceAssertedParameterName(const size_t start, const BinKind kind, const BinFields& fields,
-    AssertedScopeKind scopeKind,
-    MutableHandle<GCVector<JSAtom*>> positionalParams);
+JS::Result<ParseNode*> parseInterfaceAssertedParameterName(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<Ok> parseInterfaceAssertedParameterScope(const size_t start, const BinKind kind, const BinFields& fields,
     MutableHandle<GCVector<JSAtom*>> positionalParams);
 JS::Result<Ok> parseInterfaceAssertedPositionalParameterName(const size_t start, const BinKind kind, const BinFields& fields,
     AssertedScopeKind scopeKind,
     MutableHandle<GCVector<JSAtom*>> positionalParams);
-JS::Result<Ok> parseInterfaceAssertedRestParameterName(const size_t start, const BinKind kind, const BinFields& fields,
-    AssertedScopeKind scopeKind,
-    MutableHandle<GCVector<JSAtom*>> positionalParams);
+JS::Result<ParseNode*> parseInterfaceAssertedRestParameterName(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<Ok> parseInterfaceAssertedScriptGlobalScope(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<Ok> parseInterfaceAssertedVarScope(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<ParseNode*> parseInterfaceAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<ParseNode*> parseInterfaceAssignmentTargetIdentifier(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<ParseNode*> parseInterfaceAssignmentTargetPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<ParseNode*> parseInterfaceAssignmentTargetPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<ParseNode*> parseInterfaceAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields);
 JS::Result<ParseNode*> parseInterfaceAwaitExpression(const size_t start, const BinKind kind, const BinFields& fields);
--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -236,18 +236,27 @@ BinASTParser<Tok>::buildFunctionBox(Gene
 
     RootedAtom atom(cx_);
     if (name) {
         atom = name->name();
     }
 
     if (parseContext_ && syntax == FunctionSyntaxKind::Statement) {
         auto ptr = parseContext_->varScope().lookupDeclaredName(atom);
-        MOZ_ASSERT(ptr);
-        ptr->value()->alterKind(DeclarationKind::BodyLevelFunction);
+        if (!ptr) {
+            return raiseError("FunctionDeclaration without corresponding AssertedDeclaredName.");
+        }
+
+        // FIXME: Should be merged with ParseContext::tryDeclareVarHelper
+        //        (bug 1499044).
+        DeclarationKind declaredKind = ptr->value()->kind();
+        if (DeclarationKindIsVar(declaredKind)) {
+            MOZ_ASSERT(declaredKind != DeclarationKind::VarForAnnexBLexicalFunction);
+            ptr->value()->alterKind(DeclarationKind::BodyLevelFunction);
+        }
     }
 
     // Allocate the function before walking down the tree.
     RootedFunction fun(cx_);
     BINJS_TRY_VAR(fun, !parseContext_
         ? lazyScript_->functionNonDelazifying()
         : AllocNewFunction(cx_, atom, syntax, generatorKind, functionAsyncKind, nullptr));
     MOZ_ASSERT_IF(parseContext_, fun->explicitName() == atom);
@@ -467,62 +476,94 @@ BinASTParser<Tok>::checkBinding(JSAtom* 
 }
 
 // Binary AST (revision 8eab67e0c434929a66ff6abe99ff790bca087dda)
 // 3.1.5 CheckPositionalParameterIndices.
 template<typename Tok> JS::Result<Ok>
 BinASTParser<Tok>::checkPositionalParameterIndices(Handle<GCVector<JSAtom*>> positionalParams,
                                                    ListNode* params)
 {
-#ifdef DEBUG
-    // positionalParams should have the same length as non-rest parameters.
-    size_t paramsCount = params->count();
-    if (paramsCount > 0) {
-        if (params->last()->isKind(ParseNodeKind::Spread)) {
-            paramsCount--;
-        }
-    }
-    MOZ_ASSERT(positionalParams.get().length() == paramsCount);
-#endif
+    // positionalParams should have the corresponding entry up to the last
+    // positional parameter.
+
+    // `positionalParams` corresponds to `expectedParams` parameter in the spec.
+    // `params` corresponds to `parseTree` in 3.1.9 CheckAssertedScope, and
+    // `positionalParamNames` parameter
 
+    // Steps 1-3.
+    // PositionalParameterNames (3.1.9 CheckAssertedScope step 5.d) and
+    // CreatePositionalParameterIndices (3.1.5 CheckPositionalParameterIndices
+    // step 1) are done implicitly.
     uint32_t i = 0;
+    const bool hasRest = parseContext_->functionBox()->hasRest();
     for (ParseNode* param : params->contents()) {
         if (param->isKind(ParseNodeKind::Assign)) {
             param = param->as<AssignmentNode>().left();
         }
-        if (param->isKind(ParseNodeKind::Spread)) {
-            continue;
-        }
 
-        MOZ_ASSERT(param->isKind(ParseNodeKind::Name) ||
-                   param->isKind(ParseNodeKind::Object) ||
-                   param->isKind(ParseNodeKind::Array));
+        // At this point, function body is not part of params list.
+        const bool isRest = hasRest && !param->pn_next;
+        if (isRest) {
+            // Rest parameter
 
-        if (JSAtom* name = positionalParams.get()[i]) {
+            // Step 3.
+            if (i >= positionalParams.get().length()) {
+                continue;
+            }
+
+            if (positionalParams.get()[i]) {
+                return raiseError("Expected positional parameter per AssertedParameterScope.paramNames, got rest parameter");
+            }
+        } else if (param->isKind(ParseNodeKind::Name)) {
             // Simple or default parameter.
-            if (param->isKind(ParseNodeKind::Object) || param->isKind(ParseNodeKind::Array)) {
-                return raiseError("AssertedPositionalParameterName: expected positional parameter, got destructuring parameter");
-            }
-            if (param->isKind(ParseNodeKind::Spread)) {
-                return raiseError("AssertedPositionalParameterName: expected positional parameter, got rest parameter");
+
+            // Step 2.a.
+            if (i >= positionalParams.get().length()) {
+                return raiseError("AssertedParameterScope.paramNames doesn't have corresponding entry to positional parameter");
             }
 
+            JSAtom* name = positionalParams.get()[i];
+            if (!name) {
+                // Step 2.a.ii.1.
+                return raiseError("Expected destructuring/rest parameter per AssertedParameterScope.paramNames, got positional parameter");
+            }
+
+            // Step 2.a.i.
             if (param->name() != name) {
-                return raiseError("AssertedPositionalParameterName: name mismatch");
+                // Step 2.a.ii.1.
+                return raiseError("Name mismatch between AssertedPositionalParameterName in AssertedParameterScope.paramNames and actual parameter");
             }
+
+            // Step 2.a.i.1.
+            // Implicitly done.
         } else {
-            // Destructuring or rest parameter.
-            if (param->isKind(ParseNodeKind::Name)) {
-                return raiseError("AssertedParameterName/AssertedRestParameterName: expected destructuring/rest parameter, got positional parameter");
+            // Destructuring parameter.
+
+            MOZ_ASSERT(param->isKind(ParseNodeKind::Object) ||
+                       param->isKind(ParseNodeKind::Array));
+
+            // Step 3.
+            if (i >= positionalParams.get().length()) {
+                continue;
+            }
+
+            if (positionalParams.get()[i]) {
+                return raiseError("Expected positional parameter per AssertedParameterScope.paramNames, got destructuring parameter");
             }
         }
 
         i++;
     }
 
+    // Step 3.
+    if (positionalParams.get().length() > params->count()) {
+        // `positionalParams` has unchecked entries.
+        return raiseError("AssertedParameterScope.paramNames has unmatching items than the actual parameters");
+    }
+
     return Ok();
 }
 
 // Binary AST (revision 8eab67e0c434929a66ff6abe99ff790bca087dda)
 // 3.1.13 CheckFunctionLength.
 template<typename Tok> JS::Result<Ok>
 BinASTParser<Tok>::checkFunctionLength(uint32_t expectedLength)
 {
--- a/js/src/frontend/BinSource.yaml
+++ b/js/src/frontend/BinSource.yaml
@@ -266,39 +266,49 @@ AssertedDeclaredName:
 
 AssertedMaybePositionalParameterName:
     inherits: AssertedBoundName
     extra-params: |
         AssertedScopeKind scopeKind,
         MutableHandle<GCVector<JSAtom*>> positionalParams
     extra-args: |
         scopeKind, positionalParams
+    sum-arms:
+        AssertedRestParameterName:
+            disabled: true
+        AssertedParameterName:
+            disabled: true
 
 AssertedPositionalParameterName:
     inherits: AssertedMaybePositionalParameterName
     fields:
         name:
             after: |
-                // FIXME: The following checks should be performed inside
-                // checkPositionalParameterIndices to match the spec's order
-                // (bug 1490976).
-                if (index >= positionalParams.get().length()) {
-                    return raiseError("AssertedPositionalParameterName.length out of range");
+                // `positionalParams` vector can be shorter than the actual
+                // parameter length. Resize on demand.
+                // (see also ListOfAssertedMaybePositionalParameterName)
+                size_t prevLength = positionalParams.get().length();
+                if (index >= prevLength) {
+                    // This is implementation limit, which is not in the spec.
+                    size_t newLength = index + 1;
+                    if (newLength >= ARGNO_LIMIT) {
+                        return raiseError("AssertedPositionalParameterName.index is too big");
+                    }
+
+                    BINJS_TRY(positionalParams.get().resize(newLength));
+                    for (uint32_t i = prevLength; i < newLength; i++) {
+                        positionalParams.get()[i] = nullptr;
+                    }
                 }
+
                 if (positionalParams.get()[index]) {
                     return raiseError("AssertedPositionalParameterName has duplicate entry for the same index");
                 }
                 positionalParams.get()[index] = name;
 
-AssertedRestParameterName:
-    inherits: AssertedMaybePositionalParameterName
-
-AssertedParameterName:
-    inherits: AssertedMaybePositionalParameterName
-
 AssertedBoundNamesScope:
     inherits: AssertedBlockScope
     init: |
         const auto scopeKind = AssertedScopeKind::Catch;
     fields:
         boundNames:
             extra-args: scopeKind
 
@@ -834,18 +844,17 @@ ForInStatement:
         }
 
 FormalParameters:
     type-ok:
         ListNode*
     build: |
         auto result = items;
         if (rest) {
-            BINJS_TRY_DECL(spread, factory_.newSpread(start, rest));
-            factory_.addList(result, spread);
+            return raiseError("Rest parameter is not supported in this preview release");
         }
 
 ForStatement:
     init: |
         ParseContext::Statement stmt(parseContext_, StatementKind::ForLoop);
 
         // Implicit scope around the `for`, used to store `for (let x; ...; ...)`
         // or `for (const x; ...; ...)`-style declarations. Detail on the
@@ -904,23 +913,24 @@ ListOfAssertedMaybePositionalParameterNa
     extra-params: |
         AssertedScopeKind scopeKind,
         MutableHandle<GCVector<JSAtom*>> positionalParams
     extra-args: |
         scopeKind, positionalParams
     init: |
         (void) start;
         auto result = Ok();
-        if (length >= ARGNO_LIMIT) {
-            return raiseError("Too many function parameters");
-        }
-        BINJS_TRY(positionalParams.get().resize(length));
-        for (uint32_t i = 0; i < length; i++) {
-            positionalParams.get()[i] = nullptr;
-        }
+        // This list contains also destructuring parameters, and the number of
+        // list items can be greater than the actual parameters, or more than
+        // ARGNO_LIMIT even if the number of parameters fits into ARGNO_LIMIT.
+        // Also, the number of parameters can be greater than this list's length
+        // if one of destructuring parameter is empty.
+        //
+        // We resize `positionalParams` vector on demand, to keep the vector
+        // length match to the known maximum positional parameter index + 1.
 
 ListOfAssertedDeclaredName:
     inherits: ListOfAssertedBoundName
 
 ListOfDirective:
     type-ok:
         ListNode*
     init:
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -1392,17 +1392,17 @@ PerHandlerParser<ParseHandler>::noteDest
         ReportOutOfMemory(context);
         return false;
     }
 
     handler.addFunctionFormalParameter(funNode, destruct);
     return true;
 }
 
-static bool
+bool
 DeclarationKindIsVar(DeclarationKind kind)
 {
     return kind == DeclarationKind::Var ||
            kind == DeclarationKind::BodyLevelFunction ||
            kind == DeclarationKind::VarForAnnexBLexicalFunction ||
            kind == DeclarationKind::ForOfVar;
 }
 
--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -1695,12 +1695,16 @@ mozilla::Maybe<VarScope::Data*>
 NewVarScopeData(JSContext* context, ParseContext::Scope& scope, LifoAlloc& alloc, ParseContext* pc);
 mozilla::Maybe<LexicalScope::Data*>
 NewLexicalScopeData(JSContext* context, ParseContext::Scope& scope, LifoAlloc& alloc, ParseContext* pc);
 
 JSFunction*
 AllocNewFunction(JSContext* cx, HandleAtom atom, FunctionSyntaxKind kind, GeneratorKind generatorKind, FunctionAsyncKind asyncKind,
                  HandleObject proto, bool isSelfHosting = false, bool inFunctionBox = false);
 
+// Returns true if the declaration is `var` or equivalent.
+bool
+DeclarationKindIsVar(DeclarationKind kind);
+
 } /* namespace frontend */
 } /* namespace js */
 
 #endif /* frontend_Parser_h */
--- a/js/src/frontend/binsource/src/main.rs
+++ b/js/src/frontend/binsource/src/main.rs
@@ -53,16 +53,19 @@ struct FieldRules {
 
     /// Extra arguments passed to the method when parsing this field.
     extra_args: Option<Rc<String>>,
 }
 
 #[derive(Clone, Default)]
 struct SumRules {
     after_arm: Option<String>,
+
+    // Disable this arm (false by default).
+    disabled: bool,
 }
 
 
 /// Rules for generating the code for parsing a full node
 /// of a node.
 ///
 /// Extracted from the yaml file.
 #[derive(Clone, Default)]
@@ -350,16 +353,25 @@ impl GlobalRules {
                                 let arm_config_key = arm_config_key.as_str()
                                     .expect("Expected a string as a key");
                                 match arm_config_key
                                 {
                                     "after" => {
                                         update_rule(&mut sum_rule.after_arm, arm_config_entry)
                                             .unwrap_or_else(|()| panic!("Rule {}.sum-arms.{}.{} must be a string", node_key, sum_arm_key, arm_config_key));
                                     }
+                                    "disabled" => {
+                                        if let Some(disabled) = arm_config_entry.as_bool() {
+                                            if disabled {
+                                                sum_rule.disabled = true;
+                                            }
+                                        } else {
+                                            panic!("Rule {}.sum-arms.{}.{} must be a bool", node_key, sum_arm_key, arm_config_key);
+                                        }
+                                    }
                                     _ => {
                                         panic!("Unexpected {}.sum-arms.{}.{}", node_key, sum_arm_key, arm_config_key);
                                     }
                                 }
                             }
                             node_rule.by_sum.insert(sum_arm_name.clone(), sum_rule);
                         }
                     }
@@ -1175,29 +1187,39 @@ impl CPPExporter {
         let inner_prefix = "Sum";
         if !self.refgraph.is_used(Rc::new(format!("{}{}", inner_prefix, name))) {
             return;
         }
 
         // Generate inner method
         let mut buffer_cases = String::new();
         for node in nodes {
+            let rule_for_this_arm = rules_for_this_sum.by_sum.get(&node)
+                .cloned()
+                .unwrap_or_default();
+
+            if rule_for_this_arm.disabled {
+                buffer_cases.push_str(&format!("
+      case BinKind::{variant_name}:
+        return raiseError(\"FIXME: Not implemented yet in this preview release ({variant_name})\");",
+                    variant_name = node.to_cpp_enum_case()));
+                continue;
+            }
+
             buffer_cases.push_str(&format!("
       case BinKind::{variant_name}:
 {call}
 {arm_after}        break;",
                 call = self.get_method_call("result", node,
                                             "Interface", INTERFACE_ARGS,
                                             &extra_args,
                                             MethodCallKind::AlwaysVar)
                     .reindent("        "),
                 variant_name = node.to_cpp_enum_case(),
-                arm_after = rules_for_this_sum.by_sum.get(&node)
-                    .cloned()
-                    .unwrap_or_default().after_arm.reindent("        ")
+                arm_after = rule_for_this_arm.after_arm.reindent("        ")
                     .newline_if_not_empty()));
         }
         buffer.push_str(&format!("\n{first_line}
 {{
     {type_ok} result;
     switch (kind) {{{cases}
       default:
         return raiseInvalidKind(\"{kind}\", kind);
@@ -1243,17 +1265,17 @@ impl CPPExporter {
 
         let init = match rules_for_this_list.init {
             Some(str) => str.reindent("    "),
             None => {
                 // We cannot generate the method if we don't know how to initialize the list.
                 let rendered = format!("
 {first_line}
 {{
-    return raiseError(\"FIXME: Not implemented yet ({kind})\");
+    return raiseError(\"FIXME: Not implemented yet in this preview release ({kind})\");
 }}\n",
                     first_line = first_line,
                     kind = kind,
                 );
                 buffer.push_str(&rendered);
                 return;
             }
         };
@@ -1453,17 +1475,17 @@ impl CPPExporter {
                     }
                     &TypeSpec::String => {
                         let build_result = rules_for_this_node.init.reindent("    ");
                         let first_line = self.get_method_definition_start(&parser.name, "", "",
                                                                           &extra_params);
                         if build_result.len() == 0 {
                             buffer.push_str(&format!("{first_line}
 {{
-    return raiseError(\"FIXME: Not implemented yet ({kind})\");
+    return raiseError(\"FIXME: Not implemented yet in this preview release ({kind})\");
 }}
 
 ",
                                 first_line = first_line,
                                 kind = parser.name.to_str()));
                         } else {
                             buffer.push_str(&format!("{first_line}
 {{
@@ -1482,17 +1504,17 @@ impl CPPExporter {
                     }
                     &TypeSpec::IdentifierName => {
                         let build_result = rules_for_this_node.init.reindent("    ");
                         let first_line = self.get_method_definition_start(&parser.name, "", "",
                                                                           &extra_params);
                         if build_result.len() == 0 {
                             buffer.push_str(&format!("{first_line}
 {{
-    return raiseError(\"FIXME: Not implemented yet ({kind})\");
+    return raiseError(\"FIXME: Not implemented yet in this preview release ({kind})\");
 }}
 
 ",
                                 first_line = first_line,
                                 kind = parser.name.to_str()));
                         } else {
                             buffer.push_str(&format!("{first_line}
 {{
@@ -1512,17 +1534,17 @@ impl CPPExporter {
                     &TypeSpec::PropertyKey => {
                         debug!(target: "generate_spidermonkey", "Generating method for PropertyKey: {:?}", parser.name);
                         let build_result = rules_for_this_node.init.reindent("    ");
                         let first_line = self.get_method_definition_start(&parser.name, "", "",
                                                                           &extra_params);
                         if build_result.len() == 0 {
                             buffer.push_str(&format!("{first_line}
 {{
-    return raiseError(\"FIXME: Not implemented yet ({kind})\");
+    return raiseError(\"FIXME: Not implemented yet in this preview release ({kind})\");
 }}
 
 ",
                                 first_line = first_line,
                                 kind = parser.name.to_str()));
                         } else {
                             buffer.push_str(&format!("{first_line}
 {{
@@ -1758,17 +1780,17 @@ impl CPPExporter {
         }
 
         let init = rules_for_this_interface.init.reindent("    ");
         let build_result = rules_for_this_interface.build_result.reindent("    ");
 
         if build_result == "" {
             buffer.push_str(&format!("{first_line}
 {{
-    return raiseError(\"FIXME: Not implemented yet ({class_name})\");
+    return raiseError(\"FIXME: Not implemented yet in this preview release ({class_name})\");
 }}
 
 ",
                 class_name = name.to_class_cases(),
                 first_line = first_line,
             ));
         } else {
             let check_fields = if number_of_fields == 0 {
--- a/js/src/wasm/cranelift/build.rs
+++ b/js/src/wasm/cranelift/build.rs
@@ -21,23 +21,16 @@
 
 extern crate bindgen;
 
 use std::env;
 use std::fs::File;
 use std::io::prelude::*;
 use std::path::PathBuf;
 
-enum Arch {
-    X86,
-    X64,
-    Arm,
-    Aarch64
-}
-
 fn main() {
     // Tell Cargo to regenerate the bindings if the header file changes.
     println!("cargo:rerun-if-changed=baldrapi.h");
 
     let mut bindings = bindgen::builder()
         .disable_name_namespacing()
         // We whitelist the Baldr C functions and get the associated types for free.
         .whitelist_function("env_.*")
@@ -47,79 +40,16 @@ fn main() {
         .whitelist_type("Cranelift.*")
         // The enum classes defined in baldrapi.h and WasmBinaryConstants are all Rust-safe.
         .rustified_enum("BD_.*|Trap|TypeCode|FuncTypeIdDescKind")
         .whitelist_type("BD_.*|Trap|TypeCode|FuncTypeIdDescKind")
         .header("baldrapi.h")
         .clang_args(&["-x", "c++", "-std=gnu++14", "-fno-sized-deallocation", "-DRUST_BINDGEN"])
         .clang_arg("-I../..");
 
-    let arch = {
-        let target_arch = env::var("CARGO_CFG_TARGET_ARCH");
-        match target_arch.as_ref().map(|x| x.as_str()) {
-            Ok("aarch64") => Some(Arch::Aarch64),
-            Ok("arm") => Some(Arch::Arm),
-            Ok("x86") => Some(Arch::X86),
-            Ok("x86_64") => Some(Arch::X64),
-            _ => None
-        }
-    };
-
-    match env::var("CARGO_CFG_TARGET_OS").as_ref().map(|x| x.as_str()) {
-        Ok("android") => {
-            bindings = bindings.clang_arg("-DOS_ANDROID=1");
-            bindings = match arch.expect("unknown android architecture") {
-                Arch::Aarch64 => { bindings.clang_arg("--target=aarch64-linux-android") }
-                Arch::Arm => { bindings.clang_arg("--target=armv7-linux-androideabi") }
-                Arch::X86 => { bindings.clang_arg("--target=i686-linux-android") }
-                Arch::X64 => { bindings.clang_arg("--target=x86_64-linux-android") }
-            };
-        }
-
-        Ok("linux") | Ok("freebsd") | Ok("dragonfly") | Ok("openbsd") | Ok("bitrig") | Ok("netbsd")
-            | Ok("ios") => {
-            // Nothing to do in particular for these OSes, until proven the contrary.
-        }
-
-        Ok("macos") => {
-            bindings = bindings.clang_arg("-DOS_MACOSX=1");
-            bindings = bindings.clang_arg("-stdlib=libc++");
-            bindings = bindings.clang_arg("--target=x86_64-apple-darwin");
-        }
-
-        Ok("windows") => {
-            let arch = arch.expect("unknown Windows architecture");
-            bindings = bindings.clang_arg("-DOS_WIN=1")
-                .clang_arg("-DWIN32=1");
-            bindings = match env::var("CARGO_CFG_TARGET_ENV").as_ref().map(|x| x.as_str()) {
-                Ok("msvc") => {
-                    bindings = bindings.clang_arg("-fms-compatibility-version=19");
-                    bindings = bindings.clang_arg("-D_CRT_USE_BUILTIN_OFFSETOF");
-                    bindings = bindings.clang_arg("-DHAVE_VISIBILITY_HIDDEN_ATTRIBUTE=1");
-                    match arch {
-                        Arch::X86 => { bindings.clang_arg("--target=i686-pc-win32") },
-                        Arch::X64 => { bindings.clang_arg("--target=x86_64-pc-win32") },
-                        Arch::Aarch64 => { bindings.clang_arg("--target=aarch64-pc-windows-msvc") }
-                        _ => panic!("unknown Windows architecture for msvc build")
-                    }
-                }
-                Ok("gnu") => {
-                    match arch {
-                        Arch::X86 => { bindings.clang_arg("--target=i686-pc-mingw32") },
-                        Arch::X64 => { bindings.clang_arg("--target=x86_64-w64-mingw32") },
-                        _ => panic!("unknown Windows architecture for gnu build")
-                    }
-                }
-                _ => panic!("unknown Windows build environment")
-            };
-        }
-
-        os => panic!("unknown target os {:?}!", os)
-    }
-
     let path = PathBuf::from(env::var_os("MOZ_TOPOBJDIR").unwrap()).join("js/src/rust/extra-bindgen-flags");
 
     let mut extra_flags = String::new();
         File::open(&path)
             .expect("Failed to open extra-bindgen-flags file")
             .read_to_string(&mut extra_flags)
             .expect("Failed to read extra-bindgen-flags file");
 
new file mode 100644
--- /dev/null
+++ b/layout/reftests/bugs/1149304-1-transform-change-ref.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+  body { transform:translateY(10px); white-space: pre; }
+  p { margin: 0; }
+  span { padding: 2px; color: red; background: blue; }
+</style>
+</head>
+<body><p> <span>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> &nbsp; &nbsp; </p>
+</body>
+</html>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/bugs/1149304-1-transform-change.html
@@ -0,0 +1,23 @@
+<!DOCTYPE HTML>
+<html class="reftest-wait">
+<head>
+<meta charset="utf-8">
+<style>
+  body { transform:translateY(100px); white-space: pre; }
+  p { margin: 0; }
+  span { padding: 2px; color: red; background: blue; }
+</style>
+<script>
+function test(n) {
+  document.body.style.transform = "translateY(" + n + "px)";
+  if (n > 10) {
+    setTimeout("test(" + (n - 10) + ")", 0);
+  } else {
+    document.documentElement.removeAttribute("class");
+  }
+}
+</script>
+</head>
+<body onload="test(100)"><p> <span>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> &nbsp; &nbsp; </p>
+</body>
+</html>
--- a/layout/reftests/bugs/reftest.list
+++ b/layout/reftests/bugs/reftest.list
@@ -1934,16 +1934,17 @@ skip-if(!Android) == 1133905-4-h-rtl.htm
 skip-if(!Android) == 1133905-5-h-rtl.html 1133905-ref-h-rtl.html
 skip-if(!Android) == 1133905-6-h-rtl.html 1133905-ref-h-rtl.html
 skip-if(!Android) fails-if(Android) == 1133905-1-vh-rtl.html 1133905-ref-vh-rtl.html
 skip-if(!Android) fails-if(Android) == 1133905-2-vh-rtl.html 1133905-ref-vh-rtl.html
 skip-if(!Android) fails-if(Android) == 1133905-3-vh-rtl.html 1133905-ref-vh-rtl.html
 skip-if(!Android) == 1133905-4-vh-rtl.html 1133905-ref-vh-rtl.html
 skip-if(!Android) fails-if(Android) == 1133905-5-vh-rtl.html 1133905-ref-vh-rtl.html
 skip-if(!Android) fails-if(Android) == 1133905-6-vh-rtl.html 1133905-ref-vh-rtl.html
+== 1149304-1-transform-change.html 1149304-1-transform-change-ref.html
 == 1150021-1.xul 1150021-1-ref.xul
 == 1151145-1.html 1151145-1-ref.html
 == 1151306-1.html 1151306-1-ref.html
 == 1153845-1.html 1153845-1-ref.html
 == 1155828-1.html 1155828-1-ref.html
 fuzzy-if(skiaContent,0-7,0-84) == 1156129-1.html 1156129-1-ref.html
 pref(dom.use_xbl_scopes_for_remote_xul,true) HTTP(..) == 1157127-1.html 1157127-1-ref.html
 fuzzy-if(Android,0-6,0-6) == 1169331-1.html 1169331-1-ref.html
--- a/layout/style/ServoBindings.toml
+++ b/layout/style/ServoBindings.toml
@@ -1,66 +1,8 @@
-[build]
-args = [
-    "-x", "c++", "-std=gnu++14", "-fno-sized-deallocation",
-    "-DTRACING=1", "-DIMPL_LIBXUL", "-DMOZ_STYLO_BINDINGS=1",
-    "-DMOZILLA_INTERNAL_API", "-DRUST_BINDGEN"
-]
-"family=unix" = ["-DOS_POSIX=1"]
-"os=solaris" = ["-DOS_SOLARIS=1"]
-"os=dragonfly" = ["-DOS_BSD=1", "-DOS_DRAGONFLY=1"]
-"os=freebsd" = ["-DOS_BSD=1", "-DOS_FREEBSD=1"]
-"os=netbsd" = ["-DOS_BSD=1", "-DOS_NETBSD=1"]
-"os=openbsd" = ["-DOS_BSD=1", "-DOS_OPENBSD=1"]
-"os=macos" = [
-    "-DOS_MACOSX=1", "-stdlib=libc++",
-    # To disable the fixup bindgen applies which adds search
-    # paths from clang command line in order to avoid potential
-    # conflict with -stdlib=libc++.
-    "--target=x86_64-apple-darwin",
-]
-
-[build."os=linux"]
-args = ["-DOS_LINUX=1"]
-"arch=x86" = ["-m32"]
-"arch=x86_64" = ["-m64"]
-
-[build."os=android"]
-args = ["-DOS_ANDROID=1"]
-"arch=aarch64" = ["--target=aarch64-linux-android"]
-"arch=arm" = ["--target=armv7-linux-androideabi"]
-"arch=x86" = ["--target=i686-linux-android"]
-"arch=x86_64" = ["--target=x86_64-linux-android"]
-
-[build."os=windows"]
-args = [
-    "-DOS_WIN=1", "-DWIN32=1",
-]
-
-[build."os=windows"."env=msvc"]
-args = [
-    # For compatibility with MSVC 2015
-    "-fms-compatibility-version=19",
-    # To enable the builtin __builtin_offsetof so that CRT wouldn't
-    # use reinterpret_cast in offsetof() which is not allowed inside
-    # static_assert().
-    "-D_CRT_USE_BUILTIN_OFFSETOF",
-    # Enable hidden attribute (which is not supported by MSVC and
-    # thus not enabled by default with a MSVC-compatibile build)
-    # to exclude hidden symbols from the generated file.
-    "-DHAVE_VISIBILITY_HIDDEN_ATTRIBUTE=1",
-]
-"arch=x86" = ["--target=i686-pc-win32"]
-"arch=x86_64" = ["--target=x86_64-pc-win32"]
-"arch=aarch64" = ["--target=aarch64-pc-windows-msvc"]
-
-[build."os=windows"."env=gnu"]
-"arch=x86" = ["--target=i686-pc-mingw32"]
-"arch=x86_64" = ["--target=x86_64-w64-mingw32"]
-
 [structs]
 headers = [
     "nsStyleStruct.h",
     "mozilla/StyleAnimationValue.h",
     "gfxFontConstants.h",
     "gfxFontFeatures.h",
     "nsStyleConsts.h",
     "mozilla/css/Loader.h",
--- a/mozilla-config.h.in
+++ b/mozilla-config.h.in
@@ -40,22 +40,11 @@
 /*
  * Force-include sdkdecls.h for building the chromium sandbox code.
  *
  * CHROMIUM_SANDBOX_BUILD is defined in security/sandbox/moz.build.
  * Note that this include path relies on the LOCAL_INCLUDES in that file.
  */
 #if defined(CHROMIUM_SANDBOX_BUILD) && defined(XP_WIN)
 #include "base/win/sdkdecls.h"
-
-#ifdef __MINGW32__
-/*
- * MinGW doesn't support __try / __except. There are a few mechanisms available
- * to hack around it and pseudo-support it, but these are untested in Firefox.
- * What is tested (and works) is replacing them with if(true) and else.
- */
-#define __try if(true)
-#define __except(x) else
-
-#endif /* __MINGW32__ */
 #endif /* defined(CHROMIUM_SANDBOX_BUILD) && defined(XP_WIN) */
 
 #endif /* MOZILLA_CONFIG_H */
deleted file mode 100644
--- a/security/sandbox/chromium-shim/patches/with_update/mingw_disable_one_try.patch
+++ /dev/null
@@ -1,51 +0,0 @@
-# HG changeset patch
-# User Tom Ritter <tom@mozilla.com>
-# Date 1516389982 21600
-#      Fri Jan 19 13:26:22 2018 -0600
-# Node ID 3ca7306d73ebc1ce47ccdc62ee8cbb69a9bfbb2c
-# Parent  6aa6c7d894609140ccde2e9e50eba8c25a9caeb5
-Bug 1431803 Disable a specific __try block on MinGW r?bobowen
-
-This function is a technique to name a thread for debugging purposes,
-and it always throws an exception (and then continues). On MinGW
-we don't want it to throw an exception, so we do nothing.
-
-This means on MinGW we won't get nice thread naming during debugging,
-but we'll limp along.
-
-MozReview-Commit-ID: JRKY4wp7sdu
-
-diff --git a/security/sandbox/chromium/base/threading/platform_thread_win.cc b/security/sandbox/chromium/base/threading/platform_thread_win.cc
---- a/security/sandbox/chromium/base/threading/platform_thread_win.cc
-+++ b/security/sandbox/chromium/base/threading/platform_thread_win.cc
-@@ -32,27 +32,30 @@ typedef struct tagTHREADNAME_INFO {
- } THREADNAME_INFO;
- 
- // The SetThreadDescription API was brought in version 1607 of Windows 10.
- typedef HRESULT(WINAPI* SetThreadDescription)(HANDLE hThread,
-                                               PCWSTR lpThreadDescription);
- 
- // This function has try handling, so it is separated out of its caller.
- void SetNameInternal(PlatformThreadId thread_id, const char* name) {
-+  //This function is only used for debugging purposes, as you can find by its caller
-+#ifndef __MINGW32__
-   THREADNAME_INFO info;
-   info.dwType = 0x1000;
-   info.szName = name;
-   info.dwThreadID = thread_id;
-   info.dwFlags = 0;
- 
-   __try {
-     RaiseException(kVCThreadNameException, 0, sizeof(info)/sizeof(DWORD),
-                    reinterpret_cast<DWORD_PTR*>(&info));
-   } __except(EXCEPTION_CONTINUE_EXECUTION) {
-   }
-+#endif
- }
- 
- struct ThreadParams {
-   PlatformThread::Delegate* delegate;
-   bool joinable;
-   ThreadPriority priority;
- };
- 
--- a/security/sandbox/chromium-shim/patches/with_update/patch_order.txt
+++ b/security/sandbox/chromium-shim/patches/with_update/patch_order.txt
@@ -13,11 +13,10 @@ allow_read_only_all_paths_rule.patch
 revert_TargetNtSetInformationThread_change.patch
 mingw_base_win_get_caller.patch
 mingw_duplicate_instatinations.patch
 mingw_msvc_requirement_error.patch
 mingw_copy_s.patch
 mingw_operator_new.patch
 mingw_cast_getprocaddress.patch
 mingw_capitalization.patch
-mingw_disable_one_try.patch
 mingw_noexports_casts.patch
-mingw_offsetof.patch
\ No newline at end of file
+mingw_offsetof.patch
--- a/security/sandbox/chromium-shim/sandbox/win/permissionsService.cpp
+++ b/security/sandbox/chromium-shim/sandbox/win/permissionsService.cpp
@@ -3,16 +3,17 @@
 /* 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/. */
 
 /* SandboxPermissions.cpp - Special permissions granted to sandboxed processes */
 
 #include "permissionsService.h"
 #include <algorithm>
+#include <string>
 #include <winternl.h>
 
 namespace mozilla {
 namespace sandboxing {
 
 static const std::wstring ZONE_IDENTIFIER_STR(L":ZONE.IDENTIFIER");
 static const std::wstring ZONE_ID_DATA_STR(L":ZONE.IDENTIFIER:$DATA");
 // Generic name we use for all Flash temp files.
--- a/security/sandbox/chromium/base/threading/platform_thread_win.cc
+++ b/security/sandbox/chromium/base/threading/platform_thread_win.cc
@@ -32,30 +32,27 @@ typedef struct tagTHREADNAME_INFO {
 } THREADNAME_INFO;
 
 // The SetThreadDescription API was brought in version 1607 of Windows 10.
 typedef HRESULT(WINAPI* SetThreadDescription)(HANDLE hThread,
                                               PCWSTR lpThreadDescription);
 
 // This function has try handling, so it is separated out of its caller.
 void SetNameInternal(PlatformThreadId thread_id, const char* name) {
-  //This function is only used for debugging purposes, as you can find by its caller
-#ifndef __MINGW32__
   THREADNAME_INFO info;
   info.dwType = 0x1000;
   info.szName = name;
   info.dwThreadID = thread_id;
   info.dwFlags = 0;
 
   __try {
     RaiseException(kVCThreadNameException, 0, sizeof(info)/sizeof(DWORD),
                    reinterpret_cast<DWORD_PTR*>(&info));
   } __except(EXCEPTION_CONTINUE_EXECUTION) {
   }
-#endif
 }
 
 struct ThreadParams {
   PlatformThread::Delegate* delegate;
   bool joinable;
   ThreadPriority priority;
 };
 
--- a/servo/components/style/build_gecko.rs
+++ b/servo/components/style/build_gecko.rs
@@ -53,32 +53,20 @@ mod bindings {
         static ref CONFIG: Table = {
             // Load Gecko's binding generator config from the source tree.
             let path = PathBuf::from(env::var_os("MOZ_SRC").unwrap())
                 .join("layout/style/ServoBindings.toml");
             read_config(&path)
         };
         static ref BUILD_CONFIG: Table = {
             // Load build-specific config overrides.
-            // FIXME: We should merge with CONFIG above instead of
-            // forcing callers to do it.
             let path = PathBuf::from(env::var_os("MOZ_TOPOBJDIR").unwrap())
                 .join("layout/style/bindgen.toml");
             read_config(&path)
         };
-        static ref TARGET_INFO: HashMap<String, String> = {
-            const TARGET_PREFIX: &'static str = "CARGO_CFG_TARGET_";
-            let mut result = HashMap::new();
-            for (k, v) in env::vars() {
-                if k.starts_with(TARGET_PREFIX) {
-                    result.insert(k[TARGET_PREFIX.len()..].to_lowercase(), v);
-                }
-            }
-            result
-        };
         static ref INCLUDE_RE: Regex = Regex::new(r#"#include\s*"(.+?)""#).unwrap();
         static ref DISTDIR_PATH: PathBuf = {
             let path = PathBuf::from(env::var_os("MOZ_DIST").unwrap());
             if !path.is_absolute() || !path.is_dir() {
                 panic!("MOZ_DIST must be an absolute directory, was: {}", path.display());
             }
             path
         };
@@ -140,45 +128,16 @@ mod bindings {
     trait BuilderExt {
         fn get_initial_builder() -> Builder;
         fn include<T: Into<String>>(self, file: T) -> Builder;
         fn zero_size_type(self, ty: &str, structs_list: &HashSet<&str>) -> Builder;
         fn borrowed_type(self, ty: &str) -> Builder;
         fn mutable_borrowed_type(self, ty: &str) -> Builder;
     }
 
-    fn add_clang_args(mut builder: Builder, config: &Table, matched_os: &mut bool) -> Builder {
-        fn add_args(mut builder: Builder, values: &[toml::Value]) -> Builder {
-            for item in values.iter() {
-                builder = builder.clang_arg(item.as_str().expect("Expect string in list"));
-            }
-            builder
-        }
-        for (k, v) in config.iter() {
-            if k == "args" {
-                builder = add_args(builder, v.as_array().unwrap().as_slice());
-                continue;
-            }
-            let equal_idx = k.find('=').expect(&format!("Invalid key: {}", k));
-            let (target_type, target_value) = k.split_at(equal_idx);
-            if TARGET_INFO[target_type] != target_value[1..] {
-                continue;
-            }
-            if target_type == "os" {
-                *matched_os = true;
-            }
-            builder = match *v {
-                toml::Value::Table(ref table) => add_clang_args(builder, table, matched_os),
-                toml::Value::Array(ref array) => add_args(builder, array),
-                _ => panic!("Unknown type"),
-            };
-        }
-        builder
-    }
-
     impl BuilderExt for Builder {
         fn get_initial_builder() -> Builder {
             use bindgen::RustTarget;
 
             // Disable rust unions, because we replace some types inside of
             // them.
             let mut builder = Builder::default().rust_target(RustTarget::Stable_1_0);
 
@@ -202,26 +161,24 @@ mod bindings {
             }
 
             builder = builder.include(add_include("mozilla-config.h"));
 
             if env::var("CARGO_FEATURE_GECKO_DEBUG").is_ok() {
                 builder = builder.clang_arg("-DDEBUG=1").clang_arg("-DJS_DEBUG=1");
             }
 
-            let mut matched_os = false;
-            let build_config = CONFIG["build"].as_table().expect("Malformed config file");
-            builder = add_clang_args(builder, build_config, &mut matched_os);
             let build_config = BUILD_CONFIG["build"]
                 .as_table()
                 .expect("Malformed config file");
-            builder = add_clang_args(builder, build_config, &mut matched_os);
-            if !matched_os {
-                panic!("Unknown platform");
+            let extra_bindgen_flags = build_config["args"].as_array().unwrap().as_slice();
+            for item in extra_bindgen_flags.iter() {
+                builder = builder.clang_arg(item.as_str().expect("Expect string in list"));
             }
+
             builder
         }
         fn include<T: Into<String>>(self, file: T) -> Builder {
             self.clang_arg("-include").clang_arg(file)
         }
         // This makes an FFI-safe void type that can't be matched on
         // &VoidType is UB to have, because you can match on it
         // to produce a reachable unreachable. If it's wrapped in
--- a/testing/talos/requirements.txt
+++ b/testing/talos/requirements.txt
@@ -2,11 +2,12 @@ jsonschema>=2.5.1
 mozlog>=3.1
 mozcrash>=0.15
 mozfile>=1.2
 mozhttpd>=0.7
 mozinfo>=0.8
 mozprocess>=0.22
 mozversion>=1.3
 mozprofile>=0.25
+mozrunner>=7.1.0
 psutil>=3.1.1
 simplejson>=2.1.1
 requests>=2.9.1
--- a/testing/talos/talos/cmanager_mac.py
+++ b/testing/talos/talos/cmanager_mac.py
@@ -3,17 +3,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 """CounterManager for Mac OSX"""
 from __future__ import absolute_import, print_function
 
 import subprocess
 import sys
 
-from cmanager_base import CounterManager
+from talos.cmanager_base import CounterManager
 
 
 def GetProcessData(pid):
     """Runs a ps on the process identified by pid and returns the output line
       as a list (pid, vsz, rss)
     """
     command = ['ps -o pid,vsize,rss -p'+str(pid)]
     try:
--- a/testing/talos/talos/cmanager_win32.py
+++ b/testing/talos/talos/cmanager_win32.py
@@ -5,18 +5,18 @@ from __future__ import absolute_import
 
 import struct
 from ctypes import byref, create_string_buffer, memmove, Union, c_double, \
     c_longlong
 from ctypes import windll
 from ctypes.wintypes import DWORD, HANDLE, LPSTR, LPCSTR, LPCWSTR, Structure, \
     pointer, LONG
 
-from cmanager_base import CounterManager
-from utils import TalosError
+from talos.cmanager_base import CounterManager
+from talos.utils import TalosError
 
 pdh = windll.pdh
 
 _LONGLONG = c_longlong
 
 
 class _PDH_COUNTER_PATH_ELEMENTS_A(Structure):
     _fields_ = [("szMachineName", LPSTR),
--- a/testing/talos/talos/mainthreadio.py
+++ b/testing/talos/talos/mainthreadio.py
@@ -2,18 +2,18 @@
 # vim: set ts=8 sts=4 et sw=4 tw=80:
 # 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/.
 from __future__ import absolute_import, print_function
 
 import os
 import re
-import utils
-import whitelist
+from talos import utils
+from talos import whitelist
 
 from collections import OrderedDict
 
 SCRIPT_DIR = os.path.abspath(os.path.realpath(os.path.dirname(__file__)))
 
 STAGE_STARTUP = 0
 STAGE_STRINGS = ('startup', 'normal', 'shutdown')
 
--- a/testing/talos/talos/output.py
+++ b/testing/talos/talos/output.py
@@ -1,20 +1,20 @@
 
 # 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/.
 
 """output formats for Talos"""
 from __future__ import absolute_import
 
-import filter
+from talos import filter
 # NOTE: we have a circular dependency with output.py when we import results
 import simplejson as json
-import utils
+from talos import utils
 from mozlog import get_proxy_logger
 
 LOG = get_proxy_logger()
 
 
 class Output(object):
     """abstract base class for Talos output"""
 
--- a/testing/talos/talos/run_tests.py
+++ b/testing/talos/talos/run_tests.py
@@ -11,17 +11,18 @@ import subprocess
 import sys
 import time
 import traceback
 import urllib
 
 import mozhttpd
 import mozinfo
 import mozversion
-import utils
+
+from talos import utils
 from mozlog import get_proxy_logger
 from talos.config import get_configs, ConfigurationError
 from talos.mitmproxy import mitmproxy
 from talos.results import TalosResults
 from talos.ttest import TTest
 from talos.utils import TalosError, TalosRegression
 
 # directory of this file
--- a/testing/talos/talos/talos_process.py
+++ b/testing/talos/talos/talos_process.py
@@ -9,17 +9,17 @@ import time
 import traceback
 import subprocess
 from threading import Event
 
 import mozcrash
 import psutil
 from mozlog import get_proxy_logger
 from mozprocess import ProcessHandler
-from utils import TalosError
+from talos.utils import TalosError
 
 LOG = get_proxy_logger()
 
 
 class ProcessContext(object):
     """
     Store useful results of the browser execution.
     """
--- a/testing/talos/talos/ttest.py
+++ b/testing/talos/talos/ttest.py
@@ -18,23 +18,24 @@ import os
 import platform
 import shutil
 import subprocess
 import sys
 import time
 
 import mozcrash
 import mozfile
-import results
-import talosconfig
-import utils
+
 from mozlog import get_proxy_logger
 from talos.cmanager import CounterManagement
 from talos.ffsetup import FFSetup
 from talos.talos_process import run_browser
+from talos import utils
+from talos import results
+from talos import talosconfig
 from talos.utils import TalosCrash, TalosError, TalosRegression, run_in_debug_mode
 
 LOG = get_proxy_logger()
 
 
 class TTest(object):
     def check_for_crashes(self, browser_config, minidump_dir, test_name):
         # check for minidumps
--- a/testing/talos/talos/whitelist.py
+++ b/testing/talos/talos/whitelist.py
@@ -3,17 +3,17 @@
 # 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/.
 from __future__ import absolute_import, print_function
 
 import json
 import os
 import re
-import utils
+from talos import utils
 
 KEY_XRE = '{xre}'
 DEFAULT_DURATION = 100.0
 
 
 class Whitelist:
     # we need to find the root dir of the profile at runtime
     PRE_PROFILE = ''
deleted file mode 100644
--- a/testing/web-platform/meta/dom/events/EventListener-addEventListener.sub.window.js.ini
+++ /dev/null
@@ -1,5 +0,0 @@
-[EventListener-addEventListener.sub.window.html]
-  expected: TIMEOUT
-  [EventListener.addEventListener doesn't throw when a cross origin object is passed in.]
-    expected: TIMEOUT
-
deleted file mode 100644
--- a/testing/web-platform/meta/dom/events/EventListener-incumbent-global-1.sub.html.ini
+++ /dev/null
@@ -1,9 +0,0 @@
-[EventListener-incumbent-global-1.sub.html]
-  expected:
-    if not debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): TIMEOUT
-    if debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): TIMEOUT
-  [Check the incumbent global EventListeners  are called with]
-    expected:
-      if not debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): TIMEOUT
-      if debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): TIMEOUT
-
--- a/testing/web-platform/tests/dom/events/EventListener-addEventListener.sub.window.js
+++ b/testing/web-platform/tests/dom/events/EventListener-addEventListener.sub.window.js
@@ -1,9 +1,9 @@
 async_test(function(t) {
   let crossOriginFrame = document.createElement('iframe');
-  crossOriginFrame.src = 'https://{{hosts[alt][]}}/common/blank.html';
+  crossOriginFrame.src = 'https://{{hosts[alt][]}}:{{ports[https][0]}}/common/blank.html';
   document.body.appendChild(crossOriginFrame);
   crossOriginFrame.addEventListener('load', t.step_func_done(function() {
     let crossOriginWindow = crossOriginFrame.contentWindow;
     window.addEventListener('click', crossOriginWindow);
   }));
 }, "EventListener.addEventListener doesn't throw when a cross origin object is passed in.");
--- a/toolkit/components/antitracking/test/browser/browser_blockingServiceWorkers.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingServiceWorkers.js
@@ -1,15 +1,16 @@
 requestLongerTimeout(2);
 
 AntiTracking.runTest("ServiceWorkers",
   async _ => {
     await navigator.serviceWorker.register("empty.js").then(
       _ => { ok(false, "ServiceWorker cannot be used!"); },
-      _ => { ok(true, "ServiceWorker cannot be used!"); });
+      _ => { ok(true, "ServiceWorker cannot be used!"); }).
+      catch(e => ok(false, "Promise rejected: " + e));
   },
   null,
   async _ => {
     await new Promise(resolve => {
       Services.clearData.deleteData(Ci.nsIClearDataService.CLEAR_ALL, value => resolve());
     });
   },
   [["dom.serviceWorkers.exemptFromPerDomainMax", true],