Thread ui transform animations

ui/compositor/layer.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.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 190 matching lines @@
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   GetAnimator()->SetTransform(transform);
 }
 
 gfx::Transform Layer::GetTargetTransform() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::TRANSFORM)) {
     return animator_->GetTargetTransform();
   }
-  return transform_;
+  return transform();
 }
 
 void Layer::SetBounds(const gfx::Rect& bounds) {
   GetAnimator()->SetBounds(bounds);
 }
 
 gfx::Rect Layer::GetTargetBounds() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::BOUNDS)) {
     return animator_->GetTargetBounds();
@@ skipping 189 matching lines @@
 
   const Layer* root_layer = GetRoot(source);
   CHECK_EQ(root_layer, GetRoot(target));
 
   if (source != root_layer)
     source->ConvertPointForAncestor(root_layer, point);
   if (target != root_layer)
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
+// static
+gfx::Transform Layer::ConvertTransformToCCTransform(
+    const gfx::Transform& transform,
+    const gfx::Rect& bounds,
+    float device_scale_factor) {
+  gfx::Transform cc_transform;
+  cc_transform.Scale(device_scale_factor, device_scale_factor);
+  cc_transform.Translate(bounds.x(), bounds.y());
+  cc_transform.PreconcatTransform(transform);
+  cc_transform.Scale(1.0f / device_scale_factor, 1.0f / device_scale_factor);
+  return cc_transform;
+}
+
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
   cc_layer_->SetContentsOpaque(fills_bounds_opaquely);
 }
 
 void Layer::SwitchToLayer(scoped_refptr<cc::Layer> new_layer) {
   if (texture_layer_.get())
     texture_layer_->willModifyTexture();
   // TODO(piman): delegated_renderer_layer_ cleanup.
 
   cc_layer_->RemoveAllChildren();
   if (parent_) {
     DCHECK(parent_->cc_layer_);
     parent_->cc_layer_->ReplaceChild(cc_layer_, new_layer);
   }
   cc_layer_->RemoveLayerAnimationEventObserver(this);
   new_layer->SetOpacity(cc_layer_->opacity());
+  new_layer->SetTransform(cc_layer_->transform());
 
   cc_layer_= new_layer;
   content_layer_ = NULL;
   solid_color_layer_ = NULL;
   texture_layer_ = NULL;
   delegated_renderer_layer_ = NULL;
 
   cc_layer_->AddLayerAnimationEventObserver(this);
   for (size_t i = 0; i < children_.size(); ++i) {
     DCHECK(children_[i]->cc_layer_);
@@ skipping 18 matching lines @@
           cc::TextureLayer::Create(this);
       new_layer->setFlipped(texture_->flipped());
       SwitchToLayer(new_layer);
       texture_layer_ = new_layer;
     } else {
       scoped_refptr<cc::ContentLayer> new_layer =
           cc::ContentLayer::Create(this);
       SwitchToLayer(new_layer);
       content_layer_ = new_layer;
     }
-    RecomputeTransform();
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame,
                               gfx::Size frame_size_in_dip) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   bool has_frame = frame.get() && !frame->render_pass_list.empty();
   layer_updated_externally_ = has_frame;
   delegated_frame_size_in_dip_ = frame_size_in_dip;
   if (!!delegated_renderer_layer_ != has_frame) {
     if (has_frame) {
       scoped_refptr<cc::DelegatedRendererLayer> new_layer =
           cc::DelegatedRendererLayer::Create();
       SwitchToLayer(new_layer);
       delegated_renderer_layer_ = new_layer;
     } else {
       scoped_refptr<cc::ContentLayer> new_layer =
           cc::ContentLayer::Create(this);
       SwitchToLayer(new_layer);
       content_layer_ = new_layer;
     }
-    RecomputeTransform();
   }
   if (has_frame)
     delegated_renderer_layer_->SetFrameData(frame.Pass());
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::TakeUnusedResourcesForChildCompositor(
     cc::TransferableResourceArray* list) {
   if (delegated_renderer_layer_)
     delegated_renderer_layer_->TakeUnusedResourcesForChildCompositor(list);
@@ skipping 46 matching lines @@
   if (!delegate_)
     return;
   delegate_ = NULL;
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SuppressPaint();
 }
 
 void Layer::OnDeviceScaleFactorChanged(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
+  if (animator_)
+    animator_->StopAnimatingProperty(LayerAnimationElement::TRANSFORM);
+  gfx::Transform transform = this->transform();
   device_scale_factor_ = device_scale_factor;
-  RecomputeTransform();
+  RecomputeCCTransformFromTransform(transform);
   RecomputeDrawsContentAndUVRect();
   SchedulePaint(gfx::Rect(bounds_.size()));
   if (delegate_)
     delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->OnDeviceScaleFactorChanged(device_scale_factor);
   if (layer_mask_)
     layer_mask_->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
@@ skipping 100 matching lines @@
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   if (bounds == bounds_)
     return;
 
   base::Closure closure;
   if (delegate_)
     closure = delegate_->PrepareForLayerBoundsChange();
   bool was_move = bounds_.size() == bounds.size();
+  gfx::Transform transform = this->transform();
   bounds_ = bounds;
 
-  RecomputeTransform();
+  RecomputeCCTransformFromTransform(transform);
   RecomputeDrawsContentAndUVRect();
   if (!closure.is_null())
     closure.Run();
 
   if (was_move) {
     // Don't schedule a draw if we're invisible. We'll schedule one
     // automatically when we get visible.
     if (IsDrawn())
       ScheduleDraw();
   } else {
     // Always schedule a paint, even if we're invisible.
     SchedulePaint(gfx::Rect(bounds.size()));
   }
 }
 
 void Layer::SetTransformImmediately(const gfx::Transform& transform) {
-  transform_ = transform;
-
-  RecomputeTransform();
+  RecomputeCCTransformFromTransform(transform);
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
   cc_layer_->SetOpacity(opacity);
   ScheduleDraw();
 }
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
@@ skipping 48 matching lines @@
 }
 
 void Layer::ScheduleDrawForAnimation() {
   ScheduleDraw();
 }
 
 const gfx::Rect& Layer::GetBoundsForAnimation() const {
   return bounds();
 }
 
-const gfx::Transform& Layer::GetTransformForAnimation() const {
+gfx::Transform Layer::GetTransformForAnimation() const {
   return transform();
 }
 
 float Layer::GetOpacityForAnimation() const {
   return opacity();
 }
 
 bool Layer::GetVisibilityForAnimation() const {
   return visible();
 }
 
 float Layer::GetBrightnessForAnimation() const {
   return layer_brightness();
 }
 
 float Layer::GetGrayscaleForAnimation() const {
   return layer_grayscale();
 }
 
 SkColor Layer::GetColorForAnimation() const {
   // WebColor is equivalent to SkColor, per WebColor.h.
   // The NULL check is here since this is invoked regardless of whether we have
   // been configured as LAYER_SOLID_COLOR.
   return solid_color_layer_.get() ?
       solid_color_layer_->background_color() : SK_ColorBLACK;
 }
 
+float Layer::GetDeviceScaleFactor() const {
+  return device_scale_factor_;
+}
+
 void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
   DCHECK(cc_layer_);
   // Until this layer has a compositor (and hence cc_layer_ has a
   // LayerTreeHost), addAnimation will fail.
   if (GetCompositor())
     cc_layer_->AddAnimation(animation.Pass());
   else
     pending_threaded_animations_.push_back(animation.Pass());
 }
 
@@ skipping 48 matching lines @@
   } else {
     content_layer_ = cc::ContentLayer::Create(this);
     cc_layer_ = content_layer_.get();
   }
   cc_layer_->SetAnchorPoint(gfx::PointF());
   cc_layer_->SetContentsOpaque(true);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
   cc_layer_->AddLayerAnimationEventObserver(this);
 }
 
-void Layer::RecomputeTransform() {
-  gfx::Transform scale_translate;
-  scale_translate.matrix().set3x3(device_scale_factor_, 0, 0,
-                                  0, device_scale_factor_, 0,
-                                  0, 0, 1);
-  // Start with the inverse matrix of above.
+void Layer::RecomputeCCTransformFromTransform(const gfx::Transform& transform) {
+  cc_layer_->SetTransform(ConvertTransformToCCTransform(transform,
+                                                        bounds_,
+                                                        device_scale_factor_));
+}
+
+gfx::Transform Layer::transform() const {
   gfx::Transform transform;
-  transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0,
-                            0, 1.0f / device_scale_factor_, 0,
-                            0, 0, 1);
-  transform.ConcatTransform(transform_);
-  gfx::Transform translate;
-  translate.Translate(bounds_.x(), bounds_.y());
-  transform.ConcatTransform(translate);
-  transform.ConcatTransform(scale_translate);
-  cc_layer_->SetTransform(transform);
+  transform.Translate(-bounds_.x(), -bounds_.y());
+  transform.Scale(1.0f / device_scale_factor_, 1.0f / device_scale_factor_);
+  transform.PreconcatTransform(cc_layer_->transform());
+  transform.Scale(device_scale_factor_, device_scale_factor_);
+  return transform;
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
   gfx::Size size(bounds_.size());
   if (texture_layer_.get()) {
     DCHECK(texture_);
 
     float texture_scale_factor = 1.0f / texture_->device_scale_factor();
     gfx::Size texture_size = gfx::ToFlooredSize(
         gfx::ScaleSize(texture_->size(), texture_scale_factor));
     size.ClampToMax(texture_size);
 
     gfx::PointF uv_top_left(0.f, 0.f);
     gfx::PointF uv_bottom_right(
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUV(uv_top_left, uv_bottom_right);
   } else if (delegated_renderer_layer_.get()) {
     delegated_renderer_layer_->SetDisplaySize(
         ConvertSizeToPixel(this, delegated_frame_size_in_dip_));
     size.ClampToMax(delegated_frame_size_in_dip_);
   }
   cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
 }
 
 }  // namespace ui