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