/* -*- 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 "nsGenericHTMLElement.h"
#include "nsAttrValueInlines.h"
#include "nsLeafFrame.h"
#include "nsContainerFrame.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsIContentInlines.h"
#include "nsIPresShell.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsHTMLParts.h"
#include "nsNameSpaceManager.h"
#include "nsCSSAnonBoxes.h"
#include "mozilla/ServoStyleSet.h"
#include "mozilla/dom/Element.h"
#include "nsDisplayList.h"
#include "nsNodeUtils.h"
#include "mozAutoDocUpdate.h"
#include "mozilla/Preferences.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(NS_LITERAL_STRING("FramesetBlank"), 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() {}

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();
  nsIPresShell* shell = 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

  for (nsIContent* child = mContent->GetFirstChild(); child;
       child = child->GetNextSibling()) {
    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->IsHTMLElement()) {
      continue;
    }

    if (!child->IsAnyOfHTMLElements(nsGkAtoms::frameset, nsGkAtoms::frame)) {
      continue;
    }

    RefPtr<ComputedStyle> kidSC = shell->StyleSet()->ResolveStyleFor(
        child->AsElement(), LazyComputeBehavior::Allow);

    nsIFrame* frame;
    if (child->IsHTMLElement(nsGkAtoms::frameset)) {
      frame = NS_NewHTMLFramesetFrame(shell, kidSC);

      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(shell, kidSC);

      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 =
        shell->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 (shell)
        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()->button == WidgetMouseEvent::eLeftButton) {
          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()->AppendToTop(
        MakeDisplayItem<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, 0, status);
  NS_ASSERTION(status.IsComplete(), "bad status");

  // Place and size the child
  reflowOutput.Width() = aSize.width;
  reflowOutput.Height() = aSize.height;
  FinishReflowChild(aChild, aPresContext, reflowOutput, nullptr, aOffset.x,
                    aOffset.y, 0);
}

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!");

  nsIPresShell* shell = aPresContext->PresShell();
  ServoStyleSet* styleSet = shell->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 (shell) 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 (shell) 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);
      nsSubDocumentFrame* subdocFrame;
      if (framesetFrame) {
        childVis = framesetFrame->mEdgeVisibility;
        mChildBorderColors[childX] = framesetFrame->mEdgeColors;
      } else if ((subdocFrame = do_QueryFrame(child))) {
        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(NS_LITERAL_STRING("Frameset"), 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

  nsIPresShell::SetCapturingContent(GetContent(), CAPTURE_IGNOREALLOWED);

  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 (nsIPresShell::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) {
  nsIPresShell::SetCapturingContent(nullptr, 0);
  mDragger = nullptr;
  gDragInProgress = false;
}

nsIFrame* NS_NewHTMLFramesetFrame(nsIPresShell* 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 nsDisplayItem {
 public:
  nsDisplayFramesetBorder(nsDisplayListBuilder* aBuilder,
                          nsHTMLFramesetBorderFrame* aFrame)
      : nsDisplayItem(aBuilder, aFrame) {
    MOZ_COUNT_CTOR(nsDisplayFramesetBorder);
  }
#ifdef NS_BUILD_REFCNT_LOGGING
  virtual ~nsDisplayFramesetBorder() {
    MOZ_COUNT_DTOR(nsDisplayFramesetBorder);
  }
#endif

  // 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()->AppendToTop(
      MakeDisplayItem<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::eColorID_WidgetBackground, NS_RGB(200, 200, 200))));

  ColorPattern fgColor(ToDeviceColor(LookAndFeel::GetColor(
      LookAndFeel::eColorID_WidgetForeground, NS_RGB(0, 0, 0))));

  ColorPattern hltColor(ToDeviceColor(LookAndFeel::GetColor(
      LookAndFeel::eColorID_Widget3DHighlight, NS_RGB(255, 255, 255))));

  ColorPattern sdwColor(ToDeviceColor(LookAndFeel::GetColor(
      LookAndFeel::eColorID_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()->button == WidgetMouseEvent::eLeftButton) {
    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(NS_LITERAL_STRING("FramesetBorder"), 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 nsDisplayItem {
 public:
  nsDisplayFramesetBlank(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
      : nsDisplayItem(aBuilder, aFrame) {
    MOZ_COUNT_CTOR(nsDisplayFramesetBlank);
  }
#ifdef NS_BUILD_REFCNT_LOGGING
  virtual ~nsDisplayFramesetBlank() { MOZ_COUNT_DTOR(nsDisplayFramesetBlank); }
#endif

  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(Color(1.f, 1.f, 1.f, 1.f)));
  drawTarget->FillRect(rect, white);
}

void nsHTMLFramesetBlankFrame::BuildDisplayList(
    nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) {
  aLists.Content()->AppendToTop(
      MakeDisplayItem<nsDisplayFramesetBlank>(aBuilder, this));
}