[cleanup] Rename RenderBox::frameRect()/setFrameRect() to borderBoxRectInContainer()/setBorderBoxRectInContainer()

https://bugs.webkit.org/show_bug.cgi?id=318048
<rdar://problem/181125416>

Reviewed by Antti Koivisto.

m_frameRect and its frameRect()/setFrameRect() accessors hold the border box
positioned in the container's coordinate space, but "frame" was vague and collided
with Frame/LocalFrame. Rename them to m_borderBoxRectInContainer /
borderBoxRectInContainer() / setBorderBoxRectInContainer(), naming the thing for what
it is and pairing directly with the existing borderBoxRect() (the same rect in the
renderer's own coordinates, { 0, 0, size }) -- the only difference is the coordinate
space. "container" matches RenderBox.h's own description of the location ("relative to
your container") and the mapLocalToContainer/offsetFromContainer vocabulary.

Also fixes the stale "frame rect" comments left behind and renames the flex
repaint-snapshot helpers (ChildFrameRects/FlexItemFrameRects and their append*
functions) to ...BorderBoxRects to match. No behavior change.

* Source/WebCore/accessibility/AccessibilityRenderObject.cpp:
(AccessibilityRenderObject::localRect):
* Source/WebCore/inspector/InspectorOverlay.cpp:
(InspectorOverlay::buildFlexOverlay):
* Source/WebCore/layout/Verification.cpp:
(outputMismatchingBlockBoxInformationIfNeeded):
* Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp:
(LineLayout::updateRenderTreePositions):
* Source/WebCore/page/LocalFrameView.cpp:
(LocalFrameView::visibleRectOfChild):
* Source/WebCore/rendering/RenderBlockFlow.cpp:
(RenderBlockFlow::layoutBlockChild):
(RenderBlockFlow::positionNewFloats):
* Source/WebCore/rendering/RenderBox.cpp:
(RenderBox::repaintDuringLayoutIfMoved):
* Source/WebCore/rendering/RenderBox.h:
* Source/WebCore/rendering/RenderBoxInlines.h:
(RenderBox::logicalSize):
* Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp:
(appendChildBorderBoxRects):
(repaintChildrenDuringLayoutIfMoved):
(RenderDeprecatedFlexibleBox::layoutBlock):
* Source/WebCore/rendering/RenderElement.cpp:
(RenderElement::getTrailingCorner):
* Source/WebCore/rendering/RenderFlexibleBox.cpp:
(RenderFlexibleBox::appendFlexItemBorderBoxRects):
(RenderFlexibleBox::repaintFlexItemsDuringLayoutIfMoved):
(RenderFlexibleBox::layoutBlock):
* Source/WebCore/rendering/RenderFlexibleBox.h:
* Source/WebCore/rendering/RenderGrid.cpp:
(RenderGrid::layoutGridItems):
* Source/WebCore/rendering/RenderLayer.cpp:
(computeLayerPositionAndIntegralSize):
* Source/WebCore/rendering/RenderLayerBacking.cpp:
(RenderLayerBacking::RenderLayerBacking):
* Source/WebCore/rendering/RenderLayerScrollableArea.cpp:
(RenderLayerScrollableArea::positionOverflowControls):
* Source/WebCore/rendering/RenderLayoutState.h:
* Source/WebCore/rendering/RenderMeter.cpp:
(RenderMeter::updateLogicalWidth):
(RenderMeter::computeLogicalHeight):
* Source/WebCore/rendering/RenderMultiColumnSet.cpp:
(RenderMultiColumnSet::collectLayerFragments):
* Source/WebCore/rendering/RenderObject.cpp:
(RenderObject::outputRenderObject):
* Source/WebCore/rendering/RenderProgress.cpp:
(RenderProgress::updateFromElement):
* Source/WebCore/rendering/RenderReplica.cpp:
(RenderReplica::layout):
* Source/WebCore/rendering/RenderScrollbar.cpp:
(RenderScrollbar::buttonRect):
* Source/WebCore/rendering/RenderTable.cpp:
(RenderTable::layoutCaption):
* Source/WebCore/rendering/RenderTableCell.cpp:
(backgroundRectForRow):
* Source/WebCore/rendering/RenderTableSection.cpp:
(RenderTableSection::layoutRows):
(RenderTableSection::paintObject):
* Source/WebCore/rendering/RenderTextControlSingleLine.cpp:
(RenderTextControlSingleLine::controlClipRect):
* Source/WebCore/rendering/RenderTreeAsText.cpp:
(RenderTreeAsText::writeRenderObject):
* Source/WebCore/rendering/mathml/RenderMathMLMath.cpp:
(RenderMathMLMath::centerChildren):
* Source/WebCore/rendering/mathml/RenderMathMLRow.cpp:
(RenderMathMLRow::layoutRowItems):
* Source/WebCore/rendering/svg/RenderSVGText.cpp:
(RenderSVGText::updatePositionAndOverflow):
* Source/WebCore/rendering/svg/SVGRenderTreeAsText.cpp:
(writePositionAndStyle):

Canonical link: https://commits.webkit.org/316286@main

Author: alanbaradlay

Source/WebCore/accessibility/AccessibilityRenderObject.cpp

@@ -3220,7 +3220,7 @@ FloatRect AccessibilityRenderObject::localRect() const
 {
     CheckedPtr renderer = this->renderer();
     if (CheckedPtr box = dynamicDowncast<RenderBox>(renderer.get()))
-        return box ? convertFrameToSpace(box->frameRect(), AccessibilityConversionSpace::Page) : FloatRect();
+        return box ? convertFrameToSpace(box->borderBoxRectInContainer(), AccessibilityConversionSpace::Page) : FloatRect();
 
     CheckedPtr renderText = dynamicDowncast<RenderText>(renderer.get());
     return renderText ? renderText->linesBoundingBox() : FloatRect();

Source/WebCore/inspector/InspectorOverlay.cpp

@@ -2271,7 +2271,7 @@ std::optional<InspectorOverlay::Highlight::FlexHighlightOverlay> InspectorOverla
     for (CheckedPtr renderChild : renderChildrenInFlexOrder) {
         // Build bounds for each child and collect children on the same logical line.
         {
-            auto childRect = renderChild->frameRect();
+            auto childRect = renderChild->borderBoxRectInContainer();
             renderFlex->flipForWritingMode(childRect);
             childRect.expand(renderChild->marginBox());
 

Source/WebCore/layout/Verification.cpp

@@ -219,7 +219,7 @@ static bool outputMismatchingBlockBoxInformationIfNeeded(TextStream& stream, con
     };
 
     // rendering does not offset for relative positioned boxes.
-    auto frameRect = renderer.frameRect();
+    auto frameRect = renderer.borderBoxRectInContainer();
     if (renderer.isInFlowPositioned())
         frameRect.move(renderer.offsetForInFlowPosition());
 
@@ -245,7 +245,7 @@ static bool outputMismatchingBlockBoxInformationIfNeeded(TextStream& stream, con
             return false;
     }
     if (!areEssentiallyEqual(frameRect, BoxGeometry::borderBoxRect(boxGeometry))) {
-        outputRect("frameBox"_s, renderer.frameRect(), BoxGeometry::borderBoxRect(boxGeometry));
+        outputRect("frameBox"_s, renderer.borderBoxRectInContainer(), BoxGeometry::borderBoxRect(boxGeometry));
         return true;
     }
 

Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp

@@ -634,7 +634,7 @@ void LineLayout::updateRenderTreePositions(const Vector<LineAdjustment>& lineAdj
             floatingObject.setMarginOffset({ borderBoxVisualRect.x() - marginBoxVisualRect.x(), borderBoxVisualRect.y() - marginBoxVisualRect.y() });
             floatingObject.setIsPlaced(true);
 
-            auto oldRect = renderer->frameRect();
+            auto oldRect = renderer->borderBoxRectInContainer();
             renderer->setLocation(borderBoxVisualRect.location());
 
             if (renderer->checkForRepaintDuringLayout()) {

Source/WebCore/page/LocalFrameView.cpp

@@ -2130,7 +2130,7 @@ std::optional<LayoutRect> LocalFrameView::visibleRectOfChild(const Frame& child)
     ASSERT(childOwnerRenderer->frame().frameID() == m_frame->frameID());
 
     auto rects = childOwnerRenderer->computeVisibleRectsInContainer(
-        { childOwnerRenderer->frameRect() },
+        { childOwnerRenderer->borderBoxRectInContainer() },
         &childOwnerRenderer->view(),
         {
             .hasPositionFixedDescendant = false,

Source/WebCore/rendering/RenderBlockFlow.cpp

@@ -1182,7 +1182,7 @@ void RenderBlockFlow::layoutBlockChild(RenderBox& child, MarginInfo& marginInfo,
     LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, marginInfo, estimateWithoutPagination);
 
     // Cache our old rect so that we can dirty the proper repaint rects if the child moves.
-    LayoutRect oldRect = child.frameRect();
+    LayoutRect oldRect = child.borderBoxRectInContainer();
     LayoutUnit oldLogicalTop = logicalTopForChild(child);
 
 #if ASSERT_ENABLED
@@ -2972,7 +2972,7 @@ bool RenderBlockFlow::positionNewFloats()
         if (childBox.containingBlock() != this)
             continue;
 
-        LayoutRect oldRect = childBox.frameRect();
+        LayoutRect oldRect = childBox.borderBoxRectInContainer();
         auto childBoxUsedClear = Style::ComputedStyle::usedClear(childBox);
         if (childBoxUsedClear == UsedClear::Left || childBoxUsedClear == UsedClear::Both)
             logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatLeft), logicalTop);

Source/WebCore/rendering/RenderBox.cpp

@@ -119,7 +119,7 @@ WTF_MAKE_TZONE_ALLOCATED_IMPL(RenderBox);
 
 struct SameSizeAsRenderBox : public RenderBoxModelObject {
     virtual ~SameSizeAsRenderBox() = default;
-    LayoutRect frameRect;
+    LayoutRect borderBoxRectInContainer;
     LayoutBoxExtent marginBox;
     LayoutUnit preferredLogicalWidths[2];
     void* pointers[1];
@@ -2754,14 +2754,14 @@ auto RenderBox::computeVisibleRectsInContainer(const RepaintRects& rects, const
 
 void RenderBox::repaintDuringLayoutIfMoved(const LayoutRect& oldRect)
 {
-    if (oldRect.location() != m_frameRect.location()) {
-        LayoutRect newRect = m_frameRect;
+    if (oldRect.location() != m_borderBoxRectInContainer.location()) {
+        LayoutRect newRect = m_borderBoxRectInContainer;
         // The child moved.  Invalidate the object's old and new positions.  We have to do this
         // since the object may not have gotten a layout.
-        m_frameRect = oldRect;
+        m_borderBoxRectInContainer = oldRect;
         repaint();
         repaintOverhangingFloats(true);
-        m_frameRect = newRect;
+        m_borderBoxRectInContainer = newRect;
         repaint();
         repaintOverhangingFloats(true);
     }

Source/WebCore/rendering/RenderBox.h

@@ -62,20 +62,18 @@ class RenderBox : public RenderBoxModelObject {
     bool NODELETE requiresLayerWithScrollableArea() const;
     bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const override;
 
-    LayoutUnit x() const { return m_frameRect.x(); }
-    LayoutUnit y() const { return m_frameRect.y(); }
-    LayoutUnit borderBoxWidth() const { return m_frameRect.width(); }
-    LayoutUnit borderBoxHeight() const { return m_frameRect.height(); }
+    LayoutUnit x() const { return m_borderBoxRectInContainer.x(); }
+    LayoutUnit y() const { return m_borderBoxRectInContainer.y(); }
 
     // These represent your location relative to your container as a physical offset.
     // In layout related methods you almost always want the logical location (e.g. x() and y()).
     LayoutUnit top() const { return topLeftLocation().y(); }
     LayoutUnit left() const { return topLeftLocation().x(); }
 
-    template<typename T> void setX(T x) { m_frameRect.setX(x); }
-    template<typename T> void setY(T y) { m_frameRect.setY(y); }
-    template<typename T> void setBorderBoxWidth(T width) { m_frameRect.setWidth(width); }
-    template<typename T> void setBorderBoxHeight(T height) { m_frameRect.setHeight(height); }
+    template<typename T> void setX(T x) { m_borderBoxRectInContainer.setX(x); }
+    template<typename T> void setY(T y) { m_borderBoxRectInContainer.setY(y); }
+    template<typename T> void setBorderBoxWidth(T width) { m_borderBoxRectInContainer.setWidth(width); }
+    template<typename T> void setBorderBoxHeight(T height) { m_borderBoxRectInContainer.setHeight(height); }
 
     inline LayoutUnit logicalLeft() const;
     inline LayoutUnit logicalRight() const;
@@ -96,28 +94,22 @@ class RenderBox : public RenderBoxModelObject {
     inline void setLogicalHeight(LayoutUnit);
     inline void setLogicalSize(LayoutSize);
 
-    LayoutPoint location() const { return m_frameRect.location(); }
+    LayoutPoint location() const { return m_borderBoxRectInContainer.location(); }
     LayoutSize locationOffset() const { return LayoutSize(x(), y()); }
-    LayoutSize borderBoxSize() const { return m_frameRect.size(); }
     inline LayoutSize logicalSize() const;
 
-    void setLocation(const LayoutPoint& location) { m_frameRect.setLocation(location); }
+    void setLocation(const LayoutPoint& location) { m_borderBoxRectInContainer.setLocation(location); }
 
-    void setBorderBoxSize(const LayoutSize& size) { m_frameRect.setSize(size); }
-    void move(LayoutUnit dx, LayoutUnit dy) { m_frameRect.move(dx, dy); }
+    void setBorderBoxSize(const LayoutSize& size) { m_borderBoxRectInContainer.setSize(size); }
+    void move(LayoutUnit dx, LayoutUnit dy) { m_borderBoxRectInContainer.move(dx, dy); }
 
-    LayoutRect frameRect() const { return m_frameRect; }
-    void setFrameRect(const LayoutRect& rect) { m_frameRect = rect; }
-
-    inline LayoutRect marginBoxRect() const;
-    LayoutRect borderBoxRect() const { return LayoutRect(LayoutPoint(), borderBoxSize()); }
-    LayoutRect borderBoundingBox() const final { return borderBoxRect(); }
+    LayoutRect borderBoxRectInContainer() const { return m_borderBoxRectInContainer; }
+    void setBorderBoxInContainer(const LayoutRect& rect) { m_borderBoxRectInContainer = rect; }
 
     // Don't use this; it doesn't make sense in a future world with corner-shape. Use BorderShape instead.
     WEBCORE_EXPORT LayoutRoundedRectRadii borderRadii() const;
 
     // The content area of the box (excludes padding - and intrinsic padding for table cells, etc... - and border).
-    inline LayoutRect contentBoxRect() const;
     LayoutPoint contentBoxLocation() const;
     inline LayoutRect flippedContentBoxRect() const;
 
@@ -196,6 +188,12 @@ class RenderBox : public RenderBoxModelObject {
 
     void applyTransform(TransformationMatrix&, const Style::ComputedStyle&, const FloatRect& boundingBox, OptionSet<Style::TransformResolverOption>) const override;
 
+    // margin, border, padding and content box rects are relative to border box.
+    inline LayoutRect marginBoxRect() const;
+    LayoutRect borderBoxRect() const { return { { }, borderBoxSize() }; }
+    LayoutRect paddingBoxRect() const;
+    inline LayoutRect contentBoxRect() const;
+
     inline LayoutSize contentBoxSize() const;
     inline LayoutUnit contentBoxWidth() const;
     inline LayoutUnit contentBoxHeight() const;
@@ -210,9 +208,14 @@ class RenderBox : public RenderBoxModelObject {
     inline LayoutUnit paddingBoxLogicalWidth() const;
     inline LayoutUnit paddingBoxLogicalHeight() const;
     inline LayoutUnit paddingBoxLogicalBottom() const;
-    LayoutRect paddingBoxRect() const;
     inline LayoutRect paddingBoxRectIncludingScrollbar() const;
 
+    LayoutUnit borderBoxWidth() const { return m_borderBoxRectInContainer.width(); }
+    LayoutUnit borderBoxHeight() const { return m_borderBoxRectInContainer.height(); }
+    LayoutSize borderBoxSize() const { return m_borderBoxRectInContainer.size(); }
+
+    LayoutRect borderBoundingBox() const final { return borderBoxRect(); }
+
     // IE extensions. Used to calculate offsetWidth/Height.  Overridden by inlines (RenderFlow)
     // to return the remaining width on a given line (and the height of a single line).
     LayoutUnit offsetWidth() const override { return borderBoxWidth(); }
@@ -758,7 +761,7 @@ class RenderBox : public RenderBoxModelObject {
     // These include tables, positioned objects, floats and flexible boxes.
     virtual void computeIntrinsicLogicalWidthContributions();
 
-    LayoutRect frameRectForStickyPositioning() const override { return frameRect(); }
+    LayoutRect frameRectForStickyPositioning() const override { return borderBoxRectInContainer(); }
 
     RepaintRects computeVisibleRectsUsingPaintOffset(const RepaintRects&) const;
 
@@ -768,8 +771,8 @@ class RenderBox : public RenderBoxModelObject {
     void removeShapeOutsideInfo();
 
 private:
-    // The width/height of the contents + borders + padding.  The x/y location is relative to our container (which is not always our parent).
-    LayoutRect m_frameRect;
+    // Relative to our container.
+    LayoutRect m_borderBoxRectInContainer;
 
 protected:
     LayoutBoxExtent m_marginBox;

Source/WebCore/rendering/RenderBoxInlines.h

@@ -62,7 +62,7 @@ inline LayoutUnit RenderBox::logicalLeftVisualOverflow() const { return writingM
 inline LayoutUnit RenderBox::logicalRight() const { return logicalLeft() + logicalWidth(); }
 inline LayoutUnit RenderBox::logicalRightLayoutOverflow() const { return writingMode().isHorizontal() ? layoutOverflowRect().maxX() : layoutOverflowRect().maxY(); }
 inline LayoutUnit RenderBox::logicalRightVisualOverflow() const { return writingMode().isHorizontal() ? visualOverflowRect().maxX() : visualOverflowRect().maxY(); }
-inline LayoutSize RenderBox::logicalSize() const { return writingMode().isHorizontal() ? m_frameRect.size() : m_frameRect.size().transposedSize(); }
+inline LayoutSize RenderBox::logicalSize() const { return writingMode().isHorizontal() ? m_borderBoxRectInContainer.size() : m_borderBoxRectInContainer.size().transposedSize(); }
 inline LayoutUnit RenderBox::logicalTop() const { return writingMode().isHorizontal() ? y() : x(); }
 inline LayoutUnit RenderBox::logicalWidth() const { return writingMode().isHorizontal() ? borderBoxWidth() : borderBoxHeight(); }
 inline LayoutUnit RenderBox::paddingBoxHeight() const { return std::max(0_lu, borderBoxHeight() - borderTop() - borderBottom() - horizontalScrollbarHeight()); }

Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp

@@ -281,15 +281,15 @@ void RenderDeprecatedFlexibleBox::computeIntrinsicLogicalWidthContributions()
 }
 
 // Use an inline capacity of 8, since flexbox containers usually have less than 8 children.
-typedef Vector<LayoutRect, 8> ChildFrameRects;
+typedef Vector<LayoutRect, 8> ChildBorderBoxRects;
 typedef Vector<LayoutSize, 8> ChildLayoutDeltas;
 
-static void appendChildFrameRects(RenderDeprecatedFlexibleBox* box, ChildFrameRects& childFrameRects)
+static void appendChildBorderBoxRects(RenderDeprecatedFlexibleBox* box, ChildBorderBoxRects& childBorderBoxRects)
 {
     FlexBoxIterator iterator(box);
     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
         if (!child->isOutOfFlowPositioned())
-            childFrameRects.append(child->frameRect());
+            childBorderBoxRects.append(child->borderBoxRectInContainer());
     }
 }
 
@@ -302,7 +302,7 @@ static void appendChildLayoutDeltas(RenderDeprecatedFlexibleBox* box, ChildLayou
     }
 }
 
-static void repaintChildrenDuringLayoutIfMoved(RenderDeprecatedFlexibleBox* box, const ChildFrameRects& oldChildRects)
+static void repaintChildrenDuringLayoutIfMoved(RenderDeprecatedFlexibleBox* box, const ChildBorderBoxRects& oldChildRects)
 {
     size_t childIndex = 0;
     FlexBoxIterator iterator(box);
@@ -383,8 +383,8 @@ void RenderDeprecatedFlexibleBox::layoutBlock(RelayoutChildren relayoutChildren,
         // It doesn't get included in the normal layout process but is instead skipped.
         layoutExcludedChildren(relayoutChildren);
 
-        ChildFrameRects oldChildRects;
-        appendChildFrameRects(this, oldChildRects);
+        ChildBorderBoxRects oldChildRects;
+        appendChildBorderBoxRects(this, oldChildRects);
 
         if (isHorizontal())
             layoutHorizontalBox(relayoutChildren);