Plumb overlay processing into DirectRenderer.

cc/output/gl_renderer.cc

Index: cc/output/gl_renderer.cc
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 89b1e00554a01a3e2eed1ac300305bae578e7be0..a3a936e34cbebe820195865aabfbb0186c280386 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -2000,6 +2000,8 @@ void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
 
   GLC(gl_, gl_->Disable(GL_BLEND));
   blend_shadow_ = false;
+
+  ScheduleOverlays(frame);
 }
 
 void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); }
@@ -2171,6 +2173,11 @@ void GLRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {
   }
   output_surface_->SwapBuffers(&compositor_frame);
 
+  // Release previously used overlay resources and hold onto the pending ones
+  // until the next swap buffers.
+  in_use_overlay_resources_.clear();
+  in_use_overlay_resources_.swap(pending_overlay_resources_);

[alexst (slow to review), 2014/03/24 23:25:40]

This particular section, I am not 100% certain about and would like some
feedback on. I think this is sufficient and the sync point that these buffers
will be returned with should prevent the renderer from writing while they are
scanned out, but I want to be sure there is no race condition with SwapBuffers
above.

[piman, 2014/03/25 00:08:08]

The ScopedReadLockGL is not enough to prevent the resource from being returned.
The assumption is that the ScopedReadLockGL is short term, just for the duration
of the draw calls, but would not span frames. There are some DCHECKs that I
think would trigger, when we want to return the resources to the child. See e.g.
ResourceProvider::DeleteAndReturnUnusedResourcesToChild or
ResourceProvider::DeleteResource, where we
DCHECK(!resource.lock_for_read_count);

I think we have 2 ways of dealing with this:
1- add logic to make ScopedReadLockGL prevent the returns. I.e. remove all these
DCHECKs and instead handle gracefully.
2- use the logic that is meant to deal with that for delegated renderers, i.e.
through the resource's "exported_count". The idea is to treat the overlays as a
"parent" compositor. We would "export" the resource when giving it to an overlay
plane, and "return" it on the next swap (well, the one *after* we commit the
overlays). The count would make sure that if we reuse a resource across frames
we wouldn't return it to the child until it's fully not used.

Most of the logic already exists for (2), it's just a matter of adding a path
for overlays (unless we can reuse the
PrepareSendToParent/ReceiveReturnsFromParent logic?). I'm not sure how much is
needed for (1), it may be small.

+
   swap_buffer_rect_ = gfx::Rect();
 
   // We don't have real fences, so we mark read fences as passed
@@ -3047,4 +3054,43 @@ bool GLRenderer::IsContextLost() {
   return output_surface_->context_provider()->IsContextLost();
 }
 
+void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {
+  if (!frame->overlay_passes_in_draw_order)
+    return;
+
+  const RenderPassList* pass_list = frame->overlay_passes_in_draw_order;
+  int plane_z_order = 1;
+  for (RenderPassList::const_reverse_iterator it = pass_list->rbegin();
+       it != pass_list->rend();
+       ++it) {
+    RenderPass* pass = *it;
+    if (pass->overlay_state != RenderPass::SIMPLE_OVERLAY)
+      continue;

[piman, 2014/03/25 00:08:08]

I wonder if it could make sense to construct the overlay list in DirectRenderer,
instead of passing the full set of render passes, construct the list of overlay
passes as we skip them when drawing.

+
+    DCHECK_EQ(pass->quad_list.size(), 1U);
+    const DrawQuad* candidate_quad = pass->quad_list.front();
+    DCHECK_EQ(candidate_quad->material, DrawQuad::TEXTURE_CONTENT);
+    const TextureDrawQuad& quad =
+        *TextureDrawQuad::MaterialCast(candidate_quad);
+
+    pending_overlay_resources_.push_back(
+        make_scoped_ptr(new ResourceProvider::ScopedReadLockGL(
+            resource_provider(), quad.resource_id)));
+
+    OverlayCandidate::OverlayTransform overlay_transform =
+        OverlayCandidate::GetOverlayTransform(quad.quadTransform(),
+                                              quad.flipped);
+    gfx::Rect display_bounds =
+        OverlayCandidate::GetOverlayRect(quad.quadTransform(), quad.rect);
+    gfx::RectF uv_rect = BoundingRect(quad.uv_top_left, quad.uv_bottom_right);

[piman, 2014/03/25 00:08:08]

Mmh, a lot of these we computed previously when trying to figure out what can go
as an overlay.
Is there a way we could reuse that?
E.g. having ProcessForOverlays output a list of OverlayCandidates, that we'd
pass back through here?

+
+    context_support_->ScheduleOverlayPlane(
+        plane_z_order++,
+        overlay_transform,
+        pending_overlay_resources_.back()->texture_id(),
+        display_bounds,
+        uv_rect);
+  }
+}
+
 }  // namespace cc