Revert "Revert 210138 "Perform glReadPixels with PBOs in the gpu, if PBO...""

content/common/gpu/client/gl_helper.cc

 // Copyright (c) 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 "content/common/gpu/client/gl_helper.h"
 
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 177 matching lines @@
   // thread marks that it handles the request by resetting the pixels field
   // (meaning it guarantees that the callback with be called).
   // In either case, the callback must be called exactly once, and the texture
   // must be deleted by the main thread context.
   struct Request {
     Request(const gfx::Size& size_,
             int32 bytes_per_row_,
             int32 row_stride_bytes_,
             unsigned char* pixels_,
             const base::Callback<void(bool)>& callback_)
-        : size(size_),
+        : done(false),
+          size(size_),
           bytes_per_row(bytes_per_row_),
           row_stride_bytes(row_stride_bytes_),
           pixels(pixels_),
           callback(callback_),
-          buffer(0) {
+          buffer(0),
+          query(0) {
     }
 
+    bool done;
     gfx::Size size;
     int bytes_per_row;
     int row_stride_bytes;
     unsigned char* pixels;
     base::Callback<void(bool)> callback;
     GLuint buffer;
+    WebKit::WebGLId query;
   };
 
   // A readback pipeline that also converts the data to YUV before
   // reading it back.
   class ReadbackYUVImpl : public ReadbackYUVInterface {
    public:
     ReadbackYUVImpl(WebGraphicsContext3D* context,
                     CopyTextureToImpl* copy_impl,
                     GLHelperScaling* scaler_impl,
                     GLHelper::ScalerQuality quality,
@@ skipping 72 matching lines @@
   // |src_size| is the size of |src_texture|.
   WebGLId ScaleTexture(WebGLId src_texture,
                        const gfx::Size& src_size,
                        const gfx::Rect& src_subrect,
                        const gfx::Size& dst_size,
                        bool vertically_flip_texture,
                        bool swizzle,
                        GLHelper::ScalerQuality quality);
 
   static void nullcallback(bool success) {}
-  void ReadbackDone(Request* request);
+  void ReadbackDone(Request *request);
   void FinishRequest(Request* request, bool result);
   void CancelRequests();
 
   static const float kRGBtoYColorWeights[];
   static const float kRGBtoUColorWeights[];
   static const float kRGBtoVColorWeights[];
 
   WebGraphicsContext3D* context_;
   GLHelper* helper_;
 
@@ skipping 67 matching lines @@
                                  callback);
   request_queue_.push(request);
   request->buffer = context_->createBuffer();
   context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                        request->buffer);
   context_->bufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                        4 * dst_size.GetArea(),
                        NULL,
                        GL_STREAM_READ);
 
+  request->query = context_->createQueryEXT();
+  context_->beginQueryEXT(GL_ASYNC_READ_PIXELS_COMPLETED_CHROMIUM,
+                          request->query);
   context_->readPixels(0, 0, dst_size.width(), dst_size.height(),
                        GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  context_->endQueryEXT(GL_ASYNC_READ_PIXELS_COMPLETED_CHROMIUM);
   context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
-  cc::SyncPointHelper::SignalSyncPoint(
+  cc::SyncPointHelper::SignalQuery(
       context_,
-      context_->insertSyncPoint(),
+      request->query,
       base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(), request));
 }
 
 
 void GLHelper::CopyTextureToImpl::CropScaleReadbackAndCleanTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
@@ skipping 57 matching lines @@
     GLHelper::ScalerQuality quality) {
   return ScaleTexture(src_texture,
                       src_size,
                       gfx::Rect(src_size),
                       dst_size,
                       vertically_flip_texture,
                       false,
                       quality);
 }
 
-void GLHelper::CopyTextureToImpl::ReadbackDone(Request* request) {
+void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request) {
   TRACE_EVENT0("mirror",
                "GLHelper::CopyTextureToImpl::CheckReadbackFramebufferComplete");
-  DCHECK(request == request_queue_.front());
+  finished_request->done = true;
 
-  bool result = false;
-  if (request->buffer != 0) {
-    context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
-                         request->buffer);
-    unsigned char* data = static_cast<unsigned char *>(
-        context_->mapBufferCHROMIUM(
-            GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY));
-    if (data) {
-      result = true;
-      if (request->bytes_per_row == request->size.width() * 4 &&
-          request->bytes_per_row == request->row_stride_bytes) {
-        memcpy(request->pixels, data, request->size.GetArea() * 4);
-      } else {
-        unsigned char* out = request->pixels;
-        for (int y = 0; y < request->size.height(); y++) {
-          memcpy(out, data, request->bytes_per_row);
-          out += request->row_stride_bytes;
-          data += request->size.width() * 4;
+  // We process transfer requests in the order they were received, regardless
+  // of the order we get the callbacks in.
+  while (!request_queue_.empty()) {
+    Request* request = request_queue_.front();
+    if (!request->done) {
+      break;
+    }
+
+    bool result = false;
+    if (request->buffer != 0) {
+      context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
+                           request->buffer);
+      unsigned char* data = static_cast<unsigned char *>(
+          context_->mapBufferCHROMIUM(
+              GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY));
+      if (data) {
+        result = true;
+        if (request->bytes_per_row == request->size.width() * 4 &&
+            request->bytes_per_row == request->row_stride_bytes) {
+          memcpy(request->pixels, data, request->size.GetArea() * 4);
+        } else {
+          unsigned char* out = request->pixels;
+          for (int y = 0; y < request->size.height(); y++) {
+            memcpy(out, data, request->bytes_per_row);
+            out += request->row_stride_bytes;
+            data += request->size.width() * 4;
+          }
         }
+        context_->unmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM);
       }
-      context_->unmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM);
+      context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
     }
-    context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
+
+    FinishRequest(request, result);
   }
-
-  FinishRequest(request, result);
 }
 
 void GLHelper::CopyTextureToImpl::FinishRequest(Request* request,
                                                 bool result) {
+  TRACE_EVENT0("mirror", "GLHelper::CopyTextureToImpl::FinishRequest");
   DCHECK(request_queue_.front() == request);
   request_queue_.pop();
   request->callback.Run(result);
   ScopedFlush flush(context_);
+  if (request->query != 0) {
+    context_->deleteQueryEXT(request->query);
+    request->query = 0;
+  }
   if (request->buffer != 0) {
     context_->deleteBuffer(request->buffer);
     request->buffer = 0;
   }
   delete request;
 }
 
 void GLHelper::CopyTextureToImpl::CancelRequests() {
   while (!request_queue_.empty()) {
     Request* request = request_queue_.front();
@@ skipping 483 matching lines @@
       quality,
       src_size,
       src_subrect,
       dst_size,
       dst_subrect,
       flip_vertically,
       use_mrt);
 }
 
 }  // namespace content