From a8d469a8d0564b390c59a1e22ccba0126d796a8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Sun, 16 Jan 2022 23:31:22 +0000
Subject: [PATCH] Bug 1744009 - Simplify combobox <select> code.
 r=mconley,dholbert

With this patch on its own we get some a11y tests failures, but those
are fixed on a later patch.

Combobox select no longer creates frames for its <options>, nor an
nsListControlFrame. Instead, it computes its right intrinsic size using
the largest size of the options. This is better, because we render the
option text using the select style so if the select and option styles
are mismatched it'd cause changes in the size of the select when text
changes. See the following in a build without the patch, for example:

  <select>
    <option>ABC</option>
    <option style="font-size: 1px">Something long</option>
  </select>

This seems like a rather obscure case, but it's important to get it
right, see bug 1741888.

With this patch we use the same setup in content and parent processes
(this needs bug 1596852 and bug 1744152). This means we can remove a
bunch of the native view and popup code in nsListControlFrame. A couple
browser_* tests are affected by this change and have been tweaked
appropriately (the changes there are trivial).

Not creating an nsListControlFrame for dropdown select means that we
need to move a bunch of the event handling code from nsListControlFrame
to a common place that nsComboboxControlFrame can also use. That place
is HTMLSelectEventListener, and I think the setup is much nicer than
having the code intertwined with nsListControlFrame. It should be
relatively straight-forward to review, mostly moving code from one part
to another.

Another thing that we need to do in HTMLSelectEventListener that we
didn't use to do is listening for DOM mutations on the dropdown. Before,
we were relying on changes like text mutations triggering a reflow of
the listcontrolframe, which also triggered a reflow of the
comboboxcontrolframe, which in turn updated the text of the anonymous
content. Now we need to trigger that reflow manually.

There are some further simplifications that can be done after this
lands (cleanup naming of openInParentProcess and so on, among others),
but I'd rather land this first (after the merge of course) and work on
them separately.

Differential Revision: https://phabricator.services.mozilla.com/D132719
---
 accessible/html/HTMLSelectAccessible.cpp      |   22 +-
 accessible/html/HTMLSelectAccessible.h        |    1 -
 browser/base/content/browser.xhtml            |    1 +
 browser/base/content/main-popupset.inc.xhtml  |    1 +
 .../content/test/forms/browser_selectpopup.js |    5 +-
 .../test/forms/browser_selectpopup_colors.js  |    5 +-
 .../forms/browser_selectpopup_searchfocus.js  |    5 +-
 .../test/tabdialogs/browser_subdialog_esc.js  |    4 +-
 devtools/client/framework/toolbox-hosts.js    |    1 +
 ...on_logic_adjust-time-with-playback-rate.js |    2 +-
 ..._animation_pause-resume-button_end-time.js |    2 +-
 ...rowser_animation_playback-rate-selector.js |    6 +-
 .../client/inspector/animation/test/head.js   |   22 +-
 dom/events/EventStateManager.cpp              |   11 -
 dom/html/HTMLSelectElement.cpp                |   17 +-
 dom/html/HTMLSelectElement.h                  |    4 +-
 layout/base/nsCSSFrameConstructor.cpp         |   51 +-
 layout/base/nsCSSFrameConstructor.h           |   17 +-
 layout/base/nsLayoutUtils.cpp                 |   17 +-
 layout/build/nsLayoutStatics.cpp              |    2 -
 layout/forms/HTMLSelectEventListener.cpp      |  804 ++++++++++
 layout/forms/HTMLSelectEventListener.h        |  102 ++
 layout/forms/moz.build                        |    1 +
 layout/forms/nsComboboxControlFrame.cpp       |  844 ++---------
 layout/forms/nsComboboxControlFrame.h         |  111 +-
 layout/forms/nsListControlFrame.cpp           | 1299 +----------------
 layout/forms/nsListControlFrame.h             |  154 +-
 layout/forms/nsSelectsAreaFrame.cpp           |   20 +-
 layout/forms/test/bug665540_window.xhtml      |   12 -
 layout/forms/test/chrome.ini                  |    4 -
 layout/forms/test/test_bug665540.html         |  133 --
 ...test_select_key_navigation_bug1498769.html |    9 +-
 layout/generic/nsFontInflationData.cpp        |    4 +-
 layout/generic/nsGfxScrollFrame.cpp           |   29 +-
 layout/generic/nsGfxScrollFrame.h             |   14 -
 layout/generic/nsIScrollableFrame.h           |    5 +-
 layout/generic/nsTextFrameUtils.cpp           |   62 +-
 layout/generic/nsTextFrameUtils.h             |    4 +-
 modules/libpref/init/all.js                   |    1 -
 ...select-intrinsic-option-font-size-ref.html |    5 +
 .../select-intrinsic-option-font-size.html    |    6 +
 .../tests/browser_destination_change.js       |    9 +-
 .../printing/tests/browser_print_duplex.js    |   16 +-
 .../printing/tests/browser_print_margins.js   |   89 +-
 .../tests/browser_print_page_range.js         |   46 +-
 .../printing/tests/browser_sheet_count.js     |   22 +-
 widget/windows/nsNativeThemeWin.cpp           |    4 +-
 47 files changed, 1357 insertions(+), 2648 deletions(-)
 create mode 100644 layout/forms/HTMLSelectEventListener.cpp
 create mode 100644 layout/forms/HTMLSelectEventListener.h
 delete mode 100644 layout/forms/test/bug665540_window.xhtml
 delete mode 100644 layout/forms/test/test_bug665540.html
 create mode 100644 testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size-ref.html
 create mode 100644 testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size.html

diff --git a/accessible/html/HTMLSelectAccessible.cpp b/accessible/html/HTMLSelectAccessible.cpp
index e8ef7294ce69..7c25f3c7b801 100644
--- a/accessible/html/HTMLSelectAccessible.cpp
+++ b/accessible/html/HTMLSelectAccessible.cpp
@@ -308,14 +308,10 @@ HTMLComboboxAccessible::HTMLComboboxAccessible(nsIContent* aContent,
   mGenericTypes |= eCombobox;
   mStateFlags |= eNoKidsFromDOM;
 
-  nsComboboxControlFrame* comboFrame = do_QueryFrame(GetFrame());
-  if (comboFrame) {
-    nsIFrame* listFrame = comboFrame->GetDropDown();
-    if (listFrame) {
-      mListAccessible = new HTMLComboboxListAccessible(mParent, mContent, mDoc);
-      Document()->BindToDocument(mListAccessible, nullptr);
-      AppendChild(mListAccessible);
-    }
+  if ((nsComboboxControlFrame*)do_QueryFrame(GetFrame())) {
+    mListAccessible = new HTMLComboboxListAccessible(mParent, mContent, mDoc);
+    Document()->BindToDocument(mListAccessible, nullptr);
+    AppendChild(mListAccessible);
   }
 }
 
@@ -458,16 +454,6 @@ HTMLComboboxListAccessible::HTMLComboboxListAccessible(LocalAccessible* aParent,
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLComboboxAccessible: LocalAccessible
 
-nsIFrame* HTMLComboboxListAccessible::GetFrame() const {
-  nsIFrame* frame = HTMLSelectListAccessible::GetFrame();
-  nsComboboxControlFrame* comboBox = do_QueryFrame(frame);
-  if (comboBox) {
-    return comboBox->GetDropDown();
-  }
-
-  return nullptr;
-}
-
 role HTMLComboboxListAccessible::NativeRole() const {
   return roles::COMBOBOX_LIST;
 }
diff --git a/accessible/html/HTMLSelectAccessible.h b/accessible/html/HTMLSelectAccessible.h
index 4e9f96d4708d..9ccf611259a6 100644
--- a/accessible/html/HTMLSelectAccessible.h
+++ b/accessible/html/HTMLSelectAccessible.h
@@ -205,7 +205,6 @@ class HTMLComboboxListAccessible : public HTMLSelectListAccessible {
   virtual ~HTMLComboboxListAccessible() {}
 
   // LocalAccessible
-  virtual nsIFrame* GetFrame() const override;
   virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() const override;
   virtual nsRect RelativeBounds(nsIFrame** aBoundingFrame) const override;
diff --git a/browser/base/content/browser.xhtml b/browser/base/content/browser.xhtml
index 71480fc2f6d4..3c8f487a8f35 100644
--- a/browser/base/content/browser.xhtml
+++ b/browser/base/content/browser.xhtml
@@ -136,6 +136,7 @@
       <hbox class="dialogBox">
         <browser class="dialogFrame"
                  autoscroll="false"
+                 selectmenulist="ContentSelectDropdown"
                  disablehistory="true"/>
       </hbox>
     </vbox>
diff --git a/browser/base/content/main-popupset.inc.xhtml b/browser/base/content/main-popupset.inc.xhtml
index 100c2f0eff02..c531d2b0ce10 100644
--- a/browser/base/content/main-popupset.inc.xhtml
+++ b/browser/base/content/main-popupset.inc.xhtml
@@ -283,6 +283,7 @@
       <vbox class="dialogTemplate dialogOverlay" align="center" topmost="true" hidden="true">
         <hbox class="dialogBox">
           <browser class="dialogFrame"
+                   selectmenulist="ContentSelectDropdown"
                    autoscroll="false"
                    disablehistory="true"/>
         </hbox>
diff --git a/browser/base/content/test/forms/browser_selectpopup.js b/browser/base/content/test/forms/browser_selectpopup.js
index 2c72ce8f7d00..88573f38d2e3 100644
--- a/browser/base/content/test/forms/browser_selectpopup.js
+++ b/browser/base/content/test/forms/browser_selectpopup.js
@@ -323,10 +323,7 @@ async function doSelectTests(contentType, content) {
 
 add_task(async function setup() {
   await SpecialPowers.pushPrefEnv({
-    set: [
-      ["dom.select_popup_in_parent.enabled", true],
-      ["dom.forms.select.customstyling", true],
-    ],
+    set: [["dom.forms.select.customstyling", true]],
   });
 });
 
diff --git a/browser/base/content/test/forms/browser_selectpopup_colors.js b/browser/base/content/test/forms/browser_selectpopup_colors.js
index acb280e4b9a3..1b2805fdf890 100644
--- a/browser/base/content/test/forms/browser_selectpopup_colors.js
+++ b/browser/base/content/test/forms/browser_selectpopup_colors.js
@@ -461,10 +461,7 @@ let kDefaultSelectStyles = {};
 
 add_task(async function setup() {
   await SpecialPowers.pushPrefEnv({
-    set: [
-      ["dom.select_popup_in_parent.enabled", true],
-      ["dom.forms.select.customstyling", true],
-    ],
+    set: [["dom.forms.select.customstyling", true]],
   });
   kDefaultSelectStyles = await BrowserTestUtils.withNewTab(
     `data:text/html,<select>`,
diff --git a/browser/base/content/test/forms/browser_selectpopup_searchfocus.js b/browser/base/content/test/forms/browser_selectpopup_searchfocus.js
index bdfcf9800503..72ce956cb0e1 100644
--- a/browser/base/content/test/forms/browser_selectpopup_searchfocus.js
+++ b/browser/base/content/test/forms/browser_selectpopup_searchfocus.js
@@ -8,10 +8,7 @@ SELECT +=
 
 add_task(async function setup() {
   await SpecialPowers.pushPrefEnv({
-    set: [
-      ["dom.select_popup_in_parent.enabled", true],
-      ["dom.forms.selectSearch", true],
-    ],
+    set: [["dom.forms.selectSearch", true]],
   });
 });
 
diff --git a/browser/base/content/test/tabdialogs/browser_subdialog_esc.js b/browser/base/content/test/tabdialogs/browser_subdialog_esc.js
index f39723d003ed..84bf07478911 100644
--- a/browser/base/content/test/tabdialogs/browser_subdialog_esc.js
+++ b/browser/base/content/test/tabdialogs/browser_subdialog_esc.js
@@ -80,7 +80,7 @@ add_task(async function test_subdialog_esc_on_dropdown_does_not_close_dialog() {
     // Open dropdown
     let select = dialog._frame.contentDocument.getElementById("select");
     let shownPromise = BrowserTestUtils.waitForEvent(
-      select,
+      document.getElementById("ContentSelectDropdown"),
       "popupshowing",
       true
     );
@@ -92,7 +92,7 @@ add_task(async function test_subdialog_esc_on_dropdown_does_not_close_dialog() {
     await shownPromise;
 
     let hiddenPromise = BrowserTestUtils.waitForEvent(
-      select,
+      document.getElementById("ContentSelectDropdown"),
       "popuphiding",
       true
     );
diff --git a/devtools/client/framework/toolbox-hosts.js b/devtools/client/framework/toolbox-hosts.js
index 200d1af4ed13..4facba5771ba 100644
--- a/devtools/client/framework/toolbox-hosts.js
+++ b/devtools/client/framework/toolbox-hosts.js
@@ -420,6 +420,7 @@ function createDevToolsFrame(doc, className) {
   frame.setAttribute("type", "content");
   frame.flex = 1; // Required to be able to shrink when the window shrinks
   frame.className = className;
+  frame.setAttribute("selectmenulist", "ContentSelectDropdown");
 
   const inXULDocument = doc.documentElement.namespaceURI === XUL_NS;
   if (inXULDocument) {
diff --git a/devtools/client/inspector/animation/test/browser_animation_logic_adjust-time-with-playback-rate.js b/devtools/client/inspector/animation/test/browser_animation_logic_adjust-time-with-playback-rate.js
index d924c2ba7a9c..7cd7634b534a 100644
--- a/devtools/client/inspector/animation/test/browser_animation_logic_adjust-time-with-playback-rate.js
+++ b/devtools/client/inspector/animation/test/browser_animation_logic_adjust-time-with-playback-rate.js
@@ -30,7 +30,7 @@ add_task(async function() {
   info("Change the playback rate to x10 after selecting '.div2'");
   await selectNode(".div2", inspector);
   await waitUntil(() => panel.querySelectorAll(".animation-item").length === 1);
-  clickOnPlaybackRateSelector(animationInspector, panel, 10);
+  await changePlaybackRateSelector(animationInspector, panel, 10);
 
   info("Check each adjusted result of animations after selecting 'body' again");
   await selectNode("body", inspector);
diff --git a/devtools/client/inspector/animation/test/browser_animation_pause-resume-button_end-time.js b/devtools/client/inspector/animation/test/browser_animation_pause-resume-button_end-time.js
index 8510aa120221..065319ac0710 100644
--- a/devtools/client/inspector/animation/test/browser_animation_pause-resume-button_end-time.js
+++ b/devtools/client/inspector/animation/test/browser_animation_pause-resume-button_end-time.js
@@ -40,7 +40,7 @@ add_task(async function() {
   info("Make the current time of animation to be over its end time");
   clickOnCurrentTimeScrubberController(animationInspector, panel, 1.1);
   await waitUntilAnimationsPlayState(animationInspector, "paused");
-  clickOnPlaybackRateSelector(animationInspector, panel, 0.1);
+  await changePlaybackRateSelector(animationInspector, panel, 0.1);
   info("Resume animations");
   clickOnPauseResumeButton(animationInspector, panel);
   await waitUntilAnimationsPlayState(animationInspector, "running");
diff --git a/devtools/client/inspector/animation/test/browser_animation_playback-rate-selector.js b/devtools/client/inspector/animation/test/browser_animation_playback-rate-selector.js
index 29ff99453da4..0f0f3c971eec 100644
--- a/devtools/client/inspector/animation/test/browser_animation_playback-rate-selector.js
+++ b/devtools/client/inspector/animation/test/browser_animation_playback-rate-selector.js
@@ -31,13 +31,13 @@ add_task(async function() {
   is(Number(selectEl.value), 1.5, "Selected option should be 1.5");
 
   info("Checking playback rate of animations");
-  clickOnPlaybackRateSelector(animationInspector, panel, 0.5);
+  await changePlaybackRateSelector(animationInspector, panel, 0.5);
   await assertPlaybackRate(animationInspector, 0.5);
 
   info("Checking mixed playback rate");
   await selectNode("div", inspector);
   await waitUntil(() => panel.querySelectorAll(".animation-item").length === 1);
-  clickOnPlaybackRateSelector(animationInspector, panel, 2);
+  await changePlaybackRateSelector(animationInspector, panel, 2);
   await assertPlaybackRate(animationInspector, 2);
   await selectNode("body", inspector);
   await waitUntil(() => panel.querySelectorAll(".animation-item").length === 2);
@@ -45,7 +45,7 @@ add_task(async function() {
   ok(true, "Selected option should be empty");
 
   info("Checking playback rate after re-setting");
-  clickOnPlaybackRateSelector(animationInspector, panel, 1);
+  await changePlaybackRateSelector(animationInspector, panel, 1);
   await assertPlaybackRate(animationInspector, 1);
 
   info(
diff --git a/devtools/client/inspector/animation/test/head.js b/devtools/client/inspector/animation/test/head.js
index a7299d96ee07..4b5b5a84d05e 100644
--- a/devtools/client/inspector/animation/test/head.js
+++ b/devtools/client/inspector/animation/test/head.js
@@ -269,21 +269,23 @@ const clickOnInspectIcon = async function(animationInspector, panel, index) {
 };
 
 /**
- * Click on playback rate selector to select given rate.
+ * Change playback rate selector to select given rate.
  *
  * @param {AnimationInspector} animationInspector
  * @param {DOMElement} panel
  *        #animation-container element.
  * @param {Number} rate
  */
-const clickOnPlaybackRateSelector = function(animationInspector, panel, rate) {
+const changePlaybackRateSelector = async function(
+  animationInspector,
+  panel,
+  rate
+) {
   info(`Click on playback rate selector to select ${rate}`);
   const selectEl = panel.querySelector(".playback-rate-selector");
-  const optionEl = [...selectEl.options].filter(
-    o => Number(o.value) === rate
-  )[0];
+  const optionIndex = [...selectEl.options].findIndex(o => +o.value == rate);
 
-  if (!optionEl) {
+  if (optionIndex == -1) {
     ok(
       false,
       `Could not find an option for rate ${rate} in the rate selector. ` +
@@ -292,9 +294,13 @@ const clickOnPlaybackRateSelector = function(animationInspector, panel, rate) {
     return;
   }
 
+  selectEl.focus();
+
   const win = selectEl.ownerGlobal;
-  EventUtils.synthesizeMouseAtCenter(selectEl, { type: "mousedown" }, win);
-  EventUtils.synthesizeMouseAtCenter(optionEl, { type: "mouseup" }, win);
+  while (selectEl.selectedIndex != optionIndex) {
+    const key = selectEl.selectedIndex > optionIndex ? "LEFT" : "RIGHT";
+    EventUtils.sendKey(key, win);
+  }
 };
 
 /**
diff --git a/dom/events/EventStateManager.cpp b/dom/events/EventStateManager.cpp
index acfa341ffdae..d736ee045f63 100644
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -2815,17 +2815,6 @@ nsIFrame* EventStateManager::ComputeScrollTargetAndMayAdjustWheelEvent(
       canScroll = true;
     }
 
-    // Comboboxes need special care.
-    nsComboboxControlFrame* comboBox = do_QueryFrame(scrollFrame);
-    if (comboBox) {
-      if (comboBox->IsDroppedDown()) {
-        // Don't propagate to parent when drop down menu is active.
-        return canScroll ? frameToScroll : nullptr;
-      }
-      // Always propagate when not dropped down (even if focused).
-      continue;
-    }
-
     if (canScroll) {
       return frameToScroll;
     }
diff --git a/dom/html/HTMLSelectElement.cpp b/dom/html/HTMLSelectElement.cpp
index ddf62aa70c4f..36d877ce49b4 100644
--- a/dom/html/HTMLSelectElement.cpp
+++ b/dom/html/HTMLSelectElement.cpp
@@ -1423,20 +1423,9 @@ HTMLSelectElement::SubmitNamesValues(FormData* aFormData) {
 }
 
 void HTMLSelectElement::DispatchContentReset() {
-  nsIFormControlFrame* formControlFrame = GetFormControlFrame(false);
-  if (formControlFrame) {
-    // Only dispatch content reset notification if this is a list control
-    // frame or combo box control frame.
-    if (IsCombobox()) {
-      nsComboboxControlFrame* comboFrame = do_QueryFrame(formControlFrame);
-      if (comboFrame) {
-        comboFrame->OnContentReset();
-      }
-    } else {
-      nsListControlFrame* listFrame = do_QueryFrame(formControlFrame);
-      if (listFrame) {
-        listFrame->OnContentReset();
-      }
+  if (nsIFormControlFrame* formControlFrame = GetFormControlFrame(false)) {
+    if (nsListControlFrame* listFrame = do_QueryFrame(formControlFrame)) {
+      listFrame->OnContentReset();
     }
   }
 }
diff --git a/dom/html/HTMLSelectElement.h b/dom/html/HTMLSelectElement.h
index 1e24e91f3eef..f520f2e9ea02 100644
--- a/dom/html/HTMLSelectElement.h
+++ b/dom/html/HTMLSelectElement.h
@@ -437,8 +437,8 @@ class HTMLSelectElement final : public nsGenericHTMLFormControlElementWithState,
   nsISelectControlFrame* GetSelectFrame();
 
   /**
-   * Helper method for dispatching ContentReset notifications to list
-   * and combo box frames.
+   * Helper method for dispatching ContentReset notifications to list box
+   * frames.
    */
   void DispatchContentReset();
 
diff --git a/layout/base/nsCSSFrameConstructor.cpp b/layout/base/nsCSSFrameConstructor.cpp
index 4425a6bd407c..0a4dcb44fb43 100644
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -2911,34 +2911,9 @@ nsIFrame* nsCSSFrameConstructor::ConstructSelectFrame(
         mPresShell->StyleSet()->ResolveInheritingAnonymousBoxStyle(
             PseudoStyleType::dropDownList, computedStyle);
 
-    // Create a listbox
-    nsListControlFrame* listFrame =
-        NS_NewListControlFrame(mPresShell, listStyle);
-
-    // Notify the listbox that it is being used as a dropdown list.
-    listFrame->SetComboboxFrame(comboboxFrame);
-
-    // Notify combobox that it should use the listbox as it's popup
-    comboboxFrame->SetDropDown(listFrame);
-
-    NS_ASSERTION(!listFrame->IsAbsPosContainingBlock(),
-                 "Ended up with positioned dropdown list somehow.");
-    NS_ASSERTION(!listFrame->IsFloating(),
-                 "Ended up with floating dropdown list somehow.");
-
     // child frames of combobox frame
     nsFrameList childList;
 
-    // Initialize the scroll frame positioned. Note that it is NOT
-    // initialized as absolutely positioned.
-    nsContainerFrame* scrolledFrame =
-        NS_NewSelectsAreaFrame(mPresShell, computedStyle, flags);
-
-    InitializeSelectFrame(aState, listFrame, scrolledFrame, content,
-                          comboboxFrame, listStyle, true, childList);
-
-    NS_ASSERTION(listFrame->GetView(), "ListFrame's view is nullptr");
-
     // Create display and button frames from the combobox's anonymous content.
     // The anonymous content is appended to existing anonymous content for this
     // element (the scrollbars).
@@ -2973,12 +2948,6 @@ nsIFrame* nsCSSFrameConstructor::ConstructSelectFrame(
 
     comboboxFrame->SetInitialChildList(kPrincipalList, childList);
 
-    // Initialize the additional popup child list which contains the
-    // dropdown list frame.
-    nsFrameList popupList;
-    popupList.AppendFrame(nullptr, listFrame);
-    comboboxFrame->SetInitialChildList(nsIFrame::kSelectPopupList, popupList);
-
     aState.mFrameState = historyState;
     if (aState.mFrameState) {
       // Restore frame state for the entire subtree of |comboboxFrame|.
@@ -2997,22 +2966,17 @@ nsIFrame* nsCSSFrameConstructor::ConstructSelectFrame(
   // ******* this code stolen from Initialze ScrollFrame ********
   // please adjust this code to use BuildScrollFrame.
 
-  InitializeSelectFrame(aState, listFrame, scrolledFrame, content, aParentFrame,
-                        computedStyle, false, aFrameList);
+  InitializeListboxSelect(aState, listFrame, scrolledFrame, content,
+                          aParentFrame, computedStyle, aFrameList);
 
   return listFrame;
 }
 
-/**
- * Used to be InitializeScrollFrame but now it's only used for the select tag
- * But the select tag should really be fixed to use GFX scrollbars that can
- * be create with BuildScrollFrame.
- */
-void nsCSSFrameConstructor::InitializeSelectFrame(
+void nsCSSFrameConstructor::InitializeListboxSelect(
     nsFrameConstructorState& aState, nsContainerFrame* scrollFrame,
     nsContainerFrame* scrolledFrame, nsIContent* aContent,
     nsContainerFrame* aParentFrame, ComputedStyle* aComputedStyle,
-    bool aBuildCombobox, nsFrameList& aFrameList) {
+    nsFrameList& aFrameList) {
   // Initialize it
   nsContainerFrame* geometricParent =
       aState.GetGeometricParent(*aComputedStyle->StyleDisplay(), aParentFrame);
@@ -3022,14 +2986,9 @@ void nsCSSFrameConstructor::InitializeSelectFrame(
   // the scrollable view). So we have to split Init and Restore.
 
   scrollFrame->Init(aContent, geometricParent, nullptr);
-
-  if (!aBuildCombobox) {
-    aState.AddChild(scrollFrame, aFrameList, aContent, aParentFrame);
-  }
-
+  aState.AddChild(scrollFrame, aFrameList, aContent, aParentFrame);
   BuildScrollFrame(aState, aContent, aComputedStyle, scrolledFrame,
                    geometricParent, scrollFrame);
-
   if (aState.mFrameState) {
     // Restore frame state for the scroll frame
     RestoreFrameStateFor(scrollFrame, aState.mFrameState);
diff --git a/layout/base/nsCSSFrameConstructor.h b/layout/base/nsCSSFrameConstructor.h
index f2f8001c4653..93e22caa5f28 100644
--- a/layout/base/nsCSSFrameConstructor.h
+++ b/layout/base/nsCSSFrameConstructor.h
@@ -1662,16 +1662,13 @@ class nsCSSFrameConstructor final : public nsFrameManager {
   void FinishBuildingScrollFrame(nsContainerFrame* aScrollFrame,
                                  nsIFrame* aScrolledFrame);
 
-  // InitializeSelectFrame puts scrollFrame in aFrameList if aBuildCombobox is
-  // false aBuildCombobox indicates if we are building a combobox that has a
-  // dropdown popup widget or not.
-  void InitializeSelectFrame(nsFrameConstructorState& aState,
-                             nsContainerFrame* aScrollFrame,
-                             nsContainerFrame* aScrolledFrame,
-                             nsIContent* aContent,
-                             nsContainerFrame* aParentFrame,
-                             ComputedStyle* aComputedStyle, bool aBuildCombobox,
-                             nsFrameList& aFrameList);
+  void InitializeListboxSelect(nsFrameConstructorState& aState,
+                               nsContainerFrame* aScrollFrame,
+                               nsContainerFrame* aScrolledFrame,
+                               nsIContent* aContent,
+                               nsContainerFrame* aParentFrame,
+                               ComputedStyle* aComputedStyle,
+                               nsFrameList& aFrameList);
 
   /**
    * Recreate frames for aContent.
diff --git a/layout/base/nsLayoutUtils.cpp b/layout/base/nsLayoutUtils.cpp
index bdffdbea78b1..f397756dd1ac 100644
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -6850,27 +6850,14 @@ nsTransparencyMode nsLayoutUtils::GetFrameTransparency(
   return eTransparencyOpaque;
 }
 
-static bool IsPopupFrame(const nsIFrame* aFrame) {
-  // aFrame is a popup it's the list control frame dropdown for a combobox.
-  LayoutFrameType frameType = aFrame->Type();
-  if (frameType == LayoutFrameType::ListControl) {
-    const nsListControlFrame* lcf =
-        static_cast<const nsListControlFrame*>(aFrame);
-    return lcf->IsInDropDownMode();
-  }
-
-  // ... or if it's a XUL menupopup frame.
-  return frameType == LayoutFrameType::MenuPopup;
-}
-
 /* static */
 bool nsLayoutUtils::IsPopup(const nsIFrame* aFrame) {
   // Optimization: the frame can't possibly be a popup if it has no view.
   if (!aFrame->HasView()) {
-    NS_ASSERTION(!IsPopupFrame(aFrame), "popup frame must have a view");
+    NS_ASSERTION(!aFrame->IsMenuPopupFrame(), "popup frame must have a view");
     return false;
   }
-  return IsPopupFrame(aFrame);
+  return aFrame->IsMenuPopupFrame();
 }
 
 /* static */
diff --git a/layout/build/nsLayoutStatics.cpp b/layout/build/nsLayoutStatics.cpp
index 06675a37fac4..c7337bfda78f 100644
--- a/layout/build/nsLayoutStatics.cpp
+++ b/layout/build/nsLayoutStatics.cpp
@@ -47,7 +47,6 @@
 #include "nsHtml5Module.h"
 #include "nsHTMLTags.h"
 #include "nsFocusManager.h"
-#include "nsListControlFrame.h"
 #include "mozilla/dom/HTMLDNSPrefetch.h"
 #include "mozilla/dom/HTMLInputElement.h"
 #include "mozilla/dom/SVGElementFactory.h"
@@ -356,7 +355,6 @@ void nsLayoutStatics::Shutdown() {
   ShutdownJSEnvironment();
   nsGlobalWindowInner::ShutDown();
   nsGlobalWindowOuter::ShutDown();
-  nsListControlFrame::Shutdown();
 
   CubebUtils::ShutdownLibrary();
   WebAudioUtils::Shutdown();
diff --git a/layout/forms/HTMLSelectEventListener.cpp b/layout/forms/HTMLSelectEventListener.cpp
new file mode 100644
index 000000000000..158c390d0597
--- /dev/null
+++ b/layout/forms/HTMLSelectEventListener.cpp
@@ -0,0 +1,804 @@
+/* -*- 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 "HTMLSelectEventListener.h"
+
+#include "nsListControlFrame.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/MouseEvent.h"
+#include "mozilla/Casting.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/dom/HTMLSelectElement.h"
+#include "mozilla/dom/HTMLOptionElement.h"
+#include "mozilla/StaticPrefs_ui.h"
+#include "mozilla/ClearOnShutdown.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+static bool IsOptionInteractivelySelectable(HTMLSelectElement& aSelect,
+                                            HTMLOptionElement& aOption,
+                                            bool aIsCombobox) {
+  if (aSelect.IsOptionDisabled(&aOption)) {
+    return false;
+  }
+  if (!aIsCombobox) {
+    return aOption.GetPrimaryFrame();
+  }
+  // In dropdown mode no options have frames, but we can check whether they
+  // are rendered / not in a display: none subtree.
+  if (!aOption.HasServoData() || Servo_Element_IsDisplayNone(&aOption)) {
+    return false;
+  }
+  // TODO(emilio): This is a bit silly and doesn't match the options that we
+  // show / don't show in the dropdown, but matches the frame construction we
+  // do for multiple selects. For backwards compat also don't allow selecting
+  // options in a display: contents subtree interactively.
+  // test_select_key_navigation_bug1498769.html tests for this and should
+  // probably be changed (and this loop removed) or alternatively
+  // SelectChild.jsm should be changed to match it.
+  for (Element* el = &aOption; el && el != &aSelect;
+       el = el->GetParentElement()) {
+    if (Servo_Element_IsDisplayContents(el)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+namespace mozilla {
+
+static StaticAutoPtr<nsString> sIncrementalString;
+static DOMTimeStamp gLastKeyTime = 0;
+static constexpr int32_t kNothingSelected = -1;
+
+static nsString& GetIncrementalString() {
+  if (!sIncrementalString) {
+    sIncrementalString = new nsString();
+    ClearOnShutdown(&sIncrementalString);
+  }
+  return *sIncrementalString;
+}
+
+class MOZ_RAII AutoIncrementalSearchResetter {
+ public:
+  AutoIncrementalSearchResetter() = default;
+  ~AutoIncrementalSearchResetter() {
+    if (!mCancelled) {
+      GetIncrementalString().Truncate();
+    }
+  }
+  void Cancel() { mCancelled = true; }
+
+ private:
+  bool mCancelled = false;
+};
+
+NS_IMPL_ISUPPORTS(HTMLSelectEventListener, nsIMutationObserver,
+                  nsIDOMEventListener)
+
+HTMLSelectEventListener::~HTMLSelectEventListener() = default;
+
+nsListControlFrame* HTMLSelectEventListener::GetListControlFrame() const {
+  if (mIsCombobox) {
+    MOZ_ASSERT(!mElement->GetPrimaryFrame() ||
+               !mElement->GetPrimaryFrame()->IsListControlFrame());
+    return nullptr;
+  }
+  return do_QueryFrame(mElement->GetPrimaryFrame());
+}
+
+int32_t HTMLSelectEventListener::GetEndSelectionIndex() const {
+  if (auto* lf = GetListControlFrame()) {
+    return lf->GetEndSelectionIndex();
+  }
+  // Combobox selects only have one selected index, so the end and start is the
+  // same.
+  return mElement->SelectedIndex();
+}
+
+bool HTMLSelectEventListener::IsOptionInteractivelySelectable(
+    uint32_t aIndex) const {
+  HTMLOptionElement* option = mElement->Item(aIndex);
+  return option &&
+         ::IsOptionInteractivelySelectable(*mElement, *option, mIsCombobox);
+}
+
+//---------------------------------------------------------------------
+// Ok, the entire idea of this routine is to move to the next item that
+// is suppose to be selected. If the item is disabled then we search in
+// the same direction looking for the next item to select. If we run off
+// the end of the list then we start at the end of the list and search
+// backwards until we get back to the original item or an enabled option
+//
+// aStartIndex - the index to start searching from
+// aNewIndex - will get set to the new index if it finds one
+// aNumOptions - the total number of options in the list
+// aDoAdjustInc - the initial index increment / decrement
+// aDoAdjustIncNext - the subsequent index increment/decrement used to search
+//                    for the next enabled option
+//
+// the aDoAdjustInc could be a "1" for a single item or
+// any number greater representing a page of items
+//
+void HTMLSelectEventListener::AdjustIndexForDisabledOpt(
+    int32_t aStartIndex, int32_t& aNewIndex, int32_t aNumOptions,
+    int32_t aDoAdjustInc, int32_t aDoAdjustIncNext) {
+  // Cannot select anything if there is nothing to select
+  if (aNumOptions == 0) {
+    aNewIndex = kNothingSelected;
+    return;
+  }
+
+  // means we reached the end of the list and now we are searching backwards
+  bool doingReverse = false;
+  // lowest index in the search range
+  int32_t bottom = 0;
+  // highest index in the search range
+  int32_t top = aNumOptions;
+
+  // Start off keyboard options at selectedIndex if nothing else is defaulted to
+  //
+  // XXX Perhaps this should happen for mouse too, to start off shift click
+  // automatically in multiple ... to do this, we'd need to override
+  // OnOptionSelected and set mStartSelectedIndex if nothing is selected.  Not
+  // sure of the effects, though, so I'm not doing it just yet.
+  int32_t startIndex = aStartIndex;
+  if (startIndex < bottom) {
+    startIndex = mElement->SelectedIndex();
+  }
+  int32_t newIndex = startIndex + aDoAdjustInc;
+
+  // make sure we start off in the range
+  if (newIndex < bottom) {
+    newIndex = 0;
+  } else if (newIndex >= top) {
+    newIndex = aNumOptions - 1;
+  }
+
+  while (true) {
+    // if the newIndex is selectable, we are golden, bail out
+    if (IsOptionInteractivelySelectable(newIndex)) {
+      break;
+    }
+
+    // it WAS disabled, so sart looking ahead for the next enabled option
+    newIndex += aDoAdjustIncNext;
+
+    // well, if we reach end reverse the search
+    if (newIndex < bottom) {
+      if (doingReverse) {
+        return;  // if we are in reverse mode and reach the end bail out
+      }
+      // reset the newIndex to the end of the list we hit
+      // reverse the incrementer
+      // set the other end of the list to our original starting index
+      newIndex = bottom;
+      aDoAdjustIncNext = 1;
+      doingReverse = true;
+      top = startIndex;
+    } else if (newIndex >= top) {
+      if (doingReverse) {
+        return;  // if we are in reverse mode and reach the end bail out
+      }
+      // reset the newIndex to the end of the list we hit
+      // reverse the incrementer
+      // set the other end of the list to our original starting index
+      newIndex = top - 1;
+      aDoAdjustIncNext = -1;
+      doingReverse = true;
+      bottom = startIndex;
+    }
+  }
+
+  // Looks like we found one
+  aNewIndex = newIndex;
+}
+
+NS_IMETHODIMP
+HTMLSelectEventListener::HandleEvent(dom::Event* aEvent) {
+  nsAutoString eventType;
+  aEvent->GetType(eventType);
+  if (eventType.EqualsLiteral("keydown")) {
+    return KeyDown(aEvent);
+  }
+  if (eventType.EqualsLiteral("keypress")) {
+    return KeyPress(aEvent);
+  }
+  if (eventType.EqualsLiteral("mousedown")) {
+    if (aEvent->DefaultPrevented()) {
+      return NS_OK;
+    }
+    return MouseDown(aEvent);
+  }
+  if (eventType.EqualsLiteral("mouseup")) {
+    // Don't try to honor defaultPrevented here - it's not web compatible.
+    // (bug 1194733)
+    return MouseUp(aEvent);
+  }
+  if (eventType.EqualsLiteral("mousemove")) {
+    // I don't think we want to honor defaultPrevented on mousemove
+    // in general, and it would only prevent highlighting here.
+    return MouseMove(aEvent);
+  }
+
+  MOZ_ASSERT_UNREACHABLE("Unexpected eventType");
+  return NS_OK;
+}
+
+void HTMLSelectEventListener::Attach() {
+  mElement->AddSystemEventListener(u"keydown"_ns, this, false, false);
+  mElement->AddSystemEventListener(u"keypress"_ns, this, false, false);
+  mElement->AddSystemEventListener(u"mousedown"_ns, this, false, false);
+  mElement->AddSystemEventListener(u"mouseup"_ns, this, false, false);
+  mElement->AddSystemEventListener(u"mousemove"_ns, this, false, false);
+
+  if (mIsCombobox) {
+    mElement->AddMutationObserver(this);
+  }
+}
+
+void HTMLSelectEventListener::Detach() {
+  mElement->RemoveSystemEventListener(u"keydown"_ns, this, false);
+  mElement->RemoveSystemEventListener(u"keypress"_ns, this, false);
+  mElement->RemoveSystemEventListener(u"mousedown"_ns, this, false);
+  mElement->RemoveSystemEventListener(u"mouseup"_ns, this, false);
+  mElement->RemoveSystemEventListener(u"mousemove"_ns, this, false);
+
+  if (mIsCombobox) {
+    mElement->RemoveMutationObserver(this);
+    nsContentUtils::AddScriptRunner(
+        new AsyncEventDispatcher(mElement, u"mozhidedropdown"_ns,
+                                 CanBubble::eYes, ChromeOnlyDispatch::eYes));
+  }
+}
+
+const uint32_t kMaxDropdownRows = 20;  // matches the setting for 4.x browsers
+
+int32_t HTMLSelectEventListener::ItemsPerPage() const {
+  uint32_t size = [&] {
+    if (mIsCombobox) {
+      return kMaxDropdownRows;
+    }
+    if (auto* lf = GetListControlFrame()) {
+      return lf->GetNumDisplayRows();
+    }
+    return mElement->Size();
+  }();
+  if (size <= 1) {
+    return 1;
+  }
+  if (MOZ_UNLIKELY(size > INT32_MAX)) {
+    return INT32_MAX - 1;
+  }
+  return AssertedCast<int32_t>(size - 1u);
+}
+
+void HTMLSelectEventListener::AttributeChanged(dom::Element* aElement,
+                                               int32_t aNameSpaceID,
+                                               nsAtom* aAttribute,
+                                               int32_t aModType,
+                                               const nsAttrValue* aOldValue) {
+  if (aElement->IsHTMLElement(nsGkAtoms::option) &&
+      aNameSpaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::label) {
+    ComboboxMightHaveChanged();
+  }
+}
+
+void HTMLSelectEventListener::CharacterDataChanged(
+    nsIContent* aContent, const CharacterDataChangeInfo&) {
+  if (nsContentUtils::IsInSameAnonymousTree(mElement, aContent)) {
+    ComboboxMightHaveChanged();
+  }
+}
+
+void HTMLSelectEventListener::ContentRemoved(nsIContent* aChild,
+                                             nsIContent* aPreviousSibling) {
+  if (nsContentUtils::IsInSameAnonymousTree(mElement, aChild)) {
+    ComboboxMightHaveChanged();
+  }
+}
+
+void HTMLSelectEventListener::ContentAppended(nsIContent* aFirstNewContent) {
+  if (nsContentUtils::IsInSameAnonymousTree(mElement, aFirstNewContent)) {
+    ComboboxMightHaveChanged();
+  }
+}
+
+void HTMLSelectEventListener::ContentInserted(nsIContent* aChild) {
+  if (nsContentUtils::IsInSameAnonymousTree(mElement, aChild)) {
+    ComboboxMightHaveChanged();
+  }
+}
+
+void HTMLSelectEventListener::ComboboxMightHaveChanged() {
+  if (nsIFrame* f = mElement->GetPrimaryFrame()) {
+    // nsComoboxControlFrame::Reflow updates the selected text. AddOption /
+    // RemoveOption / etc takes care of keeping the displayed index up to date.
+    f->PresShell()->FrameNeedsReflow(f, IntrinsicDirty::StyleChange,
+                                     NS_FRAME_IS_DIRTY);
+  }
+}
+
+void HTMLSelectEventListener::FireOnInputAndOnChange() {
+  RefPtr<HTMLSelectElement> element = mElement;
+  // Dispatch the input event.
+  DebugOnly<nsresult> rvIgnored = nsContentUtils::DispatchInputEvent(element);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                       "Failed to dispatch input event");
+
+  // Dispatch the change event.
+  nsContentUtils::DispatchTrustedEvent(element->OwnerDoc(), ToSupports(element),
+                                       u"change"_ns, CanBubble::eYes,
+                                       Cancelable::eNo);
+}
+
+static void FireDropDownEvent(HTMLSelectElement* aElement, bool aShow,
+                              bool aIsSourceTouchEvent) {
+  const auto eventName = [&] {
+    if (aShow) {
+      return aIsSourceTouchEvent ? u"mozshowdropdown-sourcetouch"_ns
+                                 : u"mozshowdropdown"_ns;
+    }
+    return u"mozhidedropdown"_ns;
+  }();
+  nsContentUtils::DispatchChromeEvent(aElement->OwnerDoc(),
+                                      ToSupports(aElement), eventName,
+                                      CanBubble::eYes, Cancelable::eNo);
+}
+
+nsresult HTMLSelectEventListener::MouseDown(dom::Event* aMouseEvent) {
+  NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
+
+  MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
+  NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
+
+  EventStates eventStates = mElement->State();
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
+    return NS_OK;
+  }
+
+  // only allow selection with the left button
+  // if a right button click is on the combobox itself
+  // or on the select when in listbox mode, then let the click through
+  const bool isLeftButton = mouseEvent->Button() == 0;
+  if (!isLeftButton) {
+    return NS_OK;
+  }
+
+  if (mIsCombobox) {
+    uint16_t inputSource = mouseEvent->MozInputSource();
+    if (mElement->OpenInParentProcess()) {
+      nsCOMPtr<nsIContent> target = do_QueryInterface(aMouseEvent->GetTarget());
+      if (target && target->IsHTMLElement(nsGkAtoms::option)) {
+        return NS_OK;
+      }
+    }
+
+    const bool isSourceTouchEvent =
+        inputSource == MouseEvent_Binding::MOZ_SOURCE_TOUCH;
+    FireDropDownEvent(mElement, !mElement->OpenInParentProcess(),
+                      isSourceTouchEvent);
+    return NS_OK;
+  }
+
+  if (nsListControlFrame* list = GetListControlFrame()) {
+    mButtonDown = true;
+    return list->HandleLeftButtonMouseDown(aMouseEvent);
+  }
+  return NS_OK;
+}
+
+nsresult HTMLSelectEventListener::MouseUp(dom::Event* aMouseEvent) {
+  NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
+
+  MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
+  NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
+
+  mButtonDown = false;
+
+  EventStates eventStates = mElement->State();
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
+    return NS_OK;
+  }
+
+  if (nsListControlFrame* lf = GetListControlFrame()) {
+    lf->CaptureMouseEvents(false);
+  }
+
+  // only allow selection with the left button
+  // if a right button click is on the combobox itself
+  // or on the select when in listbox mode, then let the click through
+  const bool isLeftButton = mouseEvent->Button() == 0;
+  if (!isLeftButton) {
+    return NS_OK;
+  }
+
+  if (nsListControlFrame* lf = GetListControlFrame()) {
+    return lf->HandleLeftButtonMouseUp(aMouseEvent);
+  }
+
+  return NS_OK;
+}
+
+nsresult HTMLSelectEventListener::MouseMove(dom::Event* aMouseEvent) {
+  NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
+
+  MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
+  NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
+
+  if (!mButtonDown) {
+    return NS_OK;
+  }
+
+  if (nsListControlFrame* lf = GetListControlFrame()) {
+    return lf->DragMove(aMouseEvent);
+  }
+
+  return NS_OK;
+}
+
+nsresult HTMLSelectEventListener::KeyPress(dom::Event* aKeyEvent) {
+  MOZ_ASSERT(aKeyEvent, "aKeyEvent is null.");
+
+  EventStates eventStates = mElement->State();
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
+    return NS_OK;
+  }
+
+  AutoIncrementalSearchResetter incrementalSearchResetter;
+
+  const WidgetKeyboardEvent* keyEvent =
+      aKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
+  MOZ_ASSERT(keyEvent,
+             "DOM event must have WidgetKeyboardEvent for its internal event");
+
+  // Select option with this as the first character
+  // XXX Not I18N compliant
+
+  // Don't do incremental search if the key event has already consumed.
+  if (keyEvent->DefaultPrevented()) {
+    return NS_OK;
+  }
+
+  if (keyEvent->IsAlt()) {
+    return NS_OK;
+  }
+
+  // With some keyboard layout, space key causes non-ASCII space.
+  // So, the check in keydown event handler isn't enough, we need to check it
+  // again with keypress event.
+  if (keyEvent->mCharCode != ' ') {
+    mControlSelectMode = false;
+  }
+
+  bool isControlOrMeta = keyEvent->IsControl() || keyEvent->IsMeta();
+  if (isControlOrMeta && keyEvent->mCharCode != ' ') {
+    return NS_OK;
+  }
+
+  // NOTE: If mKeyCode of keypress event is not 0, mCharCode is always 0.
+  //       Therefore, all non-printable keys are not handled after this block.
+  if (!keyEvent->mCharCode) {
+    // Backspace key will delete the last char in the string.  Otherwise,
+    // non-printable keypress should reset incremental search.
+    if (keyEvent->mKeyCode == NS_VK_BACK) {
+      incrementalSearchResetter.Cancel();
+      if (!GetIncrementalString().IsEmpty()) {
+        GetIncrementalString().Truncate(GetIncrementalString().Length() - 1);
+      }
+      aKeyEvent->PreventDefault();
+    } else {
+      // XXX When a select element has focus, even if the key causes nothing,
+      //     it might be better to call preventDefault() here because nobody
+      //     should expect one of other elements including chrome handles the
+      //     key event.
+    }
+    return NS_OK;
+  }
+
+  incrementalSearchResetter.Cancel();
+
+  // We ate the key if we got this far.
+  aKeyEvent->PreventDefault();
+
+  // XXX Why don't we check/modify timestamp first?
+
+  // Incremental Search: if time elapsed is below
+  // ui.menu.incremental_search.timeout, append this keystroke to the search
+  // string we will use to find options and start searching at the current
+  // keystroke.  Otherwise, Truncate the string if it's been a long time
+  // since our last keypress.
+  if (keyEvent->mTime - gLastKeyTime >
+      StaticPrefs::ui_menu_incremental_search_timeout()) {
+    // If this is ' ' and we are at the beginning of the string, treat it as
+    // "select this option" (bug 191543)
+    if (keyEvent->mCharCode == ' ') {
+      // Actually process the new index and let the selection code
+      // do the scrolling for us
+      PostHandleKeyEvent(GetEndSelectionIndex(), keyEvent->mCharCode,
+                         keyEvent->IsShift(), isControlOrMeta);
+
+      return NS_OK;
+    }
+
+    GetIncrementalString().Truncate();
+  }
+
+  gLastKeyTime = keyEvent->mTime;
+
+  // Append this keystroke to the search string.
+  char16_t uniChar = ToLowerCase(static_cast<char16_t>(keyEvent->mCharCode));
+  GetIncrementalString().Append(uniChar);
+
+  // See bug 188199, if all letters in incremental string are same, just try to
+  // match the first one
+  nsAutoString incrementalString(GetIncrementalString());
+  uint32_t charIndex = 1, stringLength = incrementalString.Length();
+  while (charIndex < stringLength &&
+         incrementalString[charIndex] == incrementalString[charIndex - 1]) {
+    charIndex++;
+  }
+  if (charIndex == stringLength) {
+    incrementalString.Truncate(1);
+    stringLength = 1;
+  }
+
+  // Determine where we're going to start reading the string
+  // If we have multiple characters to look for, we start looking *at* the
+  // current option.  If we have only one character to look for, we start
+  // looking *after* the current option.
+  // Exception: if there is no option selected to start at, we always start
+  // *at* 0.
+  int32_t startIndex = mElement->SelectedIndex();
+  if (startIndex == kNothingSelected) {
+    startIndex = 0;
+  } else if (stringLength == 1) {
+    startIndex++;
+  }
+
+  // now make sure there are options or we are wasting our time
+  RefPtr<dom::HTMLOptionsCollection> options = mElement->Options();
+  uint32_t numOptions = options->Length();
+
+  for (uint32_t i = 0; i < numOptions; ++i) {
+    uint32_t index = (i + startIndex) % numOptions;
+    RefPtr<dom::HTMLOptionElement> optionElement = options->ItemAsOption(index);
+    if (!optionElement || !::IsOptionInteractivelySelectable(
+                              *mElement, *optionElement, mIsCombobox)) {
+      continue;
+    }
+
+    nsAutoString text;
+    optionElement->GetRenderedLabel(text);
+    if (!StringBeginsWith(
+            nsContentUtils::TrimWhitespace<
+                nsContentUtils::IsHTMLWhitespaceOrNBSP>(text, false),
+            incrementalString, nsCaseInsensitiveStringComparator)) {
+      continue;
+    }
+
+    if (mIsCombobox) {
+      if (optionElement->Selected()) {
+        return NS_OK;
+      }
+      optionElement->SetSelected(true);
+      FireOnInputAndOnChange();
+      return NS_OK;
+    }
+
+    if (nsListControlFrame* lf = GetListControlFrame()) {
+      bool wasChanged =
+          lf->PerformSelection(index, keyEvent->IsShift(), isControlOrMeta);
+      if (!wasChanged) {
+        return NS_OK;
+      }
+      FireOnInputAndOnChange();
+    }
+    break;
+  }
+
+  return NS_OK;
+}
+
+nsresult HTMLSelectEventListener::KeyDown(dom::Event* aKeyEvent) {
+  MOZ_ASSERT(aKeyEvent, "aKeyEvent is null.");
+
+  EventStates eventStates = mElement->State();
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
+    return NS_OK;
+  }
+
+  AutoIncrementalSearchResetter incrementalSearchResetter;
+
+  if (aKeyEvent->DefaultPrevented()) {
+    return NS_OK;
+  }
+
+  const WidgetKeyboardEvent* keyEvent =
+      aKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
+  MOZ_ASSERT(keyEvent,
+             "DOM event must have WidgetKeyboardEvent for its internal event");
+
+  bool dropDownMenuOnUpDown;
+  bool dropDownMenuOnSpace;
+#ifdef XP_MACOSX
+  dropDownMenuOnUpDown = mIsCombobox && !mElement->OpenInParentProcess();
+  dropDownMenuOnSpace = mIsCombobox && !keyEvent->IsAlt() &&
+                        !keyEvent->IsControl() && !keyEvent->IsMeta();
+#else
+  dropDownMenuOnUpDown = mIsCombobox && keyEvent->IsAlt();
+  dropDownMenuOnSpace = mIsCombobox && !mElement->OpenInParentProcess();
+#endif
+  bool withinIncrementalSearchTime =
+      keyEvent->mTime - gLastKeyTime <=
+      StaticPrefs::ui_menu_incremental_search_timeout();
+  if ((dropDownMenuOnUpDown &&
+       (keyEvent->mKeyCode == NS_VK_UP || keyEvent->mKeyCode == NS_VK_DOWN)) ||
+      (dropDownMenuOnSpace && keyEvent->mKeyCode == NS_VK_SPACE &&
+       !withinIncrementalSearchTime)) {
+    FireDropDownEvent(mElement, !mElement->OpenInParentProcess(), false);
+    aKeyEvent->PreventDefault();
+    return NS_OK;
+  }
+  if (keyEvent->IsAlt()) {
+    return NS_OK;
+  }
+
+  // We should not change the selection if the popup is "opened in the parent
+  // process" (even when we're in single-process mode).
+  const bool shouldSelect = !mIsCombobox || !mElement->OpenInParentProcess();
+
+  // now make sure there are options or we are wasting our time
+  RefPtr<dom::HTMLOptionsCollection> options = mElement->Options();
+  uint32_t numOptions = options->Length();
+
+  // this is the new index to set
+  int32_t newIndex = kNothingSelected;
+
+  bool isControlOrMeta = keyEvent->IsControl() || keyEvent->IsMeta();
+  // Don't try to handle multiple-select pgUp/pgDown in single-select lists.
+  if (isControlOrMeta && !mElement->Multiple() &&
+      (keyEvent->mKeyCode == NS_VK_PAGE_UP ||
+       keyEvent->mKeyCode == NS_VK_PAGE_DOWN)) {
+    return NS_OK;
+  }
+  if (isControlOrMeta &&
+      (keyEvent->mKeyCode == NS_VK_UP || keyEvent->mKeyCode == NS_VK_LEFT ||
+       keyEvent->mKeyCode == NS_VK_DOWN || keyEvent->mKeyCode == NS_VK_RIGHT ||
+       keyEvent->mKeyCode == NS_VK_HOME || keyEvent->mKeyCode == NS_VK_END)) {
+    // Don't go into multiple-select mode unless this list can handle it.
+    isControlOrMeta = mControlSelectMode = mElement->Multiple();
+  } else if (keyEvent->mKeyCode != NS_VK_SPACE) {
+    mControlSelectMode = false;
+  }
+
+  switch (keyEvent->mKeyCode) {
+    case NS_VK_UP:
+    case NS_VK_LEFT:
+      if (shouldSelect) {
+        AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
+                                  int32_t(numOptions), -1, -1);
+      }
+      break;
+    case NS_VK_DOWN:
+    case NS_VK_RIGHT:
+      if (shouldSelect) {
+        AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
+                                  int32_t(numOptions), 1, 1);
+      }
+      break;
+    case NS_VK_RETURN:
+      // If this is single select listbox, Enter key doesn't cause anything.
+      if (!mElement->Multiple()) {
+        return NS_OK;
+      }
+
+      newIndex = GetEndSelectionIndex();
+      break;
+    case NS_VK_PAGE_UP: {
+      if (shouldSelect) {
+        AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
+                                  int32_t(numOptions), -ItemsPerPage(), -1);
+      }
+      break;
+    }
+    case NS_VK_PAGE_DOWN: {
+      if (shouldSelect) {
+        AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
+                                  int32_t(numOptions), ItemsPerPage(), 1);
+      }
+      break;
+    }
+    case NS_VK_HOME:
+      if (shouldSelect) {
+        AdjustIndexForDisabledOpt(0, newIndex, int32_t(numOptions), 0, 1);
+      }
+      break;
+    case NS_VK_END:
+      if (shouldSelect) {
+        AdjustIndexForDisabledOpt(int32_t(numOptions) - 1, newIndex,
+                                  int32_t(numOptions), 0, -1);
+      }
+      break;
+    default:  // printable key will be handled by keypress event.
+      incrementalSearchResetter.Cancel();
+      return NS_OK;
+  }
+
+  aKeyEvent->PreventDefault();
+
+  // Actually process the new index and let the selection code
+  // do the scrolling for us
+  PostHandleKeyEvent(newIndex, 0, keyEvent->IsShift(), isControlOrMeta);
+  return NS_OK;
+}
+
+HTMLOptionElement* HTMLSelectEventListener::GetCurrentOption() const {
+  // The mEndSelectionIndex is what is currently being selected. Use
+  // the selected index if this is kNothingSelected.
+  int32_t endIndex = GetEndSelectionIndex();
+  int32_t focusedIndex =
+      endIndex == kNothingSelected ? mElement->SelectedIndex() : endIndex;
+  if (focusedIndex != kNothingSelected) {
+    return mElement->Item(AssertedCast<uint32_t>(focusedIndex));
+  }
+
+  // There is no selected option. Return the first non-disabled option, if any.
+  return GetNonDisabledOptionFrom(0);
+}
+
+HTMLOptionElement* HTMLSelectEventListener::GetNonDisabledOptionFrom(
+    int32_t aFromIndex, int32_t* aFoundIndex) const {
+  const uint32_t length = mElement->Length();
+  for (uint32_t i = std::max(aFromIndex, 0); i < length; ++i) {
+    if (IsOptionInteractivelySelectable(i)) {
+      if (aFoundIndex) {
+        *aFoundIndex = i;
+      }
+      return mElement->Item(i);
+    }
+  }
+  return nullptr;
+}
+
+void HTMLSelectEventListener::PostHandleKeyEvent(int32_t aNewIndex,
+                                                 uint32_t aCharCode,
+                                                 bool aIsShift,
+                                                 bool aIsControlOrMeta) {
+  if (aNewIndex == kNothingSelected) {
+    int32_t endIndex = GetEndSelectionIndex();
+    int32_t focusedIndex =
+        endIndex == kNothingSelected ? mElement->SelectedIndex() : endIndex;
+    if (focusedIndex != kNothingSelected) {
+      return;
+    }
+    // No options are selected.  In this case the focus ring is on the first
+    // non-disabled option (if any), so we should behave as if that's the option
+    // the user acted on.
+    if (!GetNonDisabledOptionFrom(0, &aNewIndex)) {
+      return;
+    }
+  }
+
+  if (mIsCombobox) {
+    RefPtr<HTMLOptionElement> newOption = mElement->Item(aNewIndex);
+    MOZ_ASSERT(newOption);
+    if (newOption->Selected()) {
+      return;
+    }
+    newOption->SetSelected(true);
+    FireOnInputAndOnChange();
+    return;
+  }
+  if (nsListControlFrame* lf = GetListControlFrame()) {
+    lf->UpdateSelectionAfterKeyEvent(aNewIndex, aCharCode, aIsShift,
+                                     aIsControlOrMeta, mControlSelectMode);
+  }
+}
+
+}  // namespace mozilla
diff --git a/layout/forms/HTMLSelectEventListener.h b/layout/forms/HTMLSelectEventListener.h
new file mode 100644
index 000000000000..220b37fa69d5
--- /dev/null
+++ b/layout/forms/HTMLSelectEventListener.h
@@ -0,0 +1,102 @@
+/* -*- 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/. */
+
+#ifndef mozilla_HTMLSelectEventListener_h
+#define mozilla_HTMLSelectEventListener_h
+
+#include "nsIDOMEventListener.h"
+#include "nsStubMutationObserver.h"
+
+class nsIFrame;
+class nsListControlFrame;
+
+namespace mozilla {
+
+namespace dom {
+class HTMLSelectElement;
+class HTMLOptionElement;
+class Event;
+}  // namespace dom
+
+/**
+ * HTMLSelectEventListener
+ * This class is responsible for propagating events to the select element while
+ * it has a frame.
+ * Frames are not refcounted so they can't be used as event listeners.
+ */
+
+class HTMLSelectEventListener final : public nsStubMutationObserver,
+                                      public nsIDOMEventListener {
+ public:
+  enum class SelectType : uint8_t { Listbox, Combobox };
+  HTMLSelectEventListener(dom::HTMLSelectElement& aElement,
+                          SelectType aSelectType)
+      : mElement(&aElement), mIsCombobox(aSelectType == SelectType::Combobox) {
+    Attach();
+  }
+
+  NS_DECL_ISUPPORTS
+
+  // For comboboxes, we need to keep the list up to date when options change.
+  NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
+  NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
+  NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
+  NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
+  NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
+
+  // nsIDOMEventListener
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD HandleEvent(dom::Event*) override;
+
+  void Attach();
+  void Detach();
+
+  dom::HTMLOptionElement* GetCurrentOption() const;
+
+  MOZ_CAN_RUN_SCRIPT void FireOnInputAndOnChange();
+
+ private:
+  // This is always guaranteed to be > 0, but callers want signed integers so we
+  // do the cast for them.
+  int32_t ItemsPerPage() const;
+
+  nsListControlFrame* GetListControlFrame() const;
+
+  MOZ_CAN_RUN_SCRIPT nsresult KeyDown(dom::Event*);
+  MOZ_CAN_RUN_SCRIPT nsresult KeyPress(dom::Event*);
+  MOZ_CAN_RUN_SCRIPT nsresult MouseDown(dom::Event*);
+  MOZ_CAN_RUN_SCRIPT nsresult MouseUp(dom::Event*);
+  MOZ_CAN_RUN_SCRIPT nsresult MouseMove(dom::Event*);
+
+  void AdjustIndexForDisabledOpt(int32_t aStartIndex, int32_t& aNewIndex,
+                                 int32_t aNumOptions, int32_t aDoAdjustInc,
+                                 int32_t aDoAdjustIncNext);
+  bool IsOptionInteractivelySelectable(uint32_t aIndex) const;
+  int32_t GetEndSelectionIndex() const;
+
+  MOZ_CAN_RUN_SCRIPT
+  void PostHandleKeyEvent(int32_t aNewIndex, uint32_t aCharCode, bool aIsShift,
+                          bool aIsControlOrMeta);
+
+  /**
+   * Return the first non-disabled option starting at aFromIndex (inclusive).
+   * @param aFoundIndex if non-null, set to the index of the returned option
+   */
+  dom::HTMLOptionElement* GetNonDisabledOptionFrom(
+      int32_t aFromIndex, int32_t* aFoundIndex = nullptr) const;
+
+  void ComboboxMightHaveChanged();
+
+  ~HTMLSelectEventListener();
+
+  RefPtr<dom::HTMLSelectElement> mElement;
+  const bool mIsCombobox;
+  bool mButtonDown = false;
+  bool mControlSelectMode = false;
+};
+
+}  // namespace mozilla
+
+#endif  // mozilla_HTMLSelectEventListener_h
diff --git a/layout/forms/moz.build b/layout/forms/moz.build
index 86a002bec71a..3b0cbba2e34e 100644
--- a/layout/forms/moz.build
+++ b/layout/forms/moz.build
@@ -17,6 +17,7 @@ EXPORTS += [
 ]
 
 UNIFIED_SOURCES += [
+    "HTMLSelectEventListener.cpp",
     "nsButtonFrameRenderer.cpp",
     "nsCheckboxRadioFrame.cpp",
     "nsColorControlFrame.cpp",
diff --git a/layout/forms/nsComboboxControlFrame.cpp b/layout/forms/nsComboboxControlFrame.cpp
index 1c368fb62aac..ed9b8f7b6304 100644
--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -40,6 +40,9 @@
 #include "nsDisplayList.h"
 #include "nsITheme.h"
 #include "nsStyleConsts.h"
+#include "nsTextFrameUtils.h"
+#include "nsTextRunTransformations.h"
+#include "HTMLSelectEventListener.h"
 #include "mozilla/Likely.h"
 #include <algorithm>
 #include "nsTextNode.h"
@@ -53,15 +56,8 @@
 #include "gfx2DGlue.h"
 #include "mozilla/widget/nsAutoRollup.h"
 
-#ifdef XP_WIN
-#  define COMBOBOX_ROLLUP_CONSUME_EVENT 0
-#else
-#  define COMBOBOX_ROLLUP_CONSUME_EVENT 1
-#endif
-
 using namespace mozilla;
 using namespace mozilla::gfx;
-using mozilla::dom::Document;
 
 NS_IMETHODIMP
 nsComboboxControlFrame::RedisplayTextEvent::Run() {
@@ -81,35 +77,6 @@ nsComboboxControlFrame::RedisplayTextEvent::Run() {
 // The drop-down list does not explicitly set capture when it is in the
 // drop-down mode.
 
-/**
- * Helper class that listens to the combo boxes button. If the button is pressed
- * the combo box is toggled to open or close. this is used by Accessibility
- * which presses that button Programmatically.
- */
-class nsComboButtonListener final : public nsIDOMEventListener {
- private:
-  virtual ~nsComboButtonListener() = default;
-
- public:
-  NS_DECL_ISUPPORTS
-
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD HandleEvent(dom::Event*) override {
-    mComboBox->ShowDropDown(!mComboBox->IsDroppedDown());
-    return NS_OK;
-  }
-
-  explicit nsComboButtonListener(nsComboboxControlFrame* aCombobox) {
-    mComboBox = aCombobox;
-  }
-
-  nsComboboxControlFrame* mComboBox;
-};
-
-NS_IMPL_ISUPPORTS(nsComboButtonListener, nsIDOMEventListener)
-
-// static class data member for Bug 32920
-nsComboboxControlFrame* nsComboboxControlFrame::sFocused = nullptr;
-
 nsComboboxControlFrame* NS_NewComboboxControlFrame(PresShell* aPresShell,
                                                    ComputedStyle* aStyle,
                                                    nsFrameState aStateFlags) {
@@ -224,16 +191,11 @@ nsComboboxControlFrame::nsComboboxControlFrame(ComputedStyle* aStyle,
     : nsBlockFrame(aStyle, aPresContext, kClassID),
       mDisplayFrame(nullptr),
       mButtonFrame(nullptr),
-      mDropdownFrame(nullptr),
       mDisplayISize(0),
       mMaxDisplayISize(0),
       mRecentSelectedIndex(NS_SKIP_NOTIFY_INDEX),
       mDisplayedIndex(-1),
-      mLastDropDownBeforeScreenBCoord(nscoord_MIN),
-      mLastDropDownAfterScreenBCoord(nscoord_MIN),
-      mDroppedDown(false),
       mInRedisplayText(false),
-      mDelayedShowDropDown(false),
       mIsOpenInParentProcess(false){REFLOW_COUNTER_INIT()}
 
       //--------------------------------------------------------------
@@ -248,7 +210,6 @@ NS_QUERYFRAME_HEAD(nsComboboxControlFrame)
   NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
   NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
   NS_QUERYFRAME_ENTRY(nsISelectControlFrame)
-  NS_QUERYFRAME_ENTRY(nsIStatefulFrame)
 NS_QUERYFRAME_TAIL_INHERITING(nsBlockFrame)
 
 #ifdef ACCESSIBILITY
@@ -258,206 +219,12 @@ a11y::AccType nsComboboxControlFrame::AccessibleType() {
 #endif
 
 void nsComboboxControlFrame::SetFocus(bool aOn, bool aRepaint) {
-  AutoWeakFrame weakFrame(this);
-  if (aOn) {
-    nsListControlFrame::ComboboxFocusSet();
-    sFocused = this;
-    if (mDelayedShowDropDown) {
-      ShowDropDown(true);  // might destroy us
-      if (!weakFrame.IsAlive()) {
-        return;
-      }
-    }
-  } else {
-    sFocused = nullptr;
-    mDelayedShowDropDown = false;
-    if (mDroppedDown) {
-      mDropdownFrame->ComboboxFinish(mDisplayedIndex);  // might destroy us
-      if (!weakFrame.IsAlive()) {
-        return;
-      }
-    }
-    // May delete |this|.
-    mDropdownFrame->FireOnInputAndOnChange();
-  }
-
-  if (!weakFrame.IsAlive()) {
-    return;
-  }
-
   // This is needed on a temporary basis. It causes the focus
   // rect to be drawn. This is much faster than ReResolvingStyle
   // Bug 32920
   InvalidateFrame();
 }
 
-void nsComboboxControlFrame::ShowPopup(bool aShowPopup) {
-  nsView* view = mDropdownFrame->GetView();
-  nsViewManager* viewManager = view->GetViewManager();
-
-  if (aShowPopup) {
-    nsRect rect = mDropdownFrame->GetRect();
-    rect.x = rect.y = 0;
-    viewManager->ResizeView(view, rect);
-    viewManager->SetViewVisibility(view, nsViewVisibility_kShow);
-  } else {
-    viewManager->SetViewVisibility(view, nsViewVisibility_kHide);
-    nsRect emptyRect(0, 0, 0, 0);
-    viewManager->ResizeView(view, emptyRect);
-  }
-
-  // fire a popup dom event if it is safe to do so
-  RefPtr<mozilla::PresShell> presShell = PresContext()->GetPresShell();
-  if (presShell && nsContentUtils::IsSafeToRunScript()) {
-    nsEventStatus status = nsEventStatus_eIgnore;
-    WidgetMouseEvent event(true,
-                           aShowPopup ? eXULPopupShowing : eXULPopupHiding,
-                           nullptr, WidgetMouseEvent::eReal);
-
-    nsCOMPtr<nsIContent> content = mContent;
-    presShell->HandleDOMEventWithTarget(content, &event, &status);
-  }
-}
-
-bool nsComboboxControlFrame::ShowList(bool aShowList) {
-  nsView* view = mDropdownFrame->GetView();
-  if (aShowList) {
-    NS_ASSERTION(
-        !view->HasWidget(),
-        "We shouldn't have a widget before we need to display the popup");
-
-    // Create the widget for the drop-down list
-    view->GetViewManager()->SetViewFloating(view, true);
-
-    nsWidgetInitData widgetData;
-    widgetData.mWindowType = eWindowType_popup;
-    widgetData.mBorderStyle = eBorderStyle_default;
-    view->CreateWidgetForPopup(&widgetData);
-  } else {
-    nsIWidget* widget = view->GetWidget();
-    if (widget) {
-      // We must do this before ShowPopup in case it destroys us (bug 813442).
-      widget->CaptureRollupEvents(this, false);
-    }
-  }
-
-  AutoWeakFrame weakFrame(this);
-  ShowPopup(aShowList);  // might destroy us
-  if (!weakFrame.IsAlive()) {
-    return false;
-  }
-
-  mDroppedDown = aShowList;
-  nsIWidget* widget = view->GetWidget();
-  if (mDroppedDown) {
-    // The listcontrol frame will call back to the nsComboboxControlFrame's
-    // ListWasSelected which will stop the capture.
-    mDropdownFrame->AboutToDropDown();
-    mDropdownFrame->CaptureMouseEvents(true);
-    if (widget) {
-      widget->CaptureRollupEvents(this, true);
-    }
-  } else {
-    if (widget) {
-      view->DestroyWidget();
-    }
-  }
-
-  return weakFrame.IsAlive();
-}
-
-class nsResizeDropdownAtFinalPosition final : public nsIReflowCallback,
-                                              public Runnable {
- public:
-  explicit nsResizeDropdownAtFinalPosition(nsComboboxControlFrame* aFrame)
-      : mozilla::Runnable("nsResizeDropdownAtFinalPosition"), mFrame(aFrame) {}
-
- protected:
-  ~nsResizeDropdownAtFinalPosition() = default;
-
- public:
-  bool ReflowFinished() final {
-    Run();
-    NS_RELEASE_THIS();
-    return false;
-  }
-
-  void ReflowCallbackCanceled() final { NS_RELEASE_THIS(); }
-
-  NS_IMETHOD Run() final {
-    if (mFrame.IsAlive()) {
-      static_cast<nsComboboxControlFrame*>(mFrame.GetFrame())
-          ->AbsolutelyPositionDropDown();
-    }
-    return NS_OK;
-  }
-
-  WeakFrame mFrame;
-};
-
-void nsComboboxControlFrame::ReflowDropdown(nsPresContext* aPresContext,
-                                            const ReflowInput& aReflowInput) {
-  // All we want out of it later on, really, is the block size of a row, so we
-  // don't even need to cache mDropdownFrame's ascent or anything.  If we don't
-  // need to reflow it, just bail out here.
-  if (!aReflowInput.ShouldReflowAllKids() &&
-      !mDropdownFrame->IsSubtreeDirty()) {
-    return;
-  }
-
-  // XXXbz this will, for small-block-size dropdowns, have extra space
-  // on the appropriate edge for the scrollbar we don't show... but
-  // that's the best we can do here for now.
-  WritingMode wm = mDropdownFrame->GetWritingMode();
-  LogicalSize availSize = aReflowInput.AvailableSize(wm);
-  availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
-  ReflowInput kidReflowInput(aPresContext, aReflowInput, mDropdownFrame,
-                             availSize);
-
-  // If the dropdown's intrinsic inline size is narrower than our
-  // specified inline size, then expand it out.  We want our border-box
-  // inline size to end up the same as the dropdown's so account for
-  // both sets of mComputedBorderPadding.
-  nscoord forcedISize =
-      aReflowInput.ComputedISize() +
-      aReflowInput.ComputedLogicalBorderPadding(wm).IStartEnd(wm) -
-      kidReflowInput.ComputedLogicalBorderPadding(wm).IStartEnd(wm);
-  kidReflowInput.SetComputedISize(
-      std::max(kidReflowInput.ComputedISize(), forcedISize));
-
-  // ensure we start off hidden
-  if (!mDroppedDown && HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
-    nsView* view = mDropdownFrame->GetView();
-    nsViewManager* viewManager = view->GetViewManager();
-    viewManager->SetViewVisibility(view, nsViewVisibility_kHide);
-    nsRect emptyRect(0, 0, 0, 0);
-    viewManager->ResizeView(view, emptyRect);
-  }
-
-  // Allow the child to move/size/change-visibility its view if it's currently
-  // dropped down
-  ReflowChildFlags flags = mDroppedDown ? ReflowChildFlags::Default
-                                        : ReflowChildFlags::NoMoveFrame |
-                                              ReflowChildFlags::NoSizeView;
-
-  // XXX Can this be different from the dropdown's writing mode?
-  // That would be odd!
-  // Note that we don't need to pass the true frame position or container size
-  // to ReflowChild or FinishReflowChild here; it will be positioned as needed
-  // by AbsolutelyPositionDropDown().
-  WritingMode outerWM = GetWritingMode();
-  const nsSize dummyContainerSize;
-  ReflowOutput desiredSize(aReflowInput);
-  nsReflowStatus ignoredStatus;
-  ReflowChild(mDropdownFrame, aPresContext, desiredSize, kidReflowInput,
-              outerWM, LogicalPoint(outerWM), dummyContainerSize, flags,
-              ignoredStatus);
-
-  // Set the child's width and height to its desired size
-  FinishReflowChild(mDropdownFrame, aPresContext, desiredSize, &kidReflowInput,
-                    outerWM, LogicalPoint(outerWM), dummyContainerSize, flags);
-}
-
 nsPoint nsComboboxControlFrame::GetCSSTransformTranslation() {
   nsIFrame* frame = this;
   bool is3DTransform = false;
@@ -491,205 +258,6 @@ nsPoint nsComboboxControlFrame::GetCSSTransformTranslation() {
   return translation;
 }
 
-class nsAsyncRollup : public Runnable {
- public:
-  explicit nsAsyncRollup(nsComboboxControlFrame* aFrame)
-      : mozilla::Runnable("nsAsyncRollup"), mFrame(aFrame) {}
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
-    if (mFrame.IsAlive()) {
-      static_cast<nsComboboxControlFrame*>(mFrame.GetFrame())->RollupFromList();
-    }
-    return NS_OK;
-  }
-  WeakFrame mFrame;
-};
-
-class nsAsyncResize : public Runnable {
- public:
-  explicit nsAsyncResize(nsComboboxControlFrame* aFrame)
-      : mozilla::Runnable("nsAsyncResize"), mFrame(aFrame) {}
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
-    if (mFrame.IsAlive()) {
-      nsComboboxControlFrame* combo =
-          static_cast<nsComboboxControlFrame*>(mFrame.GetFrame());
-      combo->mDropdownFrame->SetSuppressScrollbarUpdate(true);
-      RefPtr<PresShell> presShell = mFrame->PresShell();
-      presShell->FrameNeedsReflow(combo->mDropdownFrame, IntrinsicDirty::Resize,
-                                  NS_FRAME_IS_DIRTY);
-      presShell->FlushPendingNotifications(FlushType::Layout);
-      if (mFrame.IsAlive()) {
-        combo = static_cast<nsComboboxControlFrame*>(mFrame.GetFrame());
-        combo->mDropdownFrame->SetSuppressScrollbarUpdate(false);
-        if (combo->mDelayedShowDropDown) {
-          combo->ShowDropDown(true);
-        }
-      }
-    }
-    return NS_OK;
-  }
-  WeakFrame mFrame;
-};
-
-// Returns the usable screen rect in app units, the rect where we can
-// draw the dropdown.
-static nsRect GetUsableScreenRect(nsPresContext* aPresContext) {
-  nsRect screen;
-
-  nsDeviceContext* context = aPresContext->DeviceContext();
-  int32_t dropdownCanOverlapOSBar =
-      LookAndFeel::GetInt(LookAndFeel::IntID::MenusCanOverlapOSBar, 0);
-  if (dropdownCanOverlapOSBar) {
-    context->GetRect(screen);
-  } else {
-    context->GetClientRect(screen);
-  }
-  return screen;
-}
-
-void nsComboboxControlFrame::GetAvailableDropdownSpace(
-    WritingMode aWM, nscoord* aBefore, nscoord* aAfter,
-    LogicalPoint* aTranslation) {
-  MOZ_ASSERT(!XRE_IsContentProcess());
-  // Note: At first glance, it appears that you could simply get the
-  // absolute bounding box for the dropdown list by first getting its
-  // view, then getting the view's nsIWidget, then asking the nsIWidget
-  // for its AbsoluteBounds.
-  // The problem with this approach, is that the dropdown list's bcoord
-  // location can change based on whether the dropdown is placed after
-  // or before the display frame.  The approach taken here is to get the
-  // absolute position of the display frame and use its location to
-  // determine if the dropdown will go offscreen.
-
-  // Normal frame geometry (eg GetOffsetTo, mRect) doesn't include transforms.
-  // In the special case that our transform is only a 2D translation we
-  // introduce this hack so that the dropdown will show up in the right place.
-  // Use null container size when converting a vector from logical to physical.
-  const nsSize nullContainerSize;
-  *aTranslation =
-      LogicalPoint(aWM, GetCSSTransformTranslation(), nullContainerSize);
-  *aBefore = 0;
-  *aAfter = 0;
-
-  nsRect screen = ::GetUsableScreenRect(PresContext());
-  nsSize containerSize = screen.Size();
-  LogicalRect logicalScreen(aWM, screen, containerSize);
-  if (mLastDropDownAfterScreenBCoord == nscoord_MIN) {
-    LogicalRect thisScreenRect(aWM, GetScreenRectInAppUnits(), containerSize);
-    mLastDropDownAfterScreenBCoord =
-        thisScreenRect.BEnd(aWM) + aTranslation->B(aWM);
-    mLastDropDownBeforeScreenBCoord =
-        thisScreenRect.BStart(aWM) + aTranslation->B(aWM);
-  }
-
-  nscoord minBCoord;
-  nsPresContext* pc =
-      PresContext()->GetInProcessRootContentDocumentPresContext();
-  nsIFrame* root = pc ? pc->PresShell()->GetRootFrame() : nullptr;
-  if (root) {
-    minBCoord = LogicalRect(aWM, root->GetScreenRectInAppUnits(), containerSize)
-                    .BStart(aWM);
-    if (mLastDropDownAfterScreenBCoord < minBCoord) {
-      // Don't allow the drop-down to be placed before the content area.
-      return;
-    }
-  } else {
-    minBCoord = logicalScreen.BStart(aWM);
-  }
-
-  nscoord after = logicalScreen.BEnd(aWM) - mLastDropDownAfterScreenBCoord;
-  nscoord before = mLastDropDownBeforeScreenBCoord - minBCoord;
-
-  // If the difference between the space before and after is less
-  // than a row-block-size, then we favor the space after.
-  if (before >= after) {
-    nscoord rowBSize = mDropdownFrame->GetBSizeOfARow();
-    if (before < after + rowBSize) {
-      before -= rowBSize;
-    }
-  }
-
-  *aAfter = after;
-  *aBefore = before;
-}
-
-nsComboboxControlFrame::DropDownPositionState
-nsComboboxControlFrame::AbsolutelyPositionDropDown() {
-  if (XRE_IsContentProcess()) {
-    return eDropDownPositionSuppressed;
-  }
-
-  WritingMode wm = GetWritingMode();
-  LogicalPoint translation(wm);
-  nscoord before, after;
-  mLastDropDownAfterScreenBCoord = nscoord_MIN;
-  GetAvailableDropdownSpace(wm, &before, &after, &translation);
-  if (before <= 0 && after <= 0) {
-    if (IsDroppedDown()) {
-      // Hide the view immediately to minimize flicker.
-      nsView* view = mDropdownFrame->GetView();
-      view->GetViewManager()->SetViewVisibility(view, nsViewVisibility_kHide);
-      NS_DispatchToCurrentThread(new nsAsyncRollup(this));
-    }
-    return eDropDownPositionSuppressed;
-  }
-
-  LogicalSize dropdownSize = mDropdownFrame->GetLogicalSize(wm);
-  nscoord bSize = std::max(before, after);
-  if (bSize < dropdownSize.BSize(wm)) {
-    if (mDropdownFrame->GetNumDisplayRows() > 1) {
-      // The drop-down doesn't fit and currently shows more than 1 row -
-      // schedule a resize to show fewer rows.
-      NS_DispatchToCurrentThread(new nsAsyncResize(this));
-      return eDropDownPositionPendingResize;
-    }
-  } else if (bSize > (dropdownSize.BSize(wm) +
-                      mDropdownFrame->GetBSizeOfARow() * 1.5) &&
-             mDropdownFrame->GetDropdownCanGrow()) {
-    // The drop-down fits but there is room for at least 1.5 more rows -
-    // schedule a resize to show more rows if it has more rows to show.
-    // (1.5 rows for good measure to avoid any rounding issues that would
-    // lead to a loop of reflow requests)
-    NS_DispatchToCurrentThread(new nsAsyncResize(this));
-    return eDropDownPositionPendingResize;
-  }
-
-  // Position the drop-down after if there is room, otherwise place it before
-  // if there is room.  If there is no room for it on either side then place
-  // it after (to avoid overlapping UI like the URL bar).
-  bool b = dropdownSize.BSize(wm) <= after || dropdownSize.BSize(wm) > before;
-  LogicalPoint dropdownPosition(wm, 0, b ? BSize(wm) : -dropdownSize.BSize(wm));
-
-  // Don't position the view unless the position changed since it might cause
-  // a call to NotifyGeometryChange() and an infinite loop here.
-  nsSize containerSize = GetSize();
-  const LogicalPoint currentPos =
-      mDropdownFrame->GetLogicalPosition(containerSize);
-  const LogicalPoint newPos = dropdownPosition + translation;
-  if (currentPos != newPos) {
-    mDropdownFrame->SetPosition(wm, newPos, containerSize);
-    nsContainerFrame::PositionFrameView(mDropdownFrame);
-  }
-  return eDropDownPositionFinal;
-}
-
-void nsComboboxControlFrame::NotifyGeometryChange() {
-  if (XRE_IsContentProcess()) {
-    return;
-  }
-
-  // We don't need to resize if we're not dropped down since ShowDropDown
-  // does that, or if we're dirty then the reflow callback does it,
-  // or if we have a delayed ShowDropDown pending.
-  if (IsDroppedDown() && !HasAnyStateBits(NS_FRAME_IS_DIRTY) &&
-      !mDelayedShowDropDown) {
-    // Async because we're likely in a middle of a scroll here so
-    // frame/view positions are in flux.
-    RefPtr<nsResizeDropdownAtFinalPosition> resize =
-        new nsResizeDropdownAtFinalPosition(this);
-    NS_DispatchToCurrentThread(resize);
-  }
-}
-
 //----------------------------------------------------------
 //
 //----------------------------------------------------------
@@ -734,53 +302,69 @@ nscoord nsComboboxControlFrame::DropDownButtonISize() {
   return presContext->DevPixelsToAppUnits(dropdownButtonSize.width);
 }
 
+int32_t nsComboboxControlFrame::CharCountOfLargestOptionForInflation() const {
+  uint32_t maxLength = 0;
+  nsAutoString label;
+  for (auto i : IntegerRange(Select().Options()->Length())) {
+    GetOptionText(i, label);
+    maxLength = std::max(
+        maxLength,
+        nsTextFrameUtils::ComputeApproximateLengthWithWhitespaceCompression(
+            label, StyleText()));
+  }
+  if (MOZ_UNLIKELY(maxLength > uint32_t(INT32_MAX))) {
+    return INT32_MAX;
+  }
+  return int32_t(maxLength);
+}
+
 nscoord nsComboboxControlFrame::GetIntrinsicISize(gfxContext* aRenderingContext,
                                                   IntrinsicISizeType aType) {
-  MOZ_ASSERT(mDropdownFrame, "No dropdown frame!");
+  nscoord displayISize = mDisplayFrame->IntrinsicISizeOffsets().padding;
 
-  // get the scrollbar width, we'll use this later
-  nscoord scrollbarWidth = 0;
-  nsPresContext* presContext = PresContext();
-  scrollbarWidth = mDropdownFrame->GetNondisappearingScrollbarWidth(
-      presContext, aRenderingContext, GetWritingMode());
-
-  const bool isContainSize = StyleDisplay()->IsContainSize();
-  nscoord displayISize = 0;
-  if (MOZ_LIKELY(mDisplayFrame)) {
-    if (isContainSize) {
-      // Get padding from the inline-axis
-      displayISize = mDisplayFrame->IntrinsicISizeOffsets().padding;
-    } else {
-      displayISize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
-                                                          mDisplayFrame, aType);
+  if (!StyleDisplay()->IsContainSize() && !StyleContent()->mContent.IsNone()) {
+    // Compute the width of each option's (potentially text-transformed) text,
+    // and use the widest one as part of our intrinsic size.
+    nscoord maxOptionSize = 0;
+    nsAutoString label;
+    nsAutoString transformedLabel;
+    RefPtr<nsFontMetrics> fm =
+        nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
+    auto textTransform = StyleText()->mTextTransform.IsNone()
+                             ? Nothing()
+                             : Some(StyleText()->mTextTransform);
+    nsAtom* language = StyleFont()->mLanguage;
+    AutoTArray<bool, 50> charsToMergeArray;
+    AutoTArray<bool, 50> deletedCharsArray;
+    for (auto i : IntegerRange(Select().Options()->Length())) {
+      GetOptionText(i, label);
+      const nsAutoString* stringToUse = &label;
+      if (textTransform) {
+        transformedLabel.Truncate();
+        charsToMergeArray.SetLengthAndRetainStorage(0);
+        deletedCharsArray.SetLengthAndRetainStorage(0);
+        nsCaseTransformTextRunFactory::TransformString(
+            label, transformedLabel, textTransform,
+            /* aCaseTransformsOnly = */ false, language, charsToMergeArray,
+            deletedCharsArray);
+        stringToUse = &transformedLabel;
+      }
+      maxOptionSize = std::max(
+          maxOptionSize, nsLayoutUtils::AppUnitWidthOfStringBidi(
+                             *stringToUse, this, *fm, *aRenderingContext));
     }
+
+    displayISize += maxOptionSize;
   }
 
-  if (mDropdownFrame) {
-    nscoord dropdownContentISize;
-    const bool isUsingOverlayScrollbars = PresContext()->UseOverlayScrollbars();
-    if (aType == IntrinsicISizeType::MinISize) {
-      dropdownContentISize =
-          isContainSize ? 0 : mDropdownFrame->GetMinISize(aRenderingContext);
-      if (isUsingOverlayScrollbars) {
-        dropdownContentISize += scrollbarWidth;
-      }
-    } else {
-      NS_ASSERTION(aType == IntrinsicISizeType::PrefISize, "Unexpected type");
-      dropdownContentISize =
-          isContainSize ? 0 : mDropdownFrame->GetPrefISize(aRenderingContext);
-      if (isUsingOverlayScrollbars) {
-        dropdownContentISize += scrollbarWidth;
-      }
-    }
-    dropdownContentISize = NSCoordSaturatingSubtract(
-        dropdownContentISize, scrollbarWidth, nscoord_MAX);
-
-    displayISize = std::max(dropdownContentISize, displayISize);
-  }
-
-  // Add room for the dropmarker button if there is one.
+  // Add room for the dropmarker button (if there is one) and scrollbar on the
+  // popup.
   displayISize += DropDownButtonISize();
+  nsPresContext* pc = PresContext();
+  if (!pc->UseOverlayScrollbars()) {
+    displayISize += nsIScrollableFrame::GetNondisappearingScrollbarWidth(
+        pc, GetWritingMode());
+  }
 
   return displayISize;
 }
@@ -800,6 +384,18 @@ nscoord nsComboboxControlFrame::GetPrefISize(gfxContext* aRenderingContext) {
   return prefISize;
 }
 
+dom::HTMLSelectElement& nsComboboxControlFrame::Select() const {
+  return *static_cast<dom::HTMLSelectElement*>(GetContent());
+}
+
+void nsComboboxControlFrame::GetOptionText(uint32_t aIndex,
+                                           nsAString& aText) const {
+  aText.Truncate();
+  if (Element* el = Select().Options()->GetElementAt(aIndex)) {
+    static_cast<dom::HTMLOptionElement*>(el)->GetRenderedLabel(aText);
+  }
+}
+
 void nsComboboxControlFrame::Reflow(nsPresContext* aPresContext,
                                     ReflowOutput& aDesiredSize,
                                     const ReflowInput& aReflowInput,
@@ -814,33 +410,20 @@ void nsComboboxControlFrame::Reflow(nsPresContext* aPresContext,
   // 3) Default block size of button is block size of display area
   // 4) Inline size of display area is whatever is left over from our
   //    inline size after allocating inline size for the button.
-  // 5) Block Size of display area is GetBSizeOfARow() on the
-  //    mDropdownFrame.
 
-  if (!mDisplayFrame || !mButtonFrame || !mDropdownFrame) {
+  if (!mDisplayFrame || !mButtonFrame) {
     NS_ERROR("Why did the frame constructor allow this to happen?  Fix it!!");
     return;
   }
 
   // Make sure the displayed text is the same as the selected option,
   // bug 297389.
-  if (!mDroppedDown) {
-    mDisplayedIndex = mDropdownFrame->GetSelectedIndex();
-  }
+  mDisplayedIndex = Select().SelectedIndex();
+
   // In dropped down mode the "selected index" is the hovered menu item,
   // we want the last selected item which is |mDisplayedIndex| in this case.
   RedisplayText();
 
-  // First reflow our dropdown so that we know how tall we should be.
-  ReflowDropdown(aPresContext, aReflowInput);
-  RefPtr<nsResizeDropdownAtFinalPosition> resize =
-      new nsResizeDropdownAtFinalPosition(this);
-  if (NS_SUCCEEDED(aPresContext->PresShell()->PostReflowCallback(resize))) {
-    // The reflow callback queue doesn't AddRef so we keep it alive until
-    // it's released in its ReflowFinished / ReflowCallbackCanceled.
-    Unused << resize.forget();
-  }
-
   WritingMode wm = aReflowInput.GetWritingMode();
 
   // Check if the theme specifies a minimum size for the dropdown button
@@ -874,7 +457,14 @@ void nsComboboxControlFrame::Reflow(nsPresContext* aPresContext,
   }
 }
 
-//--------------------------------------------------------------
+void nsComboboxControlFrame::Init(nsIContent* aContent,
+                                  nsContainerFrame* aParent,
+                                  nsIFrame* aPrevInFlow) {
+  nsBlockFrame::Init(aContent, aParent, aPrevInFlow);
+
+  mEventListener = new HTMLSelectEventListener(
+      Select(), HTMLSelectEventListener::SelectType::Combobox);
+}
 
 #ifdef DEBUG_FRAME_DUMP
 nsresult nsComboboxControlFrame::GetFrameName(nsAString& aResult) const {
@@ -882,48 +472,11 @@ nsresult nsComboboxControlFrame::GetFrameName(nsAString& aResult) const {
 }
 #endif
 
-void nsComboboxControlFrame::ShowDropDown(bool aDoDropDown) {
-  MOZ_ASSERT(!XRE_IsContentProcess());
-  mDelayedShowDropDown = false;
-  EventStates eventStates = mContent->AsElement()->State();
-  if (aDoDropDown && eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
-    return;
-  }
-
-  if (!mDroppedDown && aDoDropDown) {
-    nsFocusManager* fm = nsFocusManager::GetFocusManager();
-    if (!fm || fm->GetFocusedElement() == GetContent()) {
-      DropDownPositionState state = AbsolutelyPositionDropDown();
-      if (state == eDropDownPositionFinal) {
-        ShowList(aDoDropDown);  // might destroy us
-      } else if (state == eDropDownPositionPendingResize) {
-        // Delay until after the resize reflow, see nsAsyncResize.
-        mDelayedShowDropDown = true;
-      }
-    } else {
-      // Delay until we get focus, see SetFocus().
-      mDelayedShowDropDown = true;
-    }
-  } else if (mDroppedDown && !aDoDropDown) {
-    ShowList(aDoDropDown);  // might destroy us
-  }
-}
-
-void nsComboboxControlFrame::SetDropDown(nsListControlFrame* aDropDownFrame) {
-  mDropdownFrame = aDropDownFrame;
-  if (!sFocused && nsContentUtils::IsFocusedContent(GetContent())) {
-    sFocused = this;
-    nsListControlFrame::ComboboxFocusSet();
-  }
-}
-
-nsIFrame* nsComboboxControlFrame::GetDropDown() { return mDropdownFrame; }
-
 ///////////////////////////////////////////////////////////////
 
 nsresult nsComboboxControlFrame::RedisplaySelectedText() {
   nsAutoScriptBlocker scriptBlocker;
-  mDisplayedIndex = mDropdownFrame->GetSelectedIndex();
+  mDisplayedIndex = Select().SelectedIndex();
   return RedisplayText();
 }
 
@@ -931,14 +484,12 @@ nsresult nsComboboxControlFrame::RedisplayText() {
   nsString previewValue;
   nsString previousText(mDisplayedOptionTextOrPreview);
 
-  auto* selectElement = static_cast<dom::HTMLSelectElement*>(GetContent());
-  selectElement->GetPreviewValue(previewValue);
+  Select().GetPreviewValue(previewValue);
   // Get the text to display
   if (!previewValue.IsEmpty()) {
     mDisplayedOptionTextOrPreview = previewValue;
   } else if (mDisplayedIndex != -1 && !StyleContent()->mContent.IsNone()) {
-    mDropdownFrame->GetOptionText(mDisplayedIndex,
-                                  mDisplayedOptionTextOrPreview);
+    GetOptionText(mDisplayedIndex, mDisplayedOptionTextOrPreview);
   } else {
     mDisplayedOptionTextOrPreview.Truncate();
   }
@@ -1027,9 +578,7 @@ int32_t nsComboboxControlFrame::GetIndexOfDisplayArea() {
 // nsISelectControlFrame
 //----------------------------------------------------------------------
 NS_IMETHODIMP
-nsComboboxControlFrame::DoneAddingChildren(bool aIsDone) {
-  return mDropdownFrame->DoneAddingChildren(aIsDone);
-}
+nsComboboxControlFrame::DoneAddingChildren(bool aIsDone) { return NS_OK; }
 
 NS_IMETHODIMP
 nsComboboxControlFrame::AddOption(int32_t aIndex) {
@@ -1037,13 +586,12 @@ nsComboboxControlFrame::AddOption(int32_t aIndex) {
     ++mDisplayedIndex;
   }
 
-  return mDropdownFrame->AddOption(aIndex);
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComboboxControlFrame::RemoveOption(int32_t aIndex) {
-  AutoWeakFrame weakThis(this);
-  if (mDropdownFrame->GetNumberOfOptions() > 0) {
+  if (Select().Options()->Length()) {
     if (aIndex < mDisplayedIndex) {
       --mDisplayedIndex;
     } else if (aIndex == mDisplayedIndex) {
@@ -1055,10 +603,7 @@ nsComboboxControlFrame::RemoveOption(int32_t aIndex) {
     mDisplayedIndex = -1;
     RedisplayText();
   }
-
-  if (!weakThis.IsAlive()) return NS_OK;
-
-  return mDropdownFrame->RemoveOption(aIndex);
+  return NS_OK;
 }
 
 NS_IMETHODIMP_(void)
@@ -1067,8 +612,6 @@ nsComboboxControlFrame::OnSetSelectedIndex(int32_t aOldIndex,
   nsAutoScriptBlocker scriptBlocker;
   mDisplayedIndex = aNewIndex;
   RedisplayText();
-  MOZ_ASSERT(mDropdownFrame, "No dropdown frame!");
-  return mDropdownFrame->OnSetSelectedIndex(aOldIndex, aNewIndex);
 }
 
 // End nsISelectControlFrame
@@ -1088,17 +631,6 @@ nsresult nsComboboxControlFrame::HandleEvent(nsPresContext* aPresContext,
     return NS_OK;
   }
 
-#if COMBOBOX_ROLLUP_CONSUME_EVENT == 0
-  if (aEvent->mMessage == eMouseDown) {
-    if (GetContent() == mozilla::widget::nsAutoRollup::GetLastRollup()) {
-      // This event did a Rollup on this control - prevent it from opening
-      // the dropdown again!
-      *aEventStatus = nsEventStatus_eConsumeNoDefault;
-      return NS_OK;
-    }
-  }
-#endif
-
   // If we have style that affects how we are selected, feed event down to
   // nsIFrame::HandleEvent so that selection takes place when appropriate.
   if (IsContentDisabled()) {
@@ -1107,19 +639,12 @@ nsresult nsComboboxControlFrame::HandleEvent(nsPresContext* aPresContext,
   return NS_OK;
 }
 
-nsresult nsComboboxControlFrame::SetFormProperty(nsAtom* aName,
-                                                 const nsAString& aValue) {
-  return mDropdownFrame->SetFormProperty(aName, aValue);
-}
-
 nsContainerFrame* nsComboboxControlFrame::GetContentInsertionFrame() {
-  return mInRedisplayText ? mDisplayFrame
-                          : mDropdownFrame->GetContentInsertionFrame();
+  return mInRedisplayText ? mDisplayFrame : nullptr;
 }
 
 void nsComboboxControlFrame::AppendDirectlyOwnedAnonBoxes(
     nsTArray<OwnedAnonBox>& aResult) {
-  aResult.AppendElement(OwnedAnonBox(mDropdownFrame));
   aResult.AppendElement(OwnedAnonBox(mDisplayFrame));
 }
 
@@ -1151,10 +676,9 @@ nsresult nsComboboxControlFrame::CreateAnonymousContent(
   mDisplayContent = new (nimgr) nsTextNode(nimgr);
 
   // set the value of the text node
-  mDisplayedIndex = mDropdownFrame->GetSelectedIndex();
+  mDisplayedIndex = Select().SelectedIndex();
   if (mDisplayedIndex != -1) {
-    mDropdownFrame->GetOptionText(mDisplayedIndex,
-                                  mDisplayedOptionTextOrPreview);
+    GetOptionText(mDisplayedIndex, mDisplayedOptionTextOrPreview);
   }
   ActuallyDisplayText(false);
 
@@ -1165,11 +689,7 @@ nsresult nsComboboxControlFrame::CreateAnonymousContent(
   mButtonContent = mContent->OwnerDoc()->CreateHTMLElement(nsGkAtoms::button);
   if (!mButtonContent) return NS_ERROR_OUT_OF_MEMORY;
 
-  // make someone to listen to the button. If its pressed by someone like
-  // Accessibility then open or close the combo box.
-  mButtonListener = new nsComboButtonListener(this);
-  mButtonContent->AddEventListener(u"click"_ns, mButtonListener, false, false);
-
+  // make someone to listen to the button.
   mButtonContent->SetAttr(kNameSpaceID_None, nsGkAtoms::type, u"button"_ns,
                           false);
   // Set tabindex="-1" so that the button is not tabbable
@@ -1296,24 +816,23 @@ nsIFrame* nsComboboxControlFrame::CreateFrameForDisplayNode() {
   MOZ_ASSERT(mDisplayContent);
 
   // Get PresShell
-  mozilla::PresShell* presShell = PresShell();
-  ServoStyleSet* styleSet = presShell->StyleSet();
+  mozilla::PresShell* ps = PresShell();
+  ServoStyleSet* styleSet = ps->StyleSet();
 
   // create the ComputedStyle for the anonymous block frame and text frame
-  RefPtr<ComputedStyle> computedStyle;
-  computedStyle = styleSet->ResolveInheritingAnonymousBoxStyle(
-      PseudoStyleType::mozDisplayComboboxControlFrame, mComputedStyle);
+  RefPtr<ComputedStyle> computedStyle =
+      styleSet->ResolveInheritingAnonymousBoxStyle(
+          PseudoStyleType::mozDisplayComboboxControlFrame, mComputedStyle);
 
-  RefPtr<ComputedStyle> textComputedStyle;
-  textComputedStyle =
+  RefPtr<ComputedStyle> textComputedStyle =
       styleSet->ResolveStyleForText(mDisplayContent, mComputedStyle);
 
   // Start by creating our anonymous block frame
-  mDisplayFrame = new (presShell) nsComboboxDisplayFrame(computedStyle, this);
+  mDisplayFrame = new (ps) nsComboboxDisplayFrame(computedStyle, this);
   mDisplayFrame->Init(mContent, this, nullptr);
 
   // Create a text frame and put it inside the block frame
-  nsIFrame* textFrame = NS_NewTextFrame(presShell, textComputedStyle);
+  nsIFrame* textFrame = NS_NewTextFrame(ps, textComputedStyle);
 
   // initialize the text frame
   textFrame->Init(mDisplayContent, mDisplayFrame, nullptr);
@@ -1324,28 +843,12 @@ nsIFrame* nsComboboxControlFrame::CreateFrameForDisplayNode() {
   return mDisplayFrame;
 }
 
-nsIScrollableFrame* nsComboboxControlFrame::GetScrollTargetFrame() const {
-  return mDropdownFrame;
-}
-
 void nsComboboxControlFrame::DestroyFrom(nsIFrame* aDestructRoot,
                                          PostDestroyData& aPostDestroyData) {
-  if (sFocused == this) {
-    sFocused = nullptr;
-  }
-
   // Revoke any pending RedisplayTextEvent
   mRedisplayTextEvent.Revoke();
 
-  if (mDroppedDown) {
-    MOZ_ASSERT(mDropdownFrame, "mDroppedDown without frame");
-    nsView* view = mDropdownFrame->GetView();
-    MOZ_ASSERT(view);
-    nsIWidget* widget = view->GetWidget();
-    if (widget) {
-      widget->CaptureRollupEvents(this, false);
-    }
-  }
+  mEventListener->Detach();
 
   // Cleanup frames in popup child list
   mPopupFrames.DestroyFramesFrom(aDestructRoot, aPostDestroyData);
@@ -1391,69 +894,6 @@ void nsComboboxControlFrame::SetInitialChildList(ChildListID aListID,
   }
 }
 
-//----------------------------------------------------------------------
-// nsIRollupListener
-//----------------------------------------------------------------------
-bool nsComboboxControlFrame::Rollup(uint32_t aCount, bool aFlush,
-                                    const LayoutDeviceIntPoint* pos,
-                                    nsIContent** aLastRolledUp) {
-  if (aLastRolledUp) {
-    *aLastRolledUp = nullptr;
-  }
-
-  if (!mDroppedDown) {
-    return false;
-  }
-
-  bool consume = !!COMBOBOX_ROLLUP_CONSUME_EVENT;
-  AutoWeakFrame weakFrame(this);
-  mDropdownFrame->AboutToRollup();  // might destroy us
-  if (!weakFrame.IsAlive()) {
-    return consume;
-  }
-  ShowDropDown(false);  // might destroy us
-  if (weakFrame.IsAlive()) {
-    mDropdownFrame->CaptureMouseEvents(false);
-  }
-
-  if (aFlush && weakFrame.IsAlive()) {
-    // The popup's visibility doesn't update until the minimize animation has
-    // finished, so call UpdateWidgetGeometry to update it right away.
-    RefPtr<nsViewManager> viewManager =
-        mDropdownFrame->GetView()->GetViewManager();
-    viewManager->UpdateWidgetGeometry();  // might destroy us
-  }
-
-  if (!weakFrame.IsAlive()) {
-    return consume;
-  }
-
-  if (aLastRolledUp) {
-    *aLastRolledUp = GetContent();
-  }
-  return consume;
-}
-
-nsIWidget* nsComboboxControlFrame::GetRollupWidget() {
-  nsView* view = mDropdownFrame->GetView();
-  MOZ_ASSERT(view);
-  return view->GetWidget();
-}
-
-void nsComboboxControlFrame::RollupFromList() {
-  if (ShowList(false)) {
-    mDropdownFrame->CaptureMouseEvents(false);
-  }
-}
-
-int32_t nsComboboxControlFrame::UpdateRecentIndex(int32_t aIndex) {
-  int32_t index = mRecentSelectedIndex;
-  if (mRecentSelectedIndex == NS_SKIP_NOTIFY_INDEX ||
-      aIndex == NS_SKIP_NOTIFY_INDEX)
-    mRecentSelectedIndex = aIndex;
-  return index;
-}
-
 namespace mozilla {
 
 class nsDisplayComboboxFocus : public nsPaintedDisplayItem {
@@ -1507,7 +947,10 @@ void nsComboboxControlFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
 void nsComboboxControlFrame::PaintFocus(DrawTarget& aDrawTarget, nsPoint aPt) {
   /* Do we need to do anything? */
   EventStates eventStates = mContent->AsElement()->State();
-  if (eventStates.HasState(NS_EVENT_STATE_DISABLED) || sFocused != this) return;
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED) ||
+      !eventStates.HasState(NS_EVENT_STATE_FOCUS)) {
+    return;
+  }
 
   int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel();
 
@@ -1515,13 +958,6 @@ void nsComboboxControlFrame::PaintFocus(DrawTarget& aDrawTarget, nsPoint aPt) {
   aDrawTarget.PushClipRect(
       NSRectToSnappedRect(clipRect, appUnitsPerDevPixel, aDrawTarget));
 
-  // REVIEW: Why does the old code paint mDisplayFrame again? We've
-  // already painted it in the children above. So clipping it here won't do
-  // us much good.
-
-  /////////////////////
-  // draw focus
-
   StrokeOptions strokeOptions;
   nsLayoutUtils::InitDashPattern(strokeOptions, StyleBorderStyle::Dotted);
   ColorPattern color(ToDeviceColor(StyleText()->mColor));
@@ -1540,22 +976,17 @@ void nsComboboxControlFrame::PaintFocus(DrawTarget& aDrawTarget, nsPoint aPt) {
 //---------------------------------------------------------
 NS_IMETHODIMP
 nsComboboxControlFrame::OnOptionSelected(int32_t aIndex, bool aSelected) {
-  if (mDroppedDown) {
-    mDropdownFrame->OnOptionSelected(aIndex, aSelected);
+  if (aSelected) {
+    nsAutoScriptBlocker blocker;
+    mDisplayedIndex = aIndex;
+    RedisplayText();
   } else {
-    if (aSelected) {
-      nsAutoScriptBlocker blocker;
-      mDisplayedIndex = aIndex;
-      RedisplayText();
-    } else {
-      AutoWeakFrame weakFrame(this);
-      RedisplaySelectedText();
-      if (weakFrame.IsAlive()) {
-        FireValueChangeEvent();  // Fire after old option is unselected
-      }
+    AutoWeakFrame weakFrame(this);
+    RedisplaySelectedText();
+    if (weakFrame.IsAlive()) {
+      FireValueChangeEvent();  // Fire after old option is unselected
     }
   }
-
   return NS_OK;
 }
 
@@ -1564,50 +995,3 @@ void nsComboboxControlFrame::FireValueChangeEvent() {
   nsContentUtils::AddScriptRunner(new AsyncEventDispatcher(
       mContent, u"ValueChange"_ns, CanBubble::eYes, ChromeOnlyDispatch::eNo));
 }
-
-void nsComboboxControlFrame::OnContentReset() {
-  mDropdownFrame->OnContentReset();
-}
-
-//--------------------------------------------------------
-// nsIStatefulFrame
-//--------------------------------------------------------
-UniquePtr<PresState> nsComboboxControlFrame::SaveState() {
-  UniquePtr<PresState> state = NewPresState();
-  state->droppedDown() = mDroppedDown;
-  return state;
-}
-
-NS_IMETHODIMP
-nsComboboxControlFrame::RestoreState(PresState* aState) {
-  if (!aState) {
-    return NS_ERROR_FAILURE;
-  }
-  ShowList(aState->droppedDown());  // might destroy us
-  return NS_OK;
-}
-
-// Append a suffix so that the state key for the combobox is different
-// from the state key the list control uses to sometimes save the scroll
-// position for the same Element
-void nsComboboxControlFrame::GenerateStateKey(nsIContent* aContent,
-                                              Document* aDocument,
-                                              nsACString& aKey) {
-  nsContentUtils::GenerateStateKey(aContent, aDocument, aKey);
-  if (aKey.IsEmpty()) {
-    return;
-  }
-  aKey.AppendLiteral("CCF");
-}
-
-// Fennec uses a custom combobox built-in widget.
-//
-
-/* static */
-bool nsComboboxControlFrame::ToolkitHasNativePopup() {
-#ifdef MOZ_USE_NATIVE_POPUP_WINDOWS
-  return true;
-#else
-  return false;
-#endif /* MOZ_USE_NATIVE_POPUP_WINDOWS */
-}
diff --git a/layout/forms/nsComboboxControlFrame.h b/layout/forms/nsComboboxControlFrame.h
index bfa6129e465e..58a44841778d 100644
--- a/layout/forms/nsComboboxControlFrame.h
+++ b/layout/forms/nsComboboxControlFrame.h
@@ -28,17 +28,18 @@
 #include "nsIAnonymousContentCreator.h"
 #include "nsISelectControlFrame.h"
 #include "nsIRollupListener.h"
-#include "nsIStatefulFrame.h"
 #include "nsThreadUtils.h"
 
-class nsListControlFrame;
 class nsComboboxDisplayFrame;
-class nsIDOMEventListener;
-class nsIScrollableFrame;
 class nsTextNode;
 
 namespace mozilla {
 class PresShell;
+class HTMLSelectEventListener;
+namespace dom {
+class HTMLSelectElement;
+}
+
 namespace gfx {
 class DrawTarget;
 }  // namespace gfx
@@ -47,9 +48,7 @@ class DrawTarget;
 class nsComboboxControlFrame final : public nsBlockFrame,
                                      public nsIFormControlFrame,
                                      public nsIAnonymousContentCreator,
-                                     public nsISelectControlFrame,
-                                     public nsIRollupListener,
-                                     public nsIStatefulFrame {
+                                     public nsISelectControlFrame {
   using DrawTarget = mozilla::gfx::DrawTarget;
   using Element = mozilla::dom::Element;
 
@@ -100,7 +99,8 @@ class nsComboboxControlFrame final : public nsBlockFrame,
         aFlags & ~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock));
   }
 
-  nsIScrollableFrame* GetScrollTargetFrame() const final;
+  void Init(nsIContent* aContent, nsContainerFrame* aParent,
+            nsIFrame* aPrevInFlow) final;
 
 #ifdef DEBUG_FRAME_DUMP
   nsresult GetFrameName(nsAString& aResult) const final;
@@ -117,7 +117,10 @@ class nsComboboxControlFrame final : public nsBlockFrame,
   void AppendDirectlyOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) final;
 
   // nsIFormControlFrame
-  nsresult SetFormProperty(nsAtom* aName, const nsAString& aValue) final;
+  nsresult SetFormProperty(nsAtom* aName, const nsAString& aValue) final {
+    return NS_OK;
+  }
+
   /**
    * Inform the control that it got (or lost) focus.
    * If it lost focus, the dropdown menu will be rolled up if needed,
@@ -130,12 +133,6 @@ class nsComboboxControlFrame final : public nsBlockFrame,
   MOZ_CAN_RUN_SCRIPT_BOUNDARY
   void SetFocus(bool aOn, bool aRepaint) final;
 
-  bool IsDroppedDown() { return mDroppedDown; }
-  MOZ_CAN_RUN_SCRIPT void ShowDropDown(bool aDoDropDown);
-  nsIFrame* GetDropDown();
-  void SetDropDown(nsListControlFrame* aDropDownFrame);
-  MOZ_CAN_RUN_SCRIPT void RollupFromList();
-
   /**
    * Return the available space before and after this frame for
    * placing the drop-down list, and the current 2D translation.
@@ -151,15 +148,12 @@ class nsComboboxControlFrame final : public nsBlockFrame,
    */
   nsresult RedisplaySelectedText();
   int32_t UpdateRecentIndex(int32_t aIndex);
-  void OnContentReset();
 
   bool IsOpenInParentProcess() { return mIsOpenInParentProcess; }
 
   void SetOpenInParentProcess(bool aVal) { mIsOpenInParentProcess = aVal; }
 
-  bool IsDroppedDownOrHasParentPopup() {
-    return IsDroppedDown() || IsOpenInParentProcess();
-  }
+  bool IsDroppedDown() { return IsOpenInParentProcess(); }
 
   // nsISelectControlFrame
   NS_IMETHOD AddOption(int32_t index) final;
@@ -169,55 +163,13 @@ class nsComboboxControlFrame final : public nsBlockFrame,
   NS_IMETHOD_(void)
   OnSetSelectedIndex(int32_t aOldIndex, int32_t aNewIndex) final;
 
-  // nsIRollupListener
-  /**
-   * Hide the dropdown menu and stop capturing mouse events.
-   * @note This method might destroy |this|.
-   */
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY
-  bool Rollup(uint32_t aCount, bool aFlush,
-              const mozilla::LayoutDeviceIntPoint* pos,
-              nsIContent** aLastRolledUp) final;
-  void NotifyGeometryChange() final;
-
-  /**
-   * A combobox should roll up if a mousewheel event happens outside of
-   * the popup area.
-   */
-  bool ShouldRollupOnMouseWheelEvent() final { return true; }
-
-  bool ShouldConsumeOnMouseWheelEvent() final { return false; }
-
-  /**
-   * A combobox should not roll up if activated by a mouse activate message
-   * (eg. X-mouse).
-   */
-  bool ShouldRollupOnMouseActivate() final { return false; }
-
-  uint32_t GetSubmenuWidgetChain(nsTArray<nsIWidget*>* aWidgetChain) final {
-    return 0;
-  }
-
-  nsIWidget* GetRollupWidget() final;
-
-  // nsIStatefulFrame
-  mozilla::UniquePtr<mozilla::PresState> SaveState() final;
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY
-  NS_IMETHOD RestoreState(mozilla::PresState* aState) final;
-  void GenerateStateKey(nsIContent* aContent, mozilla::dom::Document* aDocument,
-                        nsACString& aKey) final;
-
-  static bool ToolkitHasNativePopup();
+  int32_t CharCountOfLargestOptionForInflation() const;
 
  protected:
   friend class RedisplayTextEvent;
   friend class nsAsyncResize;
   friend class nsResizeDropdownAtFinalPosition;
 
-  // Utilities
-  void ReflowDropdown(nsPresContext* aPresContext,
-                      const ReflowInput& aReflowInput);
-
   // Return true if we should render a dropdown button.
   bool HasDropDownButton() const;
   nscoord DropDownButtonISize();
@@ -248,38 +200,25 @@ class nsComboboxControlFrame final : public nsBlockFrame,
     nsComboboxControlFrame* mControlFrame;
   };
 
-  /**
-   * Show or hide the dropdown list.
-   * @note This method might destroy |this|.
-   */
-  MOZ_CAN_RUN_SCRIPT void ShowPopup(bool aShowPopup);
-
-  /**
-   * Show or hide the dropdown list.
-   * @param aShowList true to show, false to hide the dropdown.
-   * @note This method might destroy |this|.
-   * @return false if this frame is destroyed, true if still alive.
-   */
-  MOZ_CAN_RUN_SCRIPT bool ShowList(bool aShowList);
   void CheckFireOnChange();
   void FireValueChangeEvent();
   nsresult RedisplayText();
   void HandleRedisplayTextEvent();
   void ActuallyDisplayText(bool aNotify);
 
- private:
   // If our total transform to the root frame of the root document is only a 2d
   // translation then return that translation, otherwise returns (0,0).
   nsPoint GetCSSTransformTranslation();
 
- protected:
+  mozilla::dom::HTMLSelectElement& Select() const;
+  void GetOptionText(uint32_t aIndex, nsAString& aText) const;
+
   nsFrameList mPopupFrames;            // additional named child list
   RefPtr<nsTextNode> mDisplayContent;  // Anonymous content used to display the
                                        // current selection
   RefPtr<Element> mButtonContent;      // Anonymous content for the button
   nsContainerFrame* mDisplayFrame;     // frame to display selection
   nsIFrame* mButtonFrame;              // button frame
-  nsListControlFrame* mDropdownFrame;  // dropdown list frame
 
   // The inline size of our display area.  Used by that frame's reflow
   // to size to the full inline size except the drop-marker.
@@ -296,24 +235,10 @@ class nsComboboxControlFrame final : public nsBlockFrame,
   int32_t mDisplayedIndex;
   nsString mDisplayedOptionTextOrPreview;
 
-  // make someone to listen to the button. If its programmatically pressed by
-  // someone like Accessibility then open or close the combo box.
-  nsCOMPtr<nsIDOMEventListener> mButtonListener;
+  RefPtr<mozilla::HTMLSelectEventListener> mEventListener;
 
-  // The last y-positions used for estimating available space before and
-  // after for the dropdown list in GetAvailableDropdownSpace.  These are
-  // reset to nscoord_MIN in AbsolutelyPositionDropDown when placing the
-  // dropdown at its actual position.  The GetAvailableDropdownSpace call
-  // from nsListControlFrame::ReflowAsDropdown use the last position.
-  nscoord mLastDropDownBeforeScreenBCoord;
-  nscoord mLastDropDownAfterScreenBCoord;
-  // Current state of the dropdown list, true is dropped down.
-  bool mDroppedDown;
   // See comment in HandleRedisplayTextEvent().
   bool mInRedisplayText;
-  // Acting on ShowDropDown(true) is delayed until we're focused.
-  bool mDelayedShowDropDown;
-
   bool mIsOpenInParentProcess;
 
   // static class data member for Bug 32920
diff --git a/layout/forms/nsListControlFrame.cpp b/layout/forms/nsListControlFrame.cpp
index cdb4b518526e..9841cbdd748e 100644
--- a/layout/forms/nsListControlFrame.cpp
+++ b/layout/forms/nsListControlFrame.cpp
@@ -8,12 +8,12 @@
 #include "nsCOMPtr.h"
 #include "nsUnicharUtils.h"
 #include "nsListControlFrame.h"
+#include "HTMLSelectEventListener.h"
 #include "nsGkAtoms.h"
 #include "nsComboboxControlFrame.h"
 #include "nsFontMetrics.h"
 #include "nsIScrollableFrame.h"
 #include "nsCSSRendering.h"
-#include "nsIDOMEventListener.h"
 #include "nsLayoutUtils.h"
 #include "nsDisplayList.h"
 #include "nsContentUtils.h"
@@ -38,39 +38,8 @@
 using namespace mozilla;
 using namespace mozilla::dom;
 
-// Constants
-const uint32_t kMaxDropDownRows = 20;  // matches the setting for 4.x browsers
-const int32_t kNothingSelected = -1;
-
 // Static members
 nsListControlFrame* nsListControlFrame::mFocused = nullptr;
-StaticAutoPtr<nsString> nsListControlFrame::sIncrementalString;
-
-DOMTimeStamp nsListControlFrame::gLastKeyTime = 0;
-
-/******************************************************************************
- * nsListEventListener
- * This class is responsible for propagating events to the nsListControlFrame.
- * Frames are not refcounted so they can't be used as event listeners.
- *****************************************************************************/
-
-class nsListEventListener final : public nsIDOMEventListener {
- public:
-  explicit nsListEventListener(nsListControlFrame* aFrame) : mFrame(aFrame) {}
-
-  void SetFrame(nsListControlFrame* aFrame) { mFrame = aFrame; }
-
-  NS_DECL_ISUPPORTS
-
-  // nsIDOMEventListener
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY
-  NS_IMETHOD HandleEvent(Event* aEvent) override;
-
- private:
-  ~nsListEventListener() = default;
-
-  nsListControlFrame* mFrame;
-};
 
 //---------------------------------------------------------
 nsListControlFrame* NS_NewListControlFrame(PresShell* aPresShell,
@@ -85,37 +54,23 @@ nsListControlFrame* NS_NewListControlFrame(PresShell* aPresShell,
 
 NS_IMPL_FRAMEARENA_HELPERS(nsListControlFrame)
 
-//---------------------------------------------------------
 nsListControlFrame::nsListControlFrame(ComputedStyle* aStyle,
                                        nsPresContext* aPresContext)
     : nsHTMLScrollFrame(aStyle, aPresContext, kClassID, false),
-      mView(nullptr),
       mMightNeedSecondPass(false),
       mHasPendingInterruptAtStartOfReflow(false),
-      mDropdownCanGrow(false),
       mForceSelection(false),
       mLastDropdownComputedBSize(NS_UNCONSTRAINEDSIZE) {
-  mComboboxFrame = nullptr;
   mChangesSinceDragStart = false;
-  mButtonDown = false;
 
   mIsAllContentHere = false;
   mIsAllFramesHere = false;
   mHasBeenInitialized = false;
   mNeedToReset = true;
   mPostChildrenLoadedReset = false;
-
-  mControlSelectMode = false;
 }
 
-//---------------------------------------------------------
-nsListControlFrame::~nsListControlFrame() { mComboboxFrame = nullptr; }
-
-static bool ShouldFireDropDownEvent() {
-  return (XRE_IsContentProcess() &&
-          StaticPrefs::browser_tabs_remote_desktopbehavior()) ||
-         Preferences::GetBool("dom.select_popup_in_parent.enabled", false);
-}
+nsListControlFrame::~nsListControlFrame() = default;
 
 // for Bug 47302 (remove this comment later)
 void nsListControlFrame::DestroyFrom(nsIFrame* aDestructRoot,
@@ -126,20 +81,7 @@ void nsListControlFrame::DestroyFrom(nsIFrame* aDestructRoot,
   // Clear the frame pointer on our event listener, just in case the
   // event listener can outlive the frame.
 
-  mEventListener->SetFrame(nullptr);
-
-  mContent->RemoveSystemEventListener(u"keydown"_ns, mEventListener, false);
-  mContent->RemoveSystemEventListener(u"keypress"_ns, mEventListener, false);
-  mContent->RemoveSystemEventListener(u"mousedown"_ns, mEventListener, false);
-  mContent->RemoveSystemEventListener(u"mouseup"_ns, mEventListener, false);
-  mContent->RemoveSystemEventListener(u"mousemove"_ns, mEventListener, false);
-
-  if (ShouldFireDropDownEvent()) {
-    nsContentUtils::AddScriptRunner(
-        new AsyncEventDispatcher(mContent, u"mozhidedropdown"_ns,
-                                 CanBubble::eYes, ChromeOnlyDispatch::eYes));
-  }
-
+  mEventListener->Detach();
   nsHTMLScrollFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
 }
 
@@ -154,20 +96,13 @@ void nsListControlFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
 
   DO_GLOBAL_REFLOW_COUNT_DSP("nsListControlFrame");
 
-  if (IsInDropDownMode()) {
-    NS_ASSERTION(NS_GET_A(mLastDropdownBackstopColor) == 255,
-                 "need an opaque backstop color");
-    // XXX Because we have an opaque widget and we get called to paint with
-    // this frame as the root of a stacking context we need make sure to draw
-    // some opaque color over the whole widget. (Bug 511323)
-    aLists.BorderBackground()->AppendNewToBottom<nsDisplaySolidColor>(
-        aBuilder, this, nsRect(aBuilder->ToReferenceFrame(this), GetSize()),
-        mLastDropdownBackstopColor);
-  }
-
   nsHTMLScrollFrame::BuildDisplayList(aBuilder, aLists);
 }
 
+HTMLOptionElement* nsListControlFrame::GetCurrentOption() const {
+  return mEventListener->GetCurrentOption();
+}
+
 /**
  * This is called by the SelectsAreaFrame, which is the same
  * as the frame returned by GetOptionsContainer. It's the frame which is
@@ -355,11 +290,6 @@ void nsListControlFrame::Reflow(nsPresContext* aPresContext,
     }
   }
 
-  if (IsInDropDownMode()) {
-    ReflowAsDropdown(aPresContext, aDesiredSize, aReflowInput, aStatus);
-    return;
-  }
-
   MarkInReflow();
   /*
    * Due to the fact that our intrinsic block size depends on the block
@@ -461,136 +391,10 @@ void nsListControlFrame::Reflow(nsPresContext* aPresContext,
   nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
 }
 
-void nsListControlFrame::ReflowAsDropdown(nsPresContext* aPresContext,
-                                          ReflowOutput& aDesiredSize,
-                                          const ReflowInput& aReflowInput,
-                                          nsReflowStatus& aStatus) {
-  MOZ_ASSERT(aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE,
-             "We should not have a computed block size here!");
-
-  mMightNeedSecondPass = IsSubtreeDirty() || aReflowInput.ShouldReflowAllKids();
-
-  WritingMode wm = aReflowInput.GetWritingMode();
-#ifdef DEBUG
-  nscoord oldBSizeOfARow = BSizeOfARow();
-  nscoord oldVisibleBSize = HasAnyStateBits(NS_FRAME_FIRST_REFLOW)
-                                ? NS_UNCONSTRAINEDSIZE
-                                : GetScrolledFrame()->BSize(wm);
-#endif
-
-  ReflowInput state(aReflowInput);
-
-  if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
-    // When not doing an initial reflow, and when the block size is
-    // auto, start off with our computed block size set to what we'd
-    // expect our block size to be.
-    // Note: At this point, mLastDropdownComputedBSize can be
-    // NS_UNCONSTRAINEDSIZE in cases when last time we didn't have to
-    // constrain the block size.  That's fine; just do the same thing as
-    // last time.
-    state.SetComputedBSize(mLastDropdownComputedBSize);
-  }
-
-  nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
-
-  if (!mMightNeedSecondPass) {
-    NS_ASSERTION(oldVisibleBSize == GetScrolledFrame()->BSize(wm),
-                 "How did our kid's BSize change if nothing was dirty?");
-    NS_ASSERTION(BSizeOfARow() == oldBSizeOfARow,
-                 "How did our BSize of a row change if nothing was dirty?");
-    NS_ASSERTION(!IsScrollbarUpdateSuppressed(),
-                 "Shouldn't be suppressing if we don't need a second pass!");
-    NS_ASSERTION(!HasAnyStateBits(NS_FRAME_FIRST_REFLOW),
-                 "How can we avoid a second pass during first reflow?");
-    return;
-  }
-
-  mMightNeedSecondPass = false;
-
-  // Now see whether we need a second pass.  If we do, our nsSelectsAreaFrame
-  // will have suppressed the scrollbar update.
-  if (!IsScrollbarUpdateSuppressed()) {
-    // All done.  No need to do more reflow.
-    NS_ASSERTION(!HasAnyStateBits(NS_FRAME_FIRST_REFLOW),
-                 "How can we avoid a second pass during first reflow?");
-    return;
-  }
-
-  SetSuppressScrollbarUpdate(false);
-
-  nscoord visibleBSize = GetScrolledFrame()->BSize(wm);
-  nscoord blockSizeOfARow = BSizeOfARow();
-
-  // Gotta reflow again.
-  // XXXbz We're just changing the block size here; do we need to dirty
-  // ourselves or anything like that?  We might need to, per the letter
-  // of the reflow protocol, but things seem to work fine without it...
-  // Is that just an implementation detail of nsHTMLScrollFrame that
-  // we're depending on?
-  nsHTMLScrollFrame::DidReflow(aPresContext, &state);
-
-  // Now compute the block size we want to have.
-  // Note: no need to apply min/max constraints, since we have no such
-  // rules applied to the combobox dropdown.
-
-  mDropdownCanGrow = false;
-  if (visibleBSize <= 0 || blockSizeOfARow <= 0 || XRE_IsContentProcess()) {
-    // Looks like we have no options.  Just size us to a single row
-    // block size.
-    state.SetComputedBSize(blockSizeOfARow);
-    // mNumDisplayRows is used as the number of options to move for the page
-    // up/down keys. If we're in a content process, we can't calculate
-    // mNumDisplayRows properly, but the maximum number of rows is a lot more
-    // uesful for page up/down than 1.
-    mNumDisplayRows = XRE_IsContentProcess() ? kMaxDropDownRows : 1;
-  } else {
-    nsComboboxControlFrame* combobox =
-        static_cast<nsComboboxControlFrame*>(mComboboxFrame);
-    LogicalPoint translation(wm);
-    nscoord before, after;
-    combobox->GetAvailableDropdownSpace(wm, &before, &after, &translation);
-    if (before <= 0 && after <= 0) {
-      state.SetComputedBSize(blockSizeOfARow);
-      mNumDisplayRows = 1;
-      mDropdownCanGrow = GetNumberOfRows() > 1;
-    } else {
-      nscoord bp = aReflowInput.ComputedLogicalBorderPadding(wm).BStartEnd(wm);
-      nscoord availableBSize = std::max(before, after) - bp;
-      nscoord newBSize;
-      uint32_t rows;
-      if (visibleBSize <= availableBSize) {
-        // The dropdown fits in the available block size.
-        rows = GetNumberOfRows();
-        mNumDisplayRows = clamped<uint32_t>(rows, 1, kMaxDropDownRows);
-        if (mNumDisplayRows == rows) {
-          newBSize = visibleBSize;  // use the exact block size
-        } else {
-          newBSize = mNumDisplayRows * blockSizeOfARow;  // approximate
-          // The approximation here might actually be too big (bug 1208978);
-          // don't let it exceed the actual block-size of the list.
-          newBSize = std::min(newBSize, visibleBSize);
-        }
-      } else {
-        rows = availableBSize / blockSizeOfARow;
-        mNumDisplayRows = clamped<uint32_t>(rows, 1, kMaxDropDownRows);
-        newBSize = mNumDisplayRows * blockSizeOfARow;  // approximate
-      }
-      state.SetComputedBSize(newBSize);
-      mDropdownCanGrow = visibleBSize - newBSize >= blockSizeOfARow &&
-                         mNumDisplayRows != kMaxDropDownRows;
-    }
-  }
-
-  mLastDropdownComputedBSize = state.ComputedBSize();
-
-  aStatus.Reset();
-  nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
-}
-
 ScrollStyles nsListControlFrame::GetScrollStyles() const {
-  // We can't express this in the style system yet; when we can, this can go
-  // away and GetScrollStyles can be devirtualized
-  auto style = IsInDropDownMode() ? StyleOverflow::Auto : StyleOverflow::Scroll;
+  // TODO(emilio, bug 1750431): Set this in html.css and devirtualize
+  // GetScrollStyles().
+  auto style = StyleOverflow::Scroll;
   if (GetWritingMode().IsVertical()) {
     return ScrollStyles(style, StyleOverflow::Hidden);
   } else {
@@ -599,7 +403,7 @@ ScrollStyles nsListControlFrame::GetScrollStyles() const {
 }
 
 bool nsListControlFrame::ShouldPropagateComputedBSizeToScrolledContent() const {
-  return !IsInDropDownMode();
+  return true;
 }
 
 //---------------------------------------------------------
@@ -616,12 +420,8 @@ bool nsListControlFrame::ExtendedSelection(int32_t aStartIndex,
 //---------------------------------------------------------
 bool nsListControlFrame::SingleSelection(int32_t aClickedIndex,
                                          bool aDoToggle) {
-  if (mComboboxFrame) {
-    mComboboxFrame->UpdateRecentIndex(GetSelectedIndex());
-  }
-
 #ifdef ACCESSIBILITY
-  nsCOMPtr<nsIContent> prevOption = GetCurrentOption();
+  nsCOMPtr<nsIContent> prevOption = mEventListener->GetCurrentOption();
 #endif
   bool wasChanged = false;
   // Get Current selection
@@ -801,25 +601,11 @@ bool nsListControlFrame::HandleListSelection(dom::Event* aEvent,
 
 //---------------------------------------------------------
 void nsListControlFrame::CaptureMouseEvents(bool aGrabMouseEvents) {
-  // Currently cocoa widgets use a native popup widget which tracks clicks
-  // synchronously, so we never want to do mouse capturing. Note that we only
-  // bail if the list is in drop-down mode, and the caller is requesting capture
-  // (we let release capture requests go through to ensure that we can release
-  // capture requested via other code paths, if any exist).
-  if (aGrabMouseEvents && IsInDropDownMode() &&
-      nsComboboxControlFrame::ToolkitHasNativePopup())
-    return;
-
   if (aGrabMouseEvents) {
     PresShell::SetCapturingContent(mContent, CaptureFlags::IgnoreAllowedState);
   } else {
     nsIContent* capturingContent = PresShell::GetCapturingContent();
-
-    bool dropDownIsHidden = false;
-    if (IsInDropDownMode()) {
-      dropDownIsHidden = !mComboboxFrame->IsDroppedDown();
-    }
-    if (capturingContent == mContent || dropDownIsHidden) {
+    if (capturingContent == mContent) {
       // only clear the capturing content if *we* are the ones doing the
       // capturing (or if the dropdown is hidden, in which case NO-ONE should
       // be capturing anything - it could be a scrollbar inside this listbox
@@ -897,30 +683,21 @@ void nsListControlFrame::SetInitialChildList(ChildListID aListID,
   }*/
 }
 
+HTMLSelectElement& nsListControlFrame::Select() const {
+  return *static_cast<HTMLSelectElement*>(GetContent());
+}
+
 //---------------------------------------------------------
 void nsListControlFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
                               nsIFrame* aPrevInFlow) {
   nsHTMLScrollFrame::Init(aContent, aParent, aPrevInFlow);
 
-  if (IsInDropDownMode()) {
-    AddStateBits(NS_FRAME_IN_POPUP);
-    CreateView();
-  }
-
   // we shouldn't have to unregister this listener because when
   // our frame goes away all these content node go away as well
   // because our frame is the only one who references them.
   // we need to hook up our listeners before the editor is initialized
-  mEventListener = new nsListEventListener(this);
-
-  mContent->AddSystemEventListener(u"keydown"_ns, mEventListener, false, false);
-  mContent->AddSystemEventListener(u"keypress"_ns, mEventListener, false,
-                                   false);
-  mContent->AddSystemEventListener(u"mousedown"_ns, mEventListener, false,
-                                   false);
-  mContent->AddSystemEventListener(u"mouseup"_ns, mEventListener, false, false);
-  mContent->AddSystemEventListener(u"mousemove"_ns, mEventListener, false,
-                                   false);
+  mEventListener = new HTMLSelectEventListener(
+      Select(), HTMLSelectEventListener::SelectType::Listbox);
 
   mStartSelectionIndex = kNothingSelected;
   mEndSelectionIndex = kNothingSelected;
@@ -988,7 +765,6 @@ void nsListControlFrame::SetFocus(bool aOn, bool aRepaint) {
   InvalidateFocus();
 
   if (aOn) {
-    ComboboxFocusSet();
     mFocused = this;
   } else {
     mFocused = nullptr;
@@ -997,14 +773,6 @@ void nsListControlFrame::SetFocus(bool aOn, bool aRepaint) {
   InvalidateFocus();
 }
 
-void nsListControlFrame::ComboboxFocusSet() { gLastKeyTime = 0; }
-
-void nsListControlFrame::SetComboboxFrame(nsIFrame* aComboboxFrame) {
-  if (nullptr != aComboboxFrame) {
-    mComboboxFrame = do_QueryFrame(aComboboxFrame);
-  }
-}
-
 void nsListControlFrame::GetOptionText(uint32_t aIndex, nsAString& aStr) {
   aStr.Truncate();
   if (dom::HTMLOptionElement* optionElement = GetOption(aIndex)) {
@@ -1018,46 +786,6 @@ int32_t nsListControlFrame::GetSelectedIndex() {
   return select->SelectedIndex();
 }
 
-dom::HTMLOptionElement* nsListControlFrame::GetCurrentOption() {
-  // The mEndSelectionIndex is what is currently being selected. Use
-  // the selected index if this is kNothingSelected.
-  int32_t focusedIndex = (mEndSelectionIndex == kNothingSelected)
-                             ? GetSelectedIndex()
-                             : mEndSelectionIndex;
-
-  if (focusedIndex != kNothingSelected) {
-    return GetOption(AssertedCast<uint32_t>(focusedIndex));
-  }
-
-  // There is no selected option. Return the first non-disabled option, if any.
-  return GetNonDisabledOptionFrom(0);
-}
-
-HTMLOptionElement* nsListControlFrame::GetNonDisabledOptionFrom(
-    int32_t aFromIndex, int32_t* aFoundIndex) {
-  RefPtr<dom::HTMLSelectElement> selectElement =
-      dom::HTMLSelectElement::FromNode(mContent);
-
-  const uint32_t length = selectElement->Length();
-  for (uint32_t i = std::max(aFromIndex, 0); i < length; ++i) {
-    HTMLOptionElement* node = selectElement->Item(i);
-    if (!node) {
-      break;
-    }
-    if (IsOptionInteractivelySelectable(selectElement, node)) {
-      if (aFoundIndex) {
-        *aFoundIndex = i;
-      }
-      return node;
-    }
-  }
-  return nullptr;
-}
-
-bool nsListControlFrame::IsInDropDownMode() const {
-  return (mComboboxFrame != nullptr);
-}
-
 uint32_t nsListControlFrame::GetNumberOfOptions() {
   dom::HTMLOptionsCollection* options = GetOptions();
   if (!options) {
@@ -1127,7 +855,7 @@ nsListControlFrame::AddOption(int32_t aIndex) {
 }
 
 static int32_t DecrementAndClamp(int32_t aSelectionIndex, int32_t aLength) {
-  return aLength == 0 ? kNothingSelected : std::max(0, aSelectionIndex - 1);
+  return aLength == 0 ? nsListControlFrame::kNothingSelected : std::max(0, aSelectionIndex - 1);
 }
 
 NS_IMETHODIMP
@@ -1135,11 +863,6 @@ nsListControlFrame::RemoveOption(int32_t aIndex) {
   MOZ_ASSERT(aIndex >= 0, "negative <option> index");
 
   // Need to reset if we're a dropdown
-  if (IsInDropDownMode()) {
-    mNeedToReset = true;
-    mPostChildrenLoadedReset = mIsAllContentHere;
-  }
-
   if (mStartSelectionIndex != kNothingSelected) {
     NS_ASSERTION(mEndSelectionIndex != kNothingSelected, "");
     int32_t numOptions = GetNumberOfOptions();
@@ -1204,87 +927,20 @@ bool nsListControlFrame::ToggleOptionSelectedFromFrame(int32_t aIndex) {
 // Dispatch event and such
 bool nsListControlFrame::UpdateSelection() {
   if (mIsAllFramesHere) {
-    // if it's a combobox, display the new text
+    // if it's a combobox, display the new text. Note that after
+    // FireOnInputAndOnChange we might be dead, as that can run script.
     AutoWeakFrame weakFrame(this);
-    if (mComboboxFrame) {
-      mComboboxFrame->RedisplaySelectedText();
-
-      // When dropdown list is open, onchange event will be fired when Enter key
-      // is hit or when dropdown list is dismissed.
-      if (mComboboxFrame->IsDroppedDown()) {
-        return weakFrame.IsAlive();
-      }
-    }
     if (mIsAllContentHere) {
-      FireOnInputAndOnChange();
+      RefPtr listener = mEventListener;
+      listener->FireOnInputAndOnChange();
     }
     return weakFrame.IsAlive();
   }
   return true;
 }
 
-void nsListControlFrame::ComboboxFinish(int32_t aIndex) {
-  gLastKeyTime = 0;
-
-  if (mComboboxFrame) {
-    int32_t displayIndex = mComboboxFrame->GetIndexOfDisplayArea();
-    // Make sure we can always reset to the displayed index
-    mForceSelection = displayIndex == aIndex;
-
-    AutoWeakFrame weakFrame(this);
-    PerformSelection(aIndex, false, false);  // might destroy us
-    if (!weakFrame.IsAlive() || !mComboboxFrame) {
-      return;
-    }
-
-    if (displayIndex != aIndex) {
-      mComboboxFrame->RedisplaySelectedText();  // might destroy us
-    }
-
-    if (weakFrame.IsAlive() && mComboboxFrame) {
-      mComboboxFrame->RollupFromList();  // might destroy us
-    }
-  }
-}
-
-// Send out an onInput and onChange notification.
-void nsListControlFrame::FireOnInputAndOnChange() {
-  if (mComboboxFrame) {
-    // Return hit without changing anything
-    int32_t index = mComboboxFrame->UpdateRecentIndex(NS_SKIP_NOTIFY_INDEX);
-    if (index == NS_SKIP_NOTIFY_INDEX) {
-      return;
-    }
-
-    // See if the selection actually changed
-    if (index == GetSelectedIndex()) {
-      return;
-    }
-  }
-
-  RefPtr<Element> element = Element::FromNodeOrNull(mContent);
-  if (NS_WARN_IF(!element)) {
-    return;
-  }
-  // Dispatch the input event.
-  DebugOnly<nsresult> rvIgnored = nsContentUtils::DispatchInputEvent(element);
-  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
-                       "Failed to dispatch input event");
-
-  // Dispatch the change event.
-  nsContentUtils::DispatchTrustedEvent(element->OwnerDoc(), element,
-                                       u"change"_ns, CanBubble::eYes,
-                                       Cancelable::eNo);
-}
-
 NS_IMETHODIMP_(void)
 nsListControlFrame::OnSetSelectedIndex(int32_t aOldIndex, int32_t aNewIndex) {
-  if (mComboboxFrame) {
-    // UpdateRecentIndex with NS_SKIP_NOTIFY_INDEX, so that we won't fire an
-    // onchange event for this setting of selectedIndex.
-    mComboboxFrame->UpdateRecentIndex(NS_SKIP_NOTIFY_INDEX);
-  }
-
 #ifdef ACCESSIBILITY
   nsCOMPtr<nsIContent> prevOption = GetCurrentOption();
 #endif
@@ -1324,63 +980,6 @@ nsresult nsListControlFrame::SetFormProperty(nsAtom* aName,
   return NS_OK;
 }
 
-void nsListControlFrame::AboutToDropDown() {
-  NS_ASSERTION(IsInDropDownMode(),
-               "AboutToDropDown called without being in dropdown mode");
-
-  // Our widget doesn't get invalidated on changes to the rest of the document,
-  // so compute and store this color at the start of a dropdown so we don't
-  // get weird painting behaviour.
-  // We start looking for backgrounds above the combobox frame to avoid
-  // duplicating the combobox frame's background and compose each background
-  // color we find underneath until we have an opaque color, or run out of
-  // backgrounds. We compose with the PresContext default background color,
-  // which is always opaque, in case we don't end up with an opaque color.
-  // This gives us a very poor approximation of translucency.
-  nsIFrame* comboboxFrame = do_QueryFrame(mComboboxFrame);
-  nsIFrame* ancestor = comboboxFrame->GetParent();
-  mLastDropdownBackstopColor = NS_RGBA(0, 0, 0, 0);
-  while (NS_GET_A(mLastDropdownBackstopColor) < 255 && ancestor) {
-    ComputedStyle* context = ancestor->Style();
-    mLastDropdownBackstopColor =
-        NS_ComposeColors(context->StyleBackground()->BackgroundColor(context),
-                         mLastDropdownBackstopColor);
-    ancestor = ancestor->GetParent();
-  }
-  mLastDropdownBackstopColor = NS_ComposeColors(
-      PresContext()->DefaultBackgroundColor(), mLastDropdownBackstopColor);
-
-  if (mIsAllContentHere && mIsAllFramesHere && mHasBeenInitialized) {
-    AutoWeakFrame weakFrame(this);
-    ScrollToIndex(GetSelectedIndex());
-    if (!weakFrame.IsAlive()) {
-      return;
-    }
-#ifdef ACCESSIBILITY
-    FireMenuItemActiveEvent(nullptr);  // Inform assistive tech what got focus
-#endif
-  }
-  mItemSelectionStarted = false;
-  mForceSelection = false;
-}
-
-// We are about to be rolledup from the outside (ComboboxFrame)
-void nsListControlFrame::AboutToRollup() {
-  // We've been updating the combobox with the keyboard up until now, but not
-  // with the mouse.  The problem is, even with mouse selection, we are
-  // updating the <select>.  So if the mouse goes over an option just before
-  // he leaves the box and clicks, that's what the <select> will show.
-  //
-  // To deal with this we say "whatever is in the combobox is canonical."
-  // - IF the combobox is different from the current selected index, we
-  //   reset the index.
-
-  if (IsInDropDownMode()) {
-    ComboboxFinish(
-        mComboboxFrame->GetIndexOfDisplayArea());  // might destroy us
-  }
-}
-
 void nsListControlFrame::DidReflow(nsPresContext* aPresContext,
                                    const ReflowInput* aReflowInput) {
   bool wasInterrupted = !mHasPendingInterruptAtStartOfReflow &&
@@ -1427,15 +1026,6 @@ bool nsListControlFrame::IsOptionInteractivelySelectable(
   return !aSelect->IsOptionDisabled(aOption) && aOption->GetPrimaryFrame();
 }
 
-//----------------------------------------------------------------------
-// helper
-//----------------------------------------------------------------------
-bool nsListControlFrame::IsLeftButton(dom::Event* aMouseEvent) {
-  // only allow selection with the left button
-  MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
-  return mouseEvent && mouseEvent->Button() == 0;
-}
-
 nscoord nsListControlFrame::CalcFallbackRowBSize(float aFontSizeInflation) {
   RefPtr<nsFontMetrics> fontMet =
       nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation);
@@ -1444,146 +1034,16 @@ nscoord nsListControlFrame::CalcFallbackRowBSize(float aFontSizeInflation) {
 
 nscoord nsListControlFrame::CalcIntrinsicBSize(nscoord aBSizeOfARow,
                                                int32_t aNumberOfOptions) {
-  MOZ_ASSERT(!IsInDropDownMode(),
-             "Shouldn't be in dropdown mode when we call this");
-
-  dom::HTMLSelectElement* select =
-      dom::HTMLSelectElement::FromNodeOrNull(mContent);
-  if (select) {
-    mNumDisplayRows = select->Size();
-  } else {
-    mNumDisplayRows = 1;
-  }
-
+  mNumDisplayRows = Select().Size();
   if (mNumDisplayRows < 1) {
     mNumDisplayRows = 4;
   }
-
   return mNumDisplayRows * aBSizeOfARow;
 }
 
-//----------------------------------------------------------------------
-// nsIDOMMouseListener
-//----------------------------------------------------------------------
-nsresult nsListControlFrame::MouseUp(dom::Event* aMouseEvent) {
-  NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
-
-  MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
-  NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
-
-  UpdateInListState(aMouseEvent);
-
-  mButtonDown = false;
-
-  EventStates eventStates = mContent->AsElement()->State();
-  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
-    return NS_OK;
-  }
-
-  // only allow selection with the left button
-  // if a right button click is on the combobox itself
-  // or on the select when in listbox mode, then let the click through
-  if (!IsLeftButton(aMouseEvent)) {
-    if (IsInDropDownMode()) {
-      if (!IgnoreMouseEventForSelection(aMouseEvent)) {
-        aMouseEvent->PreventDefault();
-        aMouseEvent->StopPropagation();
-      } else {
-        CaptureMouseEvents(false);
-        return NS_OK;
-      }
-      CaptureMouseEvents(false);
-      return NS_ERROR_FAILURE;  // means consume event
-    } else {
-      CaptureMouseEvents(false);
-      return NS_OK;
-    }
-  }
-
-  const nsStyleVisibility* vis = StyleVisibility();
-
-  if (!vis->IsVisible()) {
-    return NS_OK;
-  }
-
-  if (IsInDropDownMode()) {
-    // XXX This is a bit of a hack, but.....
-    // But the idea here is to make sure you get an "onclick" event when you
-    // mouse down on the select and the drag over an option and let go And then
-    // NOT get an "onclick" event when when you click down on the select and
-    // then up outside of the select the EventStateManager tracks the content of
-    // the mouse down and the mouse up to make sure they are the same, and the
-    // onclick is sent in the PostHandleEvent depeneding on whether the
-    // clickCount is non-zero. So we cheat here by either setting or unsetting
-    // the clcikCount in the native event so the right thing happens for the
-    // onclick event
-    WidgetMouseEvent* mouseEvent =
-        aMouseEvent->WidgetEventPtr()->AsMouseEvent();
-
-    int32_t selectedIndex;
-    if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
-      // If it's not selectable, disallow the click and leave.
-      if (!IsOptionInteractivelySelectable(selectedIndex)) {
-        aMouseEvent->PreventDefault();
-        aMouseEvent->StopPropagation();
-        CaptureMouseEvents(false);
-        return NS_ERROR_FAILURE;
-      }
-
-      if (kNothingSelected != selectedIndex) {
-        AutoWeakFrame weakFrame(this);
-        ComboboxFinish(selectedIndex);
-        if (!weakFrame.IsAlive()) {
-          return NS_OK;
-        }
-
-        FireOnInputAndOnChange();
-      }
-
-      mouseEvent->mClickCount = 1;
-    } else {
-      // the click was out side of the select or its dropdown
-      mouseEvent->mClickCount =
-          IgnoreMouseEventForSelection(aMouseEvent) ? 1 : 0;
-    }
-  } else {
-    CaptureMouseEvents(false);
-    // Notify
-    if (mChangesSinceDragStart) {
-      // reset this so that future MouseUps without a prior MouseDown
-      // won't fire onchange
-      mChangesSinceDragStart = false;
-      FireOnInputAndOnChange();
-    }
-  }
-
-  return NS_OK;
-}
-
-void nsListControlFrame::UpdateInListState(dom::Event* aEvent) {
-  if (!mComboboxFrame || !mComboboxFrame->IsDroppedDown()) return;
-
-  nsPoint pt = nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(aEvent, this);
-  nsRect borderInnerEdge = GetScrollPortRect();
-  if (pt.y >= borderInnerEdge.y && pt.y < borderInnerEdge.YMost()) {
-    mItemSelectionStarted = true;
-  }
-}
-
-bool nsListControlFrame::IgnoreMouseEventForSelection(dom::Event* aEvent) {
-  if (!mComboboxFrame) return false;
-
-  // Our DOM listener does get called when the dropdown is not
-  // showing, because it listens to events on the SELECT element
-  if (!mComboboxFrame->IsDroppedDown()) return true;
-
-  return !mItemSelectionStarted;
-}
-
 #ifdef ACCESSIBILITY
 void nsListControlFrame::FireMenuItemActiveEvent(nsIContent* aPreviousOption) {
-  if ((mFocused != this && !IsInDropDownMode()) ||
-      (IsInDropDownMode() && !mComboboxFrame->IsDroppedDown())) {
+  if (mFocused != this) {
     return;
   }
 
@@ -1605,8 +1065,6 @@ void nsListControlFrame::FireMenuItemActiveEvent(nsIContent* aPreviousOption) {
 
 nsresult nsListControlFrame::GetIndexFromDOMEvent(dom::Event* aMouseEvent,
                                                   int32_t& aCurIndex) {
-  if (IgnoreMouseEventForSelection(aMouseEvent)) return NS_ERROR_FAILURE;
-
   if (PresShell::GetCapturingContent() != mContent) {
     // If we're not capturing, then ignore movement in the border
     nsPoint pt =
@@ -1633,59 +1091,11 @@ nsresult nsListControlFrame::GetIndexFromDOMEvent(dom::Event* aMouseEvent,
   return NS_ERROR_FAILURE;
 }
 
-static bool FireShowDropDownEvent(nsIContent* aContent, bool aShow,
-                                  bool aIsSourceTouchEvent) {
-  if (ShouldFireDropDownEvent()) {
-    nsString eventName;
-    if (aShow) {
-      eventName = aIsSourceTouchEvent ? u"mozshowdropdown-sourcetouch"_ns
-                                      : u"mozshowdropdown"_ns;
-    } else {
-      eventName = u"mozhidedropdown"_ns;
-    }
-    nsContentUtils::DispatchChromeEvent(aContent->OwnerDoc(), aContent,
-                                        eventName, CanBubble::eYes,
-                                        Cancelable::eNo);
-    return true;
-  }
-
-  return false;
-}
-
-nsresult nsListControlFrame::MouseDown(dom::Event* aMouseEvent) {
-  NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
-
-  MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
-  NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
-
-  UpdateInListState(aMouseEvent);
-
-  EventStates eventStates = mContent->AsElement()->State();
-  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
-    return NS_OK;
-  }
-
-  // only allow selection with the left button
-  // if a right button click is on the combobox itself
-  // or on the select when in listbox mode, then let the click through
-  if (!IsLeftButton(aMouseEvent)) {
-    if (IsInDropDownMode()) {
-      if (!IgnoreMouseEventForSelection(aMouseEvent)) {
-        aMouseEvent->PreventDefault();
-        aMouseEvent->StopPropagation();
-      } else {
-        return NS_OK;
-      }
-      return NS_ERROR_FAILURE;  // means consume event
-    } else {
-      return NS_OK;
-    }
-  }
-
+nsresult nsListControlFrame::HandleLeftButtonMouseDown(
+    dom::Event* aMouseEvent) {
   int32_t selectedIndex;
   if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
     // Handle Like List
-    mButtonDown = true;
     CaptureMouseEvents(true);
     AutoWeakFrame weakFrame(this);
     bool change =
@@ -1694,67 +1104,22 @@ nsresult nsListControlFrame::MouseDown(dom::Event* aMouseEvent) {
       return NS_OK;
     }
     mChangesSinceDragStart = change;
-  } else {
-    // NOTE: the combo box is responsible for dropping it down
-    if (mComboboxFrame) {
-      // Ignore the click that occurs on the option element when one is
-      // selected from the parent process popup.
-      if (mComboboxFrame->IsOpenInParentProcess()) {
-        nsCOMPtr<nsIContent> econtent =
-            do_QueryInterface(aMouseEvent->GetTarget());
-        HTMLOptionElement* option = HTMLOptionElement::FromNodeOrNull(econtent);
-        if (option) {
-          return NS_OK;
-        }
-      }
-
-      uint16_t inputSource = mouseEvent->MozInputSource();
-      bool isSourceTouchEvent =
-          inputSource == MouseEvent_Binding::MOZ_SOURCE_TOUCH;
-      if (FireShowDropDownEvent(
-              mContent, !mComboboxFrame->IsDroppedDownOrHasParentPopup(),
-              isSourceTouchEvent)) {
-        return NS_OK;
-      }
-
-      if (!IgnoreMouseEventForSelection(aMouseEvent)) {
-        return NS_OK;
-      }
-
-      if (!nsComboboxControlFrame::ToolkitHasNativePopup()) {
-        bool isDroppedDown = mComboboxFrame->IsDroppedDown();
-        nsIFrame* comboFrame = do_QueryFrame(mComboboxFrame);
-        AutoWeakFrame weakFrame(comboFrame);
-        mComboboxFrame->ShowDropDown(!isDroppedDown);
-        if (!weakFrame.IsAlive()) return NS_OK;
-        if (isDroppedDown) {
-          CaptureMouseEvents(false);
-        }
-      }
-    }
   }
-
   return NS_OK;
 }
 
-nsresult nsListControlFrame::MouseMove(dom::Event* aMouseEvent) {
-  NS_ASSERTION(aMouseEvent, "aMouseEvent is null.");
-  MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
-  NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
-
-  UpdateInListState(aMouseEvent);
-
-  if (IsInDropDownMode()) {
-    if (mComboboxFrame->IsDroppedDown()) {
-      int32_t selectedIndex;
-      if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
-        PerformSelection(selectedIndex, false, false);  // might destroy us
-      }
-    }
-  } else {  // XXX - temporary until we get drag events
-    if (mButtonDown) {
-      return DragMove(aMouseEvent);  // might destroy us
-    }
+nsresult nsListControlFrame::HandleLeftButtonMouseUp(dom::Event* aMouseEvent) {
+  if (!StyleVisibility()->IsVisible()) {
+    return NS_OK;
+  }
+  // Notify
+  if (mChangesSinceDragStart) {
+    // reset this so that future MouseUps without a prior MouseDown
+    // won't fire onchange
+    mChangesSinceDragStart = false;
+    RefPtr listener = mEventListener;
+    listener->FireOnInputAndOnChange();
+    // Note that `this` may be dead now, as the above call runs script.
   }
   return NS_OK;
 }
@@ -1762,31 +1127,27 @@ nsresult nsListControlFrame::MouseMove(dom::Event* aMouseEvent) {
 nsresult nsListControlFrame::DragMove(dom::Event* aMouseEvent) {
   NS_ASSERTION(aMouseEvent, "aMouseEvent is null.");
 
-  UpdateInListState(aMouseEvent);
-
-  if (!IsInDropDownMode()) {
-    int32_t selectedIndex;
-    if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
-      // Don't waste cycles if we already dragged over this item
-      if (selectedIndex == mEndSelectionIndex) {
-        return NS_OK;
-      }
-      MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
-      NS_ASSERTION(mouseEvent, "aMouseEvent is not a MouseEvent!");
-      bool isControl;
-#ifdef XP_MACOSX
-      isControl = mouseEvent->MetaKey();
-#else
-      isControl = mouseEvent->CtrlKey();
-#endif
-      AutoWeakFrame weakFrame(this);
-      // Turn SHIFT on when you are dragging, unless control is on.
-      bool wasChanged = PerformSelection(selectedIndex, !isControl, isControl);
-      if (!weakFrame.IsAlive()) {
-        return NS_OK;
-      }
-      mChangesSinceDragStart = mChangesSinceDragStart || wasChanged;
+  int32_t selectedIndex;
+  if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
+    // Don't waste cycles if we already dragged over this item
+    if (selectedIndex == mEndSelectionIndex) {
+      return NS_OK;
     }
+    MouseEvent* mouseEvent = aMouseEvent->AsMouseEvent();
+    NS_ASSERTION(mouseEvent, "aMouseEvent is not a MouseEvent!");
+    bool isControl;
+#ifdef XP_MACOSX
+    isControl = mouseEvent->MetaKey();
+#else
+    isControl = mouseEvent->CtrlKey();
+#endif
+    AutoWeakFrame weakFrame(this);
+    // Turn SHIFT on when you are dragging, unless control is on.
+    bool wasChanged = PerformSelection(selectedIndex, !isControl, isControl);
+    if (!weakFrame.IsAlive()) {
+      return NS_OK;
+    }
+    mChangesSinceDragStart = mChangesSinceDragStart || wasChanged;
   }
   return NS_OK;
 }
@@ -1820,502 +1181,9 @@ void nsListControlFrame::ScrollToFrame(dom::HTMLOptionElement& aOptElement) {
   }
 }
 
-//---------------------------------------------------------------------
-// Ok, the entire idea of this routine is to move to the next item that
-// is suppose to be selected. If the item is disabled then we search in
-// the same direction looking for the next item to select. If we run off
-// the end of the list then we start at the end of the list and search
-// backwards until we get back to the original item or an enabled option
-//
-// aStartIndex - the index to start searching from
-// aNewIndex - will get set to the new index if it finds one
-// aNumOptions - the total number of options in the list
-// aDoAdjustInc - the initial increment 1-n
-// aDoAdjustIncNext - the increment used to search for the next enabled option
-//
-// the aDoAdjustInc could be a "1" for a single item or
-// any number greater representing a page of items
-//
-void nsListControlFrame::AdjustIndexForDisabledOpt(int32_t aStartIndex,
-                                                   int32_t& aNewIndex,
-                                                   int32_t aNumOptions,
-                                                   int32_t aDoAdjustInc,
-                                                   int32_t aDoAdjustIncNext) {
-  // Cannot select anything if there is nothing to select
-  if (aNumOptions == 0) {
-    aNewIndex = kNothingSelected;
-    return;
-  }
-
-  // means we reached the end of the list and now we are searching backwards
-  bool doingReverse = false;
-  // lowest index in the search range
-  int32_t bottom = 0;
-  // highest index in the search range
-  int32_t top = aNumOptions;
-
-  // Start off keyboard options at selectedIndex if nothing else is defaulted to
-  //
-  // XXX Perhaps this should happen for mouse too, to start off shift click
-  // automatically in multiple ... to do this, we'd need to override
-  // OnOptionSelected and set mStartSelectedIndex if nothing is selected.  Not
-  // sure of the effects, though, so I'm not doing it just yet.
-  int32_t startIndex = aStartIndex;
-  if (startIndex < bottom) {
-    startIndex = GetSelectedIndex();
-  }
-  int32_t newIndex = startIndex + aDoAdjustInc;
-
-  // make sure we start off in the range
-  if (newIndex < bottom) {
-    newIndex = 0;
-  } else if (newIndex >= top) {
-    newIndex = aNumOptions - 1;
-  }
-
-  while (1) {
-    // if the newIndex is selectable, we are golden, bail out
-    if (IsOptionInteractivelySelectable(newIndex)) {
-      break;
-    }
-
-    // it WAS disabled, so sart looking ahead for the next enabled option
-    newIndex += aDoAdjustIncNext;
-
-    // well, if we reach end reverse the search
-    if (newIndex < bottom) {
-      if (doingReverse) {
-        return;  // if we are in reverse mode and reach the end bail out
-      } else {
-        // reset the newIndex to the end of the list we hit
-        // reverse the incrementer
-        // set the other end of the list to our original starting index
-        newIndex = bottom;
-        aDoAdjustIncNext = 1;
-        doingReverse = true;
-        top = startIndex;
-      }
-    } else if (newIndex >= top) {
-      if (doingReverse) {
-        return;  // if we are in reverse mode and reach the end bail out
-      } else {
-        // reset the newIndex to the end of the list we hit
-        // reverse the incrementer
-        // set the other end of the list to our original starting index
-        newIndex = top - 1;
-        aDoAdjustIncNext = -1;
-        doingReverse = true;
-        bottom = startIndex;
-      }
-    }
-  }
-
-  // Looks like we found one
-  aNewIndex = newIndex;
-}
-
-nsAString& nsListControlFrame::GetIncrementalString() {
-  if (!sIncrementalString) {
-    sIncrementalString = new nsString();
-  }
-
-  return *sIncrementalString;
-}
-
-void nsListControlFrame::Shutdown() { sIncrementalString = nullptr; }
-
-void nsListControlFrame::DropDownToggleKey(dom::Event* aKeyEvent) {
-  // Cocoa widgets do native popups, so don't try to show
-  // dropdowns there.
-  if (IsInDropDownMode() && !nsComboboxControlFrame::ToolkitHasNativePopup()) {
-    aKeyEvent->PreventDefault();
-    if (!mComboboxFrame->IsDroppedDown()) {
-      if (!FireShowDropDownEvent(mContent, true, false)) {
-        mComboboxFrame->ShowDropDown(true);
-      }
-    } else {
-      AutoWeakFrame weakFrame(this);
-      // mEndSelectionIndex is the last item that got selected.
-      ComboboxFinish(mEndSelectionIndex);
-      if (weakFrame.IsAlive()) {
-        FireOnInputAndOnChange();
-      }
-    }
-  }
-}
-
-nsresult nsListControlFrame::KeyDown(dom::Event* aKeyEvent) {
-  MOZ_ASSERT(aKeyEvent, "aKeyEvent is null.");
-
-  EventStates eventStates = mContent->AsElement()->State();
-  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
-    return NS_OK;
-  }
-
-  AutoIncrementalSearchResetter incrementalSearchResetter;
-
-  if (aKeyEvent->DefaultPrevented()) {
-    return NS_OK;
-  }
-
-  const WidgetKeyboardEvent* keyEvent =
-      aKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
-  MOZ_ASSERT(keyEvent,
-             "DOM event must have WidgetKeyboardEvent for its internal event");
-
-  bool dropDownMenuOnUpDown;
-  bool dropDownMenuOnSpace;
-#ifdef XP_MACOSX
-  dropDownMenuOnUpDown = IsInDropDownMode() && !mComboboxFrame->IsDroppedDown();
-  dropDownMenuOnSpace =
-      !keyEvent->IsAlt() && !keyEvent->IsControl() && !keyEvent->IsMeta();
-#else
-  dropDownMenuOnUpDown = keyEvent->IsAlt();
-  dropDownMenuOnSpace = IsInDropDownMode() && !mComboboxFrame->IsDroppedDown();
-#endif
-  bool withinIncrementalSearchTime =
-      keyEvent->mTime - gLastKeyTime <=
-      StaticPrefs::ui_menu_incremental_search_timeout();
-  if ((dropDownMenuOnUpDown &&
-       (keyEvent->mKeyCode == NS_VK_UP || keyEvent->mKeyCode == NS_VK_DOWN)) ||
-      (dropDownMenuOnSpace && keyEvent->mKeyCode == NS_VK_SPACE &&
-       !withinIncrementalSearchTime)) {
-    DropDownToggleKey(aKeyEvent);
-    if (keyEvent->DefaultPrevented()) {
-      return NS_OK;
-    }
-  }
-  if (keyEvent->IsAlt()) {
-    return NS_OK;
-  }
-
-  // now make sure there are options or we are wasting our time
-  RefPtr<dom::HTMLOptionsCollection> options = GetOptions();
-  NS_ENSURE_TRUE(options, NS_ERROR_FAILURE);
-
-  uint32_t numOptions = options->Length();
-
-  // this is the new index to set
-  int32_t newIndex = kNothingSelected;
-
-  bool isControlOrMeta = (keyEvent->IsControl() || keyEvent->IsMeta());
-  // Don't try to handle multiple-select pgUp/pgDown in single-select lists.
-  if (isControlOrMeta && !GetMultiple() &&
-      (keyEvent->mKeyCode == NS_VK_PAGE_UP ||
-       keyEvent->mKeyCode == NS_VK_PAGE_DOWN)) {
-    return NS_OK;
-  }
-  if (isControlOrMeta &&
-      (keyEvent->mKeyCode == NS_VK_UP || keyEvent->mKeyCode == NS_VK_LEFT ||
-       keyEvent->mKeyCode == NS_VK_DOWN || keyEvent->mKeyCode == NS_VK_RIGHT ||
-       keyEvent->mKeyCode == NS_VK_HOME || keyEvent->mKeyCode == NS_VK_END)) {
-    // Don't go into multiple-select mode unless this list can handle it.
-    isControlOrMeta = mControlSelectMode = GetMultiple();
-  } else if (keyEvent->mKeyCode != NS_VK_SPACE) {
-    mControlSelectMode = false;
-  }
-
-  // We should not change the selection if the popup is "opened
-  // in the parent process" (even when we're in single-process mode).
-  bool shouldSelectByKey =
-      !mComboboxFrame || !mComboboxFrame->IsOpenInParentProcess();
-
-  switch (keyEvent->mKeyCode) {
-    case NS_VK_UP:
-    case NS_VK_LEFT:
-      if (shouldSelectByKey) {
-        AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
-                                  static_cast<int32_t>(numOptions), -1, -1);
-      }
-      break;
-    case NS_VK_DOWN:
-    case NS_VK_RIGHT:
-      if (shouldSelectByKey) {
-        AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
-                                  static_cast<int32_t>(numOptions), 1, 1);
-      }
-      break;
-    case NS_VK_RETURN:
-      if (IsInDropDownMode()) {
-        if (mComboboxFrame->IsDroppedDown()) {
-          // If the select element is a dropdown style, Enter key should be
-          // consumed while the dropdown is open for security.
-          aKeyEvent->PreventDefault();
-
-          AutoWeakFrame weakFrame(this);
-          ComboboxFinish(mEndSelectionIndex);
-          if (!weakFrame.IsAlive()) {
-            return NS_OK;
-          }
-        }
-        FireOnInputAndOnChange();
-        return NS_OK;
-      }
-
-      // If this is single select listbox, Enter key doesn't cause anything.
-      if (!GetMultiple()) {
-        return NS_OK;
-      }
-
-      newIndex = mEndSelectionIndex;
-      break;
-    case NS_VK_ESCAPE: {
-      // If the select element is a listbox style, Escape key causes nothing.
-      if (!IsInDropDownMode()) {
-        return NS_OK;
-      }
-
-      // We don't want to preventDefault for escape key if the dropdown
-      // popup is not shown.
-      // Need to do the check before AboutToRollup because AboutToRollup
-      // may update the dropdown flags.
-      bool doPreventDefault =
-          !mComboboxFrame || mComboboxFrame->IsDroppedDownOrHasParentPopup();
-
-      AboutToRollup();
-      // If the select element is a dropdown style, Escape key should be
-      // consumed everytime since Escape key may be pressed accidentally after
-      // the dropdown is closed by Escepe key.
-      if (doPreventDefault) {
-        aKeyEvent->PreventDefault();
-      }
-      return NS_OK;
-    }
-    case NS_VK_PAGE_UP: {
-      if (shouldSelectByKey) {
-        int32_t itemsPerPage =
-            std::max(1, static_cast<int32_t>(mNumDisplayRows - 1));
-        AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
-                                  static_cast<int32_t>(numOptions),
-                                  -itemsPerPage, -1);
-      }
-      break;
-    }
-    case NS_VK_PAGE_DOWN: {
-      if (shouldSelectByKey) {
-        int32_t itemsPerPage =
-            std::max(1, static_cast<int32_t>(mNumDisplayRows - 1));
-        AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
-                                  static_cast<int32_t>(numOptions),
-                                  itemsPerPage, 1);
-      }
-      break;
-    }
-    case NS_VK_HOME:
-      if (shouldSelectByKey) {
-        AdjustIndexForDisabledOpt(0, newIndex, static_cast<int32_t>(numOptions),
-                                  0, 1);
-      }
-      break;
-    case NS_VK_END:
-      if (shouldSelectByKey) {
-        AdjustIndexForDisabledOpt(static_cast<int32_t>(numOptions) - 1,
-                                  newIndex, static_cast<int32_t>(numOptions), 0,
-                                  -1);
-      }
-      break;
-
-#if defined(XP_WIN)
-    case NS_VK_F4:
-      if (!isControlOrMeta) {
-        DropDownToggleKey(aKeyEvent);
-      }
-      return NS_OK;
-#endif
-
-    default:  // printable key will be handled by keypress event.
-      incrementalSearchResetter.Cancel();
-      return NS_OK;
-  }
-
-  aKeyEvent->PreventDefault();
-
-  // Actually process the new index and let the selection code
-  // do the scrolling for us
-  PostHandleKeyEvent(newIndex, 0, keyEvent->IsShift(), isControlOrMeta);
-  return NS_OK;
-}
-
-nsresult nsListControlFrame::KeyPress(dom::Event* aKeyEvent) {
-  MOZ_ASSERT(aKeyEvent, "aKeyEvent is null.");
-
-  EventStates eventStates = mContent->AsElement()->State();
-  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
-    return NS_OK;
-  }
-
-  AutoIncrementalSearchResetter incrementalSearchResetter;
-
-  const WidgetKeyboardEvent* keyEvent =
-      aKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
-  MOZ_ASSERT(keyEvent,
-             "DOM event must have WidgetKeyboardEvent for its internal event");
-
-  // Select option with this as the first character
-  // XXX Not I18N compliant
-
-  // Don't do incremental search if the key event has already consumed.
-  if (keyEvent->DefaultPrevented()) {
-    return NS_OK;
-  }
-
-  if (keyEvent->IsAlt()) {
-    return NS_OK;
-  }
-
-  // With some keyboard layout, space key causes non-ASCII space.
-  // So, the check in keydown event handler isn't enough, we need to check it
-  // again with keypress event.
-  if (keyEvent->mCharCode != ' ') {
-    mControlSelectMode = false;
-  }
-
-  bool isControlOrMeta = (keyEvent->IsControl() || keyEvent->IsMeta());
-  if (isControlOrMeta && keyEvent->mCharCode != ' ') {
-    return NS_OK;
-  }
-
-  // NOTE: If mKeyCode of keypress event is not 0, mCharCode is always 0.
-  //       Therefore, all non-printable keys are not handled after this block.
-  if (!keyEvent->mCharCode) {
-    // Backspace key will delete the last char in the string.  Otherwise,
-    // non-printable keypress should reset incremental search.
-    if (keyEvent->mKeyCode == NS_VK_BACK) {
-      incrementalSearchResetter.Cancel();
-      if (!GetIncrementalString().IsEmpty()) {
-        GetIncrementalString().Truncate(GetIncrementalString().Length() - 1);
-      }
-      aKeyEvent->PreventDefault();
-    } else {
-      // XXX When a select element has focus, even if the key causes nothing,
-      //     it might be better to call preventDefault() here because nobody
-      //     should expect one of other elements including chrome handles the
-      //     key event.
-    }
-    return NS_OK;
-  }
-
-  incrementalSearchResetter.Cancel();
-
-  // We ate the key if we got this far.
-  aKeyEvent->PreventDefault();
-
-  // XXX Why don't we check/modify timestamp first?
-
-  // Incremental Search: if time elapsed is below
-  // ui.menu.incremental_search.timeout, append this keystroke to the search
-  // string we will use to find options and start searching at the current
-  // keystroke.  Otherwise, Truncate the string if it's been a long time
-  // since our last keypress.
-  if (keyEvent->mTime - gLastKeyTime >
-      StaticPrefs::ui_menu_incremental_search_timeout()) {
-    // If this is ' ' and we are at the beginning of the string, treat it as
-    // "select this option" (bug 191543)
-    if (keyEvent->mCharCode == ' ') {
-      // Actually process the new index and let the selection code
-      // do the scrolling for us
-      PostHandleKeyEvent(mEndSelectionIndex, keyEvent->mCharCode,
-                         keyEvent->IsShift(), isControlOrMeta);
-
-      return NS_OK;
-    }
-
-    GetIncrementalString().Truncate();
-  }
-
-  gLastKeyTime = keyEvent->mTime;
-
-  // Append this keystroke to the search string.
-  char16_t uniChar = ToLowerCase(static_cast<char16_t>(keyEvent->mCharCode));
-  GetIncrementalString().Append(uniChar);
-
-  // See bug 188199, if all letters in incremental string are same, just try to
-  // match the first one
-  nsAutoString incrementalString(GetIncrementalString());
-  uint32_t charIndex = 1, stringLength = incrementalString.Length();
-  while (charIndex < stringLength &&
-         incrementalString[charIndex] == incrementalString[charIndex - 1]) {
-    charIndex++;
-  }
-  if (charIndex == stringLength) {
-    incrementalString.Truncate(1);
-    stringLength = 1;
-  }
-
-  // Determine where we're going to start reading the string
-  // If we have multiple characters to look for, we start looking *at* the
-  // current option.  If we have only one character to look for, we start
-  // looking *after* the current option.
-  // Exception: if there is no option selected to start at, we always start
-  // *at* 0.
-  int32_t startIndex = GetSelectedIndex();
-  if (startIndex == kNothingSelected) {
-    startIndex = 0;
-  } else if (stringLength == 1) {
-    startIndex++;
-  }
-
-  // now make sure there are options or we are wasting our time
-  RefPtr<dom::HTMLOptionsCollection> options = GetOptions();
-  NS_ENSURE_TRUE(options, NS_ERROR_FAILURE);
-
-  uint32_t numOptions = options->Length();
-
-  AutoWeakFrame weakFrame(this);
-  for (uint32_t i = 0; i < numOptions; ++i) {
-    uint32_t index = (i + startIndex) % numOptions;
-    RefPtr<dom::HTMLOptionElement> optionElement = options->ItemAsOption(index);
-    if (!optionElement || !optionElement->GetPrimaryFrame()) {
-      continue;
-    }
-
-    nsAutoString text;
-    optionElement->GetRenderedLabel(text);
-    if (!StringBeginsWith(
-            nsContentUtils::TrimWhitespace<
-                nsContentUtils::IsHTMLWhitespaceOrNBSP>(text, false),
-            incrementalString, nsCaseInsensitiveStringComparator)) {
-      continue;
-    }
-
-    bool wasChanged =
-        PerformSelection(index, keyEvent->IsShift(), isControlOrMeta);
-    if (!weakFrame.IsAlive()) {
-      return NS_OK;
-    }
-    if (!wasChanged) {
-      break;
-    }
-
-    // If UpdateSelection() returns false, that means the frame is no longer
-    // alive. We should stop doing anything.
-    if (!UpdateSelection()) {
-      return NS_OK;
-    }
-    break;
-  }
-
-  return NS_OK;
-}
-
-void nsListControlFrame::PostHandleKeyEvent(int32_t aNewIndex,
-                                            uint32_t aCharCode, bool aIsShift,
-                                            bool aIsControlOrMeta) {
-  if (aNewIndex == kNothingSelected) {
-    int32_t focusedIndex = mEndSelectionIndex == kNothingSelected
-                               ? GetSelectedIndex()
-                               : mEndSelectionIndex;
-    if (focusedIndex != kNothingSelected) {
-      return;
-    }
-    // No options are selected.  In this case the focus ring is on the first
-    // non-disabled option (if any), so we should behave as if that's the option
-    // the user acted on.
-    if (!GetNonDisabledOptionFrom(0, &aNewIndex)) {
-      return;
-    }
-  }
-
+void nsListControlFrame::UpdateSelectionAfterKeyEvent(
+    int32_t aNewIndex, uint32_t aCharCode, bool aIsShift, bool aIsControlOrMeta,
+    bool aIsControlSelectMode) {
   // If you hold control, but not shift, no key will actually do anything
   // except space.
   AutoWeakFrame weakFrame(this);
@@ -2335,7 +1203,7 @@ void nsListControlFrame::PostHandleKeyEvent(int32_t aNewIndex,
 #ifdef ACCESSIBILITY
     FireMenuItemActiveEvent(prevOption);
 #endif
-  } else if (mControlSelectMode && aCharCode == ' ') {
+  } else if (aIsControlSelectMode && aCharCode == ' ') {
     wasChanged = SingleSelection(aNewIndex, true);
   } else {
     wasChanged = PerformSelection(aNewIndex, aIsShift, aIsControlOrMeta);
@@ -2345,42 +1213,3 @@ void nsListControlFrame::PostHandleKeyEvent(int32_t aNewIndex,
     UpdateSelection();
   }
 }
-
-/******************************************************************************
- * nsListEventListener
- *****************************************************************************/
-
-NS_IMPL_ISUPPORTS(nsListEventListener, nsIDOMEventListener)
-
-NS_IMETHODIMP
-nsListEventListener::HandleEvent(dom::Event* aEvent) {
-  if (!mFrame) return NS_OK;
-
-  nsAutoString eventType;
-  aEvent->GetType(eventType);
-  if (eventType.EqualsLiteral("keydown")) {
-    return mFrame->nsListControlFrame::KeyDown(aEvent);
-  }
-  if (eventType.EqualsLiteral("keypress")) {
-    return mFrame->nsListControlFrame::KeyPress(aEvent);
-  }
-  if (eventType.EqualsLiteral("mousedown")) {
-    if (aEvent->DefaultPrevented()) {
-      return NS_OK;
-    }
-    return mFrame->nsListControlFrame::MouseDown(aEvent);
-  }
-  if (eventType.EqualsLiteral("mouseup")) {
-    // Don't try to honor defaultPrevented here - it's not web compatible.
-    // (bug 1194733)
-    return mFrame->nsListControlFrame::MouseUp(aEvent);
-  }
-  if (eventType.EqualsLiteral("mousemove")) {
-    // I don't think we want to honor defaultPrevented on mousemove
-    // in general, and it would only prevent highlighting here.
-    return mFrame->nsListControlFrame::MouseMove(aEvent);
-  }
-
-  MOZ_ASSERT_UNREACHABLE("Unexpected eventType");
-  return NS_OK;
-}
diff --git a/layout/forms/nsListControlFrame.h b/layout/forms/nsListControlFrame.h
index 67779e7b0eb2..246b81260a3c 100644
--- a/layout/forms/nsListControlFrame.h
+++ b/layout/forms/nsListControlFrame.h
@@ -24,17 +24,13 @@
 #include "nsISelectControlFrame.h"
 #include "nsSelectsAreaFrame.h"
 
-// X.h defines KeyPress
-#ifdef KeyPress
-#  undef KeyPress
-#endif
-
 class nsComboboxControlFrame;
 class nsPresContext;
-class nsListEventListener;
 
 namespace mozilla {
 class PresShell;
+class HTMLSelectEventListener;
+
 namespace dom {
 class Event;
 class HTMLOptionElement;
@@ -86,6 +82,10 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
 
   nsContainerFrame* GetContentInsertionFrame() final;
 
+  int32_t GetEndSelectionIndex() const { return mEndSelectionIndex; }
+
+  mozilla::dom::HTMLOptionElement* GetCurrentOption() const;
+
   bool IsFrameOfType(uint32_t aFlags) const final {
     return nsHTMLScrollFrame::IsFrameOfType(
         aFlags & ~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock));
@@ -108,9 +108,7 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
   mozilla::a11y::AccType AccessibleType() final;
 #endif
 
-  void SetComboboxFrame(nsIFrame* aComboboxFrame);
   int32_t GetSelectedIndex();
-  HTMLOptionElement* GetCurrentOption();
 
   /**
    * Gets the text of the currently selected item.
@@ -122,25 +120,7 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
   void CaptureMouseEvents(bool aGrabMouseEvents);
   nscoord GetBSizeOfARow();
   uint32_t GetNumberOfOptions();
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY void AboutToDropDown();
 
-  /**
-   * @note This method might destroy the frame, pres shell and other objects.
-   */
-  void AboutToRollup();
-
-  /**
-   * Dispatch a DOM oninput and onchange event synchroniously.
-   * @note This method might destroy the frame, pres shell and other objects.
-   */
-  MOZ_CAN_RUN_SCRIPT
-  void FireOnInputAndOnChange();
-
-  /**
-   * Makes aIndex the selected option of a combobox list.
-   * @note This method might destroy the frame, pres shell and other objects.
-   */
-  MOZ_CAN_RUN_SCRIPT_BOUNDARY void ComboboxFinish(int32_t aIndex);
   MOZ_CAN_RUN_SCRIPT_BOUNDARY void OnContentReset();
 
   // nsISelectControlFrame
@@ -164,17 +144,19 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
    * @note These methods might destroy the frame, pres shell and other objects.
    */
   MOZ_CAN_RUN_SCRIPT
-  nsresult MouseDown(mozilla::dom::Event* aMouseEvent);
+  nsresult HandleLeftButtonMouseDown(mozilla::dom::Event* aMouseEvent);
   MOZ_CAN_RUN_SCRIPT
-  nsresult MouseUp(mozilla::dom::Event* aMouseEvent);
-  MOZ_CAN_RUN_SCRIPT
-  nsresult MouseMove(mozilla::dom::Event* aMouseEvent);
+  nsresult HandleLeftButtonMouseUp(mozilla::dom::Event* aMouseEvent);
   MOZ_CAN_RUN_SCRIPT
   nsresult DragMove(mozilla::dom::Event* aMouseEvent);
   MOZ_CAN_RUN_SCRIPT
-  nsresult KeyDown(mozilla::dom::Event* aKeyEvent);
+
   MOZ_CAN_RUN_SCRIPT
-  nsresult KeyPress(mozilla::dom::Event* aKeyEvent);
+  bool PerformSelection(int32_t aClickedIndex, bool aIsShift, bool aIsControl);
+  MOZ_CAN_RUN_SCRIPT
+  void UpdateSelectionAfterKeyEvent(int32_t aNewIndex, uint32_t aCharCode,
+                                    bool aIsShift, bool aIsControlOrMeta,
+                                    bool aIsControlSelectMode);
 
   /**
    * Returns the options collection for mContent, if any.
@@ -185,8 +167,6 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
    */
   HTMLOptionElement* GetOption(uint32_t aIndex) const;
 
-  static void ComboboxFocusSet();
-
   // Helper
   bool IsFocused() { return this == mFocused; }
 
@@ -222,27 +202,11 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
     nsHTMLScrollFrame::SetSuppressScrollbarUpdate(aSuppress);
   }
 
-  /**
-   * Return whether the list is in dropdown mode.
-   */
-  bool IsInDropDownMode() const;
-
   /**
    * Return the number of displayed rows in the list.
    */
   uint32_t GetNumDisplayRows() const { return mNumDisplayRows; }
 
-  /**
-   * Return true if the drop-down list can display more rows.
-   * (always false if not in drop-down mode)
-   */
-  bool GetDropdownCanGrow() const { return mDropdownCanGrow; }
-
-  /**
-   * Frees statics owned by this class.
-   */
-  static void Shutdown();
-
 #ifdef ACCESSIBILITY
   /**
    * Post a custom DOM event for the change, so that accessibility can
@@ -254,13 +218,6 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
 #endif
 
  protected:
-  /**
-   * Return the first non-disabled option starting at aFromIndex (inclusive).
-   * @param aFoundIndex if non-null, set to the index of the returned option
-   */
-  HTMLOptionElement* GetNonDisabledOptionFrom(int32_t aFromIndex,
-                                              int32_t* aFoundIndex = nullptr);
-
   /**
    * Updates the selected text in a combobox and then calls FireOnChange().
    * @note This method might destroy the frame, pres shell and other objects.
@@ -277,12 +234,7 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
                                           nsGkAtoms::multiple);
   }
 
-  /**
-   * Toggles (show/hide) the combobox dropdown menu.
-   * @note This method might destroy the frame, pres shell and other objects.
-   */
-  MOZ_CAN_RUN_SCRIPT
-  void DropDownToggleKey(mozilla::dom::Event* aKeyEvent);
+  mozilla::dom::HTMLSelectElement& Select() const;
 
   /**
    * @return true if the <option> at aIndex is selectable by the user.
@@ -299,27 +251,6 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
 
   MOZ_CAN_RUN_SCRIPT void ScrollToIndex(int32_t anIndex);
 
-  /**
-   * When the user clicks on the comboboxframe to show the dropdown
-   * listbox, they then have to move the mouse into the list. We don't
-   * want to process those mouse events as selection events (i.e., to
-   * scroll list items into view). So we ignore the events until
-   * the mouse moves below our border-inner-edge, when
-   * mItemSelectionStarted is set.
-   *
-   * @param aPoint relative to this frame
-   */
-  bool IgnoreMouseEventForSelection(mozilla::dom::Event* aEvent);
-
-  /**
-   * If the dropdown is showing and the mouse has moved below our
-   * border-inner-edge, then set mItemSelectionStarted.
-   */
-  void UpdateInListState(mozilla::dom::Event* aEvent);
-  void AdjustIndexForDisabledOpt(int32_t aStartIndex, int32_t& anNewIndex,
-                                 int32_t aNumOptions, int32_t aDoAdjustInc,
-                                 int32_t aDoAdjustIncNext);
-
   /**
    * Resets the select back to it's original default values;
    * those values as determined by the original HTML
@@ -340,7 +271,6 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
                                 int32_t& aCurIndex);
 
   bool CheckIfAllFramesHere();
-  bool IsLeftButton(mozilla::dom::Event* aMouseEvent);
 
   // guess at a row block size based on our own style.
   nscoord CalcFallbackRowBSize(float aFontSizeInflation);
@@ -353,15 +283,6 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
   // Dropped down stuff
   void SetComboboxItem(int32_t aIndex);
 
-  /**
-   * Method to reflow ourselves as a dropdown list.  This differs from
-   * reflow as a listbox because the criteria for needing a second
-   * pass are different.  This will be called from Reflow() as needed.
-   */
-  void ReflowAsDropdown(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
-                        const ReflowInput& aReflowInput,
-                        nsReflowStatus& aStatus);
-
   // Selection
   bool SetOptionsSelectedFromFrame(int32_t aStartIndex, int32_t aEndIndex,
                                    bool aValue, bool aClearAll);
@@ -372,20 +293,17 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
   bool ExtendedSelection(int32_t aStartIndex, int32_t aEndIndex,
                          bool aClearAll);
   MOZ_CAN_RUN_SCRIPT
-  bool PerformSelection(int32_t aClickedIndex, bool aIsShift, bool aIsControl);
-  MOZ_CAN_RUN_SCRIPT
   bool HandleListSelection(mozilla::dom::Event* aDOMEvent,
                            int32_t selectedIndex);
   void InitSelectionRange(int32_t aClickedIndex);
-  MOZ_CAN_RUN_SCRIPT
-  void PostHandleKeyEvent(int32_t aNewIndex, uint32_t aCharCode, bool aIsShift,
-                          bool aIsControlOrMeta);
 
  public:
   nsSelectsAreaFrame* GetOptionsContainer() const {
     return static_cast<nsSelectsAreaFrame*>(GetScrolledFrame());
   }
 
+  static constexpr int32_t kNothingSelected = -1;
+
  protected:
   nscoord BSizeOfARow() { return GetOptionsContainer()->BSizeOfARow(); }
 
@@ -394,21 +312,12 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
    */
   uint32_t GetNumberOfRows();
 
-  nsView* GetViewInternal() const final { return mView; }
-  void SetViewInternal(nsView* aView) final { mView = aView; }
-
   // Data Members
   int32_t mStartSelectionIndex;
   int32_t mEndSelectionIndex;
 
-  nsComboboxControlFrame* mComboboxFrame;
-
-  // The view is only created (& non-null) if IsInDropDownMode() is true.
-  nsView* mView;
-
   uint32_t mNumDisplayRows;
   bool mChangesSinceDragStart : 1;
-  bool mButtonDown : 1;
 
   // Has the user selected a visible item since we showed the dropdown?
   bool mItemSelectionStarted : 1;
@@ -419,9 +328,6 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
   bool mNeedToReset : 1;
   bool mPostChildrenLoadedReset : 1;
 
-  // bool value for multiple discontiguous selection
-  bool mControlSelectMode : 1;
-
   // True if we're in the middle of a reflow and might need a second
   // pass.  This only happens for auto heights.
   bool mMightNeedSecondPass : 1;
@@ -432,10 +338,6 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
    */
   bool mHasPendingInterruptAtStartOfReflow : 1;
 
-  // True if the drop-down can show more rows.  Always false if this list
-  // is not in drop-down mode.
-  bool mDropdownCanGrow : 1;
-
   // True if the selection can be set to nothing or disabled options.
   bool mForceSelection : 1;
 
@@ -449,33 +351,13 @@ class nsListControlFrame final : public nsHTMLScrollFrame,
   // are translucent.
   nscolor mLastDropdownBackstopColor;
 
-  RefPtr<nsListEventListener> mEventListener;
+  RefPtr<mozilla::HTMLSelectEventListener> mEventListener;
 
   static nsListControlFrame* mFocused;
-  static mozilla::StaticAutoPtr<nsString> sIncrementalString;
 
 #ifdef DO_REFLOW_COUNTER
   int32_t mReflowId;
 #endif
-
- private:
-  // for incremental typing navigation
-  static nsAString& GetIncrementalString();
-  static DOMTimeStamp gLastKeyTime;
-
-  class MOZ_RAII AutoIncrementalSearchResetter {
-   public:
-    AutoIncrementalSearchResetter() : mCancelled(false) {}
-    ~AutoIncrementalSearchResetter() {
-      if (!mCancelled) {
-        nsListControlFrame::GetIncrementalString().Truncate();
-      }
-    }
-    void Cancel() { mCancelled = true; }
-
-   private:
-    bool mCancelled;
-  };
 };
 
 #endif /* nsListControlFrame_h___ */
diff --git a/layout/forms/nsSelectsAreaFrame.cpp b/layout/forms/nsSelectsAreaFrame.cpp
index 9d7c5bfb009d..64fcdbd0298a 100644
--- a/layout/forms/nsSelectsAreaFrame.cpp
+++ b/layout/forms/nsSelectsAreaFrame.cpp
@@ -49,22 +49,6 @@ void nsSelectsAreaFrame::Reflow(nsPresContext* aPresContext,
                "Must have an nsListControlFrame!  Frame constructor is "
                "broken");
 
-  bool isInDropdownMode = list->IsInDropDownMode();
-
-  // See similar logic in nsListControlFrame::Reflow and
-  // nsListControlFrame::ReflowAsDropdown.  We need to match it here.
-  WritingMode wm = aReflowInput.GetWritingMode();
-  nscoord oldBSize;
-  if (isInDropdownMode) {
-    // Store the block size now in case it changes during
-    // nsBlockFrame::Reflow for some odd reason.
-    if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
-      oldBSize = BSize(wm);
-    } else {
-      oldBSize = NS_UNCONSTRAINEDSIZE;
-    }
-  }
-
   nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowInput, aStatus);
 
   // Check whether we need to suppress scrollbar updates.  We want to do
@@ -76,9 +60,7 @@ void nsSelectsAreaFrame::Reflow(nsPresContext* aPresContext,
     // comboboxes, we'll also need it if our block size changed.  If
     // we're going to do a second pass, suppress scrollbar updates for
     // this pass.
-    if (newBSizeOfARow != mBSizeOfARow ||
-        (isInDropdownMode &&
-         (oldBSize != aDesiredSize.BSize(wm) || oldBSize != BSize(wm)))) {
+    if (newBSizeOfARow != mBSizeOfARow) {
       mBSizeOfARow = newBSizeOfARow;
       list->SetSuppressScrollbarUpdate(true);
     }
diff --git a/layout/forms/test/bug665540_window.xhtml b/layout/forms/test/bug665540_window.xhtml
deleted file mode 100644
index 3c9a0b58b1af..000000000000
--- a/layout/forms/test/bug665540_window.xhtml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0"?>
-<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
-
-<window title="Test Select Dropdown Positioning in Fullscreen Window"
-        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <body xmlns="http://www.w3.org/1999/xhtml">
-    <select id="select" style="-moz-appearance:none">
-      <option id="optiona">a</option>
-      <option>b</option>
-    </select>
-  </body>
-</window>
diff --git a/layout/forms/test/chrome.ini b/layout/forms/test/chrome.ini
index e8418139b418..cab43b716c5a 100644
--- a/layout/forms/test/chrome.ini
+++ b/layout/forms/test/chrome.ini
@@ -3,9 +3,5 @@ skip-if = os == 'android'
 support-files =
   bug536567_iframe.html
   bug536567_subframe.html
-  bug665540_window.xhtml
 
 [test_bug536567_perwindowpb.html]
-[test_bug665540.html]
-tags = fullscreen
-skip-if = (os == 'linux' && bits == 64) # Bug 888164
diff --git a/layout/forms/test/test_bug665540.html b/layout/forms/test/test_bug665540.html
deleted file mode 100644
index b84c5afd579e..000000000000
--- a/layout/forms/test/test_bug665540.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=665540
--->
-<head>
-  <title>Test for Bug 665540 Select dropdown position in fullscreen window</title>
-  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
-  <script src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"></script>
-  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
-</head>
-<body onload="openFullscreenWindow()">
-<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=665540">Mozilla Bug 665540</a>
-<p id="display"></p>
-<div id="content" style="display: none">
-  
-</div>
-<pre id="test">
-<script type="application/javascript">
-
-/** Test for Bug 665540 **/
-
-SimpleTest.waitForExplicitFinish();
-
-var win;
-var select;
-var optiona;
-var eventType = "mouseover";
-var timeoutID;
-var eventOffsetX = 2;
-var eventOffsetY = 2;
-
-let sizemodeChanged = false;
-let fullscreenChanged = false;
-let childHasFocused = false;
-
-function openFullscreenWindow() {
-    win = window.browsingContext.topChromeWindow
-                .openDialog("bug665540_window.xhtml", "_blank", "resizable=yes,chrome");
-
-    win.addEventListener("sizemodechange", () => {
-        info("sizemodechange. windowState = " + win.windowState + " fullScreen = " + win.fullScreen);
-        sizemodeChanged = true;
-        tryStart();
-    }, { once: true });
-
-    win.addEventListener("fullscreen", () => {
-        info("fullscreen event. windowState = " + win.windowState + " fullScreen = " + win.fullScreen);
-        fullscreenChanged = true;
-        tryStart();
-    }, { once: true });
-
-    SimpleTest.waitForFocus(() => {
-        win.fullScreen = true;
-    }, win);
-
-    // Close our window if the test times out so that it doesn't interfere
-    // with later tests.
-    timeoutID = setTimeout(function () {
-        ok(false, "Test timed out.");
-        // Provide some time for a screenshot
-        setTimeout(finish, 1000);
-    }, 20000);
-}
-
-function tryStart() {
-    // wait until the window goes full screen and its size mode actually changes.
-    if (!sizemodeChanged || !fullscreenChanged) {
-        return;
-    }
-    SimpleTest.waitForFocus(start, win);
-}
-
-function start() {
-    // The select doesn't open if the mouse click is fired too soon
-    // (on X11 at least).
-    setTimeout(openSelect, 1000);
-}
-
-function openSelect() {
-    select = win.document.getElementById("select");
-    synthesizeMouseAtCenter(select, {}, win);
-    // A yield was required on X11 tinderbox machines.
-    // (Wasn't required on other platforms nor on an X11 system with kwin.)
-    setTimeout(checkPosition, 1000);
-}
-
-function checkPosition() {
-    optiona = win.document.getElementById("optiona");
-    optiona.addEventListener(eventType, eventReceived);
-
-    // If the select dropdown is opened in the position where
-    // getBoundingClientRect() predicts, then optiona will receive the event.
-    // The event is received asynchronously (I don't know why), so the handler
-    // is removed later.
-    synthesizeMouse(optiona, eventOffsetX, eventOffsetY,
-                    { type: eventType }, win);
-}
-
-function eventReceived(event) {
-    clearTimeout(timeoutID);
-    optiona.removeEventListener(eventType, eventReceived);
-
-    var rect = optiona.getBoundingClientRect();
-
-    // Note that fullscreen only fully covers one monitor, so win.screenX can
-    // be non-zero.
-    is(event.screenX, win.screenX + rect.left + eventOffsetX,
-       "event.screenX should match sent event");
-    is(event.screenY, win.screenY + rect.top + eventOffsetY,
-       "event.screenY should match sent event");
-
-    finish();
-}
-
-function finish() {
-    if (select && navigator.platform.includes("Win")) {
-        todo(false,
-             "Should not have to close select before closing its window");
-        // This avoids mochitest "Unable to restore focus" errors (bug 670053).
-        synthesizeMouseAtCenter(select, {}, win);
-    }
-
-    is(win.windowState, win.STATE_FULLSCREEN,
-       "window state should still be fullscreen");
-
-    win.close();
-    SimpleTest.finish();
-}
-</script>
-</pre>
-</body>
-</html>
diff --git a/layout/forms/test/test_select_key_navigation_bug1498769.html b/layout/forms/test/test_select_key_navigation_bug1498769.html
index 82b11414d185..3574761e662a 100644
--- a/layout/forms/test/test_select_key_navigation_bug1498769.html
+++ b/layout/forms/test/test_select_key_navigation_bug1498769.html
@@ -19,18 +19,19 @@ https://bugzilla.mozilla.org/show_bug.cgi?id=1498769
     SimpleTest.waitForFocus(function() {
       [...document.querySelectorAll('select')].forEach(function(e) {
         e.focus();
-        is(e.selectedIndex, 1, "the 'selected' attribute is respected");
+        const description = ` (size ${e.size})`;
+        is(e.selectedIndex, 1, "the 'selected' attribute is respected" + description);
         if (kIsMac && e.size == "1") {
           // On OSX, UP/DOWN opens the dropdown menu rather than changing
           // the value so we skip the rest of this test there in this case.
           return;
         }
         synthesizeKey("VK_DOWN", {});
-        is(e.selectedIndex, 2, "VK_DOWN selected the first option below");
+        is(e.selectedIndex, 2, "VK_DOWN selected the first option below" + description);
         synthesizeKey("VK_UP", {});
-        is(e.selectedIndex, 0, "VK_UP skips the display:none/contents option");
+        is(e.selectedIndex, 0, "VK_UP skips the display:none/contents option" + description);
         synthesizeKey("VK_DOWN", {});
-        is(e.selectedIndex, 2, "VK_DOWN skips the display:none/contents option");
+        is(e.selectedIndex, 2, "VK_DOWN skips the display:none/contents option" + description);
       });
       SimpleTest.finish();
     });
diff --git a/layout/generic/nsFontInflationData.cpp b/layout/generic/nsFontInflationData.cpp
index 943b4109adfd..b510a62b0cfb 100644
--- a/layout/generic/nsFontInflationData.cpp
+++ b/layout/generic/nsFontInflationData.cpp
@@ -352,8 +352,8 @@ void nsFontInflationData::ScanTextIn(nsIFrame* aFrame) {
         // Don't just recurse down to the list control inside, since we
         // need to exclude the display frame.
         nscoord fontSize = kid->StyleFont()->mFont.size.ToAppUnits();
-        int32_t charCount = CharCountOfLargestOption(
-            static_cast<nsComboboxControlFrame*>(kid)->GetDropDown());
+        int32_t charCount = static_cast<nsComboboxControlFrame*>(kid)
+                                ->CharCountOfLargestOptionForInflation();
         mTextAmount += charCount * fontSize;
       } else if (fType == LayoutFrameType::ListControl) {
         // See textInputFrame above (with s/amount of text/selected option/).
diff --git a/layout/generic/nsGfxScrollFrame.cpp b/layout/generic/nsGfxScrollFrame.cpp
index b9a49a35269c..1e1c891d5771 100644
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -1616,26 +1616,15 @@ nsMargin ScrollFrameHelper::GetDesiredScrollbarSizes(nsBoxLayoutState* aState) {
   return result;
 }
 
-nscoord ScrollFrameHelper::GetNondisappearingScrollbarWidth(
-    nsBoxLayoutState* aState, WritingMode aWM) {
-  NS_ASSERTION(aState && aState->GetRenderingContext(),
-               "Must have rendering context in layout state for size "
-               "computations");
-
-  bool verticalWM = aWM.IsVertical();
-  // We need to have the proper un-themed scrollbar size, regardless of whether
-  // we're using e.g. scrollbar-width: thin, or overlay scrollbars.
-  nsIFrame* box = verticalWM ? mHScrollbarBox : mVScrollbarBox;
-  if (box) {
-    auto sizes = aState->PresContext()->Theme()->GetScrollbarSizes(
-        aState->PresContext(), StyleScrollbarWidth::Auto,
-        nsITheme::Overlay::No);
-    return aState->PresContext()->DevPixelsToAppUnits(
-        verticalWM ? sizes.mHorizontal : sizes.mVertical);
-  }
-
-  nsMargin sizes(GetDesiredScrollbarSizes(aState));
-  return verticalWM ? sizes.TopBottom() : sizes.LeftRight();
+nscoord nsIScrollableFrame::GetNondisappearingScrollbarWidth(nsPresContext* aPc,
+                                                             WritingMode aWM) {
+  // We use this to size the combobox dropdown button. For that, we need to have
+  // the proper big, non-overlay scrollbar size, regardless of whether we're
+  // using e.g. scrollbar-width: thin, or overlay scrollbars.
+  auto sizes = aPc->Theme()->GetScrollbarSizes(aPc, StyleScrollbarWidth::Auto,
+                                               nsITheme::Overlay::No);
+  return aPc->DevPixelsToAppUnits(aWM.IsVertical() ? sizes.mHorizontal
+                                                   : sizes.mVertical);
 }
 
 void ScrollFrameHelper::HandleScrollbarStyleSwitching() {
diff --git a/layout/generic/nsGfxScrollFrame.h b/layout/generic/nsGfxScrollFrame.h
index 4b5f5f0c5b46..11b55ff82f63 100644
--- a/layout/generic/nsGfxScrollFrame.h
+++ b/layout/generic/nsGfxScrollFrame.h
@@ -382,8 +382,6 @@ class ScrollFrameHelper : public nsIReflowCallback {
       nsIScrollableFrame::ScrollbarSizesOptions aOptions =
           nsIScrollableFrame::ScrollbarSizesOptions::NONE) const;
   nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState);
-  nscoord GetNondisappearingScrollbarWidth(nsBoxLayoutState* aState,
-                                           mozilla::WritingMode aVerticalWM);
   bool IsPhysicalLTR() const {
     return mOuter->GetWritingMode().IsPhysicalLTR();
   }
@@ -988,12 +986,6 @@ class nsHTMLScrollFrame : public nsContainerFrame,
     nsBoxLayoutState bls(aPresContext, aRC, 0);
     return GetDesiredScrollbarSizes(&bls);
   }
-  nscoord GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
-                                           gfxContext* aRC,
-                                           mozilla::WritingMode aWM) final {
-    nsBoxLayoutState bls(aPresContext, aRC, 0);
-    return mHelper.GetNondisappearingScrollbarWidth(&bls, aWM);
-  }
   nsSize GetLayoutSize() const final { return mHelper.GetLayoutSize(); }
   nsRect GetScrolledRect() const final { return mHelper.GetScrolledRect(); }
   nsRect GetScrollPortRect() const final { return mHelper.GetScrollPortRect(); }
@@ -1462,12 +1454,6 @@ class nsXULScrollFrame final : public nsBoxFrame,
     nsBoxLayoutState bls(aPresContext, aRC, 0);
     return GetDesiredScrollbarSizes(&bls);
   }
-  nscoord GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
-                                           gfxContext* aRC,
-                                           mozilla::WritingMode aWM) final {
-    nsBoxLayoutState bls(aPresContext, aRC, 0);
-    return mHelper.GetNondisappearingScrollbarWidth(&bls, aWM);
-  }
   nsSize GetLayoutSize() const final { return mHelper.GetLayoutSize(); }
   nsRect GetScrolledRect() const final { return mHelper.GetScrolledRect(); }
   nsRect GetScrollPortRect() const final { return mHelper.GetScrollPortRect(); }
diff --git a/layout/generic/nsIScrollableFrame.h b/layout/generic/nsIScrollableFrame.h
index 9f7bf2a38415..e515bc9d4fd0 100644
--- a/layout/generic/nsIScrollableFrame.h
+++ b/layout/generic/nsIScrollableFrame.h
@@ -143,9 +143,8 @@ class nsIScrollableFrame : public nsIScrollbarMediator {
   /**
    * Return the width for non-disappearing scrollbars.
    */
-  virtual nscoord GetNondisappearingScrollbarWidth(
-      nsPresContext* aPresContext, gfxContext* aRC,
-      mozilla::WritingMode aWM) = 0;
+  static nscoord GetNondisappearingScrollbarWidth(nsPresContext*,
+                                                  mozilla::WritingMode);
   /**
    * Get the layout size of this frame.
    * Note that this is a value which is not expanded by the minimum scale size.
diff --git a/layout/generic/nsTextFrameUtils.cpp b/layout/generic/nsTextFrameUtils.cpp
index 6ad10c6cb9dd..170ee0f7e617 100644
--- a/layout/generic/nsTextFrameUtils.cpp
+++ b/layout/generic/nsTextFrameUtils.cpp
@@ -341,45 +341,51 @@ template bool nsTextFrameUtils::IsSkippableCharacterForTransformText(
 template bool nsTextFrameUtils::IsSkippableCharacterForTransformText(
     char16_t aChar);
 
-uint32_t nsTextFrameUtils::ComputeApproximateLengthWithWhitespaceCompression(
-    Text* aText, const nsStyleText* aStyleText) {
-  const nsTextFragment* frag = &aText->TextFragment();
+template <typename CharT>
+static uint32_t DoComputeApproximateLengthWithWhitespaceCompression(
+    const CharT* aChars, uint32_t aLength, const nsStyleText* aStyleText) {
   // This is an approximation so we don't really need anything
   // too fancy here.
   uint32_t len;
   if (aStyleText->WhiteSpaceIsSignificant()) {
-    len = frag->GetLength();
-  } else {
-    bool is2b = frag->Is2b();
-    union {
-      const char* s1b;
-      const char16_t* s2b;
-    } u;
-    if (is2b) {
-      u.s2b = frag->Get2b();
-    } else {
-      u.s1b = frag->Get1b();
-    }
-    bool prevWS = true;  // more important to ignore blocks with
-                         // only whitespace than get inline boundaries
-                         // exactly right
-    len = 0;
-    for (uint32_t i = 0, i_end = frag->GetLength(); i < i_end; ++i) {
-      char16_t c = is2b ? u.s2b[i] : u.s1b[i];
-      if (c == ' ' || c == '\n' || c == '\t' || c == '\r') {
-        if (!prevWS) {
-          ++len;
-        }
-        prevWS = true;
-      } else {
+    return aLength;
+  }
+  bool prevWS = true;  // more important to ignore blocks with
+                       // only whitespace than get inline boundaries
+                       // exactly right
+  len = 0;
+  for (uint32_t i = 0; i < aLength; ++i) {
+    CharT c = aChars[i];
+    if (c == ' ' || c == '\n' || c == '\t' || c == '\r') {
+      if (!prevWS) {
         ++len;
-        prevWS = false;
       }
+      prevWS = true;
+    } else {
+      ++len;
+      prevWS = false;
     }
   }
   return len;
 }
 
+uint32_t nsTextFrameUtils::ComputeApproximateLengthWithWhitespaceCompression(
+    Text* aText, const nsStyleText* aStyleText) {
+  const nsTextFragment* frag = &aText->TextFragment();
+  if (frag->Is2b()) {
+    return DoComputeApproximateLengthWithWhitespaceCompression(
+        frag->Get2b(), frag->GetLength(), aStyleText);
+  }
+  return DoComputeApproximateLengthWithWhitespaceCompression(
+      frag->Get1b(), frag->GetLength(), aStyleText);
+}
+
+uint32_t nsTextFrameUtils::ComputeApproximateLengthWithWhitespaceCompression(
+    const nsAString& aString, const nsStyleText* aStyleText) {
+  return DoComputeApproximateLengthWithWhitespaceCompression(
+      aString.BeginReading(), aString.Length(), aStyleText);
+}
+
 bool nsSkipCharsRunIterator::NextRun() {
   do {
     if (mRunLength) {
diff --git a/layout/generic/nsTextFrameUtils.h b/layout/generic/nsTextFrameUtils.h
index 59dc646bbebf..7990ba1632bf 100644
--- a/layout/generic/nsTextFrameUtils.h
+++ b/layout/generic/nsTextFrameUtils.h
@@ -146,7 +146,9 @@ class nsTextFrameUtils {
   }
 
   static uint32_t ComputeApproximateLengthWithWhitespaceCompression(
-      mozilla::dom::Text* aText, const nsStyleText* aStyleText);
+      mozilla::dom::Text*, const nsStyleText*);
+  static uint32_t ComputeApproximateLengthWithWhitespaceCompression(
+      const nsAString&, const nsStyleText*);
 };
 
 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(nsTextFrameUtils::Flags)
diff --git a/modules/libpref/init/all.js b/modules/libpref/init/all.js
index fab5c7b41b8e..4a2c211c0409 100644
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -1034,7 +1034,6 @@ pref("dom.forms.selectSearch", false);
 #else
   pref("dom.forms.select.customstyling", true);
 #endif
-pref("dom.select_popup_in_parent.enabled", false);
 
 pref("dom.cycle_collector.incremental", true);
 
diff --git a/testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size-ref.html b/testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size-ref.html
new file mode 100644
index 000000000000..a02d851c093b
--- /dev/null
+++ b/testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size-ref.html
@@ -0,0 +1,5 @@
+<!doctype html>
+<title>CSS Test Reference</title>
+<select>
+  <option>ABC</option>
+</select>
diff --git a/testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size.html b/testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size.html
new file mode 100644
index 000000000000..1ab40cbb7f1f
--- /dev/null
+++ b/testing/web-platform/tests/html/rendering/replaced-elements/the-select-element/select-intrinsic-option-font-size.html
@@ -0,0 +1,6 @@
+<!doctype html>
+<title>Select should be as wide as needed to fit its options regardless of option styles</title>
+<link rel=match href=select-intrinsic-option-font-size-ref.html>
+<select>
+  <option style="font-size: 5px">ABC</option>
+</select>
diff --git a/toolkit/components/printing/tests/browser_destination_change.js b/toolkit/components/printing/tests/browser_destination_change.js
index a9f1dd0f821e..e2024833e50c 100644
--- a/toolkit/components/printing/tests/browser_destination_change.js
+++ b/toolkit/components/printing/tests/browser_destination_change.js
@@ -28,10 +28,15 @@ async function setupPrinters(helper) {
 async function changeDestination(helper, dir) {
   let picker = helper.get("printer-picker");
   let changed = BrowserTestUtils.waitForEvent(picker, "change");
+  let pickerOpened = BrowserTestUtils.waitForEvent(
+    document.getElementById("ContentSelectDropdown"),
+    "popupshown"
+  );
   picker.focus();
   EventUtils.sendKey("space", helper.win);
-  EventUtils.sendKey(dir, helper.win);
-  EventUtils.sendKey("return", helper.win);
+  await pickerOpened;
+  EventUtils.sendKey(dir, window);
+  EventUtils.sendKey("return", window);
   await changed;
 }
 
diff --git a/toolkit/components/printing/tests/browser_print_duplex.js b/toolkit/components/printing/tests/browser_print_duplex.js
index b4d7e3fbb235..362f2a8fffbf 100644
--- a/toolkit/components/printing/tests/browser_print_duplex.js
+++ b/toolkit/components/printing/tests/browser_print_duplex.js
@@ -4,24 +4,32 @@
 "use strict";
 
 function changeToOption(helper, index) {
-  return helper.waitForSettingsEvent(function() {
+  return helper.waitForSettingsEvent(async function() {
     let select = helper.get("duplex-select");
     select.focus();
     select.scrollIntoView({ block: "center" });
 
+    let popupOpen = BrowserTestUtils.waitForEvent(
+      document.getElementById("ContentSelectDropdown"),
+      "popupshown"
+    );
+
     EventUtils.sendKey("space", helper.win);
+
+    await popupOpen;
+
     let selectedIndex = select.selectedIndex;
     info(`Looking for ${index} from ${selectedIndex}`);
     while (selectedIndex != index) {
       if (index > selectedIndex) {
-        EventUtils.sendKey("down", helper.win);
+        EventUtils.sendKey("down", window);
         selectedIndex++;
       } else {
-        EventUtils.sendKey("up", helper.win);
+        EventUtils.sendKey("up", window);
         selectedIndex--;
       }
     }
-    EventUtils.sendKey("return", helper.win);
+    EventUtils.sendKey("return", window);
   });
 }
 
diff --git a/toolkit/components/printing/tests/browser_print_margins.js b/toolkit/components/printing/tests/browser_print_margins.js
index 02f0b34c6cae..1dbb8bbaa315 100644
--- a/toolkit/components/printing/tests/browser_print_margins.js
+++ b/toolkit/components/printing/tests/browser_print_margins.js
@@ -3,33 +3,44 @@
 
 "use strict";
 
-function changeDefaultToCustom(helper) {
+async function changeMargin(helper, scroll, value) {
   let marginSelect = helper.get("margins-picker");
+
+  info("  current value is " + marginSelect.value);
+
   marginSelect.focus();
-  marginSelect.scrollIntoView({ block: "center" });
-  EventUtils.sendKey("space", helper.win);
-  EventUtils.sendKey("down", helper.win);
-  EventUtils.sendKey("down", helper.win);
-  EventUtils.sendKey("down", helper.win);
-  EventUtils.sendKey("return", helper.win);
+
+  if (scroll) {
+    marginSelect.scrollIntoView({ block: "center" });
+  }
+
+  marginSelect.value = value;
+  marginSelect.dispatchEvent(
+    new marginSelect.ownerGlobal.Event("input", {
+      bubbles: true,
+      composed: true,
+    })
+  );
+  marginSelect.dispatchEvent(
+    new marginSelect.ownerGlobal.Event("change", {
+      bubbles: true,
+    })
+  );
+}
+
+function changeDefaultToCustom(helper) {
+  info("Trying to change margin from default -> custom");
+  return changeMargin(helper, true, "custom");
 }
 
 function changeCustomToDefault(helper) {
-  let marginSelect = helper.get("margins-picker");
-  marginSelect.focus();
-  EventUtils.sendKey("space", helper.win);
-  EventUtils.sendKey("up", helper.win);
-  EventUtils.sendKey("up", helper.win);
-  EventUtils.sendKey("up", helper.win);
-  EventUtils.sendKey("return", helper.win);
+  info("Trying to change margin from custom -> default");
+  return changeMargin(helper, false, "default");
 }
 
 function changeCustomToNone(helper) {
-  let marginSelect = helper.get("margins-picker");
-  marginSelect.focus();
-  EventUtils.sendKey("space", helper.win);
-  EventUtils.sendKey("up", helper.win);
-  EventUtils.sendKey("return", helper.win);
+  info("Trying to change margin from custom -> none");
+  return changeMargin(helper, false, "none");
 }
 
 function assertPendingMarginsUpdate(helper) {
@@ -101,7 +112,7 @@ add_task(async function testCustomMarginMaxAttrsSet() {
 
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
 
     let marginsSelect = helper.get("margins-select");
     is(
@@ -156,7 +167,7 @@ add_task(async function testPresetMargins() {
         is(marginSelect.value, "default", "Default margins set");
         helper.assertSettingsMatch({ honorPageRuleMargins: true });
 
-        changeDefaultToCustom(helper);
+        await changeDefaultToCustom(helper);
 
         is(marginSelect.value, "custom", "Custom margins are now set");
         ok(!customMargins.hidden, "Custom margins are present");
@@ -205,7 +216,7 @@ add_task(async function testHeightError() {
   await PrintHelper.withTestPage(async helper => {
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
 
     await helper.assertSettingsNotChanged(
       { marginTop: 0.5, marginRight: 0.5, marginBottom: 0.5, marginLeft: 0.5 },
@@ -228,7 +239,7 @@ add_task(async function testWidthError() {
   await PrintHelper.withTestPage(async helper => {
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
 
     await helper.assertSettingsNotChanged(
       { marginTop: 0.5, marginRight: 0.5, marginBottom: 0.5, marginLeft: 0.5 },
@@ -251,7 +262,7 @@ add_task(async function testInvalidMarginsReset() {
   await PrintHelper.withTestPage(async helper => {
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     let marginError = helper.get("error-invalid-margin");
 
     await helper.assertSettingsNotChanged(
@@ -267,13 +278,13 @@ add_task(async function testInvalidMarginsReset() {
       }
     );
 
-    this.changeCustomToDefault(helper);
+    await changeCustomToDefault(helper);
     assertNoPendingMarginsUpdate(helper);
     await BrowserTestUtils.waitForCondition(
       () => marginError.hidden,
       "Wait for margin error to be hidden"
     );
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     helper.assertSettingsMatch({
       marginTop: 0.5,
       marginRight: 0.5,
@@ -319,7 +330,7 @@ add_task(async function testChangeInvalidToValidUpdate() {
     await setupLetterPaper();
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     await helper.awaitAnimationFrame();
     let marginError = helper.get("error-invalid-margin");
 
@@ -367,7 +378,7 @@ add_task(async function testChangeInvalidCanRevalidate() {
     await setupLetterPaper();
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     await helper.awaitAnimationFrame();
     let marginError = helper.get("error-invalid-margin");
 
@@ -423,7 +434,7 @@ add_task(async function testCustomMarginsPersist() {
       { marginTop: 0.5, marginRight: 0.5, marginBottom: 0.5, marginLeft: 0.5 },
       { marginTop: 0.25, marginRight: 1, marginBottom: 2, marginLeft: 0 },
       async () => {
-        changeDefaultToCustom(helper);
+        await changeDefaultToCustom(helper);
         await helper.awaitAnimationFrame();
 
         await helper.text(helper.get("custom-margin-top"), "0.25");
@@ -523,7 +534,7 @@ add_task(async function testChangingBetweenMargins() {
       { marginLeft: 0.5 },
       async () => {
         let settingsChanged = helper.waitForSettingsEvent();
-        changeCustomToDefault(helper);
+        await changeCustomToDefault(helper);
         await settingsChanged;
       }
     );
@@ -536,7 +547,7 @@ add_task(async function testChangingBetweenMargins() {
       { marginLeft: 1 },
       async () => {
         let settingsChanged = helper.waitForSettingsEvent();
-        changeDefaultToCustom(helper);
+        await changeDefaultToCustom(helper);
         await settingsChanged;
       }
     );
@@ -549,7 +560,7 @@ add_task(async function testChangingBetweenMargins() {
       { marginLeft: 0.5 },
       async () => {
         let settingsChanged = helper.waitForSettingsEvent();
-        changeCustomToDefault(helper);
+        await changeCustomToDefault(helper);
         await settingsChanged;
       }
     );
@@ -569,7 +580,7 @@ add_task(async function testChangeHonoredInPrint() {
 
     await helper.openMoreSettings();
     helper.assertSettingsMatch({ marginRight: 0.5 });
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
 
     await helper.withClosingFn(async () => {
       await helper.text(helper.get("custom-margin-right"), "1");
@@ -638,7 +649,7 @@ add_task(async function testRevalidateSwitchToNone() {
     await setupLetterPaper();
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     await helper.awaitAnimationFrame();
 
     await helper.text(helper.get("custom-margin-bottom"), "6");
@@ -669,7 +680,7 @@ add_task(async function testRevalidateSwitchToNone() {
       { marginTop: 6, marginRight: 0.5, marginBottom: 3, marginLeft: 0.5 },
       { marginTop: 0, marginRight: 0, marginBottom: 0, marginLeft: 0 },
       async () => {
-        this.changeCustomToNone(helper);
+        await changeCustomToNone(helper);
         is(
           helper.get("margins-picker").value,
           "none",
@@ -701,7 +712,7 @@ add_task(async function testInvalidMarginResetAfterDestinationChange() {
     let destinationPicker = helper.get("printer-picker");
 
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     await helper.awaitAnimationFrame();
 
     let marginError = helper.get("error-invalid-margin");
@@ -743,7 +754,7 @@ add_task(async function testRevalidateCustomMarginsAfterPaperChanges() {
     await helper.startPrint();
     helper.dispatchSettingsChange({ paperId: "iso_a3" });
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     await helper.awaitAnimationFrame();
     let marginError = helper.get("error-invalid-margin");
 
@@ -784,7 +795,7 @@ add_task(async function testRevalidateCustomMarginsAfterOrientationChanges() {
     await setupLetterPaper();
     await helper.startPrint();
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     await helper.awaitAnimationFrame();
     let marginError = helper.get("error-invalid-margin");
 
@@ -821,7 +832,7 @@ add_task(async function testResetMarginPersists() {
     await helper.startPrint();
 
     await helper.openMoreSettings();
-    changeDefaultToCustom(helper);
+    await changeDefaultToCustom(helper);
     await helper.awaitAnimationFrame();
     let marginError = helper.get("error-invalid-margin");
 
diff --git a/toolkit/components/printing/tests/browser_print_page_range.js b/toolkit/components/printing/tests/browser_print_page_range.js
index e67544cff5ee..2f6b4a291a73 100644
--- a/toolkit/components/printing/tests/browser_print_page_range.js
+++ b/toolkit/components/printing/tests/browser_print_page_range.js
@@ -3,20 +3,34 @@
 
 "use strict";
 
-function changeRangeTo(helper, destination) {
+async function changeRangeTo(helper, destination) {
   let rangeSelect = helper.get("range-picker");
   let options = getRangeOptions(helper);
   let numberMove =
     options.indexOf(destination) - options.indexOf(rangeSelect.value);
   let direction = numberMove > 0 ? "down" : "up";
+  if (!numberMove) {
+    return;
+  }
+
+  let input = BrowserTestUtils.waitForEvent(rangeSelect, "input");
+
+  let popupOpen = BrowserTestUtils.waitForEvent(
+    document.getElementById("ContentSelectDropdown"),
+    "popupshown"
+  );
 
   rangeSelect.focus();
   rangeSelect.scrollIntoView({ block: "center" });
   EventUtils.sendKey("space", helper.win);
+
+  await popupOpen;
   for (let i = Math.abs(numberMove); i > 0; i--) {
-    EventUtils.sendKey(direction, helper.win);
+    EventUtils.sendKey(direction, window);
   }
-  EventUtils.sendKey("return", helper.win);
+  EventUtils.sendKey("return", window);
+
+  await input;
 }
 
 function getRangeOptions(helper) {
@@ -43,7 +57,7 @@ add_task(async function testRangeResetAfterScale() {
     await helper.setupMockPrint();
 
     helper.mockFilePicker("changeRangeFromScale.pdf");
-    changeRangeTo(helper, "custom");
+    await changeRangeTo(helper, "custom");
 
     await helper.openMoreSettings();
     let scaleRadio = helper.get("percent-scale-choice");
@@ -83,7 +97,7 @@ add_task(async function testRangeResetAfterPaperSize() {
     await helper.waitForPreview(() => helper.text(percentScale, "200"));
 
     let customRange = helper.get("custom-range");
-    changeRangeTo(helper, "custom");
+    await changeRangeTo(helper, "custom");
     await BrowserTestUtils.waitForAttributeRemoval("hidden", customRange);
 
     let rangeError = helper.get("error-invalid-range");
@@ -116,7 +130,7 @@ add_task(async function testInvalidRangeResetAfterDestinationChange() {
     let customPageRange = helper.get("custom-range");
 
     await helper.assertSettingsNotChanged({ pageRanges: [] }, async () => {
-      changeRangeTo(helper, "custom");
+      await changeRangeTo(helper, "custom");
     });
     let rangeError = helper.get("error-invalid-range");
 
@@ -151,7 +165,7 @@ add_task(async function testPageRangeSets() {
 
     ok(customRange.hidden, "Custom range input is hidden");
 
-    changeRangeTo(helper, "custom");
+    await changeRangeTo(helper, "custom");
     await BrowserTestUtils.waitForAttributeRemoval("hidden", customRange);
 
     ok(!customRange.hidden, "Custom range is showing");
@@ -216,11 +230,11 @@ add_task(async function testPageRangeSelect() {
 
     let pageRangeInput = helper.get("page-range-input");
 
-    changeRangeTo(helper, "all");
+    await changeRangeTo(helper, "all");
     let pageRanges = pageRangeInput.formatPageRange();
     ok(!pageRanges.length, "Page range for all should be []");
 
-    changeRangeTo(helper, "odd");
+    await changeRangeTo(helper, "odd");
     pageRanges = pageRangeInput.formatPageRange();
     ok(
       pageRanges.length == 4 &&
@@ -228,7 +242,7 @@ add_task(async function testPageRangeSelect() {
       "Page range for odd should be [1, 1, 3, 3]"
     );
 
-    changeRangeTo(helper, "even");
+    await changeRangeTo(helper, "even");
     pageRanges = pageRangeInput.formatPageRange();
     ok(
       pageRanges.length == 2 &&
@@ -242,7 +256,7 @@ add_task(async function testRangeError() {
   await PrintHelper.withTestPage(async helper => {
     await helper.startPrint();
 
-    changeRangeTo(helper, "custom");
+    await changeRangeTo(helper, "custom");
 
     let invalidError = helper.get("error-invalid-range");
     let invalidOverflowError = helper.get("error-invalid-start-range-overflow");
@@ -265,7 +279,7 @@ add_task(async function testStartOverflowRangeError() {
   await PrintHelper.withTestPage(async helper => {
     await helper.startPrint();
 
-    changeRangeTo(helper, "custom");
+    await changeRangeTo(helper, "custom");
 
     await helper.openMoreSettings();
     let scaleRadio = helper.get("percent-scale-choice");
@@ -297,7 +311,7 @@ add_task(async function testErrorClearedAfterSwitchingToAll() {
   await PrintHelper.withTestPage(async helper => {
     await helper.startPrint();
 
-    changeRangeTo(helper, "custom");
+    await changeRangeTo(helper, "custom");
 
     let customRange = helper.get("custom-range");
     let rangeError = helper.get("error-invalid-range");
@@ -308,7 +322,7 @@ add_task(async function testErrorClearedAfterSwitchingToAll() {
     await BrowserTestUtils.waitForAttributeRemoval("hidden", rangeError);
     ok(!rangeError.hidden, "Generic error message is showing");
 
-    changeRangeTo(helper, "all");
+    await changeRangeTo(helper, "all");
 
     await BrowserTestUtils.waitForCondition(
       () => rangeError.hidden,
@@ -403,7 +417,7 @@ add_task(async function testPageCountChangeRangeNoRerender() {
         ]);
 
         await helper.waitForPreview(async () => {
-          changeRangeTo(helper, "custom");
+          await changeRangeTo(helper, "custom");
           helper.text(helper.get("custom-range"), "1");
         });
       }
@@ -460,7 +474,7 @@ add_task(async function testPageCountChangeRangeRerender() {
         ]);
 
         await helper.waitForPreview(async () => {
-          changeRangeTo(helper, "custom");
+          await changeRangeTo(helper, "custom");
           helper.text(helper.get("custom-range"), "1-");
         });
       }
diff --git a/toolkit/components/printing/tests/browser_sheet_count.js b/toolkit/components/printing/tests/browser_sheet_count.js
index ffdcc9f79fe5..3606eef9fcfb 100644
--- a/toolkit/components/printing/tests/browser_sheet_count.js
+++ b/toolkit/components/printing/tests/browser_sheet_count.js
@@ -294,14 +294,28 @@ add_task(async function testPagesPerSheetCount() {
     let pagesPerSheet = helper.get("pages-per-sheet-picker");
     ok(BrowserTestUtils.is_visible(pagesPerSheet), "Pages per sheet is shown");
     pagesPerSheet.focus();
+
+    let popupOpen = BrowserTestUtils.waitForEvent(
+      document.getElementById("ContentSelectDropdown"),
+      "popupshown"
+    );
+
     EventUtils.sendKey("space", helper.win);
-    for (let i = 0; i < 7; i++) {
-      EventUtils.sendKey("down", helper.win);
-      if (pagesPerSheet.value == 16) {
+
+    await popupOpen;
+
+    let numberMove =
+      [...pagesPerSheet.options].map(o => o.value).indexOf("16") -
+      pagesPerSheet.selectedIndex;
+
+    for (let i = 0; i < numberMove; i++) {
+      EventUtils.sendKey("down", window);
+      if (document.activeElement.value == 16) {
         break;
       }
     }
-    await helper.waitForPreview(() => EventUtils.sendKey("return", helper.win));
+
+    await helper.waitForPreview(() => EventUtils.sendKey("return", window));
 
     sheets = helper.sheetCount;
     is(sheets, 1, "There's only one sheet now");
diff --git a/widget/windows/nsNativeThemeWin.cpp b/widget/windows/nsNativeThemeWin.cpp
index bef6b381832c..e7dd23ac511c 100644
--- a/widget/windows/nsNativeThemeWin.cpp
+++ b/widget/windows/nsNativeThemeWin.cpp
@@ -1203,7 +1203,7 @@ nsresult nsNativeThemeWin::GetThemePartAndState(nsIFrame* aFrame,
 
       if (isHTML) {
         nsComboboxControlFrame* ccf = do_QueryFrame(aFrame);
-        isOpen = (ccf && ccf->IsDroppedDownOrHasParentPopup());
+        isOpen = (ccf && ccf->IsDroppedDown());
       } else
         isOpen = IsOpenButton(aFrame);
 
@@ -2981,7 +2981,7 @@ nsresult nsNativeThemeWin::ClassicGetThemePartAndState(
 
       if (isHTML) {
         nsComboboxControlFrame* ccf = do_QueryFrame(aFrame);
-        isOpen = (ccf && ccf->IsDroppedDownOrHasParentPopup());
+        isOpen = (ccf && ccf->IsDroppedDown());
       } else
         isOpen = IsOpenButton(aFrame);