Pass accurate contentsScale to LayerImpl.

cc/layer.cc

 // Copyright 2010 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 "config.h"
 
 #include "cc/layer.h"
 
 #include "cc/active_animation.h"
 #include "cc/animation_events.h"
@@ skipping 46 matching lines @@
     , m_preserves3D(false)
     , m_useParentBackfaceVisibility(false)
     , m_drawCheckerboardForMissingTiles(false)
     , m_forceRenderSurface(false)
     , m_replicaLayer(0)
     , m_drawOpacity(0)
     , m_drawOpacityIsAnimating(false)
     , m_renderTarget(0)
     , m_drawTransformIsAnimating(false)
     , m_screenSpaceTransformIsAnimating(false)
-    , m_contentsScale(1.0)
     , m_rasterScale(1.0)
     , m_automaticallyComputeRasterScale(false)
     , m_boundsContainPageScale(false)
     , m_layerAnimationDelegate(0)
     , m_layerScrollClient(0)
 {
     if (m_layerId < 0) {
         s_nextLayerId = 1;
         m_layerId = s_nextLayerId++;
     }
@@ skipping 37 matching lines @@
 }
 
 void Layer::setNeedsCommit()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
 IntRect Layer::layerRectToContentRect(const WebKit::WebRect& layerRect)
 {
-    float widthScale = static_cast<float>(contentBounds().width()) / bounds().width();
-    float heightScale = static_cast<float>(contentBounds().height()) / bounds().height();
     FloatRect contentRect(layerRect.x, layerRect.y, layerRect.width, layerRect.height);
-    contentRect.scale(widthScale, heightScale);
+    contentRect.scale(contentsScaleX(), contentsScaleY());
     return enclosingIntRect(contentRect);

[danakj, 2012/10/29 20:06:51]

Since this conversion is not exactly right for images always, we might end up
with a rect 1 pixel outside the area of the image. Can you intersect the result
with the area of the content bounds (ie Rect(Point(), contentBounds())) before
returning? Along with a comment explaining why.

[wangxianzhu, 2012/10/30 02:14:21]

Done.

 }
 
 void Layer::setParent(Layer* layer)
 {
     DCHECK(!layer || !layer->hasAncestor(this));
     m_parent = layer;
     setLayerTreeHost(m_parent ? m_parent->layerTreeHost() : 0);
 
     forceAutomaticRasterScaleToBeRecomputed();
 }
@@ skipping 409 matching lines @@
     m_fixedToContainerLayer = fixedToContainerLayer;
     setNeedsCommit();
 }
 
 void Layer::pushPropertiesTo(LayerImpl* layer)
 {
     layer->setAnchorPoint(m_anchorPoint);
     layer->setAnchorPointZ(m_anchorPointZ);
     layer->setBackgroundColor(m_backgroundColor);
     layer->setBounds(m_bounds);
-    layer->setContentBounds(contentBounds());
+    layer->setContentsScale(contentsScaleX(), contentsScaleY());
     layer->setDebugBorderColor(m_debugBorderColor);
     layer->setDebugBorderWidth(m_debugBorderWidth);
     layer->setDebugName(m_debugName);
     layer->setDoubleSided(m_doubleSided);
     layer->setDrawCheckerboardForMissingTiles(m_drawCheckerboardForMissingTiles);
     layer->setForceRenderSurface(m_forceRenderSurface);
     layer->setDrawsContent(drawsContent());
     layer->setFilters(filters());
     layer->setFilter(filter());
     layer->setBackgroundFilters(backgroundFilters());
@@ skipping 53 matching lines @@
 bool Layer::drawsContent() const
 {
     return m_isDrawable;
 }
 
 bool Layer::needMoreUpdates()
 {
     return false;
 }
 
-bool Layer::needsContentsScale() const
-{
-    return false;
-}
-
 void Layer::setDebugBorderColor(SkColor color)
 {
     m_debugBorderColor = color;
     setNeedsCommit();
 }
 
 void Layer::setDebugBorderWidth(float width)
 {
     m_debugBorderWidth = width;
     setNeedsCommit();
 }
 
 void Layer::setDebugName(const std::string& debugName)
 {
     m_debugName = debugName;
     setNeedsCommit();
 }
 
-void Layer::setContentsScale(float contentsScale)
-{
-    if (!needsContentsScale() || m_contentsScale == contentsScale)
-        return;
-    m_contentsScale = contentsScale;
-
-    setNeedsDisplay();
-}
-
 void Layer::setRasterScale(float scale)
 {
     if (m_rasterScale == scale)
         return;
     m_rasterScale = scale;
 
     if (!m_automaticallyComputeRasterScale)
         return;
     setNeedsDisplay();
 }
@@ skipping 166 matching lines @@
 {
     return 0;
 }
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*)
 {
     // Currently we don't use z-order to decide what to paint, so there's no need to actually sort Layers.
 }
 
 }