Use a bitfield to store animatable properties.

ui/compositor/layer_animation_element.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_animation_element.h"
 
 #include "base/compiler_specific.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/float_animation_curve_adapter.h"
@@ skipping 11 matching lines @@
 
 // The factor by which duration is scaled up or down when
 // ScopedAnimationDurationScaleMode::duration_scale_mode() is SLOW_DURATION or
 // FAST_DURATION.
 const int kSlowDurationScaleFactor = 4;
 const int kFastDurationScaleFactor = 4;
 
 // Pause -----------------------------------------------------------------------
 class Pause : public LayerAnimationElement {
  public:
-  Pause(const AnimatableProperties& properties, base::TimeDelta duration)
+  Pause(AnimatableProperties properties, base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   virtual ~Pause() {}
 
  private:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {}
   virtual bool OnProgress(double t,
                           LayerAnimationDelegate* delegate) OVERRIDE {
     return false;
   }
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {}
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
   DISALLOW_COPY_AND_ASSIGN(Pause);
 };
 
 // TransformTransition ---------------------------------------------------------
 
 class TransformTransition : public LayerAnimationElement {
  public:
     TransformTransition(const gfx::Transform& target, base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(TRANSFORM, duration),
         target_(target) {
   }
   virtual ~TransformTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetTransformForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetTransformFromAnimation(
         gfx::Tween::TransformValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->transform = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::TRANSFORM);
-    return properties;
-  }
-
   gfx::Transform start_;
   const gfx::Transform target_;
 
   DISALLOW_COPY_AND_ASSIGN(TransformTransition);
 };
 
 // InterpolatedTransformTransition ---------------------------------------------
 
 class InterpolatedTransformTransition : public LayerAnimationElement {
  public:
   InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform,
                                   base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(TRANSFORM, duration),
         interpolated_transform_(interpolated_transform) {
   }
   virtual ~InterpolatedTransformTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetTransformFromAnimation(
         interpolated_transform_->Interpolate(static_cast<float>(t)));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->transform = interpolated_transform_->Interpolate(1.0f);
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::TRANSFORM);
-    return properties;
-  }
-
   scoped_ptr<InterpolatedTransform> interpolated_transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformTransition);
 };
 
 // BoundsTransition ------------------------------------------------------------
 
 class BoundsTransition : public LayerAnimationElement {
  public:
   BoundsTransition(const gfx::Rect& target, base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(BOUNDS, duration),
         target_(target) {
   }
   virtual ~BoundsTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetBoundsForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetBoundsFromAnimation(
         gfx::Tween::RectValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->bounds = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::BOUNDS);
-    return properties;
-  }
-
   gfx::Rect start_;
   const gfx::Rect target_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsTransition);
 };
 
 // OpacityTransition -----------------------------------------------------------
 
 class OpacityTransition : public LayerAnimationElement {
  public:
   OpacityTransition(float target, base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(OPACITY, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~OpacityTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetOpacityForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetOpacityFromAnimation(
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->opacity = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::OPACITY);
-    return properties;
-  }
-
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(OpacityTransition);
 };
 
 // VisibilityTransition --------------------------------------------------------
 
 class VisibilityTransition : public LayerAnimationElement {
  public:
   VisibilityTransition(bool target, base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(VISIBILITY, duration),
         start_(false),
         target_(target) {
   }
   virtual ~VisibilityTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetVisibilityForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_);
     return t == 1.0;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->visibility = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::VISIBILITY);
-    return properties;
-  }
-
   bool start_;
   const bool target_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityTransition);
 };
 
 // BrightnessTransition --------------------------------------------------------
 
 class BrightnessTransition : public LayerAnimationElement {
  public:
   BrightnessTransition(float target, base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(BRIGHTNESS, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~BrightnessTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetBrightnessForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetBrightnessFromAnimation(
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->brightness = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::BRIGHTNESS);
-    return properties;
-  }
-
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(BrightnessTransition);
 };
 
 // GrayscaleTransition ---------------------------------------------------------
 
 class GrayscaleTransition : public LayerAnimationElement {
  public:
   GrayscaleTransition(float target, base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(GRAYSCALE, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~GrayscaleTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetGrayscaleForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetGrayscaleFromAnimation(
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->grayscale = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::GRAYSCALE);
-    return properties;
-  }
-
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(GrayscaleTransition);
 };
 
 // ColorTransition -------------------------------------------------------------
 
 class ColorTransition : public LayerAnimationElement {
  public:
   ColorTransition(SkColor target, base::TimeDelta duration)
-      : LayerAnimationElement(GetProperties(), duration),
+      : LayerAnimationElement(COLOR, duration),
         start_(SK_ColorBLACK),
         target_(target) {
   }
   virtual ~ColorTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetColorForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetColorFromAnimation(
         gfx::Tween::ColorValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->color = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::COLOR);
-    return properties;
-  }
-
   SkColor start_;
   const SkColor target_;
 
   DISALLOW_COPY_AND_ASSIGN(ColorTransition);
 };
 
 // ThreadedLayerAnimationElement -----------------------------------------------
 
 class ThreadedLayerAnimationElement : public LayerAnimationElement {
  public:
-  ThreadedLayerAnimationElement(const AnimatableProperties& properties,
+  ThreadedLayerAnimationElement(AnimatableProperties properties,
                                 base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   virtual ~ThreadedLayerAnimationElement() {}
 
   virtual bool IsThreaded() const OVERRIDE {
     return (duration() != base::TimeDelta());
   }
 
  protected:
@@ skipping 39 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ThreadedLayerAnimationElement);
 };
 
 // ThreadedOpacityTransition ---------------------------------------------------
 
 class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
  public:
   ThreadedOpacityTransition(float target, base::TimeDelta duration)
-      : ThreadedLayerAnimationElement(GetProperties(), duration),
+      : ThreadedLayerAnimationElement(OPACITY, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~ThreadedOpacityTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetOpacityForAnimation();
   }
 
@@ skipping 23 matching lines @@
                               animation_group_id(),
                               cc::Animation::Opacity));
     return animation.Pass();
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->opacity = target_;
   }
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::OPACITY);
-    return properties;
-  }
-
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedOpacityTransition);
 };
 
 // ThreadedTransformTransition -------------------------------------------------
 
 class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
  public:
   ThreadedTransformTransition(const gfx::Transform& target,
                               base::TimeDelta duration)
-      : ThreadedLayerAnimationElement(GetProperties(), duration),
+      : ThreadedLayerAnimationElement(TRANSFORM, duration),
         target_(target) {
   }
   virtual ~ThreadedTransformTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetTransformForAnimation();
     float device_scale_factor = delegate->GetDeviceScaleFactor();
     cc_start_ = Layer::ConvertTransformToCCTransform(start_,
                                                      device_scale_factor);
@@ skipping 27 matching lines @@
                               animation_group_id(),
                               cc::Animation::Transform));
     return animation.Pass();
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->transform = target_;
   }
 
  private:
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::TRANSFORM);
-    return properties;
-  }
-
   gfx::Transform start_;
   gfx::Transform cc_start_;
   const gfx::Transform target_;
   gfx::Transform cc_target_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedTransformTransition);
 };
 
 // InverseTransformTransision --------------------------------------------------
 
@@ skipping 83 matching lines @@
   gfx::Transform ComputeWithBaseTransform(gfx::Transform start,
                                           gfx::Transform target) const {
     gfx::Transform to_return(gfx::Transform::kSkipInitialization);
     bool success = target.GetInverse(&to_return);
     DCHECK(success) << "Target transform must be invertible.";
 
     to_return.PreconcatTransform(start);
     return to_return;
   }
 
-  static AnimatableProperties GetProperties() {
-    AnimatableProperties properties;
-    properties.insert(LayerAnimationElement::TRANSFORM);
-    return properties;
-  }
-
   template <typename T>
   static T CheckAndCast(const LayerAnimationElement* element) {
-    const AnimatableProperties& properties = element->properties();
-    DCHECK(properties.find(TRANSFORM) != properties.end());
+    AnimatableProperties properties = element->properties();
+    DCHECK(properties & TRANSFORM);
     return static_cast<T>(element);
   }
 
   gfx::Transform effective_start_;
   gfx::Transform computed_target_transform_;
 
   const gfx::Transform base_transform_;
   gfx::Transform base_target_;
 
   scoped_ptr<cc::AnimationCurve> animation_curve_;
@@ skipping 23 matching lines @@
       opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
       visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
       brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
       grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f),
       color(delegate ? delegate->GetColorForAnimation() : 0.0f) {
 }
 
 // LayerAnimationElement -------------------------------------------------------
 
 LayerAnimationElement::LayerAnimationElement(
-    const AnimatableProperties& properties,
-    base::TimeDelta duration)
+    AnimatableProperties properties, base::TimeDelta duration)
     : first_frame_(true),
       properties_(properties),
       duration_(GetEffectiveDuration(duration)),
       tween_type_(gfx::Tween::LINEAR),
       animation_id_(cc::AnimationIdProvider::NextAnimationId()),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
       weak_ptr_factory_(this) {
 }
 
@@ skipping 193 matching lines @@
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateGrayscaleElement(
     float grayscale,
     base::TimeDelta duration) {
   return new GrayscaleTransition(grayscale, duration);
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreatePauseElement(
-    const AnimatableProperties& properties,
+    AnimatableProperties properties,
     base::TimeDelta duration) {
   return new Pause(properties, duration);
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui