CC Animation: Remove Observers and Observations in namings.

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 40 matching lines @@
 
   host_->AddAnimationTimeline(timeline_);
 
   timeline_->AttachPlayer(player_);
   player_->AttachLayer(layer_id_);
 
   scoped_refptr<ElementAnimations> element_animations =
       player_->element_animations();
   EXPECT_TRUE(element_animations);
 
-  EXPECT_TRUE(element_animations->needs_active_value_observations());
-  EXPECT_FALSE(element_animations->needs_pending_value_observations());
+  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->needs_active_value_observations());
-  EXPECT_TRUE(element_animations_impl->needs_pending_value_observations());
+  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(layer_id_, LayerTreeType::ACTIVE);
-  EXPECT_TRUE(element_animations_impl->needs_active_value_observations());
-  EXPECT_TRUE(element_animations_impl->needs_pending_value_observations());
+  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(layer_id_, LayerTreeType::ACTIVE));
   EXPECT_TRUE(client_impl_.IsLayerInTree(layer_id_, LayerTreeType::PENDING));
 
   // kill layer on main thread.
   client_.UnregisterLayer(layer_id_, LayerTreeType::ACTIVE);
   EXPECT_EQ(element_animations, player_->element_animations());
-  EXPECT_FALSE(element_animations->needs_active_value_observations());
-  EXPECT_FALSE(element_animations->needs_pending_value_observations());
+  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->needs_active_value_observations());
-  EXPECT_TRUE(element_animations_impl->needs_pending_value_observations());
+  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(layer_id_, LayerTreeType::PENDING);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
-  EXPECT_TRUE(element_animations_impl->needs_active_value_observations());
-  EXPECT_FALSE(element_animations_impl->needs_pending_value_observations());
+  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(layer_id_, LayerTreeType::ACTIVE);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
-  EXPECT_FALSE(element_animations_impl->needs_active_value_observations());
-  EXPECT_FALSE(element_animations_impl->needs_pending_value_observations());
+  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->needs_active_value_observations());
-  EXPECT_FALSE(element_animations_impl->needs_pending_value_observations());
+  EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
+  EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   player_->DetachLayer();
   EXPECT_FALSE(player_->element_animations());
 
   // Release ptrs now to test the order of destruction.
   ReleaseRefPtrs();
 }
 
 TEST_F(ElementAnimationsTest, AttachToNotYetCreatedLayer) {
   host_->AddAnimationTimeline(timeline_);
   timeline_->AttachPlayer(player_);
 
   host_->PushPropertiesTo(host_impl_);
 
   GetImplTimelineAndPlayerByID();
 
   player_->AttachLayer(layer_id_);
 
   scoped_refptr<ElementAnimations> element_animations =
       player_->element_animations();
   EXPECT_TRUE(element_animations);
 
-  EXPECT_FALSE(element_animations->needs_active_value_observations());
-  EXPECT_FALSE(element_animations->needs_pending_value_observations());
+  EXPECT_FALSE(element_animations->has_element_in_active_list());
+  EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
   host_->PushPropertiesTo(host_impl_);
 
   scoped_refptr<ElementAnimations> element_animations_impl =
       player_impl_->element_animations();
   EXPECT_TRUE(element_animations_impl);
 
-  EXPECT_FALSE(element_animations_impl->needs_active_value_observations());
-  EXPECT_FALSE(element_animations_impl->needs_pending_value_observations());
+  EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
+  EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   // Create layer.
   client_.RegisterLayer(layer_id_, LayerTreeType::ACTIVE);
-  EXPECT_TRUE(element_animations->needs_active_value_observations());
-  EXPECT_FALSE(element_animations->needs_pending_value_observations());
+  EXPECT_TRUE(element_animations->has_element_in_active_list());
+  EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
   client_impl_.RegisterLayer(layer_id_, LayerTreeType::PENDING);
-  EXPECT_FALSE(element_animations_impl->needs_active_value_observations());
-  EXPECT_TRUE(element_animations_impl->needs_pending_value_observations());
+  EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
+  EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
   client_impl_.RegisterLayer(layer_id_, LayerTreeType::ACTIVE);
-  EXPECT_TRUE(element_animations_impl->needs_active_value_observations());
-  EXPECT_TRUE(element_animations_impl->needs_pending_value_observations());
+  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(layer_id_);
 
   scoped_refptr<ElementAnimations> element_animations =
       player_->element_animations();
   EXPECT_TRUE(element_animations);
@@ skipping 46 matching lines @@
        node = node->next()) {
     const AnimationPlayer* player_impl = node->value();
     EXPECT_TRUE(timeline_->GetPlayerById(player_impl->id()));
     ++list_size_after;
   }
   EXPECT_EQ(2, list_size_after);
 }
 
 TEST_F(ElementAnimationsTest, SyncNewAnimation) {
   auto animations_impl = ElementAnimations::Create();
-  animations_impl->set_needs_active_value_observations(true);
+  animations_impl->set_has_element_in_active_list(true);
 
   auto animations = ElementAnimations::Create();
-  animations->set_needs_active_value_observations(true);
+  animations->set_has_element_in_active_list(true);
 
   EXPECT_FALSE(animations_impl->GetAnimation(TargetProperty::OPACITY));
 
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
   EXPECT_FALSE(animations_impl->needs_to_start_animations_for_testing());
 
   int animation_id =
       AddOpacityTransitionToElementAnimations(animations.get(), 1, 0, 1, false);
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
 
@@ skipping 788 matching lines @@
 // scroll offset.
 TEST_F(ElementAnimationsTest, ScrollOffsetTransitionNoImplProvider) {
   CreateTestLayer(false, false);
   CreateTestImplLayer(LayerTreeType::PENDING);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
-  EXPECT_TRUE(animations_impl->needs_pending_value_observations());
-  EXPECT_FALSE(animations_impl->needs_active_value_observations());
+  EXPECT_TRUE(animations_impl->has_element_in_pending_list());
+  EXPECT_FALSE(animations_impl->has_element_in_active_list());
 
   auto events = host_impl_->CreateEvents();
 
   gfx::ScrollOffset initial_value(500.f, 100.f);
   gfx::ScrollOffset target_value(300.f, 200.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(target_value,
                                          EaseInOutTimingFunction::Create()));
 
   std::unique_ptr<Animation> animation(
@@ skipping 716 matching lines @@
       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());
 
-  // animations->set_needs_pending_value_observations(true);
   CreateTestImplLayer(LayerTreeType::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(layer_id_, LayerTreeType::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(layer_id_, LayerTreeType::PENDING));
 
-  // animations->set_needs_active_value_observations(true);
   CreateTestImplLayer(LayerTreeType::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(layer_id_, LayerTreeType::PENDING));
@@ skipping 487 matching lines @@
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 3, 3, TargetProperty::TRANSFORM);
-  animation->set_affects_active_observers(false);
+  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));
   EXPECT_TRUE(
       animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(
       animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
   EXPECT_FALSE(
       animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
 
-  animations_impl->GetAnimationById(3)->set_affects_pending_observers(false);
+  animations_impl->GetAnimationById(3)->set_affects_pending_elements(false);
   EXPECT_TRUE(
       animations_impl->HasOnlyTranslationTransforms(LayerTreeType::PENDING));
   EXPECT_FALSE(
       animations_impl->HasOnlyTranslationTransforms(LayerTreeType::ACTIVE));
 
   animations_impl->GetAnimationById(3)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // HasOnlyTranslationTransforms.
@@ skipping 15 matching lines @@
 
   TransformOperations operations1;
   operations1.AppendScale(2.0, 3.0, 4.0);
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   TransformOperations operations2;
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
-  animation->set_affects_active_observers(false);
+  animation->set_affects_active_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   float start_scale = 0.f;
   EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(4.f, start_scale);
   EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
                                                    &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
@@ skipping 14 matching lines @@
   operations3.AppendScale(6.0, 5.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations3, nullptr));
 
   animations_impl->RemoveAnimation(1);
   animation =
       Animation::Create(std::move(curve2), 2, 2, TargetProperty::TRANSFORM);
 
   // Reverse Direction
   animation->set_direction(Animation::DIRECTION_REVERSE);
-  animation->set_affects_active_observers(false);
+  animation->set_affects_active_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve3(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations4;
   operations4.AppendScale(5.0, 3.0, 1.0);
   curve3->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations4, nullptr));
   TransformOperations operations5;
   curve3->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations5, nullptr));
 
   animation =
       Animation::Create(std::move(curve3), 3, 3, TargetProperty::TRANSFORM);
-  animation->set_affects_active_observers(false);
+  animation->set_affects_active_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(6.f, start_scale);
   EXPECT_TRUE(animations_impl->AnimationStartScale(LayerTreeType::ACTIVE,
                                                    &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
   animations_impl->ActivateAnimations();
@@ skipping 37 matching lines @@
 
   TransformOperations operations1;
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendScale(2.0, 3.0, 4.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations1, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
-  animation->set_affects_active_observers(false);
+  animation->set_affects_active_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(4.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(0.f, max_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(4.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(6.0, 5.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 2, 2, TargetProperty::TRANSFORM);
-  animation->set_affects_active_observers(false);
+  animation->set_affects_active_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve3(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations3;
   curve3->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations3, nullptr));
   operations3.AppendPerspective(6.0);
   curve3->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations3, nullptr));
 
   animation =
       Animation::Create(std::move(curve3), 3, 3, TargetProperty::TRANSFORM);
-  animation->set_affects_active_observers(false);
+  animation->set_affects_active_elements(false);
   animations_impl->AddAnimation(std::move(animation));
 
   EXPECT_FALSE(
       animations_impl->MaximumTargetScale(LayerTreeType::PENDING, &max_scale));
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(LayerTreeType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(
@@ skipping 134 matching lines @@
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
 
   EXPECT_FALSE(animations_impl->needs_to_start_animations_for_testing());
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_TRUE(animations_impl->needs_to_start_animations_for_testing());
 
   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_observers());
+                  ->affects_pending_elements());
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
-                   ->affects_active_observers());
+                   ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime);
   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(layer_id_, LayerTreeType::PENDING));
   EXPECT_EQ(0.f, client_impl_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
-                  ->affects_pending_observers());
+                  ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
-                  ->affects_active_observers());
+                  ->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(layer_id_, LayerTreeType::PENDING));
@@ skipping 12 matching lines @@
 
   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_observers());
+                  ->affects_pending_elements());
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
-                   ->affects_active_observers());
+                   ->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(layer_id_, LayerTreeType::PENDING));
   EXPECT_EQ(0.f, client_impl_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
-                  ->affects_pending_observers());
+                  ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
-                  ->affects_active_observers());
+                  ->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 observers should have been ticked.
+  // Both elements should have been ticked.
   EXPECT_EQ(0.75f, client_impl_.GetOpacity(layer_id_, LayerTreeType::PENDING));
   EXPECT_EQ(0.75f, client_impl_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest,
        ObserverNotifiedWhenTransformIsPotentiallyAnimatingChanges) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
@@ skipping 186 matching lines @@
   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(layer_id_, LayerTreeType::PENDING));
   EXPECT_EQ(0.5f, client_impl_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
-                  ->affects_pending_observers());
+                  ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
-                  ->affects_active_observers());
+                  ->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 observers.
+  // The animation should no longer affect pending elements.
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
-                   ->affects_pending_observers());
+                   ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
-                  ->affects_active_observers());
+                  ->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(layer_id_, LayerTreeType::PENDING));
   EXPECT_EQ(0.75f, client_impl_.GetOpacity(layer_id_, LayerTreeType::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 observers won't block
-// an animation that affects only pending observers from starting.
+// 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) {
   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 first_animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.f, 1.f, true);
 
   animations->PushPropertiesTo(animations_impl.get());
   animations_impl->ActivateAnimations();
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
 
   // Remove the first animation from the main-thread animations, and add a
   // new animation affecting the same property.
   animations->RemoveAnimation(
       animations->GetAnimation(TargetProperty::OPACITY)->id());
   const int second_animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 1.f, 0.5f, true);
   animations->PushPropertiesTo(animations_impl.get());
 
-  // The original animation should only affect active observers, and the new
-  // animation should only affect pending observers.
+  // The original animation should only affect active elements, and the new
+  // animation should only affect pending elements.
   EXPECT_FALSE(animations_impl->GetAnimationById(first_animation_id)
-                   ->affects_pending_observers());
+                   ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(first_animation_id)
-                  ->affects_active_observers());
+                  ->affects_active_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(second_animation_id)
-                  ->affects_pending_observers());
+                  ->affects_pending_elements());
   EXPECT_FALSE(animations_impl->GetAnimationById(second_animation_id)
-                   ->affects_active_observers());
+                   ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations_impl->UpdateState(true, events.get());
 
   // 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(layer_id_, LayerTreeType::PENDING));
   EXPECT_EQ(0.5f, client_impl_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 
   animations_impl->ActivateAnimations();
 
   // The original animation should have been deleted, and the new animation
-  // should now affect both observers.
+  // should now affect both elements.
   EXPECT_FALSE(animations_impl->GetAnimationById(first_animation_id));
   EXPECT_TRUE(animations_impl->GetAnimationById(second_animation_id)
-                  ->affects_pending_observers());
+                  ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(second_animation_id)
-                  ->affects_active_observers());
+                  ->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(layer_id_, LayerTreeType::PENDING));
   EXPECT_EQ(1.f, client_impl_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TestIsCurrentlyAnimatingProperty) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
-  // Create an animation that initially affects only pending observers.
+  // 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_observers(false);
+  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));
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->HasActiveAnimation());
 
@@ skipping 46 matching lines @@
 
   EXPECT_EQ(1.f, client_.GetOpacity(layer_id_, LayerTreeType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TestIsAnimatingPropertyTimeOffsetFillMode) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
-  // Create an animation that initially affects only pending observers, and has
+  // 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_observers(false);
+  animation->set_affects_active_elements(false);
 
   animations->AddAnimation(std::move(animation));
 
   animations->Animate(kInitialTickTime);
 
-  // Since the animation has a start delay, the observers it affects have a
+  // 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));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, LayerTreeType::PENDING));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                         LayerTreeType::ACTIVE));
@@ skipping 26 matching lines @@
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, LayerTreeType::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));
 
-  // After the animaton finishes, the observers it affects have neither a
+  // 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));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, LayerTreeType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, LayerTreeType::PENDING));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                         LayerTreeType::ACTIVE));
 }
 
 }  // namespace
 }  // namespace cc