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

third_party/WebKit/Source/core/animation/AnimationTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/animation/Animation.h"
 
+#include <memory>
 #include "core/animation/AnimationClock.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorPendingAnimations.h"
 #include "core/animation/ElementAnimations.h"
 #include "core/animation/KeyframeEffect.h"
+#include "core/dom/DOMNodeIds.h"
 #include "core/dom/Document.h"
 #include "core/dom/QualifiedName.h"
 #include "core/testing/DummyPageHolder.h"
+#include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "platform/weborigin/KURL.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include <memory>
 
 namespace blink {
 
 class AnimationAnimationTest : public ::testing::Test {
  protected:
   void SetUp() override {
     setUpWithoutStartingTimeline();
     startTimeline();
   }
 
@@ skipping 10 matching lines @@
 
   void startTimeline() { simulateFrame(0); }
 
   KeyframeEffect* makeAnimation(double duration = 30, double playbackRate = 1) {
     Timing timing;
     timing.iterationDuration = duration;
     timing.playbackRate = playbackRate;
     return KeyframeEffect::create(0, nullptr, timing);
   }
 
-  bool simulateFrame(double time) {
+  bool simulateFrame(double time,
+                     Optional<CompositorElementIdSet> compositedElementIds =
+                         Optional<CompositorElementIdSet>()) {
     document->animationClock().updateTime(time);
-    document->compositorPendingAnimations().update(false);
+    document->compositorPendingAnimations().update(compositedElementIds, false);
     // The timeline does not know about our animation, so we have to explicitly
     // call update().
     return animation->update(TimingUpdateForAnimationFrame);
   }
 
   Persistent<Document> document;
   Persistent<AnimationTimeline> timeline;
   Persistent<Animation> animation;
   std::unique_ptr<DummyPageHolder> pageHolder;
 };
@@ skipping 688 matching lines @@
   animation->cancel();
   EXPECT_EQ(Animation::Idle, animation->playStateInternal());
   EXPECT_TRUE(std::isnan(animation->currentTime()));
   EXPECT_TRUE(std::isnan(animation->startTime()));
   animation->pause();
   EXPECT_EQ(Animation::Pending, animation->playStateInternal());
   EXPECT_EQ(0, animation->currentTime());
   EXPECT_TRUE(std::isnan(animation->startTime()));
 }
 
+TEST_F(AnimationAnimationTest, NoCompositeWithoutCompositedElementId) {
+  ScopedSlimmingPaintV2ForTest enableSPv2(true);
+
+  Persistent<Element> elementComposited = document->createElement("foo");
+  Persistent<Element> elementNotComposited = document->createElement("bar");
+
+  Optional<CompositorElementIdSet> compositedElementIds =
+      CompositorElementIdSet();
+  CompositorElementId expectedCompositorElementId =
+      createCompositorElementId(DOMNodeIds::idForNode(elementComposited),
+                                CompositorSubElementId::Primary);
+  compositedElementIds->insert(expectedCompositorElementId);
+
+  Timing timing;
+  timing.iterationDuration = 30;
+  timing.playbackRate = 1;
+  KeyframeEffect* keyframeEffectComposited =
+      KeyframeEffect::create(elementComposited.get(), nullptr, timing);
+  Animation* animationComposited = timeline->play(keyframeEffectComposited);
+  KeyframeEffect* keyframeEffectNotComposited =
+      KeyframeEffect::create(elementNotComposited.get(), nullptr, timing);
+  Animation* animationNotComposited =
+      timeline->play(keyframeEffectNotComposited);
+
+  simulateFrame(0, compositedElementIds);
+  EXPECT_TRUE(
+      animationComposited->canStartAnimationOnCompositor(compositedElementIds));
+  EXPECT_FALSE(animationNotComposited->canStartAnimationOnCompositor(
+      compositedElementIds));
+}
+
 }  // namespace blink