Update PaintLayer::needsPaintPhaseXXX flags when add/remove layer on style change

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 1239 matching lines @@
     setNeedsRepaint();
 
     return oldChild;
 }
 
 void PaintLayer::removeOnlyThisLayer()
 {
     if (!m_parent)
         return;
 
+    bool didSetPaintInvalidation = false;
     if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         DisableCompositingQueryAsserts disabler; // We need the current compositing status.
         if (isPaintInvalidationContainer()) {
             // Our children will be reparented and contained by a new paint invalidation container,
             // so need paint invalidation. CompositingUpdate can't see this layer (which has been
             // removed) so won't do this for us.
             DisablePaintInvalidationStateAsserts disabler;
             layoutObject()->invalidatePaintIncludingNonCompositingDescendants();
             layoutObject()->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
+            didSetPaintInvalidation = true;
         }
     }
 
+    if (!didSetPaintInvalidation && isSelfPaintingLayer()) {

[pdr., 2016/04/08 19:46:07]

Could we just check "if (!needsRepaint() && isSelfPaintingLayer())" ?

[Xianzhu, 2016/04/08 21:30:55]

No. First, needsRepaint flag is set during paint invalidation, and it's always
false before paint invalidation. Second, needsRepaint flag is set when anything
in the layer needs repaint, which doesn't mean the needsPaintPhase flags will be
updated.

+        if (PaintLayer* enclosingSelfPaintingLayer = m_parent->enclosingSelfPaintingLayer())
+            enclosingSelfPaintingLayer->mergeNeedsPaintPhaseFlagsFrom(*this);
+    }
+
     clipper().clearClipRectsIncludingDescendants();
 
     PaintLayer* nextSib = nextSibling();
 
     // Remove the child reflection layer before moving other child layers.
     // The reflection layer should not be moved to the parent.
     if (PaintLayerReflectionInfo* reflectionInfo = this->reflectionInfo())
         removeChild(reflectionInfo->reflectionLayer());
 
     // Now walk our kids and reattach them to our parent.
     PaintLayer* current = m_first;
     while (current) {
         PaintLayer* next = current->nextSibling();
         removeChild(current);
         m_parent->addChild(current, nextSib);
 
         // FIXME: We should call a specialized version of this function.
         current->updateLayerPositionsAfterLayout();
         current = next;
     }
 
     // Remove us from the parent.
     m_parent->removeChild(this);
     m_layoutObject->destroyLayer();
 }
 
 void PaintLayer::insertOnlyThisLayer()

[pdr., 2016/04/08 19:46:07]

LayoutObject::insertedIntoTree (which calls blink::addLayers) looks similar to
PaintLayer::{insert,remove}OnlyThisLayer(). I think we don't need the merge
flags logic because insertedIntoTree will always cause a paint invalidation...
is that true?

[Xianzhu, 2016/04/08 21:30:56]

Yes.

 {
+    // If the current paint invalidation container is not a stacking context and this object is
+    // stacked content, creating this layer may cause this object and its
+    // descendants to change paint invalidation container. Therefore we must eagerly invalidate
+    // them on the original paint invalidation container before creating the layer.
+    bool didSetPaintInvalidation = false;
+    if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() && layoutObject()->isRooted() && layoutObject()->styleRef().isStacked()) {
+        const LayoutBoxModelObject& currentPaintInvalidationContainer = layoutObject()->containerForPaintInvalidation();
+        if (!currentPaintInvalidationContainer.styleRef().isStackingContext()) {
+            layoutObject()->invalidatePaintIncludingNonSelfPaintingLayerDescendants(currentPaintInvalidationContainer);
+            didSetPaintInvalidation = true;
+        }
+    }
+
     if (!m_parent && layoutObject()->parent()) {
         // We need to connect ourselves when our layoutObject() has a parent.
         // Find our enclosingLayer and add ourselves.
         PaintLayer* parentLayer = layoutObject()->parent()->enclosingLayer();
         ASSERT(parentLayer);
         PaintLayer* beforeChild = !parentLayer->reflectionInfo() || parentLayer->reflectionInfo()->reflectionLayer() != this ? layoutObject()->parent()->findNextLayer(parentLayer, layoutObject()) : 0;
         parentLayer->addChild(this, beforeChild);
     }
 
+    if (!didSetPaintInvalidation && isSelfPaintingLayer()) {
+        if (PaintLayer* enclosingSelfPaintingLayer = m_parent->enclosingSelfPaintingLayer())

[pdr., 2016/04/08 19:46:07]

Similar to my comment in LayoutBoxModelObject::createLayer, will
"m_parent->enclosingSelfPaintingLayer()" always be the original enclosing self
painting layer of the layout object before it gained a layer?

[Xianzhu, 2016/04/08 21:30:55]

Yes, because here it's using m_parent->.

+            mergeNeedsPaintPhaseFlagsFrom(*enclosingSelfPaintingLayer);
+    }
+
     // Remove all descendant layers from the hierarchy and add them to the new position.
     for (LayoutObject* curr = layoutObject()->slowFirstChild(); curr; curr = curr->nextSibling())
         curr->moveLayers(m_parent, this);
 
     // Clear out all the clip rects.
     clipper().clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const PaintLayer* accumulateOffsetTowardsAncestor(const PaintLayer* layer, const PaintLayer* ancestorLayer, LayoutPoint& location)
@@ skipping 1559 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif