[SPv2] Create effect nodes for CSS filter

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/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 20 matching lines @@
 ClipPaintPropertyNode* rootClipNode() {
   DEFINE_STATIC_REF(ClipPaintPropertyNode, rootClip,
                     (ClipPaintPropertyNode::create(
                         nullptr, rootTransformNode(),
                         FloatRoundedRect(LayoutRect::infiniteIntRect()))));
   return rootClip;
 }
 
 EffectPaintPropertyNode* rootEffectNode() {
   DEFINE_STATIC_REF(EffectPaintPropertyNode, rootEffect,
-                    (EffectPaintPropertyNode::create(nullptr, 1.0)));
+                    (EffectPaintPropertyNode::create(
+                        nullptr, rootTransformNode(), rootClipNode(),
+                        CompositorFilterOperations(), 1.0)));
   return rootEffect;
 }
 
 ScrollPaintPropertyNode* rootScrollNode() {
   DEFINE_STATIC_REF(
       ScrollPaintPropertyNode, rootScroll,
       (ScrollPaintPropertyNode::create(nullptr, rootTransformNode(), IntSize(),
                                        IntSize(), false, false)));
   return rootScroll;
 }
@@ skipping 288 matching lines @@
   }
 
   if (ObjectPaintProperties* properties =
           object.getMutableForPainting().objectPaintProperties())
     properties->clearTransform();
 }
 
 void PaintPropertyTreeBuilder::updateEffect(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
-  if (!object.styleRef().hasOpacity()) {
+  const ComputedStyle& style = object.styleRef();
+
+  if (!style.isStackingContext()) {

[pdr., 2016/10/22 03:58:37]

Is this needed? It seems to include hasOpacity() and
hasFilterInducingProperty().

[trchen, 2016/10/24 21:53:20]

I've thought about whether to make it a DCHECK or an early out, and decided
early out is probably a better choice.

The logic goes like:
1. An effect node is the abstraction of an isolated group. Create an effect node
whenever there is an isolated group. In HTML/CSS, every stacking context is
isolated (#1).
2. That said, we can omit creation of effect nodes if we can prove the rendering
will be equivalent. Things require proper isolation include effects applied on
the current group, children that interact with backdrop (i.e. mix-blend-mode,
backdrop-filter), and depth sorting of 3D children.

Note #1: Which is not true in SVG. SVG can actually have non-isolated stacking
context.

     if (ObjectPaintProperties* properties =
             object.getMutableForPainting().objectPaintProperties())
       properties->clearEffect();
+    return;
+  }
+
+  // TODO(trchen): Can't omit effect node if we have 3D children.
+  // TODO(trchen): Can't omit effect node if we have blending children.
+  bool effectNodeNeeded = false;
+
+  float opacity = style.opacity();
+  if (opacity != 1.0f)
+    effectNodeNeeded = true;
+
+  CompositorFilterOperations filter;

[pdr., 2016/10/22 03:58:37]

Could the following avoid the duplicated clearing code?
if (style.opacity() == 1.0f && !object->hasFilterInducingProperty())
  // clear effect and return.
// ...continue constructing effect node.

Alternatively something like:
bool effectNodeNeeded = false;
if (style.opacity() != 1.0f)
    effectNodeNeeded = true;
if (object->hasFilterInducingProperty())
    effectNodeNeeded = true;

// TODO(trchen): Can't omit effect node if we have 3D children.
// TODO(trchen): Can't omit effect node if we have blending children.

if (!effectNodeNeeded)
  // clear effect and return
// ...continue constructing effect node.

[trchen, 2016/10/24 21:53:20]

I'm thinking something like this:

bool PPTB::findIsolationReasonAndUpdateEffectNode() {
  bool effectNodeNeeded = false;
  if (opacity != 1.0)
    effectNodeNeeded = true;
  if (!filter.isEmpty())   
    effectNodeNeeded = true;

  if (!effectNodeNeeded)
    return false;

  createOrUpdateEffect(...);
  return true;
}

void PaintPropertyTreeBuilder::updateEffect() {
  if (!object.styleRef().isStackingContext() ||
!findIsolationReasonAndUpdateEffectNode())
    properties->clearEffect();
}

+  if (object.isSVG() && !object.isSVGRoot()) {
+    // TODO(trchen): SVG caches filters in SVGResources. Implement it.
+  } else {
+    // TODO(trchen): Eliminate PaintLayer dependency.
+    PaintLayer* layer = toLayoutBoxModelObject(object).layer();
+    DCHECK(layer);
+    filter = layer->createCompositorFilterOperationsForFilter(style);
+    if (!filter.isEmpty())
+      effectNodeNeeded = true;
+  }
+
+  const ClipPaintPropertyNode* outputClip = rootClipNode();
+  // 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()) {
+    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. Need to
+    // generate special clip node to hint how to expand clip / cull rect.
+    const ClipPaintPropertyNode* expansionHint = context.current.clip;
+    context.current.clip = context.absolutePosition.clip =
+        context.fixedPosition.clip = expansionHint;
+  }
+
+  if (!effectNodeNeeded) {
+    if (ObjectPaintProperties* properties =
+            object.getMutableForPainting().objectPaintProperties())
+      properties->clearEffect();
     return;
   }
 
   context.currentEffect =
       object.getMutableForPainting()
           .ensureObjectPaintProperties()
           .createOrUpdateEffect(context.currentEffect,
-                                object.styleRef().opacity());
+                                context.current.transform, outputClip,
+                                std::move(filter), object.styleRef().opacity());
 }
 
 void PaintPropertyTreeBuilder::updateCssClip(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   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
     // object must be a container for absolute position descendants, and will
     // copy from in-flow context later at updateOutOfFlowContext() step.
@@ skipping 440 matching lines @@
     return;
 
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 }
 
 }  // namespace blink