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