Overlays: Remove special casing of primary overlay plane

Mac will soon want to skip drawing the primary overlay plane, which
now can be accomplished by having the overlay strategy simply not emit
it.

BUG=533687
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1376883004

Cr-Commit-Position: refs/heads/master@{#352186}

9 files changed, 115 insertions, 96 deletions

diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 58facc4..f981518 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -222,6 +222,20 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
 
   BeginDrawingFrame(&frame);
 
+  if (output_surface_->IsDisplayedAsOverlayPlane()) {
+    // Create the overlay candidate for the output surface, and mark it as
+    // always
+    // handled.
+    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;
+    frame.overlay_list.push_back(output_surface_plane);
+  }
+
   // If we have any copy requests, we can't remove any quads for overlays,
   // otherwise the framebuffer will be missing the overlay contents.
   if (root_render_pass->copy_requests.empty()) {
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 11a4b45..536ab50 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -3515,10 +3515,6 @@ void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {
   ResourceProvider::ResourceIdArray resources;
   OverlayCandidateList& overlays = frame->overlay_list;
   for (const OverlayCandidate& overlay : overlays) {
-    // Skip primary plane.
-    if (overlay.plane_z_order == 0)
-      continue;
-
     unsigned texture_id = 0;
     if (overlay.use_output_surface_for_resource) {
       texture_id = output_surface_->GetOverlayTextureId();
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index bd6eeb9..dd025f2 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -2124,7 +2124,7 @@ class SingleOverlayOnTopProcessor : public OverlayProcessor {
     }
 
     void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
-      ASSERT_EQ(2U, surfaces->size());
+      ASSERT_EQ(1U, surfaces->size());
       OverlayCandidate& candidate = surfaces->back();
       candidate.overlay_handled = true;
     }
diff --git a/cc/output/output_surface.cc b/cc/output/output_surface.cc
index c1a1ec2..38b1346 100644
--- a/cc/output/output_surface.cc
+++ b/cc/output/output_surface.cc
@@ -299,6 +299,10 @@ OverlayCandidateValidator* OutputSurface::GetOverlayCandidateValidator() const {
   return nullptr;
 }
 
+bool OutputSurface::IsDisplayedAsOverlayPlane() const {
+  return false;
+}
+
 unsigned OutputSurface::GetOverlayTextureId() const {
   return 0;
 }
diff --git a/cc/output/output_surface.h b/cc/output/output_surface.h
index 66d1c79..bb6a59e 100644
--- a/cc/output/output_surface.h
+++ b/cc/output/output_surface.h
@@ -151,6 +151,9 @@ class CC_EXPORT OutputSurface : public base::trace_event::MemoryDumpProvider {
   // Get the class capable of informing cc of hardware overlay capability.
   virtual OverlayCandidateValidator* GetOverlayCandidateValidator() const;
 
+  // Returns true if a main image overlay plane should be scheduled.
+  virtual bool IsDisplayedAsOverlayPlane() const;
+
   // Get the texture for the main image's overlay.
   virtual unsigned GetOverlayTextureId() const;
 
diff --git a/cc/output/overlay_strategy_common.cc b/cc/output/overlay_strategy_common.cc
index 4fd67c3..d142ba5 100644
--- a/cc/output/overlay_strategy_common.cc
+++ b/cc/output/overlay_strategy_common.cc
@@ -24,12 +24,6 @@ bool OverlayStrategyCommon::Attempt(RenderPassList* render_passes_in_draw_order,
   RenderPass* root_render_pass = render_passes_in_draw_order->back();
   DCHECK(root_render_pass);
 
-  // Add our primary surface.
-  OverlayCandidate main_image;
-  main_image.display_rect = gfx::RectF(root_render_pass->output_rect);
-  DCHECK(candidate_list->empty());
-  candidate_list->push_back(main_image);
-
   bool created_overlay = false;
   QuadList& quad_list = root_render_pass->quad_list;
   for (auto it = quad_list.begin(); it != quad_list.end();) {
@@ -54,11 +48,6 @@ bool OverlayStrategyCommon::Attempt(RenderPassList* render_passes_in_draw_order,
     }
   }
 
-  if (!created_overlay) {
-    DCHECK_EQ(1u, candidate_list->size());
-    candidate_list->clear();
-  }
-
   return created_overlay;
 }
 
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 854c267..155707b 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -67,9 +67,13 @@ class SingleOverlayValidator : public OverlayCandidateValidator {
         new OverlayStrategyCommon(this, new OverlayStrategyUnderlay)));
   }
   void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
-    ASSERT_EQ(2U, surfaces->size());
+    // 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 {
@@ -149,6 +153,7 @@ class OverlayOutputSurface : public OutputSurface {
       : OutputSurface(context_provider) {
     surface_size_ = kDisplaySize;
     device_scale_factor_ = 1;
+    is_displayed_as_overlay_plane_ = true;
   }
 
   void SetScaleFactor(float scale_factor) {
@@ -166,8 +171,17 @@ class OverlayOutputSurface : public OutputSurface {
     return overlay_candidate_validator_.get();
   }
 
+  bool IsDisplayedAsOverlayPlane() const override {
+    return is_displayed_as_overlay_plane_;
+  }
+  unsigned GetOverlayTextureId() const override { return 10000; }
+  void set_is_displayed_as_overlay_plane(bool value) {
+    is_displayed_as_overlay_plane_ = value;
+  }
+
  private:
   scoped_ptr<OverlayCandidateValidator> overlay_candidate_validator_;
+  bool is_displayed_as_overlay_plane_;
 };
 
 void OverlayOutputSurface::SwapBuffers(CompositorFrame* frame) {
@@ -406,7 +420,7 @@ TEST_F(SandwichTest, SuccessfulSingleOverlay) {
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
+  ASSERT_EQ(1U, candidate_list.size());
 
   RenderPass* main_pass = pass_list.back();
   // Check that the quad is gone.
@@ -448,10 +462,10 @@ TEST_F(SandwichTest, CroppedSingleOverlay) {
 
   // Ensure that the display and uv rects have cropping applied to them.
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
-  EXPECT_EQ(candidate_id, candidate_list[1].resource_id);
-  EXPECT_EQ(gfx::RectF(0.f, 32.f, 64.f, 64.f), candidate_list[1].display_rect);
-  EXPECT_EQ(gfx::RectF(0.f, 0.25f, 0.5f, 0.5f), candidate_list[1].uv_rect);
+  ASSERT_EQ(1U, candidate_list.size());
+  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
+  EXPECT_EQ(gfx::RectF(0.f, 32.f, 64.f, 64.f), candidate_list[0].display_rect);
+  EXPECT_EQ(gfx::RectF(0.f, 0.25f, 0.5f, 0.5f), candidate_list[0].uv_rect);
 }
 
 TEST_F(SandwichTest, SuccessfulTwoOverlays) {
@@ -476,10 +490,10 @@ TEST_F(SandwichTest, SuccessfulTwoOverlays) {
 
   // Both candidates should become overlays.
   EXPECT_EQ(1u, pass_list.size());
-  EXPECT_EQ(3u, candidate_list.size());
-  EXPECT_EQ(gfx::RectF(kOverlayTopLeftRect), candidate_list[1].display_rect);
+  EXPECT_EQ(2u, candidate_list.size());
+  EXPECT_EQ(gfx::RectF(kOverlayTopLeftRect), candidate_list[0].display_rect);
   EXPECT_EQ(gfx::RectF(kOverlayBottomRightRect),
-            candidate_list[2].display_rect);
+            candidate_list[1].display_rect);
 
   // The overlay quads should be gone.
   const QuadList& quad_list = pass_list.back()->quad_list;
@@ -509,8 +523,8 @@ TEST_F(SandwichTest, OverlappingOverlays) {
 
   // Only one of the candidates should become an overlay.
   EXPECT_EQ(1u, pass_list.size());
-  EXPECT_EQ(2u, candidate_list.size());
-  EXPECT_EQ(gfx::RectF(kOverlayTopLeftRect), candidate_list[1].display_rect);
+  EXPECT_EQ(1u, candidate_list.size());
+  EXPECT_EQ(gfx::RectF(kOverlayTopLeftRect), candidate_list[0].display_rect);
 
   // One of the overlay quads should be gone.
   const QuadList& quad_list = pass_list.back()->quad_list;
@@ -542,7 +556,7 @@ TEST_F(SandwichTest, SuccessfulSandwichOverlay) {
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(3U, candidate_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
 
   RenderPass* main_pass = pass_list.back();
   // Check that the quad is gone.
@@ -553,13 +567,12 @@ TEST_F(SandwichTest, SuccessfulSandwichOverlay) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
   }
 
-  EXPECT_FALSE(candidate_list[0].use_output_surface_for_resource);
-  EXPECT_EQ(candidate_id, candidate_list[1].resource_id);
-  EXPECT_EQ(gfx::RectF(32.f, 32.f, 32.f, 32.f), candidate_list[1].display_rect);
-  EXPECT_TRUE(candidate_list[2].use_output_surface_for_resource);
-  EXPECT_EQ(gfx::RectF(32.f, 32.f, 16.f, 16.f), candidate_list[2].display_rect);
+  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
+  EXPECT_EQ(gfx::RectF(32.f, 32.f, 32.f, 32.f), candidate_list[0].display_rect);
+  EXPECT_TRUE(candidate_list[1].use_output_surface_for_resource);
+  EXPECT_EQ(gfx::RectF(32.f, 32.f, 16.f, 16.f), candidate_list[1].display_rect);
   EXPECT_EQ(gfx::RectF(32.f / 256.f, 32.f / 256.f, 16.f / 256.f, 16.f / 256.f),
-            candidate_list[2].uv_rect);
+            candidate_list[1].uv_rect);
 }
 
 TEST_F(SandwichTest, MultiQuadOverlay) {
@@ -597,7 +610,7 @@ TEST_F(SandwichTest, MultiQuadOverlay) {
   EXPECT_EQ(4U, main_pass->quad_list.size());
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(4U, candidate_list.size());
+  ASSERT_EQ(3U, candidate_list.size());
 
   // Check that the candidate quad is gone and that we now have two transparent
   // quads for the same region that was covered on the overlay.
@@ -617,14 +630,13 @@ TEST_F(SandwichTest, MultiQuadOverlay) {
   DCHECK(covered_region == transparent_quad_region);
 
   // Check that overlays cover the same region that the quads covered.
-  EXPECT_FALSE(candidate_list[0].use_output_surface_for_resource);
-  EXPECT_EQ(candidate_id, candidate_list[1].resource_id);
-  EXPECT_EQ(gfx::RectF(64.f, 64.f), candidate_list[1].display_rect);
+  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
+  EXPECT_EQ(gfx::RectF(64.f, 64.f), candidate_list[0].display_rect);
+  EXPECT_TRUE(candidate_list[1].use_output_surface_for_resource);
   EXPECT_TRUE(candidate_list[2].use_output_surface_for_resource);
-  EXPECT_TRUE(candidate_list[3].use_output_surface_for_resource);
   Region overlay_region;
+  overlay_region.Union(gfx::ToEnclosingRect(candidate_list[1].display_rect));
   overlay_region.Union(gfx::ToEnclosingRect(candidate_list[2].display_rect));
-  overlay_region.Union(gfx::ToEnclosingRect(candidate_list[3].display_rect));
   DCHECK(covered_region == overlay_region);
 }
 
@@ -650,7 +662,7 @@ TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
+  ASSERT_EQ(1U, candidate_list.size());
 
   RenderPass* main_pass = pass_list.back();
   // Check that the quad is gone.
@@ -734,7 +746,7 @@ TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 
   // This should be the same.
   ASSERT_EQ(2U, pass_list.size());
@@ -847,7 +859,7 @@ TEST_F(SingleOverlayOnTopTest, AllowClipped) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
@@ -865,7 +877,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
+  ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL,
             candidate_list.back().transform);
 }
@@ -885,7 +897,7 @@ TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
+  ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
             candidate_list.back().transform);
 }
@@ -904,7 +916,7 @@ TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
@@ -921,7 +933,7 @@ TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
+  ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform);
 }
 
@@ -939,7 +951,7 @@ TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
+  ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform);
 }
 
@@ -957,7 +969,7 @@ TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
+  ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform);
 }
 
@@ -980,7 +992,7 @@ TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
@@ -1003,7 +1015,7 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
@@ -1024,7 +1036,7 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) {
@@ -1096,7 +1108,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoXMirrorTransform) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) {
@@ -1110,7 +1122,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) {
@@ -1124,7 +1136,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
@@ -1138,7 +1150,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  EXPECT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
@@ -1155,9 +1167,8 @@ TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
-  EXPECT_EQ(0, candidate_list[0].plane_z_order);
-  EXPECT_EQ(-1, candidate_list[1].plane_z_order);
+  ASSERT_EQ(1U, candidate_list.size());
+  EXPECT_EQ(-1, candidate_list[0].plane_z_order);
   EXPECT_EQ(2U, pass_list[0]->quad_list.size());
   // The overlay quad should have changed to a SOLID_COLOR quad.
   EXPECT_EQ(pass_list[0]->quad_list.back()->material, DrawQuad::SOLID_COLOR);
@@ -1178,9 +1189,8 @@ TEST_F(UnderlayTest, AllowOnTop) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
-  EXPECT_EQ(0, candidate_list[0].plane_z_order);
-  EXPECT_EQ(-1, candidate_list[1].plane_z_order);
+  ASSERT_EQ(1U, candidate_list.size());
+  EXPECT_EQ(-1, candidate_list[0].plane_z_order);
   // The overlay quad should have changed to a SOLID_COLOR quad.
   EXPECT_EQ(pass_list[0]->quad_list.front()->material, DrawQuad::SOLID_COLOR);
 }
@@ -1353,11 +1363,13 @@ TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
   // so only draw 2 quads.
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(2);
   EXPECT_CALL(scheduler_,
-              Schedule(1,
-                       gfx::OVERLAY_TRANSFORM_NONE,
-                       _,
-                       kOverlayRect,
-                       BoundingRect(kUVTopLeft, kUVBottomRight))).Times(1);
+              Schedule(0, gfx::OVERLAY_TRANSFORM_NONE, _,
+                       gfx::Rect(kDisplaySize), gfx::RectF(0, 0, 1, 1)))
+      .Times(1);
+  EXPECT_CALL(scheduler_,
+              Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _, kOverlayRect,
+                       BoundingRect(kUVTopLeft, kUVBottomRight)))
+      .Times(1);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 
   SwapBuffers();
@@ -1390,8 +1402,13 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadInUnderlay) {
   // Expect to be replaced with transparent hole quad and placed in underlay.
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(3);
   EXPECT_CALL(scheduler_,
+              Schedule(0, gfx::OVERLAY_TRANSFORM_NONE, _,
+                       gfx::Rect(kDisplaySize), gfx::RectF(0, 0, 1, 1)))
+      .Times(1);
+  EXPECT_CALL(scheduler_,
               Schedule(-1, gfx::OVERLAY_TRANSFORM_NONE, _, kOverlayRect,
-                       BoundingRect(kUVTopLeft, kUVBottomRight))).Times(1);
+                       BoundingRect(kUVTopLeft, kUVBottomRight)))
+      .Times(1);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 
   SwapBuffers();
@@ -1420,13 +1437,12 @@ TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
-  // Should see no overlays.
+  // Should not see the primary surface's overlay.
+  output_surface_->set_is_displayed_as_overlay_plane(false);
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(3);
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
-
   SwapBuffers();
-
   Mock::VerifyAndClearExpectations(renderer_.get());
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
@@ -1446,6 +1462,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturned) {
   DirectRenderer::DrawingFrame frame1;
   frame1.render_passes_in_draw_order = &pass_list;
   frame1.overlay_list.resize(2);
+  frame1.overlay_list.front().use_output_surface_for_resource = true;
   OverlayCandidate& overlay1 = frame1.overlay_list.back();
   overlay1.resource_id = resource1;
   overlay1.plane_z_order = 1;
@@ -1453,19 +1470,21 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturned) {
   DirectRenderer::DrawingFrame frame2;
   frame2.render_passes_in_draw_order = &pass_list;
   frame2.overlay_list.resize(2);
+  frame2.overlay_list.front().use_output_surface_for_resource = true;
   OverlayCandidate& overlay2 = frame2.overlay_list.back();
   overlay2.resource_id = resource2;
   overlay2.plane_z_order = 1;
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
+  printf("About to finish, %d %d\n", resource1, resource2);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource2));
   SwapBuffers();
   Mock::VerifyAndClearExpectations(&scheduler_);
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame2);
   renderer_->FinishDrawingFrame(&frame2);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
@@ -1474,7 +1493,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturned) {
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
@@ -1498,14 +1517,14 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturned) {
 
   // Use the same buffer twice.
   renderer_->set_expect_overlays(true);
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   Mock::VerifyAndClearExpectations(&scheduler_);
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
@@ -1540,6 +1559,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   DirectRenderer::DrawingFrame frame1;
   frame1.render_passes_in_draw_order = &pass_list;
   frame1.overlay_list.resize(2);
+  frame1.overlay_list.front().use_output_surface_for_resource = true;
   OverlayCandidate& overlay1 = frame1.overlay_list.back();
   overlay1.resource_id = resource1;
   overlay1.plane_z_order = 1;
@@ -1547,6 +1567,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   DirectRenderer::DrawingFrame frame2;
   frame2.render_passes_in_draw_order = &pass_list;
   frame2.overlay_list.resize(2);
+  frame2.overlay_list.front().use_output_surface_for_resource = true;
   OverlayCandidate& overlay2 = frame2.overlay_list.back();
   overlay2.resource_id = resource2;
   overlay2.plane_z_order = 1;
@@ -1554,11 +1575,12 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   DirectRenderer::DrawingFrame frame3;
   frame3.render_passes_in_draw_order = &pass_list;
   frame3.overlay_list.resize(2);
+  frame3.overlay_list.front().use_output_surface_for_resource = true;
   OverlayCandidate& overlay3 = frame3.overlay_list.back();
   overlay3.resource_id = resource3;
   overlay3.plane_z_order = 1;
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
@@ -1566,7 +1588,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   SwapBuffers();
   Mock::VerifyAndClearExpectations(&scheduler_);
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame2);
   renderer_->FinishDrawingFrame(&frame2);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
@@ -1576,7 +1598,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource2));
   Mock::VerifyAndClearExpectations(&scheduler_);
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame3);
   renderer_->FinishDrawingFrame(&frame3);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
@@ -1606,14 +1628,14 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
 
   // Use the same buffer twice.
   renderer_->set_expect_overlays(true);
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   Mock::VerifyAndClearExpectations(&scheduler_);
 
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(1);
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(2);
   renderer_->BeginDrawingFrame(&frame1);
   renderer_->FinishDrawingFrame(&frame1);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
diff --git a/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.cc b/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.cc
index b70436b..0ce2773 100644
--- a/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.cc
+++ b/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.cc
@@ -57,6 +57,11 @@ GpuSurfacelessBrowserCompositorOutputSurface::
     ~GpuSurfacelessBrowserCompositorOutputSurface() {
 }
 
+bool GpuSurfacelessBrowserCompositorOutputSurface::IsDisplayedAsOverlayPlane()
+    const {
+  return true;
+}
+
 unsigned GpuSurfacelessBrowserCompositorOutputSurface::GetOverlayTextureId()
     const {
   return output_surface_->current_texture_id();
@@ -65,22 +70,7 @@ unsigned GpuSurfacelessBrowserCompositorOutputSurface::GetOverlayTextureId()
 void GpuSurfacelessBrowserCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame* frame) {
   DCHECK(output_surface_);
-
-  GLuint texture = output_surface_->current_texture_id();
   output_surface_->SwapBuffers(frame->gl_frame_data->sub_buffer_rect);
-  const gfx::Size& size = frame->gl_frame_data->size;
-  context_provider_->ContextGL()->ScheduleOverlayPlaneCHROMIUM(
-      0,
-      GL_OVERLAY_TRANSFORM_NONE_CHROMIUM,
-      texture,
-      0,
-      0,
-      size.width(),
-      size.height(),
-      0,
-      0,
-      1.0f,
-      1.0f);
   GpuBrowserCompositorOutputSurface::SwapBuffers(frame);
 }
 
diff --git a/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h b/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h
index e114ba9..d733772 100644
--- a/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h
+++ b/content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h
@@ -34,6 +34,7 @@ class GpuSurfacelessBrowserCompositorOutputSurface
   void OnSwapBuffersComplete() override;
   void BindFramebuffer() override;
   void Reshape(const gfx::Size& size, float scale_factor) override;
+  bool IsDisplayedAsOverlayPlane() const override;
   unsigned GetOverlayTextureId() const override;
 
   void OnSwapBuffersCompleted(const std::vector<ui::LatencyInfo>& latency_info,