Early wait on texture resource sync points in gl_renderer.

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 440 matching lines @@
   always_clear = true;
 #endif
   if (always_clear || frame->current_render_pass->has_transparent_background) {
     GLbitfield clear_bits = GL_COLOR_BUFFER_BIT;
     if (always_clear)
       clear_bits |= GL_STENCIL_BUFFER_BIT;
     gl_->Clear(clear_bits);
   }
 }
 
+static ResourceProvider::ResourceId WaitOnResourceSyncPoints(
+    ResourceProvider* resource_provider,
+    ResourceProvider::ResourceId resource_id) {
+  resource_provider->WaitSyncPointIfNeeded(resource_id);
+  return resource_id;
+}
+
 void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   if (frame->device_viewport_rect.IsEmpty())
     return;
 
   TRACE_EVENT0("cc", "GLRenderer::BeginDrawingFrame");
 
   scoped_refptr<ResourceProvider::Fence> read_lock_fence;
   if (use_sync_query_) {
     // Block until oldest sync query has passed if the number of pending queries
     // ever reach kMaxPendingSyncQueries.
@@ skipping 14 matching lines @@
     current_sync_query_ = available_sync_queries_.empty()
                               ? make_scoped_ptr(new SyncQuery(gl_))
                               : available_sync_queries_.take_front();
 
     read_lock_fence = current_sync_query_->Begin();
   } else {
     read_lock_fence = make_scoped_refptr(new FallbackFence(gl_));
   }
   resource_provider_->SetReadLockFence(read_lock_fence.get());
 
+  // Insert WaitSyncPointCHROMIUM on quad resources prior to drawing the frame,
+  // so that drawing can proceed without GL context switching interruptions.
+  DrawQuad::ResourceIteratorCallback wait_on_resource_syncpoints_callback =
+      base::Bind(&WaitOnResourceSyncPoints, resource_provider_);
+
+  for (size_t i = 0; i < frame->render_passes_in_draw_order->size(); ++i) {
+    RenderPass* pass = frame->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);
+    }
+  }
+
   // TODO(enne): Do we need to reinitialize all of this state per frame?
   ReinitializeGLState();
 }
 
 void GLRenderer::DoNoOp() {
   GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, 0));
   GLC(gl_, gl_->Flush());
 }
 
 void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
@@ skipping 2692 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc