New paint invalidation using paint property tree walk

third_party/WebKit/Source/core/paint/PrePaintTreeWalk.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/paint/PrePaintTreeWalk.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) { }
+struct PrePaintTreeWalkContext {
+    PrePaintTreeWalkContext()
+        : paintInvalidationContainer(nullptr)
+        , paintInvalidationContainerForOutOfFlowPositioned(nullptr)

[trchen, 2016/03/11 23:09:39]

The name of the variable isn't accurate. Paint invalidation container is a paint
order tree concept, and it shouldn't have anything to do with in-flow or
out-of-flow, which is containing block tree concept.

in-flow v.s. out-of-flow means whether a layout object's position is based on
the direct parent or some ancestor containing block.

where as normal-flow v.s. negative-flow/positive-flow means whether a layout
object paints as a part of a (pseudo) stacking context, or create paint in its
own (pseudo) stacking context.

I think what you really want to say is
paintInvalidationContainer -> paintInvalidationContainerForNormalFlow
paintInvalidationContainerForOutOfFlowPositioned ->
paintInvalidationContainerForDescendantStackingContext

And I think it worth a comment to say that normally we only need to keep one
context, but due to composited scrolling we may create paint invalidation
container for normal flow. It is the
paintInvalidationContainerForOutOfFlowPositioned that handles a special case
here.

+    { }
+
+    // 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;
+
+    // For SPv1 only.
+    const LayoutBoxModelObject* paintInvalidationContainer;
+    const LayoutBoxModelObject* paintInvalidationContainerForOutOfFlowPositioned;
 };
 
-void PaintPropertyTreeBuilder::buildPropertyTrees(FrameView& rootFrame)
+void PrePaintTreeWalk::buildPropertyTreesAndInvalidatePaint(FrameView& rootFrame)
 {
-    walk(rootFrame, PaintPropertyTreeBuilderContext());
+    walk(rootFrame, PrePaintTreeWalkContext(), nullptr);
 }
 
-void PaintPropertyTreeBuilder::walk(FrameView& frameView, const PaintPropertyTreeBuilderContext& context)
+void PrePaintTreeWalk::walk(FrameView& frameView, const PrePaintTreeWalkContext& context, const PaintInvalidationState* paintInvalidationState)
 {
-    PaintPropertyTreeBuilderContext localContext(context);
+    PrePaintTreeWalkContext 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 deriveBorderBoxFromContainerContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static void adjustContainerContextForPosition(const LayoutObject& object, PrePaintTreeWalkContext& context)
+{
+    switch (object.styleRef().position()) {
+    case AbsolutePosition:
+        context.currentTransform = context.transformForAbsolutePosition;
+        context.paintOffset = context.paintOffsetForAbsolutePosition;
+        context.currentClip = context.clipForAbsolutePosition;
+        context.paintInvalidationContainer = context.paintInvalidationContainerForOutOfFlowPositioned;

[trchen, 2016/03/11 23:36:19]

Per the previous comment, it is not the right place to switch back invalidation
container.

+        break;
+    case FixedPosition:
+        context.currentTransform = context.transformForFixedPosition;
+        context.paintOffset = context.paintOffsetForFixedPosition;
+        context.currentClip = context.clipForFixedPosition;
+        context.paintInvalidationContainer = context.paintInvalidationContainerForOutOfFlowPositioned;

[trchen, 2016/03/11 23:36:19]

Ditto.

+        break;
+    default:
+        break;
+    }
+}
+
+static void deriveBorderBoxFromContainerContext(const LayoutObject& object, PrePaintTreeWalkContext& 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())

[trchen, 2016/03/11 23:36:19]

While this refactoring is appreciated, can we do this in another CL to reduce
noises for this CL?

         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)
+static PassRefPtr<TransformPaintPropertyNode> createPaintOffsetTranslationIfNeeded(const LayoutObject& object, PrePaintTreeWalkContext& 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;
     } else if (object.isBoxModelObject()) {
         // TODO(trchen): Eliminate PaintLayer dependency.
         PaintLayer* layer = toLayoutBoxModelObject(object).layer();
         shouldCreatePaintOffsetTranslationNode = layer && layer->paintsWithTransform(GlobalPaintNormalPhase);
     }
@@ skipping 12 matching lines @@
 static FloatPoint3D transformOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
     FloatSize borderBoxSize(box.size());
     return FloatPoint3D(
         floatValueForLength(style.transformOriginX(), borderBoxSize.width()),
         floatValueForLength(style.transformOriginY(), borderBoxSize.height()),
         style.transformOriginZ());
 }
 
-static PassRefPtr<TransformPaintPropertyNode> createTransformIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<TransformPaintPropertyNode> createTransformIfNeeded(const LayoutObject& object, PrePaintTreeWalkContext& context)
 {
     if (object.isSVG() && !object.isSVGRoot()) {
         const AffineTransform& transform = object.localToParentTransform();
         if (transform.isIdentity())
             return nullptr;
 
         // SVG's transform origin is baked into the localToParentTransform.
         RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = TransformPaintPropertyNode::create(
             transform, FloatPoint3D(0, 0, 0), context.currentTransform);
         context.currentTransform = newTransformNodeForTransform.get();
         return newTransformNodeForTransform.release();
     }
 
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasTransform())
         return nullptr;
 
     ASSERT(context.paintOffset == LayoutPoint());
 
     TransformationMatrix matrix;
     style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
         ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = TransformPaintPropertyNode::create(
         matrix, transformOrigin(toLayoutBox(object)), context.currentTransform);
     context.currentTransform = newTransformNodeForTransform.get();
     return newTransformNodeForTransform.release();
 }
 
-static PassRefPtr<EffectPaintPropertyNode> createEffectIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<EffectPaintPropertyNode> createEffectIfNeeded(const LayoutObject& object, PrePaintTreeWalkContext& context)
 {
     const ComputedStyle& style = object.styleRef();
     if (!style.hasOpacity())
         return nullptr;
     RefPtr<EffectPaintPropertyNode> newEffectNode = EffectPaintPropertyNode::create(style.opacity(), context.currentEffect);
     context.currentEffect = newEffectNode.get();
     return newEffectNode.release();
 }
 
-static PassRefPtr<ClipPaintPropertyNode> createOverflowClipIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<ClipPaintPropertyNode> createOverflowClipIfNeeded(const LayoutObject& object, PrePaintTreeWalkContext& context)
 {
     if (!object.isBox())
         return nullptr;
     const LayoutBox& box = toLayoutBox(object);
 
     // The <input> elements can't have contents thus CSS overflow property doesn't apply.
     // However for layout purposes we do generate child layout objects for them, e.g. button label.
     // We should clip the overflow from those children. This is called control clip and we
     // technically treat them like overflow clip.
     LayoutRect clipRect;
     if (box.hasControlClip())
         clipRect = box.controlClipRect(context.paintOffset);
     else if (box.hasOverflowClip())
         clipRect = box.overflowClipRect(context.paintOffset);
     else
         return nullptr;
 
     RefPtr<ClipPaintPropertyNode> newClipNodeForBorderRadiusClip;
     const ComputedStyle& style = box.styleRef();
     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()),
         floatValueForLength(style.perspectiveOriginY(), borderBoxSize.height()));
 }
 
-static PassRefPtr<TransformPaintPropertyNode> createPerspectiveIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<TransformPaintPropertyNode> createPerspectiveIfNeeded(const LayoutObject& object, PrePaintTreeWalkContext& context)
 {
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasPerspective())
         return nullptr;
 
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = TransformPaintPropertyNode::create(
         TransformationMatrix().applyPerspective(style.perspective()),
         perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.paintOffset), context.currentTransform);
     context.currentTransform = newTransformNodeForPerspective.get();
     return newTransformNodeForPerspective.release();
 }
 
-static PassRefPtr<TransformPaintPropertyNode> createScrollTranslationIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<TransformPaintPropertyNode> createScrollTranslationIfNeeded(const LayoutObject& object, PrePaintTreeWalkContext& context)
 {
     if (!object.isBoxModelObject() || !object.hasOverflowClip())
         return nullptr;
 
     PaintLayer* layer = toLayoutBoxModelObject(object).layer();
     ASSERT(layer);
     DoubleSize scrollOffset = layer->getScrollableArea()->scrollOffset();
     if (scrollOffset.isZero() && !layer->scrollsOverflow())
         return nullptr;
 
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = TransformPaintPropertyNode::create(
         TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height()),
         FloatPoint3D(), context.currentTransform);
     context.currentTransform = newTransformNodeForScrollTranslation.get();
     return newTransformNodeForScrollTranslation.release();
 }
 
-static void updateOutOfFlowContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static void updateOutOfFlowContext(const LayoutObject& object, PrePaintTreeWalkContext& context)
 {
     // At the html->svg boundary (see: createPaintOffsetTranslationIfNeeded) the currentTransform is
     // up-to-date for all children of the svg root element. Additionally, inside SVG, all positioning
     // uses transforms. Therefore, we only need to check createdNewTransform and isSVGRoot() to
     // ensure out-of-flow and fixed positioning is correct at the svg->html boundary.
 
     if (object.canContainAbsolutePositionObjects()) {
         context.transformForAbsolutePosition = context.currentTransform;
         context.paintOffsetForAbsolutePosition = context.paintOffset;
         context.clipForAbsolutePosition = context.currentClip;
     }
 
     // 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 PrePaintTreeWalkContext& 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, PrePaintTreeWalkContext& context)
 {
-    PaintPropertyTreeBuilderContext localContext(context);
+    // Paint invalidation container is a SPv1-only concept.
+    ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
-    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 (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();
+    if (!object.isPaintInvalidationContainer()) {

[trchen, 2016/03/11 23:36:19]

This doesn't look right. I think it should be

if (!object.isPaintInvalidationContainer()) {
    if (object.isOrTreatedAsStackingContext())
        paintInvalidationContainerForNormalFlow =
paintInvalidationContainerForDescendantStackingContext;
    return;
}

paintInvalidationContainerForNormalFlow = object;
if (object.isStackingContext())
    paintInvalidationContainerForDescendantStackingContext = object;

+        if (context.paintInvalidationContainer)
+            return;
+        ASSERT(object.isLayoutView());
     }
 
-    for (LayoutObject* child = object.slowFirstChild(); child; child = child->nextSibling()) {
-        if (child->isBoxModelObject() || child->isSVG())
-            walk(*child, localContext);
+    context.currentTransform = nullptr;
+    context.paintOffset = LayoutPoint();
+    context.currentClip = nullptr;
+    context.paintInvalidationContainer = &toLayoutBoxModelObject(object);
+
+    // A composited stacking context establishes new paint invalidation container for
+    // out-of-flow-positioned descendants.
+    if (object.styleRef().isStackingContext() || !context.paintInvalidationContainerForOutOfFlowPositioned) {
+        // 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.

[trchen, 2016/03/11 23:36:19]

As pdr@ already pointed out, I don't think it makes sense to isolate property
tree per invalidation container. Actually as you handle the clip/scroll
escaping, most likely you will need the trees to produce correct paint offset.

For the classic example:
<div style="position:relative;">
  <div style="overflow:scroll;">
    <div style="opacity:0.5; will-change:opacity;">
      <div style="position:absolute;"></div>
    </div>
  </div>
</div>

The opacity div will create a paint invalidation container, and the innermost
element will paint into it, but the paint offset of the innermost element
involves converting from the viewport's transform node to the scrolling div's
transform node.

+        context.transformForAbsolutePosition = nullptr;
+        context.paintOffsetForAbsolutePosition = LayoutPoint();
+        context.clipForAbsolutePosition = nullptr;
+        context.transformForFixedPosition = nullptr;
+        context.paintOffsetForFixedPosition = LayoutPoint();
+        context.clipForFixedPosition = nullptr;
+        context.paintInvalidationContainerForOutOfFlowPositioned = &toLayoutBoxModelObject(object);
+    }
+}
+
+void PrePaintTreeWalk::walk(const LayoutObject& object, const PrePaintTreeWalkContext& context, const PaintInvalidationState* parentPaintInvalidationState)
+{
+    PrePaintTreeWalkContext localContext(context);
+    adjustContainerContextForPosition(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;

[trchen, 2016/03/11 23:36:19]

The early return check is too late, and the semantic is unclear. We should move
it to the top and say

if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() ||
!object.shouldCheckForPaintInvalidation(*paintInvalidationState)))
    return;

Then the message is clear: "quit if we have nothing to do".

+
+        PaintInvalidationReason reason = object.getMutableForPainting().invalidatePaintIfNeeded(*paintInvalidationState, *localContext.paintInvalidationContainer);
+        object.getMutableForPainting().clearPaintInvalidationState(*paintInvalidationState);
+        if (reason == PaintInvalidationDelayedFull)
+            m_pendingDelayedPaintInvalidations.append(const_cast<LayoutObject*>(&object));
+    }
+
+    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