[SPv2] Add filter support in PaintArtifactCompositor

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"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/SVGRootPainter.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 PaintPropertyTreeBuilderContext
 PaintPropertyTreeBuilder::setupInitialContext() {
   PaintPropertyTreeBuilderContext context;
 
   context.current.clip = context.absolutePosition.clip =
       context.fixedPosition.clip = ClipPaintPropertyNode::root();
   context.currentEffect = EffectPaintPropertyNode::root();
+  context.inputClipOfCurrentEffect = ClipPaintPropertyNode::root();
   context.current.transform = context.absolutePosition.transform =
       context.fixedPosition.transform = TransformPaintPropertyNode::root();
   context.current.scroll = context.absolutePosition.scroll =
       context.fixedPosition.scroll = ScrollPaintPropertyNode::root();
 
   // Ensure scroll tree properties are reset. They will be rebuilt during the
   // tree walk.
   ScrollPaintPropertyNode::root()->clearMainThreadScrollingReasons();
 
   return context;
@@ skipping 310 matching lines @@
     effectNodeNeeded = true;
 
   CompositorFilterOperations filter;
   if (object.isSVG() && !object.isSVGRoot()) {
     // 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 = ClipPaintPropertyNode::root();
+  const ClipPaintPropertyNode* outputClip = context.inputClipOfCurrentEffect;
+  const ClipPaintPropertyNode* expansionHint = nullptr;
   // 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;
 
     // 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.
+    expansionHint = outputClip;

[chrishtr, 2016/11/14 19:45:10]

Why is it called expansionHint? It's not a hint is it?

[trchen, 2016/11/23 04:47:18]

We haven't implemented one yet. The output clip is used as an approximation.

   }
 
   if (effectNodeNeeded) {
     object.getMutableForPainting().ensurePaintProperties().updateEffect(
         context.currentEffect, context.current.transform, outputClip,
         std::move(filter), opacity);
   } else {
     if (auto* properties = object.getMutableForPainting().paintProperties())
       properties->clearEffect();
   }
 
   const auto* properties = object.paintProperties();
   if (properties && properties->effect()) {
     context.currentEffect = properties->effect();
-    // TODO(pdr): Once the expansion clip node is created above, it should be
-    // used here to update all current clip nodes;
-    const ClipPaintPropertyNode* expansionHint = context.current.clip;
-    context.current.clip = context.absolutePosition.clip =
-        context.fixedPosition.clip = expansionHint;
+    if (expansionHint) {
+      context.inputClipOfCurrentEffect = context.current.clip =
+          context.absolutePosition.clip = context.fixedPosition.clip =
+              expansionHint;
+    }
   }
 }
 
 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
@@ skipping 445 matching lines @@
     return;
 
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 }
 
 }  // namespace blink