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 142 matching lines @@
     }
   }
 
   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;
+  TargetProperties properties_animation_removed;
+
   // 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()) {
+      properties_animation_removed[(*it)->target_property()] = 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);
+    element_animations_->UpdateClientAnimationState(
+        properties_animation_removed);
     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_)
@@ skipping 233 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;
+  TargetProperties properties_animation_finished;
+
   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;
+      properties_animation_finished[animations_[i]->target_property()] = true;
     }
   }
 
   DCHECK(element_animations_);
-  element_animations_->UpdateClientAnimationState(finished_transform_animation,
-                                                  finished_opacity_animation,
-                                                  finished_filter_animation);
+  element_animations_->UpdateClientAnimationState(
+      properties_animation_finished);
 }
 
-void AnimationPlayer::ActivateAnimations(bool* changed_transform_animation,
-                                         bool* changed_opacity_animation,
-                                         bool* changed_filter_animation) {
+TargetProperties AnimationPlayer::ActivateAnimations() {
+  TargetProperties activated_properties;
+
   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;
+      activated_properties[animations_[i]->target_property()] = 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());
+
+  return activated_properties;
 }
 
 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 220 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;
+  TargetProperties properties_animation_aborted;
+
   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;
+        properties_animation_aborted[animation_impl->target_property()] = true;
       }
     }
   }
 
   if (element_animations_)
     element_animations_->SetNeedsUpdateImplClientState(
-        aborted_transform_animation, aborted_opacity_animation,
-        aborted_filter_animation);
+        properties_animation_aborted);
 }
 
 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;
+  TargetProperties properties_animation_completed;
+
   // 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;
+      properties_animation_completed[animation->target_property()] = 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);
+        properties_animation_completed);
 }
 
 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