Title: [241263] trunk/Source/WebCore
Revision
241263
Author
[email protected]
Date
2019-02-11 08:19:36 -0800 (Mon, 11 Feb 2019)

Log Message

[LFC] FormattingContext::intrinsicWidthConstraints should compute and save the intrinsic widths consistently.
https://bugs.webkit.org/show_bug.cgi?id=194483

Reviewed by Antti Koivisto.

Rename intrinsicWidthConstraints to computeIntrinsicWidthConstraints (it does not return the width values anymore).

* layout/FormattingContext.h:
* layout/FormattingContextGeometry.cpp:
(WebCore::Layout::FormattingContext::Geometry::shrinkToFitWidth):
* layout/blockformatting/BlockFormattingContext.cpp:
(WebCore::Layout::BlockFormattingContext::computeIntrinsicWidthConstraints const):
(WebCore::Layout::BlockFormattingContext::intrinsicWidthConstraints const): Deleted.
* layout/blockformatting/BlockFormattingContext.h:
* layout/inlineformatting/InlineFormattingContext.cpp:
(WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthConstraints const):
(WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthForFormattingContextRoot const):
(WebCore::Layout::InlineFormattingContext::intrinsicWidthConstraints const): Deleted.
* layout/inlineformatting/InlineFormattingContext.h:

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (241262 => 241263)


--- trunk/Source/WebCore/ChangeLog	2019-02-11 14:08:00 UTC (rev 241262)
+++ trunk/Source/WebCore/ChangeLog	2019-02-11 16:19:36 UTC (rev 241263)
@@ -1,3 +1,25 @@
+2019-02-11  Zalan Bujtas  <[email protected]>
+
+        [LFC] FormattingContext::intrinsicWidthConstraints should compute and save the intrinsic widths consistently.
+        https://bugs.webkit.org/show_bug.cgi?id=194483
+
+        Reviewed by Antti Koivisto.
+
+        Rename intrinsicWidthConstraints to computeIntrinsicWidthConstraints (it does not return the width values anymore).
+
+        * layout/FormattingContext.h:
+        * layout/FormattingContextGeometry.cpp:
+        (WebCore::Layout::FormattingContext::Geometry::shrinkToFitWidth):
+        * layout/blockformatting/BlockFormattingContext.cpp:
+        (WebCore::Layout::BlockFormattingContext::computeIntrinsicWidthConstraints const):
+        (WebCore::Layout::BlockFormattingContext::intrinsicWidthConstraints const): Deleted.
+        * layout/blockformatting/BlockFormattingContext.h:
+        * layout/inlineformatting/InlineFormattingContext.cpp:
+        (WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthConstraints const):
+        (WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthForFormattingContextRoot const):
+        (WebCore::Layout::InlineFormattingContext::intrinsicWidthConstraints const): Deleted.
+        * layout/inlineformatting/InlineFormattingContext.h:
+
 2019-02-10  Zalan Bujtas  <[email protected]>
 
         [LFC] Fix spelling error.

Modified: trunk/Source/WebCore/layout/FormattingContext.h (241262 => 241263)


--- trunk/Source/WebCore/layout/FormattingContext.h	2019-02-11 14:08:00 UTC (rev 241262)
+++ trunk/Source/WebCore/layout/FormattingContext.h	2019-02-11 16:19:36 UTC (rev 241263)
@@ -56,7 +56,7 @@
         LayoutUnit minimum;
         LayoutUnit maximum;
     };
-    virtual IntrinsicWidthConstraints intrinsicWidthConstraints() const = 0;
+    virtual void computeIntrinsicWidthConstraints() const = 0;
 
     static Display::Box mapBoxToAncestor(const LayoutState&, const Box&, const Container& ancestor);
     static LayoutUnit mapTopToAncestor(const LayoutState&, const Box&, const Container& ancestor);

Modified: trunk/Source/WebCore/layout/FormattingContextGeometry.cpp (241262 => 241263)


--- trunk/Source/WebCore/layout/FormattingContextGeometry.cpp	2019-02-11 14:08:00 UTC (rev 241262)
+++ trunk/Source/WebCore/layout/FormattingContextGeometry.cpp	2019-02-11 16:19:36 UTC (rev 241263)
@@ -238,6 +238,7 @@
 {
     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 @@
     // '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 intrinsicWidthConstraints = formattingStateForRoot.intrinsicWidthConstraints(formattingRoot);
+    if (!intrinsicWidthConstraints) {
+        layoutState.createFormattingContext(formattingRoot)->computeIntrinsicWidthConstraints();
+        intrinsicWidthConstraints = formattingStateForRoot.intrinsicWidthConstraints(formattingRoot);
+    }
     auto availableWidth = *usedValues.containingBlockWidth;
-    auto intrinsicWidthConstraints = layoutState.createFormattingContext(formattingRoot)->intrinsicWidthConstraints();
-    return std::min(std::max(intrinsicWidthConstraints.minimum, availableWidth), intrinsicWidthConstraints.maximum);
+    return std::min(std::max(intrinsicWidthConstraints->minimum, availableWidth), intrinsicWidthConstraints->maximum);
 }
 
 VerticalGeometry FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)

Modified: trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp (241262 => 241263)


--- trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp	2019-02-11 14:08:00 UTC (rev 241262)
+++ trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp	2019-02-11 16:19:36 UTC (rev 241263)
@@ -392,20 +392,16 @@
     MarginCollapse::updateMarginAfterForPreviousSibling(layoutState, layoutBox);
 }
 
-FormattingContext::IntrinsicWidthConstraints BlockFormattingContext::intrinsicWidthConstraints() const
+void BlockFormattingContext::computeIntrinsicWidthConstraints() const
 {
     auto& layoutState = this->layoutState();
     auto& formattingRoot = root();
     auto& formattingStateForRoot = layoutState.formattingStateForBox(formattingRoot);
-    if (auto intrinsicWidthConstraints = formattingStateForRoot.intrinsicWidthConstraints(formattingRoot))
-        return *intrinsicWidthConstraints;
+    ASSERT(!formattingStateForRoot.intrinsicWidthConstraints(formattingRoot));
 
     // Can we just compute them without checking the children?
-    if (!Geometry::intrinsicWidthConstraintsNeedChildrenWidth(formattingRoot)) {
-        auto intrinsicWidthConstraints = Geometry::intrinsicWidthConstraints(layoutState, formattingRoot);
-        formattingStateForRoot.setIntrinsicWidthConstraints(formattingRoot, intrinsicWidthConstraints);
-        return intrinsicWidthConstraints;
-    }
+    if (!Geometry::intrinsicWidthConstraintsNeedChildrenWidth(formattingRoot))
+        return formattingStateForRoot.setIntrinsicWidthConstraints(formattingRoot, Geometry::intrinsicWidthConstraints(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 @@
     while (!queue.isEmpty()) {
         while (true) {
             auto& childBox = *queue.last();
-            auto skipDescendants = formattingState.intrinsicWidthConstraints(childBox) || !Geometry::intrinsicWidthConstraintsNeedChildrenWidth(childBox) || childBox.establishesFormattingContext();
+            auto childIntrinsicWidthConstraints = formattingState.intrinsicWidthConstraints(childBox);
+            auto skipDescendants = childIntrinsicWidthConstraints || !Geometry::intrinsicWidthConstraintsNeedChildrenWidth(childBox) || childBox.establishesFormattingContext();
 
             if (skipDescendants) {
-                IntrinsicWidthConstraints intrinsicWidthConstraints;
-                if (!Geometry::intrinsicWidthConstraintsNeedChildrenWidth(childBox))
-                    intrinsicWidthConstraints = Geometry::intrinsicWidthConstraints(layoutState, childBox);
-                else if (childBox.establishesFormattingContext())
-                    intrinsicWidthConstraints = layoutState.createFormattingContext(childBox)->intrinsicWidthConstraints();
-                formattingState.setIntrinsicWidthConstraints(childBox, intrinsicWidthConstraints);
-
+                if (!childIntrinsicWidthConstraints) {
+                    if (!Geometry::intrinsicWidthConstraintsNeedChildrenWidth(childBox))
+                        formattingState.setIntrinsicWidthConstraints(childBox, Geometry::intrinsicWidthConstraints(layoutState, childBox));
+                    else if (childBox.establishesFormattingContext())
+                        layoutState.createFormattingContext(childBox)->computeIntrinsicWidthConstraints();
+                    else
+                        ASSERT_NOT_REACHED();
+                }
                 queue.removeLast();
                 if (!childBox.nextInFlowOrFloatingSibling())
                     break;
@@ -450,10 +448,7 @@
             queue.append(downcast<Container>(childBox).nextInFlowOrFloatingSibling());
         }
     }
-
-    auto intrinsicWidthConstraints = Geometry::intrinsicWidthConstraints(layoutState, formattingRoot);
-    formattingStateForRoot.setIntrinsicWidthConstraints(formattingRoot, intrinsicWidthConstraints); 
-    return intrinsicWidthConstraints;
+    formattingStateForRoot.setIntrinsicWidthConstraints(formattingRoot, Geometry::intrinsicWidthConstraints(layoutState, formattingRoot));
 }
 
 LayoutUnit BlockFormattingContext::verticalPositionWithMargin(const Box& layoutBox, const UsedVerticalMargin& verticalMargin) const

Modified: trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h (241262 => 241263)


--- trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h	2019-02-11 14:08:00 UTC (rev 241262)
+++ trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h	2019-02-11 16:19:36 UTC (rev 241263)
@@ -67,7 +67,7 @@
     void computeEstimatedVerticalPositionForFormattingRoot(const Box&) const;
     void computeEstimatedVerticalPositionForFloatClear(const FloatingContext&, const Box&) const;
 
-    IntrinsicWidthConstraints intrinsicWidthConstraints() const override;
+    void computeIntrinsicWidthConstraints() const override;
     LayoutUnit verticalPositionWithMargin(const Box&, const UsedVerticalMargin&) const;
 
     // This class implements positioning and sizing for boxes participating in a block formatting context.

Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp (241262 => 241263)


--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp	2019-02-11 14:08:00 UTC (rev 241262)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp	2019-02-11 16:19:36 UTC (rev 241263)
@@ -92,14 +92,13 @@
     LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> formatting root(" << &root << ")");
 }
 
-FormattingContext::IntrinsicWidthConstraints InlineFormattingContext::intrinsicWidthConstraints() const
+void InlineFormattingContext::computeIntrinsicWidthConstraints() const
 {
     ASSERT(is<Container>(root()));
 
     auto& layoutState = this->layoutState();
     auto& root = downcast<Container>(this->root());
-    if (auto intrinsicWidthConstraints = layoutState.formattingStateForBox(root).intrinsicWidthConstraints(root))
-        return *intrinsicWidthConstraints;
+    ASSERT(!layoutState.formattingStateForBox(root).intrinsicWidthConstraints(root));
 
     Vector<const Box*> formattingContextRootList;
     auto usedValues = UsedHorizontalValues { };
@@ -150,7 +149,6 @@
 
     auto intrinsicWidthConstraints = FormattingContext::IntrinsicWidthConstraints { maximumLineWidth(0), maximumLineWidth(LayoutUnit::max()) };
     layoutState.formattingStateForBox(root).setIntrinsicWidthConstraints(root, intrinsicWidthConstraints);
-    return intrinsicWidthConstraints;
 }
 
 void InlineFormattingContext::computeIntrinsicWidthForFormattingContextRoot(const Box& layoutBox) const
@@ -160,7 +158,7 @@
     auto usedValues = UsedHorizontalValues { };
     computeBorderAndPadding(layoutBox, usedValues);
     computeMargin(downcast<InlineContainer>(layoutBox), usedValues);
-    layoutState().createFormattingContext(layoutBox)->intrinsicWidthConstraints();
+    layoutState().createFormattingContext(layoutBox)->computeIntrinsicWidthConstraints();
 }
 
 void InlineFormattingContext::computeMargin(const InlineContainer& inlineContainer, UsedHorizontalValues usedValues) const

Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h (241262 => 241263)


--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h	2019-02-11 14:08:00 UTC (rev 241262)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h	2019-02-11 16:19:36 UTC (rev 241263)
@@ -50,6 +50,8 @@
     void layout() const override;
 
 private:
+    void computeIntrinsicWidthConstraints() const override;
+
     class LineLayout {
     public:
         LineLayout(const InlineFormattingContext&);
@@ -94,7 +96,6 @@
     void computeWidthAndMargin(const Box&, UsedHorizontalValues) const;
 
     void collectInlineContent(InlineRunProvider&) const;
-    IntrinsicWidthConstraints intrinsicWidthConstraints() const override;
 
     InlineFormattingState& formattingState() const { return downcast<InlineFormattingState>(FormattingContext::formattingState()); }
 };
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to