Mac Overlays: Add AllOrNothing strategy

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_all_or_nothing.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"
@@ skipping 86 matching lines @@
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(make_scoped_ptr(
         new OverlayStrategyCommon(this, new OverlayStrategySandwich)));
   }
   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)));
+  }
+  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();
 };
 
 DefaultOverlayProcessor::DefaultOverlayProcessor(OutputSurface* surface)
     : OverlayProcessor(surface) {
 }
 
@@ skipping 207 matching lines @@
   scoped_ptr<OverlayOutputSurface> output_surface_;
   FakeOutputSurfaceClient client_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<OverlayProcessor> overlay_processor_;
 };
 
 typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest;
 typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest;
 typedef OverlayTest<SandwichOverlayValidator> SandwichTest;
+typedef OverlayTest<AllOrNothingOverlayValidator> AllOrNothingOverlayTest;
 
 TEST(OverlayTest, NoOverlaysByDefault) {
   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
   OverlayOutputSurface output_surface(provider);
   EXPECT_EQ(NULL, output_surface.GetOverlayCandidateValidator());
 
   output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator);
   EXPECT_TRUE(output_surface.GetOverlayCandidateValidator() != NULL);
 }
 
@@ skipping 808 matching lines @@
   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);
 }
 
+TEST_F(AllOrNothingOverlayTest, SuccessfulOverlappingOverlays) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+
+  // Add two overlapping candidates.
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayTopLeftRect);
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayRect);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  OverlayCandidateList candidates;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidates);
+
+  // Both quads should become overlays.
+  EXPECT_EQ(2u, candidates.size());
+  EXPECT_EQ(-1, candidates[0].plane_z_order);
+  EXPECT_EQ(-2, candidates[1].plane_z_order);
+  EXPECT_EQ(gfx::RectF(kOverlayTopLeftRect), candidates[0].display_rect);
+  EXPECT_EQ(gfx::RectF(kOverlayRect), candidates[1].display_rect);
+
+  // All quads should be gone.
+  EXPECT_TRUE(pass_list.back()->quad_list.empty());
+}
+
+TEST_F(AllOrNothingOverlayTest, RejectQuadWithTransform) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayTopLeftRect);
+
+  // Add a rotated quad that can't be promoted into overlay.
+  SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
+  shared_state->opacity = 1.f;
+  shared_state->quad_to_target_transform.Rotate(90);
+  CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(),
+                         kOverlayBottomRightRect);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  OverlayCandidateList candidates;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidates);
+
+  // No quads should become overlays.
+  EXPECT_EQ(0u, candidates.size());
+  EXPECT_EQ(2u, pass_list.back()->quad_list.size());
+}
+
 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 386 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