Mac Overlays: Allow SolidColor and Tile quads to be candidates for overlays.

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/region.h"
 #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"
@@ skipping 47 matching lines @@
                      BlockingTaskRunner* main_thread_task_runner) {
 }
 
 class SingleOverlayValidator : public OverlayCandidateValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(
         make_scoped_ptr(new OverlayStrategySingleOnTop(this)));
     strategies->push_back(make_scoped_ptr(new OverlayStrategyUnderlay(this)));
   }
+  bool IsSupportedQuad(const DrawQuad* quad) override { return true; }
   void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
     // We may have 1 or 2 surfaces depending on whether this ran through the
     // full renderer and picked up the output surface, or not.
     ASSERT_LE(1U, surfaces->size());
     ASSERT_GE(2U, surfaces->size());
 
     OverlayCandidate& candidate = surfaces->back();
-    EXPECT_TRUE(!candidate.use_output_surface_for_resource);
+    EXPECT_EQ(OverlayCandidate::HAS_RESOURCE, candidate.resource_type);
     if (candidate.display_rect.width() == 64) {
       EXPECT_EQ(gfx::RectF(kOverlayBottomRightRect), candidate.display_rect);
     } else {
       EXPECT_NEAR(kOverlayRect.x(), candidate.display_rect.x(), 0.01f);
       EXPECT_NEAR(kOverlayRect.y(), candidate.display_rect.y(), 0.01f);
       EXPECT_NEAR(kOverlayRect.width(), candidate.display_rect.width(), 0.01f);
       EXPECT_NEAR(kOverlayRect.height(), candidate.display_rect.height(),
                   0.01f);
     }
     EXPECT_FLOAT_RECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight),
@@ skipping 19 matching lines @@
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(make_scoped_ptr(new OverlayStrategyUnderlay(this)));
   }
 };
 
 class SandwichOverlayValidator : public OverlayCandidateValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(make_scoped_ptr(new OverlayStrategySandwich(this)));
   }
+  bool IsSupportedQuad(const DrawQuad* quad) override { return true; }
   void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
     for (OverlayCandidate& candidate : *surfaces)
       candidate.overlay_handled = true;
   }
 };
 
 class AllOrNothingOverlayValidator : public OverlayCandidateValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(
         make_scoped_ptr(new OverlayStrategyAllOrNothing(this)));
   }
+  bool IsSupportedQuad(const DrawQuad* quad) override { return true; }
   void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
     for (OverlayCandidate& candidate : *surfaces)
       candidate.overlay_handled = true;
   }
 };
 
 class DefaultOverlayProcessor : public OverlayProcessor {
  public:
   explicit DefaultOverlayProcessor(OutputSurface* surface);
   size_t GetStrategyCount();
@@ skipping 290 matching lines @@
   RenderPass* main_pass = pass_list.back();
   // Check that the quad is gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd(); ++it) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
   }
 
   // Check that the right resource id got extracted.
-  EXPECT_EQ(original_resource_id, candidate_list.back().resource_id);
+  EXPECT_EQ(original_resource_id, candidate_list.back().resource.resource_id);
 }
 
 TEST_F(SandwichTest, CroppedSingleOverlay) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(0, 32, 64, 64);
 
   TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad(
       resource_provider_.get(), pass->shared_quad_state_list.back(),
       pass.get());
@@ skipping 11 matching lines @@
   pass_list.push_back(pass.Pass());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
                                          &candidate_list);
 
   // Ensure that the display and uv rects have cropping applied to them.
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
-  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
+  EXPECT_EQ(candidate_id, candidate_list[0].resource.resource_id);
   EXPECT_EQ(gfx::RectF(0.f, 32.f, 64.f, 64.f), candidate_list[0].display_rect);
   EXPECT_EQ(gfx::RectF(0.f, 0.25f, 0.5f, 0.5f), candidate_list[0].uv_rect);
 }
 
 TEST_F(SandwichTest, SuccessfulTwoOverlays) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
 
   // Add two non-overlapping candidates.
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
@@ skipping 86 matching lines @@
 
   RenderPass* main_pass = pass_list.back();
   // Check that the quad is gone.
   EXPECT_EQ(3U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd(); ++it) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
   }
 
-  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
+  EXPECT_EQ(candidate_id, candidate_list[0].resource.resource_id);
   EXPECT_EQ(gfx::RectF(32.f, 32.f, 32.f, 32.f), candidate_list[0].display_rect);
-  EXPECT_TRUE(candidate_list[1].use_output_surface_for_resource);
+  EXPECT_EQ(OverlayCandidate::USE_OUTPUT_SURFACE,
+            candidate_list[1].resource_type);
   EXPECT_EQ(gfx::RectF(32.f, 32.f, 16.f, 16.f), candidate_list[1].display_rect);
   EXPECT_EQ(gfx::RectF(32.f / 256.f, 32.f / 256.f, 16.f / 256.f, 16.f / 256.f),
             candidate_list[1].uv_rect);
 }
 
 TEST_F(SandwichTest, MultiQuadOverlay) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
 
   // Put two non-intersecting quads on top.
   const gfx::Rect rect1(gfx::Rect(0, 0, 32, 32));
@@ skipping 41 matching lines @@
     if (it->material == DrawQuad::SOLID_COLOR) {
       const SolidColorDrawQuad* solid_color_quad =
           SolidColorDrawQuad::MaterialCast(*it);
       if (solid_color_quad->color == SK_ColorTRANSPARENT)
         transparent_quad_region.Union(solid_color_quad->rect);
     }
   }
   DCHECK(covered_region == transparent_quad_region);
 
   // Check that overlays cover the same region that the quads covered.
-  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
+  EXPECT_EQ(candidate_id, candidate_list[0].resource.resource_id);
   EXPECT_EQ(gfx::RectF(64.f, 64.f), candidate_list[0].display_rect);
-  EXPECT_TRUE(candidate_list[1].use_output_surface_for_resource);
-  EXPECT_TRUE(candidate_list[2].use_output_surface_for_resource);
+  EXPECT_EQ(OverlayCandidate::USE_OUTPUT_SURFACE,
+            candidate_list[1].resource_type);
+  EXPECT_EQ(OverlayCandidate::USE_OUTPUT_SURFACE,
+            candidate_list[2].resource_type);
   Region overlay_region;
   overlay_region.Union(gfx::ToEnclosingRect(candidate_list[1].display_rect));
   overlay_region.Union(gfx::ToEnclosingRect(candidate_list[2].display_rect));
   DCHECK(covered_region == overlay_region);
 }
 
 TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
@@ skipping 22 matching lines @@
   // Check that the quad is gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
        ++it) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
   }
 
   // Check that the right resource id got extracted.
-  EXPECT_EQ(original_resource_id, candidate_list.back().resource_id);
+  EXPECT_EQ(original_resource_id, candidate_list.back().resource.resource_id);
 }
 
 TEST_F(SingleOverlayOnTopTest, NoCandidates) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   RenderPassList pass_list;
@@ skipping 610 matching lines @@
 
   void FinishDrawingFrame(DrawingFrame* frame) override {
     GLRenderer::FinishDrawingFrame(frame);
 
     if (!expect_overlays_) {
       EXPECT_EQ(0U, frame->overlay_list.size());
       return;
     }
 
     ASSERT_EQ(2U, frame->overlay_list.size());
-    EXPECT_NE(0U, frame->overlay_list.back().resource_id);
+    EXPECT_NE(0U, frame->overlay_list.back().resource.resource_id);
   }
 
   void set_expect_overlays(bool expect_overlays) {
     expect_overlays_ = expect_overlays;
   }
 
  private:
   bool expect_overlays_;
 };
 
@@ skipping 169 matching lines @@
   ResourceId resource3 =
       CreateResource(resource_provider_.get(), gfx::Size(32, 32), true);
 
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   DirectRenderer::DrawingFrame frame1;
   frame1.render_passes_in_draw_order = &pass_list;
   frame1.overlay_list.resize(2);
-  frame1.overlay_list.front().use_output_surface_for_resource = true;
+  frame1.overlay_list.front().resource_type =
+      OverlayCandidate::USE_OUTPUT_SURFACE;
   OverlayCandidate& overlay1 = frame1.overlay_list.back();
-  overlay1.resource_id = resource1;
+  overlay1.resource.resource_id = resource1;
   overlay1.plane_z_order = 1;
 
   DirectRenderer::DrawingFrame frame2;
   frame2.render_passes_in_draw_order = &pass_list;
   frame2.overlay_list.resize(2);
-  frame2.overlay_list.front().use_output_surface_for_resource = true;
+  frame2.overlay_list.front().resource_type =
+      OverlayCandidate::USE_OUTPUT_SURFACE;
   OverlayCandidate& overlay2 = frame2.overlay_list.back();
-  overlay2.resource_id = resource2;
+  overlay2.resource.resource_id = resource2;
   overlay2.plane_z_order = 1;
 
   DirectRenderer::DrawingFrame frame3;
   frame3.render_passes_in_draw_order = &pass_list;
   frame3.overlay_list.resize(2);
-  frame3.overlay_list.front().use_output_surface_for_resource = true;
+  frame3.overlay_list.front().resource_type =
+      OverlayCandidate::USE_OUTPUT_SURFACE;
   OverlayCandidate& overlay3 = frame3.overlay_list.back();
-  overlay3.resource_id = resource3;
+  overlay3.resource.resource_id = resource3;
   overlay3.plane_z_order = 1;
 
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource2));
   SwapBuffers();
   Mock::VerifyAndClearExpectations(&scheduler_);
 
@@ skipping 66 matching lines @@
   renderer_->BeginDrawingFrame(&frame_no_overlays);
   renderer_->FinishDrawingFrame(&frame_no_overlays);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc