[SPv2] Implement effect compositing for indirect reasons

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp

 // Copyright 2016 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 "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include <memory>
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 529 matching lines @@
   TestPaintArtifact artifact;
   artifact
       .chunk(TransformPaintPropertyNode::root(), clip1,
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 640, 480), Color::white);
   artifact
       .chunk(TransformPaintPropertyNode::root(), clip2,
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 640, 480), Color::black);
   update(artifact.build());
-
   ASSERT_EQ(2u, contentLayerCount());
 
   const cc::Layer* whiteLayer = contentLayerAt(0);
   EXPECT_THAT(whiteLayer->GetPicture(),
               Pointee(drawsRectangle(FloatRect(0, 0, 640, 480), Color::white)));
   EXPECT_EQ(gfx::Transform(), whiteLayer->screen_space_transform());
   const cc::ClipNode* whiteClip =
       propertyTrees().clip_tree.Node(whiteLayer->clip_tree_index());
   EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, whiteClip->clip_type);
   EXPECT_TRUE(whiteClip->layers_are_clipped);
@@ skipping 28 matching lines @@
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact.chunk(defaultPaintChunkProperties())
       .foreignLayer(FloatPoint(50, 60), IntSize(400, 300), layer);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer1(
-      artifact.paintChunks()[0]);
-  // Foreign layers can't merge.
-  EXPECT_FALSE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer1));
-  PaintArtifactCompositor::PendingLayer pendingLayer2(
-      artifact.paintChunks()[1]);
-  EXPECT_FALSE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer2));
-
   update(artifact);
 
   ASSERT_EQ(3u, contentLayerCount());
   EXPECT_EQ(layer, contentLayerAt(1));
   EXPECT_EQ(gfx::Size(400, 300), layer->bounds());
   EXPECT_EQ(translation(50, 60), layer->screen_space_transform());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectTreeConversion) {
-  RefPtr<EffectPaintPropertyNode> effect1 =
-      createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
-  RefPtr<EffectPaintPropertyNode> effect2 =
-      createOpacityOnlyEffect(effect1, 0.3);
-  RefPtr<EffectPaintPropertyNode> effect3 =
-      createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.2);
+  RefPtr<EffectPaintPropertyNode> effect1 = EffectPaintPropertyNode::create(

[chrishtr, 2017/02/28 22:50:36]

Why can't you use createOpacityOnlyEffect and add an argument to specify
compositing
reasons?

[trchen, 2017/03/01 01:26:11]

Actually I'm thinking to abuse designated initializer to implement optional
keyword arguments. Pattern like this:

class EffectPaintPropertyNode {
public:
  struct Params {
    PassRefPtr<EffectPaintPropertyNode> parent = nullptr;
    float opacity = 1.0;
    SkBlendMode blendMode = kSrcOver;
    CompositorFilterOperation filter;
    CompositingReasons compositingReasons = CompositingReasonNone;
    ...
  };
  PassRefPtr<EffectPaintPropertyNode> create(const Params&);
};

void func() {
  RefPtr<EffectPaintPropertyNode> newNode =
EffectPaintPropertyNode::create({.parent = EffectPaintPropertyNode::root(),
.opacity = 0.5, .compositingReasons = CompositingReasonAll});
}

The style guide doesn't say whether it's approved or not, but I don't see any
obvious foot gun.

+      EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      ClipPaintPropertyNode::root(), ColorFilterNone,
+      CompositorFilterOperations(), 0.5, SkBlendMode::kSrcOver,
+      CompositingReasonAll);
+  RefPtr<EffectPaintPropertyNode> effect2 = EffectPaintPropertyNode::create(
+      effect1, TransformPaintPropertyNode::root(),
+      ClipPaintPropertyNode::root(), ColorFilterNone,
+      CompositorFilterOperations(), 0.3, SkBlendMode::kSrcOver,
+      CompositingReasonAll);
+  RefPtr<EffectPaintPropertyNode> effect3 = EffectPaintPropertyNode::create(
+      EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      ClipPaintPropertyNode::root(), ColorFilterNone,
+      CompositorFilterOperations(), 0.2, SkBlendMode::kSrcOver,
+      CompositingReasonAll);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              effect2.get())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   artifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              effect1.get())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
@@ skipping 141 matching lines @@
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, NestedScrollNodes) {
   RefPtr<EffectPaintPropertyNode> effect =
       createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
 
   CompositorElementId expectedCompositorElementIdA = CompositorElementId(2, 0);
   RefPtr<TransformPaintPropertyNode> scrollTranslationA =
       TransformPaintPropertyNode::createScrollTranslation(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(11, 13), FloatPoint3D(), false, 0,
-          CompositingReasonNone, expectedCompositorElementIdA,
-          ScrollPaintPropertyNode::root(), IntSize(2, 3), IntSize(5, 7), false,
-          true, MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects,
+          CompositingReasonLayerForScrollingContents,
+          expectedCompositorElementIdA, ScrollPaintPropertyNode::root(),
+          IntSize(2, 3), IntSize(5, 7), false, true,
+          MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects,
           nullptr);
 
   CompositorElementId expectedCompositorElementIdB = CompositorElementId(3, 0);
   RefPtr<TransformPaintPropertyNode> scrollTranslationB =
       TransformPaintPropertyNode::createScrollTranslation(
           scrollTranslationA, TransformationMatrix().translate(37, 41),
           FloatPoint3D(), false, 0, CompositingReasonNone,
           expectedCompositorElementIdB, scrollTranslationA->scrollNode(),
           IntSize(19, 23), IntSize(29, 31), true, false,
           0 /* mainThreadScrollingReasons */, nullptr);
@@ skipping 34 matching lines @@
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(2u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-
   update(artifact);
 
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 200, 300), Color::gray));
 
@@ skipping 17 matching lines @@
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
 
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
-
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // Clip is applied to this PaintChunk.
     rectsWithColor.push_back(
         RectWithColor(FloatRect(10, 20, 50, 60), Color::black));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 300, 400), Color::gray));
@@ skipping 18 matching lines @@
   testArtifact
       .chunk(transform.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
-
   update(artifact);
 
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // Transform is applied to this PaintChunk.
     rectsWithColor.push_back(
         RectWithColor(FloatRect(50, 50, 100, 100), Color::black));
@@ skipping 23 matching lines @@
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   // The second chunk can merge into the first because it has a descendant
   // state of the first's transform and no direct compositing reason.
   testArtifact
       .chunk(transform2.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(2u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // Transform is applied to this PaintChunk.
     rectsWithColor.push_back(
         RectWithColor(FloatRect(50, 50, 100, 100), Color::black));
 
     const cc::Layer* layer = contentLayerAt(0);
@@ skipping 15 matching lines @@
   testArtifact
       .chunk(transform.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 42, 100, 100), Color::white));
     // Transform is applied to this PaintChunk.
     rectsWithColor.push_back(RectWithColor(
         FloatRect(29.2893, 0.578644, 141.421, 141.421), Color::black));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(00, 42, 200, 300), Color::gray));
@@ skipping 16 matching lines @@
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              effect.get())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
-
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // Transform is applied to this PaintChunk.
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100),
                       Color(Color::black).combineWithAlpha(opacity).rgb()));
     rectsWithColor.push_back(
@@ skipping 30 matching lines @@
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact.chunk(transform.get(), clip.get(), effect.get())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // Transform is applied to this PaintChunk.
     rectsWithColor.push_back(
         RectWithColor(FloatRect(60, 70, 50, 60),
                       Color(Color::black).combineWithAlpha(opacity).rgb()));
     rectsWithColor.push_back(
@@ skipping 32 matching lines @@
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), clip.get(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // The two transforms (combined translation of (40, 50)) are applied here,
     // before clipping.
     rectsWithColor.push_back(
         RectWithColor(FloatRect(50, 70, 50, 60), Color(Color::black)));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 200, 300), Color::gray));
 
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(), Pointee(drawsRectangles(rectsWithColor)));
   }
 }
 
-TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectPushedUp) {
+// TODO(crbug.com/696842): The effect refuses to "decomposite" because it's in
+// a deeper transform space than its chunk. We should allow decomposite if
+// the two transform nodes share the same direct compositing ancestor.
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectPushedUp_DISABLED) {
   // Tests merging of an element which has an effect applied to it,
   // but has an ancestor transform of them. This can happen for fixed-
   // or absolute-position elements which escape scroll transforms.
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
           false, 0);
 
@@ skipping 16 matching lines @@
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              effect.get())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 300, 400),
                       Color(Color::black).combineWithAlpha(opacity).rgb()));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 200, 300), Color::gray));
 
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(), Pointee(drawsRectangles(rectsWithColor)));
   }
 }
 
-TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectAndClipPushedUp) {
+// TODO(crbug.com/696842): The effect refuses to "decomposite" because it's in
+// a deeper transform space than its chunk. We should allow decomposite if
+// the two transform nodes share the same direct compositing ancestor.
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       EffectAndClipPushedUp_DISABLED) {
   // Tests merging of an element which has an effect applied to it,
   // but has an ancestor transform of them. This can happen for fixed-
   // or absolute-position elements which escape scroll transforms.
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
           false, 0);
 
@@ skipping 19 matching lines @@
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), clip.get(), effect.get())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // The clip is under |transform| but not |transform2|, so only an adjustment
     // of (20, 25) occurs.
     rectsWithColor.push_back(
         RectWithColor(FloatRect(30, 45, 50, 60),
                       Color(Color::black).combineWithAlpha(opacity).rgb()));
@@ skipping 26 matching lines @@
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), clip.get(), effect.get())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(10, 20, 50, 60),
                       Color(Color::black).combineWithAlpha(opacity).rgb()));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 200, 300), Color::gray));
@@ skipping 23 matching lines @@
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), clip2.get(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
-
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     // The interesction of the two clips is (20, 30, 10, 20).
     rectsWithColor.push_back(
         RectWithColor(FloatRect(20, 30, 10, 20), Color(Color::black)));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 200, 300), Color::gray));
@@ skipping 21 matching lines @@
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(transform2.get(), clip.get(), EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
+
   const PaintArtifact& artifact = testArtifact.build();
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-  pendingLayer.add(artifact.paintChunks()[1], nullptr);
-  EXPECT_TRUE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer));
   update(artifact);
   ASSERT_EQ(1u, contentLayerCount());
   {
     Vector<RectWithColor> rectsWithColor;
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::white));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(40, 50, 50, 60), Color(Color::black)));
     rectsWithColor.push_back(
         RectWithColor(FloatRect(0, 0, 200, 300), Color::gray));
@@ skipping 13 matching lines @@
   testArtifact.chunk(defaultPaintChunkProperties())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(transform.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
   testArtifact.chunk(defaultPaintChunkProperties())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
 
   const PaintArtifact& artifact = testArtifact.build();
-
   ASSERT_EQ(3u, artifact.paintChunks().size());
-  PaintArtifactCompositor::PendingLayer pendingLayer(artifact.paintChunks()[0]);
-
-  EXPECT_FALSE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[1], pendingLayer));
-
-  PaintArtifactCompositor::PendingLayer pendingLayer2(
-      artifact.paintChunks()[1]);
-  EXPECT_FALSE(PaintArtifactCompositor::canMergeInto(
-      artifact, artifact.paintChunks()[2], pendingLayer2));
-
-  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
-  EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(
-      artifact.paintChunks()[2], pendingLayer2, *geometryMapper));
-
   update(artifact);
-
   // The third paint chunk overlaps the second but can't merge due to
   // incompatible transform. The second paint chunk can't merge into the first
   // due to a direct compositing reason.
   ASSERT_EQ(3u, contentLayerCount());
 }
 
-TEST_F(PaintArtifactCompositorTestWithPropertyTrees, MightOverlap) {
-  PaintChunk paintChunk;
-  paintChunk.properties = defaultPaintChunkProperties();
-  paintChunk.bounds = FloatRect(0, 0, 100, 100);
-
-  PaintChunk paintChunk2;
-  paintChunk2.properties = defaultPaintChunkProperties();
-  paintChunk2.bounds = FloatRect(0, 0, 100, 100);
-
-  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
-  PaintArtifactCompositor::PendingLayer pendingLayer(paintChunk);
-  EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(paintChunk2, pendingLayer,
-                                                    *geometryMapper));
-
-  RefPtr<TransformPaintPropertyNode> transform =
-      TransformPaintPropertyNode::create(
-          TransformPaintPropertyNode::root(),
-          TransformationMatrix().translate(99, 0), FloatPoint3D(100, 100, 0),
-          false);
-
-  paintChunk2.properties.propertyTreeState.setTransform(transform.get());
-  EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(paintChunk2, pendingLayer,
-                                                    *geometryMapper));
-
-  RefPtr<TransformPaintPropertyNode> transform2 =
-      TransformPaintPropertyNode::create(
-          TransformPaintPropertyNode::root(),
-          TransformationMatrix().translate(100, 0), FloatPoint3D(100, 100, 0),
-          false);
-  paintChunk2.properties.propertyTreeState.setTransform(transform2.get());
-
-  EXPECT_FALSE(PaintArtifactCompositor::mightOverlap(paintChunk2, pendingLayer,
-                                                     *geometryMapper));
-}
-
-TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayer) {
-  PaintChunk chunk1;
-  chunk1.properties.propertyTreeState = PropertyTreeState(
-      TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
-      EffectPaintPropertyNode::root());
-  chunk1.properties.backfaceHidden = true;
-  chunk1.knownToBeOpaque = true;
-  chunk1.bounds = FloatRect(0, 0, 30, 40);
-
-  PaintArtifactCompositor::PendingLayer pendingLayer(chunk1);
-
-  EXPECT_TRUE(pendingLayer.backfaceHidden);
-  EXPECT_TRUE(pendingLayer.knownToBeOpaque);
-  EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 40), pendingLayer.bounds);
-
-  PaintChunk chunk2;
-  chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
-  chunk2.properties.backfaceHidden = true;
-  chunk2.knownToBeOpaque = true;
-  chunk2.bounds = FloatRect(10, 20, 30, 40);
-  pendingLayer.add(chunk2, nullptr);
-
-  EXPECT_TRUE(pendingLayer.backfaceHidden);
-  // Bounds not equal to one PaintChunk.
-  EXPECT_FALSE(pendingLayer.knownToBeOpaque);
-  EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 40, 60), pendingLayer.bounds);
-
-  PaintChunk chunk3;
-  chunk3.properties.propertyTreeState = chunk1.properties.propertyTreeState;
-  chunk3.properties.backfaceHidden = true;
-  chunk3.knownToBeOpaque = true;
-  chunk3.bounds = FloatRect(-5, -25, 20, 20);
-  pendingLayer.add(chunk3, nullptr);
-
-  EXPECT_TRUE(pendingLayer.backfaceHidden);
-  EXPECT_FALSE(pendingLayer.knownToBeOpaque);
-  EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(-5, -25, 45, 85), pendingLayer.bounds);
-}
-
-TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayerWithGeometry) {
-  RefPtr<TransformPaintPropertyNode> transform =
-      TransformPaintPropertyNode::create(
-          TransformPaintPropertyNode::root(),
-          TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
-          false, 0);
-
-  PaintChunk chunk1;
-  chunk1.properties.propertyTreeState = PropertyTreeState(
-      TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
-      EffectPaintPropertyNode::root());
-  chunk1.bounds = FloatRect(0, 0, 30, 40);
-
-  PaintArtifactCompositor::PendingLayer pendingLayer(chunk1);
-
-  EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 40), pendingLayer.bounds);
-
-  PaintChunk chunk2;
-  chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
-  chunk2.properties.propertyTreeState.setTransform(transform);
-  chunk2.bounds = FloatRect(0, 0, 50, 60);
-  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
-  pendingLayer.add(chunk2, geometryMapper.get());
-
-  EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 70, 85), pendingLayer.bounds);
-}
-
-TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayerKnownOpaque) {
-  PaintChunk chunk1;
-  chunk1.properties.propertyTreeState = PropertyTreeState(
-      TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
-      EffectPaintPropertyNode::root());
-  chunk1.bounds = FloatRect(0, 0, 30, 40);
-  chunk1.knownToBeOpaque = false;
-  PaintArtifactCompositor::PendingLayer pendingLayer(chunk1);
-
-  EXPECT_FALSE(pendingLayer.knownToBeOpaque);
-
-  PaintChunk chunk2;
-  chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
-  chunk2.bounds = FloatRect(0, 0, 25, 35);
-  chunk2.knownToBeOpaque = true;
-  pendingLayer.add(chunk2, nullptr);
-
-  // Chunk 2 doesn't cover the entire layer, so not opaque.
-  EXPECT_FALSE(pendingLayer.knownToBeOpaque);
-
-  PaintChunk chunk3;
-  chunk3.properties.propertyTreeState = chunk1.properties.propertyTreeState;
-  chunk3.bounds = FloatRect(0, 0, 50, 60);
-  chunk3.knownToBeOpaque = true;
-  pendingLayer.add(chunk3, nullptr);
-
-  // Chunk 3 covers the entire layer, so now it's opaque.
-  EXPECT_TRUE(pendingLayer.knownToBeOpaque);
-}
-
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, TransformWithElementId) {
   CompositorElementId expectedCompositorElementId(2, 0);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(), TransformationMatrix().rotate(90),
           FloatPoint3D(100, 100, 0), false, 0, CompositingReason3DTransform,
           expectedCompositorElementId);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(transform, ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
   update(artifact.build());
 
   EXPECT_EQ(2, elementIdToTransformNodeIndex(expectedCompositorElementId));
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectWithElementId) {
   CompositorElementId expectedCompositorElementId(2, 0);
   float opacity = 2.0 / 255.0;
   RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::create(
       EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       ClipPaintPropertyNode::root(), ColorFilterNone,
       CompositorFilterOperations(), opacity, SkBlendMode::kSrcOver,
-      CompositingReasonNone, expectedCompositorElementId);
+      CompositingReasonActiveAnimation, expectedCompositorElementId);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              effect.get())
       .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
   update(artifact.build());
 
   EXPECT_EQ(2, elementIdToEffectNodeIndex(expectedCompositorElementId));
 }
@@ skipping 12 matching lines @@
   TestPaintArtifact artifact;
   artifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              masked.get())
       .rectDrawing(FloatRect(100, 100, 200, 200), Color::gray);
   artifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              masking.get())
       .rectDrawing(FloatRect(150, 150, 100, 100), Color::white);
   update(artifact.build());
-
   ASSERT_EQ(2u, contentLayerCount());
 
   const cc::Layer* maskedLayer = contentLayerAt(0);
   EXPECT_THAT(maskedLayer->GetPicture(),
               Pointee(drawsRectangle(FloatRect(0, 0, 200, 200), Color::gray)));
   EXPECT_EQ(translation(100, 100), maskedLayer->screen_space_transform());
   EXPECT_EQ(gfx::Size(200, 200), maskedLayer->bounds());
   const cc::EffectNode* maskedGroup =
       propertyTrees().effect_tree.Node(maskedLayer->effect_tree_index());
   EXPECT_TRUE(maskedGroup->has_render_surface);
 
   const cc::Layer* maskingLayer = contentLayerAt(1);
   EXPECT_THAT(maskingLayer->GetPicture(),
               Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::white)));
   EXPECT_EQ(translation(150, 150), maskingLayer->screen_space_transform());
   EXPECT_EQ(gfx::Size(100, 100), maskingLayer->bounds());
   const cc::EffectNode* maskingGroup =
       propertyTrees().effect_tree.Node(maskingLayer->effect_tree_index());
   EXPECT_TRUE(maskingGroup->has_render_surface);
   EXPECT_EQ(maskedGroup->id, maskingGroup->parent_id);
   ASSERT_EQ(1u, maskingGroup->filters.size());
   EXPECT_EQ(cc::FilterOperation::REFERENCE, maskingGroup->filters.at(0).type());
 }
 
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, DecompositeEffect) {
+  // An effect node without direct compositing reason and does not need to
+  // group compositing descendants should not be composited and can merge
+  // with other chunks.
+
+  RefPtr<EffectPaintPropertyNode> effect =
+      createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
+
+  TestPaintArtifact artifact;
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(50, 25, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect.get())
+      .rectDrawing(FloatRect(25, 75, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(75, 75, 100, 100), Color::gray);
+  update(artifact.build());
+  ASSERT_EQ(1u, contentLayerCount());
+
+  const cc::Layer* layer = contentLayerAt(0);
+  EXPECT_EQ(gfx::Vector2dF(25.f, 25.f), layer->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(150, 150), layer->bounds());
+  EXPECT_EQ(1, layer->effect_tree_index());
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, DirectlyCompositedEffect) {
+  // An effect node with direct compositing shall be composited.
+  RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::create(
+      EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      ClipPaintPropertyNode::root(), ColorFilterNone,
+      CompositorFilterOperations(), 0.5f, SkBlendMode::kSrcOver,
+      CompositingReasonAll);
+
+  TestPaintArtifact artifact;
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(50, 25, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect.get())
+      .rectDrawing(FloatRect(25, 75, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(75, 75, 100, 100), Color::gray);
+  update(artifact.build());
+  ASSERT_EQ(3u, contentLayerCount());
+
+  const cc::Layer* layer1 = contentLayerAt(0);
+  EXPECT_EQ(gfx::Vector2dF(50.f, 25.f), layer1->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer1->bounds());
+  EXPECT_EQ(1, layer1->effect_tree_index());
+
+  const cc::Layer* layer2 = contentLayerAt(1);
+  EXPECT_EQ(gfx::Vector2dF(25.f, 75.f), layer2->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer2->bounds());
+  const cc::EffectNode* effectNode =
+      propertyTrees().effect_tree.Node(layer2->effect_tree_index());
+  EXPECT_EQ(1, effectNode->parent_id);
+  EXPECT_EQ(0.5f, effectNode->opacity);
+
+  const cc::Layer* layer3 = contentLayerAt(2);
+  EXPECT_EQ(gfx::Vector2dF(75.f, 75.f), layer3->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer3->bounds());
+  EXPECT_EQ(1, layer3->effect_tree_index());
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, DecompositeDeepEffect) {
+  // A paint chunk may enter multiple level effects with or without compositing
+  // reasons. This test verifies we still decomposite effects without a direct
+  // reason, but stop at a directly composited effect.
+  RefPtr<EffectPaintPropertyNode> effect1 =
+      createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.1f);
+  RefPtr<EffectPaintPropertyNode> effect2 = EffectPaintPropertyNode::create(
+      effect1, TransformPaintPropertyNode::root(),
+      ClipPaintPropertyNode::root(), ColorFilterNone,
+      CompositorFilterOperations(), 0.2f, SkBlendMode::kSrcOver,
+      CompositingReasonAll);
+  RefPtr<EffectPaintPropertyNode> effect3 =
+      createOpacityOnlyEffect(effect2, 0.3f);
+
+  TestPaintArtifact artifact;
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(50, 25, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect3.get())
+      .rectDrawing(FloatRect(25, 75, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(75, 75, 100, 100), Color::gray);
+  update(artifact.build());
+  ASSERT_EQ(3u, contentLayerCount());
+
+  const cc::Layer* layer1 = contentLayerAt(0);
+  EXPECT_EQ(gfx::Vector2dF(50.f, 25.f), layer1->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer1->bounds());
+  EXPECT_EQ(1, layer1->effect_tree_index());
+
+  const cc::Layer* layer2 = contentLayerAt(1);
+  EXPECT_EQ(gfx::Vector2dF(25.f, 75.f), layer2->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer2->bounds());
+  const cc::EffectNode* effectNode2 =
+      propertyTrees().effect_tree.Node(layer2->effect_tree_index());
+  EXPECT_EQ(0.2f, effectNode2->opacity);
+  const cc::EffectNode* effectNode1 =
+      propertyTrees().effect_tree.Node(effectNode2->parent_id);
+  EXPECT_EQ(1, effectNode1->parent_id);
+  EXPECT_EQ(0.1f, effectNode1->opacity);
+
+  const cc::Layer* layer3 = contentLayerAt(2);
+  EXPECT_EQ(gfx::Vector2dF(75.f, 75.f), layer3->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer3->bounds());
+  EXPECT_EQ(1, layer3->effect_tree_index());
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       IndirectlyCompositedEffect) {
+  // An effect node without direct compositing still needs to be composited
+  // for grouping, if some chunks need to be composited.
+  RefPtr<EffectPaintPropertyNode> effect =
+      createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5f);
+  RefPtr<TransformPaintPropertyNode> transform =
+      TransformPaintPropertyNode::create(
+          TransformPaintPropertyNode::root(), TransformationMatrix(),
+          FloatPoint3D(), false, 0, CompositingReason3DTransform);
+
+  TestPaintArtifact artifact;
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(50, 25, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect.get())
+      .rectDrawing(FloatRect(25, 75, 100, 100), Color::gray);
+  artifact.chunk(transform.get(), ClipPaintPropertyNode::root(), effect.get())
+      .rectDrawing(FloatRect(75, 75, 100, 100), Color::gray);
+  update(artifact.build());
+  ASSERT_EQ(3u, contentLayerCount());
+
+  const cc::Layer* layer1 = contentLayerAt(0);
+  EXPECT_EQ(gfx::Vector2dF(50.f, 25.f), layer1->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer1->bounds());
+  EXPECT_EQ(1, layer1->effect_tree_index());
+
+  const cc::Layer* layer2 = contentLayerAt(1);
+  EXPECT_EQ(gfx::Vector2dF(25.f, 75.f), layer2->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer2->bounds());
+  const cc::EffectNode* effectNode =
+      propertyTrees().effect_tree.Node(layer2->effect_tree_index());
+  EXPECT_EQ(1, effectNode->parent_id);
+  EXPECT_EQ(0.5f, effectNode->opacity);
+
+  const cc::Layer* layer3 = contentLayerAt(2);
+  EXPECT_EQ(gfx::Vector2dF(75.f, 75.f), layer3->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(100, 100), layer3->bounds());
+  EXPECT_EQ(effectNode->id, layer3->effect_tree_index());
+}
+
 }  // namespace blink