Merge mozilla-central to autoland
authorCarsten "Tomcat" Book <cbook@mozilla.com>
Fri, 28 Jul 2017 09:50:36 +0200
changeset 420258 bbcec17958a9f17a7bd9fb5a581c4a51a29803de
parent 420257 18525ab193663e4564d96d61b69dd9fc8220d4a3 (current diff)
parent 420164 5845151f1a2cd00957fdd48e204542ccbdfaba1e (diff)
child 420259 87bd87bb40646066039afd60e8bbae10b53e400b
push id7566
push usermtabara@mozilla.com
push dateWed, 02 Aug 2017 08:25:16 +0000
treeherdermozilla-beta@86913f512c3c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone56.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
browser/base/content/test/performance/browser_urlbar_search_reflows.js
modules/libpref/init/all.js
toolkit/content/browser-child.js
xpcom/threads/InputEventStatistics.cpp
xpcom/threads/InputEventStatistics.h
--- a/.cron.yml
+++ b/.cron.yml
@@ -41,22 +41,17 @@ jobs:
     - name: nightly-desktop-win
       job:
           type: decision-task
           treeherder-symbol: Nd-Win
           target-tasks-method: nightly_win
       run-on-projects:
           - mozilla-central
           - date
-      when:
-          by-project:
-            # Match buildbot starts for now
-            date: [{hour: 15, minute: 0}]
-            mozilla-central: [{hour: 10, minute: 0}]
-            # No default
+      when: [] # never (hook only)
 
     - name: nightly-android
       job:
           type: decision-task
           treeherder-symbol: Na
           target-tasks-method: nightly_fennec
       run-on-projects:
           - mozilla-central
--- a/browser/base/content/tab-content.js
+++ b/browser/base/content/tab-content.js
@@ -906,17 +906,16 @@ var RefreshBlocker = {
       }
     }
   },
 
   enable() {
     this._filter = Cc["@mozilla.org/appshell/component/browser-status-filter;1"]
                      .createInstance(Ci.nsIWebProgress);
     this._filter.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_ALL);
-    this._filter.target = tabEventTarget;
 
     let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
                               .getInterface(Ci.nsIWebProgress);
     webProgress.addProgressListener(this._filter, Ci.nsIWebProgress.NOTIFY_ALL);
 
     addMessageListener("RefreshBlocker:Refresh", this);
   },
 
--- a/browser/base/content/test/performance/browser.ini
+++ b/browser/base/content/test/performance/browser.ini
@@ -9,13 +9,11 @@ skip-if = !e10s
 [browser_startup_images.js]
 skip-if = !debug
 [browser_tabclose_grow_reflows.js]
 [browser_tabclose_reflows.js]
 [browser_tabopen_reflows.js]
 [browser_tabopen_squeeze_reflows.js]
 [browser_tabswitch_reflows.js]
 [browser_toolbariconcolor_restyles.js]
-[browser_urlbar_search_reflows.js]
-skip-if = os == 'mac' && !debug # Disabled due to frequent failures. Bug 1384582
 [browser_windowclose_reflows.js]
 [browser_windowopen_reflows.js]
 skip-if = os == 'linux' # Disabled due to frequent failures. Bug 1380465.
--- a/browser/base/content/test/performance/browser_appmenu_reflows.js
+++ b/browser/base/content/test/performance/browser_appmenu_reflows.js
@@ -5,79 +5,99 @@
  * EXPECTED_APPMENU_OPEN_REFLOWS. This is a whitelist that should slowly go
  * away as we improve the performance of the front-end. Instead of adding more
  * reflows to the whitelist, you should be modifying your code to avoid the reflow.
  *
  * See https://developer.mozilla.org/en-US/Firefox/Performance_best_practices_for_Firefox_fe_engineers
  * for tips on how to do that.
  */
 const EXPECTED_APPMENU_OPEN_REFLOWS = [
-  {
-    stack: [
-      "openPopup@chrome://global/content/bindings/popup.xml",
-      "show/</<@chrome://browser/content/customizableui/panelUI.js",
-    ],
-  },
+  [
+    "openPopup@chrome://global/content/bindings/popup.xml",
+    "show/</<@chrome://browser/content/customizableui/panelUI.js",
+  ],
+
+  [
+    "get_alignmentPosition@chrome://global/content/bindings/popup.xml",
+    "adjustArrowPosition@chrome://global/content/bindings/popup.xml",
+    "onxblpopupshowing@chrome://global/content/bindings/popup.xml",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+    "show/</<@chrome://browser/content/customizableui/panelUI.js",
+  ],
 
-  {
-    stack: [
-      "get_alignmentPosition@chrome://global/content/bindings/popup.xml",
-      "adjustArrowPosition@chrome://global/content/bindings/popup.xml",
-      "onxblpopupshowing@chrome://global/content/bindings/popup.xml",
-      "openPopup@chrome://global/content/bindings/popup.xml",
-      "show/</<@chrome://browser/content/customizableui/panelUI.js",
-    ],
+  [
+    "get_alignmentPosition@chrome://global/content/bindings/popup.xml",
+    "adjustArrowPosition@chrome://global/content/bindings/popup.xml",
+    "onxblpopupshowing@chrome://global/content/bindings/popup.xml",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+    "show/</<@chrome://browser/content/customizableui/panelUI.js",
+  ],
 
-    times: 2, // This number should only ever go down - never up.
-  },
+  [
+    "get_alignmentPosition@chrome://global/content/bindings/popup.xml",
+    "adjustArrowPosition@chrome://global/content/bindings/popup.xml",
+    "onxblpopuppositioned@chrome://global/content/bindings/popup.xml",
+  ],
 
-  {
-    stack: [
-      "get_alignmentPosition@chrome://global/content/bindings/popup.xml",
-      "adjustArrowPosition@chrome://global/content/bindings/popup.xml",
-      "onxblpopuppositioned@chrome://global/content/bindings/popup.xml",
-    ],
-  },
+  [
+    "get_alignmentPosition@chrome://global/content/bindings/popup.xml",
+    "handleEvent@resource:///modules/PanelMultiView.jsm",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+  ],
+
+  [
+    "handleEvent@resource:///modules/PanelMultiView.jsm",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+  ],
+
+  [
+    "handleEvent@resource:///modules/PanelMultiView.jsm",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+  ],
 
-  {
-    stack: [
-      "get_alignmentPosition@chrome://global/content/bindings/popup.xml",
-      "handleEvent@resource:///modules/PanelMultiView.jsm",
-      "openPopup@chrome://global/content/bindings/popup.xml",
-    ],
-  },
+  [
+    "handleEvent@resource:///modules/PanelMultiView.jsm",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+  ],
+
+  [
+    "handleEvent@resource:///modules/PanelMultiView.jsm",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+  ],
 
-  {
-    stack: [
-      "handleEvent@resource:///modules/PanelMultiView.jsm",
-      "openPopup@chrome://global/content/bindings/popup.xml",
-    ],
+  [
+    "handleEvent@resource:///modules/PanelMultiView.jsm",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+  ],
 
-    times: 6, // This number should only ever go down - never up.
-  },
+  [
+    "handleEvent@resource:///modules/PanelMultiView.jsm",
+    "openPopup@chrome://global/content/bindings/popup.xml",
+  ],
 ];
 
 const EXPECTED_APPMENU_SUBVIEW_REFLOWS = [
   /**
    * The synced tabs view has labels that are multiline. Because of bugs in
    * XUL layout relating to multiline text in scrollable containers, we need
    * to manually read their height in order to ensure container heights are
    * correct. Unfortunately this requires 2 sync reflows.
    *
    * If we add more views where this is necessary, we may need to duplicate
    * these expected reflows further.
    */
-  {
-    stack: [
-      "descriptionHeightWorkaround@resource:///modules/PanelMultiView.jsm",
-      "onTransitionEnd@resource:///modules/PanelMultiView.jsm",
-    ],
+  [
+    "descriptionHeightWorkaround@resource:///modules/PanelMultiView.jsm",
+    "onTransitionEnd@resource:///modules/PanelMultiView.jsm",
+  ],
 
-    times: 2, // This number should only ever go down - never up.
-  },
+  [
+    "descriptionHeightWorkaround@resource:///modules/PanelMultiView.jsm",
+    "onTransitionEnd@resource:///modules/PanelMultiView.jsm",
+  ],
 
   /**
    * Please don't add anything new!
    */
 ];
 
 add_task(async function() {
   await ensureNoPreloadedBrowser();
--- a/browser/base/content/test/performance/browser_tabopen_reflows.js
+++ b/browser/base/content/test/performance/browser_tabopen_reflows.js
@@ -10,21 +10,19 @@
  * be modifying your code to avoid the reflow.
  *
  * See https://developer.mozilla.org/en-US/Firefox/Performance_best_practices_for_Firefox_fe_engineers
  * for tips on how to do that.
  */
 const EXPECTED_REFLOWS = [
   // selection change notification may cause querying the focused editor content
   // by IME and that will cause reflow.
-  {
-    stack: [
-      "select@chrome://global/content/bindings/textbox.xml",
-    ],
-  }
+  [
+    "select@chrome://global/content/bindings/textbox.xml",
+  ],
 ];
 
 /*
  * This test ensures that there are no unexpected
  * uninterruptible reflows when opening new tabs.
  */
 add_task(async function() {
   await ensureNoPreloadedBrowser();
--- a/browser/base/content/test/performance/browser_tabopen_squeeze_reflows.js
+++ b/browser/base/content/test/performance/browser_tabopen_squeeze_reflows.js
@@ -5,23 +5,21 @@
  * is a whitelist that should slowly go away as we improve the performance of
  * the front-end. Instead of adding more reflows to the whitelist, you should
  * be modifying your code to avoid the reflow.
  *
  * See https://developer.mozilla.org/en-US/Firefox/Performance_best_practices_for_Firefox_fe_engineers
  * for tips on how to do that.
  */
 const EXPECTED_REFLOWS = [
-  {
-    stack: [
-      "select@chrome://global/content/bindings/textbox.xml",
-      "focusAndSelectUrlBar@chrome://browser/content/browser.js",
-      "_adjustFocusAfterTabSwitch@chrome://browser/content/tabbrowser.xml",
-    ],
-  }
+  [
+    "select@chrome://global/content/bindings/textbox.xml",
+    "focusAndSelectUrlBar@chrome://browser/content/browser.js",
+    "_adjustFocusAfterTabSwitch@chrome://browser/content/tabbrowser.xml",
+  ],
 ];
 
 /*
  * This test ensures that there are no unexpected
  * uninterruptible reflows when opening a new tab that will
  * cause the existing tabs to squeeze smaller.
  */
 add_task(async function() {
deleted file mode 100644
--- a/browser/base/content/test/performance/browser_urlbar_search_reflows.js
+++ /dev/null
@@ -1,264 +0,0 @@
-"use strict";
-
-XPCOMUtils.defineLazyModuleGetter(this, "PlacesTestUtils",
-                                  "resource://testing-common/PlacesTestUtils.jsm");
-
-/**
- * WHOA THERE: We should never be adding new things to EXPECTED_REFLOWS. This
- * is a whitelist that should slowly go away as we improve the performance of
- * the front-end. Instead of adding more reflows to the whitelist, you should
- * be modifying your code to avoid the reflow.
- *
- * See https://developer.mozilla.org/en-US/Firefox/Performance_best_practices_for_Firefox_fe_engineers
- * for tips on how to do that.
- */
-
-/* These reflows happen only the first time the awesomebar panel opens. */
-const EXPECTED_REFLOWS_FIRST_OPEN = [
-  // Bug 1357054
-  {
-    stack: [
-      "_rebuild@chrome://browser/content/search/search.xml",
-      "set_popup@chrome://browser/content/search/search.xml",
-      "enableOneOffSearches@chrome://browser/content/urlbarBindings.xml",
-      "_enableOrDisableOneOffSearches@chrome://browser/content/urlbarBindings.xml",
-      "urlbar_XBL_Constructor/<@chrome://browser/content/urlbarBindings.xml",
-      "openPopup@chrome://global/content/bindings/popup.xml",
-      "_openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openPopup@chrome://global/content/bindings/autocomplete.xml",
-      "set_popupOpen@chrome://global/content/bindings/autocomplete.xml"
-    ],
-    times: 1, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "adjustSiteIconStart@chrome://global/content/bindings/autocomplete.xml",
-      "set_siteIconStart@chrome://global/content/bindings/autocomplete.xml",
-      "_openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openPopup@chrome://global/content/bindings/autocomplete.xml",
-      "set_popupOpen@chrome://global/content/bindings/autocomplete.xml",
-    ],
-  },
-
-  {
-    stack: [
-      "adjustSiteIconStart@chrome://global/content/bindings/autocomplete.xml",
-      "_reuseAcItem@chrome://global/content/bindings/autocomplete.xml",
-      "_appendCurrentResult@chrome://global/content/bindings/autocomplete.xml",
-      "_invalidate@chrome://global/content/bindings/autocomplete.xml",
-      "invalidate@chrome://global/content/bindings/autocomplete.xml",
-    ],
-    times: 9, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "adjustHeight@chrome://global/content/bindings/autocomplete.xml",
-      "onxblpopupshown@chrome://global/content/bindings/autocomplete.xml"
-    ],
-    times: 5, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "_handleOverflow@chrome://global/content/bindings/autocomplete.xml",
-      "handleOverUnderflow@chrome://global/content/bindings/autocomplete.xml",
-      "set_siteIconStart@chrome://global/content/bindings/autocomplete.xml",
-    ],
-    times: 6, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "adjustHeight@chrome://global/content/bindings/autocomplete.xml",
-      "_invalidate/this._adjustHeightTimeout<@chrome://global/content/bindings/autocomplete.xml",
-    ],
-    times: 3, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "_handleOverflow@chrome://global/content/bindings/autocomplete.xml",
-      "handleOverUnderflow@chrome://global/content/bindings/autocomplete.xml",
-      "_reuseAcItem@chrome://global/content/bindings/autocomplete.xml",
-      "_appendCurrentResult@chrome://global/content/bindings/autocomplete.xml",
-      "_invalidate@chrome://global/content/bindings/autocomplete.xml",
-      "invalidate@chrome://global/content/bindings/autocomplete.xml"
-    ],
-    times: 390, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "_openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openPopup@chrome://global/content/bindings/autocomplete.xml",
-      "set_popupOpen@chrome://global/content/bindings/autocomplete.xml",
-    ],
-    times: 3, // This number should only ever go down - never up.
-  },
-
-  // Bug 1359989
-  {
-    stack: [
-      "openPopup@chrome://global/content/bindings/popup.xml",
-      "_openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openPopup@chrome://global/content/bindings/autocomplete.xml",
-      "set_popupOpen@chrome://global/content/bindings/autocomplete.xml",
-    ],
-  },
-];
-
-/* These reflows happen everytime the awesomebar panel opens. */
-const EXPECTED_REFLOWS_SECOND_OPEN = [
-  {
-    stack: [
-      "adjustHeight@chrome://global/content/bindings/autocomplete.xml",
-      "onxblpopupshown@chrome://global/content/bindings/autocomplete.xml"
-    ],
-    times: 3, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "adjustHeight@chrome://global/content/bindings/autocomplete.xml",
-      "_invalidate/this._adjustHeightTimeout<@chrome://global/content/bindings/autocomplete.xml",
-    ],
-    times: 3, // This number should only ever go down - never up.
-  },
-
-  {
-    stack: [
-      "_handleOverflow@chrome://global/content/bindings/autocomplete.xml",
-      "handleOverUnderflow@chrome://global/content/bindings/autocomplete.xml",
-      "_reuseAcItem@chrome://global/content/bindings/autocomplete.xml",
-      "_appendCurrentResult@chrome://global/content/bindings/autocomplete.xml",
-      "_invalidate@chrome://global/content/bindings/autocomplete.xml",
-      "invalidate@chrome://global/content/bindings/autocomplete.xml"
-    ],
-    times: 444, // This number should only ever go down - never up.
-  },
-
-  // Bug 1384256
-  {
-    stack: [
-      "_openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openPopup@chrome://global/content/bindings/autocomplete.xml",
-      "set_popupOpen@chrome://global/content/bindings/autocomplete.xml",
-    ],
-    times: 3, // This number should only ever go down - never up.
-  },
-
-  // Bug 1359989
-  {
-    stack: [
-      "openPopup@chrome://global/content/bindings/popup.xml",
-      "_openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openAutocompletePopup@chrome://browser/content/urlbarBindings.xml",
-      "openPopup@chrome://global/content/bindings/autocomplete.xml",
-      "set_popupOpen@chrome://global/content/bindings/autocomplete.xml",
-    ],
-  },
-];
-
-/**
- * Returns a Promise that resolves once the AwesomeBar popup for a particular
- * window has appeared after having done a search for its input text.
- *
- * @param win (browser window)
- *        The window to do the search in.
- * @returns Promise
- */
-async function promiseAutocompleteResultPopup(win) {
-  let URLBar = win.gURLBar;
-  URLBar.controller.startSearch(URLBar.value);
-  await BrowserTestUtils.waitForEvent(URLBar.popup, "popupshown");
-  await BrowserTestUtils.waitForCondition(() => {
-    return URLBar.controller.searchStatus >=
-      Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH;
-  });
-  let matchCount = URLBar.popup._matchCount;
-  await BrowserTestUtils.waitForCondition(() => {
-    return URLBar.popup.richlistbox.childNodes.length == matchCount;
-  });
-
-  URLBar.controller.stopSearch();
-  // There are several setTimeout(fn, 0); calls inside autocomplete.xml
-  // that we need to wait for. Since those have higher priority than
-  // idle callbacks, we can be sure they will have run once this
-  // idle callback is called. The timeout seems to be required in
-  // automation - presumably because the machines can be pretty busy
-  // especially if it's GC'ing from previous tests.
-  await new Promise(resolve => win.requestIdleCallback(resolve, { timeout: 1000 }));
-
-  let hiddenPromise = BrowserTestUtils.waitForEvent(URLBar.popup, "popuphidden");
-  EventUtils.synthesizeKey("VK_ESCAPE", {}, win);
-  await hiddenPromise;
-}
-
-const SEARCH_TERM = "urlbar-reflows";
-
-add_task(async function setup() {
-  const NUM_VISITS = 10;
-  let visits = [];
-
-  for (let i = 0; i < NUM_VISITS; ++i) {
-    visits.push({
-      uri: `http://example.com/urlbar-reflows-${i}`,
-      title: `Reflow test for URL bar entry #${i}`,
-    });
-  }
-
-  await PlacesTestUtils.addVisits(visits);
-
-  registerCleanupFunction(async function() {
-    await PlacesTestUtils.clearHistory();
-  });
-});
-
-/**
- * This test ensures that there are no unexpected
- * uninterruptible reflows when typing into the URL bar
- * with the default values in Places.
- */
-add_task(async function() {
-  let win = await BrowserTestUtils.openNewBrowserWindow();
-  await ensureNoPreloadedBrowser(win);
-
-  let URLBar = win.gURLBar;
-  let popup = URLBar.popup;
-
-  URLBar.focus();
-  URLBar.value = SEARCH_TERM;
-  let testFn = async function(dirtyFrameFn) {
-    let oldInvalidate = popup.invalidate.bind(popup);
-    let oldResultsAdded = popup.onResultsAdded.bind(popup);
-
-    // We need to invalidate the frame tree outside of the normal
-    // mechanism since invalidations and result additions to the
-    // URL bar occur without firing JS events (which is how we
-    // normally know to dirty the frame tree).
-    popup.invalidate = (reason) => {
-      dirtyFrameFn();
-      oldInvalidate(reason);
-    };
-
-    popup.onResultsAdded = () => {
-      dirtyFrameFn();
-      oldResultsAdded();
-    };
-
-    await promiseAutocompleteResultPopup(win);
-  };
-
-  await withReflowObserver(testFn, EXPECTED_REFLOWS_FIRST_OPEN, win);
-
-  await withReflowObserver(testFn, EXPECTED_REFLOWS_SECOND_OPEN, win);
-
-  await BrowserTestUtils.closeWindow(win);
-});
--- a/browser/base/content/test/performance/browser_windowopen_reflows.js
+++ b/browser/base/content/test/performance/browser_windowopen_reflows.js
@@ -8,104 +8,124 @@
  * is a whitelist that should slowly go away as we improve the performance of
  * the front-end. Instead of adding more reflows to the whitelist, you should
  * be modifying your code to avoid the reflow.
  *
  * See https://developer.mozilla.org/en-US/Firefox/Performance_best_practices_for_Firefox_fe_engineers
  * for tips on how to do that.
  */
 const EXPECTED_REFLOWS = [
-  {
-    stack: [
-      "select@chrome://global/content/bindings/textbox.xml",
-      "focusAndSelectUrlBar@chrome://browser/content/browser.js",
-      "_delayedStartup@chrome://browser/content/browser.js",
-    ],
-  },
+  [
+    "select@chrome://global/content/bindings/textbox.xml",
+    "focusAndSelectUrlBar@chrome://browser/content/browser.js",
+    "_delayedStartup@chrome://browser/content/browser.js",
+  ],
 ];
 
 if (Services.appinfo.OS == "Linux") {
   if (gMultiProcessBrowser) {
-    EXPECTED_REFLOWS.push({
-      stack: [
+    EXPECTED_REFLOWS.push(
+      [
         "handleEvent@chrome://browser/content/tabbrowser.xml",
         "EventListener.handleEvent*tabbrowser-tabs_XBL_Constructor@chrome://browser/content/tabbrowser.xml",
       ],
-    });
+    );
   } else {
-    EXPECTED_REFLOWS.push({
-      stack: [
+    EXPECTED_REFLOWS.push(
+      [
         "handleEvent@chrome://browser/content/tabbrowser.xml",
         "inferFromText@chrome://browser/content/browser.js",
         "handleEvent@chrome://browser/content/browser.js",
       ],
-    });
+    );
   }
 }
 
 if (Services.appinfo.OS == "Darwin") {
-  EXPECTED_REFLOWS.push({
-    stack: [
+  EXPECTED_REFLOWS.push(
+    [
       "handleEvent@chrome://browser/content/tabbrowser.xml",
       "inferFromText@chrome://browser/content/browser.js",
       "handleEvent@chrome://browser/content/browser.js",
     ],
-  });
+  );
 }
 
 if (Services.appinfo.OS == "WINNT") {
   EXPECTED_REFLOWS.push(
-    {
-      stack: [
-        "verticalMargins@chrome://browser/content/browser-tabsintitlebar.js",
-        "_update@chrome://browser/content/browser-tabsintitlebar.js",
-        "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
-        "handleEvent@chrome://browser/content/tabbrowser.xml",
-      ],
-      times: 2, // This number should only ever go down - never up.
-    },
+    [
+      "verticalMargins@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
 
-    {
-      stack: [
-        "handleEvent@chrome://browser/content/tabbrowser.xml",
-        "inferFromText@chrome://browser/content/browser.js",
-        "handleEvent@chrome://browser/content/browser.js",
-      ],
-    },
+    [
+      "verticalMargins@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
 
-    {
-      stack: [
-        "handleEvent@chrome://browser/content/tabbrowser.xml",
-        "EventListener.handleEvent*tabbrowser-tabs_XBL_Constructor@chrome://browser/content/tabbrowser.xml",
-      ],
-    }
+    [
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+      "inferFromText@chrome://browser/content/browser.js",
+      "handleEvent@chrome://browser/content/browser.js",
+    ],
+
+    [
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+      "EventListener.handleEvent*tabbrowser-tabs_XBL_Constructor@chrome://browser/content/tabbrowser.xml",
+    ],
   );
 }
 
 if (Services.appinfo.OS == "WINNT" || Services.appinfo.OS == "Darwin") {
   EXPECTED_REFLOWS.push(
-    {
-      stack: [
-        "rect@chrome://browser/content/browser-tabsintitlebar.js",
-        "_update@chrome://browser/content/browser-tabsintitlebar.js",
-        "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
-        "handleEvent@chrome://browser/content/tabbrowser.xml",
-      ],
-      times: 4, // This number should only ever go down - never up.
-    },
+    [
+      "rect@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
+
+    [
+      "rect@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
+
+    [
+      "rect@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
 
-    {
-      stack: [
-        "verticalMargins@chrome://browser/content/browser-tabsintitlebar.js",
-        "_update@chrome://browser/content/browser-tabsintitlebar.js",
-        "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
-        "handleEvent@chrome://browser/content/tabbrowser.xml",
-      ],
-      times: 2, // This number should only ever go down - never up.
-    }
+    [
+      "rect@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
+
+    [
+      "verticalMargins@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
+
+    [
+      "verticalMargins@chrome://browser/content/browser-tabsintitlebar.js",
+      "_update@chrome://browser/content/browser-tabsintitlebar.js",
+      "updateAppearance@chrome://browser/content/browser-tabsintitlebar.js",
+      "handleEvent@chrome://browser/content/tabbrowser.xml",
+    ],
   );
 }
 
 /*
  * This test ensures that there are no unexpected
  * uninterruptible reflows when opening new windows.
  */
 add_task(async function() {
--- a/browser/base/content/test/performance/head.js
+++ b/browser/base/content/test/performance/head.js
@@ -1,82 +1,94 @@
 /**
  * Async utility function for ensuring that no unexpected uninterruptible
  * reflows occur during some period of time in a window.
  *
+ * The helper works by running a JS function before each event is
+ * dispatched that attempts to dirty the layout tree - the idea being
+ * that this puts us in the "worst case scenario" so that any JS
+ * that attempts to query for layout or style information will cause
+ * a reflow to fire. We also dirty the layout tree after each reflow
+ * occurs, for good measure.
+ *
+ * This sounds good in theory, but it's trickier in practice due to
+ * various optimizations in our Layout engine. The default function
+ * for dirtying the layout tree adds a margin to the first element
+ * child it finds in the window to a maximum of 3px, and then goes
+ * back to 0px again and loops.
+ *
+ * This is not sufficient for reflows that we expect to happen within
+ * scrollable frames, as Gecko is able to side-step reflowing the
+ * contents of a scrollable frame if outer frames are dirtied. Because
+ * of this, it's currently possible to override the default node to
+ * dirty with one more appropriate for the test.
+ *
+ * It is also theoretically possible for enough events to fire between
+ * reflows such that the before and after state of the layout tree is
+ * exactly the same, meaning that no reflow is required, which opens
+ * us up to missing expected reflows. This seems to be possible in
+ * theory, but hasn't yet shown up in practice - it's just something
+ * to be aware of.
+ *
+ * Bug 1363361 has been filed for a more reliable way of dirtying layout.
+ *
  * @param testFn (async function)
  *        The async function that will exercise the browser activity that is
  *        being tested for reflows.
- *
- *        The testFn will be passed a single argument, which is a frame dirtying
- *        function that can be called if the test needs to trigger frame
- *        dirtying outside of the normal mechanism.
- * @param expectedReflows (Array, optional)
- *        An Array of Objects representing reflows.
+ * @param expectedStacks (Array, optional)
+ *        An Array of Arrays representing stacks.
  *
  *        Example:
  *
  *        [
- *          {
- *            // This reflow is caused by lorem ipsum
- *            stack: [
- *              "select@chrome://global/content/bindings/textbox.xml",
- *              "focusAndSelectUrlBar@chrome://browser/content/browser.js",
- *              "openLinkIn@chrome://browser/content/utilityOverlay.js",
- *              "openUILinkIn@chrome://browser/content/utilityOverlay.js",
- *              "BrowserOpenTab@chrome://browser/content/browser.js",
- *            ],
- *            // We expect this particular reflow to happen 2 times
- *            times: 2,
- *          },
+ *          // This reflow is caused by lorem ipsum
+ *          [
+ *            "select@chrome://global/content/bindings/textbox.xml",
+ *            "focusAndSelectUrlBar@chrome://browser/content/browser.js",
+ *            "openLinkIn@chrome://browser/content/utilityOverlay.js",
+ *            "openUILinkIn@chrome://browser/content/utilityOverlay.js",
+ *            "BrowserOpenTab@chrome://browser/content/browser.js",
+ *          ],
  *
- *          {
- *            // This reflow is caused by lorem ipsum. We expect this reflow
- *            // to only happen once, so we can omit the "times" property.
- *            stack: [
- *              "get_scrollPosition@chrome://global/content/bindings/scrollbox.xml",
- *              "_fillTrailingGap@chrome://browser/content/tabbrowser.xml",
- *              "_handleNewTab@chrome://browser/content/tabbrowser.xml",
- *              "onxbltransitionend@chrome://browser/content/tabbrowser.xml",
- *            ],
- *          }
+ *          // This reflow is caused by lorem ipsum
+ *          [
+ *            "get_scrollPosition@chrome://global/content/bindings/scrollbox.xml",
+ *            "_fillTrailingGap@chrome://browser/content/tabbrowser.xml",
+ *            "_handleNewTab@chrome://browser/content/tabbrowser.xml",
+ *            "onxbltransitionend@chrome://browser/content/tabbrowser.xml",
+ *          ],
  *
  *        ]
  *
  *        Note that line numbers are not included in the stacks.
  *
  *        Order of the reflows doesn't matter. Expected reflows that aren't seen
  *        will cause an assertion failure. When this argument is not passed,
  *        it defaults to the empty Array, meaning no reflows are expected.
  * @param window (browser window, optional)
  *        The browser window to monitor. Defaults to the current window.
  */
-async function withReflowObserver(testFn, expectedReflows = [], win = window) {
+async function withReflowObserver(testFn, expectedStacks = [], win = window) {
   let dwu = win.QueryInterface(Ci.nsIInterfaceRequestor)
                .getInterface(Ci.nsIDOMWindowUtils);
   let dirtyFrameFn = () => {
     try {
       dwu.ensureDirtyRootFrame();
     } catch (e) {
       // If this fails, we should probably make note of it, but it's not fatal.
       info("Note: ensureDirtyRootFrame threw an exception.");
     }
   };
 
   let els = Cc["@mozilla.org/eventlistenerservice;1"]
               .getService(Ci.nsIEventListenerService);
 
-  // We're going to remove the reflows one by one as we see them so that
+  // We're going to remove the stacks one by one as we see them so that
   // we can check for expected, unseen reflows, so let's clone the array.
-  // While we're at it, for reflows that omit the "times" property, default
-  // it to 1.
-  expectedReflows = expectedReflows.slice(0);
-  expectedReflows.forEach(r => {
-    r.times = r.times || 1;
-  });
+  expectedStacks = expectedStacks.slice(0);
 
   let observer = {
     reflow(start, end) {
       // Gather information about the current code path, slicing out the current
       // frame.
       let path = (new Error().stack).split("\n").slice(1).map(line => {
         return line.replace(/:\d+:\d+$/, "");
       }).join("|");
@@ -87,24 +99,22 @@ async function withReflowObserver(testFn
       dirtyFrameFn();
 
       // Stack trace is empty. Reflow was triggered by native code, which
       // we ignore.
       if (path === "") {
         return;
       }
 
-      let index = expectedReflows.findIndex(reflow => path.startsWith(reflow.stack.join("|")));
+      let index = expectedStacks.findIndex(stack => path.startsWith(stack.join("|")));
 
       if (index != -1) {
         Assert.ok(true, "expected uninterruptible reflow: '" +
                   JSON.stringify(pathWithLineNumbers, null, "\t") + "'");
-        if (--expectedReflows[index].times == 0) {
-          expectedReflows.splice(index, 1);
-        }
+        expectedStacks.splice(index, 1);
       } else {
         Assert.ok(false, "unexpected uninterruptible reflow \n" +
                          JSON.stringify(pathWithLineNumbers, null, "\t") + "\n");
       }
     },
 
     reflowInterruptible(start, end) {
       // We're not interested in interruptible reflows, but might as well take the
@@ -120,26 +130,26 @@ async function withReflowObserver(testFn
                     .getInterface(Ci.nsIWebNavigation)
                     .QueryInterface(Ci.nsIDocShell);
   docShell.addWeakReflowObserver(observer);
 
   els.addListenerForAllEvents(win, dirtyFrameFn, true);
 
   try {
     dirtyFrameFn();
-    await testFn(dirtyFrameFn);
+    await testFn();
   } finally {
-    for (let remainder of expectedReflows) {
+    for (let remainder of expectedStacks) {
       Assert.ok(false,
-                `Unused expected reflow: ${JSON.stringify(remainder.stack, null, "\t")}\n` +
-                `This reflow was supposed to be hit ${remainder.times} more time(s).\n` +
+                `Unused expected reflow: ${JSON.stringify(remainder, null, "\t")}.\n` +
                 "This is probably a good thing - just remove it from the " +
                 "expected list.");
     }
 
+
     els.removeListenerForAllEvents(win, dirtyFrameFn, true);
     docShell.removeWeakReflowObserver(observer);
   }
 }
 
 async function ensureNoPreloadedBrowser() {
   // If we've got a preloaded browser, get rid of it so that it
   // doesn't interfere with the test if it's loading. We have to
--- a/browser/components/customizableui/test/browser_1008559_anchor_undo_restore.js
+++ b/browser/components/customizableui/test/browser_1008559_anchor_undo_restore.js
@@ -12,19 +12,17 @@ const kAnchorAttribute = "cui-anchorid";
 add_task(async function() {
   await SpecialPowers.pushPrefEnv({set: [["browser.photon.structure.enabled", false]]});
   await startCustomizing();
   let button = document.getElementById("history-panelmenu");
   is(button.getAttribute(kAnchorAttribute), "PanelUI-menu-button",
      "Button (" + button.id + ") starts out with correct anchor");
 
   let navbar = document.getElementById("nav-bar").customizationTarget;
-  let onMouseUp = BrowserTestUtils.waitForEvent(navbar, "mouseup");
   simulateItemDrag(button, navbar);
-  await onMouseUp;
   is(CustomizableUI.getPlacementOfWidget(button.id).area, "nav-bar",
      "Button (" + button.id + ") ends up in nav-bar");
 
   ok(!button.hasAttribute(kAnchorAttribute),
      "Button (" + button.id + ") has no anchor in toolbar");
 
   let resetButton = document.getElementById("customization-reset-button");
   ok(!resetButton.hasAttribute("disabled"), "Should be able to reset now.");
@@ -52,19 +50,17 @@ add_task(async function() {
  */
 add_task(async function() {
   await startCustomizing();
   let button = document.getElementById("bookmarks-menu-button");
   ok(!button.hasAttribute(kAnchorAttribute),
      "Button (" + button.id + ") has no anchor in toolbar");
 
   let panel = document.getElementById("PanelUI-contents");
-  let onMouseUp = BrowserTestUtils.waitForEvent(panel, "mouseup");
   simulateItemDrag(button, panel);
-  await onMouseUp;
   is(CustomizableUI.getPlacementOfWidget(button.id).area, "PanelUI-contents",
      "Button (" + button.id + ") ends up in panel");
   is(button.getAttribute(kAnchorAttribute), "PanelUI-menu-button",
      "Button (" + button.id + ") has correct anchor in the panel");
 
   let resetButton = document.getElementById("customization-reset-button");
   ok(!resetButton.hasAttribute("disabled"), "Should be able to reset now.");
   await gCustomizeMode.reset();
--- a/devtools/client/framework/test/browser_toolbox_races.js
+++ b/devtools/client/framework/test/browser_toolbox_races.js
@@ -6,17 +6,16 @@
 "use strict";
 
 // Toggling the toolbox three time can take more than 45s on slow test machine
 requestLongerTimeout(2);
 
 // Test toggling the toolbox quickly and see if there is any race breaking it.
 
 const URL = "data:text/html;charset=utf-8,Toggling devtools quickly";
-const {gDevToolsBrowser} = require("devtools/client/framework/devtools-browser");
 
 add_task(function* () {
   // Make sure this test starts with the selectedTool pref cleared. Previous
   // tests select various tools, and that sets this pref.
   Services.prefs.clearUserPref("devtools.toolbox.selectedTool");
 
   let tab = yield addTab(URL);
 
@@ -76,15 +75,10 @@ add_task(function* () {
   gDevTools.off("toolbox-ready", onReady);
   gDevTools.off("toolbox-destroy", onDestroy);
   gDevTools.off("toolbox-destroyed", onDestroyed);
 
   gBrowser.removeCurrentTab();
 });
 
 function toggle() {
-  // When enabling the input event prioritization, we'll reserve some time to
-  // process input events in each frame. In that case, the synthesized input
-  // events may delay the normal events. Replace synthesized key events by
-  // toggleToolboxCommand to prevent the synthesized input events jam the
-  // content process and cause the test timeout.
-  gDevToolsBrowser.toggleToolboxCommand(window.gBrowser);
+  EventUtils.synthesizeKey("VK_F12", {});
 }
--- a/devtools/client/inspector/test/browser_inspector_highlighter-eyedropper-events.js
+++ b/devtools/client/inspector/test/browser_inspector_highlighter-eyedropper-events.js
@@ -108,34 +108,34 @@ function* respondsToMoveEvents(helper, t
     } else {
       info(`Simulating ${type} event: ${desc}`);
     }
 
     if (type === "mouse") {
       yield mouse.move(x, y);
     } else if (type === "keyboard") {
       let options = shift ? {shiftKey: true} : {};
-      yield EventUtils.synthesizeAndWaitKey(key, options);
+      yield EventUtils.synthesizeKey(key, options);
     }
     yield checkPosition(expected, helper);
   }
 }
 
 function* checkPosition({x, y}, {getElementAttribute}) {
   let style = yield getElementAttribute("root", "style");
   is(style, `top:${y}px;left:${x}px;`,
      `The eyedropper is at the expected ${x} ${y} position`);
 }
 
 function* respondsToReturnAndEscape({isElementHidden, show}) {
   info("Simulating return to select the color and hide the eyedropper");
 
-  yield EventUtils.synthesizeAndWaitKey("VK_RETURN", {});
+  yield EventUtils.synthesizeKey("VK_RETURN", {});
   let hidden = yield isElementHidden("root");
   ok(hidden, "The eyedropper has been hidden");
 
   info("Showing the eyedropper again and simulating escape to hide it");
 
   yield show("html");
-  yield EventUtils.synthesizeAndWaitKey("VK_ESCAPE", {});
+  yield EventUtils.synthesizeKey("VK_ESCAPE", {});
   hidden = yield isElementHidden("root");
   ok(hidden, "The eyedropper has been hidden again");
 }
--- a/dom/base/TabGroup.h
+++ b/dom/base/TabGroup.h
@@ -2,17 +2,16 @@
 /* vim: set ts=8 sts=2 et sw=2 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/. */
 
 #ifndef TabGroup_h
 #define TabGroup_h
 
-#include "nsHashKeys.h"
 #include "nsISupportsImpl.h"
 #include "nsIPrincipal.h"
 #include "nsTHashtable.h"
 #include "nsString.h"
 
 #include "mozilla/Atomics.h"
 #include "mozilla/SchedulerGroup.h"
 #include "mozilla/RefPtr.h"
@@ -39,17 +38,16 @@ class TabChild;
 // A TabGroup is a set of browsing contexts which are all "related". Within a
 // TabGroup, browsing contexts are broken into "similar-origin" DocGroups. In
 // more detail, a DocGroup is actually a collection of documents, and a
 // TabGroup is a collection of DocGroups. A TabGroup typically will contain
 // (through its DocGroups) the documents from one or more tabs related by
 // window.opener. A DocGroup is a member of exactly one TabGroup.
 
 class DocGroup;
-class TabChild;
 
 class TabGroup final : public SchedulerGroup
 {
 private:
   class HashEntry : public nsCStringHashKey
   {
   public:
     // NOTE: Weak reference. The DocGroup destructor removes itself from its
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -170,40 +170,16 @@ private:
     return item;
   }
 
   static LinkedList<OldWindowSize> sList;
   nsWeakPtr mWindowRef;
   nsSize mSize;
 };
 
-namespace {
-
-class NativeInputRunnable final : public PrioritizableRunnable
-{
-  explicit NativeInputRunnable(already_AddRefed<nsIRunnable>&& aEvent);
-  ~NativeInputRunnable() {}
-public:
-  static already_AddRefed<nsIRunnable> Create(already_AddRefed<nsIRunnable>&& aEvent);
-};
-
-NativeInputRunnable::NativeInputRunnable(already_AddRefed<nsIRunnable>&& aEvent)
-  : PrioritizableRunnable(Move(aEvent), nsIRunnablePriority::PRIORITY_INPUT)
-{
-}
-
-/* static */ already_AddRefed<nsIRunnable>
-NativeInputRunnable::Create(already_AddRefed<nsIRunnable>&& aEvent)
-{
-  nsCOMPtr<nsIRunnable> event(new NativeInputRunnable(Move(aEvent)));
-  return event.forget();
-}
-
-} // unnamed namespace
-
 LinkedList<OldWindowSize> OldWindowSize::sList;
 
 NS_INTERFACE_MAP_BEGIN(nsDOMWindowUtils)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMWindowUtils)
   NS_INTERFACE_MAP_ENTRY(nsIDOMWindowUtils)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 NS_INTERFACE_MAP_END
 
@@ -1139,77 +1115,76 @@ nsDOMWindowUtils::SendNativeKeyEvent(int
                                      const nsAString& aUnmodifiedCharacters,
                                      nsIObserver* aObserver)
 {
   // get the widget to send the event to
   nsCOMPtr<nsIWidget> widget = GetWidget();
   if (!widget)
     return NS_ERROR_FAILURE;
 
-  NS_DispatchToMainThread(NativeInputRunnable::Create(
+  NS_DispatchToMainThread(
     NewRunnableMethod<int32_t,
                       int32_t,
                       uint32_t,
                       nsString,
                       nsString,
                       nsIObserver*>("nsIWidget::SynthesizeNativeKeyEvent",
                                     widget,
                                     &nsIWidget::SynthesizeNativeKeyEvent,
                                     aNativeKeyboardLayout,
                                     aNativeKeyCode,
                                     aModifiers,
                                     aCharacters,
                                     aUnmodifiedCharacters,
-                                    aObserver)));
+                                    aObserver));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::SendNativeMouseEvent(int32_t aScreenX,
                                        int32_t aScreenY,
                                        int32_t aNativeMessage,
                                        int32_t aModifierFlags,
                                        nsIDOMElement* aElement,
                                        nsIObserver* aObserver)
 {
   // get the widget to send the event to
   nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
   if (!widget)
     return NS_ERROR_FAILURE;
 
-  NS_DispatchToMainThread(NativeInputRunnable::Create(
+  NS_DispatchToMainThread(
     NewRunnableMethod<LayoutDeviceIntPoint, int32_t, int32_t, nsIObserver*>(
       "nsIWidget::SynthesizeNativeMouseEvent",
       widget,
       &nsIWidget::SynthesizeNativeMouseEvent,
       LayoutDeviceIntPoint(aScreenX, aScreenY),
       aNativeMessage,
       aModifierFlags,
-      aObserver)));
+      aObserver));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::SendNativeMouseMove(int32_t aScreenX,
                                       int32_t aScreenY,
                                       nsIDOMElement* aElement,
                                       nsIObserver* aObserver)
 {
   // get the widget to send the event to
   nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
   if (!widget)
     return NS_ERROR_FAILURE;
 
-  NS_DispatchToMainThread(NativeInputRunnable::Create(
-    NewRunnableMethod<LayoutDeviceIntPoint, nsIObserver*>(
-      "nsIWidget::SynthesizeNativeMouseMove",
-      widget,
-      &nsIWidget::SynthesizeNativeMouseMove,
-      LayoutDeviceIntPoint(aScreenX, aScreenY),
-      aObserver)));
+  NS_DispatchToMainThread(NewRunnableMethod<LayoutDeviceIntPoint, nsIObserver*>(
+    "nsIWidget::SynthesizeNativeMouseMove",
+    widget,
+    &nsIWidget::SynthesizeNativeMouseMove,
+    LayoutDeviceIntPoint(aScreenX, aScreenY),
+    aObserver));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::SendNativeMouseScrollEvent(int32_t aScreenX,
                                              int32_t aScreenY,
                                              uint32_t aNativeMessage,
                                              double aDeltaX,
@@ -1221,36 +1196,35 @@ nsDOMWindowUtils::SendNativeMouseScrollE
                                              nsIObserver* aObserver)
 {
   // get the widget to send the event to
   nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
   if (!widget) {
     return NS_ERROR_FAILURE;
   }
 
-  NS_DispatchToMainThread(NativeInputRunnable::Create(
-    NewRunnableMethod<mozilla::LayoutDeviceIntPoint,
-                      uint32_t,
-                      double,
-                      double,
-                      double,
-                      uint32_t,
-                      uint32_t,
-                      nsIObserver*>(
-      "nsIWidget::SynthesizeNativeMouseScrollEvent",
-      widget,
-      &nsIWidget::SynthesizeNativeMouseScrollEvent,
-      LayoutDeviceIntPoint(aScreenX, aScreenY),
-      aNativeMessage,
-      aDeltaX,
-      aDeltaY,
-      aDeltaZ,
-      aModifierFlags,
-      aAdditionalFlags,
-      aObserver)));
+  NS_DispatchToMainThread(NewRunnableMethod<mozilla::LayoutDeviceIntPoint,
+                                            uint32_t,
+                                            double,
+                                            double,
+                                            double,
+                                            uint32_t,
+                                            uint32_t,
+                                            nsIObserver*>(
+    "nsIWidget::SynthesizeNativeMouseScrollEvent",
+    widget,
+    &nsIWidget::SynthesizeNativeMouseScrollEvent,
+    LayoutDeviceIntPoint(aScreenX, aScreenY),
+    aNativeMessage,
+    aDeltaX,
+    aDeltaY,
+    aDeltaZ,
+    aModifierFlags,
+    aAdditionalFlags,
+    aObserver));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::SendNativeTouchPoint(uint32_t aPointerId,
                                        uint32_t aTouchState,
                                        int32_t aScreenX,
                                        int32_t aScreenY,
@@ -1262,53 +1236,53 @@ nsDOMWindowUtils::SendNativeTouchPoint(u
   if (!widget) {
     return NS_ERROR_FAILURE;
   }
 
   if (aPressure < 0 || aPressure > 1 || aOrientation > 359) {
     return NS_ERROR_INVALID_ARG;
   }
 
-  NS_DispatchToMainThread(NativeInputRunnable::Create(
+  NS_DispatchToMainThread(
     NewRunnableMethod<uint32_t,
                       nsIWidget::TouchPointerState,
                       LayoutDeviceIntPoint,
                       double,
                       uint32_t,
                       nsIObserver*>("nsIWidget::SynthesizeNativeTouchPoint",
                                     widget,
                                     &nsIWidget::SynthesizeNativeTouchPoint,
                                     aPointerId,
                                     (nsIWidget::TouchPointerState)aTouchState,
                                     LayoutDeviceIntPoint(aScreenX, aScreenY),
                                     aPressure,
                                     aOrientation,
-                                    aObserver)));
+                                    aObserver));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::SendNativeTouchTap(int32_t aScreenX,
                                      int32_t aScreenY,
                                      bool aLongTap,
                                      nsIObserver* aObserver)
 {
   nsCOMPtr<nsIWidget> widget = GetWidget();
   if (!widget) {
     return NS_ERROR_FAILURE;
   }
 
-  NS_DispatchToMainThread(NativeInputRunnable::Create(
+  NS_DispatchToMainThread(
     NewRunnableMethod<LayoutDeviceIntPoint, bool, nsIObserver*>(
       "nsIWidget::SynthesizeNativeTouchTap",
       widget,
       &nsIWidget::SynthesizeNativeTouchTap,
       LayoutDeviceIntPoint(aScreenX, aScreenY),
       aLongTap,
-      aObserver)));
+      aObserver));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::SuppressAnimation(bool aSuppress)
 {
   nsIWidget* widget = GetWidget();
   if (widget) {
@@ -1320,21 +1294,21 @@ nsDOMWindowUtils::SuppressAnimation(bool
 NS_IMETHODIMP
 nsDOMWindowUtils::ClearNativeTouchSequence(nsIObserver* aObserver)
 {
   nsCOMPtr<nsIWidget> widget = GetWidget();
   if (!widget) {
     return NS_ERROR_FAILURE;
   }
 
-  NS_DispatchToMainThread(NativeInputRunnable::Create(
+  NS_DispatchToMainThread(
     NewRunnableMethod<nsIObserver*>("nsIWidget::ClearNativeTouchSequence",
                                     widget,
                                     &nsIWidget::ClearNativeTouchSequence,
-                                    aObserver)));
+                                    aObserver));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::ActivateNativeMenuItemAt(const nsAString& indexString)
 {
   // get the widget to send the event to
   nsCOMPtr<nsIWidget> widget = GetWidget();
--- a/dom/base/nsFrameMessageManager.cpp
+++ b/dom/base/nsFrameMessageManager.cpp
@@ -845,23 +845,16 @@ nsFrameMessageManager::GetContent(mozIDO
 NS_IMETHODIMP
 nsFrameMessageManager::GetDocShell(nsIDocShell** aDocShell)
 {
   *aDocShell = nullptr;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFrameMessageManager::GetTabEventTarget(nsIEventTarget** aTarget)
-{
-  *aTarget = nullptr;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
 nsFrameMessageManager::Btoa(const nsAString& aBinaryData,
                             nsAString& aAsciiBase64String)
 {
   return nsContentUtils::Btoa(aBinaryData, aAsciiBase64String);
 }
 
 NS_IMETHODIMP
 nsFrameMessageManager::Atob(const nsAString& aAsciiString,
--- a/dom/base/nsIMessageManager.idl
+++ b/dom/base/nsIMessageManager.idl
@@ -3,17 +3,16 @@
  * 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/. */
 
 #include "nsISupports.idl"
 
 interface mozIDOMWindowProxy;
 interface nsIDocShell;
 interface nsIContent;
-interface nsIEventTarget;
 interface nsIFrameLoader;
 interface nsIPrincipal;
 
 /**
  * Message managers provide a way for chrome-privileged JS code to
  * communicate with each other, even across process boundaries.
  *
  * Message managers are separated into "parent side" and "child side".
@@ -394,22 +393,16 @@ interface nsIContentFrameMessageManager 
    * The current top level window in the frame or null.
    */
   readonly attribute mozIDOMWindowProxy content;
 
   /**
    * The top level docshell or null.
    */
   readonly attribute nsIDocShell docShell;
-
-  /**
-   * Returns the SchedulerEventTarget corresponding to the TabGroup
-   * for this frame.
-   */
-  readonly attribute nsIEventTarget tabEventTarget;
 };
 
 [uuid(b39a3324-b574-4f85-8cdb-274d04f807ef)]
 interface nsIInProcessContentFrameMessageManager : nsIContentFrameMessageManager
 {
   [notxpcom] nsIContent getOwnerContent();
   [notxpcom] void cacheFrameLoader(in nsIFrameLoader aFrameLoader);
 };
--- a/dom/base/nsInProcessTabChildGlobal.cpp
+++ b/dom/base/nsInProcessTabChildGlobal.cpp
@@ -194,24 +194,16 @@ nsInProcessTabChildGlobal::GetContent(mo
 
 NS_IMETHODIMP
 nsInProcessTabChildGlobal::GetDocShell(nsIDocShell** aDocShell)
 {
   NS_IF_ADDREF(*aDocShell = mDocShell);
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsInProcessTabChildGlobal::GetTabEventTarget(nsIEventTarget** aTarget)
-{
-  nsCOMPtr<nsIEventTarget> target = GetMainThreadEventTarget();
-  target.forget(aTarget);
-  return NS_OK;
-}
-
 void
 nsInProcessTabChildGlobal::FireUnloadEvent()
 {
   // We're called from nsDocument::MaybeInitializeFinalizeFrameLoaders, so it
   // should be safe to run script.
   MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
 
   // Don't let the unload event propagate to chrome event handlers.
--- a/dom/base/nsInProcessTabChildGlobal.h
+++ b/dom/base/nsInProcessTabChildGlobal.h
@@ -72,17 +72,16 @@ public:
   {
     return mMessageManager
       ? mMessageManager->SendRpcMessage(aMessageName, aObject, aRemote,
                                         aPrincipal, aCx, aArgc, aRetval)
       : NS_ERROR_NULL_POINTER;
   }
   NS_IMETHOD GetContent(mozIDOMWindowProxy** aContent) override;
   NS_IMETHOD GetDocShell(nsIDocShell** aDocShell) override;
-  NS_IMETHOD GetTabEventTarget(nsIEventTarget** aTarget) override;
 
   NS_DECL_NSIINPROCESSCONTENTFRAMEMESSAGEMANAGER
 
   /**
    * MessageManagerCallback methods that we override.
    */
   virtual bool DoSendBlockingMessage(JSContext* aCx,
                                       const nsAString& aMessage,
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -2862,42 +2862,23 @@ NodeAllowsClickThrough(nsINode* aNode)
     aNode = nsContentUtils::GetCrossDocParentNode(aNode);
   }
   return true;
 }
 #endif
 
 void
 EventStateManager::PostHandleKeyboardEvent(WidgetKeyboardEvent* aKeyboardEvent,
-                                           nsIFrame* aTargetFrame,
                                            nsEventStatus& aStatus)
 {
   if (aStatus == nsEventStatus_eConsumeNoDefault) {
     return;
   }
 
   if (!aKeyboardEvent->HasBeenPostedToRemoteProcess()) {
-    if (aKeyboardEvent->IsWaitingReplyFromRemoteProcess()) {
-      RefPtr<TabParent> remote = aTargetFrame ?
-        TabParent::GetFrom(aTargetFrame->GetContent()) : nullptr;
-      if (remote && !remote->IsReadyToHandleInputEvents()) {
-        // We need to dispatch the event to the browser element again if we were
-        // waiting for the key reply but the event wasn't sent to the content
-        // process due to the remote browser wasn't ready.
-        WidgetKeyboardEvent keyEvent(*aKeyboardEvent);
-        aKeyboardEvent->MarkAsHandledInRemoteProcess();
-        EventDispatcher::Dispatch(remote->GetOwnerElement(), mPresContext,
-                                  &keyEvent);
-        if (keyEvent.DefaultPrevented()) {
-          aKeyboardEvent->PreventDefault(!keyEvent.DefaultPreventedByContent());
-          aStatus = nsEventStatus_eConsumeNoDefault;
-          return;
-        }
-      }
-    }
     // The widget expects a reply for every keyboard event. If the event wasn't
     // dispatched to a content process (non-e10s or no content process
     // running), we need to short-circuit here. Otherwise, we need to wait for
     // the content process to handle the event.
     aKeyboardEvent->mWidget->PostHandleKeyEvent(aKeyboardEvent);
     if (aKeyboardEvent->DefaultPrevented()) {
       aStatus = nsEventStatus_eConsumeNoDefault;
       return;
@@ -3539,17 +3520,17 @@ EventStateManager::PostHandleEvent(nsPre
     break;
 
   case eKeyUp:
     break;
 
   case eKeyPress:
     {
       WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
-      PostHandleKeyboardEvent(keyEvent, mCurrentTarget, *aStatus);
+      PostHandleKeyboardEvent(keyEvent, *aStatus);
     }
     break;
 
   case eMouseEnterIntoWidget:
     if (mCurrentTarget) {
       nsCOMPtr<nsIContent> targetContent;
       mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent));
       SetContentState(targetContent, NS_EVENT_STATE_HOVER);
--- a/dom/events/EventStateManager.h
+++ b/dom/events/EventStateManager.h
@@ -104,17 +104,17 @@ public:
    * DOM and frame processing.
    */
   nsresult PostHandleEvent(nsPresContext* aPresContext,
                            WidgetEvent* aEvent,
                            nsIFrame* aTargetFrame,
                            nsEventStatus* aStatus);
 
   void PostHandleKeyboardEvent(WidgetKeyboardEvent* aKeyboardEvent,
-                               nsIFrame* aTargetFrame, nsEventStatus& aStatus);
+                               nsEventStatus& aStatus);
 
   /**
    * DispatchLegacyMouseScrollEvents() dispatches eLegacyMouseLineOrPageScroll
    * event and eLegacyMousePixelScroll event for compatibility with old Gecko.
    */
   void DispatchLegacyMouseScrollEvents(nsIFrame* aTargetFrame,
                                        WidgetWheelEvent* aEvent,
                                        nsEventStatus* aStatus);
--- a/dom/events/test/window_wheel_default_action.html
+++ b/dom/events/test/window_wheel_default_action.html
@@ -1136,61 +1136,37 @@ function doTestZoom(aSettings, aCallback
     event.ctrlKey  = true;
 
     // NOTE: Zooming might change scrollTop and scrollLeft by rounding fraction.
     //       This test assume that zoom happens synchronously and scrolling
     //       happens asynchronously.
     var scrollTop = gScrollableElement.scrollTop;
     var scrollLeft = gScrollableElement.scrollLeft;
 
-    fullZoomChangePromise = new Promise(resolve => {
-      if (currentTest.expected & (kNegative | kPositive)) {
-        SpecialPowers.addChromeEventListener("FullZoomChange", function onFullZoomChange() {
-          if (SpecialPowers.getFullZoom(window) != 1) {
-            SpecialPowers.removeChromeEventListener("FullZoomChange", onFullZoomChange)
-            setTimeout(() => resolve(), 0);
-          }
-        });
-      } else {
-        resolve();
-      }
-    });
-
     sendWheelAndWait(10, 10, event, function () {
       is(gScrollableElement.scrollTop, scrollTop, description + "scrolled vertical");
       is(gScrollableElement.scrollLeft, scrollLeft, description + "scrolled horizontal");
-
-      fullZoomChangePromise.then(() => {
-        // When input event prioritization is enabled, the wheel event may be
-        // dispatched to the content process before the message 'FullZoom' to
-        // zoom in/out. Waiting for the event 'FullZoomChange' and then check
-        // the result.
-        if (!(currentTest.expected & (kNegative | kPositive))) {
-          is(SpecialPowers.getFullZoom(window), 1.0, description + "zoomed");
+      if (!(currentTest.expected & (kNegative | kPositive))) {
+        is(SpecialPowers.getFullZoom(window), 1.0, description + "zoomed");
+      } else {
+        var isReverted = (currentTest.expected & kUseX) ? isXReverted :
+                         (currentTest.expected & kUseY) ? isYReverted : false;
+        if ((!isReverted && (currentTest.expected & kNegative)) ||
+            (isReverted && (currentTest.expected & kPositive))) {
+          ok(SpecialPowers.getFullZoom(window) > 1.0,
+             description + "not zoomed in, got " + SpecialPowers.getFullZoom(window));
         } else {
-          var isReverted = (currentTest.expected & kUseX) ? isXReverted :
-                           (currentTest.expected & kUseY) ? isYReverted : false;
-          if ((!isReverted && (currentTest.expected & kNegative)) ||
-              (isReverted && (currentTest.expected & kPositive))) {
-            ok(SpecialPowers.getFullZoom(window) > 1.0,
-               description + "not zoomed in, got " + SpecialPowers.getFullZoom(window));
-          } else {
-            ok(SpecialPowers.getFullZoom(window) < 1.0,
-               description + "not zoomed out, got " + SpecialPowers.getFullZoom(window));
-          }
+          ok(SpecialPowers.getFullZoom(window) < 1.0,
+             description + "not zoomed out, got " + SpecialPowers.getFullZoom(window));
         }
-        if (SpecialPowers.getFullZoom(window) != 1) {
-          // Only synthesizes key event to reset zoom when necessary to avoid
-          // triggering the next test before the key event is handled. In that
-          // case, the key event may break the next test.
-          synthesizeKey("0", { accelKey: true });
-        }
-        onZoomReset(function () {
-          hitEventLoop(doNextTest, 20);
-        });
+      }
+
+      synthesizeKey("0", { accelKey: true });
+      onZoomReset(function () {
+        hitEventLoop(doNextTest, 20);
       });
     });
   }
   doNextTest();
 }
 
 function doTestZoomedScroll(aCallback)
 {
--- a/dom/html/test/test_bug1261673.html
+++ b/dom/html/test/test_bug1261673.html
@@ -3,17 +3,16 @@
 <!--
 https://bugzilla.mozilla.org/show_bug.cgi?id=1261673
 -->
 <head>
   <meta charset="utf-8">
   <title>Test for Bug 1261673</title>
   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <script type="text/javascript" src="/tests/SimpleTest/EventUtils.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/paint_listener.js"></script>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
 </head>
 <body>
 <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1261673">Mozilla Bug 1261673</a>
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <input id="test_number" type="number" value=5>
@@ -50,23 +49,29 @@ function runTests() {
     ++numberChange;
   });
 
   function runNext() {
     let p = params[testIdx];
     (p["focus"]) ? input.focus() : input.blur();
     expectChange = p["valueChanged"] == 0 ? expectChange : expectChange + 1;
     result += parseInt(p["valueChanged"]);
-    sendWheelAndPaint(input, 1, 1, { deltaY: p["deltaY"], deltaMode: p["deltaMode"] }, () => {
+    synthesizeWheel(input, 1, 1, { deltaY: p["deltaY"], deltaMode: p["deltaMode"] });
+    window.postMessage("finished", "http://mochi.test:8888");
+    testIdx++;
+  }
+
+  window.addEventListener("message", event => {
+    if (event.data == "finished") {
       ok(input.value == result,
         "Handle wheel in number input test-" + testIdx + " expect " + result +
         " get " + input.value);
       ok(numberChange == expectChange,
          "UA should fire change event when input's value changed, expect " + expectChange + " get " + numberChange);
-      (++testIdx >= params.length) ? SimpleTest.finish() : runNext();
-    });
-  }
+      (testIdx >= params.length) ? SimpleTest.finish() : runNext();
+    }
+  });
   runNext();
 }
 
 </script>
 </body>
 </html>
--- a/dom/ipc/ContentBridgeParent.cpp
+++ b/dom/ipc/ContentBridgeParent.cpp
@@ -166,34 +166,16 @@ ContentBridgeParent::AllocPBrowserParent
 }
 
 bool
 ContentBridgeParent::DeallocPBrowserParent(PBrowserParent* aParent)
 {
   return nsIContentParent::DeallocPBrowserParent(aParent);
 }
 
-mozilla::ipc::IPCResult
-ContentBridgeParent::RecvPBrowserConstructor(PBrowserParent* actor,
-                                             const TabId& tabId,
-                                             const TabId& sameTabGroupAs,
-                                             const IPCTabContext& context,
-                                             const uint32_t& chromeFlags,
-                                             const ContentParentId& cpId,
-                                             const bool& isForBrowser)
-{
-  return nsIContentParent::RecvPBrowserConstructor(actor,
-                                                   tabId,
-                                                   sameTabGroupAs,
-                                                   context,
-                                                   chromeFlags,
-                                                   cpId,
-                                                   isForBrowser);
-}
-
 void
 ContentBridgeParent::NotifyTabDestroyed()
 {
   int32_t numLiveTabs = ManagedPBrowserParent().Count();
   if (numLiveTabs == 1) {
     MessageLoop::current()->PostTask(NewRunnableMethod(
       "dom::ContentBridgeParent::Close", this, &ContentBridgeParent::Close));
   }
--- a/dom/ipc/ContentBridgeParent.h
+++ b/dom/ipc/ContentBridgeParent.h
@@ -133,25 +133,16 @@ protected:
                       const TabId& aSameTabGroupAs,
                       const IPCTabContext &aContext,
                       const uint32_t& aChromeFlags,
                       const ContentParentId& aCpID,
                       const bool& aIsForBrowser) override;
 
   virtual bool DeallocPBrowserParent(PBrowserParent*) override;
 
-  virtual mozilla::ipc::IPCResult
-  RecvPBrowserConstructor(PBrowserParent* actor,
-                          const TabId& tabId,
-                          const TabId& sameTabGroupAs,
-                          const IPCTabContext& context,
-                          const uint32_t& chromeFlags,
-                          const ContentParentId& cpId,
-                          const bool& isForBrowser) override;
-
   virtual PIPCBlobInputStreamParent*
   SendPIPCBlobInputStreamConstructor(PIPCBlobInputStreamParent* aActor,
                                      const nsID& aID,
                                      const uint64_t& aSize) override;
 
   virtual PIPCBlobInputStreamParent*
   AllocPIPCBlobInputStreamParent(const nsID& aID,
                                  const uint64_t& aSize) override;
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -1171,19 +1171,16 @@ ContentChild::InitXPCOM(const XPCOMInitD
   nsLayoutStylesheetCache::SetUserContentCSSURL(ucsURL);
 
   // This will register cross-process observer.
   mozilla::dom::time::InitializeDateCacheCleaner();
 
   GfxInfoBase::SetFeatureStatus(aXPCOMInit.gfxFeatureStatus());
 
   DataStorage::SetCachedStorageEntries(aXPCOMInit.dataStorage());
-
-  // Enable input event prioritization.
-  nsThreadManager::get().EnableMainThreadEventPrioritization();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvRequestMemoryReport(const uint32_t& aGeneration,
                                       const bool& aAnonymize,
                                       const bool& aMinimizeMemoryUsage,
                                       const MaybeFileDesc& aDMDFile)
 {
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -2872,34 +2872,16 @@ ContentParent::AllocPBrowserParent(const
 }
 
 bool
 ContentParent::DeallocPBrowserParent(PBrowserParent* frame)
 {
   return nsIContentParent::DeallocPBrowserParent(frame);
 }
 
-mozilla::ipc::IPCResult
-ContentParent::RecvPBrowserConstructor(PBrowserParent* actor,
-                                       const TabId& tabId,
-                                       const TabId& sameTabGroupAs,
-                                       const IPCTabContext& context,
-                                       const uint32_t& chromeFlags,
-                                       const ContentParentId& cpId,
-                                       const bool& isForBrowser)
-{
-  return nsIContentParent::RecvPBrowserConstructor(actor,
-                                                   tabId,
-                                                   sameTabGroupAs,
-                                                   context,
-                                                   chromeFlags,
-                                                   cpId,
-                                                   isForBrowser);
-}
-
 PIPCBlobInputStreamParent*
 ContentParent::AllocPIPCBlobInputStreamParent(const nsID& aID,
                                               const uint64_t& aSize)
 {
   return nsIContentParent::AllocPIPCBlobInputStreamParent(aID, aSize);
 }
 
 bool
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -840,25 +840,16 @@ private:
                                               const TabId& aSameTabGroupAs,
                                               const IPCTabContext& aContext,
                                               const uint32_t& aChromeFlags,
                                               const ContentParentId& aCpId,
                                               const bool& aIsForBrowser) override;
 
   virtual bool DeallocPBrowserParent(PBrowserParent* frame) override;
 
-  virtual mozilla::ipc::IPCResult
-  RecvPBrowserConstructor(PBrowserParent* actor,
-                          const TabId& tabId,
-                          const TabId& sameTabGroupAs,
-                          const IPCTabContext& context,
-                          const uint32_t& chromeFlags,
-                          const ContentParentId& cpId,
-                          const bool& isForBrowser) override;
-
   virtual PIPCBlobInputStreamParent*
   SendPIPCBlobInputStreamConstructor(PIPCBlobInputStreamParent* aActor,
                                      const nsID& aID,
                                      const uint64_t& aSize) override;
 
   virtual PIPCBlobInputStreamParent*
   AllocPIPCBlobInputStreamParent(const nsID& aID,
                                  const uint64_t& aSize) override;
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -538,22 +538,16 @@ parent:
      * compositing.  This is sent when all pending changes have been
      * sent to the compositor and are ready to be shown on the next composite.
      * @see PCompositor
      * @see RequestNotifyAfterRemotePaint
      */
     async RemotePaintIsReady();
 
     /**
-     * Child informs the parent that the content is ready to handle input
-     * events. This is sent when the TabChild is created.
-     */
-    async RemoteIsReadyToHandleInputEvents();
-
-    /**
      * Child informs the parent that the layer tree is already available.
      */
     async ForcePaintNoOp(uint64_t aLayerObserverEpoch);
 
     /**
      * Sent by the child to the parent to inform it that an update to the
      * dimensions has been requested, likely through win.moveTo or resizeTo
      */
@@ -646,49 +640,39 @@ child:
                      int32_t aClickCount,
                      int32_t aModifiers,
                      bool aIgnoreRootScrollFrame);
 
     /**
      * When two consecutive mouse move events would be added to the message queue,
      * they are 'compressed' by dumping the oldest one.
      */
-    prio(input) async RealMouseMoveEvent(WidgetMouseEvent event,
-                                         ScrollableLayerGuid aGuid,
-                                         uint64_t aInputBlockId) compress;
+    async RealMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId) compress;
     /**
      * Mouse move events with |reason == eSynthesized| are sent via a separate
      * message because they do not generate DOM 'mousemove' events, and the
      * 'compress' attribute on RealMouseMoveEvent() could result in a
      * |reason == eReal| event being dropped in favour of an |eSynthesized|
      * event, and thus a DOM 'mousemove' event to be lost.
      */
-    prio(input) async SynthMouseMoveEvent(WidgetMouseEvent event,
-                                          ScrollableLayerGuid aGuid,
-                                          uint64_t aInputBlockId);
-    prio(input) async RealMouseButtonEvent(WidgetMouseEvent event,
-                                           ScrollableLayerGuid aGuid,
-                                           uint64_t aInputBlockId);
-    prio(input) async RealKeyEvent(WidgetKeyboardEvent event);
-    prio(input) async MouseWheelEvent(WidgetWheelEvent event,
-                                      ScrollableLayerGuid aGuid,
-                                      uint64_t aInputBlockId);
-    prio(input) async RealTouchEvent(WidgetTouchEvent aEvent,
-                                     ScrollableLayerGuid aGuid,
-                                     uint64_t aInputBlockId,
-                                     nsEventStatus aApzResponse);
-    prio(input) async HandleTap(TapType aType, LayoutDevicePoint point,
-                                Modifiers aModifiers, ScrollableLayerGuid aGuid,
-                                uint64_t aInputBlockId);
-    prio(input) async RealTouchMoveEvent(WidgetTouchEvent aEvent,
-                                         ScrollableLayerGuid aGuid,
-                                         uint64_t aInputBlockId,
-                                         nsEventStatus aApzResponse);
-    prio(input) async RealDragEvent(WidgetDragEvent aEvent,
-                                    uint32_t aDragAction, uint32_t aDropEffect);
+    async SynthMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+    async RealMouseButtonEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+    async RealKeyEvent(WidgetKeyboardEvent event);
+    async MouseWheelEvent(WidgetWheelEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+    async RealTouchEvent(WidgetTouchEvent aEvent,
+                         ScrollableLayerGuid aGuid,
+                         uint64_t aInputBlockId,
+                         nsEventStatus aApzResponse);
+    async HandleTap(TapType aType, LayoutDevicePoint point, Modifiers aModifiers,
+                    ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+    async RealTouchMoveEvent(WidgetTouchEvent aEvent,
+                             ScrollableLayerGuid aGuid,
+                             uint64_t aInputBlockId,
+                             nsEventStatus aApzResponse);
+    async RealDragEvent(WidgetDragEvent aEvent, uint32_t aDragAction, uint32_t aDropEffect);
     async PluginEvent(WidgetPluginEvent aEvent);
 
     /**
      * @see nsIDOMWindowUtils sendKeyEvent.
      */
     async KeyEvent(nsString aType,
                    int32_t aKeyCode,
                    int32_t aCharCode,
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -85,17 +85,16 @@
 #include "nsIWebBrowserFocus.h"
 #include "nsIWebBrowserSetup.h"
 #include "nsIWebProgress.h"
 #include "nsIXULRuntime.h"
 #include "nsPIDOMWindow.h"
 #include "nsPIWindowRoot.h"
 #include "nsLayoutUtils.h"
 #include "nsPrintfCString.h"
-#include "nsThreadManager.h"
 #include "nsThreadUtils.h"
 #include "nsViewManager.h"
 #include "nsWeakReference.h"
 #include "nsWindowWatcher.h"
 #include "PermissionMessageUtils.h"
 #include "PuppetWidget.h"
 #include "StructuredCloneData.h"
 #include "nsViewportInfo.h"
@@ -317,29 +316,17 @@ private:
         MOZ_ASSERT(!mTabChild);
     }
 
     NS_IMETHOD
     Run() override
     {
         MOZ_ASSERT(NS_IsMainThread());
         MOZ_ASSERT(mTabChild);
-        // When enabling input event prioritization, we reserve limited time
-        // to process input events. We may handle the rest in the next frame
-        // when running out of time of the current frame. In that case, input
-        // events may be dispatched after ActorDestroy. Delay
-        // DelayedDeleteRunnable to avoid it to happen.
-        nsThread* thread = nsThreadManager::get().GetCurrentThread();
-        MOZ_ASSERT(thread);
-        bool eventPrioritizationEnabled = false;
-        thread->IsEventPrioritizationEnabled(&eventPrioritizationEnabled);
-        if (eventPrioritizationEnabled && thread->HasPendingInputEvents()) {
-          MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(this));
-          return NS_OK;
-        }
+
         // Check in case ActorDestroy was called after RecvDestroy message.
         if (mTabChild->IPCOpen()) {
             Unused << PBrowserChild::Send__delete__(mTabChild);
         }
 
         mTabChild = nullptr;
         return NS_OK;
     }
@@ -3515,24 +3502,16 @@ TabChildGlobal::GetDocShell(nsIDocShell*
   *aDocShell = nullptr;
   if (!mTabChild)
     return NS_ERROR_NULL_POINTER;
   nsCOMPtr<nsIDocShell> docShell = do_GetInterface(mTabChild->WebNavigation());
   docShell.swap(*aDocShell);
   return NS_OK;
 }
 
-NS_IMETHODIMP
-TabChildGlobal::GetTabEventTarget(nsIEventTarget** aTarget)
-{
-  nsCOMPtr<nsIEventTarget> target = EventTargetFor(TaskCategory::Other);
-  target.forget(aTarget);
-  return NS_OK;
-}
-
 nsIPrincipal*
 TabChildGlobal::GetPrincipal()
 {
   if (!mTabChild)
     return nullptr;
   return mTabChild->GetPrincipal();
 }
 
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -109,17 +109,16 @@ public:
   {
     return mMessageManager
       ? mMessageManager->SendRpcMessage(aMessageName, aObject, aRemote,
                                         aPrincipal, aCx, aArgc, aRetval)
       : NS_ERROR_NULL_POINTER;
   }
   NS_IMETHOD GetContent(mozIDOMWindowProxy** aContent) override;
   NS_IMETHOD GetDocShell(nsIDocShell** aDocShell) override;
-  NS_IMETHOD GetTabEventTarget(nsIEventTarget** aTarget) override;
 
   nsresult AddEventListener(const nsAString& aType,
                             nsIDOMEventListener* aListener,
                             bool aUseCapture)
   {
     // By default add listeners only for trusted events!
     return DOMEventTargetHelper::AddEventListener(aType, aListener,
                                                   aUseCapture, false, 2);
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -167,18 +167,16 @@ TabParent::TabParent(nsIContentParent* a
   , mHasContentOpener(false)
 #ifdef DEBUG
   , mActiveSupressDisplayportCount(0)
 #endif
   , mLayerTreeEpoch(0)
   , mPreserveLayers(false)
   , mHasPresented(false)
   , mHasBeforeUnload(false)
-  , mIsReadyToHandleInputEvents(false)
-  , mIsMouseEnterIntoWidgetEventSuppressed(false)
 {
   MOZ_ASSERT(aManager);
 }
 
 TabParent::~TabParent()
 {
 }
 
@@ -1078,17 +1076,17 @@ TabParent::SendMouseEvent(const nsAStrin
 
 void
 TabParent::SendKeyEvent(const nsAString& aType,
                         int32_t aKeyCode,
                         int32_t aCharCode,
                         int32_t aModifiers,
                         bool aPreventDefault)
 {
-  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+  if (mIsDestroyed) {
     return;
   }
   Unused << PBrowserParent::SendKeyEvent(nsString(aType), aKeyCode, aCharCode,
                                          aModifiers, aPreventDefault);
 }
 
 void
 TabParent::SendRealMouseEvent(WidgetMouseEvent& aEvent)
@@ -1109,43 +1107,21 @@ TabParent::SendRealMouseEvent(WidgetMous
                           mCustomCursorHotspotX, mCustomCursorHotspotY);
       } else if (mCursor != nsCursor(-1)) {
         widget->SetCursor(mCursor);
       }
     } else if (eMouseExitFromWidget == aEvent.mMessage) {
       mTabSetsCursor = false;
     }
   }
-  if (!mIsReadyToHandleInputEvents) {
-    if (eMouseEnterIntoWidget == aEvent.mMessage) {
-      MOZ_ASSERT(!mIsMouseEnterIntoWidgetEventSuppressed);
-      mIsMouseEnterIntoWidgetEventSuppressed = true;
-    } else if (eMouseExitFromWidget == aEvent.mMessage) {
-      MOZ_ASSERT(mIsMouseEnterIntoWidgetEventSuppressed);
-      mIsMouseEnterIntoWidgetEventSuppressed = false;
-    }
-    return;
-  }
 
   ScrollableLayerGuid guid;
   uint64_t blockId;
   ApzAwareEventRoutingToChild(&guid, &blockId, nullptr);
 
-  if (mIsMouseEnterIntoWidgetEventSuppressed) {
-    // In the case that the TabParent suppressed the eMouseEnterWidget event due
-    // to its corresponding TabChild wasn't ready to handle it, we have to
-    // resend it when the TabChild is ready.
-    mIsMouseEnterIntoWidgetEventSuppressed = false;
-    WidgetMouseEvent localEvent(aEvent);
-    localEvent.mMessage = eMouseEnterIntoWidget;
-    DebugOnly<bool> ret = SendRealMouseButtonEvent(localEvent, guid, blockId);
-    NS_WARNING_ASSERTION(ret, "SendRealMouseButtonEvent(eMouseEnterIntoWidget) failed");
-    MOZ_ASSERT(!ret || localEvent.HasBeenPostedToRemoteProcess());
-  }
-
   if (eMouseMove == aEvent.mMessage) {
     if (aEvent.mReason == WidgetMouseEvent::eSynthesized) {
       DebugOnly<bool> ret = SendSynthMouseMoveEvent(aEvent, guid, blockId);
       NS_WARNING_ASSERTION(ret, "SendSynthMouseMoveEvent() failed");
       MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
       return;
     }
     DebugOnly<bool> ret = SendRealMouseMoveEvent(aEvent, guid, blockId);
@@ -1170,17 +1146,17 @@ TabParent::GetLayoutDeviceToCSSScale()
     ? (float)ctx->AppUnitsPerDevPixel() / nsPresContext::AppUnitsPerCSSPixel()
     : 0.0f);
 }
 
 void
 TabParent::SendRealDragEvent(WidgetDragEvent& aEvent, uint32_t aDragAction,
                              uint32_t aDropEffect)
 {
-  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+  if (mIsDestroyed) {
     return;
   }
   aEvent.mRefPoint += GetChildProcessOffset();
   DebugOnly<bool> ret =
     PBrowserParent::SendRealDragEvent(aEvent, aDragAction, aDropEffect);
   NS_WARNING_ASSERTION(ret, "PBrowserParent::SendRealDragEvent() failed");
   MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
 }
@@ -1189,17 +1165,17 @@ LayoutDevicePoint
 TabParent::AdjustTapToChildWidget(const LayoutDevicePoint& aPoint)
 {
   return aPoint + LayoutDevicePoint(GetChildProcessOffset());
 }
 
 void
 TabParent::SendMouseWheelEvent(WidgetWheelEvent& aEvent)
 {
-  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+  if (mIsDestroyed) {
     return;
   }
 
   ScrollableLayerGuid guid;
   uint64_t blockId;
   ApzAwareEventRoutingToChild(&guid, &blockId, nullptr);
   aEvent.mRefPoint += GetChildProcessOffset();
   DebugOnly<bool> ret =
@@ -1468,17 +1444,17 @@ TabParent::RecvClearNativeTouchSequence(
     widget->ClearNativeTouchSequence(responder.GetObserver());
   }
   return IPC_OK();
 }
 
 void
 TabParent::SendRealKeyEvent(WidgetKeyboardEvent& aEvent)
 {
-  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+  if (mIsDestroyed) {
     return;
   }
   aEvent.mRefPoint += GetChildProcessOffset();
 
   if (aEvent.mMessage == eKeyPress) {
     // XXX Should we do this only when input context indicates an editor having
     //     focus and the key event won't cause inputting text?
     aEvent.InitAllEditCommands();
@@ -1489,17 +1465,17 @@ TabParent::SendRealKeyEvent(WidgetKeyboa
   DebugOnly<bool> ret = PBrowserParent::SendRealKeyEvent(aEvent);
   NS_WARNING_ASSERTION(ret, "PBrowserParent::SendRealKeyEvent() failed");
   MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
 }
 
 void
 TabParent::SendRealTouchEvent(WidgetTouchEvent& aEvent)
 {
-  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+  if (mIsDestroyed) {
     return;
   }
 
   // PresShell::HandleEventInternal adds touches on touch end/cancel.  This
   // confuses remote content and the panning and zooming logic into thinking
   // that the added touches are part of the touchend/cancel, when actually
   // they're not.
   if (aEvent.mMessage == eTouchEnd || aEvent.mMessage == eTouchCancel) {
@@ -1550,17 +1526,17 @@ TabParent::SendPluginEvent(WidgetPluginE
 
 bool
 TabParent::SendHandleTap(TapType aType,
                          const LayoutDevicePoint& aPoint,
                          Modifiers aModifiers,
                          const ScrollableLayerGuid& aGuid,
                          uint64_t aInputBlockId)
 {
-  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+  if (mIsDestroyed) {
     return false;
   }
   if ((aType == TapType::eSingleTap || aType == TapType::eSecondTap) &&
       GetRenderFrame()) {
     GetRenderFrame()->TakeFocusForClickFromTap();
   }
   LayoutDeviceIntPoint offset = GetChildProcessOffset();
   return PBrowserParent::SendHandleTap(aType, aPoint + offset, aModifiers,
@@ -2955,28 +2931,16 @@ TabParent::RecvRemotePaintIsReady()
   event->InitEvent(NS_LITERAL_STRING("MozAfterRemotePaint"), false, false);
   event->SetTrusted(true);
   event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
   bool dummy;
   mFrameElement->DispatchEvent(event, &dummy);
   return IPC_OK();
 }
 
-mozilla::ipc::IPCResult
-TabParent::RecvRemoteIsReadyToHandleInputEvents()
-{
-  // When enabling input event prioritization, input events may preempt other
-  // normal priority IPC messages. To prevent the input events preempt
-  // PBrowserConstructor, we use an IPC 'RemoteIsReadyToHandleInputEvents' to
-  // notify the parent that TabChild is created and ready to handle input
-  // events.
-  SetReadyToHandleInputEvents();
-  return IPC_OK();
-}
-
 mozilla::plugins::PPluginWidgetParent*
 TabParent::AllocPPluginWidgetParent()
 {
 #ifdef XP_WIN
   return new mozilla::plugins::PluginWidgetParent();
 #else
   MOZ_ASSERT_UNREACHABLE();
   return nullptr;
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -598,19 +598,16 @@ public:
                           uint64_t* aLayersId);
 
   mozilla::ipc::IPCResult RecvEnsureLayersConnected(CompositorOptions* aCompositorOptions) override;
 
   // LiveResizeListener implementation
   void LiveResizeStarted() override;
   void LiveResizeStopped() override;
 
-  void SetReadyToHandleInputEvents() { mIsReadyToHandleInputEvents = true; }
-  bool IsReadyToHandleInputEvents() { return mIsReadyToHandleInputEvents; }
-
 protected:
   bool ReceiveMessage(const nsString& aMessage,
                       bool aSync,
                       ipc::StructuredCloneData* aData,
                       mozilla::jsipc::CpowHolder* aCpows,
                       nsIPrincipal* aPrincipal,
                       nsTArray<ipc::StructuredCloneData>* aJSONRetVal = nullptr);
 
@@ -626,18 +623,16 @@ protected:
   nsCOMPtr<nsIBrowserDOMWindow> mBrowserDOMWindow;
 
   virtual PRenderFrameParent* AllocPRenderFrameParent() override;
 
   virtual bool DeallocPRenderFrameParent(PRenderFrameParent* aFrame) override;
 
   virtual mozilla::ipc::IPCResult RecvRemotePaintIsReady() override;
 
-  virtual mozilla::ipc::IPCResult RecvRemoteIsReadyToHandleInputEvents() override;
-
   virtual mozilla::ipc::IPCResult RecvForcePaintNoOp(const uint64_t& aLayerObserverEpoch) override;
 
   virtual mozilla::ipc::IPCResult RecvSetDimensions(const uint32_t& aFlags,
                                                     const int32_t& aX, const int32_t& aY,
                                                     const int32_t& aCx, const int32_t& aCy) override;
 
   virtual mozilla::ipc::IPCResult RecvGetTabCount(uint32_t* aValue) override;
 
@@ -778,24 +773,16 @@ private:
   // True if this TabParent has had its layer tree sent to the compositor
   // at least once.
   bool mHasPresented;
 
   // True if at least one window hosted in the TabChild has added a
   // beforeunload event listener.
   bool mHasBeforeUnload;
 
-  // True when the remote browser is created and ready to handle input events.
-  bool mIsReadyToHandleInputEvents;
-
-  // True if we suppress the eMouseEnterIntoWidget event due to the TabChild was
-  // not ready to handle it. We will resend it when the next time we fire a
-  // mouse event and the TabChild is ready.
-  bool mIsMouseEnterIntoWidgetEventSuppressed;
-
 public:
   static TabParent* GetTabParentFromLayersId(uint64_t aLayersId);
 };
 
 struct MOZ_STACK_CLASS TabParent::AutoUseNewTab final
 {
 public:
   AutoUseNewTab(TabParent* aNewTab, nsCString* aURLToLoad)
--- a/dom/ipc/nsIContentChild.cpp
+++ b/dom/ipc/nsIContentChild.cpp
@@ -97,18 +97,17 @@ nsIContentChild::RecvPBrowserConstructor
   if (NS_WARN_IF(NS_FAILED(tabChild->Init()))) {
     return IPC_FAIL(tabChild, "TabChild::Init failed");
   }
 
   nsCOMPtr<nsIObserverService> os = services::GetObserverService();
   if (os) {
     os->NotifyObservers(static_cast<nsITabChild*>(tabChild), "tab-child-created", nullptr);
   }
-  // Notify parent that we are ready to handle input events.
-  tabChild->SendRemoteIsReadyToHandleInputEvents();
+
   return IPC_OK();
 }
 
 PIPCBlobInputStreamChild*
 nsIContentChild::AllocPIPCBlobInputStreamChild(const nsID& aID,
                                                const uint64_t& aSize)
 {
   // IPCBlobInputStreamChild is refcounted. Here it's created and in
--- a/dom/ipc/nsIContentParent.cpp
+++ b/dom/ipc/nsIContentParent.cpp
@@ -201,35 +201,16 @@ nsIContentParent::AllocPBrowserParent(co
 bool
 nsIContentParent::DeallocPBrowserParent(PBrowserParent* aFrame)
 {
   TabParent* parent = TabParent::GetFrom(aFrame);
   NS_RELEASE(parent);
   return true;
 }
 
-mozilla::ipc::IPCResult
-nsIContentParent::RecvPBrowserConstructor(PBrowserParent* actor,
-                                          const TabId& tabId,
-                                          const TabId& sameTabGroupAs,
-                                          const IPCTabContext& context,
-                                          const uint32_t& chromeFlags,
-                                          const ContentParentId& cpId,
-                                          const bool& isForBrowser)
-{
-  TabParent* parent = TabParent::GetFrom(actor);
-  // When enabling input event prioritization, input events may preempt other
-  // normal priority IPC messages. To prevent the input events preempt
-  // PBrowserConstructor, we use an IPC 'RemoteIsReadyToHandleInputEvents' to
-  // notify parent that TabChild is created. In this case, PBrowser is initiated
-  // from content so that we can set TabParent as ready to handle input events.
-  parent->SetReadyToHandleInputEvents();
-  return IPC_OK();
-}
-
 PIPCBlobInputStreamParent*
 nsIContentParent::AllocPIPCBlobInputStreamParent(const nsID& aID,
                                                  const uint64_t& aSize)
 {
   MOZ_CRASH("PIPCBlobInputStreamParent actors should be manually constructed!");
   return nullptr;
 }
 
--- a/dom/ipc/nsIContentParent.h
+++ b/dom/ipc/nsIContentParent.h
@@ -112,25 +112,16 @@ protected: // IPDL methods
   virtual PBrowserParent* AllocPBrowserParent(const TabId& aTabId,
                                               const TabId& aSameTabGroupsAs,
                                               const IPCTabContext& aContext,
                                               const uint32_t& aChromeFlags,
                                               const ContentParentId& aCpId,
                                               const bool& aIsForBrowser);
   virtual bool DeallocPBrowserParent(PBrowserParent* frame);
 
-  virtual mozilla::ipc::IPCResult
-  RecvPBrowserConstructor(PBrowserParent* actor,
-                          const TabId& tabId,
-                          const TabId& sameTabGroupAs,
-                          const IPCTabContext& context,
-                          const uint32_t& chromeFlags,
-                          const ContentParentId& cpId,
-                          const bool& isForBrowser);
-
   virtual mozilla::ipc::PIPCBlobInputStreamParent*
   AllocPIPCBlobInputStreamParent(const nsID& aID, const uint64_t& aSize);
 
   virtual bool
   DeallocPIPCBlobInputStreamParent(mozilla::ipc::PIPCBlobInputStreamParent* aActor);
 
   virtual mozilla::ipc::PFileDescriptorSetParent*
   AllocPFileDescriptorSetParent(const mozilla::ipc::FileDescriptor& aFD);
--- a/dom/tests/browser/browser_bug1316330.js
+++ b/dom/tests/browser/browser_bug1316330.js
@@ -13,24 +13,24 @@ const URL =
   "  if (e.charCode == 'p'.charCodeAt(0)) while (Date.now() - startTime < 500) {}" +
   "};" +
   "</script>";
 
 add_task(async function() {
   let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, URL);
   let browser = tab.linkedBrowser;
 
-  await EventUtils.synthesizeAndWaitKey("d", { code: "KeyD", repeat: 3 });
+  EventUtils.synthesizeKey("d", { code: "KeyD", repeat: 3 });
 
   await ContentTask.spawn(browser, null, async function() {
     is(content.document.body.getAttribute("data-down"), "2", "Correct number of events");
     is(content.document.body.getAttribute("data-press"), "2", "Correct number of events");
   });
 
-  await EventUtils.synthesizeAndWaitKey("p", { code: "KeyP", repeat: 3 });
+  EventUtils.synthesizeKey("p", { code: "KeyP", repeat: 3 });
 
   await ContentTask.spawn(browser, null, async function() {
     is(content.document.body.getAttribute("data-down"), "4", "Correct number of events");
     is(content.document.body.getAttribute("data-press"), "4", "Correct number of events");
   });
 
   gBrowser.removeCurrentTab();
 });
--- a/editor/libeditor/tests/browser_bug629172.js
+++ b/editor/libeditor/tests/browser_bug629172.js
@@ -38,20 +38,21 @@ add_task(async function() {
       };
     });
 
     function simulateCtrlShiftX(aBrowser) {
       // In e10s, the keypress event will be dispatched to the content process,
       // but in non-e10s it is handled by the browser UI code and hence won't
       // reach the web page.  As a result, we need to observe the event in
       // the content process only in e10s mode.
+      var waitForKeypressContent = BrowserTestUtils.waitForContentEvent(aBrowser, "keypress");
+      EventUtils.synthesizeKey("x", {accelKey: true, shiftKey: true});
       if (gMultiProcessBrowser) {
-        return EventUtils.synthesizeAndWaitKey("x", {accelKey: true, shiftKey: true});
+        return waitForKeypressContent;
       }
-      EventUtils.synthesizeKey("x", {accelKey: true, shiftKey: true});
       return Promise.resolve();
     }
 
     async function testDirection(initialDir, aBrowser) {
       await ContentTask.spawn(aBrowser, {initialDir}, function({initialDir}) {
         var window = content.window.wrappedJSObject;
         var document = window.document;
 
--- a/gfx/layers/apz/test/mochitest/helper_touch_action_regions.html
+++ b/gfx/layers/apz/test/mochitest/helper_touch_action_regions.html
@@ -88,21 +88,16 @@ function waitFor(eventType, count) {
     if (Date.now() - start > 10000) {
       // It's taking too long, let's abort
       return false;
     }
   }
   return true;
 }
 
-function RunAfterProcessedQueuedInputEvents(aCallback) {
-  let tm = SpecialPowers.Services.tm;
-  tm.dispatchToMainThread(aCallback, SpecialPowers.Ci.nsIRunnablePriority.PRIORITY_INPUT);
-}
-
 function* test(testDriver) {
   // The main part of this test should run completely before the child process'
   // main-thread deals with the touch event, so check to make sure that happens.
   document.body.addEventListener('touchstart', failure, { passive: true });
 
   // What we want here is to synthesize all of the touch events (from this code in
   // the child process), and have the chrome process generate and process them,
   // but not allow the events to be dispatched back into the child process until
@@ -139,29 +134,26 @@ function* test(testDriver) {
   //     handle DOM touchstart  <-- touchstart goes at end of queue
   //
   // As we continue yielding one at a time, the synthesizations run, and the
   // touch events get added to the end of the queue. As we yield, we take
   // snapshots in the chrome process, to make sure that the APZ has started
   // scrolling even though we know we haven't yet processed the DOM touch events
   // in the child process yet.
   //
-  // Note that the "async callback" we use here is SpecialPowers.tm.dispatchToMainThread
-  // with priority = input, because nothing else does exactly what we want:
+  // Note that the "async callback" we use here is SpecialPowers.executeSoon,
+  // because nothing else does exactly what we want:
   // - setTimeout(..., 0) does not maintain ordering, because it respects the
   //   time delta provided (i.e. the callback can jump the queue to meet its
   //   deadline).
   // - SpecialPowers.spinEventLoop and SpecialPowers.executeAfterFlushingMessageQueue
   //   are not e10s friendly, and can get arbitrarily delayed due to IPC
   //   round-trip time.
   // - SimpleTest.executeSoon has a codepath that delegates to setTimeout, so
   //   is less reliable if it ever decides to switch to that codepath.
-  // - SpecialPowers.executeSoon dispatches a task to main thread. However,
-  //   normal runnables may be preempted by input events and be executed in an
-  //   unexpected order.
 
   // The other problem we need to deal with is the asynchronicity in the chrome
   // process. That is, we might request a snapshot before the chrome process has
   // actually synthesized the event and processed it. To guard against this, we
   // register a thing in the chrome process that counts the touch events that
   // have been dispatched, and poll that thing synchronously in order to make
   // sure we only snapshot after the event in question has been processed.
   // That's what the chromeTouchEventCounter business is all about. The sync
@@ -172,23 +164,23 @@ function* test(testDriver) {
   // So, here we go...
 
   // Set up the chrome process touch listener
   ok(chromeTouchEventCounter('start'), "Chrome touch counter registered");
 
   // Set up the child process events and callbacks
   var scroller = document.getElementById('scroller');
   synthesizeNativeTouch(scroller, 10, 110, SpecialPowers.DOMWindowUtils.TOUCH_CONTACT, null, 0);
-  RunAfterProcessedQueuedInputEvents(testDriver);
+  SpecialPowers.executeSoon(testDriver);
   for (var i = 1; i < 10; i++) {
     synthesizeNativeTouch(scroller, 10, 110 - (i * 10), SpecialPowers.DOMWindowUtils.TOUCH_CONTACT, null, 0);
-    RunAfterProcessedQueuedInputEvents(testDriver);
+    SpecialPowers.executeSoon(testDriver);
   }
   synthesizeNativeTouch(scroller, 10, 10, SpecialPowers.DOMWindowUtils.TOUCH_REMOVE, null, 0);
-  RunAfterProcessedQueuedInputEvents(testDriver);
+  SpecialPowers.executeSoon(testDriver);
   ok(true, "Finished setting up event queue");
 
   // Get our baseline snapshot
   var rect = rectRelativeToScreen(scroller);
   var lastSnapshot = getSnapshot(rect);
   ok(true, "Got baseline snapshot");
   var numDifferentSnapshotPairs = 0;
 
--- a/ipc/chromium/src/chrome/common/ipc_message.cc
+++ b/ipc/chromium/src/chrome/common/ipc_message.cc
@@ -62,17 +62,18 @@ Message::Message(int32_t routing_id,
                  MessageCompression compression,
                  const char* const aName,
                  bool recordWriteLatency)
     : Pickle(MSG_HEADER_SZ, segment_capacity) {
   MOZ_COUNT_CTOR(IPC::Message);
   header()->routing = routing_id;
   header()->type = type;
   header()->flags = nestedLevel;
-  set_priority(priority);
+  if (priority == HIGH_PRIORITY)
+    header()->flags |= PRIO_BIT;
   if (compression == COMPRESSION_ENABLED)
     header()->flags |= COMPRESS_BIT;
   else if (compression == COMPRESSION_ALL)
     header()->flags |= COMPRESSALL_BIT;
 #if defined(OS_POSIX)
   header()->num_fds = 0;
 #endif
   header()->interrupt_remote_stack_depth_guess = static_cast<uint32_t>(-1);
--- a/ipc/chromium/src/chrome/common/ipc_message.h
+++ b/ipc/chromium/src/chrome/common/ipc_message.h
@@ -41,19 +41,18 @@ class Message : public Pickle {
 
   enum NestedLevel {
     NOT_NESTED = 1,
     NESTED_INSIDE_SYNC = 2,
     NESTED_INSIDE_CPOW = 3
   };
 
   enum PriorityValue {
-    NORMAL_PRIORITY = 0,
-    INPUT_PRIORITY = 1,
-    HIGH_PRIORITY = 2,
+    NORMAL_PRIORITY,
+    HIGH_PRIORITY,
   };
 
   enum MessageCompression {
     COMPRESSION_NONE,
     COMPRESSION_ENABLED,
     COMPRESSION_ALL
   };
 
@@ -87,22 +86,27 @@ class Message : public Pickle {
   }
 
   void set_nested_level(NestedLevel nestedLevel) {
     DCHECK((nestedLevel & ~NESTED_MASK) == 0);
     header()->flags = (header()->flags & ~NESTED_MASK) | nestedLevel;
   }
 
   PriorityValue priority() const {
-    return static_cast<PriorityValue>((header()->flags & PRIO_MASK) >> 2);
+    if (header()->flags & PRIO_BIT) {
+      return HIGH_PRIORITY;
+    }
+    return NORMAL_PRIORITY;
   }
 
   void set_priority(PriorityValue prio) {
-    DCHECK(((prio << 2) & ~PRIO_MASK) == 0);
-    header()->flags = (header()->flags & ~PRIO_MASK) | (prio << 2);
+    header()->flags &= ~PRIO_BIT;
+    if (prio == HIGH_PRIORITY) {
+      header()->flags |= PRIO_BIT;
+    }
   }
 
   bool is_constructor() const {
     return (header()->flags & CONSTRUCTOR_BIT) != 0;
   }
 
   void set_constructor() {
     header()->flags |= CONSTRUCTOR_BIT;
@@ -306,26 +310,26 @@ class Message : public Pickle {
 
 #if !defined(OS_MACOSX)
  protected:
 #endif
 
   // flags
   enum {
     NESTED_MASK     = 0x0003,
-    PRIO_MASK       = 0x000C,
-    SYNC_BIT        = 0x0010,
-    REPLY_BIT       = 0x0020,
-    REPLY_ERROR_BIT = 0x0040,
-    INTERRUPT_BIT   = 0x0080,
-    COMPRESS_BIT    = 0x0100,
-    COMPRESSALL_BIT = 0x0200,
-    CONSTRUCTOR_BIT = 0x0400,
+    PRIO_BIT        = 0x0004,
+    SYNC_BIT        = 0x0008,
+    REPLY_BIT       = 0x0010,
+    REPLY_ERROR_BIT = 0x0020,
+    INTERRUPT_BIT   = 0x0040,
+    COMPRESS_BIT    = 0x0080,
+    COMPRESSALL_BIT = 0x0100,
+    CONSTRUCTOR_BIT = 0x0200,
 #ifdef MOZ_TASK_TRACER
-    TASKTRACER_BIT  = 0x0800,
+    TASKTRACER_BIT  = 0x0400,
 #endif
   };
 
   struct Header : Pickle::Header {
     int32_t routing;  // ID of the view that this message is destined for
     msgid_t type;   // specifies the user-defined message type
     uint32_t flags;   // specifies control flags for the message
 #if defined(OS_POSIX)
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -1971,30 +1971,18 @@ MessageChannel::MessageTask::Clear()
     mChannel->AssertWorkerThread();
 
     mChannel = nullptr;
 }
 
 NS_IMETHODIMP
 MessageChannel::MessageTask::GetPriority(uint32_t* aPriority)
 {
-  switch (mMessage.priority()) {
-  case Message::NORMAL_PRIORITY:
-    *aPriority = PRIORITY_NORMAL;
-    break;
-  case Message::INPUT_PRIORITY:
-    *aPriority = PRIORITY_INPUT;
-    break;
-  case Message::HIGH_PRIORITY:
-    *aPriority = PRIORITY_HIGH;
-    break;
-  default:
-    MOZ_ASSERT(false);
-    break;
-  }
+  *aPriority = mMessage.priority() == Message::HIGH_PRIORITY ?
+               PRIORITY_HIGH : PRIORITY_NORMAL;
   return NS_OK;
 }
 
 void
 MessageChannel::DispatchMessage(Message &&aMsg)
 {
     AssertWorkerThread();
     mMonitor->AssertCurrentThreadOwns();
--- a/ipc/ipdl/ipdl/ast.py
+++ b/ipc/ipdl/ipdl/ast.py
@@ -4,18 +4,17 @@
 
 import sys
 
 NOT_NESTED = 1
 INSIDE_SYNC_NESTED = 2
 INSIDE_CPOW_NESTED = 3
 
 NORMAL_PRIORITY = 1
-INPUT_PRIORITY = 2
-HIGH_PRIORITY = 3
+HIGH_PRIORITY = 2
 
 class Visitor:
     def defaultVisit(self, node):
         raise Exception, "INTERNAL ERROR: no visitor for node type `%s'"% (
             node.__class__.__name__)
 
     def visitTranslationUnit(self, tu):
         for cxxInc in tu.cxxIncludes:
--- a/ipc/ipdl/ipdl/lower.py
+++ b/ipc/ipdl/ipdl/lower.py
@@ -1722,19 +1722,18 @@ def _generateMessageConstructor(clsname,
     elif nested == ipdl.ast.INSIDE_SYNC_NESTED:
         nestedEnum = 'IPC::Message::NESTED_INSIDE_SYNC'
     else:
         assert nested == ipdl.ast.INSIDE_CPOW_NESTED
         nestedEnum = 'IPC::Message::NESTED_INSIDE_CPOW'
 
     if prio == ipdl.ast.NORMAL_PRIORITY:
         prioEnum = 'IPC::Message::NORMAL_PRIORITY'
-    elif prio == ipdl.ast.INPUT_PRIORITY:
-        prioEnum = 'IPC::Message::INPUT_PRIORITY'
     else:
+        assert prio == ipdl.ast.HIGH_PRIORITY
         prioEnum = 'IPC::Message::HIGH_PRIORITY'
 
     func.addstmt(
         StmtReturn(ExprNew(Type('IPC::Message'),
                            args=[ routingId,
                                   ExprVar(msgid),
                                   ExprLiteral.Int(int(segmentSize)),
                                   ExprVar(nestedEnum),
--- a/ipc/ipdl/ipdl/parser.py
+++ b/ipc/ipdl/ipdl/parser.py
@@ -498,18 +498,17 @@ def p_Nested(p):
     if p[1] not in kinds:
         _error(locFromTok(p, 1), "Expected not, inside_sync, or inside_cpow for nested()")
 
     p[0] = { 'nested': kinds[p[1]] }
 
 def p_Priority(p):
     """Priority : ID"""
     kinds = {'normal': 1,
-             'input': 2,
-             'high': 3}
+             'high': 2}
     if p[1] not in kinds:
         _error(locFromTok(p, 1), "Expected normal or high for prio()")
 
     p[0] = { 'prio': kinds[p[1]] }
 
 def p_SendQualifier(p):
     """SendQualifier : NESTED '(' Nested ')'
                      | PRIO '(' Priority ')'"""
--- a/ipc/ipdl/test/cxx/PTestPriority.ipdl
+++ b/ipc/ipdl/test/cxx/PTestPriority.ipdl
@@ -1,17 +1,14 @@
 namespace mozilla {
 namespace _ipdltest {
 
 sync protocol PTestPriority {
 parent:
-    prio(input) async PMsg1();
-    prio(input) sync PMsg2();
-    prio(high) async PMsg3();
-    prio(high) sync PMsg4();
+    prio(high) async Msg1();
+    prio(high) sync Msg2();
 
 child:
-    prio(input) async CMsg1();
-    prio(high) async CMsg2();
+    prio(high) async Msg3();
 };
 
 } // namespace _ipdltest
 } // namespace mozilla
--- a/layout/base/nsRefreshDriver.cpp
+++ b/layout/base/nsRefreshDriver.cpp
@@ -250,23 +250,16 @@ public:
       return aDefault;
     }
 
     idleEnd = idleEnd - TimeDuration::FromMilliseconds(
       nsLayoutUtils::IdlePeriodDeadlineLimit());
     return idleEnd < aDefault ? idleEnd : aDefault;
   }
 
-  Maybe<TimeStamp> GetNextTickHint()
-  {
-    MOZ_ASSERT(NS_IsMainThread());
-    TimeStamp nextTick = MostRecentRefresh() + GetTimerRate();
-    return nextTick < TimeStamp::Now() ? Nothing() : Some(nextTick);
-  }
-
 protected:
   virtual void StartTimer() = 0;
   virtual void StopTimer() = 0;
   virtual void ScheduleNextTick(TimeStamp aNowTime) = 0;
 
   bool IsRootRefreshDriver(nsRefreshDriver* aDriver)
   {
     nsPresContext* pc = aDriver->GetPresContext();
@@ -2404,27 +2397,16 @@ nsRefreshDriver::GetIdleDeadlineHint(Tim
   // sRegularRateTimer, since we consider refresh drivers attached to
   // sThrottledRateTimer to be inactive. This implies that tasks
   // resulting from a tick on the sRegularRateTimer counts as being
   // busy but tasks resulting from a tick on sThrottledRateTimer
   // counts as being idle.
   return sRegularRateTimer->GetIdleDeadlineHint(aDefault);
 }
 
-/* static */ Maybe<TimeStamp>
-nsRefreshDriver::GetNextTickHint()
-{
-  MOZ_ASSERT(NS_IsMainThread());
-
-  if (!sRegularRateTimer) {
-    return Nothing();
-  }
-  return sRegularRateTimer->GetNextTickHint();
-}
-
 void
 nsRefreshDriver::Disconnect()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   StopTimer();
 
   if (mPresContext) {
--- a/layout/base/nsRefreshDriver.h
+++ b/layout/base/nsRefreshDriver.h
@@ -340,22 +340,16 @@ public:
    * expected deadline. If the next expected deadline is later than
    * the default value, the default value is returned.
    *
    * If we're animating and we have skipped paints a time in the past
    * is returned.
    */
   static mozilla::TimeStamp GetIdleDeadlineHint(mozilla::TimeStamp aDefault);
 
-  /**
-   * It returns the expected timestamp of the next tick or nothing if the next
-   * tick is missed.
-   */
-  static mozilla::Maybe<mozilla::TimeStamp> GetNextTickHint();
-
   static void DispatchIdleRunnableAfterTick(nsIRunnable* aRunnable,
                                             uint32_t aDelay);
   static void CancelIdleRunnable(nsIRunnable* aRunnable);
 
   bool SkippedPaints() const
   {
     return mSkippedPaints;
   }
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -3118,36 +3118,16 @@ pref("dom.max_script_run_time", 10);
 pref("dom.global_stop_script", true);
 
 // Time (milliseconds) between throttled idle callbacks.
 pref("dom.idle_period.throttled_length", 10000);
 
 // The amount of idle time (milliseconds) reserved for a long idle period
 pref("idle_queue.long_period", 50);
 
-// Control the event prioritization on content main thread
-#ifdef NIGHTLY_BUILD
-pref("prioritized_input_events.enabled", true);
-#else
-pref("prioritized_input_events.enabled", false);
-#endif
-
-// The maximum and minimum time (milliseconds) we reserve for handling input
-// events in each frame.
-pref("prioritized_input_events.duration.max", 8);
-pref("prioritized_input_events.duration.min", 1);
-
-// The default amount of time (milliseconds) required for handling a input
-// event.
-pref("prioritized_input_events.default_duration_per_event", 1);
-
-// The number of processed input events we use to predict the amount of time
-// required to process the following input events.
-pref("prioritized_input_events.count_for_prediction", 9);
-
 // The minimum amount of time (milliseconds) required for an idle
 // period to be scheduled on the main thread. N.B. that
 // layout.idle_period.time_limit adds padding at the end of the idle
 // period, which makes the point in time that we expect to become busy
 // again be:
 // now + idle_queue.min_period + layout.idle_period.time_limit
 pref("idle_queue.min_period", 3);
 
--- a/testing/mochitest/tests/SimpleTest/EventUtils.js
+++ b/testing/mochitest/tests/SimpleTest/EventUtils.js
@@ -673,54 +673,16 @@ function synthesizeNativeMouseMove(aTarg
       if (aCallback && topic == "mouseevent") {
         aCallback(data);
       }
     }
   };
   utils.sendNativeMouseMove(x * scale, y * scale, null, observer);
 }
 
-/**
- * This is a wrapper around synthesizeNativeMouseMove that waits for the mouse
- * event to be dispatched to the target content.
- *
- * This API is supposed to be used in those test cases that synthesize some
- * input events to chrome process and have some checks in content.
- */
-function synthesizeAndWaitNativeMouseMove(aTarget, aOffsetX, aOffsetY,
-                                          aCallback, aWindow = window) {
-  let browser = gBrowser.selectedTab.linkedBrowser;
-  let mm = browser.messageManager;
-  let ContentTask =
-    _EU_Cu.import("resource://testing-common/ContentTask.jsm", null).ContentTask;
-
-  let eventRegisteredPromise = new Promise(resolve => {
-    mm.addMessageListener("Test:MouseMoveRegistered", function processed(message) {
-      mm.removeMessageListener("Test:MouseMoveRegistered", processed);
-      resolve();
-    });
-  });
-  let eventReceivedPromise = ContentTask.spawn(browser, [aOffsetX, aOffsetY],
-                                               ([clientX, clientY]) => {
-    return new Promise(resolve => {
-      addEventListener("mousemove", function onMouseMoveEvent(e) {
-        if (e.clientX == clientX && e.clientY == clientY) {
-          removeEventListener("mousemove", onMouseMoveEvent);
-          resolve();
-        }
-      });
-      sendAsyncMessage("Test:MouseMoveRegistered");
-    });
-  });
-  eventRegisteredPromise.then(() => {
-    synthesizeNativeMouseMove(aTarget, aOffsetX, aOffsetY, null, aWindow);
-  });
-  return eventReceivedPromise;
-}
-
 function _computeKeyCodeFromChar(aChar)
 {
   if (aChar.length != 1) {
     return 0;
   }
   var KeyEvent = _EU_Ci.nsIDOMKeyEvent;
   if (aChar >= 'a' && aChar <= 'z') {
     return KeyEvent.DOM_VK_A + aChar.charCodeAt(0) - 'a'.charCodeAt(0);
@@ -862,61 +824,16 @@ function synthesizeKey(aKey, aEvent, aWi
     if (dispatchKeyup) {
       TIP.keyup(keyEvent, keyEventDict.flags);
     }
   } finally {
     _emulateToInactivateModifiers(TIP, modifiers, aWindow);
   }
 }
 
-/**
- * This is a wrapper around synthesizeKey that waits for the key event to be
- * dispatched to the target content. It returns a promise which is resolved
- * when the content receives the key event.
- *
- * This API is supposed to be used in those test cases that synthesize some
- * input events to chrome process and have some checks in content.
- */
-function synthesizeAndWaitKey(aKey, aEvent, aWindow = window,
-                              checkBeforeSynthesize, checkAfterSynthesize)
-{
-  let browser = gBrowser.selectedTab.linkedBrowser;
-  let mm = browser.messageManager;
-  let keyCode = _createKeyboardEventDictionary(aKey, aEvent, aWindow).dictionary.keyCode;
-  let ContentTask = _EU_Cu.import("resource://testing-common/ContentTask.jsm", null).ContentTask;
-
-  let keyRegisteredPromise = new Promise(resolve => {
-    mm.addMessageListener("Test:KeyRegistered", function processed(message) {
-      mm.removeMessageListener("Test:KeyRegistered", processed);
-      resolve();
-    });
-  });
-  let keyReceivedPromise = ContentTask.spawn(browser, keyCode, (keyCode) => {
-    return new Promise(resolve => {
-      addEventListener("keyup", function onKeyEvent(e) {
-        if (e.keyCode == keyCode) {
-          removeEventListener("keyup", onKeyEvent);
-          resolve();
-        }
-      });
-      sendAsyncMessage("Test:KeyRegistered");
-    });
-  });
-  keyRegisteredPromise.then(() => {
-    if (checkBeforeSynthesize) {
-      checkBeforeSynthesize();
-    }
-    synthesizeKey(aKey, aEvent, aWindow);
-    if (checkAfterSynthesize) {
-      checkAfterSynthesize();
-    }
-  });
-  return keyReceivedPromise;
-}
-
 function _parseNativeModifiers(aModifiers, aWindow = window)
 {
   var navigator = _getNavigator(aWindow);
   var modifiers;
   if (aModifiers.capsLockKey) {
     modifiers |= 0x00000001;
   }
   if (aModifiers.numLockKey) {
--- a/toolkit/components/statusfilter/nsBrowserStatusFilter.cpp
+++ b/toolkit/components/statusfilter/nsBrowserStatusFilter.cpp
@@ -4,27 +4,25 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsBrowserStatusFilter.h"
 #include "mozilla/SystemGroup.h"
 #include "nsIChannel.h"
 #include "nsITimer.h"
 #include "nsIServiceManager.h"
 #include "nsString.h"
-#include "nsThreadUtils.h"
 
 using namespace mozilla;
 
 //-----------------------------------------------------------------------------
 // nsBrowserStatusFilter <public>
 //-----------------------------------------------------------------------------
 
 nsBrowserStatusFilter::nsBrowserStatusFilter()
-    : mTarget(GetMainThreadEventTarget())
-    , mCurProgress(0)
+    : mCurProgress(0)
     , mMaxProgress(0)
     , mStatusIsDirty(true)
     , mCurrentPercentage(0)
     , mTotalRequests(0)
     , mFinishedRequests(0)
     , mUseRealProgressFlag(false)
     , mDelayedStatus(false)
     , mDelayedProgress(false)
@@ -109,31 +107,16 @@ nsBrowserStatusFilter::GetIsLoadingDocum
 NS_IMETHODIMP
 nsBrowserStatusFilter::GetLoadType(uint32_t *aLoadType)
 {
     *aLoadType = 0;
     NS_NOTREACHED("nsBrowserStatusFilter::GetLoadType");
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-NS_IMETHODIMP
-nsBrowserStatusFilter::GetTarget(nsIEventTarget** aTarget)
-{
-    nsCOMPtr<nsIEventTarget> target = mTarget;
-    target.forget(aTarget);
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsBrowserStatusFilter::SetTarget(nsIEventTarget* aTarget)
-{
-    mTarget = aTarget;
-    return NS_OK;
-}
-
 //-----------------------------------------------------------------------------
 // nsBrowserStatusFilter::nsIWebProgressListener
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
 nsBrowserStatusFilter::OnStateChange(nsIWebProgress *aWebProgress,
                                      nsIRequest *aRequest,
                                      uint32_t aStateFlags,
@@ -374,17 +357,19 @@ nsresult
 nsBrowserStatusFilter::StartDelayTimer()
 {
     NS_ASSERTION(!DelayInEffect(), "delay should not be in effect");
 
     mTimer = do_CreateInstance("@mozilla.org/timer;1");
     if (!mTimer)
         return NS_ERROR_FAILURE;
 
-    mTimer->SetTarget(mTarget);
+    // Use the system group. The browser status filter is always used by chrome
+    // code.
+    mTimer->SetTarget(SystemGroup::EventTargetFor(TaskCategory::Other));
     return mTimer->InitWithNamedFuncCallback(
         TimeoutHandler, this, 160, nsITimer::TYPE_ONE_SHOT,
         "nsBrowserStatusFilter::TimeoutHandler");
 }
 
 void
 nsBrowserStatusFilter::ProcessTimeout()
 {
--- a/toolkit/components/statusfilter/nsBrowserStatusFilter.h
+++ b/toolkit/components/statusfilter/nsBrowserStatusFilter.h
@@ -41,17 +41,16 @@ private:
     void MaybeSendStatus();
     void ResetMembers();
     bool DelayInEffect() { return mDelayedStatus || mDelayedProgress; }
 
     static void TimeoutHandler(nsITimer *aTimer, void *aClosure);
 
 private:
     nsCOMPtr<nsIWebProgressListener> mListener;
-    nsCOMPtr<nsIEventTarget>         mTarget;
     nsCOMPtr<nsITimer>               mTimer;
 
     // delayed values
     nsString                         mStatusMsg;
     int64_t                          mCurProgress;
     int64_t                          mMaxProgress;
 
     nsString                         mCurrentStatusMsg;
--- a/toolkit/components/tooltiptext/tests/browser_input_file_tooltips.js
+++ b/toolkit/components/tooltiptext/tests/browser_input_file_tooltips.js
@@ -29,17 +29,19 @@ add_task(async function test_requiredset
 });
 
 async function do_test(test) {
   info(`starting test ${JSON.stringify(test)}`);
 
   let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
 
   info("Moving mouse out of the way.");
-  await EventUtils.synthesizeAndWaitNativeMouseMove(tab.linkedBrowser, 300, 300);
+  await new Promise(resolve => {
+    EventUtils.synthesizeNativeMouseMove(tab.linkedBrowser, 300, 300, resolve);
+  });
 
   info("creating input field");
   await ContentTask.spawn(tab.linkedBrowser, test, async function(test) {
     let doc = content.document;
     let input = doc.createElement("input");
     doc.body.appendChild(input);
     input.id = "test_input";
     input.setAttribute("style", "position: absolute; top: 0; left: 0;");
@@ -85,21 +87,25 @@ async function do_test(test) {
                       "remoteBrowserTooltip" :
                       "aHTMLTooltip";
     let tooltip = document.getElementById(tooltipId);
     tooltip.addEventListener("popupshown", function(event) {
       resolve(event.target);
     }, {once: true});
   });
   info("Initial mouse move");
-  await EventUtils.synthesizeAndWaitNativeMouseMove(tab.linkedBrowser, 50, 5);
+  await new Promise(resolve => {
+    EventUtils.synthesizeNativeMouseMove(tab.linkedBrowser, 50, 5, resolve);
+  });
   info("Waiting");
   await new Promise(resolve => setTimeout(resolve, 400));
   info("Second mouse move");
-  await EventUtils.synthesizeAndWaitNativeMouseMove(tab.linkedBrowser, 70, 5);
+  await new Promise(resolve => {
+    EventUtils.synthesizeNativeMouseMove(tab.linkedBrowser, 70, 5, resolve);
+  });
   info("Waiting for tooltip to open");
   let tooltip = await awaitTooltipOpen;
 
   is(tooltip.getAttribute("label"), test.result, "tooltip label should match expectation");
 
   info("Closing tab");
   await BrowserTestUtils.removeTab(tab);
 }
--- a/toolkit/content/browser-child.js
+++ b/toolkit/content/browser-child.js
@@ -28,17 +28,16 @@ if (AppConstants.MOZ_CRASHREPORTER) {
                                      "nsICrashReporter");
 }
 
 var WebProgressListener = {
   init() {
     this._filter = Cc["@mozilla.org/appshell/component/browser-status-filter;1"]
                      .createInstance(Ci.nsIWebProgress);
     this._filter.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_ALL);
-    this._filter.target = tabEventTarget;
 
     let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
                               .getInterface(Ci.nsIWebProgress);
     webProgress.addProgressListener(this._filter, Ci.nsIWebProgress.NOTIFY_ALL);
   },
 
   uninit() {
     let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
--- a/toolkit/content/tests/browser/browser_findbar.js
+++ b/toolkit/content/tests/browser/browser_findbar.js
@@ -170,28 +170,26 @@ add_task(async function() {
   let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE_URI);
   let browser = tab.linkedBrowser;
 
   ok(!gFindBarInitialized, "findbar isn't initialized yet");
 
   let findBar = gFindBar;
   let initialValue = findBar._findField.value;
 
-  await EventUtils.synthesizeAndWaitKey("f", { accelKey: true }, window, null,
-                                        () => {
-    isnot(document.activeElement, findBar._findField.inputField,
-      "findbar is not yet focused");
-  });
+  EventUtils.synthesizeKey("f", { accelKey: true }, window);
 
   let promises = [
     BrowserTestUtils.sendChar("a", browser),
     BrowserTestUtils.sendChar("b", browser),
     BrowserTestUtils.sendChar("c", browser)
   ];
 
+  isnot(document.activeElement, findBar._findField.inputField,
+    "findbar is not yet focused");
   is(findBar._findField.value, initialValue, "still has initial find query");
 
   await Promise.all(promises);
   is(document.activeElement, findBar._findField.inputField,
     "findbar is now focused");
   is(findBar._findField.value, "abc", "abc fully entered as find query");
 
   await BrowserTestUtils.removeTab(tab);
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/frame-script.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/frame-script.js
@@ -17,12 +17,11 @@ module.exports = {
     content: false,
     docShell: false,
     privateNoteIntentionalCrash: false,
     processMessageManager: false,
     removeMessageListener: false,
     removeWeakMessageListener: false,
     sendAsyncMessage: false,
     sendSyncMessage: false,
-    sendRpcMessage: false,
-    tabEventTarget: false
+    sendRpcMessage: false
   }
 };
--- a/uriloader/base/nsDocLoader.cpp
+++ b/uriloader/base/nsDocLoader.cpp
@@ -1,15 +1,14 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nspr.h"
-#include "mozilla/dom/TabGroup.h"
 #include "mozilla/Logging.h"
 #include "mozilla/IntegerPrintfMacros.h"
 
 #include "nsDocLoader.h"
 #include "nsCURILoader.h"
 #include "nsNetUtil.h"
 #include "nsIHttpChannel.h"
 #include "nsIWebProgressListener2.h"
@@ -976,37 +975,16 @@ nsDocLoader::GetIsLoadingDocument(bool *
 NS_IMETHODIMP
 nsDocLoader::GetLoadType(uint32_t *aLoadType)
 {
   *aLoadType = 0;
 
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-NS_IMETHODIMP
-nsDocLoader::GetTarget(nsIEventTarget** aTarget)
-{
-  nsCOMPtr<mozIDOMWindowProxy> window;
-  nsresult rv = GetDOMWindow(getter_AddRefs(window));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  nsCOMPtr<nsPIDOMWindowOuter> piwindow = nsPIDOMWindowOuter::From(window);
-  NS_ENSURE_STATE(piwindow);
-
-  nsCOMPtr<nsIEventTarget> target = piwindow->TabGroup()->EventTargetFor(mozilla::TaskCategory::Other);
-  target.forget(aTarget);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsDocLoader::SetTarget(nsIEventTarget* aTarget)
-{
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
 int64_t nsDocLoader::GetMaxTotalProgress()
 {
   int64_t newMaxTotal = 0;
 
   uint32_t count = mChildList.Length();
   for (uint32_t i=0; i < count; i++)
   {
     int64_t individualProgress = 0;
--- a/uriloader/base/nsIWebProgress.idl
+++ b/uriloader/base/nsIWebProgress.idl
@@ -2,17 +2,16 @@
  *
  * 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/. */
 
 #include "nsISupports.idl"
 
 interface mozIDOMWindowProxy;
-interface nsIEventTarget;
 interface nsIWebProgressListener;
 
 /**
  * The nsIWebProgress interface is used to add or remove nsIWebProgressListener
  * instances to observe the loading of asynchronous requests (usually in the
  * context of a DOM window).
  *
  * nsIWebProgress instances may be arranged in a parent-child configuration,
@@ -147,16 +146,9 @@ interface nsIWebProgress : nsISupports
    */
   readonly attribute boolean isLoadingDocument;
 
   /**
    * Contains a load type as specified by the load* constants in
    * nsIDocShellLoadInfo.idl.
    */
   readonly attribute unsigned long loadType;
-
-  /**
-   * Main thread event target to which progress updates should be
-   * dispatched. This typically will be a SchedulerEventTarget
-   * corresponding to the tab requesting updates.
-   */
-  attribute nsIEventTarget target;
 };
--- a/widget/tests/test_assign_event_data.html
+++ b/widget/tests/test_assign_event_data.html
@@ -95,26 +95,16 @@ function onEvent(aEvent)
         attr != "multipleActionsPrevented" && // multipleActionsPrevented isn't defined in any DOM event specs.
         typeof(aEvent[attr]) != "function") {
       gCopiedEvent.push({ name: attr, value: aEvent[attr]});
     }
   }
   setTimeout(gCallback, 0);
 }
 
-function observeKeyUpOnContent(aKeyCode, aCallback)
-{
-  document.addEventListener("keyup", function keyUp(ev) {
-    if (ev.keyCode == aKeyCode) {
-      document.removeEventListener("keyup", keyUp);
-      SimpleTest.executeSoon(aCallback);
-    }
-  });
-}
-
 const kTests = [
   { description: "InternalScrollPortEvent (overflow, vertical)",
     targetID: "scrollable-div", eventType: "overflow",
     dispatchEvent: function () {
       document.getElementById("scrolled-div").style.height = "500px";
     },
     canRun: function () {
       return true;
@@ -155,69 +145,55 @@ const kTests = [
   },
   { description: "WidgetKeyboardEvent (keydown of 'a' key without modifiers)",
     targetID: "input-text", eventType: "keydown",
     dispatchEvent: function () {
       document.getElementById(this.targetID).value = "";
       document.getElementById(this.targetID).focus();
       synthesizeNativeKey(KEYBOARD_LAYOUT_EN_US, kIsWin ? WIN_VK_A : MAC_VK_ANSI_A,
                           {}, "a", "a");
-      observeKeyUpOnContent(KeyboardEvent.DOM_VK_A, runNextTest);
-      return true;
     },
     canRun: function () {
       return (kIsMac || kIsWin);
     },
     todoMismatch: [],
   },
   { description: "WidgetKeyboardEvent (keyup of 'a' key without modifiers)",
     targetID: "input-text", eventType: "keydown",
     dispatchEvent: function () {
       document.getElementById(this.targetID).value = "";
       document.getElementById(this.targetID).focus();
       synthesizeNativeKey(KEYBOARD_LAYOUT_EN_US, kIsWin ? WIN_VK_A : MAC_VK_ANSI_A,
                           {}, "a", "a");
-      observeKeyUpOnContent(KeyboardEvent.DOM_VK_A, runNextTest);
-      return true;
     },
     canRun: function () {
       return (kIsMac || kIsWin);
     },
     todoMismatch: [],
   },
   { description: "WidgetKeyboardEvent (keypress of 'b' key with Shift)",
     targetID: "input-text", eventType: "keypress",
     dispatchEvent: function () {
       document.getElementById(this.targetID).value = "";
       document.getElementById(this.targetID).focus();
       synthesizeNativeKey(KEYBOARD_LAYOUT_EN_US, kIsWin ? WIN_VK_B : MAC_VK_ANSI_B,
                           { shiftKey: true }, "B", "B");
-      observeKeyUpOnContent(KeyboardEvent.DOM_VK_B, runNextTest);
-      return true;
     },
     canRun: function () {
       return (kIsMac || kIsWin);
     },
     todoMismatch: [],
   },
   { description: "WidgetKeyboardEvent (keypress of 'c' key with Accel)",
     targetID: "input-text", eventType: "keypress",
     dispatchEvent: function () {
       document.getElementById(this.targetID).value = "";
       document.getElementById(this.targetID).focus();
       synthesizeNativeKey(KEYBOARD_LAYOUT_EN_US, kIsWin ? WIN_VK_C : MAC_VK_ANSI_C,
                           { accelKey: true }, kIsWin ? "\u0003" : "c", "c");
-
-      // On Windows, synthesizeNativeKey will also fire keyup for accelKey
-      // (control key on Windows). We have to wait for it to prevent the key
-      // event break the next test case.
-      let waitKeyCode = _EU_isWin(window) ? KeyboardEvent.DOM_VK_CONTROL :
-                                            KeyboardEvent.DOM_VK_C;
-      observeKeyUpOnContent(waitKeyCode, runNextTest);
-      return true;
     },
     canRun: function () {
       return (kIsMac || kIsWin);
     },
     todoMismatch: [],
   },
   { description: "WidgetKeyboardEvent (keyup during composition)",
     targetID: "input-text", eventType: "keyup",
@@ -344,18 +320,16 @@ const kTests = [
   },
   { description: "InternalEditorInputEvent (input at key input)",
     targetID: "input-text", eventType: "input",
     dispatchEvent: function () {
       document.getElementById(this.targetID).value = "";
       document.getElementById(this.targetID).focus();
       synthesizeNativeKey(KEYBOARD_LAYOUT_EN_US, kIsWin ? WIN_VK_B : MAC_VK_ANSI_B,
                           { shiftKey: true }, "B", "B");
-      observeKeyUpOnContent(KeyboardEvent.DOM_VK_B, runNextTest);
-      return true;
     },
     canRun: function () {
       return (kIsMac || kIsWin);
     },
     todoMismatch: [],
   },
   { description: "InternalEditorInputEvent (input at composing)",
     targetID: "input-text", eventType: "input",
deleted file mode 100644
--- a/xpcom/threads/InputEventStatistics.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 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/. */
-
-#include "InputEventStatistics.h"
-
-#include "nsRefreshDriver.h"
-
-namespace mozilla {
-
-TimeDuration
-InputEventStatistics::TimeDurationCircularBuffer::GetMean()
-{
-  return mTotal / (int64_t)mSize;
-}
-
-InputEventStatistics::InputEventStatistics()
-  : mEnable(false)
-{
-  MOZ_ASSERT(Preferences::IsServiceAvailable());
-  uint32_t inputDuration =
-    Preferences::GetUint("prioritized_input_events.default_duration_per_event",
-                         sDefaultInputDuration);
-
-  TimeDuration defaultDuration = TimeDuration::FromMilliseconds(inputDuration);
-
-  uint32_t count =
-    Preferences::GetUint("prioritized_input_events.count_for_prediction",
-                         sInputCountForPrediction);
-
-  mLastInputDurations =
-    MakeUnique<TimeDurationCircularBuffer>(count, defaultDuration);
-
-  uint32_t maxDuration =
-    Preferences::GetUint("prioritized_input_events.duration.max",
-                         sMaxReservedTimeForHandlingInput);
-
-  uint32_t minDuration =
-    Preferences::GetUint("prioritized_input_events.duration.min",
-                         sMinReservedTimeForHandlingInput);
-
-  mMaxInputDuration = TimeDuration::FromMilliseconds(maxDuration);
-  mMinInputDuration = TimeDuration::FromMilliseconds(minDuration);
-}
-
-TimeStamp
-InputEventStatistics::GetInputHandlingStartTime(uint32_t aInputCount)
-{
-  MOZ_ASSERT(mEnable);
-  Maybe<TimeStamp> nextTickHint = nsRefreshDriver::GetNextTickHint();
-
-  if (nextTickHint.isNothing()) {
-    // Return a past time to process input events immediately.
-    return TimeStamp::Now() - TimeDuration::FromMilliseconds(1);
-  }
-  TimeDuration inputCost = mLastInputDurations->GetMean() * aInputCount;
-  inputCost = inputCost > mMaxInputDuration
-              ? mMaxInputDuration
-              : inputCost < mMinInputDuration
-              ? mMinInputDuration
-              : inputCost;
-
-  return nextTickHint.value() - inputCost;
-}
-
-} // namespace mozilla
deleted file mode 100644
--- a/xpcom/threads/InputEventStatistics.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 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/. */
-
-#if !defined(InputEventStatistics_h_)
-#define InputEventStatistics_h_
-
-#include "mozilla/Maybe.h"
-#include "mozilla/Preferences.h"
-#include "mozilla/TimeStamp.h"
-
-namespace mozilla {
-
-class InputEventStatistics
-{
-  // The default amount of time (milliseconds) required for handling a input
-  // event.
-  static const uint16_t sDefaultInputDuration = 1;
-
-  // The number of processed input events we use to predict the amount of time
-  // required to process the following input events.
-  static const uint16_t sInputCountForPrediction = 9;
-
-  // The default maximum and minimum time (milliseconds) we reserve for handling
-  // input events in each frame.
-  static const uint16_t sMaxReservedTimeForHandlingInput = 8;
-  static const uint16_t sMinReservedTimeForHandlingInput = 1;
-
-  class TimeDurationCircularBuffer
-  {
-    int16_t mSize;
-    int16_t mCurrentIndex;
-    nsTArray<TimeDuration> mBuffer;
-    TimeDuration mTotal;
-
-  public:
-    TimeDurationCircularBuffer(uint32_t aSize, TimeDuration& aDefaultValue)
-      : mSize(aSize)
-      , mCurrentIndex(0)
-    {
-      mSize = mSize == 0 ? sInputCountForPrediction : mSize;
-      for (int16_t index = 0; index < mSize; ++index) {
-        mBuffer.AppendElement(aDefaultValue);
-        mTotal += aDefaultValue;
-      }
-    }
-
-    void Insert(TimeDuration& aDuration)
-    {
-      mTotal += (aDuration - mBuffer[mCurrentIndex]);
-      mBuffer[mCurrentIndex++] = aDuration;
-      if (mCurrentIndex == mSize) {
-        mCurrentIndex = 0;
-      }
-    }
-
-    TimeDuration GetMean();
-  };
-
-  UniquePtr<TimeDurationCircularBuffer> mLastInputDurations;
-  TimeDuration mMaxInputDuration;
-  TimeDuration mMinInputDuration;
-  bool mEnable;
-
-  InputEventStatistics();
-  ~InputEventStatistics()
-  {
-  }
-
-public:
-  static InputEventStatistics& Get()
-  {
-    static InputEventStatistics sInstance;
-    return sInstance;
-  }
-
-  void UpdateInputDuration(TimeDuration aDuration)
-  {
-    if (!mEnable) {
-      return;
-    }
-    mLastInputDurations->Insert(aDuration);
-  }
-
-  TimeStamp GetInputHandlingStartTime(uint32_t aInputCount);
-
-  void SetEnable(bool aEnable)
-  {
-    mEnable = aEnable;
-  }
-};
-
-class MOZ_RAII AutoTimeDurationHelper final
-{
-public:
-  AutoTimeDurationHelper()
-  {
-    mStartTime = TimeStamp::Now();
-  }
-
-  ~AutoTimeDurationHelper()
-  {
-    InputEventStatistics::Get().UpdateInputDuration(TimeStamp::Now() - mStartTime);
-  }
-
-private:
-  TimeStamp mStartTime;
-};
-
-} // namespace mozilla
-
-#endif // InputEventStatistics_h_
--- a/xpcom/threads/LazyIdleThread.cpp
+++ b/xpcom/threads/LazyIdleThread.cpp
@@ -509,28 +509,16 @@ LazyIdleThread::HasPendingEvents(bool* a
 
 NS_IMETHODIMP
 LazyIdleThread::IdleDispatch(already_AddRefed<nsIRunnable> aEvent)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-LazyIdleThread::EnableEventPrioritization()
-{
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
-LazyIdleThread::IsEventPrioritizationEnabled(bool* aResult)
-{
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
 LazyIdleThread::RegisterIdlePeriod(already_AddRefed<nsIIdlePeriod> aIdlePeriod)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 LazyIdleThread::ProcessNextEvent(bool aMayWait,
                                  bool* aEventWasProcessed)
--- a/xpcom/threads/SchedulerGroup.cpp
+++ b/xpcom/threads/SchedulerGroup.cpp
@@ -359,27 +359,18 @@ SchedulerGroup::Runnable::Run()
   // The runnable's destructor can have side effects, so try to execute it in
   // the scope of the TabGroup.
   mRunnable = nullptr;
 
   mGroup->SetValidatingAccess(EndValidation);
   return result;
 }
 
-NS_IMETHODIMP
-SchedulerGroup::Runnable::GetPriority(uint32_t* aPriority)
-{
-  *aPriority = nsIRunnablePriority::PRIORITY_NORMAL;
-  nsCOMPtr<nsIRunnablePriority> runnablePrio = do_QueryInterface(mRunnable);
-  return runnablePrio ? runnablePrio->GetPriority(aPriority) : NS_OK;
-}
-
 NS_IMPL_ISUPPORTS_INHERITED(SchedulerGroup::Runnable,
                             mozilla::Runnable,
-                            nsIRunnablePriority,
                             SchedulerGroup::Runnable)
 
 SchedulerGroup::AutoProcessEvent::AutoProcessEvent()
  : mPrevRunningDispatcher(SchedulerGroup::sRunningDispatcher)
 {
   SchedulerGroup* prev = sRunningDispatcher;
   if (prev) {
     MOZ_ASSERT(prev->mAccessValid);
--- a/xpcom/threads/SchedulerGroup.h
+++ b/xpcom/threads/SchedulerGroup.h
@@ -76,31 +76,30 @@ public:
   }
 
   // Ensure that it's valid to access the TabGroup at this time.
   void ValidateAccess() const
   {
     MOZ_ASSERT(IsSafeToRun());
   }
 
-  class Runnable final : public mozilla::Runnable, public nsIRunnablePriority
+  class Runnable final : public mozilla::Runnable
   {
   public:
     Runnable(already_AddRefed<nsIRunnable>&& aRunnable,
              SchedulerGroup* aGroup);
 
     SchedulerGroup* Group() const { return mGroup; }
 
     NS_IMETHOD GetName(nsACString& aName) override;
 
     bool IsBackground() const { return mGroup->IsBackground(); }
 
     NS_DECL_ISUPPORTS_INHERITED
     NS_DECL_NSIRUNNABLE
-    NS_DECL_NSIRUNNABLEPRIORITY
 
     NS_DECLARE_STATIC_IID_ACCESSOR(NS_SCHEDULERGROUPRUNNABLE_IID);
 
  private:
     ~Runnable() = default;
 
     nsCOMPtr<nsIRunnable> mRunnable;
     RefPtr<SchedulerGroup> mGroup;
--- a/xpcom/threads/TimerThread.h
+++ b/xpcom/threads/TimerThread.h
@@ -14,17 +14,16 @@
 #include "nsTimerImpl.h"
 #include "nsThreadUtils.h"
 
 #include "nsTArray.h"
 
 #include "mozilla/Atomics.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Monitor.h"
-#include "mozilla/UniquePtr.h"
 
 #include <algorithm>
 
 namespace mozilla {
 class TimeStamp;
 } // namespace mozilla
 
 class TimerThread final
@@ -106,31 +105,30 @@ private:
     {
       if (mTimerImpl) {
         mTimerImpl->SetHolder(nullptr);
       }
       return mTimerImpl.forget();
     }
 
     static bool
-    UniquePtrLessThan(mozilla::UniquePtr<Entry>& aLeft,
-                      mozilla::UniquePtr<Entry>& aRight)
+    UniquePtrLessThan(UniquePtr<Entry>& aLeft, UniquePtr<Entry>& aRight)
     {
       // This is reversed because std::push_heap() sorts the "largest" to
       // the front of the heap.  We want that to be the earliest timer.
       return aRight->mTimeout < aLeft->mTimeout;
     }
 
     TimeStamp Timeout() const
     {
       return mTimeout;
     }
   };
 
-  nsTArray<mozilla::UniquePtr<Entry>> mTimers;
+  nsTArray<UniquePtr<Entry>> mTimers;
   uint32_t mAllowedEarlyFiringMicroseconds;
 };
 
 struct TimerAdditionComparator
 {
   TimerAdditionComparator(const mozilla::TimeStamp& aNow,
                           nsTimerImpl* aTimerToInsert) :
     now(aNow)
--- a/xpcom/threads/moz.build
+++ b/xpcom/threads/moz.build
@@ -38,17 +38,16 @@ EXPORTS += [
 EXPORTS.mozilla += [
     'AbstractThread.h',
     'BackgroundHangMonitor.h',
     'BlockingResourceBase.h',
     'CondVar.h',
     'DeadlockDetector.h',
     'HangAnnotations.h',
     'HangMonitor.h',
-    'InputEventStatistics.h',
     'LazyIdleThread.h',
     'MainThreadIdlePeriod.h',
     'Monitor.h',
     'MozPromise.h',
     'Mutex.h',
     'RecursiveMutex.h',
     'ReentrantMonitor.h',
     'RWLock.h',
@@ -65,17 +64,16 @@ EXPORTS.mozilla += [
 ]
 
 UNIFIED_SOURCES += [
     'AbstractThread.cpp',
     'BackgroundHangMonitor.cpp',
     'BlockingResourceBase.cpp',
     'HangAnnotations.cpp',
     'HangMonitor.cpp',
-    'InputEventStatistics.cpp',
     'LazyIdleThread.cpp',
     'MainThreadIdlePeriod.cpp',
     'nsEnvironment.cpp',
     'nsEventQueue.cpp',
     'nsMemoryPressure.cpp',
     'nsProcessCommon.cpp',
     'nsProxyRelease.cpp',
     'nsThread.cpp',
--- a/xpcom/threads/nsIRunnable.idl
+++ b/xpcom/threads/nsIRunnable.idl
@@ -13,16 +13,15 @@
 interface nsIRunnable : nsISupports
 {
     /**
      * The function implementing the task to be run.
      */
     void run();
 };
 
-[scriptable, uuid(e75aa42a-80a9-11e6-afb5-e89d87348e2c)]
+[uuid(e75aa42a-80a9-11e6-afb5-e89d87348e2c)]
 interface nsIRunnablePriority : nsISupports
 {
     const unsigned short PRIORITY_NORMAL = 0;
-    const unsigned short PRIORITY_INPUT = 1;
-    const unsigned short PRIORITY_HIGH = 2;
+    const unsigned short PRIORITY_HIGH = 1;
     readonly attribute unsigned long priority;
 };
--- a/xpcom/threads/nsIThread.idl
+++ b/xpcom/threads/nsIThread.idl
@@ -147,19 +147,16 @@ interface nsIThread : nsISerialEventTarg
    * @throws NS_ERROR_INVALID_ARG
    *   Indicates that event is null.
    * @throws NS_ERROR_UNEXPECTED
    *   Indicates that the thread is shutting down and has finished processing
    * events, so this event would never run and has not been dispatched.
    */
   [noscript] void idleDispatch(in alreadyAddRefed_nsIRunnable event);
 
-  [noscript] void enableEventPrioritization();
-  [noscript] bool isEventPrioritizationEnabled();
-
   /**
    * Use this attribute to dispatch runnables to the thread. Eventually, the
    * eventTarget attribute will be the only way to dispatch events to a
    * thread--nsIThread will no longer inherit from nsIEventTarget.
    */
   readonly attribute nsIEventTarget eventTarget;
 
   /**
--- a/xpcom/threads/nsIThreadManager.idl
+++ b/xpcom/threads/nsIThreadManager.idl
@@ -3,17 +3,16 @@
 /* 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/. */
 
 #include "nsISupports.idl"
 
 [ptr] native PRThread(PRThread);
 
-interface nsIEventTarget;
 interface nsIRunnable;
 interface nsIThread;
 
 [scriptable, function, uuid(039a227d-0cb7-44a5-a8f9-dbb7071979f2)]
 interface nsINestedEventLoopCondition : nsISupports
 {
   /**
    * Returns true if the current nested event loop should stop spinning.
@@ -88,17 +87,17 @@ interface nsIThreadManager : nsISupports
   /**
    * This queues a runnable to the main thread. It's a shortcut for JS callers
    * to be used instead of
    *   .mainThread.dispatch(runnable, Ci.nsIEventTarget.DISPATCH_NORMAL);
    * or
    *   .currentThread.dispatch(runnable, Ci.nsIEventTarget.DISPATCH_NORMAL);
    * C++ callers should instead use NS_DispatchToMainThread.
    */
-  void dispatchToMainThread(in nsIRunnable event, [optional] in uint32_t priority);
+  void dispatchToMainThread(in nsIRunnable event);
 
   /**
    * This queues a runnable to the main thread's idle queue.
    *
    * @param event
    *   The event to dispatch.
    * @param timeout
    *   The time in milliseconds until this event should be moved from the idle
@@ -122,14 +121,9 @@ interface nsIThreadManager : nsISupports
 
   /**
    * Spin the current thread's event loop until there are no more pending
    * events.  This could be done with spinEventLoopUntil, but that would
    * require access to the current thread from JavaScript, which we are
    * moving away from.
    */
   void spinEventLoopUntilEmpty();
-
-  /**
-   * Return the SchedulerEventTarget for the SystemGroup.
-   */
-  readonly attribute nsIEventTarget systemGroupEventTarget;
 };
--- a/xpcom/threads/nsThread.cpp
+++ b/xpcom/threads/nsThread.cpp
@@ -36,17 +36,16 @@
 #include "mozilla/TimeStamp.h"
 #include "mozilla/Unused.h"
 #include "mozilla/dom/ScriptSettings.h"
 #include "nsIIdlePeriod.h"
 #include "nsIIdleRunnable.h"
 #include "nsThreadSyncDispatch.h"
 #include "LeakRefPtr.h"
 #include "GeckoProfiler.h"
-#include "InputEventStatistics.h"
 
 #ifdef MOZ_CRASHREPORTER
 #include "nsServiceManagerUtils.h"
 #include "nsICrashReporter.h"
 #include "mozilla/dom/ContentChild.h"
 #endif
 
 #ifdef XP_LINUX
@@ -811,166 +810,55 @@ nsThread::DispatchInternal(already_AddRe
     return NS_OK;
   }
 
   NS_ASSERTION(aFlags == NS_DISPATCH_NORMAL ||
                aFlags == NS_DISPATCH_AT_END, "unexpected dispatch flags");
   return PutEvent(event.take(), aTarget);
 }
 
-NS_IMPL_ISUPPORTS(nsThread::nsChainedEventQueue::EnablePrioritizationRunnable,
-                  nsIRunnable)
-
-void
-nsThread::nsChainedEventQueue::EnablePrioritization(MutexAutoLock& aProofOfLock)
-{
-  MOZ_ASSERT(!mIsInputPrioritizationEnabled);
-  // When enabling event prioritization, there may be some pending events with
-  // different priorities in the normal queue. Create an event in the normal
-  // queue to consume all pending events in the time order to make sure we won't
-  // preempt a pending event (e.g. input) in the normal queue by another newly
-  // created event with the same priority.
-  mNormalQueue->PutEvent(new EnablePrioritizationRunnable(this), aProofOfLock);
-  mInputHandlingStartTime = TimeStamp();
-  mIsInputPrioritizationEnabled = true;
-}
-
 bool
-nsThread::nsChainedEventQueue::
-GetNormalOrInputOrHighPriorityEvent(bool aMayWait, nsIRunnable** aEvent,
-                                    unsigned short* aPriority,
-                                    MutexAutoLock& aProofOfLock)
+nsThread::nsChainedEventQueue::GetEvent(bool aMayWait, nsIRunnable** aEvent,
+                                        unsigned short* aPriority,
+                                        mozilla::MutexAutoLock& aProofOfLock)
 {
   bool retVal = false;
   do {
-    // Use mProcessHighPriorityQueueRunnable to prevent the high priority events
-    // from consuming all cpu time and causing starvation.
-    if (mProcessHighPriorityQueueRunnable) {
-      MOZ_ASSERT(mHighQueue->HasPendingEvent(aProofOfLock));
-      retVal = mHighQueue->GetEvent(false, aEvent, aProofOfLock);
+    if (mProcessSecondaryQueueRunnable) {
+      MOZ_ASSERT(mSecondaryQueue->HasPendingEvent(aProofOfLock));
+      retVal = mSecondaryQueue->GetEvent(aMayWait, aEvent, aProofOfLock);
       MOZ_ASSERT(*aEvent);
-      SetPriorityIfNotNull(aPriority, nsIRunnablePriority::PRIORITY_HIGH);
-      mInputHandlingStartTime = TimeStamp();
-      mProcessHighPriorityQueueRunnable = false;
-      return retVal;
-    }
-    mProcessHighPriorityQueueRunnable =
-      mHighQueue->HasPendingEvent(aProofOfLock);
-
-    uint32_t pendingInputCount = mInputQueue->Count(aProofOfLock);
-    if (pendingInputCount > 0) {
-      if (mInputHandlingStartTime.IsNull()) {
-        mInputHandlingStartTime =
-          InputEventStatistics::Get()
-            .GetInputHandlingStartTime(mInputQueue->Count(aProofOfLock));
+      if (aPriority) {
+        *aPriority = nsIRunnablePriority::PRIORITY_HIGH;
       }
-      if (TimeStamp::Now() > mInputHandlingStartTime) {
-        retVal = mInputQueue->GetEvent(false, aEvent, aProofOfLock);
-        MOZ_ASSERT(*aEvent);
-        SetPriorityIfNotNull(aPriority, nsIRunnablePriority::PRIORITY_INPUT);
-        return retVal;
-      }
-    }
-
-    // We don't want to wait if there are some high priority events or input
-    // events in the queues.
-    bool reallyMayWait = aMayWait && !mProcessHighPriorityQueueRunnable &&
-                         pendingInputCount == 0;
-
-    retVal = mNormalQueue->GetEvent(reallyMayWait, aEvent, aProofOfLock);
-    if (*aEvent) {
-      // We got an event, return early.
-      SetPriorityIfNotNull(aPriority, nsIRunnablePriority::PRIORITY_NORMAL);
-      return retVal;
-    }
-    if (pendingInputCount > 0 && !mProcessHighPriorityQueueRunnable) {
-      // Handle input events if we have time for them.
-      MOZ_ASSERT(mInputQueue->HasPendingEvent(aProofOfLock));
-      retVal = mInputQueue->GetEvent(false, aEvent, aProofOfLock);
-      MOZ_ASSERT(*aEvent);
-      SetPriorityIfNotNull(aPriority, nsIRunnablePriority::PRIORITY_INPUT);
+      mProcessSecondaryQueueRunnable = false;
       return retVal;
     }
-  } while (aMayWait || mProcessHighPriorityQueueRunnable);
-  return retVal;
-}
 
-bool
-nsThread::nsChainedEventQueue::
-GetNormalOrHighPriorityEvent(bool aMayWait, nsIRunnable** aEvent,
-                             unsigned short* aPriority,
-                             MutexAutoLock& aProofOfLock)
-{
-  bool retVal = false;
-  do {
-    // Use mProcessHighPriorityQueueRunnable to prevent the high priority events
-    // from consuming all cpu time and causing starvation.
-    if (mProcessHighPriorityQueueRunnable) {
-      MOZ_ASSERT(mHighQueue->HasPendingEvent(aProofOfLock));
-      retVal = mHighQueue->GetEvent(false, aEvent, aProofOfLock);
-      MOZ_ASSERT(*aEvent);
-      SetPriorityIfNotNull(aPriority, nsIRunnablePriority::PRIORITY_HIGH);
-      mProcessHighPriorityQueueRunnable = false;
-      return retVal;
+    // We don't want to wait if mSecondaryQueue has some events.
+    bool reallyMayWait =
+      aMayWait && !mSecondaryQueue->HasPendingEvent(aProofOfLock);
+    retVal =
+      mNormalQueue->GetEvent(reallyMayWait, aEvent, aProofOfLock);
+    if (aPriority) {
+      *aPriority = nsIRunnablePriority::PRIORITY_NORMAL;
     }
-    mProcessHighPriorityQueueRunnable =
-      mHighQueue->HasPendingEvent(aProofOfLock);
 
-    // We don't want to wait if there are some events in the high priority
+    // Let's see if we should next time process an event from the secondary
     // queue.
-    bool reallyMayWait = aMayWait && !mProcessHighPriorityQueueRunnable;
+    mProcessSecondaryQueueRunnable =
+      mSecondaryQueue->HasPendingEvent(aProofOfLock);
 
-    retVal = mNormalQueue->GetEvent(reallyMayWait, aEvent, aProofOfLock);
     if (*aEvent) {
       // We got an event, return early.
-      SetPriorityIfNotNull(aPriority, nsIRunnablePriority::PRIORITY_NORMAL);
       return retVal;
     }
-  } while (aMayWait || mProcessHighPriorityQueueRunnable);
-  return retVal;
-}
+  } while(aMayWait || mProcessSecondaryQueueRunnable);
 
-void
-nsThread::nsChainedEventQueue::PutEvent(already_AddRefed<nsIRunnable> aEvent,
-                                        MutexAutoLock& aProofOfLock)
-{
-  RefPtr<nsIRunnable> event(aEvent);
-  nsCOMPtr<nsIRunnablePriority> runnablePrio(do_QueryInterface(event));
-  uint32_t prio = nsIRunnablePriority::PRIORITY_NORMAL;
-  if (runnablePrio) {
-    runnablePrio->GetPriority(&prio);
-  }
-  switch (prio) {
-  case nsIRunnablePriority::PRIORITY_NORMAL:
-    mNormalQueue->PutEvent(event.forget(), aProofOfLock);
-    break;
-  case nsIRunnablePriority::PRIORITY_INPUT:
-    if (mIsInputPrioritizationEnabled) {
-      mInputQueue->PutEvent(event.forget(), aProofOfLock);
-    } else {
-      mNormalQueue->PutEvent(event.forget(), aProofOfLock);
-    }
-    break;
-  case nsIRunnablePriority::PRIORITY_HIGH:
-    if (mIsInputPrioritizationEnabled) {
-      mHighQueue->PutEvent(event.forget(), aProofOfLock);
-    } else {
-      // During startup, ContentParent sends SetXPCOMProcessAttributes to
-      // initialize ContentChild and enable input event prioritization. After
-      // that, ContentParent sends PBrowserConstructor to create PBrowserChild.
-      // To prevent PBrowserConstructor preempt SetXPCOMProcessAttributes and
-      // cause problems, we have to put high priority events in mNormalQueue to
-      // keep the correct order of initialization.
-      mNormalQueue->PutEvent(event.forget(), aProofOfLock);
-    }
-    break;
-  default:
-    MOZ_ASSERT(false);
-    break;
-  }
+  return retVal;
 }
 
 //-----------------------------------------------------------------------------
 // nsIEventTarget
 
 NS_IMETHODIMP
 nsThread::DispatchFromScript(nsIRunnable* aEvent, uint32_t aFlags)
 {
@@ -1272,34 +1160,16 @@ nsThread::IdleDispatch(already_AddRefed<
     NS_WARNING("An idle event was posted to a thread that will never run it (rejected)");
     return NS_ERROR_UNEXPECTED;
   }
 
   mIdleEvents.PutEvent(event.take(), lock);
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsThread::EnableEventPrioritization()
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  MutexAutoLock lock(mLock);
-  // Only support event prioritization for main event queue.
-  mEventsRoot.EnablePrioritization(lock);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsThread::IsEventPrioritizationEnabled(bool* aResult)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  *aResult = mEventsRoot.IsPrioritizationEnabled();
-  return NS_OK;
-}
-
 #ifdef MOZ_CANARY
 void canary_alarm_handler(int signum);
 
 class Canary
 {
   //XXX ToDo: support nested loops
 public:
   Canary()
@@ -1567,20 +1437,17 @@ nsThread::ProcessNextEvent(bool aMayWait
         // Copy the name into sMainThreadRunnableName's buffer, and append a
         // terminating null.
         uint32_t length = std::min((uint32_t) kRunnableNameBufSize - 1,
                                    (uint32_t) name.Length());
         memcpy(sMainThreadRunnableName.begin(), name.BeginReading(), length);
         sMainThreadRunnableName[length] = '\0';
       }
 #endif
-      Maybe<AutoTimeDurationHelper> timeDurationHelper;
-      if (priority == nsIRunnablePriority::PRIORITY_INPUT) {
-        timeDurationHelper.emplace();
-      }
+
       event->Run();
     } else if (aMayWait) {
       MOZ_ASSERT(ShuttingDown(),
                  "This should only happen when shutting down");
       rv = NS_ERROR_UNEXPECTED;
     }
   }
 
--- a/xpcom/threads/nsThread.h
+++ b/xpcom/threads/nsThread.h
@@ -92,26 +92,16 @@ public:
   };
 
   static bool SaveMemoryReportNearOOM(ShouldSaveMemoryReport aShouldSave);
 #endif
 
   static const uint32_t kRunnableNameBufSize = 1000;
   static mozilla::Array<char, kRunnableNameBufSize> sMainThreadRunnableName;
 
-  // Query whether there are some pending input events in the queue. This method
-  // is supposed to be called on main thread with input event prioritization
-  // enabled.
-  bool HasPendingInputEvents()
-  {
-    MOZ_ASSERT(NS_IsMainThread());
-    mozilla::MutexAutoLock lock(mLock);
-    return mEventsRoot.HasPendingEventsInInputQueue(lock);
-  }
-
 private:
   void DoMainThreadSpecificProcessing(bool aReallyWait);
 
   // Returns a null TimeStamp if we're not in the idle period.
   mozilla::TimeStamp GetIdleDeadline();
   void GetIdleEvent(nsIRunnable** aEvent, mozilla::MutexAutoLock& aProofOfLock);
   void GetEvent(bool aWait, nsIRunnable** aEvent,
                 unsigned short* aPriority,
@@ -147,137 +137,82 @@ protected:
   nsresult PutEvent(already_AddRefed<nsIRunnable> aEvent,
                     nsNestedEventTarget* aTarget);
 
   nsresult DispatchInternal(already_AddRefed<nsIRunnable> aEvent,
                             uint32_t aFlags, nsNestedEventTarget* aTarget);
 
   struct nsThreadShutdownContext* ShutdownInternal(bool aSync);
 
-  // Wrapper for nsEventQueue that supports chaining and prioritization.
+  // Wrapper for nsEventQueue that supports chaining.
   class nsChainedEventQueue
   {
   public:
     explicit nsChainedEventQueue(mozilla::Mutex& aLock)
       : mNext(nullptr)
       , mEventsAvailable(aLock, "[nsChainedEventQueue.mEventsAvailable]")
-      , mIsInputPrioritizationEnabled(false)
-      , mIsReadyToPrioritizeEvents(false)
-      , mProcessHighPriorityQueueRunnable(false)
+      , mProcessSecondaryQueueRunnable(false)
     {
       mNormalQueue =
         mozilla::MakeUnique<nsEventQueue>(mEventsAvailable,
                                           nsEventQueue::eSharedCondVarQueue);
-      // All queues need to use the same CondVar!
-      mInputQueue =
-        mozilla::MakeUnique<nsEventQueue>(mEventsAvailable,
-                                          nsEventQueue::eSharedCondVarQueue);
-      mHighQueue =
+      // Both queues need to use the same CondVar!
+      mSecondaryQueue =
         mozilla::MakeUnique<nsEventQueue>(mEventsAvailable,
                                           nsEventQueue::eSharedCondVarQueue);
     }
 
-    void EnablePrioritization(mozilla::MutexAutoLock& aProofOfLock);
-
-    bool IsPrioritizationEnabled()
-    {
-      return mIsInputPrioritizationEnabled;
-    }
-
     bool GetEvent(bool aMayWait, nsIRunnable** aEvent,
                   unsigned short* aPriority,
-                  mozilla::MutexAutoLock& aProofOfLock) {
-      return mIsReadyToPrioritizeEvents
-        ? GetNormalOrInputOrHighPriorityEvent(aMayWait, aEvent, aPriority, aProofOfLock)
-        : GetNormalOrHighPriorityEvent(aMayWait, aEvent, aPriority, aProofOfLock);
-    }
+                  mozilla::MutexAutoLock& aProofOfLock);
 
     void PutEvent(nsIRunnable* aEvent, mozilla::MutexAutoLock& aProofOfLock)
     {
       RefPtr<nsIRunnable> event(aEvent);
       PutEvent(event.forget(), aProofOfLock);
     }
 
     void PutEvent(already_AddRefed<nsIRunnable> aEvent,
-                  mozilla::MutexAutoLock& aProofOfLock);
+                  mozilla::MutexAutoLock& aProofOfLock)
+    {
+      RefPtr<nsIRunnable> event(aEvent);
+      nsCOMPtr<nsIRunnablePriority> runnablePrio =
+        do_QueryInterface(event);
+      uint32_t prio = nsIRunnablePriority::PRIORITY_NORMAL;
+      if (runnablePrio) {
+        runnablePrio->GetPriority(&prio);
+      }
+      MOZ_ASSERT(prio == nsIRunnablePriority::PRIORITY_NORMAL ||
+                 prio == nsIRunnablePriority::PRIORITY_HIGH);
+      if (prio == nsIRunnablePriority::PRIORITY_NORMAL) {
+        mNormalQueue->PutEvent(event.forget(), aProofOfLock);
+      } else {
+        mSecondaryQueue->PutEvent(event.forget(), aProofOfLock);
+      }
+    }
 
     bool HasPendingEvent(mozilla::MutexAutoLock& aProofOfLock)
     {
       return mNormalQueue->HasPendingEvent(aProofOfLock) ||
-             mInputQueue->HasPendingEvent(aProofOfLock) ||
-             mHighQueue->HasPendingEvent(aProofOfLock);
-    }
-
-    bool HasPendingEventsInInputQueue(mozilla::MutexAutoLock& aProofOfLock)
-    {
-      MOZ_ASSERT(mIsInputPrioritizationEnabled);
-      return mInputQueue->HasPendingEvent(aProofOfLock);
+             mSecondaryQueue->HasPendingEvent(aProofOfLock);
     }
 
     nsChainedEventQueue* mNext;
     RefPtr<nsNestedEventTarget> mEventTarget;
 
   private:
-    bool GetNormalOrInputOrHighPriorityEvent(bool aMayWait,
-                                             nsIRunnable** aEvent,
-                                             unsigned short* aPriority,
-                                             mozilla::MutexAutoLock& aProofOfLock);
-
-    bool GetNormalOrHighPriorityEvent(bool aMayWait, nsIRunnable** aEvent,
-                                      unsigned short* aPriority,
-                                      mozilla::MutexAutoLock& aProofOfLock);
-
-    // This is used to flush pending events in nsChainedEventQueue::mNormalQueue
-    // before starting event prioritization.
-    class EnablePrioritizationRunnable final : public nsIRunnable
-    {
-      nsChainedEventQueue* mEventQueue;
-
-    public:
-      NS_DECL_ISUPPORTS
-
-      explicit EnablePrioritizationRunnable(nsChainedEventQueue* aQueue)
-        : mEventQueue(aQueue)
-      {
-      }
+    mozilla::CondVar mEventsAvailable;
+    mozilla::UniquePtr<nsEventQueue> mNormalQueue;
+    mozilla::UniquePtr<nsEventQueue> mSecondaryQueue;
 
-      NS_IMETHOD Run() override
-      {
-        mEventQueue->mIsReadyToPrioritizeEvents = true;
-        return NS_OK;
-      }
-    private:
-      ~EnablePrioritizationRunnable()
-      {
-      }
-    };
-
-    static void SetPriorityIfNotNull(unsigned short* aPriority, short aValue)
-    {
-      if (aPriority) {
-        *aPriority = aValue;
-      }
-    }
-    mozilla::CondVar mEventsAvailable;
-    mozilla::TimeStamp mInputHandlingStartTime;
-    mozilla::UniquePtr<nsEventQueue> mNormalQueue;
-    mozilla::UniquePtr<nsEventQueue> mInputQueue;
-    mozilla::UniquePtr<nsEventQueue> mHighQueue;
-    bool mIsInputPrioritizationEnabled;
-
-    // When enabling input event prioritization, there may be some events in the
-    // queue. We have to process all of them before the new coming events to
-    // prevent the queued events are preempted by the newly ones with the same
-    // priority.
-    bool mIsReadyToPrioritizeEvents;
     // Try to process one high priority runnable after each normal
     // priority runnable. This gives the processing model HTML spec has for
     // 'Update the rendering' in the case only vsync messages are in the
     // secondary queue and prevents starving the normal queue.
-    bool mProcessHighPriorityQueueRunnable;
+    bool mProcessSecondaryQueueRunnable;
   };
 
   class nsNestedEventTarget final : public nsIEventTarget
   {
   public:
     NS_DECL_THREADSAFE_ISUPPORTS
     NS_DECL_NSIEVENTTARGET_FULL
 
--- a/xpcom/threads/nsThreadManager.cpp
+++ b/xpcom/threads/nsThreadManager.cpp
@@ -6,20 +6,17 @@
 
 #include "nsThreadManager.h"
 #include "nsThread.h"
 #include "nsThreadUtils.h"
 #include "nsIClassInfoImpl.h"
 #include "nsTArray.h"
 #include "nsAutoPtr.h"
 #include "mozilla/AbstractThread.h"
-#include "mozilla/InputEventStatistics.h"
-#include "mozilla/SystemGroup.h"
 #include "mozilla/ThreadLocal.h"
-#include "mozilla/Preferences.h"
 #ifdef MOZ_CANARY
 #include <fcntl.h>
 #include <unistd.h>
 #endif
 
 #include "MainThreadIdlePeriod.h"
 
 using namespace mozilla;
@@ -325,17 +322,17 @@ nsThreadManager::GetMainThread(nsIThread
   NS_ADDREF(*aResult = mMainThread);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsThreadManager::GetCurrentThread(nsIThread** aResult)
 {
   // Keep this functioning during Shutdown
-  if (!mMainThread) {
+  if (NS_WARN_IF(!mMainThread)) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   *aResult = GetCurrentThread();
   if (!*aResult) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   NS_ADDREF(*aResult);
   return NS_OK;
@@ -374,68 +371,37 @@ nsThreadManager::SpinEventLoopUntilEmpty
 
   while (NS_HasPendingEvents(thread)) {
     (void)NS_ProcessNextEvent(thread, false);
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsThreadManager::GetSystemGroupEventTarget(nsIEventTarget** aTarget)
-{
-  nsCOMPtr<nsIEventTarget> target = SystemGroup::EventTargetFor(TaskCategory::Other);
-  target.forget(aTarget);
-  return NS_OK;
-}
-
 uint32_t
 nsThreadManager::GetHighestNumberOfThreads()
 {
   OffTheBooksMutexAutoLock lock(mLock);
   return mHighestNumberOfThreads;
 }
 
 NS_IMETHODIMP
-nsThreadManager::DispatchToMainThread(nsIRunnable *aEvent, uint32_t aPriority)
+nsThreadManager::DispatchToMainThread(nsIRunnable *aEvent)
 {
   // Note: C++ callers should instead use NS_DispatchToMainThread.
   MOZ_ASSERT(NS_IsMainThread());
 
   // Keep this functioning during Shutdown
   if (NS_WARN_IF(!mMainThread)) {
     return NS_ERROR_NOT_INITIALIZED;
   }
-  if (aPriority != nsIRunnablePriority::PRIORITY_NORMAL) {
-    nsCOMPtr<nsIRunnable> event(aEvent);
-    return mMainThread->DispatchFromScript(
-             new PrioritizableRunnable(event.forget(), aPriority), 0);
-  }
+
   return mMainThread->DispatchFromScript(aEvent, 0);
 }
 
-void
-nsThreadManager::EnableMainThreadEventPrioritization()
-{
-  static bool sIsInitialized = false;
-  if (sIsInitialized) {
-    return;
-  }
-  sIsInitialized = true;
-  MOZ_ASSERT(Preferences::IsServiceAvailable());
-  bool enable =
-    Preferences::GetBool("prioritized_input_events.enabled", false);
-
-  if (!enable) {
-    return;
-  }
-  InputEventStatistics::Get().SetEnable(true);
-  mMainThread->EnableEventPrioritization();
-}
-
 NS_IMETHODIMP
 nsThreadManager::IdleDispatchToMainThread(nsIRunnable *aEvent, uint32_t aTimeout)
 {
   // Note: C++ callers should instead use NS_IdleDispatchToThread or
   // NS_IdleDispatchToCurrentThread.
   MOZ_ASSERT(NS_IsMainThread());
 
   nsCOMPtr<nsIRunnable> event(aEvent);
--- a/xpcom/threads/nsThreadManager.h
+++ b/xpcom/threads/nsThreadManager.h
@@ -48,17 +48,16 @@ public:
   // simultaneously during the execution of the thread manager.
   uint32_t GetHighestNumberOfThreads();
 
   // This needs to be public in order to support static instantiation of this
   // class with older compilers (e.g., egcs-2.91.66).
   ~nsThreadManager()
   {
   }
-  void EnableMainThreadEventPrioritization();
 
 private:
   nsThreadManager()
     : mCurThreadIndex(0)
     , mMainPRThread(nullptr)
     , mLock("nsThreadManager.mLock")
     , mInitialized(false)
     , mCurrentNumberOfThreads(1)
--- a/xpcom/threads/nsThreadUtils.cpp
+++ b/xpcom/threads/nsThreadUtils.cpp
@@ -83,57 +83,16 @@ namespace detail {
 already_AddRefed<nsITimer> CreateTimer()
 {
   nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID);
   return timer.forget();
 }
 } // namespace detail
 } // namespace mozilla
 
-NS_IMPL_ISUPPORTS_INHERITED(PrioritizableRunnable, Runnable,
-                            nsIRunnablePriority)
-
-PrioritizableRunnable::PrioritizableRunnable(already_AddRefed<nsIRunnable>&& aRunnable,
-                                             uint32_t aPriority)
- // Real runnable name is managed by overridding the GetName function.
- : Runnable("PrioritizableRunnable")
- , mRunnable(Move(aRunnable))
- , mPriority(aPriority)
-{
-#if DEBUG
-  nsCOMPtr<nsIRunnablePriority> runnablePrio = do_QueryInterface(mRunnable);
-  MOZ_ASSERT(!runnablePrio);
-#endif
-}
-
-NS_IMETHODIMP
-PrioritizableRunnable::GetName(nsACString& aName)
-{
-  // Try to get a name from the underlying runnable.
-  nsCOMPtr<nsINamed> named = do_QueryInterface(mRunnable);
-  if (named) {
-    named->GetName(aName);
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-PrioritizableRunnable::Run()
-{
-  MOZ_RELEASE_ASSERT(NS_IsMainThread());
-  return mRunnable->Run();
-}
-
-NS_IMETHODIMP
-PrioritizableRunnable::GetPriority(uint32_t* aPriority)
-{
-  *aPriority = mPriority;
-  return NS_OK;
-}
-
 #endif  // XPCOM_GLUE_AVOID_NSPR
 
 //-----------------------------------------------------------------------------
 
 nsresult
 NS_NewNamedThread(const nsACString& aName,
                   nsIThread** aResult,
                   nsIRunnable* aEvent,
--- a/xpcom/threads/nsThreadUtils.h
+++ b/xpcom/threads/nsThreadUtils.h
@@ -481,36 +481,16 @@ public:
 protected:
   virtual ~IdleRunnable() {}
 private:
   IdleRunnable(const IdleRunnable&) = delete;
   IdleRunnable& operator=(const IdleRunnable&) = delete;
   IdleRunnable& operator=(const IdleRunnable&&) = delete;
 };
 
-// This class is designed to be a wrapper of a real runnable to support event
-// prioritizable.
-class PrioritizableRunnable : public Runnable, public nsIRunnablePriority
-{
-public:
-  PrioritizableRunnable(already_AddRefed<nsIRunnable>&& aRunnable,
-                        uint32_t aPriority);
-
-  NS_IMETHOD GetName(nsACString& aName) override;
-
-  NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_NSIRUNNABLE
-  NS_DECL_NSIRUNNABLEPRIORITY
-
-protected:
-  virtual ~PrioritizableRunnable() {};
-  nsCOMPtr<nsIRunnable> mRunnable;
-  uint32_t mPriority;
-};
-
 namespace detail {
 
 // An event that can be used to call a C++11 functions or function objects,
 // including lambdas. The function must have no required arguments, and must
 // return void.
 template<typename StoredFunction>
 class RunnableFunction : public Runnable
 {
--- a/xpcom/threads/nsTimerImpl.h
+++ b/xpcom/threads/nsTimerImpl.h
@@ -127,17 +127,17 @@ public:
     Name mName;
 
     void*                 mClosure;
   };
 
   nsresult InitCommon(uint32_t aDelayMS, uint32_t aType,
                       Callback&& newCallback);
 
-  nsresult InitCommon(const mozilla::TimeDuration& aDelay, uint32_t aType,
+  nsresult InitCommon(const TimeDuration& aDelay, uint32_t aType,
                       Callback&& newCallback);
 
   Callback& GetCallback()
   {
     mMutex.AssertCurrentThreadOwns();
     if (mCallback.mType == Callback::Type::Unknown) {
       return mCallbackDuringFire;
     }
@@ -195,19 +195,19 @@ public:
   uint8_t               mType;
 
   // The generation number of this timer, re-generated each time the timer is
   // initialized so one-shot timers can be canceled and re-initialized by the
   // arming thread without any bad race conditions.
   // Updated only after this timer has been removed from the timer thread.
   int32_t               mGeneration;
 
-  mozilla::TimeDuration mDelay;
+  TimeDuration          mDelay;
   // Updated only after this timer has been removed from the timer thread.
-  mozilla::TimeStamp    mTimeout;
+  TimeStamp             mTimeout;
 
 #ifdef MOZ_TASK_TRACER
   mozilla::tasktracer::TracedTaskCommon mTracedTask;
 #endif
 
   static double         sDeltaSum;
   static double         sDeltaSumSquared;
   static double         sDeltaNum;