[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(
+      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);
+  PaintArtifactCompositor::PendingLayer pendingLayer(paintChunk, false);
 
   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));
+
+  {
+    PaintArtifactCompositor::PendingLayer pendingLayer2(paintChunk2, false);
+    EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(
+        pendingLayer, pendingLayer2, *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));
+  {
+    paintChunk2.properties.propertyTreeState.setTransform(transform.get());
+    PaintArtifactCompositor::PendingLayer pendingLayer2(paintChunk2, false);
+    EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(
+        pendingLayer, pendingLayer2, *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));
+  {
+    paintChunk2.properties.propertyTreeState.setTransform(transform2.get());
+    PaintArtifactCompositor::PendingLayer pendingLayer2(paintChunk2, false);
+    EXPECT_FALSE(PaintArtifactCompositor::mightOverlap(
+        pendingLayer, pendingLayer2, *geometryMapper));
+  }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayer) {
+  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
+
   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);
+  PaintArtifactCompositor::PendingLayer pendingLayer(chunk1, false);
 
   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);
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false),
+                     *geometryMapper);
 
   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);
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk3, false),
+                     *geometryMapper);
 
   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);
+  PaintArtifactCompositor::PendingLayer pendingLayer(chunk1, false);
 
   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());
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false),
+                     *geometryMapper);
 
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 70, 85), pendingLayer.bounds);
 }
 
-TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayerKnownOpaque) {
+// TODO(crbug.com/701991):
+// The test is disabled because opaque rect mapping is not implemented yet.
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       PendingLayerKnownOpaque_DISABLED) {
+  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
+
   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);
+  PaintArtifactCompositor::PendingLayer pendingLayer(chunk1, false);
 
   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);
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false),
+                     *geometryMapper);
 
   // 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);
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk3, false),
+                     *geometryMapper);
 
   // 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),
@@ skipping 10 matching lines @@
   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);
@@ skipping 56 matching lines @@
   update(artifact.build());
 
   EXPECT_EQ(5u, rootLayer()->children().size());
   sequenceNumber++;
   EXPECT_EQ(sequenceNumber, propertyTrees().sequence_number);
   for (auto layer : rootLayer()->children()) {
     EXPECT_EQ(sequenceNumber, layer->property_tree_sequence_number());
   }
 }
 
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, DecompositeClip) {
+  // A clipped paint chunk that gets merged into a previous layer should
+  // only contribute clipped bounds to the layer bound.
+
+  RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(75, 75, 100, 100));
+
+  TestPaintArtifact artifact;
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(50, 50, 100, 100), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip.get(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(100, 100, 100, 100), Color::gray);
+  update(artifact.build());
+  ASSERT_EQ(1u, contentLayerCount());
+
+  const cc::Layer* layer = contentLayerAt(0);
+  EXPECT_EQ(gfx::Vector2dF(50.f, 50.f), layer->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(125, 125), layer->bounds());
+}
+
+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());
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       DecompositedEffectNotMergingDueToOverlap) {
+  // This tests an effect that doesn't need to be composited, but needs
+  // separate backing due to overlap with a previous composited effect.
+  RefPtr<EffectPaintPropertyNode> effect1 =
+      createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.1f);
+  RefPtr<EffectPaintPropertyNode> effect2 =
+      createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.2f);
+  RefPtr<TransformPaintPropertyNode> transform =
+      TransformPaintPropertyNode::create(
+          TransformPaintPropertyNode::root(), TransformationMatrix(),
+          FloatPoint3D(), false, 0, CompositingReason3DTransform);
+  TestPaintArtifact artifact;
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(0, 0, 50, 50), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect1.get())
+      .rectDrawing(FloatRect(100, 0, 50, 50), Color::gray);
+  // This chunk has a transform that must be composited, thus causing effect1
+  // to be composited too.
+  artifact.chunk(transform.get(), ClipPaintPropertyNode::root(), effect1.get())
+      .rectDrawing(FloatRect(200, 0, 50, 50), Color::gray);
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect2.get())
+      .rectDrawing(FloatRect(200, 100, 50, 50), Color::gray);
+  // This chunk overlaps with the 2nd chunk, but is seemingly safe to merge.
+  // However because effect1 gets composited due to a composited transform,
+  // we can't merge with effect1 nor skip it to merge with the first chunk.
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect2.get())
+      .rectDrawing(FloatRect(100, 0, 50, 50), Color::gray);
+
+  update(artifact.build());
+  ASSERT_EQ(4u, contentLayerCount());
+
+  const cc::Layer* layer1 = contentLayerAt(0);
+  EXPECT_EQ(gfx::Vector2dF(0.f, 0.f), layer1->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(50, 50), layer1->bounds());
+  EXPECT_EQ(1, layer1->effect_tree_index());
+
+  const cc::Layer* layer2 = contentLayerAt(1);
+  EXPECT_EQ(gfx::Vector2dF(100.f, 0.f), layer2->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(50, 50), layer2->bounds());
+  const cc::EffectNode* effectNode =
+      propertyTrees().effect_tree.Node(layer2->effect_tree_index());
+  EXPECT_EQ(1, effectNode->parent_id);
+  EXPECT_EQ(0.1f, effectNode->opacity);
+
+  const cc::Layer* layer3 = contentLayerAt(2);
+  EXPECT_EQ(gfx::Vector2dF(200.f, 0.f), layer3->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(50, 50), layer3->bounds());
+  EXPECT_EQ(effectNode->id, layer3->effect_tree_index());
+
+  const cc::Layer* layer4 = contentLayerAt(3);
+  EXPECT_EQ(gfx::Vector2dF(100.f, 0.f), layer4->offset_to_transform_parent());
+  EXPECT_EQ(gfx::Size(150, 150), layer4->bounds());
+  EXPECT_EQ(1, layer4->effect_tree_index());
+}
+
 }  // namespace blink