cc: Moving anti-aliasing decision to parent compositor.

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/math_util.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "cc/yuv_video_draw_quad.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperations.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
 TEST(DrawQuadTest, copySharedQuadState)
 {
     gfx::Transform quadTransform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
+    gfx::Size contentBounds(26, 28);
     gfx::Rect visibleContentRect(10, 12, 14, 16);
     gfx::Rect clipRect(19, 21, 23, 25);
     bool isClipped = true;
     float opacity = 0.25;
 
     scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
-    state->SetAll(quadTransform, visibleContentRect, clipRect, isClipped, opacity);
+    state->SetAll(quadTransform, contentBounds, visibleContentRect, clipRect,
+                  isClipped, opacity);
 
     scoped_ptr<SharedQuadState> copy(state->Copy());
     EXPECT_EQ(quadTransform, copy->content_to_target_transform);
     EXPECT_RECT_EQ(visibleContentRect, copy->visible_content_rect);
     EXPECT_EQ(opacity, copy->opacity);
     EXPECT_RECT_EQ(clipRect, copy->clip_rect);
     EXPECT_EQ(isClipped, copy->is_clipped);
 }
 
 scoped_ptr<SharedQuadState> createSharedQuadState()
 {
     gfx::Transform quadTransform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
+    gfx::Size contentBounds(26, 28);
     gfx::Rect visibleContentRect(10, 12, 14, 16);
     gfx::Rect clipRect(19, 21, 23, 25);
     bool isClipped = false;
     float opacity = 1;
 
     scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
-    state->SetAll(quadTransform, visibleContentRect, clipRect, isClipped, opacity);
+    state->SetAll(quadTransform, contentBounds, visibleContentRect, clipRect,
+                  isClipped, opacity);
     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);
@@ skipping 388 matching lines @@
     }
 }
 
 TEST(DrawQuadTest, copyTileDrawQuad)
 {
     gfx::Rect opaqueRect(33, 44, 22, 33);
     unsigned resourceId = 104;
     gfx::RectF texCoordRect(31, 12, 54, 20);
     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_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+    CREATE_QUAD_5_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents);
     EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(resourceId, copyQuad->resource_id);
     EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
     EXPECT_EQ(textureSize, copyQuad->texture_size);
     EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
-    EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
-    EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
-    EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
-    EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
 
-    CREATE_QUAD_8_ALL(TileDrawQuad, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+    CREATE_QUAD_4_ALL(TileDrawQuad, resourceId, texCoordRect, textureSize, swizzleContents);
     EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
     EXPECT_EQ(resourceId, copyQuad->resource_id);
     EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
     EXPECT_EQ(textureSize, copyQuad->texture_size);
     EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
-    EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
-    EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
-    EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
-    EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
 }
 
 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;
@@ skipping 30 matching lines @@
     EXPECT_EQ(uPlane.resourceId, copyQuad->u_plane.resourceId);
     EXPECT_EQ(uPlane.size, copyQuad->u_plane.size);
     EXPECT_EQ(uPlane.format, copyQuad->u_plane.format);
     EXPECT_EQ(vPlane.resourceId, copyQuad->v_plane.resourceId);
     EXPECT_EQ(vPlane.size, copyQuad->v_plane.size);
     EXPECT_EQ(vPlane.format, copyQuad->v_plane.format);
 }
 
 }  // namespace
 }  // namespace cc