CC Animation: Erase ElementAnimations::ObserverType.

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 2236 matching lines @@
   EXPECT_FALSE(animations_impl->HasAnimationThatAffectsScale());
 }
 
 TEST_F(ElementAnimationsTest, HasOnlyTranslationTransforms) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::ACTIVE));
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::PENDING));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
 
   animations_impl->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
 
   // Opacity animations aren't non-translation transforms.
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::ACTIVE));
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::PENDING));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve1(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendTranslate(10.0, 15.0, 0.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations1, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 2, 2, TargetProperty::TRANSFORM));
   animations_impl->AddAnimation(std::move(animation));
 
   // The only transform animation we've added is a translation.
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::ACTIVE));
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::PENDING));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 3, 3, TargetProperty::TRANSFORM);
   animation->set_affects_active_observers(false);
   animations_impl->AddAnimation(std::move(animation));
 
   // A scale animation is not a translation.
-  EXPECT_FALSE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::PENDING));
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::ACTIVE));
+  EXPECT_FALSE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
 
   animations_impl->ActivateAnimations();
-  EXPECT_FALSE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::ACTIVE));
+  EXPECT_FALSE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+  EXPECT_FALSE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
 
   animations_impl->GetAnimationById(3)->set_affects_pending_observers(false);
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::ACTIVE));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+  EXPECT_FALSE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
 
   animations_impl->GetAnimationById(3)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // HasOnlyTranslationTransforms.
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::PENDING));
-  EXPECT_TRUE(animations_impl->HasOnlyTranslationTransforms(
-      ElementAnimations::ObserverType::ACTIVE));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+  EXPECT_TRUE(
+      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, AnimationStartScale) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve1(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
   operations1.AppendScale(2.0, 3.0, 4.0);
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   TransformOperations operations2;
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
   animation->set_affects_active_observers(false);
   animations_impl->AddAnimation(std::move(animation));
 
   float start_scale = 0.f;
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::PENDING, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+                                                   &start_scale));
   EXPECT_EQ(4.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::ACTIVE, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+                                                   &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::PENDING, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+                                                   &start_scale));
   EXPECT_EQ(4.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::ACTIVE, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+                                                   &start_scale));
   EXPECT_EQ(4.f, start_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations3;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations3, nullptr));
   operations3.AppendScale(6.0, 5.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
@@ skipping 17 matching lines @@
       TransformKeyframe::Create(base::TimeDelta(), operations4, nullptr));
   TransformOperations operations5;
   curve3->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations5, nullptr));
 
   animation =
       Animation::Create(std::move(curve3), 3, 3, TargetProperty::TRANSFORM);
   animation->set_affects_active_observers(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::PENDING, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+                                                   &start_scale));
   EXPECT_EQ(6.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::ACTIVE, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+                                                   &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::PENDING, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+                                                   &start_scale));
   EXPECT_EQ(6.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::ACTIVE, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+                                                   &start_scale));
   EXPECT_EQ(6.f, start_scale);
 
   animations_impl->GetAnimationById(2)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // AnimationStartScale.
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::PENDING, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+                                                   &start_scale));
   EXPECT_EQ(5.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(
-      ElementAnimations::ObserverType::ACTIVE, &start_scale));
+  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+                                                   &start_scale));
   EXPECT_EQ(5.f, start_scale);
 }
 
 TEST_F(ElementAnimationsTest, MaximumTargetScale) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   float max_scale = 0.f;
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(0.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(0.f, max_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve1(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendScale(2.0, 3.0, 4.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations1, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
   animation->set_affects_active_observers(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(4.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(0.f, max_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(4.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(6.0, 5.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 2, 2, TargetProperty::TRANSFORM);
   animation->set_affects_active_observers(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve3(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations3;
   curve3->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations3, nullptr));
   operations3.AppendPerspective(6.0);
   curve3->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations3, nullptr));
 
   animation =
       Animation::Create(std::move(curve3), 3, 3, TargetProperty::TRANSFORM);
   animation->set_affects_active_observers(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_FALSE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_FALSE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_FALSE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
-  EXPECT_FALSE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_FALSE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_FALSE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
 
   animations_impl->GetAnimationById(3)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
   animations_impl->GetAnimationById(2)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // MaximumTargetScale.
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(4.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 }
 
 TEST_F(ElementAnimationsTest, MaximumTargetScaleWithDirection) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
@@ skipping 12 matching lines @@
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
   Animation* animation = animation_owned.get();
   animations_impl->AddAnimation(std::move(animation_owned));
 
   float max_scale = 0.f;
 
   EXPECT_GT(animation->playback_rate(), 0.0);
 
   // NORMAL direction with positive playback rate.
   animation->set_direction(Animation::DIRECTION_NORMAL);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   // ALTERNATE direction with positive playback rate.
   animation->set_direction(Animation::DIRECTION_ALTERNATE);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   // REVERSE direction with positive playback rate.
   animation->set_direction(Animation::DIRECTION_REVERSE);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(3.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(3.f, max_scale);
 
   // ALTERNATE reverse direction.
   animation->set_direction(Animation::DIRECTION_REVERSE);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(3.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(3.f, max_scale);
 
   animation->set_playback_rate(-1.0);
 
   // NORMAL direction with negative playback rate.
   animation->set_direction(Animation::DIRECTION_NORMAL);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(3.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(3.f, max_scale);
 
   // ALTERNATE direction with negative playback rate.
   animation->set_direction(Animation::DIRECTION_ALTERNATE);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(3.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(3.f, max_scale);
 
   // REVERSE direction with negative playback rate.
   animation->set_direction(Animation::DIRECTION_REVERSE);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   // ALTERNATE reverse direction with negative playback rate.
   animation->set_direction(Animation::DIRECTION_REVERSE);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::PENDING, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
-  EXPECT_TRUE(animations_impl->MaximumTargetScale(
-      ElementAnimations::ObserverType::ACTIVE, &max_scale));
+  EXPECT_TRUE(
+      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 }
 
 TEST_F(ElementAnimationsTest, NewlyPushedAnimationWaitsForActivation) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
@@ skipping 414 matching lines @@
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   // Create an animation that initially affects only pending observers.
   std::unique_ptr<Animation> animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   animation->set_affects_active_observers(false);
 
   animations->AddAnimation(std::move(animation));
   animations->Animate(kInitialTickTime);
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                        LayerTreeType::ACTIVE));
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->HasActiveAnimation());
 
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                        LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::FILTER, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
+                                                        LayerTreeType::ACTIVE));
 
   animations->ActivateAnimations();
 
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::PENDING));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::FILTER, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
+                                                        LayerTreeType::ACTIVE));
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(10));
   animations->UpdateState(true, nullptr);
 
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::PENDING));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::FILTER, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
+                                                        LayerTreeType::ACTIVE));
 
   EXPECT_EQ(0.f, client_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 
   // Tick past the end of the animation.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1100));
   animations->UpdateState(true, nullptr);
 
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                        LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::FILTER, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
+                                                        LayerTreeType::ACTIVE));
 
   EXPECT_EQ(1.f, client_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TestIsAnimatingPropertyTimeOffsetFillMode) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   // Create an animation that initially affects only pending observers, and has
   // a start delay of 2 seconds.
   std::unique_ptr<Animation> animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(TimeDelta::FromMilliseconds(-2000));
   animation->set_affects_active_observers(false);
 
   animations->AddAnimation(std::move(animation));
 
   animations->Animate(kInitialTickTime);
 
   // Since the animation has a start delay, the observers it affects have a
   // potentially running transform animation but aren't currently animating
   // transform.
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                        LayerTreeType::ACTIVE));
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::PENDING));
+      TargetProperty::FILTER, LayerTreeType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::FILTER, LayerTreeType::ACTIVE));
 
   animations->ActivateAnimations();
 
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                        LayerTreeType::ACTIVE));
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::PENDING));
+      TargetProperty::FILTER, LayerTreeType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::FILTER, LayerTreeType::ACTIVE));
 
   animations->UpdateState(true, nullptr);
 
   // Tick past the start delay.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::PENDING));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                       LayerTreeType::ACTIVE));
 
   // After the animaton finishes, the observers it affects have neither a
   // potentially running transform animation nor a currently running transform
   // animation.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
   animations->UpdateState(true, nullptr);
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, ElementAnimations::ObserverType::ACTIVE));
+      TargetProperty::OPACITY, LayerTreeType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
+                                                        LayerTreeType::ACTIVE));
 }
 
 }  // namespace
 }  // namespace cc