Compute damage rect for Cast video compositing

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 4472c9ec8f8977e40b8c1b08ab71a017d6c32d20..0ad9e916a4a3fc6428a71a0f4f6390517c7931c2 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -17,6 +17,7 @@
 #include "cc/output/output_surface_frame.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
+#include "cc/output/overlay_strategy_cast_underlay.h"
 #include "cc/output/overlay_strategy_fullscreen.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
@@ -130,6 +131,13 @@ class UnderlayOverlayValidator : public SingleOverlayValidator {
   }
 };
 
+class CastUnderlayOverlayValidator : public SingleOverlayValidator {
+ public:
+  void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
+    strategies->push_back(base::MakeUnique<OverlayStrategyCastUnderlay>(this));
+  }
+};
+
 class DefaultOverlayProcessor : public OverlayProcessor {
  public:
   explicit DefaultOverlayProcessor(OutputSurface* surface);
@@ -303,6 +311,16 @@ void CreateOpaqueQuadAt(ResourceProvider* resource_provider,
   color_quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
 }
 
+void CreateOpaqueQuadAt(ResourceProvider* resource_provider,
+                        const SharedQuadState* shared_quad_state,
+                        RenderPass* render_pass,
+                        const gfx::Rect& rect,
+                        SkColor color) {
+  SolidColorDrawQuad* color_quad =
+      render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  color_quad->SetNew(shared_quad_state, rect, rect, color, false);
+}
+
 void CreateFullscreenOpaqueQuad(ResourceProvider* resource_provider,
                                 const SharedQuadState* shared_quad_state,
                                 RenderPass* render_pass) {
@@ -372,6 +390,7 @@ typedef OverlayTest<FullscreenOverlayValidator> FullscreenOverlayTest;
 typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest;
 typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest;
 typedef OverlayTest<CALayerValidator> CALayerOverlayTest;
+typedef OverlayTest<CastUnderlayOverlayValidator> CastUnderlayTest;
 
 TEST(OverlayTest, NoOverlaysByDefault) {
   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
@@ -1140,6 +1159,109 @@ TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) {
   EXPECT_TRUE(damage_rect_.IsEmpty());
 }
 
+TEST_F(CastUnderlayTest, NoOverlayDamageRect) {
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(),
+                     kOverlayTopLeftRect);
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
+
+  gfx::Rect swap_with_damage_rect;
+  EXPECT_FALSE(
+      overlay_processor_->GetSwapWithDamageRect(&swap_with_damage_rect));
+}
+
+TEST_F(CastUnderlayTest, FullScreenOverlayDamageRect) {
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayRect);
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
+
+  gfx::Rect swap_with_damage_rect;
+  EXPECT_TRUE(
+      overlay_processor_->GetSwapWithDamageRect(&swap_with_damage_rect));
+  EXPECT_TRUE(swap_with_damage_rect.IsEmpty());
+}
+
+TEST_F(CastUnderlayTest, BlackOutsideOverlayDamageRect) {
+  const gfx::Rect kLeftSide(0, 0, 128, 256);
+  const gfx::Rect kTopRight(128, 0, 128, 128);
+
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayBottomRightRect);
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(), kLeftSide,
+                     SK_ColorBLACK);
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(), kTopRight,
+                     SK_ColorBLACK);
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
+
+  gfx::Rect swap_with_damage_rect;
+  EXPECT_TRUE(
+      overlay_processor_->GetSwapWithDamageRect(&swap_with_damage_rect));
+  EXPECT_TRUE(swap_with_damage_rect.IsEmpty());
+}
+
+TEST_F(CastUnderlayTest, OverlayOccludedDamageRect) {
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+  CreateOpaqueQuadAt(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);
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
+
+  gfx::Rect swap_with_damage_rect;
+  EXPECT_TRUE(
+      overlay_processor_->GetSwapWithDamageRect(&swap_with_damage_rect));
+  EXPECT_EQ(kOverlayTopLeftRect, swap_with_damage_rect);
+}
+
+TEST_F(CastUnderlayTest, OverlayOccludedUnionDamageRect) {
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(),
+                     kOverlayTopLeftRect);
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(),
+                     kOverlayBottomRightRect);
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayRect);
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
+
+  gfx::Rect swap_with_damage_rect;
+  EXPECT_TRUE(
+      overlay_processor_->GetSwapWithDamageRect(&swap_with_damage_rect));
+  EXPECT_EQ(kOverlayRect, swap_with_damage_rect);
+}
+
 OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) {
   OverlayCandidateList list;
   OverlayCandidate output_surface_plane;