Merge ui::Layer's concept of position with cc::Layer's

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 407 matching lines @@
     if (!p->GetTargetTransform().IsIdentity())
       transform->ConcatTransform(p->GetTargetTransform());
     transform->ConcatTransform(translation);
   }
   return p == ancestor;
 }
 
 // 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;
@@ skipping 13 matching lines @@
   // 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());
+  new_layer->SetPosition(cc_layer_->position());
 
   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 118 matching lines @@
 
 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;
   RecomputeCCTransformFromTransform(transform);
   RecomputeDrawsContentAndUVRect();
+  RecomputePosition();
   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);
 }
 
 void Layer::PaintContents(SkCanvas* sk_canvas,
@@ skipping 83 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;
 
-  RecomputeCCTransformFromTransform(transform);
   RecomputeDrawsContentAndUVRect();
+  RecomputePosition();
+
   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.
@@ skipping 162 matching lines @@
     solid_color_layer_ = cc::SolidColorLayer::Create();
     cc_layer_ = solid_color_layer_.get();
   } 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);
+  RecomputePosition();
 }
 
 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.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()) {
@@ skipping 10 matching lines @@
         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));
 }
 
+void Layer::RecomputePosition() {
+  cc_layer_->SetPosition(gfx::ScalePoint(
+        gfx::PointF(bounds_.x(), bounds_.y()),
+        device_scale_factor_));
+}
+
 }  // namespace ui