CC Animation: Use bitset instead of unordered_set in LayerAnimationController

cc/animation/layer_animation_controller.cc

 // Copyright 2012 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/layer_animation_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 778 matching lines @@
   // First collect running properties affecting each type of observer.
   TargetProperties blocked_properties_for_active_observers;
   TargetProperties blocked_properties_for_pending_observers;
   std::vector<size_t> animations_waiting_for_target;
 
   animations_waiting_for_target.reserve(animations_.size());
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::STARTING ||
         animations_[i]->run_state() == Animation::RUNNING) {
       if (animations_[i]->affects_active_observers()) {
-        blocked_properties_for_active_observers.insert(
-            animations_[i]->target_property());
+        blocked_properties_for_active_observers[animations_[i]
+                                                    ->target_property()] = true;
       }
       if (animations_[i]->affects_pending_observers()) {
-        blocked_properties_for_pending_observers.insert(
-            animations_[i]->target_property());
+        blocked_properties_for_pending_observers[animations_[i]
+                                                     ->target_property()] =
+            true;
       }
     } else if (animations_[i]->run_state() ==
                Animation::WAITING_FOR_TARGET_AVAILABILITY) {
       animations_waiting_for_target.push_back(i);
     }
   }
 
   for (size_t i = 0; i < animations_waiting_for_target.size(); ++i) {
       // Collect all properties for animations with the same group id (they
       // should all also be in the list of animations).
     size_t animation_index = animations_waiting_for_target[i];
     Animation* animation_waiting_for_target =
         animations_[animation_index].get();
     // Check for the run state again even though the animation was waiting
     // for target because it might have changed the run state while handling
     // previous animation in this loop (if they belong to same group).
     if (animation_waiting_for_target->run_state() ==
         Animation::WAITING_FOR_TARGET_AVAILABILITY) {
       TargetProperties enqueued_properties;
       bool affects_active_observers =
           animation_waiting_for_target->affects_active_observers();
       bool affects_pending_observers =
           animation_waiting_for_target->affects_pending_observers();
-      enqueued_properties.insert(
-          animation_waiting_for_target->target_property());
+      enqueued_properties[animation_waiting_for_target->target_property()] =
+          true;
       for (size_t j = animation_index + 1; j < animations_.size(); ++j) {
         if (animation_waiting_for_target->group() == animations_[j]->group()) {
-          enqueued_properties.insert(animations_[j]->target_property());
+          enqueued_properties[animations_[j]->target_property()] = true;
           affects_active_observers |=
               animations_[j]->affects_active_observers();
           affects_pending_observers |=
               animations_[j]->affects_pending_observers();
         }
       }
 
       // 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 observers 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;
-      for (TargetProperties::iterator p_iter = enqueued_properties.begin();
-           p_iter != enqueued_properties.end();
-           ++p_iter) {
-        if (affects_active_observers &&
-            !blocked_properties_for_active_observers.insert(*p_iter).second)
-          null_intersection = false;
-        if (affects_pending_observers &&
-            !blocked_properties_for_pending_observers.insert(*p_iter).second)
-          null_intersection = false;
+      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_observers) {
+            if (blocked_properties_for_active_observers[property])
+              null_intersection = false;
+            else
+              blocked_properties_for_active_observers[property] = true;
+          }
+          if (affects_pending_observers) {
+            if (blocked_properties_for_pending_observers[property])
+              null_intersection = false;
+            else
+              blocked_properties_for_pending_observers[property] = true;
+          }
+        }
       }
 
       // If the intersection is null, then we are free to start the animations
       // in the group.
       if (null_intersection) {
         animation_waiting_for_target->SetRunState(Animation::STARTING,
                                                   monotonic_time);
         for (size_t j = animation_index + 1; j < animations_.size(); ++j) {
           if (animation_waiting_for_target->group() ==
               animations_[j]->group()) {
@@ skipping 410 matching lines @@
         &value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != nullptr)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc