Enable asynchronous glReadPixels on Windows.

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
@@ skipping 1305 matching lines @@
   GLuint buffer_id;
   if (GetBoundPixelTransferBuffer(target, "glBufferData", &buffer_id)) {
     if (!buffer_id) {
       return;
     }
 
     BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
     if (buffer)
       RemoveTransferBuffer(buffer);
 
-    // Create new buffer.
-    buffer = buffer_tracker_->CreateBuffer(buffer_id, size);
+    // Create new buffer.  For the async readback use case, allocate a few
+    // extra bytes to contain any service-side glMapBuffer errors.
+    const GLsizeiptr metadata_size =
+        target == GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM ?
+            sizeof(cmds::ReadPixels::Result) : 0;
+    buffer = buffer_tracker_->CreateBuffer(buffer_id, size, metadata_size);
     DCHECK(buffer);
     if (buffer->address() && data)
       memcpy(buffer->address(), data, size);
     return;
   }
 
   if (size == 0) {
     return;
   }
 
@@ skipping 904 matching lines @@
   uint32 temp_size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, 2, format, type, pack_alignment_, &temp_size, &unpadded_row_size,
       &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
     return;
   }
 
-  if (bound_pixel_pack_transfer_buffer_id_) {
+  if (bound_pixel_pack_transfer_buffer_id_) {  // Asynchronous readback path.
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
         bound_pixel_pack_transfer_buffer_id_,
         "glReadPixels", offset, padded_row_size * height);
-    if (buffer && buffer->shm_id() != -1) {
-      helper_->ReadPixels(xoffset, yoffset, width, height, format, type,
-                          buffer->shm_id(), buffer->shm_offset(),
-                          0, 0, true);
-      CheckGLError();
+    if (!buffer || buffer->shm_id() == -1) {
+      SetGLError(GL_INVALID_OPERATION, "glReadPixels", "invalid buffer.");
+      return;
     }
+
+    DCHECK_EQ(buffer->metadata_size(), sizeof(Result));
+    helper_->ReadPixels(
+        xoffset, yoffset, width, height, format, type,
+        buffer->shm_id(), buffer->shm_offset(),
+        buffer->metadata_shm_id(), buffer->metadata_shm_offset(),
+        true);
+    CheckGLError();
     return;
   }
 
   if (!pixels) {
     SetGLError(GL_INVALID_OPERATION, "glReadPixels", "pixels = NULL");
     return;
   }
 
   // Transfer by rows.
   // The max rows we can transfer.
   while (height) {
     GLsizei desired_size = padded_row_size * height - 1 + unpadded_row_size;
     ScopedTransferBufferPtr buffer(desired_size, helper_, transfer_buffer_);
     if (!buffer.valid()) {
       return;
     }
     GLint num_rows = ComputeNumRowsThatFitInBuffer(
         padded_row_size, unpadded_row_size, buffer.size());
     num_rows = std::min(num_rows, height);
     // NOTE: We must look up the address of the result area AFTER allocation
     // of the transfer buffer since the transfer buffer may be reallocated.
     Result* result = GetResultAs<Result*>();
     if (!result) {
       return;
     }
-    *result = 0;  // mark as failed.
     helper_->ReadPixels(
         xoffset, yoffset, width, num_rows, format, type,
         buffer.shm_id(), buffer.offset(),
         GetResultShmId(), GetResultShmOffset(),
         false);
     WaitForCmd();
-    if (*result != 0) {
-      // when doing a y-flip we have to iterate through top-to-bottom chunks
-      // of the dst. The service side handles reversing the rows within a
-      // chunk.
-      int8* rows_dst;
-      if (pack_reverse_row_order_) {
-          rows_dst = dest + (height - num_rows) * padded_row_size;
-      } else {
-          rows_dst = dest;
-      }
-      // We have to copy 1 row at a time to avoid writing pad bytes.
-      const int8* src = static_cast<const int8*>(buffer.address());
-      for (GLint yy = 0; yy < num_rows; ++yy) {
-        memcpy(rows_dst, src, unpadded_row_size);
-        rows_dst += padded_row_size;
-        src += padded_row_size;
-      }
-      if (!pack_reverse_row_order_) {
-        dest = rows_dst;
-      }
-    }
-    // If it was not marked as successful exit.
-    if (*result == 0) {
+    if (*result != GL_NO_ERROR) {
+      SetGLError(*result, "glReadPixels", "Service-side error.");
       return;
     }
+
+    // when doing a y-flip we have to iterate through top-to-bottom chunks
+    // of the dst. The service side handles reversing the rows within a
+    // chunk.
+    int8* rows_dst;
+    if (pack_reverse_row_order_) {
+        rows_dst = dest + (height - num_rows) * padded_row_size;
+    } else {
+        rows_dst = dest;
+    }
+    // We have to copy 1 row at a time to avoid writing pad bytes.
+    const int8* src = static_cast<const int8*>(buffer.address());
+    for (GLint yy = 0; yy < num_rows; ++yy) {
+      memcpy(rows_dst, src, unpadded_row_size);
+      rows_dst += padded_row_size;
+      src += padded_row_size;
+    }
+    if (!pack_reverse_row_order_) {
+      dest = rows_dst;
+    }
+
     yoffset += num_rows;
     height -= num_rows;
   }
   CheckGLError();
 }
 
 void GLES2Implementation::ActiveTexture(GLenum texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glActiveTexture("
       << GLES2Util::GetStringEnum(texture) << ")");
@@ skipping 1339 matching lines @@
       }
       break;
     default:
       SetGLError(
           GL_INVALID_ENUM, "glMapBufferCHROMIUM", "invalid target");
       return NULL;
   }
   GLuint buffer_id;
   GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id);
   if (!buffer_id) {
+    SetGLError(GL_INVALID_VALUE, "glMapBufferCHROMIUM", "invalid buffer");
     return NULL;
   }
   BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
   if (!buffer) {
     SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "invalid buffer");
     return NULL;
   }
+
+  if (target == GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM) {
+    DCHECK_EQ(buffer->metadata_size(), sizeof(cmds::ReadPixels::Result));
+    const GLenum error =
+        *(static_cast<cmds::ReadPixels::Result*>(buffer->metadata_address()));
+    if (error != GL_NO_ERROR) {
+      SetGLError(error, "glMapBufferCHROMIUM", "service map buffer error");
+      return NULL;
+    }
+  }
+
   if (buffer->mapped()) {
     SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "already mapped");
     return NULL;
   }
   // Here we wait for previous transfer operations to be finished.
   // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work
   // with this method of synchronization. Until this is fixed,
   // MapBufferCHROMIUM will not block even if the transfer is not ready
   // for these calls.
   if (buffer->last_usage_token()) {
@@ skipping 421 matching lines @@
   return true;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu