Pass accurate contentsScale to LayerImpl.

cc/layer_impl.h

 // Copyright 2011 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 CCLayerImpl_h
 #define CCLayerImpl_h
 
 #include "FloatRect.h"
 #include "IntRect.h"
 #include "Region.h"
@@ skipping 149 matching lines @@
 
     float drawOpacity() const { return m_drawOpacity; }
     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
 
     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
 
     LayerImpl* renderTarget() const { DCHECK(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
     void setRenderTarget(LayerImpl* target) { m_renderTarget = target; }
 
+    // The client should be responsible for setting bounds, contentBounds and
+    // contentsScale to appropriate values. LayerImpl doesn't calculate any of
+    // them from the other values.
+
     void setBounds(const IntSize&);
     const IntSize& bounds() const { return m_bounds; }
 
-    const IntSize& contentBounds() const { return m_contentBounds; }
+    // ContentBounds may be [0, 1) pixels larger than bounds * contentsScale.
+    // Don't calculate scale from it. Use contentsScale instead for accuracy.
     void setContentBounds(const IntSize&);
+    IntSize contentBounds() const { return m_contentBounds; }
+
+    float contentsScaleX() const { return m_contentsScaleX; }
+    float contentsScaleY() const { return m_contentsScaleY; }
+    void setContentsScale(float contentsScaleX, float contentsScaleY);
 
     const IntPoint& scrollPosition() const { return m_scrollPosition; }
     void setScrollPosition(const IntPoint&);
 
     const IntSize& maxScrollPosition() const {return m_maxScrollPosition; }
     void setMaxScrollPosition(const IntSize&);
 
     const FloatSize& scrollDelta() const { return m_scrollDelta; }
     void setScrollDelta(const FloatSize&);
 
@@ skipping 68 matching lines @@
     virtual void didLoseContext();
 
     ScrollbarAnimationController* scrollbarAnimationController() const { return m_scrollbarAnimationController.get(); }
 
     ScrollbarLayerImpl* horizontalScrollbarLayer() const;
     void setHorizontalScrollbarLayer(ScrollbarLayerImpl*);
 
     ScrollbarLayerImpl* verticalScrollbarLayer() const;
     void setVerticalScrollbarLayer(ScrollbarLayerImpl*);
 
+    IntRect layerRectToContentRect(const FloatRect& layerRect) const;
+
 protected:
     explicit LayerImpl(int);
 
     void appendDebugBorderQuad(QuadSink&, const SharedQuadState*, AppendQuadsData&) const;
 
-    IntRect layerRectToContentRect(const WebKit::WebRect& layerRect);
-
     virtual void dumpLayerProperties(std::string*, int indent) const;
     static std::string indentString(int indent);
 
 private:
     void setParent(LayerImpl* parent) { m_parent = parent; }
     friend class TreeSynchronizer;
     void clearChildList(); // Warning: This does not preserve tree structure invariants and so is only exposed to the tree synchronizer.
 
     void noteLayerPropertyChangedForSubtree();
 
@@ skipping 13 matching lines @@
     int m_replicaLayerId; // ditto
     scoped_ptr<LayerImpl> m_replicaLayer;
     int m_layerId;
     LayerTreeHostImpl* m_layerTreeHostImpl;
 
     // Properties synchronized from the associated Layer.
     FloatPoint m_anchorPoint;
     float m_anchorPointZ;
     IntSize m_bounds;
     IntSize m_contentBounds;
+    float m_contentsScaleX;
+    float m_contentsScaleY;
     IntPoint m_scrollPosition;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
     Region m_nonFastScrollableRegion;
     SkColor m_backgroundColor;
 
     // Whether the "back" of this layer should draw.
     bool m_doubleSided;
 
@@ skipping 81 matching lines @@
 
     // Manages scrollbars for this layer
     scoped_ptr<ScrollbarAnimationController> m_scrollbarAnimationController;
 };
 
 void sortLayers(std::vector<LayerImpl*>::iterator first, std::vector<LayerImpl*>::iterator end, LayerSorter*);
 
 }
 
 #endif // CCLayerImpl_h