Subtree caching implementation in blink-core

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 1147 matching lines @@
         toLayoutView(&paintInvalidationContainer)->invalidatePaintForRectangle(r, invalidationReason);
         return;
     }
 
     if (paintInvalidationContainer.view()->usesCompositing()) {
         ASSERT(paintInvalidationContainer.isPaintInvalidationContainer());
         paintInvalidationContainer.setBackingNeedsPaintInvalidationInRect(r, invalidationReason);
     }
 }
 
-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;
 
     // Not using enclosingCompositedContainer() directly because this object may be in an orphaned subtree.
     if (const DeprecatedPaintLayer* enclosingLayer = this->enclosingLayer()) {
         // This is valid because we want to invalidate the client in the display item list of the current backing.
         DisableCompositingQueryAsserts disabler;
         if (const DeprecatedPaintLayer* paintInvalidationLayer = enclosingLayer->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
             paintInvalidationLayer->layoutObject()->invalidateDisplayItemClientOnBacking(displayItemClient);
     }
 }
 
-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)
         return computePaintInvalidationRect(paintInvalidationContainer, paintInvalidationState);
     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());
 
     if (r.isEmpty())
         return nullptr;
 
     if (view()->document().printing())
         return nullptr; // Don't invalidate paints if we're printing.
 
     LayoutRect dirtyRect(r);
 
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
     DeprecatedPaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, dirtyRect);
     invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRect, PaintInvalidationRectangle);
     return &paintInvalidationContainer;
 }
 
-void LayoutObject::invalidatePaintRectangle(const LayoutRect& r) const
+void LayoutObject::invalidatePaintRectangle(const LayoutRect& r)
 {
     if (const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(r)) {
         if (RuntimeEnabledFeatures::slimmingPaintEnabled())
             invalidateDisplayItemClients(*paintInvalidationContainer);
     }
 }
 
 void LayoutObject::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
 {
     ASSERT(!needsLayout());
@@ skipping 2042 matching lines @@
 
         // If a paint invalidation container is not a stacking context,
         // some of its descendants may belong to the parent container.
         findNonCompositedDescendantLayerToTraverse(*descendant, functor);
         descendant = descendant->nextInPreOrderAfterChildren(&object);
     }
 }
 
 } // unnamed namespace
 
-void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(const LayoutObject& object) const
+void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(LayoutObject& object)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
 
     // Not using enclosingCompositedContainer() directly because this object may be in an orphaned subtree.
     const DeprecatedPaintLayer* enclosingLayer = this->enclosingLayer();
     if (!enclosingLayer)
         return;
 
     // This is valid because we want to invalidate the client in the display item list of the current backing.
     DisableCompositingQueryAsserts disabler;
@@ skipping 97 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