Mac Overlays: Allow sandwich strategy to emit multiple 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"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
 #include "cc/output/overlay_strategy_sandwich.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/solid_color_draw_quad.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/fake_resource_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rect_conversions.h"
 
 using testing::_;
 using testing::Mock;
 
 namespace cc {
 namespace {
 
 const gfx::Size kDisplaySize(256, 256);
 const gfx::Rect kOverlayRect(0, 0, 128, 128);
 const gfx::Rect kOverlayTopLeftRect(0, 0, 64, 64);
@@ skipping 497 matching lines @@
   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());
   ASSERT_EQ(0U, candidate_list.size());
 }
 
+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));
+  const gfx::Rect rect2(gfx::Rect(32, 32, 32, 32));
+  Region covered_region;
+  covered_region.Union(rect1);
+  covered_region.Union(rect2);
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(), rect1);
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(), rect2);
+
+  // Then a candidate that we'll turn into an overlay.
+  unsigned candidate_id =
+      CreateCandidateQuadAt(resource_provider_.get(),
+                            pass->shared_quad_state_list.back(), pass.get(),
+                            gfx::Rect(0, 0, 64, 64))
+          ->resource_id();
+
+  // Then some opaque background.
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(),
+                     gfx::Rect(kDisplaySize));
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  // Run the overlay strategy on that input.
+  RenderPass* main_pass = pass_list.back();
+  OverlayCandidateList candidate_list;
+  EXPECT_EQ(4U, main_pass->quad_list.size());
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  ASSERT_EQ(1U, pass_list.size());
+  ASSERT_EQ(4U, candidate_list.size());
+
+  // Check that the candidate quad is gone and that we now have two transparent
+  // quads for the same region that was covered on the overlay.
+  EXPECT_EQ(5U, main_pass->quad_list.size());
+  const QuadList& quad_list = main_pass->quad_list;
+  Region transparent_quad_region;
+  for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
+       it != quad_list.BackToFrontEnd(); ++it) {
+    EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
+    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_FALSE(candidate_list[0].use_output_surface_for_resource);
+  EXPECT_EQ(candidate_id, candidate_list[1].resource_id);
+  EXPECT_EQ(gfx::Rect(0, 0, 64, 64), candidate_list[1].display_rect);
+  EXPECT_TRUE(candidate_list[2].use_output_surface_for_resource);
+  EXPECT_TRUE(candidate_list[3].use_output_surface_for_resource);
+  Region overlay_region;
+  overlay_region.Union(gfx::ToEnclosingRect(candidate_list[2].display_rect));
+  overlay_region.Union(gfx::ToEnclosingRect(candidate_list[3].display_rect));
+  DCHECK(covered_region == overlay_region);
+}
+
 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.
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
@@ skipping 810 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