Plumb overlay processing into DirectRenderer.

cc/output/direct_renderer.cc

 // Copyright 2012 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/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 40 matching lines @@
   // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
   canvas.Translate3d(0.5, 0.5, 0.5);
   canvas.Scale3d(0.5, 0.5, 0.5);
 
   return canvas;
 }
 
 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) {}
 
 DirectRenderer::DrawingFrame::~DrawingFrame() {}
 
 //
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
@@ skipping 54 matching lines @@
     window_rect.set_y(current_surface_size_.height() - window_rect.bottom());
   return window_rect;
 }
 
 DirectRenderer::DirectRenderer(RendererClient* client,
                                const LayerTreeSettings* settings,
                                OutputSurface* output_surface,
                                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() {}
 
 bool DirectRenderer::CanReadPixels() const { return true; }
 
 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
     const gfx::Vector2d& amount) {
   enlarge_pass_texture_amount_ = amount;
 }
 
@@ skipping 64 matching lines @@
   frame.root_damage_rect = Capabilities().using_partial_swap
                                ? root_render_pass->damage_rect
                                : root_render_pass->output_rect;
   frame.root_damage_rect.Intersect(gfx::Rect(device_viewport_rect.size()));
   frame.device_viewport_rect = device_viewport_rect;
   frame.device_clip_rect = device_clip_rect;
   frame.offscreen_context_provider = offscreen_context_provider;
   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
   // can leave the window at the wrong size if we never draw and the proper
   // viewport size is never set.
   output_surface_->Reshape(device_viewport_rect.size(), device_scale_factor);
 
   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 =
              pass->copy_requests.begin();
          it != pass->copy_requests.end();
          ++it) {
       if (i > 0) {
         // Doing a readback is destructive of our state on Mac, so make sure
         // we restore the state between readbacks. http://crbug.com/99393.
         UseRenderPass(&frame, pass);
@@ skipping 207 matching lines @@
   ScopedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc