Add underlays and split off common overlay functionality

cc/output/overlay_unittest.cc

Index: cc/output/overlay_unittest.cc
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 75fbb6ebaf1059ce8a71cf32b2434e9cf2f50d3e..745e859815a83e8abd2370606a1952b320e4cce2 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -10,6 +10,7 @@
 #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"
@@ -69,30 +70,26 @@ void SingleOverlayValidator::CheckOverlaySupport(
   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,
@@ -303,7 +300,8 @@ TEST(OverlayTest, OverlaysProcessorHasStrategy) {
   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();
@@ -321,7 +319,7 @@ class SingleOverlayOnTopTest : public testing::Test {
                                                   false,
                                                   1);
 
-    overlay_processor_.reset(new SingleOverlayProcessor(
+    overlay_processor_.reset(new SingleOverlayProcessor<OverlayStrategyType>(
         output_surface_.get(), resource_provider_.get()));
     overlay_processor_->Initialize();
   }
@@ -331,9 +329,12 @@ class SingleOverlayOnTopTest : public testing::Test {
   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 =
@@ -762,6 +763,51 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
   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,