Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(265)

Side by Side Diff: cc/output/overlay_unittest.cc

Issue 2693023002: Use SwapBuffersWithBounds on Chromecast (Closed)
Patch Set: Address danakj comments on PS1 Created 3 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698