Use SwapBuffersWithBounds on Chromecast

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 8dcd8dd4b0baa0b6f273d9cd2aaff47e8b8517ce..fb82fe69f5a59270f5964fa2c32f6f8a5adb8da7 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -20,6 +20,7 @@
 #include "cc/output/overlay_strategy_fullscreen.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
+#include "cc/output/overlay_strategy_underlay_cast.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ -130,6 +131,13 @@ class UnderlayOverlayValidator : public SingleOverlayValidator {
   }
 };
 
+class UnderlayCastOverlayValidator : public SingleOverlayValidator {
+ public:
+  void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
+    strategies->push_back(base::MakeUnique<OverlayStrategyUnderlayCast>(this));
+  }
+};
+
 class DefaultOverlayProcessor : public OverlayProcessor {
  public:
   explicit DefaultOverlayProcessor(OutputSurface* surface);
@@ -302,6 +310,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) {
@@ -370,6 +388,7 @@ class OverlayTest : public testing::Test {
 typedef OverlayTest<FullscreenOverlayValidator> FullscreenOverlayTest;
 typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest;
 typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest;
+typedef OverlayTest<UnderlayCastOverlayValidator> UnderlayCastTest;

[danakj, 2017/02/14 17:28:58]

using instead of typedef

[halliwell, 2017/02/15 22:29:04]

Done.

 typedef OverlayTest<CALayerValidator> CALayerOverlayTest;
 
 TEST(OverlayTest, NoOverlaysByDefault) {
@@ -1221,6 +1240,119 @@ TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) {
   EXPECT_TRUE(damage_rect_.IsEmpty());
 }
 
+TEST_F(UnderlayCastTest, NoOverlayDamageRect) {

[danakj, 2017/02/14 17:28:58]

These tests are named for damage rects but that seems incorrect

[danakj, 2017/02/14 17:32:35]

.. but then should they be testing the damage rect and candidate list too, or
that will become untested code now?

[halliwell, 2017/02/15 22:29:04]

They are mis-named (I copied them over from previous CL).  Renamed now to
*ContentBounds.  The point of the tests is to assert on content bounds returned
from Attempt.

+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+
+  CreateOpaqueQuadAt(resource_provider_.get(),
+                     pass->shared_quad_state_list.back(), pass.get(),
+                     kOverlayTopLeftRect);
+
+  OverlayCandidateList candidate_list;
+  RenderPassFilterList render_pass_filters;
+  RenderPassFilterList render_pass_background_filters;
+  overlay_processor_->ProcessForOverlays(
+      resource_provider_.get(), pass.get(), render_pass_filters,
+      render_pass_background_filters, &candidate_list, nullptr, &damage_rect_);
+
+  std::vector<gfx::Rect> content_bounds;
+  overlay_processor_->GetContentBounds(&content_bounds);
+  EXPECT_EQ(0U, content_bounds.size());
+}
+
+TEST_F(UnderlayCastTest, FullScreenOverlayDamageRect) {
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(),
+                        kOverlayRect);
+
+  OverlayCandidateList candidate_list;
+  RenderPassFilterList render_pass_filters;
+  RenderPassFilterList render_pass_background_filters;
+  overlay_processor_->ProcessForOverlays(
+      resource_provider_.get(), pass.get(), render_pass_filters,
+      render_pass_background_filters, &candidate_list, nullptr, &damage_rect_);
+
+  std::vector<gfx::Rect> content_bounds;
+  overlay_processor_->GetContentBounds(&content_bounds);
+  EXPECT_EQ(1U, content_bounds.size());
+  EXPECT_TRUE(content_bounds[0].IsEmpty());

[danakj, 2017/02/14 17:32:35]

What is the difference between swapping an empty rect vs an empty vector?

[halliwell, 2017/02/15 22:29:04]

I clarified in the comment on OutputFrame.  Empty vector is the default value
for content_bounds, and is equivalent to swapping full screen.  An empty rect
means no content (as in this test, we expect to see this when playing
full-screen video, and it means the driver can completely ignore graphics plane
at scanout time).

+}
+
+TEST_F(UnderlayCastTest, 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;
+  RenderPassFilterList render_pass_filters;
+  RenderPassFilterList render_pass_background_filters;
+  overlay_processor_->ProcessForOverlays(
+      resource_provider_.get(), pass.get(), render_pass_filters,
+      render_pass_background_filters, &candidate_list, nullptr, &damage_rect_);
+
+  std::vector<gfx::Rect> content_bounds;
+  overlay_processor_->GetContentBounds(&content_bounds);
+  EXPECT_EQ(1U, content_bounds.size());
+  EXPECT_TRUE(content_bounds[0].IsEmpty());
+}
+
+TEST_F(UnderlayCastTest, 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;
+  RenderPassFilterList render_pass_filters;
+  RenderPassFilterList render_pass_background_filters;
+  overlay_processor_->ProcessForOverlays(
+      resource_provider_.get(), pass.get(), render_pass_filters,
+      render_pass_background_filters, &candidate_list, nullptr, &damage_rect_);
+
+  std::vector<gfx::Rect> content_bounds;
+  overlay_processor_->GetContentBounds(&content_bounds);
+  EXPECT_EQ(1U, content_bounds.size());
+  EXPECT_EQ(kOverlayTopLeftRect, content_bounds[0]);
+}
+
+TEST_F(UnderlayCastTest, 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;
+  RenderPassFilterList render_pass_filters;
+  RenderPassFilterList render_pass_background_filters;
+  overlay_processor_->ProcessForOverlays(
+      resource_provider_.get(), pass.get(), render_pass_filters,
+      render_pass_background_filters, &candidate_list, nullptr, &damage_rect_);
+
+  std::vector<gfx::Rect> content_bounds;
+  overlay_processor_->GetContentBounds(&content_bounds);
+  EXPECT_EQ(1U, content_bounds.size());
+  EXPECT_EQ(kOverlayRect, content_bounds[0]);
+}
+
 OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) {
   OverlayCandidateList list;
   OverlayCandidate output_surface_plane;