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.
+    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