Remove most remaining references to IntRect and FloatRect.

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 130 matching lines @@
 
 void TiledLayer::updateBounds()
 {
     gfx::Size oldBounds = m_tiler->bounds();
     gfx::Size newBounds = contentBounds();
     if (oldBounds == newBounds)
         return;
     m_tiler->setBounds(newBounds);
 
     // Invalidate any areas that the new bounds exposes.
-    Region oldRegion = IntRect(IntPoint(), cc::IntSize(oldBounds));
-    Region newRegion = IntRect(IntPoint(), cc::IntSize(newBounds));
-    newRegion.subtract(oldRegion);
+    Region oldRegion = gfx::Rect(gfx::Point(), oldBounds);
+    Region newRegion = gfx::Rect(gfx::Point(), newBounds);
+    newRegion.Subtract(oldRegion);
     Vector<WebCore::IntRect> rects = newRegion.rects();
     for (size_t i = 0; i < rects.size(); ++i)
         invalidateContentRect(cc::IntRect(rects[i]));
 }
 
 void TiledLayer::setTileSize(const gfx::Size& size)
 {
     m_tiler->setTileSize(size);
 }
 
@@ skipping 158 matching lines @@
 
     bool ignoreOcclusions = !occlusion;
     if (!haveTexturesForTiles(left, top, right, bottom, ignoreOcclusions)) {
         m_failedUpdate = true;
         return false;
     }
 
     gfx::Rect paintRect = markTilesForUpdate(left, top, right, bottom, ignoreOcclusions);
 
     if (occlusion)
-        occlusion->overdrawMetrics().didPaint(cc::IntRect(paintRect));
+        occlusion->overdrawMetrics().didPaint(paintRect);
 
     if (paintRect.IsEmpty())
         return true;
 
     didPaint = true;
     updateTileTextures(paintRect, left, top, right, bottom, queue, occlusion, stats);
     return true;
 }
 
 void TiledLayer::markOcclusionsAndRequestTextures(int left, int top, int right, int bottom, const OcclusionTracker* occlusion)
@@ skipping 160 matching lines @@
                 CRASH();
             if (paintOffset.y() < 0)
                 CRASH();
             if (paintOffset.x() + sourceRect.width() > paintRect.width())
                 CRASH();
             if (paintOffset.y() + sourceRect.height() > paintRect.height())
                 CRASH();
 
             tile->updaterResource()->update(queue, sourceRect, destOffset, tile->partialUpdate, stats);
             if (occlusion)
-                occlusion->overdrawMetrics().didUpload(WebTransformationMatrix(), cc::IntRect(sourceRect), cc::IntRect(tile->opaqueRect()));
+                occlusion->overdrawMetrics().didUpload(WebTransformationMatrix(), sourceRect, tile->opaqueRect());
 
         }
     }
 }
 
 namespace {
 // This picks a small animated layer to be anything less than one viewport. This
 // is specifically for page transitions which are viewport-sized layers. The extra
 // 64 pixels is due to these layers being slightly larger than the viewport in some cases.
 bool isSmallAnimatedLayer(TiledLayer* layer)
@@ skipping 61 matching lines @@
         gfx::Rect tileRect = m_tiler->tileRect(tile);
         setPriorityForTexture(m_predictedVisibleRect, tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
     }
 }
 
 Region TiledLayer::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (contentsOpaque())
-        return cc::IntRect(visibleContentRect());
+        return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
 void TiledLayer::resetUpdateState()
 {
     m_skipsDraw = false;
     m_failedUpdate = false;
 
     LayerTilingData::TileMap::const_iterator end = m_tiler->tiles().end();
     for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != end; ++iter) {
@@ skipping 172 matching lines @@
     gfx::Rect prepaintRect = visibleContentRect();
     prepaintRect.Inset(-m_tiler->tileSize().width() * prepaintColumns,
                        -m_tiler->tileSize().height() * prepaintRows);
     gfx::Rect contentRect(gfx::Point(), contentBounds());
     prepaintRect.Intersect(contentRect);
 
     return prepaintRect;
 }
 
 }