cc : Track opacity animation changes on effect tree

cc/animation/element_animations_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/animation/element_animations.h"
 
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
@@ skipping 2907 matching lines @@
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(4000));
   animations_impl->UpdateState(true, events.get());
 
   animations->NotifyAnimationAborted(events->events_[0]);
   EXPECT_FALSE(
       client_.GetTransformIsAnimating(element_id_, ElementListType::ACTIVE));
 }
 
+TEST_F(ElementAnimationsTest, ObserverNotifiedWhenOpacityAnimationChanges) {
+  CreateTestLayer(true, true);
+  AttachTimelinePlayerLayer();
+  CreateImplTimelineAndPlayer();
+
+  scoped_refptr<ElementAnimations> animations = element_animations();
+  scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
+
+  auto events = host_impl_->CreateEvents();
+
+  EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
+                                                      ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  // Case 1: An animation that's allowed to run until its finish point.
+  AddOpacityTransitionToElementAnimations(animations.get(), 1.0, 0.f, 1.f,
+                                          false /*use_timing_function*/);
+  EXPECT_TRUE(client_.GetHasPotentialOpacityAnimation(element_id_,
+                                                      ElementListType::ACTIVE));
+  EXPECT_TRUE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
+                                                     ElementListType::ACTIVE));
+
+  animations->PushPropertiesTo(animations_impl.get());
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->ActivateAnimations();
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->Animate(kInitialTickTime);
+  animations_impl->UpdateState(true, events.get());
+
+  animations->NotifyAnimationStarted(events->events_[0]);
+  events->events_.clear();
+
+  // Finish the animation.
+  animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  animations->UpdateState(true, nullptr);
+  EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
+                                                      ElementListType::ACTIVE));
+
+  animations->PushPropertiesTo(animations_impl.get());
+
+  // animations_impl hasn't yet ticked at/past the end of the animation.
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
+  animations_impl->UpdateState(true, events.get());
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  // Case 2: An animation that's removed before it finishes.
+  int animation_id = AddOpacityTransitionToElementAnimations(
+      animations.get(), 10.0, 0.f, 1.f, false /*use_timing_function*/);
+  EXPECT_TRUE(client_.GetHasPotentialOpacityAnimation(element_id_,
+                                                      ElementListType::ACTIVE));
+  EXPECT_TRUE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
+                                                     ElementListType::ACTIVE));
+
+  animations->PushPropertiesTo(animations_impl.get());
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->ActivateAnimations();
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(2000));
+  animations_impl->UpdateState(true, events.get());
+
+  animations->NotifyAnimationStarted(events->events_[0]);
+  events->events_.clear();
+
+  animations->RemoveAnimation(animation_id);
+  EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
+                                                      ElementListType::ACTIVE));
+
+  animations->PushPropertiesTo(animations_impl.get());
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->ActivateAnimations();
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  // Case 3: An animation that's aborted before it finishes.
+  animation_id = AddOpacityTransitionToElementAnimations(
+      animations.get(), 10.0, 0.f, 0.5f, false /*use_timing_function*/);
+  EXPECT_TRUE(client_.GetHasPotentialOpacityAnimation(element_id_,
+                                                      ElementListType::ACTIVE));
+  EXPECT_TRUE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
+                                                     ElementListType::ACTIVE));
+
+  animations->PushPropertiesTo(animations_impl.get());
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->ActivateAnimations();
+  EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(2000));
+  animations_impl->UpdateState(true, events.get());
+
+  animations->NotifyAnimationStarted(events->events_[0]);
+  events->events_.clear();
+
+  animations_impl->AbortAnimations(TargetProperty::OPACITY);
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
+      element_id_, ElementListType::ACTIVE));
+
+  animations_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(4000));
+  animations_impl->UpdateState(true, events.get());
+
+  animations->NotifyAnimationAborted(events->events_[0]);
+  EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
+      element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
+                                                      ElementListType::ACTIVE));

[ajuma, 2016/05/09 16:56:55]

Please also test the case where potentially-animating is true but
currently-animating is false (that is, when Animation::InEffect is false for a
running animation).

[jaydasika, 2016/05/10 20:22:29]

Done.

+}
+
 TEST_F(ElementAnimationsTest, ClippedOpacityValues) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   AddOpacityTransitionToElementAnimations(animations.get(), 1, 1.f, 2.f, true);
 
   animations->Animate(kInitialTickTime);
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
@@ skipping 302 matching lines @@
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
 }
 
 }  // namespace
 }  // namespace cc