Clear box from percentage descendants when it is split off from the ancestor

third_party/WebKit/Source/core/layout/LayoutBox.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 74 matching lines @@
 
 
 // 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;
 
 struct SameSizeAsLayoutBox : public LayoutBoxModelObject {
     LayoutRect frameRect;
     LayoutUnit intrinsicContentLogicalHeight;
     LayoutRectOutsets marginBoxOutsets;

[mstensho (USE GERRIT), 2016/01/21 19:12:33]

What's this? Please submit master rebases and your changes as separate patch
sets, so I can more easily diff each patch set.

     LayoutUnit preferredLogicalWidth[2];
     void* pointers[3];
 };
 
 static_assert(sizeof(LayoutBox) == sizeof(SameSizeAsLayoutBox), "LayoutBox should stay small");
 
 LayoutBox::LayoutBox(ContainerNode* node)
     : LayoutBoxModelObject(node)
     , m_intrinsicContentLogicalHeight(-1)
     , m_minPreferredLogicalWidth(-1)
@@ skipping 4557 matching lines @@
         // Because we may have added some sections with already computed column structures, we need to
         // sync the table structure with them now. This avoids crashes when adding new cells to the table.
         toLayoutTable(box)->forceSectionsRecalc();
     } else if (box->isTableSection()) {
         toLayoutTableSection(box)->setNeedsCellRecalc();
     }
 
     box->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
 }
 
+static bool collapseIfWillBecomeLoneAnonymousBlock(LayoutBox* child)
+{
+    if (!child->isAnonymousBlock())
+        return false;
+    LayoutBlock* childBlock = toLayoutBlock(child);
+    if (childBlock->beingDestroyed())
+        return false;
+    // We're splitting from our previousSibling().

[mstensho (USE GERRIT), 2016/01/21 19:12:33]

It's not lone if it has a previousSibling(). Please add a test, or at least an
assertion that previousSibling() is NULL.

[rhogan, 2016/01/24 12:31:37]

No, but it's about to split from the previousSibling so it will become a lone
anonymous block. Test 2 covers this.

[mstensho (USE GERRIT), 2016/01/25 09:17:07]

That's making an assumption about what the caller is doing. If we want to do
that, maybe skip the childBlock->beingDestroyed() check as well? And maybe just
put the code inside splitAnonymousBoxesAroundChild(), since we're making scary
assumptions anyway.

+    if (child->nextSibling() || childBlock->continuation())
+        return false;
+    LayoutBlock* parent = child->containingBlock();
+    if (parent->isRubyBase() || parent->isRubyRun())
+        return false;
+    LayoutBlock::collapseAnonymousBlockChild(parent, childBlock);
+    return true;
+}
+
 LayoutObject* LayoutBox::splitAnonymousBoxesAroundChild(LayoutObject* beforeChild)
 {
     bool didSplitParentAnonymousBoxes = false;
 
     while (beforeChild->parent() != this) {
         LayoutBox* boxToSplit = toLayoutBox(beforeChild->parent());
         if (boxToSplit->slowFirstChild() != beforeChild && boxToSplit->isAnonymous()) {
             didSplitParentAnonymousBoxes = true;
 
             // We have to split the parent box into two boxes and move children
             // from |beforeChild| to end into the new post box.
             LayoutBox* postBox = boxToSplit->createAnonymousBoxWithSameTypeAs(this);
             postBox->setChildrenInline(boxToSplit->childrenInline());
             LayoutBox* parentBox = toLayoutBox(boxToSplit->parent());
             // We need to invalidate the |parentBox| before inserting the new node
             // so that the table paint invalidation logic knows the structure is dirty.
             // See for example LayoutTableCell:clippedOverflowRectForPaintInvalidation.
             markBoxForRelayoutAfterSplit(parentBox);
             parentBox->virtualChildren()->insertChildNode(parentBox, postBox, boxToSplit->nextSibling());
             boxToSplit->moveChildrenTo(postBox, beforeChild, 0, true);
 
             markBoxForRelayoutAfterSplit(boxToSplit);
             markBoxForRelayoutAfterSplit(postBox);
 
+            // Splitting the box means the left side of the container chain will lose any percent height descendants
+            // below |postBox| in the right hand side.
+            if (LayoutBlock::hasPercentHeightContainerMap())
+                LayoutBlock::clearPercentHeightDescendantsFrom(postBox);
+
             beforeChild = postBox;
         } else {
-            beforeChild = boxToSplit;
+            // If a lone anonymous block is now unnecessary collapse it away - this will make beforeChild's current
+            // grandparent its parent so no need to set it before looping.

[mstensho (USE GERRIT), 2016/01/21 19:12:33]

Thanks for explaining!

+            if (!collapseIfWillBecomeLoneAnonymousBlock(boxToSplit))
+                beforeChild = boxToSplit;
         }
     }
 
     if (didSplitParentAnonymousBoxes)
         markBoxForRelayoutAfterSplit(this);
 
     ASSERT(beforeChild->parent() == this);
     return beforeChild;
 }
 
@@ skipping 194 matching lines @@
 }
 
 void LayoutBox::clearPreviousPaintInvalidationRects()
 {
     LayoutBoxModelObject::clearPreviousPaintInvalidationRects();
     if (PaintLayerScrollableArea* scrollableArea = this->scrollableArea())
         scrollableArea->clearPreviousPaintInvalidationRects();
 }
 
 } // namespace blink