Pass accurate contentsScale to LayerImpl.

cc/tiled_layer.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/tiled_layer.h"
 
 #include "Region.h"
 #include "base/basictypes.h"
@@ skipping 66 matching lines @@
         , m_updaterResource(updaterResource.Pass())
     {
     }
 
     scoped_ptr<LayerUpdater::Resource> m_updaterResource;
 
     DISALLOW_COPY_AND_ASSIGN(UpdatableTile);
 };
 
 TiledLayer::TiledLayer()
-    : Layer()
+    : ContentsScalingLayer()
     , m_textureFormat(GL_INVALID_ENUM)
     , m_skipsDraw(false)
     , m_failedUpdate(false)
     , m_tilingOption(AutoTile)
 {
     m_tiler = LayerTilingData::create(IntSize(), LayerTilingData::HasBorderTexels);
 }
 
 TiledLayer::~TiledLayer()
 {
@@ skipping 61 matching lines @@
     m_tiler->setTileSize(size);
 }
 
 void TiledLayer::setBorderTexelOption(LayerTilingData::BorderTexelOption borderTexelOption)
 {
     m_tiler->setBorderTexelOption(borderTexelOption);
 }
 
 bool TiledLayer::drawsContent() const
 {
-    if (!Layer::drawsContent())
+    if (!ContentsScalingLayer::drawsContent())
         return false;
 
     bool hasMoreThanOneTile = m_tiler->numTilesX() > 1 || m_tiler->numTilesY() > 1;
     if (m_tilingOption == NeverTile && hasMoreThanOneTile)
         return false;
 
     return true;
 }
 
-bool TiledLayer::needsContentsScale() const
-{
-    return true;
-}
-
-IntSize TiledLayer::contentBounds() const
-{
-    return IntSize(lroundf(bounds().width() * contentsScale()), lroundf(bounds().height() * contentsScale()));
-}
-
 void TiledLayer::setTilingOption(TilingOption tilingOption)
 {
     m_tilingOption = tilingOption;
 }
 
 void TiledLayer::setIsMask(bool isMask)
 {
     setTilingOption(isMask ? NeverTile : AutoTile);
 }
 
 void TiledLayer::pushPropertiesTo(LayerImpl* layer)
 {
-    Layer::pushPropertiesTo(layer);
+    ContentsScalingLayer::pushPropertiesTo(layer);
 
     TiledLayerImpl* tiledLayer = static_cast<TiledLayerImpl*>(layer);
 
     tiledLayer->setSkipsDraw(m_skipsDraw);
     tiledLayer->setTilingData(*m_tiler);
     Vector<UpdatableTile*> invalidTiles;
 
     for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         int i = iter->first.first;
         int j = iter->first.second;
@@ skipping 31 matching lines @@
 {
     if (host && host != layerTreeHost()) {
         for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
             UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             tile->managedTexture()->setTextureManager(host->contentsTextureManager());
         }
     }
-    Layer::setLayerTreeHost(host);
+    ContentsScalingLayer::setLayerTreeHost(host);
 }
 
 UpdatableTile* TiledLayer::tileAt(int i, int j) const
 {
     return static_cast<UpdatableTile*>(m_tiler->tileAt(i, j));
 }
 
 UpdatableTile* TiledLayer::createTile(int i, int j)
 {
     createUpdaterIfNeeded();
@@ skipping 10 matching lines @@
     if (!addedTile)
         CRASH();
     if (!tileAt(i, j))
         CRASH();
 
     return addedTile;
 }
 
 void TiledLayer::setNeedsDisplayRect(const FloatRect& dirtyRect)
 {
-    float contentsWidthScale = static_cast<float>(contentBounds().width()) / bounds().width();
-    float contentsHeightScale = static_cast<float>(contentBounds().height()) / bounds().height();
     FloatRect scaledDirtyRect(dirtyRect);
-    scaledDirtyRect.scale(contentsWidthScale, contentsHeightScale);
+    scaledDirtyRect.scale(contentsScaleX(), contentsScaleY());
     IntRect dirty = enclosingIntRect(scaledDirtyRect);

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

Can you use Layer::layerRectToContentRect() here and anywhere else that we are
doing this conversion in place?

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

Done.

     invalidateContentRect(dirty);
-    Layer::setNeedsDisplayRect(dirtyRect);
+    ContentsScalingLayer::setNeedsDisplayRect(dirtyRect);
 }
 
 void TiledLayer::setUseLCDText(bool useLCDText)
 {
-    Layer::setUseLCDText(useLCDText);
+    ContentsScalingLayer::setUseLCDText(useLCDText);
 
     LayerTilingData::BorderTexelOption borderTexelOption;
 #if OS(ANDROID)
     // Always want border texels and GL_LINEAR due to pinch zoom.
     borderTexelOption = LayerTilingData::HasBorderTexels;
 #else
     borderTexelOption = useLCDText ? LayerTilingData::NoBorderTexels : LayerTilingData::HasBorderTexels;
 #endif
     setBorderTexelOption(borderTexelOption);
 }
@@ skipping 486 matching lines @@
     IntRect prepaintRect = visibleContentRect();
     prepaintRect.inflateX(m_tiler->tileSize().width() * prepaintColumns);
     prepaintRect.inflateY(m_tiler->tileSize().height() * prepaintRows);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }