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