[CSS Grid Layout] Fix positioned grid children position and size

Source/core/rendering/RenderBox.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 54 matching lines @@
 
 using namespace HTMLNames;
 
 // Used by flexible boxes when flexing this element and by table cells.
 typedef WTF::HashMap<const RenderBox*, LayoutUnit> OverrideSizeMap;
 
 // Used by grid elements to properly size their grid items.
 // FIXME: Move these into RenderBoxRareData.
 static OverrideSizeMap* gOverrideContainingBlockLogicalHeightMap = 0;
 static OverrideSizeMap* gOverrideContainingBlockLogicalWidthMap = 0;
+static OverrideSizeMap* gOverrideInlineOffsetMap = 0;
+static OverrideSizeMap* gOverrideBlockOffsetMap = 0;
 
 
 // Size of border belt for autoscroll. When mouse pointer in border belt,
 // autoscroll is started.
 static const int autoscrollBeltSize = 20;
 static const unsigned backgroundObscurationTestMaxDepth = 4;
 
 static bool skipBodyBackground(const RenderBox* bodyElementRenderer)
 {
     ASSERT(bodyElementRenderer->isBody());
@@ skipping 11 matching lines @@
     , m_minPreferredLogicalWidth(-1)
     , m_maxPreferredLogicalWidth(-1)
 {
     setIsBox();
 }
 
 void RenderBox::willBeDestroyed()
 {
     clearOverrideSize();
     clearContainingBlockOverrideSize();
+    clearOverrideInlineAndBlockOffests();
 
     RenderBlock::removePercentHeightDescendantIfNeeded(this);
 
     ShapeOutsideInfo::removeInfo(*this);
 
     RenderBoxModelObject::willBeDestroyed();
 }
 
 void RenderBox::removeFloatingOrPositionedChildFromBlockLists()
 {
@@ skipping 888 matching lines @@
         gOverrideContainingBlockLogicalWidthMap->remove(this);
     clearOverrideContainingBlockContentLogicalHeight();
 }
 
 void RenderBox::clearOverrideContainingBlockContentLogicalHeight()
 {
     if (gOverrideContainingBlockLogicalHeightMap)
         gOverrideContainingBlockLogicalHeightMap->remove(this);
 }
 
+LayoutUnit RenderBox::overrideInlineOffset() const
+{
+    ASSERT(hasOverrideInlineOffset());
+    return gOverrideInlineOffsetMap->get(this);
+}
+
+LayoutUnit RenderBox::overrideBlockOffset() const
+{
+    ASSERT(hasOverrideBlockOffset());
+    return gOverrideBlockOffsetMap->get(this);
+}
+
+bool RenderBox::hasOverrideInlineOffset() const
+{
+    return gOverrideInlineOffsetMap && gOverrideInlineOffsetMap->contains(this);
+}
+
+bool RenderBox::hasOverrideBlockOffset() const
+{
+    return gOverrideBlockOffsetMap && gOverrideBlockOffsetMap->contains(this);
+}
+
+void RenderBox::setOverrideInlineOffset(LayoutUnit inlineOffest)
+{
+    if (!gOverrideInlineOffsetMap)
+        gOverrideInlineOffsetMap = new OverrideSizeMap;
+    gOverrideInlineOffsetMap->set(this, inlineOffest);
+}
+
+void RenderBox::setOverrideBlockOffset(LayoutUnit blockOffest)
+{
+    if (!gOverrideBlockOffsetMap)
+        gOverrideBlockOffsetMap = new OverrideSizeMap;
+    gOverrideBlockOffsetMap->set(this, blockOffest);
+}
+
+void RenderBox::clearOverrideInlineAndBlockOffests()
+{
+    if (gOverrideInlineOffsetMap)
+        gOverrideInlineOffsetMap->remove(this);
+    if (gOverrideBlockOffsetMap)
+        gOverrideBlockOffsetMap->remove(this);
+}
+
 LayoutUnit RenderBox::adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const
 {
     LayoutUnit bordersPlusPadding = borderAndPaddingLogicalWidth();
     if (style()->boxSizing() == CONTENT_BOX)
         return width + bordersPlusPadding;
     return std::max(width, bordersPlusPadding);
 }
 
 LayoutUnit RenderBox::adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit height) const
 {
@@ skipping 1586 matching lines @@
 
     // Use viewport as container for top-level fixed-position elements.
     if (style()->position() == FixedPosition && containingBlock->isRenderView()) {
         const RenderView* view = toRenderView(containingBlock);
         if (FrameView* frameView = view->frameView()) {
             LayoutRect viewportRect = frameView->viewportConstrainedVisibleContentRect();
             return containingBlock->isHorizontalWritingMode() ? viewportRect.width() : viewportRect.height();
         }
     }
 
+    if (hasOverrideContainingBlockLogicalWidth())
+        return overrideContainingBlockContentLogicalWidth();
+
     if (containingBlock->isBox())
         return toRenderBox(containingBlock)->clientLogicalWidth();
 
     ASSERT(containingBlock->isRenderInline() && containingBlock->isRelPositioned());
 
     const RenderInline* flow = toRenderInline(containingBlock);
     InlineFlowBox* first = flow->firstLineBox();
     InlineFlowBox* last = flow->lastLineBox();
 
     // If the containing block is empty, return a width of 0.
@@ skipping 20 matching lines @@
 
     // Use viewport as container for top-level fixed-position elements.
     if (style()->position() == FixedPosition && containingBlock->isRenderView()) {
         const RenderView* view = toRenderView(containingBlock);
         if (FrameView* frameView = view->frameView()) {
             LayoutRect viewportRect = frameView->viewportConstrainedVisibleContentRect();
             return containingBlock->isHorizontalWritingMode() ? viewportRect.height() : viewportRect.width();
         }
     }
 
+    if (hasOverrideContainingBlockLogicalHeight())
+        return overrideContainingBlockContentLogicalHeight();
+
     if (containingBlock->isBox()) {
         const RenderBlock* cb = containingBlock->isRenderBlock() ?
             toRenderBlock(containingBlock) : containingBlock->containingBlock();
         return cb->clientLogicalHeight();
     }
 
     ASSERT(containingBlock->isRenderInline() && containingBlock->isRelPositioned());
 
     const RenderInline* flow = toRenderInline(containingBlock);
     InlineFlowBox* first = flow->firstLineBox();
@@ skipping 166 matching lines @@
                                            minValues);
 
         if (computedValues.m_extent < minValues.m_extent) {
             computedValues.m_extent = minValues.m_extent;
             computedValues.m_position = minValues.m_position;
             computedValues.m_margins.m_start = minValues.m_margins.m_start;
             computedValues.m_margins.m_end = minValues.m_margins.m_end;
         }
     }
 
+    if (hasOverrideInlineOffset() && !style()->hasStaticInlinePosition(isHorizontal))

[Julien - ping for review, 2014/12/02 20:46:05]

This adds one hash lookup for every layout with potentially 2 for grid.

To avoid the hash lookup, we could reorganize the code to do at most a single
hash lookup always.

if (!style()->hasStaticInlinePosition(isHorizontal)) {
    // overrideInlineOffset returns 0 (or we should make it to by using a
correct empty HashMap trait value) if we don't have an offset.
    computedValues.m_position += overrideInlineOffset();
}

[Manuel Rego, 2014/12/03 09:48:58]

Nice catch. We can even minimize this more if we check that
the container block is a RenderGrid.
That way we'll only do the hash lookup in the case of grids.

+        computedValues.m_position += overrideInlineOffset();
+
     computedValues.m_extent += bordersPlusPadding;
 }
 
 static void computeLogicalLeftPositionedOffset(LayoutUnit& logicalLeftPos, const RenderBox* child, LayoutUnit logicalWidthValue, const RenderBoxModelObject* containerBlock, LayoutUnit containerLogicalWidth)
 {
     // Deal with differing writing modes here.  Our offset needs to be in the containing block's coordinate space. If the containing block is flipped
     // along this axis, then we need to flip the coordinate.  This can only happen if the containing block is both a flipped mode and perpendicular to us.
     if (containerBlock->isHorizontalWritingMode() != child->isHorizontalWritingMode() && containerBlock->style()->slowIsFlippedBlocksWritingMode()) {
         logicalLeftPos = containerLogicalWidth - logicalWidthValue - logicalLeftPos;
         logicalLeftPos += (child->isHorizontalWritingMode() ? containerBlock->borderRight() : containerBlock->borderBottom());
@@ skipping 290 matching lines @@
                                             minValues);
 
         if (computedValues.m_extent < minValues.m_extent) {
             computedValues.m_extent = minValues.m_extent;
             computedValues.m_position = minValues.m_position;
             computedValues.m_margins.m_before = minValues.m_margins.m_before;
             computedValues.m_margins.m_after = minValues.m_margins.m_after;
         }
     }
 
+    if (hasOverrideBlockOffset() && !style()->hasStaticBlockPosition(isHorizontalWritingMode()))
+        computedValues.m_position += overrideBlockOffset();
+
     // Set final height value.
     computedValues.m_extent += bordersPlusPadding;
 }
 
 static void computeLogicalTopPositionedOffset(LayoutUnit& logicalTopPos, const RenderBox* child, LayoutUnit logicalHeightValue, const RenderBoxModelObject* containerBlock, LayoutUnit containerLogicalHeight)
 {
     // Deal with differing writing modes here.  Our offset needs to be in the containing block's coordinate space. If the containing block is flipped
     // along this axis, then we need to flip the coordinate.  This can only happen if the containing block is both a flipped mode and perpendicular to us.
     if ((child->style()->slowIsFlippedBlocksWritingMode() && child->isHorizontalWritingMode() != containerBlock->isHorizontalWritingMode())
         || (child->style()->slowIsFlippedBlocksWritingMode() != containerBlock->style()->slowIsFlippedBlocksWritingMode() && child->isHorizontalWritingMode() == containerBlock->isHorizontalWritingMode()))
@@ skipping 1273 matching lines @@
 
     setLogicalTop(oldLogicalTop);
     setLogicalWidth(oldLogicalWidth);
     setMarginLeft(oldMarginLeft);
     setMarginRight(oldMarginRight);
 
     return borderBox;
 }
 
 } // namespace blink