cc: Use ui/gfx geometry types for the CCRenderPass and CCDrawQuad classes.

cc/draw_quad_unittest.cc

 // Copyright 2012 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 "CCDrawQuad.h"
 
 #include "CCCheckerboardDrawQuad.h"
 #include "CCDebugBorderDrawQuad.h"
@@ skipping 10 matching lines @@
 
 using WebKit::WebTransformationMatrix;
 
 using namespace cc;
 
 namespace {
 
 TEST(CCDrawQuadTest, copySharedQuadState)
 {
     WebTransformationMatrix quadTransform(1, 0.5, 0, 1, 0.5, 0);
-    IntRect visibleContentRect(10, 12, 14, 16);
-    IntRect clippedRectInTarget(19, 21, 23, 25);
+    gfx::Rect visibleContentRect(10, 12, 14, 16);
+    gfx::Rect clippedRectInTarget(19, 21, 23, 25);
     float opacity = 0.25;
     bool opaque = true;
     int id = 3;
 
     scoped_ptr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity, opaque));
     state->id = id;
 
     scoped_ptr<CCSharedQuadState> copy(state->copy());
     EXPECT_EQ(id, copy->id);
     EXPECT_EQ(quadTransform, copy->quadTransform);
     EXPECT_RECT_EQ(visibleContentRect, copy->visibleContentRect);
     EXPECT_RECT_EQ(clippedRectInTarget, copy->clippedRectInTarget);
     EXPECT_EQ(opacity, copy->opacity);
     EXPECT_EQ(opaque, copy->opaque);
 }
 
 scoped_ptr<CCSharedQuadState> createSharedQuadState()
 {
     WebTransformationMatrix quadTransform(1, 0.5, 0, 1, 0.5, 0);
-    IntRect visibleContentRect(10, 12, 14, 16);
-    IntRect clippedRectInTarget(19, 21, 23, 25);
+    gfx::Rect visibleContentRect(10, 12, 14, 16);
+    gfx::Rect clippedRectInTarget(19, 21, 23, 25);
     float opacity = 1;
     bool opaque = false;
     int id = 3;
 
     scoped_ptr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity, opaque));
     state->id = id;
     return state.Pass();
 }
 
 void compareDrawQuad(CCDrawQuad* quad, CCDrawQuad* copy, CCSharedQuadState* copySharedState)
@@ skipping 12 matching lines @@
     EXPECT_EQ(quad->sharedQuadStateId(), quad->sharedQuadState()->id);
     EXPECT_EQ(copy->sharedQuadStateId(), copy->sharedQuadState()->id);
 }
 
 #define CREATE_SHARED_STATE() \
     scoped_ptr<CCSharedQuadState> sharedState(createSharedQuadState()); \
     scoped_ptr<CCSharedQuadState> copySharedState(sharedState->copy()); \
     copySharedState->id = 5;
 
 #define QUAD_DATA \
-    IntRect quadRect(30, 40, 50, 60); \
-    IntRect quadVisibleRect(40, 50, 30, 20); \
+    gfx::Rect quadRect(30, 40, 50, 60); \
+    gfx::Rect quadVisibleRect(40, 50, 30, 20);
 
 #define SETUP_AND_COPY_QUAD(Type, quad) \
     quad->setQuadVisibleRect(quadVisibleRect); \
     scoped_ptr<CCDrawQuad> copy(quad->copy(copySharedState.get())); \
     compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
     const Type* copyQuad = Type::materialCast(copy.get());
 
 #define SETUP_AND_COPY_QUAD_1(Type, quad, a) \
     quad->setQuadVisibleRect(quadVisibleRect); \
     scoped_ptr<CCDrawQuad> copy(quad->copy(copySharedState.get(), a));    \
@@ skipping 74 matching lines @@
     SkColor color = 0xfabb0011;
     int width = 99;
     CREATE_SHARED_STATE();
     CREATE_QUAD_2(CCDebugBorderDrawQuad, color, width);
     EXPECT_EQ(color, copyQuad->color());
     EXPECT_EQ(width, copyQuad->width());
 }
 
 TEST(CCDrawQuadTest, copyIOSurfaceDrawQuad)
 {
-    IntSize size(58, 95);
+    gfx::Size size(58, 95);
     unsigned textureId = 72;
     CCIOSurfaceDrawQuad::Orientation orientation = CCIOSurfaceDrawQuad::Unflipped;
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_3(CCIOSurfaceDrawQuad, size, textureId, orientation);
     EXPECT_EQ(size, copyQuad->ioSurfaceSize());
     EXPECT_EQ(textureId, copyQuad->ioSurfaceTextureId());
     EXPECT_EQ(orientation, copyQuad->orientation());
 }
 
 TEST(CCDrawQuadTest, copyRenderPassDrawQuad)
 {
     CCRenderPass::Id renderPassId(22, 64);
     bool isReplica = true;
     CCResourceProvider::ResourceId maskResourceId = 78;
-    IntRect contentsChangedSinceLastFrame(42, 11, 74, 24);
+    gfx::Rect contentsChangedSinceLastFrame(42, 11, 74, 24);
     float maskTexCoordScaleX = 33;
     float maskTexCoordScaleY = 19;
     float maskTexCoordOffsetX = -45;
     float maskTexCoordOffsetY = -21;
 
     CCRenderPass::Id copiedRenderPassId(235, 11);
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_8_1(CCRenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId);
     EXPECT_EQ(copiedRenderPassId, copyQuad->renderPassId());
@@ skipping 23 matching lines @@
     CREATE_SHARED_STATE();
     CREATE_QUAD_2(CCStreamVideoDrawQuad, textureId, matrix);
     EXPECT_EQ(textureId, copyQuad->textureId());
     EXPECT_EQ(matrix, copyQuad->matrix());
 }
 
 TEST(CCDrawQuadTest, copyTextureDrawQuad)
 {
     unsigned resourceId = 82;
     bool premultipliedAlpha = true;
-    FloatRect uvRect(0.5, 224, -51, 36);
+    gfx::RectF uvRect(0.5, 224, -51, 36);
     bool flipped = true;
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_4(CCTextureDrawQuad, resourceId, premultipliedAlpha, uvRect, flipped);
     EXPECT_EQ(resourceId, copyQuad->resourceId());
     EXPECT_EQ(premultipliedAlpha, copyQuad->premultipliedAlpha());
-    EXPECT_EQ(uvRect, copyQuad->uvRect());
+    EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uvRect());
     EXPECT_EQ(flipped, copyQuad->flipped());
 }
 
 TEST(CCDrawQuadTest, copyTileDrawQuad)
 {
-    IntRect opaqueRect(33, 44, 22, 33);
+    gfx::Rect opaqueRect(33, 44, 22, 33);
     unsigned resourceId = 104;
-    IntPoint textureOffset(-31, 47);
-    IntSize textureSize(85, 32);
+    gfx::Point textureOffset(-31, 47);
+    gfx::Size textureSize(85, 32);
     GLint textureFilter = 82;
     bool swizzleContents = true;
     bool leftEdgeAA = true;
     bool topEdgeAA = true;
     bool rightEdgeAA = false;
     bool bottomEdgeAA = true;
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_10(CCTileDrawQuad, opaqueRect, resourceId, textureOffset, textureSize, textureFilter, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaqueRect());
@@ skipping 36 matching lines @@
     EXPECT_EQ(uPlane.size, copyQuad->uPlane().size);
     EXPECT_EQ(uPlane.format, copyQuad->uPlane().format);
     EXPECT_EQ(uPlane.visibleSize, copyQuad->uPlane().visibleSize);
     EXPECT_EQ(vPlane.resourceId, copyQuad->vPlane().resourceId);
     EXPECT_EQ(vPlane.size, copyQuad->vPlane().size);
     EXPECT_EQ(vPlane.format, copyQuad->vPlane().format);
     EXPECT_EQ(vPlane.visibleSize, copyQuad->vPlane().visibleSize);
 }
 
 } // namespace