Plumb overlay processing into DirectRenderer.

cc/output/direct_renderer.cc

Index: cc/output/direct_renderer.cc
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 1eb0fbc2af680bdfff66211567011f46c6e0a0d7..6a7f96d5dd7a969a1210be3a741653ee6acfd029 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -58,7 +58,8 @@ static gfx::Transform window_matrix(int x, int y, int width, int height) {
 namespace cc {
 
 DirectRenderer::DrawingFrame::DrawingFrame()
-    : root_render_pass(NULL),
+    : render_passes_in_draw_order(NULL),
+      root_render_pass(NULL),
       current_render_pass(NULL),
       current_texture(NULL),
       offscreen_context_provider(NULL) {}
@@ -133,7 +134,11 @@ DirectRenderer::DirectRenderer(RendererClient* client,
                                ResourceProvider* resource_provider)
     : Renderer(client, settings),
       output_surface_(output_surface),
-      resource_provider_(resource_provider) {}
+      resource_provider_(resource_provider),
+      overlay_processor_(
+          new OverlayProcessor(output_surface, resource_provider)) {
+  overlay_processor_->Initialize();
+}
 
 DirectRenderer::~DirectRenderer() {}
 
@@ -218,6 +223,9 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   frame.disable_picture_quad_image_filtering =
       disable_picture_quad_image_filtering;
 
+  if (overlay_processor_->ProcessForOverlays(render_passes_in_draw_order))
+    frame.render_passes_in_draw_order = render_passes_in_draw_order;

[enne (OOO), 2014/03/21 18:15:49]

This variable is a little awkward.  It says render_passes_in_draw_order, but it
only gets set when the OverlayProcessor succeeds, and it's only used as a
boolean in tests.

Could you always set it, or have your test verify that DrawRenderPass doesn't
occur for overlays that you expect to happen?

[enne (OOO), 2014/03/21 18:16:08]

(Er, sorry, I see that it's not just used as a boolean, but it's still only used
in tests.)

[alexst (slow to review), 2014/03/21 18:37:41]

It's not useful unless overlays are present, so it could be utilized to quickly
skip extra work in GLRenderer. I could rename it overlay_passes_in_draw_order,
since it's what they are used as. 

It already tests that the contents of that pass are not drawn via DrawQuad. I
could make DrawRenderPass virtual and test it that way as well if you think the
above is insufficient.

As for it only being used in tests, I decided to break my patch here fully
tested because the next one will be pretty long and tricky. It'll be adding
plumbing to the GPU process and buffer lifetimes and I didn't want to mix the
two to avoid mega-patches. 

[piman, 2014/03/21 21:45:12]

Do you have a CL that shows how it will be used? Your "overall" CL doesn't seem
to have it... What more are you thinking of skipping beyond what you have below?

[alexst (slow to review), 2014/03/24 12:46:45]

I'll add more code so this makes more sense. I was going to get a read lock on
the texture resources in GLRenderer:: FinishDrawingFrame, hold on to them until
the next swap and make a call on context support to schedule the planes. The
plumbing was in a different place, which I didn't like in the overall patch, so
I'm doing it here instead. Patch coming up.

+
   EnsureBackbuffer();
 
   // Only reshape when we know we are going to draw. Otherwise, the reshape
@@ -228,6 +236,9 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   BeginDrawingFrame(&frame);
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     RenderPass* pass = render_passes_in_draw_order->at(i);
+    if (pass->overlay_state == RenderPass::SIMPLE_OVERLAY)
+      continue;
+
     DrawRenderPass(&frame, pass);
 
     for (ScopedPtrVector<CopyOutputRequest>::iterator it =