cc: Use gfx:: Geometry types for positions, bounds, and related things.

cc/tiled_layer_impl.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_impl.h"
 
 #include "FloatQuad.h"
 #include "base/basictypes.h"
@@ skipping 100 matching lines @@
 DrawableTile* TiledLayerImpl::createTile(int i, int j)
 {
     scoped_ptr<DrawableTile> tile(DrawableTile::create());
     DrawableTile* addedTile = tile.get();
     m_tiler->addTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
     return addedTile;
 }
 
 void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 {
-    const IntRect& contentRect = visibleContentRect();
+    const gfx::Rect& contentRect = visibleContentRect();
 
-    if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.isEmpty())
+    if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.IsEmpty())
         return;
 
     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
     appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 
     int left, top, right, bottom;
     m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
 
     if (hasDebugBorders()) {
         for (int j = top; j <= bottom; ++j) {
             for (int i = left; i <= right; ++i) {
                 DrawableTile* tile = tileAt(i, j);
-                IntRect tileRect = m_tiler->tileBounds(i, j);
+                gfx::Rect tileRect = m_tiler->tileBounds(i, j);
                 SkColor borderColor;
 
                 if (m_skipsDraw || !tile || !tile->resourceId())
                     borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderMissingTileColorRed, debugTileBorderMissingTileColorGreen, debugTileBorderMissingTileColorBlue);
                 else
                     borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderColorRed, debugTileBorderColorGreen, debugTileBorderColorBlue);
                 quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, debugTileBorderWidth).PassAs<DrawQuad>(), appendQuadsData);
             }
         }
     }
 
     if (m_skipsDraw)
         return;
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             DrawableTile* tile = tileAt(i, j);
-            IntRect tileRect = m_tiler->tileBounds(i, j);
-            IntRect displayRect = tileRect;
-            tileRect.intersect(contentRect);
+            gfx::Rect tileRect = m_tiler->tileBounds(i, j);
+            gfx::Rect displayRect = tileRect;
+            tileRect.Intersect(contentRect);
 
             // Skip empty tiles.
-            if (tileRect.isEmpty())
+            if (tileRect.IsEmpty())
                 continue;
 
             if (!tile || !tile->resourceId()) {
                 if (drawCheckerboardForMissingTiles()) {
                     SkColor defaultColor = SkColorSetRGB(defaultCheckerboardColorRed, defaultCheckerboardColorGreen, defaultCheckerboardColorBlue);
                     SkColor evictedColor = SkColorSetRGB(debugTileEvictedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
                     SkColor invalidatedColor = SkColorSetRGB(debugTileInvalidatedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
 
                     SkColor checkerColor;
                     if (hasDebugBorders())
                         checkerColor = tile ? invalidatedColor : evictedColor;
                     else
                         checkerColor = defaultColor;
 
                     appendQuadsData.hadMissingTiles |= quadSink.append(CheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<DrawQuad>(), appendQuadsData);
                 } else
                     appendQuadsData.hadMissingTiles |= quadSink.append(SolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData);
                 continue;
             }
 
-            IntRect tileOpaqueRect = tile->opaqueRect();
-            tileOpaqueRect.intersect(contentRect);
+            gfx::Rect tileOpaqueRect = tile->opaqueRect();
+            tileOpaqueRect.Intersect(contentRect);
 
             // Keep track of how the top left has moved, so the texture can be
             // offset the same amount.
-            IntSize displayOffset = tileRect.minXMinYCorner() - displayRect.minXMinYCorner();
-            IntPoint textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
+            gfx::Vector2d displayOffset = tileRect.origin() - displayRect.origin();
+            gfx::Vector2d textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
             float tileWidth = static_cast<float>(m_tiler->tileSize().width());
             float tileHeight = static_cast<float>(m_tiler->tileSize().height());
-            IntSize textureSize(tileWidth, tileHeight);
+            gfx::Size textureSize(tileWidth, tileHeight);
 
             bool clipped = false;
             FloatQuad visibleContentInTargetQuad = MathUtil::mapQuad(drawTransform(), FloatQuad(visibleContentRect()), clipped);
             bool isAxisAlignedInTarget = !clipped && visibleContentInTargetQuad.isRectilinear();
             bool useAA = m_tiler->hasBorderTexels() && !isAxisAlignedInTarget;
 
             bool leftEdgeAA = !i && useAA;
             bool topEdgeAA = !j && useAA;
             bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
             bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
 
             const GLint textureFilter = m_tiler->hasBorderTexels() ? GL_LINEAR : GL_NEAREST;
             quadSink.append(TileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), textureOffset, textureSize, textureFilter, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<DrawQuad>(), appendQuadsData);
         }
     }
 }
 
 void TiledLayerImpl::setTilingData(const LayerTilingData& tiler)
 {
     if (m_tiler)
         m_tiler->reset();
     else
         m_tiler = LayerTilingData::create(tiler.tileSize(), tiler.hasBorderTexels() ? LayerTilingData::HasBorderTexels : LayerTilingData::NoBorderTexels);
     *m_tiler = tiler;
 }
 
-void TiledLayerImpl::pushTileProperties(int i, int j, ResourceProvider::ResourceId resourceId, const IntRect& opaqueRect, bool contentsSwizzled)
+void TiledLayerImpl::pushTileProperties(int i, int j, ResourceProvider::ResourceId resourceId, const gfx::Rect& opaqueRect, bool contentsSwizzled)
 {
     DrawableTile* tile = tileAt(i, j);
     if (!tile)
         tile = createTile(i, j);
     tile->setResourceId(resourceId);
     tile->setOpaqueRect(opaqueRect);
     tile->setContentsSwizzled(contentsSwizzled);
 }
 
 void TiledLayerImpl::pushInvalidTile(int i, int j)
 {
     DrawableTile* tile = tileAt(i, j);
     if (!tile)
         tile = createTile(i, j);
     tile->setResourceId(0);
-    tile->setOpaqueRect(IntRect());
+    tile->setOpaqueRect(gfx::Rect());
     tile->setContentsSwizzled(false);
 }
 
 Region TiledLayerImpl::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (contentsOpaque())
-        return visibleContentRect();
+        return cc::IntRect(visibleContentRect());
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
 void TiledLayerImpl::didLoseContext()
 {
     m_tiler->reset();
 }
 
 const char* TiledLayerImpl::layerTypeAsString() const
 {
     return "ContentLayer";
 }
 
 } // namespace cc