Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (210196 => 210197)
--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-12-28 11:04:16 UTC (rev 210196)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-12-28 11:06:44 UTC (rev 210197)
@@ -362,9 +362,10 @@
class RenderGrid::GridSizingData {
WTF_MAKE_NONCOPYABLE(GridSizingData);
public:
- GridSizingData(unsigned gridColumnCount, unsigned gridRowCount)
+ GridSizingData(unsigned gridColumnCount, unsigned gridRowCount, Grid& grid)
: columnTracks(gridColumnCount)
, rowTracks(gridRowCount)
+ , m_grid(grid)
{
}
@@ -420,6 +421,8 @@
return false;
}
+ Grid& grid() const { return m_grid; }
+
private:
std::optional<LayoutUnit> freeSpaceForColumns;
std::optional<LayoutUnit> freeSpaceForRows;
@@ -426,6 +429,8 @@
// No need to store one per direction as it will be only used for computations during each axis
// track sizing. It's cached here because we need it to compute relative sizes.
std::optional<LayoutUnit> m_availableSpace;
+
+ Grid& m_grid;
};
void RenderGrid::GridSizingData::setFreeSpace(GridTrackSizingDirection direction, std::optional<LayoutUnit> freeSpace)
@@ -516,7 +521,7 @@
for (const auto& row : sizingData.rowTracks)
logicalHeight += row.baseSize();
- logicalHeight += guttersSize(ForRows, 0, sizingData.rowTracks.size());
+ logicalHeight += guttersSize(sizingData.grid(), ForRows, 0, sizingData.rowTracks.size());
return logicalHeight;
}
@@ -524,7 +529,7 @@
void RenderGrid::computeTrackSizesForDirection(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit availableSpace)
{
ASSERT(sizingData.isValidTransition(direction));
- LayoutUnit totalGuttersSize = guttersSize(direction, 0, m_grid.numTracks(direction));
+ LayoutUnit totalGuttersSize = guttersSize(sizingData.grid(), direction, 0, m_grid.numTracks(direction));
sizingData.setAvailableSpace(availableSpace);
sizingData.setFreeSpace(direction, availableSpace - totalGuttersSize);
sizingData.sizingOperation = TrackSizing;
@@ -537,7 +542,7 @@
void RenderGrid::repeatTracksSizingIfNeeded(GridSizingData& sizingData, LayoutUnit availableSpaceForColumns, LayoutUnit availableSpaceForRows)
{
- ASSERT(!m_grid.needsItemsPlacement());
+ ASSERT(!sizingData.grid().needsItemsPlacement());
ASSERT(sizingData.sizingState > GridSizingData::RowSizingFirstIteration);
// In orthogonal flow cases column track's size is determined by using the computed
@@ -548,7 +553,7 @@
// a new cycle of the sizing algorithm; there may be more. In addition, not all the
// cases with orthogonal flows require this extra cycle; we need a more specific
// condition to detect whether child's min-content contribution has changed or not.
- if (m_grid.hasAnyOrthogonalGridItem()) {
+ if (sizingData.grid().hasAnyOrthogonalGridItem()) {
computeTrackSizesForDirection(ForColumns, sizingData, availableSpaceForColumns);
computeTrackSizesForDirection(ForRows, sizingData, availableSpaceForRows);
}
@@ -596,7 +601,7 @@
placeItemsOnGrid(m_grid, TrackSizing);
- GridSizingData sizingData(numTracks(ForColumns, m_grid), numTracks(ForRows, m_grid));
+ GridSizingData sizingData(numTracks(ForColumns, m_grid), numTracks(ForRows, m_grid), m_grid);
// At this point the logical width is always definite as the above call to updateLogicalWidth()
// properly resolves intrinsic sizes. We cannot do the same for heights though because many code
@@ -667,7 +672,7 @@
return valueForLength(direction == ForColumns ? style().gridColumnGap() : style().gridRowGap(), LayoutUnit());
}
-LayoutUnit RenderGrid::guttersSize(GridTrackSizingDirection direction, unsigned startLine, unsigned span) const
+LayoutUnit RenderGrid::guttersSize(const Grid& grid, GridTrackSizingDirection direction, unsigned startLine, unsigned span) const
{
if (span <= 1)
return { };
@@ -675,7 +680,7 @@
LayoutUnit gap = gridGapForDirection(direction);
// Fast path, no collapsing tracks.
- if (!m_grid.hasAutoRepeatEmptyTracks(direction))
+ if (!grid.hasAutoRepeatEmptyTracks(direction))
return gap * (span - 1);
// If there are collapsing tracks we need to be sure that gutters are properly collapsed. Apart
@@ -687,12 +692,12 @@
unsigned endLine = startLine + span;
for (unsigned line = startLine; line < endLine - 1; ++line) {
- if (!m_grid.isEmptyAutoRepeatTrack(direction, line))
+ if (!grid.isEmptyAutoRepeatTrack(direction, line))
gapAccumulator += gap;
}
// The above loop adds one extra gap for trailing collapsed tracks.
- if (gapAccumulator && m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+ if (gapAccumulator && grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
ASSERT(gapAccumulator >= gap);
gapAccumulator -= gap;
}
@@ -699,9 +704,9 @@
// If the startLine is the start line of a collapsed track we need to go backwards till we reach
// a non collapsed track. If we find a non collapsed track we need to add that gap.
- if (startLine && m_grid.isEmptyAutoRepeatTrack(direction, startLine)) {
+ if (startLine && grid.isEmptyAutoRepeatTrack(direction, startLine)) {
unsigned nonEmptyTracksBeforeStartLine = startLine;
- auto begin = m_grid.autoRepeatEmptyTracks(direction)->begin();
+ auto begin = grid.autoRepeatEmptyTracks(direction)->begin();
for (auto it = begin; *it != startLine; ++it) {
ASSERT(nonEmptyTracksBeforeStartLine);
--nonEmptyTracksBeforeStartLine;
@@ -712,10 +717,10 @@
// If the endLine is the end line of a collapsed track we need to go forward till we reach a non
// collapsed track. If we find a non collapsed track we need to add that gap.
- if (m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
- unsigned nonEmptyTracksAfterEndLine = m_grid.numTracks(direction) - endLine;
- auto currentEmptyTrack = m_grid.autoRepeatEmptyTracks(direction)->find(endLine - 1);
- auto endEmptyTrack = m_grid.autoRepeatEmptyTracks(direction)->end();
+ if (grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+ unsigned nonEmptyTracksAfterEndLine = grid.numTracks(direction) - endLine;
+ auto currentEmptyTrack = grid.autoRepeatEmptyTracks(direction)->find(endLine - 1);
+ auto endEmptyTrack = grid.autoRepeatEmptyTracks(direction)->end();
// HashSet iterators do not implement operator- so we have to manually iterate to know the number of remaining empty tracks.
for (auto it = ++currentEmptyTrack; it != endEmptyTrack; ++it) {
ASSERT(nonEmptyTracksAfterEndLine >= 1);
@@ -734,13 +739,13 @@
if (!wasPopulated)
const_cast<RenderGrid*>(this)->placeItemsOnGrid(const_cast<Grid&>(m_grid), IntrinsicSizeComputation);
- GridSizingData sizingData(numTracks(ForColumns, m_grid), numTracks(ForRows, m_grid));
+ GridSizingData sizingData(numTracks(ForColumns, m_grid), numTracks(ForRows, m_grid), const_cast<Grid&>(m_grid));
sizingData.setAvailableSpace(std::nullopt);
sizingData.setFreeSpace(ForColumns, std::nullopt);
sizingData.sizingOperation = IntrinsicSizeComputation;
computeUsedBreadthOfGridTracks(ForColumns, sizingData, minLogicalWidth, maxLogicalWidth);
- LayoutUnit totalGuttersSize = guttersSize(ForColumns, 0, sizingData.columnTracks.size());
+ LayoutUnit totalGuttersSize = guttersSize(sizingData.grid(), ForColumns, 0, sizingData.columnTracks.size());
minLogicalWidth += totalGuttersSize;
maxLogicalWidth += totalGuttersSize;
@@ -767,7 +772,7 @@
minHeight += scrollbarHeight;
maxHeight += scrollbarHeight;
- LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
+ LayoutUnit totalGuttersSize = guttersSize(sizingData.grid(), ForRows, 0, m_grid.numTracks(ForRows));
minHeight += totalGuttersSize;
maxHeight += totalGuttersSize;
@@ -821,7 +826,7 @@
// 1. Initialize per Grid track variables.
for (unsigned i = 0; i < tracks.size(); ++i) {
GridTrack& track = tracks[i];
- const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData.sizingOperation);
+ const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData);
track.setBaseSize(computeUsedBreadthOfMinLength(trackSize, maxSize));
track.setGrowthLimit(computeUsedBreadthOfMaxLength(trackSize, track.baseSize(), maxSize));
@@ -885,22 +890,23 @@
// 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
double flexFraction = 0;
if (hasDefiniteFreeSpace)
- flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), direction, sizingData.sizingOperation, initialFreeSpace.value());
+ flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), direction, initialFreeSpace.value(), sizingData);
else {
for (const auto& trackIndex : flexibleSizedTracksIndex)
- flexFraction = std::max(flexFraction, normalizedFlexFraction(tracks[trackIndex], gridTrackSize(direction, trackIndex, sizingData.sizingOperation).maxTrackBreadth().flex()));
+ flexFraction = std::max(flexFraction, normalizedFlexFraction(tracks[trackIndex], gridTrackSize(direction, trackIndex, sizingData).maxTrackBreadth().flex()));
- if (m_grid.hasGridItems()) {
+ Grid& grid = sizingData.grid();
+ if (grid.hasGridItems()) {
for (unsigned i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
- GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
+ GridIterator iterator(grid, direction, flexibleSizedTracksIndex[i]);
while (auto* gridItem = iterator.nextGridItem()) {
- const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
+ const GridSpan& span = grid.gridItemSpan(*gridItem, direction);
// Do not include already processed items.
if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
continue;
- flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, sizingData.sizingOperation, maxContentForChild(*gridItem, direction, sizingData)));
+ flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, maxContentForChild(*gridItem, direction, sizingData), sizingData));
}
}
}
@@ -908,7 +914,7 @@
LayoutUnit totalGrowth;
Vector<LayoutUnit> increments;
increments.grow(flexibleSizedTracksIndex.size());
- computeFlexSizedTracksGrowth(direction, sizingData.sizingOperation, tracks, flexibleSizedTracksIndex, flexFraction, increments, totalGrowth);
+ computeFlexSizedTracksGrowth(direction, sizingData, tracks, flexibleSizedTracksIndex, flexFraction, increments, totalGrowth);
// We only need to redo the flex fraction computation for indefinite heights (definite sizes are
// already constrained by min/max sizes). Regarding widths, they are always definite at layout
@@ -924,11 +930,11 @@
bool checkMaxSize = maxSize && rowsSize > maxSize.value();
if (checkMinSize || checkMaxSize) {
LayoutUnit constrainedFreeSpace = checkMaxSize ? maxSize.value() : LayoutUnit(-1);
- constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
- flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), ForRows, sizingData.sizingOperation, constrainedFreeSpace);
+ constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(sizingData.grid(), ForRows, 0, sizingData.grid().numTracks(ForRows));
+ flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), ForRows, constrainedFreeSpace, sizingData);
totalGrowth = LayoutUnit(0);
- computeFlexSizedTracksGrowth(ForRows, sizingData.sizingOperation, tracks, flexibleSizedTracksIndex, flexFraction, increments, totalGrowth);
+ computeFlexSizedTracksGrowth(ForRows, sizingData, tracks, flexibleSizedTracksIndex, flexFraction, increments, totalGrowth);
}
}
@@ -943,13 +949,13 @@
sizingData.setFreeSpace(direction, freeSpace);
}
-void RenderGrid::computeFlexSizedTracksGrowth(GridTrackSizingDirection direction, SizingOperation sizingOperation, Vector<GridTrack>& tracks, const Vector<unsigned>& flexibleSizedTracksIndex, double flexFraction, Vector<LayoutUnit>& increments, LayoutUnit& totalGrowth) const
+void RenderGrid::computeFlexSizedTracksGrowth(GridTrackSizingDirection direction, const GridSizingData& sizingData, Vector<GridTrack>& tracks, const Vector<unsigned>& flexibleSizedTracksIndex, double flexFraction, Vector<LayoutUnit>& increments, LayoutUnit& totalGrowth) const
{
size_t numFlexTracks = flexibleSizedTracksIndex.size();
ASSERT(increments.size() == numFlexTracks);
for (size_t i = 0; i < numFlexTracks; ++i) {
unsigned trackIndex = flexibleSizedTracksIndex[i];
- auto trackSize = gridTrackSize(direction, trackIndex, sizingOperation);
+ auto trackSize = gridTrackSize(direction, trackIndex, sizingData);
ASSERT(trackSize.maxTrackBreadth().isFlex());
LayoutUnit oldBaseSize = tracks[trackIndex].baseSize();
LayoutUnit newBaseSize = std::max(oldBaseSize, LayoutUnit(flexFraction * trackSize.maxTrackBreadth().flex()));
@@ -986,7 +992,7 @@
return infinity;
}
-double RenderGrid::computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, GridTrackSizingDirection direction, SizingOperation sizingOperation, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<unsigned, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const
+double RenderGrid::computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, GridTrackSizingDirection direction, const GridSizingData& sizingData, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<unsigned, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const
{
// We want to avoid the effect of flex factors sum below 1 making the factor unit size to grow exponentially.
double hypotheticalFactorUnitSize = leftOverSpace / std::max<double>(1, flexFactorSum);
@@ -997,7 +1003,7 @@
if (tracksToTreatAsInflexible && tracksToTreatAsInflexible->contains(index))
continue;
LayoutUnit baseSize = tracks[index].baseSize();
- double flexFactor = gridTrackSize(direction, index, sizingOperation).maxTrackBreadth().flex();
+ double flexFactor = gridTrackSize(direction, index, sizingData).maxTrackBreadth().flex();
// treating all such tracks as inflexible.
if (baseSize > hypotheticalFactorUnitSize * flexFactor) {
leftOverSpace -= baseSize;
@@ -1009,11 +1015,11 @@
}
}
if (!validFlexFactorUnit)
- return computeFlexFactorUnitSize(tracks, direction, sizingOperation, flexFactorSum, leftOverSpace, flexibleTracksIndexes, WTFMove(tracksToTreatAsInflexible));
+ return computeFlexFactorUnitSize(tracks, direction, sizingData, flexFactorSum, leftOverSpace, flexibleTracksIndexes, WTFMove(tracksToTreatAsInflexible));
return hypotheticalFactorUnitSize;
}
-double RenderGrid::findFlexFactorUnitSize(const Vector<GridTrack>& tracks, const GridSpan& tracksSpan, GridTrackSizingDirection direction, SizingOperation sizingOperation, LayoutUnit leftOverSpace) const
+double RenderGrid::findFlexFactorUnitSize(const Vector<GridTrack>& tracks, const GridSpan& tracksSpan, GridTrackSizingDirection direction, LayoutUnit leftOverSpace, const GridSizingData& sizingData) const
{
if (leftOverSpace <= 0)
return 0;
@@ -1021,7 +1027,7 @@
double flexFactorSum = 0;
Vector<unsigned, 8> flexibleTracksIndexes;
for (auto trackIndex : tracksSpan) {
- GridTrackSize trackSize = gridTrackSize(direction, trackIndex, sizingOperation);
+ GridTrackSize trackSize = gridTrackSize(direction, trackIndex, sizingData);
if (!trackSize.maxTrackBreadth().isFlex())
leftOverSpace -= tracks[trackIndex].baseSize();
else {
@@ -1034,7 +1040,7 @@
// The function is not called if we don't have <flex> grid tracks
ASSERT(!flexibleTracksIndexes.isEmpty());
- return computeFlexFactorUnitSize(tracks, direction, sizingOperation, flexFactorSum, leftOverSpace, flexibleTracksIndexes);
+ return computeFlexFactorUnitSize(tracks, direction, sizingData, flexFactorSum, leftOverSpace, flexibleTracksIndexes);
}
static bool hasOverrideContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
@@ -1062,7 +1068,7 @@
return child.hasRelativeLogicalHeight() || child.style().logicalHeight().isIntrinsicOrAuto();
}
-const GridTrackSize& RenderGrid::rawGridTrackSize(GridTrackSizingDirection direction, unsigned translatedIndex) const
+const GridTrackSize& RenderGrid::rawGridTrackSize(GridTrackSizingDirection direction, unsigned translatedIndex, const GridSizingData& sizingData) const
{
bool isRowAxis = direction == ForColumns;
auto& trackStyles = isRowAxis ? style().gridColumns() : style().gridRows();
@@ -1069,7 +1075,7 @@
auto& autoRepeatTrackStyles = isRowAxis ? style().gridAutoRepeatColumns() : style().gridAutoRepeatRows();
auto& autoTrackStyles = isRowAxis ? style().gridAutoColumns() : style().gridAutoRows();
unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
- unsigned autoRepeatTracksCount = m_grid.autoRepeatTracks(direction);
+ unsigned autoRepeatTracksCount = sizingData.grid().autoRepeatTracks(direction);
// We should not use GridPositionsResolver::explicitGridXXXCount() for this because the
// explicit grid might be larger than the number of tracks in grid-template-rows|columns (if
@@ -1076,7 +1082,7 @@
// grid-template-areas is specified for example).
unsigned explicitTracksCount = trackStyles.size() + autoRepeatTracksCount;
- int untranslatedIndexAsInt = translatedIndex + m_grid.smallestTrackStart(direction);
+ int untranslatedIndexAsInt = translatedIndex + sizingData.grid().smallestTrackStart(direction);
unsigned autoTrackStylesSize = autoTrackStyles.size();
if (untranslatedIndexAsInt < 0) {
int index = untranslatedIndexAsInt % static_cast<int>(autoTrackStylesSize);
@@ -1100,13 +1106,13 @@
return trackStyles[untranslatedIndex - autoRepeatTracksCount];
}
-GridTrackSize RenderGrid::gridTrackSize(GridTrackSizingDirection direction, unsigned translatedIndex, SizingOperation sizingOperation) const
+GridTrackSize RenderGrid::gridTrackSize(GridTrackSizingDirection direction, unsigned translatedIndex, const GridSizingData& sizingData) const
{
// Collapse empty auto repeat tracks if auto-fit.
- if (m_grid.hasAutoRepeatEmptyTracks(direction) && m_grid.isEmptyAutoRepeatTrack(direction, translatedIndex))
+ if (sizingData.grid().hasAutoRepeatEmptyTracks(direction) && sizingData.grid().isEmptyAutoRepeatTrack(direction, translatedIndex))
return { Length(Fixed), LengthTrackSizing };
- auto& trackSize = rawGridTrackSize(direction, translatedIndex);
+ auto& trackSize = rawGridTrackSize(direction, translatedIndex, sizingData);
if (trackSize.isFitContent())
return trackSize;
@@ -1117,7 +1123,7 @@
if (minTrackBreadth.isPercentage() || maxTrackBreadth.isPercentage()) {
// If the logical width/height of the grid container is indefinite, percentage values are treated as <auto>.
// For the inline axis this only happens when we're computing the intrinsic sizes (IntrinsicSizeComputation).
- if (sizingOperation == IntrinsicSizeComputation || (direction == ForRows && !hasDefiniteLogicalHeight())) {
+ if (sizingData.sizingOperation == IntrinsicSizeComputation || (direction == ForRows && !hasDefiniteLogicalHeight())) {
if (minTrackBreadth.isPercentage())
minTrackBreadth = Length(Auto);
if (maxTrackBreadth.isPercentage())
@@ -1269,10 +1275,10 @@
GridSpan m_span;
};
-bool RenderGrid::spanningItemCrossesFlexibleSizedTracks(const GridSpan& itemSpan, GridTrackSizingDirection direction, SizingOperation sizingOperation) const
+bool RenderGrid::spanningItemCrossesFlexibleSizedTracks(const GridSpan& itemSpan, GridTrackSizingDirection direction, const GridSizingData& sizingData) const
{
for (auto trackPosition : itemSpan) {
- const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition, sizingOperation);
+ const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition, sizingData);
if (trackSize.minTrackBreadth().isFlex() || trackSize.maxTrackBreadth().isFlex())
return true;
}
@@ -1289,17 +1295,18 @@
{
sizingData.itemsSortedByIncreasingSpan.shrink(0);
HashSet<RenderBox*> itemsSet;
- if (m_grid.hasGridItems()) {
+ Grid& grid = sizingData.grid();
+ if (grid.hasGridItems()) {
for (auto trackIndex : sizingData.contentSizedTracksIndex) {
- GridIterator iterator(m_grid, direction, trackIndex);
+ GridIterator iterator(grid, direction, trackIndex);
GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackIndex] : sizingData.rowTracks[trackIndex];
while (auto* gridItem = iterator.nextGridItem()) {
if (itemsSet.add(gridItem).isNewEntry) {
- const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
+ const GridSpan& span = grid.gridItemSpan(*gridItem, direction);
if (span.integerSpan() == 1)
resolveContentBasedTrackSizingFunctionsForNonSpanningItems(direction, span, *gridItem, track, sizingData);
- else if (!spanningItemCrossesFlexibleSizedTracks(span, direction, sizingData.sizingOperation))
+ else if (!spanningItemCrossesFlexibleSizedTracks(span, direction, sizingData))
sizingData.itemsSortedByIncreasingSpan.append(GridItemWithSpan(*gridItem, span));
}
}
@@ -1329,7 +1336,7 @@
void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, GridSizingData& sizingData) const
{
unsigned trackPosition = span.startLine();
- GridTrackSize trackSize = gridTrackSize(direction, trackPosition, sizingData.sizingOperation);
+ GridTrackSize trackSize = gridTrackSize(direction, trackPosition, sizingData);
if (trackSize.hasMinContentMinTrackBreadth())
track.setBaseSize(std::max(track.baseSize(), minContentForChild(gridItem, direction, sizingData)));
@@ -1488,7 +1495,7 @@
sizingData.growBeyondGrowthLimitsTracks.shrink(0);
LayoutUnit spanningTracksSize;
for (auto trackPosition : itemSpan) {
- const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition, sizingData.sizingOperation);
+ const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition, sizingData);
GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition] : sizingData.rowTracks[trackPosition];
spanningTracksSize += trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
@@ -1503,7 +1510,7 @@
if (sizingData.filteredTracks.isEmpty())
continue;
- spanningTracksSize += guttersSize(direction, itemSpan.startLine(), itemSpan.integerSpan());
+ spanningTracksSize += guttersSize(sizingData.grid(), direction, itemSpan.startLine(), itemSpan.integerSpan());
LayoutUnit extraSpace = currentItemSizeForTrackSizeComputationPhase(phase, gridItemWithSpan.gridItem(), direction, sizingData) - spanningTracksSize;
extraSpace = std::max<LayoutUnit>(extraSpace, 0);
@@ -1603,7 +1610,7 @@
const Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
const LayoutUnit maxSize = sizingData.availableSpace().value_or(0);
for (unsigned i = 0; i < tracks.size(); ++i) {
- const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData.sizingOperation);
+ const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData);
if (computeUsedBreadthOfMinLength(trackSize, maxSize) > tracks[i].baseSize())
return false;
}
@@ -1962,6 +1969,8 @@
if (numPositions < 2)
return tracks;
+ // FIXME: enable the ASSERT once m_grid is persistent.
+ // ASSERT(!m_grid.needsItemsPlacement());
bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
tracks.reserveCapacity(numPositions - 1);
@@ -2009,7 +2018,7 @@
Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
Vector<unsigned> autoSizedTracksIndex;
for (unsigned i = 0; i < tracks.size(); ++i) {
- const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData.sizingOperation);
+ const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData);
if (trackSize.hasAutoMaxTrackBreadth())
autoSizedTracksIndex.append(i);
}
@@ -2066,7 +2075,7 @@
updateAutoMarginsInColumnAxisIfNeeded(*child);
updateAutoMarginsInRowAxisIfNeeded(*child);
- child->setLogicalLocation(findChildLogicalPosition(*child));
+ child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
// If the child moved, we have to repaint it as well as any floating/positioned
// descendants. An exception is if we need a layout. In this case, we know we're going to
@@ -2167,7 +2176,8 @@
// These vectors store line positions including gaps, but we shouldn't consider them for the edges of the grid.
if (endLine > 0 && endLine < lastLine) {
- end -= guttersSize(direction, endLine - 1, 2);
+ ASSERT(!m_grid.needsItemsPlacement());
+ end -= guttersSize(m_grid, direction, endLine - 1, 2);
end -= isRowAxis ? m_offsetBetweenColumns : m_offsetBetweenRows;
}
}
@@ -2184,7 +2194,8 @@
offset = translateRTLCoordinate(m_columnPositions[endLine]) - borderLogicalLeft();
if (endLine > 0 && endLine < lastLine) {
- offset += guttersSize(direction, endLine - 1, 2);
+ ASSERT(!m_grid.needsItemsPlacement());
+ offset += guttersSize(m_grid, direction, endLine - 1, 2);
offset += isRowAxis ? m_offsetBetweenColumns : m_offsetBetweenRows;
}
}
@@ -2191,15 +2202,15 @@
}
}
-LayoutUnit RenderGrid::assumedRowsSizeForOrthogonalChild(const RenderBox& child, SizingOperation sizingOperation) const
+LayoutUnit RenderGrid::assumedRowsSizeForOrthogonalChild(const RenderBox& child, const GridSizingData& sizingData) const
{
ASSERT(isOrthogonalChild(child));
- const GridSpan& span = m_grid.gridItemSpan(child, ForRows);
+ const GridSpan& span = sizingData.grid().gridItemSpan(child, ForRows);
LayoutUnit gridAreaSize;
bool gridAreaIsIndefinite = false;
LayoutUnit containingBlockAvailableSize = containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
for (auto trackPosition : span) {
- GridLength maxTrackSize = gridTrackSize(ForRows, trackPosition, sizingOperation).maxTrackBreadth();
+ GridLength maxTrackSize = gridTrackSize(ForRows, trackPosition, sizingData).maxTrackBreadth();
if (maxTrackSize.isContentSized() || maxTrackSize.isFlex())
gridAreaIsIndefinite = true;
else
@@ -2206,7 +2217,7 @@
gridAreaSize += valueForLength(maxTrackSize.length(), containingBlockAvailableSize);
}
- gridAreaSize += guttersSize(ForRows, span.startLine(), span.integerSpan());
+ gridAreaSize += guttersSize(sizingData.grid(), ForRows, span.startLine(), span.integerSpan());
return gridAreaIsIndefinite ? std::max(child.maxPreferredLogicalWidth(), gridAreaSize) : gridAreaSize;
}
@@ -2217,15 +2228,15 @@
// may depend on the row track's size. It's possible that the row tracks sizing logic has not been performed yet,
// so we will need to do an estimation.
if (direction == ForRows && sizingData.sizingState == GridSizingData::ColumnSizingFirstIteration)
- return assumedRowsSizeForOrthogonalChild(child, sizingData.sizingOperation);
+ return assumedRowsSizeForOrthogonalChild(child, sizingData);
const Vector<GridTrack>& tracks = direction == ForColumns ? sizingData.columnTracks : sizingData.rowTracks;
- const GridSpan& span = m_grid.gridItemSpan(child, direction);
+ const GridSpan& span = sizingData.grid().gridItemSpan(child, direction);
LayoutUnit gridAreaBreadth = 0;
for (auto trackPosition : span)
gridAreaBreadth += tracks[trackPosition].baseSize();
- gridAreaBreadth += guttersSize(direction, span.startLine(), span.integerSpan());
+ gridAreaBreadth += guttersSize(sizingData.grid(), direction, span.startLine(), span.integerSpan());
return gridAreaBreadth;
}
@@ -2235,7 +2246,7 @@
// We need the cached value when available because Content Distribution alignment properties
// may have some influence in the final grid area breadth.
const auto& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
- const auto& span = m_grid.gridItemSpan(child, direction);
+ const auto& span = sizingData.grid().gridItemSpan(child, direction);
const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
LayoutUnit initialTrackPosition = linePositions[span.startLine()];
@@ -2265,10 +2276,11 @@
positions.resize(numberOfLines);
auto borderAndPadding = isRowAxis ? borderAndPaddingLogicalLeft() : borderAndPaddingBefore();
positions[0] = borderAndPadding + offset.positionOffset;
+ Grid& grid = sizingData.grid();
if (numberOfLines > 1) {
// If we have collapsed tracks we just ignore gaps here and add them later as we might not
// compute the gap between two consecutive tracks without examining the surrounding ones.
- bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
+ bool hasCollapsedTracks = grid.hasAutoRepeatEmptyTracks(direction);
LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
unsigned nextToLastLine = numberOfLines - 2;
for (unsigned i = 0; i < nextToLastLine; ++i)
@@ -2279,16 +2291,16 @@
// coincide exactly) except on the edges of the grid where they become 0.
if (hasCollapsedTracks) {
gap = gridGapForDirection(direction);
- unsigned remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
+ unsigned remainingEmptyTracks = grid.autoRepeatEmptyTracks(direction)->size();
LayoutUnit gapAccumulator;
for (unsigned i = 1; i < lastLine; ++i) {
- if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1))
+ if (grid.isEmptyAutoRepeatTrack(direction, i - 1))
--remainingEmptyTracks;
else {
// Add gap between consecutive non empty tracks. Add it also just once for an
// arbitrary number of empty tracks between two non empty ones.
bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
- if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i))
+ if (!allRemainingTracksAreEmpty || !grid.isEmptyAutoRepeatTrack(direction, i))
gapAccumulator += gap;
}
positions[i] += gapAccumulator;
@@ -2582,9 +2594,9 @@
return GridAxisStart;
}
-LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
+LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child, const GridSizingData& sizingData) const
{
- const GridSpan& rowsSpan = m_grid.gridItemSpan(child, ForRows);
+ const GridSpan& rowsSpan = sizingData.grid().gridItemSpan(child, ForRows);
unsigned childStartLine = rowsSpan.startLine();
LayoutUnit startOfRow = m_rowPositions[childStartLine];
LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
@@ -2615,9 +2627,9 @@
}
-LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
+LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child, const GridSizingData& sizingData) const
{
- const GridSpan& columnsSpan = m_grid.gridItemSpan(child, ForColumns);
+ const GridSpan& columnsSpan = sizingData.grid().gridItemSpan(child, ForColumns);
unsigned childStartLine = columnsSpan.startLine();
LayoutUnit startOfColumn = m_columnPositions[childStartLine];
LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
@@ -2757,10 +2769,10 @@
return rightGridEdgePosition + alignmentOffset - coordinate;
}
-LayoutPoint RenderGrid::findChildLogicalPosition(const RenderBox& child) const
+LayoutPoint RenderGrid::findChildLogicalPosition(const RenderBox& child, const GridSizingData& sizingData) const
{
- LayoutUnit columnAxisOffset = columnAxisOffsetForChild(child);
- LayoutUnit rowAxisOffset = rowAxisOffsetForChild(child);
+ LayoutUnit columnAxisOffset = columnAxisOffsetForChild(child, sizingData);
+ LayoutUnit rowAxisOffset = rowAxisOffsetForChild(child, sizingData);
// We stored m_columnPositions's data ignoring the direction, hence we might need now
// to translate positions from RTL to LTR, as it's more convenient for painting.
if (!style().isLeftToRightDirection())
@@ -2781,6 +2793,7 @@
// to get it from the style. Note that we know for sure that there are't any implicit tracks,
// because not having rows implies that there are no "normal" children (out-of-flow children are
// not stored in m_grid).
+ ASSERT(!m_grid.needsItemsPlacement());
if (direction == ForRows)
return grid.numTracks(ForRows);
@@ -2790,6 +2803,8 @@
void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset, PaintInfo& forChild, bool usePrintRect)
{
+ // FIXME: enable the ASSERT once m_grid is persistent.
+ // ASSERT(!m_grid.needsItemsPlacement());
for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next())
paintChild(*child, paintInfo, paintOffset, forChild, usePrintRect, PaintAsInlineBlock);
}
Modified: trunk/Source/WebCore/rendering/RenderGrid.h (210196 => 210197)
--- trunk/Source/WebCore/rendering/RenderGrid.h 2016-12-28 11:04:16 UTC (rev 210196)
+++ trunk/Source/WebCore/rendering/RenderGrid.h 2016-12-28 11:06:44 UTC (rev 210197)
@@ -84,7 +84,7 @@
class GridSizingData;
enum SizingOperation { TrackSizing, IntrinsicSizeComputation };
void computeUsedBreadthOfGridTracks(GridTrackSizingDirection, GridSizingData&, LayoutUnit& baseSizesWithoutMaximization, LayoutUnit& growthLimitsWithoutMaximization) const;
- void computeFlexSizedTracksGrowth(GridTrackSizingDirection, SizingOperation, Vector<GridTrack>&, const Vector<unsigned>& flexibleSizedTracksIndex, double flexFraction, Vector<LayoutUnit>& increments, LayoutUnit& totalGrowth) const;
+ void computeFlexSizedTracksGrowth(GridTrackSizingDirection, const GridSizingData&, Vector<GridTrack>&, const Vector<unsigned>& flexibleSizedTracksIndex, double flexFraction, Vector<LayoutUnit>& increments, LayoutUnit& totalGrowth) const;
LayoutUnit computeUsedBreadthOfMinLength(const GridTrackSize&, LayoutUnit maxSize) const;
LayoutUnit computeUsedBreadthOfMaxLength(const GridTrackSize&, LayoutUnit usedBreadth, LayoutUnit maxSize) const;
void resolveContentBasedTrackSizingFunctions(GridTrackSizingDirection, GridSizingData&) const;
@@ -131,11 +131,11 @@
template <TrackSizeComputationPhase> void distributeSpaceToTracks(Vector<GridTrack*>&, Vector<GridTrack*>* growBeyondGrowthLimitsTracks, LayoutUnit& availableLogicalSpace) const;
typedef HashSet<unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> TrackIndexSet;
- double computeFlexFactorUnitSize(const Vector<GridTrack>&, GridTrackSizingDirection, SizingOperation, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<unsigned, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible = nullptr) const;
- double findFlexFactorUnitSize(const Vector<GridTrack>&, const GridSpan&, GridTrackSizingDirection, SizingOperation, LayoutUnit spaceToFill) const;
+ double computeFlexFactorUnitSize(const Vector<GridTrack>&, GridTrackSizingDirection, const GridSizingData&, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<unsigned, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible = nullptr) const;
+ double findFlexFactorUnitSize(const Vector<GridTrack>&, const GridSpan&, GridTrackSizingDirection, LayoutUnit spaceToFill, const GridSizingData&) const;
- const GridTrackSize& rawGridTrackSize(GridTrackSizingDirection, unsigned) const;
- GridTrackSize gridTrackSize(GridTrackSizingDirection, unsigned, SizingOperation) const;
+ const GridTrackSize& rawGridTrackSize(GridTrackSizingDirection, unsigned, const GridSizingData&) const;
+ GridTrackSize gridTrackSize(GridTrackSizingDirection, unsigned, const GridSizingData&) const;
bool updateOverrideContainingBlockContentSizeForChild(RenderBox&, GridTrackSizingDirection, GridSizingData&) const;
LayoutUnit logicalHeightForChild(RenderBox&) const;
@@ -144,10 +144,10 @@
LayoutUnit maxContentForChild(RenderBox&, GridTrackSizingDirection, GridSizingData&) const;
GridAxisPosition columnAxisPositionForChild(const RenderBox&) const;
GridAxisPosition rowAxisPositionForChild(const RenderBox&) const;
- LayoutUnit columnAxisOffsetForChild(const RenderBox&) const;
- LayoutUnit rowAxisOffsetForChild(const RenderBox&) const;
+ LayoutUnit columnAxisOffsetForChild(const RenderBox&, const GridSizingData&) const;
+ LayoutUnit rowAxisOffsetForChild(const RenderBox&, const GridSizingData&) const;
ContentAlignmentData computeContentPositionAndDistributionOffset(GridTrackSizingDirection, const LayoutUnit& availableFreeSpace, unsigned numberOfGridTracks) const;
- LayoutPoint findChildLogicalPosition(const RenderBox&) const;
+ LayoutPoint findChildLogicalPosition(const RenderBox&, const GridSizingData&) const;
GridArea cachedGridArea(const RenderBox&) const;
GridSpan cachedGridSpan(const RenderBox&, GridTrackSizingDirection) const;
@@ -154,7 +154,7 @@
LayoutUnit gridAreaBreadthForChild(const RenderBox& child, GridTrackSizingDirection, const GridSizingData&) const;
LayoutUnit gridAreaBreadthForChildIncludingAlignmentOffsets(const RenderBox&, GridTrackSizingDirection, const GridSizingData&) const;
- LayoutUnit assumedRowsSizeForOrthogonalChild(const RenderBox&, SizingOperation) const;
+ LayoutUnit assumedRowsSizeForOrthogonalChild(const RenderBox&, const GridSizingData&) const;
void applyStretchAlignmentToTracksIfNeeded(GridTrackSizingDirection, GridSizingData&);
@@ -181,9 +181,9 @@
#endif
LayoutUnit gridGapForDirection(GridTrackSizingDirection) const;
- LayoutUnit guttersSize(GridTrackSizingDirection, unsigned startLine, unsigned span) const;
+ LayoutUnit guttersSize(const Grid&, GridTrackSizingDirection, unsigned startLine, unsigned span) const;
- bool spanningItemCrossesFlexibleSizedTracks(const GridSpan&, GridTrackSizingDirection, SizingOperation) const;
+ bool spanningItemCrossesFlexibleSizedTracks(const GridSpan&, GridTrackSizingDirection, const GridSizingData&) const;
unsigned numTracks(GridTrackSizingDirection, const Grid&) const;
