cc: Ignore certain quads that would otherwise block overlays

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 46826799c95d6354abfbc93b079029da1f0c5b35..61e08d6725e5a4034d777bea7882c5bfe1e9a329 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -156,6 +156,17 @@ ResourceProvider::ResourceId CreateResource(
       mailbox, release_callback.Pass());
 }
 
+SolidColorDrawQuad* CreateSolidColorQuadAt(
+    const SharedQuadState* shared_quad_state,
+    SkColor color,
+    RenderPass* render_pass,
+    const gfx::Rect& rect) {
+  SolidColorDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  quad->SetNew(shared_quad_state, rect, rect, color, false);
+  return quad;
+}
+
 TextureDrawQuad* CreateCandidateQuadAt(ResourceProvider* resource_provider,
                                        const SharedQuadState* shared_quad_state,
                                        RenderPass* render_pass,
@@ -592,6 +603,94 @@ TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
   EXPECT_EQ(2U, candidate_list.size());
 }
 
+TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
+  shared_state->opacity = 0.f;
+  CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(),
+                         kOverlayBottomRightRect);
+  shared_state = pass->CreateAndAppendSharedQuadState();
+  shared_state->opacity = 1.f;
+  CreateCandidateQuadAt(resource_provider_.get(), shared_state, 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());
+}
+
+TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateSolidColorQuadAt(pass->shared_quad_state_list.back(),
+                         SK_ColorTRANSPARENT, pass.get(),
+                         kOverlayBottomRightRect);
+  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());
+}
+
+TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
+  shared_state->opacity = 0.5f;
+  CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(),
+                         kOverlayBottomRightRect);
+  shared_state = pass->CreateAndAppendSharedQuadState();
+  shared_state->opacity = 1.f;
+  CreateCandidateQuadAt(resource_provider_.get(), shared_state, 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(0U, candidate_list.size());
+}
+
+TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTopWithBlending) {

[danakj, 2015/02/05 19:35:40]

RejectTransparentOnTopWithoutBlending?

+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
+  CreateSolidColorQuadAt(shared_state, SK_ColorTRANSPARENT, pass.get(),
+                         kOverlayBottomRightRect)->opaque_rect =

[danakj, 2015/02/05 19:35:40]

ah this wont happen, instead can you set the needs_blending bool to true? this
is how it can occur, which is used for holepunching

[achaulk, 2015/02/05 19:44:56]

Blended transparent quads should not block overlaying. This tests for
ShouldDrawWithBlending() returning false with alpha=0 - in the other test it
will return true and then fail due to alpha. Holepunching is done with
needs_blending=false and sets the opaque_rect, which is exactly what this one
does

[danakj, 2015/02/05 19:59:22]

ahh sorry you're right. Test name should be WithoutBlendingThough right?

[achaulk, 2015/02/05 20:00:16]

oh right, yes i should rename it

+      kOverlayBottomRightRect;
+  CreateCandidateQuadAt(resource_provider_.get(), shared_state, 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(0U, candidate_list.size());
+}
+
 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),