CC Animation: Expose TargetProperty enum to be aliased in Blink Platform.

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 <utility>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 405 matching lines @@
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetOpacityFromAnimation(target_);
   }
 
   scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::AnimationCurve> animation_curve(
         new FloatAnimationCurveAdapter(tween_type(),
                                        start_,
                                        target_,
                                        duration()));
-    scoped_ptr<cc::Animation> animation(
-        cc::Animation::Create(std::move(animation_curve), animation_id(),
-                              animation_group_id(), cc::Animation::OPACITY));
+    scoped_ptr<cc::Animation> animation(cc::Animation::Create(
+        std::move(animation_curve), animation_id(), animation_group_id(),
+        cc::TargetProperty::OPACITY));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->opacity = target_;
   }
 
  private:
   float start_;
   const float target_;
@@ skipping 30 matching lines @@
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(target_);
   }
 
   scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::AnimationCurve> animation_curve(
         new TransformAnimationCurveAdapter(tween_type(),
                                            start_,
                                            target_,
                                            duration()));
-    scoped_ptr<cc::Animation> animation(
-        cc::Animation::Create(std::move(animation_curve), animation_id(),
-                              animation_group_id(), cc::Animation::TRANSFORM));
+    scoped_ptr<cc::Animation> animation(cc::Animation::Create(
+        std::move(animation_curve), animation_id(), animation_group_id(),
+        cc::TargetProperty::TRANSFORM));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = target_;
   }
 
  private:
   gfx::Transform start_;
   const gfx::Transform target_;
@@ skipping 49 matching lines @@
       ThreadedLayerAnimationElement::OnAbort(delegate);
       delegate->SetTransformFromAnimation(ComputeCurrentTransform());
     }
   }
 
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(computed_target_transform_);
   }
 
   scoped_ptr<cc::Animation> CreateCCAnimation() override {
-    scoped_ptr<cc::Animation> animation(
-        cc::Animation::Create(animation_curve_->Clone(), animation_id(),
-                              animation_group_id(), cc::Animation::TRANSFORM));
+    scoped_ptr<cc::Animation> animation(cc::Animation::Create(
+        animation_curve_->Clone(), animation_id(), animation_group_id(),
+        cc::TargetProperty::TRANSFORM));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = computed_target_transform_;
   }
 
  private:
   gfx::Transform ComputeCurrentTransform() const {
     gfx::Transform base_current = gfx::Tween::TransformValueBetween(
@@ skipping 171 matching lines @@
 }
 
 void LayerAnimationElement::RequestEffectiveStart(
     LayerAnimationDelegate* delegate) {
   DCHECK(requested_start_time_ != base::TimeTicks());
   effective_start_time_ = requested_start_time_;
 }
 
 // static
 LayerAnimationElement::AnimatableProperty
-LayerAnimationElement::ToAnimatableProperty(
-    cc::Animation::TargetProperty property) {
+LayerAnimationElement::ToAnimatableProperty(cc::TargetProperty::Type property) {
   switch (property) {
-    case cc::Animation::TRANSFORM:
+    case cc::TargetProperty::TRANSFORM:
       return TRANSFORM;
-    case cc::Animation::OPACITY:
+    case cc::TargetProperty::OPACITY:
       return OPACITY;
     default:
       NOTREACHED();
       return AnimatableProperty();
   }
 }
 
 // static
 base::TimeDelta LayerAnimationElement::GetEffectiveDuration(
     const base::TimeDelta& duration) {
@@ skipping 85 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui