Add m-esr52 at 52.6.0

1 files changed, 2111 insertions, 0 deletions

diff --git a/layout/xul/nsBoxFrame.cpp b/layout/xul/nsBoxFrame.cpp
new file mode 100644
index 000000000..9ca351d94
--- /dev/null
+++ b/layout/xul/nsBoxFrame.cpp
@@ -0,0 +1,2111 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//
+// Eric Vaughan
+// Netscape Communications
+//
+// See documentation in associated header file
+//
+
+// How boxes layout
+// ----------------
+// Boxes layout a bit differently than html. html does a bottom up layout. Where boxes do a top down.
+// 1) First thing a box does it goes out and askes each child for its min, max, and preferred sizes.
+// 2) It then adds them up to determine its size.
+// 3) If the box was asked to layout it self intrinically it will layout its children at their preferred size
+//    otherwise it will layout the child at the size it was told to. It will squeeze or stretch its children if 
+//    Necessary.
+//
+// However there is a catch. Some html components like block frames can not determine their preferred size. 
+// this is their size if they were laid out intrinsically. So the box will flow the child to determine this can
+// cache the value.
+
+// Boxes and Incremental Reflow
+// ----------------------------
+// Boxes layout out top down by adding up their children's min, max, and preferred sizes. Only problem is if a incremental
+// reflow occurs. The preferred size of a child deep in the hierarchy could change. And this could change
+// any number of syblings around the box. Basically any children in the reflow chain must have their caches cleared
+// so when asked for there current size they can relayout themselves. 
+
+#include "nsBoxFrame.h"
+
+#include "gfxUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "nsBoxLayoutState.h"
+#include "mozilla/dom/Touch.h"
+#include "mozilla/Move.h"
+#include "nsStyleContext.h"
+#include "nsPlaceholderFrame.h"
+#include "nsPresContext.h"
+#include "nsCOMPtr.h"
+#include "nsNameSpaceManager.h"
+#include "nsGkAtoms.h"
+#include "nsIContent.h"
+#include "nsHTMLParts.h"
+#include "nsViewManager.h"
+#include "nsView.h"
+#include "nsIPresShell.h"
+#include "nsCSSRendering.h"
+#include "nsIServiceManager.h"
+#include "nsBoxLayout.h"
+#include "nsSprocketLayout.h"
+#include "nsIScrollableFrame.h"
+#include "nsWidgetsCID.h"
+#include "nsCSSAnonBoxes.h"
+#include "nsContainerFrame.h"
+#include "nsIDOMElement.h"
+#include "nsITheme.h"
+#include "nsTransform2D.h"
+#include "mozilla/EventStateManager.h"
+#include "nsIDOMEvent.h"
+#include "nsDisplayList.h"
+#include "mozilla/Preferences.h"
+#include "nsThemeConstants.h"
+#include "nsLayoutUtils.h"
+#include "nsSliderFrame.h"
+#include <algorithm>
+
+// Needed for Print Preview
+#include "nsIURI.h"
+
+#include "mozilla/TouchEvents.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+
+//define DEBUG_REDRAW
+
+#define DEBUG_SPRING_SIZE 8
+#define DEBUG_BORDER_SIZE 2
+#define COIL_SIZE 8
+
+//#define TEST_SANITY
+
+#ifdef DEBUG_rods
+//#define DO_NOISY_REFLOW
+#endif
+
+#ifdef DEBUG_LAYOUT
+bool nsBoxFrame::gDebug = false;
+nsIFrame* nsBoxFrame::mDebugChild = nullptr;
+#endif
+
+nsIFrame*
+NS_NewBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext, bool aIsRoot, nsBoxLayout* aLayoutManager)
+{
+  return new (aPresShell) nsBoxFrame(aContext, aIsRoot, aLayoutManager);
+}
+
+nsIFrame*
+NS_NewBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsBoxFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsBoxFrame)
+
+#ifdef DEBUG
+NS_QUERYFRAME_HEAD(nsBoxFrame)
+  NS_QUERYFRAME_ENTRY(nsBoxFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+#endif
+
+nsBoxFrame::nsBoxFrame(nsStyleContext* aContext,
+                       bool aIsRoot,
+                       nsBoxLayout* aLayoutManager) :
+  nsContainerFrame(aContext)
+{
+  mState |= NS_STATE_IS_HORIZONTAL;
+  mState |= NS_STATE_AUTO_STRETCH;
+
+  if (aIsRoot) 
+     mState |= NS_STATE_IS_ROOT;
+
+  mValign = vAlign_Top;
+  mHalign = hAlign_Left;
+  
+  // if no layout manager specified us the static sprocket layout
+  nsCOMPtr<nsBoxLayout> layout = aLayoutManager;
+
+  if (layout == nullptr) {
+    NS_NewSprocketLayout(layout);
+  }
+
+  SetXULLayoutManager(layout);
+}
+
+nsBoxFrame::~nsBoxFrame()
+{
+}
+
+void
+nsBoxFrame::SetInitialChildList(ChildListID     aListID,
+                                nsFrameList&    aChildList)
+{
+  nsContainerFrame::SetInitialChildList(aListID, aChildList);
+  if (aListID == kPrincipalList) {
+    // initialize our list of infos.
+    nsBoxLayoutState state(PresContext());
+    CheckBoxOrder();
+    if (mLayoutManager)
+      mLayoutManager->ChildrenSet(this, state, mFrames.FirstChild());
+  }
+}
+
+/* virtual */ void
+nsBoxFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
+{
+  nsContainerFrame::DidSetStyleContext(aOldStyleContext);
+
+  // The values that CacheAttributes() computes depend on our style,
+  // so we need to recompute them here...
+  CacheAttributes();
+}
+
+/**
+ * Initialize us. This is a good time to get the alignment of the box
+ */
+void
+nsBoxFrame::Init(nsIContent*       aContent,
+                 nsContainerFrame* aParent,
+                 nsIFrame*         aPrevInFlow)
+{
+  nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+
+  if (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER) {
+    AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
+  }
+
+  MarkIntrinsicISizesDirty();
+
+  CacheAttributes();
+
+#ifdef DEBUG_LAYOUT
+    // if we are root and this
+  if (mState & NS_STATE_IS_ROOT) {
+    GetDebugPref();
+  }
+#endif
+
+  UpdateMouseThrough();
+
+  // register access key
+  RegUnregAccessKey(true);
+}
+
+void nsBoxFrame::UpdateMouseThrough()
+{
+  if (mContent) {
+    static nsIContent::AttrValuesArray strings[] =
+      {&nsGkAtoms::never, &nsGkAtoms::always, nullptr};
+    switch (mContent->FindAttrValueIn(kNameSpaceID_None,
+              nsGkAtoms::mousethrough, strings, eCaseMatters)) {
+      case 0: AddStateBits(NS_FRAME_MOUSE_THROUGH_NEVER); break;
+      case 1: AddStateBits(NS_FRAME_MOUSE_THROUGH_ALWAYS); break;
+      case 2: {
+        RemoveStateBits(NS_FRAME_MOUSE_THROUGH_ALWAYS);
+        RemoveStateBits(NS_FRAME_MOUSE_THROUGH_NEVER);
+        break;
+      }
+    }
+  }
+}
+
+void
+nsBoxFrame::CacheAttributes()
+{
+  /*
+  printf("Caching: ");
+  XULDumpBox(stdout);
+  printf("\n");
+   */
+
+  mValign = vAlign_Top;
+  mHalign = hAlign_Left;
+
+  bool orient = false;
+  GetInitialOrientation(orient); 
+  if (orient)
+    mState |= NS_STATE_IS_HORIZONTAL;
+  else
+    mState &= ~NS_STATE_IS_HORIZONTAL;
+
+  bool normal = true;
+  GetInitialDirection(normal); 
+  if (normal)
+    mState |= NS_STATE_IS_DIRECTION_NORMAL;
+  else
+    mState &= ~NS_STATE_IS_DIRECTION_NORMAL;
+
+  GetInitialVAlignment(mValign);
+  GetInitialHAlignment(mHalign);
+  
+  bool equalSize = false;
+  GetInitialEqualSize(equalSize); 
+  if (equalSize)
+        mState |= NS_STATE_EQUAL_SIZE;
+    else
+        mState &= ~NS_STATE_EQUAL_SIZE;
+
+  bool autostretch = !!(mState & NS_STATE_AUTO_STRETCH);
+  GetInitialAutoStretch(autostretch);
+  if (autostretch)
+        mState |= NS_STATE_AUTO_STRETCH;
+     else
+        mState &= ~NS_STATE_AUTO_STRETCH;
+
+
+#ifdef DEBUG_LAYOUT
+  bool debug = mState & NS_STATE_SET_TO_DEBUG;
+  bool debugSet = GetInitialDebug(debug); 
+  if (debugSet) {
+        mState |= NS_STATE_DEBUG_WAS_SET;
+        if (debug)
+            mState |= NS_STATE_SET_TO_DEBUG;
+        else
+            mState &= ~NS_STATE_SET_TO_DEBUG;
+  } else {
+        mState &= ~NS_STATE_DEBUG_WAS_SET;
+  }
+#endif
+}
+
+#ifdef DEBUG_LAYOUT
+bool
+nsBoxFrame::GetInitialDebug(bool& aDebug)
+{
+  if (!GetContent())
+    return false;
+
+  static nsIContent::AttrValuesArray strings[] =
+    {&nsGkAtoms::_false, &nsGkAtoms::_true, nullptr};
+  int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None,
+      nsGkAtoms::debug, strings, eCaseMatters);
+  if (index >= 0) {
+    aDebug = index == 1;
+    return true;
+  }
+
+  return false;
+}
+#endif
+
+bool
+nsBoxFrame::GetInitialHAlignment(nsBoxFrame::Halignment& aHalign)
+{
+  if (!GetContent())
+    return false;
+
+  // XXXdwh Everything inside this if statement is deprecated code.
+  static nsIContent::AttrValuesArray alignStrings[] =
+    {&nsGkAtoms::left, &nsGkAtoms::right, nullptr};
+  static const Halignment alignValues[] = {hAlign_Left, hAlign_Right};
+  int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::align,
+      alignStrings, eCaseMatters);
+  if (index >= 0) {
+    aHalign = alignValues[index];
+    return true;
+  }
+      
+  // Now that the deprecated stuff is out of the way, we move on to check the appropriate 
+  // attribute.  For horizontal boxes, we are checking the PACK attribute.  For vertical boxes
+  // we are checking the ALIGN attribute.
+  nsIAtom* attrName = IsXULHorizontal() ? nsGkAtoms::pack : nsGkAtoms::align;
+  static nsIContent::AttrValuesArray strings[] =
+    {&nsGkAtoms::_empty, &nsGkAtoms::start, &nsGkAtoms::center, &nsGkAtoms::end, nullptr};
+  static const Halignment values[] =
+    {hAlign_Left/*not used*/, hAlign_Left, hAlign_Center, hAlign_Right};
+  index = GetContent()->FindAttrValueIn(kNameSpaceID_None, attrName,
+      strings, eCaseMatters);
+
+  if (index == nsIContent::ATTR_VALUE_NO_MATCH) {
+    // The attr was present but had a nonsensical value. Revert to the default.
+    return false;
+  }
+  if (index > 0) {    
+    aHalign = values[index];
+    return true;
+  }
+
+  // Now that we've checked for the attribute it's time to check CSS.  For 
+  // horizontal boxes we're checking PACK.  For vertical boxes we are checking
+  // ALIGN.
+  const nsStyleXUL* boxInfo = StyleXUL();
+  if (IsXULHorizontal()) {
+    switch (boxInfo->mBoxPack) {
+      case StyleBoxPack::Start:
+        aHalign = nsBoxFrame::hAlign_Left;
+        return true;
+      case StyleBoxPack::Center:
+        aHalign = nsBoxFrame::hAlign_Center;
+        return true;
+      case StyleBoxPack::End:
+        aHalign = nsBoxFrame::hAlign_Right;
+        return true;
+      default: // Nonsensical value. Just bail.
+        return false;
+    }
+  }
+  else {
+    switch (boxInfo->mBoxAlign) {
+      case StyleBoxAlign::Start:
+        aHalign = nsBoxFrame::hAlign_Left;
+        return true;
+      case StyleBoxAlign::Center:
+        aHalign = nsBoxFrame::hAlign_Center;
+        return true;
+      case StyleBoxAlign::End:
+        aHalign = nsBoxFrame::hAlign_Right;
+        return true;
+      default: // Nonsensical value. Just bail.
+        return false;
+    }
+  }
+
+  return false;
+}
+
+bool
+nsBoxFrame::GetInitialVAlignment(nsBoxFrame::Valignment& aValign)
+{
+  if (!GetContent())
+    return false;
+
+  static nsIContent::AttrValuesArray valignStrings[] =
+    {&nsGkAtoms::top, &nsGkAtoms::baseline, &nsGkAtoms::middle, &nsGkAtoms::bottom, nullptr};
+  static const Valignment valignValues[] =
+    {vAlign_Top, vAlign_BaseLine, vAlign_Middle, vAlign_Bottom};
+  int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::valign,
+      valignStrings, eCaseMatters);
+  if (index >= 0) {
+    aValign = valignValues[index];
+    return true;
+  }
+
+  // Now that the deprecated stuff is out of the way, we move on to check the appropriate 
+  // attribute.  For horizontal boxes, we are checking the ALIGN attribute.  For vertical boxes
+  // we are checking the PACK attribute.
+  nsIAtom* attrName = IsXULHorizontal() ? nsGkAtoms::align : nsGkAtoms::pack;
+  static nsIContent::AttrValuesArray strings[] =
+    {&nsGkAtoms::_empty, &nsGkAtoms::start, &nsGkAtoms::center,
+     &nsGkAtoms::baseline, &nsGkAtoms::end, nullptr};
+  static const Valignment values[] =
+    {vAlign_Top/*not used*/, vAlign_Top, vAlign_Middle, vAlign_BaseLine, vAlign_Bottom};
+  index = GetContent()->FindAttrValueIn(kNameSpaceID_None, attrName,
+      strings, eCaseMatters);
+  if (index == nsIContent::ATTR_VALUE_NO_MATCH) {
+    // The attr was present but had a nonsensical value. Revert to the default.
+    return false;
+  }
+  if (index > 0) {
+    aValign = values[index];
+    return true;
+  }
+
+  // Now that we've checked for the attribute it's time to check CSS.  For 
+  // horizontal boxes we're checking ALIGN.  For vertical boxes we are checking
+  // PACK.
+  const nsStyleXUL* boxInfo = StyleXUL();
+  if (IsXULHorizontal()) {
+    switch (boxInfo->mBoxAlign) {
+      case StyleBoxAlign::Start:
+        aValign = nsBoxFrame::vAlign_Top;
+        return true;
+      case StyleBoxAlign::Center:
+        aValign = nsBoxFrame::vAlign_Middle;
+        return true;
+      case StyleBoxAlign::Baseline:
+        aValign = nsBoxFrame::vAlign_BaseLine;
+        return true;
+      case StyleBoxAlign::End:
+        aValign = nsBoxFrame::vAlign_Bottom;
+        return true;
+      default: // Nonsensical value. Just bail.
+        return false;
+    }
+  }
+  else {
+    switch (boxInfo->mBoxPack) {
+      case StyleBoxPack::Start:
+        aValign = nsBoxFrame::vAlign_Top;
+        return true;
+      case StyleBoxPack::Center:
+        aValign = nsBoxFrame::vAlign_Middle;
+        return true;
+      case StyleBoxPack::End:
+        aValign = nsBoxFrame::vAlign_Bottom;
+        return true;
+      default: // Nonsensical value. Just bail.
+        return false;
+    }
+  }
+
+  return false;
+}
+
+void
+nsBoxFrame::GetInitialOrientation(bool& aIsHorizontal)
+{
+ // see if we are a vertical or horizontal box.
+  if (!GetContent())
+    return;
+
+  // Check the style system first.
+  const nsStyleXUL* boxInfo = StyleXUL();
+  if (boxInfo->mBoxOrient == StyleBoxOrient::Horizontal) {
+    aIsHorizontal = true;
+  } else {
+    aIsHorizontal = false;
+  }
+
+  // Now see if we have an attribute.  The attribute overrides
+  // the style system value.
+  static nsIContent::AttrValuesArray strings[] =
+    {&nsGkAtoms::vertical, &nsGkAtoms::horizontal, nullptr};
+  int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::orient,
+      strings, eCaseMatters);
+  if (index >= 0) {
+    aIsHorizontal = index == 1;
+  }
+}
+
+void
+nsBoxFrame::GetInitialDirection(bool& aIsNormal)
+{
+  if (!GetContent())
+    return;
+
+  if (IsXULHorizontal()) {
+    // For horizontal boxes only, we initialize our value based off the CSS 'direction' property.
+    // This means that BiDI users will end up with horizontally inverted chrome.
+    aIsNormal = (StyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR); // If text runs RTL then so do we.
+  }
+  else
+    aIsNormal = true; // Assume a normal direction in the vertical case.
+
+  // Now check the style system to see if we should invert aIsNormal.
+  const nsStyleXUL* boxInfo = StyleXUL();
+  if (boxInfo->mBoxDirection == StyleBoxDirection::Reverse) {
+    aIsNormal = !aIsNormal; // Invert our direction.
+  }
+
+  // Now see if we have an attribute.  The attribute overrides
+  // the style system value.
+  if (IsXULHorizontal()) {
+    static nsIContent::AttrValuesArray strings[] =
+      {&nsGkAtoms::reverse, &nsGkAtoms::ltr, &nsGkAtoms::rtl, nullptr};
+    int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::dir,
+        strings, eCaseMatters);
+    if (index >= 0) {
+      bool values[] = {!aIsNormal, true, false};
+      aIsNormal = values[index];
+    }
+  } else if (GetContent()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
+                                       nsGkAtoms::reverse, eCaseMatters)) {
+    aIsNormal = !aIsNormal;
+  }
+}
+
+/* Returns true if it was set.
+ */
+bool
+nsBoxFrame::GetInitialEqualSize(bool& aEqualSize)
+{
+ // see if we are a vertical or horizontal box.
+  if (!GetContent())
+     return false;
+
+  if (GetContent()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::equalsize,
+                           nsGkAtoms::always, eCaseMatters)) {
+    aEqualSize = true;
+    return true;
+  }
+
+  return false;
+}
+
+/* Returns true if it was set.
+ */
+bool
+nsBoxFrame::GetInitialAutoStretch(bool& aStretch)
+{
+  if (!GetContent())
+     return false;
+  
+  // Check the align attribute.
+  static nsIContent::AttrValuesArray strings[] =
+    {&nsGkAtoms::_empty, &nsGkAtoms::stretch, nullptr};
+  int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::align,
+      strings, eCaseMatters);
+  if (index != nsIContent::ATTR_MISSING && index != 0) {
+    aStretch = index == 1;
+    return true;
+  }
+
+  // Check the CSS box-align property.
+  const nsStyleXUL* boxInfo = StyleXUL();
+  aStretch = (boxInfo->mBoxAlign == StyleBoxAlign::Stretch);
+
+  return true;
+}
+
+void
+nsBoxFrame::DidReflow(nsPresContext*           aPresContext,
+                      const ReflowInput*  aReflowInput,
+                      nsDidReflowStatus         aStatus)
+{
+  nsFrameState preserveBits =
+    mState & (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN);
+  nsFrame::DidReflow(aPresContext, aReflowInput, aStatus);
+  mState |= preserveBits;
+}
+
+bool
+nsBoxFrame::HonorPrintBackgroundSettings()
+{
+  return (!mContent || !mContent->IsInNativeAnonymousSubtree()) &&
+    nsContainerFrame::HonorPrintBackgroundSettings();
+}
+
+#ifdef DO_NOISY_REFLOW
+static int myCounter = 0;
+static void printSize(char * aDesc, nscoord aSize) 
+{
+  printf(" %s: ", aDesc);
+  if (aSize == NS_UNCONSTRAINEDSIZE) {
+    printf("UC");
+  } else {
+    printf("%d", aSize);
+  }
+}
+#endif
+
+/* virtual */ nscoord
+nsBoxFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+{
+  nscoord result;
+  DISPLAY_MIN_WIDTH(this, result);
+
+  nsBoxLayoutState state(PresContext(), aRenderingContext);
+  nsSize minSize = GetXULMinSize(state);
+
+  // GetXULMinSize returns border-box width, and we want to return content
+  // width.  Since Reflow uses the reflow state's border and padding, we
+  // actually just want to subtract what GetXULMinSize added, which is the
+  // result of GetXULBorderAndPadding.
+  nsMargin bp;
+  GetXULBorderAndPadding(bp);
+
+  result = minSize.width - bp.LeftRight();
+  result = std::max(result, 0);
+
+  return result;
+}
+
+/* virtual */ nscoord
+nsBoxFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+{
+  nscoord result;
+  DISPLAY_PREF_WIDTH(this, result);
+
+  nsBoxLayoutState state(PresContext(), aRenderingContext);
+  nsSize prefSize = GetXULPrefSize(state);
+
+  // GetXULPrefSize returns border-box width, and we want to return content
+  // width.  Since Reflow uses the reflow state's border and padding, we
+  // actually just want to subtract what GetXULPrefSize added, which is the
+  // result of GetXULBorderAndPadding.
+  nsMargin bp;
+  GetXULBorderAndPadding(bp);
+
+  result = prefSize.width - bp.LeftRight();
+  result = std::max(result, 0);
+
+  return result;
+}
+
+void
+nsBoxFrame::Reflow(nsPresContext*          aPresContext,
+                   ReflowOutput&     aDesiredSize,
+                   const ReflowInput& aReflowInput,
+                   nsReflowStatus&          aStatus)
+{
+  MarkInReflow();
+  // If you make changes to this method, please keep nsLeafBoxFrame::Reflow
+  // in sync, if the changes are applicable there.
+
+  DO_GLOBAL_REFLOW_COUNT("nsBoxFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+
+  NS_ASSERTION(aReflowInput.ComputedWidth() >=0 &&
+               aReflowInput.ComputedHeight() >= 0, "Computed Size < 0");
+
+#ifdef DO_NOISY_REFLOW
+  printf("\n-------------Starting BoxFrame Reflow ----------------------------\n");
+  printf("%p ** nsBF::Reflow %d ", this, myCounter++);
+  
+  printSize("AW", aReflowInput.AvailableWidth());
+  printSize("AH", aReflowInput.AvailableHeight());
+  printSize("CW", aReflowInput.ComputedWidth());
+  printSize("CH", aReflowInput.ComputedHeight());
+
+  printf(" *\n");
+
+#endif
+
+  aStatus = NS_FRAME_COMPLETE;
+
+  // create the layout state
+  nsBoxLayoutState state(aPresContext, aReflowInput.mRenderingContext,
+                         &aReflowInput, aReflowInput.mReflowDepth);
+
+  WritingMode wm = aReflowInput.GetWritingMode();
+  LogicalSize computedSize(wm, aReflowInput.ComputedISize(),
+                           aReflowInput.ComputedBSize());
+
+  LogicalMargin m = aReflowInput.ComputedLogicalBorderPadding();
+  // GetXULBorderAndPadding(m);
+
+  LogicalSize prefSize(wm);
+
+  // if we are told to layout intrinsic then get our preferred size.
+  NS_ASSERTION(computedSize.ISize(wm) != NS_INTRINSICSIZE,
+               "computed inline size should always be computed");
+  if (computedSize.BSize(wm) == NS_INTRINSICSIZE) {
+    nsSize physicalPrefSize = GetXULPrefSize(state);
+    nsSize minSize = GetXULMinSize(state);
+    nsSize maxSize = GetXULMaxSize(state);
+    // XXXbz isn't GetXULPrefSize supposed to bounds-check for us?
+    physicalPrefSize = BoundsCheck(minSize, physicalPrefSize, maxSize);
+    prefSize = LogicalSize(wm, physicalPrefSize);
+  }
+
+  // get our desiredSize
+  computedSize.ISize(wm) += m.IStart(wm) + m.IEnd(wm);
+
+  if (aReflowInput.ComputedBSize() == NS_INTRINSICSIZE) {
+    computedSize.BSize(wm) = prefSize.BSize(wm);
+    // prefSize is border-box but min/max constraints are content-box.
+    nscoord blockDirBorderPadding =
+      aReflowInput.ComputedLogicalBorderPadding().BStartEnd(wm);
+    nscoord contentBSize = computedSize.BSize(wm) - blockDirBorderPadding;
+    // Note: contentHeight might be negative, but that's OK because min-height
+    // is never negative.
+    computedSize.BSize(wm) = aReflowInput.ApplyMinMaxHeight(contentBSize) +
+                             blockDirBorderPadding;
+  } else {
+    computedSize.BSize(wm) += m.BStart(wm) + m.BEnd(wm);
+  }
+
+  nsSize physicalSize = computedSize.GetPhysicalSize(wm);
+  nsRect r(mRect.x, mRect.y, physicalSize.width, physicalSize.height);
+
+  SetXULBounds(state, r);
+ 
+  // layout our children
+  XULLayout(state);
+  
+  // ok our child could have gotten bigger. So lets get its bounds
+  
+  // get the ascent
+  LogicalSize boxSize = GetLogicalSize(wm);
+  nscoord ascent = boxSize.BSize(wm);
+
+  // getting the ascent could be a lot of work. Don't get it if
+  // we are the root. The viewport doesn't care about it.
+  if (!(mState & NS_STATE_IS_ROOT)) {
+    ascent = GetXULBoxAscent(state);
+  }
+
+  aDesiredSize.SetSize(wm, boxSize);
+  aDesiredSize.SetBlockStartAscent(ascent);
+
+  aDesiredSize.mOverflowAreas = GetOverflowAreas();
+
+#ifdef DO_NOISY_REFLOW
+  {
+    printf("%p ** nsBF(done) W:%d H:%d  ", this, aDesiredSize.Width(), aDesiredSize.Height());
+
+    if (maxElementSize) {
+      printf("MW:%d\n", *maxElementWidth); 
+    } else {
+      printf("MW:?\n"); 
+    }
+
+  }
+#endif
+
+  ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus);
+
+  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+nsSize
+nsBoxFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState)
+{
+  NS_ASSERTION(aBoxLayoutState.GetRenderingContext(),
+               "must have rendering context");
+
+  nsSize size(0,0);
+  DISPLAY_PREF_SIZE(this, size);
+  if (!DoesNeedRecalc(mPrefSize)) {
+     return mPrefSize;
+  }
+
+#ifdef DEBUG_LAYOUT
+  PropagateDebug(aBoxLayoutState);
+#endif
+
+  if (IsXULCollapsed())
+    return size;
+
+  // if the size was not completely redefined in CSS then ask our children
+  bool widthSet, heightSet;
+  if (!nsIFrame::AddXULPrefSize(this, size, widthSet, heightSet))
+  {
+    if (mLayoutManager) {
+      nsSize layoutSize = mLayoutManager->GetXULPrefSize(this, aBoxLayoutState);
+      if (!widthSet)
+        size.width = layoutSize.width;
+      if (!heightSet)
+        size.height = layoutSize.height;
+    }
+    else {
+      size = nsBox::GetXULPrefSize(aBoxLayoutState);
+    }
+  }
+
+  nsSize minSize = GetXULMinSize(aBoxLayoutState);
+  nsSize maxSize = GetXULMaxSize(aBoxLayoutState);
+  mPrefSize = BoundsCheck(minSize, size, maxSize);
+ 
+  return mPrefSize;
+}
+
+nscoord
+nsBoxFrame::GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState)
+{
+  if (!DoesNeedRecalc(mAscent))
+     return mAscent;
+
+#ifdef DEBUG_LAYOUT
+  PropagateDebug(aBoxLayoutState);
+#endif
+
+  if (IsXULCollapsed())
+    return 0;
+
+  if (mLayoutManager)
+    mAscent = mLayoutManager->GetAscent(this, aBoxLayoutState);
+  else
+    mAscent = nsBox::GetXULBoxAscent(aBoxLayoutState);
+
+  return mAscent;
+}
+
+nsSize
+nsBoxFrame::GetXULMinSize(nsBoxLayoutState& aBoxLayoutState)
+{
+  NS_ASSERTION(aBoxLayoutState.GetRenderingContext(),
+               "must have rendering context");
+
+  nsSize size(0,0);
+  DISPLAY_MIN_SIZE(this, size);
+  if (!DoesNeedRecalc(mMinSize)) {
+    return mMinSize;
+  }
+
+#ifdef DEBUG_LAYOUT
+  PropagateDebug(aBoxLayoutState);
+#endif
+
+  if (IsXULCollapsed())
+    return size;
+
+  // if the size was not completely redefined in CSS then ask our children
+  bool widthSet, heightSet;
+  if (!nsIFrame::AddXULMinSize(aBoxLayoutState, this, size, widthSet, heightSet))
+  {
+    if (mLayoutManager) {
+      nsSize layoutSize = mLayoutManager->GetXULMinSize(this, aBoxLayoutState);
+      if (!widthSet)
+        size.width = layoutSize.width;
+      if (!heightSet)
+        size.height = layoutSize.height;
+    }
+    else {
+      size = nsBox::GetXULMinSize(aBoxLayoutState);
+    }
+  }
+  
+  mMinSize = size;
+
+  return size;
+}
+
+nsSize
+nsBoxFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState)
+{
+  NS_ASSERTION(aBoxLayoutState.GetRenderingContext(),
+               "must have rendering context");
+
+  nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
+  DISPLAY_MAX_SIZE(this, size);
+  if (!DoesNeedRecalc(mMaxSize)) {
+    return mMaxSize;
+  }
+
+#ifdef DEBUG_LAYOUT
+  PropagateDebug(aBoxLayoutState);
+#endif
+
+  if (IsXULCollapsed())
+    return size;
+
+  // if the size was not completely redefined in CSS then ask our children
+  bool widthSet, heightSet;
+  if (!nsIFrame::AddXULMaxSize(this, size, widthSet, heightSet))
+  {
+    if (mLayoutManager) {
+      nsSize layoutSize = mLayoutManager->GetXULMaxSize(this, aBoxLayoutState);
+      if (!widthSet)
+        size.width = layoutSize.width;
+      if (!heightSet)
+        size.height = layoutSize.height;
+    }
+    else {
+      size = nsBox::GetXULMaxSize(aBoxLayoutState);
+    }
+  }
+
+  mMaxSize = size;
+
+  return size;
+}
+
+nscoord
+nsBoxFrame::GetXULFlex()
+{
+  if (!DoesNeedRecalc(mFlex))
+     return mFlex;
+
+  mFlex = nsBox::GetXULFlex();
+
+  return mFlex;
+}
+
+/**
+ * If subclassing please subclass this method not layout. 
+ * layout will call this method.
+ */
+NS_IMETHODIMP
+nsBoxFrame::DoXULLayout(nsBoxLayoutState& aState)
+{
+  uint32_t oldFlags = aState.LayoutFlags();
+  aState.SetLayoutFlags(0);
+
+  nsresult rv = NS_OK;
+  if (mLayoutManager) {
+    CoordNeedsRecalc(mAscent);
+    rv = mLayoutManager->XULLayout(this, aState);
+  }
+
+  aState.SetLayoutFlags(oldFlags);
+
+  if (HasAbsolutelyPositionedChildren()) {
+    // Set up a |reflowInput| to pass into ReflowAbsoluteFrames
+    WritingMode wm = GetWritingMode();
+    ReflowInput reflowInput(aState.PresContext(), this,
+                                  aState.GetRenderingContext(),
+                                  LogicalSize(wm, GetLogicalSize().ISize(wm),
+                                              NS_UNCONSTRAINEDSIZE));
+
+    // Set up a |desiredSize| to pass into ReflowAbsoluteFrames
+    ReflowOutput desiredSize(reflowInput);
+    desiredSize.Width() = mRect.width;
+    desiredSize.Height() = mRect.height;
+
+    // get the ascent (cribbed from ::Reflow)
+    nscoord ascent = mRect.height;
+
+    // getting the ascent could be a lot of work. Don't get it if
+    // we are the root. The viewport doesn't care about it.
+    if (!(mState & NS_STATE_IS_ROOT)) {
+      ascent = GetXULBoxAscent(aState);
+    }
+    desiredSize.SetBlockStartAscent(ascent);
+    desiredSize.mOverflowAreas = GetOverflowAreas();
+
+    AddStateBits(NS_FRAME_IN_REFLOW);
+    // Set up a |reflowStatus| to pass into ReflowAbsoluteFrames
+    // (just a dummy value; hopefully that's OK)
+    nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
+    ReflowAbsoluteFrames(aState.PresContext(), desiredSize,
+                         reflowInput, reflowStatus);
+    RemoveStateBits(NS_FRAME_IN_REFLOW);
+  }
+
+  return rv;
+}
+
+void
+nsBoxFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  // unregister access key
+  RegUnregAccessKey(false);
+
+  // clean up the container box's layout manager and child boxes
+  SetXULLayoutManager(nullptr);
+
+  nsContainerFrame::DestroyFrom(aDestructRoot);
+} 
+
+#ifdef DEBUG_LAYOUT
+nsresult
+nsBoxFrame::SetXULDebug(nsBoxLayoutState& aState, bool aDebug)
+{
+  // see if our state matches the given debug state
+  bool debugSet = mState & NS_STATE_CURRENTLY_IN_DEBUG;
+  bool debugChanged = (!aDebug && debugSet) || (aDebug && !debugSet);
+
+  // if it doesn't then tell each child below us the new debug state
+  if (debugChanged)
+  {
+     if (aDebug) {
+         mState |= NS_STATE_CURRENTLY_IN_DEBUG;
+     } else {
+         mState &= ~NS_STATE_CURRENTLY_IN_DEBUG;
+     }
+ 
+     SetDebugOnChildList(aState, mFirstChild, aDebug);
+
+    MarkIntrinsicISizesDirty();
+  }
+
+  return NS_OK;
+}
+#endif
+
+/* virtual */ void
+nsBoxFrame::MarkIntrinsicISizesDirty()
+{
+  SizeNeedsRecalc(mPrefSize);
+  SizeNeedsRecalc(mMinSize);
+  SizeNeedsRecalc(mMaxSize);
+  CoordNeedsRecalc(mFlex);
+  CoordNeedsRecalc(mAscent);
+
+  if (mLayoutManager) {
+    nsBoxLayoutState state(PresContext());
+    mLayoutManager->IntrinsicISizesDirty(this, state);
+  }
+
+  // Don't call base class method, since everything it does is within an
+  // IsXULBoxWrapped check.
+}
+
+void
+nsBoxFrame::RemoveFrame(ChildListID     aListID,
+                        nsIFrame*       aOldFrame)
+{
+  NS_PRECONDITION(aListID == kPrincipalList, "We don't support out-of-flow kids");
+  nsPresContext* presContext = PresContext();
+  nsBoxLayoutState state(presContext);
+
+  // remove the child frame
+  mFrames.RemoveFrame(aOldFrame);
+
+  // notify the layout manager
+  if (mLayoutManager)
+    mLayoutManager->ChildrenRemoved(this, state, aOldFrame);
+
+  // destroy the child frame
+  aOldFrame->Destroy();
+
+  // mark us dirty and generate a reflow command
+  PresContext()->PresShell()->
+    FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                     NS_FRAME_HAS_DIRTY_CHILDREN);
+}
+
+void
+nsBoxFrame::InsertFrames(ChildListID     aListID,
+                         nsIFrame*       aPrevFrame,
+                         nsFrameList&    aFrameList)
+{
+   NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
+                "inserting after sibling frame with different parent");
+   NS_ASSERTION(!aPrevFrame || mFrames.ContainsFrame(aPrevFrame),
+                "inserting after sibling frame not in our child list");
+   NS_PRECONDITION(aListID == kPrincipalList, "We don't support out-of-flow kids");
+   nsBoxLayoutState state(PresContext());
+
+   // insert the child frames
+   const nsFrameList::Slice& newFrames =
+     mFrames.InsertFrames(this, aPrevFrame, aFrameList);
+
+   // notify the layout manager
+   if (mLayoutManager)
+     mLayoutManager->ChildrenInserted(this, state, aPrevFrame, newFrames);
+
+   // Make sure to check box order _after_ notifying the layout
+   // manager; otherwise the slice we give the layout manager will
+   // just be bogus.  If the layout manager cares about the order, we
+   // just lose.
+   CheckBoxOrder();
+
+#ifdef DEBUG_LAYOUT
+   // if we are in debug make sure our children are in debug as well.
+   if (mState & NS_STATE_CURRENTLY_IN_DEBUG)
+       SetDebugOnChildList(state, mFrames.FirstChild(), true);
+#endif
+
+   PresContext()->PresShell()->
+     FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                      NS_FRAME_HAS_DIRTY_CHILDREN);
+}
+
+
+void
+nsBoxFrame::AppendFrames(ChildListID     aListID,
+                         nsFrameList&    aFrameList)
+{
+   NS_PRECONDITION(aListID == kPrincipalList, "We don't support out-of-flow kids");
+   nsBoxLayoutState state(PresContext());
+
+   // append the new frames
+   const nsFrameList::Slice& newFrames = mFrames.AppendFrames(this, aFrameList);
+
+   // notify the layout manager
+   if (mLayoutManager)
+     mLayoutManager->ChildrenAppended(this, state, newFrames);
+
+   // Make sure to check box order _after_ notifying the layout
+   // manager; otherwise the slice we give the layout manager will
+   // just be bogus.  If the layout manager cares about the order, we
+   // just lose.
+   CheckBoxOrder();
+
+#ifdef DEBUG_LAYOUT
+   // if we are in debug make sure our children are in debug as well.
+   if (mState & NS_STATE_CURRENTLY_IN_DEBUG)
+       SetDebugOnChildList(state, mFrames.FirstChild(), true);
+#endif
+
+   // XXXbz why is this NS_FRAME_FIRST_REFLOW check here?
+   if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
+     PresContext()->PresShell()->
+       FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+                        NS_FRAME_HAS_DIRTY_CHILDREN);
+   }
+}
+
+/* virtual */ nsContainerFrame*
+nsBoxFrame::GetContentInsertionFrame()
+{
+  if (GetStateBits() & NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK)
+    return PrincipalChildList().FirstChild()->GetContentInsertionFrame();
+  return nsContainerFrame::GetContentInsertionFrame();
+}
+
+nsresult
+nsBoxFrame::AttributeChanged(int32_t aNameSpaceID,
+                             nsIAtom* aAttribute,
+                             int32_t aModType)
+{
+  nsresult rv = nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute,
+                                                   aModType);
+
+  // Ignore 'width', 'height', 'screenX', 'screenY' and 'sizemode' on a
+  // <window>.
+  if (mContent->IsAnyOfXULElements(nsGkAtoms::window,
+                                   nsGkAtoms::page,
+                                   nsGkAtoms::dialog,
+                                   nsGkAtoms::wizard) &&
+      (nsGkAtoms::width == aAttribute ||
+       nsGkAtoms::height == aAttribute ||
+       nsGkAtoms::screenX == aAttribute ||
+       nsGkAtoms::screenY == aAttribute ||
+       nsGkAtoms::sizemode == aAttribute)) {
+    return rv;
+  }
+
+  if (aAttribute == nsGkAtoms::width       ||
+      aAttribute == nsGkAtoms::height      ||
+      aAttribute == nsGkAtoms::align       ||
+      aAttribute == nsGkAtoms::valign      ||
+      aAttribute == nsGkAtoms::left        ||
+      aAttribute == nsGkAtoms::top         ||
+      aAttribute == nsGkAtoms::right        ||
+      aAttribute == nsGkAtoms::bottom       ||
+      aAttribute == nsGkAtoms::start        ||
+      aAttribute == nsGkAtoms::end          ||
+      aAttribute == nsGkAtoms::minwidth     ||
+      aAttribute == nsGkAtoms::maxwidth     ||
+      aAttribute == nsGkAtoms::minheight    ||
+      aAttribute == nsGkAtoms::maxheight    ||
+      aAttribute == nsGkAtoms::flex         ||
+      aAttribute == nsGkAtoms::orient       ||
+      aAttribute == nsGkAtoms::pack         ||
+      aAttribute == nsGkAtoms::dir          ||
+      aAttribute == nsGkAtoms::mousethrough ||
+      aAttribute == nsGkAtoms::equalsize) {
+
+    if (aAttribute == nsGkAtoms::align  ||
+        aAttribute == nsGkAtoms::valign ||
+        aAttribute == nsGkAtoms::orient  ||
+        aAttribute == nsGkAtoms::pack    ||
+#ifdef DEBUG_LAYOUT
+        aAttribute == nsGkAtoms::debug   ||
+#endif
+        aAttribute == nsGkAtoms::dir) {
+
+      mValign = nsBoxFrame::vAlign_Top;
+      mHalign = nsBoxFrame::hAlign_Left;
+
+      bool orient = true;
+      GetInitialOrientation(orient); 
+      if (orient)
+        mState |= NS_STATE_IS_HORIZONTAL;
+      else
+        mState &= ~NS_STATE_IS_HORIZONTAL;
+
+      bool normal = true;
+      GetInitialDirection(normal);
+      if (normal)
+        mState |= NS_STATE_IS_DIRECTION_NORMAL;
+      else
+        mState &= ~NS_STATE_IS_DIRECTION_NORMAL;
+
+      GetInitialVAlignment(mValign);
+      GetInitialHAlignment(mHalign);
+
+      bool equalSize = false;
+      GetInitialEqualSize(equalSize); 
+      if (equalSize)
+        mState |= NS_STATE_EQUAL_SIZE;
+      else
+        mState &= ~NS_STATE_EQUAL_SIZE;
+
+#ifdef DEBUG_LAYOUT
+      bool debug = mState & NS_STATE_SET_TO_DEBUG;
+      bool debugSet = GetInitialDebug(debug);
+      if (debugSet) {
+        mState |= NS_STATE_DEBUG_WAS_SET;
+
+        if (debug)
+          mState |= NS_STATE_SET_TO_DEBUG;
+        else
+          mState &= ~NS_STATE_SET_TO_DEBUG;
+      } else {
+        mState &= ~NS_STATE_DEBUG_WAS_SET;
+      }
+#endif
+
+      bool autostretch = !!(mState & NS_STATE_AUTO_STRETCH);
+      GetInitialAutoStretch(autostretch);
+      if (autostretch)
+        mState |= NS_STATE_AUTO_STRETCH;
+      else
+        mState &= ~NS_STATE_AUTO_STRETCH;
+    }
+    else if (aAttribute == nsGkAtoms::left ||
+             aAttribute == nsGkAtoms::top ||
+             aAttribute == nsGkAtoms::right ||
+             aAttribute == nsGkAtoms::bottom ||
+             aAttribute == nsGkAtoms::start ||
+             aAttribute == nsGkAtoms::end) {
+      mState &= ~NS_STATE_STACK_NOT_POSITIONED;
+    }
+    else if (aAttribute == nsGkAtoms::mousethrough) {
+      UpdateMouseThrough();
+    }
+
+    PresContext()->PresShell()->
+      FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
+  }
+  else if (aAttribute == nsGkAtoms::ordinal) {
+    nsIFrame* parent = GetParentXULBox(this);
+    // If our parent is not a box, there's not much we can do... but in that
+    // case our ordinal doesn't matter anyway, so that's ok.
+    // Also don't bother with popup frames since they are kept on the 
+    // kPopupList and XULRelayoutChildAtOrdinal() only handles
+    // principal children.
+    if (parent && !(GetStateBits() & NS_FRAME_OUT_OF_FLOW) &&
+        StyleDisplay()->mDisplay != mozilla::StyleDisplay::Popup) {
+      parent->XULRelayoutChildAtOrdinal(this);
+      // XXXldb Should this instead be a tree change on the child or parent?
+      PresContext()->PresShell()->
+        FrameNeedsReflow(parent, nsIPresShell::eStyleChange,
+                         NS_FRAME_IS_DIRTY);
+    }
+  }
+  // If the accesskey changed, register for the new value
+  // The old value has been unregistered in nsXULElement::SetAttr
+  else if (aAttribute == nsGkAtoms::accesskey) {
+    RegUnregAccessKey(true);
+  }
+  else if (aAttribute == nsGkAtoms::rows &&
+           mContent->IsXULElement(nsGkAtoms::tree)) {
+    // Reflow ourselves and all our children if "rows" changes, since
+    // nsTreeBodyFrame's layout reads this from its parent (this frame).
+    PresContext()->PresShell()->
+      FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
+  }
+
+  return rv;
+}
+
+#ifdef DEBUG_LAYOUT
+void
+nsBoxFrame::GetDebugPref()
+{
+  gDebug = Preferences::GetBool("xul.debug.box");
+}
+
+class nsDisplayXULDebug : public nsDisplayItem {
+public:
+  nsDisplayXULDebug(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) :
+    nsDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplayXULDebug);
+  }
+#ifdef NS_BUILD_REFCNT_LOGGING
+  virtual ~nsDisplayXULDebug() {
+    MOZ_COUNT_DTOR(nsDisplayXULDebug);
+  }
+#endif
+
+  virtual void HitTest(nsDisplayListBuilder* aBuilder, nsRect aRect,
+                       HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames) {
+    nsPoint rectCenter(aRect.x + aRect.width / 2, aRect.y + aRect.height / 2);
+    static_cast<nsBoxFrame*>(mFrame)->
+      DisplayDebugInfoFor(this, rectCenter - ToReferenceFrame());
+    aOutFrames->AppendElement(this);
+  }
+  virtual void Paint(nsDisplayListBuilder* aBuilder
+                     nsRenderingContext* aCtx);
+  NS_DISPLAY_DECL_NAME("XULDebug", TYPE_XUL_DEBUG)
+};
+
+void
+nsDisplayXULDebug::Paint(nsDisplayListBuilder* aBuilder,
+                         nsRenderingContext* aCtx)
+{
+  static_cast<nsBoxFrame*>(mFrame)->
+    PaintXULDebugOverlay(*aCtx->GetDrawTarget(), ToReferenceFrame());
+}
+
+static void
+PaintXULDebugBackground(nsIFrame* aFrame, DrawTarget* aDrawTarget,
+                        const nsRect& aDirtyRect, nsPoint aPt)
+{
+  static_cast<nsBoxFrame*>(aFrame)->PaintXULDebugBackground(aDrawTarget, aPt);
+}
+#endif
+
+void
+nsBoxFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                             const nsRect&           aDirtyRect,
+                             const nsDisplayListSet& aLists)
+{
+  bool forceLayer = false;
+
+  if (GetContent()->IsXULElement()) {
+    // forcelayer is only supported on XUL elements with box layout
+    if (GetContent()->HasAttr(kNameSpaceID_None, nsGkAtoms::layer)) {
+      forceLayer = true;
+    }
+    // Check for frames that are marked as a part of the region used
+    // in calculating glass margins on Windows.
+    const nsStyleDisplay* styles = StyleDisplay();
+    if (styles && styles->mAppearance == NS_THEME_WIN_EXCLUDE_GLASS) {
+      aBuilder->AddWindowExcludeGlassRegion(
+          nsRect(aBuilder->ToReferenceFrame(this), GetSize()));
+    }
+  }
+
+  nsDisplayListCollection tempLists;
+  const nsDisplayListSet& destination = forceLayer ? tempLists : aLists;
+
+  DisplayBorderBackgroundOutline(aBuilder, destination);
+
+#ifdef DEBUG_LAYOUT
+  if (mState & NS_STATE_CURRENTLY_IN_DEBUG) {
+    destination.BorderBackground()->AppendNewToTop(new (aBuilder)
+      nsDisplayGeneric(aBuilder, this, PaintXULDebugBackground,
+                       "XULDebugBackground"));
+    destination.Outlines()->AppendNewToTop(new (aBuilder)
+      nsDisplayXULDebug(aBuilder, this));
+  }
+#endif
+
+  BuildDisplayListForChildren(aBuilder, aDirtyRect, destination);
+
+  // see if we have to draw a selection frame around this container
+  DisplaySelectionOverlay(aBuilder, destination.Content());
+
+  if (forceLayer) {
+    // This is a bit of a hack. Collect up all descendant display items
+    // and merge them into a single Content() list. This can cause us
+    // to violate CSS stacking order, but forceLayer is a magic
+    // XUL-only extension anyway.
+    nsDisplayList masterList;
+    masterList.AppendToTop(tempLists.BorderBackground());
+    masterList.AppendToTop(tempLists.BlockBorderBackgrounds());
+    masterList.AppendToTop(tempLists.Floats());
+    masterList.AppendToTop(tempLists.Content());
+    masterList.AppendToTop(tempLists.PositionedDescendants());
+    masterList.AppendToTop(tempLists.Outlines());
+
+    // Wrap the list to make it its own layer
+    aLists.Content()->AppendNewToTop(new (aBuilder)
+      nsDisplayOwnLayer(aBuilder, this, &masterList));
+  }
+}
+
+void
+nsBoxFrame::BuildDisplayListForChildren(nsDisplayListBuilder*   aBuilder,
+                                        const nsRect&           aDirtyRect,
+                                        const nsDisplayListSet& aLists)
+{
+  nsIFrame* kid = mFrames.FirstChild();
+  // Put each child's background onto the BlockBorderBackgrounds list
+  // to emulate the existing two-layer XUL painting scheme.
+  nsDisplayListSet set(aLists, aLists.BlockBorderBackgrounds());
+  // The children should be in the right order
+  while (kid) {
+    BuildDisplayListForChild(aBuilder, kid, aDirtyRect, set);
+    kid = kid->GetNextSibling();
+  }
+}
+
+// REVIEW: PaintChildren did a few things none of which are a big deal
+// anymore:
+// * Paint some debugging rects for this frame.
+// This is done by nsDisplayXULDebugBackground, which goes in the
+// BorderBackground() layer so it isn't clipped by OVERFLOW_CLIP.
+// * Apply OVERFLOW_CLIP to the children.
+// This is now in nsFrame::BuildDisplayListForStackingContext/Child.
+// * Actually paint the children.
+// Moved to BuildDisplayList.
+// * Paint per-kid debug information.
+// This is done by nsDisplayXULDebug, which is in the Outlines()
+// layer so it goes on top. This means it is not clipped by OVERFLOW_CLIP,
+// whereas it did used to respect OVERFLOW_CLIP, but too bad.
+#ifdef DEBUG_LAYOUT
+void
+nsBoxFrame::PaintXULDebugBackground(DrawTarget* aDrawTarget, nsPoint aPt)
+{
+  nsMargin border;
+  GetXULBorder(border);
+
+  nsMargin debugBorder;
+  nsMargin debugMargin;
+  nsMargin debugPadding;
+
+  bool isHorizontal = IsXULHorizontal();
+
+  GetDebugBorder(debugBorder);
+  PixelMarginToTwips(debugBorder);
+
+  GetDebugMargin(debugMargin);
+  PixelMarginToTwips(debugMargin);
+
+  GetDebugPadding(debugPadding);
+  PixelMarginToTwips(debugPadding);
+
+  nsRect inner(mRect);
+  inner.MoveTo(aPt);
+  inner.Deflate(debugMargin);
+  inner.Deflate(border);
+  //nsRect borderRect(inner);
+
+  int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel();
+
+  ColorPattern color(ToDeviceColor(isHorizontal ? Color(0.f, 0.f, 1.f, 1.f) :
+                                                  Color(1.f, 0.f, 0.f, 1.f)));
+
+  //left
+  nsRect r(inner);
+  r.width = debugBorder.left;
+  aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color);
+
+  // top
+  r = inner;
+  r.height = debugBorder.top;
+  aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color);
+
+  //right
+  r = inner;
+  r.x = r.x + r.width - debugBorder.right;
+  r.width = debugBorder.right;
+  aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color);
+
+  //bottom
+  r = inner;
+  r.y = r.y + r.height - debugBorder.bottom;
+  r.height = debugBorder.bottom;
+  aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color);
+
+  // If we have dirty children or we are dirty place a green border around us.
+  if (NS_SUBTREE_DIRTY(this)) {
+    nsRect dirty(inner);
+    ColorPattern green(ToDeviceColor(Color(0.f, 1.f, 0.f, 1.f)));
+    aDrawTarget->StrokeRect(NSRectToRect(dirty, appUnitsPerDevPixel), green);
+  }
+}
+
+void
+nsBoxFrame::PaintXULDebugOverlay(DrawTarget& aDrawTarget, nsPoint aPt)
+{
+  nsMargin border;
+  GetXULBorder(border);
+
+  nsMargin debugMargin;
+  GetDebugMargin(debugMargin);
+  PixelMarginToTwips(debugMargin);
+
+  nsRect inner(mRect);
+  inner.MoveTo(aPt);
+  inner.Deflate(debugMargin);
+  inner.Deflate(border);
+
+  nscoord onePixel = GetPresContext()->IntScaledPixelsToTwips(1);
+
+  kid = nsBox::GetChildXULBox(this);
+  while (nullptr != kid) {
+    bool isHorizontal = IsXULHorizontal();
+
+    nscoord x, y, borderSize, spacerSize;
+    
+    nsRect cr(kid->mRect);
+    nsMargin margin;
+    kid->GetXULMargin(margin);
+    cr.Inflate(margin);
+    
+    if (isHorizontal) 
+    {
+        cr.y = inner.y;
+        x = cr.x;
+        y = cr.y + onePixel;
+        spacerSize = debugBorder.top - onePixel*4;
+    } else {
+        cr.x = inner.x;
+        x = cr.y;
+        y = cr.x + onePixel;
+        spacerSize = debugBorder.left - onePixel*4;
+    }
+
+    nscoord flex = kid->GetXULFlex();
+
+    if (!kid->IsXULCollapsed()) {
+      if (isHorizontal) 
+          borderSize = cr.width;
+      else 
+          borderSize = cr.height;
+
+      DrawSpacer(GetPresContext(), aDrawTarget, isHorizontal, flex, x, y, borderSize, spacerSize);
+    }
+
+    kid = GetNextXULBox(kid);
+  }
+}
+#endif
+
+#ifdef DEBUG_LAYOUT
+void
+nsBoxFrame::GetBoxName(nsAutoString& aName)
+{
+   GetFrameName(aName);
+}
+#endif
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult
+nsBoxFrame::GetFrameName(nsAString& aResult) const
+{
+  return MakeFrameName(NS_LITERAL_STRING("Box"), aResult);
+}
+#endif
+
+nsIAtom*
+nsBoxFrame::GetType() const
+{
+  return nsGkAtoms::boxFrame;
+}
+
+#ifdef DEBUG_LAYOUT
+nsresult
+nsBoxFrame::GetXULDebug(bool& aDebug)
+{
+  aDebug = (mState & NS_STATE_CURRENTLY_IN_DEBUG);
+  return NS_OK;
+}
+#endif
+
+// REVIEW: nsBoxFrame::GetFrameForPoint is a problem because of 'mousethrough'
+// attribute support. Here's how it works:
+// * For each child frame F, we determine the target frame T(F) by recursively
+// invoking GetFrameForPoint on the child
+// * Let F' be the last child frame such that T(F') doesn't have mousethrough.
+// If F' exists, return T(F')
+// * Otherwise let F'' be the first child frame such that T(F'') is non-null.
+// If F'' exists, return T(F'')
+// * Otherwise return this frame, if this frame contains the point
+// * Otherwise return null
+// It's not clear how this should work for more complex z-ordering situations.
+// The basic principle seems to be that if a frame F has a descendant
+// 'mousethrough' frame that includes the target position, then F
+// will not receive events (unless it overrides GetFrameForPoint).
+// A 'mousethrough' frame will only receive an event if, after applying that rule,
+// all eligible frames are 'mousethrough'; the bottom-most inner-most 'mousethrough'
+// frame is then chosen (the first eligible frame reached in a
+// traversal of the frame tree --- pre/post is irrelevant since ancestors
+// of the mousethrough frames can't be eligible).
+// IMHO this is very bogus and adds a great deal of complexity for something
+// that is very rarely used. So I'm redefining 'mousethrough' to the following:
+// a frame with mousethrough is transparent to mouse events. This is compatible
+// with the way 'mousethrough' is used in Seamonkey's navigator.xul and
+// Firefox's browser.xul. The only other place it's used is in the 'expander'
+// XBL binding, which in our tree is only used by Thunderbird SMIME Advanced
+// Preferences, and I can't figure out what that does, so I'll have to test it.
+// If it's broken I'll probably just change the binding to use it more sensibly.
+// This new behaviour is implemented in nsDisplayList::HitTest. 
+// REVIEW: This debug-box stuff is annoying. I'm just going to put debug boxes
+// in the outline layer and avoid GetDebugBoxAt.
+
+// REVIEW: GetCursor had debug-only event dumping code. I have replaced it
+// with instrumentation in nsDisplayXULDebug.
+
+#ifdef DEBUG_LAYOUT
+void
+nsBoxFrame::DrawLine(DrawTarget& aDrawTarget, bool aHorizontal, nscoord x1, nscoord y1, nscoord x2, nscoord y2)
+{
+    nsPoint p1(x1, y1);
+    nsPoint p2(x2, y2);
+    if (!aHorizontal) {
+      Swap(p1.x, p1.y);
+      Swap(p2.x, p2.y);
+    }
+    ColorPattern white(ToDeviceColor(Color(1.f, 1.f, 1.f, 1.f)));
+    StrokeLineWithSnapping(p1, p2, PresContext()->AppUnitsPerDevPixel(),
+                           aDrawTarget, color);
+}
+
+void
+nsBoxFrame::FillRect(DrawTarget& aDrawTarget, bool aHorizontal, nscoord x, nscoord y, nscoord width, nscoord height)
+{
+    Rect rect = NSRectToSnappedRect(aHorizontal ? nsRect(x, y, width, height) :
+                                                  nsRect(y, x, height, width),
+                                    PresContext()->AppUnitsPerDevPixel(),
+                                    aDrawTarget);
+    ColorPattern white(ToDeviceColor(Color(1.f, 1.f, 1.f, 1.f)));
+    aDrawTarget.FillRect(rect, white);
+}
+
+void 
+nsBoxFrame::DrawSpacer(nsPresContext* aPresContext, DrawTarget& aDrawTarget,
+                       bool aHorizontal, int32_t flex, nscoord x, nscoord y,
+                       nscoord size, nscoord spacerSize)
+{    
+         nscoord onePixel = aPresContext->IntScaledPixelsToTwips(1);
+
+     // if we do draw the coils
+        int distance = 0;
+        int center = 0;
+        int offset = 0;
+        int coilSize = COIL_SIZE*onePixel;
+        int halfSpacer = spacerSize/2;
+
+        distance = size;
+        center = y + halfSpacer;
+        offset = x;
+
+        int coils = distance/coilSize;
+
+        int halfCoilSize = coilSize/2;
+
+        if (flex == 0) {
+            DrawLine(aDrawTarget, aHorizontal, x,y + spacerSize/2, x + size, y + spacerSize/2);
+        } else {
+            for (int i=0; i < coils; i++)
+            {
+                   DrawLine(aDrawTarget, aHorizontal, offset, center+halfSpacer, offset+halfCoilSize, center-halfSpacer);
+                   DrawLine(aDrawTarget, aHorizontal, offset+halfCoilSize, center-halfSpacer, offset+coilSize, center+halfSpacer);
+
+                   offset += coilSize;
+            }
+        }
+
+        FillRect(aDrawTarget, aHorizontal, x + size - spacerSize/2, y, spacerSize/2, spacerSize);
+        FillRect(aDrawTarget, aHorizontal, x, y, spacerSize/2, spacerSize);
+}
+
+void
+nsBoxFrame::GetDebugBorder(nsMargin& aInset)
+{
+    aInset.SizeTo(2,2,2,2);
+
+    if (IsXULHorizontal()) 
+       aInset.top = 10;
+    else 
+       aInset.left = 10;
+}
+
+void
+nsBoxFrame::GetDebugMargin(nsMargin& aInset)
+{
+    aInset.SizeTo(2,2,2,2);
+}
+
+void
+nsBoxFrame::GetDebugPadding(nsMargin& aPadding)
+{
+    aPadding.SizeTo(2,2,2,2);
+}
+
+void 
+nsBoxFrame::PixelMarginToTwips(nsMargin& aMarginPixels)
+{
+  nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1);
+  aMarginPixels.left   *= onePixel;
+  aMarginPixels.right  *= onePixel;
+  aMarginPixels.top    *= onePixel;
+  aMarginPixels.bottom *= onePixel;
+}
+
+void
+nsBoxFrame::GetValue(nsPresContext* aPresContext, const nsSize& a, const nsSize& b, char* ch) 
+{
+    float p2t = aPresContext->ScaledPixelsToTwips();
+
+    char width[100];
+    char height[100];
+    
+    if (a.width == NS_INTRINSICSIZE)
+        sprintf(width,"%s","INF");
+    else
+        sprintf(width,"%d", nscoord(a.width/*/p2t*/));
+    
+    if (a.height == NS_INTRINSICSIZE)
+        sprintf(height,"%s","INF");
+    else 
+        sprintf(height,"%d", nscoord(a.height/*/p2t*/));
+    
+
+    sprintf(ch, "(%s%s, %s%s)", width, (b.width != NS_INTRINSICSIZE ? "[SET]" : ""),
+                    height, (b.height != NS_INTRINSICSIZE ? "[SET]" : ""));
+
+}
+
+void
+nsBoxFrame::GetValue(nsPresContext* aPresContext, int32_t a, int32_t b, char* ch) 
+{
+    if (a == NS_INTRINSICSIZE)
+      sprintf(ch, "%d[SET]", b);             
+    else
+      sprintf(ch, "%d", a);             
+}
+
+nsresult
+nsBoxFrame::DisplayDebugInfoFor(nsIFrame*  aBox,
+                                nsPoint& aPoint)
+{
+    nsBoxLayoutState state(GetPresContext());
+
+    nscoord x = aPoint.x;
+    nscoord y = aPoint.y;
+
+    // get the area inside our border but not our debug margins.
+    nsRect insideBorder(aBox->mRect);
+    insideBorder.MoveTo(0,0):
+    nsMargin border(0,0,0,0);
+    aBox->GetXULBorderAndPadding(border);
+    insideBorder.Deflate(border);
+
+    bool isHorizontal = IsXULHorizontal();
+
+    if (!insideBorder.Contains(nsPoint(x,y)))
+        return NS_ERROR_FAILURE;
+
+    //printf("%%%%%% inside box %%%%%%%\n");
+
+    int count = 0;
+    nsIFrame* child = nsBox::GetChildXULBox(aBox);
+
+    nsMargin m;
+    nsMargin m2;
+    GetDebugBorder(m);
+    PixelMarginToTwips(m);
+
+    GetDebugMargin(m2);
+    PixelMarginToTwips(m2);
+
+    m += m2;
+
+    if ((isHorizontal && y < insideBorder.y + m.top) ||
+        (!isHorizontal && x < insideBorder.x + m.left)) {
+        //printf("**** inside debug border *******\n");
+        while (child) 
+        {
+            const nsRect& r = child->mRect;
+
+            // if we are not in the child. But in the spacer above the child.
+            if ((isHorizontal && x >= r.x && x < r.x + r.width) ||
+                (!isHorizontal && y >= r.y && y < r.y + r.height)) {
+                aCursor = NS_STYLE_CURSOR_POINTER;
+                   // found it but we already showed it.
+                    if (mDebugChild == child)
+                        return NS_OK;
+
+                    if (aBox->GetContent()) {
+                      printf("---------------\n");
+                      XULDumpBox(stdout);
+                      printf("\n");
+                    }
+
+                    if (child->GetContent()) {
+                        printf("child #%d: ", count);
+                        child->XULDumpBox(stdout);
+                        printf("\n");
+                    }
+
+                    mDebugChild = child;
+
+                    nsSize prefSizeCSS(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
+                    nsSize minSizeCSS (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
+                    nsSize maxSizeCSS (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
+                    nscoord flexCSS = NS_INTRINSICSIZE;
+
+                    bool widthSet, heightSet;
+                    nsIFrame::AddXULPrefSize(child, prefSizeCSS, widthSet, heightSet);
+                    nsIFrame::AddXULMinSize (state, child, minSizeCSS, widthSet, heightSet);
+                    nsIFrame::AddXULMaxSize (child, maxSizeCSS, widthSet, heightSet);
+                    nsIFrame::AddXULFlex    (child, flexCSS);
+
+                    nsSize prefSize = child->GetXULPrefSize(state);
+                    nsSize minSize = child->GetXULMinSize(state);
+                    nsSize maxSize = child->GetXULMaxSize(state);
+                    nscoord flexSize = child->GetXULFlex();
+                    nscoord ascentSize = child->GetXULBoxAscent(state);
+
+                    char min[100];
+                    char pref[100];
+                    char max[100];
+                    char calc[100];
+                    char flex[100];
+                    char ascent[100];
+                  
+                    nsSize actualSize;
+                    GetFrameSizeWithMargin(child, actualSize);
+                    nsSize actualSizeCSS (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
+
+                    GetValue(aPresContext, minSize,  minSizeCSS, min);
+                    GetValue(aPresContext, prefSize, prefSizeCSS, pref);
+                    GetValue(aPresContext, maxSize,  maxSizeCSS, max);
+                    GetValue(aPresContext, actualSize, actualSizeCSS, calc);
+                    GetValue(aPresContext, flexSize,  flexCSS, flex);
+                    GetValue(aPresContext, ascentSize,  NS_INTRINSICSIZE, ascent);
+
+
+                    printf("min%s, pref%s, max%s, actual%s, flex=%s, ascent=%s\n\n", 
+                        min,
+                        pref,
+                        max,
+                        calc,
+                        flex,
+                        ascent
+                    );
+
+                    return NS_OK;   
+            }
+
+          child = GetNextXULBox(child);
+          count++;
+        }
+    } else {
+    }
+
+    mDebugChild = nullptr;
+
+    return NS_OK;
+}
+
+void
+nsBoxFrame::SetDebugOnChildList(nsBoxLayoutState& aState, nsIFrame* aChild, bool aDebug)
+{
+    nsIFrame* child = nsBox::GetChildXULBox(this);
+     while (child)
+     {
+        child->SetXULDebug(aState, aDebug);
+        child = GetNextXULBox(child);
+     }
+}
+
+nsresult
+nsBoxFrame::GetFrameSizeWithMargin(nsIFrame* aBox, nsSize& aSize)
+{
+  nsRect rect(aBox->GetRect());
+  nsMargin margin(0,0,0,0);
+  aBox->GetXULMargin(margin);
+  rect.Inflate(margin);
+  aSize.width = rect.width;
+  aSize.height = rect.height;
+  return NS_OK;
+}
+#endif
+
+// If you make changes to this function, check its counterparts
+// in nsTextBoxFrame and nsXULLabelFrame
+void
+nsBoxFrame::RegUnregAccessKey(bool aDoReg)
+{
+  MOZ_ASSERT(mContent);
+
+  // only support accesskeys for the following elements
+  if (!mContent->IsAnyOfXULElements(nsGkAtoms::button,
+                                    nsGkAtoms::toolbarbutton,
+                                    nsGkAtoms::checkbox,
+                                    nsGkAtoms::textbox,
+                                    nsGkAtoms::tab,
+                                    nsGkAtoms::radio)) {
+    return;
+  }
+
+  nsAutoString accessKey;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey);
+
+  if (accessKey.IsEmpty())
+    return;
+
+  // With a valid PresContext we can get the ESM 
+  // and register the access key
+  EventStateManager* esm = PresContext()->EventStateManager();
+
+  uint32_t key = accessKey.First();
+  if (aDoReg)
+    esm->RegisterAccessKey(mContent, key);
+  else
+    esm->UnregisterAccessKey(mContent, key);
+}
+
+bool
+nsBoxFrame::SupportsOrdinalsInChildren()
+{
+  return true;
+}
+
+// Helper less-than-or-equal function, used in CheckBoxOrder() as a
+// template-parameter for the sorting functions.
+bool
+IsBoxOrdinalLEQ(nsIFrame* aFrame1,
+                nsIFrame* aFrame2)
+{
+  // If we've got a placeholder frame, use its out-of-flow frame's ordinal val.
+  nsIFrame* aRealFrame1 = nsPlaceholderFrame::GetRealFrameFor(aFrame1);
+  nsIFrame* aRealFrame2 = nsPlaceholderFrame::GetRealFrameFor(aFrame2);
+  return aRealFrame1->GetXULOrdinal() <= aRealFrame2->GetXULOrdinal();
+}
+
+void 
+nsBoxFrame::CheckBoxOrder()
+{
+  if (SupportsOrdinalsInChildren() &&
+      !nsIFrame::IsFrameListSorted<IsBoxOrdinalLEQ>(mFrames)) {
+    nsIFrame::SortFrameList<IsBoxOrdinalLEQ>(mFrames);
+  }
+}
+
+nsresult
+nsBoxFrame::LayoutChildAt(nsBoxLayoutState& aState, nsIFrame* aBox, const nsRect& aRect)
+{
+  // get the current rect
+  nsRect oldRect(aBox->GetRect());
+  aBox->SetXULBounds(aState, aRect);
+
+  bool layout = NS_SUBTREE_DIRTY(aBox);
+  
+  if (layout || (oldRect.width != aRect.width || oldRect.height != aRect.height))  {
+    return aBox->XULLayout(aState);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsBoxFrame::XULRelayoutChildAtOrdinal(nsIFrame* aChild)
+{
+  if (!SupportsOrdinalsInChildren())
+    return NS_OK;
+
+  uint32_t ord = aChild->GetXULOrdinal();
+  
+  nsIFrame* child = mFrames.FirstChild();
+  nsIFrame* newPrevSib = nullptr;
+
+  while (child) {
+    if (ord < child->GetXULOrdinal()) {
+      break;
+    }
+
+    if (child != aChild) {
+      newPrevSib = child;
+    }
+
+    child = GetNextXULBox(child);
+  }
+
+  if (aChild->GetPrevSibling() == newPrevSib) {
+    // This box is not moving.
+    return NS_OK;
+  }
+
+  // Take |aChild| out of its old position in the child list.
+  mFrames.RemoveFrame(aChild);
+
+  // Insert it after |newPrevSib| or at the start if it's null.
+  mFrames.InsertFrame(nullptr, newPrevSib, aChild);
+
+  return NS_OK;
+}
+
+/**
+ * This wrapper class lets us redirect mouse hits from descendant frames
+ * of a menu to the menu itself, if they didn't specify 'allowevents'.
+ * 
+ * The wrapper simply turns a hit on a descendant element
+ * into a hit on the menu itself, unless there is an element between the target
+ * and the menu with the "allowevents" attribute.
+ * 
+ * This is used by nsMenuFrame and nsTreeColFrame.
+ * 
+ * Note that turning a hit on a descendant element into nullptr, so events
+ * could fall through to the menu background, might be an appealing simplification
+ * but it would mean slightly strange behaviour in some cases, because grabber
+ * wrappers can be created for many individual lists and items, so the exact
+ * fallthrough behaviour would be complex. E.g. an element with "allowevents"
+ * on top of the Content() list could receive the event even if it was covered
+ * by a PositionedDescenants() element without "allowevents". It is best to
+ * never convert a non-null hit into null.
+ */
+// REVIEW: This is roughly of what nsMenuFrame::GetFrameForPoint used to do.
+// I've made 'allowevents' affect child elements because that seems the only
+// reasonable thing to do.
+class nsDisplayXULEventRedirector : public nsDisplayWrapList {
+public:
+  nsDisplayXULEventRedirector(nsDisplayListBuilder* aBuilder,
+                              nsIFrame* aFrame, nsDisplayItem* aItem,
+                              nsIFrame* aTargetFrame)
+    : nsDisplayWrapList(aBuilder, aFrame, aItem), mTargetFrame(aTargetFrame) {}
+  nsDisplayXULEventRedirector(nsDisplayListBuilder* aBuilder,
+                              nsIFrame* aFrame, nsDisplayList* aList,
+                              nsIFrame* aTargetFrame)
+    : nsDisplayWrapList(aBuilder, aFrame, aList), mTargetFrame(aTargetFrame) {}
+  virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
+                       HitTestState* aState,
+                       nsTArray<nsIFrame*> *aOutFrames) override;
+  virtual bool ShouldFlattenAway(nsDisplayListBuilder* aBuilder) override {
+    return false;
+  }
+  NS_DISPLAY_DECL_NAME("XULEventRedirector", TYPE_XUL_EVENT_REDIRECTOR)
+private:
+  nsIFrame* mTargetFrame;
+};
+
+void nsDisplayXULEventRedirector::HitTest(nsDisplayListBuilder* aBuilder,
+    const nsRect& aRect, HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames)
+{
+  nsTArray<nsIFrame*> outFrames;
+  mList.HitTest(aBuilder, aRect, aState, &outFrames);
+
+  bool topMostAdded = false;
+  uint32_t localLength = outFrames.Length();
+
+  for (uint32_t i = 0; i < localLength; i++) {
+
+    for (nsIContent* content = outFrames.ElementAt(i)->GetContent();
+         content && content != mTargetFrame->GetContent();
+         content = content->GetParent()) {
+      if (content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::allowevents,
+                               nsGkAtoms::_true, eCaseMatters)) {
+        // Events are allowed on 'frame', so let it go.
+        aOutFrames->AppendElement(outFrames.ElementAt(i));
+        topMostAdded = true;
+      }
+    }
+
+    // If there was no hit on the topmost frame or its ancestors,
+    // add the target frame itself as the first candidate (see bug 562554).
+    if (!topMostAdded) {
+      topMostAdded = true;
+      aOutFrames->AppendElement(mTargetFrame);
+    }
+  }
+}
+
+class nsXULEventRedirectorWrapper : public nsDisplayWrapper
+{
+public:
+  explicit nsXULEventRedirectorWrapper(nsIFrame* aTargetFrame)
+      : mTargetFrame(aTargetFrame) {}
+  virtual nsDisplayItem* WrapList(nsDisplayListBuilder* aBuilder,
+                                  nsIFrame* aFrame,
+                                  nsDisplayList* aList) override {
+    return new (aBuilder)
+        nsDisplayXULEventRedirector(aBuilder, aFrame, aList, mTargetFrame);
+  }
+  virtual nsDisplayItem* WrapItem(nsDisplayListBuilder* aBuilder,
+                                  nsDisplayItem* aItem) override {
+    return new (aBuilder)
+        nsDisplayXULEventRedirector(aBuilder, aItem->Frame(), aItem,
+                                    mTargetFrame);
+  }
+private:
+  nsIFrame* mTargetFrame;
+};
+
+void
+nsBoxFrame::WrapListsInRedirector(nsDisplayListBuilder*   aBuilder,
+                                  const nsDisplayListSet& aIn,
+                                  const nsDisplayListSet& aOut)
+{
+  nsXULEventRedirectorWrapper wrapper(this);
+  wrapper.WrapLists(aBuilder, this, aIn, aOut);
+}
+
+bool
+nsBoxFrame::GetEventPoint(WidgetGUIEvent* aEvent, nsPoint &aPoint) {
+  LayoutDeviceIntPoint refPoint;
+  bool res = GetEventPoint(aEvent, refPoint);
+  aPoint = nsLayoutUtils::GetEventCoordinatesRelativeTo(
+    aEvent, refPoint, this);
+  return res;
+}
+
+bool
+nsBoxFrame::GetEventPoint(WidgetGUIEvent* aEvent, LayoutDeviceIntPoint& aPoint) {
+  NS_ENSURE_TRUE(aEvent, false);
+
+  WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
+  if (touchEvent) {
+    // return false if there is more than one touch on the page, or if
+    // we can't find a touch point
+    if (touchEvent->mTouches.Length() != 1) {
+      return false;
+    }
+
+    dom::Touch* touch = touchEvent->mTouches.SafeElementAt(0);
+    if (!touch) {
+      return false;
+    }
+    aPoint = touch->mRefPoint;
+  } else {
+    aPoint = aEvent->mRefPoint;
+  }
+  return true;
+}