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

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 37 matching lines @@
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/stream_texture.h"
 #include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_definition.h"
 #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"
 #if defined(OS_MACOSX)
 #include "ui/surface/io_surface_support_mac.h"
 #endif
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
@@ skipping 3430 matching lines @@
   if (info->target() != 0 && info->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "texture bound to more than 1 target.");
     return;
   }
   if (info->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "illegal target for stream texture.");
     return;
   }
-  if (info->target() == 0) {
-    texture_manager()->SetInfoTarget(info, target);
+
+  if (!info->IsAsyncTransferTexture()) {
+    if (info->target() == 0) {
+      texture_manager()->SetInfoTarget(info, target);
+    }
+    glBindTexture(target, info->service_id());
+  } else {
+    // If the texture has async transfers, they must be complete.
+    if (info->AsyncTransferIsInProgress()) {

[greggman, 2012/12/05 02:23:42]

Why is this needed? Binding a texture should not be dependent on state. For
example if you want to query a texture you should always be able to do this

  glBindTexture(target, tex);
  glGetTextParameteriv(target, pname, &value);

This will break other code that assuming binding always works which is what GL
expects

[epenner, 2012/12/05 04:01:54]

Good point! I was trying to preserve the 'level cleared' safety while not doing
a black-fill. An async upload might clear the level, but we still need to not
mark the level cleared until it has actually happened.

Hmm. I think I can avoid the bind restriction entirely and just make a
conditional SetLevelCleared for async textures.

There is also some lazy binding that needs to happen for asyncTexSubImage2D,
since the allocation has occurred on the other thread. I figured bind is the
best place to do these things.

[epenner, 2012/12/08 03:15:04]

Done.

+      SetGLError(GL_INVALID_OPERATION,
+               "glBindTexture", "async transfer already in progress");
+      return;
+    }
+
+    if (info->target() == 0) {
+      texture_manager()->SetInfoTarget(info, target);
+    }
+
+    // Bind the GL texture, and perform any custom binding.
+    info->BindAsyncTransferTexture(target);
+
+    // We now know the transfer texture is cleared.
+    texture_manager()->SetLevelCleared(info, target, 0);
   }
-  glBindTexture(target, info->service_id());
+
+
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
       unit.bound_texture_2d = info;
       break;
     case GL_TEXTURE_CUBE_MAP:
       unit.bound_texture_cube_map = info;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
@@ skipping 5818 matching lines @@
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
       return error::kOutOfBounds;
     }
   }
 
-  // TODO(epenner): Do this via an async task.
-  return DoTexImage2D(
-      target, level, internal_format, width, height, border, format, type,
-      pixels, pixels_size);
+  // We only support async uploads to 2D textures for now.
+  if (target != GL_TEXTURE_2D) {
+    SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");
+    return error::kNoError;
+  }
+
+  // We only support uploads to level zero for now.
+  if (level != 0) {
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "level != 0");
+    return error::kNoError;
+  }
+
+  // We only support one async transfer in progress.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!info || info->AsyncTransferState()->TransferIsInProgress()) {
+    SetGLError(GL_INVALID_OPERATION,
+        "glAsyncTexImage2D", "transfer already in progress");
+  }
+
+  // TODO(epenner): Fix the use-after-free vulnerability here
+  // by referencing the shared memory for "pixels" until completion.
+  gfx::AsyncPixelTransferDelegate::Get()->AsyncTexImage2D(
+      info->AsyncTransferState(), target, level, internal_format,
+      width, height, border, format, type, pixels);
+  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);
@@ skipping 24 matching lines @@
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(format)) {
     SetGLErrorInvalidEnum("glTexSubImage2D", format, "format");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
     SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");
     return error::kNoError;
   }
-  if (pixels == NULL) {
-    return error::kOutOfBounds;
+
+  // We only support async uploads to 2D textures for now.
+  if (target != GL_TEXTURE_2D) {
+    SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");
+    return error::kNoError;
   }
 
-  // TODO(epenner): Do this via an async task.
-  DoTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type, pixels);
+  // We only support uploads to level zero for now.
+  if (level != 0) {
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "level != 0");
+    return error::kNoError;
+  }
+
+  // We only support one async transfer in progress.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!info || info->AsyncTransferState()->TransferIsInProgress()) {
+    SetGLError(GL_INVALID_OPERATION,
+        "glTexSubImage2D", "transfer already in progress");
+  }
+
+  // It would be nice to do this async as well, but that way we can't
+  // be sure the texture is cleared after this call. So better to do it
+  // immediately (it's easy to avoid this penalty anyway).
+  GLsizei tex_width = 0;
+  GLsizei tex_height = 0;
+  bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
+  DCHECK(ok);
+  if (xoffset != 0 || yoffset != 0 ||
+      width != tex_width || height != tex_height) {
+    if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+      SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");
+      return error::kNoError;
+    }
+    // The level is certainly cleared now. In the full update case
+    // we wait until the texture is used to mark it as cleared.
+    texture_manager()->SetLevelCleared(info, target, level);
+  }
+
+  // TODO(epenner): Fix the use-after-free vulnerability here
+  // by referencing the shared memory for "pixels" until completion.
+  gfx::AsyncPixelTransferDelegate::Get()->AsyncTexSubImage2D(
+      info->AsyncTransferState(), target, level, xoffset, yoffset,
+      width, height, format, type, pixels);
   return error::kNoError;
 }
 
 // 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