[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 412 matching lines @@
       context.current.renderingContextId =
           properties->transform()->renderingContextId();
       context.current.shouldFlattenInheritedTransform = false;
     } else {
       context.current.renderingContextId = 0;
       context.current.shouldFlattenInheritedTransform = true;
     }
   }
 }
 
+void PaintPropertyTreeBuilder::updateMask(
+    const LayoutObject& object,
+    PaintPropertyTreeBuilderContext& context) {
+  DCHECK(object.isBoxModelObject() || object.isSVGChild());
+  const ComputedStyle& style = object.styleRef();
+
+  bool hasMask = false;
+  IntRect maskClip;
+  if (object.isSVGChild()) {
+    // TODO(trchen): Figure out what to do with SVG. SVG may use object
+    // bounding box for mask sizing, but computing it requires property
+    // tree to be built.
+  } else if (style.hasMask()) {
+    // 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.
+    LayoutRect maximumMaskRegion;
+    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(context.current.paintOffset);
+    maskClip = enclosingIntRect(maximumMaskRegion);
+    hasMask = true;
+  }
+
+  if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
+    if (hasMask) {
+      SkBlendMode blendMode = object.isBlendingAllowed()
+                                  ? WebCoreCompositeToSkiaComposite(
+                                        CompositeSourceOver, style.blendMode())
+                                  : SkBlendMode::kSrcOver;
+      float opacity = style.opacity();
+
+      auto& properties = object.getMutableForPainting().ensurePaintProperties();
+      context.forceSubtreeUpdate |= properties.updateMaskClip(
+          context.current.clip, context.current.transform,
+          FloatRoundedRect(maskClip));
+      context.forceSubtreeUpdate |= properties.updateMaskIsolation(
+          context.currentEffect, context.current.transform,
+          properties.maskClip(), CompositorFilterOperations(), opacity,
+          blendMode, CompositingReasonNone, CompositorElementId());
+      context.forceSubtreeUpdate |= properties.updateMaskContent(
+          properties.maskIsolation(), context.current.transform,
+          properties.maskClip(), CompositorFilterOperations(), 1.f,
+          SkBlendMode::kDstIn, CompositingReasonNone, CompositorElementId());
+    } else if (auto* properties =
+                   object.getMutableForPainting().paintProperties()) {
+      context.forceSubtreeUpdate |= properties->clearMaskClip();
+      context.forceSubtreeUpdate |= properties->clearMaskIsolation();
+      context.forceSubtreeUpdate |= properties->clearMaskContent();
+    }
+  }
+
+  if (hasMask) {
+    auto& properties = *object.getMutableForPainting().paintProperties();
+    context.inputClipOfCurrentEffect = context.current.clip =
+        context.absolutePosition.clip = context.fixedPosition.clip =
+            properties.maskClip();
+    context.currentEffect = properties.maskIsolation();
+  }
+}
+
 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())
         context.forceSubtreeUpdate |= properties->clearEffect();
     }
     return;
   }
 
   // TODO(trchen): Can't omit effect node if we have 3D children.
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
+    bool blendModeAndOpacityAlreadyApplied = false;

[trchen, 2017/01/21 01:27:08]

I feel this blend mode & opacity juggling will make a maintenance headache.

Maybe we should make {blend mode, opacity, mask, child isolation} the primary
group of effect and split filter from them? i.e. a primary effect node is
created iff. one or more of above effect is present. Plus one effect node that
is created iff. a filter exists. WDYT?

[chrishtr, 2017/01/24 01:16:28]

How about just making different nodes for all of them, and then the PAC can
simplify if it sees
two in a row with no content between?

[trchen, 2017/02/11 02:35:45]

As discussed offline. Kick filter out is the most convenient thing for now.

+    if (auto* properties = object.getMutableForPainting().paintProperties())
+      blendModeAndOpacityAlreadyApplied = !!properties->maskIsolation();
+
     bool effectNodeNeeded = false;
 
     // Can't omit effect node if we have paint children with exotic blending.
-    if (object.isSVG()) {
+    if (blendModeAndOpacityAlreadyApplied) {
+      // No-op. The current effect node already isolated for us.
+    } else 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;
+    SkBlendMode blendMode =
+        (!blendModeAndOpacityAlreadyApplied && object.isBlendingAllowed())
+            ? WebCoreCompositeToSkiaComposite(CompositeSourceOver,
+                                              style.blendMode())
+            : SkBlendMode::kSrcOver;
     if (blendMode != SkBlendMode::kSrcOver)
       effectNodeNeeded = true;
 
-    float opacity = style.opacity();
+    float opacity = blendModeAndOpacityAlreadyApplied ? 1.0f : style.opacity();
     if (opacity != 1.0f)
       effectNodeNeeded = true;
 
     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);
     }
@@ skipping 473 matching lines @@
 void PaintPropertyTreeBuilder::updatePropertiesForSelf(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
 #if DCHECK_IS_ON()
   FindObjectPropertiesNeedingUpdateScope checkNeedsUpdateScope(object, context);
 #endif
 
   if (object.isBoxModelObject() || object.isSVG()) {
     updatePaintOffsetTranslation(object, context);
     updateTransform(object, context);
+    updateMask(object, context);
     updateEffect(object, context);
     updateCssClip(object, context);
     updateLocalBorderBoxContext(object, context);
     updateScrollbarPaintOffset(object, context);
   }
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
         object.paintOffset() != context.current.paintOffset) {
       object.getMutableForPainting().setShouldDoFullPaintInvalidation(
@@ skipping 16 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink