Changeset 157393 in webkit for trunk/Source/WebCore/rendering/RenderGrid.cpp

Timestamp:

Oct 14, 2013, 3:36:39 AM (12 years ago)

Author:

[email protected]

Message:

[CSS Grid Layout] Implement support for <flex>
​https://bugs.webkit.org/show_bug.cgi?id=115362

Reviewed by Andreas Kling.

From Blink r149134, r149480, r149532, r150287 and r156127 by <​[email protected]>
From Blink r157820 by <​[email protected]>

Source/WebCore:

Added support for flexible lengths ('fr' unit) in CSS Grid Layout
code. This requires the addition of GridLength class to
encapsulate the knowledge of <flex> to the grid layout code.

Also updated the algorithm that computes the layout. It increases
the value of 1fr based on the grid tracks' usedBreath to fraction
ratio (called normalizedFractionValue). This enables increasing
the fraction value while updating the available space to account
for processed grid tracks. The algorithm stops when we run out of
grid tracks or available space (one grid item has an intrinsic
size too big). This matches the specs to the letter for the known
available space case (both the unknown case and the interaction
with 'span' are left out of this patch).

Tests: fast/css-grid-layout/flex-and-minmax-content-resolution-columns.html

fast/css-grid-layout/flex-and-minmax-content-resolution-rows.html
fast/css-grid-layout/flex-content-resolution-columns.html
fast/css-grid-layout/flex-content-resolution-rows.html

• GNUmakefile.list.am: Added GridLength.h to the build system.
• Target.pri: Ditto.
• WebCore.vcxproj/WebCore.vcxproj: Ditto.
• WebCore.vcxproj/WebCore.vcxproj.filters: Ditto.
• WebCore.xcodeproj/project.pbxproj: Ditto.
• css/CSSComputedStyleDeclaration.cpp:

(WebCore::valueForGridTrackBreadth): Replace Length by GridLength.

• css/CSSGrammar.y.in: Added FR support.
• css/CSSParser.cpp: Ditto.

(WebCore::CSSParser::parseGridBreadth):
(WebCore::CSSParser::detectNumberToken):

• css/CSSParserValues.cpp: Added FR support.

(WebCore::CSSParserValue::createCSSValue):

• css/CSSParserValues.h:

(WebCore::CSSParserString::operator[]):
(WebCore::CSSParserString::equalIgnoringCase):

• css/CSSPrimitiveValue.cpp: Added FR support.

(WebCore::isValidCSSUnitTypeForDoubleConversion):
(WebCore::CSSPrimitiveValue::cleanup):
(WebCore::CSSPrimitiveValue::customCSSText):
(WebCore::CSSPrimitiveValue::cloneForCSSOM):
(WebCore::CSSPrimitiveValue::equals):

• css/CSSPrimitiveValue.h: Added a couple of missing const.

(WebCore::CSSPrimitiveValue::isFlex):

• css/StyleResolver.cpp: Added FR support.

(WebCore::createGridTrackBreadth):
(WebCore::createGridTrackSize):

• rendering/RenderGrid.cpp:

(WebCore::GridTrackForNormalization::GridTrackForNormalization):
New helper struct to ease the computation of track breadths with
flexible lengths.
(WebCore::GridTrackForNormalization::operator=):
(WebCore::RenderGrid::computePreferredTrackWidth): Replaced Length by GridLength.
(WebCore::RenderGrid::computedUsedBreadthOfGridTracks): Grow grid lines
having a fraction as the MaxTrackSizingFunction.
(WebCore::RenderGrid::computeUsedBreadthOfMinLength): Replaced Length by GridLength.
(WebCore::RenderGrid::computeUsedBreadthOfMaxLength): Ditto.
(WebCore::sortByGridNormalizedFlexValue):
(WebCore::RenderGrid::computeNormalizedFractionBreadth): Increase
the fraction value while updating the available space to account
for processed grid tracks.
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):
(WebCore::RenderGrid::distributeSpaceToTracks): Never shrink track sizes.
(WebCore::RenderGrid::tracksAreWiderThanMinTrackBreadth):

• rendering/RenderGrid.h:
• rendering/style/GridLength.h: Added.

(WebCore::GridLength::GridLength):
(WebCore::GridLength::isLength):
(WebCore::GridLength::isFlex):
(WebCore::GridLength::length):
(WebCore::GridLength::flex):
(WebCore::GridLength::setFlex):
(WebCore::GridLength::operator==):

• rendering/style/GridTrackSize.h: Replaced Length by GridLength.

(WebCore::GridTrackSize::length):
(WebCore::GridTrackSize::setLength):
(WebCore::GridTrackSize::minTrackBreadth):
(WebCore::GridTrackSize::maxTrackBreadth):
(WebCore::GridTrackSize::setMinMax):
(WebCore::GridTrackSize::hasMinOrMaxContentMinTrackBreadth):
(WebCore::GridTrackSize::hasMaxContentMinTrackBreadth):
(WebCore::GridTrackSize::hasMinOrMaxContentMaxTrackBreadth):
(WebCore::GridTrackSize::hasMaxContentMaxTrackBreadth):

LayoutTests:

Added 4 new test cases to test the support for <flex> in CSS Grid
Layout code. Also updated some of the existing ones to check the
support for 'fr' units.

• fast/css-grid-layout/flex-and-minmax-content-resolution-columns-expected.txt: Added.
• fast/css-grid-layout/flex-and-minmax-content-resolution-columns.html: Added.
• fast/css-grid-layout/flex-and-minmax-content-resolution-rows-expected.txt: Added.
• fast/css-grid-layout/flex-and-minmax-content-resolution-rows.html: Added.
• fast/css-grid-layout/flex-content-resolution-columns-expected.txt: Added.
• fast/css-grid-layout/flex-content-resolution-columns.html: Added.
• fast/css-grid-layout/flex-content-resolution-rows-expected.txt: Added.
• fast/css-grid-layout/flex-content-resolution-rows.html: Added.
• fast/css-grid-layout/grid-columns-rows-get-set-expected.txt:
• fast/css-grid-layout/grid-columns-rows-get-set-multiple-expected.txt:
• fast/css-grid-layout/grid-columns-rows-get-set-multiple.html:
• fast/css-grid-layout/grid-columns-rows-get-set.html:
• fast/css-grid-layout/grid-dynamic-updates-relayout-expected.txt:
• fast/css-grid-layout/grid-dynamic-updates-relayout.html:
• fast/css-grid-layout/resources/grid-columns-rows-get-set-multiple.js:
• fast/css-grid-layout/resources/grid-columns-rows-get-set.js:

File:

• trunk/Source/WebCore/rendering/RenderGrid.cpp (modified) (10 diffs)

trunk/Source/WebCore/rendering/RenderGrid.cpp

@@ -1 +1 @@
 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2013 Igalia S.L.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -68 +69 @@
 };
 
+struct GridTrackForNormalization {
+    GridTrackForNormalization(const GridTrack& track, double flex)
+        : m_track(&track)
+        , m_flex(flex)
+        , m_normalizedFlexValue(track.m_usedBreadth / flex)
+    {
+    }
+
+    const GridTrack* m_track;
+    double m_flex;
+    LayoutUnit m_normalizedFlexValue;
+};
+
 class RenderGrid::GridIterator {
     WTF_MAKE_NONCOPYABLE(GridIterator);
@@ -230 +244 @@
 }
 
-LayoutUnit RenderGrid::computePreferredTrackWidth(const Length& length, size_t trackIndex) const
-{
+LayoutUnit RenderGrid::computePreferredTrackWidth(const GridLength& gridLength, size_t trackIndex) const
+{
+    if (gridLength.isFlex())
+        return 0;
+
+    const Length& length = gridLength.length();
+
     if (length.isFixed()) {
         // Grid areas don't have borders, margins or paddings so we don't need to account for them.
@@ -269 +288 @@
         GridTrack& track = tracks[i];
         const GridTrackSize& trackSize = gridTrackSize(direction, i);
-        const Length& minTrackBreadth = trackSize.minTrackBreadth();
-        const Length& maxTrackBreadth = trackSize.maxTrackBreadth();
+        const GridLength& minTrackBreadth = trackSize.minTrackBreadth();
+        const GridLength& maxTrackBreadth = trackSize.maxTrackBreadth();
 
         track.m_usedBreadth = computeUsedBreadthOfMinLength(direction, minTrackBreadth);
-        track.m_maxBreadth = computeUsedBreadthOfMaxLength(direction, maxTrackBreadth);
+        track.m_maxBreadth = computeUsedBreadthOfMaxLength(direction, maxTrackBreadth, track.m_usedBreadth);
 
         track.m_maxBreadth = std::max(track.m_maxBreadth, track.m_usedBreadth);
@@ -290 +309 @@
 
     distributeSpaceToTracks(tracksForDistribution, 0, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth, availableLogicalSpace);
-}
-
-LayoutUnit RenderGrid::computeUsedBreadthOfMinLength(TrackSizingDirection direction, const Length& trackLength) const
-{
+
+    // 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
+
+    // FIXME: Handle the case where RemainingSpace is not defined.
+    double normalizedFractionBreadth = computeNormalizedFractionBreadth(tracks, direction, availableLogicalSpace);
+    for (size_t i = 0; i < tracksSize; ++i) {
+        const GridTrackSize& trackSize = gridTrackSize(direction, i);
+        if (!trackSize.maxTrackBreadth().isFlex())
+            continue;
+
+        tracks[i].m_usedBreadth = std::max<LayoutUnit>(tracks[i].m_usedBreadth, normalizedFractionBreadth * trackSize.maxTrackBreadth().flex());
+    }
+}
+
+LayoutUnit RenderGrid::computeUsedBreadthOfMinLength(TrackSizingDirection direction, const GridLength& gridLength) const
+{
+    if (gridLength.isFlex())
+        return 0;
+
+    const Length& trackLength = gridLength.length();
+    ASSERT(!trackLength.isAuto());
     if (trackLength.isFixed() || trackLength.isPercent() || trackLength.isViewportPercentage())
         return computeUsedBreadthOfSpecifiedLength(direction, trackLength);
 
-    ASSERT(trackLength.isMinContent() || trackLength.isMaxContent() || trackLength.isAuto());
+    ASSERT(trackLength.isMinContent() || trackLength.isMaxContent());
     return 0;
 }
 
-LayoutUnit RenderGrid::computeUsedBreadthOfMaxLength(TrackSizingDirection direction, const Length& trackLength) const
-{
+LayoutUnit RenderGrid::computeUsedBreadthOfMaxLength(TrackSizingDirection direction, const GridLength& gridLength, LayoutUnit usedBreadth) const
+{
+    if (gridLength.isFlex())
+        return usedBreadth;
+
+    const Length& trackLength = gridLength.length();
+    ASSERT(!trackLength.isAuto());
     if (trackLength.isFixed() || trackLength.isPercent() || trackLength.isViewportPercentage()) {
         LayoutUnit computedBreadth = computeUsedBreadthOfSpecifiedLength(direction, trackLength);
@@ -309 +350 @@
     }
 
-    ASSERT(trackLength.isMinContent() || trackLength.isMaxContent() || trackLength.isAuto());
+    ASSERT(trackLength.isMinContent() || trackLength.isMaxContent());
     return infinity;
 }
@@ -318 +359 @@
     ASSERT(trackLength.isFixed() || trackLength.isPercent() || trackLength.isViewportPercentage());
     return valueForLength(trackLength, direction == ForColumns ? logicalWidth() : computeContentLogicalHeight(style()->logicalHeight()));
+}
+
+double RenderGrid::computeNormalizedFractionBreadth(Vector<GridTrack>& tracks, TrackSizingDirection direction, LayoutUnit availableLogicalSpace) const
+{
+    // |availableLogicalSpace| already accounts for the used breadths so no need to remove it here.
+
+    Vector<GridTrackForNormalization> tracksForNormalization;
+    for (size_t i = 0; i < tracks.size(); ++i) {
+        const GridTrackSize& trackSize = gridTrackSize(direction, i);
+        if (!trackSize.maxTrackBreadth().isFlex())
+            continue;
+
+        tracksForNormalization.append(GridTrackForNormalization(tracks[i], trackSize.maxTrackBreadth().flex()));
+    }
+
+    // FIXME: Ideally we shouldn't come here without any <flex> grid track.
+    if (tracksForNormalization.isEmpty())
+        return LayoutUnit();
+
+    std::sort(tracksForNormalization.begin(), tracksForNormalization.end(),
+              [](const GridTrackForNormalization& track1, const GridTrackForNormalization& track2) {
+                  return track1.m_normalizedFlexValue < track2.m_normalizedFlexValue;
+              });
+
+    // These values work together: as we walk over our grid tracks, we increase fractionValueBasedOnGridItemsRatio
+    // to match a grid track's usedBreadth to <flex> ratio until the total fractions sized grid tracks wouldn't
+    // fit into availableLogicalSpaceIgnoringFractionTracks.
+    double accumulatedFractions = 0;
+    LayoutUnit fractionValueBasedOnGridItemsRatio = 0;
+    LayoutUnit availableLogicalSpaceIgnoringFractionTracks = availableLogicalSpace;
+
+    for (size_t i = 0; i < tracksForNormalization.size(); ++i) {
+        const GridTrackForNormalization& track = tracksForNormalization[i];
+        if (track.m_normalizedFlexValue > fractionValueBasedOnGridItemsRatio) {
+            // If the normalized flex value (we ordered |tracksForNormalization| by increasing normalized flex value)
+            // will make us overflow our container, then stop. We have the previous step's ratio is the best fit.
+            if (track.m_normalizedFlexValue * accumulatedFractions > availableLogicalSpaceIgnoringFractionTracks)
+                break;
+
+            fractionValueBasedOnGridItemsRatio = track.m_normalizedFlexValue;
+        }
+
+        accumulatedFractions += track.m_flex;
+        // This item was processed so we re-add its used breadth to the available space to accurately count the remaining space.
+        availableLogicalSpaceIgnoringFractionTracks += track.m_track->m_usedBreadth;
+    }
+
+    return availableLogicalSpaceIgnoringFractionTracks / accumulatedFractions;
 }
 
@@ -413 +502 @@
 void RenderGrid::resolveContentBasedTrackSizingFunctions(TrackSizingDirection direction, Vector<GridTrack>& columnTracks, Vector<GridTrack>& rowTracks, LayoutUnit& availableLogicalSpace)
 {
-    // FIXME: Split the grid tracks once we support fractions (step 1 of the algorithm).
+    // FIXME: Split the grid tracks into groups that doesn't overlap a <flex> grid track.
 
     Vector<GridTrack>& tracks = (direction == ForColumns) ? columnTracks : rowTracks;
@@ -476 +565 @@
         LayoutUnit availableLogicalSpaceShare = availableLogicalSpace / (tracksSize - i);
         LayoutUnit trackBreadth = (tracks[i]->*trackGetter)();
-        LayoutUnit growthShare = std::min(availableLogicalSpaceShare, track.m_maxBreadth - trackBreadth);
+        LayoutUnit growthShare = std::max(LayoutUnit(), std::min(availableLogicalSpaceShare, track.m_maxBreadth - trackBreadth));
+        // We should never shrink any grid track or else we can't guarantee we abide by our min-sizing function.
         updatedTrackBreadths[i] = trackBreadth + growthShare;
         availableLogicalSpace -= growthShare;
@@ -502 +592 @@
     for (size_t i = 0; i < tracks.size(); ++i) {
         const GridTrackSize& trackSize = gridTrackSize(direction, i);
-        const Length& minTrackBreadth = trackSize.minTrackBreadth();
+        const GridLength& minTrackBreadth = trackSize.minTrackBreadth();
         if (computeUsedBreadthOfMinLength(direction, minTrackBreadth) > tracks[i].m_usedBreadth)
             return false;