Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3224)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/animation/layer_animation_controller_unittest.cc

Issue 1882733005: CC Animation: Make LayerAnimationController to have just one value observer. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@privatelac
Patch Set: Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« cc/animation/layer_animation_controller.h ('K') | « cc/animation/layer_animation_controller.cc ('k') | cc/animation/layer_animation_value_observer.h » ('j') | cc/test/animation_test_common.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/animation/layer_animation_controller_unittest.cc
diff --git a/cc/animation/layer_animation_controller_unittest.cc b/cc/animation/layer_animation_controller_unittest.cc
index 45fe7269861b4d7ec047cef596b686230f889d45..0b9000bf0c9e0b9f32108f6c5f4f24978657f88b 100644
--- a/cc/animation/layer_animation_controller_unittest.cc
+++ b/cc/animation/layer_animation_controller_unittest.cc
@@ -48,11 +48,14 @@ TEST(LayerAnimationControllerTest, SyncNewAnimation) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller_impl->SetNeedsActiveValueObservations(true);
EXPECT_FALSE(controller_impl->GetAnimation(TargetProperty::OPACITY));
@@ -78,13 +81,16 @@ TEST(LayerAnimationControllerTest,
FakeLayerAnimationValueProvider dummy_provider_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
controller_impl->set_value_provider(&dummy_provider_impl);
+
FakeLayerAnimationValueObserver dummy;
FakeLayerAnimationValueProvider dummy_provider;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
controller->set_value_provider(&dummy_provider);
EXPECT_FALSE(controller_impl->GetAnimation(TargetProperty::SCROLL_OFFSET));
@@ -135,11 +141,14 @@ TEST(LayerAnimationControllerTest, DoNotClobberStartTimes) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
EXPECT_FALSE(controller_impl->GetAnimation(TargetProperty::OPACITY));
@@ -174,11 +183,14 @@ TEST(LayerAnimationControllerTest, UseSpecifiedStartTimes) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
int animation_id =
AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
@@ -225,11 +237,15 @@ TEST(LayerAnimationControllerTest, Activation) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
+
std::unique_ptr<AnimationEvents> events = host->CreateEvents();
controller->SetAnimationHost(host.get());
@@ -305,11 +321,14 @@ TEST(LayerAnimationControllerTest, SyncPause) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
EXPECT_FALSE(controller_impl->GetAnimation(TargetProperty::OPACITY));
@@ -381,11 +400,15 @@ TEST(LayerAnimationControllerTest, DoNotSyncFinishedAnimation) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
+
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
@@ -439,8 +462,10 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
LayerAnimationController::Create(0));
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
- controller_impl->AddValueObserver(&dummy_impl);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
AddOpacityTransitionToController(controller.get(), 1.0, 0.0f, 1.0f, false);
controller->Animate(kInitialTickTime);
@@ -511,7 +536,8 @@ TEST(LayerAnimationControllerTest, TrivialTransition) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
std::unique_ptr<Animation> to_add(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
@@ -542,7 +568,8 @@ TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
std::unique_ptr<Animation> to_add(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
@@ -576,7 +603,8 @@ TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
// Choose different values for x and y to avoid coincidental values in the
// observed transforms.
@@ -632,7 +660,8 @@ TEST(LayerAnimationControllerTest, FilterTransition) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
std::unique_ptr<KeyframedFilterAnimationCurve> curve(
KeyframedFilterAnimationCurve::Create());
@@ -680,7 +709,8 @@ TEST(LayerAnimationControllerTest, FilterTransitionOnImplOnly) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
std::unique_ptr<KeyframedFilterAnimationCurve> curve(
KeyframedFilterAnimationCurve::Create());
@@ -730,7 +760,9 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
FakeLayerAnimationValueProvider dummy_provider_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
controller_impl->set_value_provider(&dummy_provider_impl);
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
@@ -738,7 +770,8 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
FakeLayerAnimationValueProvider dummy_provider;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
controller->set_value_provider(&dummy_provider);
gfx::ScrollOffset initial_value(100.f, 300.f);
@@ -810,14 +843,17 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
FakeLayerAnimationValueObserver dummy;
FakeLayerAnimationValueProvider dummy_provider;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
controller->set_value_provider(&dummy_provider);
gfx::ScrollOffset initial_value(500.f, 100.f);
@@ -886,7 +922,8 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
@@ -934,7 +971,8 @@ TEST(LayerAnimationControllerTest, ScrollOffsetRemovalClearsScrollDelta) {
FakeLayerAnimationValueProvider dummy_provider_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
controller_impl->set_value_provider(&dummy_provider_impl);
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
@@ -942,7 +980,8 @@ TEST(LayerAnimationControllerTest, ScrollOffsetRemovalClearsScrollDelta) {
FakeLayerAnimationValueProvider dummy_provider;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
controller->set_value_provider(&dummy_provider);
// First test the 1-argument version of RemoveAnimation.
@@ -1089,7 +1128,9 @@ TEST(LayerAnimationControllerTest,
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
FakeAnimationDelegate delegate;
@@ -1125,11 +1166,15 @@ TEST(LayerAnimationControllerTest,
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
+
FakeAnimationDelegate delegate;
controller->set_layer_animation_delegate(&delegate);
@@ -1177,11 +1222,15 @@ TEST(LayerAnimationControllerTest, SpecifiedStartTimesAreSentToEventObservers) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
+
FakeLayerAnimationEventObserver observer;
controller->AddEventObserver(&observer);
@@ -1219,7 +1268,8 @@ TEST(LayerAnimationControllerTest,
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
std::unique_ptr<Animation> to_add(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
@@ -1259,7 +1309,8 @@ TEST(LayerAnimationControllerTest, TrivialQueuing) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
EXPECT_FALSE(controller->needs_to_start_animations_for_testing());
@@ -1301,7 +1352,9 @@ TEST(LayerAnimationControllerTest, Interrupt) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
+
controller->AddAnimation(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
1, TargetProperty::OPACITY));
@@ -1336,7 +1389,8 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
controller->AddAnimation(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1,
@@ -1373,7 +1427,8 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
controller->AddAnimation(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeTransformTransition(2)), 1,
@@ -1414,7 +1469,8 @@ TEST(LayerAnimationControllerTest, TrivialLooping) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
std::unique_ptr<Animation> to_add(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
@@ -1460,7 +1516,8 @@ TEST(LayerAnimationControllerTest, InfiniteLooping) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
std::unique_ptr<Animation> to_add(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
@@ -1507,7 +1564,8 @@ TEST(LayerAnimationControllerTest, PauseResume) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
controller->AddAnimation(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
@@ -1553,7 +1611,8 @@ TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
const int animation_id = 2;
controller->AddAnimation(Animation::Create(
@@ -1593,13 +1652,15 @@ TEST(LayerAnimationControllerTest, PushUpdatesWhenSynchronizedStartTimeNeeded) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
std::unique_ptr<Animation> to_add(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)),
@@ -1631,7 +1692,8 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
std::unique_ptr<Animation> first_animation(CreateAnimation(
std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1,
@@ -1676,10 +1738,10 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
- FakeLayerAnimationValueObserver dummy;
- FakeInactiveLayerAnimationValueObserver pending_dummy;
+ FakeTypedLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
+ controller->SetValueObserver(&dummy);
const int id = 1;
controller->AddAnimation(CreateAnimation(
@@ -1694,7 +1756,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
controller->GetAnimation(TargetProperty::OPACITY)->run_state());
- controller->AddValueObserver(&pending_dummy);
+ controller->SetNeedsPendingValueObservations(true);
// With only a pending observer, the animation should progress to the
// STARTING state and get ticked at its starting point, but should not
@@ -1704,7 +1766,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
EXPECT_EQ(0u, events->events_.size());
EXPECT_EQ(Animation::STARTING,
controller->GetAnimation(TargetProperty::OPACITY)->run_state());
- EXPECT_EQ(0.5f, pending_dummy.opacity());
+ EXPECT_EQ(0.5f, dummy.opacity(LayerTreeType::PENDING));
// Even when already in the STARTING state, the animation should stay
// there, and shouldn't be ticked past its starting point.
@@ -1713,9 +1775,9 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
EXPECT_EQ(0u, events->events_.size());
EXPECT_EQ(Animation::STARTING,
controller->GetAnimation(TargetProperty::OPACITY)->run_state());
- EXPECT_EQ(0.5f, pending_dummy.opacity());
+ EXPECT_EQ(0.5f, dummy.opacity(LayerTreeType::PENDING));
- controller->AddValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
// Now that an active observer has been added, the animation should still
// initially tick at its starting point, but should now progress to RUNNING.
@@ -1724,13 +1786,13 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
EXPECT_EQ(1u, events->events_.size());
EXPECT_EQ(Animation::RUNNING,
controller->GetAnimation(TargetProperty::OPACITY)->run_state());
- EXPECT_EQ(0.5f, pending_dummy.opacity());
- EXPECT_EQ(0.5f, dummy.opacity());
+ EXPECT_EQ(0.5f, dummy.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.5f, dummy.opacity(LayerTreeType::ACTIVE));
// The animation should now tick past its starting point.
controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3500));
- EXPECT_NE(0.5f, pending_dummy.opacity());
- EXPECT_NE(0.5f, dummy.opacity());
+ EXPECT_NE(0.5f, dummy.opacity(LayerTreeType::PENDING));
+ EXPECT_NE(0.5f, dummy.opacity(LayerTreeType::ACTIVE));
}
TEST(LayerAnimationControllerTest, TransformAnimationBounds) {
@@ -1809,7 +1871,8 @@ TEST(LayerAnimationControllerTest, AbortAnimations) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
// Start with several animations, and allow some of them to reach the finished
// state.
@@ -1856,11 +1919,13 @@ TEST(LayerAnimationControllerTest, MainThreadAbortedAnimationGetsDeleted) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
int animation_id =
AddOpacityTransitionToController(controller.get(), 1.0, 0.f, 1.f, false);
@@ -1891,11 +1956,13 @@ TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
FakeAnimationDelegate delegate;
controller->set_layer_animation_delegate(&delegate);
@@ -1946,11 +2013,13 @@ TEST(LayerAnimationControllerTest, ImplThreadTakeoverAnimationGetsDeleted) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
FakeAnimationDelegate delegate_impl;
controller_impl->set_layer_animation_delegate(&delegate_impl);
FakeAnimationDelegate delegate;
@@ -2014,7 +2083,8 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
const int group_id = 1;
@@ -2071,7 +2141,8 @@ TEST(LayerAnimationControllerTest, FinishedAndAbortedEventsForGroup) {
FakeLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
// Add two animations with the same group id.
std::unique_ptr<Animation> first_animation(CreateAnimation(
@@ -2560,16 +2631,17 @@ TEST(LayerAnimationControllerTest, MaximumTargetScaleWithDirection) {
TEST(LayerAnimationControllerTest, NewlyPushedAnimationWaitsForActivation) {
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
- FakeLayerAnimationValueObserver dummy_impl;
- FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
+ FakeTypedLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
- controller_impl->AddValueObserver(&pending_dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+ controller_impl->SetNeedsPendingValueObservations(true);
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
EXPECT_FALSE(controller->needs_to_start_animations_for_testing());
int animation_id =
@@ -2599,8 +2671,8 @@ TEST(LayerAnimationControllerTest, NewlyPushedAnimationWaitsForActivation) {
// Since the animation hasn't been activated, only the pending observer
// should have been ticked.
- EXPECT_EQ(0.5f, pending_dummy_impl.opacity());
- EXPECT_EQ(0.f, dummy_impl.opacity());
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.f, dummy_impl.opacity(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
EXPECT_TRUE(controller_impl->GetAnimationById(animation_id)
@@ -2616,23 +2688,25 @@ TEST(LayerAnimationControllerTest, NewlyPushedAnimationWaitsForActivation) {
// RUNNING state and the active observer should start to get ticked.
EXPECT_EQ(Animation::RUNNING,
controller_impl->GetAnimationById(animation_id)->run_state());
- EXPECT_EQ(0.5f, pending_dummy_impl.opacity());
- EXPECT_EQ(0.5f, dummy_impl.opacity());
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::ACTIVE));
}
TEST(LayerAnimationControllerTest, ActivationBetweenAnimateAndUpdateState) {
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
- FakeLayerAnimationValueObserver dummy_impl;
- FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
+ FakeTypedLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
- controller_impl->AddValueObserver(&pending_dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+ controller_impl->SetNeedsPendingValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
int animation_id =
AddOpacityTransitionToController(controller.get(), 1, 0.5f, 1.f, true);
@@ -2651,8 +2725,8 @@ TEST(LayerAnimationControllerTest, ActivationBetweenAnimateAndUpdateState) {
// Since the animation hasn't been activated, only the pending observer
// should have been ticked.
- EXPECT_EQ(0.5f, pending_dummy_impl.opacity());
- EXPECT_EQ(0.f, dummy_impl.opacity());
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.f, dummy_impl.opacity(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
EXPECT_TRUE(controller_impl->GetAnimationById(animation_id)
@@ -2670,39 +2744,41 @@ TEST(LayerAnimationControllerTest, ActivationBetweenAnimateAndUpdateState) {
controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
// Both observers should have been ticked.
- EXPECT_EQ(0.75f, pending_dummy_impl.opacity());
- EXPECT_EQ(0.75f, dummy_impl.opacity());
+ EXPECT_EQ(0.75f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.75f, dummy_impl.opacity(LayerTreeType::ACTIVE));
}
TEST(LayerAnimationControllerTest,
ObserverNotifiedWhenTransformIsPotentiallyAnimatingChanges) {
AnimationEvents events;
- FakeLayerAnimationValueObserver active_dummy_impl;
- FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
+ FakeTypedLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&active_dummy_impl);
- controller_impl->AddValueObserver(&pending_dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+ controller_impl->SetNeedsPendingValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
EXPECT_FALSE(dummy.transform_is_animating());
- EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
- EXPECT_FALSE(active_dummy_impl.transform_is_animating());
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
// Case 1: An animation that's allowed to run until its finish point.
AddAnimatedTransformToController(controller.get(), 1.0, 1, 1);
EXPECT_TRUE(dummy.transform_is_animating());
controller->PushAnimationUpdatesTo(controller_impl.get());
- EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
- EXPECT_FALSE(active_dummy_impl.transform_is_animating());
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
- EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
- EXPECT_TRUE(active_dummy_impl.transform_is_animating());
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->Animate(kInitialTickTime);
controller_impl->UpdateState(true, &events);
@@ -2718,14 +2794,14 @@ TEST(LayerAnimationControllerTest,
controller->PushAnimationUpdatesTo(controller_impl.get());
// controller_impl hasn't yet ticked at/past the end of the animation.
- EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
- EXPECT_TRUE(active_dummy_impl.transform_is_animating());
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->Animate(kInitialTickTime +
TimeDelta::FromMilliseconds(1000));
controller_impl->UpdateState(true, &events);
- EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
- EXPECT_FALSE(active_dummy_impl.transform_is_animating());
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller->NotifyAnimationFinished(events.events_[0]);
events.events_.clear();
@@ -2736,12 +2812,12 @@ TEST(LayerAnimationControllerTest,
EXPECT_TRUE(dummy.transform_is_animating());
controller->PushAnimationUpdatesTo(controller_impl.get());
- EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
- EXPECT_FALSE(active_dummy_impl.transform_is_animating());
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
- EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
- EXPECT_TRUE(active_dummy_impl.transform_is_animating());
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->Animate(kInitialTickTime +
TimeDelta::FromMilliseconds(2000));
@@ -2754,24 +2830,24 @@ TEST(LayerAnimationControllerTest,
EXPECT_FALSE(dummy.transform_is_animating());
controller->PushAnimationUpdatesTo(controller_impl.get());
- EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
- EXPECT_TRUE(active_dummy_impl.transform_is_animating());
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
- EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
- EXPECT_FALSE(active_dummy_impl.transform_is_animating());
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
// Case 3: An animation that's aborted before it finishes.
animation_id = AddAnimatedTransformToController(controller.get(), 10.0, 3, 3);
EXPECT_TRUE(dummy.transform_is_animating());
controller->PushAnimationUpdatesTo(controller_impl.get());
- EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
- EXPECT_FALSE(active_dummy_impl.transform_is_animating());
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
- EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
- EXPECT_TRUE(active_dummy_impl.transform_is_animating());
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_TRUE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->Animate(kInitialTickTime +
TimeDelta::FromMilliseconds(3000));
@@ -2781,8 +2857,8 @@ TEST(LayerAnimationControllerTest,
events.events_.clear();
controller_impl->AbortAnimations(TargetProperty::TRANSFORM);
- EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
- EXPECT_FALSE(active_dummy_impl.transform_is_animating());
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::PENDING));
+ EXPECT_FALSE(dummy_impl.transform_is_animating(LayerTreeType::ACTIVE));
controller_impl->Animate(kInitialTickTime +
TimeDelta::FromMilliseconds(4000));
@@ -2796,7 +2872,8 @@ TEST(LayerAnimationControllerTest, ClippedOpacityValues) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
AddOpacityTransitionToController(controller.get(), 1, 1.f, 2.f, true);
@@ -2812,7 +2889,8 @@ TEST(LayerAnimationControllerTest, ClippedNegativeOpacityValues) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
AddOpacityTransitionToController(controller.get(), 1, 0.f, -2.f, true);
@@ -2827,16 +2905,18 @@ TEST(LayerAnimationControllerTest, ClippedNegativeOpacityValues) {
TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
- FakeLayerAnimationValueObserver dummy_impl;
- FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
+ FakeTypedLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
- controller_impl->AddValueObserver(&pending_dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+ controller_impl->SetNeedsPendingValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
int animation_id =
AddOpacityTransitionToController(controller.get(), 1, 0.5f, 1.f, true);
@@ -2847,8 +2927,8 @@ TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {
controller_impl->UpdateState(true, events.get());
EXPECT_EQ(Animation::RUNNING,
controller_impl->GetAnimationById(animation_id)->run_state());
- EXPECT_EQ(0.5f, pending_dummy_impl.opacity());
- EXPECT_EQ(0.5f, dummy_impl.opacity());
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::ACTIVE));
EXPECT_TRUE(controller_impl->GetAnimationById(animation_id)
->affects_pending_observers());
@@ -2870,8 +2950,8 @@ TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {
controller_impl->UpdateState(true, events.get());
// Only the active observer should have been ticked.
- EXPECT_EQ(0.5f, pending_dummy_impl.opacity());
- EXPECT_EQ(0.75f, dummy_impl.opacity());
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.75f, dummy_impl.opacity(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
@@ -2884,16 +2964,18 @@ TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {
TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {
std::unique_ptr<AnimationEvents> events(
base::WrapUnique(new AnimationEvents));
- FakeLayerAnimationValueObserver dummy_impl;
- FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
+ FakeTypedLayerAnimationValueObserver dummy_impl;
scoped_refptr<LayerAnimationController> controller_impl(
LayerAnimationController::Create(0));
- controller_impl->AddValueObserver(&dummy_impl);
- controller_impl->AddValueObserver(&pending_dummy_impl);
+ controller_impl->SetValueObserver(&dummy_impl);
+ controller_impl->SetNeedsActiveValueObservations(true);
+ controller_impl->SetNeedsPendingValueObservations(true);
+
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
int first_animation_id =
AddOpacityTransitionToController(controller.get(), 1, 0.f, 1.f, true);
@@ -2935,8 +3017,8 @@ TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {
// The active observer should have been ticked by the original animation,
// and the pending observer should have been ticked by the new animation.
- EXPECT_EQ(1.f, pending_dummy_impl.opacity());
- EXPECT_EQ(0.5f, dummy_impl.opacity());
+ EXPECT_EQ(1.f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(0.5f, dummy_impl.opacity(LayerTreeType::ACTIVE));
controller_impl->ActivateAnimations();
@@ -2957,15 +3039,16 @@ TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {
EXPECT_EQ(
Animation::RUNNING,
controller_impl->GetAnimationById(second_animation_id)->run_state());
- EXPECT_EQ(1.f, pending_dummy_impl.opacity());
- EXPECT_EQ(1.f, dummy_impl.opacity());
+ EXPECT_EQ(1.f, dummy_impl.opacity(LayerTreeType::PENDING));
+ EXPECT_EQ(1.f, dummy_impl.opacity(LayerTreeType::ACTIVE));
}
TEST(LayerAnimationControllerTest, TestIsCurrentlyAnimatingProperty) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
// Create an animation that initially affects only pending observers.
std::unique_ptr<Animation> animation(CreateAnimation(
@@ -3041,7 +3124,8 @@ TEST(LayerAnimationControllerTest, TestIsAnimatingPropertyTimeOffsetFillMode) {
FakeLayerAnimationValueObserver dummy;
scoped_refptr<LayerAnimationController> controller(
LayerAnimationController::Create(0));
- controller->AddValueObserver(&dummy);
+ controller->SetValueObserver(&dummy);
+ controller->SetNeedsActiveValueObservations(true);
// Create an animation that initially affects only pending observers, and has
// a start delay of 2 seconds.
« cc/animation/layer_animation_controller.h ('K') | « cc/animation/layer_animation_controller.cc ('k') | cc/animation/layer_animation_value_observer.h » ('j') | cc/test/animation_test_common.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698