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