CC Animation: Let MutatorHostClient deals with elements instead of layers.

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 25 matching lines @@
  public:
   ElementAnimationsTest() {}
   ~ElementAnimationsTest() override {}
 };
 
 // See animation_player_unittest.cc for integration with AnimationPlayer.
 
 TEST_F(ElementAnimationsTest, AttachToLayerInActiveTree) {
   // Set up the layer which is in active tree for main thread and not
   // yet passed onto the impl thread.
-  client_.RegisterLayer(element_id_, LayerTreeType::ACTIVE);
-  client_impl_.RegisterLayer(element_id_, LayerTreeType::PENDING);
+  client_.RegisterElement(element_id_, ElementListType::ACTIVE);
+  client_impl_.RegisterElement(element_id_, ElementListType::PENDING);
 
-  EXPECT_TRUE(client_.IsLayerInTree(element_id_, LayerTreeType::ACTIVE));
-  EXPECT_FALSE(client_.IsLayerInTree(element_id_, LayerTreeType::PENDING));
+  EXPECT_TRUE(client_.IsElementInList(element_id_, ElementListType::ACTIVE));
+  EXPECT_FALSE(client_.IsElementInList(element_id_, ElementListType::PENDING));
 
   host_->AddAnimationTimeline(timeline_);
 
   timeline_->AttachPlayer(player_);
   player_->AttachLayer(element_id_);
 
   scoped_refptr<ElementAnimations> element_animations =
       player_->element_animations();
   EXPECT_TRUE(element_animations);
 
   EXPECT_TRUE(element_animations->has_element_in_active_list());
   EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
   host_->PushPropertiesTo(host_impl_);
 
   GetImplTimelineAndPlayerByID();
 
   scoped_refptr<ElementAnimations> element_animations_impl =
       player_impl_->element_animations();
   EXPECT_TRUE(element_animations_impl);
 
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
   // Create the layer in the impl active tree.
-  client_impl_.RegisterLayer(element_id_, LayerTreeType::ACTIVE);
+  client_impl_.RegisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_TRUE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
-  EXPECT_TRUE(client_impl_.IsLayerInTree(element_id_, LayerTreeType::ACTIVE));
-  EXPECT_TRUE(client_impl_.IsLayerInTree(element_id_, LayerTreeType::PENDING));
+  EXPECT_TRUE(
+      client_impl_.IsElementInList(element_id_, ElementListType::ACTIVE));
+  EXPECT_TRUE(
+      client_impl_.IsElementInList(element_id_, ElementListType::PENDING));
 
   // kill layer on main thread.
-  client_.UnregisterLayer(element_id_, LayerTreeType::ACTIVE);
+  client_.UnregisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_EQ(element_animations, player_->element_animations());
   EXPECT_FALSE(element_animations->has_element_in_active_list());
   EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
   // Sync doesn't detach LayerImpl.
   host_->PushPropertiesTo(host_impl_);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_TRUE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
   // Kill layer on impl thread in pending tree.
-  client_impl_.UnregisterLayer(element_id_, LayerTreeType::PENDING);
+  client_impl_.UnregisterElement(element_id_, ElementListType::PENDING);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_TRUE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   // Kill layer on impl thread in active tree.
-  client_impl_.UnregisterLayer(element_id_, LayerTreeType::ACTIVE);
+  client_impl_.UnregisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   // Sync doesn't change anything.
   host_->PushPropertiesTo(host_impl_);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
@@ skipping 24 matching lines @@
   host_->PushPropertiesTo(host_impl_);
 
   scoped_refptr<ElementAnimations> element_animations_impl =
       player_impl_->element_animations();
   EXPECT_TRUE(element_animations_impl);
 
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   // Create layer.
-  client_.RegisterLayer(element_id_, LayerTreeType::ACTIVE);
+  client_.RegisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_TRUE(element_animations->has_element_in_active_list());
   EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
-  client_impl_.RegisterLayer(element_id_, LayerTreeType::PENDING);
+  client_impl_.RegisterElement(element_id_, ElementListType::PENDING);
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
-  client_impl_.RegisterLayer(element_id_, LayerTreeType::ACTIVE);
+  client_impl_.RegisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_TRUE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 }
 
 TEST_F(ElementAnimationsTest, AddRemovePlayers) {
   host_->AddAnimationTimeline(timeline_);
   timeline_->AttachPlayer(player_);
   player_->AttachLayer(element_id_);
 
   scoped_refptr<ElementAnimations> element_animations =
@@ skipping 327 matching lines @@
 
   animations->Animate(time);
   animations->UpdateState(true, nullptr);
   animations->NotifyAnimationStarted(events->events_[0]);
 
   EXPECT_EQ(Animation::RUNNING,
             animations_impl->GetAnimationById(animation_id)->run_state());
   EXPECT_EQ(Animation::RUNNING,
             animations->GetAnimationById(animation_id)->run_state());
 
-  EXPECT_EQ(0.3f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
-  EXPECT_EQ(0.3f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.3f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
+  EXPECT_EQ(0.3f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_EQ(kInitialTickTime,
             animations->GetAnimationById(animation_id)->start_time());
   EXPECT_EQ(kInitialTickTime,
             animations_impl->GetAnimationById(animation_id)->start_time());
 
   // Pause the animation at the middle of the second range so the offset
   // delays animation until the middle of the third range.
   animations->PauseAnimation(animation_id, TimeDelta::FromSecondsD(1.5));
   EXPECT_EQ(Animation::PAUSED,
             animations->GetAnimationById(animation_id)->run_state());
 
   // The pause run state change should make it to the impl thread animations.
   animations->PushPropertiesTo(animations_impl.get());
   animations_impl->ActivateAnimations();
 
   // Advance time so it stays within the first range.
   time += TimeDelta::FromMilliseconds(10);
   animations->Animate(time);
   animations_impl->Animate(time);
 
   EXPECT_EQ(Animation::PAUSED,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   // Opacity value doesn't depend on time if paused at specified time offset.
-  EXPECT_EQ(0.4f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
-  EXPECT_EQ(0.4f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.4f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
+  EXPECT_EQ(0.4f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, DoNotSyncFinishedAnimation) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
@@ skipping 133 matching lines @@
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
 
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
   animations->AddAnimation(std::move(to_add));
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
   animations->Animate(kInitialTickTime);
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   // A non-impl-only animation should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 TEST_F(ElementAnimationsTest, TrivialTransitionOnImpl) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   to_add->set_is_impl_only(true);
 
   animations_impl->AddAnimation(std::move(to_add));
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_TRUE(animations_impl->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_EQ(1u, events->events_.size());
   const AnimationEvent* start_opacity_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(0.f, start_opacity_event->opacity);
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   animations_impl->UpdateState(true, events.get());
-  EXPECT_EQ(1.f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations_impl->HasActiveAnimation());
   EXPECT_EQ(2u, events->events_.size());
   const AnimationEvent* end_opacity_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(1.f, end_opacity_event->opacity);
 }
 
 TEST_F(ElementAnimationsTest, TrivialTransformOnImpl) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
@@ skipping 22 matching lines @@
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::TRANSFORM));
   animation->set_is_impl_only(true);
   animations_impl->AddAnimation(std::move(animation));
 
   // Run animation.
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_TRUE(animations_impl->HasActiveAnimation());
   EXPECT_EQ(gfx::Transform(),
-            client_impl_.GetTransform(element_id_, LayerTreeType::ACTIVE));
+            client_impl_.GetTransform(element_id_, ElementListType::ACTIVE));
   EXPECT_EQ(1u, events->events_.size());
   const AnimationEvent* start_transform_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   ASSERT_TRUE(start_transform_event);
   EXPECT_EQ(gfx::Transform(), start_transform_event->transform);
   EXPECT_TRUE(start_transform_event->is_impl_only);
 
   gfx::Transform expected_transform;
   expected_transform.Translate(delta_x, delta_y);
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   animations_impl->UpdateState(true, events.get());
   EXPECT_EQ(expected_transform,
-            client_impl_.GetTransform(element_id_, LayerTreeType::ACTIVE));
+            client_impl_.GetTransform(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations_impl->HasActiveAnimation());
   EXPECT_EQ(2u, events->events_.size());
   const AnimationEvent* end_transform_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(expected_transform, end_transform_event->transform);
   EXPECT_TRUE(end_transform_event->is_impl_only);
 }
 
 TEST_F(ElementAnimationsTest, FilterTransition) {
   CreateTestLayer(true, false);
@@ skipping 16 matching lines @@
                                             end_filters, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::FILTER));
   animations->AddAnimation(std::move(animation));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(start_filters,
-            client_.GetFilters(element_id_, LayerTreeType::ACTIVE));
+            client_.GetFilters(element_id_, ElementListType::ACTIVE));
   // A non-impl-only animation should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(1u, client_.GetFilters(element_id_, LayerTreeType::ACTIVE).size());
+  EXPECT_EQ(1u,
+            client_.GetFilters(element_id_, ElementListType::ACTIVE).size());
   EXPECT_EQ(FilterOperation::CreateBrightnessFilter(1.5f),
-            client_.GetFilters(element_id_, LayerTreeType::ACTIVE).at(0));
+            client_.GetFilters(element_id_, ElementListType::ACTIVE).at(0));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
   EXPECT_EQ(end_filters,
-            client_.GetFilters(element_id_, LayerTreeType::ACTIVE));
+            client_.GetFilters(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 TEST_F(ElementAnimationsTest, FilterTransitionOnImplOnly) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
@@ skipping 17 matching lines @@
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::FILTER));
   animation->set_is_impl_only(true);
   animations_impl->AddAnimation(std::move(animation));
 
   // Run animation.
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_TRUE(animations_impl->HasActiveAnimation());
   EXPECT_EQ(start_filters,
-            client_impl_.GetFilters(element_id_, LayerTreeType::ACTIVE));
+            client_impl_.GetFilters(element_id_, ElementListType::ACTIVE));
   EXPECT_EQ(1u, events->events_.size());
   const AnimationEvent* start_filter_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_TRUE(start_filter_event);
   EXPECT_EQ(start_filters, start_filter_event->filters);
   EXPECT_TRUE(start_filter_event->is_impl_only);
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   animations_impl->UpdateState(true, events.get());
   EXPECT_EQ(end_filters,
-            client_impl_.GetFilters(element_id_, LayerTreeType::ACTIVE));
+            client_impl_.GetFilters(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations_impl->HasActiveAnimation());
   EXPECT_EQ(2u, events->events_.size());
   const AnimationEvent* end_filter_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_TRUE(end_filter_event);
   EXPECT_EQ(end_filters, end_filter_event->filters);
   EXPECT_TRUE(end_filter_event->is_impl_only);
 }
 
 TEST_F(ElementAnimationsTest, ScrollOffsetTransition) {
@@ skipping 26 matching lines @@
           ->curve()
           ->Duration();
   EXPECT_EQ(duration, animations->GetAnimation(TargetProperty::SCROLL_OFFSET)
                           ->curve()
                           ->Duration());
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(initial_value,
-            client_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
+            client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_TRUE(animations_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value,
-            client_impl_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
+            client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations->NotifyAnimationStarted(events->events_[0]);
   animations->Animate(kInitialTickTime + duration / 2);
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(200.f, 250.f),
-      client_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
+      client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime + duration / 2);
   animations_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(200.f, 250.f),
-      client_impl_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
+      client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations_impl->Animate(kInitialTickTime + duration);
   animations_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, client_impl_.GetScrollOffset(
-                                        element_id_, LayerTreeType::ACTIVE));
+                                        element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations_impl->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations->Animate(kInitialTickTime + duration);
   animations->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, client_.GetScrollOffset(
-                                        element_id_, LayerTreeType::ACTIVE));
+                                        element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 TEST_F(ElementAnimationsTest, ScrollOffsetTransitionOnImplOnly) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   gfx::ScrollOffset initial_value(100.f, 300.f);
   gfx::ScrollOffset target_value(300.f, 200.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(target_value,
                                          EaseInOutTimingFunction::Create()));
   curve->SetInitialValue(initial_value);
   double duration_in_seconds = curve->Duration().InSecondsF();
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
   animation->set_is_impl_only(true);
   animations_impl->AddAnimation(std::move(animation));
 
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_TRUE(animations_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value,
-            client_impl_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
+            client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   TimeDelta duration = TimeDelta::FromMicroseconds(
       duration_in_seconds * base::Time::kMicrosecondsPerSecond);
 
   animations_impl->Animate(kInitialTickTime + duration / 2);
   animations_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(200.f, 250.f),
-      client_impl_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
+      client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations_impl->Animate(kInitialTickTime + duration);
   animations_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, client_impl_.GetScrollOffset(
-                                        element_id_, LayerTreeType::ACTIVE));
+                                        element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations_impl->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 // Ensure that when the impl animations doesn't have a value provider,
 // the main-thread animations's value provider is used to obtain the intial
 // scroll offset.
 TEST_F(ElementAnimationsTest, ScrollOffsetTransitionNoImplProvider) {
   CreateTestLayer(false, false);
-  CreateTestImplLayer(LayerTreeType::PENDING);
+  CreateTestImplLayer(ElementListType::PENDING);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   EXPECT_TRUE(animations_impl->has_element_in_pending_list());
   EXPECT_FALSE(animations_impl->has_element_in_active_list());
 
   auto events = host_impl_->CreateEvents();
@@ skipping 19 matching lines @@
           ->Duration();
   EXPECT_EQ(duration, animations->GetAnimation(TargetProperty::SCROLL_OFFSET)
                           ->curve()
                           ->Duration());
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, nullptr);
 
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(initial_value,
-            client_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
-  EXPECT_EQ(gfx::ScrollOffset(),
-            client_impl_.GetScrollOffset(element_id_, LayerTreeType::PENDING));
+            client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
+  EXPECT_EQ(gfx::ScrollOffset(), client_impl_.GetScrollOffset(
+                                     element_id_, ElementListType::PENDING));
 
   animations_impl->Animate(kInitialTickTime);
 
   EXPECT_TRUE(animations_impl->HasActiveAnimation());
-  EXPECT_EQ(initial_value,
-            client_impl_.GetScrollOffset(element_id_, LayerTreeType::PENDING));
+  EXPECT_EQ(initial_value, client_impl_.GetScrollOffset(
+                               element_id_, ElementListType::PENDING));
 
-  CreateTestImplLayer(LayerTreeType::ACTIVE);
+  CreateTestImplLayer(ElementListType::ACTIVE);
 
   animations_impl->UpdateState(true, events.get());
   DCHECK_EQ(1UL, events->events_.size());
 
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations->NotifyAnimationStarted(events->events_[0]);
   animations->Animate(kInitialTickTime + duration / 2);
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(400.f, 150.f),
-      client_.GetScrollOffset(element_id_, LayerTreeType::ACTIVE));
+      client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime + duration / 2);
   animations_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(400.f, 150.f),
-      client_impl_.GetScrollOffset(element_id_, LayerTreeType::PENDING));
+      client_impl_.GetScrollOffset(element_id_, ElementListType::PENDING));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations_impl->Animate(kInitialTickTime + duration);
   animations_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, client_impl_.GetScrollOffset(
-                                        element_id_, LayerTreeType::PENDING));
+                                        element_id_, ElementListType::PENDING));
   EXPECT_FALSE(animations_impl->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   animations->Animate(kInitialTickTime + duration);
   animations->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, client_.GetScrollOffset(
-                                        element_id_, LayerTreeType::ACTIVE));
+                                        element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 TEST_F(ElementAnimationsTest, ScrollOffsetRemovalClearsScrollDelta) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
@@ skipping 177 matching lines @@
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   to_add->set_needs_synchronized_start_time(true);
 
   // We should pause at the first keyframe indefinitely waiting for that
   // animation to start.
   animations->AddAnimation(std::move(to_add));
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Send the synchronized start time.
   animations->NotifyAnimationStarted(
       AnimationEvent(AnimationEvent::STARTED, 0, 1, TargetProperty::OPACITY,
                      kInitialTickTime + TimeDelta::FromMilliseconds(2000)));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(5000));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 // Tests that two queued animations affecting the same property run in sequence.
 TEST_F(ElementAnimationsTest, TrivialQueuing) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
@@ skipping 10 matching lines @@
 
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
 
   animations->Animate(kInitialTickTime);
 
   // The second animation still needs to be started.
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
 
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
   animations->UpdateState(true, events.get());
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
 
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 // Tests interrupting a transition with another transition.
 TEST_F(ElementAnimationsTest, Interrupt) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.5f)),
       2, TargetProperty::OPACITY));
   animations->AbortAnimations(TargetProperty::OPACITY);
   animations->AddAnimation(std::move(to_add));
 
   // Since the previous animation was aborted, the new animation should start
   // right in this call to animate.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 // Tests scheduling two animations to run together when only one property is
 // free.
 TEST_F(ElementAnimationsTest, ScheduleTogetherWhenAPropertyIsBlocked) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1,
       TargetProperty::TRANSFORM));
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 2,
       TargetProperty::TRANSFORM));
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       2, TargetProperty::OPACITY));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(animations->HasActiveAnimation());
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
   // Should not have started the float transition yet.
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   // The float animation should have started at time 1 and should be done.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 // Tests scheduling two animations to run together with different lengths and
 // another animation queued to start when the shorter animation finishes (should
 // wait for both to finish).
 TEST_F(ElementAnimationsTest, ScheduleTogetherWithAnAnimWaiting) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(2)), 1,
       TargetProperty::TRANSFORM));
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.5f)),
       2, TargetProperty::OPACITY));
 
   // Animations with id 1 should both start now.
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   // The opacity animation should have finished at time 1, but the group
   // of animations with id 1 don't finish until time 2 because of the length
   // of the transform animation.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, events.get());
   // Should not have started the float transition yet.
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // The second opacity animation should start at time 2 and should be done by
   // time 3.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 // Test that a looping animation loops and for the correct number of iterations.
 TEST_F(ElementAnimationsTest, TrivialLooping) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   to_add->set_iterations(3);
   animations->AddAnimation(std::move(to_add));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2250));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2750));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   animations->UpdateState(true, events.get());
   EXPECT_FALSE(animations->HasActiveAnimation());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Just be extra sure.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
   animations->UpdateState(true, events.get());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 // Test that an infinitely looping animation does indeed go until aborted.
 TEST_F(ElementAnimationsTest, InfiniteLooping) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   to_add->set_iterations(-1);
   animations->AddAnimation(std::move(to_add));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations->Animate(kInitialTickTime +
                       TimeDelta::FromMilliseconds(1073741824250));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime +
                       TimeDelta::FromMilliseconds(1073741824750));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(animations->GetAnimation(TargetProperty::OPACITY));
   animations->GetAnimation(TargetProperty::OPACITY)
       ->SetRunState(Animation::ABORTED,
                     kInitialTickTime + TimeDelta::FromMilliseconds(750));
   EXPECT_FALSE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 // Test that pausing and resuming work as expected.
 TEST_F(ElementAnimationsTest, PauseResume) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(animations->GetAnimation(TargetProperty::OPACITY));
   animations->GetAnimation(TargetProperty::OPACITY)
       ->SetRunState(Animation::PAUSED,
                     kInitialTickTime + TimeDelta::FromMilliseconds(500));
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024000));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(animations->GetAnimation(TargetProperty::OPACITY));
   animations->GetAnimation(TargetProperty::OPACITY)
       ->SetRunState(Animation::RUNNING,
                     kInitialTickTime + TimeDelta::FromMilliseconds(1024000));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024250));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024500));
   animations->UpdateState(true, events.get());
   EXPECT_FALSE(animations->HasActiveAnimation());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, AbortAGroupedAnimation) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   const int animation_id = 2;
   animations->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1, 1,
       TargetProperty::TRANSFORM));
   animations->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)),
       animation_id, 1, TargetProperty::OPACITY));
   animations->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.75f)),
       3, 2, TargetProperty::OPACITY));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(animations->GetAnimationById(animation_id));
   animations->GetAnimationById(animation_id)
       ->SetRunState(Animation::ABORTED,
                     kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(!animations->HasActiveAnimation());
-  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, PushUpdatesWhenSynchronizedStartTimeNeeded) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
@@ skipping 52 matching lines @@
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   events = host_impl_->CreateEvents();
   animations->UpdateState(true, events.get());
 
   // Should have one STARTED event and one FINISHED event.
   EXPECT_EQ(2u, events->events_.size());
   EXPECT_NE(events->events_[0].type, events->events_[1].type);
 
   // The float transition should still be at its starting point.
   EXPECT_TRUE(animations->HasActiveAnimation());
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   animations->UpdateState(true, events.get());
 
   // The float tranisition should now be done.
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->HasActiveAnimation());
 }
 
 // Tests that an animation animations with only a pending observer gets ticked
 // but doesn't progress animations past the STARTING state.
 TEST_F(ElementAnimationsTest, InactiveObserverGetsTicked) {
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   const int id = 1;
   animations->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.5f, 1.f)),
       id, TargetProperty::OPACITY));
 
   // Without an observer, the animation shouldn't progress to the STARTING
   // state.
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
 
-  CreateTestImplLayer(LayerTreeType::PENDING);
+  CreateTestImplLayer(ElementListType::PENDING);
 
   // With only a pending observer, the animation should progress to the
   // STARTING state and get ticked at its starting point, but should not
   // progress to RUNNING.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::STARTING,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
 
   // Even when already in the STARTING state, the animation should stay
   // there, and shouldn't be ticked past its starting point.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::STARTING,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
 
-  CreateTestImplLayer(LayerTreeType::ACTIVE);
+  CreateTestImplLayer(ElementListType::ACTIVE);
 
   // Now that an active observer has been added, the animation should still
   // initially tick at its starting point, but should now progress to RUNNING.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   animations->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(Animation::RUNNING,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // The animation should now tick past its starting point.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3500));
-  EXPECT_NE(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_NE(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_NE(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_NE(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TransformAnimationBounds) {
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve1(
       KeyframedTransformAnimationCurve::Create());
@@ skipping 425 matching lines @@
 }
 
 TEST_F(ElementAnimationsTest, HasOnlyTranslationTransforms) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::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(LayerTreeType::ACTIVE));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::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(LayerTreeType::ACTIVE));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::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_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   // A scale animation is not a translation.
   EXPECT_FALSE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::PENDING));
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::PENDING));
   EXPECT_FALSE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
 
   animations_impl->GetAnimationById(3)->set_affects_pending_elements(false);
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::PENDING));
   EXPECT_FALSE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
 
   animations_impl->GetAnimationById(3)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // HasOnlyTranslationTransforms.
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::PENDING));
   EXPECT_TRUE(
-      animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
+      animations_impl->HasOnlyTranslationTransforms(ElementListType::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_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   float start_scale = 0.f;
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(4.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::ACTIVE,
                                                    &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(4.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::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);
@@ skipping 18 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_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(6.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::ACTIVE,
                                                    &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(6.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::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(LayerTreeType::PENDING,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(5.f, start_scale);
-  EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
+  EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(0.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(4.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(0.f, max_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(4.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   animations_impl->ActivateAnimations();
-  EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
-  EXPECT_FALSE(
-      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_FALSE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                   &max_scale));
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   animations_impl->ActivateAnimations();
+  EXPECT_FALSE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                   &max_scale));
   EXPECT_FALSE(
-      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
-  EXPECT_FALSE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(4.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(3.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(3.f, max_scale);
 
   // ALTERNATE reverse direction.
   animation->set_direction(Animation::DIRECTION_REVERSE);
-  EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(3.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(3.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(3.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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(LayerTreeType::PENDING, &max_scale));
+  EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
+                                                  &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
-      animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
+      animations_impl->MaximumTargetScale(ElementListType::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 21 matching lines @@
   EXPECT_FALSE(animations_impl->needs_to_start_animations_for_testing());
   animations_impl->UpdateState(true, events.get());
 
   // Since the animation hasn't been activated, it should still be STARTING
   // rather than RUNNING.
   EXPECT_EQ(Animation::STARTING,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   // Since the animation hasn't been activated, only the pending observer
   // should have been ticked.
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   animations_impl->UpdateState(true, events.get());
 
   // Since the animation has been activated, it should have reached the
   // RUNNING state and the active observer should start to get ticked.
   EXPECT_EQ(Animation::RUNNING,
             animations_impl->GetAnimationById(animation_id)->run_state());
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, ActivationBetweenAnimateAndUpdateState) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   const int animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.5f, 1.f, true);
 
   animations->PushPropertiesTo(animations_impl.get());
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_pending_elements());
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
                    ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime);
 
   // Since the animation hasn't been activated, only the pending observer
   // should have been ticked.
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_active_elements());
 
   animations_impl->UpdateState(true, events.get());
 
   // Since the animation has been activated, it should have reached the
   // RUNNING state.
   EXPECT_EQ(Animation::RUNNING,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   animations_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
 
   // Both elements should have been ticked.
   EXPECT_EQ(0.75f,
-            client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.75f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.75f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest,
        ObserverNotifiedWhenTransformIsPotentiallyAnimatingChanges) {
   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_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+      client_.GetTransformIsAnimating(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                    LayerTreeType::PENDING));
-  EXPECT_FALSE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                    ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                    ElementListType::ACTIVE));
 
   // Case 1: An animation that's allowed to run until its finish point.
   AddAnimatedTransformToElementAnimations(animations.get(), 1.0, 1, 1);
   EXPECT_TRUE(
-      client_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+      client_.GetTransformIsAnimating(element_id_, ElementListType::ACTIVE));
 
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                   LayerTreeType::PENDING));
-  EXPECT_FALSE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                   ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                    ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                   LayerTreeType::PENDING));
-  EXPECT_TRUE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                   ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetTransformIsAnimating(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_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+      client_.GetTransformIsAnimating(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_.GetTransformIsAnimating(element_id_,
-                                                   LayerTreeType::PENDING));
-  EXPECT_TRUE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                   ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                   ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   animations_impl->UpdateState(true, events.get());
   EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                    LayerTreeType::PENDING));
-  EXPECT_FALSE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                    ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                    ElementListType::ACTIVE));
 
   animations->NotifyAnimationFinished(events->events_[0]);
   events->events_.clear();
 
   // Case 2: An animation that's removed before it finishes.
   int animation_id =
       AddAnimatedTransformToElementAnimations(animations.get(), 10.0, 2, 2);
   EXPECT_TRUE(
-      client_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+      client_.GetTransformIsAnimating(element_id_, ElementListType::ACTIVE));
 
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                   LayerTreeType::PENDING));
-  EXPECT_FALSE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                   ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                    ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                   LayerTreeType::PENDING));
-  EXPECT_TRUE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                   ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetTransformIsAnimating(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_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+      client_.GetTransformIsAnimating(element_id_, ElementListType::ACTIVE));
 
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                    LayerTreeType::PENDING));
-  EXPECT_TRUE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                    ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                   ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                    LayerTreeType::PENDING));
-  EXPECT_FALSE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                    ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                    ElementListType::ACTIVE));
 
   // Case 3: An animation that's aborted before it finishes.
   animation_id =
       AddAnimatedTransformToElementAnimations(animations.get(), 10.0, 3, 3);
   EXPECT_TRUE(
-      client_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+      client_.GetTransformIsAnimating(element_id_, ElementListType::ACTIVE));
 
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                   LayerTreeType::PENDING));
-  EXPECT_FALSE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                   ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                    ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                   LayerTreeType::PENDING));
-  EXPECT_TRUE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                   ElementListType::PENDING));
+  EXPECT_TRUE(client_impl_.GetTransformIsAnimating(element_id_,
+                                                   ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(3000));
   animations_impl->UpdateState(true, events.get());
 
   animations->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   animations_impl->AbortAnimations(TargetProperty::TRANSFORM);
   EXPECT_FALSE(client_impl_.GetTransformIsAnimating(element_id_,
-                                                    LayerTreeType::PENDING));
-  EXPECT_FALSE(
-      client_impl_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+                                                    ElementListType::PENDING));
+  EXPECT_FALSE(client_impl_.GetTransformIsAnimating(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_.GetTransformIsAnimating(element_id_, LayerTreeType::ACTIVE));
+      client_.GetTransformIsAnimating(element_id_, ElementListType::ACTIVE));
 }
 
 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_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Opacity values are clipped [0,1]
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, ClippedNegativeOpacityValues) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   AddOpacityTransitionToElementAnimations(animations.get(), 1, 0.f, -2.f, true);
 
   animations->Animate(kInitialTickTime);
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Opacity values are clipped [0,1]
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, PushedDeletedAnimationWaitsForActivation) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   const int animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.5f, 1.f, true);
 
   animations->PushPropertiesTo(animations_impl.get());
   animations_impl->ActivateAnimations();
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_EQ(Animation::RUNNING,
             animations_impl->GetAnimationById(animation_id)->run_state());
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_active_elements());
 
   // Delete the animation on the main-thread animations.
   animations->RemoveAnimation(
       animations->GetAnimation(TargetProperty::OPACITY)->id());
   animations->PushPropertiesTo(animations_impl.get());
 
   // The animation should no longer affect pending elements.
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
                    ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations_impl->UpdateState(true, events.get());
 
   // Only the active observer should have been ticked.
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.75f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.75f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
 
   // Activation should cause the animation to be deleted.
   EXPECT_FALSE(animations_impl->has_any_animation());
 }
 
 // Tests that an animation that affects only active elements won't block
 // an animation that affects only pending elements from starting.
 TEST_F(ElementAnimationsTest, StartAnimationsAffectingDifferentObservers) {
@@ skipping 39 matching lines @@
   // The original animation should still be running, and the new animation
   // should be starting.
   EXPECT_EQ(Animation::RUNNING,
             animations_impl->GetAnimationById(first_animation_id)->run_state());
   EXPECT_EQ(
       Animation::STARTING,
       animations_impl->GetAnimationById(second_animation_id)->run_state());
 
   // 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, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(0.5f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(0.5f,
+            client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
 
   // The original animation should have been deleted, and the new animation
   // should now affect both elements.
   EXPECT_FALSE(animations_impl->GetAnimationById(first_animation_id));
   EXPECT_TRUE(animations_impl->GetAnimationById(second_animation_id)
                   ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(second_animation_id)
                   ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   animations_impl->UpdateState(true, events.get());
 
   // The new animation should be running, and the active observer should have
   // been ticked at the new animation's starting point.
   EXPECT_EQ(
       Animation::RUNNING,
       animations_impl->GetAnimationById(second_animation_id)->run_state());
-  EXPECT_EQ(1.f, client_impl_.GetOpacity(element_id_, LayerTreeType::PENDING));
-  EXPECT_EQ(1.f, client_impl_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f,
+            client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
+  EXPECT_EQ(1.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TestIsCurrentlyAnimatingProperty) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   // Create an animation that initially affects only pending elements.
   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_elements(false);
 
   animations->AddAnimation(std::move(animation));
   animations->Animate(kInitialTickTime);
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                        LayerTreeType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->HasActiveAnimation());
 
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                        LayerTreeType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::FILTER, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::FILTER, ElementListType::ACTIVE));
 
   animations->ActivateAnimations();
 
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::PENDING));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::PENDING));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::FILTER, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::FILTER, ElementListType::ACTIVE));
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(10));
   animations->UpdateState(true, nullptr);
 
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::PENDING));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::PENDING));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::FILTER, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::FILTER, ElementListType::ACTIVE));
 
-  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Tick past the end of the animation.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1100));
   animations->UpdateState(true, nullptr);
 
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::FILTER, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::FILTER, ElementListType::ACTIVE));
 
-  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, LayerTreeType::ACTIVE));
+  EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TestIsAnimatingPropertyTimeOffsetFillMode) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   // Create an animation that initially affects only pending elements, 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_elements(false);
 
   animations->AddAnimation(std::move(animation));
 
   animations->Animate(kInitialTickTime);
 
   // Since the animation has a start delay, the elements it affects have a
   // potentially running transform animation but aren't currently animating
   // transform.
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::PENDING));
+      TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::PENDING));
+      TargetProperty::FILTER, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::ACTIVE));
+      TargetProperty::FILTER, ElementListType::ACTIVE));
 
   animations->ActivateAnimations();
 
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::PENDING));
+      TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::PENDING));
+      TargetProperty::FILTER, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::FILTER, LayerTreeType::ACTIVE));
+      TargetProperty::FILTER, ElementListType::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, LayerTreeType::PENDING));
+      TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::PENDING));
-  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                       LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::PENDING));
+  EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
 
   // After the animaton finishes, the elements 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, LayerTreeType::PENDING));
+      TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
-      TargetProperty::OPACITY, LayerTreeType::PENDING));
-  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
-                                                        LayerTreeType::ACTIVE));
+      TargetProperty::OPACITY, ElementListType::PENDING));
+  EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
+      TargetProperty::OPACITY, ElementListType::ACTIVE));
 }
 
 }  // namespace
 }  // namespace cc