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

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 56 matching lines @@
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
-      scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       fills_bounds_completely_(false),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
-      scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::~Layer() {
   // Destroying the animator may cause observers to use the layer (and
   // indirectly the WebLayer). Destroy the animator first so that the WebLayer
   // is still around.
   if (animator_.get())
     animator_->SetDelegate(NULL);
@@ skipping 322 matching lines @@
                           static_cast<float>(p->bounds().y()));
     // Use target transform so that result will be correct once animation is
     // finished.
     if (!p->GetTargetTransform().IsIdentity())
       transform->ConcatTransform(p->GetTargetTransform());
     transform->ConcatTransform(translation);
   }
   return p == ancestor;
 }
 
-// static
-gfx::Transform Layer::ConvertTransformToCCTransform(
-    const gfx::Transform& transform,
-    float device_scale_factor) {
-  gfx::Transform cc_transform;
-  cc_transform.Scale(device_scale_factor, device_scale_factor);
-  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::SetFillsBoundsCompletely(bool fills_bounds_completely) {
@@ skipping 138 matching lines @@
 
 void Layer::SendDamagedRects() {
   if ((delegate_ || mailbox_.IsValid()) && !damaged_region_.isEmpty()) {
     for (SkRegion::Iterator iter(damaged_region_); !iter.done(); iter.next()) {
       const SkIRect& sk_damaged = iter.rect();
       gfx::Rect damaged(
           sk_damaged.x(),
           sk_damaged.y(),
           sk_damaged.width(),
           sk_damaged.height());
-
-      gfx::Rect damaged_in_pixel = ConvertRectToPixel(this, damaged);
-      cc_layer_->SetNeedsDisplayRect(damaged_in_pixel);
+      cc_layer_->SetNeedsDisplayRect(damaged);
     }
     damaged_region_.setEmpty();
   }
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SendDamagedRects();
 }
 
 void Layer::SuppressPaint() {
   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_.get())
     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::RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request) {
   cc_layer_->RequestCopyOfOutput(request.Pass());
 }
 
 void Layer::PaintContents(SkCanvas* sk_canvas,
                           const gfx::Rect& clip,
                           gfx::RectF* opaque,
                           ContentLayerClient::GraphicsContextStatus gc_status) {
   TRACE_EVENT0("ui", "Layer::PaintContents");
   scoped_ptr<gfx::Canvas> canvas(gfx::Canvas::CreateCanvasWithoutScaling(
       sk_canvas, device_scale_factor_));
-
-  bool scale_content = scale_content_;
-  if (scale_content) {
-    canvas->Save();
-    canvas->sk_canvas()->scale(SkFloatToScalar(device_scale_factor_),
-                               SkFloatToScalar(device_scale_factor_));
-  }
-
   if (delegate_)
     delegate_->OnPaintLayer(canvas.get());
-  if (scale_content)
-    canvas->Restore();
 }
 
 bool Layer::FillsBoundsCompletely() const { return fills_bounds_completely_; }
 
 bool Layer::PrepareTextureMailbox(
     cc::TextureMailbox* mailbox,
     scoped_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!mailbox_release_callback_)
     return false;
@@ skipping 97 matching lines @@
     // 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::SetTransformFromAnimation(const gfx::Transform& transform) {
-  RecomputeCCTransformFromTransform(transform);
+  cc_layer_->SetTransform(transform);
 }
 
 void Layer::SetOpacityFromAnimation(float opacity) {
   cc_layer_->SetOpacity(opacity);
   ScheduleDraw();
 }
 
 void Layer::SetVisibilityFromAnimation(bool visible) {
   if (visible_ == visible)
     return;
@@ skipping 124 matching lines @@
     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);
   cc_layer_->SetLayerClient(this);
   RecomputePosition();
 }
 
-void Layer::RecomputeCCTransformFromTransform(const gfx::Transform& transform) {
-  cc_layer_->SetTransform(ConvertTransformToCCTransform(transform,
-                                                        device_scale_factor_));
-}
-
 gfx::Transform Layer::transform() const {
-  gfx::Transform transform;
-  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;
+  return cc_layer_->transform();
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
   gfx::Size size(bounds_.size());
   if (texture_layer_.get()) {
     size.SetToMin(frame_size_in_dip_);
     gfx::PointF uv_top_left(0.f, 0.f);
     gfx::PointF uv_bottom_right(
         static_cast<float>(size.width()) / frame_size_in_dip_.width(),
         static_cast<float>(size.height()) / frame_size_in_dip_.height());
     texture_layer_->SetUV(uv_top_left, uv_bottom_right);
   } else if (delegated_renderer_layer_.get()) {
     size.SetToMin(frame_size_in_dip_);
-    delegated_renderer_layer_->SetDisplaySize(
-        ConvertSizeToPixel(this, frame_size_in_dip_));
+    delegated_renderer_layer_->SetDisplaySize(frame_size_in_dip_);
   }
-  cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
+  cc_layer_->SetBounds(size);
 }
 
 void Layer::RecomputePosition() {
-  cc_layer_->SetPosition(gfx::ScalePoint(
-        gfx::PointF(bounds_.x(), bounds_.y()),
-        device_scale_factor_));
+  cc_layer_->SetPosition(gfx::PointF(bounds_.x(), bounds_.y()));
 }
 
 }  // namespace ui