Subtree caching implementation in blink-core

Source/core/layout/LayoutObject.cpp

Index: Source/core/layout/LayoutObject.cpp
diff --git a/Source/core/layout/LayoutObject.cpp b/Source/core/layout/LayoutObject.cpp
index fb0062c7711f8310c7700117e88d6e360ffe14e5..0969c25548316aaaa0ab283065f1134249558b8c 100644
--- a/Source/core/layout/LayoutObject.cpp
+++ b/Source/core/layout/LayoutObject.cpp
@@ -1165,7 +1165,21 @@ void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& pai
     }
 }
 
-void LayoutObject::invalidateDisplayItemClient(const DisplayItemClientWrapper& displayItemClient) const
+void LayoutObject::invalidateDisplayItemClient(const NonLayoutObjectDisplayItemClientWrapper& displayItemClient)
+{
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        setChildNeedsRepaint();
+    invalidateDisplayItemClientInternal(displayItemClient);
+}
+
+void LayoutObject::invalidateDisplayItemClient(LayoutObject& object)
+{
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        object.setNeedsRepaint();
+    invalidateDisplayItemClientInternal(object);
+}
+
+void LayoutObject::invalidateDisplayItemClientInternal(const DisplayItemClientWrapper& displayItemClient)
 {
     if (!RuntimeEnabledFeatures::slimmingPaintEnabled())
         return;
@@ -1179,12 +1193,70 @@ void LayoutObject::invalidateDisplayItemClient(const DisplayItemClientWrapper& d
     }
 }
 
-void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
+void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        setNeedsRepaint();
     paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this);
 }
 
+void LayoutObject::setNeedsRepaint()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    ASSERT(document().lifecycle().state() <= DocumentLifecycle::InPaintInvalidation);
+
+    if (!selfNeedsRepaint()) {
+        m_bitfields.setSelfNeedsRepaint(true);
+        markContainerChainForChildNeedsRepaint();
+    }
+}
+
+void LayoutObject::setChildNeedsRepaint()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    ASSERT(document().lifecycle().state() <= DocumentLifecycle::InPaintInvalidation);
+
+    if (!childNeedsRepaint()) {
+        m_bitfields.setChildNeedsRepaint(true);
+        markContainerChainForChildNeedsRepaint();
+    }
+}
+
+void LayoutObject::markContainerChainForChildNeedsRepaint()
+{
+    // TODO(wangxianzhu): This should be "markPaintContainerChainForChildNeedsRepaint"
+    // (which returns the painting container instead of positioning container for fixed-pos)
+    // when we remove DeprecatedPaintLayer. Currently DeprecatedPaintLayer paints fixed-pos
+    // object which is not fully controlled by normal LayoutBlock subtree repaint flags.

[trchen, 2015/08/25 06:30:38]

Sorry I just realized that fixed-pos element is not the only thing that breaks
the invariant "being painting ancestor implies being position ancestor". There
are tons of things that creates stacking context without being position
container, for example, opacity.

I think it wouldn't be too hard to add a helper function to find painting
parent?

[Xianzhu, 2015/08/25 15:55:03]

This is not too hard, but it'll need non-constant time to find the contained
descendants (needed in clearRepaintFlagsRecursively). For now the other
non-position-container cases seem similar to fixed-positions which are handled
by DeprecatedPaintLayer. I'd like to handle this in later CLs.

Will update the comment.

[chrishtr, 2015/08/25 20:49:52]

I'm not sure all the complexity of encoding paint relationships that differ from
layout tree topology. I think we just need to know if something in the subtree
needed repaint,
regardless of what its paint ancestor was, because the paint ancestor is always
an ancestor at some distance up the tree.

+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    for (LayoutObject* container = this->containerCrossingFrameBoundaries(); container && !container->childNeedsRepaint(); container = container->containerCrossingFrameBoundaries())
+        container->m_bitfields.setChildNeedsRepaint(true);
+}
+
+void LayoutObject::clearRepaintFlagsRecursively()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    ASSERT(document().lifecycle().state() == DocumentLifecycle::InPaintForSlimmingPaintV2);
+
+    m_bitfields.setSelfNeedsRepaint(false);
+
+    if (!m_bitfields.childNeedsRepaint())
+        return;
+
+    clearRepaintFlagsOfSubtrees();
+    m_bitfields.setChildNeedsRepaint(false);
+}
+
+void LayoutObject::clearRepaintFlagsOfSubtrees()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
+        if (!child->isOutOfFlowPositioned())
+            child->clearRepaintFlagsRecursively();
+    }
+}
+
 LayoutRect LayoutObject::boundsRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     if (!paintInvalidationContainer)
@@ -1192,7 +1264,7 @@ LayoutRect LayoutObject::boundsRectForPaintInvalidation(const LayoutBoxModelObje
     return DeprecatedPaintLayer::computePaintInvalidationRect(this, paintInvalidationContainer->layer(), paintInvalidationState);
 }
 
-const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(const LayoutRect& r) const
+const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(const LayoutRect& r)
 {
     RELEASE_ASSERT(isRooted());
 
@@ -1210,7 +1282,7 @@ const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(const
     return &paintInvalidationContainer;
 }
 
-void LayoutObject::invalidatePaintRectangle(const LayoutRect& r) const
+void LayoutObject::invalidatePaintRectangle(const LayoutRect& r)
 {
     if (const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(r)) {
         if (RuntimeEnabledFeatures::slimmingPaintEnabled())
@@ -3273,7 +3345,7 @@ void traverseNonCompositingDescendants(LayoutObject& object, const LayoutObjectT
 
 } // unnamed namespace
 
-void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(const LayoutObject& object) const
+void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(LayoutObject& object)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());