Subtree caching implementation in blink-core

Source/core/paint/DeprecatedPaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 105 matching lines @@
     , m_has3DTransformedDescendant(false)
     , m_containsDirtyOverlayScrollbars(false)
     , m_hasFilterInfo(false)
     , m_needsAncestorDependentCompositingInputsUpdate(true)
     , m_needsDescendantDependentCompositingInputsUpdate(true)
     , m_childNeedsCompositingInputsUpdate(true)
     , m_hasCompositingDescendant(false)
     , m_hasNonCompositedChild(false)
     , m_shouldIsolateCompositedDescendants(false)
     , m_lostGroupedMapping(false)
+    , m_needsRepaint(false)
     , m_layoutObject(layoutObject)
     , m_parent(0)
     , m_previous(0)
     , m_next(0)
     , m_first(0)
     , m_last(0)
     , m_staticInlinePosition(0)
     , m_staticBlockPosition(0)
     , m_enclosingPaginationLayer(0)
     , m_potentialCompositingReasonsFromStyle(CompositingReasonNone)
@@ skipping 715 matching lines @@
 {
     const AncestorDependentCompositingInputs& properties = ancestorDependentCompositingInputs();
 
     TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
     // FIXME: add a test that checks flipped writing mode and ApplyContainerFlip are correct.
     layoutObject()->mapLocalToContainer(properties.transformAncestor ? properties.transformAncestor->layoutObject() : 0, transformState, ApplyContainerFlip);
     transformState.flatten();
     return LayoutPoint(transformState.lastPlanarPoint());
 }
 
-const DeprecatedPaintLayer* DeprecatedPaintLayer::compositingContainer() const
+DeprecatedPaintLayer* DeprecatedPaintLayer::compositingContainer() const
 {
     if (!stackingNode()->isTreatedAsStackingContextForPainting())
         return parent();
     if (DeprecatedPaintLayerStackingNode* ancestorStackingNode = stackingNode()->ancestorStackingContextNode())
         return ancestorStackingNode->layer();
-    return 0;
+    return nullptr;
 }
 
 bool DeprecatedPaintLayer::isPaintInvalidationContainer() const
 {
     return compositingState() == PaintsIntoOwnBacking || compositingState() == PaintsIntoGroupedBacking;
 }
 
 // Note: enclosingCompositingLayer does not include squashed layers. Compositing stacking children of squashed layers
 // receive graphics layers that are parented to the compositing ancestor of the squashed layer.
 DeprecatedPaintLayer* DeprecatedPaintLayer::enclosingLayerWithCompositedDeprecatedPaintLayerMapping(IncludeSelfOrNot includeSelf) const
 {
     ASSERT(isAllowedToQueryCompositingState());
 
     if ((includeSelf == IncludeSelf) && compositingState() != NotComposited && compositingState() != PaintsIntoGroupedBacking)
         return const_cast<DeprecatedPaintLayer*>(this);
 
-    for (const DeprecatedPaintLayer* curr = compositingContainer(); curr; curr = curr->compositingContainer()) {
+    for (DeprecatedPaintLayer* curr = compositingContainer(); curr; curr = curr->compositingContainer()) {
         if (curr->compositingState() != NotComposited && curr->compositingState() != PaintsIntoGroupedBacking)
-            return const_cast<DeprecatedPaintLayer*>(curr);
+            return curr;
     }
 
-    return 0;
+    return nullptr;
 }
 
 // Return the enclosingCompositedLayerForPaintInvalidation for the given Layer
 // including crossing frame boundaries.
 DeprecatedPaintLayer* DeprecatedPaintLayer::enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const
 {
     const DeprecatedPaintLayer* layer = this;
     DeprecatedPaintLayer* compositedLayer = 0;
     while (!compositedLayer) {
         compositedLayer = layer->enclosingLayerForPaintInvalidation();
         if (!compositedLayer) {
             LayoutObject* owner = layer->layoutObject()->frame()->ownerLayoutObject();
             if (!owner)
                 break;
             layer = owner->enclosingLayer();
         }
     }
     return compositedLayer;
 }
 
 DeprecatedPaintLayer* DeprecatedPaintLayer::enclosingLayerForPaintInvalidation() const
 {
     ASSERT(isAllowedToQueryCompositingState());
 
     if (isPaintInvalidationContainer())
         return const_cast<DeprecatedPaintLayer*>(this);
 
-    for (const DeprecatedPaintLayer* curr = compositingContainer(); curr; curr = curr->compositingContainer()) {
+    for (DeprecatedPaintLayer* curr = compositingContainer(); curr; curr = curr->compositingContainer()) {
         if (curr->isPaintInvalidationContainer())
-            return const_cast<DeprecatedPaintLayer*>(curr);
+            return curr;
     }
 
-    return 0;
+    return nullptr;
 }
 
 void DeprecatedPaintLayer::setNeedsCompositingInputsUpdate()
 {
     m_needsAncestorDependentCompositingInputsUpdate = true;
     m_needsDescendantDependentCompositingInputsUpdate = true;
 
     for (DeprecatedPaintLayer* current = this; current && !current->m_childNeedsCompositingInputsUpdate; current = current->parent())
         current->m_childNeedsCompositingInputsUpdate = true;
 
@@ skipping 1746 matching lines @@
                     iter->value.append(physicalBoundingBox(parentLayer));
                 }
             }
         } else {
             rect.append(logicalBoundingBox());
             rects.set(this, rect);
         }
     }
 }
 
+void DeprecatedPaintLayer::setNeedsRepaint()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+
+    DeprecatedPaintLayer* layer = this;
+    while (!layer->isSelfPaintingLayer() && !layer->hasSelfPaintingLayerDescendant()) {
+        layer = layer->parent();
+        ASSERT(layer); // At least the root layer is self painting.
+    }
+
+    if (layer->m_needsRepaint)
+        return;
+    layer->m_needsRepaint = true;
+    layer->markCompositingContainerChainForNeedsRepaint();
+}
+
+void DeprecatedPaintLayer::markCompositingContainerChainForNeedsRepaint()
+{
+    DeprecatedPaintLayer* layer = this;
+    while (true) {
+        DeprecatedPaintLayer* container = layer->compositingContainer();
+        if (!container) {
+            LayoutObject* owner = layer->layoutObject()->frame()->ownerLayoutObject();
+            if (!owner)
+                break;
+            container = owner->enclosingLayer();
+        }
+        if (container->m_needsRepaint)
+            break;
+        if (container->isSelfPaintingLayer() || container->hasSelfPaintingLayerDescendant())
+            container->m_needsRepaint = true;
+        layer = container;
+    }
+}
+
 DisableCompositingQueryAsserts::DisableCompositingQueryAsserts()
     : m_disabler(gCompositingQueryMode, CompositingQueriesAreAllowed) { }
 
 } // namespace blink
 
 #ifndef NDEBUG
 // FIXME: Rename?
 void showLayerTree(const blink::DeprecatedPaintLayer* layer)
 {
     if (!layer) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
 
     if (blink::LocalFrame* frame = layer->layoutObject()->frame()) {
         WTF::String output = externalRepresentation(frame, blink::LayoutAsTextShowAllLayers | blink::LayoutAsTextShowLayerNesting | blink::LayoutAsTextShowCompositedLayers | blink::LayoutAsTextShowAddresses | blink::LayoutAsTextShowIDAndClass | blink::LayoutAsTextDontUpdateLayout | blink::LayoutAsTextShowLayoutState);
         fprintf(stderr, "%s\n", output.utf8().data());
     }
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif