[css-flexbox] Implement new abspos handling

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

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1296 matching lines @@
 }
 
 void LayoutFlexibleBox::setOverrideMainAxisSizeForChild(LayoutBox& child, LayoutUnit childPreferredSize)
 {
     if (hasOrthogonalFlow(child))
         child.setOverrideLogicalContentHeight(childPreferredSize - child.borderAndPaddingLogicalHeight());
     else
         child.setOverrideLogicalContentWidth(childPreferredSize - child.borderAndPaddingLogicalWidth());
 }
 
-void LayoutFlexibleBox::prepareChildForPositionedLayout(LayoutBox& child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset, PositionedLayoutMode layoutMode)
+LayoutUnit LayoutFlexibleBox::staticMainAxisPositionForPositionedChild(const LayoutBox& child)
+{
+    const LayoutUnit mainAxisExtent = mainAxisContentExtent(contentLogicalHeight());
+
+    ContentPosition position = styleRef().resolvedJustifyContentPosition(normalValueBehavior());
+    ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(normalValueBehavior());
+    // TODO(cbiesinger): Support the other values for these properties (we're not shipping them yet)
+    // TODO(cbiesinger): what should row-reverse/column-reverse do? https://lists.w3.org/Archives/Public/www-style/2016Apr/0387.html
+    switch (position) {
+    case ContentPositionFlexEnd:
+        return (mainAxisExtent - mainAxisExtentForChild(child));
+    case ContentPositionCenter:
+        return (mainAxisExtent - mainAxisExtentForChild(child)) / 2;
+    default:
+            break;
+    }
+    switch (distribution) {

[eae, 2016/04/25 02:37:28]

Probably easier to use a regular if statement here.

if (distribution == ContentDistributionSpaceAround)
  return (mainAxisExtent - mainAxisExtentForChild(child)) / 2;

[cbiesinger, 2016/04/26 18:21:56]

I realized I can simplify this by reusing code, so this is quite different now.

Can't do it easily for cross axis though :(

+    case ContentDistributionSpaceAround:
+        return (mainAxisExtent - mainAxisExtentForChild(child)) / 2;
+    default:
+        break;
+    }
+    return LayoutUnit();
+}
+
+LayoutUnit LayoutFlexibleBox::staticCrossAxisPositionForPositionedChild(const LayoutBox& child)
+{
+    switch (alignmentForChild(child)) {
+    case ItemPositionAuto:
+    case ItemPositionStretch:
+        return LayoutUnit(); // static position is unaffected by stretching
+    case ItemPositionBaseline:
+    case ItemPositionLastBaseline:
+        return LayoutUnit();
+    case ItemPositionCenter:
+        return (crossAxisContentExtent() - crossAxisExtentForChild(child)) / 2;
+    case ItemPositionStart:
+    case ItemPositionFlexStart:
+        // These are equivalent here because alignmentForChild maps
+        // flex-start to flex-end when they would be different.
+        return LayoutUnit();
+    case ItemPositionEnd:
+    case ItemPositionFlexEnd:
+        return (crossAxisContentExtent() - crossAxisExtentForChild(child));
+    case ItemPositionSelfStart:
+        // TODO(cbiesinger): Support this value (not shipped yet)
+        return LayoutUnit();
+    case ItemPositionSelfEnd:
+        // TODO(cbiesinger): Support this value (not shipped yet)
+        return LayoutUnit();
+    case ItemPositionLeft:
+        if (!isHorizontalFlow())
+            return LayoutUnit();
+        if (styleRef().isLeftToRightDirection())
+            return LayoutUnit();
+        return (crossAxisContentExtent() - crossAxisExtentForChild(child));
+    case ItemPositionRight:
+        if (!isHorizontalFlow())
+            return LayoutUnit();
+        if (!styleRef().isLeftToRightDirection())
+            return LayoutUnit();
+        return (crossAxisContentExtent() - crossAxisExtentForChild(child));
+    }
+    return LayoutUnit();
+}
+
+LayoutUnit LayoutFlexibleBox::staticInlinePositionForPositionedChild(const LayoutBox& child)
+{
+    LayoutUnit staticInlineOffset = flowAwareBorderStart() + flowAwarePaddingStart();
+    if (isColumnFlow())

[eae, 2016/04/25 02:37:28]

(optional) There is a bit of code duplication here, how about having a helper
for getting the resolvedAxisPosition or using an iif-statement?

LayoutUnit LayoutFlexibleBox::resolvedAxisPosition(...)
{
  return isColumnFlow()
    ? staticCrossAxisPositionForPositionedChild(child)
    : staticMainAxisPositionForPositionedChild(child);
}

LayoutFlexibleBox::staticInlinePositionForPositionedChild(...)
{
  ...
  return staticInlineOffset + resolvedAxisPosition(child);
}


or

return staticInlineOffset + isColumnFlow()
  ? staticCrossAxisPositionForPositionedChild(child)
  : staticMainAxisPositionForPositionedChild(child);



Again, this is just a suggestion and only do it if you think it makes it simpler
or reduces code duplication.

[cbiesinger, 2016/04/26 18:21:56]

I like the second idea, thanks! Changed, modulo some parentheses required by the
C++ grammar (thanks clang for pointing that out)

+        return staticInlineOffset + staticCrossAxisPositionForPositionedChild(child);
+    return staticInlineOffset + staticMainAxisPositionForPositionedChild(child);
+}
+
+LayoutUnit LayoutFlexibleBox::staticBlockPositionForPositionedChild(const LayoutBox& child)
+{
+    LayoutUnit staticBlockOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
+    if (isColumnFlow())
+        return staticBlockOffset + staticMainAxisPositionForPositionedChild(child);
+    return staticBlockOffset + staticCrossAxisPositionForPositionedChild(child);
+}
+
+bool LayoutFlexibleBox::setStaticPositionForPositionedLayout(LayoutBox& child)
+{
+    bool positionChanged = false;
+    PaintLayer* childLayer = child.layer();
+    if (child.styleRef().hasStaticInlinePosition(styleRef().isHorizontalWritingMode())) {
+        LayoutUnit inlinePosition = staticInlinePositionForPositionedChild(child);
+        if (childLayer->staticInlinePosition() != inlinePosition) {
+            childLayer->setStaticInlinePosition(inlinePosition);
+            positionChanged = true;
+        }
+    }
+    if (child.styleRef().hasStaticBlockPosition(styleRef().isHorizontalWritingMode())) {
+        LayoutUnit blockPosition = staticBlockPositionForPositionedChild(child);
+        if (childLayer->staticBlockPosition() != blockPosition) {
+            childLayer->setStaticBlockPosition(blockPosition);
+            positionChanged = true;
+        }
+    }
+    return positionChanged;
+}
+
+void LayoutFlexibleBox::prepareChildForPositionedLayout(LayoutBox& child)
 {
     ASSERT(child.isOutOfFlowPositioned());
     child.containingBlock()->insertPositionedObject(&child);
     PaintLayer* childLayer = child.layer();
-    LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
-    if (layoutMode == FlipForRowReverse && style()->flexDirection() == FlowRowReverse)
-        inlinePosition = mainAxisExtent() - mainAxisOffset;
-    childLayer->setStaticInlinePosition(inlinePosition);
+    LayoutUnit staticInlinePosition = flowAwareBorderStart() + flowAwarePaddingStart();
+    if (childLayer->staticInlinePosition() != staticInlinePosition) {
+        childLayer->setStaticInlinePosition(staticInlinePosition);
+        if (child.style()->hasStaticInlinePosition(style()->isHorizontalWritingMode()))
+            child.setChildNeedsLayout(MarkOnlyThis);
+    }
 
-    LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
+    LayoutUnit staticBlockPosition = flowAwareBorderBefore() + flowAwarePaddingBefore();
     if (childLayer->staticBlockPosition() != staticBlockPosition) {
         childLayer->setStaticBlockPosition(staticBlockPosition);
         if (child.style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
             child.setChildNeedsLayout(MarkOnlyThis);
     }
 }
 
 ItemPosition LayoutFlexibleBox::alignmentForChild(const LayoutBox& child) const
 {
     ItemPosition align = ComputedStyle::resolveAlignment(styleRef(), child.styleRef(), ItemPositionStretch);
@@ skipping 101 matching lines @@
 
     LayoutUnit totalMainExtent = mainAxisExtent();
     LayoutUnit maxAscent, maxDescent; // Used when align-items: baseline.
     LayoutUnit maxChildCrossAxisExtent;
     size_t seenInFlowPositionedChildren = 0;
     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
     for (size_t i = 0; i < children.size(); ++i) {
         LayoutBox* child = children[i];
 
         if (child->isOutOfFlowPositioned()) {
-            prepareChildForPositionedLayout(*child, mainAxisOffset, crossAxisOffset, FlipForRowReverse);
+            prepareChildForPositionedLayout(*child);
             continue;
         }
 
         // FIXME Investigate if this can be removed based on other flags. crbug.com/370010
         child->setMayNeedPaintInvalidation();
 
         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(*child);
         setOverrideMainAxisSizeForChild(*child, childPreferredSize);
         if (childPreferredSize != mainAxisExtentForChild(*child)) {
             child->setChildNeedsLayout(MarkOnlyThis);
@@ skipping 77 matching lines @@
     // just moving the children to a new position.
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
     mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, position, distribution, numberOfChildrenForJustifyContent);
     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 
     size_t seenInFlowPositionedChildren = 0;
     for (size_t i = 0; i < children.size(); ++i) {
         LayoutBox* child = children[i];
 
-        if (child->isOutOfFlowPositioned()) {
-            child->layer()->setStaticBlockPosition(mainAxisOffset);
+        if (child->isOutOfFlowPositioned())
             continue;
-        }
+
         mainAxisOffset -= mainAxisExtentForChild(*child) + flowAwareMarginEndForChild(*child);
 
         setFlowAwareLocationForChild(*child, LayoutPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(*child)));
 
         mainAxisOffset -= flowAwareMarginStartForChild(*child);
 
         ++seenInFlowPositionedChildren;
         if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
             mainAxisOffset -= justifyContentSpaceBetweenChildren(availableFreeSpace, distribution, numberOfChildrenForJustifyContent);
     }
@@ skipping 56 matching lines @@
 
         if (distribution == ContentDistributionStretch && availableCrossAxisSpace > 0)
             lineContexts[lineNumber].crossAxisExtent += availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size());
 
         lineOffset += alignContentSpaceBetweenChildren(availableCrossAxisSpace, distribution, lineContexts.size());
     }
 }
 
 void LayoutFlexibleBox::adjustAlignmentForChild(LayoutBox& child, LayoutUnit delta)
 {
-    if (child.isOutOfFlowPositioned()) {
-        LayoutUnit staticInlinePosition = child.layer()->staticInlinePosition();
-        LayoutUnit staticBlockPosition = child.layer()->staticBlockPosition();
-        LayoutUnit mainAxis = isColumnFlow() ? staticBlockPosition : staticInlinePosition;
-        LayoutUnit crossAxis = isColumnFlow() ? staticInlinePosition : staticBlockPosition;
-        crossAxis += delta;
-        prepareChildForPositionedLayout(child, mainAxis, crossAxis, NoFlipForRowReverse);
+    if (child.isOutOfFlowPositioned())
         return;
-    }
 
     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(LayoutUnit(), delta));
 }
 
 void LayoutFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts)
 {
     // Keep track of the space between the baseline edge and the after edge of the box for each line.
     Vector<LayoutUnit> minMarginAfterBaselines;
 
     LayoutBox* child = m_orderIterator.first();
@@ skipping 139 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 } // namespace blink