[SPv2] Decomposite otherwise-compositable animations that paint nothing.

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 101 matching lines @@
     return m_webLayerTreeView->layerTreeHost()
         ->property_trees()
         ->element_id_to_scroll_node_index[elementId];
   }
 
   const cc::TransformNode& transformNode(const cc::Layer* layer) {
     return *propertyTrees().transform_tree.Node(layer->transform_tree_index());
   }
 
   void update(const PaintArtifact& artifact) {
-    m_paintArtifactCompositor->update(artifact, nullptr, false);
+    CompositorElementIdSet elementIds;
+    update(artifact, elementIds);
+  }
+
+  void update(const PaintArtifact& artifact,
+              CompositorElementIdSet& elementIds) {
+    m_paintArtifactCompositor->update(artifact, nullptr, false, elementIds);
     m_webLayerTreeView->layerTreeHost()->LayoutAndUpdateLayers();
   }
 
   cc::Layer* rootLayer() { return m_paintArtifactCompositor->rootLayer(); }
 
   size_t contentLayerCount() {
     return m_paintArtifactCompositor->getExtraDataForTesting()
         ->contentLayers.size();
   }
 
@@ skipping 1440 matching lines @@
   PaintChunk chunk3;
   chunk3.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk3.bounds = FloatRect(0, 0, 50, 60);
   chunk3.knownToBeOpaque = true;
   pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk3, false));
 
   // Chunk 3 covers the entire layer, so now it's opaque.
   EXPECT_TRUE(pendingLayer.knownToBeOpaque);
 }
 
+PassRefPtr<EffectPaintPropertyNode> createSampleEffectNodeWithElementId() {
+  CompositorElementId expectedCompositorElementId(2, 0);
+  float opacity = 2.0 / 255.0;
+  return EffectPaintPropertyNode::create(
+      EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      ClipPaintPropertyNode::root(), ColorFilterNone,
+      CompositorFilterOperations(), opacity, SkBlendMode::kSrcOver,
+      CompositingReasonActiveAnimation, expectedCompositorElementId);
+}
+
+PassRefPtr<TransformPaintPropertyNode>
+createSampleTransformNodeWithElementId() {
+  CompositorElementId expectedCompositorElementId(3, 0);
+  return TransformPaintPropertyNode::create(
+      TransformPaintPropertyNode::root(), TransformationMatrix().rotate(90),
+      FloatPoint3D(100, 100, 0), false, 0, CompositingReason3DTransform,
+      expectedCompositorElementId);
+}
+
 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);
-
+      createSampleTransformNodeWithElementId();
   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));
+  EXPECT_EQ(2, elementIdToTransformNodeIndex(transform->compositorElementId()));
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
        TransformNodeHasOwningLayerId) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(), TransformationMatrix().rotate(90),
           FloatPoint3D(100, 100, 0), false, 0, CompositingReason3DTransform);
 
   TestPaintArtifact artifact;
@@ skipping 11 matching lines @@
       propertyTrees().transform_tree.Node(
           transformNodeLayer->transform_tree_index());
   EXPECT_EQ(transformNodeLayer->id(), ccTransformNode->owning_layer_id);
   auto transformNodeIndex =
       propertyTrees().transform_tree.FindNodeIndexFromOwningLayerId(
           transformNodeLayer->id());
   EXPECT_EQ(transformNodeIndex, ccTransformNode->id);
 }
 
 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,
-      CompositingReasonActiveAnimation, expectedCompositorElementId);
-
+  RefPtr<EffectPaintPropertyNode> effect =
+      createSampleEffectNodeWithElementId();
   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));
+  EXPECT_EQ(2, elementIdToEffectNodeIndex(effect->compositorElementId()));
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, CompositedLuminanceMask) {
   RefPtr<EffectPaintPropertyNode> masked = EffectPaintPropertyNode::create(
       EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       ClipPaintPropertyNode::root(), ColorFilterNone,
       CompositorFilterOperations(), 1.0, SkBlendMode::kSrcOver,
       CompositingReasonIsolateCompositedDescendants);
   RefPtr<EffectPaintPropertyNode> masking = EffectPaintPropertyNode::create(
       masked, TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
@@ skipping 337 matching lines @@
   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());
 }
 
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       UpdatePopulatesCompositedElementIds) {
+  RefPtr<TransformPaintPropertyNode> transform =
+      createSampleTransformNodeWithElementId();
+  RefPtr<EffectPaintPropertyNode> effect =
+      createSampleEffectNodeWithElementId();
+  TestPaintArtifact artifact;
+  artifact
+      .chunk(transform, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
+      .rectDrawing(FloatRect(0, 0, 100, 100), Color::black)
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect.get())
+      .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
+
+  CompositorElementIdSet compositedElementIds;
+  update(artifact.build(), compositedElementIds);
+
+  EXPECT_EQ(2u, compositedElementIds.size());
+  EXPECT_TRUE(compositedElementIds.contains(transform->compositorElementId()));
+  EXPECT_TRUE(compositedElementIds.contains(effect->compositorElementId()));
+}
+
 }  // namespace blink