cc: Fork OverlayCandidate to CALayerOverlay

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 33 matching lines @@
                      bool lost_resource,
                      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 AllowCALayerOverlays() override { return false; }
   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);
     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),
                          candidate.uv_rect);
     if (!candidate.clip_rect.IsEmpty()) {
       EXPECT_EQ(true, candidate.is_clipped);
       EXPECT_EQ(kOverlayClipRect, candidate.clip_rect);
     }
     candidate.overlay_handled = true;
   }
 };
 
+class CALayerValidator : public OverlayCandidateValidator {
+ public:
+  void GetStrategies(OverlayProcessor::StrategyList* strategies) override {}
+  bool AllowCALayerOverlays() override { return true; }
+  void CheckOverlaySupport(OverlayCandidateList* surfaces) override {}
+};
+
 class SingleOnTopOverlayValidator : public SingleOverlayValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(
         make_scoped_ptr(new OverlayStrategySingleOnTop(this)));
   }
 };
 
 class UnderlayOverlayValidator : public SingleOverlayValidator {
  public:
   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 AllowCALayerOverlays() override { return false; }
   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)
@@ skipping 224 matching lines @@
   FakeOutputSurfaceClient client_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<OverlayProcessor> overlay_processor_;
   gfx::Rect damage_rect_;
 };
 
 typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest;
 typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest;
 typedef OverlayTest<SandwichOverlayValidator> SandwichTest;
-typedef OverlayTest<AllOrNothingOverlayValidator> AllOrNothingOverlayTest;
+typedef OverlayTest<CALayerValidator> CALayerOverlayTest;
 
 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 936 matching lines @@
   output_surface_plane.quad_rect_in_target_space = kOverlayRect;
   output_surface_plane.use_output_surface_for_resource = true;
   output_surface_plane.overlay_handled = true;
   candidate_list.push_back(output_surface_plane);
 
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
                                          &candidate_list, &damage_rect_);
   DCHECK(!damage_rect_.IsEmpty());
 }
 
-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(resource_provider_.get(), &pass_list,
-                                         &candidates, &damage_rect_);
-
-  // 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());
+OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) {
+  OverlayCandidateList list;
+  OverlayCandidate output_surface_plane;
+  output_surface_plane.display_rect = gfx::RectF(root_render_pass->output_rect);
+  output_surface_plane.quad_rect_in_target_space =
+      root_render_pass->output_rect;
+  output_surface_plane.use_output_surface_for_resource = true;
+  output_surface_plane.overlay_handled = true;
+  list.push_back(output_surface_plane);
+  return list;
 }
 
-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(resource_provider_.get(), &pass_list,
-                                         &candidates, &damage_rect_);
-
-  // No quads should become overlays.
-  EXPECT_EQ(0u, candidates.size());
-  EXPECT_EQ(2u, pass_list.back()->quad_list.size());
-}
-
-TEST_F(AllOrNothingOverlayTest, DamageRect) {
+TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
-
-  damage_rect_ = kOverlayRect;
-
-  // Add something behind it.
-  CreateFullscreenOpaqueQuad(resource_provider_.get(),
-                             pass->shared_quad_state_list.back(), pass.get());
-  CreateFullscreenOpaqueQuad(resource_provider_.get(),
-                             pass->shared_quad_state_list.back(), pass.get());
+  pass->shared_quad_state_list.back()
+      ->quad_to_target_transform.RotateAboutZAxis(45.f);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
+  CALayerOverlayList ca_layer_list;
+  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
+                                         &ca_layer_list, &overlay_list);
+  ASSERT_EQ(1U, pass_list.size());
+  EXPECT_EQ(0U, pass_list.back()->quad_list.size());
+  EXPECT_EQ(0U, overlay_list.size());
+  EXPECT_EQ(1U, ca_layer_list.size());
+}
 
-  // Check for potential candidates.
-  OverlayCandidateList candidate_list;
+TEST_F(CALayerOverlayTest, Disallow3DTransform) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  pass->shared_quad_state_list.back()
+      ->quad_to_target_transform.RotateAboutXAxis(45.f);
 
-  // Primary plane.
-  OverlayCandidate output_surface_plane;
-  output_surface_plane.display_rect = gfx::RectF(kOverlayRect);
-  output_surface_plane.quad_rect_in_target_space = kOverlayRect;
-  output_surface_plane.use_output_surface_for_resource = true;
-  output_surface_plane.overlay_handled = true;
-  candidate_list.push_back(output_surface_plane);
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  CALayerOverlayList ca_layer_list;
+  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
+                                         &ca_layer_list, &overlay_list);
+  ASSERT_EQ(1U, pass_list.size());
+  EXPECT_EQ(1U, pass_list.back()->quad_list.size());
+  EXPECT_EQ(1U, overlay_list.size());
+  EXPECT_EQ(0U, ca_layer_list.size());
+}
 
-  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
-  DCHECK(!damage_rect_.IsEmpty());
+TEST_F(CALayerOverlayTest, AllowContainingClip) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  pass->shared_quad_state_list.back()->is_clipped = true;
+  pass->shared_quad_state_list.back()->clip_rect = kOverlayRect;
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  CALayerOverlayList ca_layer_list;
+  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
+                                         &ca_layer_list, &overlay_list);
+  ASSERT_EQ(1U, pass_list.size());
+  EXPECT_EQ(0U, pass_list.back()->quad_list.size());
+  EXPECT_EQ(0U, overlay_list.size());
+  EXPECT_EQ(1U, ca_layer_list.size());
+}
+
+TEST_F(CALayerOverlayTest, SkipDisjointClip) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  pass->shared_quad_state_list.back()->is_clipped = true;
+  pass->shared_quad_state_list.back()->clip_rect =
+      gfx::Rect(128, 128, 128, 128);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  CALayerOverlayList ca_layer_list;
+  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
+                                         &ca_layer_list, &overlay_list);
+  ASSERT_EQ(1U, pass_list.size());
+  EXPECT_EQ(0U, pass_list.back()->quad_list.size());
+  EXPECT_EQ(0U, overlay_list.size());
+  EXPECT_EQ(0U, ca_layer_list.size());
+}
+
+TEST_F(CALayerOverlayTest, DisallowNontrivialClip) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  pass->shared_quad_state_list.back()->is_clipped = true;
+  pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(64, 64, 128, 128);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  CALayerOverlayList ca_layer_list;
+  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
+                                         &ca_layer_list, &overlay_list);
+
+  ASSERT_EQ(1U, pass_list.size());
+  EXPECT_EQ(1U, pass_list.back()->quad_list.size());
+  EXPECT_EQ(1U, overlay_list.size());
+  EXPECT_EQ(0U, ca_layer_list.size());
+}
+
+TEST_F(CALayerOverlayTest, SkipTransparent) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  pass->shared_quad_state_list.back()->opacity = 0;
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  CALayerOverlayList ca_layer_list;
+  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
+                                         &ca_layer_list, &overlay_list);
+  ASSERT_EQ(1U, pass_list.size());
+  EXPECT_EQ(0U, pass_list.back()->quad_list.size());
+  EXPECT_EQ(0U, overlay_list.size());
+  EXPECT_EQ(0U, ca_layer_list.size());
 }
 
 class OverlayInfoRendererGL : public GLRenderer {
  public:
   OverlayInfoRendererGL(RendererClient* client,
                         const RendererSettings* settings,
                         OutputSurface* output_surface,
                         ResourceProvider* resource_provider)
       : GLRenderer(client,
                    settings,
@@ skipping 335 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