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 1146 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());

[pdr., 2015/08/20 22:45:05]

Can we assert that we're in the appropriate document lifecycle phase here and
below?

[Xianzhu, 2015/08/21 00:31:38]

Done. The condition will change in next steps for combining paint invalidation
into painting and combining paint invalidation flags with repaint flags.

+    if (!selfNeedsRepaint()) {
+        m_bitfields.setSelfNeedsRepaint(true);
+        markContainerChainForRepaint();
+    }
+}
+
+void LayoutObject::setChildNeedsRepaint()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    if (!childNeedsRepaint()) {
+        m_bitfields.setChildNeedsRepaint(true);
+        markContainerChainForRepaint();
+    }
+}
+
+void LayoutObject::markContainerChainForRepaint()

[pdr., 2015/08/20 22:45:05]

markContainerChainForChildNeedsRepaint?

[Xianzhu, 2015/08/21 00:31:38]

Done.

+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    for (LayoutObject* container = this->containerCrossingFrameBoundaries(); container && !container->childNeedsRepaint(); container = container->containerCrossingFrameBoundaries())
+        container->m_bitfields.setChildNeedsRepaint(true);

[trchen, 2015/08/21 00:37:29]

I think we need to special case fixed-pos elements.

If I understand correctly, we want to mark all ancestors in the painting order,
but instead this marks all ancestors in the positioning order. For most element
isPaintingAncestor(o) implies isPositionAncestor(o). Fixed-pos is the only
exception.

[Xianzhu, 2015/08/21 04:54:51]

container() is actually equivalent to paintingAncestor(). It has a special case
for fixed position. If not, the original paint invalidation would have been
incorrect.

However, I need to confirm the paint invalidation traversal sequence (which is
also the clearRepaintFlagsRecursively traversal sequence) about fixed-pos.

[Xianzhu, 2015/08/21 05:52:45]

Scratch the above. Perhaps I misunderstood painting order about fixed-pos. Will
investigate more.

+}
+
+bool LayoutObject::clearRepaintFlagsRecursively()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    m_bitfields.setSelfNeedsRepaint(false);
+
+    if (!m_bitfields.childNeedsRepaint())
+        return true;
+
+    if (clearRepaintFlagsOfSubtrees()) {
+        m_bitfields.setChildNeedsRepaint(false);
+        return true;
+    }
+    return false;
+}
+
+bool LayoutObject::clearRepaintFlagsOfSubtrees()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    bool result = true;
+    for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
+        if (!child->isOutOfFlowPositioned())
+            result &= child->clearRepaintFlagsRecursively();
+    }
+    return result;
+}
+
 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 2056 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