cc/quads/draw_quad_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/quads/draw_quad.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/compiler_specific.h"
  11 #include "cc/base/math_util.h"
  12 #include "cc/output/filter_operations.h"
  13 #include "cc/quads/checkerboard_draw_quad.h"
  14 #include "cc/quads/debug_border_draw_quad.h"
  15 #include "cc/quads/io_surface_draw_quad.h"
  16 #include "cc/quads/picture_draw_quad.h"
  17 #include "cc/quads/render_pass_draw_quad.h"
  18 #include "cc/quads/solid_color_draw_quad.h"
  19 #include "cc/quads/stream_video_draw_quad.h"
  20 #include "cc/quads/surface_draw_quad.h"
  21 #include "cc/quads/texture_draw_quad.h"
  22 #include "cc/quads/tile_draw_quad.h"
  23 #include "cc/quads/yuv_video_draw_quad.h"
  24 #include "cc/resources/picture_pile_impl.h"
  25 #include "cc/test/geometry_test_utils.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
  28 #include "ui/gfx/transform.h"
  29
  30 namespace cc {
  31 namespace {
  32
  33 TEST(DrawQuadTest, CopySharedQuadState) {
  34   gfx::Transform quad_transform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
  35   gfx::Size content_bounds(26, 28);
  36   gfx::Rect visible_content_rect(10, 12, 14, 16);
  37   gfx::Rect clip_rect(19, 21, 23, 25);
  38   bool is_clipped = true;
  39   float opacity = 0.25f;
  40   SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
  41
  42   scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
  43   state->SetAll(quad_transform,
  44                 content_bounds,
  45                 visible_content_rect,
  46                 clip_rect,
  47                 is_clipped,
  48                 opacity,
  49                 blend_mode);
  50
  51   scoped_ptr<SharedQuadState> copy(state->Copy());
  52   EXPECT_EQ(quad_transform, copy->content_to_target_transform);
  53   EXPECT_RECT_EQ(visible_content_rect, copy->visible_content_rect);
  54   EXPECT_EQ(opacity, copy->opacity);
  55   EXPECT_RECT_EQ(clip_rect, copy->clip_rect);
  56   EXPECT_EQ(is_clipped, copy->is_clipped);
  57   EXPECT_EQ(blend_mode, copy->blend_mode);
  58 }
  59
  60 scoped_ptr<SharedQuadState> CreateSharedQuadState() {
  61   gfx::Transform quad_transform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
  62   gfx::Size content_bounds(26, 28);
  63   gfx::Rect visible_content_rect(10, 12, 14, 16);
  64   gfx::Rect clip_rect(19, 21, 23, 25);
  65   bool is_clipped = false;
  66   float opacity = 1.f;
  67   SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
  68
  69   scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
  70   state->SetAll(quad_transform,
  71                 content_bounds,
  72                 visible_content_rect,
  73                 clip_rect,
  74                 is_clipped,
  75                 opacity,
  76                 blend_mode);
  77   return state.Pass();
  78 }
  79
  80 void CompareDrawQuad(DrawQuad* quad,
  81                      DrawQuad* copy,
  82                      SharedQuadState* copy_shared_state) {
  83   EXPECT_EQ(quad->material, copy->material);
  84   EXPECT_RECT_EQ(quad->rect, copy->rect);
  85   EXPECT_RECT_EQ(quad->visible_rect, copy->visible_rect);
  86   EXPECT_RECT_EQ(quad->opaque_rect, copy->opaque_rect);
  87   EXPECT_EQ(quad->needs_blending, copy->needs_blending);
  88   EXPECT_EQ(copy_shared_state, copy->shared_quad_state);
  89 }
  90
  91 #define CREATE_SHARED_STATE() \
  92     scoped_ptr<SharedQuadState> shared_state(CreateSharedQuadState()); \
  93     scoped_ptr<SharedQuadState> copy_shared_state(shared_state->Copy()); \
  94
  95 #define QUAD_DATA \
  96     gfx::Rect quad_rect(30, 40, 50, 60); \
  97     gfx::Rect quad_visible_rect(40, 50, 30, 20); \
  98     gfx::Rect ALLOW_UNUSED quad_opaque_rect(60, 55, 10, 10); \
  99     bool ALLOW_UNUSED needs_blending = true;
 100
 101 #define SETUP_AND_COPY_QUAD_NEW(Type, quad) \
 102     scoped_ptr<DrawQuad> copy_new(quad_new->Copy(copy_shared_state.get())); \
 103     CompareDrawQuad(quad_new.get(), copy_new.get(), copy_shared_state.get()); \
 104     const Type* ALLOW_UNUSED copy_quad = Type::MaterialCast(copy_new.get());
 105
 106 #define SETUP_AND_COPY_QUAD_ALL(Type, quad) \
 107     scoped_ptr<DrawQuad> copy_all(quad_all->Copy(copy_shared_state.get())); \
 108     CompareDrawQuad(quad_all.get(), copy_all.get(), copy_shared_state.get()); \
 109     copy_quad = Type::MaterialCast(copy_all.get());
 110
 111 #define SETUP_AND_COPY_QUAD_NEW_1(Type, quad, a) \
 112     scoped_ptr<DrawQuad> copy_new(quad_new->Copy(copy_shared_state.get(), a)); \
 113     CompareDrawQuad(quad_new.get(), copy_new.get(), copy_shared_state.get()); \
 114     const Type* ALLOW_UNUSED copy_quad = Type::MaterialCast(copy_new.get());
 115
 116 #define SETUP_AND_COPY_QUAD_ALL_1(Type, quad, a) \
 117     scoped_ptr<DrawQuad> copy_all(quad_all->Copy(copy_shared_state.get(), a)); \
 118     CompareDrawQuad(quad_all.get(), copy_all.get(), copy_shared_state.get()); \
 119     copy_quad = Type::MaterialCast(copy_all.get());
 120
 121 #define CREATE_QUAD_1_NEW(Type, a) \
 122     scoped_ptr<Type> quad_new(Type::Create()); \
 123     { \
 124       QUAD_DATA \
 125       quad_new->SetNew(shared_state.get(), quad_rect, a); \
 126     } \
 127     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 128
 129 #define CREATE_QUAD_1_ALL(Type, a) \
 130     scoped_ptr<Type> quad_all(Type::Create()); \
 131     { \
 132       QUAD_DATA \
 133       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 134                        quad_visible_rect, needs_blending, a); \
 135     } \
 136     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 137
 138 #define CREATE_QUAD_2_NEW(Type, a, b) \
 139     scoped_ptr<Type> quad_new(Type::Create()); \
 140     { \
 141       QUAD_DATA \
 142       quad_new->SetNew(shared_state.get(), quad_rect, a, b); \
 143     } \
 144     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 145
 146 #define CREATE_QUAD_2_ALL(Type, a, b) \
 147     scoped_ptr<Type> quad_all(Type::Create()); \
 148     { \
 149       QUAD_DATA \
 150       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 151                        quad_visible_rect, needs_blending, a, b); \
 152     } \
 153     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 154
 155 #define CREATE_QUAD_3_NEW(Type, a, b, c) \
 156     scoped_ptr<Type> quad_new(Type::Create()); \
 157     { \
 158       QUAD_DATA \
 159       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c); \
 160     } \
 161     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 162
 163 #define CREATE_QUAD_3_ALL(Type, a, b, c) \
 164     scoped_ptr<Type> quad_all(Type::Create()); \
 165     { \
 166       QUAD_DATA \
 167       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 168                        quad_visible_rect, needs_blending, a, b, c); \
 169     } \
 170     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 171
 172 #define CREATE_QUAD_4_NEW(Type, a, b, c, d) \
 173     scoped_ptr<Type> quad_new(Type::Create()); \
 174     { \
 175       QUAD_DATA \
 176       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d); \
 177     } \
 178     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 179
 180 #define CREATE_QUAD_4_ALL(Type, a, b, c, d) \
 181     scoped_ptr<Type> quad_all(Type::Create()); \
 182     { \
 183       QUAD_DATA \
 184       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 185                        quad_visible_rect, needs_blending, a, b, c, d); \
 186     } \
 187     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 188
 189 #define CREATE_QUAD_5_NEW(Type, a, b, c, d, e) \
 190     scoped_ptr<Type> quad_new(Type::Create()); \
 191     { \
 192       QUAD_DATA \
 193       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e); \
 194     } \
 195     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 196
 197 #define CREATE_QUAD_5_ALL(Type, a, b, c, d, e) \
 198     scoped_ptr<Type> quad_all(Type::Create()); \
 199     { \
 200       QUAD_DATA \
 201       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 202                        quad_visible_rect, needs_blending, a, b, c, d, e); \
 203     } \
 204     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 205
 206 #define CREATE_QUAD_5_NEW_1(Type, a, b, c, d, e, copy_a) \
 207     scoped_ptr<Type> quad_new(Type::Create()); \
 208     { \
 209       QUAD_DATA \
 210       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e); \
 211     } \
 212     SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
 213
 214 #define CREATE_QUAD_5_ALL_1(Type, a, b, c, d, e, copy_a) \
 215     scoped_ptr<Type> quad_all(Type::Create()); \
 216     { \
 217       QUAD_DATA \
 218       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 219                        quad_visible_rect, needs_blending, a, b, c, d, e); \
 220     } \
 221     SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
 222
 223 #define CREATE_QUAD_6_NEW(Type, a, b, c, d, e, f) \
 224     scoped_ptr<Type> quad_new(Type::Create()); \
 225     { \
 226       QUAD_DATA \
 227       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f); \
 228     } \
 229     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 230
 231 #define CREATE_QUAD_6_ALL(Type, a, b, c, d, e, f) \
 232     scoped_ptr<Type> quad_all(Type::Create()); \
 233     { \
 234       QUAD_DATA \
 235       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 236                        quad_visible_rect, needs_blending, a, b, c, d, e, f); \
 237     } \
 238     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 239
 240 #define CREATE_QUAD_7_NEW(Type, a, b, c, d, e, f, g) \
 241     scoped_ptr<Type> quad_new(Type::Create()); \
 242     { \
 243       QUAD_DATA \
 244       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g); \
 245     } \
 246     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 247
 248 #define CREATE_QUAD_7_ALL(Type, a, b, c, d, e, f, g) \
 249     scoped_ptr<Type> quad_all(Type::Create()); \
 250     { \
 251       QUAD_DATA \
 252       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 253                        quad_visible_rect, needs_blending, \
 254                        a, b, c, d, e, f, g); \
 255     } \
 256     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 257
 258 #define CREATE_QUAD_7_NEW_1(Type, a, b, c, d, e, f, g, copy_a) \
 259     scoped_ptr<Type> quad_new(Type::Create()); \
 260     { \
 261       QUAD_DATA \
 262       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g); \
 263     } \
 264     SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
 265
 266 #define CREATE_QUAD_7_ALL_1(Type, a, b, c, d, e, f, g, copy_a) \
 267     scoped_ptr<Type> quad_all(Type::Create()); \
 268     { \
 269       QUAD_DATA \
 270       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 271                        quad_visible_rect, needs_blending, \
 272                        a, b, c, d, e, f, g); \
 273     } \
 274     SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
 275
 276 #define CREATE_QUAD_8_NEW(Type, a, b, c, d, e, f, g, h) \
 277     scoped_ptr<Type> quad_new(Type::Create()); \
 278     { \
 279       QUAD_DATA \
 280       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g, h); \
 281     } \
 282     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 283
 284 #define CREATE_QUAD_8_ALL(Type, a, b, c, d, e, f, g, h) \
 285     scoped_ptr<Type> quad_all(Type::Create()); \
 286     { \
 287       QUAD_DATA \
 288       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 289                        quad_visible_rect, needs_blending, \
 290                        a, b, c, d, e, f, g, h); \
 291     } \
 292     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 293
 294 #define CREATE_QUAD_8_NEW_1(Type, a, b, c, d, e, f, g, h, copy_a) \
 295     scoped_ptr<Type> quad_new(Type::Create()); \
 296     { \
 297       QUAD_DATA \
 298       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g, h); \
 299     } \
 300     SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
 301
 302 #define CREATE_QUAD_8_ALL_1(Type, a, b, c, d, e, f, g, h, copy_a) \
 303     scoped_ptr<Type> quad_all(Type::Create()); \
 304     { \
 305       QUAD_DATA \
 306       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 307                        quad_visible_rect, needs_blending, \
 308                        a, b, c, d, e, f, g, h); \
 309     } \
 310     SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
 311
 312 #define CREATE_QUAD_9_NEW(Type, a, b, c, d, e, f, g, h, i) \
 313     scoped_ptr<Type> quad_new(Type::Create()); \
 314     { \
 315       QUAD_DATA \
 316       quad_new->SetNew(shared_state.get(), quad_rect, \
 317                        a, b, c, d, e, f, g, h, i); \
 318     } \
 319     SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
 320
 321 #define CREATE_QUAD_9_ALL(Type, a, b, c, d, e, f, g, h, i) \
 322     scoped_ptr<Type> quad_all(Type::Create()); \
 323     { \
 324       QUAD_DATA \
 325       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
 326                        quad_visible_rect, needs_blending, \
 327                        a, b, c, d, e, f, g, h, i); \
 328     } \
 329     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 330
 331 TEST(DrawQuadTest, CopyCheckerboardDrawQuad) {
 332   gfx::Rect visible_rect(40, 50, 30, 20);
 333   SkColor color = 0xfabb0011;
 334   CREATE_SHARED_STATE();
 335
 336   CREATE_QUAD_2_NEW(CheckerboardDrawQuad, visible_rect, color);
 337   EXPECT_EQ(DrawQuad::CHECKERBOARD, copy_quad->material);
 338   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 339   EXPECT_EQ(color, copy_quad->color);
 340
 341   CREATE_QUAD_1_ALL(CheckerboardDrawQuad, color);
 342   EXPECT_EQ(DrawQuad::CHECKERBOARD, copy_quad->material);
 343   EXPECT_EQ(color, copy_quad->color);
 344 }
 345
 346 TEST(DrawQuadTest, CopyDebugBorderDrawQuad) {
 347   gfx::Rect visible_rect(40, 50, 30, 20);
 348   SkColor color = 0xfabb0011;
 349   int width = 99;
 350   CREATE_SHARED_STATE();
 351
 352   CREATE_QUAD_3_NEW(DebugBorderDrawQuad, visible_rect, color, width);
 353   EXPECT_EQ(DrawQuad::DEBUG_BORDER, copy_quad->material);
 354   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 355   EXPECT_EQ(color, copy_quad->color);
 356   EXPECT_EQ(width, copy_quad->width);
 357
 358   CREATE_QUAD_2_ALL(DebugBorderDrawQuad, color, width);
 359   EXPECT_EQ(DrawQuad::DEBUG_BORDER, copy_quad->material);
 360   EXPECT_EQ(color, copy_quad->color);
 361   EXPECT_EQ(width, copy_quad->width);
 362 }
 363
 364 TEST(DrawQuadTest, CopyIOSurfaceDrawQuad) {
 365   gfx::Rect opaque_rect(33, 47, 10, 12);
 366   gfx::Rect visible_rect(40, 50, 30, 20);
 367   gfx::Size size(58, 95);
 368   ResourceProvider::ResourceId resource_id = 72;
 369   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
 370   CREATE_SHARED_STATE();
 371
 372   CREATE_QUAD_5_NEW(IOSurfaceDrawQuad,
 373                     opaque_rect,
 374                     visible_rect,
 375                     size,
 376                     resource_id,
 377                     orientation);
 378   EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copy_quad->material);
 379   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 380   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
 381   EXPECT_EQ(size, copy_quad->io_surface_size);
 382   EXPECT_EQ(resource_id, copy_quad->io_surface_resource_id);
 383   EXPECT_EQ(orientation, copy_quad->orientation);
 384
 385   CREATE_QUAD_3_ALL(IOSurfaceDrawQuad, size, resource_id, orientation);
 386   EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copy_quad->material);
 387   EXPECT_EQ(size, copy_quad->io_surface_size);
 388   EXPECT_EQ(resource_id, copy_quad->io_surface_resource_id);
 389   EXPECT_EQ(orientation, copy_quad->orientation);
 390 }
 391
 392 TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
 393   gfx::Rect visible_rect(40, 50, 30, 20);
 394   RenderPass::Id render_pass_id(22, 64);
 395   bool is_replica = true;
 396   ResourceProvider::ResourceId mask_resource_id = 78;
 397   gfx::Rect contents_changed_since_last_frame(42, 11, 74, 24);
 398   gfx::RectF mask_u_v_rect(-45.f, -21.f, 33.f, 19.f);
 399   FilterOperations filters;
 400   filters.Append(FilterOperation::CreateBlurFilter(1.f));
 401   FilterOperations background_filters;
 402   background_filters.Append(
 403       FilterOperation::CreateGrayscaleFilter(1.f));
 404
 405   RenderPass::Id copied_render_pass_id(235, 11);
 406   CREATE_SHARED_STATE();
 407
 408   CREATE_QUAD_8_NEW_1(RenderPassDrawQuad,
 409                       visible_rect,
 410                       render_pass_id,
 411                       is_replica,
 412                       mask_resource_id,
 413                       contents_changed_since_last_frame,
 414                       mask_u_v_rect,
 415                       filters,
 416                       background_filters,
 417                       copied_render_pass_id);
 418   EXPECT_EQ(DrawQuad::RENDER_PASS, copy_quad->material);
 419   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 420   EXPECT_EQ(copied_render_pass_id, copy_quad->render_pass_id);
 421   EXPECT_EQ(is_replica, copy_quad->is_replica);
 422   EXPECT_EQ(mask_resource_id, copy_quad->mask_resource_id);
 423   EXPECT_RECT_EQ(contents_changed_since_last_frame,
 424                  copy_quad->contents_changed_since_last_frame);
 425   EXPECT_EQ(mask_u_v_rect.ToString(), copy_quad->mask_uv_rect.ToString());
 426   EXPECT_EQ(filters, copy_quad->filters);
 427   EXPECT_EQ(background_filters, copy_quad->background_filters);
 428
 429   CREATE_QUAD_7_ALL_1(RenderPassDrawQuad,
 430                       render_pass_id,
 431                       is_replica,
 432                       mask_resource_id,
 433                       contents_changed_since_last_frame,
 434                       mask_u_v_rect,
 435                       filters,
 436                       background_filters,
 437                       copied_render_pass_id);
 438   EXPECT_EQ(DrawQuad::RENDER_PASS, copy_quad->material);
 439   EXPECT_EQ(copied_render_pass_id, copy_quad->render_pass_id);
 440   EXPECT_EQ(is_replica, copy_quad->is_replica);
 441   EXPECT_EQ(mask_resource_id, copy_quad->mask_resource_id);
 442   EXPECT_RECT_EQ(contents_changed_since_last_frame,
 443                  copy_quad->contents_changed_since_last_frame);
 444   EXPECT_EQ(mask_u_v_rect.ToString(), copy_quad->mask_uv_rect.ToString());
 445   EXPECT_EQ(filters, copy_quad->filters);
 446   EXPECT_EQ(background_filters, copy_quad->background_filters);
 447 }
 448
 449 TEST(DrawQuadTest, CopySolidColorDrawQuad) {
 450   gfx::Rect visible_rect(40, 50, 30, 20);
 451   SkColor color = 0x49494949;
 452   bool force_anti_aliasing_off = false;
 453   CREATE_SHARED_STATE();
 454
 455   CREATE_QUAD_3_NEW(
 456       SolidColorDrawQuad, visible_rect, color, force_anti_aliasing_off);
 457   EXPECT_EQ(DrawQuad::SOLID_COLOR, copy_quad->material);
 458   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 459   EXPECT_EQ(color, copy_quad->color);
 460   EXPECT_EQ(force_anti_aliasing_off, copy_quad->force_anti_aliasing_off);
 461
 462   CREATE_QUAD_2_ALL(SolidColorDrawQuad, color, force_anti_aliasing_off);
 463   EXPECT_EQ(DrawQuad::SOLID_COLOR, copy_quad->material);
 464   EXPECT_EQ(color, copy_quad->color);
 465   EXPECT_EQ(force_anti_aliasing_off, copy_quad->force_anti_aliasing_off);
 466 }
 467
 468 TEST(DrawQuadTest, CopyStreamVideoDrawQuad) {
 469   gfx::Rect opaque_rect(33, 47, 10, 12);
 470   gfx::Rect visible_rect(40, 50, 30, 20);
 471   ResourceProvider::ResourceId resource_id = 64;
 472   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
 473   CREATE_SHARED_STATE();
 474
 475   CREATE_QUAD_4_NEW(
 476       StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id, matrix);
 477   EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copy_quad->material);
 478   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 479   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
 480   EXPECT_EQ(resource_id, copy_quad->resource_id);
 481   EXPECT_EQ(matrix, copy_quad->matrix);
 482
 483   CREATE_QUAD_2_ALL(StreamVideoDrawQuad, resource_id, matrix);
 484   EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copy_quad->material);
 485   EXPECT_EQ(resource_id, copy_quad->resource_id);
 486   EXPECT_EQ(matrix, copy_quad->matrix);
 487 }
 488
 489 TEST(DrawQuadTest, CopySurfaceDrawQuad) {
 490   gfx::Rect visible_rect(40, 50, 30, 20);
 491   int surface_id = 1234;
 492   CREATE_SHARED_STATE();
 493
 494   CREATE_QUAD_2_NEW(SurfaceDrawQuad, visible_rect, surface_id);
 495   EXPECT_EQ(DrawQuad::SURFACE_CONTENT, copy_quad->material);
 496   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 497   EXPECT_EQ(surface_id, copy_quad->surface_id);
 498
 499   CREATE_QUAD_1_ALL(SurfaceDrawQuad, surface_id);
 500   EXPECT_EQ(DrawQuad::SURFACE_CONTENT, copy_quad->material);
 501   EXPECT_EQ(surface_id, copy_quad->surface_id);
 502 }
 503
 504
 505 TEST(DrawQuadTest, CopyTextureDrawQuad) {
 506   gfx::Rect opaque_rect(33, 47, 10, 12);
 507   gfx::Rect visible_rect(40, 50, 30, 20);
 508   unsigned resource_id = 82;
 509   bool premultiplied_alpha = true;
 510   gfx::PointF uv_top_left(0.5f, 224.f);
 511   gfx::PointF uv_bottom_right(51.5f, 260.f);
 512   const float vertex_opacity[] = { 1.0f, 1.0f, 1.0f, 1.0f };
 513   bool flipped = true;
 514   CREATE_SHARED_STATE();
 515
 516   CREATE_QUAD_9_NEW(TextureDrawQuad,
 517                     opaque_rect,
 518                     visible_rect,
 519                     resource_id,
 520                     premultiplied_alpha,
 521                     uv_top_left,
 522                     uv_bottom_right,
 523                     SK_ColorTRANSPARENT,
 524                     vertex_opacity,
 525                     flipped);
 526   EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copy_quad->material);
 527   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 528   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
 529   EXPECT_EQ(resource_id, copy_quad->resource_id);
 530   EXPECT_EQ(premultiplied_alpha, copy_quad->premultiplied_alpha);
 531   EXPECT_EQ(uv_top_left, copy_quad->uv_top_left);
 532   EXPECT_EQ(uv_bottom_right, copy_quad->uv_bottom_right);
 533   EXPECT_FLOAT_ARRAY_EQ(vertex_opacity, copy_quad->vertex_opacity, 4);
 534   EXPECT_EQ(flipped, copy_quad->flipped);
 535
 536   CREATE_QUAD_7_ALL(TextureDrawQuad,
 537                     resource_id,
 538                     premultiplied_alpha,
 539                     uv_top_left,
 540                     uv_bottom_right,
 541                     SK_ColorTRANSPARENT,
 542                     vertex_opacity,
 543                     flipped);
 544   EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copy_quad->material);
 545   EXPECT_EQ(resource_id, copy_quad->resource_id);
 546   EXPECT_EQ(premultiplied_alpha, copy_quad->premultiplied_alpha);
 547   EXPECT_EQ(uv_top_left, copy_quad->uv_top_left);
 548   EXPECT_EQ(uv_bottom_right, copy_quad->uv_bottom_right);
 549   EXPECT_FLOAT_ARRAY_EQ(vertex_opacity, copy_quad->vertex_opacity, 4);
 550   EXPECT_EQ(flipped, copy_quad->flipped);
 551 }
 552
 553 TEST(DrawQuadTest, CopyTileDrawQuad) {
 554   gfx::Rect opaque_rect(33, 44, 22, 33);
 555   gfx::Rect visible_rect(40, 50, 30, 20);
 556   unsigned resource_id = 104;
 557   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
 558   gfx::Size texture_size(85, 32);
 559   bool swizzle_contents = true;
 560   CREATE_SHARED_STATE();
 561
 562   CREATE_QUAD_6_NEW(TileDrawQuad,
 563                     opaque_rect,
 564                     visible_rect,
 565                     resource_id,
 566                     tex_coord_rect,
 567                     texture_size,
 568                     swizzle_contents);
 569   EXPECT_EQ(DrawQuad::TILED_CONTENT, copy_quad->material);
 570   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
 571   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 572   EXPECT_EQ(resource_id, copy_quad->resource_id);
 573   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
 574   EXPECT_EQ(texture_size, copy_quad->texture_size);
 575   EXPECT_EQ(swizzle_contents, copy_quad->swizzle_contents);
 576
 577   CREATE_QUAD_4_ALL(TileDrawQuad,
 578                     resource_id,
 579                     tex_coord_rect,
 580                     texture_size,
 581                     swizzle_contents);
 582   EXPECT_EQ(DrawQuad::TILED_CONTENT, copy_quad->material);
 583   EXPECT_EQ(resource_id, copy_quad->resource_id);
 584   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
 585   EXPECT_EQ(texture_size, copy_quad->texture_size);
 586   EXPECT_EQ(swizzle_contents, copy_quad->swizzle_contents);
 587 }
 588
 589 TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
 590   gfx::Rect opaque_rect(33, 47, 10, 12);
 591   gfx::Rect visible_rect(40, 50, 30, 20);
 592   gfx::RectF tex_coord_rect(0.0f, 0.0f, 0.75f, 0.5f);
 593   ResourceProvider::ResourceId y_plane_resource_id = 45;
 594   ResourceProvider::ResourceId u_plane_resource_id = 532;
 595   ResourceProvider::ResourceId v_plane_resource_id = 4;
 596   ResourceProvider::ResourceId a_plane_resource_id = 63;
 597   CREATE_SHARED_STATE();
 598
 599   CREATE_QUAD_7_NEW(YUVVideoDrawQuad,
 600                     opaque_rect,
 601                     visible_rect,
 602                     tex_coord_rect,
 603                     y_plane_resource_id,
 604                     u_plane_resource_id,
 605                     v_plane_resource_id,
 606                     a_plane_resource_id);
 607   EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copy_quad->material);
 608   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
 609   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 610   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
 611   EXPECT_EQ(y_plane_resource_id, copy_quad->y_plane_resource_id);
 612   EXPECT_EQ(u_plane_resource_id, copy_quad->u_plane_resource_id);
 613   EXPECT_EQ(v_plane_resource_id, copy_quad->v_plane_resource_id);
 614   EXPECT_EQ(a_plane_resource_id, copy_quad->a_plane_resource_id);
 615
 616   CREATE_QUAD_5_ALL(YUVVideoDrawQuad,
 617                     tex_coord_rect,
 618                     y_plane_resource_id,
 619                     u_plane_resource_id,
 620                     v_plane_resource_id,
 621                     a_plane_resource_id);
 622   EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copy_quad->material);
 623   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
 624   EXPECT_EQ(y_plane_resource_id, copy_quad->y_plane_resource_id);
 625   EXPECT_EQ(u_plane_resource_id, copy_quad->u_plane_resource_id);
 626   EXPECT_EQ(v_plane_resource_id, copy_quad->v_plane_resource_id);
 627   EXPECT_EQ(a_plane_resource_id, copy_quad->a_plane_resource_id);
 628 }
 629
 630 TEST(DrawQuadTest, CopyPictureDrawQuad) {
 631   gfx::Rect opaque_rect(33, 44, 22, 33);
 632   gfx::Rect visible_rect(40, 50, 30, 20);
 633   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
 634   gfx::Size texture_size(85, 32);
 635   ResourceFormat texture_format = RGBA_8888;
 636   gfx::Rect content_rect(30, 40, 20, 30);
 637   float contents_scale = 3.141592f;
 638   scoped_refptr<PicturePileImpl> picture_pile = PicturePileImpl::Create();
 639   CREATE_SHARED_STATE();
 640
 641   CREATE_QUAD_8_NEW(PictureDrawQuad,
 642                     opaque_rect,
 643                     visible_rect,
 644                     tex_coord_rect,
 645                     texture_size,
 646                     texture_format,
 647                     content_rect,
 648                     contents_scale,
 649                     picture_pile);
 650   EXPECT_EQ(DrawQuad::PICTURE_CONTENT, copy_quad->material);
 651   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
 652   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
 653   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
 654   EXPECT_EQ(texture_size, copy_quad->texture_size);
 655   EXPECT_EQ(texture_format, copy_quad->texture_format);
 656   EXPECT_RECT_EQ(content_rect, copy_quad->content_rect);
 657   EXPECT_EQ(contents_scale, copy_quad->contents_scale);
 658   EXPECT_EQ(picture_pile, copy_quad->picture_pile);
 659
 660   CREATE_QUAD_6_ALL(PictureDrawQuad,
 661                     tex_coord_rect,
 662                     texture_size,
 663                     texture_format,
 664                     content_rect,
 665                     contents_scale,
 666                     picture_pile);
 667   EXPECT_EQ(DrawQuad::PICTURE_CONTENT, copy_quad->material);
 668   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
 669   EXPECT_EQ(texture_size, copy_quad->texture_size);
 670   EXPECT_EQ(texture_format, copy_quad->texture_format);
 671   EXPECT_RECT_EQ(content_rect, copy_quad->content_rect);
 672   EXPECT_EQ(contents_scale, copy_quad->contents_scale);
 673   EXPECT_EQ(picture_pile, copy_quad->picture_pile);
 674 }
 675
 676 class DrawQuadIteratorTest : public testing::Test {
 677  protected:
 678   ResourceProvider::ResourceId IncrementResourceId(
 679       ResourceProvider::ResourceId id) {
 680     ++num_resources_;
 681     return id + 1;
 682   }
 683
 684   int IterateAndCount(DrawQuad* quad) {
 685     num_resources_ = 0;
 686     quad->IterateResources(base::Bind(
 687         &DrawQuadIteratorTest::IncrementResourceId, base::Unretained(this)));
 688     return num_resources_;
 689   }
 690
 691  private:
 692   int num_resources_;
 693 };
 694
 695 TEST_F(DrawQuadIteratorTest, CheckerboardDrawQuad) {
 696   gfx::Rect visible_rect(40, 50, 30, 20);
 697   SkColor color = 0xfabb0011;
 698
 699   CREATE_SHARED_STATE();
 700   CREATE_QUAD_2_NEW(CheckerboardDrawQuad, visible_rect, color);
 701   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 702 }
 703
 704 TEST_F(DrawQuadIteratorTest, DebugBorderDrawQuad) {
 705   gfx::Rect visible_rect(40, 50, 30, 20);
 706   SkColor color = 0xfabb0011;
 707   int width = 99;
 708
 709   CREATE_SHARED_STATE();
 710   CREATE_QUAD_3_NEW(DebugBorderDrawQuad, visible_rect, color, width);
 711   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 712 }
 713
 714 TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
 715   gfx::Rect opaque_rect(33, 47, 10, 12);
 716   gfx::Rect visible_rect(40, 50, 30, 20);
 717   gfx::Size size(58, 95);
 718   ResourceProvider::ResourceId resource_id = 72;
 719   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
 720
 721   CREATE_SHARED_STATE();
 722   CREATE_QUAD_5_NEW(IOSurfaceDrawQuad,
 723                     opaque_rect,
 724                     visible_rect,
 725                     size,
 726                     resource_id,
 727                     orientation);
 728   EXPECT_EQ(resource_id, quad_new->io_surface_resource_id);
 729   EXPECT_EQ(1, IterateAndCount(quad_new.get()));
 730   EXPECT_EQ(resource_id + 1, quad_new->io_surface_resource_id);
 731 }
 732
 733 TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
 734   gfx::Rect visible_rect(40, 50, 30, 20);
 735   RenderPass::Id render_pass_id(22, 64);
 736   bool is_replica = true;
 737   ResourceProvider::ResourceId mask_resource_id = 78;
 738   gfx::Rect contents_changed_since_last_frame(42, 11, 74, 24);
 739   gfx::RectF mask_u_v_rect(-45.f, -21.f, 33.f, 19.f);
 740   FilterOperations filters;
 741   filters.Append(FilterOperation::CreateBlurFilter(1.f));
 742   FilterOperations background_filters;
 743   background_filters.Append(
 744       FilterOperation::CreateGrayscaleFilter(1.f));
 745
 746   RenderPass::Id copied_render_pass_id(235, 11);
 747
 748   CREATE_SHARED_STATE();
 749   CREATE_QUAD_8_NEW_1(RenderPassDrawQuad,
 750                       visible_rect,
 751                       render_pass_id,
 752                       is_replica,
 753                       mask_resource_id,
 754                       contents_changed_since_last_frame,
 755                       mask_u_v_rect,
 756                       filters,
 757                       background_filters,
 758                       copied_render_pass_id);
 759   EXPECT_EQ(mask_resource_id, quad_new->mask_resource_id);
 760   EXPECT_EQ(1, IterateAndCount(quad_new.get()));
 761   EXPECT_EQ(mask_resource_id + 1, quad_new->mask_resource_id);
 762   quad_new->mask_resource_id = 0;
 763   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 764   EXPECT_EQ(0u, quad_new->mask_resource_id);
 765 }
 766
 767 TEST_F(DrawQuadIteratorTest, SolidColorDrawQuad) {
 768   gfx::Rect visible_rect(40, 50, 30, 20);
 769   SkColor color = 0x49494949;
 770   bool force_anti_aliasing_off = false;
 771
 772   CREATE_SHARED_STATE();
 773   CREATE_QUAD_3_NEW(
 774       SolidColorDrawQuad, visible_rect, color, force_anti_aliasing_off);
 775   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 776 }
 777
 778 TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
 779   gfx::Rect opaque_rect(33, 47, 10, 12);
 780   gfx::Rect visible_rect(40, 50, 30, 20);
 781   ResourceProvider::ResourceId resource_id = 64;
 782   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
 783
 784   CREATE_SHARED_STATE();
 785   CREATE_QUAD_4_NEW(
 786       StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id, matrix);
 787   EXPECT_EQ(resource_id, quad_new->resource_id);
 788   EXPECT_EQ(1, IterateAndCount(quad_new.get()));
 789   EXPECT_EQ(resource_id + 1, quad_new->resource_id);
 790 }
 791
 792 TEST_F(DrawQuadIteratorTest, SurfaceDrawQuad) {
 793   gfx::Rect visible_rect(40, 50, 30, 20);
 794   int surface_id = 4321;
 795
 796   CREATE_SHARED_STATE();
 797   CREATE_QUAD_2_NEW(SurfaceDrawQuad, visible_rect, surface_id);
 798   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 799 }
 800
 801 TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
 802   gfx::Rect opaque_rect(33, 47, 10, 12);
 803   gfx::Rect visible_rect(40, 50, 30, 20);
 804   unsigned resource_id = 82;
 805   bool premultiplied_alpha = true;
 806   gfx::PointF uv_top_left(0.5f, 224.f);
 807   gfx::PointF uv_bottom_right(51.5f, 260.f);
 808   const float vertex_opacity[] = { 1.0f, 1.0f, 1.0f, 1.0f };
 809   bool flipped = true;
 810
 811   CREATE_SHARED_STATE();
 812   CREATE_QUAD_9_NEW(TextureDrawQuad,
 813                     opaque_rect,
 814                     visible_rect,
 815                     resource_id,
 816                     premultiplied_alpha,
 817                     uv_top_left,
 818                     uv_bottom_right,
 819                     SK_ColorTRANSPARENT,
 820                     vertex_opacity,
 821                     flipped);
 822   EXPECT_EQ(resource_id, quad_new->resource_id);
 823   EXPECT_EQ(1, IterateAndCount(quad_new.get()));
 824   EXPECT_EQ(resource_id + 1, quad_new->resource_id);
 825 }
 826
 827 TEST_F(DrawQuadIteratorTest, TileDrawQuad) {
 828   gfx::Rect opaque_rect(33, 44, 22, 33);
 829   gfx::Rect visible_rect(40, 50, 30, 20);
 830   unsigned resource_id = 104;
 831   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
 832   gfx::Size texture_size(85, 32);
 833   bool swizzle_contents = true;
 834
 835   CREATE_SHARED_STATE();
 836   CREATE_QUAD_6_NEW(TileDrawQuad,
 837                     opaque_rect,
 838                     visible_rect,
 839                     resource_id,
 840                     tex_coord_rect,
 841                     texture_size,
 842                     swizzle_contents);
 843   EXPECT_EQ(resource_id, quad_new->resource_id);
 844   EXPECT_EQ(1, IterateAndCount(quad_new.get()));
 845   EXPECT_EQ(resource_id + 1, quad_new->resource_id);
 846 }
 847
 848 TEST_F(DrawQuadIteratorTest, YUVVideoDrawQuad) {
 849   gfx::Rect opaque_rect(33, 47, 10, 12);
 850   gfx::Rect visible_rect(40, 50, 30, 20);
 851   gfx::RectF tex_coord_rect(0.0f, 0.0f, 0.75f, 0.5f);
 852   ResourceProvider::ResourceId y_plane_resource_id = 45;
 853   ResourceProvider::ResourceId u_plane_resource_id = 532;
 854   ResourceProvider::ResourceId v_plane_resource_id = 4;
 855   ResourceProvider::ResourceId a_plane_resource_id = 63;
 856
 857   CREATE_SHARED_STATE();
 858   CREATE_QUAD_7_NEW(YUVVideoDrawQuad,
 859                     opaque_rect,
 860                     visible_rect,
 861                     tex_coord_rect,
 862                     y_plane_resource_id,
 863                     u_plane_resource_id,
 864                     v_plane_resource_id,
 865                     a_plane_resource_id);
 866   EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copy_quad->material);
 867   EXPECT_EQ(y_plane_resource_id, quad_new->y_plane_resource_id);
 868   EXPECT_EQ(u_plane_resource_id, quad_new->u_plane_resource_id);
 869   EXPECT_EQ(v_plane_resource_id, quad_new->v_plane_resource_id);
 870   EXPECT_EQ(a_plane_resource_id, quad_new->a_plane_resource_id);
 871   EXPECT_EQ(4, IterateAndCount(quad_new.get()));
 872   EXPECT_EQ(y_plane_resource_id + 1, quad_new->y_plane_resource_id);
 873   EXPECT_EQ(u_plane_resource_id + 1, quad_new->u_plane_resource_id);
 874   EXPECT_EQ(v_plane_resource_id + 1, quad_new->v_plane_resource_id);
 875   EXPECT_EQ(a_plane_resource_id + 1, quad_new->a_plane_resource_id);
 876 }
 877
 878 // Disabled until picture draw quad is supported for ubercomp: crbug.com/231715
 879 TEST_F(DrawQuadIteratorTest, DISABLED_PictureDrawQuad) {
 880   gfx::Rect opaque_rect(33, 44, 22, 33);
 881   gfx::Rect visible_rect(40, 50, 30, 20);
 882   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
 883   gfx::Size texture_size(85, 32);
 884   ResourceFormat texture_format = RGBA_8888;
 885   gfx::Rect content_rect(30, 40, 20, 30);
 886   float contents_scale = 3.141592f;
 887   scoped_refptr<PicturePileImpl> picture_pile = PicturePileImpl::Create();
 888
 889   CREATE_SHARED_STATE();
 890   CREATE_QUAD_8_NEW(PictureDrawQuad,
 891                     opaque_rect,
 892                     visible_rect,
 893                     tex_coord_rect,
 894                     texture_size,
 895                     texture_format,
 896                     content_rect,
 897                     contents_scale,
 898                     picture_pile);
 899   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 900 }
 901
 902 }  // namespace
 903 }  // namespace cc