Let OverlayStrategySingleOnTop select non-topmost quad

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 01e7cc2f350de1ed518b86ff12eb616372b6b359..f55b7a3df4f7463caee812ee66c10303024d1699 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -28,6 +28,8 @@ namespace cc {
 namespace {
 
 const gfx::Rect kOverlayRect(0, 0, 128, 128);
+const gfx::Rect kOverlayTopLeftRect(0, 0, 64, 64);
+const gfx::Rect kOverlayBottomRightRect(64, 64, 64, 64);
 const gfx::PointF kUVTopLeft(0.1f, 0.2f);
 const gfx::PointF kUVBottomRight(1.0f, 1.0f);
 
@@ -43,7 +45,11 @@ void SingleOverlayValidator::CheckOverlaySupport(
   ASSERT_EQ(2U, surfaces->size());
 
   OverlayCandidate& candidate = surfaces->back();
-  EXPECT_EQ(kOverlayRect.ToString(), candidate.display_rect.ToString());
+  if (candidate.display_rect.width() == 64)

[danakj, 2014/08/06 15:52:59]

need {} on the if and the else, since the body is multi-line

+    EXPECT_EQ(kOverlayBottomRightRect.ToString(),

[danakj, 2014/08/06 15:52:59]

we don't need to ToString() rects anymore, it happens automatically now :D

[achaulk, 2014/08/06 16:00:10]

Done.

+              candidate.display_rect.ToString());
+  else
+    EXPECT_EQ(kOverlayRect.ToString(), candidate.display_rect.ToString());
   EXPECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight).ToString(),
             candidate.uv_rect.ToString());
   candidate.overlay_handled = true;
@@ -129,9 +135,10 @@ ResourceProvider::ResourceId CreateResource(
       mailbox, release_callback.Pass());
 }
 
-TextureDrawQuad* CreateCandidateQuad(ResourceProvider* resource_provider,
-                                     const SharedQuadState* shared_quad_state,
-                                     RenderPass* render_pass) {
+TextureDrawQuad* CreateCandidateQuadAt(ResourceProvider* resource_provider,
+                                       const SharedQuadState* shared_quad_state,
+                                       RenderPass* render_pass,
+                                       const gfx::Rect& rect) {
   ResourceProvider::ResourceId resource_id = CreateResource(resource_provider);
   bool premultiplied_alpha = false;
   bool flipped = false;
@@ -140,9 +147,9 @@ TextureDrawQuad* CreateCandidateQuad(ResourceProvider* resource_provider,
   TextureDrawQuad* overlay_quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(shared_quad_state,
-                       kOverlayRect,
-                       kOverlayRect,
-                       kOverlayRect,
+                       rect,
+                       rect,
+                       rect,
                        resource_id,
                        premultiplied_alpha,
                        kUVTopLeft,
@@ -154,13 +161,27 @@ TextureDrawQuad* CreateCandidateQuad(ResourceProvider* resource_provider,
   return overlay_quad;
 }
 
+TextureDrawQuad* CreateCandidateQuad(ResourceProvider* resource_provider,

[danakj, 2014/08/06 15:52:59]

CreateFullscreenCandidateQuad?

+                                     const SharedQuadState* shared_quad_state,
+                                     RenderPass* render_pass) {
+  return CreateCandidateQuadAt(
+      resource_provider, shared_quad_state, render_pass, kOverlayRect);
+}
+
+void CreateCheckeredQuadAt(ResourceProvider* resource_provider,
+                           const SharedQuadState* shared_quad_state,
+                           RenderPass* render_pass,
+                           const gfx::Rect& rect) {
+  CheckerboardDrawQuad* checkerboard_quad =
+      render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
+  checkerboard_quad->SetNew(shared_quad_state, rect, rect, SkColor());
+}
+
 void CreateCheckeredQuad(ResourceProvider* resource_provider,

[danakj, 2014/08/06 15:52:59]

CreateFullscreenCheckeredQuad?

                          const SharedQuadState* shared_quad_state,
                          RenderPass* render_pass) {
-  CheckerboardDrawQuad* checkerboard_quad =
-      render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
-  checkerboard_quad->SetNew(
-      shared_quad_state, kOverlayRect, kOverlayRect, SkColor());
+  CreateCheckeredQuadAt(
+      resource_provider, shared_quad_state, render_pass, kOverlayRect);
 }
 
 static void CompareRenderPassLists(const RenderPassList& expected_list,
@@ -367,22 +388,6 @@ TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
   ASSERT_EQ(2U, pass_list.size());
 }
 
-TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) {

[danakj, 2014/08/06 15:52:59]

Where'd this go?

[achaulk, 2014/08/06 16:00:10]

Deleted, seems to work fine on actual hardware (so far anyway)

[danakj, 2014/08/06 16:03:34]

Ok, it seems unrelated to this CL, can you do it separately?

-  scoped_ptr<RenderPass> pass = CreateRenderPass();
-  TextureDrawQuad* quad =
-      CreateCandidateQuad(resource_provider_.get(),
-                          pass->shared_quad_state_list.back(),
-                          pass.get());
-  quad->premultiplied_alpha = true;
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-  OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
-  EXPECT_EQ(1U, pass_list.size());
-  EXPECT_EQ(0U, candidate_list.size());
-}
-
 TEST_F(SingleOverlayOnTopTest, RejectBlending) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* quad =
@@ -450,8 +455,8 @@ TEST_F(SingleOverlayOnTopTest, RejectTransform) {
   CreateCandidateQuad(resource_provider_.get(),
                       pass->shared_quad_state_list.back(),
                       pass.get());
-  pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.f,
-                                                                         2.f);
+  pass->shared_quad_state_list.back()
+      ->content_to_target_transform.RotateAboutXAxis(45.f);

[danakj, 2014/08/06 15:52:59]

Why this change? Does scale not get rejected anymore? Should it?

[achaulk, 2014/08/06 16:00:10]

The hardware should be capable of handling basic positive scaling - on link for
example the scale is always 2, but it works.

[danakj, 2014/08/06 16:03:34]

Can we do this as a separate CL so if we have problems you don't have to roll
out the whole thing with other unrelated changes?

 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -461,6 +466,29 @@ TEST_F(SingleOverlayOnTopTest, RejectTransform) {
   EXPECT_EQ(0U, candidate_list.size());
 }
 
+TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {

[danakj, 2014/08/06 15:52:59]

What if it is occluded, is that covered?

[achaulk, 2014/08/06 16:00:10]

Covered by another test

+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCheckeredQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(),
+                        pass.get(),
+                        kOverlayTopLeftRect);
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(),
+                        pass.get(),
+                        kOverlayBottomRightRect);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  RenderPassList original_pass_list;
+  RenderPass::CopyAll(pass_list, &original_pass_list);
+
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  EXPECT_EQ(1U, pass_list.size());
+  EXPECT_EQ(2U, candidate_list.size());
+}
+
 class OverlayInfoRendererGL : public GLRenderer {
  public:
   OverlayInfoRendererGL(RendererClient* client,