[SPv2] Add CSS mask support

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/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 392 matching lines @@
       context.current.renderingContextId =
           properties->transform()->renderingContextId();
       context.current.shouldFlattenInheritedTransform = false;
     } else {
       context.current.renderingContextId = 0;
       context.current.shouldFlattenInheritedTransform = true;
     }
   }
 }
 
+static bool computeMaskParameters(IntRect& maskClip,
+                                  const LayoutObject& object,
+                                  const LayoutPoint& paintOffset) {
+  DCHECK(object.isBoxModelObject() || object.isSVGChild());
+  const ComputedStyle& style = object.styleRef();
+
+  if (object.isSVGChild()) {
+    // TODO(trchen): Implement SVG masks.
+    return false;
+  }
+  if (!style.hasMask())
+    return false;
+
+  LayoutRect maximumMaskRegion;
+  // For HTML/CSS objects, the extent of the mask is known as "mask
+  // painting area", which is determined by CSS mask-clip property.
+  // We don't implement mask-clip:margin-box or no-clip currently,
+  // so the maximum we can get is border-box.
+  if (object.isBox()) {
+    maximumMaskRegion = toLayoutBox(object).borderBoxRect();
+  } else {
+    // For inline elements, depends on the value of box-decoration-break
+    // there could be one box in multiple fragments or multiple boxes.
+    // Either way here we are only interested in the bounding box of them.
+    DCHECK(object.isLayoutInline());
+    maximumMaskRegion = toLayoutInline(object).linesBoundingBox();
+  }
+  maximumMaskRegion.moveBy(paintOffset);
+  maskClip = enclosingIntRect(maximumMaskRegion);
+  return true;
+}
+
 void PaintPropertyTreeBuilder::updateEffect(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   const ComputedStyle& style = object.styleRef();
 
   const bool isCSSIsolatedGroup =
       object.isBoxModelObject() && style.isStackingContext();
   if (!isCSSIsolatedGroup && !object.isSVGChild()) {
     if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
-      if (auto* properties = object.getMutableForPainting().paintProperties())
+      if (auto* properties = object.getMutableForPainting().paintProperties()) {
         context.forceSubtreeUpdate |= properties->clearEffect();
+        context.forceSubtreeUpdate |= properties->clearMask();
+        context.forceSubtreeUpdate |= properties->clearMaskClip();
+      }
     }
     return;
   }
 
   // TODO(trchen): Can't omit effect node if we have 3D children.
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
+    const ClipPaintPropertyNode* outputClip = context.inputClipOfCurrentEffect;
+
     bool effectNodeNeeded = false;
 
     // Can't omit effect node if we have paint children with exotic blending.
     if (object.isSVG()) {
       // Yes, including LayoutSVGRoot, because SVG layout objects don't create
       // PaintLayer so PaintLayer::hasNonIsolatedDescendantWithBlendMode()
       // doesn't catch SVG descendants.
       if (SVGLayoutSupport::isIsolationRequired(&object))
         effectNodeNeeded = true;
     } else if (PaintLayer* layer = toLayoutBoxModelObject(object).layer()) {
       if (layer->hasNonIsolatedDescendantWithBlendMode())
         effectNodeNeeded = true;
     }
 
     SkBlendMode blendMode = object.isBlendingAllowed()
                                 ? WebCoreCompositeToSkiaComposite(
                                       CompositeSourceOver, style.blendMode())
                                 : SkBlendMode::kSrcOver;
     if (blendMode != SkBlendMode::kSrcOver)
       effectNodeNeeded = true;
 
     float opacity = style.opacity();
     if (opacity != 1.0f)
       effectNodeNeeded = true;
 
+    // We may begin to composite our subtree prior to an animation starts,
+    // but a compositor element ID is only needed when an animation is current.
+    CompositorElementId compositorElementId =
+        style.hasCurrentOpacityAnimation()
+            ? createDomNodeBasedCompositorElementId(object)
+            : CompositorElementId();
+    CompositingReasons compositingReasons = CompositingReasonNone;
+    if (CompositingReasonFinder::requiresCompositingForOpacityAnimation(
+            style)) {
+      compositingReasons = CompositingReasonActiveAnimation;
+      effectNodeNeeded = true;
+    }
+    DCHECK(!style.hasCurrentOpacityAnimation() ||
+           compositingReasons != CompositingReasonNone);
+
+    IntRect maskClip;
+    bool hasMask =
+        computeMaskParameters(maskClip, object, context.current.paintOffset);
+    if (hasMask) {
+      effectNodeNeeded = true;
+
+      auto& properties = object.getMutableForPainting().ensurePaintProperties();
+      context.forceSubtreeUpdate |= properties.updateMaskClip(
+          context.current.clip, context.current.transform,
+          FloatRoundedRect(maskClip));
+      outputClip = properties.maskClip();
+
+      // TODO(crbug.com/683425): PaintArtifactCompositor does not handle
+      // grouping (i.e. descendant-dependent compositing reason) properly yet.
+      // This forces masked subtree always create a layer for now.
+      compositingReasons |= CompositingReasonIsolateCompositedDescendants;
+    } else {
+      if (auto* properties = object.getMutableForPainting().paintProperties())
+        context.forceSubtreeUpdate |= properties->clearMaskClip();
+    }
+
+    if (effectNodeNeeded) {
+      auto& properties = object.getMutableForPainting().ensurePaintProperties();
+      context.forceSubtreeUpdate |= properties.updateEffect(
+          context.currentEffect, context.current.transform, outputClip,
+          CompositorFilterOperations(), opacity, blendMode, compositingReasons,
+          compositorElementId);
+      if (hasMask) {
+        // TODO(crbug.com/683425): PaintArtifactCompositor does not handle
+        // grouping (i.e. descendant-dependent compositing reason) properly yet.
+        // Adding CompositingReasonSquashingDisallowed forces mask not getting
+        // squashed into a child effect. Have no compositing reason otherwise.
+        context.forceSubtreeUpdate |= properties.updateMask(
+            properties.effect(), context.current.transform, outputClip,
+            CompositorFilterOperations(), 1.f, SkBlendMode::kDstIn,
+            CompositingReasonSquashingDisallowed, CompositorElementId());
+      } else {
+        context.forceSubtreeUpdate |= properties.clearMask();
+      }
+    } else {
+      if (auto* properties = object.getMutableForPainting().paintProperties()) {
+        context.forceSubtreeUpdate |= properties->clearEffect();
+        context.forceSubtreeUpdate |= properties->clearMask();
+      }
+    }
+  }
+
+  const auto* properties = object.paintProperties();
+  if (properties && properties->effect()) {
+    context.currentEffect = properties->effect();
+    if (properties->maskClip()) {
+      context.inputClipOfCurrentEffect = context.current.clip =
+          context.absolutePosition.clip = context.fixedPosition.clip =
+              properties->maskClip();
+    }
+  }
+}
+
+void PaintPropertyTreeBuilder::updateFilter(
+    const LayoutObject& object,
+    PaintPropertyTreeBuilderContext& context) {
+  const ComputedStyle& style = object.styleRef();
+
+  if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     CompositorFilterOperations filter;
     if (object.isSVGChild()) {
       // TODO(trchen): SVG caches filters in SVGResources. Implement it.
     } else if (PaintLayer* layer = toLayoutBoxModelObject(object).layer()) {
       // TODO(trchen): Eliminate PaintLayer dependency.
       filter = layer->createCompositorFilterOperationsForFilter(style);
     }
 
-    const ClipPaintPropertyNode* outputClip = context.inputClipOfCurrentEffect;
     // The CSS filter spec didn't specify how filters interact with overflow
     // clips. The implementation here mimics the old Blink/WebKit behavior for
     // backward compatibility.
     // Basically the output of the filter will be affected by clips that applies
     // to the current element. The descendants that paints into the input of the
     // filter ignores any clips collected so far. For example:
     // <div style="overflow:scroll">
     //   <div style="filter:blur(1px);">
     //     <div>A</div>
     //     <div style="position:absolute;">B</div>
     //   </div>
     // </div>
     // In this example "A" should be clipped if the filter was not present.
     // With the filter, "A" will be rastered without clipping, but instead
     // the blurred result will be clipped.
     // On the other hand, "B" should not be clipped because the overflow clip is
     // not in its containing block chain, but as the filter output will be
     // clipped, so a blurred "B" may still be invisible.
-    if (!filter.isEmpty()) {
-      effectNodeNeeded = true;
-      outputClip = context.current.clip;
+    const ClipPaintPropertyNode* outputClip = context.current.clip;
 
-      // TODO(trchen): A filter may contain spatial operations such that an
-      // output pixel may depend on an input pixel outside of the output clip.
-      // We should generate a special clip node to represent this expansion.
-    }
+    // TODO(trchen): A filter may contain spatial operations such that an
+    // output pixel may depend on an input pixel outside of the output clip.
+    // We should generate a special clip node to represent this expansion.
 
-    CompositingReasons compositingReasons = CompositingReasonNone;
-    if (CompositingReasonFinder::requiresCompositingForEffectAnimation(style)) {
-      compositingReasons = CompositingReasonActiveAnimation;
-      effectNodeNeeded = true;
-    }
-
+    // We may begin to composite our subtree prior to an animation starts,
+    // but a compositor element ID is only needed when an animation is current.
     CompositorElementId compositorElementId =
-        (style.hasCurrentOpacityAnimation() ||
-         style.hasCurrentFilterAnimation() ||
-         style.hasCurrentBackdropFilterAnimation())
+        style.hasCurrentFilterAnimation()
             ? createDomNodeBasedCompositorElementId(object)
             : CompositorElementId();
+    CompositingReasons compositingReasons =
+        CompositingReasonFinder::requiresCompositingForFilterAnimation(style)
+            ? CompositingReasonActiveAnimation
+            : CompositingReasonNone;
+    DCHECK(!style.hasCurrentFilterAnimation() ||
+           compositingReasons != CompositingReasonNone);
 
-    if (effectNodeNeeded) {
+    if (compositingReasons == CompositingReasonNone && filter.isEmpty()) {
+      if (auto* properties = object.getMutableForPainting().paintProperties())
+        context.forceSubtreeUpdate |= properties->clearFilter();
+    } else {
       auto& properties = object.getMutableForPainting().ensurePaintProperties();
-      context.forceSubtreeUpdate |= properties.updateEffect(
+      context.forceSubtreeUpdate |= properties.updateFilter(
           context.currentEffect, context.current.transform, outputClip,
-          std::move(filter), opacity, blendMode, compositingReasons,
+          std::move(filter), 1.f, SkBlendMode::kSrcOver, compositingReasons,
           compositorElementId);
-    } else {
-      if (auto* properties = object.getMutableForPainting().paintProperties())
-        context.forceSubtreeUpdate |= properties->clearEffect();
     }
   }
 
   const auto* properties = object.paintProperties();
-  if (properties && properties->effect()) {
-    context.currentEffect = properties->effect();
-    if (!properties->effect()->filter().isEmpty()) {
-      // TODO(trchen): Change input clip to expansion hint once implemented.
-      const ClipPaintPropertyNode* inputClip =
-          properties->effect()->outputClip();
-      context.inputClipOfCurrentEffect = context.current.clip =
-          context.absolutePosition.clip = context.fixedPosition.clip =
-              inputClip;
-    }
+  if (properties && properties->filter()) {
+    context.currentEffect = properties->filter();
+    // TODO(trchen): Change input clip to expansion hint once implemented.
+    const ClipPaintPropertyNode* inputClip = properties->filter()->outputClip();
+    context.inputClipOfCurrentEffect = context.current.clip =
+        context.absolutePosition.clip = context.fixedPosition.clip = inputClip;
   }
 }
 
 void PaintPropertyTreeBuilder::updateCssClip(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     if (object.hasClip()) {
       // Create clip node for descendants that are not fixed position.
       // We don't have to setup context.absolutePosition.clip here because this
@@ skipping 409 matching lines @@
   // This is not in FindObjectPropertiesNeedingUpdateScope because paint offset
   // can change without needsPaintPropertyUpdate.
   updateForObjectLocation(object, context);
 
 #if DCHECK_IS_ON()
   FindObjectPropertiesNeedingUpdateScope checkNeedsUpdateScope(object, context);
 #endif
 
   if (object.isBoxModelObject() || object.isSVG()) {
     updateTransform(object, context);
-    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       updateEffect(object, context);
+      updateFilter(object, context);
+    }
     updateCssClip(object, context);
     updateLocalBorderBoxContext(object, context);
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
       updateScrollbarPaintOffset(object, context);
   }
 }
 
 void PaintPropertyTreeBuilder::updatePropertiesForChildren(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
 #if DCHECK_IS_ON()
   FindObjectPropertiesNeedingUpdateScope checkNeedsUpdateScope(object, context);
 #endif
 
   if (!object.isBoxModelObject() && !object.isSVG())
     return;
 
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink