?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[GCM] Investigatory CHECKs for crash in parsing stream
[chromium-blink-merge.git] / cc / quads / draw_quad_unittest.cc
blobe3697ec4bf36ae3e3be9d450598a1d6ebf839e06
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