LayoutBox::hasDefiniteLogicalHeight() should not consider abspos boxes as definite

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 4319 matching lines @@
         return true;
     if (cb->isDocumentElement() && isOutOfFlowPositioned) {
         // Match the positioned objects behavior, which is that positioned objects will fill their viewport
         // always.  Note we could only hit this case by recurring into computePercentageLogicalHeight on a positioned containing block.
         return true;
     }
 
     return false;
 }
 
 bool LayoutBox::hasDefiniteLogicalHeight() const

[mstensho (USE GERRIT), 2015/04/24 07:22:33]

Note (not an issue that should be handled in this CL):

This may make sense for flexbox and grid (which, after all, are the only
callers), but for regular block layout, it seems strange to consider height:auto
on position:absolute as definite, unless both the top and bottom properties are
non-auto.

Maybe it's just the method names that need to be changed (or add some
documentation).

[Manuel Rego, 2015/04/24 07:35:10]

This is in the spec (http://dev.w3.org/csswg/css-sizing-3/#definite):
"Additionally, the size of the containing block of an absolutely 
positioned element is always definite with respect to that element."

So, if that should work different for regular blocks, it probably needs
to be addressed on the CSS WG first.

[mstensho (USE GERRIT), 2015/04/24 07:40:03]

That's the size of THE CONTAINING BLOCK of an absolutely positioned element. Not
the size of the absolutely positioned element itself. And even then, it's only
considered definite with respect to the abspos element.

[ojan, 2015/04/24 18:14:31]

Yeah, I think the comment in the code below is confused WRT this. This is
querying on the child, not on the containing block.

As to the test case in question, it's not clear to me how to read the spec text
and it's not clear to me what behavior we want. But if we do want to treat
abspos in this way, we'd need to make the if statement below include checks as
to whether the absolutely positioned element's top/bottom are non-auto. If one
or both of them is auto, then the element sizes to it's content (i.e. does not
have a definite size).

 {
     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;
+    if (logicalHeight.isIntrinsicOrAuto())
+        return false;
 
     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 @@
     computedValues.m_margins.m_end = marginEnd();
 
     setLogicalTop(oldLogicalTop);
     setLogicalWidth(oldLogicalWidth);
     setLogicalLeft(oldLogicalLeft);
     setMarginLeft(oldMarginLeft);
     setMarginRight(oldMarginRight);
 }
 
 } // namespace blink