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 49 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_);
 
+  OnOpacityIsCurrentlyAnimatingChanged(false);
   if (has_element_in_active_list())
     OnTransformIsPotentiallyAnimatingChanged(ElementListType::ACTIVE, false);
   set_has_element_in_active_list(false);
 
   if (has_element_in_pending_list())
     OnTransformIsPotentiallyAnimatingChanged(ElementListType::PENDING, false);
   set_has_element_in_pending_list(false);
 
   animation_host_->DidDeactivateElementAnimations(this);
   UpdateActivation(FORCE_ACTIVATION);
@@ skipping 67 matching lines @@
 
 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;
+  bool some_opacity_animation_is_now_running = !AllOpacityAnimationsEnded();
+  if (some_opacity_animation_is_now_running)
+    OnOpacityIsCurrentlyAnimatingChanged(true);
 }
 
 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 589 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 && AllOpacityAnimationsEnded())
+    OnOpacityIsCurrentlyAnimatingChanged(false);
 }
 
 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 316 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);
 }
 
+bool ElementAnimations::AllOpacityAnimationsEnded() {
+  for (const auto& animation : animations_) {
+    if (!animation->is_finished() && animation->InEffect(last_tick_time_) &&
+        animation->target_property() == TargetProperty::OPACITY)
+      return false;
+  }
+  return true;
+}
+
 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 && AllOpacityAnimationsEnded())
+    OnOpacityIsCurrentlyAnimatingChanged(false);
 }
 
 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 && AllOpacityAnimationsEnded())
+    OnOpacityIsCurrentlyAnimatingChanged(false);
 }
 
 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 && AllOpacityAnimationsEnded())
+    OnOpacityIsCurrentlyAnimatingChanged(false);
 }
 
 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::OnOpacityIsCurrentlyAnimatingChanged(
+    bool is_currently_animating) {
+  DCHECK(element_id());
+  DCHECK(animation_host());
+  if (animation_host()->mutator_host_client())
+    animation_host()
+        ->mutator_host_client()
+        ->ElementOpacityIsCurrentlyAnimatingChanged(element_id(),
+                                                    is_currently_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