CC Animation: Remove Observers and Observations in namings.

cc/animation/element_animations.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 <stddef.h>
 
 #include <algorithm>
 
@@ skipping 12 matching lines @@
 
 scoped_refptr<ElementAnimations> ElementAnimations::Create() {
   return make_scoped_refptr(new ElementAnimations());
 }
 
 ElementAnimations::ElementAnimations()
     : players_list_(new PlayersList()),
       animation_host_(),
       layer_id_(),
       is_active_(false),
-      needs_active_value_observations_(false),
-      needs_pending_value_observations_(false),
+      has_element_in_active_list_(false),
+      has_element_in_pending_list_(false),
       needs_to_start_animations_(false),
       scroll_offset_animation_was_interrupted_(false),
-      potentially_animating_transform_for_active_observers_(false),
-      potentially_animating_transform_for_pending_observers_(false) {}
+      potentially_animating_transform_for_active_elements_(false),
+      potentially_animating_transform_for_pending_elements_(false) {}
 
 ElementAnimations::~ElementAnimations() {}
 
 void ElementAnimations::SetAnimationHost(AnimationHost* host) {
   animation_host_ = host;
 }
 
 void ElementAnimations::SetLayerId(int layer_id) {
   layer_id_ = layer_id;
 }
 
-void ElementAnimations::InitValueObservations() {
+void ElementAnimations::InitAffectedElementTypes() {
   DCHECK(layer_id_);
   DCHECK(animation_host_);
 
   UpdateActivation(FORCE_ACTIVATION);
 
   DCHECK(animation_host_->mutator_host_client());
   if (animation_host_->mutator_host_client()->IsLayerInTree(
           layer_id_, LayerTreeType::ACTIVE)) {
-    set_needs_active_value_observations(true);
+    set_has_element_in_active_list(true);
   }
   if (animation_host_->mutator_host_client()->IsLayerInTree(
           layer_id_, LayerTreeType::PENDING)) {
-    set_needs_pending_value_observations(true);
+    set_has_element_in_pending_list(true);
   }
 }
 
-void ElementAnimations::ClearValueObservations() {
+void ElementAnimations::ClearAffectedElementTypes() {
   DCHECK(animation_host_);
 
-  if (needs_active_value_observations())
+  if (has_element_in_active_list())
     OnTransformIsPotentiallyAnimatingChanged(LayerTreeType::ACTIVE, false);
-  set_needs_active_value_observations(false);
+  set_has_element_in_active_list(false);
 
-  if (needs_pending_value_observations())
+  if (has_element_in_pending_list())
     OnTransformIsPotentiallyAnimatingChanged(LayerTreeType::PENDING, false);
-  set_needs_pending_value_observations(false);
+  set_has_element_in_pending_list(false);
 
   animation_host_->DidDeactivateElementAnimations(this);
   UpdateActivation(FORCE_ACTIVATION);
 }
 
 void ElementAnimations::LayerRegistered(int layer_id, LayerTreeType tree_type) {
   DCHECK_EQ(layer_id_, layer_id);
 
   if (tree_type == LayerTreeType::ACTIVE)
-    set_needs_active_value_observations(true);
+    set_has_element_in_active_list(true);
   else
-    set_needs_pending_value_observations(true);
+    set_has_element_in_pending_list(true);
 }
 
 void ElementAnimations::LayerUnregistered(int layer_id,
                                           LayerTreeType tree_type) {
   DCHECK_EQ(this->layer_id(), layer_id);
   if (tree_type == LayerTreeType::ACTIVE)
-    set_needs_active_value_observations(false);
+    set_has_element_in_active_list(false);
   else
-    set_needs_pending_value_observations(false);
+    set_has_element_in_pending_list(false);
 }
 
 void ElementAnimations::AddPlayer(AnimationPlayer* player) {
   players_list_->Append(player);
 }
 
 void ElementAnimations::RemovePlayer(AnimationPlayer* player) {
   for (PlayersListNode* node = players_list_->head();
        node != players_list_->end(); node = node->next()) {
     if (node->value() == player) {
@@ skipping 31 matching lines @@
       animation->target_property() == TargetProperty::TRANSFORM;
   animations_.push_back(std::move(animation));
   needs_to_start_animations_ = true;
   UpdateActivation(NORMAL_ACTIVATION);
   if (added_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void ElementAnimations::Animate(base::TimeTicks monotonic_time) {
   DCHECK(!monotonic_time.is_null());
-  if (!needs_active_value_observations() && !needs_pending_value_observations())
+  if (!has_element_in_active_list() && !has_element_in_pending_list())
     return;
 
   if (needs_to_start_animations_)
     StartAnimations(monotonic_time);
   TickAnimations(monotonic_time);
   last_tick_time_ = monotonic_time;
 }
 
 void ElementAnimations::AccumulatePropertyUpdates(
     base::TimeTicks monotonic_time,
@@ skipping 57 matching lines @@
         // main thread (e.g. for user-driven scrolling), so a PROPERTY_UPDATE
         // isn't needed.
         break;
       }
     }
   }
 }
 
 void ElementAnimations::UpdateState(bool start_ready_animations,
                                     AnimationEvents* events) {
-  if (!needs_active_value_observations())
+  if (!has_element_in_active_list())
     return;
 
-  // Animate hasn't been called, this happens if an observer has been added
+  // Animate hasn't been called, this happens if an element has been added
   // between the Commit and Draw phases.
   if (last_tick_time_ == base::TimeTicks())
     return;
 
   if (start_ready_animations)
     PromoteStartedAnimations(last_tick_time_, events);
 
   MarkFinishedAnimations(last_tick_time_);
   MarkAnimationsForDeletion(last_tick_time_, events);
 
   if (needs_to_start_animations_ && start_ready_animations) {
     StartAnimations(last_tick_time_);
     PromoteStartedAnimations(last_tick_time_, events);
   }
 
   AccumulatePropertyUpdates(last_tick_time_, events);
 
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 void ElementAnimations::ActivateAnimations() {
   bool changed_transform_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
-    if (animations_[i]->affects_active_observers() !=
-            animations_[i]->affects_pending_observers() &&
+    if (animations_[i]->affects_active_elements() !=
+            animations_[i]->affects_pending_elements() &&
         animations_[i]->target_property() == TargetProperty::TRANSFORM)
       changed_transform_animation = true;
-    animations_[i]->set_affects_active_observers(
-        animations_[i]->affects_pending_observers());
+    animations_[i]->set_affects_active_elements(
+        animations_[i]->affects_pending_elements());
   }
-  auto affects_no_observers = [](const std::unique_ptr<Animation>& animation) {
-    return !animation->affects_active_observers() &&
-           !animation->affects_pending_observers();
+  auto affects_no_elements = [](const std::unique_ptr<Animation>& animation) {
+    return !animation->affects_active_elements() &&
+           !animation->affects_pending_elements();
   };
   animations_.erase(std::remove_if(animations_.begin(), animations_.end(),
-                                   affects_no_observers),
+                                   affects_no_elements),
                     animations_.end());
   scroll_offset_animation_was_interrupted_ = false;
   UpdateActivation(NORMAL_ACTIVATION);
   if (changed_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void ElementAnimations::NotifyAnimationStarted(const AnimationEvent& event) {
   if (event.is_impl_only) {
     NotifyPlayersAnimationStarted(event.monotonic_time, event.target_property,
@@ skipping 59 matching lines @@
         aborted_transform_animation = true;
       break;
     }
   }
   if (aborted_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void ElementAnimations::NotifyAnimationPropertyUpdate(
     const AnimationEvent& event) {
-  bool notify_active_observers = true;
-  bool notify_pending_observers = true;
+  bool notify_active_elements = true;
+  bool notify_pending_elements = true;
   switch (event.target_property) {
     case TargetProperty::OPACITY:
-      NotifyObserversOpacityAnimated(event.opacity, notify_active_observers,
-                                     notify_pending_observers);
+      NotifyClientOpacityAnimated(event.opacity, notify_active_elements,
+                                  notify_pending_elements);
       break;
     case TargetProperty::TRANSFORM:
-      NotifyObserversTransformAnimated(event.transform, notify_active_observers,
-                                       notify_pending_observers);
+      NotifyClientTransformAnimated(event.transform, notify_active_elements,
+                                    notify_pending_elements);
       break;
     default:
       NOTREACHED();
   }
 }
 
 bool ElementAnimations::HasFilterAnimationThatInflatesBounds() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == TargetProperty::FILTER &&
@@ skipping 60 matching lines @@
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (transform_animation_curve->AffectsScale())
       return true;
   }
 
   return false;
 }
 
 bool ElementAnimations::HasOnlyTranslationTransforms(
-    LayerTreeType observer_type) const {
+    LayerTreeType tree_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
-    if ((observer_type == LayerTreeType::ACTIVE &&
-         !animations_[i]->affects_active_observers()) ||
-        (observer_type == LayerTreeType::PENDING &&
-         !animations_[i]->affects_pending_observers()))
+    if ((tree_type == LayerTreeType::ACTIVE &&
+         !animations_[i]->affects_active_elements()) ||
+        (tree_type == LayerTreeType::PENDING &&
+         !animations_[i]->affects_pending_elements()))
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (!transform_animation_curve->IsTranslation())
       return false;
   }
 
   return true;
 }
 
 bool ElementAnimations::AnimationsPreserveAxisAlignment() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (!transform_animation_curve->PreservesAxisAlignment())
       return false;
   }
 
   return true;
 }
 
-bool ElementAnimations::AnimationStartScale(LayerTreeType observer_type,
+bool ElementAnimations::AnimationStartScale(LayerTreeType tree_type,
                                             float* start_scale) const {
   *start_scale = 0.f;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
-    if ((observer_type == LayerTreeType::ACTIVE &&
-         !animations_[i]->affects_active_observers()) ||
-        (observer_type == LayerTreeType::PENDING &&
-         !animations_[i]->affects_pending_observers()))
+    if ((tree_type == LayerTreeType::ACTIVE &&
+         !animations_[i]->affects_active_elements()) ||
+        (tree_type == LayerTreeType::PENDING &&
+         !animations_[i]->affects_pending_elements()))
       continue;
 
     bool forward_direction = true;
     switch (animations_[i]->direction()) {
       case Animation::DIRECTION_NORMAL:
       case Animation::DIRECTION_ALTERNATE:
         forward_direction = animations_[i]->playback_rate() >= 0.0;
         break;
       case Animation::DIRECTION_REVERSE:
       case Animation::DIRECTION_ALTERNATE_REVERSE:
         forward_direction = animations_[i]->playback_rate() < 0.0;
         break;
     }
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     float animation_start_scale = 0.f;
     if (!transform_animation_curve->AnimationStartScale(forward_direction,
                                                         &animation_start_scale))
       return false;
     *start_scale = std::max(*start_scale, animation_start_scale);
   }
   return true;
 }
 
-bool ElementAnimations::MaximumTargetScale(LayerTreeType observer_type,
+bool ElementAnimations::MaximumTargetScale(LayerTreeType tree_type,
                                            float* max_scale) const {
   *max_scale = 0.f;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
-    if ((observer_type == LayerTreeType::ACTIVE &&
-         !animations_[i]->affects_active_observers()) ||
-        (observer_type == LayerTreeType::PENDING &&
-         !animations_[i]->affects_pending_observers()))
+    if ((tree_type == LayerTreeType::ACTIVE &&
+         !animations_[i]->affects_active_elements()) ||
+        (tree_type == LayerTreeType::PENDING &&
+         !animations_[i]->affects_pending_elements()))
       continue;
 
     bool forward_direction = true;
     switch (animations_[i]->direction()) {
       case Animation::DIRECTION_NORMAL:
       case Animation::DIRECTION_ALTERNATE:
         forward_direction = animations_[i]->playback_rate() >= 0.0;
         break;
       case Animation::DIRECTION_REVERSE:
       case Animation::DIRECTION_ALTERNATE_REVERSE:
@@ skipping 22 matching lines @@
     // need to copy it over.
     if (element_animations_impl->GetAnimationById(animations_[i]->id()))
       continue;
 
     if (animations_[i]->target_property() == TargetProperty::SCROLL_OFFSET &&
         !animations_[i]
              ->curve()
              ->ToScrollOffsetAnimationCurve()
              ->HasSetInitialValue()) {
       gfx::ScrollOffset current_scroll_offset;
-      if (element_animations_impl->needs_active_value_observations()) {
+      if (element_animations_impl->has_element_in_active_list()) {
         current_scroll_offset =
             element_animations_impl->ScrollOffsetForAnimation();
       } else {
         // The owning layer isn't yet in the active tree, so the main thread
         // scroll offset will be up-to-date.
         current_scroll_offset = ScrollOffsetForAnimation();
       }
       animations_[i]->curve()->ToScrollOffsetAnimationCurve()->SetInitialValue(
           current_scroll_offset);
     }
 
     // The new animation should be set to run as soon as possible.
     Animation::RunState initial_run_state =
         Animation::WAITING_FOR_TARGET_AVAILABILITY;
     std::unique_ptr<Animation> to_add(
         animations_[i]->CloneAndInitialize(initial_run_state));
     DCHECK(!to_add->needs_synchronized_start_time());
-    to_add->set_affects_active_observers(false);
+    to_add->set_affects_active_elements(false);
     element_animations_impl->AddAnimation(std::move(to_add));
   }
 }
 
 static bool IsCompleted(
     Animation* animation,
     const ElementAnimations* main_thread_element_animations) {
   if (animation->is_impl_only()) {
     return (animation->run_state() == Animation::WAITING_FOR_DELETION);
   } else {
     return !main_thread_element_animations->GetAnimationById(animation->id());
   }
 }
 
 void ElementAnimations::RemoveAnimationsCompletedOnMainThread(
     ElementAnimations* element_animations_impl) const {
   bool removed_transform_animation = false;
   // Animations removed on the main thread should no longer affect pending
-  // observers, and should stop affecting active observers after the next call
+  // elements, and should stop affecting active elements after the next call
   // to ActivateAnimations. If already WAITING_FOR_DELETION, they can be removed
   // immediately.
   auto& animations = element_animations_impl->animations_;
   for (const auto& animation : animations) {
     if (IsCompleted(animation.get(), this)) {
-      animation->set_affects_pending_observers(false);
+      animation->set_affects_pending_elements(false);
       if (animation->target_property() == TargetProperty::TRANSFORM)
         removed_transform_animation = true;
     }
   }
   auto affects_active_only_and_is_waiting_for_deletion =
       [](const std::unique_ptr<Animation>& animation) {
         return animation->run_state() == Animation::WAITING_FOR_DELETION &&
-               !animation->affects_pending_observers();
+               !animation->affects_pending_elements();
       };
   animations.erase(
       std::remove_if(animations.begin(), animations.end(),
                      affects_active_only_and_is_waiting_for_deletion),
       animations.end());
 
   if (removed_transform_animation)
     element_animations_impl->UpdatePotentiallyAnimatingTransform();
 }
 
 void ElementAnimations::PushPropertiesToImplThread(
     ElementAnimations* element_animations_impl) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* current_impl =
         element_animations_impl->GetAnimationById(animations_[i]->id());
     if (current_impl)
       animations_[i]->PushPropertiesTo(current_impl);
   }
   element_animations_impl->scroll_offset_animation_was_interrupted_ =
       scroll_offset_animation_was_interrupted_;
   scroll_offset_animation_was_interrupted_ = false;
 }
 
 void ElementAnimations::StartAnimations(base::TimeTicks monotonic_time) {
   DCHECK(needs_to_start_animations_);
   needs_to_start_animations_ = false;
-  // First collect running properties affecting each type of observer.
-  TargetProperties blocked_properties_for_active_observers;
-  TargetProperties blocked_properties_for_pending_observers;
+  // First collect running properties affecting each type of element.
+  TargetProperties blocked_properties_for_active_elements;
+  TargetProperties blocked_properties_for_pending_elements;
   std::vector<size_t> animations_waiting_for_target;
 
   animations_waiting_for_target.reserve(animations_.size());
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::STARTING ||
         animations_[i]->run_state() == Animation::RUNNING) {
-      if (animations_[i]->affects_active_observers()) {
-        blocked_properties_for_active_observers[animations_[i]
+      if (animations_[i]->affects_active_elements()) {
+        blocked_properties_for_active_elements[animations_[i]
+                                                   ->target_property()] = true;
+      }
+      if (animations_[i]->affects_pending_elements()) {
+        blocked_properties_for_pending_elements[animations_[i]
                                                     ->target_property()] = true;
       }
-      if (animations_[i]->affects_pending_observers()) {
-        blocked_properties_for_pending_observers[animations_[i]
-                                                     ->target_property()] =
-            true;
-      }
     } else if (animations_[i]->run_state() ==
                Animation::WAITING_FOR_TARGET_AVAILABILITY) {
       animations_waiting_for_target.push_back(i);
     }
   }
 
   for (size_t i = 0; i < animations_waiting_for_target.size(); ++i) {
     // Collect all properties for animations with the same group id (they
     // should all also be in the list of animations).
     size_t animation_index = animations_waiting_for_target[i];
     Animation* animation_waiting_for_target =
         animations_[animation_index].get();
     // Check for the run state again even though the animation was waiting
     // for target because it might have changed the run state while handling
     // previous animation in this loop (if they belong to same group).
     if (animation_waiting_for_target->run_state() ==
         Animation::WAITING_FOR_TARGET_AVAILABILITY) {
       TargetProperties enqueued_properties;
-      bool affects_active_observers =
-          animation_waiting_for_target->affects_active_observers();
-      bool affects_pending_observers =
-          animation_waiting_for_target->affects_pending_observers();
+      bool affects_active_elements =
+          animation_waiting_for_target->affects_active_elements();
+      bool affects_pending_elements =
+          animation_waiting_for_target->affects_pending_elements();
       enqueued_properties[animation_waiting_for_target->target_property()] =
           true;
       for (size_t j = animation_index + 1; j < animations_.size(); ++j) {
         if (animation_waiting_for_target->group() == animations_[j]->group()) {
           enqueued_properties[animations_[j]->target_property()] = true;
-          affects_active_observers |=
-              animations_[j]->affects_active_observers();
-          affects_pending_observers |=
-              animations_[j]->affects_pending_observers();
+          affects_active_elements |= animations_[j]->affects_active_elements();
+          affects_pending_elements |=
+              animations_[j]->affects_pending_elements();
         }
       }
 
       // Check to see if intersection of the list of properties affected by
       // the group and the list of currently blocked properties is null, taking
-      // into account the type(s) of observers affected by the group. In any
+      // into account the type(s) of elements affected by the group. In any
       // case, the group's target properties need to be added to the lists of
       // blocked properties.
       bool null_intersection = true;
       static_assert(TargetProperty::FIRST_TARGET_PROPERTY == 0,
                     "TargetProperty must be 0-based enum");
       for (int property = TargetProperty::FIRST_TARGET_PROPERTY;
            property <= TargetProperty::LAST_TARGET_PROPERTY; ++property) {
         if (enqueued_properties[property]) {
-          if (affects_active_observers) {
-            if (blocked_properties_for_active_observers[property])
+          if (affects_active_elements) {
+            if (blocked_properties_for_active_elements[property])
               null_intersection = false;
             else
-              blocked_properties_for_active_observers[property] = true;
+              blocked_properties_for_active_elements[property] = true;
           }
-          if (affects_pending_observers) {
-            if (blocked_properties_for_pending_observers[property])
+          if (affects_pending_elements) {
+            if (blocked_properties_for_pending_elements[property])
               null_intersection = false;
             else
-              blocked_properties_for_pending_observers[property] = true;
+              blocked_properties_for_pending_elements[property] = true;
           }
         }
       }
 
       // If the intersection is null, then we are free to start the animations
       // in the group.
       if (null_intersection) {
         animation_waiting_for_target->SetRunState(Animation::STARTING,
                                                   monotonic_time);
         for (size_t j = animation_index + 1; j < animations_.size(); ++j) {
           if (animation_waiting_for_target->group() ==
               animations_[j]->group()) {
             animations_[j]->SetRunState(Animation::STARTING, monotonic_time);
           }
         }
       } else {
         needs_to_start_animations_ = true;
       }
     }
   }
 }
 
 void ElementAnimations::PromoteStartedAnimations(base::TimeTicks monotonic_time,
                                                  AnimationEvents* events) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::STARTING &&
-        animations_[i]->affects_active_observers()) {
+        animations_[i]->affects_active_elements()) {
       animations_[i]->SetRunState(Animation::RUNNING, monotonic_time);
       if (!animations_[i]->has_set_start_time() &&
           !animations_[i]->needs_synchronized_start_time())
         animations_[i]->set_start_time(monotonic_time);
       if (events) {
         base::TimeTicks start_time;
         if (animations_[i]->has_set_start_time())
           start_time = animations_[i]->start_time();
         else
           start_time = monotonic_time;
@@ skipping 141 matching lines @@
           else
             events->events_.push_back(finished_event);
         }
         animations_[animation_index]->SetRunState(
             Animation::WAITING_FOR_DELETION, monotonic_time);
       }
       marked_animations_for_deletions = true;
     }
   }
   if (marked_animations_for_deletions)
-    NotifyObserversAnimationWaitingForDeletion();
+    NotifyClientAnimationWaitingForDeletion();
 }
 
 void ElementAnimations::MarkAbortedAnimationsForDeletion(
     ElementAnimations* element_animations_impl) const {
   bool aborted_transform_animation = false;
   auto& animations_impl = element_animations_impl->animations_;
   for (const auto& animation_impl : animations_impl) {
     // If the animation has been aborted on the main thread, mark it for
     // deletion.
     if (Animation* animation = GetAnimationById(animation_impl->id())) {
@@ skipping 33 matching lines @@
 
       base::TimeDelta trimmed =
           animations_[i]->TrimTimeToCurrentIteration(monotonic_time);
 
       switch (animations_[i]->target_property()) {
         case TargetProperty::TRANSFORM: {
           const TransformAnimationCurve* transform_animation_curve =
               animations_[i]->curve()->ToTransformAnimationCurve();
           const gfx::Transform transform =
               transform_animation_curve->GetValue(trimmed);
-          NotifyObserversTransformAnimated(
-              transform, animations_[i]->affects_active_observers(),
-              animations_[i]->affects_pending_observers());
+          NotifyClientTransformAnimated(
+              transform, animations_[i]->affects_active_elements(),
+              animations_[i]->affects_pending_elements());
           break;
         }
 
         case TargetProperty::OPACITY: {
           const FloatAnimationCurve* float_animation_curve =
               animations_[i]->curve()->ToFloatAnimationCurve();
           const float opacity = std::max(
               std::min(float_animation_curve->GetValue(trimmed), 1.0f), 0.f);
-          NotifyObserversOpacityAnimated(
-              opacity, animations_[i]->affects_active_observers(),
-              animations_[i]->affects_pending_observers());
+          NotifyClientOpacityAnimated(
+              opacity, animations_[i]->affects_active_elements(),
+              animations_[i]->affects_pending_elements());
           break;
         }
 
         case TargetProperty::FILTER: {
           const FilterAnimationCurve* filter_animation_curve =
               animations_[i]->curve()->ToFilterAnimationCurve();
           const FilterOperations filter =
               filter_animation_curve->GetValue(trimmed);
-          NotifyObserversFilterAnimated(
-              filter, animations_[i]->affects_active_observers(),
-              animations_[i]->affects_pending_observers());
+          NotifyClientFilterAnimated(
+              filter, animations_[i]->affects_active_elements(),
+              animations_[i]->affects_pending_elements());
           break;
         }
 
         case TargetProperty::BACKGROUND_COLOR: {
           // Not yet implemented.
           break;
         }
 
         case TargetProperty::SCROLL_OFFSET: {
           const ScrollOffsetAnimationCurve* scroll_offset_animation_curve =
               animations_[i]->curve()->ToScrollOffsetAnimationCurve();
           const gfx::ScrollOffset scroll_offset =
               scroll_offset_animation_curve->GetValue(trimmed);
-          NotifyObserversScrollOffsetAnimated(
-              scroll_offset, animations_[i]->affects_active_observers(),
-              animations_[i]->affects_pending_observers());
+          NotifyClientScrollOffsetAnimated(
+              scroll_offset, animations_[i]->affects_active_elements(),
+              animations_[i]->affects_pending_elements());
           break;
         }
       }
     }
   }
 }
 
 void ElementAnimations::UpdateActivation(UpdateActivationType type) {
   bool force = type == FORCE_ACTIVATION;
   if (animation_host_) {
     bool was_active = is_active_;
     is_active_ = false;
     for (size_t i = 0; i < animations_.size(); ++i) {
       if (animations_[i]->run_state() != Animation::WAITING_FOR_DELETION) {
         is_active_ = true;
         break;
       }
     }
 
     if (is_active_ && (!was_active || force))
       animation_host_->DidActivateElementAnimations(this);
     else if (!is_active_ && (was_active || force))
       animation_host_->DidDeactivateElementAnimations(this);
   }
 }
 
-void ElementAnimations::NotifyObserversOpacityAnimated(
+void ElementAnimations::NotifyClientOpacityAnimated(
     float opacity,
-    bool notify_active_observers,
-    bool notify_pending_observers) {
-  if (notify_active_observers && needs_active_value_observations())
+    bool notify_active_elements,
+    bool notify_pending_elements) {
+  if (notify_active_elements && has_element_in_active_list())
     OnOpacityAnimated(LayerTreeType::ACTIVE, opacity);
-  if (notify_pending_observers && needs_pending_value_observations())
+  if (notify_pending_elements && has_element_in_pending_list())
     OnOpacityAnimated(LayerTreeType::PENDING, opacity);
 }
 
-void ElementAnimations::NotifyObserversTransformAnimated(
+void ElementAnimations::NotifyClientTransformAnimated(
     const gfx::Transform& transform,
-    bool notify_active_observers,
-    bool notify_pending_observers) {
-  if (notify_active_observers && needs_active_value_observations())
+    bool notify_active_elements,
+    bool notify_pending_elements) {
+  if (notify_active_elements && has_element_in_active_list())
     OnTransformAnimated(LayerTreeType::ACTIVE, transform);
-  if (notify_pending_observers && needs_pending_value_observations())
+  if (notify_pending_elements && has_element_in_pending_list())
     OnTransformAnimated(LayerTreeType::PENDING, transform);
 }
 
-void ElementAnimations::NotifyObserversFilterAnimated(
+void ElementAnimations::NotifyClientFilterAnimated(
     const FilterOperations& filters,
-    bool notify_active_observers,
-    bool notify_pending_observers) {
-  if (notify_active_observers && needs_active_value_observations())
+    bool notify_active_elements,
+    bool notify_pending_elements) {
+  if (notify_active_elements && has_element_in_active_list())
     OnFilterAnimated(LayerTreeType::ACTIVE, filters);
-  if (notify_pending_observers && needs_pending_value_observations())
+  if (notify_pending_elements && has_element_in_pending_list())
     OnFilterAnimated(LayerTreeType::PENDING, filters);
 }
 
-void ElementAnimations::NotifyObserversScrollOffsetAnimated(
+void ElementAnimations::NotifyClientScrollOffsetAnimated(
     const gfx::ScrollOffset& scroll_offset,
-    bool notify_active_observers,
-    bool notify_pending_observers) {
-  if (notify_active_observers && needs_active_value_observations())
+    bool notify_active_elements,
+    bool notify_pending_elements) {
+  if (notify_active_elements && has_element_in_active_list())
     OnScrollOffsetAnimated(LayerTreeType::ACTIVE, scroll_offset);
-  if (notify_pending_observers && needs_pending_value_observations())
+  if (notify_pending_elements && has_element_in_pending_list())
     OnScrollOffsetAnimated(LayerTreeType::PENDING, scroll_offset);
 }
 
-void ElementAnimations::NotifyObserversAnimationWaitingForDeletion() {
+void ElementAnimations::NotifyClientAnimationWaitingForDeletion() {
   OnAnimationWaitingForDeletion();
 }
 
-void ElementAnimations::NotifyObserversTransformIsPotentiallyAnimatingChanged(
-    bool notify_active_observers,
-    bool notify_pending_observers) {
-  if (notify_active_observers && needs_active_value_observations())
+void ElementAnimations::NotifyClientTransformIsPotentiallyAnimatingChanged(
+    bool notify_active_elements,
+    bool notify_pending_elements) {
+  if (notify_active_elements && has_element_in_active_list())
     OnTransformIsPotentiallyAnimatingChanged(
         LayerTreeType::ACTIVE,
-        potentially_animating_transform_for_active_observers_);
-  if (notify_pending_observers && needs_pending_value_observations())
+        potentially_animating_transform_for_active_elements_);
+  if (notify_pending_elements && has_element_in_pending_list())
     OnTransformIsPotentiallyAnimatingChanged(
         LayerTreeType::PENDING,
-        potentially_animating_transform_for_pending_observers_);
+        potentially_animating_transform_for_pending_elements_);
 }
 
 void ElementAnimations::UpdatePotentiallyAnimatingTransform() {
-  bool was_potentially_animating_transform_for_active_observers =
-      potentially_animating_transform_for_active_observers_;
-  bool was_potentially_animating_transform_for_pending_observers =
-      potentially_animating_transform_for_pending_observers_;
+  bool was_potentially_animating_transform_for_active_elements =
+      potentially_animating_transform_for_active_elements_;
+  bool was_potentially_animating_transform_for_pending_elements =
+      potentially_animating_transform_for_pending_elements_;
 
-  potentially_animating_transform_for_active_observers_ = false;
-  potentially_animating_transform_for_pending_observers_ = false;
+  potentially_animating_transform_for_active_elements_ = false;
+  potentially_animating_transform_for_pending_elements_ = false;
 
   for (const auto& animation : animations_) {
     if (!animation->is_finished() &&
         animation->target_property() == TargetProperty::TRANSFORM) {
-      potentially_animating_transform_for_active_observers_ |=
-          animation->affects_active_observers();
-      potentially_animating_transform_for_pending_observers_ |=
-          animation->affects_pending_observers();
+      potentially_animating_transform_for_active_elements_ |=
+          animation->affects_active_elements();
+      potentially_animating_transform_for_pending_elements_ |=
+          animation->affects_pending_elements();
     }
   }
 
-  bool changed_for_active_observers =
-      was_potentially_animating_transform_for_active_observers !=
-      potentially_animating_transform_for_active_observers_;
-  bool changed_for_pending_observers =
-      was_potentially_animating_transform_for_pending_observers !=
-      potentially_animating_transform_for_pending_observers_;
+  bool changed_for_active_elements =
+      was_potentially_animating_transform_for_active_elements !=
+      potentially_animating_transform_for_active_elements_;
+  bool changed_for_pending_elements =
+      was_potentially_animating_transform_for_pending_elements !=
+      potentially_animating_transform_for_pending_elements_;
 
-  if (!changed_for_active_observers && !changed_for_pending_observers)
+  if (!changed_for_active_elements && !changed_for_pending_elements)
     return;
 
-  NotifyObserversTransformIsPotentiallyAnimatingChanged(
-      changed_for_active_observers, changed_for_pending_observers);
+  NotifyClientTransformIsPotentiallyAnimatingChanged(
+      changed_for_active_elements, changed_for_pending_elements);
 }
 
 bool ElementAnimations::HasActiveAnimation() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished())
       return true;
   }
   return false;
 }
 
 bool ElementAnimations::IsPotentiallyAnimatingProperty(
     TargetProperty::Type target_property,
-    LayerTreeType observer_type) const {
+    LayerTreeType tree_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == target_property) {
-      if ((observer_type == LayerTreeType::ACTIVE &&
-           animations_[i]->affects_active_observers()) ||
-          (observer_type == LayerTreeType::PENDING &&
-           animations_[i]->affects_pending_observers()))
+      if ((tree_type == LayerTreeType::ACTIVE &&
+           animations_[i]->affects_active_elements()) ||
+          (tree_type == LayerTreeType::PENDING &&
+           animations_[i]->affects_pending_elements()))
         return true;
     }
   }
   return false;
 }
 
 bool ElementAnimations::IsCurrentlyAnimatingProperty(
     TargetProperty::Type target_property,
-    LayerTreeType observer_type) const {
+    LayerTreeType tree_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->InEffect(last_tick_time_) &&
         animations_[i]->target_property() == target_property) {
-      if ((observer_type == LayerTreeType::ACTIVE &&
-           animations_[i]->affects_active_observers()) ||
-          (observer_type == LayerTreeType::PENDING &&
-           animations_[i]->affects_pending_observers()))
+      if ((tree_type == LayerTreeType::ACTIVE &&
+           animations_[i]->affects_active_elements()) ||
+          (tree_type == LayerTreeType::PENDING &&
+           animations_[i]->affects_pending_elements()))
         return true;
     }
   }
   return false;
 }
 
 void ElementAnimations::PauseAnimation(int animation_id,
                                        base::TimeDelta time_offset) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->id() == animation_id) {
@@ skipping 193 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         layer_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc