gpu: Add async pixel transfer interface, stub and tests.

gpu/command_buffer/service/gles2_cmd_decoder.cc

Index: gpu/command_buffer/service/gles2_cmd_decoder.cc
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 54c95eb5078d509839581920568109cad761ebcb..5d0516c5b63fa87b27a80878cb59692dd29f0e99 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -56,6 +56,7 @@
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
+#include "ui/gl/async_pixel_transfer_delegate.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
@@ -550,6 +551,12 @@ class GLES2DecoderImpl : public GLES2Decoder {
   virtual void SetMsgCallback(const MsgCallback& callback) OVERRIDE;
 
   virtual void SetStreamTextureManager(StreamTextureManager* manager) OVERRIDE;
+
+  virtual gfx::AsyncPixelTransferDelegate*
+      GetAsyncPixelTransferDelegate() OVERRIDE;
+  virtual void SetAsyncPixelTransferDelegate(
+      gfx::AsyncPixelTransferDelegate* delegate) OVERRIDE;
+
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id) OVERRIDE;
 
@@ -772,6 +779,14 @@ class GLES2DecoderImpl : public GLES2Decoder {
       GLenum type,
       const void * data);
 
+  // Extra validation for async tex(Sub)Image2D.
+  bool ValidateAsyncTransfer(
+      const char* function_name,
+      TextureManager::TextureInfo* info,
+      GLenum target,
+      GLint level,
+      const void * data);
+
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
       GLenum target,
@@ -1596,6 +1611,7 @@ class GLES2DecoderImpl : public GLES2Decoder {
   MsgCallback msg_callback_;
 
   StreamTextureManager* stream_texture_manager_;
+  scoped_ptr<gfx::AsyncPixelTransferDelegate> async_pixel_transfer_delegate_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
@@ -2376,6 +2392,9 @@ bool GLES2DecoderImpl::Initialize(
     glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
   }
 
+  // Create a delegate to perform async pixel transfers.
+  async_pixel_transfer_delegate_ = gfx::AsyncPixelTransferDelegate::Create();
+
   return true;
 }
 
@@ -2873,6 +2892,16 @@ void GLES2DecoderImpl::SetStreamTextureManager(StreamTextureManager* manager) {
   stream_texture_manager_ = manager;
 }
 
+gfx::AsyncPixelTransferDelegate*
+    GLES2DecoderImpl::GetAsyncPixelTransferDelegate() {
+  return async_pixel_transfer_delegate_.get();
+}
+
+void GLES2DecoderImpl::SetAsyncPixelTransferDelegate(
+    gfx::AsyncPixelTransferDelegate* delegate) {
+  async_pixel_transfer_delegate_ = make_scoped_ptr(delegate);
+}
+
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
   TextureManager::TextureInfo* texture =
@@ -3610,11 +3639,19 @@ void GLES2DecoderImpl::DoBindTexture(GLenum target, GLuint client_id) {
                "glBindTexture", "illegal target for stream texture.");
     return;
   }
+
   LogClientServiceForInfo(info, client_id, "glBindTexture");
   if (info->target() == 0) {
     texture_manager()->SetInfoTarget(info, target);
   }
   glBindTexture(target, info->service_id());
+
+  // Lazily bind async transfers if they have completed.
+  // TODO(epenner): Should this be delayed to draw time?
+  if (info->GetAsyncTransferState()) {
+    info->BindAsyncTransferToTexture(target);
+  }
+
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
@@ -9652,13 +9689,39 @@ void GLES2DecoderImpl::DoTraceEndCHROMIUM() {
   gpu_trace_stack_.pop();
 }
 
+bool GLES2DecoderImpl::ValidateAsyncTransfer(
+    const char* function_name,
+    TextureManager::TextureInfo* info,
+    GLenum target,
+    GLint level,
+    const void * data) {
+  // We only support async uploads to 2D textures for now.
+  if (GL_TEXTURE_2D != target) {
+    SetGLErrorInvalidEnum(function_name, target, "target");
+    return false;
+  }
+  // We only support uploads to level zero for now.
+  if (0 != level) {

[greggman, 2012/12/12 03:51:36]

style: the chromium style guide prefers if (var == const) 

[epennerAtGoogle, 2012/12/12 04:49:49]

Done.

+    SetGLError(GL_INVALID_VALUE, function_name, "level != 0");
+    return false;
+  }
+  // A transfer buffer must be bound, even for asyncTexImage2D.
+  if (0 == data) {

[greggman, 2012/12/12 03:51:36]

style: the chromium style guide prefers if (var == const) 

[epennerAtGoogle, 2012/12/12 04:49:49]

Done.

+    SetGLError(GL_INVALID_OPERATION, function_name, "buffer == 0");
+    return false;
+  }
+  // We only support one async transfer in progress.
+  if (!info || info->AsyncTransferIsInProgress()) {
+    SetGLError(GL_INVALID_OPERATION,
+        function_name, "transfer already in progress");
+    return false;
+  }
+  return true;
+}
+
 error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
     uint32 immediate_data_size, const gles2::AsyncTexImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM");
-
-  // TODO: This is a copy of HandleTexImage2D validation. Merge
-  // as much of it as possible.
-  tex_image_2d_failed_ = true;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
@@ -9670,6 +9733,9 @@ error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
   uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
   uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
   uint32 pixels_size;
+
+  // TODO(epenner): Move this and copies of this memory validation
+  // into ValidateTexImage2D step.
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &pixels_size, NULL,
       NULL)) {
@@ -9684,19 +9750,72 @@ error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
     }
   }
 
-  // TODO(epenner): Do this via an async task.
-  DoTexImage2D(
-      target, level, internal_format, width, height, border, format, type,
-      pixels, pixels_size);
+  // All the normal glTexSubImage2D validation.
+  if (!ValidateTexImage2D("glAsyncTexImage2D", target, level, internal_format,
+      width, height, border, format, type, pixels, pixels_size)) {
+    return error::kNoError;
+  }
+
+  // Extra async validation.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!ValidateAsyncTransfer("glAsyncTexImage2D", info, target, level, pixels))
+    return error::kNoError;
+
+  // Don't allow async redefinition of a textures.
+  // TODO(epenner): Is there a better check that the texture has been defined?
+  if (info->estimated_size() > 0) {

[greggman, 2012/12/12 03:51:36]

Are you sure you need this check? If so I'd consider adding info->IsDefined() so
you can play with the code outside of this function.

I'm not sure there is an easy way to check though but for now estimated_size > 0
as the check inside info->IsDefined might be okay.

[epennerAtGoogle, 2012/12/12 04:49:49]

Done (added IsDefined).

Redefining a texture that has an EGLImage will 'orphan' the EGLImage and result
in a lot of complexity. It also gets more complicated tracking the 'cleared'
state for the existing texture and the new texture being defined on another
thread.

+    SetGLError(GL_INVALID_OPERATION, "glAsyncTexImage2D", "already defined");
+    return error::kNoError;
+  }
+
+  // Return errors for any cases in DoTexImage2D which aren't handled here.
+  if (info->IsAttachedToFramebuffer()) {

[greggman, 2012/12/12 03:51:36]

If they are not allowed be bound to a framebuffer then you probably also need a
similar check in DoFramebufferTexture2D so you can't bind an texture with a
pending async upload to an fbo

[epennerAtGoogle, 2012/12/12 04:49:49]

Let me do a quick check to see if I can just allow FBO binding.. This was just
because there was some custom code in DoTexImage2D

[epennerAtGoogle, 2012/12/12 05:17:00]

I had to copy a small piece of DoTexImage2D, but just enabled FBOs.

+    SetGLError(GL_INVALID_OPERATION, "glAsyncTexImage2D",
+        "bound to framebuffer");
+    return error::kNoError;
+  }
+  if (type == GL_FLOAT || type == GL_HALF_FLOAT_OES) {

[greggman, 2012/12/12 03:51:36]

Would it would be better to list the valid types rather than assume that any
type but FLOAT and HALF_FLOAT is valid?

[epennerAtGoogle, 2012/12/12 04:49:49]

Ditto, maybe I can just allow floats actually.

[epennerAtGoogle, 2012/12/12 05:17:00]

Okay, I allowed floats by adding
GetTexInternalFormat(internal_format,format,type), and reusing that. It looks
like some more simple refactoring is possible with that,

+    SetGLError(GL_INVALID_VALUE, "glAsyncTexImage2D", "type is float");
+    return error::kNoError;
+  }
+  GLenum gl_internal_format = GetTexInternalFormat(internal_format);
+
+  // We know the memory/size is safe, so get the real shared memory since
+  // it might need to be duped to prevent use-after-free of the memory.
+  Buffer buffer = GetSharedMemoryBuffer(c.pixels_shm_id);
+  base::SharedMemory* shared_memory = buffer.shared_memory;
+  uint32 shm_size = buffer.size;
+  uint32 shm_data_offset = c.pixels_shm_offset;
+  uint32 shm_data_size = pixels_size;
+
+  DCHECK(!info->GetAsyncTransferState());

[greggman, 2012/12/12 03:51:36]

It seems like this DCHECK is in conflict with the IF below it. Either the DCHECK
is valid or the if is valid. not both?

[epennerAtGoogle, 2012/12/12 04:49:49]

DCHECK is correct. Just being defensive against crashes, but I can just keep the
DCHECK.

+  if (!info->GetAsyncTransferState()) {
+    // Set up the async state if needed, and make the texture
+    // immutable so the async state stays valid.
+    info->SetAsyncTransferState(
+        async_pixel_transfer_delegate_->
+            CreatePixelTransferState(info->service_id()));
+    info->SetImmutable(true);
+    bool cleared = true;
+    texture_manager()->SetLevelInfo(

[greggman, 2012/12/12 03:51:36]

I'm confused. You can't call SetLevelInfo until the texture has actually been
created right? Otherwise the command buffer will think this texture is ok to
render with.

[epennerAtGoogle, 2012/12/12 04:49:49]

My understanding was that we want to avoid reading from a texture which has been
defined but not uploaded to.

In this case, the texture hasn't even been defined. If this isn't okay, I could
define it as a 1x1 texture temporarily. The data is 'replaced' when the async
transfer is bound.

The end goal is to have it always be 'safe', since the black clear will actually
corrupt a pending upload (they both access the same memory at once).

[epennerAtGoogle, 2012/12/12 05:53:33]

Another possibility would be to not set the level info now. It could be deferred
until the async texture is bound to the texture id (done lazily).

[greggman, 2012/12/12 06:58:18]

That seems like that would be best.

+        info, target, level, internal_format,
+        width, height, 1, border, format, type,
+        cleared);
+  }
+
+  // Issue the async call and set up the texture.
+  gfx::AsyncTexImage2DParams tex_params = {target, level, gl_internal_format,
+                                           width, height, border, format, type};
+  gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
+                                       shm_data_offset, shm_data_size};
+  async_pixel_transfer_delegate_->AsyncTexImage2D(
+      info->GetAsyncTransferState(), tex_params, mem_params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
     uint32 immediate_data_size, const gles2::AsyncTexSubImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
-
-  // TODO: This is a copy of HandleTexSubImage2D validation. Merge
-  // as much of it as possible.
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
@@ -9705,6 +9824,9 @@ error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
+
+  // TODO(epenner): Move this and copies of this memory validation
+  // into ValidateTexImage2D step.
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &data_size,
@@ -9713,13 +9835,57 @@ error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.data_shm_id, c.data_shm_offset, data_size);
-  if (pixels == NULL) {
-    return error::kOutOfBounds;
+
+  // All the normal glTexSubImage2D validation.
+  error::Error error = error::kNoError;
+  if (!ValidateTexSubImage2D(&error, "glAsyncTexSubImage2D", target, level,
+      xoffset, yoffset, width, height, format, type, pixels)) {
+    return error;
   }
 
-  // TODO(epenner): Do this via an async task.
-  return DoTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type, pixels);
+  // Extra async validation.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!ValidateAsyncTransfer(
+         "glAsyncTexSubImage2D", info, target, level, pixels))
+    return error::kNoError;
+
+  // Guarantee async textures are always 'cleared' as follows:
+  // - AsyncTexImage2D can not redefine an existing texture
+  // - AsyncTexImage2D must initialize the entire image via non-null buffer.
+  // - AsyncTexSubImage2D clears synchronously if not already cleared.
+  // - Textures become immutable after an async call.
+  // This way we know in all cases that an async texture is always clear.
+  if (!info->SafeToRenderFrom()) {
+    if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+      SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");

[greggman, 2012/12/12 03:51:36]

"glAsyncTexSubImage2D"

[epennerAtGoogle, 2012/12/12 04:49:49]

Done.

+      return error::kNoError;
+    }
+  }
+
+  // We know the memory/size is safe, so get the real shared memory since
+  // it might need to be duped to prevent use-after-free of the memory.
+  Buffer buffer = GetSharedMemoryBuffer(c.data_shm_id);
+  base::SharedMemory* shared_memory = buffer.shared_memory;
+  uint32 shm_size = buffer.size;
+  uint32 shm_data_offset = c.data_shm_offset;
+  uint32 shm_data_size = data_size;
+
+  if (!info->GetAsyncTransferState()) {
+    // Set up the async state if needed, and make the texture
+    // immutable so the async state stays valid.
+    info->SetAsyncTransferState(
+        async_pixel_transfer_delegate_->
+            CreatePixelTransferState(info->service_id()));
+    info->SetImmutable(true);
+  }
+
+  gfx::AsyncTexSubImage2DParams tex_params = {target, level, xoffset, yoffset,
+                                              width, height, format, type};
+  gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
+                                       shm_data_offset, shm_data_size};
+  async_pixel_transfer_delegate_->AsyncTexSubImage2D(
+      info->GetAsyncTransferState(), tex_params, mem_params);
+  return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means