[CSS Grid Layout] Don't resolve align-self and justify-self properties

Source/core/rendering/RenderFlexibleBox.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 178 matching lines @@
         return baseline;
 
     int marginAscent = direction == HorizontalLine ? marginTop() : marginRight();
     return synthesizedBaselineFromContentBox(this, direction) + marginAscent;
 }
 
 static ItemPosition resolveAlignment(const RenderStyle* parentStyle, const RenderStyle* childStyle)
 {
     ItemPosition align = childStyle->alignSelf();
     if (align == ItemPositionAuto)
-        align = (parentStyle->alignItems() == ItemPositionAuto) ? ItemPositionStretch : parentStyle->alignItems();
+        align = parentStyle->alignItems();

[esprehn, 2014/08/19 00:56:33]

What if your parent is also auto? This doesn't seem like it can work.

[jfernandez, 2014/08/19 21:39:18]

It shouldn't be; the 'align-items' property value is resolved during the
cascade. It was my previous patch which forced stretch for the cases where
parent was 'auto', but I've decided to go back to the original code to detect
incorrect cases. Actually. there is an ASSERTION to prevent 'auto' values during
the layout.

[esprehn, 2014/09/03 21:45:28]

That doesn't make sense, if childStyle->alignSelf() can be Auto here, why can't
parentStyle() alignItems() be Auto?

[jfernandez, 2014/09/03 22:27:49]

Well, it's not that it can't, but it shouldn't. Current spec states that "auto"
value must be resolved (for all the alignment related properties) to either
'start' or 'stretch' depending on different aspects. The purpose of align-items
and justify-items is to determine the default/auto value for align-self and
justify-self respectively on the children.  Any 'auto' value on the xxx-items
properties will be resolved during the cascade. This patch precisely avoids
doing the same with the xxx-self  properties because many Renders alter the
xxx-items value during the layout phase, assuming that the corresponding
xxx-self properties will be update accordingly. 

It's possible, though, that some Render objects set "auto" to the xxx-items
property during the layout, or at any other stage after the cascade. This should
not be allowed since "auto" is not a valid value for any of those properties. We
could keep current behavior and default to 'stretch' (for flex and grid) if
'auto' is set on the xxx-items property. I thought that using the ASSERT we
could detect some incorrect logic out there.

     return align;
 }
 
 void RenderFlexibleBox::removeChild(RenderObject* child)
 {
     RenderBlock::removeChild(child);
     m_intrinsicSizeAlongMainAxis.remove(child);
 }
 
 void RenderFlexibleBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
@@ skipping 1099 matching lines @@
                 break;
             }
             case ItemPositionLastBaseline:
             case ItemPositionSelfStart:
             case ItemPositionSelfEnd:
             case ItemPositionStart:
             case ItemPositionEnd:
             case ItemPositionLeft:
             case ItemPositionRight:
                 // FIXME: File a bug about implementing that. The extended grammar
-                // is not enabled by default so we shouldn't hit this codepath.
+                // is not implemented yet so we default to "stretch" for now.
+                break;
+            default:
                 ASSERT_NOT_REACHED();
                 break;
             }
         }
         minMarginAfterBaselines.append(minMarginAfterBaseline);
     }
 
     if (style()->flexWrap() != FlexWrapReverse)
         return;
 
@@ skipping 67 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(child, newOffset - originalOffset);
         }
     }
 }
 
 }