Invalidate non-self-painting-layer descendants when creating a layer

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 3370 matching lines @@
             object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationFull, invalidationRect, invalidationRect);
         }
     private:
         const LayoutBoxModelObject& m_paintInvalidationContainer;
     };
 
     const LayoutBoxModelObject& paintInvalidationContainer = *paintInvalidationLayer->layoutObject();
     traverseNonCompositingDescendants(const_cast<LayoutObject&>(object), Functor(paintInvalidationContainer));
 }
 
+void LayoutObject::invalidatePaintOfPreviousPaintInvalidationRect(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason reason) const
+{
+    // These disablers are valid because we want to use the current compositing/invalidation status.
+    DisablePaintInvalidationStateAsserts invalidationDisabler;
+    DisableCompositingQueryAsserts compositingDisabler;
+
+    LayoutRect invalidationRect = previousPaintInvalidationRect();
+    adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+    invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationLayer);
+    invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationLayer, invalidationRect, invalidationRect);
+}
+
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
     class Functor : public LayoutObjectTraversalFunctor {
     public:
         explicit Functor(const LayoutBoxModelObject& paintInvalidationContainer) : m_paintInvalidationContainer(paintInvalidationContainer) { }
         void operator()(LayoutObject& object) const override
         {
-            LayoutRect invalidationRect = object.previousPaintInvalidationRect();
-            object.adjustInvalidationRectForCompositedScrolling(invalidationRect, m_paintInvalidationContainer);
-            object.invalidatePaintUsingContainer(m_paintInvalidationContainer, invalidationRect, PaintInvalidationLayer);
-            object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationLayer, invalidationRect, invalidationRect);
+            object.invalidatePaintOfPreviousPaintInvalidationRect(m_paintInvalidationContainer, PaintInvalidationLayer);
+            object.setPreviousPaintInvalidationRect(LayoutRect());
         }
     private:
         const LayoutBoxModelObject& m_paintInvalidationContainer;
     };
 
     // Since we're only painting non-composited layers, we know that they all share the same paintInvalidationContainer.
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
     traverseNonCompositingDescendants(*this, Functor(paintInvalidationContainer));
 }
 
 // FIXME: If we had a flag to force invalidations in a whole subtree, we could get rid of this function (crbug.com/410097).
 void LayoutObject::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
 {
     class Functor : public LayoutObjectTraversalFunctor {
     public:
         void operator()(LayoutObject& object) const override
         {
             object.setShouldDoFullPaintInvalidation();
         }
     };
 
     // Need to access the current compositing status.
     DisableCompositingQueryAsserts disabler;
     traverseNonCompositingDescendants(*this, Functor());
 }
 
+void LayoutObject::invalidatePaintIncludingNonSelfPaintingLayerDescendants(const LayoutBoxModelObject& paintInvalidationContainer)
+{
+    invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationLayer);
+    setPreviousPaintInvalidationRect(LayoutRect());

[Xianzhu, 2015/10/14 18:17:48]

I removed this line (and line 3411 above) because it caused wrong invalidation
when the object is removed later.

+    for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
+        if (!child->hasLayer() || !toLayoutBoxModelObject(child)->layer()->isSelfPaintingLayer())

[chrishtr, 2015/10/14 17:43:00]

Also non-compositing right? Non-self-painting paint layers can get composited
layers I think.

[Xianzhu, 2015/10/14 18:17:48]

I think all composited layers are self-painting, otherwise we'll paint them
twice on the parent composited layer (by layout object painter walk) and its own
composited layer (by CompositedLayerMapping::paintContents()).
PaintLayer::shouldBeSelfPaintingLayer() seems to ensure this.

+            child->invalidatePaintIncludingNonSelfPaintingLayerDescendants(paintInvalidationContainer);
+    }
+}
+
 void LayoutObject::setIsSlowRepaintObject(bool isSlowRepaintObject)
 {
     ASSERT(frameView());
     if (m_bitfields.isSlowRepaintObject() == isSlowRepaintObject)
         return;
     m_bitfields.setIsSlowRepaintObject(isSlowRepaintObject);
     if (isSlowRepaintObject)
         frameView()->addSlowRepaintObject();
     else
         frameView()->removeSlowRepaintObject();
@@ skipping 30 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif