Add m-esr52 at 52.6.0

1 files changed, 1535 insertions, 0 deletions

diff --git a/layout/xul/nsListBoxBodyFrame.cpp b/layout/xul/nsListBoxBodyFrame.cpp
new file mode 100644
index 000000000..8c4a5e2fd
--- /dev/null
+++ b/layout/xul/nsListBoxBodyFrame.cpp
@@ -0,0 +1,1535 @@
+/* -*- 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 "nsListBoxBodyFrame.h"
+
+#include "nsListBoxLayout.h"
+
+#include "mozilla/MathAlgorithms.h"
+#include "nsCOMPtr.h"
+#include "nsGridRowGroupLayout.h"
+#include "nsIServiceManager.h"
+#include "nsGkAtoms.h"
+#include "nsIContent.h"
+#include "nsNameSpaceManager.h"
+#include "nsIDocument.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMNodeList.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsIScrollableFrame.h"
+#include "nsScrollbarFrame.h"
+#include "nsView.h"
+#include "nsViewManager.h"
+#include "nsStyleContext.h"
+#include "nsFontMetrics.h"
+#include "nsITimer.h"
+#include "mozilla/StyleSetHandle.h"
+#include "mozilla/StyleSetHandleInlines.h"
+#include "nsPIBoxObject.h"
+#include "nsLayoutUtils.h"
+#include "nsPIListBoxObject.h"
+#include "nsContentUtils.h"
+#include "ChildIterator.h"
+#include "nsRenderingContext.h"
+#include "prtime.h"
+#include <algorithm>
+
+#ifdef ACCESSIBILITY
+#include "nsAccessibilityService.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+/////////////// nsListScrollSmoother //////////////////
+
+/* A mediator used to smooth out scrolling. It works by seeing if 
+ * we have time to scroll the amount of rows requested. This is determined
+ * by measuring how long it takes to scroll a row. If we can scroll the 
+ * rows in time we do so. If not we start a timer and skip the request. We
+ * do this until the timer finally first because the user has stopped moving
+ * the mouse. Then do all the queued requests in on shot.
+ */
+
+// the longest amount of time that can go by before the use
+// notices it as a delay.
+#define USER_TIME_THRESHOLD 150000
+
+// how long it takes to layout a single row initial value.
+// we will time this after we scroll a few rows.
+#define TIME_PER_ROW_INITAL  50000
+
+// if we decide we can't layout the rows in the amount of time. How long
+// do we wait before checking again?
+#define SMOOTH_INTERVAL 100
+
+class nsListScrollSmoother final : public nsITimerCallback
+{
+private:
+  virtual ~nsListScrollSmoother();
+
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit nsListScrollSmoother(nsListBoxBodyFrame* aOuter);
+
+  // nsITimerCallback
+  NS_DECL_NSITIMERCALLBACK
+
+  void Start();
+  void Stop();
+  bool IsRunning();
+
+  nsCOMPtr<nsITimer> mRepeatTimer;
+  int32_t mDelta;
+  nsListBoxBodyFrame* mOuter;
+}; 
+
+nsListScrollSmoother::nsListScrollSmoother(nsListBoxBodyFrame* aOuter)
+{
+  mDelta = 0;
+  mOuter = aOuter;
+}
+
+nsListScrollSmoother::~nsListScrollSmoother()
+{
+  Stop();
+}
+
+NS_IMETHODIMP
+nsListScrollSmoother::Notify(nsITimer *timer)
+{
+  Stop();
+
+  NS_ASSERTION(mOuter, "mOuter is null, see bug #68365");
+  if (!mOuter) return NS_OK;
+
+  // actually do some work.
+  mOuter->InternalPositionChangedCallback();
+  return NS_OK;
+}
+
+bool
+nsListScrollSmoother::IsRunning()
+{
+  return mRepeatTimer ? true : false;
+}
+
+void
+nsListScrollSmoother::Start()
+{
+  Stop();
+  mRepeatTimer = do_CreateInstance("@mozilla.org/timer;1");
+  mRepeatTimer->InitWithCallback(this, SMOOTH_INTERVAL, nsITimer::TYPE_ONE_SHOT);
+}
+
+void
+nsListScrollSmoother::Stop()
+{
+  if ( mRepeatTimer ) {
+    mRepeatTimer->Cancel();
+    mRepeatTimer = nullptr;
+  }
+}
+
+NS_IMPL_ISUPPORTS(nsListScrollSmoother, nsITimerCallback)
+
+/////////////// nsListBoxBodyFrame //////////////////
+
+nsListBoxBodyFrame::nsListBoxBodyFrame(nsStyleContext* aContext,
+                                       nsBoxLayout* aLayoutManager)
+  : nsBoxFrame(aContext, false, aLayoutManager),
+    mTopFrame(nullptr),
+    mBottomFrame(nullptr),
+    mLinkupFrame(nullptr),
+    mScrollSmoother(nullptr),
+    mRowsToPrepend(0),
+    mRowCount(-1),
+    mRowHeight(0),
+    mAvailableHeight(0),
+    mStringWidth(-1),
+    mCurrentIndex(0),
+    mOldIndex(0),
+    mYPosition(0),
+    mTimePerRow(TIME_PER_ROW_INITAL),
+    mRowHeightWasSet(false),
+    mScrolling(false),
+    mAdjustScroll(false),
+    mReflowCallbackPosted(false)
+{
+}
+
+nsListBoxBodyFrame::~nsListBoxBodyFrame()
+{
+  NS_IF_RELEASE(mScrollSmoother);
+
+#if USE_TIMER_TO_DELAY_SCROLLING
+  StopScrollTracking();
+  mAutoScrollTimer = nullptr;
+#endif
+
+}
+
+NS_QUERYFRAME_HEAD(nsListBoxBodyFrame)
+  NS_QUERYFRAME_ENTRY(nsIScrollbarMediator)
+  NS_QUERYFRAME_ENTRY(nsListBoxBodyFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
+
+////////// nsIFrame /////////////////
+
+void
+nsListBoxBodyFrame::Init(nsIContent*       aContent,
+                         nsContainerFrame* aParent, 
+                         nsIFrame*         aPrevInFlow)
+{
+  nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+  // Don't call nsLayoutUtils::GetScrollableFrameFor since we are not its
+  // scrollframe child yet.
+  nsIScrollableFrame* scrollFrame = do_QueryFrame(aParent);
+  if (scrollFrame) {
+    nsIFrame* verticalScrollbar = scrollFrame->GetScrollbarBox(true);
+    nsScrollbarFrame* scrollbarFrame = do_QueryFrame(verticalScrollbar);
+    if (scrollbarFrame) {
+      scrollbarFrame->SetScrollbarMediatorContent(GetContent());
+    }
+  }
+  RefPtr<nsFontMetrics> fm =
+    nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
+  mRowHeight = fm->MaxHeight();
+}
+
+void
+nsListBoxBodyFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  // make sure we cancel any posted callbacks.
+  if (mReflowCallbackPosted)
+     PresContext()->PresShell()->CancelReflowCallback(this);
+
+  // Revoke any pending position changed events
+  for (uint32_t i = 0; i < mPendingPositionChangeEvents.Length(); ++i) {
+    mPendingPositionChangeEvents[i]->Revoke();
+  }
+
+  // Make sure we tell our listbox's box object we're being destroyed.
+  if (mBoxObject) {
+    mBoxObject->ClearCachedValues();
+  }
+
+  nsBoxFrame::DestroyFrom(aDestructRoot);
+}
+
+nsresult
+nsListBoxBodyFrame::AttributeChanged(int32_t aNameSpaceID,
+                                     nsIAtom* aAttribute, 
+                                     int32_t aModType)
+{
+  nsresult rv = NS_OK;
+
+  if (aAttribute == nsGkAtoms::rows) {
+    PresContext()->PresShell()->
+      FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
+  }
+  else
+    rv = nsBoxFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
+
+  return rv;
+ 
+}
+
+/* virtual */ void
+nsListBoxBodyFrame::MarkIntrinsicISizesDirty()
+{
+  mStringWidth = -1;
+  nsBoxFrame::MarkIntrinsicISizesDirty();
+}
+
+/////////// nsBox ///////////////
+
+NS_IMETHODIMP
+nsListBoxBodyFrame::DoXULLayout(nsBoxLayoutState& aBoxLayoutState)
+{
+  if (mScrolling)
+    aBoxLayoutState.SetPaintingDisabled(true);
+
+  nsresult rv = nsBoxFrame::DoXULLayout(aBoxLayoutState);
+
+  // determine the real height for the scrollable area from the total number
+  // of rows, since non-visible rows don't yet have frames
+  nsRect rect(nsPoint(0, 0), GetSize());
+  nsOverflowAreas overflow(rect, rect);
+  if (mLayoutManager) {
+    nsIFrame* childFrame = mFrames.FirstChild();
+    while (childFrame) {
+      ConsiderChildOverflow(overflow, childFrame);
+      childFrame = childFrame->GetNextSibling();
+    }
+
+    nsSize prefSize = mLayoutManager->GetXULPrefSize(this, aBoxLayoutState);
+    NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
+      nsRect& o = overflow.Overflow(otype);
+      o.height = std::max(o.height, prefSize.height);
+    }
+  }
+  FinishAndStoreOverflow(overflow, GetSize());
+
+  if (mScrolling)
+    aBoxLayoutState.SetPaintingDisabled(false);
+
+  // if we are scrolled and the row height changed
+  // make sure we are scrolled to a correct index.
+  if (mAdjustScroll)
+     PostReflowCallback();
+
+  return rv;
+}
+
+nsSize
+nsListBoxBodyFrame::GetXULMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState)
+{
+  nsSize result(0, 0);
+  if (nsContentUtils::HasNonEmptyAttr(GetContent(), kNameSpaceID_None,
+                                      nsGkAtoms::sizemode)) {
+    result = GetXULPrefSize(aBoxLayoutState);
+    result.height = 0;
+    nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this);
+    if (scrollFrame &&
+        scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) {
+      nsMargin scrollbars =
+        scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState);
+      result.width += scrollbars.left + scrollbars.right;
+    }
+  }
+  return result;
+}
+
+nsSize
+nsListBoxBodyFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState)
+{  
+  nsSize pref = nsBoxFrame::GetXULPrefSize(aBoxLayoutState);
+
+  int32_t size = GetFixedRowSize();
+  if (size > -1)
+    pref.height = size*GetRowHeightAppUnits();
+
+  nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this);
+  if (scrollFrame &&
+      scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) {
+    nsMargin scrollbars = scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState);
+    pref.width += scrollbars.left + scrollbars.right;
+  }
+  return pref;
+}
+
+///////////// nsIScrollbarMediator ///////////////
+
+void
+nsListBoxBodyFrame::ScrollByPage(nsScrollbarFrame* aScrollbar, int32_t aDirection,
+                                 nsIScrollbarMediator::ScrollSnapMode aSnap)
+{
+  // CSS Scroll Snapping is not enabled for XUL, aSnap is ignored
+  MOZ_ASSERT(aScrollbar != nullptr);
+  aScrollbar->SetIncrementToPage(aDirection);
+  nsWeakFrame weakFrame(this);
+  int32_t newPos = aScrollbar->MoveToNewPosition();
+  if (!weakFrame.IsAlive()) {
+    return;
+  }
+  UpdateIndex(newPos);
+}
+
+void
+nsListBoxBodyFrame::ScrollByWhole(nsScrollbarFrame* aScrollbar, int32_t aDirection,
+                                  nsIScrollbarMediator::ScrollSnapMode aSnap)
+{
+  // CSS Scroll Snapping is not enabled for XUL, aSnap is ignored
+  MOZ_ASSERT(aScrollbar != nullptr);
+  aScrollbar->SetIncrementToWhole(aDirection);
+  nsWeakFrame weakFrame(this);
+  int32_t newPos = aScrollbar->MoveToNewPosition();
+  if (!weakFrame.IsAlive()) {
+    return;
+  }
+  UpdateIndex(newPos);
+}
+
+void
+nsListBoxBodyFrame::ScrollByLine(nsScrollbarFrame* aScrollbar, int32_t aDirection,
+                                 nsIScrollbarMediator::ScrollSnapMode aSnap)
+{
+  // CSS Scroll Snapping is not enabled for XUL, aSnap is ignored
+  MOZ_ASSERT(aScrollbar != nullptr);
+  aScrollbar->SetIncrementToLine(aDirection);
+  nsWeakFrame weakFrame(this);
+  int32_t newPos = aScrollbar->MoveToNewPosition();
+  if (!weakFrame.IsAlive()) {
+    return;
+  }
+  UpdateIndex(newPos);
+}
+
+void
+nsListBoxBodyFrame::RepeatButtonScroll(nsScrollbarFrame* aScrollbar)
+{
+  nsWeakFrame weakFrame(this);
+  int32_t newPos = aScrollbar->MoveToNewPosition();
+  if (!weakFrame.IsAlive()) {
+    return;
+  }
+  UpdateIndex(newPos);
+}
+
+int32_t
+nsListBoxBodyFrame::ToRowIndex(nscoord aPos) const
+{
+  return NS_roundf(float(std::max(aPos, 0)) / mRowHeight);
+}
+
+void
+nsListBoxBodyFrame::ThumbMoved(nsScrollbarFrame* aScrollbar,
+                               nscoord aOldPos,
+                               nscoord aNewPos)
+{ 
+  if (mScrolling || mRowHeight == 0)
+    return;
+
+  int32_t newIndex = ToRowIndex(aNewPos);
+  if (newIndex == mCurrentIndex) {
+    return;
+  }
+  int32_t rowDelta = newIndex - mCurrentIndex;
+
+  nsListScrollSmoother* smoother = GetSmoother();
+
+  // if we can't scroll the rows in time then start a timer. We will eat
+  // events until the user stops moving and the timer stops.
+  if (smoother->IsRunning() || Abs(rowDelta)*mTimePerRow > USER_TIME_THRESHOLD) {
+
+     smoother->Stop();
+
+     smoother->mDelta = rowDelta;
+
+     smoother->Start();
+
+     return;
+  }
+
+  smoother->Stop();
+
+  mCurrentIndex = newIndex;
+  smoother->mDelta = 0;
+  
+  if (mCurrentIndex < 0) {
+    mCurrentIndex = 0;
+    return;
+  }
+  InternalPositionChanged(rowDelta < 0, Abs(rowDelta));
+}
+
+void
+nsListBoxBodyFrame::VisibilityChanged(bool aVisible)
+{
+  if (mRowHeight == 0)
+    return;
+
+  int32_t lastPageTopRow = GetRowCount() - (GetAvailableHeight() / mRowHeight);
+  if (lastPageTopRow < 0)
+    lastPageTopRow = 0;
+  int32_t delta = mCurrentIndex - lastPageTopRow;
+  if (delta > 0) {
+    mCurrentIndex = lastPageTopRow;
+    InternalPositionChanged(true, delta);
+  }
+}
+
+nsIFrame*
+nsListBoxBodyFrame::GetScrollbarBox(bool aVertical)
+{
+  nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this);
+  return scrollFrame ? scrollFrame->GetScrollbarBox(true) : nullptr;
+}
+
+void
+nsListBoxBodyFrame::UpdateIndex(int32_t aNewPos)
+{
+  int32_t newIndex = ToRowIndex(nsPresContext::CSSPixelsToAppUnits(aNewPos));
+  if (newIndex == mCurrentIndex) {
+    return;
+  }
+  bool up = newIndex < mCurrentIndex;
+  int32_t indexDelta = Abs(newIndex - mCurrentIndex);
+  mCurrentIndex = newIndex;
+  InternalPositionChanged(up, indexDelta);
+}
+ 
+///////////// nsIReflowCallback ///////////////
+
+bool
+nsListBoxBodyFrame::ReflowFinished()
+{
+  nsAutoScriptBlocker scriptBlocker;
+  // now create or destroy any rows as needed
+  CreateRows();
+
+  // keep scrollbar in sync
+  if (mAdjustScroll) {
+     VerticalScroll(mYPosition);
+     mAdjustScroll = false;
+  }
+
+  // if the row height changed then mark everything as a style change. 
+  // That will dirty the entire listbox
+  if (mRowHeightWasSet) {
+    PresContext()->PresShell()->
+      FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
+     int32_t pos = mCurrentIndex * mRowHeight;
+     if (mYPosition != pos) 
+       mAdjustScroll = true;
+    mRowHeightWasSet = false;
+  }
+
+  mReflowCallbackPosted = false;
+  return true;
+}
+
+void
+nsListBoxBodyFrame::ReflowCallbackCanceled()
+{
+  mReflowCallbackPosted = false;
+}
+
+///////// ListBoxObject ///////////////
+
+int32_t
+nsListBoxBodyFrame::GetNumberOfVisibleRows()
+{
+  return mRowHeight ? GetAvailableHeight() / mRowHeight : 0;
+}
+
+int32_t
+nsListBoxBodyFrame::GetIndexOfFirstVisibleRow()
+{
+  return mCurrentIndex;
+}
+
+nsresult
+nsListBoxBodyFrame::EnsureIndexIsVisible(int32_t aRowIndex)
+{
+  if (aRowIndex < 0)
+    return NS_ERROR_ILLEGAL_VALUE;
+
+  int32_t rows = 0;
+  if (mRowHeight)
+    rows = GetAvailableHeight()/mRowHeight;
+  if (rows <= 0)
+    rows = 1;
+  int32_t bottomIndex = mCurrentIndex + rows;
+  
+  // if row is visible, ignore
+  if (mCurrentIndex <= aRowIndex && aRowIndex < bottomIndex)
+    return NS_OK;
+
+  int32_t delta;
+
+  bool up = aRowIndex < mCurrentIndex;
+  if (up) {
+    delta = mCurrentIndex - aRowIndex;
+    mCurrentIndex = aRowIndex;
+  }
+  else {
+    // Check to be sure we're not scrolling off the bottom of the tree
+    if (aRowIndex >= GetRowCount())
+      return NS_ERROR_ILLEGAL_VALUE;
+
+    // Bring it just into view.
+    delta = 1 + (aRowIndex-bottomIndex);
+    mCurrentIndex += delta; 
+  }
+
+  // Safe to not go off an event here, since this is coming from the
+  // box object.
+  DoInternalPositionChangedSync(up, delta);
+  return NS_OK;
+}
+
+nsresult
+nsListBoxBodyFrame::ScrollByLines(int32_t aNumLines)
+{
+  int32_t scrollIndex = GetIndexOfFirstVisibleRow(),
+    visibleRows = GetNumberOfVisibleRows();
+
+  scrollIndex += aNumLines;
+  
+  if (scrollIndex < 0)
+    scrollIndex = 0;
+  else {
+    int32_t numRows = GetRowCount();
+    int32_t lastPageTopRow = numRows - visibleRows;
+    if (scrollIndex > lastPageTopRow)
+      scrollIndex = lastPageTopRow;
+  }
+  
+  ScrollToIndex(scrollIndex);
+
+  return NS_OK;
+}
+
+// walks the DOM to get the zero-based row index of the content
+nsresult
+nsListBoxBodyFrame::GetIndexOfItem(nsIDOMElement* aItem, int32_t* _retval)
+{
+  if (aItem) {
+    *_retval = 0;
+    nsCOMPtr<nsIContent> itemContent(do_QueryInterface(aItem));
+
+    FlattenedChildIterator iter(mContent);
+    for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
+      // we hit a list row, count it
+      if (child->IsXULElement(nsGkAtoms::listitem)) {
+        // is this it?
+        if (child == itemContent)
+          return NS_OK;
+
+        ++(*_retval);
+      }
+    }
+  }
+
+  // not found
+  *_retval = -1;
+  return NS_OK;
+}
+
+nsresult
+nsListBoxBodyFrame::GetItemAtIndex(int32_t aIndex, nsIDOMElement** aItem)
+{
+  *aItem = nullptr;
+  if (aIndex < 0)
+    return NS_OK;
+
+  int32_t itemCount = 0;
+  FlattenedChildIterator iter(mContent);
+  for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
+    // we hit a list row, check if it is the one we are looking for
+    if (child->IsXULElement(nsGkAtoms::listitem)) {
+      // is this it?
+      if (itemCount == aIndex) {
+        return CallQueryInterface(child, aItem);
+      }
+      ++itemCount;
+    }
+  }
+
+  // not found
+  return NS_OK;
+}
+
+/////////// nsListBoxBodyFrame ///////////////
+
+int32_t
+nsListBoxBodyFrame::GetRowCount()
+{
+  if (mRowCount < 0)
+    ComputeTotalRowCount();
+  return mRowCount;
+}
+
+int32_t
+nsListBoxBodyFrame::GetFixedRowSize()
+{
+  nsresult dummy;
+
+  nsAutoString rows;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::rows, rows);
+  if (!rows.IsEmpty())
+    return rows.ToInteger(&dummy);
+ 
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::size, rows);
+
+  if (!rows.IsEmpty())
+    return rows.ToInteger(&dummy);
+
+  return -1;
+}
+
+void
+nsListBoxBodyFrame::SetRowHeight(nscoord aRowHeight)
+{ 
+  if (aRowHeight > mRowHeight) { 
+    mRowHeight = aRowHeight;
+
+    // signal we need to dirty everything 
+    // and we want to be notified after reflow
+    // so we can create or destory rows as needed
+    mRowHeightWasSet = true;
+    PostReflowCallback();
+  }
+}
+
+nscoord
+nsListBoxBodyFrame::GetAvailableHeight()
+{
+  nsIScrollableFrame* scrollFrame =
+    nsLayoutUtils::GetScrollableFrameFor(this);
+  if (scrollFrame) {
+    return scrollFrame->GetScrollPortRect().height;
+  }
+  return 0;
+}
+
+nscoord
+nsListBoxBodyFrame::GetYPosition()
+{
+  return mYPosition;
+}
+
+nscoord
+nsListBoxBodyFrame::ComputeIntrinsicISize(nsBoxLayoutState& aBoxLayoutState)
+{
+  if (mStringWidth != -1)
+    return mStringWidth;
+
+  nscoord largestWidth = 0;
+
+  int32_t index = 0;
+  nsCOMPtr<nsIDOMElement> firstRowEl;
+  GetItemAtIndex(index, getter_AddRefs(firstRowEl));
+  nsCOMPtr<nsIContent> firstRowContent(do_QueryInterface(firstRowEl));
+
+  if (firstRowContent) {
+    RefPtr<nsStyleContext> styleContext;
+    nsPresContext *presContext = aBoxLayoutState.PresContext();
+    styleContext = presContext->StyleSet()->
+      ResolveStyleFor(firstRowContent->AsElement(), nullptr);
+
+    nscoord width = 0;
+    nsMargin margin(0,0,0,0);
+
+    if (styleContext->StylePadding()->GetPadding(margin))
+      width += margin.LeftRight();
+    width += styleContext->StyleBorder()->GetComputedBorder().LeftRight();
+    if (styleContext->StyleMargin()->GetMargin(margin))
+      width += margin.LeftRight();
+
+    FlattenedChildIterator iter(mContent);
+    for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
+      if (child->IsXULElement(nsGkAtoms::listitem)) {
+        nsRenderingContext* rendContext = aBoxLayoutState.GetRenderingContext();
+        if (rendContext) {
+          nsAutoString value;
+          uint32_t textCount = child->GetChildCount();
+          for (uint32_t j = 0; j < textCount; ++j) {
+            nsIContent* text = child->GetChildAt(j);
+            if (text && text->IsNodeOfType(nsINode::eTEXT)) {
+              text->AppendTextTo(value);
+            }
+          }
+
+          RefPtr<nsFontMetrics> fm =
+            nsLayoutUtils::GetFontMetricsForStyleContext(styleContext);
+
+          nscoord textWidth =
+            nsLayoutUtils::AppUnitWidthOfStringBidi(value, this, *fm,
+                                                    *rendContext);
+          textWidth += width;
+
+          if (textWidth > largestWidth) 
+            largestWidth = textWidth;
+        }
+      }
+    }
+  }
+
+  mStringWidth = largestWidth;
+  return mStringWidth;
+}
+
+void
+nsListBoxBodyFrame::ComputeTotalRowCount()
+{
+  mRowCount = 0;
+  FlattenedChildIterator iter(mContent);
+  for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
+    if (child->IsXULElement(nsGkAtoms::listitem)) {
+      ++mRowCount;
+    }
+  }
+}
+
+void
+nsListBoxBodyFrame::PostReflowCallback()
+{
+  if (!mReflowCallbackPosted) {
+    mReflowCallbackPosted = true;
+    PresContext()->PresShell()->PostReflowCallback(this);
+  }
+}
+
+////////// scrolling
+
+nsresult
+nsListBoxBodyFrame::ScrollToIndex(int32_t aRowIndex)
+{
+  if (( aRowIndex < 0 ) || (mRowHeight == 0))
+    return NS_OK;
+    
+  int32_t newIndex = aRowIndex;
+  int32_t delta = mCurrentIndex > newIndex ? mCurrentIndex - newIndex : newIndex - mCurrentIndex;
+  bool up = newIndex < mCurrentIndex;
+
+  // Check to be sure we're not scrolling off the bottom of the tree
+  int32_t lastPageTopRow = GetRowCount() - (GetAvailableHeight() / mRowHeight);
+  if (lastPageTopRow < 0)
+    lastPageTopRow = 0;
+
+  if (aRowIndex > lastPageTopRow)
+    return NS_OK;
+
+  mCurrentIndex = newIndex;
+
+  nsWeakFrame weak(this);
+
+  // Since we're going to flush anyway, we need to not do this off an event
+  DoInternalPositionChangedSync(up, delta);
+
+  if (!weak.IsAlive()) {
+    return NS_OK;
+  }
+
+  // This change has to happen immediately.
+  // Flush any pending reflow commands.
+  // XXXbz why, exactly?
+  mContent->GetComposedDoc()->FlushPendingNotifications(Flush_Layout);
+
+  return NS_OK;
+}
+
+nsresult
+nsListBoxBodyFrame::InternalPositionChangedCallback()
+{
+  nsListScrollSmoother* smoother = GetSmoother();
+
+  if (smoother->mDelta == 0)
+    return NS_OK;
+
+  mCurrentIndex += smoother->mDelta;
+
+  if (mCurrentIndex < 0)
+    mCurrentIndex = 0;
+
+  return DoInternalPositionChangedSync(smoother->mDelta < 0,
+                                       smoother->mDelta < 0 ?
+                                         -smoother->mDelta : smoother->mDelta);
+}
+
+nsresult
+nsListBoxBodyFrame::InternalPositionChanged(bool aUp, int32_t aDelta)
+{
+  RefPtr<nsPositionChangedEvent> ev =
+    new nsPositionChangedEvent(this, aUp, aDelta);
+  nsresult rv = NS_DispatchToCurrentThread(ev);
+  if (NS_SUCCEEDED(rv)) {
+    if (!mPendingPositionChangeEvents.AppendElement(ev)) {
+      rv = NS_ERROR_OUT_OF_MEMORY;
+      ev->Revoke();
+    }
+  }
+  return rv;
+}
+
+nsresult
+nsListBoxBodyFrame::DoInternalPositionChangedSync(bool aUp, int32_t aDelta)
+{
+  nsWeakFrame weak(this);
+  
+  // Process all the pending position changes first
+  nsTArray< RefPtr<nsPositionChangedEvent> > temp;
+  temp.SwapElements(mPendingPositionChangeEvents);
+  for (uint32_t i = 0; i < temp.Length(); ++i) {
+    if (weak.IsAlive()) {
+      temp[i]->Run();
+    }
+    temp[i]->Revoke();
+  }
+
+  if (!weak.IsAlive()) {
+    return NS_OK;
+  }
+
+  return DoInternalPositionChanged(aUp, aDelta);
+}
+
+nsresult
+nsListBoxBodyFrame::DoInternalPositionChanged(bool aUp, int32_t aDelta)
+{
+  if (aDelta == 0)
+    return NS_OK;
+
+  RefPtr<nsPresContext> presContext(PresContext());
+  nsBoxLayoutState state(presContext);
+
+  // begin timing how long it takes to scroll a row
+  PRTime start = PR_Now();
+
+  nsWeakFrame weakThis(this);
+  mContent->GetComposedDoc()->FlushPendingNotifications(Flush_Layout);
+  if (!weakThis.IsAlive()) {
+    return NS_OK;
+  }
+
+  {
+    nsAutoScriptBlocker scriptBlocker;
+
+    int32_t visibleRows = 0;
+    if (mRowHeight)
+      visibleRows = GetAvailableHeight()/mRowHeight;
+  
+    if (aDelta < visibleRows) {
+      int32_t loseRows = aDelta;
+      if (aUp) {
+        // scrolling up, destroy rows from the bottom downwards
+        ReverseDestroyRows(loseRows);
+        mRowsToPrepend += aDelta;
+        mLinkupFrame = nullptr;
+      }
+      else {
+        // scrolling down, destroy rows from the top upwards
+        DestroyRows(loseRows);
+        mRowsToPrepend = 0;
+      }
+    }
+    else {
+      // We have scrolled so much that all of our current frames will
+      // go off screen, so blow them all away. Weeee!
+      nsIFrame *currBox = mFrames.FirstChild();
+      nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor();
+      fc->BeginUpdate();
+      while (currBox) {
+        nsIFrame *nextBox = currBox->GetNextSibling();
+        RemoveChildFrame(state, currBox);
+        currBox = nextBox;
+      }
+      fc->EndUpdate();
+    }
+
+    // clear frame markers so that CreateRows will re-create
+    mTopFrame = mBottomFrame = nullptr; 
+  
+    mYPosition = mCurrentIndex*mRowHeight;
+    mScrolling = true;
+    presContext->PresShell()->
+      FrameNeedsReflow(this, nsIPresShell::eResize, NS_FRAME_HAS_DIRTY_CHILDREN);
+  }
+  if (!weakThis.IsAlive()) {
+    return NS_OK;
+  }
+  // Flush calls CreateRows
+  // XXXbz there has to be a better way to do this than flushing!
+  presContext->PresShell()->FlushPendingNotifications(Flush_Layout);
+  if (!weakThis.IsAlive()) {
+    return NS_OK;
+  }
+
+  mScrolling = false;
+  
+  VerticalScroll(mYPosition);
+
+  PRTime end = PR_Now();
+
+  int32_t newTime = int32_t(end - start) / aDelta;
+
+  // average old and new
+  mTimePerRow = (newTime + mTimePerRow)/2;
+  
+  return NS_OK;
+}
+
+nsListScrollSmoother* 
+nsListBoxBodyFrame::GetSmoother()
+{
+  if (!mScrollSmoother) {
+    mScrollSmoother = new nsListScrollSmoother(this);
+    NS_ASSERTION(mScrollSmoother, "out of memory");
+    NS_IF_ADDREF(mScrollSmoother);
+  }
+
+  return mScrollSmoother;
+}
+
+void
+nsListBoxBodyFrame::VerticalScroll(int32_t aPosition)
+{
+  nsIScrollableFrame* scrollFrame
+    = nsLayoutUtils::GetScrollableFrameFor(this);
+  if (!scrollFrame) {
+    return;
+  }
+
+  nsPoint scrollPosition = scrollFrame->GetScrollPosition();
+ 
+  nsWeakFrame weakFrame(this);
+  scrollFrame->ScrollTo(nsPoint(scrollPosition.x, aPosition),
+                        nsIScrollableFrame::INSTANT);
+  if (!weakFrame.IsAlive()) {
+    return;
+  }
+
+  mYPosition = aPosition;
+}
+
+////////// frame and box retrieval
+
+nsIFrame*
+nsListBoxBodyFrame::GetFirstFrame()
+{
+  mTopFrame = mFrames.FirstChild();
+  return mTopFrame;
+}
+
+nsIFrame*
+nsListBoxBodyFrame::GetLastFrame()
+{
+  return mFrames.LastChild();
+}
+
+bool
+nsListBoxBodyFrame::SupportsOrdinalsInChildren()
+{
+  return false;
+}
+
+////////// lazy row creation and destruction
+
+void
+nsListBoxBodyFrame::CreateRows()
+{
+  // Get our client rect.
+  nsRect clientRect;
+  GetXULClientRect(clientRect);
+
+  // Get the starting y position and the remaining available
+  // height.
+  nscoord availableHeight = GetAvailableHeight();
+  
+  if (availableHeight <= 0) {
+    bool fixed = (GetFixedRowSize() != -1);
+    if (fixed)
+      availableHeight = 10;
+    else
+      return;
+  }
+  
+  // get the first tree box. If there isn't one create one.
+  bool created = false;
+  nsIFrame* box = GetFirstItemBox(0, &created);
+  nscoord rowHeight = GetRowHeightAppUnits();
+  while (box) {  
+    if (created && mRowsToPrepend > 0)
+      --mRowsToPrepend;
+
+    // if the row height is 0 then fail. Wait until someone 
+    // laid out and sets the row height.
+    if (rowHeight == 0)
+        return;
+     
+    availableHeight -= rowHeight;
+    
+    // should we continue? Is the enought height?
+    if (!ContinueReflow(availableHeight))
+      break;
+
+    // get the next tree box. Create one if needed.
+    box = GetNextItemBox(box, 0, &created);
+  }
+
+  mRowsToPrepend = 0;
+  mLinkupFrame = nullptr;
+}
+
+void
+nsListBoxBodyFrame::DestroyRows(int32_t& aRowsToLose) 
+{
+  // We need to destroy frames until our row count has been properly
+  // reduced.  A reflow will then pick up and create the new frames.
+  nsIFrame* childFrame = GetFirstFrame();
+  nsBoxLayoutState state(PresContext());
+
+  nsCSSFrameConstructor* fc = PresContext()->PresShell()->FrameConstructor();
+  fc->BeginUpdate();
+  while (childFrame && aRowsToLose > 0) {
+    --aRowsToLose;
+
+    nsIFrame* nextFrame = childFrame->GetNextSibling();
+    RemoveChildFrame(state, childFrame);
+
+    mTopFrame = childFrame = nextFrame;
+  }
+  fc->EndUpdate();
+
+  PresContext()->PresShell()->
+    FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                     NS_FRAME_HAS_DIRTY_CHILDREN);
+}
+
+void
+nsListBoxBodyFrame::ReverseDestroyRows(int32_t& aRowsToLose) 
+{
+  // We need to destroy frames until our row count has been properly
+  // reduced.  A reflow will then pick up and create the new frames.
+  nsIFrame* childFrame = GetLastFrame();
+  nsBoxLayoutState state(PresContext());
+
+  nsCSSFrameConstructor* fc = PresContext()->PresShell()->FrameConstructor();
+  fc->BeginUpdate();
+  while (childFrame && aRowsToLose > 0) {
+    --aRowsToLose;
+    
+    nsIFrame* prevFrame;
+    prevFrame = childFrame->GetPrevSibling();
+    RemoveChildFrame(state, childFrame);
+
+    mBottomFrame = childFrame = prevFrame;
+  }
+  fc->EndUpdate();
+
+  PresContext()->PresShell()->
+    FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                     NS_FRAME_HAS_DIRTY_CHILDREN);
+}
+
+static bool
+IsListItemChild(nsListBoxBodyFrame* aParent, nsIContent* aChild,
+                nsIFrame** aChildFrame)
+{
+  *aChildFrame = nullptr;
+  if (!aChild->IsXULElement(nsGkAtoms::listitem)) {
+    return false;
+  }
+  nsIFrame* existingFrame = aChild->GetPrimaryFrame();
+  if (existingFrame && existingFrame->GetParent() != aParent) {
+    return false;
+  }
+  *aChildFrame = existingFrame;
+  return true;
+}
+
+//
+// Get the nsIFrame for the first visible listitem, and if none exists,
+// create one.
+//
+nsIFrame*
+nsListBoxBodyFrame::GetFirstItemBox(int32_t aOffset, bool* aCreated)
+{
+  if (aCreated)
+   *aCreated = false;
+
+  // Clear ourselves out.
+  mBottomFrame = mTopFrame;
+
+  if (mTopFrame) {
+    return mTopFrame->IsXULBoxFrame() ? mTopFrame : nullptr;
+  }
+
+  // top frame was cleared out
+  mTopFrame = GetFirstFrame();
+  mBottomFrame = mTopFrame;
+
+  if (mTopFrame && mRowsToPrepend <= 0) {
+    return mTopFrame->IsXULBoxFrame() ? mTopFrame : nullptr;
+  }
+
+  // At this point, we either have no frames at all, 
+  // or the user has scrolled upwards, leaving frames
+  // to be created at the top.  Let's determine which
+  // content needs a new frame first.
+
+  nsCOMPtr<nsIContent> startContent;
+  if (mTopFrame && mRowsToPrepend > 0) {
+    // We need to insert rows before the top frame
+    nsIContent* topContent = mTopFrame->GetContent();
+    nsIContent* topParent = topContent->GetParent();
+    int32_t contentIndex = topParent->IndexOf(topContent);
+    contentIndex -= aOffset;
+    if (contentIndex < 0)
+      return nullptr;
+    startContent = topParent->GetChildAt(contentIndex - mRowsToPrepend);
+  } else {
+    // This will be the first item frame we create.  Use the content
+    // at the current index, which is the first index scrolled into view
+    GetListItemContentAt(mCurrentIndex+aOffset, getter_AddRefs(startContent));
+  }
+
+  if (startContent) {  
+    nsIFrame* existingFrame;
+    if (!IsListItemChild(this, startContent, &existingFrame)) {
+      return GetFirstItemBox(++aOffset, aCreated);
+    }
+    if (existingFrame) {
+      return existingFrame->IsXULBoxFrame() ? existingFrame : nullptr;
+    }
+
+    // Either append the new frame, or prepend it (at index 0)
+    // XXX check here if frame was even created, it may not have been if
+    //     display: none was on listitem content
+    bool isAppend = mRowsToPrepend <= 0;
+    
+    nsPresContext* presContext = PresContext();
+    nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor();
+    nsIFrame* topFrame = nullptr;
+    fc->CreateListBoxContent(this, nullptr, startContent, &topFrame, isAppend);
+    mTopFrame = topFrame;
+    if (mTopFrame) {
+      if (aCreated)
+        *aCreated = true;
+
+      mBottomFrame = mTopFrame;
+
+      return mTopFrame->IsXULBoxFrame() ? mTopFrame : nullptr;
+    } else
+      return GetFirstItemBox(++aOffset, 0);
+  }
+
+  return nullptr;
+}
+
+//
+// Get the nsIFrame for the next visible listitem after aBox, and if none
+// exists, create one.
+//
+nsIFrame*
+nsListBoxBodyFrame::GetNextItemBox(nsIFrame* aBox, int32_t aOffset,
+                                   bool* aCreated)
+{
+  if (aCreated)
+    *aCreated = false;
+
+  nsIFrame* result = aBox->GetNextSibling();
+
+  if (!result || result == mLinkupFrame || mRowsToPrepend > 0) {
+    // No result found. See if there's a content node that wants a frame.
+    nsIContent* prevContent = aBox->GetContent();
+    nsIContent* parentContent = prevContent->GetParent();
+
+    int32_t i = parentContent->IndexOf(prevContent);
+
+    uint32_t childCount = parentContent->GetChildCount();
+    if (((uint32_t)i + aOffset + 1) < childCount) {
+      // There is a content node that wants a frame.
+      nsIContent *nextContent = parentContent->GetChildAt(i + aOffset + 1);
+
+      nsIFrame* existingFrame;
+      if (!IsListItemChild(this, nextContent, &existingFrame)) {
+        return GetNextItemBox(aBox, ++aOffset, aCreated);
+      }
+      if (!existingFrame) {
+        // Either append the new frame, or insert it after the current frame
+        bool isAppend = result != mLinkupFrame && mRowsToPrepend <= 0;
+        nsIFrame* prevFrame = isAppend ? nullptr : aBox;
+      
+        nsPresContext* presContext = PresContext();
+        nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor();
+        fc->CreateListBoxContent(this, prevFrame, nextContent,
+                                 &result, isAppend);
+
+        if (result) {
+          if (aCreated)
+            *aCreated = true;
+        } else
+          return GetNextItemBox(aBox, ++aOffset, aCreated);
+      } else {
+        result = existingFrame;
+      }
+            
+      mLinkupFrame = nullptr;
+    }
+  }
+
+  if (!result)
+    return nullptr;
+
+  mBottomFrame = result;
+
+  NS_ASSERTION(!result->IsXULBoxFrame() || result->GetParent() == this,
+               "returning frame that is not in childlist");
+
+  return result->IsXULBoxFrame() ? result : nullptr;
+}
+
+bool
+nsListBoxBodyFrame::ContinueReflow(nscoord height) 
+{
+#ifdef ACCESSIBILITY
+  if (nsIPresShell::IsAccessibilityActive()) {
+    // Create all the frames at once so screen readers and
+    // onscreen keyboards can see the full list right away
+    return true;
+  }
+#endif
+
+  if (height <= 0) {
+    nsIFrame* lastChild = GetLastFrame();
+    nsIFrame* startingPoint = mBottomFrame;
+    if (startingPoint == nullptr) {
+      // We just want to delete everything but the first item.
+      startingPoint = GetFirstFrame();
+    }
+
+    if (lastChild != startingPoint) {
+      // We have some hangers on (probably caused by shrinking the size of the window).
+      // Nuke them.
+      nsIFrame* currFrame = startingPoint->GetNextSibling();
+      nsBoxLayoutState state(PresContext());
+
+      nsCSSFrameConstructor* fc =
+        PresContext()->PresShell()->FrameConstructor();
+      fc->BeginUpdate();
+      while (currFrame) {
+        nsIFrame* nextFrame = currFrame->GetNextSibling();
+        RemoveChildFrame(state, currFrame);
+        currFrame = nextFrame;
+      }
+      fc->EndUpdate();
+
+      PresContext()->PresShell()->
+        FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                         NS_FRAME_HAS_DIRTY_CHILDREN);
+    }
+    return false;
+  }
+  else
+    return true;
+}
+
+NS_IMETHODIMP
+nsListBoxBodyFrame::ListBoxAppendFrames(nsFrameList& aFrameList)
+{
+  // append them after
+  nsBoxLayoutState state(PresContext());
+  const nsFrameList::Slice& newFrames = mFrames.AppendFrames(nullptr, aFrameList);
+  if (mLayoutManager)
+    mLayoutManager->ChildrenAppended(this, state, newFrames);
+  PresContext()->PresShell()->
+    FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                     NS_FRAME_HAS_DIRTY_CHILDREN);
+  
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsListBoxBodyFrame::ListBoxInsertFrames(nsIFrame* aPrevFrame,
+                                        nsFrameList& aFrameList)
+{
+  // insert the frames to our info list
+  nsBoxLayoutState state(PresContext());
+  const nsFrameList::Slice& newFrames =
+    mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
+  if (mLayoutManager)
+    mLayoutManager->ChildrenInserted(this, state, aPrevFrame, newFrames);
+  PresContext()->PresShell()->
+    FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                     NS_FRAME_HAS_DIRTY_CHILDREN);
+
+  return NS_OK;
+}
+
+// 
+// Called by nsCSSFrameConstructor when a new listitem content is inserted.
+//
+void
+nsListBoxBodyFrame::OnContentInserted(nsIContent* aChildContent)
+{
+  if (mRowCount >= 0)
+    ++mRowCount;
+
+  // The RDF content builder will build content nodes such that they are all 
+  // ready when OnContentInserted is first called, meaning the first call
+  // to CreateRows will create all the frames, but OnContentInserted will
+  // still be called again for each content node - so we need to make sure
+  // that the frame for each content node hasn't already been created.
+  nsIFrame* childFrame = aChildContent->GetPrimaryFrame();
+  if (childFrame)
+    return;
+
+  int32_t siblingIndex;
+  nsCOMPtr<nsIContent> nextSiblingContent;
+  GetListItemNextSibling(aChildContent, getter_AddRefs(nextSiblingContent), siblingIndex);
+  
+  // if we're inserting our item before the first visible content,
+  // then we need to shift all rows down by one
+  if (siblingIndex >= 0 &&  siblingIndex-1 <= mCurrentIndex) {
+    mTopFrame = nullptr;
+    mRowsToPrepend = 1;
+  } else if (nextSiblingContent) {
+    // we may be inserting before a frame that is on screen
+    nsIFrame* nextSiblingFrame = nextSiblingContent->GetPrimaryFrame();
+    mLinkupFrame = nextSiblingFrame;
+  }
+  
+  CreateRows();
+  PresContext()->PresShell()->
+    FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                     NS_FRAME_HAS_DIRTY_CHILDREN);
+}
+
+// 
+// Called by nsCSSFrameConstructor when listitem content is removed.
+//
+void
+nsListBoxBodyFrame::OnContentRemoved(nsPresContext* aPresContext,
+                                     nsIContent* aContainer,
+                                     nsIFrame* aChildFrame,
+                                     nsIContent* aOldNextSibling)
+{
+  NS_ASSERTION(!aChildFrame || aChildFrame->GetParent() == this,
+               "Removing frame that's not our child... Not good");
+  
+  if (mRowCount >= 0)
+    --mRowCount;
+
+  if (aContainer) {
+    if (!aChildFrame) {
+      // The row we are removing is out of view, so we need to try to
+      // determine the index of its next sibling.
+      int32_t siblingIndex = -1;
+      if (aOldNextSibling) {
+        nsCOMPtr<nsIContent> nextSiblingContent;
+        GetListItemNextSibling(aOldNextSibling,
+                               getter_AddRefs(nextSiblingContent),
+                               siblingIndex);
+      }
+    
+      // if the row being removed is off-screen and above the top frame, we need to
+      // adjust our top index and tell the scrollbar to shift up one row.
+      if (siblingIndex >= 0 && siblingIndex-1 < mCurrentIndex) {
+        NS_PRECONDITION(mCurrentIndex > 0, "mCurrentIndex > 0");
+        --mCurrentIndex;
+        mYPosition = mCurrentIndex*mRowHeight;
+        nsWeakFrame weakChildFrame(aChildFrame);
+        VerticalScroll(mYPosition);
+        if (!weakChildFrame.IsAlive()) {
+          return;
+        }
+      }
+    } else if (mCurrentIndex > 0) {
+      // At this point, we know we have a scrollbar, and we need to know 
+      // if we are scrolled to the last row.  In this case, the behavior
+      // of the scrollbar is to stay locked to the bottom.  Since we are
+      // removing visible content, the first visible row will have to move
+      // down by one, and we will have to insert a new frame at the top.
+
+      // if the last content node has a frame, we are scrolled to the bottom
+      nsIContent* lastChild = nullptr;
+      FlattenedChildIterator iter(mContent);
+      for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
+        lastChild = child;
+      }
+
+      if (lastChild) {
+        nsIFrame* lastChildFrame = lastChild->GetPrimaryFrame();
+
+        if (lastChildFrame) {
+          mTopFrame = nullptr;
+          mRowsToPrepend = 1;
+          --mCurrentIndex;
+          mYPosition = mCurrentIndex*mRowHeight;
+          nsWeakFrame weakChildFrame(aChildFrame);
+          VerticalScroll(mYPosition);
+          if (!weakChildFrame.IsAlive()) {
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  // if we're removing the top row, the new top row is the next row
+  if (mTopFrame && mTopFrame == aChildFrame)
+    mTopFrame = mTopFrame->GetNextSibling();
+
+  // Go ahead and delete the frame.
+  nsBoxLayoutState state(aPresContext);
+  if (aChildFrame) {
+    RemoveChildFrame(state, aChildFrame);
+  }
+
+  PresContext()->PresShell()->
+    FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                     NS_FRAME_HAS_DIRTY_CHILDREN);
+}
+
+void
+nsListBoxBodyFrame::GetListItemContentAt(int32_t aIndex, nsIContent** aContent)
+{
+  *aContent = nullptr;
+
+  int32_t itemsFound = 0;
+  FlattenedChildIterator iter(mContent);
+  for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
+    if (child->IsXULElement(nsGkAtoms::listitem)) {
+      ++itemsFound;
+      if (itemsFound-1 == aIndex) {
+        *aContent = child;
+        NS_IF_ADDREF(*aContent);
+        return;
+      }
+    }
+  }
+}
+
+void
+nsListBoxBodyFrame::GetListItemNextSibling(nsIContent* aListItem, nsIContent** aContent, int32_t& aSiblingIndex)
+{
+  *aContent = nullptr;
+  aSiblingIndex = -1;
+  nsIContent *prevKid = nullptr;
+  FlattenedChildIterator iter(mContent);
+  for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
+    if (child->IsXULElement(nsGkAtoms::listitem)) {
+      ++aSiblingIndex;
+      if (prevKid == aListItem) {
+        *aContent = child;
+        NS_IF_ADDREF(*aContent);
+        return;
+      }
+    }
+    prevKid = child;
+  }
+
+  aSiblingIndex = -1; // no match, so there is no next sibling
+}
+
+void
+nsListBoxBodyFrame::RemoveChildFrame(nsBoxLayoutState &aState,
+                                     nsIFrame         *aFrame)
+{
+  MOZ_ASSERT(mFrames.ContainsFrame(aFrame));
+  MOZ_ASSERT(aFrame != GetContentInsertionFrame());
+
+#ifdef ACCESSIBILITY
+  nsAccessibilityService* accService = nsIPresShell::AccService();
+  if (accService) {
+    nsIContent* content = aFrame->GetContent();
+    accService->ContentRemoved(PresContext()->PresShell(), content);
+  }
+#endif
+
+  mFrames.RemoveFrame(aFrame);
+  if (mLayoutManager)
+    mLayoutManager->ChildrenRemoved(this, aState, aFrame);
+  aFrame->Destroy();
+}
+
+// Creation Routines ///////////////////////////////////////////////////////////////////////
+
+already_AddRefed<nsBoxLayout> NS_NewListBoxLayout();
+
+nsIFrame*
+NS_NewListBoxBodyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  nsCOMPtr<nsBoxLayout> layout = NS_NewListBoxLayout();
+  return new (aPresShell) nsListBoxBodyFrame(aContext, layout);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsListBoxBodyFrame)