cc/output/overlay_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "cc/base/scoped_ptr_vector.h"
   6 #include "cc/output/gl_renderer.h"
   7 #include "cc/output/output_surface.h"
   8 #include "cc/output/output_surface_client.h"
   9 #include "cc/output/overlay_candidate_validator.h"
  10 #include "cc/output/overlay_processor.h"
  11 #include "cc/output/overlay_strategy_single_on_top.h"
  12 #include "cc/quads/checkerboard_draw_quad.h"
  13 #include "cc/quads/render_pass.h"
  14 #include "cc/quads/texture_draw_quad.h"
  15 #include "cc/resources/resource_provider.h"
  16 #include "cc/resources/texture_mailbox.h"
  17 #include "cc/test/fake_output_surface_client.h"
  18 #include "cc/test/geometry_test_utils.h"
  19 #include "cc/test/test_context_provider.h"
  20 #include "cc/test/test_shared_bitmap_manager.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 using testing::_;
  25 using testing::Mock;
  26
  27 namespace cc {
  28 namespace {
  29
  30 const gfx::Rect kOverlayRect(0, 0, 128, 128);
  31 const gfx::Rect kOverlayTopLeftRect(0, 0, 64, 64);
  32 const gfx::Rect kOverlayBottomRightRect(64, 64, 64, 64);
  33 const gfx::PointF kUVTopLeft(0.1f, 0.2f);
  34 const gfx::PointF kUVBottomRight(1.0f, 1.0f);
  35
  36 void MailboxReleased(unsigned sync_point, bool lost_resource) {}
  37
  38 class SingleOverlayValidator : public OverlayCandidateValidator {
  39  public:
  40   virtual void CheckOverlaySupport(OverlayCandidateList* surfaces) OVERRIDE;
  41 };
  42
  43 void SingleOverlayValidator::CheckOverlaySupport(
  44     OverlayCandidateList* surfaces) {
  45   ASSERT_EQ(2U, surfaces->size());
  46
  47   OverlayCandidate& candidate = surfaces->back();
  48   if (candidate.display_rect.width() == 64)
  49     EXPECT_EQ(kOverlayBottomRightRect, candidate.display_rect);
  50   else
  51     EXPECT_EQ(kOverlayRect, candidate.display_rect);
  52   EXPECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight).ToString(),
  53             candidate.uv_rect.ToString());
  54   candidate.overlay_handled = true;
  55 }
  56
  57 class SingleOverlayProcessor : public OverlayProcessor {
  58  public:
  59   SingleOverlayProcessor(OutputSurface* surface,
  60                          ResourceProvider* resource_provider);
  61   // Virtual to allow testing different strategies.
  62   virtual void Initialize() OVERRIDE;
  63 };
  64
  65 SingleOverlayProcessor::SingleOverlayProcessor(
  66     OutputSurface* surface,
  67     ResourceProvider* resource_provider)
  68     : OverlayProcessor(surface, resource_provider) {
  69   EXPECT_EQ(surface, surface_);
  70   EXPECT_EQ(resource_provider, resource_provider_);
  71 }
  72
  73 void SingleOverlayProcessor::Initialize() {
  74   OverlayCandidateValidator* candidates =
  75       surface_->overlay_candidate_validator();
  76   ASSERT_TRUE(candidates != NULL);
  77   strategies_.push_back(scoped_ptr<Strategy>(
  78       new OverlayStrategySingleOnTop(candidates, resource_provider_)));
  79 }
  80
  81 class DefaultOverlayProcessor : public OverlayProcessor {
  82  public:
  83   DefaultOverlayProcessor(OutputSurface* surface,
  84                           ResourceProvider* resource_provider);
  85   size_t GetStrategyCount();
  86 };
  87
  88 DefaultOverlayProcessor::DefaultOverlayProcessor(
  89     OutputSurface* surface,
  90     ResourceProvider* resource_provider)
  91     : OverlayProcessor(surface, resource_provider) {}
  92
  93 size_t DefaultOverlayProcessor::GetStrategyCount() {
  94   return strategies_.size();
  95 }
  96
  97 class OverlayOutputSurface : public OutputSurface {
  98  public:
  99   explicit OverlayOutputSurface(scoped_refptr<ContextProvider> context_provider)
 100       : OutputSurface(context_provider) {}
 101
 102   void InitWithSingleOverlayValidator() {
 103     overlay_candidate_validator_.reset(new SingleOverlayValidator);
 104   }
 105 };
 106
 107 scoped_ptr<RenderPass> CreateRenderPass() {
 108   RenderPassId id(1, 0);
 109   gfx::Rect output_rect(0, 0, 256, 256);
 110   bool has_transparent_background = true;
 111
 112   scoped_ptr<RenderPass> pass = RenderPass::Create();
 113   pass->SetAll(id,
 114                output_rect,
 115                output_rect,
 116                gfx::Transform(),
 117                has_transparent_background);
 118
 119   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
 120   shared_state->opacity = 1.f;
 121   return pass.Pass();
 122 }
 123
 124 ResourceProvider::ResourceId CreateResource(
 125     ResourceProvider* resource_provider) {
 126   unsigned sync_point = 0;
 127   TextureMailbox mailbox =
 128       TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
 129   mailbox.set_allow_overlay(true);
 130   scoped_ptr<SingleReleaseCallback> release_callback =
 131       SingleReleaseCallback::Create(base::Bind(&MailboxReleased));
 132
 133   return resource_provider->CreateResourceFromTextureMailbox(
 134       mailbox, release_callback.Pass());
 135 }
 136
 137 TextureDrawQuad* CreateCandidateQuadAt(ResourceProvider* resource_provider,
 138                                        const SharedQuadState* shared_quad_state,
 139                                        RenderPass* render_pass,
 140                                        const gfx::Rect& rect) {
 141   ResourceProvider::ResourceId resource_id = CreateResource(resource_provider);
 142   bool premultiplied_alpha = false;
 143   bool flipped = false;
 144   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 145
 146   TextureDrawQuad* overlay_quad =
 147       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
 148   overlay_quad->SetNew(shared_quad_state,
 149                        rect,
 150                        rect,
 151                        rect,
 152                        resource_id,
 153                        premultiplied_alpha,
 154                        kUVTopLeft,
 155                        kUVBottomRight,
 156                        SK_ColorTRANSPARENT,
 157                        vertex_opacity,
 158                        flipped);
 159
 160   return overlay_quad;
 161 }
 162
 163 TextureDrawQuad* CreateFullscreenCandidateQuad(
 164     ResourceProvider* resource_provider,
 165     const SharedQuadState* shared_quad_state,
 166     RenderPass* render_pass) {
 167   return CreateCandidateQuadAt(
 168       resource_provider, shared_quad_state, render_pass, kOverlayRect);
 169 }
 170
 171 void CreateCheckeredQuadAt(ResourceProvider* resource_provider,
 172                            const SharedQuadState* shared_quad_state,
 173                            RenderPass* render_pass,
 174                            const gfx::Rect& rect) {
 175   CheckerboardDrawQuad* checkerboard_quad =
 176       render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
 177   checkerboard_quad->SetNew(shared_quad_state, rect, rect, SkColor());
 178 }
 179
 180 void CreateFullscreenCheckeredQuad(ResourceProvider* resource_provider,
 181                                    const SharedQuadState* shared_quad_state,
 182                                    RenderPass* render_pass) {
 183   CreateCheckeredQuadAt(
 184       resource_provider, shared_quad_state, render_pass, kOverlayRect);
 185 }
 186
 187 static void CompareRenderPassLists(const RenderPassList& expected_list,
 188                                    const RenderPassList& actual_list) {
 189   EXPECT_EQ(expected_list.size(), actual_list.size());
 190   for (size_t i = 0; i < actual_list.size(); ++i) {
 191     RenderPass* expected = expected_list[i];
 192     RenderPass* actual = actual_list[i];
 193
 194     EXPECT_EQ(expected->id, actual->id);
 195     EXPECT_RECT_EQ(expected->output_rect, actual->output_rect);
 196     EXPECT_EQ(expected->transform_to_root_target,
 197               actual->transform_to_root_target);
 198     EXPECT_RECT_EQ(expected->damage_rect, actual->damage_rect);
 199     EXPECT_EQ(expected->has_transparent_background,
 200               actual->has_transparent_background);
 201
 202     EXPECT_EQ(expected->shared_quad_state_list.size(),
 203               actual->shared_quad_state_list.size());
 204     EXPECT_EQ(expected->quad_list.size(), actual->quad_list.size());
 205
 206     for (size_t i = 0; i < expected->quad_list.size(); ++i) {
 207       EXPECT_EQ(expected->quad_list[i]->rect.ToString(),
 208                 actual->quad_list[i]->rect.ToString());
 209       EXPECT_EQ(
 210           expected->quad_list[i]->shared_quad_state->content_bounds.ToString(),
 211           actual->quad_list[i]->shared_quad_state->content_bounds.ToString());
 212     }
 213   }
 214 }
 215
 216 TEST(OverlayTest, NoOverlaysByDefault) {
 217   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
 218   OverlayOutputSurface output_surface(provider);
 219   EXPECT_EQ(NULL, output_surface.overlay_candidate_validator());
 220
 221   output_surface.InitWithSingleOverlayValidator();
 222   EXPECT_TRUE(output_surface.overlay_candidate_validator() != NULL);
 223 }
 224
 225 TEST(OverlayTest, OverlaysProcessorHasStrategy) {
 226   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
 227   OverlayOutputSurface output_surface(provider);
 228   FakeOutputSurfaceClient client;
 229   EXPECT_TRUE(output_surface.BindToClient(&client));
 230   output_surface.InitWithSingleOverlayValidator();
 231   EXPECT_TRUE(output_surface.overlay_candidate_validator() != NULL);
 232
 233   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
 234       new TestSharedBitmapManager());
 235   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
 236       &output_surface, shared_bitmap_manager.get(), 0, false, 1, false));
 237
 238   scoped_ptr<DefaultOverlayProcessor> overlay_processor(
 239       new DefaultOverlayProcessor(&output_surface, resource_provider.get()));
 240   overlay_processor->Initialize();
 241   EXPECT_GE(1U, overlay_processor->GetStrategyCount());
 242 }
 243
 244 class SingleOverlayOnTopTest : public testing::Test {
 245  protected:
 246   virtual void SetUp() {
 247     provider_ = TestContextProvider::Create();
 248     output_surface_.reset(new OverlayOutputSurface(provider_));
 249     EXPECT_TRUE(output_surface_->BindToClient(&client_));
 250     output_surface_->InitWithSingleOverlayValidator();
 251     EXPECT_TRUE(output_surface_->overlay_candidate_validator() != NULL);
 252
 253     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
 254     resource_provider_ = ResourceProvider::Create(
 255         output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1,
 256         false);
 257
 258     overlay_processor_.reset(new SingleOverlayProcessor(
 259         output_surface_.get(), resource_provider_.get()));
 260     overlay_processor_->Initialize();
 261   }
 262
 263   scoped_refptr<TestContextProvider> provider_;
 264   scoped_ptr<OverlayOutputSurface> output_surface_;
 265   FakeOutputSurfaceClient client_;
 266   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
 267   scoped_ptr<ResourceProvider> resource_provider_;
 268   scoped_ptr<SingleOverlayProcessor> overlay_processor_;
 269 };
 270
 271 TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
 272   scoped_ptr<RenderPass> pass = CreateRenderPass();
 273   TextureDrawQuad* original_quad =
 274       CreateFullscreenCandidateQuad(resource_provider_.get(),
 275                                     pass->shared_quad_state_list.back(),
 276                                     pass.get());
 277   unsigned original_resource_id = original_quad->resource_id;
 278
 279   // Add something behind it.
 280   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 281                                 pass->shared_quad_state_list.back(),
 282                                 pass.get());
 283   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 284                                 pass->shared_quad_state_list.back(),
 285                                 pass.get());
 286
 287   RenderPassList pass_list;
 288   pass_list.push_back(pass.Pass());
 289
 290   // Check for potential candidates.
 291   OverlayCandidateList candidate_list;
 292   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 293
 294   ASSERT_EQ(1U, pass_list.size());
 295   ASSERT_EQ(2U, candidate_list.size());
 296
 297   RenderPass* main_pass = pass_list.back();
 298   // Check that the quad is gone.
 299   EXPECT_EQ(2U, main_pass->quad_list.size());
 300   const QuadList& quad_list = main_pass->quad_list;
 301   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
 302        it != quad_list.BackToFrontEnd();
 303        ++it) {
 304     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, (*it)->material);
 305   }
 306
 307   // Check that the right resource id got extracted.
 308   EXPECT_EQ(original_resource_id, candidate_list.back().resource_id);
 309 }
 310
 311 TEST_F(SingleOverlayOnTopTest, NoCandidates) {
 312   scoped_ptr<RenderPass> pass = CreateRenderPass();
 313   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 314                                 pass->shared_quad_state_list.back(),
 315                                 pass.get());
 316   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 317                                 pass->shared_quad_state_list.back(),
 318                                 pass.get());
 319
 320   RenderPassList pass_list;
 321   pass_list.push_back(pass.Pass());
 322
 323   RenderPassList original_pass_list;
 324   RenderPass::CopyAll(pass_list, &original_pass_list);
 325
 326   OverlayCandidateList candidate_list;
 327   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 328   EXPECT_EQ(0U, candidate_list.size());
 329   // There should be nothing new here.
 330   CompareRenderPassLists(pass_list, original_pass_list);
 331 }
 332
 333 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) {
 334   scoped_ptr<RenderPass> pass = CreateRenderPass();
 335   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 336                                 pass->shared_quad_state_list.back(),
 337                                 pass.get());
 338   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 339                                 pass->shared_quad_state_list.back(),
 340                                 pass.get());
 341
 342   CreateFullscreenCandidateQuad(resource_provider_.get(),
 343                                 pass->shared_quad_state_list.back(),
 344                                 pass.get());
 345
 346   RenderPassList pass_list;
 347   pass_list.push_back(pass.Pass());
 348
 349   RenderPassList original_pass_list;
 350   RenderPass::CopyAll(pass_list, &original_pass_list);
 351
 352   OverlayCandidateList candidate_list;
 353   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 354   EXPECT_EQ(0U, candidate_list.size());
 355   // There should be nothing new here.
 356   CompareRenderPassLists(pass_list, original_pass_list);
 357 }
 358
 359 // Test with multiple render passes.
 360 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
 361   RenderPassList pass_list;
 362   pass_list.push_back(CreateRenderPass());
 363
 364   scoped_ptr<RenderPass> pass = CreateRenderPass();
 365   CreateFullscreenCandidateQuad(resource_provider_.get(),
 366                                 pass->shared_quad_state_list.back(),
 367                                 pass.get());
 368
 369   // Add something behind it.
 370   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 371                                 pass->shared_quad_state_list.back(),
 372                                 pass.get());
 373   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 374                                 pass->shared_quad_state_list.back(),
 375                                 pass.get());
 376
 377   pass_list.push_back(pass.Pass());
 378
 379   RenderPassList original_pass_list;
 380   RenderPass::CopyAll(pass_list, &original_pass_list);
 381
 382   // Check for potential candidates.
 383   OverlayCandidateList candidate_list;
 384   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 385   EXPECT_EQ(2U, candidate_list.size());
 386
 387   // This should be the same.
 388   ASSERT_EQ(2U, pass_list.size());
 389 }
 390
 391 TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) {
 392   scoped_ptr<RenderPass> pass = CreateRenderPass();
 393   TextureDrawQuad* quad =
 394       CreateFullscreenCandidateQuad(resource_provider_.get(),
 395                                     pass->shared_quad_state_list.back(),
 396                                     pass.get());
 397   quad->premultiplied_alpha = true;
 398
 399   RenderPassList pass_list;
 400   pass_list.push_back(pass.Pass());
 401   OverlayCandidateList candidate_list;
 402   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 403   EXPECT_EQ(1U, pass_list.size());
 404   EXPECT_EQ(0U, candidate_list.size());
 405 }
 406
 407 TEST_F(SingleOverlayOnTopTest, RejectBlending) {
 408   scoped_ptr<RenderPass> pass = CreateRenderPass();
 409   TextureDrawQuad* quad =
 410       CreateFullscreenCandidateQuad(resource_provider_.get(),
 411                                     pass->shared_quad_state_list.back(),
 412                                     pass.get());
 413   quad->needs_blending = true;
 414
 415   RenderPassList pass_list;
 416   pass_list.push_back(pass.Pass());
 417   OverlayCandidateList candidate_list;
 418   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 419   ASSERT_EQ(1U, pass_list.size());
 420   EXPECT_EQ(0U, candidate_list.size());
 421 }
 422
 423 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) {
 424   scoped_ptr<RenderPass> pass = CreateRenderPass();
 425   TextureDrawQuad* quad =
 426       CreateFullscreenCandidateQuad(resource_provider_.get(),
 427                                     pass->shared_quad_state_list.back(),
 428                                     pass.get());
 429   quad->background_color = SK_ColorBLACK;
 430
 431   RenderPassList pass_list;
 432   pass_list.push_back(pass.Pass());
 433   OverlayCandidateList candidate_list;
 434   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 435   ASSERT_EQ(1U, pass_list.size());
 436   EXPECT_EQ(0U, candidate_list.size());
 437 }
 438
 439 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) {
 440   scoped_ptr<RenderPass> pass = CreateRenderPass();
 441   CreateFullscreenCandidateQuad(resource_provider_.get(),
 442                                 pass->shared_quad_state_list.back(),
 443                                 pass.get());
 444   pass->shared_quad_state_list.back()->blend_mode = SkXfermode::kScreen_Mode;
 445
 446   RenderPassList pass_list;
 447   pass_list.push_back(pass.Pass());
 448   OverlayCandidateList candidate_list;
 449   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 450   ASSERT_EQ(1U, pass_list.size());
 451   EXPECT_EQ(0U, candidate_list.size());
 452 }
 453
 454 TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
 455   scoped_ptr<RenderPass> pass = CreateRenderPass();
 456   CreateFullscreenCandidateQuad(resource_provider_.get(),
 457                                 pass->shared_quad_state_list.back(),
 458                                 pass.get());
 459   pass->shared_quad_state_list.back()->opacity = 0.5f;
 460
 461   RenderPassList pass_list;
 462   pass_list.push_back(pass.Pass());
 463   OverlayCandidateList candidate_list;
 464   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 465   ASSERT_EQ(1U, pass_list.size());
 466   EXPECT_EQ(0U, candidate_list.size());
 467 }
 468
 469 TEST_F(SingleOverlayOnTopTest, RejectTransform) {
 470   scoped_ptr<RenderPass> pass = CreateRenderPass();
 471   CreateFullscreenCandidateQuad(resource_provider_.get(),
 472                                 pass->shared_quad_state_list.back(),
 473                                 pass.get());
 474   pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.f,
 475                                                                          2.f);
 476
 477   RenderPassList pass_list;
 478   pass_list.push_back(pass.Pass());
 479   OverlayCandidateList candidate_list;
 480   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 481   ASSERT_EQ(1U, pass_list.size());
 482   EXPECT_EQ(0U, candidate_list.size());
 483 }
 484
 485 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
 486   scoped_ptr<RenderPass> pass = CreateRenderPass();
 487   CreateCheckeredQuadAt(resource_provider_.get(),
 488                         pass->shared_quad_state_list.back(),
 489                         pass.get(),
 490                         kOverlayTopLeftRect);
 491   CreateCandidateQuadAt(resource_provider_.get(),
 492                         pass->shared_quad_state_list.back(),
 493                         pass.get(),
 494                         kOverlayBottomRightRect);
 495
 496   RenderPassList pass_list;
 497   pass_list.push_back(pass.Pass());
 498
 499   RenderPassList original_pass_list;
 500   RenderPass::CopyAll(pass_list, &original_pass_list);
 501
 502   OverlayCandidateList candidate_list;
 503   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 504   EXPECT_EQ(1U, pass_list.size());
 505   EXPECT_EQ(2U, candidate_list.size());
 506 }
 507
 508 class OverlayInfoRendererGL : public GLRenderer {
 509  public:
 510   OverlayInfoRendererGL(RendererClient* client,
 511                         const LayerTreeSettings* settings,
 512                         OutputSurface* output_surface,
 513                         ResourceProvider* resource_provider)
 514       : GLRenderer(client,
 515                    settings,
 516                    output_surface,
 517                    resource_provider,
 518                    NULL,
 519                    0),
 520         expect_overlays_(false) {}
 521
 522   MOCK_METHOD2(DoDrawQuad, void(DrawingFrame* frame, const DrawQuad* quad));
 523
 524   virtual void FinishDrawingFrame(DrawingFrame* frame) OVERRIDE {
 525     GLRenderer::FinishDrawingFrame(frame);
 526
 527     if (!expect_overlays_) {
 528       EXPECT_EQ(0U, frame->overlay_list.size());
 529       return;
 530     }
 531
 532     ASSERT_EQ(2U, frame->overlay_list.size());
 533     EXPECT_NE(0U, frame->overlay_list.back().resource_id);
 534   }
 535
 536   void set_expect_overlays(bool expect_overlays) {
 537     expect_overlays_ = expect_overlays;
 538   }
 539
 540  private:
 541   bool expect_overlays_;
 542 };
 543
 544 class FakeRendererClient : public RendererClient {
 545  public:
 546   // RendererClient methods.
 547   virtual void SetFullRootLayerDamage() OVERRIDE {}
 548 };
 549
 550 class MockOverlayScheduler {
 551  public:
 552   MOCK_METHOD5(Schedule,
 553                void(int plane_z_order,
 554                     gfx::OverlayTransform plane_transform,
 555                     unsigned overlay_texture_id,
 556                     const gfx::Rect& display_bounds,
 557                     const gfx::RectF& uv_rect));
 558 };
 559
 560 class GLRendererWithOverlaysTest : public testing::Test {
 561  protected:
 562   GLRendererWithOverlaysTest() {
 563     provider_ = TestContextProvider::Create();
 564     output_surface_.reset(new OverlayOutputSurface(provider_));
 565     CHECK(output_surface_->BindToClient(&output_surface_client_));
 566     resource_provider_ =
 567         ResourceProvider::Create(output_surface_.get(), NULL, 0, false, 1,
 568         false);
 569
 570     provider_->support()->SetScheduleOverlayPlaneCallback(base::Bind(
 571         &MockOverlayScheduler::Schedule, base::Unretained(&scheduler_)));
 572   }
 573
 574   void Init(bool use_validator) {
 575     if (use_validator)
 576       output_surface_->InitWithSingleOverlayValidator();
 577
 578     renderer_ =
 579         make_scoped_ptr(new OverlayInfoRendererGL(&renderer_client_,
 580                                                   &settings_,
 581                                                   output_surface_.get(),
 582                                                   resource_provider_.get()));
 583   }
 584
 585   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 586
 587   LayerTreeSettings settings_;
 588   FakeOutputSurfaceClient output_surface_client_;
 589   scoped_ptr<OverlayOutputSurface> output_surface_;
 590   FakeRendererClient renderer_client_;
 591   scoped_ptr<ResourceProvider> resource_provider_;
 592   scoped_ptr<OverlayInfoRendererGL> renderer_;
 593   scoped_refptr<TestContextProvider> provider_;
 594   MockOverlayScheduler scheduler_;
 595 };
 596
 597 TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
 598   bool use_validator = true;
 599   Init(use_validator);
 600   renderer_->set_expect_overlays(true);
 601   gfx::Rect viewport_rect(16, 16);
 602
 603   scoped_ptr<RenderPass> pass = CreateRenderPass();
 604
 605   CreateFullscreenCandidateQuad(resource_provider_.get(),
 606                                 pass->shared_quad_state_list.back(),
 607                                 pass.get());
 608
 609   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 610                                 pass->shared_quad_state_list.back(),
 611                                 pass.get());
 612   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 613                                 pass->shared_quad_state_list.back(),
 614                                 pass.get());
 615
 616   RenderPassList pass_list;
 617   pass_list.push_back(pass.Pass());
 618
 619   // Candidate pass was taken out and extra skipped pass added,
 620   // so only draw 2 quads.
 621   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(2);
 622   EXPECT_CALL(scheduler_,
 623               Schedule(1,
 624                        gfx::OVERLAY_TRANSFORM_NONE,
 625                        _,
 626                        kOverlayRect,
 627                        BoundingRect(kUVTopLeft, kUVBottomRight))).Times(1);
 628   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 629
 630   SwapBuffers();
 631
 632   Mock::VerifyAndClearExpectations(renderer_.get());
 633   Mock::VerifyAndClearExpectations(&scheduler_);
 634 }
 635
 636 TEST_F(GLRendererWithOverlaysTest, OccludedQuadDrawn) {
 637   bool use_validator = true;
 638   Init(use_validator);
 639   renderer_->set_expect_overlays(false);
 640   gfx::Rect viewport_rect(16, 16);
 641
 642   scoped_ptr<RenderPass> pass = CreateRenderPass();
 643
 644   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 645                                 pass->shared_quad_state_list.back(),
 646                                 pass.get());
 647   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 648                                 pass->shared_quad_state_list.back(),
 649                                 pass.get());
 650
 651   CreateFullscreenCandidateQuad(resource_provider_.get(),
 652                                 pass->shared_quad_state_list.back(),
 653                                 pass.get());
 654
 655   RenderPassList pass_list;
 656   pass_list.push_back(pass.Pass());
 657
 658   // 3 quads in the pass, all should draw.
 659   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3);
 660   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
 661   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 662
 663   SwapBuffers();
 664
 665   Mock::VerifyAndClearExpectations(renderer_.get());
 666   Mock::VerifyAndClearExpectations(&scheduler_);
 667 }
 668
 669 TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) {
 670   bool use_validator = false;
 671   Init(use_validator);
 672   renderer_->set_expect_overlays(false);
 673   gfx::Rect viewport_rect(16, 16);
 674
 675   scoped_ptr<RenderPass> pass = CreateRenderPass();
 676
 677   CreateFullscreenCandidateQuad(resource_provider_.get(),
 678                                 pass->shared_quad_state_list.back(),
 679                                 pass.get());
 680
 681   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 682                                 pass->shared_quad_state_list.back(),
 683                                 pass.get());
 684   CreateFullscreenCheckeredQuad(resource_provider_.get(),
 685                                 pass->shared_quad_state_list.back(),
 686                                 pass.get());
 687
 688   RenderPassList pass_list;
 689   pass_list.push_back(pass.Pass());
 690
 691   // Should see no overlays.
 692   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3);
 693   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
 694   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 695
 696   SwapBuffers();
 697
 698   Mock::VerifyAndClearExpectations(renderer_.get());
 699   Mock::VerifyAndClearExpectations(&scheduler_);
 700 }
 701
 702 TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturned) {
 703   bool use_validator = true;
 704   Init(use_validator);
 705   renderer_->set_expect_overlays(true);
 706
 707   ResourceProvider::ResourceId resource1 =
 708       CreateResource(resource_provider_.get());
 709   ResourceProvider::ResourceId resource2 =
 710       CreateResource(resource_provider_.get());
 711
 712   DirectRenderer::DrawingFrame frame1;
 713   frame1.overlay_list.resize(2);
 714   OverlayCandidate& overlay1 = frame1.overlay_list.back();
 715   overlay1.resource_id = resource1;
 716   overlay1.plane_z_order = 1;
 717
 718   DirectRenderer::DrawingFrame frame2;
 719   frame2.overlay_list.resize(2);
 720   OverlayCandidate& overlay2 = frame2.overlay_list.back();
 721   overlay2.resource_id = resource2;
 722   overlay2.plane_z_order = 1;
 723
 724   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
 725   renderer_->FinishDrawingFrame(&frame1);
 726   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 727   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource2));
 728   SwapBuffers();
 729   Mock::VerifyAndClearExpectations(&scheduler_);
 730
 731   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
 732   renderer_->FinishDrawingFrame(&frame2);
 733   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 734   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource2));
 735   SwapBuffers();
 736   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
 737   Mock::VerifyAndClearExpectations(&scheduler_);
 738
 739   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
 740   renderer_->FinishDrawingFrame(&frame1);
 741   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 742   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource2));
 743   SwapBuffers();
 744   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource2));
 745   Mock::VerifyAndClearExpectations(&scheduler_);
 746
 747   // No overlays, release the resource.
 748   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
 749   DirectRenderer::DrawingFrame frame3;
 750   renderer_->set_expect_overlays(false);
 751   renderer_->FinishDrawingFrame(&frame3);
 752   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 753   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource2));
 754   SwapBuffers();
 755   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
 756   Mock::VerifyAndClearExpectations(&scheduler_);
 757
 758   // Use the same buffer twice.
 759   renderer_->set_expect_overlays(true);
 760   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
 761   renderer_->FinishDrawingFrame(&frame1);
 762   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 763   SwapBuffers();
 764   Mock::VerifyAndClearExpectations(&scheduler_);
 765
 766   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
 767   renderer_->FinishDrawingFrame(&frame1);
 768   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 769   SwapBuffers();
 770   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 771   Mock::VerifyAndClearExpectations(&scheduler_);
 772
 773   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
 774   renderer_->set_expect_overlays(false);
 775   renderer_->FinishDrawingFrame(&frame3);
 776   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
 777   SwapBuffers();
 778   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
 779   Mock::VerifyAndClearExpectations(&scheduler_);
 780 }
 781
 782 }  // namespace
 783 }  // namespace cc