Enable asynchronous glReadPixels on Windows.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 7520 matching lines @@
   }
   GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.pack_alignment, &pixels_size,
       NULL, NULL);
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
   if (!pixels) {
     if (buffer != 0) {
       glDeleteBuffersARB(1, &buffer);
     }
+    if (result)
+      *result = GL_INVALID_VALUE;
     return;
   }
 
-  if (buffer != 0) {
+  if (buffer != 0) {  // Asynchronous readback path.
     glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, buffer);
     void* data;
     if (features().map_buffer_range) {
       data = glMapBufferRange(
           GL_PIXEL_PACK_BUFFER_ARB, 0, pixels_size, GL_MAP_READ_BIT);
     } else {
       data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
     }
-    memcpy(pixels, data, pixels_size);
+    if (result)
+      *result = glGetError();
+    if (data)
+      memcpy(pixels, data, pixels_size);
     // GL_PIXEL_PACK_BUFFER_ARB is currently unused, so we don't
     // have to restore the state.
     glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
     glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
     glDeleteBuffersARB(1, &buffer);
-  }
-
-  if (result != NULL) {
-    *result = true;
+    if (!data)
+      return;
   }
 
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   if ((channels_exist & 0x0008) == 0 &&
       workarounds().clear_alpha_in_readpixels) {
     // Set the alpha to 255 because some drivers are buggy in this regard.
     uint32 temp_size;
 
     uint32 unpadded_row_size;
     uint32 padded_row_size;
     if (!GLES2Util::ComputeImageDataSizes(
             width, 2, format, type, state_.pack_alignment, &temp_size,
             &unpadded_row_size, &padded_row_size)) {
+      if (result)
+        *result = GL_INVALID_VALUE;
       return;
     }
 
     uint32 channel_count = 0;
     uint32 alpha_channel = 0;
     switch (format) {
       case GL_RGBA:
       case GL_BGRA_EXT:
         channel_count = 4;
         alpha_channel = 3;
@@ skipping 157 matching lines @@
         glReadPixels(
             read_x, ry, read_width, 1, format, type, dst + dest_row_offset);
       }
       dst += padded_row_size;
     }
   } else {
     if (async && features().use_async_readpixels) {
       GLuint buffer = 0;
       glGenBuffersARB(1, &buffer);
       glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, buffer);
-      glBufferData(GL_PIXEL_PACK_BUFFER_ARB, pixels_size, NULL, GL_STREAM_READ);
+      // For ANGLE client version 2, GL_STREAM_READ is not available.
+      const GLenum usage_hint =
+          features().is_angle ? GL_STATIC_DRAW : GL_STREAM_READ;
+      glBufferData(GL_PIXEL_PACK_BUFFER_ARB, pixels_size, NULL, usage_hint);
       GLenum error = glGetError();
       if (error == GL_NO_ERROR) {
         glReadPixels(x, y, width, height, format, type, 0);
-        pending_readpixel_fences_.push(linked_ptr<FenceCallback>(
-            new FenceCallback()));
-        WaitForReadPixels(base::Bind(
-            &GLES2DecoderImpl::FinishReadPixels,
-            base::internal::SupportsWeakPtrBase::StaticAsWeakPtr
-            <GLES2DecoderImpl>(this),
-            c, buffer));
+        error = glGetError();
+        if (result)
+          *result = error;
+        if (error == GL_NO_ERROR) {
+          pending_readpixel_fences_.push(linked_ptr<FenceCallback>(
+              new FenceCallback()));
+          WaitForReadPixels(base::Bind(
+              &GLES2DecoderImpl::FinishReadPixels,
+              base::internal::SupportsWeakPtrBase::StaticAsWeakPtr
+              <GLES2DecoderImpl>(this),
+              c, buffer));
+        }
         glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
         return error::kNoError;
       } else {
         // On error, unbind pack buffer and fall through to sync readpixels
         glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
         glDeleteBuffersARB(1, &buffer);
       }
     }
     glReadPixels(x, y, width, height, format, type, pixels);
   }
-  GLenum error = LOCAL_PEEK_GL_ERROR("glReadPixels");
-  if (error == GL_NO_ERROR) {
-    if (result != NULL) {
-      *result = true;
-    }
+  const GLenum error = LOCAL_PEEK_GL_ERROR("glReadPixels");
+  if (result)
+    *result = error;
+  if (error == GL_NO_ERROR)
     FinishReadPixels(c, 0);
-  }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePixelStorei(uint32 immediate_data_size,
                                                  const void* cmd_data) {
   const gles2::cmds::PixelStorei& c =
       *static_cast<const gles2::cmds::PixelStorei*>(cmd_data);
   GLenum pname = c.pname;
   GLenum param = c.param;
@@ skipping 3670 matching lines @@
   }
 }
 
 // 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/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu