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 32namespace cc { 33namespace { 34 35TEST(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 65SharedQuadState* 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 87void 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 355TEST(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 370TEST(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 388TEST(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 416TEST(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 466TEST(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 485TEST(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 506TEST(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 522TEST(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 570TEST(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 606TEST(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 652TEST(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 698class 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 717TEST_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 726TEST_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 736TEST_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 755TEST_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 787TEST_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 798TEST_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 812TEST_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 821TEST_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 847TEST_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 868TEST_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 902TEST_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 925TEST(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 1018