OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
11 #include "cc/base/region.h" | 11 #include "cc/base/region.h" |
12 #include "cc/output/ca_layer_overlay.h" | 12 #include "cc/output/ca_layer_overlay.h" |
13 #include "cc/output/filter_operation.h" | 13 #include "cc/output/filter_operation.h" |
14 #include "cc/output/gl_renderer.h" | 14 #include "cc/output/gl_renderer.h" |
15 #include "cc/output/output_surface.h" | 15 #include "cc/output/output_surface.h" |
16 #include "cc/output/output_surface_client.h" | 16 #include "cc/output/output_surface_client.h" |
17 #include "cc/output/output_surface_frame.h" | 17 #include "cc/output/output_surface_frame.h" |
18 #include "cc/output/overlay_candidate_validator.h" | 18 #include "cc/output/overlay_candidate_validator.h" |
19 #include "cc/output/overlay_processor.h" | 19 #include "cc/output/overlay_processor.h" |
20 #include "cc/output/overlay_strategy_fullscreen.h" | 20 #include "cc/output/overlay_strategy_fullscreen.h" |
21 #include "cc/output/overlay_strategy_single_on_top.h" | 21 #include "cc/output/overlay_strategy_single_on_top.h" |
22 #include "cc/output/overlay_strategy_underlay.h" | 22 #include "cc/output/overlay_strategy_underlay.h" |
| 23 #include "cc/output/overlay_strategy_underlay_cast.h" |
23 #include "cc/quads/render_pass.h" | 24 #include "cc/quads/render_pass.h" |
24 #include "cc/quads/render_pass_draw_quad.h" | 25 #include "cc/quads/render_pass_draw_quad.h" |
25 #include "cc/quads/solid_color_draw_quad.h" | 26 #include "cc/quads/solid_color_draw_quad.h" |
26 #include "cc/quads/stream_video_draw_quad.h" | 27 #include "cc/quads/stream_video_draw_quad.h" |
27 #include "cc/quads/texture_draw_quad.h" | 28 #include "cc/quads/texture_draw_quad.h" |
28 #include "cc/resources/resource_provider.h" | 29 #include "cc/resources/resource_provider.h" |
29 #include "cc/resources/texture_mailbox.h" | 30 #include "cc/resources/texture_mailbox.h" |
30 #include "cc/test/fake_output_surface_client.h" | 31 #include "cc/test/fake_output_surface_client.h" |
31 #include "cc/test/fake_resource_provider.h" | 32 #include "cc/test/fake_resource_provider.h" |
32 #include "cc/test/geometry_test_utils.h" | 33 #include "cc/test/geometry_test_utils.h" |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
123 } | 124 } |
124 }; | 125 }; |
125 | 126 |
126 class UnderlayOverlayValidator : public SingleOverlayValidator { | 127 class UnderlayOverlayValidator : public SingleOverlayValidator { |
127 public: | 128 public: |
128 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { | 129 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { |
129 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this)); | 130 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this)); |
130 } | 131 } |
131 }; | 132 }; |
132 | 133 |
| 134 class UnderlayCastOverlayValidator : public SingleOverlayValidator { |
| 135 public: |
| 136 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { |
| 137 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlayCast>(this)); |
| 138 } |
| 139 }; |
| 140 |
133 class DefaultOverlayProcessor : public OverlayProcessor { | 141 class DefaultOverlayProcessor : public OverlayProcessor { |
134 public: | 142 public: |
135 explicit DefaultOverlayProcessor(OutputSurface* surface); | 143 explicit DefaultOverlayProcessor(OutputSurface* surface); |
136 size_t GetStrategyCount(); | 144 size_t GetStrategyCount(); |
137 }; | 145 }; |
138 | 146 |
139 DefaultOverlayProcessor::DefaultOverlayProcessor(OutputSurface* surface) | 147 DefaultOverlayProcessor::DefaultOverlayProcessor(OutputSurface* surface) |
140 : OverlayProcessor(surface) { | 148 : OverlayProcessor(surface) { |
141 } | 149 } |
142 | 150 |
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
295 | 303 |
296 void CreateOpaqueQuadAt(ResourceProvider* resource_provider, | 304 void CreateOpaqueQuadAt(ResourceProvider* resource_provider, |
297 const SharedQuadState* shared_quad_state, | 305 const SharedQuadState* shared_quad_state, |
298 RenderPass* render_pass, | 306 RenderPass* render_pass, |
299 const gfx::Rect& rect) { | 307 const gfx::Rect& rect) { |
300 SolidColorDrawQuad* color_quad = | 308 SolidColorDrawQuad* color_quad = |
301 render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 309 render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
302 color_quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false); | 310 color_quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false); |
303 } | 311 } |
304 | 312 |
| 313 void CreateOpaqueQuadAt(ResourceProvider* resource_provider, |
| 314 const SharedQuadState* shared_quad_state, |
| 315 RenderPass* render_pass, |
| 316 const gfx::Rect& rect, |
| 317 SkColor color) { |
| 318 SolidColorDrawQuad* color_quad = |
| 319 render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
| 320 color_quad->SetNew(shared_quad_state, rect, rect, color, false); |
| 321 } |
| 322 |
305 void CreateFullscreenOpaqueQuad(ResourceProvider* resource_provider, | 323 void CreateFullscreenOpaqueQuad(ResourceProvider* resource_provider, |
306 const SharedQuadState* shared_quad_state, | 324 const SharedQuadState* shared_quad_state, |
307 RenderPass* render_pass) { | 325 RenderPass* render_pass) { |
308 CreateOpaqueQuadAt(resource_provider, shared_quad_state, render_pass, | 326 CreateOpaqueQuadAt(resource_provider, shared_quad_state, render_pass, |
309 render_pass->output_rect); | 327 render_pass->output_rect); |
310 } | 328 } |
311 | 329 |
312 static void CompareRenderPassLists(const RenderPassList& expected_list, | 330 static void CompareRenderPassLists(const RenderPassList& expected_list, |
313 const RenderPassList& actual_list) { | 331 const RenderPassList& actual_list) { |
314 EXPECT_EQ(expected_list.size(), actual_list.size()); | 332 EXPECT_EQ(expected_list.size(), actual_list.size()); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
358 overlay_processor_->Initialize(); | 376 overlay_processor_->Initialize(); |
359 } | 377 } |
360 | 378 |
361 scoped_refptr<TestContextProvider> provider_; | 379 scoped_refptr<TestContextProvider> provider_; |
362 std::unique_ptr<OverlayOutputSurface> output_surface_; | 380 std::unique_ptr<OverlayOutputSurface> output_surface_; |
363 FakeOutputSurfaceClient client_; | 381 FakeOutputSurfaceClient client_; |
364 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; | 382 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; |
365 std::unique_ptr<ResourceProvider> resource_provider_; | 383 std::unique_ptr<ResourceProvider> resource_provider_; |
366 std::unique_ptr<OverlayProcessor> overlay_processor_; | 384 std::unique_ptr<OverlayProcessor> overlay_processor_; |
367 gfx::Rect damage_rect_; | 385 gfx::Rect damage_rect_; |
| 386 std::vector<gfx::Rect> content_bounds_; |
368 }; | 387 }; |
369 | 388 |
370 typedef OverlayTest<FullscreenOverlayValidator> FullscreenOverlayTest; | 389 using FullscreenOverlayTest = OverlayTest<FullscreenOverlayValidator>; |
371 typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest; | 390 using SingleOverlayOnTopTest = OverlayTest<SingleOnTopOverlayValidator>; |
372 typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest; | 391 using UnderlayTest = OverlayTest<UnderlayOverlayValidator>; |
373 typedef OverlayTest<CALayerValidator> CALayerOverlayTest; | 392 using UnderlayCastTest = OverlayTest<UnderlayCastOverlayValidator>; |
| 393 using CALayerOverlayTest = OverlayTest<CALayerValidator>; |
374 | 394 |
375 TEST(OverlayTest, NoOverlaysByDefault) { | 395 TEST(OverlayTest, NoOverlaysByDefault) { |
376 scoped_refptr<TestContextProvider> provider = TestContextProvider::Create(); | 396 scoped_refptr<TestContextProvider> provider = TestContextProvider::Create(); |
377 OverlayOutputSurface output_surface(provider); | 397 OverlayOutputSurface output_surface(provider); |
378 EXPECT_EQ(NULL, output_surface.GetOverlayCandidateValidator()); | 398 EXPECT_EQ(NULL, output_surface.GetOverlayCandidateValidator()); |
379 | 399 |
380 output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator); | 400 output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator); |
381 EXPECT_TRUE(output_surface.GetOverlayCandidateValidator() != NULL); | 401 EXPECT_TRUE(output_surface.GetOverlayCandidateValidator() != NULL); |
382 } | 402 } |
383 | 403 |
(...skipping 26 matching lines...) Expand all Loading... |
410 // Add something behind it. | 430 // Add something behind it. |
411 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 431 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
412 pass->shared_quad_state_list.back(), pass.get()); | 432 pass->shared_quad_state_list.back(), pass.get()); |
413 | 433 |
414 // Check for potential candidates. | 434 // Check for potential candidates. |
415 OverlayCandidateList candidate_list; | 435 OverlayCandidateList candidate_list; |
416 RenderPassFilterList render_pass_filters; | 436 RenderPassFilterList render_pass_filters; |
417 RenderPassFilterList render_pass_background_filters; | 437 RenderPassFilterList render_pass_background_filters; |
418 overlay_processor_->ProcessForOverlays( | 438 overlay_processor_->ProcessForOverlays( |
419 resource_provider_.get(), pass.get(), render_pass_filters, | 439 resource_provider_.get(), pass.get(), render_pass_filters, |
420 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 440 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 441 &content_bounds_); |
421 ASSERT_EQ(1U, candidate_list.size()); | 442 ASSERT_EQ(1U, candidate_list.size()); |
422 | 443 |
423 RenderPass* main_pass = pass.get(); | 444 RenderPass* main_pass = pass.get(); |
424 // Check that all the quads are gone. | 445 // Check that all the quads are gone. |
425 EXPECT_EQ(0U, main_pass->quad_list.size()); | 446 EXPECT_EQ(0U, main_pass->quad_list.size()); |
426 // Check that we have only one overlay. | 447 // Check that we have only one overlay. |
427 EXPECT_EQ(1U, candidate_list.size()); | 448 EXPECT_EQ(1U, candidate_list.size()); |
428 // Check that the right resource id got extracted. | 449 // Check that the right resource id got extracted. |
429 EXPECT_EQ(original_resource_id, candidate_list.front().resource_id); | 450 EXPECT_EQ(original_resource_id, candidate_list.front().resource_id); |
430 } | 451 } |
431 | 452 |
432 TEST_F(FullscreenOverlayTest, ResourceSizeInPixelsFail) { | 453 TEST_F(FullscreenOverlayTest, ResourceSizeInPixelsFail) { |
433 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 454 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
434 TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad( | 455 TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad( |
435 resource_provider_.get(), pass->shared_quad_state_list.back(), | 456 resource_provider_.get(), pass->shared_quad_state_list.back(), |
436 pass.get()); | 457 pass.get()); |
437 original_quad->set_resource_size_in_pixels(gfx::Size(64, 64)); | 458 original_quad->set_resource_size_in_pixels(gfx::Size(64, 64)); |
438 | 459 |
439 // Check for potential candidates. | 460 // Check for potential candidates. |
440 OverlayCandidateList candidate_list; | 461 OverlayCandidateList candidate_list; |
441 RenderPassFilterList render_pass_filters; | 462 RenderPassFilterList render_pass_filters; |
442 RenderPassFilterList render_pass_background_filters; | 463 RenderPassFilterList render_pass_background_filters; |
443 overlay_processor_->ProcessForOverlays( | 464 overlay_processor_->ProcessForOverlays( |
444 resource_provider_.get(), pass.get(), render_pass_filters, | 465 resource_provider_.get(), pass.get(), render_pass_filters, |
445 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 466 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 467 &content_bounds_); |
446 ASSERT_EQ(0U, candidate_list.size()); | 468 ASSERT_EQ(0U, candidate_list.size()); |
447 | 469 |
448 RenderPass* main_pass = pass.get(); | 470 RenderPass* main_pass = pass.get(); |
449 // Check that the quad is not gone. | 471 // Check that the quad is not gone. |
450 EXPECT_EQ(1U, main_pass->quad_list.size()); | 472 EXPECT_EQ(1U, main_pass->quad_list.size()); |
451 } | 473 } |
452 | 474 |
453 TEST_F(FullscreenOverlayTest, OnTopFail) { | 475 TEST_F(FullscreenOverlayTest, OnTopFail) { |
454 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 476 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
455 | 477 |
456 // Add something in front of it. | 478 // Add something in front of it. |
457 CreateOpaqueQuadAt(resource_provider_.get(), | 479 CreateOpaqueQuadAt(resource_provider_.get(), |
458 pass->shared_quad_state_list.back(), pass.get(), | 480 pass->shared_quad_state_list.back(), pass.get(), |
459 kOverlayTopLeftRect); | 481 kOverlayTopLeftRect); |
460 | 482 |
461 CreateFullscreenCandidateQuad(resource_provider_.get(), | 483 CreateFullscreenCandidateQuad(resource_provider_.get(), |
462 pass->shared_quad_state_list.back(), | 484 pass->shared_quad_state_list.back(), |
463 pass.get()); | 485 pass.get()); |
464 | 486 |
465 // Check for potential candidates. | 487 // Check for potential candidates. |
466 OverlayCandidateList candidate_list; | 488 OverlayCandidateList candidate_list; |
467 RenderPassFilterList render_pass_filters; | 489 RenderPassFilterList render_pass_filters; |
468 RenderPassFilterList render_pass_background_filters; | 490 RenderPassFilterList render_pass_background_filters; |
469 overlay_processor_->ProcessForOverlays( | 491 overlay_processor_->ProcessForOverlays( |
470 resource_provider_.get(), pass.get(), render_pass_filters, | 492 resource_provider_.get(), pass.get(), render_pass_filters, |
471 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 493 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 494 &content_bounds_); |
472 ASSERT_EQ(0U, candidate_list.size()); | 495 ASSERT_EQ(0U, candidate_list.size()); |
473 | 496 |
474 RenderPass* main_pass = pass.get(); | 497 RenderPass* main_pass = pass.get(); |
475 // Check that the 2 quads are not gone. | 498 // Check that the 2 quads are not gone. |
476 EXPECT_EQ(2U, main_pass->quad_list.size()); | 499 EXPECT_EQ(2U, main_pass->quad_list.size()); |
477 } | 500 } |
478 | 501 |
479 TEST_F(FullscreenOverlayTest, NotCoveringFullscreenFail) { | 502 TEST_F(FullscreenOverlayTest, NotCoveringFullscreenFail) { |
480 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 503 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
481 gfx::Rect inset_rect = pass->output_rect; | 504 gfx::Rect inset_rect = pass->output_rect; |
482 inset_rect.Inset(0, 1, 0, 1); | 505 inset_rect.Inset(0, 1, 0, 1); |
483 CreateCandidateQuadAt(resource_provider_.get(), | 506 CreateCandidateQuadAt(resource_provider_.get(), |
484 pass->shared_quad_state_list.back(), pass.get(), | 507 pass->shared_quad_state_list.back(), pass.get(), |
485 inset_rect); | 508 inset_rect); |
486 | 509 |
487 // Check for potential candidates. | 510 // Check for potential candidates. |
488 OverlayCandidateList candidate_list; | 511 OverlayCandidateList candidate_list; |
489 RenderPassFilterList render_pass_filters; | 512 RenderPassFilterList render_pass_filters; |
490 RenderPassFilterList render_pass_background_filters; | 513 RenderPassFilterList render_pass_background_filters; |
491 overlay_processor_->ProcessForOverlays( | 514 overlay_processor_->ProcessForOverlays( |
492 resource_provider_.get(), pass.get(), render_pass_filters, | 515 resource_provider_.get(), pass.get(), render_pass_filters, |
493 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 516 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 517 &content_bounds_); |
494 ASSERT_EQ(0U, candidate_list.size()); | 518 ASSERT_EQ(0U, candidate_list.size()); |
495 | 519 |
496 RenderPass* main_pass = pass.get(); | 520 RenderPass* main_pass = pass.get(); |
497 // Check that the quad is not gone. | 521 // Check that the quad is not gone. |
498 EXPECT_EQ(1U, main_pass->quad_list.size()); | 522 EXPECT_EQ(1U, main_pass->quad_list.size()); |
499 } | 523 } |
500 | 524 |
501 TEST_F(FullscreenOverlayTest, RemoveFullscreenQuadFromQuadList) { | 525 TEST_F(FullscreenOverlayTest, RemoveFullscreenQuadFromQuadList) { |
502 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 526 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
503 | 527 |
504 // Add something in front of it that is fully transparent. | 528 // Add something in front of it that is fully transparent. |
505 pass->shared_quad_state_list.back()->opacity = 0.0f; | 529 pass->shared_quad_state_list.back()->opacity = 0.0f; |
506 CreateOpaqueQuadAt(resource_provider_.get(), | 530 CreateOpaqueQuadAt(resource_provider_.get(), |
507 pass->shared_quad_state_list.back(), pass.get(), | 531 pass->shared_quad_state_list.back(), pass.get(), |
508 kOverlayTopLeftRect); | 532 kOverlayTopLeftRect); |
509 | 533 |
510 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 534 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
511 shared_state->opacity = 1.f; | 535 shared_state->opacity = 1.f; |
512 CreateFullscreenCandidateQuad(resource_provider_.get(), | 536 CreateFullscreenCandidateQuad(resource_provider_.get(), |
513 pass->shared_quad_state_list.back(), | 537 pass->shared_quad_state_list.back(), |
514 pass.get()); | 538 pass.get()); |
515 | 539 |
516 // Check for potential candidates. | 540 // Check for potential candidates. |
517 OverlayCandidateList candidate_list; | 541 OverlayCandidateList candidate_list; |
518 RenderPassFilterList render_pass_filters; | 542 RenderPassFilterList render_pass_filters; |
519 RenderPassFilterList render_pass_background_filters; | 543 RenderPassFilterList render_pass_background_filters; |
520 overlay_processor_->ProcessForOverlays( | 544 overlay_processor_->ProcessForOverlays( |
521 resource_provider_.get(), pass.get(), render_pass_filters, | 545 resource_provider_.get(), pass.get(), render_pass_filters, |
522 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 546 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 547 &content_bounds_); |
523 ASSERT_EQ(1U, candidate_list.size()); | 548 ASSERT_EQ(1U, candidate_list.size()); |
524 | 549 |
525 // Check that the fullscreen quad is gone. | 550 // Check that the fullscreen quad is gone. |
526 for (const DrawQuad* quad : pass->quad_list) { | 551 for (const DrawQuad* quad : pass->quad_list) { |
527 EXPECT_NE(pass->output_rect, quad->rect); | 552 EXPECT_NE(pass->output_rect, quad->rect); |
528 } | 553 } |
529 } | 554 } |
530 | 555 |
531 TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) { | 556 TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) { |
532 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 557 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
533 TextureDrawQuad* original_quad = | 558 TextureDrawQuad* original_quad = |
534 CreateFullscreenCandidateQuad(resource_provider_.get(), | 559 CreateFullscreenCandidateQuad(resource_provider_.get(), |
535 pass->shared_quad_state_list.back(), | 560 pass->shared_quad_state_list.back(), |
536 pass.get()); | 561 pass.get()); |
537 unsigned original_resource_id = original_quad->resource_id(); | 562 unsigned original_resource_id = original_quad->resource_id(); |
538 | 563 |
539 // Add something behind it. | 564 // Add something behind it. |
540 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 565 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
541 pass->shared_quad_state_list.back(), pass.get()); | 566 pass->shared_quad_state_list.back(), pass.get()); |
542 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 567 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
543 pass->shared_quad_state_list.back(), pass.get()); | 568 pass->shared_quad_state_list.back(), pass.get()); |
544 | 569 |
545 // Check for potential candidates. | 570 // Check for potential candidates. |
546 OverlayCandidateList candidate_list; | 571 OverlayCandidateList candidate_list; |
547 RenderPassFilterList render_pass_filters; | 572 RenderPassFilterList render_pass_filters; |
548 RenderPassFilterList render_pass_background_filters; | 573 RenderPassFilterList render_pass_background_filters; |
549 overlay_processor_->ProcessForOverlays( | 574 overlay_processor_->ProcessForOverlays( |
550 resource_provider_.get(), pass.get(), render_pass_filters, | 575 resource_provider_.get(), pass.get(), render_pass_filters, |
551 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 576 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 577 &content_bounds_); |
552 ASSERT_EQ(1U, candidate_list.size()); | 578 ASSERT_EQ(1U, candidate_list.size()); |
553 | 579 |
554 RenderPass* main_pass = pass.get(); | 580 RenderPass* main_pass = pass.get(); |
555 // Check that the quad is gone. | 581 // Check that the quad is gone. |
556 EXPECT_EQ(2U, main_pass->quad_list.size()); | 582 EXPECT_EQ(2U, main_pass->quad_list.size()); |
557 const QuadList& quad_list = main_pass->quad_list; | 583 const QuadList& quad_list = main_pass->quad_list; |
558 for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin(); | 584 for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin(); |
559 it != quad_list.BackToFrontEnd(); | 585 it != quad_list.BackToFrontEnd(); |
560 ++it) { | 586 ++it) { |
561 EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material); | 587 EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material); |
(...skipping 24 matching lines...) Expand all Loading... |
586 output_surface_plane.display_rect = gfx::RectF(kOverlayRect); | 612 output_surface_plane.display_rect = gfx::RectF(kOverlayRect); |
587 output_surface_plane.quad_rect_in_target_space = kOverlayRect; | 613 output_surface_plane.quad_rect_in_target_space = kOverlayRect; |
588 output_surface_plane.use_output_surface_for_resource = true; | 614 output_surface_plane.use_output_surface_for_resource = true; |
589 output_surface_plane.overlay_handled = true; | 615 output_surface_plane.overlay_handled = true; |
590 candidate_list.push_back(output_surface_plane); | 616 candidate_list.push_back(output_surface_plane); |
591 | 617 |
592 RenderPassFilterList render_pass_filters; | 618 RenderPassFilterList render_pass_filters; |
593 RenderPassFilterList render_pass_background_filters; | 619 RenderPassFilterList render_pass_background_filters; |
594 overlay_processor_->ProcessForOverlays( | 620 overlay_processor_->ProcessForOverlays( |
595 resource_provider_.get(), pass.get(), render_pass_filters, | 621 resource_provider_.get(), pass.get(), render_pass_filters, |
596 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 622 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 623 &content_bounds_); |
597 DCHECK(damage_rect_.IsEmpty()); | 624 DCHECK(damage_rect_.IsEmpty()); |
598 } | 625 } |
599 | 626 |
600 TEST_F(SingleOverlayOnTopTest, NoCandidates) { | 627 TEST_F(SingleOverlayOnTopTest, NoCandidates) { |
601 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 628 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
602 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 629 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
603 pass->shared_quad_state_list.back(), pass.get()); | 630 pass->shared_quad_state_list.back(), pass.get()); |
604 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 631 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
605 pass->shared_quad_state_list.back(), pass.get()); | 632 pass->shared_quad_state_list.back(), pass.get()); |
606 | 633 |
607 RenderPassList pass_list; | 634 RenderPassList pass_list; |
608 pass_list.push_back(std::move(pass)); | 635 pass_list.push_back(std::move(pass)); |
609 | 636 |
610 RenderPassList original_pass_list; | 637 RenderPassList original_pass_list; |
611 RenderPass::CopyAll(pass_list, &original_pass_list); | 638 RenderPass::CopyAll(pass_list, &original_pass_list); |
612 | 639 |
613 OverlayCandidateList candidate_list; | 640 OverlayCandidateList candidate_list; |
614 RenderPassFilterList render_pass_filters; | 641 RenderPassFilterList render_pass_filters; |
615 RenderPassFilterList render_pass_background_filters; | 642 RenderPassFilterList render_pass_background_filters; |
616 overlay_processor_->ProcessForOverlays( | 643 overlay_processor_->ProcessForOverlays( |
617 resource_provider_.get(), pass_list.back().get(), render_pass_filters, | 644 resource_provider_.get(), pass_list.back().get(), render_pass_filters, |
618 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 645 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 646 &content_bounds_); |
619 EXPECT_EQ(0U, candidate_list.size()); | 647 EXPECT_EQ(0U, candidate_list.size()); |
620 // There should be nothing new here. | 648 // There should be nothing new here. |
621 CompareRenderPassLists(pass_list, original_pass_list); | 649 CompareRenderPassLists(pass_list, original_pass_list); |
622 } | 650 } |
623 | 651 |
624 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) { | 652 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) { |
625 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 653 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
626 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 654 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
627 pass->shared_quad_state_list.back(), pass.get()); | 655 pass->shared_quad_state_list.back(), pass.get()); |
628 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 656 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
629 pass->shared_quad_state_list.back(), pass.get()); | 657 pass->shared_quad_state_list.back(), pass.get()); |
630 | 658 |
631 CreateFullscreenCandidateQuad(resource_provider_.get(), | 659 CreateFullscreenCandidateQuad(resource_provider_.get(), |
632 pass->shared_quad_state_list.back(), | 660 pass->shared_quad_state_list.back(), |
633 pass.get()); | 661 pass.get()); |
634 | 662 |
635 RenderPassList pass_list; | 663 RenderPassList pass_list; |
636 pass_list.push_back(std::move(pass)); | 664 pass_list.push_back(std::move(pass)); |
637 | 665 |
638 RenderPassList original_pass_list; | 666 RenderPassList original_pass_list; |
639 RenderPass::CopyAll(pass_list, &original_pass_list); | 667 RenderPass::CopyAll(pass_list, &original_pass_list); |
640 | 668 |
641 OverlayCandidateList candidate_list; | 669 OverlayCandidateList candidate_list; |
642 RenderPassFilterList render_pass_filters; | 670 RenderPassFilterList render_pass_filters; |
643 RenderPassFilterList render_pass_background_filters; | 671 RenderPassFilterList render_pass_background_filters; |
644 overlay_processor_->ProcessForOverlays( | 672 overlay_processor_->ProcessForOverlays( |
645 resource_provider_.get(), pass_list.back().get(), render_pass_filters, | 673 resource_provider_.get(), pass_list.back().get(), render_pass_filters, |
646 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 674 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 675 &content_bounds_); |
647 EXPECT_EQ(0U, candidate_list.size()); | 676 EXPECT_EQ(0U, candidate_list.size()); |
648 // There should be nothing new here. | 677 // There should be nothing new here. |
649 CompareRenderPassLists(pass_list, original_pass_list); | 678 CompareRenderPassLists(pass_list, original_pass_list); |
650 } | 679 } |
651 | 680 |
652 // Test with multiple render passes. | 681 // Test with multiple render passes. |
653 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) { | 682 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) { |
654 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 683 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
655 CreateFullscreenCandidateQuad(resource_provider_.get(), | 684 CreateFullscreenCandidateQuad(resource_provider_.get(), |
656 pass->shared_quad_state_list.back(), | 685 pass->shared_quad_state_list.back(), |
657 pass.get()); | 686 pass.get()); |
658 | 687 |
659 // Add something behind it. | 688 // Add something behind it. |
660 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 689 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
661 pass->shared_quad_state_list.back(), pass.get()); | 690 pass->shared_quad_state_list.back(), pass.get()); |
662 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 691 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
663 pass->shared_quad_state_list.back(), pass.get()); | 692 pass->shared_quad_state_list.back(), pass.get()); |
664 | 693 |
665 // Check for potential candidates. | 694 // Check for potential candidates. |
666 OverlayCandidateList candidate_list; | 695 OverlayCandidateList candidate_list; |
667 RenderPassFilterList render_pass_filters; | 696 RenderPassFilterList render_pass_filters; |
668 RenderPassFilterList render_pass_background_filters; | 697 RenderPassFilterList render_pass_background_filters; |
669 overlay_processor_->ProcessForOverlays( | 698 overlay_processor_->ProcessForOverlays( |
670 resource_provider_.get(), pass.get(), render_pass_filters, | 699 resource_provider_.get(), pass.get(), render_pass_filters, |
671 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 700 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 701 &content_bounds_); |
672 EXPECT_EQ(1U, candidate_list.size()); | 702 EXPECT_EQ(1U, candidate_list.size()); |
673 } | 703 } |
674 | 704 |
675 TEST_F(SingleOverlayOnTopTest, RejectBlending) { | 705 TEST_F(SingleOverlayOnTopTest, RejectBlending) { |
676 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 706 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
677 TextureDrawQuad* quad = | 707 TextureDrawQuad* quad = |
678 CreateFullscreenCandidateQuad(resource_provider_.get(), | 708 CreateFullscreenCandidateQuad(resource_provider_.get(), |
679 pass->shared_quad_state_list.back(), | 709 pass->shared_quad_state_list.back(), |
680 pass.get()); | 710 pass.get()); |
681 quad->needs_blending = true; | 711 quad->needs_blending = true; |
682 | 712 |
683 OverlayCandidateList candidate_list; | 713 OverlayCandidateList candidate_list; |
684 RenderPassFilterList render_pass_filters; | 714 RenderPassFilterList render_pass_filters; |
685 RenderPassFilterList render_pass_background_filters; | 715 RenderPassFilterList render_pass_background_filters; |
686 overlay_processor_->ProcessForOverlays( | 716 overlay_processor_->ProcessForOverlays( |
687 resource_provider_.get(), pass.get(), render_pass_filters, | 717 resource_provider_.get(), pass.get(), render_pass_filters, |
688 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 718 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 719 &content_bounds_); |
689 EXPECT_EQ(0U, candidate_list.size()); | 720 EXPECT_EQ(0U, candidate_list.size()); |
690 } | 721 } |
691 | 722 |
692 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) { | 723 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) { |
693 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 724 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
694 TextureDrawQuad* quad = | 725 TextureDrawQuad* quad = |
695 CreateFullscreenCandidateQuad(resource_provider_.get(), | 726 CreateFullscreenCandidateQuad(resource_provider_.get(), |
696 pass->shared_quad_state_list.back(), | 727 pass->shared_quad_state_list.back(), |
697 pass.get()); | 728 pass.get()); |
698 quad->background_color = SK_ColorBLACK; | 729 quad->background_color = SK_ColorBLACK; |
699 | 730 |
700 OverlayCandidateList candidate_list; | 731 OverlayCandidateList candidate_list; |
701 RenderPassFilterList render_pass_filters; | 732 RenderPassFilterList render_pass_filters; |
702 RenderPassFilterList render_pass_background_filters; | 733 RenderPassFilterList render_pass_background_filters; |
703 overlay_processor_->ProcessForOverlays( | 734 overlay_processor_->ProcessForOverlays( |
704 resource_provider_.get(), pass.get(), render_pass_filters, | 735 resource_provider_.get(), pass.get(), render_pass_filters, |
705 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 736 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 737 &content_bounds_); |
706 EXPECT_EQ(0U, candidate_list.size()); | 738 EXPECT_EQ(0U, candidate_list.size()); |
707 } | 739 } |
708 | 740 |
709 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) { | 741 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) { |
710 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 742 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
711 CreateFullscreenCandidateQuad(resource_provider_.get(), | 743 CreateFullscreenCandidateQuad(resource_provider_.get(), |
712 pass->shared_quad_state_list.back(), | 744 pass->shared_quad_state_list.back(), |
713 pass.get()); | 745 pass.get()); |
714 pass->shared_quad_state_list.back()->blend_mode = SkBlendMode::kScreen; | 746 pass->shared_quad_state_list.back()->blend_mode = SkBlendMode::kScreen; |
715 | 747 |
716 OverlayCandidateList candidate_list; | 748 OverlayCandidateList candidate_list; |
717 RenderPassFilterList render_pass_filters; | 749 RenderPassFilterList render_pass_filters; |
718 RenderPassFilterList render_pass_background_filters; | 750 RenderPassFilterList render_pass_background_filters; |
719 overlay_processor_->ProcessForOverlays( | 751 overlay_processor_->ProcessForOverlays( |
720 resource_provider_.get(), pass.get(), render_pass_filters, | 752 resource_provider_.get(), pass.get(), render_pass_filters, |
721 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 753 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 754 &content_bounds_); |
722 EXPECT_EQ(0U, candidate_list.size()); | 755 EXPECT_EQ(0U, candidate_list.size()); |
723 } | 756 } |
724 | 757 |
725 TEST_F(SingleOverlayOnTopTest, RejectOpacity) { | 758 TEST_F(SingleOverlayOnTopTest, RejectOpacity) { |
726 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 759 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
727 CreateFullscreenCandidateQuad(resource_provider_.get(), | 760 CreateFullscreenCandidateQuad(resource_provider_.get(), |
728 pass->shared_quad_state_list.back(), | 761 pass->shared_quad_state_list.back(), |
729 pass.get()); | 762 pass.get()); |
730 pass->shared_quad_state_list.back()->opacity = 0.5f; | 763 pass->shared_quad_state_list.back()->opacity = 0.5f; |
731 | 764 |
732 OverlayCandidateList candidate_list; | 765 OverlayCandidateList candidate_list; |
733 RenderPassFilterList render_pass_filters; | 766 RenderPassFilterList render_pass_filters; |
734 RenderPassFilterList render_pass_background_filters; | 767 RenderPassFilterList render_pass_background_filters; |
735 overlay_processor_->ProcessForOverlays( | 768 overlay_processor_->ProcessForOverlays( |
736 resource_provider_.get(), pass.get(), render_pass_filters, | 769 resource_provider_.get(), pass.get(), render_pass_filters, |
737 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 770 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 771 &content_bounds_); |
738 EXPECT_EQ(0U, candidate_list.size()); | 772 EXPECT_EQ(0U, candidate_list.size()); |
739 } | 773 } |
740 | 774 |
741 TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) { | 775 TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) { |
742 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 776 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
743 CreateFullscreenCandidateQuad(resource_provider_.get(), | 777 CreateFullscreenCandidateQuad(resource_provider_.get(), |
744 pass->shared_quad_state_list.back(), | 778 pass->shared_quad_state_list.back(), |
745 pass.get()); | 779 pass.get()); |
746 pass->shared_quad_state_list.back() | 780 pass->shared_quad_state_list.back() |
747 ->quad_to_target_transform.RotateAboutXAxis(45.f); | 781 ->quad_to_target_transform.RotateAboutXAxis(45.f); |
748 | 782 |
749 OverlayCandidateList candidate_list; | 783 OverlayCandidateList candidate_list; |
750 RenderPassFilterList render_pass_filters; | 784 RenderPassFilterList render_pass_filters; |
751 RenderPassFilterList render_pass_background_filters; | 785 RenderPassFilterList render_pass_background_filters; |
752 overlay_processor_->ProcessForOverlays( | 786 overlay_processor_->ProcessForOverlays( |
753 resource_provider_.get(), pass.get(), render_pass_filters, | 787 resource_provider_.get(), pass.get(), render_pass_filters, |
754 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 788 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 789 &content_bounds_); |
755 EXPECT_EQ(0U, candidate_list.size()); | 790 EXPECT_EQ(0U, candidate_list.size()); |
756 } | 791 } |
757 | 792 |
758 TEST_F(SingleOverlayOnTopTest, AllowClipped) { | 793 TEST_F(SingleOverlayOnTopTest, AllowClipped) { |
759 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 794 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
760 CreateFullscreenCandidateQuad(resource_provider_.get(), | 795 CreateFullscreenCandidateQuad(resource_provider_.get(), |
761 pass->shared_quad_state_list.back(), | 796 pass->shared_quad_state_list.back(), |
762 pass.get()); | 797 pass.get()); |
763 pass->shared_quad_state_list.back()->is_clipped = true; | 798 pass->shared_quad_state_list.back()->is_clipped = true; |
764 pass->shared_quad_state_list.back()->clip_rect = kOverlayClipRect; | 799 pass->shared_quad_state_list.back()->clip_rect = kOverlayClipRect; |
765 | 800 |
766 OverlayCandidateList candidate_list; | 801 OverlayCandidateList candidate_list; |
767 RenderPassFilterList render_pass_filters; | 802 RenderPassFilterList render_pass_filters; |
768 RenderPassFilterList render_pass_background_filters; | 803 RenderPassFilterList render_pass_background_filters; |
769 overlay_processor_->ProcessForOverlays( | 804 overlay_processor_->ProcessForOverlays( |
770 resource_provider_.get(), pass.get(), render_pass_filters, | 805 resource_provider_.get(), pass.get(), render_pass_filters, |
771 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 806 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 807 &content_bounds_); |
772 EXPECT_EQ(1U, candidate_list.size()); | 808 EXPECT_EQ(1U, candidate_list.size()); |
773 } | 809 } |
774 | 810 |
775 TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) { | 811 TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) { |
776 gfx::Rect rect = kOverlayRect; | 812 gfx::Rect rect = kOverlayRect; |
777 rect.set_width(rect.width() / 2); | 813 rect.set_width(rect.width() / 2); |
778 rect.Offset(0, -rect.height()); | 814 rect.Offset(0, -rect.height()); |
779 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 815 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
780 CreateCandidateQuadAt(resource_provider_.get(), | 816 CreateCandidateQuadAt(resource_provider_.get(), |
781 pass->shared_quad_state_list.back(), pass.get(), rect); | 817 pass->shared_quad_state_list.back(), pass.get(), rect); |
782 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, | 818 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, |
783 -1.0f); | 819 -1.0f); |
784 OverlayCandidateList candidate_list; | 820 OverlayCandidateList candidate_list; |
785 RenderPassFilterList render_pass_filters; | 821 RenderPassFilterList render_pass_filters; |
786 RenderPassFilterList render_pass_background_filters; | 822 RenderPassFilterList render_pass_background_filters; |
787 overlay_processor_->ProcessForOverlays( | 823 overlay_processor_->ProcessForOverlays( |
788 resource_provider_.get(), pass.get(), render_pass_filters, | 824 resource_provider_.get(), pass.get(), render_pass_filters, |
789 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 825 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 826 &content_bounds_); |
790 ASSERT_EQ(1U, candidate_list.size()); | 827 ASSERT_EQ(1U, candidate_list.size()); |
791 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL, | 828 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL, |
792 candidate_list.back().transform); | 829 candidate_list.back().transform); |
793 } | 830 } |
794 | 831 |
795 TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) { | 832 TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) { |
796 gfx::Rect rect = kOverlayRect; | 833 gfx::Rect rect = kOverlayRect; |
797 rect.set_height(rect.height() / 2); | 834 rect.set_height(rect.height() / 2); |
798 rect.Offset(-rect.width(), 0); | 835 rect.Offset(-rect.width(), 0); |
799 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 836 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
800 CreateCandidateQuadAt(resource_provider_.get(), | 837 CreateCandidateQuadAt(resource_provider_.get(), |
801 pass->shared_quad_state_list.back(), pass.get(), rect); | 838 pass->shared_quad_state_list.back(), pass.get(), rect); |
802 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(-1.0f, | 839 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(-1.0f, |
803 2.0f); | 840 2.0f); |
804 | 841 |
805 OverlayCandidateList candidate_list; | 842 OverlayCandidateList candidate_list; |
806 RenderPassFilterList render_pass_filters; | 843 RenderPassFilterList render_pass_filters; |
807 RenderPassFilterList render_pass_background_filters; | 844 RenderPassFilterList render_pass_background_filters; |
808 overlay_processor_->ProcessForOverlays( | 845 overlay_processor_->ProcessForOverlays( |
809 resource_provider_.get(), pass.get(), render_pass_filters, | 846 resource_provider_.get(), pass.get(), render_pass_filters, |
810 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 847 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 848 &content_bounds_); |
811 ASSERT_EQ(1U, candidate_list.size()); | 849 ASSERT_EQ(1U, candidate_list.size()); |
812 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL, | 850 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL, |
813 candidate_list.back().transform); | 851 candidate_list.back().transform); |
814 } | 852 } |
815 | 853 |
816 TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) { | 854 TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) { |
817 gfx::Rect rect = kOverlayRect; | 855 gfx::Rect rect = kOverlayRect; |
818 rect.set_width(rect.width() / 2); | 856 rect.set_width(rect.width() / 2); |
819 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 857 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
820 CreateCandidateQuadAt(resource_provider_.get(), | 858 CreateCandidateQuadAt(resource_provider_.get(), |
821 pass->shared_quad_state_list.back(), pass.get(), rect); | 859 pass->shared_quad_state_list.back(), pass.get(), rect); |
822 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, | 860 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, |
823 1.0f); | 861 1.0f); |
824 OverlayCandidateList candidate_list; | 862 OverlayCandidateList candidate_list; |
825 RenderPassFilterList render_pass_filters; | 863 RenderPassFilterList render_pass_filters; |
826 RenderPassFilterList render_pass_background_filters; | 864 RenderPassFilterList render_pass_background_filters; |
827 overlay_processor_->ProcessForOverlays( | 865 overlay_processor_->ProcessForOverlays( |
828 resource_provider_.get(), pass.get(), render_pass_filters, | 866 resource_provider_.get(), pass.get(), render_pass_filters, |
829 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 867 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 868 &content_bounds_); |
830 EXPECT_EQ(1U, candidate_list.size()); | 869 EXPECT_EQ(1U, candidate_list.size()); |
831 } | 870 } |
832 | 871 |
833 TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) { | 872 TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) { |
834 gfx::Rect rect = kOverlayRect; | 873 gfx::Rect rect = kOverlayRect; |
835 rect.Offset(0, -rect.height()); | 874 rect.Offset(0, -rect.height()); |
836 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 875 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
837 CreateCandidateQuadAt(resource_provider_.get(), | 876 CreateCandidateQuadAt(resource_provider_.get(), |
838 pass->shared_quad_state_list.back(), pass.get(), rect); | 877 pass->shared_quad_state_list.back(), pass.get(), rect); |
839 pass->shared_quad_state_list.back() | 878 pass->shared_quad_state_list.back() |
840 ->quad_to_target_transform.RotateAboutZAxis(90.f); | 879 ->quad_to_target_transform.RotateAboutZAxis(90.f); |
841 | 880 |
842 OverlayCandidateList candidate_list; | 881 OverlayCandidateList candidate_list; |
843 RenderPassFilterList render_pass_filters; | 882 RenderPassFilterList render_pass_filters; |
844 RenderPassFilterList render_pass_background_filters; | 883 RenderPassFilterList render_pass_background_filters; |
845 overlay_processor_->ProcessForOverlays( | 884 overlay_processor_->ProcessForOverlays( |
846 resource_provider_.get(), pass.get(), render_pass_filters, | 885 resource_provider_.get(), pass.get(), render_pass_filters, |
847 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 886 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 887 &content_bounds_); |
848 ASSERT_EQ(1U, candidate_list.size()); | 888 ASSERT_EQ(1U, candidate_list.size()); |
849 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform); | 889 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform); |
850 } | 890 } |
851 | 891 |
852 TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) { | 892 TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) { |
853 gfx::Rect rect = kOverlayRect; | 893 gfx::Rect rect = kOverlayRect; |
854 rect.Offset(-rect.width(), -rect.height()); | 894 rect.Offset(-rect.width(), -rect.height()); |
855 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 895 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
856 CreateCandidateQuadAt(resource_provider_.get(), | 896 CreateCandidateQuadAt(resource_provider_.get(), |
857 pass->shared_quad_state_list.back(), pass.get(), rect); | 897 pass->shared_quad_state_list.back(), pass.get(), rect); |
858 pass->shared_quad_state_list.back() | 898 pass->shared_quad_state_list.back() |
859 ->quad_to_target_transform.RotateAboutZAxis(180.f); | 899 ->quad_to_target_transform.RotateAboutZAxis(180.f); |
860 | 900 |
861 OverlayCandidateList candidate_list; | 901 OverlayCandidateList candidate_list; |
862 RenderPassFilterList render_pass_filters; | 902 RenderPassFilterList render_pass_filters; |
863 RenderPassFilterList render_pass_background_filters; | 903 RenderPassFilterList render_pass_background_filters; |
864 overlay_processor_->ProcessForOverlays( | 904 overlay_processor_->ProcessForOverlays( |
865 resource_provider_.get(), pass.get(), render_pass_filters, | 905 resource_provider_.get(), pass.get(), render_pass_filters, |
866 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 906 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 907 &content_bounds_); |
867 ASSERT_EQ(1U, candidate_list.size()); | 908 ASSERT_EQ(1U, candidate_list.size()); |
868 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform); | 909 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform); |
869 } | 910 } |
870 | 911 |
871 TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) { | 912 TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) { |
872 gfx::Rect rect = kOverlayRect; | 913 gfx::Rect rect = kOverlayRect; |
873 rect.Offset(-rect.width(), 0); | 914 rect.Offset(-rect.width(), 0); |
874 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 915 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
875 CreateCandidateQuadAt(resource_provider_.get(), | 916 CreateCandidateQuadAt(resource_provider_.get(), |
876 pass->shared_quad_state_list.back(), pass.get(), rect); | 917 pass->shared_quad_state_list.back(), pass.get(), rect); |
877 pass->shared_quad_state_list.back() | 918 pass->shared_quad_state_list.back() |
878 ->quad_to_target_transform.RotateAboutZAxis(270.f); | 919 ->quad_to_target_transform.RotateAboutZAxis(270.f); |
879 | 920 |
880 OverlayCandidateList candidate_list; | 921 OverlayCandidateList candidate_list; |
881 RenderPassFilterList render_pass_filters; | 922 RenderPassFilterList render_pass_filters; |
882 RenderPassFilterList render_pass_background_filters; | 923 RenderPassFilterList render_pass_background_filters; |
883 overlay_processor_->ProcessForOverlays( | 924 overlay_processor_->ProcessForOverlays( |
884 resource_provider_.get(), pass.get(), render_pass_filters, | 925 resource_provider_.get(), pass.get(), render_pass_filters, |
885 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 926 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 927 &content_bounds_); |
886 ASSERT_EQ(1U, candidate_list.size()); | 928 ASSERT_EQ(1U, candidate_list.size()); |
887 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform); | 929 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform); |
888 } | 930 } |
889 | 931 |
890 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) { | 932 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) { |
891 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 933 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
892 CreateOpaqueQuadAt(resource_provider_.get(), | 934 CreateOpaqueQuadAt(resource_provider_.get(), |
893 pass->shared_quad_state_list.back(), pass.get(), | 935 pass->shared_quad_state_list.back(), pass.get(), |
894 kOverlayTopLeftRect); | 936 kOverlayTopLeftRect); |
895 CreateCandidateQuadAt(resource_provider_.get(), | 937 CreateCandidateQuadAt(resource_provider_.get(), |
896 pass->shared_quad_state_list.back(), | 938 pass->shared_quad_state_list.back(), |
897 pass.get(), | 939 pass.get(), |
898 kOverlayBottomRightRect); | 940 kOverlayBottomRightRect); |
899 | 941 |
900 OverlayCandidateList candidate_list; | 942 OverlayCandidateList candidate_list; |
901 RenderPassFilterList render_pass_filters; | 943 RenderPassFilterList render_pass_filters; |
902 RenderPassFilterList render_pass_background_filters; | 944 RenderPassFilterList render_pass_background_filters; |
903 overlay_processor_->ProcessForOverlays( | 945 overlay_processor_->ProcessForOverlays( |
904 resource_provider_.get(), pass.get(), render_pass_filters, | 946 resource_provider_.get(), pass.get(), render_pass_filters, |
905 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 947 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 948 &content_bounds_); |
906 EXPECT_EQ(1U, candidate_list.size()); | 949 EXPECT_EQ(1U, candidate_list.size()); |
907 } | 950 } |
908 | 951 |
909 TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) { | 952 TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) { |
910 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 953 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
911 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 954 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
912 shared_state->opacity = 0.f; | 955 shared_state->opacity = 0.f; |
913 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), | 956 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), |
914 kOverlayBottomRightRect); | 957 kOverlayBottomRightRect); |
915 shared_state = pass->CreateAndAppendSharedQuadState(); | 958 shared_state = pass->CreateAndAppendSharedQuadState(); |
916 shared_state->opacity = 1.f; | 959 shared_state->opacity = 1.f; |
917 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), | 960 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), |
918 kOverlayBottomRightRect); | 961 kOverlayBottomRightRect); |
919 | 962 |
920 OverlayCandidateList candidate_list; | 963 OverlayCandidateList candidate_list; |
921 RenderPassFilterList render_pass_filters; | 964 RenderPassFilterList render_pass_filters; |
922 RenderPassFilterList render_pass_background_filters; | 965 RenderPassFilterList render_pass_background_filters; |
923 overlay_processor_->ProcessForOverlays( | 966 overlay_processor_->ProcessForOverlays( |
924 resource_provider_.get(), pass.get(), render_pass_filters, | 967 resource_provider_.get(), pass.get(), render_pass_filters, |
925 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 968 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 969 &content_bounds_); |
926 EXPECT_EQ(1U, candidate_list.size()); | 970 EXPECT_EQ(1U, candidate_list.size()); |
927 } | 971 } |
928 | 972 |
929 TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) { | 973 TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) { |
930 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 974 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
931 CreateSolidColorQuadAt(pass->shared_quad_state_list.back(), | 975 CreateSolidColorQuadAt(pass->shared_quad_state_list.back(), |
932 SK_ColorTRANSPARENT, pass.get(), | 976 SK_ColorTRANSPARENT, pass.get(), |
933 kOverlayBottomRightRect); | 977 kOverlayBottomRightRect); |
934 CreateCandidateQuadAt(resource_provider_.get(), | 978 CreateCandidateQuadAt(resource_provider_.get(), |
935 pass->shared_quad_state_list.back(), pass.get(), | 979 pass->shared_quad_state_list.back(), pass.get(), |
936 kOverlayBottomRightRect); | 980 kOverlayBottomRightRect); |
937 | 981 |
938 OverlayCandidateList candidate_list; | 982 OverlayCandidateList candidate_list; |
939 RenderPassFilterList render_pass_filters; | 983 RenderPassFilterList render_pass_filters; |
940 RenderPassFilterList render_pass_background_filters; | 984 RenderPassFilterList render_pass_background_filters; |
941 overlay_processor_->ProcessForOverlays( | 985 overlay_processor_->ProcessForOverlays( |
942 resource_provider_.get(), pass.get(), render_pass_filters, | 986 resource_provider_.get(), pass.get(), render_pass_filters, |
943 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 987 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 988 &content_bounds_); |
944 EXPECT_EQ(1U, candidate_list.size()); | 989 EXPECT_EQ(1U, candidate_list.size()); |
945 } | 990 } |
946 | 991 |
947 TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) { | 992 TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) { |
948 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 993 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
949 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 994 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
950 shared_state->opacity = 0.5f; | 995 shared_state->opacity = 0.5f; |
951 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), | 996 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), |
952 kOverlayBottomRightRect); | 997 kOverlayBottomRightRect); |
953 shared_state = pass->CreateAndAppendSharedQuadState(); | 998 shared_state = pass->CreateAndAppendSharedQuadState(); |
954 shared_state->opacity = 1.f; | 999 shared_state->opacity = 1.f; |
955 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), | 1000 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), |
956 kOverlayBottomRightRect); | 1001 kOverlayBottomRightRect); |
957 | 1002 |
958 OverlayCandidateList candidate_list; | 1003 OverlayCandidateList candidate_list; |
959 RenderPassFilterList render_pass_filters; | 1004 RenderPassFilterList render_pass_filters; |
960 RenderPassFilterList render_pass_background_filters; | 1005 RenderPassFilterList render_pass_background_filters; |
961 overlay_processor_->ProcessForOverlays( | 1006 overlay_processor_->ProcessForOverlays( |
962 resource_provider_.get(), pass.get(), render_pass_filters, | 1007 resource_provider_.get(), pass.get(), render_pass_filters, |
963 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1008 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1009 &content_bounds_); |
964 EXPECT_EQ(0U, candidate_list.size()); | 1010 EXPECT_EQ(0U, candidate_list.size()); |
965 } | 1011 } |
966 | 1012 |
967 TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) { | 1013 TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) { |
968 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1014 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
969 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 1015 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
970 CreateSolidColorQuadAt(shared_state, SK_ColorTRANSPARENT, pass.get(), | 1016 CreateSolidColorQuadAt(shared_state, SK_ColorTRANSPARENT, pass.get(), |
971 kOverlayBottomRightRect)->opaque_rect = | 1017 kOverlayBottomRightRect)->opaque_rect = |
972 kOverlayBottomRightRect; | 1018 kOverlayBottomRightRect; |
973 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), | 1019 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), |
974 kOverlayBottomRightRect); | 1020 kOverlayBottomRightRect); |
975 | 1021 |
976 OverlayCandidateList candidate_list; | 1022 OverlayCandidateList candidate_list; |
977 RenderPassFilterList render_pass_filters; | 1023 RenderPassFilterList render_pass_filters; |
978 RenderPassFilterList render_pass_background_filters; | 1024 RenderPassFilterList render_pass_background_filters; |
979 overlay_processor_->ProcessForOverlays( | 1025 overlay_processor_->ProcessForOverlays( |
980 resource_provider_.get(), pass.get(), render_pass_filters, | 1026 resource_provider_.get(), pass.get(), render_pass_filters, |
981 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1027 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1028 &content_bounds_); |
982 EXPECT_EQ(0U, candidate_list.size()); | 1029 EXPECT_EQ(0U, candidate_list.size()); |
983 } | 1030 } |
984 | 1031 |
985 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) { | 1032 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) { |
986 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1033 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
987 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1034 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
988 pass->shared_quad_state_list.back(), | 1035 pass->shared_quad_state_list.back(), |
989 pass.get(), kSwapTransform); | 1036 pass.get(), kSwapTransform); |
990 | 1037 |
991 OverlayCandidateList candidate_list; | 1038 OverlayCandidateList candidate_list; |
992 RenderPassFilterList render_pass_filters; | 1039 RenderPassFilterList render_pass_filters; |
993 RenderPassFilterList render_pass_background_filters; | 1040 RenderPassFilterList render_pass_background_filters; |
994 overlay_processor_->ProcessForOverlays( | 1041 overlay_processor_->ProcessForOverlays( |
995 resource_provider_.get(), pass.get(), render_pass_filters, | 1042 resource_provider_.get(), pass.get(), render_pass_filters, |
996 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1043 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1044 &content_bounds_); |
997 EXPECT_EQ(0U, candidate_list.size()); | 1045 EXPECT_EQ(0U, candidate_list.size()); |
998 } | 1046 } |
999 | 1047 |
1000 TEST_F(SingleOverlayOnTopTest, AllowVideoXMirrorTransform) { | 1048 TEST_F(SingleOverlayOnTopTest, AllowVideoXMirrorTransform) { |
1001 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1049 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1002 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1050 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1003 pass->shared_quad_state_list.back(), | 1051 pass->shared_quad_state_list.back(), |
1004 pass.get(), kXMirrorTransform); | 1052 pass.get(), kXMirrorTransform); |
1005 | 1053 |
1006 OverlayCandidateList candidate_list; | 1054 OverlayCandidateList candidate_list; |
1007 RenderPassFilterList render_pass_filters; | 1055 RenderPassFilterList render_pass_filters; |
1008 RenderPassFilterList render_pass_background_filters; | 1056 RenderPassFilterList render_pass_background_filters; |
1009 overlay_processor_->ProcessForOverlays( | 1057 overlay_processor_->ProcessForOverlays( |
1010 resource_provider_.get(), pass.get(), render_pass_filters, | 1058 resource_provider_.get(), pass.get(), render_pass_filters, |
1011 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1059 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1060 &content_bounds_); |
1012 EXPECT_EQ(1U, candidate_list.size()); | 1061 EXPECT_EQ(1U, candidate_list.size()); |
1013 } | 1062 } |
1014 | 1063 |
1015 TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) { | 1064 TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) { |
1016 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1065 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1017 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1066 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1018 pass->shared_quad_state_list.back(), | 1067 pass->shared_quad_state_list.back(), |
1019 pass.get(), kBothMirrorTransform); | 1068 pass.get(), kBothMirrorTransform); |
1020 | 1069 |
1021 OverlayCandidateList candidate_list; | 1070 OverlayCandidateList candidate_list; |
1022 RenderPassFilterList render_pass_filters; | 1071 RenderPassFilterList render_pass_filters; |
1023 RenderPassFilterList render_pass_background_filters; | 1072 RenderPassFilterList render_pass_background_filters; |
1024 overlay_processor_->ProcessForOverlays( | 1073 overlay_processor_->ProcessForOverlays( |
1025 resource_provider_.get(), pass.get(), render_pass_filters, | 1074 resource_provider_.get(), pass.get(), render_pass_filters, |
1026 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1075 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1076 &content_bounds_); |
1027 EXPECT_EQ(1U, candidate_list.size()); | 1077 EXPECT_EQ(1U, candidate_list.size()); |
1028 } | 1078 } |
1029 | 1079 |
1030 TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) { | 1080 TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) { |
1031 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1081 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1032 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1082 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1033 pass->shared_quad_state_list.back(), | 1083 pass->shared_quad_state_list.back(), |
1034 pass.get(), kNormalTransform); | 1084 pass.get(), kNormalTransform); |
1035 | 1085 |
1036 OverlayCandidateList candidate_list; | 1086 OverlayCandidateList candidate_list; |
1037 RenderPassFilterList render_pass_filters; | 1087 RenderPassFilterList render_pass_filters; |
1038 RenderPassFilterList render_pass_background_filters; | 1088 RenderPassFilterList render_pass_background_filters; |
1039 overlay_processor_->ProcessForOverlays( | 1089 overlay_processor_->ProcessForOverlays( |
1040 resource_provider_.get(), pass.get(), render_pass_filters, | 1090 resource_provider_.get(), pass.get(), render_pass_filters, |
1041 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1091 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1092 &content_bounds_); |
1042 EXPECT_EQ(1U, candidate_list.size()); | 1093 EXPECT_EQ(1U, candidate_list.size()); |
1043 } | 1094 } |
1044 | 1095 |
1045 TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) { | 1096 TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) { |
1046 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1097 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1047 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1098 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1048 pass->shared_quad_state_list.back(), | 1099 pass->shared_quad_state_list.back(), |
1049 pass.get(), kYMirrorTransform); | 1100 pass.get(), kYMirrorTransform); |
1050 | 1101 |
1051 OverlayCandidateList candidate_list; | 1102 OverlayCandidateList candidate_list; |
1052 RenderPassFilterList render_pass_filters; | 1103 RenderPassFilterList render_pass_filters; |
1053 RenderPassFilterList render_pass_background_filters; | 1104 RenderPassFilterList render_pass_background_filters; |
1054 overlay_processor_->ProcessForOverlays( | 1105 overlay_processor_->ProcessForOverlays( |
1055 resource_provider_.get(), pass.get(), render_pass_filters, | 1106 resource_provider_.get(), pass.get(), render_pass_filters, |
1056 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1107 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1108 &content_bounds_); |
1057 EXPECT_EQ(1U, candidate_list.size()); | 1109 EXPECT_EQ(1U, candidate_list.size()); |
1058 } | 1110 } |
1059 | 1111 |
1060 TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) { | 1112 TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) { |
1061 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1113 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1062 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1114 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1063 pass->shared_quad_state_list.back(), pass.get()); | 1115 pass->shared_quad_state_list.back(), pass.get()); |
1064 CreateCandidateQuadAt(resource_provider_.get(), | 1116 CreateCandidateQuadAt(resource_provider_.get(), |
1065 pass->shared_quad_state_list.back(), pass.get(), | 1117 pass->shared_quad_state_list.back(), pass.get(), |
1066 kOverlayBottomRightRect); | 1118 kOverlayBottomRightRect); |
1067 | 1119 |
1068 OverlayCandidateList candidate_list; | 1120 OverlayCandidateList candidate_list; |
1069 RenderPassFilterList render_pass_filters; | 1121 RenderPassFilterList render_pass_filters; |
1070 RenderPassFilterList render_pass_background_filters; | 1122 RenderPassFilterList render_pass_background_filters; |
1071 overlay_processor_->ProcessForOverlays( | 1123 overlay_processor_->ProcessForOverlays( |
1072 resource_provider_.get(), pass.get(), render_pass_filters, | 1124 resource_provider_.get(), pass.get(), render_pass_filters, |
1073 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1125 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1126 &content_bounds_); |
1074 ASSERT_EQ(1U, candidate_list.size()); | 1127 ASSERT_EQ(1U, candidate_list.size()); |
1075 EXPECT_EQ(-1, candidate_list[0].plane_z_order); | 1128 EXPECT_EQ(-1, candidate_list[0].plane_z_order); |
1076 EXPECT_EQ(2U, pass->quad_list.size()); | 1129 EXPECT_EQ(2U, pass->quad_list.size()); |
1077 // The overlay quad should have changed to a SOLID_COLOR quad. | 1130 // The overlay quad should have changed to a SOLID_COLOR quad. |
1078 EXPECT_EQ(pass->quad_list.back()->material, DrawQuad::SOLID_COLOR); | 1131 EXPECT_EQ(pass->quad_list.back()->material, DrawQuad::SOLID_COLOR); |
1079 } | 1132 } |
1080 | 1133 |
1081 TEST_F(UnderlayTest, AllowOnTop) { | 1134 TEST_F(UnderlayTest, AllowOnTop) { |
1082 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1135 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1083 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1136 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1084 pass->shared_quad_state_list.back(), | 1137 pass->shared_quad_state_list.back(), |
1085 pass.get()); | 1138 pass.get()); |
1086 pass->CreateAndAppendSharedQuadState()->opacity = 0.5f; | 1139 pass->CreateAndAppendSharedQuadState()->opacity = 0.5f; |
1087 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1140 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1088 pass->shared_quad_state_list.back(), pass.get()); | 1141 pass->shared_quad_state_list.back(), pass.get()); |
1089 | 1142 |
1090 OverlayCandidateList candidate_list; | 1143 OverlayCandidateList candidate_list; |
1091 RenderPassFilterList render_pass_filters; | 1144 RenderPassFilterList render_pass_filters; |
1092 RenderPassFilterList render_pass_background_filters; | 1145 RenderPassFilterList render_pass_background_filters; |
1093 overlay_processor_->ProcessForOverlays( | 1146 overlay_processor_->ProcessForOverlays( |
1094 resource_provider_.get(), pass.get(), render_pass_filters, | 1147 resource_provider_.get(), pass.get(), render_pass_filters, |
1095 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1148 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1149 &content_bounds_); |
1096 ASSERT_EQ(1U, candidate_list.size()); | 1150 ASSERT_EQ(1U, candidate_list.size()); |
1097 EXPECT_EQ(-1, candidate_list[0].plane_z_order); | 1151 EXPECT_EQ(-1, candidate_list[0].plane_z_order); |
1098 // The overlay quad should have changed to a SOLID_COLOR quad. | 1152 // The overlay quad should have changed to a SOLID_COLOR quad. |
1099 EXPECT_EQ(pass->quad_list.front()->material, DrawQuad::SOLID_COLOR); | 1153 EXPECT_EQ(pass->quad_list.front()->material, DrawQuad::SOLID_COLOR); |
1100 } | 1154 } |
1101 | 1155 |
1102 // The first time an underlay is scheduled its damage must not be subtracted. | 1156 // The first time an underlay is scheduled its damage must not be subtracted. |
1103 TEST_F(UnderlayTest, InitialUnderlayDamageNotSubtracted) { | 1157 TEST_F(UnderlayTest, InitialUnderlayDamageNotSubtracted) { |
1104 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1158 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1105 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1159 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1106 pass->shared_quad_state_list.back(), | 1160 pass->shared_quad_state_list.back(), |
1107 pass.get()); | 1161 pass.get()); |
1108 | 1162 |
1109 damage_rect_ = kOverlayRect; | 1163 damage_rect_ = kOverlayRect; |
1110 | 1164 |
1111 OverlayCandidateList candidate_list; | 1165 OverlayCandidateList candidate_list; |
1112 RenderPassFilterList render_pass_filters; | 1166 RenderPassFilterList render_pass_filters; |
1113 RenderPassFilterList render_pass_background_filters; | 1167 RenderPassFilterList render_pass_background_filters; |
1114 overlay_processor_->ProcessForOverlays( | 1168 overlay_processor_->ProcessForOverlays( |
1115 resource_provider_.get(), pass.get(), render_pass_filters, | 1169 resource_provider_.get(), pass.get(), render_pass_filters, |
1116 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1170 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1171 &content_bounds_); |
1117 | 1172 |
1118 EXPECT_EQ(kOverlayRect, damage_rect_); | 1173 EXPECT_EQ(kOverlayRect, damage_rect_); |
1119 } | 1174 } |
1120 | 1175 |
1121 // An identical underlay for two frames in a row means the damage can be | 1176 // An identical underlay for two frames in a row means the damage can be |
1122 // subtracted the second time. | 1177 // subtracted the second time. |
1123 TEST_F(UnderlayTest, DamageSubtractedForConsecutiveIdenticalUnderlays) { | 1178 TEST_F(UnderlayTest, DamageSubtractedForConsecutiveIdenticalUnderlays) { |
1124 for (int i = 0; i < 2; ++i) { | 1179 for (int i = 0; i < 2; ++i) { |
1125 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1180 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1126 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1181 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1127 pass->shared_quad_state_list.back(), | 1182 pass->shared_quad_state_list.back(), |
1128 pass.get()); | 1183 pass.get()); |
1129 | 1184 |
1130 damage_rect_ = kOverlayRect; | 1185 damage_rect_ = kOverlayRect; |
1131 | 1186 |
1132 // Add something behind it. | 1187 // Add something behind it. |
1133 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1188 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1134 pass->shared_quad_state_list.back(), pass.get()); | 1189 pass->shared_quad_state_list.back(), pass.get()); |
1135 | 1190 |
1136 OverlayCandidateList candidate_list; | 1191 OverlayCandidateList candidate_list; |
1137 RenderPassFilterList render_pass_filters; | 1192 RenderPassFilterList render_pass_filters; |
1138 RenderPassFilterList render_pass_background_filters; | 1193 RenderPassFilterList render_pass_background_filters; |
1139 overlay_processor_->ProcessForOverlays( | 1194 overlay_processor_->ProcessForOverlays( |
1140 resource_provider_.get(), pass.get(), render_pass_filters, | 1195 resource_provider_.get(), pass.get(), render_pass_filters, |
1141 render_pass_background_filters, &candidate_list, nullptr, | 1196 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1142 &damage_rect_); | 1197 &content_bounds_); |
1143 } | 1198 } |
1144 | 1199 |
1145 // The second time the same overlay rect is scheduled it will be subtracted | 1200 // The second time the same overlay rect is scheduled it will be subtracted |
1146 // from the damage rect. | 1201 // from the damage rect. |
1147 EXPECT_TRUE(damage_rect_.IsEmpty()); | 1202 EXPECT_TRUE(damage_rect_.IsEmpty()); |
1148 } | 1203 } |
1149 | 1204 |
1150 // Underlay damage can only be subtracted if the previous frame's underlay | 1205 // Underlay damage can only be subtracted if the previous frame's underlay |
1151 // was the same rect. | 1206 // was the same rect. |
1152 TEST_F(UnderlayTest, DamageNotSubtractedForNonIdenticalConsecutiveUnderlays) { | 1207 TEST_F(UnderlayTest, DamageNotSubtractedForNonIdenticalConsecutiveUnderlays) { |
1153 gfx::Rect overlay_rects[] = {kOverlayBottomRightRect, kOverlayRect}; | 1208 gfx::Rect overlay_rects[] = {kOverlayBottomRightRect, kOverlayRect}; |
1154 for (int i = 0; i < 2; ++i) { | 1209 for (int i = 0; i < 2; ++i) { |
1155 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1210 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1156 | 1211 |
1157 CreateCandidateQuadAt(resource_provider_.get(), | 1212 CreateCandidateQuadAt(resource_provider_.get(), |
1158 pass->shared_quad_state_list.back(), pass.get(), | 1213 pass->shared_quad_state_list.back(), pass.get(), |
1159 overlay_rects[i]); | 1214 overlay_rects[i]); |
1160 | 1215 |
1161 damage_rect_ = overlay_rects[i]; | 1216 damage_rect_ = overlay_rects[i]; |
1162 | 1217 |
1163 OverlayCandidateList candidate_list; | 1218 OverlayCandidateList candidate_list; |
1164 RenderPassFilterList render_pass_filters; | 1219 RenderPassFilterList render_pass_filters; |
1165 RenderPassFilterList render_pass_background_filters; | 1220 RenderPassFilterList render_pass_background_filters; |
1166 overlay_processor_->ProcessForOverlays( | 1221 overlay_processor_->ProcessForOverlays( |
1167 resource_provider_.get(), pass.get(), render_pass_filters, | 1222 resource_provider_.get(), pass.get(), render_pass_filters, |
1168 render_pass_background_filters, &candidate_list, nullptr, | 1223 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1169 &damage_rect_); | 1224 &content_bounds_); |
1170 | 1225 |
1171 EXPECT_EQ(overlay_rects[i], damage_rect_); | 1226 EXPECT_EQ(overlay_rects[i], damage_rect_); |
1172 } | 1227 } |
1173 } | 1228 } |
1174 | 1229 |
1175 TEST_F(UnderlayTest, DamageNotSubtractedWhenQuadsAboveOverlap) { | 1230 TEST_F(UnderlayTest, DamageNotSubtractedWhenQuadsAboveOverlap) { |
1176 for (int i = 0; i < 2; ++i) { | 1231 for (int i = 0; i < 2; ++i) { |
1177 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1232 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1178 // Add an overlapping quad above the candidate. | 1233 // Add an overlapping quad above the candidate. |
1179 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1234 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1180 pass->shared_quad_state_list.back(), pass.get()); | 1235 pass->shared_quad_state_list.back(), pass.get()); |
1181 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1236 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1182 pass->shared_quad_state_list.back(), | 1237 pass->shared_quad_state_list.back(), |
1183 pass.get()); | 1238 pass.get()); |
1184 | 1239 |
1185 damage_rect_ = kOverlayRect; | 1240 damage_rect_ = kOverlayRect; |
1186 | 1241 |
1187 OverlayCandidateList candidate_list; | 1242 OverlayCandidateList candidate_list; |
1188 RenderPassFilterList render_pass_filters; | 1243 RenderPassFilterList render_pass_filters; |
1189 RenderPassFilterList render_pass_background_filters; | 1244 RenderPassFilterList render_pass_background_filters; |
1190 overlay_processor_->ProcessForOverlays( | 1245 overlay_processor_->ProcessForOverlays( |
1191 resource_provider_.get(), pass.get(), render_pass_filters, | 1246 resource_provider_.get(), pass.get(), render_pass_filters, |
1192 render_pass_background_filters, &candidate_list, nullptr, | 1247 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1193 &damage_rect_); | 1248 &content_bounds_); |
1194 } | 1249 } |
1195 | 1250 |
1196 EXPECT_EQ(kOverlayRect, damage_rect_); | 1251 EXPECT_EQ(kOverlayRect, damage_rect_); |
1197 } | 1252 } |
1198 | 1253 |
1199 TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) { | 1254 TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) { |
1200 for (int i = 0; i < 2; ++i) { | 1255 for (int i = 0; i < 2; ++i) { |
1201 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1256 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1202 // Add a non-overlapping quad above the candidate. | 1257 // Add a non-overlapping quad above the candidate. |
1203 CreateOpaqueQuadAt(resource_provider_.get(), | 1258 CreateOpaqueQuadAt(resource_provider_.get(), |
1204 pass->shared_quad_state_list.back(), pass.get(), | 1259 pass->shared_quad_state_list.back(), pass.get(), |
1205 kOverlayTopLeftRect); | 1260 kOverlayTopLeftRect); |
1206 CreateCandidateQuadAt(resource_provider_.get(), | 1261 CreateCandidateQuadAt(resource_provider_.get(), |
1207 pass->shared_quad_state_list.back(), pass.get(), | 1262 pass->shared_quad_state_list.back(), pass.get(), |
1208 kOverlayBottomRightRect); | 1263 kOverlayBottomRightRect); |
1209 | 1264 |
1210 damage_rect_ = kOverlayBottomRightRect; | 1265 damage_rect_ = kOverlayBottomRightRect; |
1211 | 1266 |
1212 OverlayCandidateList candidate_list; | 1267 OverlayCandidateList candidate_list; |
1213 RenderPassFilterList render_pass_filters; | 1268 RenderPassFilterList render_pass_filters; |
1214 RenderPassFilterList render_pass_background_filters; | 1269 RenderPassFilterList render_pass_background_filters; |
1215 overlay_processor_->ProcessForOverlays( | 1270 overlay_processor_->ProcessForOverlays( |
1216 resource_provider_.get(), pass.get(), render_pass_filters, | 1271 resource_provider_.get(), pass.get(), render_pass_filters, |
1217 render_pass_background_filters, &candidate_list, nullptr, | 1272 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1218 &damage_rect_); | 1273 &content_bounds_); |
1219 } | 1274 } |
1220 | 1275 |
1221 EXPECT_TRUE(damage_rect_.IsEmpty()); | 1276 EXPECT_TRUE(damage_rect_.IsEmpty()); |
1222 } | 1277 } |
1223 | 1278 |
| 1279 TEST_F(UnderlayCastTest, NoOverlayContentBounds) { |
| 1280 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
| 1281 |
| 1282 CreateOpaqueQuadAt(resource_provider_.get(), |
| 1283 pass->shared_quad_state_list.back(), pass.get(), |
| 1284 kOverlayTopLeftRect); |
| 1285 |
| 1286 OverlayCandidateList candidate_list; |
| 1287 RenderPassFilterList render_pass_filters; |
| 1288 RenderPassFilterList render_pass_background_filters; |
| 1289 overlay_processor_->ProcessForOverlays( |
| 1290 resource_provider_.get(), pass.get(), render_pass_filters, |
| 1291 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1292 &content_bounds_); |
| 1293 EXPECT_EQ(0U, content_bounds_.size()); |
| 1294 } |
| 1295 |
| 1296 TEST_F(UnderlayCastTest, FullScreenOverlayContentBounds) { |
| 1297 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
| 1298 CreateCandidateQuadAt(resource_provider_.get(), |
| 1299 pass->shared_quad_state_list.back(), pass.get(), |
| 1300 kOverlayRect); |
| 1301 |
| 1302 OverlayCandidateList candidate_list; |
| 1303 RenderPassFilterList render_pass_filters; |
| 1304 RenderPassFilterList render_pass_background_filters; |
| 1305 overlay_processor_->ProcessForOverlays( |
| 1306 resource_provider_.get(), pass.get(), render_pass_filters, |
| 1307 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1308 &content_bounds_); |
| 1309 |
| 1310 EXPECT_EQ(1U, content_bounds_.size()); |
| 1311 EXPECT_TRUE(content_bounds_[0].IsEmpty()); |
| 1312 } |
| 1313 |
| 1314 TEST_F(UnderlayCastTest, BlackOutsideOverlayContentBounds) { |
| 1315 const gfx::Rect kLeftSide(0, 0, 128, 256); |
| 1316 const gfx::Rect kTopRight(128, 0, 128, 128); |
| 1317 |
| 1318 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
| 1319 CreateCandidateQuadAt(resource_provider_.get(), |
| 1320 pass->shared_quad_state_list.back(), pass.get(), |
| 1321 kOverlayBottomRightRect); |
| 1322 CreateOpaqueQuadAt(resource_provider_.get(), |
| 1323 pass->shared_quad_state_list.back(), pass.get(), kLeftSide, |
| 1324 SK_ColorBLACK); |
| 1325 CreateOpaqueQuadAt(resource_provider_.get(), |
| 1326 pass->shared_quad_state_list.back(), pass.get(), kTopRight, |
| 1327 SK_ColorBLACK); |
| 1328 |
| 1329 OverlayCandidateList candidate_list; |
| 1330 RenderPassFilterList render_pass_filters; |
| 1331 RenderPassFilterList render_pass_background_filters; |
| 1332 overlay_processor_->ProcessForOverlays( |
| 1333 resource_provider_.get(), pass.get(), render_pass_filters, |
| 1334 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1335 &content_bounds_); |
| 1336 |
| 1337 EXPECT_EQ(1U, content_bounds_.size()); |
| 1338 EXPECT_TRUE(content_bounds_[0].IsEmpty()); |
| 1339 } |
| 1340 |
| 1341 TEST_F(UnderlayCastTest, OverlayOccludedContentBounds) { |
| 1342 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
| 1343 CreateOpaqueQuadAt(resource_provider_.get(), |
| 1344 pass->shared_quad_state_list.back(), pass.get(), |
| 1345 kOverlayTopLeftRect); |
| 1346 CreateCandidateQuadAt(resource_provider_.get(), |
| 1347 pass->shared_quad_state_list.back(), pass.get(), |
| 1348 kOverlayRect); |
| 1349 |
| 1350 OverlayCandidateList candidate_list; |
| 1351 RenderPassFilterList render_pass_filters; |
| 1352 RenderPassFilterList render_pass_background_filters; |
| 1353 overlay_processor_->ProcessForOverlays( |
| 1354 resource_provider_.get(), pass.get(), render_pass_filters, |
| 1355 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1356 &content_bounds_); |
| 1357 |
| 1358 EXPECT_EQ(1U, content_bounds_.size()); |
| 1359 EXPECT_EQ(kOverlayTopLeftRect, content_bounds_[0]); |
| 1360 } |
| 1361 |
| 1362 TEST_F(UnderlayCastTest, OverlayOccludedUnionContentBounds) { |
| 1363 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
| 1364 CreateOpaqueQuadAt(resource_provider_.get(), |
| 1365 pass->shared_quad_state_list.back(), pass.get(), |
| 1366 kOverlayTopLeftRect); |
| 1367 CreateOpaqueQuadAt(resource_provider_.get(), |
| 1368 pass->shared_quad_state_list.back(), pass.get(), |
| 1369 kOverlayBottomRightRect); |
| 1370 CreateCandidateQuadAt(resource_provider_.get(), |
| 1371 pass->shared_quad_state_list.back(), pass.get(), |
| 1372 kOverlayRect); |
| 1373 |
| 1374 OverlayCandidateList candidate_list; |
| 1375 RenderPassFilterList render_pass_filters; |
| 1376 RenderPassFilterList render_pass_background_filters; |
| 1377 overlay_processor_->ProcessForOverlays( |
| 1378 resource_provider_.get(), pass.get(), render_pass_filters, |
| 1379 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
| 1380 &content_bounds_); |
| 1381 |
| 1382 EXPECT_EQ(1U, content_bounds_.size()); |
| 1383 EXPECT_EQ(kOverlayRect, content_bounds_[0]); |
| 1384 } |
| 1385 |
1224 OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) { | 1386 OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) { |
1225 OverlayCandidateList list; | 1387 OverlayCandidateList list; |
1226 OverlayCandidate output_surface_plane; | 1388 OverlayCandidate output_surface_plane; |
1227 output_surface_plane.display_rect = gfx::RectF(root_render_pass->output_rect); | 1389 output_surface_plane.display_rect = gfx::RectF(root_render_pass->output_rect); |
1228 output_surface_plane.quad_rect_in_target_space = | 1390 output_surface_plane.quad_rect_in_target_space = |
1229 root_render_pass->output_rect; | 1391 root_render_pass->output_rect; |
1230 output_surface_plane.use_output_surface_for_resource = true; | 1392 output_surface_plane.use_output_surface_for_resource = true; |
1231 output_surface_plane.overlay_handled = true; | 1393 output_surface_plane.overlay_handled = true; |
1232 list.push_back(output_surface_plane); | 1394 list.push_back(output_surface_plane); |
1233 return list; | 1395 return list; |
1234 } | 1396 } |
1235 | 1397 |
1236 TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) { | 1398 TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) { |
1237 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1399 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1238 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1400 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1239 pass->shared_quad_state_list.back(), | 1401 pass->shared_quad_state_list.back(), |
1240 pass.get()); | 1402 pass.get()); |
1241 pass->shared_quad_state_list.back() | 1403 pass->shared_quad_state_list.back() |
1242 ->quad_to_target_transform.RotateAboutZAxis(45.f); | 1404 ->quad_to_target_transform.RotateAboutZAxis(45.f); |
1243 | 1405 |
1244 gfx::Rect damage_rect; | 1406 gfx::Rect damage_rect; |
1245 CALayerOverlayList ca_layer_list; | 1407 CALayerOverlayList ca_layer_list; |
1246 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1408 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1247 RenderPassFilterList render_pass_filters; | 1409 RenderPassFilterList render_pass_filters; |
1248 RenderPassFilterList render_pass_background_filters; | 1410 RenderPassFilterList render_pass_background_filters; |
1249 overlay_processor_->ProcessForOverlays( | 1411 overlay_processor_->ProcessForOverlays( |
1250 resource_provider_.get(), pass.get(), render_pass_filters, | 1412 resource_provider_.get(), pass.get(), render_pass_filters, |
1251 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1413 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1252 &damage_rect); | 1414 &damage_rect_, &content_bounds_); |
1253 EXPECT_EQ(gfx::Rect(), damage_rect); | 1415 EXPECT_EQ(gfx::Rect(), damage_rect); |
1254 EXPECT_EQ(0U, overlay_list.size()); | 1416 EXPECT_EQ(0U, overlay_list.size()); |
1255 EXPECT_EQ(1U, ca_layer_list.size()); | 1417 EXPECT_EQ(1U, ca_layer_list.size()); |
1256 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1418 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1257 } | 1419 } |
1258 | 1420 |
1259 TEST_F(CALayerOverlayTest, ThreeDTransform) { | 1421 TEST_F(CALayerOverlayTest, ThreeDTransform) { |
1260 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1422 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1261 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1423 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1262 pass->shared_quad_state_list.back(), | 1424 pass->shared_quad_state_list.back(), |
1263 pass.get()); | 1425 pass.get()); |
1264 pass->shared_quad_state_list.back() | 1426 pass->shared_quad_state_list.back() |
1265 ->quad_to_target_transform.RotateAboutXAxis(45.f); | 1427 ->quad_to_target_transform.RotateAboutXAxis(45.f); |
1266 | 1428 |
1267 gfx::Rect damage_rect; | 1429 gfx::Rect damage_rect; |
1268 CALayerOverlayList ca_layer_list; | 1430 CALayerOverlayList ca_layer_list; |
1269 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1431 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1270 RenderPassFilterList render_pass_filters; | 1432 RenderPassFilterList render_pass_filters; |
1271 RenderPassFilterList render_pass_background_filters; | 1433 RenderPassFilterList render_pass_background_filters; |
1272 overlay_processor_->ProcessForOverlays( | 1434 overlay_processor_->ProcessForOverlays( |
1273 resource_provider_.get(), pass.get(), render_pass_filters, | 1435 resource_provider_.get(), pass.get(), render_pass_filters, |
1274 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1436 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1275 &damage_rect); | 1437 &damage_rect_, &content_bounds_); |
1276 EXPECT_EQ(0U, overlay_list.size()); | 1438 EXPECT_EQ(0U, overlay_list.size()); |
1277 EXPECT_EQ(1U, ca_layer_list.size()); | 1439 EXPECT_EQ(1U, ca_layer_list.size()); |
1278 gfx::Transform expected_transform; | 1440 gfx::Transform expected_transform; |
1279 expected_transform.RotateAboutXAxis(45.f); | 1441 expected_transform.RotateAboutXAxis(45.f); |
1280 gfx::Transform actual_transform(ca_layer_list.back().shared_state->transform); | 1442 gfx::Transform actual_transform(ca_layer_list.back().shared_state->transform); |
1281 EXPECT_EQ(expected_transform.ToString(), actual_transform.ToString()); | 1443 EXPECT_EQ(expected_transform.ToString(), actual_transform.ToString()); |
1282 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1444 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1283 } | 1445 } |
1284 | 1446 |
1285 TEST_F(CALayerOverlayTest, AllowContainingClip) { | 1447 TEST_F(CALayerOverlayTest, AllowContainingClip) { |
1286 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1448 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1287 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1449 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1288 pass->shared_quad_state_list.back(), | 1450 pass->shared_quad_state_list.back(), |
1289 pass.get()); | 1451 pass.get()); |
1290 pass->shared_quad_state_list.back()->is_clipped = true; | 1452 pass->shared_quad_state_list.back()->is_clipped = true; |
1291 pass->shared_quad_state_list.back()->clip_rect = kOverlayRect; | 1453 pass->shared_quad_state_list.back()->clip_rect = kOverlayRect; |
1292 | 1454 |
1293 gfx::Rect damage_rect; | 1455 gfx::Rect damage_rect; |
1294 CALayerOverlayList ca_layer_list; | 1456 CALayerOverlayList ca_layer_list; |
1295 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1457 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1296 RenderPassFilterList render_pass_filters; | 1458 RenderPassFilterList render_pass_filters; |
1297 RenderPassFilterList render_pass_background_filters; | 1459 RenderPassFilterList render_pass_background_filters; |
1298 overlay_processor_->ProcessForOverlays( | 1460 overlay_processor_->ProcessForOverlays( |
1299 resource_provider_.get(), pass.get(), render_pass_filters, | 1461 resource_provider_.get(), pass.get(), render_pass_filters, |
1300 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1462 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1301 &damage_rect); | 1463 &damage_rect_, &content_bounds_); |
1302 EXPECT_EQ(gfx::Rect(), damage_rect); | 1464 EXPECT_EQ(gfx::Rect(), damage_rect); |
1303 EXPECT_EQ(0U, overlay_list.size()); | 1465 EXPECT_EQ(0U, overlay_list.size()); |
1304 EXPECT_EQ(1U, ca_layer_list.size()); | 1466 EXPECT_EQ(1U, ca_layer_list.size()); |
1305 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1467 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1306 } | 1468 } |
1307 | 1469 |
1308 TEST_F(CALayerOverlayTest, NontrivialClip) { | 1470 TEST_F(CALayerOverlayTest, NontrivialClip) { |
1309 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1471 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1310 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1472 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1311 pass->shared_quad_state_list.back(), | 1473 pass->shared_quad_state_list.back(), |
1312 pass.get()); | 1474 pass.get()); |
1313 pass->shared_quad_state_list.back()->is_clipped = true; | 1475 pass->shared_quad_state_list.back()->is_clipped = true; |
1314 pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(64, 64, 128, 128); | 1476 pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(64, 64, 128, 128); |
1315 | 1477 |
1316 gfx::Rect damage_rect; | 1478 gfx::Rect damage_rect; |
1317 CALayerOverlayList ca_layer_list; | 1479 CALayerOverlayList ca_layer_list; |
1318 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1480 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1319 RenderPassFilterList render_pass_filters; | 1481 RenderPassFilterList render_pass_filters; |
1320 RenderPassFilterList render_pass_background_filters; | 1482 RenderPassFilterList render_pass_background_filters; |
1321 overlay_processor_->ProcessForOverlays( | 1483 overlay_processor_->ProcessForOverlays( |
1322 resource_provider_.get(), pass.get(), render_pass_filters, | 1484 resource_provider_.get(), pass.get(), render_pass_filters, |
1323 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1485 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1324 &damage_rect); | 1486 &damage_rect_, &content_bounds_); |
1325 EXPECT_EQ(gfx::Rect(), damage_rect); | 1487 EXPECT_EQ(gfx::Rect(), damage_rect); |
1326 EXPECT_EQ(0U, overlay_list.size()); | 1488 EXPECT_EQ(0U, overlay_list.size()); |
1327 EXPECT_EQ(1U, ca_layer_list.size()); | 1489 EXPECT_EQ(1U, ca_layer_list.size()); |
1328 EXPECT_TRUE(ca_layer_list.back().shared_state->is_clipped); | 1490 EXPECT_TRUE(ca_layer_list.back().shared_state->is_clipped); |
1329 EXPECT_EQ(gfx::RectF(64, 64, 128, 128), | 1491 EXPECT_EQ(gfx::RectF(64, 64, 128, 128), |
1330 ca_layer_list.back().shared_state->clip_rect); | 1492 ca_layer_list.back().shared_state->clip_rect); |
1331 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1493 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1332 } | 1494 } |
1333 | 1495 |
1334 TEST_F(CALayerOverlayTest, SkipTransparent) { | 1496 TEST_F(CALayerOverlayTest, SkipTransparent) { |
1335 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1497 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1336 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1498 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1337 pass->shared_quad_state_list.back(), | 1499 pass->shared_quad_state_list.back(), |
1338 pass.get()); | 1500 pass.get()); |
1339 pass->shared_quad_state_list.back()->opacity = 0; | 1501 pass->shared_quad_state_list.back()->opacity = 0; |
1340 | 1502 |
1341 gfx::Rect damage_rect; | 1503 gfx::Rect damage_rect; |
1342 CALayerOverlayList ca_layer_list; | 1504 CALayerOverlayList ca_layer_list; |
1343 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1505 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1344 RenderPassFilterList render_pass_filters; | 1506 RenderPassFilterList render_pass_filters; |
1345 RenderPassFilterList render_pass_background_filters; | 1507 RenderPassFilterList render_pass_background_filters; |
1346 overlay_processor_->ProcessForOverlays( | 1508 overlay_processor_->ProcessForOverlays( |
1347 resource_provider_.get(), pass.get(), render_pass_filters, | 1509 resource_provider_.get(), pass.get(), render_pass_filters, |
1348 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1510 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1349 &damage_rect); | 1511 &damage_rect_, &content_bounds_); |
1350 EXPECT_EQ(gfx::Rect(), damage_rect); | 1512 EXPECT_EQ(gfx::Rect(), damage_rect); |
1351 EXPECT_EQ(0U, overlay_list.size()); | 1513 EXPECT_EQ(0U, overlay_list.size()); |
1352 EXPECT_EQ(0U, ca_layer_list.size()); | 1514 EXPECT_EQ(0U, ca_layer_list.size()); |
1353 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1515 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1354 } | 1516 } |
1355 | 1517 |
1356 class OverlayInfoRendererGL : public GLRenderer { | 1518 class OverlayInfoRendererGL : public GLRenderer { |
1357 public: | 1519 public: |
1358 OverlayInfoRendererGL(const RendererSettings* settings, | 1520 OverlayInfoRendererGL(const RendererSettings* settings, |
1359 OutputSurface* output_surface, | 1521 OutputSurface* output_surface, |
(...skipping 519 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1879 quad_ = pass_->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); | 2041 quad_ = pass_->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); |
1880 render_pass_id_ = 3; | 2042 render_pass_id_ = 3; |
1881 } | 2043 } |
1882 | 2044 |
1883 void ProcessForOverlays() { | 2045 void ProcessForOverlays() { |
1884 gfx::Rect damage_rect; | 2046 gfx::Rect damage_rect; |
1885 overlay_list_ = BackbufferOverlayList(pass_.get()); | 2047 overlay_list_ = BackbufferOverlayList(pass_.get()); |
1886 overlay_processor_->ProcessForOverlays( | 2048 overlay_processor_->ProcessForOverlays( |
1887 resource_provider_.get(), pass_.get(), render_pass_filters_, | 2049 resource_provider_.get(), pass_.get(), render_pass_filters_, |
1888 render_pass_background_filters_, &overlay_list_, &ca_layer_list_, | 2050 render_pass_background_filters_, &overlay_list_, &ca_layer_list_, |
1889 &damage_rect); | 2051 &damage_rect_, &content_bounds_); |
1890 } | 2052 } |
1891 std::unique_ptr<RenderPass> pass_; | 2053 std::unique_ptr<RenderPass> pass_; |
1892 RenderPassDrawQuad* quad_; | 2054 RenderPassDrawQuad* quad_; |
1893 int render_pass_id_; | 2055 int render_pass_id_; |
1894 FilterOperations filters_; | 2056 FilterOperations filters_; |
1895 FilterOperations background_filters_; | 2057 FilterOperations background_filters_; |
1896 RenderPassFilterList render_pass_filters_; | 2058 RenderPassFilterList render_pass_filters_; |
1897 RenderPassFilterList render_pass_background_filters_; | 2059 RenderPassFilterList render_pass_background_filters_; |
1898 CALayerOverlayList ca_layer_list_; | 2060 CALayerOverlayList ca_layer_list_; |
1899 OverlayCandidateList overlay_list_; | 2061 OverlayCandidateList overlay_list_; |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2000 kOverlayRect, render_pass_id_, 2, gfx::Vector2dF(), | 2162 kOverlayRect, render_pass_id_, 2, gfx::Vector2dF(), |
2001 gfx::Size(), gfx::Vector2dF(1, 1), gfx::PointF()); | 2163 gfx::Size(), gfx::Vector2dF(1, 1), gfx::PointF()); |
2002 } | 2164 } |
2003 | 2165 |
2004 ProcessForOverlays(); | 2166 ProcessForOverlays(); |
2005 EXPECT_EQ(0U, ca_layer_list_.size()); | 2167 EXPECT_EQ(0U, ca_layer_list_.size()); |
2006 } | 2168 } |
2007 | 2169 |
2008 } // namespace | 2170 } // namespace |
2009 } // namespace cc | 2171 } // namespace cc |
OLD | NEW |