Pass accurate contentsScale to LayerImpl.

cc/damage_tracker.cc

 // 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.
 
 #include "config.h"
 
 #include "cc/damage_tracker.h"
 
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_common.h"
@@ skipping 250 matching lines @@
         // If a layer is new or has changed, then its entire layer rect affects the target surface.
         targetDamageRect.uniteIfNonZero(rectInTargetSpace);
 
         // The layer's old region is now exposed on the target surface, too.
         // Note oldRectInTargetSpace is already in target space.
         targetDamageRect.uniteIfNonZero(oldRectInTargetSpace);
     } else if (!layer->updateRect().isEmpty()) {
         // If the layer properties havent changed, then the the target surface is only
         // affected by the layer's update area, which could be empty.
         FloatRect updateContentRect = layer->updateRect();
-        float widthScale = layer->contentBounds().width() / static_cast<float>(layer->bounds().width());
-        float heightScale = layer->contentBounds().height() / static_cast<float>(layer->bounds().height());
-        updateContentRect.scale(widthScale, heightScale);
+        updateContentRect.scale(layer->contentsScaleX(), layer->contentsScaleY());

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

Can we use Layer::layerRectToContentRect() here? The current code isn't doing
toEnclosingIntRect, but it should be anyhow.

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

Done. However, I'm wondering if enclosingIntRect() is strictly necessary here
because all later calculations are using FloatRect.

[danakj, 2012/10/30 15:56:19]

Right, but part of a pixel can't be invalid, so I think it makes sense to do it
here as well. Thanks for the fixes!

 
         FloatRect updateRectInTargetSpace = MathUtil::mapClippedRect(layer->drawTransform(), updateContentRect);
         targetDamageRect.uniteIfNonZero(updateRectInTargetSpace);
     }
 }
 
 void DamageTracker::extendDamageForRenderSurface(LayerImpl* layer, FloatRect& targetDamageRect)
 {
     // There are two ways a "descendant surface" can damage regions of the "target surface":
     //   1. Property change:
@@ skipping 58 matching lines @@
     // If the layer has a background filter, this may cause pixels in our surface to be expanded, so we will need to expand any damage
     // at or below this layer. We expand the damage from this layer too, as we need to readback those pixels from the surface with only
     // the contents of layers below this one in them. This means we need to redraw any pixels in the surface being used for the blur in
     // this layer this frame.
     if (layer->backgroundFilters().hasFilterThatMovesPixels())
         expandDamageRectInsideRectWithFilters(targetDamageRect, surfaceRectInTargetSpace, layer->backgroundFilters());
 }
 
 }  // namespace cc