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