Merge mozilla-central to autoland. a=merge CLOSED TREE
authorNoemi Erli <nerli@mozilla.com>
Tue, 16 Oct 2018 01:21:28 +0300
changeset 499815 336f795d5b2621dd2d693649f815ad65182f5c17
parent 499811 32e5d5e6c9804247b0f82f931dc875fdc838f750 (current diff)
parent 499814 4c11ab0cd98950983cfc957f579ace6c3e918a43 (diff)
child 499816 5622861eb245cc20b3a121ffb73f1b58c9745934
push id1864
push userffxbld-merge
push dateMon, 03 Dec 2018 15:51:40 +0000
treeherdermozilla-release@f040763d99ad [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone64.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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],