[CSS Grid Layout] Determine definite/indefinite size properly in nested grids

Source/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 4158 matching lines @@
         return;
 
     if (!hasVisualOverflow() && contentsVisualOverflowRect().isEmpty()) {
         clearAllOverflows();
         return;
     }
 
     m_overflow->setLayoutOverflow(noOverflowRect());
 }
 
 bool RenderBox::logicalWidthIsResolvableFromBlock(const RenderBlock* containingBlock)

[Julien - ping for review, 2015/02/18 22:13:16]

This function looks like it could have static linkage.

[Manuel Rego, 2015/02/25 16:57:59]

This is marked as static in LayoutBox.h like
percentageLogicalHeightIsResolvableFromBlock().

 {
     const RenderBlock* cb = containingBlock;
-    while (!cb->isRenderView() && !cb->isOutOfFlowPositioned() && (cb->style()->logicalWidth().isAuto() || cb->isAnonymousBlock()))
+    while (!cb->isRenderView() && !cb->isOutOfFlowPositioned() && (cb->style()->logicalWidth().isAuto() || cb->isAnonymousBlock())) {
+        if (cb->hasOverrideContainingBlockLogicalWidth())
+            return cb->overrideContainingBlockContentLogicalWidth() != -1;

[Julien - ping for review, 2015/02/18 22:13:16]

I am concerned about this logic needing the bits in hasDefiniteLogicalWidth
below. This means that we're bleeding some details around.

Passing the descendant into logicalWidthIsResolvableFromBlock would remove this
limitation, but you're not guaranteed to manipulate a block anymore (but at
least a RenderBox). I think that's a fine tradeoff as it would make the function
self-contained.

[Manuel Rego, 2015/02/25 16:57:59]

Done.

+
         cb = cb->containingBlock();
+    }
 
     if (cb->style()->logicalWidth().isFixed())
         return true;
     if (cb->isRenderView())
         return true;
     if (cb->isOutOfFlowPositioned())
         return true;
     if (cb->style()->logicalWidth().isPercent())
         return logicalWidthIsResolvableFromBlock(cb->containingBlock());
 
     return false;
 }
 
 bool RenderBox::hasDefiniteLogicalWidth() const
 {
     const Length& logicalWidth = style()->logicalWidth();
     if (logicalWidth.isIntrinsic() || logicalWidth.isLegacyIntrinsic())
         return false;
     if (logicalWidth.isFixed())
         return true;
     // The size of the containing block of an absolutely positioned element is always definite with respect to that
     // element (http://dev.w3.org/csswg/css-sizing-3/#definite).
     if (isOutOfFlowPositioned())
         return true;
+    if (hasOverrideContainingBlockLogicalWidth())
+        return overrideContainingBlockContentLogicalWidth() != -1;
 
     return RenderBox::logicalWidthIsResolvableFromBlock(containingBlock());
 }
 
 inline static bool percentageLogicalHeightIsResolvable(const RenderBox* box)
 {
     return RenderBox::percentageLogicalHeightIsResolvableFromBlock(box->containingBlock(), box->isOutOfFlowPositioned());
 }
 
 bool RenderBox::percentageLogicalHeightIsResolvableFromBlock(const RenderBlock* containingBlock, bool isOutOfFlowPositioned)
 {
     // In quirks mode, blocks with auto height are skipped, and we keep looking for an enclosing
     // block that may have a specified height and then use it. In strict mode, this violates the
     // specification, which states that percentage heights just revert to auto if the containing
     // block has an auto height. We still skip anonymous containing blocks in both modes, though, and look
     // only at explicit containers.
     const RenderBlock* cb = containingBlock;
     bool inQuirksMode = cb->document().inQuirksMode();
     while (!cb->isRenderView() && !cb->isBody() && !cb->isTableCell() && !cb->isOutOfFlowPositioned() && cb->style()->logicalHeight().isAuto()) {
         if (!inQuirksMode && !cb->isAnonymousBlock())
             break;
+        if (cb->hasOverrideContainingBlockLogicalHeight())
+            return cb->overrideContainingBlockContentLogicalHeight() != -1;
+
         cb = cb->containingBlock();
     }
 
     // A positioned element that specified both top/bottom or that specifies height should be treated as though it has a height
     // explicitly specified that can be used for any percentage computations.
     // FIXME: We can't just check top/bottom here.
     // https://bugs.webkit.org/show_bug.cgi?id=46500
     bool isOutOfFlowPositionedWithSpecifiedHeight = cb->isOutOfFlowPositioned() && (!cb->style()->logicalHeight().isAuto() || (!cb->style()->top().isAuto() && !cb->style()->bottom().isAuto()));
 
     // Table cells violate what the CSS spec says to do with heights.  Basically we
@@ skipping 23 matching lines @@
 {
     const Length& logicalHeight = style()->logicalHeight();
     if (logicalHeight.isIntrinsicOrAuto())
         return false;
     if (logicalHeight.isFixed())
         return true;
     // The size of the containing block of an absolutely positioned element is always definite with respect to that
     // element (http://dev.w3.org/csswg/css-sizing-3/#definite).
     if (isOutOfFlowPositioned())
         return true;
+    if (hasOverrideContainingBlockLogicalHeight())
+        return overrideContainingBlockContentLogicalHeight() != -1;
 
     return percentageLogicalHeightIsResolvable(this);
 }
 
 bool RenderBox::hasUnsplittableScrollingOverflow() const
 {
     // We will paginate as long as we don't scroll overflow in the pagination direction.
     bool isHorizontal = isHorizontalWritingMode();
     if ((isHorizontal && !scrollsOverflowY()) || (!isHorizontal && !scrollsOverflowX()))
         return false;
@@ skipping 325 matching lines @@
 }
 
 void RenderBox::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
 {
     RenderBoxModelObject::invalidateDisplayItemClients(displayItemList);
     if (LayerScrollableArea* area = scrollableArea())
         displayItemList->invalidate(area->displayItemClient());
 }
 
 } // namespace blink