Remove most remaining references to IntRect and FloatRect.

cc/tiled_layer_unittest.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 "cc/bitmap_content_layer_updater.h"
 #include "cc/layer_painter.h"
@@ skipping 208 matching lines @@
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // Invalidates part of the top tile...
     layer->invalidateContentRect(gfx::Rect(0, 0, 50, 50));
     // ....but the area is occluded.
-    occluded.setOcclusion(cc::IntRect(0, 0, 50, 50));
+    occluded.setOcclusion(gfx::Rect(0, 0, 50, 50));
     updateAndPush(layer.get(), layerImpl.get());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000 + 2500, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // We should still have both tiles, as part of the top tile is still unoccluded.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
@@ skipping 196 matching lines @@
 }
 
 TEST_F(TiledLayerTest, pushIdlePaintedOccludedTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_textureManager.get()));
     ScopedFakeTiledLayerImpl layerImpl(1);
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
     
     // The tile size is 100x100, so this invalidates one occluded tile, culls it during paint, but prepaints it.
-    occluded.setOcclusion(cc::IntRect(0, 0, 100, 100));
+    occluded.setOcclusion(gfx::Rect(0, 0, 100, 100));
 
     layer->setBounds(gfx::Size(100, 100));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 100, 100));
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should have the prepainted tile on the impl side, but culled it during paint.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_EQ(1, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
@@ skipping 421 matching lines @@
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_textureManager.get()));
     TestOcclusionTracker occluded;
 
     // The tile size is 100x100.
 
     layer->setBounds(gfx::Size(600, 600));
 
-    occluded.setOcclusion(cc::IntRect(200, 200, 300, 100));
+    occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->setDrawableContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
     layer->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
     EXPECT_EQ(3, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
 
-    occluded.setOcclusion(cc::IntRect(250, 200, 300, 100));
+    occluded.setOcclusion(gfx::Rect(250, 200, 300, 100));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36-2, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000 + 340000, 1);
     EXPECT_EQ(3 + 2, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
 
-    occluded.setOcclusion(cc::IntRect(250, 250, 300, 100));
+    occluded.setOcclusion(gfx::Rect(250, 250, 300, 100));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000 + 340000 + 360000, 1);
     EXPECT_EQ(3 + 2, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_textureManager.get()));
     TestOcclusionTracker occluded;
 
     // The tile size is 100x100.
 
     layer->setBounds(gfx::Size(600, 600));
 
     // The partially occluded tiles (by the 150 occlusion height) are visible beyond the occlusion, so not culled.
-    occluded.setOcclusion(cc::IntRect(200, 200, 300, 150));
+    occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->setDrawableContentRect(gfx::Rect(0, 0, 600, 360));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 600, 360));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(24-3, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 210000, 1);
     EXPECT_EQ(3, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // Now the visible region stops at the edge of the occlusion so the partly visible tiles become fully occluded.
-    occluded.setOcclusion(cc::IntRect(200, 200, 300, 150));
+    occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->setDrawableContentRect(gfx::Rect(0, 0, 600, 350));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 600, 350));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(24-6, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 210000 + 180000, 1);
     EXPECT_EQ(3 + 6, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // Now the visible region is even smaller than the occlusion, it should have the same result.
-    occluded.setOcclusion(cc::IntRect(200, 200, 300, 150));
+    occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->setDrawableContentRect(gfx::Rect(0, 0, 600, 340));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 600, 340));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(24-6, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 210000 + 180000 + 180000, 1);
     EXPECT_EQ(3 + 6 + 6, occluded.overdrawMetrics().tilesCulledForUpload());
 
 }
 
 TEST_F(TiledLayerTest, tilesNotPaintedWithoutInvalidation)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_textureManager.get()));
     TestOcclusionTracker occluded;
 
     // The tile size is 100x100.
 
     layer->setBounds(gfx::Size(600, 600));
 
-    occluded.setOcclusion(cc::IntRect(200, 200, 300, 100));
+    occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->setDrawableContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 600, 600));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
     {
         updateTextures();
     }
@@ skipping 23 matching lines @@
     // The tile size is 100x100.
 
     // This makes sure the painting works when the occluded region (in screen space)
     // is transformed differently than the layer.
     layer->setBounds(gfx::Size(600, 600));
     WebTransformationMatrix screenTransform;
     screenTransform.scale(0.5);
     layer->setScreenSpaceTransform(screenTransform);
     layer->setDrawTransform(screenTransform);
 
-    occluded.setOcclusion(cc::IntRect(100, 100, 150, 50));
+    occluded.setOcclusion(gfx::Rect(100, 100, 150, 50));
     layer->setDrawableContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
     layer->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
@@ skipping 11 matching lines @@
     // a different layer space. In this case tiles are scaled to be 200x200
     // pixels, which means none should be occluded.
     layer->setContentsScale(0.5);
     EXPECT_FLOAT_EQ(layer->contentsScaleX(), layer->contentsScaleY());
     layer->setBounds(gfx::Size(600, 600));
     WebTransformationMatrix drawTransform;
     drawTransform.scale(1 / layer->contentsScaleX());
     layer->setDrawTransform(drawTransform);
     layer->setScreenSpaceTransform(drawTransform);
 
-    occluded.setOcclusion(cc::IntRect(200, 200, 300, 100));
+    occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->setDrawableContentRect(gfx::Rect(gfx::Point(), layer->bounds()));
     layer->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     // The content is half the size of the layer (so the number of tiles is fewer).
     // In this case, the content is 300x300, and since the tile size is 100, the
     // number of tiles 3x3.
     EXPECT_EQ(9, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 90000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // This makes sure the painting works when the content space is scaled to
     // a different layer space. In this case the occluded region catches the
     // blown up tiles.
-    occluded.setOcclusion(cc::IntRect(200, 200, 300, 200));
+    occluded.setOcclusion(gfx::Rect(200, 200, 300, 200));
     layer->setDrawableContentRect(gfx::Rect(gfx::Point(), layer->bounds()));
     layer->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(9-1, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 90000 + 80000, 1);
     EXPECT_EQ(1, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // This makes sure content scaling and transforms work together.
     WebTransformationMatrix screenTransform;
     screenTransform.scale(0.5);
     layer->setScreenSpaceTransform(screenTransform);
     layer->setDrawTransform(screenTransform);
 
-    occluded.setOcclusion(cc::IntRect(100, 100, 150, 100));
+    occluded.setOcclusion(gfx::Rect(100, 100, 150, 100));
 
     gfx::Rect layerBoundsRect(gfx::Point(), layer->bounds());
     layer->setDrawableContentRect(gfx::ToEnclosingRect(gfx::ScaleRect(layerBoundsRect, 0.5)));
     layer->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(9-1, layer->fakeLayerUpdater()->updateCount());
 
@@ skipping 21 matching lines @@
     layer->setDrawOpacity(1);
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
 
     // If the layer doesn't paint opaque content, then the visibleContentOpaqueRegion should be empty.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(contentBounds);
     layer->update(*m_queue.get(), &occluded, m_stats);
     opaqueContents = layer->visibleContentOpaqueRegion();
-    EXPECT_TRUE(opaqueContents.isEmpty());
+    EXPECT_TRUE(opaqueContents.IsEmpty());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 20000, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // visibleContentOpaqueRegion should match the visible part of what is painted opaque.
     opaquePaintRect = gfx::Rect(10, 10, 90, 190);
     layer->fakeLayerUpdater()->setOpaquePaintRect(opaquePaintRect);
     layer->invalidateContentRect(contentBounds);
@@ skipping 72 matching lines @@
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
 
     // Invalidates and paints the whole layer.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(contentBounds);
     layer->update(*m_queue.get(), &occluded, m_stats);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
-    EXPECT_TRUE(opaqueContents.isEmpty());
+    EXPECT_TRUE(opaqueContents.IsEmpty());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 30000, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 30000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // Invalidates an area on the top and bottom tile, which will cause us to paint the tile in the middle,
     // even though it is not dirty and will not be uploaded.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(gfx::Rect(0, 0, 1, 1));
     layer->invalidateContentRect(gfx::Rect(50, 200, 10, 10));
     layer->update(*m_queue.get(), &occluded, m_stats);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
-    EXPECT_TRUE(opaqueContents.isEmpty());
+    EXPECT_TRUE(opaqueContents.IsEmpty());
 
     // The middle tile was painted even though not invalidated.
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 30000 + 60 * 210, 1);
     // The pixels uploaded will not include the non-invalidated tile in the middle.
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 30000 + 1 + 100, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, dontAllocateContentsWhenTargetSurfaceCantBeAllocated)
@@ skipping 348 matching lines @@
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
     m_layerTreeHost->commitComplete();
 
     textureManagerClearAllMemory(m_layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
     m_layerTreeHost->setRootLayer(0);
 }
 
 } // namespace