Diff
Modified: trunk/Source/WebCore/ChangeLog (252459 => 252460)
--- trunk/Source/WebCore/ChangeLog 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/ChangeLog 2019-11-14 19:42:50 UTC (rev 252460)
@@ -1,3 +1,37 @@
+2019-11-14 Zalan Bujtas <[email protected]>
+
+ [LFC][Invalidation] Use InvalidationState to populate LayoutQueue
+ https://bugs.webkit.org/show_bug.cgi?id=204191
+ <rdar://problem/57179614>
+
+ Reviewed by Antti Koivisto.
+
+ Start using the InvalidationState in BlockFormattingContext::layoutInFlowContent() to filter out
+ non-dirty boxes (currently InvalidationState returns true for every box).
+
+ * layout/FormattingContext.cpp:
+ (WebCore::Layout::FormattingContext::layoutOutOfFlowContent):
+ * layout/FormattingContext.h: InvalidationState should not be const as we keep adding additional dirty boxes during layout.
+ * layout/LayoutContext.cpp:
+ (WebCore::Layout::LayoutContext::layout):
+ (WebCore::Layout::LayoutContext::layoutFormattingContextSubtree):
+ * layout/LayoutContext.h:
+ * layout/blockformatting/BlockFormattingContext.cpp:
+ (WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
+ (WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot):
+ * layout/blockformatting/BlockFormattingContext.h:
+ * layout/inlineformatting/InlineFormattingContext.cpp:
+ (WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
+ (WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot):
+ * layout/inlineformatting/InlineFormattingContext.h:
+ * layout/invalidation/InvalidationState.cpp:
+ (WebCore::Layout::InvalidationState::needsLayout const):
+ * layout/invalidation/InvalidationState.h:
+ * layout/tableformatting/TableFormattingContext.cpp:
+ (WebCore::Layout::TableFormattingContext::layoutInFlowContent):
+ (WebCore::Layout::TableFormattingContext::layoutTableCellBox):
+ * layout/tableformatting/TableFormattingContext.h:
+
2019-11-14 Chris Fleizach <[email protected]>
AX: Implement isolated tree support for math objects
Modified: trunk/Source/WebCore/layout/FormattingContext.cpp (252459 => 252460)
--- trunk/Source/WebCore/layout/FormattingContext.cpp 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/FormattingContext.cpp 2019-11-14 19:42:50 UTC (rev 252460)
@@ -149,7 +149,7 @@
displayBox.setPadding(geometry().computedPadding(layoutBox, *usedHorizontalValues));
}
-void FormattingContext::layoutOutOfFlowContent()
+void FormattingContext::layoutOutOfFlowContent(InvalidationState& invalidationState)
{
LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: layout out-of-flow content -> context: " << &layoutState() << " root: " << &root());
@@ -161,9 +161,9 @@
if (is<Container>(*outOfFlowBox)) {
auto& outOfFlowRootContainer = downcast<Container>(*outOfFlowBox);
auto formattingContext = LayoutContext::createFormattingContext(outOfFlowRootContainer, layoutState());
- formattingContext->layoutInFlowContent();
+ formattingContext->layoutInFlowContent(invalidationState);
computeOutOfFlowVerticalGeometry(outOfFlowRootContainer);
- formattingContext->layoutOutOfFlowContent();
+ formattingContext->layoutOutOfFlowContent(invalidationState);
} else
computeOutOfFlowVerticalGeometry(*outOfFlowBox);
}
Modified: trunk/Source/WebCore/layout/FormattingContext.h (252459 => 252460)
--- trunk/Source/WebCore/layout/FormattingContext.h 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/FormattingContext.h 2019-11-14 19:42:50 UTC (rev 252460)
@@ -43,19 +43,20 @@
namespace Layout {
-class Container;
class Box;
-class FormattingState;
-class LayoutState;
struct ComputedHorizontalMargin;
struct ComputedVerticalMargin;
+class Container;
+struct ContentHeightAndMargin;
+struct ContentWidthAndMargin;
struct Edges;
-struct ContentHeightAndMargin;
+class FormattingState;
struct HorizontalGeometry;
+class InvalidationState;
+class LayoutState;
struct UsedHorizontalValues;
struct UsedVerticalValues;
struct VerticalGeometry;
-struct ContentWidthAndMargin;
class FormattingContext {
WTF_MAKE_ISO_ALLOCATED(FormattingContext);
@@ -63,8 +64,8 @@
FormattingContext(const Container& formattingContextRoot, FormattingState&);
virtual ~FormattingContext();
- virtual void layoutInFlowContent() = 0;
- void layoutOutOfFlowContent();
+ virtual void layoutInFlowContent(InvalidationState&) = 0;
+ void layoutOutOfFlowContent(InvalidationState&);
struct IntrinsicWidthConstraints {
void expand(LayoutUnit horizontalValue);
Modified: trunk/Source/WebCore/layout/LayoutContext.cpp (252459 => 252460)
--- trunk/Source/WebCore/layout/LayoutContext.cpp 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/LayoutContext.cpp 2019-11-14 19:42:50 UTC (rev 252460)
@@ -56,7 +56,7 @@
{
}
-void LayoutContext::layout(const InvalidationState& invalidationState)
+void LayoutContext::layout(InvalidationState& invalidationState)
{
PhaseScope scope(Phase::Type::Layout);
@@ -63,15 +63,15 @@
auto& formattingContextRootsForLayout = invalidationState.formattingContextRoots();
ASSERT(!formattingContextRootsForLayout.computesEmpty());
for (auto& formattingContextRoot : formattingContextRootsForLayout)
- layoutFormattingContextSubtree(formattingContextRoot);
+ layoutFormattingContextSubtree(formattingContextRoot, invalidationState);
}
-void LayoutContext::layoutFormattingContextSubtree(const Container& formattingContextRoot)
+void LayoutContext::layoutFormattingContextSubtree(const Container& formattingContextRoot, InvalidationState& invalidationState)
{
RELEASE_ASSERT(formattingContextRoot.establishesFormattingContext());
auto formattingContext = createFormattingContext(formattingContextRoot, layoutState());
- formattingContext->layoutInFlowContent();
- formattingContext->layoutOutOfFlowContent();
+ formattingContext->layoutInFlowContent(invalidationState);
+ formattingContext->layoutOutOfFlowContent(invalidationState);
}
std::unique_ptr<FormattingContext> LayoutContext::createFormattingContext(const Container& formattingContextRoot, LayoutState& layoutState)
Modified: trunk/Source/WebCore/layout/LayoutContext.h (252459 => 252460)
--- trunk/Source/WebCore/layout/LayoutContext.h 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/LayoutContext.h 2019-11-14 19:42:50 UTC (rev 252460)
@@ -57,12 +57,12 @@
static void paint(const LayoutState&, GraphicsContext&, const IntRect& dirtyRect);
LayoutContext(LayoutState&);
- void layout(const InvalidationState&);
+ void layout(InvalidationState&);
static std::unique_ptr<FormattingContext> createFormattingContext(const Container& formattingContextRoot, LayoutState&);
private:
- void layoutFormattingContextSubtree(const Container&);
+ void layoutFormattingContextSubtree(const Container&, InvalidationState&);
LayoutState& layoutState() { return m_layoutState; }
// For testing purposes only
Modified: trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp (252459 => 252460)
--- trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp 2019-11-14 19:42:50 UTC (rev 252460)
@@ -31,6 +31,7 @@
#include "BlockFormattingState.h"
#include "FloatingContext.h"
#include "FloatingState.h"
+#include "InvalidationState.h"
#include "LayoutBox.h"
#include "LayoutChildIterator.h"
#include "LayoutContainer.h"
@@ -49,7 +50,8 @@
{
}
-void BlockFormattingContext::layoutInFlowContent()
+enum class LayoutDirection { Child, Sibling };
+void BlockFormattingContext::layoutInFlowContent(InvalidationState& invalidationState)
{
// 9.4.1 Block formatting contexts
// In a block formatting context, boxes are laid out one after the other, vertically, beginning at the top of a containing block.
@@ -56,14 +58,40 @@
// The vertical distance between two sibling boxes is determined by the 'margin' properties.
// Vertical margins between adjacent block-level boxes in a block formatting context collapse.
LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> block formatting context -> formatting root(" << &root() << ")");
+ auto& formattingRoot = root();
+ auto floatingContext = FloatingContext { formattingRoot, *this, formattingState().floatingState() };
- auto& formattingRoot = root();
LayoutQueue layoutQueue;
- auto floatingContext = FloatingContext { formattingRoot, *this, formattingState().floatingState() };
+ auto appendNextToLayoutQueue = [&] (const auto& layoutBox, auto direction) {
+ if (direction == LayoutDirection::Child) {
+ if (!is<Container>(layoutBox))
+ return false;
+ for (auto* child = downcast<Container>(layoutBox).firstInFlowOrFloatingChild(); child; child = child->nextInFlowOrFloatingSibling()) {
+ if (!invalidationState.needsLayout(*child))
+ continue;
+ layoutQueue.append(child);
+ return true;
+ }
+ return false;
+ }
+
+ if (direction == LayoutDirection::Sibling) {
+ for (auto* nextSibling = layoutBox.nextInFlowOrFloatingSibling(); nextSibling; nextSibling = nextSibling->nextInFlowOrFloatingSibling()) {
+ if (!invalidationState.needsLayout(*nextSibling))
+ continue;
+ layoutQueue.append(nextSibling);
+ return true;
+ }
+ return false;
+ }
+ ASSERT_NOT_REACHED();
+ return false;
+ };
+
+
// This is a post-order tree traversal layout.
// The root container layout is done in the formatting context it lives in, not that one it creates, so let's start with the first child.
- if (auto* firstChild = formattingRoot.firstInFlowOrFloatingChild())
- layoutQueue.append(firstChild);
+ appendNextToLayoutQueue(formattingRoot, LayoutDirection::Child);
// 1. Go all the way down to the leaf node
// 2. Compute static position and width as we traverse down
// 3. As we climb back on the tree, compute height and finialize position
@@ -74,23 +102,20 @@
auto& layoutBox = *layoutQueue.last();
if (layoutBox.establishesFormattingContext()) {
- layoutFormattingContextRoot(floatingContext, layoutBox);
+ // layoutFormattingContextRoot() takes care of the layoutBox itself and its descendants.
+ layoutFormattingContextRoot(floatingContext, layoutBox, invalidationState);
layoutQueue.removeLast();
- // Since this box is a formatting context root, it takes care of its entire subtree.
- // Continue with next sibling if exists.
- if (!layoutBox.nextInFlowOrFloatingSibling())
+ if (!appendNextToLayoutQueue(layoutBox, LayoutDirection::Sibling))
break;
- layoutQueue.append(layoutBox.nextInFlowOrFloatingSibling());
continue;
}
- LOG_WITH_STREAM(FormattingContextLayout, stream << "[Compute] -> [Position][Border][Padding][Width][Margin] -> for layoutBox(" << &layoutBox << ")");
computeBorderAndPadding(layoutBox);
computeWidthAndMargin(layoutBox);
computeStaticPosition(floatingContext, layoutBox);
- if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowOrFloatingChild())
+
+ if (!appendNextToLayoutQueue(layoutBox, LayoutDirection::Child))
break;
- layoutQueue.append(downcast<Container>(layoutBox).firstInFlowOrFloatingChild());
}
// Climb back on the ancestors and compute height/final position.
@@ -97,17 +122,13 @@
while (!layoutQueue.isEmpty()) {
// All inflow descendants (if there are any) are laid out by now. Let's compute the box's height.
auto& layoutBox = *layoutQueue.takeLast();
-
- LOG_WITH_STREAM(FormattingContextLayout, stream << "[Compute] -> [Height][Margin] -> for layoutBox(" << &layoutBox << ")");
// Formatting root boxes are special-cased and they don't come here.
ASSERT(!layoutBox.establishesFormattingContext());
computeHeightAndMargin(layoutBox);
// Move in-flow positioned children to their final position.
placeInFlowPositionedChildren(layoutBox);
- if (auto* nextSibling = layoutBox.nextInFlowOrFloatingSibling()) {
- layoutQueue.append(nextSibling);
+ if (appendNextToLayoutQueue(layoutBox, LayoutDirection::Sibling))
break;
- }
}
}
// Place the inflow positioned children.
@@ -149,7 +170,7 @@
return availableWidth;
}
-void BlockFormattingContext::layoutFormattingContextRoot(FloatingContext& floatingContext, const Box& layoutBox)
+void BlockFormattingContext::layoutFormattingContextRoot(FloatingContext& floatingContext, const Box& layoutBox, InvalidationState& invalidationState)
{
ASSERT(layoutBox.establishesFormattingContext());
// Start laying out this formatting root in the formatting contenxt it lives in.
@@ -167,11 +188,11 @@
// Swich over to the new formatting context (the one that the root creates).
auto& rootContainer = downcast<Container>(layoutBox);
auto formattingContext = LayoutContext::createFormattingContext(rootContainer, layoutState());
- formattingContext->layoutInFlowContent();
+ formattingContext->layoutInFlowContent(invalidationState);
// Come back and finalize the root's geometry.
computeHeightAndMargin(rootContainer);
// Now that we computed the root's height, we can go back and layout the out-of-flow content.
- formattingContext->layoutOutOfFlowContent();
+ formattingContext->layoutOutOfFlowContent(invalidationState);
} else
computeHeightAndMargin(layoutBox);
// Float related final positioning.
Modified: trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h (252459 => 252460)
--- trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h 2019-11-14 19:42:50 UTC (rev 252460)
@@ -48,10 +48,10 @@
public:
BlockFormattingContext(const Container& formattingContextRoot, BlockFormattingState&);
- void layoutInFlowContent() override;
+ void layoutInFlowContent(InvalidationState&) override;
private:
- void layoutFormattingContextRoot(FloatingContext&, const Box&);
+ void layoutFormattingContextRoot(FloatingContext&, const Box&, InvalidationState&);
void placeInFlowPositionedChildren(const Box&);
void computeWidthAndMargin(const Box&, Optional<LayoutUnit> usedAvailableWidth = { });
Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp (252459 => 252460)
--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp 2019-11-14 19:42:50 UTC (rev 252460)
@@ -30,6 +30,7 @@
#include "InlineFormattingState.h"
#include "InlineTextItem.h"
+#include "InvalidationState.h"
#include "LayoutBox.h"
#include "LayoutContainer.h"
#include "LayoutContext.h"
@@ -62,7 +63,7 @@
return nullptr;
}
-void InlineFormattingContext::layoutInFlowContent()
+void InlineFormattingContext::layoutInFlowContent(InvalidationState& invalidationState)
{
if (!root().hasInFlowOrFloatingChild())
return;
@@ -76,7 +77,7 @@
// 2. Collect the inline items (flatten the the layout tree) and place them on lines in bidirectional order.
while (layoutBox) {
if (layoutBox->establishesFormattingContext())
- layoutFormattingContextRoot(*layoutBox, usedHorizontalValues, usedVerticalValues);
+ layoutFormattingContextRoot(*layoutBox, invalidationState, usedHorizontalValues, usedVerticalValues);
else
computeHorizontalAndVerticalGeometry(*layoutBox, usedHorizontalValues, usedVerticalValues);
layoutBox = nextInPreOrder(*layoutBox, root());
@@ -132,7 +133,7 @@
}
}
-void InlineFormattingContext::layoutFormattingContextRoot(const Box& formattingContextRoot, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
+void InlineFormattingContext::layoutFormattingContextRoot(const Box& formattingContextRoot, InvalidationState& invalidationState, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
{
ASSERT(formattingContextRoot.isFloatingPositioned() || formattingContextRoot.isInlineBlockBox());
@@ -142,11 +143,11 @@
if (is<Container>(formattingContextRoot)) {
auto& rootContainer = downcast<Container>(formattingContextRoot);
auto formattingContext = LayoutContext::createFormattingContext(rootContainer, layoutState());
- formattingContext->layoutInFlowContent();
+ formattingContext->layoutInFlowContent(invalidationState);
// Come back and finalize the root's height and margin.
computeHeightAndMargin(rootContainer, usedHorizontalValues, usedVerticalValues);
// Now that we computed the root's height, we can go back and layout the out-of-flow content.
- formattingContext->layoutOutOfFlowContent();
+ formattingContext->layoutOutOfFlowContent(invalidationState);
} else
computeHeightAndMargin(formattingContextRoot, usedHorizontalValues, usedVerticalValues);
}
Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h (252459 => 252460)
--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h 2019-11-14 19:42:50 UTC (rev 252460)
@@ -35,6 +35,7 @@
namespace Layout {
class InlineFormattingState;
+class InvalidationState;
// This class implements the layout logic for inline formatting contexts.
// https://www.w3.org/TR/CSS22/visuren.html#inline-formatting
@@ -42,7 +43,7 @@
WTF_MAKE_ISO_ALLOCATED(InlineFormattingContext);
public:
InlineFormattingContext(const Container& formattingContextRoot, InlineFormattingState&);
- void layoutInFlowContent() override;
+ void layoutInFlowContent(InvalidationState&) override;
private:
IntrinsicWidthConstraints computedIntrinsicWidthConstraints() override;
@@ -76,7 +77,7 @@
InlineFormattingContext::Geometry geometry() const { return Geometry(*this); }
void lineLayout(UsedHorizontalValues);
- void layoutFormattingContextRoot(const Box&, UsedHorizontalValues, UsedVerticalValues);
+ void layoutFormattingContextRoot(const Box&, InvalidationState&, UsedHorizontalValues, UsedVerticalValues);
void computeHorizontalAndVerticalGeometry(const Box&, UsedHorizontalValues, UsedVerticalValues);
void computeIntrinsicWidthForFormattingRoot(const Box&, UsedHorizontalValues);
Modified: trunk/Source/WebCore/layout/invalidation/InvalidationState.cpp (252459 => 252460)
--- trunk/Source/WebCore/layout/invalidation/InvalidationState.cpp 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/invalidation/InvalidationState.cpp 2019-11-14 19:42:50 UTC (rev 252460)
@@ -47,6 +47,11 @@
m_formattingContextRoots.add(&layoutBox.formattingContextRoot());
}
+bool InvalidationState::needsLayout(const Box&) const
+{
+ return true;
}
+
}
+}
#endif
Modified: trunk/Source/WebCore/layout/invalidation/InvalidationState.h (252459 => 252460)
--- trunk/Source/WebCore/layout/invalidation/InvalidationState.h 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/invalidation/InvalidationState.h 2019-11-14 19:42:50 UTC (rev 252460)
@@ -41,6 +41,7 @@
InvalidationState();
void markNeedsUpdate(const Box&);
+ bool needsLayout(const Box&) const;
using FormattingContextRoots = WeakHashSet<const Container>;
// FIXME: We currently do full formatting context layouts (no partial layout within a formatting context).
Modified: trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp (252459 => 252460)
--- trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp 2019-11-14 19:42:50 UTC (rev 252460)
@@ -28,6 +28,7 @@
#if ENABLE(LAYOUT_FORMATTING_CONTEXT)
+#include "InvalidationState.h"
#include "LayoutBox.h"
#include "LayoutChildIterator.h"
#include "TableFormattingState.h"
@@ -57,7 +58,7 @@
{
}
-void TableFormattingContext::layoutInFlowContent()
+void TableFormattingContext::layoutInFlowContent(InvalidationState& invalidationState)
{
auto& grid = formattingState().tableGrid();
auto& columnsContext = grid.columnsContext();
@@ -78,7 +79,7 @@
ASSERT(!cellList.isEmpty());
for (auto& cell : cellList) {
auto& cellLayoutBox = cell->tableCellBox;
- layoutTableCellBox(cellLayoutBox, columnList.at(cell->position.x()));
+ layoutTableCellBox(cellLayoutBox, columnList.at(cell->position.x()), invalidationState);
// FIXME: Add support for column and row spanning and this requires a 2 pass layout.
auto& row = grid.rows().at(cell->position.y());
row.setLogicalHeight(std::max(row.logicalHeight(), geometryForBox(cellLayoutBox).marginBoxHeight()));
@@ -96,7 +97,7 @@
setComputedGeometryForRows();
}
-void TableFormattingContext::layoutTableCellBox(const Box& cellLayoutBox, const TableGrid::Column& column)
+void TableFormattingContext::layoutTableCellBox(const Box& cellLayoutBox, const TableGrid::Column& column, InvalidationState& invalidationState)
{
auto& cellDisplayBox = formattingState().displayBox(cellLayoutBox);
computeBorderAndPadding(cellLayoutBox);
@@ -109,7 +110,7 @@
ASSERT(cellLayoutBox.establishesBlockFormattingContext());
if (is<Container>(cellLayoutBox))
- LayoutContext::createFormattingContext(downcast<Container>(cellLayoutBox), layoutState())->layoutInFlowContent();
+ LayoutContext::createFormattingContext(downcast<Container>(cellLayoutBox), layoutState())->layoutInFlowContent(invalidationState);
cellDisplayBox.setVerticalMargin({ { }, { } });
cellDisplayBox.setContentBoxHeight(geometry().tableCellHeightAndMargin(cellLayoutBox).contentHeight);
// FIXME: Check what to do with out-of-flow content.
Modified: trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.h (252459 => 252460)
--- trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.h 2019-11-14 18:09:30 UTC (rev 252459)
+++ trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.h 2019-11-14 19:42:50 UTC (rev 252460)
@@ -34,6 +34,7 @@
namespace WebCore {
namespace Layout {
+class InvalidationState;
class TableFormattingState;
// This class implements the layout logic for table formatting contexts.
// https://www.w3.org/TR/CSS22/tables.html
@@ -41,7 +42,7 @@
WTF_MAKE_ISO_ALLOCATED(TableFormattingContext);
public:
TableFormattingContext(const Container& formattingContextRoot, TableFormattingState&);
- void layoutInFlowContent() override;
+ void layoutInFlowContent(InvalidationState&) override;
private:
class Geometry : public FormattingContext::Geometry {
@@ -58,7 +59,7 @@
TableFormattingContext::Geometry geometry() const { return Geometry(*this); }
IntrinsicWidthConstraints computedIntrinsicWidthConstraints() override;
- void layoutTableCellBox(const Box& cellLayoutBox, const TableGrid::Column&);
+ void layoutTableCellBox(const Box& cellLayoutBox, const TableGrid::Column&, InvalidationState&);
void positionTableCells();
void setComputedGeometryForRows();
void setComputedGeometryForSections();
