[CSS Grid Layout] Avoid using StyleAdjuster to resolve 'auto' values.

Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 364 matching lines @@
         direction = cssValuePool().createIdentifierValue(CSSValueLeft);
         break;
     case ReflectionRight:
         direction = cssValuePool().createIdentifierValue(CSSValueRight);
         break;
     }
 
     return CSSReflectValue::create(direction.release(), offset.release(), valueForNinePieceImage(reflection->mask(), style));
 }
 
-static ItemPosition resolveAlignmentAuto(ItemPosition position, Node* element)
+static ItemPosition resolveContainerAlignmentAuto(ItemPosition position, const LayoutObject* element)
 {
-    if (position != ItemPositionAuto)
+    if (position != ItemPositionAuto || !element)
         return position;
 
-    return isFlexOrGrid(element) ? ItemPositionStretch : ItemPositionStart;
+    LayoutBlock* container = element->containingBlock();
+    if (container && container->style()->justifyItemsPositionType() == LegacyPosition)
+        return container->style()->justifyItemsPosition();
+
+    return element->style()->isDisplayFlexibleOrGridBox() ? ItemPositionStretch : ItemPositionStart;
+}
+
+static ItemPosition resolveSelfAlignmentAuto(ItemPosition position, OverflowAlignment& overflow, const LayoutObject* element)
+{
+    if (position != ItemPositionAuto || !element || element->isOutOfFlowPositioned())
+        return position;
+
+    LayoutBlock* parent = element->containingBlock();
+    if (!parent)
+        return ItemPositionStart;
+
+    overflow = parent->style()->alignItemsOverflowAlignment();
+    return resolveContainerAlignmentAuto(parent->style()->alignItemsPosition(), parent);
+}
+
+static void resolveContentAlignmentAuto(ContentPosition& position, ContentDistributionType& distribution, const LayoutObject* element)
+{
+    if (position != ContentPositionAuto || distribution != ContentDistributionDefault)
+        return;
+
+    if (element && element->style()->isDisplayFlexibleBox())
+        distribution = ContentDistributionStretch;
+    else
+        position = ContentPositionStart;
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
 {
     RefPtrWillBeRawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
     if (positionType == LegacyPosition)
         result->append(CSSPrimitiveValue::createIdentifier(CSSValueLegacy));
     result->append(CSSPrimitiveValue::create(itemPosition));
     if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(overflowAlignment));
@@ skipping 43 matching lines @@
         RefPtrWillBeRawPtr<CSSValueList> afterSlash = CSSValueList::createSpaceSeparated();
         afterSlash->append(valueForFillSize(currLayer->size(), style));
         afterSlash->append(cssValuePool().createValue(currLayer->origin()));
         afterSlash->append(cssValuePool().createValue(currLayer->clip()));
         list->append(afterSlash);
         ret->append(list);
     }
     return ret.release();
 }
 
-static ContentPosition resolveContentAlignmentAuto(ContentPosition position, ContentDistributionType distribution, Node* element)
-{
-    if (position != ContentPositionAuto || distribution != ContentDistributionDefault)
-        return position;
-
-    bool isFlex = element && element->ensureComputedStyle()
-        && element->ensureComputedStyle()->isDisplayFlexibleBox();
-
-    return isFlex ? ContentPositionFlexStart : ContentPositionStart;
-}
-
 static PassRefPtrWillBeRawPtr<CSSValueList> valueForContentPositionAndDistributionWithOverflowAlignment(ContentPosition position, OverflowAlignment overflowAlignment, ContentDistributionType distribution)
 {
     RefPtrWillBeRawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
     if (distribution != ContentDistributionDefault)
         result->append(CSSPrimitiveValue::create(distribution));
     if (distribution == ContentDistributionDefault || position != ContentPositionAuto)
         result->append(CSSPrimitiveValue::create(position));
     if ((position >= ContentPositionCenter || distribution != ContentDistributionDefault) && overflowAlignment != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(overflowAlignment));
     ASSERT(result->length() > 0);
@@ skipping 1071 matching lines @@
             return list.release();
         }
         return value.release();
     }
     case CSSPropertyDirection:
         return cssValuePool().createValue(style.direction());
     case CSSPropertyDisplay:
         return cssValuePool().createValue(style.display());
     case CSSPropertyEmptyCells:
         return cssValuePool().createValue(style.emptyCells());
-    case CSSPropertyAlignContent:
-        return valueForContentPositionAndDistributionWithOverflowAlignment(resolveContentAlignmentAuto(style.alignContentPosition(), style.alignContentDistribution(), styledNode), style.alignContentOverflowAlignment(), style.alignContentDistribution());
+    case CSSPropertyAlignContent: {
+        ContentPosition position = style.alignContentPosition();
+        ContentDistributionType distribution = style.alignContentDistribution();
+        resolveContentAlignmentAuto(position, distribution, layoutObject);
+        return valueForContentPositionAndDistributionWithOverflowAlignment(position, style.alignContentOverflowAlignment(), distribution);
+    }
     case CSSPropertyAlignItems:
-        return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.alignItemsPosition(), styledNode), style.alignItemsOverflowAlignment(), NonLegacyPosition);
-    case CSSPropertyAlignSelf:
-        return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.alignSelfPosition(), styledNode->parentNode()), style.alignSelfOverflowAlignment(), NonLegacyPosition);
+        return valueForItemPositionWithOverflowAlignment(resolveContainerAlignmentAuto(style.alignItemsPosition(), layoutObject), style.alignItemsOverflowAlignment(), NonLegacyPosition);
+    case CSSPropertyAlignSelf: {
+        OverflowAlignment overflow = style.alignSelfOverflowAlignment();
+        ItemPosition alignSelf = resolveSelfAlignmentAuto(style.alignSelfPosition(), overflow, layoutObject);
+        return valueForItemPositionWithOverflowAlignment(alignSelf, overflow, NonLegacyPosition);
+    }
     case CSSPropertyFlex:
         return valuesForShorthandProperty(flexShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyFlexBasis:
         return zoomAdjustedPixelValueForLength(style.flexBasis(), style);
     case CSSPropertyFlexDirection:
         return cssValuePool().createValue(style.flexDirection());
     case CSSPropertyFlexFlow:
         return valuesForShorthandProperty(flexFlowShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyFlexGrow:
         return cssValuePool().createValue(style.flexGrow());
     case CSSPropertyFlexShrink:
         return cssValuePool().createValue(style.flexShrink());
     case CSSPropertyFlexWrap:
         return cssValuePool().createValue(style.flexWrap());
-    case CSSPropertyJustifyContent:
-        return valueForContentPositionAndDistributionWithOverflowAlignment(resolveContentAlignmentAuto(style.justifyContentPosition(), style.justifyContentDistribution(), styledNode), style.justifyContentOverflowAlignment(), style.justifyContentDistribution());
+    case CSSPropertyJustifyContent: {
+        ContentPosition position = style.justifyContentPosition();
+        ContentDistributionType distribution = style.justifyContentDistribution();
+        resolveContentAlignmentAuto(position, distribution, layoutObject);
+        return valueForContentPositionAndDistributionWithOverflowAlignment(position, style.justifyContentOverflowAlignment(), distribution);
+    }
     case CSSPropertyOrder:
         return cssValuePool().createValue(style.order(), CSSPrimitiveValue::CSS_NUMBER);
     case CSSPropertyFloat:
         if (style.display() != NONE && style.hasOutOfFlowPosition())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return cssValuePool().createValue(style.floating());
     case CSSPropertyFont: {
         RefPtrWillBeRawPtr<CSSFontValue> computedFont = CSSFontValue::create();
         computedFont->style = valueForFontStyle(style);
         computedFont->variant = valueForFontVariant(style);
@@ skipping 115 matching lines @@
         return cssValuePool().createValue(style.highlight(), CSSPrimitiveValue::CSS_STRING);
     case CSSPropertyWebkitHyphenateCharacter:
         if (style.hyphenationString().isNull())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
         return cssValuePool().createValue(style.hyphenationString(), CSSPrimitiveValue::CSS_STRING);
     case CSSPropertyImageRendering:
         return CSSPrimitiveValue::create(style.imageRendering());
     case CSSPropertyIsolation:
         return cssValuePool().createValue(style.isolation());
     case CSSPropertyJustifyItems:
-        return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.justifyItemsPosition(), styledNode), style.justifyItemsOverflowAlignment(), style.justifyItemsPositionType());
-    case CSSPropertyJustifySelf:
-        return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.justifySelfPosition(), styledNode->parentNode()), style.justifySelfOverflowAlignment(), NonLegacyPosition);
+        return valueForItemPositionWithOverflowAlignment(resolveContainerAlignmentAuto(style.justifyItemsPosition(), layoutObject), style.justifyItemsOverflowAlignment(), style.justifyItemsPositionType());
+    case CSSPropertyJustifySelf: {
+        OverflowAlignment overflow = style.justifySelfOverflowAlignment();
+        ItemPosition justifySelf = resolveSelfAlignmentAuto(style.justifySelfPosition(), overflow, layoutObject);
+        return valueForItemPositionWithOverflowAlignment(justifySelf, overflow, NonLegacyPosition);
+    }
     case CSSPropertyLeft:
         return valueForPositionOffset(style, CSSPropertyLeft, layoutObject);
     case CSSPropertyLetterSpacing:
         if (!style.letterSpacing())
             return cssValuePool().createIdentifierValue(CSSValueNormal);
         return zoomAdjustedPixelValue(style.letterSpacing(), style);
     case CSSPropertyWebkitLineClamp:
         if (style.lineClamp().isNone())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return cssValuePool().createValue(style.lineClamp().value(), style.lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
@@ skipping 862 matching lines @@
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 }