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

ui/compositor/layer.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_H_
 #define UI_COMPOSITOR_LAYER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 223 matching lines @@
   static void ConvertPointToLayer(const Layer* source,
                                   const Layer* target,
                                   gfx::Point* point);
 
   // Converts a transform to be relative to the given |ancestor|. Returns
   // whether success (that is, whether the given ancestor was really an
   // ancestor of this layer).
   bool GetTargetTransformRelativeTo(const Layer* ancestor,
                                     gfx::Transform* transform) const;
 
-  // Converts a ui::Layer's transform to the transform on the corresponding
-  // cc::Layer.
-  static gfx::Transform ConvertTransformToCCTransform(
-      const gfx::Transform& transform,
-      float device_scale_factor);
-
   // See description in View for details
   void SetFillsBoundsOpaquely(bool fills_bounds_opaquely);
   bool fills_bounds_opaquely() const { return fills_bounds_opaquely_; }
 
   // Set to true if this layer always paints completely within its bounds. If so
   // we can omit an unnecessary clear, even if the layer is transparent.
   void SetFillsBoundsCompletely(bool fills_bounds_completely);
 
   const std::string& name() const { return name_; }
   void set_name(const std::string& name) { name_ = name; }
@@ skipping 32 matching lines @@
   void SendDamagedRects();
 
   const SkRegion& damaged_region() const { return damaged_region_; }
 
   // Suppresses painting the content by disconnecting |delegate_|.
   void SuppressPaint();
 
   // Notifies the layer that the device scale factor has changed.
   void OnDeviceScaleFactorChanged(float device_scale_factor);
 
-  // Sets whether the layer should scale its content. If true, the canvas will
-  // be scaled in software rendering mode before it is passed to
-  // |LayerDelegate::OnPaintLayer|.
-  // Set to false if the delegate handles scaling.
-  // NOTE: if this is called during |LayerDelegate::OnPaint|, the new value will
-  // not apply to the canvas passed to the pending draw.
-  void set_scale_content(bool scale_content) { scale_content_ = scale_content; }
-
-  // Returns true if the layer scales its content.
-  bool scale_content() const { return scale_content_; }
-
   // Requets a copy of the layer's output as a texture or bitmap.
   void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
 
   // ContentLayerClient
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
       gfx::RectF* opaque,
       ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE;
   virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
@@ skipping 58 matching lines @@
   virtual SkColor GetColorForAnimation() const OVERRIDE;
   virtual float GetDeviceScaleFactor() const OVERRIDE;
   virtual void AddThreadedAnimation(
       scoped_ptr<cc::Animation> animation) OVERRIDE;
   virtual void RemoveThreadedAnimation(int animation_id) OVERRIDE;
 
   // Creates a corresponding composited layer for |type_|.
   void CreateWebLayer();
 
   // Recomputes and sets to |cc_layer_|.
-  void RecomputeCCTransformFromTransform(const gfx::Transform& transform);
   void RecomputeDrawsContentAndUVRect();
   void RecomputePosition();
 
   // Set all filters which got applied to the layer.
   void SetLayerFilters();
 
   // Set all filters which got applied to the layer background.
   void SetLayerBackgroundFilters();
 
   // Cleanup |cc_layer_| and replaces it with |new_layer|.
@@ skipping 67 matching lines @@
   cc::ScopedPtrVector<cc::Animation> pending_threaded_animations_;
 
   // Ownership of the layer is held through one of the strongly typed layer
   // pointers, depending on which sort of layer this is.
   scoped_refptr<cc::Layer> content_layer_;
   scoped_refptr<cc::TextureLayer> texture_layer_;
   scoped_refptr<cc::SolidColorLayer> solid_color_layer_;
   scoped_refptr<cc::DelegatedRendererLayer> delegated_renderer_layer_;
   cc::Layer* cc_layer_;
 
-  // If true, the layer scales the canvas and the texture with the device scale
-  // factor as apporpriate. When true, the texture size is in DIP.
-  bool scale_content_;
-
   // A cached copy of |Compositor::device_scale_factor()|.
   float device_scale_factor_;
 
   // The mailbox used by texture_layer_.
   cc::TextureMailbox mailbox_;
 
   // The callback to release the mailbox. This is only set after
   // SetTextureMailbox is called, before we give it to the TextureLayer.
   scoped_ptr<cc::SingleReleaseCallback> mailbox_release_callback_;
 
   // The size of the frame or texture in DIP, set when SetShowDelegatedContent
   // or SetTextureMailbox was called.
   gfx::Size frame_size_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_