Add support for GL_CHROMIUM_pixel_transfer_buffer_object.

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>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
 #endif
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/string_number_conversions.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ skipping 416 matching lines @@
 #if defined(OS_WIN)
   return testing_force_is_angle_ ||
          gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
 #else
   return testing_force_is_angle_;
 #endif
 }
 
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
 // cmd stuff to outside this class.
-class GLES2DecoderImpl : public base::SupportsWeakPtr<GLES2DecoderImpl>,
-                         public GLES2Decoder {
+class GLES2DecoderImpl : public GLES2Decoder {
  public:
   static const int kMaxLogMessages = 256;
 
   explicit GLES2DecoderImpl(ContextGroup* group);
   ~GLES2DecoderImpl();
 
   // Overridden from AsyncAPIInterface.
   virtual Error DoCommand(unsigned int command,
                           unsigned int arg_count,
                           const void* args);
@@ skipping 251 matching lines @@
   // Wrapper for TexSubImage2D.
   void DoTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
-    const void * data);
+    const void* pixels,
+    uint32 pixels_size);
 
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
     GLenum target,
     GLsizei width,
     GLsizei height,
     GLuint io_surface_id,
     GLuint plane);
 
   void DoCopyTextureCHROMIUM(
@@ skipping 465 matching lines @@
   // cases (primcount is 0 for non-instanced).
   error::Error DoDrawArrays(
       bool instanced, GLenum mode, GLint first, GLsizei count,
       GLsizei primcount);
   error::Error DoDrawElements(
       bool instanced, GLenum mode, GLsizei count, GLenum type,
       int32 offset, GLsizei primcount);
 
   // Gets the buffer id for a given target.
   BufferManager::BufferInfo* GetBufferInfoForTarget(GLenum target) {
-    DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
-    BufferManager::BufferInfo* info = target == GL_ARRAY_BUFFER ?
-        bound_array_buffer_ : bound_element_array_buffer_;
+    BufferManager::BufferInfo* info = NULL;
+    switch(target) {
+    case GL_ARRAY_BUFFER:
+      info = bound_array_buffer_;
+      break;
+    case GL_ELEMENT_ARRAY_BUFFER:
+      info = bound_element_array_buffer_;
+      break;
+    case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
+      info = bound_pixel_pack_transfer_buffer_;
+      break;
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
+      info = bound_pixel_unpack_transfer_buffer_;
+      break;
+    default:
+      NOTREACHED();
+      return NULL;
+    }
     return info;
   }
 
   // Gets the texture id for a given target.
   TextureManager::TextureInfo* GetTextureInfoForTarget(GLenum target) {
     TextureUnit& unit = texture_units_[active_texture_unit_];
     TextureManager::TextureInfo* info = NULL;
     switch (target) {
       case GL_TEXTURE_2D:
         info = unit.bound_texture_2d;
@@ skipping 108 matching lines @@
 
   // The GL context this decoder renders to on behalf of the client.
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
 
   // The ContextGroup for this decoder uses to track resources.
   ContextGroup::Ref group_;
 
   // A parent decoder can access this decoders saved offscreen frame buffer.
   // The parent pointer is reset if the parent is destroyed.
-  base::WeakPtr<GLES2DecoderImpl> parent_;
+  base::WeakPtr<CommonDecoder> parent_;
 
   // Current width and height of the offscreen frame buffer.
   gfx::Size offscreen_size_;
 
   // Current GL error bits.
   uint32 error_bits_;
 
   // Util to help with GL.
   GLES2Util util_;
 
@@ skipping 170 matching lines @@
   typedef std::vector<GLES2DecoderImpl*> ChildList;
   ChildList children_;
 
   scoped_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
 
   // Cached values of the currently assigned viewport dimensions.
   GLint viewport_x_, viewport_y_;
   GLsizei viewport_width_, viewport_height_;
   GLsizei viewport_max_width_, viewport_max_height_;
 
+  // The currently bound pixel pack transfer buffer.
+  BufferManager::BufferInfo::Ref bound_pixel_pack_transfer_buffer_;
+
+  // The currently bound pixel unpack transfer buffer.
+  BufferManager::BufferInfo::Ref bound_pixel_unpack_transfer_buffer_;
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   decoder_->ClearRealGLErrors();
@@ skipping 830 matching lines @@
   for (GLsizei ii = 0; ii < n; ++ii) {
     BufferManager::BufferInfo* buffer = GetBufferInfo(client_ids[ii]);
     if (buffer && !buffer->IsDeleted()) {
       vertex_attrib_manager_->Unbind(buffer);
       if (bound_array_buffer_ == buffer) {
         bound_array_buffer_ = NULL;
       }
       if (bound_element_array_buffer_ == buffer) {
         bound_element_array_buffer_ = NULL;
       }
+      if (bound_pixel_pack_transfer_buffer_ == buffer) {
+        bound_pixel_pack_transfer_buffer_ = NULL;
+      }
+      if (bound_pixel_unpack_transfer_buffer_ == buffer) {
+        bound_pixel_unpack_transfer_buffer_ = NULL;
+      }
       RemoveBufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_seperate_framebuffer_binds =
      feature_info_->feature_flags().chromium_framebuffer_multisample;
 
@@ skipping 263 matching lines @@
     return framebuffer->GetColorAttachmentFormat();
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_color_format_;
   } else {
     return back_buffer_color_format_;
   }
 }
 
 void GLES2DecoderImpl::UpdateParentTextureInfo() {
   if (parent_) {
+    GLES2DecoderImpl* parent_impl = static_cast<GLES2DecoderImpl*>(
+        parent_.get());
     // Update the info about the offscreen saved color texture in the parent.
     // The reference to the parent is a weak pointer and will become null if the
     // parent is later destroyed.
-    TextureManager* parent_texture_manager = parent_->texture_manager();
+    TextureManager* parent_texture_manager = parent_impl->texture_manager();
     parent_texture_manager->SetLevelInfo(
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_2D,
         0,  // level
         GL_RGBA,
         offscreen_size_.width(),
         offscreen_size_.height(),
         1,  // depth
         0,  // border
         GL_RGBA,
@@ skipping 51 matching lines @@
   for (ChildList::iterator it = children.begin(); it != children.end(); ++it)
     (*it)->SetParent(NULL, 0);
   DCHECK(children_.empty());
   SetParent(NULL, 0);
 
   // Unbind everything.
   vertex_attrib_manager_.reset();
   texture_units_.reset();
   bound_array_buffer_ = NULL;
   bound_element_array_buffer_ = NULL;
+  bound_pixel_pack_transfer_buffer_ = NULL;
+  bound_pixel_unpack_transfer_buffer_ = NULL;
   current_query_ = NULL;
   current_program_ = NULL;
   bound_read_framebuffer_ = NULL;
   bound_draw_framebuffer_ = NULL;
   bound_renderbuffer_ = NULL;
 
   if (have_context) {
     if (copy_texture_CHROMIUM_.get()) {
       copy_texture_CHROMIUM_->Destroy();
       copy_texture_CHROMIUM_.reset();
@@ skipping 95 matching lines @@
 
 bool GLES2DecoderImpl::SetParent(GLES2Decoder* new_parent,
                                  uint32 new_parent_texture_id) {
   if (!offscreen_saved_color_texture_.get())
     return false;
 
   // Remove the saved frame buffer mapping from the parent decoder. The
   // parent pointer is a weak pointer so it will be null if the parent has
   // already been destroyed.
   if (parent_) {
+    GLES2DecoderImpl* parent_impl = static_cast<GLES2DecoderImpl*>(
+        parent_.get());
     ChildList::iterator it = std::find(
-        parent_->children_.begin(),
-        parent_->children_.end(),
+        parent_impl->children_.begin(),
+        parent_impl->children_.end(),
         this);
-    DCHECK(it != parent_->children_.end());
-    parent_->children_.erase(it);
+    DCHECK(it != parent_impl->children_.end());
+    parent_impl->children_.erase(it);
     // First check the texture has been mapped into the parent. This might not
     // be the case if initialization failed midway through.
     GLuint service_id = offscreen_saved_color_texture_->id();
     GLuint client_id = 0;
-    if (parent_->texture_manager()->GetClientId(service_id, &client_id)) {
-      parent_->texture_manager()->RemoveTextureInfo(client_id);
+    if (parent_impl->texture_manager()->GetClientId(service_id, &client_id)) {
+      parent_impl->texture_manager()->RemoveTextureInfo(client_id);
     }
   }
 
   GLES2DecoderImpl* new_parent_impl = static_cast<GLES2DecoderImpl*>(
       new_parent);
   if (new_parent_impl) {
 #ifndef NDEBUG
     ChildList::iterator it = std::find(
         new_parent_impl->children_.begin(),
         new_parent_impl->children_.end(),
@@ skipping 10 matching lines @@
         new_parent_texture_id))
       new_parent_impl->texture_manager()->RemoveTextureInfo(
           new_parent_texture_id);
 
     offscreen_saved_color_texture_info_ =
         new_parent_impl->CreateTextureInfo(new_parent_texture_id, service_id);
     offscreen_saved_color_texture_info_->SetNotOwned();
     new_parent_impl->texture_manager()->
        SetInfoTarget(offscreen_saved_color_texture_info_, GL_TEXTURE_2D);
 
-    parent_ = new_parent_impl->AsWeakPtr();
+    parent_ = new_parent->AsWeakPtr();
 
     UpdateParentTextureInfo();
   } else {
     parent_.reset();
     offscreen_saved_color_texture_info_ = NULL;
   }
 
   return true;
 }
 
@@ skipping 310 matching lines @@
     if (!buffer_manager()->SetTarget(info, target)) {
       SetGLError(GL_INVALID_OPERATION,
                  "glBindBuffer: buffer bound to more than 1 target");
       return;
     }
     service_id = info->service_id();
   }
   switch (target) {
     case GL_ARRAY_BUFFER:
       bound_array_buffer_ = info;
+      glBindBuffer(target, service_id);
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_ = info;
+      glBindBuffer(target, service_id);
+      break;
+    case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
+      bound_pixel_pack_transfer_buffer_ = info;
+      break;
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
+      bound_pixel_unpack_transfer_buffer_ = info;
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
-  glBindBuffer(target, service_id);
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasColorAttachmentWithAlpha() {
   return (GLES2Util::GetChannelsForFormat(
       GetBoundDrawFrameBufferInternalFormat()) & 0x0008) != 0;
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasDepthAttachment() {
   FramebufferManager::FramebufferInfo* framebuffer =
       GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
@@ skipping 439 matching lines @@
           GLuint client_id = 0;
           buffer_manager()->GetClientId(
               bound_element_array_buffer_->service_id(),
               &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
+    case GL_PIXEL_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM:
+      *num_written = 1;
+      if (params) {
+        if (bound_pixel_pack_transfer_buffer_) {
+          GLuint client_id = 0;
+          buffer_manager()->GetClientId(
+              bound_pixel_pack_transfer_buffer_->service_id(),
+              &client_id);
+          *params = client_id;
+        } else {
+          *params = 0;
+        }
+      }
+      return true;
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM:
+      *num_written = 1;
+      if (params) {
+        if (bound_pixel_unpack_transfer_buffer_) {

[greggman, 2012/05/24 20:56:00]

note to gman: revisit. Does this support traditional GL sharing semantics.
Namely if you delete a buffer in ctx1 it's still useable in ctx2 if it's bound

+          GLuint client_id = 0;
+          buffer_manager()->GetClientId(
+              bound_pixel_unpack_transfer_buffer_->service_id(),
+              &client_id);
+          *params = client_id;
+        } else {
+          *params = 0;
+        }
+      }
+      return true;
     case GL_FRAMEBUFFER_BINDING:
     // case GL_DRAW_FRAMEBUFFER_BINDING_EXT: (same as GL_FRAMEBUFFER_BINDING)
       *num_written = 1;
       if (params) {
         FramebufferManager::FramebufferInfo* framebuffer =
             GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
         if (framebuffer) {
           GLuint client_id = 0;
           framebuffer_manager()->GetClientId(
               framebuffer->service_id(), &client_id);
@@ skipping 2892 matching lines @@
   }
 }
 
 error::Error GLES2DecoderImpl::HandleBufferData(
     uint32 immediate_data_size, const gles2::BufferData& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
   uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
   GLenum usage = static_cast<GLenum>(c.usage);
+
+  switch (target) {
+  case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:

[greggman, 2012/05/24 20:56:00]

style: indent

+  case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM: {
+    if (!validators_->buffer_usage.IsValid(usage)) {
+      SetGLError(GL_INVALID_ENUM, "glBufferData: usage GL_INVALID_ENUM");
+      return error::kNoError;
+    }
+    if (size < 0) {
+      SetGLError(GL_INVALID_VALUE, "glBufferData: size < 0");
+      return error::kNoError;
+    }
+    BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
+    if (!info) {
+      SetGLError(GL_INVALID_VALUE, "glBufferData: unknown buffer");
+      return error::kNoError;
+    }
+    buffer_manager()->SetInfo(
+        info, size, usage, this, data_shm_id, data_shm_offset);
+    return error::kNoError;
+  } break;

[greggman, 2012/05/24 20:56:00]

style: break goes in case block

+  }
+
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(data_shm_id, data_shm_offset, size);
     if (!data) {
       return error::kOutOfBounds;
     }
   }
   DoBufferData(target, size, data, usage);
   return error::kNoError;
 }
@@ skipping 379 matching lines @@
   GLenum type = static_cast<GLenum>(c.type);
   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;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, unpack_alignment_, &pixels_size, NULL,
       NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = NULL;
-  if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
+  if (bound_pixel_unpack_transfer_buffer_) {
+    pixels = bound_pixel_unpack_transfer_buffer_->GetRange(
+        pixels_shm_offset, pixels_size);
+    if (!pixels) {
+      return error::kOutOfBounds;
+    }
+  } else 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;
     }
   }
   return DoTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels, pixels_size);
 }
@@ skipping 53 matching lines @@
         GL_INVALID_OPERATION,
         "glCompressedTexSubImage2D: format does not match internal format.");
     return;
   }
   if (!info->ValidForTexture(
       target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexSubImage2D: bad dimensions.");
     return;
   }
+
   // Note: There is no need to deal with texture cleared tracking here
   // because the validation above means you can only get here if the level
   // is already a matching compressed format and in that case
   // CompressedTexImage2D already cleared the texture.
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, image_size, data);
 }
 
 static void Clip(
     GLint start, GLint range, GLint sourceRange,
@@ skipping 189 matching lines @@
 
 void GLES2DecoderImpl::DoTexSubImage2D(
   GLenum target,
   GLint level,
   GLint xoffset,
   GLint yoffset,
   GLsizei width,
   GLsizei height,
   GLenum format,
   GLenum type,
-  const void * data) {
+  const void* pixels,
+  uint32 pixels_size) {

[greggman, 2012/05/24 20:56:00]

pixels_size doesn't appear to be used. Was there a reason to add it?

   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glTexSubImage2D: unknown texture for target");
     return;
   }
   GLenum current_type = 0;
   GLenum internal_format = 0;
   if (!info->GetLevelType(target, level, &current_type, &internal_format)) {
     SetGLError(
@@ skipping 23 matching lines @@
   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;
     }
     glTexSubImage2D(
-        target, level, xoffset, yoffset, width, height, format, type, data);
+        target, level, xoffset, yoffset, width, height, format, type, pixels);
     return;
   }
 
   if (teximage2d_faster_than_texsubimage2d_ && !info->IsImmutable()) {
     // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
     // same as internal_foramt. If that changes we'll need to look them up.
     WrappedTexImage2D(
-        target, level, format, width, height, 0, format, type, data);
+        target, level, format, width, height, 0, format, type, pixels);
   } else {
     glTexSubImage2D(
-        target, level, xoffset, yoffset, width, height, format, type, data);
+        target, level, xoffset, yoffset, width, height, format, type, pixels);
   }
   texture_manager()->SetLevelCleared(info, target, level);
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     uint32 immediate_data_size, const gles2::TexSubImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexSubImage2D");
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && tex_image_2d_failed_)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, unpack_alignment_, &data_size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
-  const void* pixels = GetSharedMemoryAs<const void*>(
-      c.pixels_shm_id, c.pixels_shm_offset, data_size);
   if (!validators_->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: height < 0");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: type GL_INVALID_ENUM");
     return error::kNoError;
   }
+
+  const void* pixels = NULL;
+  if (bound_pixel_unpack_transfer_buffer_) {
+    pixels = bound_pixel_unpack_transfer_buffer_->GetRange(
+        c.pixels_shm_offset, data_size);
+  } else {
+    pixels = GetSharedMemoryAs<const void*>(
+        c.pixels_shm_id, c.pixels_shm_offset, data_size);
+  }
   if (pixels == NULL) {
     return error::kOutOfBounds;
   }
   DoTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type, pixels);
+      target, level, xoffset, yoffset, width, height, format, type, pixels,
+      data_size);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2DImmediate(
     uint32 immediate_data_size, const gles2::TexSubImage2DImmediate& c) {
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && tex_image_2d_failed_)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
@@ skipping 28 matching lines @@
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (pixels == NULL) {
     return error::kOutOfBounds;
   }
   DoTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type, pixels);
+      target, level, xoffset, yoffset, width, height, format, type, pixels,
+      data_size);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetVertexAttribPointerv(
     uint32 immediate_data_size, const gles2::GetVertexAttribPointerv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef gles2::GetVertexAttribPointerv::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
         c.pointer_shm_id, c.pointer_shm_offset, Result::ComputeSize(1));
@@ skipping 1265 matching lines @@
   BindAndApplyTextureParameters(info);
 }
 
 // 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