CC Animation: Use std::bitset to update animation state.

cc/animation/animation_player.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/animation_player.h"
 
 #include <algorithm>
 
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_host.h"
@@ skipping 88 matching lines @@
   // Destroy ElementAnimations or release it if it's still needed.
   animation_host_->UnregisterPlayerForElement(element_id_, this);
 }
 
 void AnimationPlayer::BindElementAnimations() {
   DCHECK(!element_animations_);
   element_animations_ =
       animation_host_->GetElementAnimationsForElementId(element_id_);
   DCHECK(element_animations_);
 
-  for (auto& animation : animations_)
-    AnimationAddedForProperty(animation->target_property());
+  if (!animations_.empty())
+    AnimationAdded();
 
   SetNeedsPushProperties();
 }
 
 void AnimationPlayer::UnbindElementAnimations() {
   SetNeedsPushProperties();
   element_animations_ = nullptr;
 }
 
 void AnimationPlayer::AddAnimation(std::unique_ptr<Animation> animation) {
   DCHECK(animation->target_property() != TargetProperty::SCROLL_OFFSET ||
          (animation_host_ && animation_host_->SupportsScrollAnimations()));
   DCHECK(!animation->is_impl_only() ||
          animation->target_property() == TargetProperty::SCROLL_OFFSET);
 
-  TargetProperty::Type target_property = animation->target_property();
   animations_.push_back(std::move(animation));
   if (element_animations_) {
-    AnimationAddedForProperty(target_property);
+    AnimationAdded();
     SetNeedsPushProperties();
   }
 }
 
-void AnimationPlayer::AnimationAddedForProperty(
-    TargetProperty::Type target_property) {
+void AnimationPlayer::AnimationAdded() {
   DCHECK(element_animations_);
 
   SetNeedsCommit();
   needs_to_start_animations_ = true;
 
   element_animations_->UpdateActivationNormal();
-  element_animations_->UpdateClientAnimationState(target_property);
+  element_animations_->UpdateClientAnimationState();
 }
 
 void AnimationPlayer::PauseAnimation(int animation_id, double time_offset) {
   const base::TimeDelta time_delta = base::TimeDelta::FromSecondsD(time_offset);
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->id() == animation_id) {
       animations_[i]->SetRunState(Animation::PAUSED,
                                   time_delta + animations_[i]->start_time() +
                                       animations_[i]->time_offset());
     }
   }
 
   if (element_animations_) {
     SetNeedsCommit();
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::RemoveAnimation(int animation_id) {
-  bool removed_transform_animation = false;
-  bool removed_opacity_animation = false;
-  bool removed_filter_animation = false;
+  bool animation_removed = 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) {
       if (element_animations_)
         element_animations_->SetScrollOffsetAnimationWasInterrupted();
-    } 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;
-    } else if ((*it)->target_property() == TargetProperty::FILTER &&
-               !(*it)->is_finished()) {
-      removed_filter_animation = true;
+    } else if (!(*it)->is_finished()) {
+      animation_removed = true;
     }
   }
 
   animations_.erase(animations_to_remove, animations_.end());
 
   if (element_animations_) {
     element_animations_->UpdateActivationNormal();
-    element_animations_->UpdateClientAnimationState(removed_transform_animation,
-                                                    removed_opacity_animation,
-                                                    removed_filter_animation);
+    if (animation_removed)
+      element_animations_->UpdateClientAnimationState();
     SetNeedsCommit();
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::AbortAnimation(int animation_id) {
   if (Animation* animation = GetAnimationById(animation_id)) {
     if (!animation->is_finished()) {
       animation->SetRunState(Animation::ABORTED, last_tick_time_);
       if (element_animations_)
-        element_animations_->UpdateClientAnimationState(
-            animation->target_property());
+        element_animations_->UpdateClientAnimationState();
     }
   }
 
   if (element_animations_) {
     SetNeedsCommit();
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::AbortAnimations(TargetProperty::Type target_property,
@@ skipping 12 matching lines @@
                                     last_tick_time_);
       } else {
         animations_[i]->SetRunState(Animation::ABORTED, last_tick_time_);
       }
       aborted_animation = true;
     }
   }
 
   if (element_animations_) {
     if (aborted_animation)
-      element_animations_->UpdateClientAnimationState(target_property);
+      element_animations_->UpdateClientAnimationState();
     SetNeedsCommit();
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::PushPropertiesTo(AnimationPlayer* player_impl) {
   if (!needs_push_properties_)
     return;
   needs_push_properties_ = false;
 
@@ skipping 188 matching lines @@
               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 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_elements) {
             if (blocked_properties_for_active_elements[property])
               null_intersection = false;
             else
               blocked_properties_for_active_elements[property] = true;
           }
           if (affects_pending_elements) {
@@ skipping 257 matching lines @@
           break;
         }
       }
     }
   }
 
   last_tick_time_ = monotonic_time;
 }
 
 void AnimationPlayer::MarkFinishedAnimations(base::TimeTicks monotonic_time) {
-  bool finished_transform_animation = false;
-  bool finished_opacity_animation = false;
-  bool finished_filter_animation = false;
+  bool animation_finished = 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)
-        finished_transform_animation = true;
-      else if (animations_[i]->target_property() == TargetProperty::OPACITY)
-        finished_opacity_animation = true;
-      else if (animations_[i]->target_property() == TargetProperty::FILTER)
-        finished_filter_animation = true;
+      animation_finished = true;
     }
   }
 
   DCHECK(element_animations_);
-  element_animations_->UpdateClientAnimationState(finished_transform_animation,
-                                                  finished_opacity_animation,
-                                                  finished_filter_animation);
+  if (animation_finished)
+    element_animations_->UpdateClientAnimationState();
 }
 
-void AnimationPlayer::ActivateAnimations(bool* changed_transform_animation,
-                                         bool* changed_opacity_animation,
-                                         bool* changed_filter_animation) {
+void AnimationPlayer::ActivateAnimations() {
+  bool animation_activated = false;
+
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_elements() !=
         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;
-      else if (animations_[i]->target_property() == TargetProperty::FILTER)
-        *changed_filter_animation = true;
+      animation_activated = 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());
+
+  if (animation_activated)
+    element_animations_->UpdateClientAnimationState();
 }
 
 bool AnimationPlayer::HasFilterAnimationThatInflatesBounds() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == TargetProperty::FILTER &&
         animations_[i]
             ->curve()
             ->ToFilterAnimationCurve()
             ->HasFilterThatMovesPixels())
@@ skipping 205 matching lines @@
   return nullptr;
 }
 
 Animation* AnimationPlayer::GetAnimationById(int animation_id) const {
   for (size_t i = 0; i < animations_.size(); ++i)
     if (animations_[i]->id() == animation_id)
       return animations_[i].get();
   return nullptr;
 }
 
-void AnimationPlayer::GetPropertyAnimationStateFor(
-    TargetProperty::Type property,
-    PropertyAnimationState* state) const {
-  state->Clear();
+void AnimationPlayer::GetPropertyAnimationState(
+    PropertyAnimationState* pending_state,
+    PropertyAnimationState* active_state) const {
+  pending_state->Clear();
+  active_state->Clear();
+
   for (const auto& animation : animations_) {
-    if (!animation->is_finished() && animation->target_property() == property) {
-      state->potentially_animating_for_active_elements |=
-          animation->affects_active_elements();
-      state->potentially_animating_for_pending_elements |=
-          animation->affects_pending_elements();
-      state->currently_running_for_active_elements |=
-          animation->affects_active_elements() &&
-          animation->InEffect(last_tick_time_);
-      state->currently_running_for_pending_elements |=
-          animation->affects_pending_elements() &&
-          animation->InEffect(last_tick_time_);
+    if (!animation->is_finished()) {
+      bool in_effect = animation->InEffect(last_tick_time_);
+      bool active = animation->affects_active_elements();
+      bool pending = animation->affects_pending_elements();
+      TargetProperty::Type property = animation->target_property();
+
+      if (pending)
+        pending_state->potentially_animating[property] = true;
+      if (pending && in_effect)
+        pending_state->currently_running[property] = true;
+
+      if (active)
+        active_state->potentially_animating[property] = true;
+      if (active && in_effect)
+        active_state->currently_running[property] = true;
     }
   }
 }
 
 void AnimationPlayer::MarkAbortedAnimationsForDeletion(
     AnimationPlayer* animation_player_impl) const {
-  bool aborted_transform_animation = false;
-  bool aborted_opacity_animation = false;
-  bool aborted_filter_animation = false;
+  bool animation_aborted = false;
+
   auto& animations_impl = animation_player_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,
                                     animation_player_impl->last_tick_time_);
         animation->SetRunState(Animation::WAITING_FOR_DELETION,
                                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;
-        else if (animation_impl->target_property() == TargetProperty::FILTER)
-          aborted_filter_animation = true;
+        animation_aborted = true;
       }
     }
   }
 
-  if (element_animations_)
-    element_animations_->SetNeedsUpdateImplClientState(
-        aborted_transform_animation, aborted_opacity_animation,
-        aborted_filter_animation);
+  if (element_animations_ && animation_aborted)
+    element_animations_->SetNeedsUpdateImplClientState();
 }
 
 void AnimationPlayer::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 42 matching lines @@
                         const AnimationPlayer* main_thread_player) {
   if (animation->is_impl_only()) {
     return (animation->run_state() == Animation::WAITING_FOR_DELETION);
   } else {
     return !main_thread_player->GetAnimationById(animation->id());
   }
 }
 
 void AnimationPlayer::RemoveAnimationsCompletedOnMainThread(
     AnimationPlayer* animation_player_impl) const {
-  bool removed_transform_animation = false;
-  bool removed_opacity_animation = false;
-  bool removed_filter_animation = false;
+  bool animation_completed = 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 = animation_player_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;
-      else if (animation->target_property() == TargetProperty::FILTER)
-        removed_filter_animation = true;
+      animation_completed = 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 (element_animations_)
-    element_animations_->SetNeedsUpdateImplClientState(
-        removed_transform_animation, removed_opacity_animation,
-        removed_filter_animation);
+  if (element_animations_ && animation_completed)
+    element_animations_->SetNeedsUpdateImplClientState();
 }
 
 void AnimationPlayer::PushPropertiesToImplThread(
     AnimationPlayer* animation_player_impl) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* current_impl =
         animation_player_impl->GetAnimationById(animations_[i]->id());
     if (current_impl)
       animations_[i]->PushPropertiesTo(current_impl);
   }
 }
 
 }  // namespace cc