Change CSS containment should invalidate layout

third_party/WebKit/Source/core/layout/LayoutBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
  * License as published by the Free Software Foundation; either
@@ skipping 127 matching lines @@
     LayoutBox::willBeDestroyed();
 }
 
 void LayoutBlock::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)
 {
     const ComputedStyle* oldStyle = style();
 
     setIsAtomicInlineLevel(newStyle.isDisplayInlineType());
 
     if (oldStyle && parent()) {
-        bool oldHasTransformRelatedProperty = oldStyle->hasTransformRelatedProperty();
-        bool newHasTransformRelatedProperty = newStyle.hasTransformRelatedProperty();
-        bool oldStyleIsContainer = oldStyle->position() != StaticPosition || oldHasTransformRelatedProperty;
+        bool oldStyleContainsFixedPosition = oldStyle->canContainFixedPositionObjects();
+        bool oldStyleContainsAbsolutePosition = oldStyleContainsFixedPosition || oldStyle->canContainAbsolutePositionObjects();
+        bool newStyleContainsFixedPosition = newStyle.canContainFixedPositionObjects();
+        bool newStyleContainsAbsolutePosition = newStyleContainsFixedPosition || newStyle.canContainAbsolutePositionObjects();
 
-        if (oldStyleIsContainer && (newStyle.position() == StaticPosition || (oldHasTransformRelatedProperty && !newHasTransformRelatedProperty))) {
+        if ((oldStyleContainsFixedPosition && !newStyleContainsFixedPosition)
+            || (oldStyleContainsAbsolutePosition && !newStyleContainsAbsolutePosition)) {
             // Clear our positioned objects list. Our absolute and fixed positioned descendants will be
             // inserted into our containing block's positioned objects list during layout.
             removePositionedObjects(nullptr, NewContainingBlock);
-        } else if (!oldStyleIsContainer && (newStyle.position() != StaticPosition || newHasTransformRelatedProperty)) {
+        }
+        if (!oldStyleContainsAbsolutePosition && newStyleContainsAbsolutePosition) {
             // Remove our absolutely positioned descendants from their current containing block.
             // They will be inserted into our positioned objects list during layout.
             if (LayoutBlock* cb = containingBlockForAbsolutePosition())
                 cb->removePositionedObjects(this, NewContainingBlock);
         }
-        if (!oldHasTransformRelatedProperty && newHasTransformRelatedProperty) {
+        if (!oldStyleContainsFixedPosition && newStyleContainsFixedPosition) {
             // Remove our fixed positioned descendants from their current containing block.
             // They will be inserted into our positioned objects list during layout.
             if (LayoutBlock* cb = containerForFixedPosition())
                 cb->removePositionedObjects(this, NewContainingBlock);
         }
     }
 
     LayoutBox::styleWillChange(diff, newStyle);
 }
 
@@ skipping 14 matching lines @@
 }
 
 void LayoutBlock::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBox::styleDidChange(diff, oldStyle);
 
     const ComputedStyle& newStyle = styleRef();
 
     if (oldStyle && parent()) {
         if (oldStyle->position() != newStyle.position() && newStyle.position() != StaticPosition) {
-            // Remove our absolute and fixed positioned descendants from their new containing block,
-            // in case containingBlock() changes by the change to the position property.
-            // See styleWillChange() for other cases.
+            // In LayoutObject::styleWillChange() we already removed ourself from our old containing
+            // block's positioned descendant list, and we will be inserted to the new containing
+            // block's list during layout. However the positioned descendant layout logic assumes
+            // layout objects to obey parent-child order in the list. Remove our descendants here
+            // so they will be re-inserted after us.
             if (LayoutBlock* cb = containingBlock())
                 cb->removePositionedObjects(this, NewContainingBlock);
         }
     }
 
     if (TextAutosizer* textAutosizer = document().textAutosizer())
         textAutosizer->record(this);
 
     propagateStyleToAnonymousChildren();
 
@@ skipping 1633 matching lines @@
         for (TrackedLayoutBoxListHashSet::const_iterator it = positionedDescendantSet->begin(); it != end; ++it) {
             LayoutBox* currBox = *it;
             ASSERT(!currBox->needsLayout());
         }
     }
 }
 
 #endif
 
 } // namespace blink