Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1538 insertions, 0 deletions

diff --git a/layout/generic/nsFrameSetFrame.cpp b/layout/generic/nsFrameSetFrame.cpp
new file mode 100644
index 0000000000..8eb7885adc
--- /dev/null
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -0,0 +1,1538 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* rendering object for HTML <frameset> elements */
+
+#include "nsFrameSetFrame.h"
+
+#include "gfxContext.h"
+#include "gfxUtils.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Helpers.h"
+#include "mozilla/Likely.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/PresShellInlines.h"
+
+#include "nsGenericHTMLElement.h"
+#include "nsAttrValueInlines.h"
+#include "nsLeafFrame.h"
+#include "nsContainerFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsPresContext.h"
+#include "nsIContentInlines.h"
+#include "nsGkAtoms.h"
+#include "nsStyleConsts.h"
+#include "nsHTMLParts.h"
+#include "nsNameSpaceManager.h"
+#include "nsCSSAnonBoxes.h"
+#include "mozilla/ServoStyleSet.h"
+#include "mozilla/ServoStyleSetInlines.h"
+#include "mozilla/dom/Element.h"
+#include "nsDisplayList.h"
+#include "mozAutoDocUpdate.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/ChildIterator.h"
+#include "mozilla/dom/HTMLFrameSetElement.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "nsSubDocumentFrame.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+
+// masks for mEdgeVisibility
+#define LEFT_VIS 0x0001
+#define RIGHT_VIS 0x0002
+#define TOP_VIS 0x0004
+#define BOTTOM_VIS 0x0008
+#define ALL_VIS 0x000F
+#define NONE_VIS 0x0000
+
+/*******************************************************************************
+ * nsFramesetDrag
+ ******************************************************************************/
+nsFramesetDrag::nsFramesetDrag() { UnSet(); }
+
+void nsFramesetDrag::Reset(bool aVertical, int32_t aIndex, int32_t aChange,
+                           nsHTMLFramesetFrame* aSource) {
+  mVertical = aVertical;
+  mIndex = aIndex;
+  mChange = aChange;
+  mSource = aSource;
+}
+
+void nsFramesetDrag::UnSet() {
+  mVertical = true;
+  mIndex = -1;
+  mChange = 0;
+  mSource = nullptr;
+}
+
+/*******************************************************************************
+ * nsHTMLFramesetBorderFrame
+ ******************************************************************************/
+class nsHTMLFramesetBorderFrame final : public nsLeafFrame {
+ public:
+  NS_DECL_FRAMEARENA_HELPERS(nsHTMLFramesetBorderFrame)
+
+#ifdef DEBUG_FRAME_DUMP
+  virtual nsresult GetFrameName(nsAString& aResult) const override;
+#endif
+
+  virtual nsresult HandleEvent(nsPresContext* aPresContext,
+                               WidgetGUIEvent* aEvent,
+                               nsEventStatus* aEventStatus) override;
+
+  Maybe<Cursor> GetCursor(const nsPoint&) override;
+
+  virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                const nsDisplayListSet& aLists) override;
+
+  virtual void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
+                      const ReflowInput& aReflowInput,
+                      nsReflowStatus& aStatus) override;
+
+  bool GetVisibility() { return mVisibility; }
+  void SetVisibility(bool aVisibility);
+  void SetColor(nscolor aColor);
+
+  void PaintBorder(DrawTarget* aDrawTarget, nsPoint aPt);
+
+ protected:
+  nsHTMLFramesetBorderFrame(ComputedStyle*, nsPresContext*, int32_t aWidth,
+                            bool aVertical, bool aVisible);
+  virtual ~nsHTMLFramesetBorderFrame();
+  virtual nscoord GetIntrinsicISize() override;
+  virtual nscoord GetIntrinsicBSize() override;
+
+  // the prev and next neighbors are indexes into the row (for a horizontal
+  // border) or col (for a vertical border) of nsHTMLFramesetFrames or
+  // nsHTMLFrames
+  int32_t mPrevNeighbor;
+  int32_t mNextNeighbor;
+  nscolor mColor;
+  int32_t mWidth;
+  bool mVertical;
+  bool mVisibility;
+  bool mCanResize;
+  friend class nsHTMLFramesetFrame;
+};
+/*******************************************************************************
+ * nsHTMLFramesetBlankFrame
+ ******************************************************************************/
+class nsHTMLFramesetBlankFrame final : public nsLeafFrame {
+ public:
+  NS_DECL_QUERYFRAME
+  NS_DECL_FRAMEARENA_HELPERS(nsHTMLFramesetBlankFrame)
+
+#ifdef DEBUG_FRAME_DUMP
+  virtual nsresult GetFrameName(nsAString& aResult) const override {
+    return MakeFrameName(u"FramesetBlank"_ns, aResult);
+  }
+#endif
+
+  virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                const nsDisplayListSet& aLists) override;
+
+  virtual void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
+                      const ReflowInput& aReflowInput,
+                      nsReflowStatus& aStatus) override;
+
+ protected:
+  explicit nsHTMLFramesetBlankFrame(ComputedStyle* aStyle,
+                                    nsPresContext* aPresContext)
+      : nsLeafFrame(aStyle, aPresContext, kClassID) {}
+
+  virtual ~nsHTMLFramesetBlankFrame();
+  virtual nscoord GetIntrinsicISize() override;
+  virtual nscoord GetIntrinsicBSize() override;
+
+  friend class nsHTMLFramesetFrame;
+  friend class nsHTMLFrameset;
+};
+
+/*******************************************************************************
+ * nsHTMLFramesetFrame
+ ******************************************************************************/
+bool nsHTMLFramesetFrame::gDragInProgress = false;
+#define DEFAULT_BORDER_WIDTH_PX 6
+
+nsHTMLFramesetFrame::nsHTMLFramesetFrame(ComputedStyle* aStyle,
+                                         nsPresContext* aPresContext)
+    : nsContainerFrame(aStyle, aPresContext, kClassID) {
+  mNumRows = 0;
+  mNumCols = 0;
+  mEdgeVisibility = 0;
+  mParentFrameborder = eFrameborder_Yes;  // default
+  mParentBorderWidth = -1;                // default not set
+  mParentBorderColor = NO_COLOR;          // default not set
+  mFirstDragPoint.x = mFirstDragPoint.y = 0;
+  mMinDrag = nsPresContext::CSSPixelsToAppUnits(2);
+  mNonBorderChildCount = 0;
+  mNonBlankChildCount = 0;
+  mDragger = nullptr;
+  mChildCount = 0;
+  mTopLevelFrameset = nullptr;
+  mEdgeColors.Set(NO_COLOR);
+}
+
+nsHTMLFramesetFrame::~nsHTMLFramesetFrame() = default;
+
+NS_QUERYFRAME_HEAD(nsHTMLFramesetFrame)
+  NS_QUERYFRAME_ENTRY(nsHTMLFramesetFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+void nsHTMLFramesetFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
+                               nsIFrame* aPrevInFlow) {
+  nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+  // find the highest ancestor that is a frameset
+  nsIFrame* parentFrame = GetParent();
+  mTopLevelFrameset = this;
+  while (parentFrame) {
+    nsHTMLFramesetFrame* frameset = do_QueryFrame(parentFrame);
+    if (frameset) {
+      mTopLevelFrameset = frameset;
+      parentFrame = parentFrame->GetParent();
+    } else {
+      break;
+    }
+  }
+
+  nsPresContext* presContext = PresContext();
+  mozilla::PresShell* presShell = presContext->PresShell();
+
+  nsFrameborder frameborder = GetFrameBorder();
+  int32_t borderWidth = GetBorderWidth(presContext, false);
+  nscolor borderColor = GetBorderColor();
+
+  // Get the rows= cols= data
+  HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
+  NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
+  const nsFramesetSpec* rowSpecs = nullptr;
+  const nsFramesetSpec* colSpecs = nullptr;
+  // GetRowSpec and GetColSpec can fail, but when they do they set
+  // mNumRows and mNumCols respectively to 0, so we deal with it fine.
+  ourContent->GetRowSpec(&mNumRows, &rowSpecs);
+  ourContent->GetColSpec(&mNumCols, &colSpecs);
+
+  static_assert(
+      NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscoord),
+      "Maximum value of mNumRows and mNumCols is NS_MAX_FRAMESET_SPEC_COUNT");
+  mRowSizes = MakeUnique<nscoord[]>(mNumRows);
+  mColSizes = MakeUnique<nscoord[]>(mNumCols);
+
+  static_assert(
+      NS_MAX_FRAMESET_SPEC_COUNT < INT32_MAX / NS_MAX_FRAMESET_SPEC_COUNT,
+      "Should not overflow numCells");
+  int32_t numCells = mNumRows * mNumCols;
+
+  static_assert(NS_MAX_FRAMESET_SPEC_COUNT <
+                    UINT_MAX / sizeof(nsHTMLFramesetBorderFrame*),
+                "Should not overflow nsHTMLFramesetBorderFrame");
+  mVerBorders = MakeUnique<nsHTMLFramesetBorderFrame*[]>(
+      mNumCols);  // 1 more than number of ver borders
+
+  for (int verX = 0; verX < mNumCols; verX++) mVerBorders[verX] = nullptr;
+
+  mHorBorders = MakeUnique<nsHTMLFramesetBorderFrame*[]>(
+      mNumRows);  // 1 more than number of hor borders
+
+  for (int horX = 0; horX < mNumRows; horX++) mHorBorders[horX] = nullptr;
+
+  static_assert(NS_MAX_FRAMESET_SPEC_COUNT <
+                    UINT_MAX / sizeof(int32_t) / NS_MAX_FRAMESET_SPEC_COUNT,
+                "Should not overflow numCells");
+  static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nsFrameborder) /
+                                                 NS_MAX_FRAMESET_SPEC_COUNT,
+                "Should not overflow numCells");
+  static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nsBorderColor) /
+                                                 NS_MAX_FRAMESET_SPEC_COUNT,
+                "Should not overflow numCells");
+  mChildFrameborder = MakeUnique<nsFrameborder[]>(numCells);
+  mChildBorderColors = MakeUnique<nsBorderColor[]>(numCells);
+
+  // create the children frames; skip content which isn't <frameset> or <frame>
+  mChildCount = 0;  // number of <frame> or <frameset> children
+
+  FlattenedChildIterator children(mContent);
+  for (nsIContent* child = children.GetNextChild(); child;
+       child = children.GetNextChild()) {
+    if (mChildCount == numCells) {
+      // we have more <frame> or <frameset> than cells
+      // Clear the lazy bits in the remaining children.  Also clear
+      // the restyle flags, like nsCSSFrameConstructor::ProcessChildren does.
+      for (; child; child = child->GetNextSibling()) {
+        child->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);
+      }
+      break;
+    }
+    child->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);
+
+    // IMPORTANT: This must match the conditions in
+    // nsCSSFrameConstructor::ContentAppended/Inserted/Removed
+    if (!child->IsAnyOfHTMLElements(nsGkAtoms::frameset, nsGkAtoms::frame)) {
+      continue;
+    }
+
+    // FIXME(emilio): This doesn't even respect display: none, but that matches
+    // other browsers ;_;
+    //
+    // Maybe we should change that though.
+    RefPtr<ComputedStyle> kidStyle =
+        ServoStyleSet::ResolveServoStyle(*child->AsElement());
+    nsIFrame* frame;
+    if (child->IsHTMLElement(nsGkAtoms::frameset)) {
+      frame = NS_NewHTMLFramesetFrame(presShell, kidStyle);
+
+      nsHTMLFramesetFrame* childFrame = (nsHTMLFramesetFrame*)frame;
+      childFrame->SetParentFrameborder(frameborder);
+      childFrame->SetParentBorderWidth(borderWidth);
+      childFrame->SetParentBorderColor(borderColor);
+      frame->Init(child, this, nullptr);
+
+      mChildBorderColors[mChildCount].Set(childFrame->GetBorderColor());
+    } else {  // frame
+      frame = NS_NewSubDocumentFrame(presShell, kidStyle);
+
+      frame->Init(child, this, nullptr);
+
+      mChildFrameborder[mChildCount] = GetFrameBorder(child);
+      mChildBorderColors[mChildCount].Set(GetBorderColor(child));
+    }
+    child->SetPrimaryFrame(frame);
+
+    mFrames.AppendFrame(nullptr, frame);
+
+    mChildCount++;
+  }
+
+  mNonBlankChildCount = mChildCount;
+  // add blank frames for frameset cells that had no content provided
+  for (int blankX = mChildCount; blankX < numCells; blankX++) {
+    RefPtr<ComputedStyle> pseudoComputedStyle;
+    pseudoComputedStyle =
+        presShell->StyleSet()->ResolveNonInheritingAnonymousBoxStyle(
+            PseudoStyleType::framesetBlank);
+
+    // XXX the blank frame is using the content of its parent - at some point it
+    // should just have null content, if we support that
+    nsHTMLFramesetBlankFrame* blankFrame = new (presShell)
+        nsHTMLFramesetBlankFrame(pseudoComputedStyle, PresContext());
+
+    blankFrame->Init(mContent, this, nullptr);
+
+    mFrames.AppendFrame(nullptr, blankFrame);
+
+    mChildBorderColors[mChildCount].Set(NO_COLOR);
+    mChildCount++;
+  }
+
+  mNonBorderChildCount = mChildCount;
+}
+
+void nsHTMLFramesetFrame::SetInitialChildList(ChildListID aListID,
+                                              nsFrameList& aChildList) {
+  // We do this weirdness where we create our child frames in Init().  On the
+  // other hand, we're going to get a SetInitialChildList() with an empty list
+  // and null list name after the frame constructor is done creating us.  So
+  // just ignore that call.
+  if (aListID == kPrincipalList && aChildList.IsEmpty()) {
+    return;
+  }
+
+  nsContainerFrame::SetInitialChildList(aListID, aChildList);
+}
+
+// XXX should this try to allocate twips based on an even pixel boundary?
+void nsHTMLFramesetFrame::Scale(nscoord aDesired, int32_t aNumIndicies,
+                                int32_t* aIndicies, int32_t aNumItems,
+                                int32_t* aItems) {
+  int32_t actual = 0;
+  int32_t i, j;
+  // get the actual total
+  for (i = 0; i < aNumIndicies; i++) {
+    j = aIndicies[i];
+    actual += aItems[j];
+  }
+
+  if (actual > 0) {
+    float factor = (float)aDesired / (float)actual;
+    actual = 0;
+    // scale the items up or down
+    for (i = 0; i < aNumIndicies; i++) {
+      j = aIndicies[i];
+      aItems[j] = NSToCoordRound((float)aItems[j] * factor);
+      actual += aItems[j];
+    }
+  } else if (aNumIndicies != 0) {
+    // All the specs say zero width, but we have to fill up space
+    // somehow.  Distribute it equally.
+    nscoord width = NSToCoordRound((float)aDesired / (float)aNumIndicies);
+    actual = width * aNumIndicies;
+    for (i = 0; i < aNumIndicies; i++) {
+      aItems[aIndicies[i]] = width;
+    }
+  }
+
+  if (aNumIndicies > 0 && aDesired != actual) {
+    int32_t unit = (aDesired > actual) ? 1 : -1;
+    for (i = 0; (i < aNumIndicies) && (aDesired != actual); i++) {
+      j = aIndicies[i];
+      if (j < aNumItems) {
+        aItems[j] += unit;
+        actual += unit;
+      }
+    }
+  }
+}
+
+/**
+ * Translate the rows/cols specs into an array of integer sizes for
+ * each cell in the frameset. Sizes are allocated based on the priorities of the
+ * specifier - fixed sizes have the highest priority, percentage sizes have the
+ * next highest priority and relative sizes have the lowest.
+ */
+void nsHTMLFramesetFrame::CalculateRowCol(nsPresContext* aPresContext,
+                                          nscoord aSize, int32_t aNumSpecs,
+                                          const nsFramesetSpec* aSpecs,
+                                          nscoord* aValues) {
+  static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(int32_t),
+                "aNumSpecs maximum value is NS_MAX_FRAMESET_SPEC_COUNT");
+
+  int32_t fixedTotal = 0;
+  int32_t numFixed = 0;
+  auto fixed = MakeUnique<int32_t[]>(aNumSpecs);
+  int32_t numPercent = 0;
+  auto percent = MakeUnique<int32_t[]>(aNumSpecs);
+  int32_t relativeSums = 0;
+  int32_t numRelative = 0;
+  auto relative = MakeUnique<int32_t[]>(aNumSpecs);
+
+  if (MOZ_UNLIKELY(!fixed || !percent || !relative)) {
+    return;  // NS_ERROR_OUT_OF_MEMORY
+  }
+
+  int32_t i, j;
+
+  // initialize the fixed, percent, relative indices, allocate the fixed sizes
+  // and zero the others
+  for (i = 0; i < aNumSpecs; i++) {
+    aValues[i] = 0;
+    switch (aSpecs[i].mUnit) {
+      case eFramesetUnit_Fixed:
+        aValues[i] = nsPresContext::CSSPixelsToAppUnits(aSpecs[i].mValue);
+        fixedTotal += aValues[i];
+        fixed[numFixed] = i;
+        numFixed++;
+        break;
+      case eFramesetUnit_Percent:
+        percent[numPercent] = i;
+        numPercent++;
+        break;
+      case eFramesetUnit_Relative:
+        relative[numRelative] = i;
+        numRelative++;
+        relativeSums += aSpecs[i].mValue;
+        break;
+    }
+  }
+
+  // scale the fixed sizes if they total too much (or too little and there
+  // aren't any percent or relative)
+  if ((fixedTotal > aSize) ||
+      ((fixedTotal < aSize) && (0 == numPercent) && (0 == numRelative))) {
+    Scale(aSize, numFixed, fixed.get(), aNumSpecs, aValues);
+    return;
+  }
+
+  int32_t percentMax = aSize - fixedTotal;
+  int32_t percentTotal = 0;
+  // allocate the percentage sizes from what is left over from the fixed
+  // allocation
+  for (i = 0; i < numPercent; i++) {
+    j = percent[i];
+    aValues[j] =
+        NSToCoordRound((float)aSpecs[j].mValue * (float)aSize / 100.0f);
+    percentTotal += aValues[j];
+  }
+
+  // scale the percent sizes if they total too much (or too little and there
+  // aren't any relative)
+  if ((percentTotal > percentMax) ||
+      ((percentTotal < percentMax) && (0 == numRelative))) {
+    Scale(percentMax, numPercent, percent.get(), aNumSpecs, aValues);
+    return;
+  }
+
+  int32_t relativeMax = percentMax - percentTotal;
+  int32_t relativeTotal = 0;
+  // allocate the relative sizes from what is left over from the percent
+  // allocation
+  for (i = 0; i < numRelative; i++) {
+    j = relative[i];
+    aValues[j] = NSToCoordRound((float)aSpecs[j].mValue * (float)relativeMax /
+                                (float)relativeSums);
+    relativeTotal += aValues[j];
+  }
+
+  // scale the relative sizes if they take up too much or too little
+  if (relativeTotal != relativeMax) {
+    Scale(relativeMax, numRelative, relative.get(), aNumSpecs, aValues);
+  }
+}
+
+/**
+ * Translate the rows/cols integer sizes into an array of specs for
+ * each cell in the frameset.  Reverse of CalculateRowCol() behaviour.
+ * This allows us to maintain the user size info through reflows.
+ */
+void nsHTMLFramesetFrame::GenerateRowCol(nsPresContext* aPresContext,
+                                         nscoord aSize, int32_t aNumSpecs,
+                                         const nsFramesetSpec* aSpecs,
+                                         nscoord* aValues, nsString& aNewAttr) {
+  int32_t i;
+
+  for (i = 0; i < aNumSpecs; i++) {
+    if (!aNewAttr.IsEmpty()) aNewAttr.Append(char16_t(','));
+
+    switch (aSpecs[i].mUnit) {
+      case eFramesetUnit_Fixed:
+        aNewAttr.AppendInt(nsPresContext::AppUnitsToIntCSSPixels(aValues[i]));
+        break;
+      case eFramesetUnit_Percent:  // XXX Only accurate to 1%, need 1 pixel
+      case eFramesetUnit_Relative:
+        // Add 0.5 to the percentage to make rounding work right.
+        aNewAttr.AppendInt(uint32_t((100.0 * aValues[i]) / aSize + 0.5));
+        aNewAttr.Append(char16_t('%'));
+        break;
+    }
+  }
+}
+
+int32_t nsHTMLFramesetFrame::GetBorderWidth(nsPresContext* aPresContext,
+                                            bool aTakeForcingIntoAccount) {
+  nsFrameborder frameborder = GetFrameBorder();
+  if (frameborder == eFrameborder_No) {
+    return 0;
+  }
+  nsGenericHTMLElement* content = nsGenericHTMLElement::FromNode(mContent);
+
+  if (content) {
+    const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::border);
+    if (attr) {
+      int32_t intVal = 0;
+      if (attr->Type() == nsAttrValue::eInteger) {
+        intVal = attr->GetIntegerValue();
+        if (intVal < 0) {
+          intVal = 0;
+        }
+      }
+
+      return nsPresContext::CSSPixelsToAppUnits(intVal);
+    }
+  }
+
+  if (mParentBorderWidth >= 0) {
+    return mParentBorderWidth;
+  }
+
+  return nsPresContext::CSSPixelsToAppUnits(DEFAULT_BORDER_WIDTH_PX);
+}
+
+void nsHTMLFramesetFrame::GetDesiredSize(nsPresContext* aPresContext,
+                                         const ReflowInput& aReflowInput,
+                                         ReflowOutput& aDesiredSize) {
+  WritingMode wm = aReflowInput.GetWritingMode();
+  LogicalSize desiredSize(wm);
+  nsHTMLFramesetFrame* framesetParent = do_QueryFrame(GetParent());
+  if (nullptr == framesetParent) {
+    if (aPresContext->IsPaginated()) {
+      // XXX This needs to be changed when framesets paginate properly
+      desiredSize.ISize(wm) = aReflowInput.AvailableISize();
+      desiredSize.BSize(wm) = aReflowInput.AvailableBSize();
+    } else {
+      LogicalSize area(wm, aPresContext->GetVisibleArea().Size());
+
+      desiredSize.ISize(wm) = area.ISize(wm);
+      desiredSize.BSize(wm) = area.BSize(wm);
+    }
+  } else {
+    LogicalSize size(wm);
+    framesetParent->GetSizeOfChild(this, wm, size);
+    desiredSize.ISize(wm) = size.ISize(wm);
+    desiredSize.BSize(wm) = size.BSize(wm);
+  }
+  aDesiredSize.SetSize(wm, desiredSize);
+}
+
+// only valid for non border children
+void nsHTMLFramesetFrame::GetSizeOfChildAt(int32_t aIndexInParent,
+                                           WritingMode aWM, LogicalSize& aSize,
+                                           nsIntPoint& aCellIndex) {
+  int32_t row = aIndexInParent / mNumCols;
+  int32_t col = aIndexInParent -
+                (row * mNumCols);  // remainder from dividing index by mNumCols
+  if ((row < mNumRows) && (col < mNumCols)) {
+    aSize.ISize(aWM) = mColSizes[col];
+    aSize.BSize(aWM) = mRowSizes[row];
+    aCellIndex.x = col;
+    aCellIndex.y = row;
+  } else {
+    aSize.SizeTo(aWM, 0, 0);
+    aCellIndex.x = aCellIndex.y = 0;
+  }
+}
+
+// only valid for non border children
+void nsHTMLFramesetFrame::GetSizeOfChild(nsIFrame* aChild, WritingMode aWM,
+                                         LogicalSize& aSize) {
+  // Reflow only creates children frames for <frameset> and <frame> content.
+  // this assumption is used here
+  int i = 0;
+  for (nsIFrame* child : mFrames) {
+    if (aChild == child) {
+      nsIntPoint ignore;
+      GetSizeOfChildAt(i, aWM, aSize, ignore);
+      return;
+    }
+    i++;
+  }
+  aSize.SizeTo(aWM, 0, 0);
+}
+
+nsresult nsHTMLFramesetFrame::HandleEvent(nsPresContext* aPresContext,
+                                          WidgetGUIEvent* aEvent,
+                                          nsEventStatus* aEventStatus) {
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+  if (mDragger) {
+    // the nsFramesetBorderFrame has captured NS_MOUSE_DOWN
+    switch (aEvent->mMessage) {
+      case eMouseMove:
+        MouseDrag(aPresContext, aEvent);
+        break;
+      case eMouseUp:
+        if (aEvent->AsMouseEvent()->mButton == MouseButton::ePrimary) {
+          EndMouseDrag(aPresContext);
+        }
+        break;
+      default:
+        break;
+    }
+    *aEventStatus = nsEventStatus_eConsumeNoDefault;
+  } else {
+    *aEventStatus = nsEventStatus_eIgnore;
+  }
+  return NS_OK;
+}
+
+Maybe<nsIFrame::Cursor> nsHTMLFramesetFrame::GetCursor(const nsPoint&) {
+  auto kind = StyleCursorKind::Default;
+  if (mDragger) {
+    kind = mDragger->mVertical ? StyleCursorKind::EwResize
+                               : StyleCursorKind::NsResize;
+  }
+  return Some(Cursor{kind, AllowCustomCursorImage::No});
+}
+
+void nsHTMLFramesetFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                           const nsDisplayListSet& aLists) {
+  BuildDisplayListForInline(aBuilder, aLists);
+
+  if (mDragger && aBuilder->IsForEventDelivery()) {
+    aLists.Content()->AppendNewToTop<nsDisplayEventReceiver>(aBuilder, this);
+  }
+}
+
+void nsHTMLFramesetFrame::ReflowPlaceChild(nsIFrame* aChild,
+                                           nsPresContext* aPresContext,
+                                           const ReflowInput& aReflowInput,
+                                           nsPoint& aOffset, nsSize& aSize,
+                                           nsIntPoint* aCellIndex) {
+  // reflow the child
+  ReflowInput reflowInput(aPresContext, aReflowInput, aChild,
+                          LogicalSize(aChild->GetWritingMode(), aSize));
+  reflowInput.SetComputedWidth(std::max(
+      0,
+      aSize.width - reflowInput.ComputedPhysicalBorderPadding().LeftRight()));
+  reflowInput.SetComputedHeight(std::max(
+      0,
+      aSize.height - reflowInput.ComputedPhysicalBorderPadding().TopBottom()));
+  ReflowOutput reflowOutput(aReflowInput);
+  reflowOutput.Width() = aSize.width;
+  reflowOutput.Height() = aSize.height;
+  nsReflowStatus status;
+
+  ReflowChild(aChild, aPresContext, reflowOutput, reflowInput, aOffset.x,
+              aOffset.y, ReflowChildFlags::Default, status);
+  NS_ASSERTION(status.IsComplete(), "bad status");
+
+  // Place and size the child
+  reflowOutput.Width() = aSize.width;
+  reflowOutput.Height() = aSize.height;
+  FinishReflowChild(aChild, aPresContext, reflowOutput, &reflowInput, aOffset.x,
+                    aOffset.y, ReflowChildFlags::Default);
+}
+
+static nsFrameborder GetFrameBorderHelper(nsGenericHTMLElement* aContent) {
+  if (nullptr != aContent) {
+    const nsAttrValue* attr = aContent->GetParsedAttr(nsGkAtoms::frameborder);
+    if (attr && attr->Type() == nsAttrValue::eEnum) {
+      switch (attr->GetEnumValue()) {
+        case NS_STYLE_FRAME_YES:
+        case NS_STYLE_FRAME_1:
+          return eFrameborder_Yes;
+
+        case NS_STYLE_FRAME_NO:
+        case NS_STYLE_FRAME_0:
+          return eFrameborder_No;
+      }
+    }
+  }
+  return eFrameborder_Notset;
+}
+
+nsFrameborder nsHTMLFramesetFrame::GetFrameBorder() {
+  nsFrameborder result = eFrameborder_Notset;
+  nsGenericHTMLElement* content = nsGenericHTMLElement::FromNode(mContent);
+
+  if (content) {
+    result = GetFrameBorderHelper(content);
+  }
+  if (eFrameborder_Notset == result) {
+    return mParentFrameborder;
+  }
+  return result;
+}
+
+nsFrameborder nsHTMLFramesetFrame::GetFrameBorder(nsIContent* aContent) {
+  nsFrameborder result = eFrameborder_Notset;
+
+  nsGenericHTMLElement* content = nsGenericHTMLElement::FromNode(aContent);
+
+  if (content) {
+    result = GetFrameBorderHelper(content);
+  }
+  if (eFrameborder_Notset == result) {
+    return GetFrameBorder();
+  }
+  return result;
+}
+
+nscolor nsHTMLFramesetFrame::GetBorderColor() {
+  nsGenericHTMLElement* content = nsGenericHTMLElement::FromNode(mContent);
+
+  if (content) {
+    const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::bordercolor);
+    if (attr) {
+      nscolor color;
+      if (attr->GetColorValue(color)) {
+        return color;
+      }
+    }
+  }
+
+  return mParentBorderColor;
+}
+
+nscolor nsHTMLFramesetFrame::GetBorderColor(nsIContent* aContent) {
+  nsGenericHTMLElement* content = nsGenericHTMLElement::FromNode(aContent);
+
+  if (content) {
+    const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::bordercolor);
+    if (attr) {
+      nscolor color;
+      if (attr->GetColorValue(color)) {
+        return color;
+      }
+    }
+  }
+  return GetBorderColor();
+}
+
+void nsHTMLFramesetFrame::Reflow(nsPresContext* aPresContext,
+                                 ReflowOutput& aDesiredSize,
+                                 const ReflowInput& aReflowInput,
+                                 nsReflowStatus& aStatus) {
+  MarkInReflow();
+  DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+  mozilla::PresShell* presShell = aPresContext->PresShell();
+  ServoStyleSet* styleSet = presShell->StyleSet();
+
+  GetParent()->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
+
+  // printf("FramesetFrame2::Reflow %X (%d,%d) \n", this,
+  // aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight());
+  // Always get the size so that the caller knows how big we are
+  GetDesiredSize(aPresContext, aReflowInput, aDesiredSize);
+
+  nscoord width = (aDesiredSize.Width() <= aReflowInput.AvailableWidth())
+                      ? aDesiredSize.Width()
+                      : aReflowInput.AvailableWidth();
+  nscoord height = (aDesiredSize.Height() <= aReflowInput.AvailableHeight())
+                       ? aDesiredSize.Height()
+                       : aReflowInput.AvailableHeight();
+
+  // We might be reflowed more than once with NS_FRAME_FIRST_REFLOW;
+  // that's allowed.  (Though it will only happen for misuse of frameset
+  // that includes it within other content.)  So measure firstTime by
+  // what we care about, which is whether we've processed the data we
+  // process below if firstTime is true.
+  MOZ_ASSERT(!mChildFrameborder == !mChildBorderColors);
+  bool firstTime = !!mChildFrameborder;
+
+  // subtract out the width of all of the potential borders. There are
+  // only borders between <frame>s. There are none on the edges (e.g the
+  // leftmost <frame> has no left border).
+  int32_t borderWidth = GetBorderWidth(aPresContext, true);
+
+  width -= (mNumCols - 1) * borderWidth;
+  if (width < 0) width = 0;
+
+  height -= (mNumRows - 1) * borderWidth;
+  if (height < 0) height = 0;
+
+  HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
+  NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
+  const nsFramesetSpec* rowSpecs = nullptr;
+  const nsFramesetSpec* colSpecs = nullptr;
+  int32_t rows = 0;
+  int32_t cols = 0;
+  ourContent->GetRowSpec(&rows, &rowSpecs);
+  ourContent->GetColSpec(&cols, &colSpecs);
+  // If the number of cols or rows has changed, the frame for the frameset
+  // will be re-created.
+  if (mNumRows != rows || mNumCols != cols) {
+    mDrag.UnSet();
+    NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+    return;
+  }
+
+  CalculateRowCol(aPresContext, width, mNumCols, colSpecs, mColSizes.get());
+  CalculateRowCol(aPresContext, height, mNumRows, rowSpecs, mRowSizes.get());
+
+  UniquePtr<bool[]> verBordersVis;  // vertical borders visibility
+  UniquePtr<nscolor[]> verBorderColors;
+  UniquePtr<bool[]> horBordersVis;  // horizontal borders visibility
+  UniquePtr<nscolor[]> horBorderColors;
+  nscolor borderColor = GetBorderColor();
+  nsFrameborder frameborder = GetFrameBorder();
+
+  if (firstTime) {
+    // Check for overflow in memory allocations using mNumCols and mNumRows
+    // which have a maxium value of NS_MAX_FRAMESET_SPEC_COUNT.
+    static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(bool),
+                  "Check for overflow");
+    static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscolor),
+                  "Check for overflow");
+
+    verBordersVis = MakeUnique<bool[]>(mNumCols);
+    verBorderColors = MakeUnique<nscolor[]>(mNumCols);
+    for (int verX = 0; verX < mNumCols; verX++) {
+      verBordersVis[verX] = false;
+      verBorderColors[verX] = NO_COLOR;
+    }
+
+    horBordersVis = MakeUnique<bool[]>(mNumRows);
+    horBorderColors = MakeUnique<nscolor[]>(mNumRows);
+    for (int horX = 0; horX < mNumRows; horX++) {
+      horBordersVis[horX] = false;
+      horBorderColors[horX] = NO_COLOR;
+    }
+  }
+
+  // reflow the children
+  int32_t lastRow = 0;
+  int32_t lastCol = 0;
+  int32_t borderChildX = mNonBorderChildCount;  // index of border children
+  nsHTMLFramesetBorderFrame* borderFrame = nullptr;
+  nsPoint offset(0, 0);
+  nsSize size, lastSize;
+  WritingMode wm = GetWritingMode();
+  LogicalSize logicalSize(wm);
+  nsIFrame* child = mFrames.FirstChild();
+
+  for (int32_t childX = 0; childX < mNonBorderChildCount; childX++) {
+    nsIntPoint cellIndex;
+    GetSizeOfChildAt(childX, wm, logicalSize, cellIndex);
+    size = logicalSize.GetPhysicalSize(wm);
+
+    if (lastRow != cellIndex.y) {  // changed to next row
+      offset.x = 0;
+      offset.y += lastSize.height;
+      if (firstTime) {  // create horizontal border
+
+        RefPtr<ComputedStyle> pseudoComputedStyle;
+        pseudoComputedStyle = styleSet->ResolveNonInheritingAnonymousBoxStyle(
+            PseudoStyleType::horizontalFramesetBorder);
+
+        borderFrame = new (presShell) nsHTMLFramesetBorderFrame(
+            pseudoComputedStyle, PresContext(), borderWidth, false, false);
+        borderFrame->Init(mContent, this, nullptr);
+        mChildCount++;
+        mFrames.AppendFrame(nullptr, borderFrame);
+        mHorBorders[cellIndex.y - 1] = borderFrame;
+        // set the neighbors for determining drag boundaries
+        borderFrame->mPrevNeighbor = lastRow;
+        borderFrame->mNextNeighbor = cellIndex.y;
+      } else {
+        borderFrame = (nsHTMLFramesetBorderFrame*)mFrames.FrameAt(borderChildX);
+        borderFrame->mWidth = borderWidth;
+        borderChildX++;
+      }
+      nsSize borderSize(aDesiredSize.Width(), borderWidth);
+      ReflowPlaceChild(borderFrame, aPresContext, aReflowInput, offset,
+                       borderSize);
+      borderFrame = nullptr;
+      offset.y += borderWidth;
+    } else {
+      if (cellIndex.x > 0) {     // moved to next col in same row
+        if (0 == cellIndex.y) {  // in 1st row
+          if (firstTime) {       // create vertical border
+
+            RefPtr<ComputedStyle> pseudoComputedStyle;
+            pseudoComputedStyle =
+                styleSet->ResolveNonInheritingAnonymousBoxStyle(
+                    PseudoStyleType::verticalFramesetBorder);
+
+            borderFrame = new (presShell) nsHTMLFramesetBorderFrame(
+                pseudoComputedStyle, PresContext(), borderWidth, true, false);
+            borderFrame->Init(mContent, this, nullptr);
+            mChildCount++;
+            mFrames.AppendFrame(nullptr, borderFrame);
+            mVerBorders[cellIndex.x - 1] = borderFrame;
+            // set the neighbors for determining drag boundaries
+            borderFrame->mPrevNeighbor = lastCol;
+            borderFrame->mNextNeighbor = cellIndex.x;
+          } else {
+            borderFrame =
+                (nsHTMLFramesetBorderFrame*)mFrames.FrameAt(borderChildX);
+            borderFrame->mWidth = borderWidth;
+            borderChildX++;
+          }
+          nsSize borderSize(borderWidth, aDesiredSize.Height());
+          ReflowPlaceChild(borderFrame, aPresContext, aReflowInput, offset,
+                           borderSize);
+          borderFrame = nullptr;
+        }
+        offset.x += borderWidth;
+      }
+    }
+
+    ReflowPlaceChild(child, aPresContext, aReflowInput, offset, size,
+                     &cellIndex);
+
+    if (firstTime) {
+      int32_t childVis;
+      nsHTMLFramesetFrame* framesetFrame = do_QueryFrame(child);
+      if (framesetFrame) {
+        childVis = framesetFrame->mEdgeVisibility;
+        mChildBorderColors[childX] = framesetFrame->mEdgeColors;
+      } else if (child->IsSubDocumentFrame()) {
+        if (eFrameborder_Yes == mChildFrameborder[childX]) {
+          childVis = ALL_VIS;
+        } else if (eFrameborder_No == mChildFrameborder[childX]) {
+          childVis = NONE_VIS;
+        } else {  // notset
+          childVis = (eFrameborder_No == frameborder) ? NONE_VIS : ALL_VIS;
+        }
+      } else {  // blank
+#ifdef DEBUG
+        nsHTMLFramesetBlankFrame* blank = do_QueryFrame(child);
+        MOZ_ASSERT(blank, "unexpected child frame type");
+#endif
+        childVis = NONE_VIS;
+      }
+      nsBorderColor childColors = mChildBorderColors[childX];
+      // set the visibility, color of our edge borders based on children
+      if (0 == cellIndex.x) {
+        if (!(mEdgeVisibility & LEFT_VIS)) {
+          mEdgeVisibility |= (LEFT_VIS & childVis);
+        }
+        if (NO_COLOR == mEdgeColors.mLeft) {
+          mEdgeColors.mLeft = childColors.mLeft;
+        }
+      }
+      if (0 == cellIndex.y) {
+        if (!(mEdgeVisibility & TOP_VIS)) {
+          mEdgeVisibility |= (TOP_VIS & childVis);
+        }
+        if (NO_COLOR == mEdgeColors.mTop) {
+          mEdgeColors.mTop = childColors.mTop;
+        }
+      }
+      if (mNumCols - 1 == cellIndex.x) {
+        if (!(mEdgeVisibility & RIGHT_VIS)) {
+          mEdgeVisibility |= (RIGHT_VIS & childVis);
+        }
+        if (NO_COLOR == mEdgeColors.mRight) {
+          mEdgeColors.mRight = childColors.mRight;
+        }
+      }
+      if (mNumRows - 1 == cellIndex.y) {
+        if (!(mEdgeVisibility & BOTTOM_VIS)) {
+          mEdgeVisibility |= (BOTTOM_VIS & childVis);
+        }
+        if (NO_COLOR == mEdgeColors.mBottom) {
+          mEdgeColors.mBottom = childColors.mBottom;
+        }
+      }
+      // set the visibility of borders that the child may affect
+      if (childVis & RIGHT_VIS) {
+        verBordersVis[cellIndex.x] = true;
+      }
+      if (childVis & BOTTOM_VIS) {
+        horBordersVis[cellIndex.y] = true;
+      }
+      if ((cellIndex.x > 0) && (childVis & LEFT_VIS)) {
+        verBordersVis[cellIndex.x - 1] = true;
+      }
+      if ((cellIndex.y > 0) && (childVis & TOP_VIS)) {
+        horBordersVis[cellIndex.y - 1] = true;
+      }
+      // set the colors of borders that the child may affect
+      if (NO_COLOR == verBorderColors[cellIndex.x]) {
+        verBorderColors[cellIndex.x] = mChildBorderColors[childX].mRight;
+      }
+      if (NO_COLOR == horBorderColors[cellIndex.y]) {
+        horBorderColors[cellIndex.y] = mChildBorderColors[childX].mBottom;
+      }
+      if ((cellIndex.x > 0) && (NO_COLOR == verBorderColors[cellIndex.x - 1])) {
+        verBorderColors[cellIndex.x - 1] = mChildBorderColors[childX].mLeft;
+      }
+      if ((cellIndex.y > 0) && (NO_COLOR == horBorderColors[cellIndex.y - 1])) {
+        horBorderColors[cellIndex.y - 1] = mChildBorderColors[childX].mTop;
+      }
+    }
+    lastRow = cellIndex.y;
+    lastCol = cellIndex.x;
+    lastSize = size;
+    offset.x += size.width;
+    child = child->GetNextSibling();
+  }
+
+  if (firstTime) {
+    nscolor childColor;
+    // set the visibility, color, mouse sensitivity of borders
+    for (int verX = 0; verX < mNumCols - 1; verX++) {
+      if (mVerBorders[verX]) {
+        mVerBorders[verX]->SetVisibility(verBordersVis[verX]);
+        SetBorderResize(mVerBorders[verX]);
+        childColor = (NO_COLOR == verBorderColors[verX])
+                         ? borderColor
+                         : verBorderColors[verX];
+        mVerBorders[verX]->SetColor(childColor);
+      }
+    }
+    for (int horX = 0; horX < mNumRows - 1; horX++) {
+      if (mHorBorders[horX]) {
+        mHorBorders[horX]->SetVisibility(horBordersVis[horX]);
+        SetBorderResize(mHorBorders[horX]);
+        childColor = (NO_COLOR == horBorderColors[horX])
+                         ? borderColor
+                         : horBorderColors[horX];
+        mHorBorders[horX]->SetColor(childColor);
+      }
+    }
+
+    mChildFrameborder.reset();
+    mChildBorderColors.reset();
+  }
+
+  mDrag.UnSet();
+
+  aDesiredSize.SetOverflowAreasToDesiredBounds();
+  FinishAndStoreOverflow(&aDesiredSize);
+
+  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsHTMLFramesetFrame::GetFrameName(nsAString& aResult) const {
+  return MakeFrameName(u"Frameset"_ns, aResult);
+}
+#endif
+
+bool nsHTMLFramesetFrame::CanResize(bool aVertical, bool aLeft) {
+  int32_t childX;
+  int32_t startX;
+  if (aVertical) {
+    startX = (aLeft) ? 0 : mNumCols - 1;
+    for (childX = startX; childX < mNonBorderChildCount; childX += mNumCols) {
+      if (!CanChildResize(aVertical, aLeft, childX)) {
+        return false;
+      }
+    }
+  } else {
+    startX = (aLeft) ? 0 : (mNumRows - 1) * mNumCols;
+    int32_t endX = startX + mNumCols;
+    for (childX = startX; childX < endX; childX++) {
+      if (!CanChildResize(aVertical, aLeft, childX)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool nsHTMLFramesetFrame::GetNoResize(nsIFrame* aChildFrame) {
+  nsIContent* content = aChildFrame->GetContent();
+
+  return content && content->IsElement() &&
+         content->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::noresize);
+}
+
+bool nsHTMLFramesetFrame::CanChildResize(bool aVertical, bool aLeft,
+                                         int32_t aChildX) {
+  nsIFrame* child = mFrames.FrameAt(aChildX);
+  nsHTMLFramesetFrame* frameset = do_QueryFrame(child);
+  return frameset ? frameset->CanResize(aVertical, aLeft) : !GetNoResize(child);
+}
+
+// This calculates and sets the resizability of all border frames
+
+void nsHTMLFramesetFrame::RecalculateBorderResize() {
+  if (!mContent) {
+    return;
+  }
+
+  static_assert(
+      NS_MAX_FRAMESET_SPEC_COUNT < INT32_MAX / NS_MAX_FRAMESET_SPEC_COUNT,
+      "Check for overflow");
+  static_assert(NS_MAX_FRAMESET_SPEC_COUNT <
+                    UINT_MAX / sizeof(int32_t) / NS_MAX_FRAMESET_SPEC_COUNT,
+                "Check for overflow");
+  // set the visibility and mouse sensitivity of borders
+  int32_t verX;
+  for (verX = 0; verX < mNumCols - 1; verX++) {
+    if (mVerBorders[verX]) {
+      mVerBorders[verX]->mCanResize = true;
+      SetBorderResize(mVerBorders[verX]);
+    }
+  }
+  int32_t horX;
+  for (horX = 0; horX < mNumRows - 1; horX++) {
+    if (mHorBorders[horX]) {
+      mHorBorders[horX]->mCanResize = true;
+      SetBorderResize(mHorBorders[horX]);
+    }
+  }
+}
+
+void nsHTMLFramesetFrame::SetBorderResize(
+    nsHTMLFramesetBorderFrame* aBorderFrame) {
+  if (aBorderFrame->mVertical) {
+    for (int rowX = 0; rowX < mNumRows; rowX++) {
+      int32_t childX = aBorderFrame->mPrevNeighbor + (rowX * mNumCols);
+      if (!CanChildResize(true, false, childX) ||
+          !CanChildResize(true, true, childX + 1)) {
+        aBorderFrame->mCanResize = false;
+      }
+    }
+  } else {
+    int32_t childX = aBorderFrame->mPrevNeighbor * mNumCols;
+    int32_t endX = childX + mNumCols;
+    for (; childX < endX; childX++) {
+      if (!CanChildResize(false, false, childX)) {
+        aBorderFrame->mCanResize = false;
+      }
+    }
+    endX = endX + mNumCols;
+    for (; childX < endX; childX++) {
+      if (!CanChildResize(false, true, childX)) {
+        aBorderFrame->mCanResize = false;
+      }
+    }
+  }
+}
+
+void nsHTMLFramesetFrame::StartMouseDrag(nsPresContext* aPresContext,
+                                         nsHTMLFramesetBorderFrame* aBorder,
+                                         WidgetGUIEvent* aEvent) {
+#if 0
+  int32_t index;
+  IndexOf(aBorder, index);
+  NS_ASSERTION((nullptr != aBorder) && (index >= 0), "invalid dragger");
+#endif
+
+  PresShell::SetCapturingContent(GetContent(),
+                                 CaptureFlags::IgnoreAllowedState);
+
+  mDragger = aBorder;
+
+  mFirstDragPoint = aEvent->mRefPoint;
+
+  // Store the original frame sizes
+  if (mDragger->mVertical) {
+    mPrevNeighborOrigSize = mColSizes[mDragger->mPrevNeighbor];
+    mNextNeighborOrigSize = mColSizes[mDragger->mNextNeighbor];
+  } else {
+    mPrevNeighborOrigSize = mRowSizes[mDragger->mPrevNeighbor];
+    mNextNeighborOrigSize = mRowSizes[mDragger->mNextNeighbor];
+  }
+
+  gDragInProgress = true;
+}
+
+void nsHTMLFramesetFrame::MouseDrag(nsPresContext* aPresContext,
+                                    WidgetGUIEvent* aEvent) {
+  // if the capture ended, reset the drag state
+  if (PresShell::GetCapturingContent() != GetContent()) {
+    mDragger = nullptr;
+    gDragInProgress = false;
+    return;
+  }
+
+  int32_t change;  // measured positive from left-to-right or top-to-bottom
+  AutoWeakFrame weakFrame(this);
+  if (mDragger->mVertical) {
+    change = aPresContext->DevPixelsToAppUnits(aEvent->mRefPoint.x -
+                                               mFirstDragPoint.x);
+    if (change > mNextNeighborOrigSize - mMinDrag) {
+      change = mNextNeighborOrigSize - mMinDrag;
+    } else if (change <= mMinDrag - mPrevNeighborOrigSize) {
+      change = mMinDrag - mPrevNeighborOrigSize;
+    }
+    mColSizes[mDragger->mPrevNeighbor] = mPrevNeighborOrigSize + change;
+    mColSizes[mDragger->mNextNeighbor] = mNextNeighborOrigSize - change;
+
+    if (change != 0) {
+      // Recompute the specs from the new sizes.
+      nscoord width =
+          mRect.width - (mNumCols - 1) * GetBorderWidth(aPresContext, true);
+      HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
+      NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
+      const nsFramesetSpec* colSpecs = nullptr;
+      ourContent->GetColSpec(&mNumCols, &colSpecs);
+      nsAutoString newColAttr;
+      GenerateRowCol(aPresContext, width, mNumCols, colSpecs, mColSizes.get(),
+                     newColAttr);
+      // Setting the attr will trigger a reflow
+      mContent->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::cols,
+                                     newColAttr, true);
+    }
+  } else {
+    change = aPresContext->DevPixelsToAppUnits(aEvent->mRefPoint.y -
+                                               mFirstDragPoint.y);
+    if (change > mNextNeighborOrigSize - mMinDrag) {
+      change = mNextNeighborOrigSize - mMinDrag;
+    } else if (change <= mMinDrag - mPrevNeighborOrigSize) {
+      change = mMinDrag - mPrevNeighborOrigSize;
+    }
+    mRowSizes[mDragger->mPrevNeighbor] = mPrevNeighborOrigSize + change;
+    mRowSizes[mDragger->mNextNeighbor] = mNextNeighborOrigSize - change;
+
+    if (change != 0) {
+      // Recompute the specs from the new sizes.
+      nscoord height =
+          mRect.height - (mNumRows - 1) * GetBorderWidth(aPresContext, true);
+      HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
+      NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
+      const nsFramesetSpec* rowSpecs = nullptr;
+      ourContent->GetRowSpec(&mNumRows, &rowSpecs);
+      nsAutoString newRowAttr;
+      GenerateRowCol(aPresContext, height, mNumRows, rowSpecs, mRowSizes.get(),
+                     newRowAttr);
+      // Setting the attr will trigger a reflow
+      mContent->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::rows,
+                                     newRowAttr, true);
+    }
+  }
+
+  NS_ENSURE_TRUE_VOID(weakFrame.IsAlive());
+  if (change != 0) {
+    mDrag.Reset(mDragger->mVertical, mDragger->mPrevNeighbor, change, this);
+  }
+}
+
+void nsHTMLFramesetFrame::EndMouseDrag(nsPresContext* aPresContext) {
+  PresShell::ReleaseCapturingContent();
+  mDragger = nullptr;
+  gDragInProgress = false;
+}
+
+nsIFrame* NS_NewHTMLFramesetFrame(PresShell* aPresShell,
+                                  ComputedStyle* aStyle) {
+#ifdef DEBUG
+  const nsStyleDisplay* disp = aStyle->StyleDisplay();
+  NS_ASSERTION(!disp->IsAbsolutelyPositionedStyle() && !disp->IsFloatingStyle(),
+               "Framesets should not be positioned and should not float");
+#endif
+
+  return new (aPresShell)
+      nsHTMLFramesetFrame(aStyle, aPresShell->GetPresContext());
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsHTMLFramesetFrame)
+
+/*******************************************************************************
+ * nsHTMLFramesetBorderFrame
+ ******************************************************************************/
+nsHTMLFramesetBorderFrame::nsHTMLFramesetBorderFrame(
+    ComputedStyle* aStyle, nsPresContext* aPresContext, int32_t aWidth,
+    bool aVertical, bool aVisibility)
+    : nsLeafFrame(aStyle, aPresContext, kClassID),
+      mWidth(aWidth),
+      mVertical(aVertical),
+      mVisibility(aVisibility) {
+  mCanResize = true;
+  mColor = NO_COLOR;
+  mPrevNeighbor = 0;
+  mNextNeighbor = 0;
+}
+
+nsHTMLFramesetBorderFrame::~nsHTMLFramesetBorderFrame() {
+  // printf("nsHTMLFramesetBorderFrame destructor %p \n", this);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsHTMLFramesetBorderFrame)
+
+nscoord nsHTMLFramesetBorderFrame::GetIntrinsicISize() {
+  // No intrinsic width
+  return 0;
+}
+
+nscoord nsHTMLFramesetBorderFrame::GetIntrinsicBSize() {
+  // No intrinsic height
+  return 0;
+}
+
+void nsHTMLFramesetBorderFrame::SetVisibility(bool aVisibility) {
+  mVisibility = aVisibility;
+}
+
+void nsHTMLFramesetBorderFrame::SetColor(nscolor aColor) { mColor = aColor; }
+
+void nsHTMLFramesetBorderFrame::Reflow(nsPresContext* aPresContext,
+                                       ReflowOutput& aDesiredSize,
+                                       const ReflowInput& aReflowInput,
+                                       nsReflowStatus& aStatus) {
+  DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBorderFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+  // Override Reflow(), since we don't want to deal with what our
+  // computed values are.
+  SizeToAvailSize(aReflowInput, aDesiredSize);
+
+  aDesiredSize.SetOverflowAreasToDesiredBounds();
+}
+
+class nsDisplayFramesetBorder : public nsPaintedDisplayItem {
+ public:
+  nsDisplayFramesetBorder(nsDisplayListBuilder* aBuilder,
+                          nsHTMLFramesetBorderFrame* aFrame)
+      : nsPaintedDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplayFramesetBorder);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayFramesetBorder)
+
+  // REVIEW: see old GetFrameForPoint
+  // Receives events in its bounds
+  virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
+                       HitTestState* aState,
+                       nsTArray<nsIFrame*>* aOutFrames) override {
+    aOutFrames->AppendElement(mFrame);
+  }
+  virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+  NS_DISPLAY_DECL_NAME("FramesetBorder", TYPE_FRAMESET_BORDER)
+};
+
+void nsDisplayFramesetBorder::Paint(nsDisplayListBuilder* aBuilder,
+                                    gfxContext* aCtx) {
+  static_cast<nsHTMLFramesetBorderFrame*>(mFrame)->PaintBorder(
+      aCtx->GetDrawTarget(), ToReferenceFrame());
+}
+
+void nsHTMLFramesetBorderFrame::BuildDisplayList(
+    nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) {
+  aLists.Content()->AppendNewToTop<nsDisplayFramesetBorder>(aBuilder, this);
+}
+
+void nsHTMLFramesetBorderFrame::PaintBorder(DrawTarget* aDrawTarget,
+                                            nsPoint aPt) {
+  nscoord widthInPixels = nsPresContext::AppUnitsToIntCSSPixels(mWidth);
+  nscoord pixelWidth = nsPresContext::CSSPixelsToAppUnits(1);
+
+  if (widthInPixels <= 0) return;
+
+  ColorPattern bgColor(ToDeviceColor(LookAndFeel::GetColor(
+      LookAndFeel::ColorID::WidgetBackground, NS_RGB(200, 200, 200))));
+
+  ColorPattern fgColor(ToDeviceColor(LookAndFeel::GetColor(
+      LookAndFeel::ColorID::WidgetForeground, NS_RGB(0, 0, 0))));
+
+  ColorPattern hltColor(ToDeviceColor(LookAndFeel::GetColor(
+      LookAndFeel::ColorID::Widget3DHighlight, NS_RGB(255, 255, 255))));
+
+  ColorPattern sdwColor(ToDeviceColor(LookAndFeel::GetColor(
+      LookAndFeel::ColorID::Widget3DShadow, NS_RGB(128, 128, 128))));
+
+  ColorPattern color(ToDeviceColor(NS_RGB(255, 255, 255)));  // default to white
+  if (mVisibility) {
+    color =
+        (NO_COLOR == mColor) ? bgColor : ColorPattern(ToDeviceColor(mColor));
+  }
+
+  int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel();
+
+  Point toRefFrame = NSPointToPoint(aPt, appUnitsPerDevPixel);
+
+  AutoRestoreTransform autoRestoreTransform(aDrawTarget);
+  aDrawTarget->SetTransform(
+      aDrawTarget->GetTransform().PreTranslate(toRefFrame));
+
+  nsPoint start(0, 0);
+  nsPoint end = mVertical ? nsPoint(0, mRect.height) : nsPoint(mRect.width, 0);
+
+  // draw grey or white first
+  for (int i = 0; i < widthInPixels; i++) {
+    StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
+                           color);
+    if (mVertical) {
+      start.x += pixelWidth;
+      end.x = start.x;
+    } else {
+      start.y += pixelWidth;
+      end.y = start.y;
+    }
+  }
+
+  if (!mVisibility) return;
+
+  if (widthInPixels >= 5) {
+    start.x = (mVertical) ? pixelWidth : 0;
+    start.y = (mVertical) ? 0 : pixelWidth;
+    end.x = (mVertical) ? start.x : mRect.width;
+    end.y = (mVertical) ? mRect.height : start.y;
+    StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
+                           hltColor);
+  }
+
+  if (widthInPixels >= 2) {
+    start.x = (mVertical) ? mRect.width - (2 * pixelWidth) : 0;
+    start.y = (mVertical) ? 0 : mRect.height - (2 * pixelWidth);
+    end.x = (mVertical) ? start.x : mRect.width;
+    end.y = (mVertical) ? mRect.height : start.y;
+    StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
+                           sdwColor);
+  }
+
+  if (widthInPixels >= 1) {
+    start.x = (mVertical) ? mRect.width - pixelWidth : 0;
+    start.y = (mVertical) ? 0 : mRect.height - pixelWidth;
+    end.x = (mVertical) ? start.x : mRect.width;
+    end.y = (mVertical) ? mRect.height : start.y;
+    StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
+                           fgColor);
+  }
+}
+
+nsresult nsHTMLFramesetBorderFrame::HandleEvent(nsPresContext* aPresContext,
+                                                WidgetGUIEvent* aEvent,
+                                                nsEventStatus* aEventStatus) {
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+  *aEventStatus = nsEventStatus_eIgnore;
+
+  // XXX Mouse setting logic removed.  The remaining logic should also move.
+  if (!mCanResize) {
+    return NS_OK;
+  }
+
+  if (aEvent->mMessage == eMouseDown &&
+      aEvent->AsMouseEvent()->mButton == MouseButton::ePrimary) {
+    nsHTMLFramesetFrame* parentFrame = do_QueryFrame(GetParent());
+    if (parentFrame) {
+      parentFrame->StartMouseDrag(aPresContext, this, aEvent);
+      *aEventStatus = nsEventStatus_eConsumeNoDefault;
+    }
+  }
+  return NS_OK;
+}
+
+Maybe<nsIFrame::Cursor> nsHTMLFramesetBorderFrame::GetCursor(const nsPoint&) {
+  auto kind = StyleCursorKind::Default;
+  if (mCanResize) {
+    kind = mVertical ? StyleCursorKind::EwResize : StyleCursorKind::NsResize;
+  }
+  return Some(Cursor{kind, AllowCustomCursorImage::No});
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsHTMLFramesetBorderFrame::GetFrameName(nsAString& aResult) const {
+  return MakeFrameName(u"FramesetBorder"_ns, aResult);
+}
+#endif
+
+/*******************************************************************************
+ * nsHTMLFramesetBlankFrame
+ ******************************************************************************/
+
+NS_QUERYFRAME_HEAD(nsHTMLFramesetBlankFrame)
+  NS_QUERYFRAME_ENTRY(nsHTMLFramesetBlankFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsLeafFrame)
+
+NS_IMPL_FRAMEARENA_HELPERS(nsHTMLFramesetBlankFrame)
+
+nsHTMLFramesetBlankFrame::~nsHTMLFramesetBlankFrame() {
+  // printf("nsHTMLFramesetBlankFrame destructor %p \n", this);
+}
+
+nscoord nsHTMLFramesetBlankFrame::GetIntrinsicISize() {
+  // No intrinsic width
+  return 0;
+}
+
+nscoord nsHTMLFramesetBlankFrame::GetIntrinsicBSize() {
+  // No intrinsic height
+  return 0;
+}
+
+void nsHTMLFramesetBlankFrame::Reflow(nsPresContext* aPresContext,
+                                      ReflowOutput& aDesiredSize,
+                                      const ReflowInput& aReflowInput,
+                                      nsReflowStatus& aStatus) {
+  DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBlankFrame");
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+  // Override Reflow(), since we don't want to deal with what our
+  // computed values are.
+  SizeToAvailSize(aReflowInput, aDesiredSize);
+
+  aDesiredSize.SetOverflowAreasToDesiredBounds();
+}
+
+class nsDisplayFramesetBlank : public nsPaintedDisplayItem {
+ public:
+  nsDisplayFramesetBlank(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
+      : nsPaintedDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplayFramesetBlank);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayFramesetBlank)
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+  NS_DISPLAY_DECL_NAME("FramesetBlank", TYPE_FRAMESET_BLANK)
+};
+
+void nsDisplayFramesetBlank::Paint(nsDisplayListBuilder* aBuilder,
+                                   gfxContext* aCtx) {
+  DrawTarget* drawTarget = aCtx->GetDrawTarget();
+  int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
+  Rect rect =
+      NSRectToSnappedRect(GetPaintRect(), appUnitsPerDevPixel, *drawTarget);
+  ColorPattern white(ToDeviceColor(sRGBColor::OpaqueWhite()));
+  drawTarget->FillRect(rect, white);
+}
+
+void nsHTMLFramesetBlankFrame::BuildDisplayList(
+    nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) {
+  aLists.Content()->AppendNewToTop<nsDisplayFramesetBlank>(aBuilder, this);
+}