[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(), 1.0, CompositorFilterOperations())));
   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()) {
     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;
+
+  // TODO(trchen): Eliminate PaintLayer dependency.
+  PaintLayer* layer = toLayoutBoxModelObject(object).layer();
+  DCHECK(layer);
+  CompositorFilterOperations 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 did not present.

[pdr., 2016/10/19 17:44:43]

Nit: did not -> is not

[trchen, 2016/10/21 23:26:39]

Done.

+  // 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.

[pdr., 2016/10/19 17:44:43]

This description is good and helped me understand what the code is doing. I
agree that matching the current behavior is the right thing to do.

+  if (!filter.isEmpty()) {
+    outputClip = context.current.clip;
+    context.current.clip = context.absolutePosition.clip =
+        context.fixedPosition.clip = rootClipNode();
+  }
+
+  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,
+                                object.styleRef().opacity(),
+                                std::move(filter));
 }
 
 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