Perform glReadPixels with PBOs in the gpu, if PBOs are available.

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 2289 matching lines @@
   }
 
   unsigned buffer = context_->createBuffer();
   GLC(context_, context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                      buffer));
   GLC(context_, context_->bufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                      4 * window_rect.size().GetArea(),
                                      NULL,
                                      GL_STREAM_READ));
 
+  WebKit::WebGLId query = 0;
+  if (is_async) {
+    query = context_->createQueryEXT();
+    GLC(context_, context_->beginQueryEXT(
+        GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM,
+        query));
+  }
+
   GLC(context_,
       context_->readPixels(window_rect.x(),
                            window_rect.y(),
                            window_rect.width(),
                            window_rect.height(),
                            GL_RGBA,
                            GL_UNSIGNED_BYTE,
                            NULL));
 
   GLC(context_, context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                      0));
 
   if (do_workaround) {
     // Clean up.
     GLC(context_, context_->bindFramebuffer(GL_FRAMEBUFFER, 0));
     GLC(context_, context_->bindTexture(GL_TEXTURE_2D, 0));
     GLC(context_, context_->deleteFramebuffer(temporary_fbo));
     GLC(context_, context_->deleteTexture(temporary_texture));
   }
 
   base::Closure finished_callback =
       base::Bind(&GLRenderer::FinishedReadback,
                  base::Unretained(this),
                  cleanup_callback,
                  buffer,
+                 query,
                  dest_pixels,
                  window_rect.size());
   // Save the finished_callback so it can be cancelled.
   pending_async_read_pixels_.front()->finished_read_pixels_callback.Reset(
       finished_callback);
 
   // Save the buffer to verify the callbacks happen in the expected order.
   pending_async_read_pixels_.front()->buffer = buffer;
 
   if (is_async) {
-    unsigned sync_point = context_->insertSyncPoint();
-    SyncPointHelper::SignalSyncPoint(
+    GLC(context_, context_->endQueryEXT(
+        GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM));
+    SyncPointHelper::SignalQuery(
         context_,
-        sync_point,
+        query,
         finished_callback);
   } else {
     resource_provider_->Finish();
     finished_callback.Run();
   }
 
   EnforceMemoryPolicy();
 }
 
 void GLRenderer::FinishedReadback(
     const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback,
     unsigned source_buffer,
+    unsigned query,
     uint8* dest_pixels,
     gfx::Size size) {
   DCHECK(!pending_async_read_pixels_.empty());
 
+  if (query != 0) {
+    GLC(context_, context_->deleteQueryEXT(query));
+  }
+
   PendingAsyncReadPixels* current_read = pending_async_read_pixels_.back();
   // Make sure we service the readbacks in order.
   DCHECK_EQ(source_buffer, current_read->buffer);
 
   uint8* src_pixels = NULL;
 
   if (source_buffer != 0) {
     GLC(context_, context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                        source_buffer));
     src_pixels = static_cast<uint8*>(
@@ skipping 659 matching lines @@
   // The Skia GPU backend requires a stencil buffer.  See ReinitializeGrCanvas
   // implementation.
   return gr_context_ && context_->getContextAttributes().stencil;
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc