Thread ui transform animations

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.h"
 #include "cc/animation_id_provider.h"
 #include "ui/base/animation/tween.h"
 #include "ui/compositor/float_animation_curve_adapter.h"
+#include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
+#include "ui/compositor/transform_animation_curve_adapter.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace ui {
 
 namespace {
 
 // 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;
@@ skipping 461 matching lines @@
     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),
+        target_(target) {
+  }
+  virtual ~ThreadedTransformTransition() {}
+
+ protected:
+  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+    gfx::Transform start_ = delegate->GetTransformForAnimation();
+    gfx::Rect bounds = delegate->GetBoundsForAnimation();
+    float device_scale_factor = delegate->GetDeviceScaleFactor();
+    cc_start_ = Layer::ConvertTransformToCCTransform(start_,
+                                                     bounds,
+                                                     device_scale_factor);
+    cc_target_ = Layer::ConvertTransformToCCTransform(target_,
+                                                      bounds,
+                                                      device_scale_factor);
+  }
+
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
+    if (delegate && animation_id()) {
+      ThreadedLayerAnimationElement::OnAbort(delegate);
+      delegate->SetTransformFromAnimation(Tween::ValueBetween(
+          Tween::CalculateValue(tween_type(), last_progressed_fraction()),
+          start_,
+          target_));
+    }
+  }
+
+  virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
+    delegate->SetTransformFromAnimation(target_);
+  }
+
+  virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
+    scoped_ptr<cc::AnimationCurve> animation_curve(
+        new TransformAnimationCurveAdapter(tween_type(),
+                                           cc_start_,
+                                           cc_target_,
+                                           duration()));
+    scoped_ptr<cc::Animation> animation(
+        cc::Animation::Create(animation_curve.Pass(),
+                              animation_id(),
+                              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);
+};
+
 }  // namespace
 
 // LayerAnimationElement::TargetValue ------------------------------------------
 
 LayerAnimationElement::TargetValue::TargetValue()
     : opacity(0.0f),
       visibility(false),
       brightness(0.0f),
       grayscale(0.0f),
       color(SK_ColorBLACK) {
@@ skipping 141 matching lines @@
     default:
       NOTREACHED();
       return base::TimeDelta();
   }
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
     const gfx::Transform& transform,
     base::TimeDelta duration) {
-  return new TransformTransition(transform, duration);
+  return new ThreadedTransformTransition(transform, duration);
 }
 
 // static
 LayerAnimationElement*
 LayerAnimationElement::CreateInterpolatedTransformElement(
     InterpolatedTransform* interpolated_transform,
     base::TimeDelta duration) {
   return new InterpolatedTransformTransition(interpolated_transform, duration);
 }
 
@@ skipping 40 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui