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 3373 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::invalidatePaintIncludingNonLayerDescendantsInternal(const LayoutBoxModelObject& paintInvalidationContainer)

[chrishtr, 2015/10/13 17:49:01]

NonPaintLayer

[Xianzhu, 2015/10/13 23:58:12]

Changed to invalidatePaintIncludingNonSelfPaintingLayerDescendants

+{
+    invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationLayer);
+    setPreviousPaintInvalidationRect(LayoutRect());
+    for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
+        if (!child->hasLayer())

[chrishtr, 2015/10/13 17:49:00]

What about non-self-painting layers?

[Xianzhu, 2015/10/13 23:58:12]

We should also invalidate them. Done.

+            child->invalidatePaintIncludingNonLayerDescendantsInternal(paintInvalidationContainer);
+    }
+}
+
+void LayoutObject::invalidatePaintIncludingNonLayerDescendants()
+{
+    invalidatePaintIncludingNonLayerDescendantsInternal(containerForPaintInvalidationOnRootedTree());
+}
+
 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