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 35 matching lines @@
     if (host && m_layerAnimationController->hasActiveAnimation())
         host->didAddAnimation();
 }
 
 void Layer::setNeedsCommit()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
-IntRect Layer::layerRectToContentRect(const WebKit::WebRect& layerRect)
+IntRect Layer::layerRectToContentRect(const FloatRect& layerRect) const
 {
-    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);
-    return enclosingIntRect(contentRect);
+    FloatRect contentRect(layerRect);
+    contentRect.scale(contentsScaleX(), contentsScaleY());
+    IntRect intContentRect = enclosingIntRect(contentRect);
+    // Intersect with content rect to avoid the extra pixel because for some
+    // values x and y, ceil((x / y) * y) may be x + 1.
+    intContentRect.intersect(IntRect(IntPoint(), contentBounds()));
+    return intContentRect;
 }
 
 void Layer::setParent(Layer* layer)
 {
     DCHECK(!layer || !layer->hasAncestor(this));
     m_parent = layer;
     setLayerTreeHost(m_parent ? m_parent->layerTreeHost() : 0);
 
     forceAutomaticRasterScaleToBeRecomputed();
 }
@@ skipping 410 matching lines @@
     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)
+float Layer::contentsScaleX() const
 {
-    if (!needsContentsScale() || m_contentsScale == contentsScale)
-        return;
-    m_contentsScale = contentsScale;
+    return 1.0;
+}
 
-    setNeedsDisplay();
+float Layer::contentsScaleY() const
+{
+    return 1.0;
 }
 
 void Layer::setRasterScale(float scale)
 {
     if (m_rasterScale == scale)
         return;
     m_rasterScale = scale;
 
     if (!m_automaticallyComputeRasterScale)
         return;
@@ skipping 168 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.
 }
 
 }