Early wait on texture resource sync points in gl_renderer.

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 208 matching lines @@
   overlay_processor_->ProcessForOverlays(render_passes_in_draw_order,
                                          &frame.overlay_list);
 
   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);
 
+  // Try to lock resources first.
+  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
+    RenderPass* pass = render_passes_in_draw_order->at(i);
+    PrelockRenderPass(&frame, pass);
+  }
+
   BeginDrawingFrame(&frame);
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     RenderPass* pass = render_passes_in_draw_order->at(i);
     DrawRenderPass(&frame, pass);
 
     for (ScopedPtrVector<CopyOutputRequest>::iterator it =
              pass->copy_requests.begin();
          it != pass->copy_requests.end();
          ++it) {
       if (i > 0) {
@@ skipping 83 matching lines @@
     const DrawingFrame* frame,
     const gfx::Rect& draw_space_rect) {
   gfx::Rect window_space_rect = MoveFromDrawToWindowSpace(draw_space_rect);
   if (NeedDeviceClip(frame))
     window_space_rect.Intersect(DeviceClipRectInWindowSpace(frame));
   SetScissorTestRect(window_space_rect);
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
+void DirectRenderer::PrelockRenderPass(DrawingFrame* frame,
+                                       const RenderPass* render_pass) {
+  const QuadList& quad_list = render_pass->quad_list;
+  int i = 0;
+  for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
+       it != quad_list.BackToFrontEnd();
+       ++it) {

[danakj, 2014/08/13 13:52:12]

You can IterateResources here to get each of the resources on each quad. Then
you don't need a switch on the quad material type.

https://code.google.com/p/chromium/codesearch#chromium/src/cc/quads/draw_quad...

Once you have all the resources, instead of doing a Lock/Unlock, how about we
just add an API to wait on any sync points. Something like:

ResourceProvider::WaitSyncPointIfNeeded(ResourceId id) {
  Resource* resource = GetResource(id);
  DCHECK_EQ(resource->exported_count, 0);
  DCHECK(resource->allocated);
  if (!resource is gl type with gl_id) return;
  if (!syncpoint) return;
  DCHECK(resource->mailbox.IsValid);
  WaitSyncPoint(syncpoint);
}

Then we don't need a virtual method and the GL/Software renderers don't need to
be involved.

Can we then DCHECK that there's no sync point to wait on in LockForRead instead
of waiting there too?

[vmiura, 2014/08/13 22:50:39]

Done.

+    DoPrelockQuad(frame, *it);
+    i++;
+  }
+}
+
 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
                                     const RenderPass* render_pass) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
   bool using_scissor_as_optimization = Capabilities().using_partial_swap;
   gfx::Rect render_pass_scissor;
   bool draw_rect_covers_full_surface = true;
   if (frame->current_render_pass == frame->root_render_pass &&
@@ skipping 78 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