Add underlays and split off common overlay functionality

cc/output/overlay_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
+#include "cc/output/overlay_strategy_underlay.h"
 #include "cc/quads/checkerboard_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
@@ skipping 39 matching lines @@
   OverlayCandidate& candidate = surfaces->back();
   if (candidate.display_rect.width() == 64)
     EXPECT_EQ(kOverlayBottomRightRect, candidate.display_rect);
   else
     EXPECT_EQ(kOverlayRect, candidate.display_rect);
   EXPECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight).ToString(),
             candidate.uv_rect.ToString());
   candidate.overlay_handled = true;
 }
 
+template <typename OverlayStrategyType>
 class SingleOverlayProcessor : public OverlayProcessor {
  public:
   SingleOverlayProcessor(OutputSurface* surface,
-                         ResourceProvider* resource_provider);
+                         ResourceProvider* resource_provider)
+      : OverlayProcessor(surface, resource_provider) {
+    EXPECT_EQ(surface, surface_);
+    EXPECT_EQ(resource_provider, resource_provider_);
+  }
+
   // Virtual to allow testing different strategies.
-  void Initialize() override;
+  void Initialize() override {
+    OverlayCandidateValidator* candidates =
+        surface_->overlay_candidate_validator();
+    ASSERT_TRUE(candidates != NULL);
+    strategies_.push_back(scoped_ptr<Strategy>(
+        new OverlayStrategyType(candidates, resource_provider_)));
+  }
 };
 
-SingleOverlayProcessor::SingleOverlayProcessor(
-    OutputSurface* surface,
-    ResourceProvider* resource_provider)
-    : OverlayProcessor(surface, resource_provider) {
-  EXPECT_EQ(surface, surface_);
-  EXPECT_EQ(resource_provider, resource_provider_);
-}
-
-void SingleOverlayProcessor::Initialize() {
-  OverlayCandidateValidator* candidates =
-      surface_->overlay_candidate_validator();
-  ASSERT_TRUE(candidates != NULL);
-  strategies_.push_back(scoped_ptr<Strategy>(
-      new OverlayStrategySingleOnTop(candidates, resource_provider_)));
-}
-
 class DefaultOverlayProcessor : public OverlayProcessor {
  public:
   DefaultOverlayProcessor(OutputSurface* surface,
                           ResourceProvider* resource_provider);
   size_t GetStrategyCount();
 };
 
 DefaultOverlayProcessor::DefaultOverlayProcessor(
     OutputSurface* surface,
     ResourceProvider* resource_provider)
@@ skipping 190 matching lines @@
       new TestSharedBitmapManager());
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       &output_surface, shared_bitmap_manager.get(), NULL, NULL, 0, false, 1));
 
   scoped_ptr<DefaultOverlayProcessor> overlay_processor(
       new DefaultOverlayProcessor(&output_surface, resource_provider.get()));
   overlay_processor->Initialize();
   EXPECT_GE(1U, overlay_processor->GetStrategyCount());
 }
 
-class SingleOverlayOnTopTest : public testing::Test {
+template <typename OverlayStrategyType>
+class OverlayTest : public testing::Test {
  protected:
   void SetUp() override {
     provider_ = TestContextProvider::Create();
     output_surface_.reset(new OverlayOutputSurface(provider_));
     EXPECT_TRUE(output_surface_->BindToClient(&client_));
     output_surface_->InitWithSingleOverlayValidator();
     EXPECT_TRUE(output_surface_->overlay_candidate_validator() != NULL);
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   shared_bitmap_manager_.get(),
                                                   NULL,
                                                   NULL,
                                                   0,
                                                   false,
                                                   1);
 
-    overlay_processor_.reset(new SingleOverlayProcessor(
+    overlay_processor_.reset(new SingleOverlayProcessor<OverlayStrategyType>(
         output_surface_.get(), resource_provider_.get()));
     overlay_processor_->Initialize();
   }
 
   scoped_refptr<TestContextProvider> provider_;
   scoped_ptr<OverlayOutputSurface> output_surface_;
   FakeOutputSurfaceClient client_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<SingleOverlayProcessor> overlay_processor_;
+  scoped_ptr<SingleOverlayProcessor<OverlayStrategyType>> overlay_processor_;
 };
 
+typedef OverlayTest<OverlayStrategySingleOnTop> SingleOverlayOnTopTest;
+typedef OverlayTest<OverlayStrategyUnderlay> UnderlayTest;
+
 TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
                                     pass.get());
   unsigned original_resource_id = original_quad->resource_id;
 
   // Add something behind it.
   CreateFullscreenCheckeredQuad(resource_provider_.get(),
@@ skipping 408 matching lines @@
                                      pass.get(), kYMirrorTransform);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(2U, candidate_list.size());
 }
 
+TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCheckeredQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayBottomRightRect);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  EXPECT_EQ(1U, pass_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(0, candidate_list[0].plane_z_order);
+  EXPECT_EQ(-1, candidate_list[1].plane_z_order);
+  // The overlay quad should have changed to a transparent SOLID_COLOR quad.
+  ASSERT_EQ(pass_list[0]->quad_list.back()->material, DrawQuad::SOLID_COLOR);

[danakj, 2015/03/24 17:55:15]

EXPECT is nicer than ASSERT unless you're guarding crashes

[danakj, 2015/03/24 17:55:15]

Can you verify the pass_list[0]->quad_list size?

Did you mean to check the quad's color is transparent? The comment changed but
not the code.

[achaulk, 2015/03/27 17:17:47]

Ah, I initially did, and changed it to an assert because of the MaterialCast,
but then I changed the solid color quad in the test to a checkered one since
that's a simpler way of doing it. I'll clean it up

+}
+
+TEST_F(UnderlayTest, AllowOnTop) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  pass->CreateAndAppendSharedQuadState()->opacity = 0.5f;
+  CreateFullscreenCheckeredQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  EXPECT_EQ(1U, pass_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(0, candidate_list[0].plane_z_order);
+  EXPECT_EQ(-1, candidate_list[1].plane_z_order);
+  // The overlay quad should have changed to a SOLID_COLOR quad.
+  EXPECT_EQ(pass_list[0]->quad_list.front()->material, DrawQuad::SOLID_COLOR);
+}
+
 class OverlayInfoRendererGL : public GLRenderer {
  public:
   OverlayInfoRendererGL(RendererClient* client,
                         const RendererSettings* settings,
                         OutputSurface* output_surface,
                         ResourceProvider* resource_provider)
       : GLRenderer(client,
                    settings,
                    output_surface,
                    resource_provider,
@@ skipping 274 matching lines @@
   renderer_->BeginDrawingFrame(&frame3);
   renderer_->FinishDrawingFrame(&frame3);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc