cc: Turn DrawQuad into a struct-like class with public data members.

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 "cc/draw_quad.h"
 
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/io_surface_draw_quad.h"
 #include "cc/render_pass_draw_quad.h"
@@ skipping 38 matching lines @@
     float opacity = 1;
     int id = 3;
 
     scoped_ptr<SharedQuadState> state(SharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity));
     state->id = id;
     return state.Pass();
 }
 
 void compareDrawQuad(DrawQuad* quad, DrawQuad* copy, SharedQuadState* copySharedState)
 {
-    EXPECT_EQ(quad->material(), copy->material());
-    EXPECT_RECT_EQ(quad->rect(), copy->rect());
-    EXPECT_RECT_EQ(quad->visible_rect(), copy->visible_rect());
-    EXPECT_RECT_EQ(quad->opaque_rect(), copy->opaque_rect());
-    EXPECT_EQ(quad->needs_blending(), copy->needs_blending());
-    EXPECT_EQ(copySharedState, copy->shared_quad_state());
+    EXPECT_EQ(quad->material, copy->material);
+    EXPECT_RECT_EQ(quad->rect, copy->rect);
+    EXPECT_RECT_EQ(quad->visible_rect, copy->visible_rect);
+    EXPECT_RECT_EQ(quad->opaque_rect, copy->opaque_rect);
+    EXPECT_EQ(quad->needs_blending, copy->needs_blending);
+    EXPECT_EQ(copySharedState, copy->shared_quad_state);
 }
 
 #define CREATE_SHARED_STATE() \
     scoped_ptr<SharedQuadState> sharedState(createSharedQuadState()); \
     scoped_ptr<SharedQuadState> copySharedState(sharedState->copy()); \
     copySharedState->id = 5;
 
 #define QUAD_DATA \
     gfx::Rect quadRect(30, 40, 50, 60); \
     gfx::Rect quadVisibleRect(40, 50, 30, 20);
 
 #define SETUP_AND_COPY_QUAD(Type, quad) \
-    quad->set_visible_rect(quadVisibleRect); \
+    quad->visible_rect = quadVisibleRect; \
     scoped_ptr<DrawQuad> 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->set_visible_rect(quadVisibleRect); \
+    quad->visible_rect = quadVisibleRect; \
     scoped_ptr<DrawQuad> copy(quad->copy(copySharedState.get(), a));    \
     compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
     const Type* copyQuad = Type::materialCast(copy.get());
 
 #define CREATE_QUAD_0(Type) \
     QUAD_DATA \
     scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect)); \
     SETUP_AND_COPY_QUAD(Type, quad); \
     UNUSED_PARAM(copyQuad);
 
@@ skipping 67 matching lines @@
 
 TEST(DrawQuadTest, copyIOSurfaceDrawQuad)
 {
     gfx::Rect opaqueRect(3, 7, 10, 12);
     gfx::Size size(58, 95);
     unsigned textureId = 72;
     IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::Unflipped;
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_4(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation);
-    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect());
+    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(size, copyQuad->ioSurfaceSize());
     EXPECT_EQ(textureId, copyQuad->ioSurfaceTextureId());
     EXPECT_EQ(orientation, copyQuad->orientation());
 }
 
 TEST(DrawQuadTest, copyRenderPassDrawQuad)
 {
     RenderPass::Id renderPassId(22, 64);
     bool isReplica = true;
     ResourceProvider::ResourceId maskResourceId = 78;
@@ skipping 27 matching lines @@
 }
 
 TEST(DrawQuadTest, copyStreamVideoDrawQuad)
 {
     gfx::Rect opaqueRect(3, 7, 10, 12);
     unsigned textureId = 64;
     WebTransformationMatrix matrix(0.5, 1, 0.25, 0.75, 0, 1);
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_3(StreamVideoDrawQuad, opaqueRect, textureId, matrix);
-    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect());
+    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(textureId, copyQuad->textureId());
     EXPECT_EQ(matrix, copyQuad->matrix());
 }
 
 TEST(DrawQuadTest, copyTextureDrawQuad)
 {
     gfx::Rect opaqueRect(3, 7, 10, 12);
     unsigned resourceId = 82;
     bool premultipliedAlpha = true;
     gfx::RectF uvRect(0.5, 224, -51, 36);
     bool flipped = true;
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_5(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped);
-    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect());
+    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(resourceId, copyQuad->resourceId());
     EXPECT_EQ(premultipliedAlpha, copyQuad->premultipliedAlpha());
     EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uvRect());
     EXPECT_EQ(flipped, copyQuad->flipped());
 }
 
 TEST(DrawQuadTest, copyTileDrawQuad)
 {
     gfx::Rect opaqueRect(33, 44, 22, 33);
     unsigned resourceId = 104;
     gfx::Vector2d textureOffset(-31, 47);
     gfx::Size textureSize(85, 32);
     bool swizzleContents = true;
     bool leftEdgeAA = true;
     bool topEdgeAA = true;
     bool rightEdgeAA = false;
     bool bottomEdgeAA = true;
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_9(TileDrawQuad, opaqueRect, resourceId, textureOffset, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
-    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect());
+    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(resourceId, copyQuad->resourceId());
     EXPECT_EQ(textureOffset, copyQuad->textureOffset());
     EXPECT_EQ(textureSize, copyQuad->textureSize());
     EXPECT_EQ(swizzleContents, copyQuad->swizzleContents());
     EXPECT_EQ(leftEdgeAA, copyQuad->leftEdgeAA());
     EXPECT_EQ(topEdgeAA, copyQuad->topEdgeAA());
     EXPECT_EQ(rightEdgeAA, copyQuad->rightEdgeAA());
     EXPECT_EQ(bottomEdgeAA, copyQuad->bottomEdgeAA());
 }
 
 TEST(DrawQuadTest, copyYUVVideoDrawQuad)
 {
     gfx::Rect opaqueRect(3, 7, 10, 12);
     gfx::SizeF texScale(0.75, 0.5);
     VideoLayerImpl::FramePlane yPlane;
     yPlane.resourceId = 45;
     yPlane.size = gfx::Size(34, 23);
     yPlane.format = 8;
     VideoLayerImpl::FramePlane uPlane;
     uPlane.resourceId = 532;
     uPlane.size = gfx::Size(134, 16);
     uPlane.format = 2;
     VideoLayerImpl::FramePlane vPlane;
     vPlane.resourceId = 4;
     vPlane.size = gfx::Size(456, 486);
     vPlane.format = 46;
 
     CREATE_SHARED_STATE();
     CREATE_QUAD_5(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane);
-    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect());
+    EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(texScale, copyQuad->texScale());
     EXPECT_EQ(yPlane.resourceId, copyQuad->yPlane().resourceId);
     EXPECT_EQ(yPlane.size, copyQuad->yPlane().size);
     EXPECT_EQ(yPlane.format, copyQuad->yPlane().format);
     EXPECT_EQ(uPlane.resourceId, copyQuad->uPlane().resourceId);
     EXPECT_EQ(uPlane.size, copyQuad->uPlane().size);
     EXPECT_EQ(uPlane.format, copyQuad->uPlane().format);
     EXPECT_EQ(vPlane.resourceId, copyQuad->vPlane().resourceId);
     EXPECT_EQ(vPlane.size, copyQuad->vPlane().size);
     EXPECT_EQ(vPlane.format, copyQuad->vPlane().format);
 }
 
 }  // namespace
 }  // namespace cc