Plumb overlay processing into DirectRenderer.

cc/output/gl_renderer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 1982 matching lines @@
 
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
 void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
   swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame->root_damage_rect));
 
   GLC(gl_, gl_->Disable(GL_BLEND));
   blend_shadow_ = false;
+
+  ScheduleOverlays(frame);
 }
 
 void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); }
 
 bool GLRenderer::FlippedFramebuffer() const { return true; }
 
 void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
     return;
 
@@ skipping 151 matching lines @@
         gfx::Rect(swap_buffer_rect_.x(),
                   flipped_y_pos_of_rect_bottom,
                   swap_buffer_rect_.width(),
                   swap_buffer_rect_.height());
   } else {
     compositor_frame.gl_frame_data->sub_buffer_rect =
         gfx::Rect(output_surface_->SurfaceSize());
   }
   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
   // assuming a double-buffered GPU pipeline. A texture can be
   // written to after one full frame has past since it was last read.
   if (last_swap_fence_.get())
     static_cast<SimpleSwapFence*>(last_swap_fence_.get())->SetHasPassed();
   last_swap_fence_ = resource_provider_->GetReadLockFence();
   resource_provider_->SetReadLockFence(new SimpleSwapFence());
 }
@@ skipping 856 matching lines @@
   // Make sure scissoring starts as disabled.
   is_scissor_enabled_ = false;
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   scissor_rect_needs_reset_ = true;
 }
 
 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