--- a/accessible/base/nsAccessibilityService.cpp
+++ b/accessible/base/nsAccessibilityService.cpp
@@ -1312,18 +1312,17 @@ LocalAccessible* nsAccessibilityService:
     }
 
     // Any XUL/flex box can be used as tabpanel, make sure we create a proper
     // accessible for it.
     if (!newAcc && aContext->IsXULTabpanels() &&
         content->GetParent() == aContext->GetContent()) {
       LayoutFrameType frameType = frame->Type();
       // FIXME(emilio): Why only these frame types?
-      if (frameType == LayoutFrameType::Box ||
-          frameType == LayoutFrameType::FlexContainer ||
+      if (frameType == LayoutFrameType::FlexContainer ||
           frameType == LayoutFrameType::Scroll) {
         newAcc = new XULTabpanelAccessible(content, document);
       }
     }
   }
 
   if (!newAcc) {
     if (content->IsSVGElement()) {

--- a/accessible/generic/LocalAccessible.cpp
+++ b/accessible/generic/LocalAccessible.cpp
@@ -402,32 +402,18 @@ uint64_t LocalAccessible::NativeState() 
 
     state |= NativeInteractiveState();
   }
 
   // Gather states::INVISIBLE and states::OFFSCREEN flags for this object.
   state |= VisibilityState();
 
   nsIFrame* frame = GetFrame();
-  if (frame) {
-    if (frame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) state |= states::FLOATING;
-
-    // XXX we should look at layout for non XUL box frames, but need to decide
-    // how that interacts with ARIA.
-    if (HasOwnContent() && mContent->IsXULElement() && frame->IsXULBoxFrame()) {
-      const nsStyleXUL* xulStyle = frame->StyleXUL();
-      if (xulStyle && frame->IsXULBoxFrame()) {
-        // In XUL all boxes are either vertical or horizontal
-        if (xulStyle->mBoxOrient == StyleBoxOrient::Vertical) {
-          state |= states::VERTICAL;
-        } else {
-          state |= states::HORIZONTAL;
-        }
-      }
-    }
+  if (frame && frame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) {
+    state |= states::FLOATING;
   }
 
   // Check if a XUL element has the popup attribute (an attached popup menu).
   if (HasOwnContent() && mContent->IsXULElement() &&
       mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::popup)) {
     state |= states::HASPOPUP;
   }
 

--- a/accessible/generic/TableAccessible.cpp
+++ b/accessible/generic/TableAccessible.cpp
@@ -179,18 +179,17 @@ bool TableAccessible::IsProbablyLayoutTa
     RETURN_LAYOUT_ANSWER(false, "table with no frame!");
   }
 
   nsIFrame* cellFrame = tableFrame->GetCellFrameAt(0, 0);
   if (!cellFrame) {
     RETURN_LAYOUT_ANSWER(false, "table's first cell has no frame!");
   }
 
-  nsMargin border;
-  cellFrame->GetXULBorder(border);
+  nsMargin border = cellFrame->StyleBorder()->GetComputedBorder();
   if (border.top && border.bottom && border.left && border.right) {
     RETURN_LAYOUT_ANSWER(false, "Has nonzero border-width on table cell");
   }
 
   // Rules for non-bordered tables with 2-4 columns and 2+ rows from here on
   // forward.
 
   // Check for styled background color across rows (alternating background

--- a/accessible/tests/mochitest/attributes/a11y.ini
+++ b/accessible/tests/mochitest/attributes/a11y.ini
@@ -2,14 +2,13 @@
 support-files =
   !/accessible/tests/mochitest/*.js
 
 [test_dpub_aria_xml-roles.html]
 [test_graphics_aria_xml-roles.html]
 [test_listbox.html]
 [test_obj.html]
 [test_obj_css.html]
-[test_obj_css.xhtml]
 [test_obj_group.html]
 [test_obj_group.xhtml]
 [test_obj_group_tree.xhtml]
 [test_tag.html]
 [test_xml-roles.html]

deleted file mode 100644
--- a/accessible/tests/mochitest/attributes/test_obj_css.xhtml
+++ /dev/null
@@ -1,53 +0,0 @@
-<?xml version="1.0"?>
-<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
-<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
-                 type="text/css"?>
-
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-        title="Accessibility CSS-based Object Attributes Test.">
-
-  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js" />
-
-  <script type="application/javascript"
-          src="../common.js" />
-  <script type="application/javascript"
-          src="../events.js" />
-  <script type="application/javascript"
-          src="../attributes.js" />
-
-  <script type="application/javascript">
-  <![CDATA[
-    function doTest()
-    {
-      // CSS display
-      testCSSAttrs("display_mozbox");
-      testCSSAttrs("display_mozinlinebox");
-
-      SimpleTest.finish();
-    }
-
-    SimpleTest.waitForExplicitFinish();
-    addA11yLoadEvent(doTest);
-  ]]>
-  </script>
-
-  <hbox flex="1" style="overflow: auto;">
-  <body xmlns="http://www.w3.org/1999/xhtml">
-    <a target="_blank"
-       href="https://bugzilla.mozilla.org/show_bug.cgi?id=714579"
-       title="Don't use GetComputedStyle for object attribute calculation">
-      Mozilla Bug 714579
-    </a><br/>
-
-    <p id="display"></p>
-    <div id="content" style="display: none">
-    </div>
-    <pre id="test">
-    </pre>
-  </body>
-
-  <vbox id="display_mozbox" style="display: -moz-box;" role="img"/>
-  <vbox id="display_mozinlinebox" style="display: -moz-inline-box;" role="img"/>
-
-  </hbox>
-</window>

--- a/devtools/server/actors/animation-type-longhand.js
+++ b/devtools/server/actors/animation-type-longhand.js
@@ -243,17 +243,16 @@ exports.ANIMATION_TYPE_FOR_LONGHANDS = [
       "min-inline-size",
       "padding-block-end",
       "padding-block-start",
       "padding-inline-end",
       "padding-inline-start",
       "page-orientation",
       "math-depth",
       "-moz-box-collapse",
-      "-moz-box-layout",
       "-moz-top-layer",
       "scroll-timeline-axis",
       "scroll-timeline-name",
       "size",
       "transition-delay",
       "transition-duration",
       "transition-property",
       "transition-timing-function",

--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -3114,61 +3114,40 @@ void EventStateManager::DecideGestureEve
 
     // Scrollbars should always be draggable
     if (currentFrameType == LayoutFrameType::Scrollbar) {
       panDirection = WidgetGestureNotifyEvent::ePanNone;
       break;
     }
 
     // Special check for trees
-    nsTreeBodyFrame* treeFrame = do_QueryFrame(current);
-    if (treeFrame) {
+    if (nsTreeBodyFrame* treeFrame = do_QueryFrame(current)) {
       if (treeFrame->GetHorizontalOverflow()) {
         panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
       }
       if (treeFrame->GetVerticalOverflow()) {
         panDirection = WidgetGestureNotifyEvent::ePanVertical;
       }
       break;
     }
 
     if (nsIScrollableFrame* scrollableFrame = do_QueryFrame(current)) {
-      if (current->IsFrameOfType(nsIFrame::eXULBox)) {
+      layers::ScrollDirections scrollbarVisibility =
+          scrollableFrame->GetScrollbarVisibility();
+
+      // Check if we have visible scrollbars
+      if (scrollbarVisibility.contains(layers::ScrollDirection::eVertical)) {
+        panDirection = WidgetGestureNotifyEvent::ePanVertical;
         displayPanFeedback = true;
-
-        nsRect scrollRange = scrollableFrame->GetScrollRange();
-        bool canScrollHorizontally = scrollRange.width > 0;
-
-        // Vertical panning has priority over horizontal panning, so
-        // when vertical movement is possible we can just finish the loop.
-        if (scrollRange.height > 0) {
-          panDirection = WidgetGestureNotifyEvent::ePanVertical;
-          break;
-        }
-
-        if (canScrollHorizontally) {
-          panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
-          displayPanFeedback = false;
-        }
-      } else {  // Not a XUL box
-        layers::ScrollDirections scrollbarVisibility =
-            scrollableFrame->GetScrollbarVisibility();
-
-        // Check if we have visible scrollbars
-        if (scrollbarVisibility.contains(layers::ScrollDirection::eVertical)) {
-          panDirection = WidgetGestureNotifyEvent::ePanVertical;
-          displayPanFeedback = true;
-          break;
-        }
-
-        if (scrollbarVisibility.contains(
-                layers::ScrollDirection::eHorizontal)) {
-          panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
-          displayPanFeedback = true;
-        }
+        break;
+      }
+
+      if (scrollbarVisibility.contains(layers::ScrollDirection::eHorizontal)) {
+        panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
+        displayPanFeedback = true;
       }
     }  // scrollableFrame
   }    // ancestor chain
   aEvent->mDisplayPanFeedback = displayPanFeedback;
   aEvent->mPanDirection = panDirection;
 }
 
 #ifdef XP_MACOSX

--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -41,17 +41,16 @@
 #include "mozilla/StaticPrefs_toolkit.h"
 #include "mozilla/TextEvents.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/TouchEvents.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/Unused.h"
 #include "mozilla/ViewportUtils.h"
 #include "mozilla/gfx/Types.h"
-#include "nsBoxLayoutState.h"
 #include <algorithm>
 
 #ifdef XP_WIN
 #  include "winuser.h"
 #endif
 
 #include "gfxContext.h"
 #include "gfxUserFontSet.h"

--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -240,20 +240,19 @@ static inline bool IsFlexContainerForLeg
          aFrame->HasAnyStateBits(NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX);
 }
 
 #if DEBUG
 static void AssertAnonymousFlexOrGridItemParent(const nsIFrame* aChild,
                                                 const nsIFrame* aParent) {
   MOZ_ASSERT(IsAnonymousItem(aChild), "expected an anonymous item child frame");
   MOZ_ASSERT(aParent, "expected a parent frame");
-  MOZ_ASSERT(aParent->IsFlexContainerFrame() ||
-                 aParent->IsGridContainerFrame() || aParent->IsXULBoxFrame(),
-             "anonymous items should only exist as children of "
-             "flex/grid/-moz-box container frames");
+  MOZ_ASSERT(aParent->IsFlexOrGridContainer(),
+             "anonymous items should only exist as children of flex/grid "
+             "container frames");
 }
 #else
 #  define AssertAnonymousFlexOrGridItemParent(x, y) PR_BEGIN_MACRO PR_END_MACRO
 #endif
 
 #define ToCreationFunc(_func)                              \
   [](PresShell* aPs, ComputedStyle* aStyle) -> nsIFrame* { \
     return _func(aPs, aStyle);                             \
@@ -299,17 +298,17 @@ static bool IsLastContinuationForColumnC
 
 /**
  * Returns true iff aFrame explicitly prevents its descendants from floating
  * (at least, down to the level of descendants which themselves are
  * float-containing blocks -- those will manage the floating status of any
  * lower-level descendents inside them, of course).
  */
 static bool ShouldSuppressFloatingOfDescendants(nsIFrame* aFrame) {
-  return aFrame->IsFlexOrGridContainer() || aFrame->IsXULBoxFrame() ||
+  return aFrame->IsFlexOrGridContainer() ||
          aFrame->IsFrameOfType(nsIFrame::eMathML);
 }
 
 // Return true if column-span descendants should be suppressed under aFrame's
 // subtree (until a multi-column container re-establishing a block formatting
 // context). Basically, this is testing whether aFrame establishes a new block
 // formatting context or not.
 static bool ShouldSuppressColumnSpanDescendants(nsIFrame* aFrame) {
@@ -2312,18 +2311,17 @@ static inline bool NeedFrameFor(const ns
   // whitespace.
 
   // We could handle all this in CreateNeededPseudoContainers or some other
   // place after we build our frame construction items, but that would involve
   // creating frame construction items for whitespace kids that ignores
   // white-space, where we know we'll be dropping them all anyway, and involve
   // an extra walk down the frame construction item list.
   auto excludesIgnorableWhitespace = [](nsIFrame* aParentFrame) {
-    return aParentFrame->IsFrameOfType(nsIFrame::eXULBox) ||
-           aParentFrame->IsFrameOfType(nsIFrame::eMathML);
+    return aParentFrame->IsFrameOfType(nsIFrame::eMathML);
   };
   if (!aParentFrame || !excludesIgnorableWhitespace(aParentFrame) ||
       aParentFrame->IsGeneratedContentFrame() || !aChildContent->IsText()) {
     return true;
   }
 
   aChildContent->SetFlags(NS_CREATE_FRAME_IF_NON_WHITESPACE |
                           NS_REFRAME_IF_WHITESPACE);
@@ -2500,18 +2498,17 @@ nsIFrame* nsCSSFrameConstructor::Constru
     static constexpr FrameConstructionData rootSVGData;
     AutoFrameConstructionItem item(this, &rootSVGData, aDocElement,
                                    do_AddRef(computedStyle), true);
 
     contentFrame = static_cast<nsContainerFrame*>(ConstructOuterSVG(
         state, item, mDocElementContainingBlock, display, frameList));
   } else if (display->mDisplay == StyleDisplay::Flex ||
              display->mDisplay == StyleDisplay::WebkitBox ||
-             display->mDisplay == StyleDisplay::Grid ||
-             display->mDisplay == StyleDisplay::MozBox) {
+             display->mDisplay == StyleDisplay::Grid) {
     auto func = [&] {
       if (display->mDisplay == StyleDisplay::Grid) {
         return NS_NewGridContainerFrame;
       }
       return NS_NewFlexContainerFrame;
     }();
     contentFrame = func(mPresShell, computedStyle);
     InitAndRestoreFrame(
@@ -4328,27 +4325,25 @@ void nsCSSFrameConstructor::BuildScrollF
   aScrolledFrame->SetComputedStyleWithoutNotification(scrolledContentStyle);
   InitAndRestoreFrame(aState, aContent, aNewFrame, aScrolledFrame);
 
   FinishBuildingScrollFrame(aNewFrame, aScrolledFrame);
 }
 
 const nsCSSFrameConstructor::FrameConstructionData*
 nsCSSFrameConstructor::FindDisplayData(const nsStyleDisplay& aDisplay,
-                                       const StyleMozBoxLayout aMozBoxLayout,
                                        const Element& aElement) {
   static_assert(eParentTypeCount < (1 << (32 - FCDATA_PARENT_TYPE_OFFSET)),
                 "Check eParentTypeCount should not overflow");
 
   // The style system ensures that floated and positioned frames are
   // block-level.
   NS_ASSERTION(
       !(aDisplay.IsFloatingStyle() || aDisplay.IsAbsolutelyPositionedStyle()) ||
-          aDisplay.IsBlockOutsideStyle() ||
-          aDisplay.DisplayOutside() == StyleDisplayOutside::XUL,
+          aDisplay.IsBlockOutsideStyle(),
       "Style system did not apply CSS2.1 section 9.7 fixups");
 
   // If this is "body", try propagating its scroll style to the viewport
   // Note that we need to do this even if the body is NOT scrollable;
   // it might have dynamically changed from scrollable to not scrollable,
   // and that might need to be propagated.
   // XXXbz is this the right place to do this?  If this code moves,
   // make this function static.
@@ -4469,24 +4464,16 @@ nsCSSFrameConstructor::FindDisplayData(c
       return &data;
     }
     case StyleDisplayInside::TableCell: {
       static constexpr FrameConstructionData data(
           &nsCSSFrameConstructor::ConstructTableCell,
           FCDATA_IS_TABLE_PART | FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeRow));
       return &data;
     }
-    case StyleDisplayInside::MozBox: {
-      if (!aElement.IsInNativeAnonymousSubtree() &&
-          aElement.OwnerDoc()->IsContentDocument()) {
-        aElement.OwnerDoc()->WarnOnceAbout(
-            DeprecatedOperations::eMozBoxOrInlineBoxDisplay);
-      }
-      [[fallthrough]];
-    }
     case StyleDisplayInside::Flex:
     case StyleDisplayInside::WebkitBox: {
       static constexpr FrameConstructionData nonScrollableData(
           ToCreationFunc(NS_NewFlexContainerFrame));
       static constexpr FrameConstructionData data(
           ToCreationFunc(NS_NewFlexContainerFrame),
           FCDATA_MAY_NEED_SCROLLFRAME);
       return MOZ_UNLIKELY(propagatedScrollToViewport) ? &nonScrollableData
@@ -5264,31 +5251,30 @@ nsCSSFrameConstructor::FindElementData(c
   // 'display' values other than 'none' or 'contents').
   if (nsImageFrame::ShouldCreateImageFrameForContentProperty(aElement,
                                                              aStyle)) {
     static constexpr FrameConstructionData sImgData(
         NS_NewImageFrameForContentProperty);
     return &sImgData;
   }
 
-  const auto boxLayout = aStyle.StyleVisibility()->mMozBoxLayout;
   const bool shouldBlockify = aFlags.contains(ItemFlag::IsForRenderedLegend) ||
                               aFlags.contains(ItemFlag::IsForOutsideMarker);
   if (shouldBlockify && !aStyle.StyleDisplay()->IsBlockOutsideStyle()) {
     // Make a temp copy of StyleDisplay and blockify its mDisplay value.
     auto display = *aStyle.StyleDisplay();
     bool isRootElement = false;
     uint16_t rawDisplayValue =
         Servo_ComputedValues_BlockifiedDisplay(&aStyle, isRootElement);
     display.mDisplay = StyleDisplay(rawDisplayValue);
-    return FindDisplayData(display, boxLayout, aElement);
+    return FindDisplayData(display, aElement);
   }
 
   const auto& display = *aStyle.StyleDisplay();
-  return FindDisplayData(display, boxLayout, aElement);
+  return FindDisplayData(display, aElement);
 }
 
 const nsCSSFrameConstructor::FrameConstructionData*
 nsCSSFrameConstructor::FindElementTagData(const Element& aElement,
                                           ComputedStyle& aStyle,
                                           nsIFrame* aParentFrame,
                                           ItemFlags aFlags) {
   switch (aElement.GetNameSpaceID()) {
@@ -8699,18 +8685,17 @@ const nsCSSFrameConstructor::PseudoParen
 
 void nsCSSFrameConstructor::CreateNeededAnonFlexOrGridItems(
     nsFrameConstructorState& aState, FrameConstructionItemList& aItems,
     nsIFrame* aParentFrame) {
   if (aItems.IsEmpty()) {
     return;
   }
 
-  if (!aParentFrame->IsFlexOrGridContainer() &&
-      !aParentFrame->IsXULBoxFrame()) {
+  if (!aParentFrame->IsFlexOrGridContainer()) {
     return;
   }
 
   const bool isLegacyWebKitBox =
       IsFlexContainerForLegacyWebKitBox(aParentFrame);
   FCItemIterator iter(aItems);
   do {
     // Advance iter past children that don't want to be wrapped
@@ -9327,18 +9312,17 @@ void nsCSSFrameConstructor::CreateNeeded
  *
  * NOTE: aContainerFrame must be a flex or grid container - this function is
  * purely for sanity-checking the children of these container types.
  * NOTE: See also NeedsAnonFlexOrGridItem(), for the non-debug version of this
  * logic (which operates a bit earlier, on FCData instead of frames).
  */
 static bool FrameWantsToBeInAnonymousItem(const nsIFrame* aContainerFrame,
                                           const nsIFrame* aFrame) {
-  MOZ_ASSERT(aContainerFrame->IsFlexOrGridContainer() ||
-             aContainerFrame->IsXULBoxFrame());
+  MOZ_ASSERT(aContainerFrame->IsFlexOrGridContainer());
 
   // Any line-participant frames (e.g. text) definitely want to be wrapped in
   // an anonymous flex/grid item.
   if (aFrame->IsFrameOfType(nsIFrame::eLineParticipant)) {
     return true;
   }
 
   // If the container is a -webkit-{inline-}box container, then placeholders
@@ -9350,18 +9334,17 @@ static bool FrameWantsToBeInAnonymousIte
 
   return false;
 }
 #endif
 
 static void VerifyGridFlexContainerChildren(nsIFrame* aParentFrame,
                                             const nsFrameList& aChildren) {
 #ifdef DEBUG
-  if (!aParentFrame->IsFlexOrGridContainer() &&
-      !aParentFrame->IsXULBoxFrame()) {
+  if (!aParentFrame->IsFlexOrGridContainer()) {
     return;
   }
 
   bool prevChildWasAnonItem = false;
   for (const nsIFrame* child : aChildren) {
     MOZ_ASSERT(!FrameWantsToBeInAnonymousItem(aParentFrame, child),
                "frame wants to be inside an anonymous item, but it isn't");
     if (IsAnonymousItem(child)) {
@@ -9798,19 +9781,16 @@ void nsCSSFrameConstructor::ProcessChild
   } else {
     ClearLazyBits(aContent->GetFirstChild(), nullptr);
   }
 
   ConstructFramesFromItemList(aState, itemsToConstruct, aFrame,
                               /* aParentIsWrapperAnonBox = */ false,
                               aFrameList);
 
-  NS_ASSERTION(!allowFirstPseudos || !aFrame->IsXULBoxFrame(),
-               "can't be both block and box");
-
   if (listItem) {
     if (auto* markerFrame = nsLayoutUtils::GetMarkerFrame(aContent)) {
       for (auto* childFrame : aFrameList) {
         if (markerFrame == childFrame) {
           if (isOutsideMarker) {
             // SetMarkerFrameForListItem will add childFrame to the
             // FrameChildListID::Bullet
             aFrameList.RemoveFrame(childFrame);
@@ -11353,20 +11333,20 @@ bool nsCSSFrameConstructor::WipeContaini
                                  InsertionKind::Async);
         return true;
       }
     }
   }
 
   nsIFrame* nextSibling = ::GetInsertNextSibling(aFrame, aPrevSibling);
 
-  // Situation #2 is a flex / grid / XUL box container frame into which we're
-  // inserting new inline non-replaced children, adjacent to an existing
-  // anonymous flex or grid item.
-  if (aFrame->IsFlexOrGridContainer() || aFrame->IsXULBoxFrame()) {
+  // Situation #2 is a flex / grid  container frame into which we're inserting
+  // new inline non-replaced children, adjacent to an existing anonymous flex or
+  // grid item.
+  if (aFrame->IsFlexOrGridContainer()) {
     FCItemIterator iter(aItems);
 
     // Check if we're adding to-be-wrapped content right *after* an existing
     // anonymous flex or grid item (which would need to absorb this content).
     const bool isLegacyWebKitBox = IsFlexContainerForLegacyWebKitBox(aFrame);
     if (aPrevSibling && IsAnonymousItem(aPrevSibling) &&
         iter.item().NeedsAnonFlexOrGridItem(aState, isLegacyWebKitBox)) {
       TRACE("Inserting inline after anon flex or grid item");

--- a/layout/base/nsCSSFrameConstructor.h
+++ b/layout/base/nsCSSFrameConstructor.h
@@ -1564,17 +1564,16 @@ class nsCSSFrameConstructor final : publ
                                                   nsIFrame* aParentFrame,
                                                   bool aIsWithinSVGText,
                                                   bool aAllowsTextPathChild,
                                                   ComputedStyle&);
 
   // Not static because it does PropagateScrollToViewport.  If this
   // changes, make this static.
   const FrameConstructionData* FindDisplayData(const nsStyleDisplay&,
-                                               mozilla::StyleMozBoxLayout,
                                                const Element&);
 
   /**
    * Construct a scrollable block frame
    */
   nsIFrame* ConstructScrollableBlock(nsFrameConstructorState& aState,
                                      FrameConstructionItem& aItem,
                                      nsContainerFrame* aParentFrame,

--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -623,17 +623,16 @@ LogicalSize nsTextControlFrame::ComputeA
               aBorderPadding, aSizeOverrides, aFlags)
               .ISize(aWM);
     }
 #ifdef DEBUG
     else {
       LogicalSize ancestorAutoSize = nsContainerFrame::ComputeAutoSize(
           aRenderingContext, aWM, aCBSize, aAvailableISize, aMargin,
           aBorderPadding, aSizeOverrides, aFlags);
-      // Disabled when there's inflation; see comment in GetXULPrefSize.
       MOZ_ASSERT(inflation != 1.0f ||
                      ancestorAutoSize.ISize(aWM) == autoSize.ISize(aWM),
                  "Incorrect size computed by ComputeAutoSize?");
     }
 #endif
   }
   return autoSize;
 }
@@ -812,26 +811,16 @@ void nsTextControlFrame::ReflowTextContr
   // place the child
   FinishReflowChild(aKid, aPresContext, desiredSize, &kidReflowInput, wm,
                     position, containerSize, ReflowChildFlags::Default);
 
   // consider the overflow
   aParentDesiredSize.mOverflowAreas.UnionWith(desiredSize.mOverflowAreas);
 }
 
-nsSize nsTextControlFrame::GetXULMinSize(nsBoxLayoutState& aState) {
-  // XXXbz why?  Why not the nsBoxFrame sizes?
-  return nsIFrame::GetUncachedXULMinSize(aState);
-}
-
-bool nsTextControlFrame::IsXULCollapsed() {
-  // We're never collapsed in the box sense.
-  return false;
-}
-
 // IMPLEMENTING NS_IFORMCONTROLFRAME
 void nsTextControlFrame::SetFocus(bool aOn, bool aRepaint) {
   TextControlElement* textControlElement =
       TextControlElement::FromNode(GetContent());
   MOZ_ASSERT(textControlElement);
 
   // If 'dom.placeholeder.show_on_focus' preference is 'false', focusing or
   // blurring the frame can have an impact on the placeholder visibility.

--- a/layout/forms/nsTextControlFrame.h
+++ b/layout/forms/nsTextControlFrame.h
@@ -95,19 +95,16 @@ class nsTextControlFrame : public nsCont
     }
     NS_ASSERTION(aFirstBaseline != NS_INTRINSIC_ISIZE_UNKNOWN,
                  "please call Reflow before asking for the baseline");
     return mozilla::Some(aBaselineGroup == BaselineSharingGroup::First
                              ? aFirstBaseline
                              : aFrame->BSize(aWM) - aFirstBaseline);
   }
 
-  nsSize GetXULMinSize(nsBoxLayoutState&) override;
-  bool IsXULCollapsed() override;
-
 #ifdef ACCESSIBILITY
   mozilla::a11y::AccType AccessibleType() override;
 #endif
 
 #ifdef DEBUG_FRAME_DUMP
   nsresult GetFrameName(nsAString& aResult) const override {
     aResult.AssignLiteral("nsTextControlFrame");
     return NS_OK;

--- a/layout/generic/CSSOrderAwareFrameIterator.cpp
+++ b/layout/generic/CSSOrderAwareFrameIterator.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* Iterator class for frame lists that respect CSS "order" during layout */
 
 #include "CSSOrderAwareFrameIterator.h"
 #include "nsIFrameInlines.h"
 
 static bool CanUse(const nsIFrame* aFrame) {
-  return aFrame->IsFlexOrGridContainer() || aFrame->IsXULBoxFrame() ||
+  return aFrame->IsFlexOrGridContainer() ||
          (aFrame->GetContent() && aFrame->GetContent()->IsAnyOfXULElements(
                                       nsGkAtoms::treecols, nsGkAtoms::treecol));
 }
 
 namespace mozilla {
 
 template <>
 bool CSSOrderAwareFrameIterator::CanUse(const nsIFrame* aFrame) {

--- a/layout/generic/FrameClasses.py
+++ b/layout/generic/FrameClasses.py
@@ -5,18 +5,16 @@
 
 from FrameClass import DYNAMIC_LEAF, LEAF, NOT_LEAF, AbstractFrame, Frame
 
 FRAME_CLASSES = [
     Frame("BRFrame", "Br", LEAF),
     Frame("nsBCTableCellFrame", "TableCell", NOT_LEAF),
     Frame("nsBackdropFrame", "Backdrop", LEAF),
     Frame("nsBlockFrame", "Block", NOT_LEAF),
-    Frame("nsBox", "None", NOT_LEAF),
-    Frame("nsButtonBoxFrame", "Box", NOT_LEAF),
     Frame("nsCanvasFrame", "Canvas", NOT_LEAF),
     Frame("nsCheckboxRadioFrame", "CheckboxRadio", LEAF),
     Frame("nsColorControlFrame", "ColorControl", LEAF),
     Frame("nsColumnSetFrame", "ColumnSet", NOT_LEAF),
     Frame("ColumnSetWrapperFrame", "ColumnSetWrapper", NOT_LEAF),
     Frame("nsComboboxControlFrame", "ComboboxControl", NOT_LEAF),
     Frame("nsComboboxDisplayFrame", "ComboboxDisplay", NOT_LEAF),
     Frame("nsContinuingTextFrame", "Text", LEAF),
@@ -34,17 +32,16 @@ FRAME_CLASSES = [
     Frame("nsHTMLCanvasFrame", "HTMLCanvas", NOT_LEAF),
     Frame("nsHTMLFramesetBlankFrame", "None", LEAF),
     Frame("nsHTMLFramesetBorderFrame", "None", LEAF),
     Frame("nsHTMLFramesetFrame", "FrameSet", LEAF),
     Frame("nsHTMLScrollFrame", "Scroll", NOT_LEAF),
     Frame("nsImageControlFrame", "ImageControl", LEAF),
     Frame("nsImageFrame", "Image", DYNAMIC_LEAF),
     Frame("nsInlineFrame", "Inline", NOT_LEAF),
-    Frame("nsLeafBoxFrame", "LeafBox", LEAF),
     Frame("nsListControlFrame", "ListControl", NOT_LEAF),
     Frame("nsMathMLFrame", "None", NOT_LEAF),
     Frame("nsMathMLmactionFrame", "None", NOT_LEAF),
     Frame("nsMathMLmathBlockFrame", "Block", NOT_LEAF),
     Frame("nsMathMLmathInlineFrame", "Inline", NOT_LEAF),
     Frame("nsMathMLmencloseFrame", "None", NOT_LEAF),
     Frame("nsMathMLmfracFrame", "None", NOT_LEAF),
     Frame("nsMathMLmmultiscriptsFrame", "None", NOT_LEAF),
@@ -78,17 +75,17 @@ FRAME_CLASSES = [
     Frame("nsRubyTextFrame", "RubyText", NOT_LEAF),
     Frame("SimpleXULLeafFrame", "SimpleXULLeaf", LEAF),
     Frame("nsScrollbarButtonFrame", "SimpleXULLeaf", LEAF),
     Frame("nsScrollbarFrame", "Scrollbar", NOT_LEAF),
     Frame("nsSearchControlFrame", "SearchControl", LEAF),
     Frame("nsSelectsAreaFrame", "Block", NOT_LEAF),
     Frame("nsPageSequenceFrame", "PageSequence", NOT_LEAF),
     Frame("nsSliderFrame", "Slider", NOT_LEAF),
-    Frame("nsSplitterFrame", "Box", NOT_LEAF),
+    Frame("nsSplitterFrame", "SimpleXULLeaf", NOT_LEAF),
     Frame("nsSubDocumentFrame", "SubDocument", LEAF),
     Frame("PrintedSheetFrame", "PrintedSheet", NOT_LEAF),
     Frame("SVGAFrame", "SVGA", NOT_LEAF),
     Frame("SVGClipPathFrame", "SVGClipPath", NOT_LEAF),
     Frame("SVGContainerFrame", "None", NOT_LEAF),
     Frame("SVGFEContainerFrame", "SVGFEContainer", NOT_LEAF),
     Frame("SVGFEImageFrame", "SVGFEImage", LEAF),
     Frame("SVGFELeafFrame", "SVGFELeaf", LEAF),
@@ -121,17 +118,17 @@ FRAME_CLASSES = [
     Frame("nsTableColFrame", "TableCol", LEAF),
     Frame("nsTableColGroupFrame", "TableColGroup", NOT_LEAF),
     Frame("nsTableFrame", "Table", NOT_LEAF),
     Frame("nsTableWrapperFrame", "TableWrapper", NOT_LEAF),
     Frame("nsTableRowFrame", "TableRow", NOT_LEAF),
     Frame("nsTableRowGroupFrame", "TableRowGroup", NOT_LEAF),
     Frame("nsTextControlFrame", "TextInput", LEAF),
     Frame("nsTextFrame", "Text", LEAF),
-    Frame("nsTreeBodyFrame", "LeafBox", LEAF),
+    Frame("nsTreeBodyFrame", "SimpleXULLeaf", LEAF),
     Frame("nsVideoFrame", "HTMLVideo", NOT_LEAF),
     Frame("ViewportFrame", "Viewport", NOT_LEAF),
     Frame("WBRFrame", "Wbr", LEAF),
     # Non-concrete classes (for FrameIID use)
     AbstractFrame("MiddleCroppingBlockFrame"),
     AbstractFrame("nsContainerFrame"),
     AbstractFrame("nsLeafFrame"),
     AbstractFrame("nsMathMLContainerFrame"),

--- a/layout/generic/ReflowInput.cpp
+++ b/layout/generic/ReflowInput.cpp
@@ -692,18 +692,17 @@ void ReflowInput::InitResizeFlags(nsPres
   }
 
   bool dependsOnCBBSize = (mStylePosition->BSizeDependsOnContainer(wm) &&
                            // FIXME: condition this on not-abspos?
                            !mStylePosition->BSize(wm).IsAuto()) ||
                           mStylePosition->MinBSizeDependsOnContainer(wm) ||
                           mStylePosition->MaxBSizeDependsOnContainer(wm) ||
                           mStylePosition->mOffset.GetBStart(wm).HasPercent() ||
-                          !mStylePosition->mOffset.GetBEnd(wm).IsAuto() ||
-                          mFrame->IsXULBoxFrame();
+                          !mStylePosition->mOffset.GetBEnd(wm).IsAuto();
 
   // If mFrame is a flex item, and mFrame's block axis is the flex container's
   // main axis (e.g. in a column-oriented flex container with same
   // writing-mode), then its block-size depends on its CB size, if its
   // flex-basis has a percentage.
   if (mFrame->IsFlexItem() &&
       !nsFlexContainerFrame::IsItemInlineAxisMainAxis(mFrame)) {
     const auto& flexBasis = mStylePosition->mFlexBasis;
@@ -1036,22 +1035,16 @@ void ReflowInput::ApplyRelativePositioni
   nsPoint pos =
       aPosition->GetPhysicalPoint(aWritingMode, aContainerSize - frameSize);
   ApplyRelativePositioning(
       aFrame, aComputedOffsets.GetPhysicalMargin(aWritingMode), &pos);
   *aPosition =
       mozilla::LogicalPoint(aWritingMode, pos, aContainerSize - frameSize);
 }
 
-// Returns true if aFrame is non-null, a XUL frame, and "XUL-collapsed" (which
-// only becomes a valid question to ask if we know it's a XUL frame).
-static bool IsXULCollapsedXULFrame(nsIFrame* aFrame) {
-  return aFrame && aFrame->IsXULBoxFrame() && aFrame->IsXULCollapsed();
-}
-
 nsIFrame* ReflowInput::GetHypotheticalBoxContainer(nsIFrame* aFrame,
                                                    nscoord& aCBIStartEdge,
                                                    LogicalSize& aCBSize) const {
   aFrame = aFrame->GetContainingBlock();
   NS_ASSERTION(aFrame != mFrame, "How did that happen?");
 
   /* Now aFrame is the containing block we want */
 
@@ -1076,31 +1069,20 @@ nsIFrame* ReflowInput::GetHypotheticalBo
   } else {
     /* Didn't find a reflow reflowInput for aFrame.  Just compute the
        information we want, on the assumption that aFrame already knows its
        size.  This really ought to be true by now. */
     NS_ASSERTION(!aFrame->HasAnyStateBits(NS_FRAME_IN_REFLOW),
                  "aFrame shouldn't be in reflow; we'll lie if it is");
     WritingMode wm = aFrame->GetWritingMode();
     // Compute CB's offset & content-box size by subtracting borderpadding from
-    // frame size.  Exception: if the CB is 0-sized, it *might* be a child of a
-    // XUL-collapsed frame and might have nonzero borderpadding that was simply
-    // discarded during its layout. (See the child-zero-sizing in
-    // nsSprocketLayout::XULLayout()).  In that case, we ignore the
-    // borderpadding here (just like we did when laying it out), or else we'd
-    // produce a bogus negative content-box size.
-    aCBIStartEdge = 0;
-    aCBSize = aFrame->GetLogicalSize(wm);
-    if (!aCBSize.IsAllZero() || !IsXULCollapsedXULFrame(aFrame->GetParent())) {
-      // aFrame is not XUL-collapsed (nor is it a child of a XUL-collapsed
-      // frame), so we can go ahead and subtract out border padding.
-      LogicalMargin borderPadding = aFrame->GetLogicalUsedBorderAndPadding(wm);
-      aCBIStartEdge += borderPadding.IStart(wm);
-      aCBSize -= borderPadding.Size(wm);
-    }
+    // frame size.
+    const auto& bp = aFrame->GetLogicalUsedBorderAndPadding(wm);
+    aCBIStartEdge = bp.IStart(wm);
+    aCBSize = aFrame->GetLogicalSize(wm) - bp.Size(wm);
   }
 
   return aFrame;
 }
 
 struct nsHypotheticalPosition {
   // offset from inline-start edge of containing block (which is a padding edge)
   nscoord mIStart;
@@ -2147,21 +2129,16 @@ LogicalSize ReflowInput::ComputeContaini
 
 // XXX refactor this code to have methods for each set of properties
 // we are computing: width,height,line-height; margin; offsets
 
 void ReflowInput::InitConstraints(
     nsPresContext* aPresContext, const Maybe<LogicalSize>& aContainingBlockSize,
     const Maybe<LogicalMargin>& aBorder, const Maybe<LogicalMargin>& aPadding,
     LayoutFrameType aFrameType) {
-  MOZ_ASSERT(!mStyleDisplay->IsFloating(mFrame) ||
-                 (mStyleDisplay->mDisplay != StyleDisplay::MozBox &&
-                  mStyleDisplay->mDisplay != StyleDisplay::MozInlineBox),
-             "Please don't try to float a -moz-box or a -moz-inline-box");
-
   WritingMode wm = GetWritingMode();
   LogicalSize cbSize = aContainingBlockSize.valueOr(
       LogicalSize(mWritingMode, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE));
   DISPLAY_INIT_CONSTRAINTS(mFrame, this, cbSize.ISize(wm), cbSize.BSize(wm),
                            aBorder, aPadding);
 
   // If this is a reflow root, then set the computed width and
   // height equal to the available space

--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -30,17 +30,16 @@
 #include "nsGkAtoms.h"
 #include "nsViewManager.h"
 #include "nsIWidget.h"
 #include "nsCanvasFrame.h"
 #include "nsCSSRendering.h"
 #include "nsError.h"
 #include "nsDisplayList.h"
 #include "nsIBaseWindow.h"
-#include "nsBoxLayoutState.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsBlockFrame.h"
 #include "nsPlaceholderFrame.h"
 #include "mozilla/AutoRestore.h"
 #include "nsIFrameInlines.h"
 #include "nsPrintfCString.h"
 #include "mozilla/webrender/WebRenderAPI.h"
 #include <algorithm>

--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -49,17 +49,16 @@ static mozilla::LazyLogModule gFlexConta
 // Returns true if aFlexContainer is a frame for some element that has
 // display:-webkit-{inline-}box (or -moz-{inline-}box). aFlexContainer is
 // expected to be an instance of nsFlexContainerFrame (enforced with an assert);
 // otherwise, this function's state-bit-check here is bogus.
 static bool IsLegacyBox(const nsIFrame* aFlexContainer) {
   MOZ_ASSERT(aFlexContainer->IsFlexContainerFrame(),
              "only flex containers may be passed to this function");
   return aFlexContainer->HasAnyStateBits(
-      NS_STATE_FLEX_IS_EMULATING_LEGACY_MOZ_BOX |
       NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX);
 }
 
 // Returns the OrderState enum we should pass to CSSOrderAwareFrameIterator
 // (depending on whether aFlexContainer has
 // NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER state bit).
 static CSSOrderAwareFrameIterator::OrderState OrderStateForIter(
     const nsFlexContainerFrame* aFlexContainer) {
@@ -2742,19 +2741,17 @@ void nsFlexContainerFrame::Init(nsIConte
                "The only way a nsFlexContainerFrame can have 'display:block' "
                "should be if it's the inner part of a scrollable or button "
                "element");
     displayInside = GetParent()->StyleDisplay()->DisplayInside();
   }
 
   // Figure out if we should set a frame state bit to indicate that this frame
   // represents a legacy -moz-{inline-}box or -webkit-{inline-}box container.
-  if (displayInside == StyleDisplayInside::MozBox) {
-    AddStateBits(NS_STATE_FLEX_IS_EMULATING_LEGACY_MOZ_BOX);
-  } else if (displayInside == StyleDisplayInside::WebkitBox) {
+  if (displayInside == StyleDisplayInside::WebkitBox) {
     AddStateBits(NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX);
   }
 }
 
 #ifdef DEBUG_FRAME_DUMP
 nsresult nsFlexContainerFrame::GetFrameName(nsAString& aResult) const {
   return MakeFrameName(u"FlexContainer"_ns, aResult);
 }
@@ -3845,17 +3842,17 @@ FlexboxAxisInfo::FlexboxAxisInfo(const n
     InitAxesFromModernProps(aFlexContainer);
   }
 }
 
 void FlexboxAxisInfo::InitAxesFromLegacyProps(const nsIFrame* aFlexContainer) {
   const nsStyleXUL* styleXUL = aFlexContainer->StyleXUL();
 
   const bool boxOrientIsVertical =
-      (styleXUL->mBoxOrient == StyleBoxOrient::Vertical);
+      styleXUL->mBoxOrient == StyleBoxOrient::Vertical;
   const bool wmIsVertical = aFlexContainer->GetWritingMode().IsVertical();
 
   // If box-orient agrees with our writing-mode, then we're "row-oriented"
   // (i.e. the flexbox main axis is the same as our writing mode's inline
   // direction).  Otherwise, we're column-oriented (i.e. the flexbox's main
   // axis is perpendicular to the writing-mode's inline direction).
   mIsRowOriented = (boxOrientIsVertical == wmIsVertical);
 
@@ -4927,17 +4924,17 @@ bool nsFlexContainerFrame::IsItemInlineA
   const WritingMode flexItemWM = aFrame->GetWritingMode();
   const nsIFrame* flexContainer = aFrame->GetParent();
 
   if (IsLegacyBox(flexContainer)) {
     // For legacy boxes, the main axis is determined by "box-orient", and we can
     // just directly check if that's vertical, and compare that to whether the
     // item's WM is also vertical:
     bool boxOrientIsVertical =
-        (flexContainer->StyleXUL()->mBoxOrient == StyleBoxOrient::Vertical);
+        flexContainer->StyleXUL()->mBoxOrient == StyleBoxOrient::Vertical;
     return flexItemWM.IsVertical() == boxOrientIsVertical;
   }
 
   // For modern CSS flexbox, we get our return value by asking two questions
   // and comparing their answers.
   // Question 1: does aFrame have the same inline axis as its flex container?
   bool itemInlineAxisIsParallelToParent =
       !flexItemWM.IsOrthogonalTo(flexContainer->GetWritingMode());

--- a/layout/generic/nsFrameStateBits.h
+++ b/layout/generic/nsFrameStateBits.h
@@ -318,34 +318,30 @@ FRAME_STATE_BIT(Generic, 59, NS_FRAME_IS
 FRAME_STATE_GROUP(FlexContainer, nsFlexContainerFrame)
 
 // True iff the normal flow children are already in CSS 'order' in the
 // order they occur in the child frame list.
 FRAME_STATE_BIT(FlexContainer, 20,
                 NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER)
 
 // Set for a flex container that is emulating a legacy
-// 'display:-moz-{inline-}box' container.
-FRAME_STATE_BIT(FlexContainer, 21, NS_STATE_FLEX_IS_EMULATING_LEGACY_MOZ_BOX)
-
-// Set for a flex container that is emulating a legacy
 // 'display:-webkit-{inline-}box'.
-FRAME_STATE_BIT(FlexContainer, 22, NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX)
+FRAME_STATE_BIT(FlexContainer, 21, NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX)
 
 // True if the container has no flex items; may lie if there is a pending reflow
-FRAME_STATE_BIT(FlexContainer, 23, NS_STATE_FLEX_SYNTHESIZE_BASELINE)
+FRAME_STATE_BIT(FlexContainer, 22, NS_STATE_FLEX_SYNTHESIZE_BASELINE)
 
 // True iff some first-in-flow in-flow children were pushed.
 // Note that those child frames may have been removed without this bit
 // being updated for performance reasons, so code shouldn't depend on
 // actually finding any pushed items when this bit is set.
-FRAME_STATE_BIT(FlexContainer, 24, NS_STATE_FLEX_DID_PUSH_ITEMS)
+FRAME_STATE_BIT(FlexContainer, 23, NS_STATE_FLEX_DID_PUSH_ITEMS)
 
 // We've merged some OverflowList children since last reflow.
-FRAME_STATE_BIT(FlexContainer, 25, NS_STATE_FLEX_HAS_CHILD_NIFS)
+FRAME_STATE_BIT(FlexContainer, 24, NS_STATE_FLEX_HAS_CHILD_NIFS)
 
 // == Frame state bits that apply to grid container frames ====================
 
 FRAME_STATE_GROUP(GridContainer, nsGridContainerFrame)
 
 // True iff the normal flow children are already in CSS 'order' in the
 // order they occur in the child frame list.
 FRAME_STATE_BIT(GridContainer, 20,

--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -19,17 +19,16 @@
 #include "nsViewportInfo.h"
 #include "nsContainerFrame.h"
 #include "nsGkAtoms.h"
 #include "nsNameSpaceManager.h"
 #include "mozilla/intl/BidiEmbeddingLevel.h"
 #include "mozilla/dom/DocumentInlines.h"
 #include "mozilla/gfx/gfxVars.h"
 #include "nsFontMetrics.h"
-#include "nsBoxLayoutState.h"
 #include "mozilla/dom/NodeInfo.h"
 #include "nsScrollbarFrame.h"
 #include "nsINode.h"
 #include "nsIScrollbarMediator.h"
 #include "nsITextControlFrame.h"
 #include "nsILayoutHistoryState.h"
 #include "nsNodeInfoManager.h"
 #include "nsContentCreatorFunctions.h"
@@ -530,29 +529,27 @@ ScrollReflowInput::ScrollReflowInput(nsH
 
   if (nsScrollbarFrame* scrollbar = aFrame->GetScrollbarBox(false)) {
     scrollbar->SetScrollbarMediatorContent(mReflowInput.mFrame->GetContent());
     mHScrollbarPrefSize = scrollbar->ScrollbarMinSize();
     // A zero minimum size is a bug with non-overlay scrollbars. That means
     // we'll always try to place the scrollbar, even if it will ultimately not
     // fit, see bug 1809630. XUL collapsing is the exception because the
     // front-end uses it.
-    MOZ_ASSERT(scrollbar->IsXULCollapsed() ||
-                   (mHScrollbarPrefSize.width && mHScrollbarPrefSize.height),
+    MOZ_ASSERT(mHScrollbarPrefSize.width && mHScrollbarPrefSize.height,
                "Shouldn't have a zero horizontal scrollbar-size");
   } else {
     mHScrollbar = ShowScrollbar::Never;
     mHScrollbarAllowedForScrollingVVInsideLV = false;
   }
   if (nsScrollbarFrame* scrollbar = aFrame->GetScrollbarBox(true)) {
     scrollbar->SetScrollbarMediatorContent(mReflowInput.mFrame->GetContent());
     mVScrollbarPrefSize = scrollbar->ScrollbarMinSize();
     // See above.
-    MOZ_ASSERT(scrollbar->IsXULCollapsed() ||
-                   (mVScrollbarPrefSize.width && mVScrollbarPrefSize.height),
+    MOZ_ASSERT(mVScrollbarPrefSize.width && mVScrollbarPrefSize.height,
                "Shouldn't have a zero vertical scrollbar-size");
   } else {
     mVScrollbar = ShowScrollbar::Never;
     mVScrollbarAllowedForScrollingVVInsideLV = false;
   }
 
   const auto* scrollbarStyle =
       nsLayoutUtils::StyleForScrollbar(mReflowInput.mFrame);
@@ -1279,29 +1276,16 @@ nscoord nsHTMLScrollFrame::GetPrefISize(
   nscoord result = containISize
                        ? *containISize
                        : mScrolledFrame->GetPrefISize(aRenderingContext);
   DISPLAY_PREF_INLINE_SIZE(this, result);
   return NSCoordSaturatingAdd(
       result, IntrinsicScrollbarGutterSizeAtInlineEdges(aRenderingContext));
 }
 
-nsresult nsHTMLScrollFrame::GetXULPadding(nsMargin& aMargin) {
-  // Our padding hangs out on the inside of the scrollframe, but XUL doesn't
-  // realize that.
-  // TODO: Remove as more XUL layout is removed.
-  aMargin.SizeTo(0, 0, 0, 0);
-  return NS_OK;
-}
-
-bool nsHTMLScrollFrame::IsXULCollapsed() {
-  // We're never collapsed in the box sense.
-  return false;
-}
-
 // When we have perspective set on the outer scroll frame, and transformed
 // children (possibly with preserve-3d) then the effective transform on the
 // child depends on the offset to the scroll frame, which changes as we scroll.
 // This perspective transform can cause the element to move relative to the
 // scrolled inner frame, which would cause the scrollable length changes during
 // scrolling if we didn't account for it. Since we don't want scrollHeight/Width
 // and the size of scrollbar thumbs to change during scrolling, we compute the
 // scrollable overflow by determining the scroll position at which the child

--- a/layout/generic/nsGfxScrollFrame.h
+++ b/layout/generic/nsGfxScrollFrame.h
@@ -12,17 +12,16 @@
 #include "mozilla/Attributes.h"
 #include "nsContainerFrame.h"
 #include "nsIAnonymousContentCreator.h"
 #include "nsIScrollableFrame.h"
 #include "nsIScrollbarMediator.h"
 #include "nsIStatefulFrame.h"
 #include "nsThreadUtils.h"
 #include "nsIReflowCallback.h"
-#include "nsBoxLayoutState.h"
 #include "nsQueryFrame.h"
 #include "nsExpirationTracker.h"
 #include "TextOverflow.h"
 #include "ScrollVelocityQueue.h"
 #include "mozilla/ScrollTypes.h"
 #include "mozilla/PresState.h"
 #include "mozilla/layout/ScrollAnchorContainer.h"
 #include "mozilla/TypedEnumBits.h"
@@ -112,18 +111,16 @@ class nsHTMLScrollFrame : public nsConta
   nscoord IntrinsicScrollbarGutterSizeAtInlineEdges(
       gfxContext* aRenderingContext);
 
   bool GetBorderRadii(const nsSize& aFrameSize, const nsSize& aBorderArea,
                       Sides aSkipSides, nscoord aRadii[8]) const final;
 
   nscoord GetMinISize(gfxContext* aRenderingContext) override;
   nscoord GetPrefISize(gfxContext* aRenderingContext) override;
-  nsresult GetXULPadding(nsMargin& aPadding) final;
-  bool IsXULCollapsed() final;
 
   void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
               const ReflowInput& aReflowInput,
               nsReflowStatus& aStatus) override;
   void DidReflow(nsPresContext* aPresContext,
                  const ReflowInput* aReflowInput) override;
 
   bool ComputeCustomOverflow(mozilla::OverflowAreas& aOverflowAreas) final;
@@ -158,18 +155,16 @@ class nsHTMLScrollFrame : public nsConta
   nsIScrollableFrame* GetScrollTargetFrame() const final {
     return const_cast<nsHTMLScrollFrame*>(this);
   }
 
   nsContainerFrame* GetContentInsertionFrame() override {
     return GetScrolledFrame()->GetContentInsertionFrame();
   }
 
-  bool DoesClipChildrenInBothAxes() final { return true; }
-
   nsPoint GetPositionOfChildIgnoringScrolling(const nsIFrame* aChild) final {
     nsPoint pt = aChild->GetPosition();
     if (aChild == GetScrolledFrame()) {
       pt += GetScrollPosition();
     }
     return pt;
   }
 

--- a/layout/generic/nsGridContainerFrame.cpp
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -22,17 +22,16 @@
 #include "mozilla/dom/GridBinding.h"
 #include "mozilla/IntegerRange.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/PodOperations.h"  // for PodZero
 #include "mozilla/Poison.h"
 #include "mozilla/PresShell.h"
 #include "nsAbsoluteContainingBlock.h"
 #include "nsAlgorithm.h"  // for clamped()
-#include "nsBoxLayoutState.h"
 #include "nsCSSAnonBoxes.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsTHashMap.h"
 #include "nsDisplayList.h"
 #include "nsHashKeys.h"
 #include "nsFieldSetFrame.h"
 #include "nsIFrameInlines.h"
 #include "nsPlaceholderFrame.h"

--- a/layout/generic/nsIFrame.cpp
+++ b/layout/generic/nsIFrame.cpp
@@ -93,17 +93,16 @@
 #include "RubyUtils.h"
 #include "TextOverflow.h"
 #include "nsAnimationManager.h"
 
 // For triple-click pref
 #include "imgIRequest.h"
 #include "nsError.h"
 #include "nsContainerFrame.h"
-#include "nsBoxLayoutState.h"
 #include "nsBlockFrame.h"
 #include "nsDisplayList.h"
 #include "nsChangeHint.h"
 #include "nsSubDocumentFrame.h"
 #include "RetainedDisplayListBuilder.h"
 
 #include "gfxContext.h"
 #include "nsAbsoluteContainingBlock.h"
@@ -184,80 +183,45 @@ const nsIFrame::FrameClassBits nsIFrame:
 #undef FRAME_ID
 #undef ABSTRACT_FRAME_ID
 };
 
 std::ostream& operator<<(std::ostream& aStream, const nsDirection& aDirection) {
   return aStream << (aDirection == eDirNext ? "eDirNext" : "eDirPrevious");
 }
 
-// Struct containing cached metrics for box-wrapped frames.
-struct nsBoxLayoutMetrics {
-  nsSize mPrefSize;
-  nsSize mMinSize;
-  nsSize mMaxSize;
-
-  nsSize mBlockMinSize;
-  nsSize mBlockPrefSize;
-  nscoord mBlockAscent;
-
-  nscoord mAscent;
-
-  nsSize mLastSize;
-};
-
 struct nsContentAndOffset {
   nsIContent* mContent = nullptr;
   int32_t mOffset = 0;
 };
 
 // Some Misc #defines
 #define SELECTION_DEBUG 0
 #define FORCE_SELECTION_UPDATE 1
 #define CALC_DEBUG 0
 
 #include "nsILineIterator.h"
 #include "prenv.h"
 
-NS_DECLARE_FRAME_PROPERTY_DELETABLE(BoxMetricsProperty, nsBoxLayoutMetrics)
-
-static void InitBoxMetrics(nsIFrame* aFrame, bool aClear) {
-  if (aClear) {
-    aFrame->RemoveProperty(BoxMetricsProperty());
-  }
-
-  nsBoxLayoutMetrics* metrics = new nsBoxLayoutMetrics();
-  aFrame->SetProperty(BoxMetricsProperty(), metrics);
-
-  aFrame->nsIFrame::MarkIntrinsicISizesDirty();
-  metrics->mBlockAscent = 0;
-  metrics->mLastSize.SizeTo(0, 0);
-}
-
 // Utility function to set a nsRect-valued property table entry on aFrame,
 // reusing the existing storage if the property happens to be already set.
 template <typename T>
 static void SetOrUpdateRectValuedProperty(
     nsIFrame* aFrame, FrameProperties::Descriptor<T> aProperty,
     const nsRect& aNewValue) {
   bool found;
   nsRect* rectStorage = aFrame->GetProperty(aProperty, &found);
   if (!found) {
     rectStorage = new nsRect(aNewValue);
     aFrame->AddProperty(aProperty, rectStorage);
   } else {
     *rectStorage = aNewValue;
   }
 }
 
-static bool IsXULBoxWrapped(const nsIFrame* aFrame) {
-  return aFrame->GetParent() && aFrame->GetParent()->IsXULBoxFrame() &&
-         !aFrame->IsXULBoxFrame();
-}
-
 /* static */
 void nsIFrame::DestroyAnonymousContent(
     nsPresContext* aPresContext, already_AddRefed<nsIContent>&& aContent) {
   if (nsCOMPtr<nsIContent> content = aContent) {
     aPresContext->EventStateManager()->NativeAnonymousContentRemoved(content);
     aPresContext->PresShell()->NativeAnonymousContentRemoved(content);
     content->UnbindFromTree();
   }
@@ -562,18 +526,17 @@ static bool IsFontSizeInflationContainer
        // Given multiple frames for the same node, only the
        // outer one should be considered a container.
        // (Important, e.g., for nsSelectsAreaFrame.)
        (aFrame->GetParent()->GetContent() == content) ||
        (content &&
         // Form controls shouldn't become inflation containers.
         (content->IsAnyOfHTMLElements(
             nsGkAtoms::option, nsGkAtoms::optgroup, nsGkAtoms::select,
-            nsGkAtoms::input, nsGkAtoms::button, nsGkAtoms::textarea)))) &&
-      !(aFrame->IsXULBoxFrame() && aFrame->GetParent()->IsXULBoxFrame());
+            nsGkAtoms::input, nsGkAtoms::button, nsGkAtoms::textarea))));
   NS_ASSERTION(!aFrame->IsFrameOfType(nsIFrame::eLineParticipant) || isInline ||
                    // br frames and mathml frames report being line
                    // participants even when their position or display is
                    // set
                    aFrame->IsBrFrame() ||
                    aFrame->IsFrameOfType(nsIFrame::eMathML),
                "line participants must not be containers");
   return !isInline;
@@ -769,18 +732,16 @@ void nsIFrame::Init(nsIContent* aContent
   }
 
   if (PresShell()->AssumeAllFramesVisible() && TrackingVisibility()) {
     IncApproximateVisibleCount();
   }
 
   DidSetComputedStyle(nullptr);
 
-  if (::IsXULBoxWrapped(this)) ::InitBoxMetrics(this, false);
-
   // For a newly created frame, we need to update this frame's visibility state.
   // Usually we update the state when the frame is restyled and has a
   // VisibilityChange change hint but we don't generate any change hints for
   // newly created frames.
   // Note: We don't need to do this for placeholders since placeholders have
   // different styles so that the styles don't have visibility:hidden even if
   // the parent has visibility:hidden style. We also don't need to update the
   // state when creating continuations because its visibility is the same as its
@@ -2485,18 +2446,17 @@ bool nsIFrame::CanBeDynamicReflowRoot() 
   if (!StaticPrefs::layout_dynamic_reflow_roots_enabled()) {
     return false;
   }
 
   auto& display = *StyleDisplay();
   if (IsFrameOfType(nsIFrame::eLineParticipant) ||
       nsStyleDisplay::IsRubyDisplayType(display.mDisplay) ||
       display.DisplayOutside() == StyleDisplayOutside::InternalTable ||
-      display.DisplayInside() == StyleDisplayInside::Table ||
-      (GetParent() && GetParent()->IsXULBoxFrame())) {
+      display.DisplayInside() == StyleDisplayInside::Table) {
     // We have a display type where 'width' and 'height' don't actually set the
     // width or height (i.e., the size depends on content).
     MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_DYNAMIC_REFLOW_ROOT),
                "should not have dynamic reflow root bit");
     return false;
   }
 
   // We can't serve as a dynamic reflow root if our used 'width' and 'height'
@@ -5883,29 +5843,16 @@ Maybe<nsIFrame::Cursor> nsIFrame::GetCur
 
   return Some(Cursor{kind, AllowCustomCursorImage::Yes});
 }
 
 // Resize and incremental reflow
 
 /* virtual */
 void nsIFrame::MarkIntrinsicISizesDirty() {
-  // This version is meant only for what used to be box-to-block adaptors.
-  // It should not be called by other derived classes.
-  if (::IsXULBoxWrapped(this)) {
-    nsBoxLayoutMetrics* metrics = BoxMetrics();
-
-    XULSizeNeedsRecalc(metrics->mPrefSize);
-    XULSizeNeedsRecalc(metrics->mMinSize);
-    XULSizeNeedsRecalc(metrics->mMaxSize);
-    XULSizeNeedsRecalc(metrics->mBlockPrefSize);
-    XULSizeNeedsRecalc(metrics->mBlockMinSize);
-    XULCoordNeedsRecalc(metrics->mAscent);
-  }
-
   // If we're a flex item, clear our flex-item-specific cached measurements
   // (which likely depended on our now-stale intrinsic isize).
   if (IsFlexItem()) {
     nsFlexContainerFrame::MarkCachedFlexMeasurementsDirty(this);
   }
 
   if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT)) {
     nsFontInflationData::MarkFontInflationDataTextDirty(this);
@@ -5930,18 +5877,17 @@ void nsIFrame::MarkSubtreeDirty() {
   AutoTArray<nsIFrame*, 32> stack;
   for (const auto& childLists : ChildLists()) {
     for (nsIFrame* kid : childLists.mList) {
       stack.AppendElement(kid);
     }
   }
   while (!stack.IsEmpty()) {
     nsIFrame* f = stack.PopLastElement();
-    if (f->HasAnyStateBits(NS_FRAME_IS_DIRTY) || f->IsTableColGroupFrame() ||
-        f->IsXULBoxFrame()) {
+    if (f->HasAnyStateBits(NS_FRAME_IS_DIRTY) || f->IsTableColGroupFrame()) {
       continue;
     }
 
     f->AddStateBits(NS_FRAME_IS_DIRTY);
 
     for (const auto& childLists : f->ChildLists()) {
       for (nsIFrame* kid : childLists.mList) {
         stack.AppendElement(kid);
@@ -6344,18 +6290,17 @@ nsIFrame::SizeComputationResult nsIFrame
     if (isGridItem) {
       // When resolving justify/align-self below, we want to use the grid
       // container's justify/align-items value and WritingMode.
       alignCB = grandParent;
     }
   }
   const bool isFlexItem =
       IsFlexItem() && !parentFrame->HasAnyStateBits(
-                          NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX |
-                          NS_STATE_FLEX_IS_EMULATING_LEGACY_MOZ_BOX);
+                          NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX);
   // This variable only gets set (and used) if isFlexItem is true.  It
   // indicates which axis (in this frame's own WM) corresponds to its
   // flex container's main axis.
   LogicalAxis flexMainAxis =
       eLogicalAxisInline;  // (init to make valgrind happy)
   if (isFlexItem) {
     flexMainAxis = nsFlexContainerFrame::IsItemInlineAxisMainAxis(this)
                        ? eLogicalAxisInline
@@ -7938,24 +7883,20 @@ bool nsIFrame::UpdateOverflow() {
     // have scheduled any necessary reflows. We can return false to say nothing
     // changed, and wait for reflow to correct it.
     return false;
   }
 
   UnionChildOverflow(overflowAreas);
 
   if (FinishAndStoreOverflow(overflowAreas, GetSize())) {
-    nsView* view = GetView();
-    if (view) {
-      ReflowChildFlags flags = GetXULLayoutFlags();
-      if (!(flags & ReflowChildFlags::NoSizeView)) {
-        // Make sure the frame's view is properly sized.
-        nsViewManager* vm = view->GetViewManager();
-        vm->ResizeView(view, overflowAreas.InkOverflow(), true);
-      }
+    if (nsView* view = GetView()) {
+      // Make sure the frame's view is properly sized.
+      nsViewManager* vm = view->GetViewManager();
+      vm->ResizeView(view, overflowAreas.InkOverflow(), true);
     }
 
     return true;
   }
 
   // Frames that combine their 3d transform with their ancestors
   // only compute a pre-transform overflow rect, and then contribute
   // to the normal overflow rect of the preserve-3d root. Always return
@@ -7964,20 +7905,26 @@ bool nsIFrame::UpdateOverflow() {
   return Combines3DTransformWithAncestors();
 }
 
 /* virtual */
 bool nsIFrame::ComputeCustomOverflow(OverflowAreas& aOverflowAreas) {
   return true;
 }
 
+bool nsIFrame::DoesClipChildrenInBothAxes() const {
+  nsIScrollableFrame* sf = do_QueryFrame(this);
+  const nsStyleDisplay* display = StyleDisplay();
+  return sf || (display->mOverflowX == StyleOverflow::Clip &&
+                display->mOverflowY == StyleOverflow::Clip);
+}
+
 /* virtual */
 void nsIFrame::UnionChildOverflow(OverflowAreas& aOverflowAreas) {
-  if (!DoesClipChildrenInBothAxes() &&
-      !(IsXULCollapsed() && (IsXULBoxFrame() || ::IsXULBoxWrapped(this)))) {
+  if (!DoesClipChildrenInBothAxes()) {
     nsLayoutUtils::UnionChildOverflow(this, aOverflowAreas);
   }
 }
 
 // Return true if this form control element's preferred size property (but not
 // percentage max size property) contains a percentage value that should be
 // resolved against zero when calculating its min-content contribution in the
 // corresponding axis.
@@ -10083,29 +10030,16 @@ bool nsIFrame::FinishAndStoreOverflow(Ov
   // dimension(s). The children are actually clipped to the padding-box, but
   // since the overflow area should include the entire border-box, just set it
   // to the border-box size here.
   if (overflowClipAxes != PhysicalAxes::None) {
     aOverflowAreas.ApplyClipping(bounds, overflowClipAxes,
                                  OverflowClipMargin(overflowClipAxes));
   }
 
-  // Note that StyleOverflow::Clip doesn't clip the frame
-  // background, so we add theme background overflow here so it's not clipped.
-  if (!::IsXULBoxWrapped(this) && IsThemed(disp)) {
-    nsRect r(bounds);
-    nsPresContext* presContext = PresContext();
-    if (presContext->Theme()->GetWidgetOverflow(
-            presContext->DeviceContext(), this, disp->EffectiveAppearance(),
-            &r)) {
-      nsRect& vo = aOverflowAreas.InkOverflow();
-      vo = vo.UnionEdges(r);
-    }
-  }
-
   ComputeAndIncludeOutlineArea(this, aOverflowAreas, aNewSize);
 
   // Nothing in here should affect scrollable overflow.
   aOverflowAreas.InkOverflow() =
       ComputeEffectsRect(this, aOverflowAreas.InkOverflow(), aNewSize);
 
   // Absolute position clipping
   const nsStyleEffects* effects = StyleEffects();
@@ -10696,510 +10630,16 @@ Maybe<StyleVerticalAlignKeyword> nsIFram
   const auto& verticalAlign = StyleDisplay()->mVerticalAlign;
   if (verticalAlign.IsKeyword()) {
     return Some(verticalAlign.AsKeyword());
   }
 
   return Nothing();
 }
 
-NS_IMETHODIMP
-nsIFrame::RefreshSizeCache(nsBoxLayoutState& aState) {
-  // XXXbz this comment needs some rewriting to make sense in the
-  // post-reflow-branch world.
-
-  // Ok we need to compute our minimum, preferred, and maximum sizes.
-  // 1) Maximum size. This is easy. Its infinite unless it is overloaded by CSS.
-  // 2) Preferred size. This is a little harder. This is the size the
-  //    block would be if it were laid out on an infinite canvas. So we can
-  //    get this by reflowing the block with and INTRINSIC width and height. We
-  //    can also do a nice optimization for incremental reflow. If the reflow is
-  //    incremental then we can pass a flag to have the block compute the
-  //    preferred width for us! Preferred height can just be the minimum height;
-  // 3) Minimum size. This is a toughy. We can pass the block a flag asking for
-  //    the max element size. That would give us the width. Unfortunately you
-  //    can only ask for a maxElementSize during an incremental reflow. So on
-  //    other reflows we will just have to use 0. The min height on the other
-  //    hand is fairly easy we need to get the largest line height. This can be
-  //    done with the line iterator.
-
-  // if we do have a rendering context
-  gfxContext* rendContext = aState.GetRenderingContext();
-  if (rendContext) {
-    nsPresContext* presContext = aState.PresContext();
-
-    // If we don't have any HTML constraints and it's a resize, then nothing in
-    // the block could have changed, so no refresh is necessary.
-    nsBoxLayoutMetrics* metrics = BoxMetrics();
-    if (!XULNeedsRecalc(metrics->mBlockPrefSize)) {
-      return NS_OK;
-    }
-
-    // the rect we plan to size to.
-    nsRect rect = GetRect();
-
-    nsMargin bp(0, 0, 0, 0);
-    GetXULBorderAndPadding(bp);
-
-    {
-      // If we're a container for font size inflation, then shrink
-      // wrapping inside of us should not apply font size inflation.
-      AutoMaybeDisableFontInflation an(this);
-
-      metrics->mBlockPrefSize.width =
-          GetPrefISize(rendContext) + bp.LeftRight();
-      metrics->mBlockMinSize.width = GetMinISize(rendContext) + bp.LeftRight();
-    }
-
-    // do the nasty.
-    const WritingMode wm = aState.OuterReflowInput()
-                               ? aState.OuterReflowInput()->GetWritingMode()
-                               : GetWritingMode();
-    ReflowOutput desiredSize(wm);
-    BoxReflow(aState, presContext, desiredSize, rendContext, rect.x, rect.y,
-              metrics->mBlockPrefSize.width, NS_UNCONSTRAINEDSIZE);
-
-    metrics->mBlockMinSize.height = 0;
-    // ok we need the max ascent of the items on the line. So to do this
-    // ask the block for its line iterator. Get the max ascent.
-    AutoAssertNoDomMutations guard;
-    if (IsBlockFrameOrSubclass()) {
-      nsILineIterator* lines = GetLineIterator();
-      MOZ_ASSERT(lines);
-      metrics->mBlockMinSize.height = 0;
-      int32_t lineCount = lines->GetNumLines();
-      for (int32_t i = 0; i < lineCount; ++i) {
-        auto line = lines->GetLine(i).unwrap();
-
-        if (line.mLineBounds.height > metrics->mBlockMinSize.height) {
-          metrics->mBlockMinSize.height = line.mLineBounds.height;
-        }
-      }
-    } else {
-      metrics->mBlockMinSize.height = desiredSize.Height();
-    }
-
-    metrics->mBlockPrefSize.height = metrics->mBlockMinSize.height;
-
-    if (desiredSize.BlockStartAscent() == ReflowOutput::ASK_FOR_BASELINE) {
-      if (!nsLayoutUtils::GetFirstLineBaseline(wm, this,
-                                               &metrics->mBlockAscent))
-        metrics->mBlockAscent = GetLogicalBaseline(wm);
-    } else {
-      metrics->mBlockAscent = desiredSize.BlockStartAscent();
-    }
-
-#ifdef DEBUG_adaptor
-    printf("min=(%d,%d), pref=(%d,%d), ascent=%d\n",
-           metrics->mBlockMinSize.width, metrics->mBlockMinSize.height,
-           metrics->mBlockPrefSize.width, metrics->mBlockPrefSize.height,
-           metrics->mBlockAscent);
-#endif
-  }
-
-  return NS_OK;
-}
-
-nsSize nsIFrame::GetXULPrefSize(nsBoxLayoutState& aState) {
-  nsSize size(0, 0);
-  DISPLAY_PREF_SIZE(this, size);
-  // If the size is cached, and there are no HTML constraints that we might
-  // be depending on, then we just return the cached size.
-  nsBoxLayoutMetrics* metrics = BoxMetrics();
-  if (!XULNeedsRecalc(metrics->mPrefSize)) {
-    size = metrics->mPrefSize;
-    return size;
-  }
-
-  if (IsXULCollapsed()) return size;
-
-  // get our size in CSS.
-  bool widthSet, heightSet;
-  bool completelyRedefined =
-      nsIFrame::AddXULPrefSize(this, size, widthSet, heightSet);
-
-  // Refresh our caches with new sizes.
-  if (!completelyRedefined) {
-    RefreshSizeCache(aState);
-    nsSize blockSize = metrics->mBlockPrefSize;
-
-    // notice we don't need to add our borders or padding
-    // in. That's because the block did it for us.
-    if (!widthSet) size.width = blockSize.width;
-    if (!heightSet) size.height = blockSize.height;
-  }
-
-  metrics->mPrefSize = size;
-  return size;
-}
-
-nsSize nsIFrame::GetXULMinSize(nsBoxLayoutState& aState) {
-  nsSize size(0, 0);
-  DISPLAY_MIN_SIZE(this, size);
-  // Don't use the cache if we have HTMLReflowInput constraints --- they might
-  // have changed
-  nsBoxLayoutMetrics* metrics = BoxMetrics();
-  if (!XULNeedsRecalc(metrics->mMinSize)) {
-    size = metrics->mMinSize;
-    return size;
-  }
-
-  if (IsXULCollapsed()) return size;
-
-  // get our size in CSS.
-  bool widthSet, heightSet;
-  bool completelyRedefined =
-      nsIFrame::AddXULMinSize(this, size, widthSet, heightSet);
-
-  // Refresh our caches with new sizes.
-  if (!completelyRedefined) {
-    RefreshSizeCache(aState);
-    nsSize blockSize = metrics->mBlockMinSize;
-
-    if (!widthSet) size.width = blockSize.width;
-    if (!heightSet) size.height = blockSize.height;
-  }
-
-  metrics->mMinSize = size;
-  return size;
-}
-
-nsSize nsIFrame::GetXULMaxSize(nsBoxLayoutState& aState) {
-  nsSize size(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
-  DISPLAY_MAX_SIZE(this, size);
-  // Don't use the cache if we have HTMLReflowInput constraints --- they might
-  // have changed
-  nsBoxLayoutMetrics* metrics = BoxMetrics();
-  if (!XULNeedsRecalc(metrics->mMaxSize)) {
-    size = metrics->mMaxSize;
-    return size;
-  }
-
-  if (IsXULCollapsed()) return size;
-
-  size = nsIFrame::GetUncachedXULMaxSize(aState);
-  metrics->mMaxSize = size;
-
-  return size;
-}
-
-int32_t nsIFrame::GetXULFlex() const {
-  return clamped(int32_t(StyleXUL()->mBoxFlex), 0, nscoord_MAX - 1);
-}
-
-nscoord nsIFrame::GetXULBoxAscent(nsBoxLayoutState& aState) {
-  nsBoxLayoutMetrics* metrics = BoxMetrics();
-  if (!XULNeedsRecalc(metrics->mAscent)) {
-    return metrics->mAscent;
-  }
-
-  if (IsXULCollapsed()) {
-    metrics->mAscent = 0;
-  } else {
-    // Refresh our caches with new sizes.
-    RefreshSizeCache(aState);
-    metrics->mAscent = metrics->mBlockAscent;
-  }
-
-  return metrics->mAscent;
-}
-
-nsresult nsIFrame::DoXULLayout(nsBoxLayoutState& aState) {
-  nsRect ourRect(mRect);
-
-  gfxContext* rendContext = aState.GetRenderingContext();
-  nsPresContext* presContext = aState.PresContext();
-  WritingMode ourWM = GetWritingMode();
-  const WritingMode outerWM = aState.OuterReflowInput()
-                                  ? aState.OuterReflowInput()->GetWritingMode()
-                                  : ourWM;
-  ReflowOutput desiredSize(outerWM);
-  LogicalSize ourSize = GetLogicalSize(outerWM);
-
-  if (rendContext) {
-    BoxReflow(aState, presContext, desiredSize, rendContext, ourRect.x,
-              ourRect.y, ourRect.width, ourRect.height);
-
-    if (IsXULCollapsed()) {
-      SetSize(nsSize(0, 0));
-    } else {
-      // if our child needs to be bigger. This might happend with
-      // wrapping text. There is no way to predict its height until we
-      // reflow it. Now that we know the height reshuffle upward.
-      if (desiredSize.ISize(outerWM) > ourSize.ISize(outerWM) ||
-          desiredSize.BSize(outerWM) > ourSize.BSize(outerWM)) {
-#ifdef DEBUG_GROW
-        XULDumpBox(stdout);
-        printf(" GREW from (%d,%d) -> (%d,%d)\n", ourSize.ISize(outerWM),
-               ourSize.BSize(outerWM), desiredSize.ISize(outerWM),
-               desiredSize.BSize(outerWM));
-#endif
-
-        if (desiredSize.ISize(outerWM) > ourSize.ISize(outerWM)) {
-          ourSize.ISize(outerWM) = desiredSize.ISize(outerWM);
-        }
-
-        if (desiredSize.BSize(outerWM) > ourSize.BSize(outerWM)) {
-          ourSize.BSize(outerWM) = desiredSize.BSize(outerWM);
-        }
-      }
-
-      // ensure our size is what we think is should be. Someone could have
-      // reset the frame to be smaller or something dumb like that.
-      SetSize(ourSize.ConvertTo(ourWM, outerWM));
-    }
-  }
-
-  // Should we do this if IsXULCollapsed() is true?
-  LogicalSize size(GetLogicalSize(outerWM));
-  desiredSize.ISize(outerWM) = size.ISize(outerWM);
-  desiredSize.BSize(outerWM) = size.BSize(outerWM);
-  desiredSize.UnionOverflowAreasWithDesiredBounds();
-
-  if (HasAbsolutelyPositionedChildren()) {
-    // Set up a |reflowInput| to pass into ReflowAbsoluteFrames
-    ReflowInput reflowInput(aState.PresContext(), this,
-                            aState.GetRenderingContext(),
-                            LogicalSize(ourWM, ISize(), NS_UNCONSTRAINEDSIZE),
-                            ReflowInput::InitFlag::DummyParentReflowInput);
-
-    AddStateBits(NS_FRAME_IN_REFLOW);
-    // Set up a |reflowStatus| to pass into ReflowAbsoluteFrames
-    // (just a dummy value; hopefully that's OK)
-    nsReflowStatus reflowStatus;
-    ReflowAbsoluteFrames(aState.PresContext(), desiredSize, reflowInput,
-                         reflowStatus);
-    RemoveStateBits(NS_FRAME_IN_REFLOW);
-  }
-
-  nsSize oldSize(ourRect.Size());
-  FinishAndStoreOverflow(desiredSize.mOverflowAreas,
-                         size.GetPhysicalSize(outerWM), &oldSize);
-
-  SyncXULLayout(aState);
-
-  return NS_OK;
-}
-
-void nsIFrame::BoxReflow(nsBoxLayoutState& aState, nsPresContext* aPresContext,
-                         ReflowOutput& aDesiredSize,
-                         gfxContext* aRenderingContext, nscoord aX, nscoord aY,
-                         nscoord aWidth, nscoord aHeight, bool aMoveFrame) {
-  DO_GLOBAL_REFLOW_COUNT("nsBoxToBlockAdaptor");
-
-  nsBoxLayoutMetrics* metrics = BoxMetrics();
-  if (MOZ_UNLIKELY(!metrics)) {
-    // Can't proceed without BoxMetrics. This should only happen if something
-    // is seriously broken, e.g. if we try to do XUL layout on a non-XUL frame.
-    // (If this is a content process, we'll abort even in release builds,
-    // because XUL layout mixup is extra surprising in content, and aborts are
-    // less catastrophic in content vs. in chrome.)
-    MOZ_RELEASE_ASSERT(!XRE_IsContentProcess(),
-                       "Starting XUL BoxReflow w/o BoxMetrics (in content)?");
-    MOZ_ASSERT_UNREACHABLE("Starting XUL BoxReflow w/o BoxMetrics?");
-    return;
-  }
-
-  nsReflowStatus status;
-
-  bool needsReflow = IsSubtreeDirty();
-
-  // if we don't need a reflow then
-  // lets see if we are already that size. Yes? then don't even reflow. We are
-  // done.
-  if (!needsReflow) {
-    if (aWidth != NS_UNCONSTRAINEDSIZE && aHeight != NS_UNCONSTRAINEDSIZE) {
-      // if the new calculated size has a 0 width or a 0 height
-      if ((metrics->mLastSize.width == 0 || metrics->mLastSize.height == 0) &&
-          (aWidth == 0 || aHeight == 0)) {
-        needsReflow = false;
-        aDesiredSize.Width() = aWidth;
-        aDesiredSize.Height() = aHeight;
-        SetSize(aDesiredSize.Size(GetWritingMode()));
-      } else {
-        aDesiredSize.Width() = metrics->mLastSize.width;
-        aDesiredSize.Height() = metrics->mLastSize.height;
-
-        // remove the margin. The rect of our child does not include it but our
-        // calculated size does. don't reflow if we are already the right size
-        if (metrics->mLastSize.width == aWidth &&
-            metrics->mLastSize.height == aHeight)
-          needsReflow = false;
-        else
-          needsReflow = true;
-      }
-    } else {
-      // if the width or height are intrinsic alway reflow because
-      // we don't know what it should be.
-      needsReflow = true;
-    }
-  }
-
-  // ok now reflow the child into the spacers calculated space
-  if (needsReflow) {
-    aDesiredSize.ClearSize();
-
-    // create a reflow input to tell our child to flow at the given size.
-
-    // Construct a bogus parent reflow input so that there's a usable reflow
-    // input for the containing block.
-    nsMargin margin(0, 0, 0, 0);
-    GetXULMargin(margin);
-
-    nsSize parentSize(aWidth, aHeight);
-    if (parentSize.height != NS_UNCONSTRAINEDSIZE)
-      parentSize.height += margin.TopBottom();
-    if (parentSize.width != NS_UNCONSTRAINEDSIZE)
-      parentSize.width += margin.LeftRight();
-
-    nsIFrame* parentFrame = GetParent();
-    WritingMode parentWM = parentFrame->GetWritingMode();
-    ReflowInput parentReflowInput(
-        aPresContext, parentFrame, aRenderingContext,
-        LogicalSize(parentWM, parentSize),
-        ReflowInput::InitFlag::DummyParentReflowInput);
-
-    // This may not do very much useful, but it's probably worth trying.
-    if (parentSize.width != NS_UNCONSTRAINEDSIZE)
-      parentReflowInput.SetComputedWidth(std::max(parentSize.width, 0));
-    if (parentSize.height != NS_UNCONSTRAINEDSIZE)
-      parentReflowInput.SetComputedHeight(std::max(parentSize.height, 0));
-    parentReflowInput.SetComputedLogicalMargin(parentWM,
-                                               LogicalMargin(parentWM));
-    // XXX use box methods
-    nsMargin padding;
-    parentFrame->GetXULPadding(padding);
-    parentReflowInput.SetComputedLogicalPadding(
-        parentWM, LogicalMargin(parentWM, padding));
-    nsMargin border;
-    parentFrame->GetXULBorder(border);
-    parentReflowInput.SetComputedLogicalBorderPadding(
-        parentWM, LogicalMargin(parentWM, border + padding));
-
-    // Construct the parent chain manually since constructing it normally
-    // messes up dimensions.
-    const ReflowInput* outerReflowInput = aState.OuterReflowInput();
-    NS_ASSERTION(!outerReflowInput || outerReflowInput->mFrame != this,
-                 "in and out of XUL on a single frame?");
-    const ReflowInput* parentRI;
-    if (outerReflowInput && outerReflowInput->mFrame == parentFrame) {
-      // We're a frame (such as a text control frame) that jumps into
-      // box reflow and then straight out of it on the child frame.
-      // This means we actually have a real parent reflow input.
-      // nsLayoutUtils::InflationMinFontSizeFor used to need this to be
-      // linked up correctly for text control frames, so do so here).
-      parentRI = outerReflowInput;
-    } else {
-      parentRI = &parentReflowInput;
-    }
-
-    // XXX Is it OK that this reflow input has only one ancestor?
-    // (It used to have a bogus parent, skipping all the boxes).
-    WritingMode wm = GetWritingMode();
-    LogicalSize logicalSize(wm, nsSize(aWidth, aHeight));
-    logicalSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
-    ReflowInput reflowInput(aPresContext, *parentRI, this, logicalSize,
-                            Nothing(),
-                            ReflowInput::InitFlag::DummyParentReflowInput);
-
-    // XXX_jwir3: This is somewhat fishy. If this is actually changing the value
-    //            here (which it might be), then we should make sure that it's
-    //            correct the first time around, rather than changing it later.
-    reflowInput.mCBReflowInput = parentRI;
-
-    reflowInput.mReflowDepth = aState.GetReflowDepth();
-
-    // mComputedWidth and mComputedHeight are content-box, not
-    // border-box
-    if (aWidth != NS_UNCONSTRAINEDSIZE) {
-      nscoord computedWidth =
-          aWidth - reflowInput.ComputedPhysicalBorderPadding().LeftRight();
-      computedWidth = std::max(computedWidth, 0);
-      reflowInput.SetComputedWidth(computedWidth);
-    }
-
-    // Most child frames of box frames (e.g. subdocument or scroll frames)
-    // need to be constrained to the provided size and overflow as necessary.
-    // The one exception are block frames, because we need to know their
-    // natural height excluding any overflow area which may be caused by
-    // various CSS effects such as shadow or outline.
-    if (!IsBlockFrameOrSubclass()) {
-      if (aHeight != NS_UNCONSTRAINEDSIZE) {
-        nscoord computedHeight =
-            aHeight - reflowInput.ComputedPhysicalBorderPadding().TopBottom();
-        computedHeight = std::max(computedHeight, 0);
-        reflowInput.SetComputedHeight(computedHeight);
-      } else {
-        reflowInput.SetComputedHeight(
-            ComputeSize(
-                aRenderingContext, wm, logicalSize, logicalSize.ISize(wm),
-                reflowInput.ComputedLogicalMargin(wm).Size(wm),
-                reflowInput.ComputedLogicalBorderPadding(wm).Size(wm), {}, {})
-                .mLogicalSize.Height(wm));
-      }
-    }
-
-    // Box layout calls SetRect before XULLayout, whereas non-box layout
-    // calls SetRect after Reflow.
-    // XXX Perhaps we should be doing this by twiddling the rect back to
-    // mLastSize before calling Reflow and then switching it back, but
-    // However, mLastSize can also be the size passed to BoxReflow by
-    // RefreshSizeCache, so that doesn't really make sense.
-    if (metrics->mLastSize.width != aWidth) {
-      reflowInput.SetHResize(true);
-
-      // When font size inflation is enabled, a horizontal resize
-      // requires a full reflow.  See ReflowInput::InitResizeFlags
-      // for more details.
-      if (nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) {
-        this->MarkSubtreeDirty();
-      }
-    }
-    if (metrics->mLastSize.height != aHeight) {
-      reflowInput.SetVResize(true);
-    }
-
-    // place the child and reflow
-
-    Reflow(aPresContext, aDesiredSize, reflowInput, status);
-
-    NS_ASSERTION(status.IsComplete(), "bad status");
-
-    ReflowChildFlags layoutFlags = aState.LayoutFlags();
-    nsContainerFrame::FinishReflowChild(
-        this, aPresContext, aDesiredSize, &reflowInput, aX, aY,
-        layoutFlags | ReflowChildFlags::NoMoveFrame);
-
-    // Save the ascent.  (bug 103925)
-    if (IsXULCollapsed()) {
-      metrics->mAscent = 0;
-    } else {
-      if (aDesiredSize.BlockStartAscent() == ReflowOutput::ASK_FOR_BASELINE) {
-        if (!nsLayoutUtils::GetFirstLineBaseline(wm, this, &metrics->mAscent))
-          metrics->mAscent = GetLogicalBaseline(wm);
-      } else
-        metrics->mAscent = aDesiredSize.BlockStartAscent();
-    }
-
-  } else {
-    aDesiredSize.SetBlockStartAscent(metrics->mBlockAscent);
-  }
-
-  metrics->mLastSize.width = aDesiredSize.Width();
-  metrics->mLastSize.height = aDesiredSize.Height();
-}
-
-nsBoxLayoutMetrics* nsIFrame::BoxMetrics() const {
-  nsBoxLayoutMetrics* metrics = GetProperty(BoxMetricsProperty());
-  NS_ASSERTION(
-      metrics,
-      "A box layout method was called but InitBoxMetrics was never called");
-  return metrics;
-}
-
 void nsIFrame::UpdateStyleOfChildAnonBox(nsIFrame* aChildFrame,
                                          ServoRestyleState& aRestyleState) {
 #ifdef DEBUG
   nsIFrame* parent = aChildFrame->GetInFlowParent();
   if (aChildFrame->IsTableFrame()) {
     parent = parent->GetParent();
   }
   if (parent->IsLineFrame()) {
@@ -11342,24 +10782,16 @@ void nsIFrame::SetParent(nsContainerFram
   // _can_ change parent if our parent is a wrapper anon box, because some
   // wrapper anon boxes can have continuations.
   MOZ_ASSERT_IF(ParentIsWrapperAnonBox(),
                 aParent->Style()->IsInheritingAnonBox());
 
   // Note that the current mParent may already be destroyed at this point.
   mParent = aParent;
   MOZ_DIAGNOSTIC_ASSERT(!mParent || PresShell() == mParent->PresShell());
-  if (::IsXULBoxWrapped(this)) {
-    ::InitBoxMetrics(this, true);
-  } else {
-    // We could call Properties().Delete(BoxMetricsProperty()); here but
-    // that's kind of slow and re-parenting in such a way that we were
-    // IsXULBoxWrapped() before but not now should be very rare, so we'll just
-    // keep this unused frame property until this frame dies instead.
-  }
 
   if (HasAnyStateBits(NS_FRAME_HAS_VIEW | NS_FRAME_HAS_CHILD_WITH_VIEW)) {
     for (nsIFrame* f = aParent;
          f && !f->HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
          f = f->GetParent()) {
       f->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
     }
   }
@@ -12470,17 +11902,16 @@ void DR_State::InitFrameTypeTable() {
   AddFrameTypeInfo(LayoutFrameType::TableColGroup, "colG", "tableColGroup");
   AddFrameTypeInfo(LayoutFrameType::Table, "tbl", "table");
   AddFrameTypeInfo(LayoutFrameType::TableWrapper, "tblW", "tableWrapper");
   AddFrameTypeInfo(LayoutFrameType::TableRowGroup, "rowG", "tableRowGroup");
   AddFrameTypeInfo(LayoutFrameType::TableRow, "row", "tableRow");
   AddFrameTypeInfo(LayoutFrameType::TextInput, "textCtl", "textInput");
   AddFrameTypeInfo(LayoutFrameType::Text, "text", "text");
   AddFrameTypeInfo(LayoutFrameType::Viewport, "VP", "viewport");
-  AddFrameTypeInfo(LayoutFrameType::Box, "Box", "Box");
   AddFrameTypeInfo(LayoutFrameType::Slider, "Slider", "Slider");
   AddFrameTypeInfo(LayoutFrameType::None, "unknown", "unknown");
 }
 
 void DR_State::DisplayFrameTypeInfo(nsIFrame* aFrame, int32_t aIndent) {
   DR_FrameTypeInfo* frameTypeInfo = GetFrameTypeInfo(aFrame->Type());
   if (frameTypeInfo) {
     for (int32_t i = 0; i < aIndent; i++) {

--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -106,31 +106,28 @@
  */
 
 class nsAtom;
 class nsView;
 class nsFrameSelection;
 class nsIWidget;
 class nsIScrollableFrame;
 class nsISelectionController;
-class nsBoxLayoutState;
-class nsBoxLayout;
 class nsILineIterator;
 class gfxSkipChars;
 class gfxSkipCharsIterator;
 class gfxContext;
 class nsLineList_iterator;
 class nsAbsoluteContainingBlock;
 class nsContainerFrame;
 class nsPlaceholderFrame;
 class nsStyleChangeList;
 class nsViewManager;
 class nsWindowSizes;
 
-struct nsBoxLayoutMetrics;
 struct CharacterDataChangeInfo;
 
 namespace mozilla {
 
 enum class PeekOffsetOption : uint8_t;
 enum class PseudoStyleType : uint8_t;
 enum class TableSelectionMode : uint32_t;
 
@@ -2398,23 +2395,20 @@ class nsIFrame : public nsQueryFrame {
 
   /**
    * Mark any stored intrinsic width information as dirty (requiring
    * re-calculation).  Note that this should generally not be called
    * directly; PresShell::FrameNeedsReflow() will call it instead.
    */
   virtual void MarkIntrinsicISizesDirty();
 
- private:
-  nsBoxLayoutMetrics* BoxMetrics() const;
-
  public:
   /**
    * Make this frame and all descendants dirty (if not already).
-   * Exceptions: XULBoxFrame and TableColGroupFrame children.
+   * Exceptions: TableColGroupFrame children.
    */
   void MarkSubtreeDirty();
 
   /**
    * Get the min-content intrinsic inline size of the frame.  This must be
    * less than or equal to the max-content intrinsic inline size.
    *
    * This is *not* affected by the CSS 'min-width', 'width', and
@@ -3289,33 +3283,32 @@ class nsIFrame : public nsQueryFrame {
     // the frame is for a replaced element, such as an image
     eReplaced = 1 << 4,
     // Frame that contains a block but looks like a replaced element
     // from the outside
     eReplacedContainsBlock = 1 << 5,
     // A frame that participates in inline reflow, i.e., one that
     // requires ReflowInput::mLineLayout.
     eLineParticipant = 1 << 6,
-    eXULBox = 1 << 7,
-    eCanContainOverflowContainers = 1 << 8,
-    eTablePart = 1 << 9,
-    eSupportsCSSTransforms = 1 << 10,
+    eCanContainOverflowContainers = 1 << 7,
+    eTablePart = 1 << 8,
+    eSupportsCSSTransforms = 1 << 9,
 
     // A replaced element that has replaced-element sizing
     // characteristics (i.e., like images or iframes), as opposed to
     // inline-block sizing characteristics (like form controls).
-    eReplacedSizing = 1 << 11,
+    eReplacedSizing = 1 << 10,
 
     // Does this frame class support 'contain: layout' and
     // 'contain:paint' (supporting one is equivalent to supporting the
     // other).
-    eSupportsContainLayoutAndPaint = 1 << 12,
+    eSupportsContainLayoutAndPaint = 1 << 11,
 
     // Does this frame class support `aspect-ratio` property.
-    eSupportsAspectRatio = 1 << 13,
+    eSupportsAspectRatio = 1 << 12,
 
     // These are to allow nsIFrame::Init to assert that IsFrameOfType
     // implementations all call the base class method.  They are only
     // meaningful in DEBUG builds.
     eDEBUGAllFrames = 1 << 30,
     eDEBUGNoFrames = 1 << 31
   };
 
@@ -4262,155 +4255,38 @@ class nsIFrame : public nsQueryFrame {
    * @param  [in, optional] aWithMouse, is this focus query for mouse clicking
    * @param  [in, optional] aCheckVisibility, whether to treat an invisible
    *   frame as not focusable
    * @return whether the frame is focusable via mouse, kbd or script.
    */
   [[nodiscard]] Focusable IsFocusable(bool aWithMouse = false,
                                       bool aCheckVisibility = true);
 
-  // BOX LAYOUT METHODS
-  // These methods have been migrated from nsIBox and are in the process of
-  // being refactored. DO NOT USE OUTSIDE OF XUL.
-  bool IsXULBoxFrame() const { return IsFrameOfType(nsIFrame::eXULBox); }
-
-  enum Halignment { hAlign_Left, hAlign_Right, hAlign_Center };
-
-  enum Valignment { vAlign_Top, vAlign_Middle, vAlign_BaseLine, vAlign_Bottom };
-
-  /**
-   * This calculates the minimum size required for a box based on its state
-   * @param[in] aBoxLayoutState The desired state to calculate for
-   * @return The minimum size
-   */
-  virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState);
-
-  /**
-   * This calculates the preferred size of a box based on its state
-   * @param[in] aBoxLayoutState The desired state to calculate for
-   * @return The preferred size
-   */
-  virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState);
-
-  /**
-   * This calculates the maximum size for a box based on its state
-   * @param[in] aBoxLayoutState The desired state to calculate for
-   * @return The maximum size
-   */
-  virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState);
-
-  int32_t GetXULFlex() const;
-  virtual nscoord GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState);
-  virtual bool IsXULCollapsed();
-  // This does not alter the overflow area. If the caller is changing
-  // the box size, the caller is responsible for updating the overflow
-  // area. It's enough to just call XULLayout or SyncXULLayout on the
-  // box. You can pass true to aRemoveOverflowArea as a
-  // convenience.
-  virtual void SetXULBounds(nsBoxLayoutState& aBoxLayoutState,
-                            const nsRect& aRect,
-                            bool aRemoveOverflowAreas = false);
-  nsresult XULLayout(nsBoxLayoutState& aBoxLayoutState);
-  // Box methods.  Note that these do NOT just get the CSS border, padding,
-  // etc.  They also talk to nsITheme.
-  virtual nsresult GetXULBorderAndPadding(nsMargin& aBorderAndPadding);
-  virtual nsresult GetXULBorder(nsMargin& aBorder);
-  virtual nsresult GetXULPadding(nsMargin& aBorderAndPadding);
-  virtual nsresult GetXULMargin(nsMargin& aMargin);
-  virtual void SetXULLayoutManager(nsBoxLayout* aLayout) {}
-  virtual nsBoxLayout* GetXULLayoutManager() { return nullptr; }
-  nsresult GetXULClientRect(nsRect& aContentRect);
-
-  virtual ReflowChildFlags GetXULLayoutFlags() {
-    return ReflowChildFlags::Default;
-  }
-
-  // For nsSprocketLayout
-  virtual Valignment GetXULVAlign() const { return vAlign_Top; }
-  virtual Halignment GetXULHAlign() const { return hAlign_Left; }
-
-  nsresult XULRedraw(nsBoxLayoutState& aState);
-
-  static bool AddXULPrefSize(nsIFrame* aBox, nsSize& aSize, bool& aWidth,
-                             bool& aHeightSet);
-  static bool AddXULMinSize(nsIFrame* aBox, nsSize& aSize, bool& aWidth,
-                            bool& aHeightSet);
-  static bool AddXULMaxSize(nsIFrame* aBox, nsSize& aSize, bool& aWidth,
-                            bool& aHeightSet);
-  static int32_t ComputeXULFlex(nsIFrame* aBox);
-
-  void AddXULBorderAndPadding(nsSize& aSize);
-
-  static void AddXULBorderAndPadding(nsIFrame* aBox, nsSize& aSize);
-  static void AddXULMargin(nsIFrame* aChild, nsSize& aSize);
-  static void AddXULMargin(nsSize& aSize, const nsMargin& aMargin);
-
-  static nsSize XULBoundsCheckMinMax(const nsSize& aMinSize,
-                                     const nsSize& aMaxSize);
-  static nsSize XULBoundsCheck(const nsSize& aMinSize, const nsSize& aPrefSize,
-                               const nsSize& aMaxSize);
-  static nscoord XULBoundsCheck(nscoord aMinSize, nscoord aPrefSize,
-                                nscoord aMaxSize);
-
-  static nsIFrame* GetChildXULBox(const nsIFrame* aFrame);
-  static nsIFrame* GetNextXULBox(const nsIFrame* aFrame);
-  static nsIFrame* GetParentXULBox(const nsIFrame* aFrame);
-
  protected:
   // Helper for IsFocusable.
   bool IsFocusableDueToScrollFrame();
 
   /**
    * Returns true if this box clips its children, e.g., if this box is an
-   * scrollbox.
-   */
-  virtual bool DoesClipChildrenInBothAxes();
-
-  // We compute and store the HTML content's overflow area. So don't
-  // try to compute it in the box code.
-  virtual bool XULComputesOwnOverflowArea() { return true; }
-
-  nsresult SyncXULLayout(nsBoxLayoutState& aBoxLayoutState);
-
-  bool XULNeedsRecalc(const nsSize& aSize);
-  bool XULNeedsRecalc(nscoord aCoord);
-  void XULSizeNeedsRecalc(nsSize& aSize);
-  void XULCoordNeedsRecalc(nscoord& aCoord);
-
-  nsresult BeginXULLayout(nsBoxLayoutState& aState);
-  NS_IMETHOD DoXULLayout(nsBoxLayoutState& aBoxLayoutState);
-  nsresult EndXULLayout(nsBoxLayoutState& aState);
-
-  nsSize GetUncachedXULMinSize(nsBoxLayoutState& aBoxLayoutState);
-  nsSize GetUncachedXULPrefSize(nsBoxLayoutState& aBoxLayoutState);
-  nsSize GetUncachedXULMaxSize(nsBoxLayoutState& aBoxLayoutState);
-
-  // END OF BOX LAYOUT METHODS
-  // The above methods have been migrated from nsIBox and are in the process of
-  // being refactored. DO NOT USE OUTSIDE OF XUL.
+   * scrollbox or has overflow: clip in both axes.
+   */
+  bool DoesClipChildrenInBothAxes() const;
 
   /**
    * NOTE: aStatus is assumed to be already-initialized. The reflow statuses of
    * any reflowed absolute children will be merged into aStatus; aside from
    * that, this method won't modify aStatus.
    */
   void ReflowAbsoluteFrames(nsPresContext* aPresContext,
                             ReflowOutput& aDesiredSize,
                             const ReflowInput& aReflowInput,
                             nsReflowStatus& aStatus,
                             bool aConstrainBSize = true);
 
  private:
-  void BoxReflow(nsBoxLayoutState& aState, nsPresContext* aPresContext,
-                 ReflowOutput& aDesiredSize, gfxContext* aRenderingContext,
-                 nscoord aX, nscoord aY, nscoord aWidth, nscoord aHeight,
-                 bool aMoveFrame = true);
-
-  NS_IMETHODIMP RefreshSizeCache(nsBoxLayoutState& aState);
-
   Maybe<nscoord> ComputeInlineSizeFromAspectRatio(
       mozilla::WritingMode aWM, const mozilla::LogicalSize& aCBSize,
       const mozilla::LogicalSize& aContentEdgeToBoxSizing,
       const mozilla::StyleSizeOverrides& aSizeOverrides,
       mozilla::ComputeSizeFlags aFlags) const;
 
  public:
   /**

--- a/layout/generic/nsIScrollableFrame.h
+++ b/layout/generic/nsIScrollableFrame.h
@@ -19,17 +19,16 @@
 #include "mozilla/ScrollStyles.h"
 #include "mozilla/ScrollTypes.h"
 #include "mozilla/gfx/Point.h"
 #include "nsIScrollbarMediator.h"
 #include "Units.h"
 #include "FrameMetrics.h"
 
 class gfxContext;
-class nsBoxLayoutState;
 class nsIScrollPositionListener;
 class nsIFrame;
 class nsPresContext;
 class nsIContent;
 
 namespace mozilla {
 class DisplayItemClip;
 class nsDisplayListBuilder;

--- a/layout/generic/nsPlaceholderFrame.cpp
+++ b/layout/generic/nsPlaceholderFrame.cpp
@@ -41,37 +41,16 @@ NS_IMPL_FRAMEARENA_HELPERS(nsPlaceholder
 
 #ifdef DEBUG
 NS_QUERYFRAME_HEAD(nsPlaceholderFrame)
   NS_QUERYFRAME_ENTRY(nsPlaceholderFrame)
 NS_QUERYFRAME_TAIL_INHERITING(nsIFrame)
 #endif
 
 /* virtual */
-nsSize nsPlaceholderFrame::GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) {
-  nsSize size(0, 0);
-  DISPLAY_MIN_SIZE(this, size);
-  return size;
-}
-
-/* virtual */
-nsSize nsPlaceholderFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) {
-  nsSize size(0, 0);
-  DISPLAY_PREF_SIZE(this, size);
-  return size;
-}
-
-/* virtual */
-nsSize nsPlaceholderFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) {
-  nsSize size(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
-  DISPLAY_MAX_SIZE(this, size);
-  return size;
-}
-
-/* virtual */
 void nsPlaceholderFrame::AddInlineMinISize(
     gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
   // Override AddInlineMinWith so that *nothing* happens.  In
   // particular, we don't want to zero out |aData->mTrailingWhitespace|,
   // since nsLineLayout skips placeholders when trimming trailing
   // whitespace, and we don't want to set aData->mSkipWhitespace to
   // false.
 

--- a/layout/generic/nsPlaceholderFrame.h
+++ b/layout/generic/nsPlaceholderFrame.h
@@ -88,48 +88,43 @@ class nsPlaceholderFrame final : public 
   nsIFrame* GetOutOfFlowFrame() const { return mOutOfFlowFrame; }
   void SetOutOfFlowFrame(nsIFrame* aFrame) {
     NS_ASSERTION(!aFrame || !aFrame->GetPrevContinuation(),
                  "OOF must be first continuation");
     mOutOfFlowFrame = aFrame;
   }
 
   // nsIFrame overrides
-  // We need to override GetXULMinSize and GetXULPrefSize because XUL uses
-  // placeholders not within lines.
-  virtual void AddInlineMinISize(gfxContext* aRenderingContext,
-                                 InlineMinISizeData* aData) override;
-  virtual void AddInlinePrefISize(gfxContext* aRenderingContext,
-                                  InlinePrefISizeData* aData) override;
-  virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
-  virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
-  virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+  void AddInlineMinISize(gfxContext* aRenderingContext,
+                         InlineMinISizeData* aData) override;
+  void AddInlinePrefISize(gfxContext* aRenderingContext,
+                          InlinePrefISizeData* aData) override;
 
-  virtual void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
-                      const ReflowInput& aReflowInput,
-                      nsReflowStatus& aStatus) override;
+  void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
+              const ReflowInput& aReflowInput,
+              nsReflowStatus& aStatus) override;
 
-  virtual void DestroyFrom(nsIFrame* aDestructRoot,
-                           PostDestroyData& aPostDestroyData) override;
+  void DestroyFrom(nsIFrame* aDestructRoot,
+                   PostDestroyData& aPostDestroyData) override;
 
 #if defined(DEBUG) || (defined(MOZ_REFLOW_PERF_DSP) && defined(MOZ_REFLOW_PERF))
-  virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
-                                const nsDisplayListSet& aLists) override;
+  void BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                        const nsDisplayListSet& aLists) override;
 #endif  // DEBUG || (MOZ_REFLOW_PERF_DSP && MOZ_REFLOW_PERF)
 
 #ifdef DEBUG_FRAME_DUMP
   void List(FILE* out = stderr, const char* aPrefix = "",
             ListFlags aFlags = ListFlags()) const override;
-  virtual nsresult GetFrameName(nsAString& aResult) const override;
+  nsresult GetFrameName(nsAString& aResult) const override;
 #endif  // DEBUG
 
-  virtual bool IsEmpty() override { return true; }
-  virtual bool IsSelfEmpty() override { return true; }
+  bool IsEmpty() override { return true; }
+  bool IsSelfEmpty() override { return true; }
 
-  virtual bool CanContinueTextRun() const override;
+  bool CanContinueTextRun() const override;
 
   void SetLineIsEmptySoFar(bool aValue) {
     AddOrRemoveStateBits(PLACEHOLDER_LINE_IS_EMPTY_SO_FAR, aValue);
     AddStateBits(PLACEHOLDER_HAVE_LINE_IS_EMPTY_SO_FAR);
   }
   bool GetLineIsEmptySoFar(bool* aResult) const {
     bool haveValue = HasAnyStateBits(PLACEHOLDER_HAVE_LINE_IS_EMPTY_SO_FAR);
     if (haveValue) {
@@ -137,17 +132,17 @@ class nsPlaceholderFrame final : public 
     }
     return haveValue;
   }
   void ForgetLineIsEmptySoFar() {
     RemoveStateBits(PLACEHOLDER_HAVE_LINE_IS_EMPTY_SO_FAR);
   }
 
 #ifdef ACCESSIBILITY
-  virtual mozilla::a11y::AccType AccessibleType() override {
+  mozilla::a11y::AccType AccessibleType() override {
     nsIFrame* realFrame = GetRealFrameForPlaceholder(this);
     return realFrame ? realFrame->AccessibleType() : nsIFrame::AccessibleType();
   }
 #endif
 
   ComputedStyle* GetParentComputedStyleForOutOfFlow(
       nsIFrame** aProviderFrame) const;
 

--- a/layout/generic/nsVideoFrame.cpp
+++ b/layout/generic/nsVideoFrame.cpp
@@ -15,17 +15,16 @@
 #include "mozilla/dom/HTMLImageElement.h"
 #include "mozilla/dom/HTMLVideoElement.h"
 #include "mozilla/dom/ShadowRoot.h"
 #include "mozilla/layers/RenderRootStateManager.h"
 #include "nsDisplayList.h"
 #include "nsGenericHTMLElement.h"
 #include "nsPresContext.h"
 #include "nsContentCreatorFunctions.h"
-#include "nsBoxLayoutState.h"
 #include "nsIContentInlines.h"
 #include "nsImageFrame.h"
 #include "nsIImageLoadingContent.h"
 #include "nsContentUtils.h"
 #include "nsLayoutUtils.h"
 #include "ImageContainer.h"
 #include "nsStyleUtil.h"
 #include <algorithm>
@@ -743,18 +742,17 @@ void nsVideoFrame::BuildDisplayList(nsDi
   if (HasVideoElement() && !shouldDisplayPoster) {
     aLists.Content()->AppendNewToTop<nsDisplayVideo>(aBuilder, this);
   }
 
   // Add child frames to display list. We expect various children,
   // but only want to draw mPosterImage conditionally. Others we
   // always add to the display list.
   for (nsIFrame* child : mFrames) {
-    if (child->GetContent() != mPosterImage || shouldDisplayPoster ||
-        child->IsBoxFrame()) {
+    if (child->GetContent() != mPosterImage || shouldDisplayPoster) {
       nsDisplayListBuilder::AutoBuildingDisplayList buildingForChild(
           aBuilder, child,
           aBuilder->GetVisibleRect() - child->GetOffsetTo(this),
           aBuilder->GetDirtyRect() - child->GetOffsetTo(this));
 
       child->BuildDisplayListForStackingContext(aBuilder, aLists.Content());
     }
   }

deleted file mode 100644
--- a/layout/reftests/box-ordinal/dynamic-1-add-to-one-grouped.xhtml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE window>
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" class="reftest-wait" onload="run()">
-  <script type="application/javascript"><![CDATA[
-
-  function run() {
-    var c = document.getElementById("C");
-    getComputedStyle(c, "").width; // flush
-    c.style.order = "2";
-    document.documentElement.removeAttribute("class");
-  }
-
-  ]]></script>
-  <label id="A" value="A" />
-  <label id="C" value="C" />
-  <label id="B" value="B" />
-</window>

deleted file mode 100644
--- a/layout/reftests/box-ordinal/dynamic-1-add-to-two-grouped-1.xhtml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE window>
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" class="reftest-wait" onload="run()">
-  <script type="application/javascript"><![CDATA[
-
-  function run() {
-    var c = document.getElementById("C");
-    getComputedStyle(c, "").width; // flush
-    c.style.order = "2";
-    document.documentElement.removeAttribute("class");
-  }
-
-  ]]></script>
-  <label id="B" value="B" style="order: 2" />
-  <label id="C" value="C" />
-  <label id="A" value="A" />
-</window>

deleted file mode 100644
--- a/layout/reftests/box-ordinal/dynamic-1-add-to-two-grouped-2.xhtml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE window>
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" class="reftest-wait" onload="run()">
-  <script type="application/javascript"><![CDATA[
-
-  function run() {
-    var b = document.getElementById("B");
-    getComputedStyle(b, "").width; // flush
-    b.style.order = "2";
-    document.documentElement.removeAttribute("class");
-  }
-
-  ]]></script>
-  <label id="B" value="B" />
-  <label id="C" value="C" style="order: 2" />
-  <label id="A" value="A" />
-</window>

deleted file mode 100644
--- a/layout/reftests/box-ordinal/dynamic-1-ref.xhtml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE window>
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <label id="A" value="A" />
-  <label id="B" value="B" />
-  <label id="C" value="C" />
-</window>

deleted file mode 100644
--- a/layout/reftests/box-ordinal/dynamic-1-remove-to-none-grouped.xhtml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE window>
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" class="reftest-wait" onload="run()">
-  <script type="application/javascript"><![CDATA[
-
-  function run() {
-    var b = document.getElementById("B");
-    getComputedStyle(b, "").width; // flush
-    b.style.order = "";
-    document.documentElement.removeAttribute("class");
-  }
-
-  ]]></script>
-  <label id="A" value="A" />
-  <label id="B" value="B" style="order: 2" />
-  <label id="C" value="C" />
-</window>

deleted file mode 100644
--- a/layout/reftests/box-ordinal/dynamic-1-remove-to-one-grouped-1.xhtml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE window>
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" class="reftest-wait" onload="run()">
-  <script type="application/javascript"><![CDATA[
-
-  function run() {
-    var b = document.getElementById("B");
-    getComputedStyle(b, "").width; // flush
-    b.style.order = "";
-    document.documentElement.removeAttribute("class");
-  }
-
-  ]]></script>
-  <label id="C" value="C" style="order: 2" />
-  <label id="A" value="A" />
-  <label id="B" value="B" style="order: 2" />
-</window>

deleted file mode 100644
--- a/layout/reftests/box-ordinal/dynamic-1-remove-to-one-grouped-2.xhtml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE window>
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" class="reftest-wait" onload="run()">
-  <script type="application/javascript"><![CDATA[
-
-  function run() {
-    var a = document.getElementById("A");
-    getComputedStyle(a, "").width; // flush
-    a.style.order = "";
-    document.documentElement.removeAttribute("class");
-  }
-
-  ]]></script>
-  <label id="C" value="C" style="order: 2" />
-  <label id="A" value="A" style="order: 2" />
-  <label id="B" value="B" />
-</window>

deleted file mode 100644
--- a/layout/reftests/box-ordinal/reftest.list
+++ /dev/null
@@ -1,6 +0,0 @@
-== chrome://reftest/content/box-ordinal/dynamic-1-remove-to-none-grouped.xhtml chrome://reftest/content/box-ordinal/dynamic-1-ref.xhtml
-== chrome://reftest/content/box-ordinal/dynamic-1-add-to-one-grouped.xhtml chrome://reftest/content/box-ordinal/dynamic-1-ref.xhtml
-== chrome://reftest/content/box-ordinal/dynamic-1-remove-to-one-grouped-1.xhtml chrome://reftest/content/box-ordinal/dynamic-1-ref.xhtml
-== chrome://reftest/content/box-ordinal/dynamic-1-remove-to-one-grouped-2.xhtml chrome://reftest/content/box-ordinal/dynamic-1-ref.xhtml
-== chrome://reftest/content/box-ordinal/dynamic-1-add-to-two-grouped-1.xhtml chrome://reftest/content/box-ordinal/dynamic-1-ref.xhtml
-== chrome://reftest/content/box-ordinal/dynamic-1-add-to-two-grouped-2.xhtml chrome://reftest/content/box-ordinal/dynamic-1-ref.xhtml

deleted file mode 100644
--- a/layout/reftests/box/box-as-grid-or-flex-item-1-ref.html
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE html>
-<title>Reference for bug 1580302</title>
-<style>
-  .grid, .flex {
-    width: 60px;
-    height: 60px;
-    border: 1px solid black;
-  }
-  .grid { display: grid; }
-  .flex { display: flex; }
-  .fCol { flex-direction: column; }
-
-  .item {
-    background: lightblue;
-  }
-  .flexible {
-    flex: 1;
-  }
-</style>
-<body>
-  <!-- The item should fill the grid here (by virtue of the default-stretchy
-       behavior of justify-items and align-items): -->
-  <div class="grid">
-    <div class="item">e</div>
-  </div>
-
-  <!-- For the rest, the item should fill the flex container in the cross axis,
-       and if it's flexible, also fill the container in the main axis. -->
-  <div class="flex">
-    <div class="item">e</div>
-  </div>
-  <div class="flex">
-    <div class="item flexible">e</div>
-  </div>
-  <div class="flex fCol">
-    <div class="item">e</div>
-  </div>
-  <div class="flex fCol">
-    <div class="item flexible">e</div>
-  </div>
-</body>

deleted file mode 100644
--- a/layout/reftests/box/box-as-grid-or-flex-item-1.html
+++ /dev/null
@@ -1,42 +0,0 @@
-<!DOCTYPE html>
-<title>Test for bug 1580302</title>
-<style>
-  .grid, .flex {
-    width: 60px;
-    height: 60px;
-    border: 1px solid black;
-  }
-  .grid { display: grid; }
-  .flex { display: flex; }
-  .fCol { flex-direction: column; }
-
-  .item {
-    display: -moz-box;
-    background: lightblue;
-  }
-  .flexible {
-    flex: 1;
-  }
-</style>
-<body>
-  <!-- The item should fill the grid here (by virtue of justify-items/align-items
-       default behavior): -->
-  <div class="grid">
-    <div class="item">e</div>
-  </div>
-
-  <!-- For the rest, the item should fill the flex container in the cross axis,
-       and if it's flexible, also fill the container in the main axis. -->
-  <div class="flex">
-    <div class="item">e</div>
-  </div>
-  <div class="flex">
-    <div class="item flexible">e</div>
-  </div>
-  <div class="flex fCol">
-    <div class="item">e</div>
-  </div>
-  <div class="flex fCol">
-    <div class="item flexible">e</div>
-  </div>
-</body>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-1-ref.xhtml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root {
-        -moz-box-layout: flex;
-      }
-      hbox {
-        width: 100px;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:hbox>
-      <xul:description>X</xul:description>
-      <xul:description flex="1" style="background: blue">X</xul:description>
-    </xul:hbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-1.xhtml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: legacy; }
-      hbox {
-        width: 100px;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:hbox>
-      <xul:description>X</xul:description>
-      <xul:description flex="1" style="background: blue">X</xul:description>
-    </xul:hbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-2-ref.xhtml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:html="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: flex; }
-      hbox {
-        width: 700px;
-      }
-      input {
-        -moz-box-flex: 1;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:hbox>
-      <xul:description>X</xul:description>
-      <html:input flex="1" style="background: blue" value="X"/>
-    </xul:hbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-2.xhtml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:html="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: legacy; }
-
-      hbox {
-        width: 700px;
-      }
-      input {
-        -moz-box-flex: 1;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:hbox>
-      <xul:description>X</xul:description>
-      <html:input flex="1" style="background: blue" value="X"/>
-    </xul:hbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-4-ref.xhtml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: flex; }
-      vbox {
-        height: 100px;
-      }
-      browser {
-        background-color: green;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:vbox>
-      <xul:browser></xul:browser>
-    </xul:vbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-4.xhtml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: legacy; }
-      vbox {
-        height: 100px;
-      }
-      browser {
-        background-color: green;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:vbox>
-      <xul:browser></xul:browser>
-    </xul:vbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-5-ref.xhtml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: legacy; }
-      .scroll {
-        height: 100px;
-        width: 100px;
-        overflow: auto;
-      }
-      .scroll > vbox {
-        width: 100px;
-        height: 100px;
-        background: green;
-      }
-      .scroll > vbox[collapsed] {
-        border: 3px solid;
-        padding: 6px;
-        margin: 9px;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:vbox class="scroll">
-      <xul:vbox/>
-      <xul:vbox collapsed="true"/>
-    </xul:vbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-5-ref2.xhtml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: legacy; }
-      .scroll {
-        height: 100px;
-        width: 100px;
-        background: green;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:vbox class="scroll"/>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flex-emulation-5.xhtml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"
-      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <head>
-    <style>
-      :root { -moz-box-layout: flex }
-      .scroll {
-        height: 100px;
-        width: 100px;
-        overflow: auto;
-      }
-      .scroll > vbox {
-        width: 100px;
-        height: 100px;
-        background: green;
-      }
-      .scroll > vbox[collapsed] {
-        border: 3px solid;
-        padding: 6px;
-        margin: 9px;
-      }
-    </style>
-  </head>
-  <body>
-    <xul:vbox class="scroll">
-      <xul:vbox/>
-      <xul:vbox collapsed="true"/>
-    </xul:vbox>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-abspos-container-1-ref.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!-- Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/ -->
-<html>
-  <head>
-    <style>
-      .relpos_parent {
-        position: relative;
-        width: 100px;
-        height: 100px;
-        background: lightblue;
-      }
-      .abspos_child {
-        position: absolute;
-        left: 30px;
-        bottom: 10px;
-        width: 20px;
-        height: 20px;
-        background: purple;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="relpos_parent">
-      <div class="abspos_child"></div>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-abspos-container-1a.html
+++ /dev/null
@@ -1,30 +0,0 @@
-<!-- Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/ -->
-<!-- This testcase has a relatively-positioned -moz-box element, which should
-     form a containing block for its absolutely positioned child. -->
-<html>
-  <head>
-    <style>
-      .box { display: -moz-box }
-      .relpos_parent {
-        position: relative;
-        width: 100px;
-        height: 100px;
-        background: lightblue;
-      }
-      .abspos_child {
-        position: absolute;
-        left: 30px;
-        bottom: 10px;
-        width: 20px;
-        height: 20px;
-        background: purple;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="box relpos_parent">
-      <div class="abspos_child"></div>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-abspos-container-1b.html
+++ /dev/null
@@ -1,29 +0,0 @@
-<!-- Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/ -->
-<!-- This testcase is the same as the -1a version, but with -moz-inline-box. -->
-<html>
-  <head>
-    <style>
-      .box { display: -moz-inline-box }
-      .relpos_parent {
-        position: relative;
-        width: 100px;
-        height: 100px;
-        background: lightblue;
-      }
-      .abspos_child {
-        position: absolute;
-        left: 30px;
-        bottom: 10px;
-        width: 20px;
-        height: 20px;
-        background: purple;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="box relpos_parent">
-      <div class="abspos_child"></div>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-abspos-container-1c.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!-- Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/ -->
-<!-- This testcase is the same as the -1a version, but with an additional
-     -moz-box wrapper, so that our relatively positioned box will never get a
-     call to Reflow. -->
-<html>
-  <head>
-    <style>
-      .box { display: -moz-box }
-      .relpos_parent {
-        position: relative;
-        width: 100px;
-        height: 100px;
-        background: lightblue;
-      }
-      .abspos_child {
-        position: absolute;
-        left: 30px;
-        bottom: 10px;
-        width: 20px;
-        height: 20px;
-        background: purple;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="box">
-      <div class="box relpos_parent">
-        <div class="abspos_child"></div>
-      </div>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-abspos-container-1d.html
+++ /dev/null
@@ -1,31 +0,0 @@
-<!-- Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/ -->
-<!-- This testcase is the same as the -1c version, but with -moz-inline-box. -->
-<html>
-  <head>
-    <style>
-      .box { display: -moz-inline-box }
-      .relpos_parent {
-        position: relative;
-        width: 100px;
-        height: 100px;
-        background: lightblue;
-      }
-      .abspos_child {
-        position: absolute;
-        left: 30px;
-        bottom: 10px;
-        width: 20px;
-        height: 20px;
-        background: purple;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="box">
-      <div class="box relpos_parent">
-        <div class="abspos_child"></div>
-      </div>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-abspos-container-2-ref.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!-- Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/ -->
-<html>
-  <head>
-    <style>
-      .relpos_parent {
-        position: relative;
-        width: 100px;
-        height: 100px;
-        background: lightblue;
-      }
-      .abspos_child {
-        position: absolute;
-        left: 30px;
-        top: 10px;
-        width: 20px;
-        height: 150px;
-        background: purple;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="relpos_parent">
-      <div class="abspos_child"></div>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-abspos-container-2.html
+++ /dev/null
@@ -1,31 +0,0 @@
-<!-- Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/ -->
-<!-- This testcase has a relatively-positioned -moz-box element, which should
-     form a containing block for its absolutely positioned child. Also: in
-     this case, the child is taller than its container. -->
-<html>
-  <head>
-    <style>
-      .box { display: -moz-box }
-      .relpos_parent {
-        position: relative;
-        width: 100px;
-        height: 100px;
-        background: lightblue;
-      }
-      .abspos_child {
-        position: absolute;
-        left: 30px;
-        top: 10px;
-        width: 20px;
-        height: 150px;
-        background: purple;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="box relpos_parent">
-      <div class="abspos_child"></div>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-attributes-no-box-horizontal-ref.xhtml
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE HTML>
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<title>Test that XUL attributes are not supported on non-XUL elements</title>
-<style type="text/css">
-<![CDATA[
-
-html, body {
-  display: -moz-box;
-  margin: 0; padding: 0;
-  width: 100%; height: 100%;
-}
-
-body > div {
-  display: -moz-box;
-  background: yellow;
-  -moz-box-flex: 1;
-  -moz-box-orient: horizontal;
-}
-
-div > div {
-  display: -moz-box;
-  -moz-box-flex: 1;
-  border: 1px solid blue;
-}
-
-]]>
-</style>
-</head>
-<body>
-<div>
-  <div>width</div>
-  <div>height</div>
-  <div>minwidth</div>
-  <div>minheight</div>
-  <div>maxwidth</div>
-  <div>maxheight</div>
-  <div>flex</div>
-</div>
-</body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-attributes-no-box-horizontal.xhtml
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE HTML>
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<title>Test that XUL attributes are not supported on non-XUL elements</title>
-<style type="text/css">
-<![CDATA[
-
-html, body {
-  display: -moz-box;
-  margin: 0; padding: 0;
-  width: 100%; height: 100%;
-}
-
-body > div {
-  display: -moz-box;
-  background: yellow;
-  -moz-box-flex: 1;
-  -moz-box-orient: horizontal;
-}
-
-div > div {
-  display: -moz-box;
-  -moz-box-flex: 1;
-  border: 1px solid blue;
-}
-
-]]>
-</style>
-</head>
-<body>
-<div>
-  <div width="100">width</div>
-  <div height="100">height</div>
-  <div minwidth="100">minwidth</div>
-  <div minheight="100">minheight</div>
-  <div maxwidth="50">maxwidth</div>
-  <div maxheight="15">maxheight</div>
-  <div style="-moz-box-flex: 100">flex</div>
-</div>
-</body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-attributes-no-box-vertical-ref.xhtml
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE HTML>
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<title>Test that XUL attributes are not supported on non-XUL elements</title>
-<style type="text/css">
-<![CDATA[
-
-html, body {
-  display: -moz-box;
-  margin: 0; padding: 0;
-  width: 100%; height: 100%;
-}
-
-body > div {
-  display: -moz-box;
-  background: yellow;
-  -moz-box-flex: 1;
-  -moz-box-orient: vertical;
-}
-
-div > div {
-  display: -moz-box;
-  -moz-box-flex: 1;
-  border: 1px solid blue;
-}
-
-]]>
-</style>
-</head>
-<body>
-<div>
-  <div>width</div>
-  <div>height</div>
-  <div>minwidth</div>
-  <div>minheight</div>
-  <div>maxwidth</div>
-  <div>maxheight</div>
-  <div>flex</div>
-</div>
-</body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-attributes-no-box-vertical.xhtml
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE HTML>
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<title>Test that XUL attributes are not supported on non-XUL elements</title>
-<style type="text/css">
-<![CDATA[
-
-html, body {
-  display: -moz-box;
-  margin: 0; padding: 0;
-  width: 100%; height: 100%;
-}
-
-body > div {
-  display: -moz-box;
-  background: yellow;
-  -moz-box-flex: 1;
-  -moz-box-orient: vertical;
-}
-
-div > div {
-  display: -moz-box;
-  -moz-box-flex: 1;
-  border: 1px solid blue;
-}
-
-]]>
-</style>
-</head>
-<body>
-<div>
-  <div width="100">width</div>
-  <div height="100">height</div>
-  <div minwidth="100">minwidth</div>
-  <div minheight="100">minheight</div>
-  <div maxwidth="50">maxwidth</div>
-  <div maxheight="15">maxheight</div>
-  <div style="-moz-box-flex: 100">flex</div>
-</div>
-</body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-attributes-no-input-horizontal-ref.xhtml
+++ /dev/null
@@ -1,36 +0,0 @@
-<!DOCTYPE HTML>
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<title>Test that XUL attributes are not supported on non-XUL elements</title>
-<style type="text/css">
-<![CDATA[
-
-html, body {
-  display: -moz-box;
-  margin: 0; padding: 0;
-  width: 100%; height: 100%;
-  pointer-events: none;
-}
-
-body > div {
-  display: -moz-box;
-  background: yellow;
-  -moz-box-flex: 1;
-  -moz-box-orient: horizontal;
-}
-
-]]>
-</style>
-</head>
-<body>
-<div>
-  <input type="text" value="width" />
-  <input type="text" value="height" />
-  <input type="text" value="minwidth" />
-  <input type="text" value="minheight" />
-  <input type="text" value="maxwidth" />
-  <input type="text" value="maxheight" />
-  <input type="text" value="flex" />
-</div>
-</body>
-</html>

deleted file mode 100644
--- a/layout/reftests/box/flexbox-attributes-no-input-horizontal.xhtml
+++ /dev/null
@@ -1,37 +0,0 @@
-<!DOCTYPE HTML>
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<title>Test that XUL attributes are not supported on non-XUL elements</title>
-<style type="text/css">
-<![CDATA[
-
-html, body {
-  display: -moz-box;
-  margin: 0; padding: 0;
-  width: 100%; height: 100%;
-  /* Disable pointer-events so we don't get weird hover artifacts */
-  pointer-events: none;
-}
-
-body > div {
-  display: -moz-box;
-  background: yellow;
-  -moz-box-flex: 1;
-  -moz-box-orient: horizontal;
-}
-
-]]>
-</style>
-</head>
-<body>
-<div>
-  <input type="text" width="100" value="width" />
-  <input type="text" height="100" value="height" />
-  <input type="text" minwidth="100" value="minwidth" />
-  <input type="text" minheight="100" value="minheight" />
-  <input type="text" maxwidth="50" value="maxwidth" />
-  <input type="text" maxheight="15" value="maxheight" />
-  <input type="text" style="-moz-box-flex: 100" value="flex" />
-</div>
-</body>
-</html>