Use a bitfield to store animatable properties.

ui/compositor/layer_animator.cc

 // Copyright (c) 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 "ui/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/animation/animation_id_provider.h"
@@ skipping 170 matching lines @@
 
   adding_animations_ = true;
   if (!is_animating()) {
     if (GetAnimationContainer()->is_running())
       last_step_time_ = GetAnimationContainer()->last_tick_time();
     else
       last_step_time_ = gfx::FrameTime::Now();
   }
 
   // Collect all the affected properties.
-  LayerAnimationElement::AnimatableProperties animated_properties;
+  LayerAnimationElement::AnimatableProperties animated_properties =
+      LayerAnimationElement::UNKNOWN;
+
   std::vector<LayerAnimationSequence*>::const_iterator iter;
-  for (iter = animations.begin(); iter != animations.end(); ++iter) {
-    animated_properties.insert((*iter)->properties().begin(),
-                               (*iter)->properties().end());
-  }
+  for (iter = animations.begin(); iter != animations.end(); ++iter)
+    animated_properties |= (*iter)->properties();
 
   // Starting a zero duration pause that affects all the animated properties
   // will prevent any of the sequences from animating until there are no
   // running animations that affect any of these properties, as well as
   // handle preemption strategy.
   StartAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreatePauseElement(animated_properties,
                                                 base::TimeDelta())));
 
   bool wait_for_group_start = false;
@@ skipping 13 matching lines @@
   adding_animations_ = false;
   UpdateAnimationState();
 }
 
 
 void LayerAnimator::ScheduleTogether(
     const std::vector<LayerAnimationSequence*>& animations) {
   scoped_refptr<LayerAnimator> retain(this);
 
   // Collect all the affected properties.
-  LayerAnimationElement::AnimatableProperties animated_properties;
+  LayerAnimationElement::AnimatableProperties animated_properties =
+      LayerAnimationElement::UNKNOWN;
+
   std::vector<LayerAnimationSequence*>::const_iterator iter;
-  for (iter = animations.begin(); iter != animations.end(); ++iter) {
-    animated_properties.insert((*iter)->properties().begin(),
-                               (*iter)->properties().end());
-  }
+  for (iter = animations.begin(); iter != animations.end(); ++iter)
+    animated_properties |= (*iter)->properties();
 
   // Scheduling a zero duration pause that affects all the animated properties
   // will prevent any of the sequences from animating until there are no
   // running animations that affect any of these properties.
   ScheduleAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreatePauseElement(animated_properties,
                                                 base::TimeDelta())));
 
   bool wait_for_group_start = false;
   for (iter = animations.begin(); iter != animations.end(); ++iter)
     wait_for_group_start |= (*iter)->IsFirstElementThreaded();
 
   int group_id = cc::AnimationIdProvider::NextGroupId();
 
   // These animations (provided they don't animate any common properties) will
   // now animate together if trivially scheduled.
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
     (*iter)->set_animation_group_id(group_id);
     (*iter)->set_waiting_for_group_start(wait_for_group_start);
     ScheduleAnimation(*iter);
   }
 
   UpdateAnimationState();
 }
 
 void LayerAnimator::SchedulePauseForProperties(
     base::TimeDelta duration,
-    LayerAnimationElement::AnimatableProperty property,
-    ...) {
-  ui::LayerAnimationElement::AnimatableProperties properties_to_pause;
-  va_list marker;
-  va_start(marker, property);
-  for (int p = static_cast<int>(property); p != -1; p = va_arg(marker, int)) {
-    properties_to_pause.insert(
-        static_cast<LayerAnimationElement::AnimatableProperty>(p));
-  }
-  va_end(marker);
+    LayerAnimationElement::AnimatableProperties properties_to_pause) {
   ScheduleAnimation(new ui::LayerAnimationSequence(
                         ui::LayerAnimationElement::CreatePauseElement(
                             properties_to_pause, duration)));
 }
 
 bool LayerAnimator::IsAnimatingProperty(
     LayerAnimationElement::AnimatableProperty property) const {
   for (AnimationQueue::const_iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
-    if ((*queue_iter)->properties().find(property) !=
-        (*queue_iter)->properties().end()) {
+    if ((*queue_iter)->properties() & property)
       return true;
-    }
   }
   return false;
 }
 
 void LayerAnimator::StopAnimatingProperty(
     LayerAnimationElement::AnimatableProperty property) {
   scoped_refptr<LayerAnimator> retain(this);
   while (true) {
     // GetRunningAnimation purges deleted animations before searching, so we are
     // guaranteed to find a live animation if any is returned at all.
@@ skipping 253 matching lines @@
 void LayerAnimator::ClearAnimations() {
   scoped_refptr<LayerAnimator> retain(this);
   ClearAnimationsInternal();
 }
 
 LayerAnimator::RunningAnimation* LayerAnimator::GetRunningAnimation(
     LayerAnimationElement::AnimatableProperty property) {
   PurgeDeletedAnimations();
   for (RunningAnimations::iterator iter = running_animations_.begin();
        iter != running_animations_.end(); ++iter) {
-    if ((*iter).sequence()->properties().find(property) !=
-        (*iter).sequence()->properties().end())
+    if ((*iter).sequence()->properties() & property)
       return &(*iter);
   }
   return NULL;
 }
 
 void LayerAnimator::AddToQueueIfNotPresent(LayerAnimationSequence* animation) {
   // If we don't have the animation in the queue yet, add it.
   bool found_sequence = false;
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
@@ skipping 130 matching lines @@
   }
   animation_queue_.push_back(make_linked_ptr(sequence));
   ProcessQueue();
 }
 
 void LayerAnimator::ProcessQueue() {
   bool started_sequence = false;
   do {
     started_sequence = false;
     // Build a list of all currently animated properties.
-    LayerAnimationElement::AnimatableProperties animated;
+    LayerAnimationElement::AnimatableProperties animated =
+        LayerAnimationElement::UNKNOWN;
     for (RunningAnimations::const_iterator iter = running_animations_.begin();
          iter != running_animations_.end(); ++iter) {
       if (!(*iter).is_sequence_alive())
         continue;
-      animated.insert((*iter).sequence()->properties().begin(),
-                      (*iter).sequence()->properties().end());
+
+      animated |= (*iter).sequence()->properties();
     }
 
     // Try to find an animation that doesn't conflict with an animated
     // property or a property that will be animated before it. Note: starting
     // the animation may indirectly cause more animations to be started, so we
     // need to operate on a copy.
     std::vector<base::WeakPtr<LayerAnimationSequence> > sequences;
     for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
          queue_iter != animation_queue_.end(); ++queue_iter)
       sequences.push_back((*queue_iter)->AsWeakPtr());
 
     for (size_t i = 0; i < sequences.size(); ++i) {
       if (!sequences[i].get() || !HasAnimation(sequences[i].get()))
         continue;
 
       if (!sequences[i]->HasConflictingProperty(animated)) {
         StartSequenceImmediately(sequences[i].get());
         started_sequence = true;
         break;
       }
 
       // Animation couldn't be started. Add its properties to the collection so
       // that we don't start a conflicting animation. For example, if our queue
       // has the elements { {T,B}, {B} } (that is, an element that animates both
       // the transform and the bounds followed by an element that animates the
       // bounds), and we're currently animating the transform, we can't start
       // the first element because it animates the transform, too. We cannot
       // start the second element, either, because the first element animates
       // bounds too, and needs to go first.
-      animated.insert(sequences[i]->properties().begin(),
-                      sequences[i]->properties().end());
+      animated |= sequences[i]->properties();
     }
 
     // If we started a sequence, try again. We may be able to start several.
   } while (started_sequence);
 }
 
 bool LayerAnimator::StartSequenceImmediately(LayerAnimationSequence* sequence) {
   PurgeDeletedAnimations();
 
   // Ensure that no one is animating one of the sequence's properties already.
@@ skipping 94 matching lines @@
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui