cc : Track opacity animation changes on effect 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 17 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),
       potentially_animating_transform_for_active_elements_(false),
-      potentially_animating_transform_for_pending_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) {
   animation_host_ = host;
 }
 
 void ElementAnimations::SetElementId(ElementId element_id) {
   element_id_ = element_id;
 }
@@ skipping 11 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())
+  if (has_element_in_active_list()) {
     OnTransformIsPotentiallyAnimatingChanged(ElementListType::ACTIVE, false);
+    OnOpacityIsAnimatingChanged(ElementListType::ACTIVE,
+                                AnimationChangeType::BOTH, false);
+  }
   set_has_element_in_active_list(false);
 
-  if (has_element_in_pending_list())
+  if (has_element_in_pending_list()) {
     OnTransformIsPotentiallyAnimatingChanged(ElementListType::PENDING, false);
+    OnOpacityIsAnimatingChanged(ElementListType::PENDING,
+                                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 45 matching lines @@
   RemoveAnimationsCompletedOnMainThread(element_animations_impl.get());
 
   PushPropertiesToImplThread(element_animations_impl.get());
   element_animations_impl->UpdateActivation(NORMAL_ACTIVATION);
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 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();
+  if (added_opacity_animation)
+    UpdateAnimatingOpacity();
 }
 
 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();
 }
 
 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 77 matching lines @@
     PromoteStartedAnimations(last_tick_time_, events);
   }
 
   AccumulatePropertyUpdates(last_tick_time_, events);
 
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 void ElementAnimations::ActivateAnimations() {
   bool changed_transform_animation = false;
+  bool changed_opacity_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_elements() !=
-            animations_[i]->affects_pending_elements() &&
-        animations_[i]->target_property() == TargetProperty::TRANSFORM)
-      changed_transform_animation = true;
+        animations_[i]->affects_pending_elements()) {
+      if (animations_[i]->target_property() == TargetProperty::TRANSFORM)
+        changed_transform_animation = true;
+      else if (animations_[i]->target_property() == TargetProperty::OPACITY)
+        changed_opacity_animation = true;
+    }
     animations_[i]->set_affects_active_elements(
         animations_[i]->affects_pending_elements());
   }
   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();
+  if (changed_opacity_animation)
+    UpdateAnimatingOpacity();
 }
 
 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 36 matching lines @@
   if (!players_list_->empty()) {
     std::unique_ptr<AnimationCurve> animation_curve = event.curve->Clone();
     NotifyPlayersAnimationTakeover(event.monotonic_time, event.target_property,
                                    event.animation_start_time,
                                    std::move(animation_curve));
   }
 }
 
 void ElementAnimations::NotifyAnimationAborted(const AnimationEvent& event) {
   bool aborted_transform_animation = false;
+  bool aborted_opacity_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property) {
       animations_[i]->SetRunState(Animation::ABORTED, event.monotonic_time);
       animations_[i]->set_received_finished_event(true);
       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();
+  if (aborted_opacity_animation)
+    UpdateAnimatingOpacity();
 }
 
 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 237 matching lines @@
   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;
+  bool removed_opacity_animation = false;
   // Animations removed on the main thread should no longer affect pending
   // 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_elements(false);
       if (animation->target_property() == TargetProperty::TRANSFORM)
         removed_transform_animation = true;
+      else if (animation->target_property() == TargetProperty::OPACITY)
+        removed_opacity_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_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();
+  if (removed_opacity_animation)
+    element_animations_impl->UpdateAnimatingOpacity();
 }
 
 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 122 matching lines @@
           NotifyAnimationStarted(started_event);
         else
           events->events_.push_back(started_event);
       }
     }
   }
 }
 
 void ElementAnimations::MarkFinishedAnimations(base::TimeTicks monotonic_time) {
   bool finished_transform_animation = false;
+  bool finished_opacity_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->IsFinishedAt(monotonic_time)) {
       animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
-      if (animations_[i]->target_property() == TargetProperty::TRANSFORM) {
+      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();
+  if (finished_opacity_animation)
+    UpdateAnimatingOpacity();
 }
 
 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 111 matching lines @@
       marked_animations_for_deletions = true;
     }
   }
   if (marked_animations_for_deletions)
     NotifyClientAnimationWaitingForDeletion();
 }
 
 void ElementAnimations::MarkAbortedAnimationsForDeletion(
     ElementAnimations* element_animations_impl) const {
   bool aborted_transform_animation = false;
+  bool aborted_opacity_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())) {
       if (animation->run_state() == Animation::ABORTED) {
         animation_impl->SetRunState(Animation::WAITING_FOR_DELETION,
                                     element_animations_impl->last_tick_time_);
         animation->SetRunState(Animation::WAITING_FOR_DELETION,
                                last_tick_time_);
-        if (animation_impl->target_property() == TargetProperty::TRANSFORM) {
+        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();
+  if (aborted_opacity_animation)
+    element_animations_impl->UpdateAnimatingOpacity();
 }
 
 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 133 matching lines @@
   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::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_);
+    }
+  }
+}
+
 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_;
 
   potentially_animating_transform_for_active_elements_ = false;
   potentially_animating_transform_for_pending_elements_ = false;
 
   for (const auto& animation : animations_) {
@@ skipping 13 matching lines @@
       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_ &&
+          animation->InEffect(last_tick_time_);
+      currently_running_opacity_animation_for_pending_elements_ =
+          potentially_animating_opacity_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_;
+  bool potentially_animating_changed_for_pending_elements =
+      was_potentially_animating_opacity_for_pending_elements !=
+      potentially_animating_opacity_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_;
+  bool currently_running_animation_changed_for_pending_elements =
+      was_currently_running_opacity_animation_for_pending_elements !=
+      currently_running_opacity_animation_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);
+}
+
 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,
@@ skipping 34 matching lines @@
     if (animations_[i]->id() == animation_id) {
       animations_[i]->SetRunState(Animation::PAUSED,
                                   time_offset + animations_[i]->start_time() +
                                       animations_[i]->time_offset());
     }
   }
 }
 
 void ElementAnimations::RemoveAnimation(int animation_id) {
   bool removed_transform_animation = false;
+  bool removed_opacity_animation = false;
   // Since we want to use the animations that we're going to remove, we need to
   // use a stable_parition here instead of remove_if. Remove_if leaves the
   // removed items in an unspecified state.
   auto animations_to_remove = std::stable_partition(
       animations_.begin(), animations_.end(),
       [animation_id](const std::unique_ptr<Animation>& animation) {
         return animation->id() != animation_id;
       });
   for (auto it = animations_to_remove; it != animations_.end(); ++it) {
     if ((*it)->target_property() == TargetProperty::SCROLL_OFFSET) {
       scroll_offset_animation_was_interrupted_ = true;
     } else if ((*it)->target_property() == TargetProperty::TRANSFORM &&
                !(*it)->is_finished()) {
       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();
+  if (removed_opacity_animation)
+    UpdateAnimatingOpacity();
 }
 
 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();
+  if (aborted_opacity_animation)
+    UpdateAnimatingOpacity();
 }
 
 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();
+  if (aborted_opacity_animation)
+    UpdateAnimatingOpacity();
 }
 
 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 55 matching lines @@
     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) {
+  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);
+}
+
 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();
     player->NotifyAnimationStarted(monotonic_time, target_property, group);
   }
 }
@@ skipping 40 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