Add m-esr52 at 52.6.0

1 files changed, 2537 insertions, 0 deletions

diff --git a/layout/forms/nsListControlFrame.cpp b/layout/forms/nsListControlFrame.cpp
new file mode 100644
index 000000000..cc5f37f9a
--- /dev/null
+++ b/layout/forms/nsListControlFrame.cpp
@@ -0,0 +1,2537 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsUnicharUtils.h"
+#include "nsListControlFrame.h"
+#include "nsFormControlFrame.h" // for COMPARE macro
+#include "nsGkAtoms.h"
+#include "nsIDOMHTMLSelectElement.h"
+#include "nsIDOMHTMLOptionElement.h"
+#include "nsComboboxControlFrame.h"
+#include "nsIDOMHTMLOptGroupElement.h"
+#include "nsIPresShell.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIXULRuntime.h"
+#include "nsFontMetrics.h"
+#include "nsIScrollableFrame.h"
+#include "nsCSSRendering.h"
+#include "nsIDOMEventListener.h"
+#include "nsLayoutUtils.h"
+#include "nsDisplayList.h"
+#include "nsContentUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/HTMLOptionsCollection.h"
+#include "mozilla/dom/HTMLSelectElement.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/TextEvents.h"
+#include <algorithm>
+
+using namespace mozilla;
+
+// Constants
+const uint32_t kMaxDropDownRows         = 20; // This matches the setting for 4.x browsers
+const int32_t kNothingSelected          = -1;
+
+// Static members
+nsListControlFrame * nsListControlFrame::mFocused = nullptr;
+nsString * nsListControlFrame::sIncrementalString = nullptr;
+
+// Using for incremental typing navigation
+#define INCREMENTAL_SEARCH_KEYPRESS_TIME 1000
+// XXX, kyle.yuan@sun.com, there are 4 definitions for the same purpose:
+//  nsMenuPopupFrame.h, nsListControlFrame.cpp, listbox.xml, tree.xml
+//  need to find a good place to put them together.
+//  if someone changes one, please also change the other.
+
+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
+  NS_DECL_NSIDOMEVENTLISTENER
+
+private:
+  ~nsListEventListener() {}
+
+  nsListControlFrame  *mFrame;
+};
+
+//---------------------------------------------------------
+nsContainerFrame*
+NS_NewListControlFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  nsListControlFrame* it =
+    new (aPresShell) nsListControlFrame(aContext);
+
+  it->AddStateBits(NS_FRAME_INDEPENDENT_SELECTION);
+
+  return it;
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsListControlFrame)
+
+//---------------------------------------------------------
+nsListControlFrame::nsListControlFrame(nsStyleContext* aContext)
+  : nsHTMLScrollFrame(aContext, false),
+    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;
+}
+
+// for Bug 47302 (remove this comment later)
+void
+nsListControlFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  // get the receiver interface from the browser button's content node
+  ENSURE_TRUE(mContent);
+
+  // Clear the frame pointer on our event listener, just in case the
+  // event listener can outlive the frame.
+
+  mEventListener->SetFrame(nullptr);
+
+  mContent->RemoveSystemEventListener(NS_LITERAL_STRING("keydown"),
+                                      mEventListener, false);
+  mContent->RemoveSystemEventListener(NS_LITERAL_STRING("keypress"),
+                                      mEventListener, false);
+  mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mousedown"),
+                                      mEventListener, false);
+  mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mouseup"),
+                                      mEventListener, false);
+  mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mousemove"),
+                                      mEventListener, false);
+
+  if (XRE_IsContentProcess() &&
+      Preferences::GetBool("browser.tabs.remote.desktopbehavior", false)) {
+    nsContentUtils::AddScriptRunner(
+      new AsyncEventDispatcher(mContent,
+                               NS_LITERAL_STRING("mozhidedropdown"), true,
+                               true));
+  }
+
+  nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
+  nsHTMLScrollFrame::DestroyFrom(aDestructRoot);
+}
+
+void
+nsListControlFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                                     const nsRect&           aDirtyRect,
+                                     const nsDisplayListSet& aLists)
+{
+  // We allow visibility:hidden <select>s to contain visible options.
+
+  // Don't allow painting of list controls when painting is suppressed.
+  // XXX why do we need this here? we should never reach this. Maybe
+  // because these can have widgets? Hmm
+  if (aBuilder->IsBackgroundOnly())
+    return;
+
+  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(
+      new (aBuilder) nsDisplaySolidColor(aBuilder,
+        this, nsRect(aBuilder->ToReferenceFrame(this), GetSize()),
+        mLastDropdownBackstopColor));
+  }
+
+  nsHTMLScrollFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists);
+}
+
+/**
+ * This is called by the SelectsAreaFrame, which is the same
+ * as the frame returned by GetOptionsContainer. It's the frame which is
+ * scrolled by us.
+ * @param aPt the offset of this frame, relative to the rendering reference
+ * frame
+ */
+void nsListControlFrame::PaintFocus(DrawTarget* aDrawTarget, nsPoint aPt)
+{
+  if (mFocused != this) return;
+
+  nsPresContext* presContext = PresContext();
+
+  nsIFrame* containerFrame = GetOptionsContainer();
+  if (!containerFrame) return;
+
+  nsIFrame* childframe = nullptr;
+  nsCOMPtr<nsIContent> focusedContent = GetCurrentOption();
+  if (focusedContent) {
+    childframe = focusedContent->GetPrimaryFrame();
+  }
+
+  nsRect fRect;
+  if (childframe) {
+    // get the child rect
+    fRect = childframe->GetRect();
+    // get it into our coordinates
+    fRect.MoveBy(childframe->GetParent()->GetOffsetTo(this));
+  } else {
+    float inflation = nsLayoutUtils::FontSizeInflationFor(this);
+    fRect.x = fRect.y = 0;
+    if (GetWritingMode().IsVertical()) {
+      fRect.width = GetScrollPortRect().width;
+      fRect.height = CalcFallbackRowBSize(inflation);
+    } else {
+      fRect.width = CalcFallbackRowBSize(inflation);
+      fRect.height = GetScrollPortRect().height;
+    }
+    fRect.MoveBy(containerFrame->GetOffsetTo(this));
+  }
+  fRect += aPt;
+
+  bool lastItemIsSelected = false;
+  if (focusedContent) {
+    nsCOMPtr<nsIDOMHTMLOptionElement> domOpt =
+      do_QueryInterface(focusedContent);
+    if (domOpt) {
+      domOpt->GetSelected(&lastItemIsSelected);
+    }
+  }
+
+  // set up back stop colors and then ask L&F service for the real colors
+  nscolor color =
+    LookAndFeel::GetColor(lastItemIsSelected ?
+                            LookAndFeel::eColorID_WidgetSelectForeground :
+                            LookAndFeel::eColorID_WidgetSelectBackground);
+
+  nsCSSRendering::PaintFocus(presContext, aDrawTarget, fRect, color);
+}
+
+void
+nsListControlFrame::InvalidateFocus()
+{
+  if (mFocused != this)
+    return;
+
+  nsIFrame* containerFrame = GetOptionsContainer();
+  if (containerFrame) {
+    containerFrame->InvalidateFrame();
+  }
+}
+
+NS_QUERYFRAME_HEAD(nsListControlFrame)
+  NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
+  NS_QUERYFRAME_ENTRY(nsIListControlFrame)
+  NS_QUERYFRAME_ENTRY(nsISelectControlFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsHTMLScrollFrame)
+
+#ifdef ACCESSIBILITY
+a11y::AccType
+nsListControlFrame::AccessibleType()
+{
+  return a11y::eHTMLSelectListType;
+}
+#endif
+
+static nscoord
+GetMaxOptionBSize(nsIFrame* aContainer, WritingMode aWM)
+{
+  nscoord result = 0;
+  for (nsIFrame* option : aContainer->PrincipalChildList()) {
+    nscoord optionBSize;
+    if (nsCOMPtr<nsIDOMHTMLOptGroupElement>
+        (do_QueryInterface(option->GetContent()))) {
+      // An optgroup; drill through any scroll frame and recurse.  |frame| might
+      // be null here though if |option| is an anonymous leaf frame of some sort.
+      auto frame = option->GetContentInsertionFrame();
+      optionBSize = frame ? GetMaxOptionBSize(frame, aWM) : 0;
+    } else {
+      // an option
+      optionBSize = option->BSize(aWM);
+    }
+    if (result < optionBSize)
+      result = optionBSize;
+  }
+  return result;
+}
+
+//-----------------------------------------------------------------
+// Main Reflow for ListBox/Dropdown
+//-----------------------------------------------------------------
+
+nscoord
+nsListControlFrame::CalcBSizeOfARow()
+{
+  // Calculate the block size in our writing mode of a single row in the
+  // listbox or dropdown list by using the tallest thing in the subtree,
+  // since there may be option groups in addition to option elements,
+  // either of which may be visible or invisible, may use different
+  // fonts, etc.
+  int32_t blockSizeOfARow = GetMaxOptionBSize(GetOptionsContainer(),
+                                              GetWritingMode());
+
+  // Check to see if we have zero items (and optimize by checking
+  // blockSizeOfARow first)
+  if (blockSizeOfARow == 0 && GetNumberOfOptions() == 0) {
+    float inflation = nsLayoutUtils::FontSizeInflationFor(this);
+    blockSizeOfARow = CalcFallbackRowBSize(inflation);
+  }
+
+  return blockSizeOfARow;
+}
+
+nscoord
+nsListControlFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+{
+  nscoord result;
+  DISPLAY_PREF_WIDTH(this, result);
+
+  // Always add scrollbar inline sizes to the pref-inline-size of the
+  // scrolled content. Combobox frames depend on this happening in the
+  // dropdown, and standalone listboxes are overflow:scroll so they need
+  // it too.
+  WritingMode wm = GetWritingMode();
+  result = GetScrolledFrame()->GetPrefISize(aRenderingContext);
+  LogicalMargin scrollbarSize(wm, GetDesiredScrollbarSizes(PresContext(),
+                                                           aRenderingContext));
+  result = NSCoordSaturatingAdd(result, scrollbarSize.IStartEnd(wm));
+  return result;
+}
+
+nscoord
+nsListControlFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+{
+  nscoord result;
+  DISPLAY_MIN_WIDTH(this, result);
+
+  // Always add scrollbar inline sizes to the min-inline-size of the
+  // scrolled content. Combobox frames depend on this happening in the
+  // dropdown, and standalone listboxes are overflow:scroll so they need
+  // it too.
+  WritingMode wm = GetWritingMode();
+  result = GetScrolledFrame()->GetMinISize(aRenderingContext);
+  LogicalMargin scrollbarSize(wm, GetDesiredScrollbarSizes(PresContext(),
+                                                           aRenderingContext));
+  result += scrollbarSize.IStartEnd(wm);
+
+  return result;
+}
+
+void
+nsListControlFrame::Reflow(nsPresContext*           aPresContext,
+                           ReflowOutput&     aDesiredSize,
+                           const ReflowInput& aReflowInput,
+                           nsReflowStatus&          aStatus)
+{
+  NS_PRECONDITION(aReflowInput.ComputedISize() != NS_UNCONSTRAINEDSIZE,
+                  "Must have a computed inline size");
+
+  SchedulePaint();
+
+  mHasPendingInterruptAtStartOfReflow = aPresContext->HasPendingInterrupt();
+
+  // If all the content and frames are here
+  // then initialize it before reflow
+  if (mIsAllContentHere && !mHasBeenInitialized) {
+    if (false == mIsAllFramesHere) {
+      CheckIfAllFramesHere();
+    }
+    if (mIsAllFramesHere && !mHasBeenInitialized) {
+      mHasBeenInitialized = true;
+    }
+  }
+
+  if (GetStateBits() & NS_FRAME_FIRST_REFLOW) {
+    nsFormControlFrame::RegUnRegAccessKey(this, true);
+  }
+
+  if (IsInDropDownMode()) {
+    ReflowAsDropdown(aPresContext, aDesiredSize, aReflowInput, aStatus);
+    return;
+  }
+
+  MarkInReflow();
+  /*
+   * Due to the fact that our intrinsic block size depends on the block
+   * sizes of our kids, we end up having to do two-pass reflow, in
+   * general -- the first pass to find the intrinsic block size and a
+   * second pass to reflow the scrollframe at that block size (which
+   * will size the scrollbars correctly, etc).
+   *
+   * Naturally, we want to avoid doing the second reflow as much as
+   * possible.
+   * We can skip it in the following cases (in all of which the first
+   * reflow is already happening at the right block size):
+   *
+   * - We're reflowing with a constrained computed block size -- just
+   *   use that block size.
+   * - We're not dirty and have no dirty kids and shouldn't be reflowing
+   *   all kids.  In this case, our cached max block size of a child is
+   *   not going to change.
+   * - We do our first reflow using our cached max block size of a
+   *   child, then compute the new max block size and it's the same as
+   *   the old one.
+   */
+
+  bool autoBSize = (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE);
+
+  mMightNeedSecondPass = autoBSize &&
+    (NS_SUBTREE_DIRTY(this) || aReflowInput.ShouldReflowAllKids());
+
+  ReflowInput state(aReflowInput);
+  int32_t length = GetNumberOfRows();
+
+  nscoord oldBSizeOfARow = BSizeOfARow();
+
+  if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW) && autoBSize) {
+    // 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.
+    nscoord computedBSize = CalcIntrinsicBSize(oldBSizeOfARow, length);
+    computedBSize = state.ApplyMinMaxBSize(computedBSize);
+    state.SetComputedBSize(computedBSize);
+  }
+
+  nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
+
+  if (!mMightNeedSecondPass) {
+    NS_ASSERTION(!autoBSize || BSizeOfARow() == oldBSizeOfARow,
+                 "How did our BSize of a row change if nothing was dirty?");
+    NS_ASSERTION(!autoBSize ||
+                 !(GetStateBits() & NS_FRAME_FIRST_REFLOW),
+                 "How do we not need a second pass during initial reflow at "
+                 "auto BSize?");
+    NS_ASSERTION(!IsScrollbarUpdateSuppressed(),
+                 "Shouldn't be suppressing if we don't need a second pass!");
+    if (!autoBSize) {
+      // Update our mNumDisplayRows based on our new row block size now
+      // that we know it.  Note that if autoBSize and we landed in this
+      // code then we already set mNumDisplayRows in CalcIntrinsicBSize.
+      //  Also note that we can't use BSizeOfARow() here because that
+      // just uses a cached value that we didn't compute.
+      nscoord rowBSize = CalcBSizeOfARow();
+      if (rowBSize == 0) {
+        // Just pick something
+        mNumDisplayRows = 1;
+      } else {
+        mNumDisplayRows = std::max(1, state.ComputedBSize() / rowBSize);
+      }
+    }
+
+    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(!IsScrollbarUpdateSuppressed(),
+                 "Shouldn't be suppressing if the block size of a row has not "
+                 "changed!");
+    return;
+  }
+
+  SetSuppressScrollbarUpdate(false);
+
+  // 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,
+                               nsDidReflowStatus::FINISHED);
+
+  // Now compute the block size we want to have
+  nscoord computedBSize = CalcIntrinsicBSize(BSizeOfARow(), length);
+  computedBSize = state.ApplyMinMaxBSize(computedBSize);
+  state.SetComputedBSize(computedBSize);
+
+  // XXXbz to make the ascent really correct, we should add our
+  // mComputedPadding.top to it (and subtract it from descent).  Need that
+  // because nsGfxScrollFrame just adds in the border....
+  nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
+}
+
+void
+nsListControlFrame::ReflowAsDropdown(nsPresContext*           aPresContext,
+                                     ReflowOutput&     aDesiredSize,
+                                     const ReflowInput& aReflowInput,
+                                     nsReflowStatus&          aStatus)
+{
+  NS_PRECONDITION(aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE,
+                  "We should not have a computed block size here!");
+
+  mMightNeedSecondPass = NS_SUBTREE_DIRTY(this) ||
+    aReflowInput.ShouldReflowAllKids();
+
+  WritingMode wm = aReflowInput.GetWritingMode();
+#ifdef DEBUG
+  nscoord oldBSizeOfARow = BSizeOfARow();
+  nscoord oldVisibleBSize = (GetStateBits() & NS_FRAME_FIRST_REFLOW) ?
+    NS_UNCONSTRAINEDSIZE : GetScrolledFrame()->BSize(wm);
+#endif
+
+  ReflowInput state(aReflowInput);
+
+  if (!(GetStateBits() & 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(!(GetStateBits() & 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(!(GetStateBits() & 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,
+                               nsDidReflowStatus::FINISHED);
+
+  // 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 = 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().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();
+
+  nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
+}
+
+ScrollbarStyles
+nsListControlFrame::GetScrollbarStyles() const
+{
+  // We can't express this in the style system yet; when we can, this can go away
+  // and GetScrollbarStyles can be devirtualized
+  int32_t style = IsInDropDownMode() ? NS_STYLE_OVERFLOW_AUTO
+                                     : NS_STYLE_OVERFLOW_SCROLL;
+  if (GetWritingMode().IsVertical()) {
+    return ScrollbarStyles(style, NS_STYLE_OVERFLOW_HIDDEN);
+  } else {
+    return ScrollbarStyles(NS_STYLE_OVERFLOW_HIDDEN, style);
+  }
+}
+
+bool
+nsListControlFrame::ShouldPropagateComputedBSizeToScrolledContent() const
+{
+  return !IsInDropDownMode();
+}
+
+//---------------------------------------------------------
+nsContainerFrame*
+nsListControlFrame::GetContentInsertionFrame() {
+  return GetOptionsContainer()->GetContentInsertionFrame();
+}
+
+//---------------------------------------------------------
+bool
+nsListControlFrame::ExtendedSelection(int32_t aStartIndex,
+                                      int32_t aEndIndex,
+                                      bool aClearAll)
+{
+  return SetOptionsSelectedFromFrame(aStartIndex, aEndIndex,
+                                     true, aClearAll);
+}
+
+//---------------------------------------------------------
+bool
+nsListControlFrame::SingleSelection(int32_t aClickedIndex, bool aDoToggle)
+{
+  if (mComboboxFrame) {
+    mComboboxFrame->UpdateRecentIndex(GetSelectedIndex());
+  }
+
+  bool wasChanged = false;
+  // Get Current selection
+  if (aDoToggle) {
+    wasChanged = ToggleOptionSelectedFromFrame(aClickedIndex);
+  } else {
+    wasChanged = SetOptionsSelectedFromFrame(aClickedIndex, aClickedIndex,
+                                true, true);
+  }
+  nsWeakFrame weakFrame(this);
+  ScrollToIndex(aClickedIndex);
+  if (!weakFrame.IsAlive()) {
+    return wasChanged;
+  }
+
+#ifdef ACCESSIBILITY
+  bool isCurrentOptionChanged = mEndSelectionIndex != aClickedIndex;
+#endif
+  mStartSelectionIndex = aClickedIndex;
+  mEndSelectionIndex = aClickedIndex;
+  InvalidateFocus();
+
+#ifdef ACCESSIBILITY
+  if (isCurrentOptionChanged) {
+    FireMenuItemActiveEvent();
+  }
+#endif
+
+  return wasChanged;
+}
+
+void
+nsListControlFrame::InitSelectionRange(int32_t aClickedIndex)
+{
+  //
+  // If nothing is selected, set the start selection depending on where
+  // the user clicked and what the initial selection is:
+  // - if the user clicked *before* selectedIndex, set the start index to
+  //   the end of the first contiguous selection.
+  // - if the user clicked *after* the end of the first contiguous
+  //   selection, set the start index to selectedIndex.
+  // - if the user clicked *within* the first contiguous selection, set the
+  //   start index to selectedIndex.
+  // The last two rules, of course, boil down to the same thing: if the user
+  // clicked >= selectedIndex, return selectedIndex.
+  //
+  // This makes it so that shift click works properly when you first click
+  // in a multiple select.
+  //
+  int32_t selectedIndex = GetSelectedIndex();
+  if (selectedIndex >= 0) {
+    // Get the end of the contiguous selection
+    RefPtr<dom::HTMLOptionsCollection> options = GetOptions();
+    NS_ASSERTION(options, "Collection of options is null!");
+    uint32_t numOptions = options->Length();
+    // Push i to one past the last selected index in the group.
+    uint32_t i;
+    for (i = selectedIndex + 1; i < numOptions; i++) {
+      if (!options->ItemAsOption(i)->Selected()) {
+        break;
+      }
+    }
+
+    if (aClickedIndex < selectedIndex) {
+      // User clicked before selection, so start selection at end of
+      // contiguous selection
+      mStartSelectionIndex = i-1;
+      mEndSelectionIndex = selectedIndex;
+    } else {
+      // User clicked after selection, so start selection at start of
+      // contiguous selection
+      mStartSelectionIndex = selectedIndex;
+      mEndSelectionIndex = i-1;
+    }
+  }
+}
+
+static uint32_t
+CountOptionsAndOptgroups(nsIFrame* aFrame)
+{
+  uint32_t count = 0;
+  nsFrameList::Enumerator e(aFrame->PrincipalChildList());
+  for (; !e.AtEnd(); e.Next()) {
+    nsIFrame* child = e.get();
+    nsIContent* content = child->GetContent();
+    if (content) {
+      if (content->IsHTMLElement(nsGkAtoms::option)) {
+        ++count;
+      } else {
+        nsCOMPtr<nsIDOMHTMLOptGroupElement> optgroup = do_QueryInterface(content);
+        if (optgroup) {
+          nsAutoString label;
+          optgroup->GetLabel(label);
+          if (label.Length() > 0) {
+            ++count;
+          }
+          count += CountOptionsAndOptgroups(child);
+        }
+      }
+    }
+  }
+  return count;
+}
+
+uint32_t
+nsListControlFrame::GetNumberOfRows()
+{
+  return ::CountOptionsAndOptgroups(GetContentInsertionFrame());
+}
+
+//---------------------------------------------------------
+bool
+nsListControlFrame::PerformSelection(int32_t aClickedIndex,
+                                     bool aIsShift,
+                                     bool aIsControl)
+{
+  bool wasChanged = false;
+
+  if (aClickedIndex == kNothingSelected && !mForceSelection) {
+    // Ignore kNothingSelected unless the selection is forced
+  } else if (GetMultiple()) {
+    if (aIsShift) {
+      // Make sure shift+click actually does something expected when
+      // the user has never clicked on the select
+      if (mStartSelectionIndex == kNothingSelected) {
+        InitSelectionRange(aClickedIndex);
+      }
+
+      // Get the range from beginning (low) to end (high)
+      // Shift *always* works, even if the current option is disabled
+      int32_t startIndex;
+      int32_t endIndex;
+      if (mStartSelectionIndex == kNothingSelected) {
+        startIndex = aClickedIndex;
+        endIndex   = aClickedIndex;
+      } else if (mStartSelectionIndex <= aClickedIndex) {
+        startIndex = mStartSelectionIndex;
+        endIndex   = aClickedIndex;
+      } else {
+        startIndex = aClickedIndex;
+        endIndex   = mStartSelectionIndex;
+      }
+
+      // Clear only if control was not pressed
+      wasChanged = ExtendedSelection(startIndex, endIndex, !aIsControl);
+      nsWeakFrame weakFrame(this);
+      ScrollToIndex(aClickedIndex);
+      if (!weakFrame.IsAlive()) {
+        return wasChanged;
+      }
+
+      if (mStartSelectionIndex == kNothingSelected) {
+        mStartSelectionIndex = aClickedIndex;
+      }
+#ifdef ACCESSIBILITY
+      bool isCurrentOptionChanged = mEndSelectionIndex != aClickedIndex;
+#endif
+      mEndSelectionIndex = aClickedIndex;
+      InvalidateFocus();
+
+#ifdef ACCESSIBILITY
+      if (isCurrentOptionChanged) {
+        FireMenuItemActiveEvent();
+      }
+#endif
+    } else if (aIsControl) {
+      wasChanged = SingleSelection(aClickedIndex, true); // might destroy us
+    } else {
+      wasChanged = SingleSelection(aClickedIndex, false); // might destroy us
+    }
+  } else {
+    wasChanged = SingleSelection(aClickedIndex, false); // might destroy us
+  }
+
+  return wasChanged;
+}
+
+//---------------------------------------------------------
+bool
+nsListControlFrame::HandleListSelection(nsIDOMEvent* aEvent,
+                                        int32_t aClickedIndex)
+{
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
+  bool isShift;
+  bool isControl;
+#ifdef XP_MACOSX
+  mouseEvent->GetMetaKey(&isControl);
+#else
+  mouseEvent->GetCtrlKey(&isControl);
+#endif
+  mouseEvent->GetShiftKey(&isShift);
+  return PerformSelection(aClickedIndex, isShift, isControl); // might destroy us
+}
+
+//---------------------------------------------------------
+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) {
+    nsIPresShell::SetCapturingContent(mContent, CAPTURE_IGNOREALLOWED);
+  } else {
+    nsIContent* capturingContent = nsIPresShell::GetCapturingContent();
+
+    bool dropDownIsHidden = false;
+    if (IsInDropDownMode()) {
+      dropDownIsHidden = !mComboboxFrame->IsDroppedDown();
+    }
+    if (capturingContent == mContent || dropDownIsHidden) {
+      // 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
+      // which is actually grabbing
+      // This shouldn't be necessary. We should simply ensure that events targeting
+      // scrollbars are never visible to DOM consumers.
+      nsIPresShell::SetCapturingContent(nullptr, 0);
+    }
+  }
+}
+
+//---------------------------------------------------------
+nsresult
+nsListControlFrame::HandleEvent(nsPresContext* aPresContext,
+                                WidgetGUIEvent* aEvent,
+                                nsEventStatus* aEventStatus)
+{
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+
+  /*const char * desc[] = {"eMouseMove",
+                          "NS_MOUSE_LEFT_BUTTON_UP",
+                          "NS_MOUSE_LEFT_BUTTON_DOWN",
+                          "<NA>","<NA>","<NA>","<NA>","<NA>","<NA>","<NA>",
+                          "NS_MOUSE_MIDDLE_BUTTON_UP",
+                          "NS_MOUSE_MIDDLE_BUTTON_DOWN",
+                          "<NA>","<NA>","<NA>","<NA>","<NA>","<NA>","<NA>","<NA>",
+                          "NS_MOUSE_RIGHT_BUTTON_UP",
+                          "NS_MOUSE_RIGHT_BUTTON_DOWN",
+                          "eMouseOver",
+                          "eMouseOut",
+                          "NS_MOUSE_LEFT_DOUBLECLICK",
+                          "NS_MOUSE_MIDDLE_DOUBLECLICK",
+                          "NS_MOUSE_RIGHT_DOUBLECLICK",
+                          "NS_MOUSE_LEFT_CLICK",
+                          "NS_MOUSE_MIDDLE_CLICK",
+                          "NS_MOUSE_RIGHT_CLICK"};
+  int inx = aEvent->mMessage - eMouseEventFirst;
+  if (inx >= 0 && inx <= (NS_MOUSE_RIGHT_CLICK - eMouseEventFirst)) {
+    printf("Mouse in ListFrame %s [%d]\n", desc[inx], aEvent->mMessage);
+  } else {
+    printf("Mouse in ListFrame <UNKNOWN> [%d]\n", aEvent->mMessage);
+  }*/
+
+  if (nsEventStatus_eConsumeNoDefault == *aEventStatus)
+    return NS_OK;
+
+  // do we have style that affects how we are selected?
+  // do we have user-input style?
+  const nsStyleUserInterface* uiStyle = StyleUserInterface();
+  if (uiStyle->mUserInput == StyleUserInput::None ||
+      uiStyle->mUserInput == StyleUserInput::Disabled) {
+    return nsFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+  }
+  EventStates eventStates = mContent->AsElement()->State();
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED))
+    return NS_OK;
+
+  return nsHTMLScrollFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+}
+
+
+//---------------------------------------------------------
+void
+nsListControlFrame::SetInitialChildList(ChildListID    aListID,
+                                        nsFrameList&   aChildList)
+{
+  if (aListID == kPrincipalList) {
+    // First check to see if all the content has been added
+    mIsAllContentHere = mContent->IsDoneAddingChildren();
+    if (!mIsAllContentHere) {
+      mIsAllFramesHere    = false;
+      mHasBeenInitialized = false;
+    }
+  }
+  nsHTMLScrollFrame::SetInitialChildList(aListID, aChildList);
+
+  // If all the content is here now check
+  // to see if all the frames have been created
+  /*if (mIsAllContentHere) {
+    // If all content and frames are here
+    // the reset/initialize
+    if (CheckIfAllFramesHere()) {
+      ResetList(aPresContext);
+      mHasBeenInitialized = true;
+    }
+  }*/
+}
+
+//---------------------------------------------------------
+void
+nsListControlFrame::Init(nsIContent*       aContent,
+                         nsContainerFrame* aParent,
+                         nsIFrame*         aPrevInFlow)
+{
+  nsHTMLScrollFrame::Init(aContent, aParent, aPrevInFlow);
+
+  // 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(NS_LITERAL_STRING("keydown"),
+                                   mEventListener, false, false);
+  mContent->AddSystemEventListener(NS_LITERAL_STRING("keypress"),
+                                   mEventListener, false, false);
+  mContent->AddSystemEventListener(NS_LITERAL_STRING("mousedown"),
+                                   mEventListener, false, false);
+  mContent->AddSystemEventListener(NS_LITERAL_STRING("mouseup"),
+                                   mEventListener, false, false);
+  mContent->AddSystemEventListener(NS_LITERAL_STRING("mousemove"),
+                                   mEventListener, false, false);
+
+  mStartSelectionIndex = kNothingSelected;
+  mEndSelectionIndex = kNothingSelected;
+
+  mLastDropdownBackstopColor = PresContext()->DefaultBackgroundColor();
+
+  if (IsInDropDownMode()) {
+    AddStateBits(NS_FRAME_IN_POPUP);
+  }
+}
+
+dom::HTMLOptionsCollection*
+nsListControlFrame::GetOptions() const
+{
+  dom::HTMLSelectElement* select =
+    dom::HTMLSelectElement::FromContentOrNull(mContent);
+  NS_ENSURE_TRUE(select, nullptr);
+
+  return select->Options();
+}
+
+dom::HTMLOptionElement*
+nsListControlFrame::GetOption(uint32_t aIndex) const
+{
+  dom::HTMLSelectElement* select =
+    dom::HTMLSelectElement::FromContentOrNull(mContent);
+  NS_ENSURE_TRUE(select, nullptr);
+
+  return select->Item(aIndex);
+}
+
+NS_IMETHODIMP
+nsListControlFrame::OnOptionSelected(int32_t aIndex, bool aSelected)
+{
+  if (aSelected) {
+    ScrollToIndex(aIndex);
+  }
+  return NS_OK;
+}
+
+void
+nsListControlFrame::OnContentReset()
+{
+  ResetList(true);
+}
+
+void
+nsListControlFrame::ResetList(bool aAllowScrolling)
+{
+  // if all the frames aren't here
+  // don't bother reseting
+  if (!mIsAllFramesHere) {
+    return;
+  }
+
+  if (aAllowScrolling) {
+    mPostChildrenLoadedReset = true;
+
+    // Scroll to the selected index
+    int32_t indexToSelect = kNothingSelected;
+
+    nsCOMPtr<nsIDOMHTMLSelectElement> selectElement(do_QueryInterface(mContent));
+    NS_ASSERTION(selectElement, "No select element!");
+    if (selectElement) {
+      selectElement->GetSelectedIndex(&indexToSelect);
+      nsWeakFrame weakFrame(this);
+      ScrollToIndex(indexToSelect);
+      if (!weakFrame.IsAlive()) {
+        return;
+      }
+    }
+  }
+
+  mStartSelectionIndex = kNothingSelected;
+  mEndSelectionIndex = kNothingSelected;
+  InvalidateFocus();
+  // Combobox will redisplay itself with the OnOptionSelected event
+}
+
+void
+nsListControlFrame::SetFocus(bool aOn, bool aRepaint)
+{
+  InvalidateFocus();
+
+  if (aOn) {
+    ComboboxFocusSet();
+    mFocused = this;
+  } else {
+    mFocused = nullptr;
+  }
+
+  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)) {
+    optionElement->GetText(aStr);
+  }
+}
+
+int32_t
+nsListControlFrame::GetSelectedIndex()
+{
+  dom::HTMLSelectElement* select =
+    dom::HTMLSelectElement::FromContentOrNull(mContent);
+  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 item. Return the first non-disabled item.
+  RefPtr<dom::HTMLSelectElement> selectElement =
+    dom::HTMLSelectElement::FromContent(mContent);
+
+  for (uint32_t i = 0, length = selectElement->Length(); i < length; ++i) {
+    dom::HTMLOptionElement* node = selectElement->Item(i);
+    if (!node) {
+      return nullptr;
+    }
+
+    if (!selectElement->IsOptionDisabled(node)) {
+      return node;
+    }
+  }
+
+  return nullptr;
+}
+
+bool
+nsListControlFrame::IsInDropDownMode() const
+{
+  return (mComboboxFrame != nullptr);
+}
+
+uint32_t
+nsListControlFrame::GetNumberOfOptions()
+{
+  dom::HTMLOptionsCollection* options = GetOptions();
+  if (!options) {
+    return 0;
+  }
+
+  return options->Length();
+}
+
+//----------------------------------------------------------------------
+// nsISelectControlFrame
+//----------------------------------------------------------------------
+bool nsListControlFrame::CheckIfAllFramesHere()
+{
+  // Get the number of optgroups and options
+  //int32_t numContentItems = 0;
+  nsCOMPtr<nsIDOMNode> node(do_QueryInterface(mContent));
+  if (node) {
+    // XXX Need to find a fail proff way to determine that
+    // all the frames are there
+    mIsAllFramesHere = true;//NS_OK == CountAllChild(node, numContentItems);
+  }
+  // now make sure we have a frame each piece of content
+
+  return mIsAllFramesHere;
+}
+
+NS_IMETHODIMP
+nsListControlFrame::DoneAddingChildren(bool aIsDone)
+{
+  mIsAllContentHere = aIsDone;
+  if (mIsAllContentHere) {
+    // Here we check to see if all the frames have been created
+    // for all the content.
+    // If so, then we can initialize;
+    if (!mIsAllFramesHere) {
+      // if all the frames are now present we can initialize
+      if (CheckIfAllFramesHere()) {
+        mHasBeenInitialized = true;
+        ResetList(true);
+      }
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsListControlFrame::AddOption(int32_t aIndex)
+{
+#ifdef DO_REFLOW_DEBUG
+  printf("---- Id: %d nsLCF %p Added Option %d\n", mReflowId, this, aIndex);
+#endif
+
+  if (!mIsAllContentHere) {
+    mIsAllContentHere = mContent->IsDoneAddingChildren();
+    if (!mIsAllContentHere) {
+      mIsAllFramesHere    = false;
+      mHasBeenInitialized = false;
+    } else {
+      mIsAllFramesHere = (aIndex == static_cast<int32_t>(GetNumberOfOptions()-1));
+    }
+  }
+
+  // Make sure we scroll to the selected option as needed
+  mNeedToReset = true;
+
+  if (!mHasBeenInitialized) {
+    return NS_OK;
+  }
+
+  mPostChildrenLoadedReset = mIsAllContentHere;
+  return NS_OK;
+}
+
+static int32_t
+DecrementAndClamp(int32_t aSelectionIndex, int32_t aLength)
+{
+  return aLength == 0 ? kNothingSelected : std::max(0, aSelectionIndex - 1);
+}
+
+NS_IMETHODIMP
+nsListControlFrame::RemoveOption(int32_t aIndex)
+{
+  NS_PRECONDITION(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();
+    // NOTE: numOptions is the new number of options whereas aIndex is the
+    // unadjusted index of the removed option (hence the <= below).
+    NS_ASSERTION(aIndex <= numOptions, "out-of-bounds <option> index");
+
+    int32_t forward = mEndSelectionIndex - mStartSelectionIndex;
+    int32_t* low  = forward >= 0 ? &mStartSelectionIndex : &mEndSelectionIndex;
+    int32_t* high = forward >= 0 ? &mEndSelectionIndex : &mStartSelectionIndex;
+    if (aIndex < *low)
+      *low = ::DecrementAndClamp(*low, numOptions);
+    if (aIndex <= *high)
+      *high = ::DecrementAndClamp(*high, numOptions);
+    if (forward == 0)
+      *low = *high;
+  }
+  else
+    NS_ASSERTION(mEndSelectionIndex == kNothingSelected, "");
+
+  InvalidateFocus();
+  return NS_OK;
+}
+
+//---------------------------------------------------------
+// Set the option selected in the DOM.  This method is named
+// as it is because it indicates that the frame is the source
+// of this event rather than the receiver.
+bool
+nsListControlFrame::SetOptionsSelectedFromFrame(int32_t aStartIndex,
+                                                int32_t aEndIndex,
+                                                bool aValue,
+                                                bool aClearAll)
+{
+  RefPtr<dom::HTMLSelectElement> selectElement =
+    dom::HTMLSelectElement::FromContent(mContent);
+
+  uint32_t mask = dom::HTMLSelectElement::NOTIFY;
+  if (mForceSelection) {
+    mask |= dom::HTMLSelectElement::SET_DISABLED;
+  }
+  if (aValue) {
+    mask |= dom::HTMLSelectElement::IS_SELECTED;
+  }
+  if (aClearAll) {
+    mask |= dom::HTMLSelectElement::CLEAR_ALL;
+  }
+
+  return selectElement->SetOptionsSelectedByIndex(aStartIndex, aEndIndex, mask);
+}
+
+bool
+nsListControlFrame::ToggleOptionSelectedFromFrame(int32_t aIndex)
+{
+  RefPtr<dom::HTMLOptionElement> option =
+    GetOption(static_cast<uint32_t>(aIndex));
+  NS_ENSURE_TRUE(option, false);
+
+  RefPtr<dom::HTMLSelectElement> selectElement =
+    dom::HTMLSelectElement::FromContent(mContent);
+
+  uint32_t mask = dom::HTMLSelectElement::NOTIFY;
+  if (!option->Selected()) {
+    mask |= dom::HTMLSelectElement::IS_SELECTED;
+  }
+
+  return selectElement->SetOptionsSelectedByIndex(aIndex, aIndex, mask);
+}
+
+
+// Dispatch event and such
+bool
+nsListControlFrame::UpdateSelection()
+{
+  if (mIsAllFramesHere) {
+    // if it's a combobox, display the new text
+    nsWeakFrame 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();
+    }
+    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;
+
+    nsWeakFrame 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;
+    }
+  }
+
+  nsCOMPtr<nsIContent> content = mContent;
+  // Dispatch the input event.
+  nsContentUtils::DispatchTrustedEvent(content->OwnerDoc(), content,
+                                       NS_LITERAL_STRING("input"), true,
+                                       false);
+  // Dispatch the change event.
+  nsContentUtils::DispatchTrustedEvent(content->OwnerDoc(), content,
+                                       NS_LITERAL_STRING("change"), true,
+                                       false);
+}
+
+NS_IMETHODIMP
+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);
+  }
+
+  nsWeakFrame weakFrame(this);
+  ScrollToIndex(aNewIndex);
+  if (!weakFrame.IsAlive()) {
+    return NS_OK;
+  }
+  mStartSelectionIndex = aNewIndex;
+  mEndSelectionIndex = aNewIndex;
+  InvalidateFocus();
+
+#ifdef ACCESSIBILITY
+  FireMenuItemActiveEvent();
+#endif
+
+  return NS_OK;
+}
+
+//----------------------------------------------------------------------
+// End nsISelectControlFrame
+//----------------------------------------------------------------------
+
+nsresult
+nsListControlFrame::SetFormProperty(nsIAtom* aName,
+                                const nsAString& aValue)
+{
+  if (nsGkAtoms::selected == aName) {
+    return NS_ERROR_INVALID_ARG; // Selected is readonly according to spec.
+  } else if (nsGkAtoms::selectedindex == aName) {
+    // You shouldn't be calling me for this!!!
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // We should be told about selectedIndex by the DOM element through
+  // OnOptionSelected
+
+  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);
+  nsStyleContext* context = comboboxFrame->StyleContext()->GetParent();
+  mLastDropdownBackstopColor = NS_RGBA(0,0,0,0);
+  while (NS_GET_A(mLastDropdownBackstopColor) < 255 && context) {
+    mLastDropdownBackstopColor =
+      NS_ComposeColors(context->StyleBackground()->mBackgroundColor,
+                       mLastDropdownBackstopColor);
+    context = context->GetParent();
+  }
+  mLastDropdownBackstopColor =
+    NS_ComposeColors(PresContext()->DefaultBackgroundColor(),
+                     mLastDropdownBackstopColor);
+
+  if (mIsAllContentHere && mIsAllFramesHere && mHasBeenInitialized) {
+    nsWeakFrame weakFrame(this);
+    ScrollToIndex(GetSelectedIndex());
+    if (!weakFrame.IsAlive()) {
+      return;
+    }
+#ifdef ACCESSIBILITY
+    FireMenuItemActiveEvent(); // 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,
+                              nsDidReflowStatus        aStatus)
+{
+  bool wasInterrupted = !mHasPendingInterruptAtStartOfReflow &&
+                          aPresContext->HasPendingInterrupt();
+
+  nsHTMLScrollFrame::DidReflow(aPresContext, aReflowInput, aStatus);
+
+  if (mNeedToReset && !wasInterrupted) {
+    mNeedToReset = false;
+    // Suppress scrolling to the selected element if we restored
+    // scroll history state AND the list contents have not changed
+    // since we loaded all the children AND nothing else forced us
+    // to scroll by calling ResetList(true). The latter two conditions
+    // are folded into mPostChildrenLoadedReset.
+    //
+    // The idea is that we want scroll history restoration to trump ResetList
+    // scrolling to the selected element, when the ResetList was probably only
+    // caused by content loading normally.
+    ResetList(!DidHistoryRestore() || mPostChildrenLoadedReset);
+  }
+
+  mHasPendingInterruptAtStartOfReflow = false;
+}
+
+nsIAtom*
+nsListControlFrame::GetType() const
+{
+  return nsGkAtoms::listControlFrame;
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult
+nsListControlFrame::GetFrameName(nsAString& aResult) const
+{
+  return MakeFrameName(NS_LITERAL_STRING("ListControl"), aResult);
+}
+#endif
+
+nscoord
+nsListControlFrame::GetBSizeOfARow()
+{
+  return BSizeOfARow();
+}
+
+nsresult
+nsListControlFrame::IsOptionDisabled(int32_t anIndex, bool &aIsDisabled)
+{
+  RefPtr<dom::HTMLSelectElement> sel =
+    dom::HTMLSelectElement::FromContent(mContent);
+  if (sel) {
+    sel->IsOptionDisabled(anIndex, &aIsDisabled);
+    return NS_OK;
+  }
+  return NS_ERROR_FAILURE;
+}
+
+//----------------------------------------------------------------------
+// helper
+//----------------------------------------------------------------------
+bool
+nsListControlFrame::IsLeftButton(nsIDOMEvent* aMouseEvent)
+{
+  // only allow selection with the left button
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
+  if (mouseEvent) {
+    int16_t whichButton;
+    if (NS_SUCCEEDED(mouseEvent->GetButton(&whichButton))) {
+      return whichButton != 0?false:true;
+    }
+  }
+  return false;
+}
+
+nscoord
+nsListControlFrame::CalcFallbackRowBSize(float aFontSizeInflation)
+{
+  RefPtr<nsFontMetrics> fontMet =
+    nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation);
+  return fontMet->MaxHeight();
+}
+
+nscoord
+nsListControlFrame::CalcIntrinsicBSize(nscoord aBSizeOfARow,
+                                       int32_t aNumberOfOptions)
+{
+  NS_PRECONDITION(!IsInDropDownMode(),
+                  "Shouldn't be in dropdown mode when we call this");
+
+  dom::HTMLSelectElement* select =
+    dom::HTMLSelectElement::FromContentOrNull(mContent);
+  if (select) {
+    mNumDisplayRows = select->Size();
+  } else {
+    mNumDisplayRows = 1;
+  }
+
+  if (mNumDisplayRows < 1) {
+    mNumDisplayRows = 4;
+  }
+
+  return mNumDisplayRows * aBSizeOfARow;
+}
+
+//----------------------------------------------------------------------
+// nsIDOMMouseListener
+//----------------------------------------------------------------------
+nsresult
+nsListControlFrame::MouseUp(nsIDOMEvent* aMouseEvent)
+{
+  NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
+
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
+  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 disabled, disallow the click and leave.
+      bool isDisabled = false;
+      IsOptionDisabled(selectedIndex, isDisabled);
+      if (isDisabled) {
+        aMouseEvent->PreventDefault();
+        aMouseEvent->StopPropagation();
+        CaptureMouseEvents(false);
+        return NS_ERROR_FAILURE;
+      }
+
+      if (kNothingSelected != selectedIndex) {
+        nsWeakFrame 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(nsIDOMEvent* 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(nsIDOMEvent* 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()
+{
+  if (mFocused != this && !IsInDropDownMode()) {
+    return;
+  }
+
+  nsCOMPtr<nsIContent> optionContent = GetCurrentOption();
+  if (!optionContent) {
+    return;
+  }
+
+  FireDOMEvent(NS_LITERAL_STRING("DOMMenuItemActive"), optionContent);
+}
+#endif
+
+nsresult
+nsListControlFrame::GetIndexFromDOMEvent(nsIDOMEvent* aMouseEvent,
+                                         int32_t&     aCurIndex)
+{
+  if (IgnoreMouseEventForSelection(aMouseEvent))
+    return NS_ERROR_FAILURE;
+
+  if (nsIPresShell::GetCapturingContent() != mContent) {
+    // If we're not capturing, then ignore movement in the border
+    nsPoint pt = nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(aMouseEvent, this);
+    nsRect borderInnerEdge = GetScrollPortRect();
+    if (!borderInnerEdge.Contains(pt)) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  RefPtr<dom::HTMLOptionElement> option;
+  for (nsCOMPtr<nsIContent> content =
+         PresContext()->EventStateManager()->GetEventTargetContent(nullptr);
+       content && !option;
+       content = content->GetParent()) {
+    option = dom::HTMLOptionElement::FromContent(content);
+  }
+
+  if (option) {
+    aCurIndex = option->Index();
+    MOZ_ASSERT(aCurIndex >= 0);
+    return NS_OK;
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+static bool
+FireShowDropDownEvent(nsIContent* aContent, bool aShow, bool aIsSourceTouchEvent)
+{
+  if (XRE_IsContentProcess() &&
+      Preferences::GetBool("browser.tabs.remote.desktopbehavior", false)) {
+    nsString eventName;
+    if (aShow) {
+      eventName = aIsSourceTouchEvent ? NS_LITERAL_STRING("mozshowdropdown-sourcetouch") :
+                                        NS_LITERAL_STRING("mozshowdropdown");
+    } else {
+      eventName = NS_LITERAL_STRING("mozhidedropdown");
+    }
+    nsContentUtils::DispatchChromeEvent(aContent->OwnerDoc(), aContent,
+                                        eventName, true, false);
+    return true;
+  }
+
+  return false;
+}
+
+nsresult
+nsListControlFrame::MouseDown(nsIDOMEvent* aMouseEvent)
+{
+  NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
+
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
+  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;
+    }
+  }
+
+  int32_t selectedIndex;
+  if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
+    // Handle Like List
+    mButtonDown = true;
+    CaptureMouseEvents(true);
+    nsWeakFrame weakFrame(this);
+    bool change =
+      HandleListSelection(aMouseEvent, selectedIndex); // might destroy us
+    if (!weakFrame.IsAlive()) {
+      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<nsIDOMEventTarget> etarget;
+        aMouseEvent->GetTarget(getter_AddRefs(etarget));
+        nsCOMPtr<nsIDOMHTMLOptionElement> option = do_QueryInterface(etarget);
+        if (option) {
+          return NS_OK;
+        }
+      }
+
+      uint16_t inputSource = nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN;
+      if (NS_FAILED(mouseEvent->GetMozInputSource(&inputSource))) {
+        return NS_ERROR_FAILURE;
+      }
+      bool isSourceTouchEvent = inputSource == nsIDOMMouseEvent::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);
+        nsWeakFrame weakFrame(comboFrame);
+        mComboboxFrame->ShowDropDown(!isDroppedDown);
+        if (!weakFrame.IsAlive())
+          return NS_OK;
+        if (isDroppedDown) {
+          CaptureMouseEvents(false);
+        }
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+//----------------------------------------------------------------------
+// nsIDOMMouseMotionListener
+//----------------------------------------------------------------------
+nsresult
+nsListControlFrame::MouseMove(nsIDOMEvent* aMouseEvent)
+{
+  NS_ASSERTION(aMouseEvent, "aMouseEvent is null.");
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
+  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
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsListControlFrame::DragMove(nsIDOMEvent* 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;
+      }
+      nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
+      NS_ASSERTION(mouseEvent, "aMouseEvent is not an nsIDOMMouseEvent!");
+      bool isControl;
+#ifdef XP_MACOSX
+      mouseEvent->GetMetaKey(&isControl);
+#else
+      mouseEvent->GetCtrlKey(&isControl);
+#endif
+      nsWeakFrame 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;
+}
+
+//----------------------------------------------------------------------
+// Scroll helpers.
+//----------------------------------------------------------------------
+void
+nsListControlFrame::ScrollToIndex(int32_t aIndex)
+{
+  if (aIndex < 0) {
+    // XXX shouldn't we just do nothing if we're asked to scroll to
+    // kNothingSelected?
+    ScrollTo(nsPoint(0, 0), nsIScrollableFrame::INSTANT);
+  } else {
+    RefPtr<dom::HTMLOptionElement> option =
+      GetOption(AssertedCast<uint32_t>(aIndex));
+    if (option) {
+      ScrollToFrame(*option);
+    }
+  }
+}
+
+void
+nsListControlFrame::ScrollToFrame(dom::HTMLOptionElement& aOptElement)
+{
+  // otherwise we find the content's frame and scroll to it
+  nsIFrame* childFrame = aOptElement.GetPrimaryFrame();
+  if (childFrame) {
+    PresContext()->PresShell()->
+      ScrollFrameRectIntoView(childFrame,
+                              nsRect(nsPoint(0, 0), childFrame->GetSize()),
+                              nsIPresShell::ScrollAxis(), nsIPresShell::ScrollAxis(),
+                              nsIPresShell::SCROLL_OVERFLOW_HIDDEN |
+                              nsIPresShell::SCROLL_FIRST_ANCESTOR_ONLY);
+  }
+}
+
+//---------------------------------------------------------------------
+// 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 isn't disabled, we are golden, bail out
+    bool isDisabled = true;
+    if (NS_SUCCEEDED(IsOptionDisabled(newIndex, isDisabled)) && !isDisabled) {
+      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 == nullptr)
+    sIncrementalString = new nsString();
+
+  return *sIncrementalString;
+}
+
+void
+nsListControlFrame::Shutdown()
+{
+  delete sIncrementalString;
+  sIncrementalString = nullptr;
+}
+
+void
+nsListControlFrame::DropDownToggleKey(nsIDOMEvent* 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 {
+      nsWeakFrame weakFrame(this);
+      // mEndSelectionIndex is the last item that got selected.
+      ComboboxFinish(mEndSelectionIndex);
+      if (weakFrame.IsAlive()) {
+        FireOnInputAndOnChange();
+      }
+    }
+  }
+}
+
+nsresult
+nsListControlFrame::KeyDown(nsIDOMEvent* aKeyEvent)
+{
+  MOZ_ASSERT(aKeyEvent, "aKeyEvent is null.");
+
+  EventStates eventStates = mContent->AsElement()->State();
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
+    return NS_OK;
+  }
+
+  AutoIncrementalSearchResetter incrementalSearchResetter;
+
+  // Don't check defaultPrevented value because other browsers don't prevent
+  // the key navigation of list control even if preventDefault() is called.
+  // XXXmats 2015-04-16: the above is not true anymore, Chrome prevents all
+  // XXXmats keyboard events, even tabbing, when preventDefault() is called
+  // XXXmats in onkeydown. That seems sub-optimal though.
+
+  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 <= INCREMENTAL_SEARCH_KEYPRESS_TIME;
+  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;
+  }
+
+  switch (keyEvent->mKeyCode) {
+    case NS_VK_UP:
+    case NS_VK_LEFT:
+      AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
+                                static_cast<int32_t>(numOptions),
+                                -1, -1);
+      break;
+    case NS_VK_DOWN:
+    case NS_VK_RIGHT:
+      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();
+
+          nsWeakFrame 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;
+      }
+
+      AboutToRollup();
+      // If the select element is a dropdown style, Enter key should be
+      // consumed everytime since Escape key may be pressed accidentally after
+      // the dropdown is closed by Escepe key.
+      aKeyEvent->PreventDefault();
+      return NS_OK;
+    }
+    case NS_VK_PAGE_UP: {
+      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: {
+      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:
+      AdjustIndexForDisabledOpt(0, newIndex,
+                                static_cast<int32_t>(numOptions),
+                                0, 1);
+      break;
+    case NS_VK_END:
+      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(nsIDOMEvent* 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
+  // INCREMENTAL_SEARCH_KEYPRESS_TIME, 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 > INCREMENTAL_SEARCH_KEYPRESS_TIME) {
+    // 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();
+
+  nsWeakFrame 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;
+    if (NS_FAILED(optionElement->GetText(text)) ||
+        !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) {
+    return;
+  }
+
+  // If you hold control, but not shift, no key will actually do anything
+  // except space.
+  nsWeakFrame weakFrame(this);
+  bool wasChanged = false;
+  if (aIsControlOrMeta && !aIsShift && aCharCode != ' ') {
+    mStartSelectionIndex = aNewIndex;
+    mEndSelectionIndex = aNewIndex;
+    InvalidateFocus();
+    ScrollToIndex(aNewIndex);
+    if (!weakFrame.IsAlive()) {
+      return;
+    }
+
+#ifdef ACCESSIBILITY
+    FireMenuItemActiveEvent();
+#endif
+  } else if (mControlSelectMode && aCharCode == ' ') {
+    wasChanged = SingleSelection(aNewIndex, true);
+  } else {
+    wasChanged = PerformSelection(aNewIndex, aIsShift, aIsControlOrMeta);
+  }
+  if (wasChanged && weakFrame.IsAlive()) {
+    // dispatch event, update combobox, etc.
+    UpdateSelection();
+  }
+}
+
+
+/******************************************************************************
+ * nsListEventListener
+ *****************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsListEventListener, nsIDOMEventListener)
+
+NS_IMETHODIMP
+nsListEventListener::HandleEvent(nsIDOMEvent* 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")) {
+    bool defaultPrevented = false;
+    aEvent->GetDefaultPrevented(&defaultPrevented);
+    if (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);
+  }
+
+  NS_ABORT();
+  return NS_OK;
+}