Attachment 361647 Details for Bug 194483 – Patch

[patch] Patch

bug-194483-20190210151730.patch (text/plain), 13.59 KB, created by zalan on 2019-02-10 15:17:31 PST

(hide)

Description:

Filename:

MIME Type:

Creator: zalan

Created: 2019-02-10 15:17:31 PST

Size: 13.59 KB

patch

obsolete

>Subversion Revision: 241250
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 695eb19fa733b81bb48941a80a75f4c0255cac2d..432d07e35fb28c51e18c176abef45a30e3d098aa 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,27 @@
>+2019-02-10  Zalan Bujtas  <zalan@apple.com>
>+
>+        [LFC] FormattingContext::instrinsicWidthConstraints should compute and save the intrinsic widths consistently.
>+        https://bugs.webkit.org/show_bug.cgi?id=194483
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Rename instrinsicWidthConstraints to computeInstrinsicWidthConstraints and it does not return the width values anymore.
>+
>+        * layout/FormattingContext.h:
>+        * layout/FormattingContextGeometry.cpp:
>+        (WebCore::Layout::FormattingContext::Geometry::shrinkToFitWidth):
>+        * layout/Verification.cpp:
>+        (WebCore::Layout::LayoutState::verifyAndOutputMismatchingLayoutTree const):
>+        * layout/blockformatting/BlockFormattingContext.cpp:
>+        (WebCore::Layout::BlockFormattingContext::computeInstrinsicWidthConstraints const):
>+        (WebCore::Layout::BlockFormattingContext::instrinsicWidthConstraints const): Deleted.
>+        * layout/blockformatting/BlockFormattingContext.h:
>+        * layout/inlineformatting/InlineFormattingContext.cpp:
>+        (WebCore::Layout::InlineFormattingContext::computeInstrinsicWidthConstraints const):
>+        (WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthForFormattingContextRoot const):
>+        (WebCore::Layout::InlineFormattingContext::instrinsicWidthConstraints const): Deleted.
>+        * layout/inlineformatting/InlineFormattingContext.h:
>+
> 2019-02-10  Zalan Bujtas  <zalan@apple.com>
> 
>         [LFC][IFC] Add intrinsic width support for inline-block boxes
>diff --git a/Source/WebCore/layout/FormattingContext.h b/Source/WebCore/layout/FormattingContext.h
>index 62530a3fde0d17e468873acea0e3c46991d5359c..0477aab7a822ea96260b40774b5c4c53f04076da 100644
>--- a/Source/WebCore/layout/FormattingContext.h
>+++ b/Source/WebCore/layout/FormattingContext.h
>@@ -56,7 +56,7 @@ public:
>         LayoutUnit minimum;
>         LayoutUnit maximum;
>     };
>-    virtual InstrinsicWidthConstraints instrinsicWidthConstraints() const = 0;
>+    virtual void computeInstrinsicWidthConstraints() const = 0;
> 
>     static Display::Box mapBoxToAncestor(const LayoutState&, const Box&, const Container& ancestor);
>     static LayoutUnit mapTopToAncestor(const LayoutState&, const Box&, const Container& ancestor);
>diff --git a/Source/WebCore/layout/FormattingContextGeometry.cpp b/Source/WebCore/layout/FormattingContextGeometry.cpp
>index afa0bc489d8b79953abab8c8321aa97ce7445675..1517a07c1e9104e4bba97a307d0c2fe1c46a5cef 100644
>--- a/Source/WebCore/layout/FormattingContextGeometry.cpp
>+++ b/Source/WebCore/layout/FormattingContextGeometry.cpp
>@@ -238,6 +238,7 @@ LayoutUnit FormattingContext::Geometry::shrinkToFitWidth(LayoutState& layoutStat
> {
>     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width] -> shrink to fit -> unsupported -> width(" << LayoutUnit { } << "px) layoutBox: " << &formattingRoot << ")");
>     ASSERT(formattingRoot.establishesFormattingContext());
>+    ASSERT(usedValues.containingBlockWidth.hasValue());
> 
>     // Calculation of the shrink-to-fit width is similar to calculating the width of a table cell using the automatic table layout algorithm.
>     // Roughly: calculate the preferred width by formatting the content without breaking lines other than where explicit line breaks occur,
>@@ -246,10 +247,14 @@ LayoutUnit FormattingContext::Geometry::shrinkToFitWidth(LayoutState& layoutStat
>     // 'padding-left', 'padding-right', 'border-right-width', 'margin-right', and the widths of any relevant scroll bars.
> 
>     // Then the shrink-to-fit width is: min(max(preferred minimum width, available width), preferred width).
>-    ASSERT(usedValues.containingBlockWidth.hasValue());
>+    auto& formattingStateForRoot = layoutState.formattingStateForBox(formattingRoot);
>+    auto instrinsicWidthConstraints = formattingStateForRoot.instrinsicWidthConstraints(formattingRoot);
>+    if (!instrinsicWidthConstraints) {
>+        layoutState.createFormattingContext(formattingRoot)->computeInstrinsicWidthConstraints();
>+        instrinsicWidthConstraints = formattingStateForRoot.instrinsicWidthConstraints(formattingRoot);
>+    }
>     auto availableWidth = *usedValues.containingBlockWidth;
>-    auto instrinsicWidthConstraints = layoutState.createFormattingContext(formattingRoot)->instrinsicWidthConstraints();
>-    return std::min(std::max(instrinsicWidthConstraints.minimum, availableWidth), instrinsicWidthConstraints.maximum);
>+    return std::min(std::max(instrinsicWidthConstraints->minimum, availableWidth), instrinsicWidthConstraints->maximum);
> }
> 
> VerticalGeometry FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
>diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp b/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
>index 557d1ea3cbbbef300b8f2aba16c93292a4dd5f6c..0bb08d91df5ba5e1257ec18e0666bf5b7172ad4b 100644
>--- a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
>+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
>@@ -392,20 +392,16 @@ void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox) const
>     MarginCollapse::updateMarginAfterForPreviousSibling(layoutState, layoutBox);
> }
> 
>-FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsicWidthConstraints() const
>+void BlockFormattingContext::computeInstrinsicWidthConstraints() const
> {
>     auto& layoutState = this->layoutState();
>     auto& formattingRoot = root();
>     auto& formattingStateForRoot = layoutState.formattingStateForBox(formattingRoot);
>-    if (auto instrinsicWidthConstraints = formattingStateForRoot.instrinsicWidthConstraints(formattingRoot))
>-        return *instrinsicWidthConstraints;
>+    ASSERT(!formattingStateForRoot.instrinsicWidthConstraints(formattingRoot));
> 
>     // Can we just compute them without checking the children?
>-    if (!Geometry::instrinsicWidthConstraintsNeedChildrenWidth(formattingRoot)) {
>-        auto instrinsicWidthConstraints = Geometry::instrinsicWidthConstraints(layoutState, formattingRoot);
>-        formattingStateForRoot.setInstrinsicWidthConstraints(formattingRoot, instrinsicWidthConstraints);
>-        return instrinsicWidthConstraints;
>-    }
>+    if (!Geometry::instrinsicWidthConstraintsNeedChildrenWidth(formattingRoot))
>+        return formattingStateForRoot.setInstrinsicWidthConstraints(formattingRoot, Geometry::instrinsicWidthConstraints(layoutState, formattingRoot));
> 
>     // Visit the in-flow descendants and compute their min/max intrinsic width if needed.
>     // 1. Go all the way down to the leaf node
>@@ -421,16 +417,18 @@ FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsic
>     while (!queue.isEmpty()) {
>         while (true) {
>             auto& childBox = *queue.last();
>-            auto skipDescendants = formattingState.instrinsicWidthConstraints(childBox) || !Geometry::instrinsicWidthConstraintsNeedChildrenWidth(childBox) || childBox.establishesFormattingContext();
>+            auto childInstrinsicWidthConstraints = formattingState.instrinsicWidthConstraints(childBox); 
>+            auto skipDescendants = childInstrinsicWidthConstraints || !Geometry::instrinsicWidthConstraintsNeedChildrenWidth(childBox) || childBox.establishesFormattingContext();
> 
>             if (skipDescendants) {
>-                InstrinsicWidthConstraints instrinsicWidthConstraints;
>-                if (!Geometry::instrinsicWidthConstraintsNeedChildrenWidth(childBox))
>-                    instrinsicWidthConstraints = Geometry::instrinsicWidthConstraints(layoutState, childBox);
>-                else if (childBox.establishesFormattingContext())
>-                    instrinsicWidthConstraints = layoutState.createFormattingContext(childBox)->instrinsicWidthConstraints();
>-                formattingState.setInstrinsicWidthConstraints(childBox, instrinsicWidthConstraints);
>-
>+                if (!childInstrinsicWidthConstraints) {
>+                    if (!Geometry::instrinsicWidthConstraintsNeedChildrenWidth(childBox))
>+                        formattingState.setInstrinsicWidthConstraints(childBox, Geometry::instrinsicWidthConstraints(layoutState, childBox));
>+                    else if (childBox.establishesFormattingContext())
>+                        layoutState.createFormattingContext(childBox)->computeInstrinsicWidthConstraints();
>+                    else
>+                        ASSERT_NOT_REACHED();
>+                }
>                 queue.removeLast();
>                 if (!childBox.nextInFlowOrFloatingSibling())
>                     break;
>@@ -450,10 +448,7 @@ FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsic
>             queue.append(downcast<Container>(childBox).nextInFlowOrFloatingSibling());
>         }
>     }
>-
>-    auto instrinsicWidthConstraints = Geometry::instrinsicWidthConstraints(layoutState, formattingRoot);
>-    formattingStateForRoot.setInstrinsicWidthConstraints(formattingRoot, instrinsicWidthConstraints); 
>-    return instrinsicWidthConstraints;
>+    formattingStateForRoot.setInstrinsicWidthConstraints(formattingRoot, Geometry::instrinsicWidthConstraints(layoutState, formattingRoot)); 
> }
> 
> LayoutUnit BlockFormattingContext::verticalPositionWithMargin(const Box& layoutBox, const UsedVerticalMargin& verticalMargin) const
>diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContext.h b/Source/WebCore/layout/blockformatting/BlockFormattingContext.h
>index 7d95cb4dc49ad547594d4cc8b9a4f06d40a440cc..434b03c3a99453a87b483f0eb91c423ce8c3c362 100644
>--- a/Source/WebCore/layout/blockformatting/BlockFormattingContext.h
>+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContext.h
>@@ -67,7 +67,7 @@ private:
>     void computeEstimatedVerticalPositionForFormattingRoot(const Box&) const;
>     void computeEstimatedVerticalPositionForFloatClear(const FloatingContext&, const Box&) const;
> 
>-    InstrinsicWidthConstraints instrinsicWidthConstraints() const override;
>+    void computeInstrinsicWidthConstraints() const override;
>     LayoutUnit verticalPositionWithMargin(const Box&, const UsedVerticalMargin&) const;
> 
>     // This class implements positioning and sizing for boxes participating in a block formatting context.
>diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
>index 93762c6523dc60e764a006692306fdfa1ca32f67..a25373d406590ee496d92c09daf760f199ef79cd 100644
>--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
>+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
>@@ -92,14 +92,13 @@ void InlineFormattingContext::layout() const
>     LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> formatting root(" << &root << ")");
> }
> 
>-FormattingContext::InstrinsicWidthConstraints InlineFormattingContext::instrinsicWidthConstraints() const
>+void InlineFormattingContext::computeInstrinsicWidthConstraints() const
> {
>     ASSERT(is<Container>(root()));
> 
>     auto& layoutState = this->layoutState();
>     auto& root = downcast<Container>(this->root());
>-    if (auto instrinsicWidthConstraints = layoutState.formattingStateForBox(root).instrinsicWidthConstraints(root))
>-        return *instrinsicWidthConstraints;
>+    ASSERT(!layoutState.formattingStateForBox(root).instrinsicWidthConstraints(root));
> 
>     Vector<const Box*> formattingContextRootList;
>     auto usedValues = UsedHorizontalValues { };
>@@ -150,7 +149,6 @@ FormattingContext::InstrinsicWidthConstraints InlineFormattingContext::instrinsi
> 
>     auto instrinsicWidthConstraints = FormattingContext::InstrinsicWidthConstraints { maximumLineWidth(0), maximumLineWidth(LayoutUnit::max()) };
>     layoutState.formattingStateForBox(root).setInstrinsicWidthConstraints(root, instrinsicWidthConstraints);
>-    return instrinsicWidthConstraints;
> }
> 
> void InlineFormattingContext::computeIntrinsicWidthForFormattingContextRoot(const Box& layoutBox) const
>@@ -160,7 +158,7 @@ void InlineFormattingContext::computeIntrinsicWidthForFormattingContextRoot(cons
>     auto usedValues = UsedHorizontalValues { };
>     computeBorderAndPadding(layoutBox, usedValues);
>     computeMargin(downcast<InlineContainer>(layoutBox), usedValues);
>-    layoutState().createFormattingContext(layoutBox)->instrinsicWidthConstraints();
>+    layoutState().createFormattingContext(layoutBox)->computeInstrinsicWidthConstraints();
> }
> 
> void InlineFormattingContext::computeMargin(const InlineContainer& inlineContainer, UsedHorizontalValues usedValues) const
>diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
>index 6f9c7acba94e083840982c6db6ddbdde6e27b4e9..8dd4ed5a0c8182cbfa37dcbc15e0a7bf28cfd32d 100644
>--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
>+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
>@@ -50,6 +50,8 @@ public:
>     void layout() const override;
> 
> private:
>+    void computeInstrinsicWidthConstraints() const override;
>+
>     class LineLayout {
>     public:
>         LineLayout(const InlineFormattingContext&);
>@@ -94,7 +96,6 @@ private:
>     void computeWidthAndMargin(const Box&, UsedHorizontalValues) const;
> 
>     void collectInlineContent(InlineRunProvider&) const;
>-    InstrinsicWidthConstraints instrinsicWidthConstraints() const override;
> 
>     InlineFormattingState& formattingState() const { return downcast<InlineFormattingState>(FormattingContext::formattingState()); }
> };

Actions: View | Formatted Diff | Diff

Attachments on bug 194483: 361647 | 361657