cc : Track transform animation changes on transform tree

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 16 matching lines @@
 
 ElementAnimations::ElementAnimations()
     : players_list_(new PlayersList()),
       animation_host_(),
       element_id_(),
       is_active_(false),
       has_element_in_active_list_(false),
       has_element_in_pending_list_(false),
       needs_to_start_animations_(false),
       scroll_offset_animation_was_interrupted_(false),
+      currently_running_transform_animation_for_active_elements_(false),
+      currently_running_transform_animation_for_pending_elements_(false),
       potentially_animating_transform_for_active_elements_(false),
       potentially_animating_transform_for_pending_elements_(false),
       currently_running_opacity_animation_for_active_elements_(false),
       currently_running_opacity_animation_for_pending_elements_(false),
       potentially_animating_opacity_for_active_elements_(false),
       potentially_animating_opacity_for_pending_elements_(false) {}
 
 ElementAnimations::~ElementAnimations() {}
 
 void ElementAnimations::SetAnimationHost(AnimationHost* host) {
@@ skipping 18 matching lines @@
   if (animation_host_->mutator_host_client()->IsElementInList(
           element_id_, ElementListType::PENDING)) {
     set_has_element_in_pending_list(true);
   }
 }
 
 void ElementAnimations::ClearAffectedElementTypes() {
   DCHECK(animation_host_);
 
   if (has_element_in_active_list()) {
-    OnTransformIsPotentiallyAnimatingChanged(ElementListType::ACTIVE, false);
-    OnOpacityIsAnimatingChanged(ElementListType::ACTIVE,
-                                AnimationChangeType::BOTH, false);
+    IsAnimatingChanged(ElementListType::ACTIVE, TargetProperty::TRANSFORM,
+                       AnimationChangeType::BOTH, false);
+    IsAnimatingChanged(ElementListType::ACTIVE, TargetProperty::OPACITY,
+                       AnimationChangeType::BOTH, false);
   }
   set_has_element_in_active_list(false);
 
   if (has_element_in_pending_list()) {
-    OnTransformIsPotentiallyAnimatingChanged(ElementListType::PENDING, false);
-    OnOpacityIsAnimatingChanged(ElementListType::PENDING,
-                                AnimationChangeType::BOTH, false);
+    IsAnimatingChanged(ElementListType::PENDING, TargetProperty::TRANSFORM,
+                       AnimationChangeType::BOTH, false);
+    IsAnimatingChanged(ElementListType::PENDING, TargetProperty::OPACITY,
+                       AnimationChangeType::BOTH, false);
   }
   set_has_element_in_pending_list(false);
 
   animation_host_->DidDeactivateElementAnimations(this);
   UpdateActivation(FORCE_ACTIVATION);
 }
 
 void ElementAnimations::ElementRegistered(ElementId element_id,
                                           ElementListType list_type) {
   DCHECK_EQ(element_id_, element_id);
@@ skipping 52 matching lines @@
 
 void ElementAnimations::AddAnimation(std::unique_ptr<Animation> animation) {
   bool added_transform_animation =
       animation->target_property() == TargetProperty::TRANSFORM;
   bool added_opacity_animation =
       animation->target_property() == TargetProperty::OPACITY;
   animations_.push_back(std::move(animation));
   needs_to_start_animations_ = true;
   UpdateActivation(NORMAL_ACTIVATION);
   if (added_transform_animation)
-    UpdatePotentiallyAnimatingTransform();
+    UpdateAnimationState(TargetProperty::TRANSFORM);
   if (added_opacity_animation)
-    UpdateAnimatingOpacity();
+    UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::Animate(base::TimeTicks monotonic_time) {
   DCHECK(!monotonic_time.is_null());
   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;
-  UpdateAnimatingOpacity();
+  UpdateAnimationState(TargetProperty::OPACITY);
+  UpdateAnimationState(TargetProperty::TRANSFORM);
 }
 
 void ElementAnimations::AccumulatePropertyUpdates(
     base::TimeTicks monotonic_time,
     AnimationEvents* events) {
   if (!events)
     return;
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* animation = animations_[i].get();
@@ skipping 99 matching lines @@
   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_elements),
                     animations_.end());
   scroll_offset_animation_was_interrupted_ = false;
   UpdateActivation(NORMAL_ACTIVATION);
   if (changed_transform_animation)
-    UpdatePotentiallyAnimatingTransform();
+    UpdateAnimationState(TargetProperty::TRANSFORM);
   if (changed_opacity_animation)
-    UpdateAnimatingOpacity();
+    UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::NotifyAnimationStarted(const AnimationEvent& event) {
   if (event.is_impl_only) {
     NotifyPlayersAnimationStarted(event.monotonic_time, event.target_property,
                                   event.group_id);
     return;
   }
 
   for (size_t i = 0; i < animations_.size(); ++i) {
@@ skipping 52 matching lines @@
       NotifyPlayersAnimationAborted(event.monotonic_time, event.target_property,
                                     event.group_id);
       if (event.target_property == TargetProperty::TRANSFORM)
         aborted_transform_animation = true;
       else if (event.target_property == TargetProperty::OPACITY)
         aborted_opacity_animation = true;
       break;
     }
   }
   if (aborted_transform_animation)
-    UpdatePotentiallyAnimatingTransform();
+    UpdateAnimationState(TargetProperty::TRANSFORM);
   if (aborted_opacity_animation)
-    UpdateAnimatingOpacity();
+    UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::NotifyAnimationPropertyUpdate(
     const AnimationEvent& event) {
   bool notify_active_elements = true;
   bool notify_pending_elements = true;
   switch (event.target_property) {
     case TargetProperty::OPACITY:
       NotifyClientOpacityAnimated(event.opacity, notify_active_elements,
                                   notify_pending_elements);
@@ skipping 263 matching lines @@
       [](const std::unique_ptr<Animation>& animation) {
         return animation->run_state() == Animation::WAITING_FOR_DELETION &&
                !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();
+    element_animations_impl->UpdateAnimationState(TargetProperty::TRANSFORM);
   if (removed_opacity_animation)
-    element_animations_impl->UpdateAnimatingOpacity();
+    element_animations_impl->UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 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);
   }
@@ skipping 134 matching lines @@
     if (!animations_[i]->is_finished() &&
         animations_[i]->IsFinishedAt(monotonic_time)) {
       animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
       if (animations_[i]->target_property() == TargetProperty::TRANSFORM)
         finished_transform_animation = true;
       else if (animations_[i]->target_property() == TargetProperty::OPACITY)
         finished_opacity_animation = true;
     }
   }
   if (finished_transform_animation)
-    UpdatePotentiallyAnimatingTransform();
+    UpdateAnimationState(TargetProperty::TRANSFORM);
   if (finished_opacity_animation)
-    UpdateAnimatingOpacity();
+    UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::MarkAnimationsForDeletion(
     base::TimeTicks monotonic_time,
     AnimationEvents* events) {
   bool marked_animations_for_deletions = false;
   std::vector<size_t> animations_with_same_group_id;
 
   animations_with_same_group_id.reserve(animations_.size());
   // Non-aborted animations are marked for deletion after a corresponding
@@ skipping 131 matching lines @@
                                last_tick_time_);
         if (animation_impl->target_property() == TargetProperty::TRANSFORM)
           aborted_transform_animation = true;
         else if (animation_impl->target_property() == TargetProperty::OPACITY)
           aborted_opacity_animation = true;
       }
     }
   }
 
   if (aborted_transform_animation)
-    element_animations_impl->UpdatePotentiallyAnimatingTransform();
+    element_animations_impl->UpdateAnimationState(TargetProperty::TRANSFORM);
   if (aborted_opacity_animation)
-    element_animations_impl->UpdateAnimatingOpacity();
+    element_animations_impl->UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::PurgeAnimationsMarkedForDeletion() {
   animations_.erase(
       std::remove_if(animations_.begin(), animations_.end(),
                      [](const std::unique_ptr<Animation>& animation) {
                        return animation->run_state() ==
                               Animation::WAITING_FOR_DELETION;
                      }),
       animations_.end());
@@ skipping 120 matching lines @@
   if (notify_active_elements && has_element_in_active_list())
     OnScrollOffsetAnimated(ElementListType::ACTIVE, scroll_offset);
   if (notify_pending_elements && has_element_in_pending_list())
     OnScrollOffsetAnimated(ElementListType::PENDING, scroll_offset);
 }
 
 void ElementAnimations::NotifyClientAnimationWaitingForDeletion() {
   OnAnimationWaitingForDeletion();
 }
 
-void ElementAnimations::NotifyClientTransformIsPotentiallyAnimatingChanged(
-    bool notify_active_elements,
-    bool notify_pending_elements) {
-  if (notify_active_elements && has_element_in_active_list())
-    OnTransformIsPotentiallyAnimatingChanged(
-        ElementListType::ACTIVE,
-        potentially_animating_transform_for_active_elements_);
-  if (notify_pending_elements && has_element_in_pending_list())
-    OnTransformIsPotentiallyAnimatingChanged(
-        ElementListType::PENDING,
-        potentially_animating_transform_for_pending_elements_);
-}
+void ElementAnimations::NotifyClientAnimationChanged(
+    TargetProperty::Type property,
+    ElementListType list_type,
+    bool notify_elements_about_potential_animation,
+    bool notify_elements_about_running_animation) {
+  bool notify_elements_about_potential_and_running_animation =
+      notify_elements_about_potential_animation &&
+      notify_elements_about_running_animation;
+  bool potentially_animating;
+  bool currently_animating;
+  bool active = list_type == ElementListType::ACTIVE;
+  switch (property) {
+    case TargetProperty::OPACITY:
+      potentially_animating =
+          active ? potentially_animating_opacity_for_active_elements_
+                 : potentially_animating_opacity_for_pending_elements_;
+      currently_animating =
+          active ? currently_running_opacity_animation_for_active_elements_
+                 : currently_running_opacity_animation_for_pending_elements_;
+      break;
+    case TargetProperty::TRANSFORM:
+      potentially_animating =
+          active ? potentially_animating_transform_for_active_elements_
+                 : potentially_animating_transform_for_pending_elements_;
+      currently_animating =
+          active ? currently_running_transform_animation_for_active_elements_
+                 : currently_running_transform_animation_for_pending_elements_;
+      break;
+    default:
+      break;
+  }
 
-void ElementAnimations::NotifyClientOpacityAnimationChanged(
-    bool notify_active_elements_about_potential_animation,
-    bool notify_pending_elements_about_potential_animation,
-    bool notify_active_elements_about_running_animation,
-    bool notify_pending_elements_about_running_animation) {
-  bool notify_active_elements_about_potential_and_running_animation =
-      notify_active_elements_about_potential_animation &&
-      notify_active_elements_about_running_animation;
-  bool notify_pending_elements_about_potential_and_running_animation =
-      notify_pending_elements_about_potential_animation &&
-      notify_pending_elements_about_running_animation;
-  if (has_element_in_active_list()) {
-    if (notify_active_elements_about_potential_and_running_animation) {
-      DCHECK_EQ(potentially_animating_opacity_for_active_elements_,
-                currently_running_opacity_animation_for_active_elements_);
-      OnOpacityIsAnimatingChanged(
-          ElementListType::ACTIVE, AnimationChangeType::BOTH,
-          potentially_animating_opacity_for_active_elements_);
-    } else if (notify_active_elements_about_potential_animation) {
-      OnOpacityIsAnimatingChanged(
-          ElementListType::ACTIVE, AnimationChangeType::POTENTIAL,
-          potentially_animating_opacity_for_active_elements_);
-    } else if (notify_active_elements_about_running_animation) {
-      OnOpacityIsAnimatingChanged(
-          ElementListType::ACTIVE, AnimationChangeType::RUNNING,
-          currently_running_opacity_animation_for_active_elements_);
-    }
-  }
-  if (has_element_in_pending_list()) {
-    if (notify_pending_elements_about_potential_and_running_animation) {
-      DCHECK_EQ(potentially_animating_opacity_for_pending_elements_,
-                currently_running_opacity_animation_for_pending_elements_);
-      OnOpacityIsAnimatingChanged(
-          ElementListType::PENDING, AnimationChangeType::BOTH,
-          potentially_animating_opacity_for_pending_elements_);
-    } else if (notify_pending_elements_about_potential_animation) {
-      OnOpacityIsAnimatingChanged(
-          ElementListType::PENDING, AnimationChangeType::POTENTIAL,
-          potentially_animating_opacity_for_pending_elements_);
-    } else if (notify_pending_elements_about_running_animation) {
-      OnOpacityIsAnimatingChanged(
-          ElementListType::PENDING, AnimationChangeType::RUNNING,
-          currently_running_opacity_animation_for_pending_elements_);
-    }
+  if (notify_elements_about_potential_and_running_animation) {
+    DCHECK_EQ(potentially_animating, currently_animating);
+    IsAnimatingChanged(list_type, property, AnimationChangeType::BOTH,
+                       potentially_animating);
+  } else if (notify_elements_about_potential_animation) {
+    IsAnimatingChanged(list_type, property, AnimationChangeType::POTENTIAL,
+                       potentially_animating);
+  } else if (notify_elements_about_running_animation) {
+    IsAnimatingChanged(list_type, property, AnimationChangeType::RUNNING,
+                       currently_animating);
   }
 }
 
-void ElementAnimations::UpdatePotentiallyAnimatingTransform() {
-  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_;
+void ElementAnimations::UpdateAnimationState(TargetProperty::Type property) {
+  bool* currently_running_property_for_active_elements = nullptr;
+  bool* currently_running_property_for_pending_elements = nullptr;
+  bool* potentially_animating_property_for_active_elements = nullptr;
+  bool* potentially_animating_property_for_pending_elements = nullptr;
+  switch (property) {
+    case TargetProperty::OPACITY:
+      currently_running_property_for_active_elements =
+          &currently_running_opacity_animation_for_active_elements_;
+      currently_running_property_for_pending_elements =
+          &currently_running_opacity_animation_for_pending_elements_;
+      potentially_animating_property_for_active_elements =
+          &potentially_animating_opacity_for_active_elements_;
+      potentially_animating_property_for_pending_elements =
+          &potentially_animating_opacity_for_pending_elements_;
+      break;
+    case TargetProperty::TRANSFORM:
+      currently_running_property_for_active_elements =
+          &currently_running_transform_animation_for_active_elements_;
+      currently_running_property_for_pending_elements =
+          &currently_running_transform_animation_for_pending_elements_;
+      potentially_animating_property_for_active_elements =
+          &potentially_animating_transform_for_active_elements_;
+      potentially_animating_property_for_pending_elements =
+          &potentially_animating_transform_for_pending_elements_;
+      break;
+    default:
+      break;
+  }
+  bool was_currently_running_animation_for_active_elements =
+      *currently_running_property_for_active_elements;
+  bool was_currently_running_animation_for_pending_elements =
+      *currently_running_property_for_pending_elements;
+  bool was_potentially_animating_for_active_elements =
+      *potentially_animating_property_for_active_elements;
+  bool was_potentially_animating_for_pending_elements =
+      *potentially_animating_property_for_pending_elements;
+  *currently_running_property_for_active_elements = false;
+  *currently_running_property_for_pending_elements = false;
+  *potentially_animating_property_for_active_elements = false;
+  *potentially_animating_property_for_pending_elements = false;
 
-  potentially_animating_transform_for_active_elements_ = false;
-  potentially_animating_transform_for_pending_elements_ = false;
+  DCHECK(was_potentially_animating_for_active_elements ||
+         !was_currently_running_animation_for_active_elements);
+  DCHECK(was_potentially_animating_for_pending_elements ||
+         !was_currently_running_animation_for_pending_elements);
 
   for (const auto& animation : animations_) {
-    if (!animation->is_finished() &&
-        animation->target_property() == TargetProperty::TRANSFORM) {
-      potentially_animating_transform_for_active_elements_ |=
+    if (!animation->is_finished() && animation->target_property() == property) {
+      *potentially_animating_property_for_active_elements |=
           animation->affects_active_elements();
-      potentially_animating_transform_for_pending_elements_ |=
+      *potentially_animating_property_for_pending_elements |=
           animation->affects_pending_elements();
-    }
-  }
-
-  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_elements && !changed_for_pending_elements)
-    return;
-
-  NotifyClientTransformIsPotentiallyAnimatingChanged(
-      changed_for_active_elements, changed_for_pending_elements);
-}
-
-void ElementAnimations::UpdateAnimatingOpacity() {
-  bool was_currently_running_opacity_animation_for_active_elements =
-      currently_running_opacity_animation_for_active_elements_;
-  bool was_currently_running_opacity_animation_for_pending_elements =
-      currently_running_opacity_animation_for_pending_elements_;
-  bool was_potentially_animating_opacity_for_active_elements =
-      potentially_animating_opacity_for_active_elements_;
-  bool was_potentially_animating_opacity_for_pending_elements =
-      potentially_animating_opacity_for_pending_elements_;
-
-  DCHECK(was_potentially_animating_opacity_for_active_elements ||
-         !was_currently_running_opacity_animation_for_active_elements);
-  DCHECK(was_potentially_animating_opacity_for_pending_elements ||
-         !was_currently_running_opacity_animation_for_pending_elements);
-  currently_running_opacity_animation_for_active_elements_ = false;
-  currently_running_opacity_animation_for_pending_elements_ = false;
-  potentially_animating_opacity_for_active_elements_ = false;
-  potentially_animating_opacity_for_pending_elements_ = false;
-
-  for (const auto& animation : animations_) {
-    if (!animation->is_finished() &&
-        animation->target_property() == TargetProperty::OPACITY) {
-      potentially_animating_opacity_for_active_elements_ |=
-          animation->affects_active_elements();
-      potentially_animating_opacity_for_pending_elements_ |=
-          animation->affects_pending_elements();
-      currently_running_opacity_animation_for_active_elements_ =
-          potentially_animating_opacity_for_active_elements_ &&
+      *currently_running_property_for_active_elements =
+          *potentially_animating_property_for_active_elements &&
           animation->InEffect(last_tick_time_);
-      currently_running_opacity_animation_for_pending_elements_ =
-          potentially_animating_opacity_for_pending_elements_ &&
+      *currently_running_property_for_pending_elements =
+          *potentially_animating_property_for_pending_elements &&
           animation->InEffect(last_tick_time_);
     }
   }
 
   bool potentially_animating_changed_for_active_elements =
-      was_potentially_animating_opacity_for_active_elements !=
-      potentially_animating_opacity_for_active_elements_;
+      was_potentially_animating_for_active_elements !=
+      *potentially_animating_property_for_active_elements;
   bool potentially_animating_changed_for_pending_elements =
-      was_potentially_animating_opacity_for_pending_elements !=
-      potentially_animating_opacity_for_pending_elements_;
+      was_potentially_animating_for_pending_elements !=
+      *potentially_animating_property_for_pending_elements;
   bool currently_running_animation_changed_for_active_elements =
-      was_currently_running_opacity_animation_for_active_elements !=
-      currently_running_opacity_animation_for_active_elements_;
+      was_currently_running_animation_for_active_elements !=
+      *currently_running_property_for_active_elements;
   bool currently_running_animation_changed_for_pending_elements =
-      was_currently_running_opacity_animation_for_pending_elements !=
-      currently_running_opacity_animation_for_pending_elements_;
+      was_currently_running_animation_for_pending_elements !=
+      *currently_running_property_for_pending_elements;
   if (!potentially_animating_changed_for_active_elements &&
       !potentially_animating_changed_for_pending_elements &&
       !currently_running_animation_changed_for_active_elements &&
       !currently_running_animation_changed_for_pending_elements)
     return;
-  NotifyClientOpacityAnimationChanged(
-      potentially_animating_changed_for_active_elements,
-      potentially_animating_changed_for_pending_elements,
-      currently_running_animation_changed_for_active_elements,
-      currently_running_animation_changed_for_pending_elements);
+  if (has_element_in_active_list())
+    NotifyClientAnimationChanged(
+        property, ElementListType::ACTIVE,
+        potentially_animating_changed_for_active_elements,
+        currently_running_animation_changed_for_active_elements);
+  if (has_element_in_pending_list())
+    NotifyClientAnimationChanged(
+        property, ElementListType::PENDING,
+        potentially_animating_changed_for_pending_elements,
+        currently_running_animation_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;
 }
 
@@ skipping 60 matching lines @@
       removed_transform_animation = true;
     } else if ((*it)->target_property() == TargetProperty::OPACITY &&
                !(*it)->is_finished()) {
       removed_opacity_animation = true;
     }
   }
 
   animations_.erase(animations_to_remove, animations_.end());
   UpdateActivation(NORMAL_ACTIVATION);
   if (removed_transform_animation)
-    UpdatePotentiallyAnimatingTransform();
+    UpdateAnimationState(TargetProperty::TRANSFORM);
   if (removed_opacity_animation)
-    UpdateAnimatingOpacity();
+    UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::AbortAnimation(int animation_id) {
   bool aborted_transform_animation = false;
   bool aborted_opacity_animation = false;
   if (Animation* animation = GetAnimationById(animation_id)) {
     if (!animation->is_finished()) {
       animation->SetRunState(Animation::ABORTED, last_tick_time_);
       if (animation->target_property() == TargetProperty::TRANSFORM)
         aborted_transform_animation = true;
       else if (animation->target_property() == TargetProperty::OPACITY)
         aborted_opacity_animation = true;
     }
   }
   if (aborted_transform_animation)
-    UpdatePotentiallyAnimatingTransform();
+    UpdateAnimationState(TargetProperty::TRANSFORM);
   if (aborted_opacity_animation)
-    UpdateAnimatingOpacity();
+    UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::AbortAnimations(TargetProperty::Type target_property,
                                         bool needs_completion) {
   if (needs_completion)
     DCHECK(target_property == TargetProperty::SCROLL_OFFSET);
 
   bool aborted_transform_animation = false;
   bool aborted_opacity_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->target_property() == target_property &&
         !animations_[i]->is_finished()) {
       // Currently only impl-only scroll offset animations can be completed on
       // the main thread.
       if (needs_completion && animations_[i]->is_impl_only()) {
         animations_[i]->SetRunState(Animation::ABORTED_BUT_NEEDS_COMPLETION,
                                     last_tick_time_);
       } else {
         animations_[i]->SetRunState(Animation::ABORTED, last_tick_time_);
       }
       if (target_property == TargetProperty::TRANSFORM)
         aborted_transform_animation = true;
       else if (target_property == TargetProperty::OPACITY)
         aborted_opacity_animation = true;
     }
   }
   if (aborted_transform_animation)
-    UpdatePotentiallyAnimatingTransform();
+    UpdateAnimationState(TargetProperty::TRANSFORM);
   if (aborted_opacity_animation)
-    UpdateAnimatingOpacity();
+    UpdateAnimationState(TargetProperty::OPACITY);
 }
 
 Animation* ElementAnimations::GetAnimation(
     TargetProperty::Type target_property) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     size_t index = animations_.size() - i - 1;
     if (animations_[index]->target_property() == target_property)
       return animations_[index].get();
   }
   return nullptr;
@@ skipping 43 matching lines @@
       element_id(), list_type, scroll_offset);
 }
 
 void ElementAnimations::OnAnimationWaitingForDeletion() {
   // TODO(loyso): Invalidate AnimationHost::SetNeedsPushProperties here.
   // But we always do PushProperties in AnimationHost for now. crbug.com/604280
   DCHECK(animation_host());
   animation_host()->OnAnimationWaitingForDeletion();
 }
 
-void ElementAnimations::OnTransformIsPotentiallyAnimatingChanged(
-    ElementListType list_type,
-    bool is_animating) {
-  DCHECK(element_id());
-  DCHECK(animation_host());
-  DCHECK(animation_host()->mutator_host_client());
-  animation_host()
-      ->mutator_host_client()
-      ->ElementTransformIsPotentiallyAnimatingChanged(element_id(), list_type,
-                                                      is_animating);
-}
-
-void ElementAnimations::OnOpacityIsAnimatingChanged(
-    ElementListType list_type,
-    AnimationChangeType change_type,
-    bool is_animating) {
+void ElementAnimations::IsAnimatingChanged(ElementListType list_type,
+                                           TargetProperty::Type property,
+                                           AnimationChangeType change_type,
+                                           bool is_animating) {
   if (!element_id())
     return;
   DCHECK(animation_host());
   if (animation_host()->mutator_host_client()) {
-    animation_host()->mutator_host_client()->ElementOpacityIsAnimatingChanged(
-        element_id(), list_type, change_type, is_animating);
+    switch (property) {
+      case TargetProperty::OPACITY:
+        animation_host()
+            ->mutator_host_client()
+            ->ElementOpacityIsAnimatingChanged(element_id(), list_type,
+                                               change_type, is_animating);
+        break;
+      case TargetProperty::TRANSFORM:
+        animation_host()
+            ->mutator_host_client()
+            ->ElementTransformIsAnimatingChanged(element_id(), list_type,
+                                                 change_type, is_animating);
+        break;
+      default:
+        break;
+    }
   }
 }
 
 void ElementAnimations::NotifyPlayersAnimationStarted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
   for (PlayersListNode* node = players_list_->head();
        node != players_list_->end(); node = node->next()) {
     AnimationPlayer* player = node->value();
@@ skipping 43 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc