Invalidate objects when containing block changed

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 211 matching lines @@
 
     LayoutBox::willBeDestroyed();
 }
 
 void LayoutBlock::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)
 {
     const ComputedStyle* oldStyle = style();
 
     setReplaced(newStyle.isDisplayInlineType());
 
-    if (oldStyle && parent()) {
+    if (oldStyle && parent() && !isLayoutView()) {

[chrishtr, 2015/10/30 18:28:18]

Why this change?

[Xianzhu, 2015/10/30 19:15:28]

Added this because I thought layout view never changes its relationship with its
contained positioned objects because of its style change. The check seems
unnecessary because LayoutView never changes position or transformed related
properties.

Reverted.

         bool oldHasTransformRelatedProperty = oldStyle->hasTransformRelatedProperty();
         bool newHasTransformRelatedProperty = newStyle.hasTransformRelatedProperty();
         bool oldStyleIsContainer = oldStyle->position() != StaticPosition || oldHasTransformRelatedProperty;
 
         if (oldStyleIsContainer && (newStyle.position() == StaticPosition || (oldHasTransformRelatedProperty && !newHasTransformRelatedProperty))) {
-            // Clear our positioned objects list. Our absolutely positioned descendants will be
+            // 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(0, NewContainingBlock);
+            removePositionedObjects(nullptr, NewContainingBlock);
         } else if (!oldStyleIsContainer && (newStyle.position() != StaticPosition || newHasTransformRelatedProperty)) {
             // 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) {
+            // 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);
 }
 
 static bool borderOrPaddingLogicalWidthChanged(const ComputedStyle& oldStyle, const ComputedStyle& newStyle)
 {
     if (newStyle.isHorizontalWritingMode()) {
         return oldStyle.borderLeftWidth() != newStyle.borderLeftWidth()
             || oldStyle.borderRightWidth() != newStyle.borderRightWidth()
@@ skipping 17 matching lines @@
         if (previousSibling() && previousSibling()->isAnonymousBlock())
             toLayoutBlock(parent())->moveChildTo(toLayoutBlock(previousSibling()), this, nullptr, false);
         else if (nextSibling() && nextSibling()->isAnonymousBlock())
             toLayoutBlock(parent())->moveChildTo(toLayoutBlock(nextSibling()), this, nextSibling()->slowFirstChild(), false);
     }
 
     const ComputedStyle& newStyle = styleRef();
 
     if (oldStyle && parent()) {
         if (oldStyle->position() != newStyle.position() && newStyle.position() != StaticPosition) {
-            // Remove our absolutely positioned descendants from their new containing block,
+            // 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.
             if (LayoutBlock* cb = containingBlock())
                 cb->removePositionedObjects(this, NewContainingBlock);
         }
     }
 
     if (TextAutosizer* textAutosizer = document().textAutosizer())
         textAutosizer->record(this);
 
@@ skipping 1164 matching lines @@
 }
 
 void LayoutBlock::removePositionedObjects(LayoutBlock* o, ContainingBlockState containingBlockState)
 {
     TrackedLayoutBoxListHashSet* positionedDescendants = positionedObjects();
     if (!positionedDescendants)
         return;
 
     Vector<LayoutBox*, 16> deadObjects;
     for (auto* positionedObject : *positionedDescendants) {
-        if (!o || positionedObject->isDescendantOf(o)) {
+        if (!o || (positionedObject->isDescendantOf(o) && o != positionedObject)) {
             if (containingBlockState == NewContainingBlock) {
                 positionedObject->setChildNeedsLayout(MarkOnlyThis);
                 if (positionedObject->needsPreferredWidthsRecalculation())
                     positionedObject->setPreferredLogicalWidthsDirty(MarkOnlyThis);
+
+                // The positioned object changing containing block may change paint invalidation container.
+                // Invalidate it (including non-compositing descendants) on its original paint invalidation container.
+                if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+                    // This valid because we need to invalidate based on the current status.
+                    DisableCompositingQueryAsserts compositingDisabler;
+                    if (!positionedObject->isPaintInvalidationContainer())
+                        positionedObject->invalidatePaintIncludingNonCompositingDescendants();
+                }
             }
 
             // It is parent blocks job to add positioned child to positioned objects list of its containing block
             // Parent layout needs to be invalidated to ensure this happens.
             LayoutObject* p = positionedObject->parent();
             while (p && !p->isLayoutBlock())
                 p = p->parent();
             if (p)
                 p->setChildNeedsLayout();
 
@@ skipping 1389 matching lines @@
 void LayoutBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
     showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink