Make ui::Layer use the cc:LayerTreeHost scale factor directly

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 431 matching lines @@
   ThreadedTransformTransition(const gfx::Transform& target,
                               base::TimeDelta 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);
-    cc_target_ = Layer::ConvertTransformToCCTransform(target_,
-                                                      device_scale_factor);
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
       delegate->SetTransformFromAnimation(gfx::Tween::TransformValueBetween(
           gfx::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_,
+                                           start_,
+                                           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:
   gfx::Transform start_;
-  gfx::Transform cc_start_;
   const gfx::Transform target_;
-  gfx::Transform cc_target_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedTransformTransition);
 };
 
 // InverseTransformTransision --------------------------------------------------
 
 class InverseTransformTransition : public ThreadedLayerAnimationElement {
  public:
   InverseTransformTransition(const gfx::Transform& base_transform,
                              const LayerAnimationElement* uninverted_transition)
@@ skipping 16 matching lines @@
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     gfx::Transform start(delegate->GetTransformForAnimation());
     effective_start_ = base_transform_ * start;
 
     TargetValue target;
     uninverted_transition_->GetTargetValue(&target);
     base_target_ = target.transform;
 
     set_tween_type(uninverted_transition_->tween_type());
 
-    float device_scale_factor = delegate->GetDeviceScaleFactor();
-    const gfx::Transform cc_base_start = Layer::ConvertTransformToCCTransform(
-        base_transform_,
-        device_scale_factor);
-    const gfx::Transform cc_base_target = Layer::ConvertTransformToCCTransform(
-        base_target_,
-        device_scale_factor);
     TransformAnimationCurveAdapter base_curve(tween_type(),
-                                              cc_base_start,
-                                              cc_base_target,
+                                              base_transform_,
+                                              base_target_,
                                               duration());
 
-    const gfx::Transform cc_start = Layer::ConvertTransformToCCTransform(
-        start, device_scale_factor);
     animation_curve_.reset(new InverseTransformCurveAdapter(
-        base_curve, cc_start, duration()));
+        base_curve, start, duration()));
     computed_target_transform_ = ComputeWithBaseTransform(effective_start_,
                                                           base_target_);
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
       delegate->SetTransformFromAnimation(ComputeCurrentTransform());
     }
   }
@@ skipping 301 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui