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 38 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 {
 
+static ResourceProvider::ResourceId WaitOnResourceSyncPoints(
+    ResourceProvider* resource_provider,
+    ResourceProvider::ResourceId resource_id) {
+  resource_provider->WaitSyncPointIfNeeded(resource_id);
+  return resource_id;
+}
+
 DirectRenderer::DrawingFrame::DrawingFrame()
     : root_render_pass(NULL), current_render_pass(NULL), current_texture(NULL) {
 }
 
 DirectRenderer::DrawingFrame::~DrawingFrame() {}
 
 //
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
@@ skipping 149 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);
 
+  // Insert WaitSyncPointCHROMIUM on quad resources prior to drawing the frame,
+  // so that drawing can proceed without GL context switching interruptions.
+  // crbug.com/394547

[danakj, 2014/08/13 23:05:19]

git blame will point to the bug, i think you can drop this from the comment

[vmiura, 2014/08/15 21:20:39]

Done.

+  DrawQuad::ResourceIteratorCallback wait_on_resource_syncpoints_callback =
+      base::Bind(&WaitOnResourceSyncPoints, resource_provider_);
+
+  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
+    RenderPass* pass = render_passes_in_draw_order->at(i);
+    for (size_t j = 0; j < pass->quad_list.size(); ++j) {
+      DrawQuad* quad = pass->quad_list[j];
+      quad->IterateResources(wait_on_resource_syncpoints_callback);
+    }
+  }
+
   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 181 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