[css-grid] Use grid area position to determine overflowing items

third_party/WebKit/Source/core/layout/LayoutGrid.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1904 matching lines @@
         // call to avoid unnecessary relayouts. This might imply that child margins, needed to correctly
         // determine the available space before stretching, are not set yet.
         applyStretchAlignmentToChildIfNeeded(*child);
 
         child->layoutIfNeeded();
 
         // We need pending layouts to be done in order to compute auto-margins properly.
         updateAutoMarginsInColumnAxisIfNeeded(*child);
         updateAutoMarginsInRowAxisIfNeeded(*child);
 
+        const GridArea& area = cachedGridArea(*child);
 #if ENABLE(ASSERT)
-        const GridArea& area = cachedGridArea(*child);
         ASSERT(area.columns.startLine() < sizingData.columnTracks.size());
         ASSERT(area.rows.startLine() < sizingData.rowTracks.size());
 #endif
         child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
 
         // Keep track of children overflowing their grid area as we might need to paint them even if the grid-area is not visible.
         // Using physical dimensions for simplicity, so we can forget about orthogonalty.
         // TODO (lajava): Child's margins should account when evaluating whether it overflows its grid area (http://crbug.com/628155).

[jfernandez, 2016/09/19 18:01:24]

Remove the TODO, please.

[svillar, 2016/09/20 11:12:46]

Acknowledged.

         LayoutUnit childGridAreaHeight = isHorizontalWritingMode() ? overrideContainingBlockContentLogicalHeight : overrideContainingBlockContentLogicalWidth;
         LayoutUnit childGridAreaWidth = isHorizontalWritingMode() ? overrideContainingBlockContentLogicalWidth : overrideContainingBlockContentLogicalHeight;
-        if (child->size().height() > childGridAreaHeight || child->size().width() > childGridAreaWidth)
+        LayoutRect gridAreaRect(gridAreaLogicalPosition(area), LayoutSize(childGridAreaWidth, childGridAreaHeight));
+        if (!gridAreaRect.contains(child->frameRect()))

[jfernandez, 2016/09/19 18:01:24]

Using FrameRect should be the same than doing operations with height()(width(),
like in the old code. I don't understand why this is solving the issue.
Additionally, wouldn't we take into account the box-sizing property ?  

[svillar, 2016/09/20 11:12:47]

The main difference are not the sizes indeed, but the location of the grid area
vs the location of the child.

             m_gridItemsOverflowingGridArea.append(child);
     }
 }
 
 void LayoutGrid::prepareChildForPositionedLayout(LayoutBox& child)
 {
     ASSERT(child.isOutOfFlowPositioned());
     child.containingBlock()->insertPositionedObject(&child);
 
     PaintLayer* childLayer = child.layer();
@@ skipping 706 matching lines @@
         rowAxisOffset = translateRTLCoordinate(rowAxisOffset) - (isOrthogonalChild(child) ? child.logicalHeight()  : child.logicalWidth());
 
     // "In the positioning phase [...] calculations are performed according to the writing mode
     // of the containing block of the box establishing the orthogonal flow." However, the
     // resulting LayoutPoint will be used in 'setLogicalPosition' in order to set the child's
     // logical position, which will only take into account the child's writing-mode.
     LayoutPoint childLocation(rowAxisOffset, columnAxisOffset);
     return isOrthogonalChild(child) ? childLocation.transposedPoint() : childLocation;
 }
 
+LayoutPoint LayoutGrid::gridAreaLogicalPosition(const GridArea& area) const
+{
+    LayoutUnit columnAxisOffset = m_rowPositions[area.rows.startLine()];
+    LayoutUnit rowAxisOffset = m_columnPositions[area.columns.startLine()];
+
+    // See comment in findChildLogicalPosition() about why we need sometimes to translate from RTL
+    // to LTR the rowAxisOffset coordinate.
+    return LayoutPoint(style()->isLeftToRightDirection() ? rowAxisOffset : translateRTLCoordinate(rowAxisOffset), columnAxisOffset);
+}
+
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
 {
     if (!m_gridItemArea.isEmpty())
         GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const
 {
     SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
     return m_hasDefiniteLogicalHeight.value();
 }
 
 } // namespace blink