Use a bitfield to store animatable properties.

ui/compositor/layer_animation_element.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 #define UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 
 #include <set>
 
 #include "base/memory/weak_ptr.h"
@@ skipping 10 matching lines @@
 
 class InterpolatedTransform;
 class LayerAnimationDelegate;
 
 // LayerAnimationElements represent one segment of an animation between two
 // keyframes. They know how to update a LayerAnimationDelegate given a value
 // between 0 and 1 (0 for initial, and 1 for final).
 class COMPOSITOR_EXPORT LayerAnimationElement {
  public:
   enum AnimatableProperty {
-    TRANSFORM = 0,
-    BOUNDS,
-    OPACITY,
-    VISIBILITY,
-    BRIGHTNESS,
-    GRAYSCALE,
-    COLOR,
+    UNKNOWN = 0,
+    TRANSFORM = (1 << 0),
+    BOUNDS = (1 << 1),
+    OPACITY = (1 << 2),
+    VISIBILITY = (1 << 3),
+    BRIGHTNESS = (1 << 4),
+    GRAYSCALE = (1 << 5),
+    COLOR = (1 << 6),
+
+    // Used when iterating over properties.
+    FIRST_PROPERTY = TRANSFORM,
+    SENTINEL = (1 << 7)
   };
 
   static AnimatableProperty ToAnimatableProperty(
       cc::Animation::TargetProperty property);
 
   struct COMPOSITOR_EXPORT TargetValue {
     TargetValue();
     // Initializes the target value to match the delegate. NULL may be supplied.
     explicit TargetValue(const LayerAnimationDelegate* delegate);
 
     gfx::Rect bounds;
     gfx::Transform transform;
     float opacity;
     bool visibility;
     float brightness;
     float grayscale;
     SkColor color;
   };
 
-  typedef std::set<AnimatableProperty> AnimatableProperties;
+  typedef unsigned AnimatableProperties;

[sky, 2014/01/13 14:26:42]

I believe we generally use uint32 for these.

[Ian Vollick, 2014/01/13 19:03:59]

Done.

 
-  LayerAnimationElement(const AnimatableProperties& properties,
+  LayerAnimationElement(AnimatableProperties properties,
                         base::TimeDelta duration);
 
   virtual ~LayerAnimationElement();
 
   // Creates an element that transitions to the given transform. The caller owns
   // the return value.
   static LayerAnimationElement* CreateTransformElement(
       const gfx::Transform& transform,
       base::TimeDelta duration);
 
@@ skipping 47 matching lines @@
 
   // Creates an element that transitions to the given grayscale value.
   // The caller owns the return value.
   static LayerAnimationElement* CreateGrayscaleElement(
       float grayscale,
       base::TimeDelta duration);
 
   // Creates an element that pauses the given properties. The caller owns the
   // return value.
   static LayerAnimationElement* CreatePauseElement(
-      const AnimatableProperties& properties,
+      AnimatableProperties properties,
       base::TimeDelta duration);
 
   // Creates an element that transitions to the given color. The caller owns the
   // return value.
   static LayerAnimationElement* CreateColorElement(
       SkColor color,
       base::TimeDelta duration);
 
   // Sets the start time for the animation. This must be called before the first
   // call to {Start, IsFinished}. Once the animation is finished, this must
@@ skipping 33 matching lines @@
   bool ProgressToEnd(LayerAnimationDelegate* delegate);
 
   // Called if the animation is not allowed to complete. This may be called
   // before OnStarted or Progress.
   void Abort(LayerAnimationDelegate* delegate);
 
   // Assigns the target value to |target|.
   void GetTargetValue(TargetValue* target) const;
 
   // The properties that the element modifies.
-  const AnimatableProperties& properties() const { return properties_; }
+  AnimatableProperties properties() const { return properties_; }
 
   // Whether this element animates on the compositor thread.
   virtual bool IsThreaded() const;
 
   gfx::Tween::Type tween_type() const { return tween_type_; }
   void set_tween_type(gfx::Tween::Type tween_type) { tween_type_ = tween_type; }
 
   // Each LayerAnimationElement has a unique animation_id. Elements belonging
   // to sequences that are supposed to start together have the same
   // animation_group_id.
@@ skipping 41 matching lines @@
   double last_progressed_fraction_;
 
   base::WeakPtrFactory<LayerAnimationElement> weak_ptr_factory_;
 
   DISALLOW_ASSIGN(LayerAnimationElement);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_