[css-align] New CSS Value 'normal' for Self Alignment

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 190 matching lines @@
 int LayoutFlexibleBox::baselinePosition(FontBaseline, bool, LineDirectionMode direction, LinePositionMode mode) const
 {
     DCHECK_EQ(mode, PositionOnContainingLine);
     int baseline = firstLineBoxBaseline();
     if (baseline == -1)
         baseline = synthesizedBaselineFromContentBox(*this, direction);
 
     return beforeMarginInLineDirection(direction) + baseline;
 }
 
-static const StyleContentAlignmentData& normalValueBehavior()
+static const StyleContentAlignmentData& contentAlignmentNormalBehavior()
 {
     // The justify-content property applies along the main axis, but since flexing
     // in the main axis is controlled by flex, stretch behaves as flex-start (ignoring
     // the specified fallback alignment, if any).
     // https://drafts.csswg.org/css-align/#distribution-flex
     static const StyleContentAlignmentData normalBehavior = {ContentPositionNormal, ContentDistributionStretch};
     return normalBehavior;
 }
 
 int LayoutFlexibleBox::firstLineBoxBaseline() const
@@ skipping 103 matching lines @@
         return flexDirection == (style()->isLeftToRightDirection() ? FlowRowReverse : FlowRow);
     return flexDirection == FlowColumnReverse;
 }
 
 void LayoutFlexibleBox::removeChild(LayoutObject* child)
 {
     LayoutBlock::removeChild(child);
     m_intrinsicSizeAlongMainAxis.remove(child);
 }
 
+// TODO (lajava): Is this function still needed ? Every time the flex container's align-items value changes we
+// propagate the diff to its children (see ComputedStyle::stylePropagationDiff).
 void LayoutFlexibleBox::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBlock::styleDidChange(diff, oldStyle);
 
     if (oldStyle && oldStyle->alignItemsPosition() == ItemPositionStretch && diff.needsFullLayout()) {
         // Flex items that were previously stretching need to be relayed out so we can compute new available cross axis space.
         // This is only necessary for stretching since other alignment values don't change the size of the box.
         for (LayoutBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
-            ItemPosition previousAlignment = ComputedStyle::resolveAlignment(*oldStyle, child->styleRef(), ItemPositionStretch);
-            if (previousAlignment == ItemPositionStretch && previousAlignment != ComputedStyle::resolveAlignment(styleRef(), child->styleRef(), ItemPositionStretch))
+            ItemPosition previousAlignment = child->styleRef().resolvedAlignSelf(selfAlignmentNormalBehavior(), oldStyle).position();
+            if (previousAlignment == ItemPositionStretch && previousAlignment != child->styleRef().resolvedAlignSelf(selfAlignmentNormalBehavior(), style()).position())
                 child->setChildNeedsLayout(MarkOnlyThis);
         }
     }
 }
 
 void LayoutFlexibleBox::layoutBlock(bool relayoutChildren)
 {
     DCHECK(needsLayout());
 
     if (!relayoutChildren && simplifiedLayout())
@@ skipping 1036 matching lines @@
         if (justifyContentDistribution == ContentDistributionSpaceAround)
             return availableFreeSpace / numberOfChildren;
     }
     return LayoutUnit();
 }
 
 static LayoutUnit alignmentOffset(LayoutUnit availableFreeSpace, ItemPosition position, LayoutUnit ascent, LayoutUnit maxAscent, bool isWrapReverse)
 {
     switch (position) {
     case ItemPositionAuto:
+    case ItemPositionNormal:
         NOTREACHED();
         break;
     case ItemPositionStretch:
         // Actual stretching must be handled by the caller.
         // Since wrap-reverse flips cross start and cross end, stretch children should be aligned with the cross end.
         // This matters because applyStretchAlignment doesn't always stretch or stretch fully (explicit cross size given,
         // or stretching constrained by max-height/max-width).
         // For flex-start and flex-end this is handled by alignmentForChild().
         if (isWrapReverse)
             return availableFreeSpace;
@@ skipping 28 matching lines @@
     if (hasOrthogonalFlow(child))
         child.setOverrideLogicalContentHeight(childPreferredSize);
     else
         child.setOverrideLogicalContentWidth(childPreferredSize);
 }
 
 LayoutUnit LayoutFlexibleBox::staticMainAxisPositionForPositionedChild(const LayoutBox& child)
 {
     const LayoutUnit availableSpace = mainAxisContentExtent(contentLogicalHeight()) - mainAxisExtentForChild(child);
 
-    ContentPosition position = styleRef().resolvedJustifyContentPosition(normalValueBehavior());
-    ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(normalValueBehavior());
+    ContentPosition position = styleRef().resolvedJustifyContentPosition(contentAlignmentNormalBehavior());
+    ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior());
     LayoutUnit offset = initialJustifyContentOffset(availableSpace, position, distribution, 1);
     if (styleRef().flexDirection() == FlowRowReverse || styleRef().flexDirection() == FlowColumnReverse)
         offset = availableSpace - offset;
     return offset;
 }
 
 LayoutUnit LayoutFlexibleBox::staticCrossAxisPositionForPositionedChild(const LayoutBox& child)
 {
     LayoutUnit availableSpace = crossAxisContentExtent() - crossAxisExtentForChild(child);
     return alignmentOffset(availableSpace, alignmentForChild(child), LayoutUnit(), LayoutUnit(), styleRef().flexWrap() == FlexWrapReverse);
@@ skipping 49 matching lines @@
     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);
+    ItemPosition align = child.styleRef().resolvedAlignSelf(selfAlignmentNormalBehavior(), child.isAnonymous() ? style() : nullptr).position();
+    DCHECK(align != ItemPositionAuto && align != ItemPositionNormal);
 
     if (align == ItemPositionBaseline && hasOrthogonalFlow(child))
         align = ItemPositionFlexStart;
 
     if (style()->flexWrap() == FlexWrapReverse) {
         if (align == ItemPositionFlexStart)
             align = ItemPositionFlexEnd;
         else if (align == ItemPositionFlexEnd)
             align = ItemPositionFlexStart;
     }
@@ skipping 69 matching lines @@
 
 EOverflow LayoutFlexibleBox::crossAxisOverflowForChild(const LayoutBox& child) const
 {
     if (isHorizontalFlow())
         return child.styleRef().overflowY();
     return child.styleRef().overflowX();
 }
 
 void LayoutFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, LayoutUnit availableFreeSpace, bool relayoutChildren, SubtreeLayoutScope& layoutScope, Vector<LineContext>& lineContexts)
 {
-    ContentPosition position = styleRef().resolvedJustifyContentPosition(normalValueBehavior());
-    ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(normalValueBehavior());
+    ContentPosition position = styleRef().resolvedJustifyContentPosition(contentAlignmentNormalBehavior());
+    ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior());
 
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, position, distribution, numberOfChildrenForJustifyContent);
     if (style()->flexDirection() == FlowRowReverse && shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 
     LayoutUnit totalMainExtent = mainAxisExtent();
     if (!shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
@@ skipping 80 matching lines @@
     }
 
     if (m_numberOfInFlowChildrenOnFirstLine == -1)
         m_numberOfInFlowChildrenOnFirstLine = seenInFlowPositionedChildren;
     lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent, children.size(), maxAscent));
     crossAxisOffset += maxChildCrossAxisExtent;
 }
 
 void LayoutFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
 {
-    ContentPosition position = styleRef().resolvedJustifyContentPosition(normalValueBehavior());
-    ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(normalValueBehavior());
+    ContentPosition position = styleRef().resolvedJustifyContentPosition(contentAlignmentNormalBehavior());
+    ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior());
 
     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
     // starting from the end of the flexbox. We also don't need to layout anything since we're
     // 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;
@@ skipping 41 matching lines @@
             return availableFreeSpace / numberOfLines;
     }
     return LayoutUnit();
 }
 
 void LayoutFlexibleBox::alignFlexLines(Vector<LineContext>& lineContexts)
 {
     if (!lineContexts.size())
         return;
 
-    ContentPosition position = styleRef().resolvedAlignContentPosition(normalValueBehavior());
-    ContentDistributionType distribution = styleRef().resolvedAlignContentDistribution(normalValueBehavior());
+    ContentPosition position = styleRef().resolvedAlignContentPosition(contentAlignmentNormalBehavior());
+    ContentDistributionType distribution = styleRef().resolvedAlignContentDistribution(contentAlignmentNormalBehavior());
 
     // If we have a single line flexbox the line height is all the available space.
     // For flex-direction: row, this means we need to use the height, so we do this after calling updateLogicalHeight.
     if (!isMultiline()) {
         lineContexts[0].crossAxisExtent = crossAxisContentExtent();
         return;
     }
 
     if (position == ContentPositionFlexStart)
         return;
@@ skipping 140 matching lines @@
             DCHECK(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 } // namespace blink