New paint invalidation using paint property tree walk

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "platform/transforms/TransformationMatrix.h"
 
 namespace blink {
 
 // The context for layout tree walk.
 // The walk will be done in the primary tree order (= DOM order), thus the context will also be
 // responsible for bookkeeping tree state in other order, for example, the most recent position
 // container seen.
 struct PaintPropertyTreeBuilderContext {
     PaintPropertyTreeBuilderContext()
-        : currentTransform(nullptr)
-        , currentClip(nullptr)
-        , transformForAbsolutePosition(nullptr)
-        , clipForAbsolutePosition(nullptr)
-        , transformForFixedPosition(nullptr)
-        , clipForFixedPosition(nullptr)
-        , currentEffect(nullptr) { }
+        : paintInvalidationContainer(nullptr)
+        , paintInvalidationContainerForOutOfFlowPositioned(nullptr)
+    { }
+
+    // TODO(wangxianzhu): The RefPtrs are needed for SPv1 which doesn't save the properties
+    // into LayoutObjects. Change them to normal pointers for SPv2.
 
     // The combination of a transform and paint offset describes a linear space.
     // When a layout object recur to its children, the main context is expected to refer
     // the object's border box, then the callee will derive its own border box by translating
     // the space with its own layout location.
-    TransformPaintPropertyNode* currentTransform;
+    RefPtr<TransformPaintPropertyNode> currentTransform;
     LayoutPoint paintOffset;
     // The clip node describes the accumulated raster clip for the current subtree.
     // Note that the computed raster region in canvas space for a clip node is independent from
     // the transform and paint offset above. Also the actual raster region may be affected
     // by layerization and occlusion tracking.
-    ClipPaintPropertyNode* currentClip;
+    RefPtr<ClipPaintPropertyNode> currentClip;
 
     // Separate context for out-of-flow positioned and fixed positioned elements are needed
     // because they don't use DOM parent as their containing block.
     // These additional contexts normally pass through untouched, and are only copied from
     // the main context when the current element serves as the containing block of corresponding
     // positioned descendants.
     // Overflow clips are also inherited by containing block tree instead of DOM tree, thus they
     // are included in the additional context too.
-    TransformPaintPropertyNode* transformForAbsolutePosition;
+    RefPtr<TransformPaintPropertyNode> transformForAbsolutePosition;
     LayoutPoint paintOffsetForAbsolutePosition;
-    ClipPaintPropertyNode* clipForAbsolutePosition;
+    RefPtr<ClipPaintPropertyNode> clipForAbsolutePosition;
 
-    TransformPaintPropertyNode* transformForFixedPosition;
+    RefPtr<TransformPaintPropertyNode> transformForFixedPosition;
     LayoutPoint paintOffsetForFixedPosition;
-    ClipPaintPropertyNode* clipForFixedPosition;
+    RefPtr<ClipPaintPropertyNode> clipForFixedPosition;
 
     // The effect hierarchy is applied by the stacking context tree. It is guaranteed that every
     // DOM descendant is also a stacking context descendant. Therefore, we don't need extra
     // bookkeeping for effect nodes and can generate the effect tree from a DOM-order traversal.
-    EffectPaintPropertyNode* currentEffect;
+    RefPtr<EffectPaintPropertyNode> currentEffect;
+
+    const LayoutBoxModelObject* paintInvalidationContainer;

[pdr., 2016/03/11 02:56:41]

Even when spv2 and spinvalidation are both enabled, it's convenient to keep the
property tree and paint invalidation state data separate. WDYT about introducing
a simple PaintInvalidationContext object? It might be able to hold onto the
invalidation state too.

[Xianzhu, 2016/03/11 20:03:44]

The paintInvalidationContainer fields are for spv1 only. As
PaintPropertyTreeBuilderContext is renamed to PrePaintTreeWalkContext, it seems
fine to include these for now.

+    const LayoutBoxModelObject* paintInvalidationContainerForOutOfFlowPositioned;
 };
 
 void PaintPropertyTreeBuilder::buildPropertyTrees(FrameView& rootFrame)
 {
-    walk(rootFrame, PaintPropertyTreeBuilderContext());
+    walk(rootFrame, PaintPropertyTreeBuilderContext(), nullptr);
 }
 
-void PaintPropertyTreeBuilder::walk(FrameView& frameView, const PaintPropertyTreeBuilderContext& context)
+void PaintPropertyTreeBuilder::walk(FrameView& frameView, const PaintPropertyTreeBuilderContext& context, const PaintInvalidationState* paintInvalidationState)
 {
     PaintPropertyTreeBuilderContext localContext(context);
 
     // TODO(pdr): Creating paint properties for FrameView here will not be
     // needed once settings()->rootLayerScrolls() is enabled.
     // TODO(pdr): Make this conditional on the rootLayerScrolls setting.
 
     TransformationMatrix frameTranslate;
     frameTranslate.translate(frameView.x() + context.paintOffset.x(), frameView.y() + context.paintOffset.y());
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPreTranslation = TransformPaintPropertyNode::create(frameTranslate, FloatPoint3D(), context.currentTransform);
     localContext.transformForFixedPosition = newTransformNodeForPreTranslation.get();
     localContext.paintOffsetForFixedPosition = LayoutPoint();
 
     FloatRoundedRect contentClip(IntRect(IntPoint(), frameView.visibleContentSize()));
     RefPtr<ClipPaintPropertyNode> newClipNodeForContentClip = ClipPaintPropertyNode::create(newTransformNodeForPreTranslation.get(), contentClip, localContext.currentClip);
     localContext.currentClip = localContext.clipForAbsolutePosition = localContext.clipForFixedPosition = newClipNodeForContentClip.get();
 
     DoubleSize scrollOffset = frameView.scrollOffsetDouble();
     TransformationMatrix frameScroll;
     frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = TransformPaintPropertyNode::create(frameScroll, FloatPoint3D(), newTransformNodeForPreTranslation);
     localContext.currentTransform = localContext.transformForAbsolutePosition = newTransformNodeForScrollTranslation.get();
     localContext.paintOffset = localContext.paintOffsetForAbsolutePosition = LayoutPoint();
 
     frameView.setPreTranslation(newTransformNodeForPreTranslation.release());
     frameView.setScrollTranslation(newTransformNodeForScrollTranslation.release());
     frameView.setContentClip(newClipNodeForContentClip.release());
 
     if (LayoutView* layoutView = frameView.layoutView())
-        walk(*layoutView, localContext);
+        walk(*layoutView, localContext, paintInvalidationState);
+}
+
+static void adjustContainerContextForPosition(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+{
+    switch (object.styleRef().position()) {
+    case AbsolutePosition:
+        context.currentTransform = context.transformForAbsolutePosition;
+        context.paintOffset = context.paintOffsetForAbsolutePosition;
+        context.currentClip = context.clipForAbsolutePosition;
+        context.paintInvalidationContainer = context.paintInvalidationContainerForOutOfFlowPositioned;
+        break;
+    case FixedPosition:
+        context.currentTransform = context.transformForFixedPosition;
+        context.paintOffset = context.paintOffsetForFixedPosition;
+        context.currentClip = context.clipForFixedPosition;
+        context.paintInvalidationContainer = context.paintInvalidationContainerForOutOfFlowPositioned;
+        break;
+    default:
+        break;
+    }
 }
 
 static void deriveBorderBoxFromContainerContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.isBoxModelObject())
         return;
 
     const LayoutBoxModelObject& boxModelObject = toLayoutBoxModelObject(object);
 
     // TODO(trchen): There is some insanity going on with tables. Double check results.
-    switch (object.styleRef().position()) {
-    case StaticPosition:
-        break;
-    case RelativePosition:
+    if (object.isInFlowPositioned())
         context.paintOffset += boxModelObject.offsetForInFlowPosition();
-        break;
-    case AbsolutePosition:
-        context.currentTransform = context.transformForAbsolutePosition;
-        context.paintOffset = context.paintOffsetForAbsolutePosition;
-        context.currentClip = context.clipForAbsolutePosition;
-        break;
-    case StickyPosition:
-        context.paintOffset += boxModelObject.offsetForInFlowPosition();
-        break;
-    case FixedPosition:
-        context.currentTransform = context.transformForFixedPosition;
-        context.paintOffset = context.paintOffsetForFixedPosition;
-        context.currentClip = context.clipForFixedPosition;
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-    }
+
     if (boxModelObject.isBox())
         context.paintOffset += toLayoutBox(boxModelObject).locationOffset();
 }
 
 static PassRefPtr<TransformPaintPropertyNode> createPaintOffsetTranslationIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     bool shouldCreatePaintOffsetTranslationNode = false;
     if (object.isSVGRoot()) {
         // SVG doesn't use paint offset internally so emit a paint offset at the html->svg boundary.
         shouldCreatePaintOffsetTranslationNode = true;
@@ skipping 86 matching lines @@
     if (style.hasBorderRadius()) {
         newClipNodeForBorderRadiusClip = ClipPaintPropertyNode::create(
             context.currentTransform,
             style.getRoundedInnerBorderFor(LayoutRect(context.paintOffset, box.size())),
             context.currentClip);
     }
 
     RefPtr<ClipPaintPropertyNode> newClipNodeForOverflowClip = ClipPaintPropertyNode::create(
         context.currentTransform,
         FloatRoundedRect(FloatRect(clipRect)),
-        newClipNodeForBorderRadiusClip ? newClipNodeForBorderRadiusClip.release() : context.currentClip);
+        newClipNodeForBorderRadiusClip ? newClipNodeForBorderRadiusClip.release() : PassRefPtr<ClipPaintPropertyNode>(context.currentClip));
     context.currentClip = newClipNodeForOverflowClip.get();
     return newClipNodeForOverflowClip.release();
 }
 
 static FloatPoint perspectiveOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
     FloatSize borderBoxSize(box.size());
     return FloatPoint(
         floatValueForLength(style.perspectiveOriginX(), borderBoxSize.width()),
@@ skipping 46 matching lines @@
 
     // TODO(pdr): Remove the !object.isLayoutView() condition when removing FrameView
     // paint properties for rootLayerScrolls.
     if (!object.isLayoutView() && object.canContainFixedPositionObjects()) {
         context.transformForFixedPosition = context.currentTransform;
         context.paintOffsetForFixedPosition = context.paintOffset;
         context.clipForFixedPosition = context.currentClip;
     }
 }
 
-static PassOwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> recordTreeContextIfNeeded(LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
+static PassOwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> recordTreeContextIfNeeded(const LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
 {
     // Note: Currently only layer painter makes use of the pre-computed context.
     // This condition may be loosened with no adverse effects beside memory use.
     if (!object.hasLayer())
         return nullptr;
 
     OwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> recordedContext = adoptPtr(new ObjectPaintProperties::LocalBorderBoxProperties);
     recordedContext->paintOffset = context.paintOffset;
     recordedContext->transform = context.currentTransform;
     recordedContext->clip = context.currentClip;
     recordedContext->effect = context.currentEffect;
     return recordedContext.release();
 }
 
-void PaintPropertyTreeBuilder::walk(LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
+static void updatePaintInvalidationContainer(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+{
+    if (!object.isPaintInvalidationContainer()) {
+        if (context.paintInvalidationContainer)
+            return;
+        ASSERT(object.isLayoutView());
+    }
+
+    context.currentTransform = nullptr;
+    context.paintOffset = LayoutPoint();
+    context.currentClip = nullptr;
+    context.paintInvalidationContainer = &toLayoutBoxModelObject(object);
+
+    if (object.styleRef().isStackingContext() || !context.paintInvalidationContainerForOutOfFlowPositioned) {

[pdr., 2016/03/11 02:56:41]

Can you help me understand why this is needed?

We eventually want both spv2 and spinvalidation to be on so it's surprising to
see paint invalidation affecting paint property trees here.

[Xianzhu, 2016/03/11 20:03:44]

This is for SPv1 only in which we need to keep separate property trees for
GraphicsLayers. PaintInvalidationContainer will disappear for SPv2.

Added ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) at the beginning
of the function, and also comments here.

+        // TODO(wangxianzhu): The following may be incorrect for some complex cases. Investigate if we could
+        // make it correct for all cases or have to use ForceHorriblySlowRectMapping.
+        context.transformForAbsolutePosition = nullptr;
+        context.paintOffsetForAbsolutePosition = LayoutPoint();
+        context.clipForAbsolutePosition = nullptr;
+        context.transformForFixedPosition = nullptr;
+        context.paintOffsetForFixedPosition = LayoutPoint();
+        context.clipForFixedPosition = nullptr;
+        context.paintInvalidationContainerForOutOfFlowPositioned = &toLayoutBoxModelObject(object);
+    }
+}
+
+void PaintPropertyTreeBuilder::walk(const LayoutObject& object, const PaintPropertyTreeBuilderContext& context, const PaintInvalidationState* parentPaintInvalidationState)
 {
     PaintPropertyTreeBuilderContext localContext(context);
+    adjustContainerContextForPosition(object, localContext);
 
-    deriveBorderBoxFromContainerContext(object, localContext);
-    RefPtr<TransformPaintPropertyNode> newTransformNodeForPaintOffsetTranslation = createPaintOffsetTranslationIfNeeded(object, localContext);
-    RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = createTransformIfNeeded(object, localContext);
-    RefPtr<EffectPaintPropertyNode> newEffectNode = createEffectIfNeeded(object, localContext);
-    OwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> newRecordedContext = recordTreeContextIfNeeded(object, localContext);
-    RefPtr<ClipPaintPropertyNode> newClipNodeForOverflowClip = createOverflowClipIfNeeded(object, localContext);
-    // TODO(trchen): Insert flattening transform here, as specified by
-    // http://www.w3.org/TR/css3-transforms/#transform-style-property
-    RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = createPerspectiveIfNeeded(object, localContext);
-    RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = createScrollTranslationIfNeeded(object, localContext);
-    updateOutOfFlowContext(object, localContext);
+    Optional<PaintInvalidationState> paintInvalidationState;
+    if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
+        if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+            updatePaintInvalidationContainer(object, localContext);
+        paintInvalidationState.emplace(parentPaintInvalidationState, object, *localContext.paintInvalidationContainer, localContext.paintOffset);
+        if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() && !object.shouldCheckForPaintInvalidation(*paintInvalidationState))
+            return;
 
-    if (newTransformNodeForPaintOffsetTranslation || newTransformNodeForTransform || newEffectNode || newClipNodeForOverflowClip || newTransformNodeForPerspective || newTransformNodeForScrollTranslation || newRecordedContext) {
-        OwnPtr<ObjectPaintProperties> updatedPaintProperties = ObjectPaintProperties::create(
-            newTransformNodeForPaintOffsetTranslation.release(),
-            newTransformNodeForTransform.release(),
-            newEffectNode.release(),
-            newClipNodeForOverflowClip.release(),
-            newTransformNodeForPerspective.release(),
-            newTransformNodeForScrollTranslation.release(),
-            newRecordedContext.release());
-        object.setObjectPaintProperties(updatedPaintProperties.release());
-    } else {
-        object.clearObjectPaintProperties();
+        PaintInvalidationReason reason = object.getMutableForPainting().invalidatePaintIfNeeded(*paintInvalidationState, *localContext.paintInvalidationContainer);
+        object.getMutableForPainting().clearPaintInvalidationState(*paintInvalidationState);
+        if (reason == PaintInvalidationDelayedFull)
+            m_pendingDelayedPaintInvalidations.append(const_cast<LayoutObject*>(&object));
     }
 
-    for (LayoutObject* child = object.slowFirstChild(); child; child = child->nextSibling()) {
-        if (child->isBoxModelObject() || child->isSVG())
-            walk(*child, localContext);
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() || !object.isPaintInvalidationContainer()) {
+        deriveBorderBoxFromContainerContext(object, localContext);
+        RefPtr<TransformPaintPropertyNode> newTransformNodeForPaintOffsetTranslation = createPaintOffsetTranslationIfNeeded(object, localContext);
+        RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = createTransformIfNeeded(object, localContext);
+        RefPtr<EffectPaintPropertyNode> newEffectNode = createEffectIfNeeded(object, localContext);
+        OwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> newRecordedContext = recordTreeContextIfNeeded(object, localContext);
+        RefPtr<ClipPaintPropertyNode> newClipNodeForOverflowClip = createOverflowClipIfNeeded(object, localContext);
+        // TODO(trchen): Insert flattening transform here, as specified by
+        // http://www.w3.org/TR/css3-transforms/#transform-style-property
+        RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = createPerspectiveIfNeeded(object, localContext);
+        RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = createScrollTranslationIfNeeded(object, localContext);
+        updateOutOfFlowContext(object, localContext);
+
+        if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+            if (newTransformNodeForPaintOffsetTranslation || newTransformNodeForTransform || newEffectNode || newClipNodeForOverflowClip || newTransformNodeForPerspective || newTransformNodeForScrollTranslation || newRecordedContext) {
+                OwnPtr<ObjectPaintProperties> updatedPaintProperties = ObjectPaintProperties::create(
+                    newTransformNodeForPaintOffsetTranslation.release(),
+                    newTransformNodeForTransform.release(),
+                    newEffectNode.release(),
+                    newClipNodeForOverflowClip.release(),
+                    newTransformNodeForPerspective.release(),
+                    newTransformNodeForScrollTranslation.release(),
+                    newRecordedContext.release());
+                object.getMutableForPainting().setObjectPaintProperties(updatedPaintProperties.release());
+            } else {
+                object.getMutableForPainting().clearObjectPaintProperties();
+            }
+        }
+    }
+
+    for (const LayoutObject* child = object.slowFirstChild(); child; child = child->nextSibling()) {
+        if (child->isBoxModelObject() || child->isSVG()) {
+            walk(*child, localContext, paintInvalidationState.get());
+        } else if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() && child->shouldCheckForPaintInvalidation(*paintInvalidationState)) {
+            child->getMutableForPainting().invalidatePaintIfNeeded(*paintInvalidationState, *localContext.paintInvalidationContainer);
+            child->getMutableForPainting().clearPaintInvalidationState(*paintInvalidationState);
+        }
     }
 
     if (object.isLayoutPart()) {
         Widget* widget = toLayoutPart(object).widget();
         if (widget && widget->isFrameView())
-            walk(*toFrameView(widget), localContext);
+            walk(*toFrameView(widget), localContext, paintInvalidationState.get());
         // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
     }
 }
 
 } // namespace blink