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

Source/core/layout/LayoutBox.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 4177 matching lines @@
         return;
 
     if (!hasVisualOverflow() && contentsVisualOverflowRect().isEmpty()) {
         clearAllOverflows();
         return;
     }
 
     m_overflow->setLayoutOverflow(noOverflowRect());
 }
 
-bool LayoutBox::logicalWidthIsResolvableFromBlock(const LayoutBlock* containingBlock)
+static bool logicalWidthIsResolvable(const LayoutBox& layoutBox)
 {
-    const LayoutBlock* cb = containingBlock;
-    while (!cb->isLayoutView() && !cb->isOutOfFlowPositioned() && (cb->style()->logicalWidth().isAuto() || cb->isAnonymousBlock()))
-        cb = cb->containingBlock();
+    const LayoutBox* box = &layoutBox;
+    while (!box->isLayoutView() && !box->isOutOfFlowPositioned()
+        && (box->style()->logicalWidth().isAuto() || box->isAnonymousBlock())
+        && !box->hasOverrideContainingBlockLogicalWidth())
+        box = box->containingBlock();
 
-    if (cb->style()->logicalWidth().isFixed())
+    if (box->style()->logicalWidth().isFixed())
         return true;
-    if (cb->isLayoutView())
+    if (box->isLayoutView())
         return true;
-    if (cb->isOutOfFlowPositioned())
+    // 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 (box->isOutOfFlowPositioned())
         return true;
-    if (cb->style()->logicalWidth().isPercent())
-        return logicalWidthIsResolvableFromBlock(cb->containingBlock());
+    if (box->hasOverrideContainingBlockLogicalWidth())
+        return box->overrideContainingBlockContentLogicalWidth() != -1;
+    if (box->style()->logicalWidth().isPercent())
+        return logicalWidthIsResolvable(*box->containingBlock());
 
     return false;
 }
 
 bool LayoutBox::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;
-
-    return LayoutBox::logicalWidthIsResolvableFromBlock(containingBlock());
+    return logicalWidthIsResolvable(*this);
 }
 
 inline static bool percentageLogicalHeightIsResolvable(const LayoutBox* box)
 {
     return LayoutBox::percentageLogicalHeightIsResolvableFromBlock(box->containingBlock(), box->isOutOfFlowPositioned());
 }
 
 bool LayoutBox::percentageLogicalHeightIsResolvableFromBlock(const LayoutBlock* 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 LayoutBlock* cb = containingBlock;
     bool inQuirksMode = cb->document().inQuirksMode();
     while (!cb->isLayoutView() && !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 LayoutBox::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 326 matching lines @@
 }
 
 void LayoutBox::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(displayItemList);
     if (LayerScrollableArea* area = scrollableArea())
         displayItemList->invalidate(area->displayItemClient());
 }
 
 } // namespace blink