Implement WebGL2 PixelStorei params constraints.

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/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 2405 matching lines @@
     params.image_height = unpack_image_height_;
     params.skip_images = unpack_skip_images_;
   }
   return params;
 }
 
 void GLES2Implementation::TexImage2D(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
+  const char* func_name = "glTexImage2D";
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
       << width << ", " << height << ", " << border << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
+    SetGLError(GL_INVALID_VALUE, func_name, "dimension < 0");
     return;
   }
   if (border != 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "border != 0");
+    SetGLError(GL_INVALID_VALUE, func_name, "border != 0");
     return;
   }
+  if ((bound_pixel_unpack_buffer_ || pixels) &&
+      (unpack_skip_pixels_ + width >
+       (unpack_row_length_ ? unpack_row_length_ : width))) {
+    // This is WebGL 2 specific constraints, but we do it for all ES3 contexts.
+    SetGLError(GL_INVALID_OPERATION, func_name,
+               "invalid unpack params combination");
+    return;
+  }
+
   uint32_t size;
   uint32_t unpadded_row_size;
   uint32_t padded_row_size;
   uint32_t skip_size;
   PixelStoreParams params = GetUnpackParameters(k2D);
   if (!GLES2Util::ComputeImageDataSizesES3(width, height, 1,
                                            format, type,
                                            params,
                                            &size,
                                            &unpadded_row_size,
                                            &padded_row_size,
                                            &skip_size,
                                            nullptr)) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "image size too large");
+    SetGLError(GL_INVALID_VALUE, func_name, "image size too large");
     return;
   }
 
   if (bound_pixel_unpack_buffer_) {
     base::CheckedNumeric<uint32_t> offset = ToGLuint(pixels);
     offset += skip_size;
     if (!offset.IsValid()) {
-      SetGLError(GL_INVALID_VALUE, "glTexImage2D", "skip size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "skip size too large");
       return;
     }
     helper_->TexImage2D(
         target, level, internalformat, width, height, format, type,
         0, offset.ValueOrDefault(0));
     CheckGLError();
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     if (unpack_row_length_ > 0 || unpack_image_height_ > 0 ||
         unpack_skip_pixels_ > 0 || unpack_skip_rows_ > 0 ||
         unpack_skip_images_ > 0) {
-      SetGLError(GL_INVALID_OPERATION, "glTexImage2D",
+      SetGLError(GL_INVALID_OPERATION, func_name,
                  "No ES3 pack parameters with pixel unpack transfer buffer.");
       return;
     }
     DCHECK_EQ(0u, skip_size);
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelTransferBufferIfValid(
-        bound_pixel_unpack_transfer_buffer_id_, "glTexImage2D", offset, size);
+        bound_pixel_unpack_transfer_buffer_id_, func_name, offset, size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->TexImage2D(
           target, level, internalformat, width, height, format, type,
           buffer->shm_id(), buffer->shm_offset() + offset);
       buffer->set_last_usage_token(helper_->InsertToken());
       CheckGLError();
     }
     return;
   }
 
@@ skipping 14 matching lines @@
     PixelStoreParams service_params;
     service_params.alignment = unpack_alignment_;
     if (!GLES2Util::ComputeImageDataSizesES3(width, height, 1,
                                              format, type,
                                              service_params,
                                              &size,
                                              nullptr,
                                              &service_padded_row_size,
                                              nullptr,
                                              nullptr)) {
-      SetGLError(GL_INVALID_VALUE, "glTexImage2D", "image size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "image size too large");
       return;
     }
   } else {
     service_padded_row_size = padded_row_size;
   }
 
   // advance pixels pointer past the skip rows and skip pixels
   pixels = reinterpret_cast<const int8_t*>(pixels) + skip_size;
 
   // Check if we can send it all at once.
@@ skipping 39 matching lines @@
       target, level, 0, 0, width, height, format, type, unpadded_row_size,
       pixels, padded_row_size, GL_TRUE, &transfer_alloc,
       service_padded_row_size);
   CheckGLError();
 }
 
 void GLES2Implementation::TexImage3D(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
     const void* pixels) {
+  const char* func_name = "glTexImage3D";
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage3D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
       << width << ", " << height << ", " << depth << ", " << border << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0 || depth < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage3D", "dimension < 0");
+    SetGLError(GL_INVALID_VALUE, func_name, "dimension < 0");
     return;
   }
   if (border != 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage3D", "border != 0");
+    SetGLError(GL_INVALID_VALUE, func_name, "border != 0");
+    return;
+  }
+  if ((bound_pixel_unpack_buffer_ || pixels) &&
+      ((unpack_skip_pixels_ + width >
+        (unpack_row_length_ ? unpack_row_length_ : width)) ||
+       (unpack_skip_rows_ + height >
+        (unpack_image_height_ ? unpack_image_height_ : height)))) {
+    // This is WebGL 2 specific constraints, but we do it for all ES3 contexts.
+    SetGLError(GL_INVALID_OPERATION, func_name,
+               "invalid unpack params combination");
     return;
   }
 
   uint32_t size;
   uint32_t unpadded_row_size;
   uint32_t padded_row_size;
   uint32_t skip_size;
   PixelStoreParams params = GetUnpackParameters(k3D);
   if (!GLES2Util::ComputeImageDataSizesES3(width, height, depth,
                                            format, type,
                                            params,
                                            &size,
                                            &unpadded_row_size,
                                            &padded_row_size,
                                            &skip_size,
                                            nullptr)) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage3D", "image size too large");
+    SetGLError(GL_INVALID_VALUE, func_name, "image size too large");
     return;
   }
 
   if (bound_pixel_unpack_buffer_) {
     base::CheckedNumeric<uint32_t> offset = ToGLuint(pixels);
     offset += skip_size;
     if (!offset.IsValid()) {
-      SetGLError(GL_INVALID_VALUE, "glTexImage3D", "skip size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "skip size too large");
       return;
     }
     helper_->TexImage3D(
         target, level, internalformat, width, height, depth, format, type,
         0, offset.ValueOrDefault(0));
     CheckGLError();
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexImage3D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     if (unpack_row_length_ > 0 || unpack_image_height_ > 0 ||
         unpack_skip_pixels_ > 0 || unpack_skip_rows_ > 0 ||
         unpack_skip_images_ > 0) {
-      SetGLError(GL_INVALID_OPERATION, "glTexImage3D",
+      SetGLError(GL_INVALID_OPERATION, func_name,
                  "No ES3 pack parameters with pixel unpack transfer buffer.");
       return;
     }
     DCHECK_EQ(0u, skip_size);
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelTransferBufferIfValid(
-        bound_pixel_unpack_transfer_buffer_id_, "glTexImage3D", offset, size);
+        bound_pixel_unpack_transfer_buffer_id_, func_name, offset, size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->TexImage3D(
           target, level, internalformat, width, height, depth, format, type,
           buffer->shm_id(), buffer->shm_offset() + offset);
       buffer->set_last_usage_token(helper_->InsertToken());
       CheckGLError();
     }
     return;
   }
 
@@ skipping 16 matching lines @@
     PixelStoreParams service_params;
     service_params.alignment = unpack_alignment_;
     if (!GLES2Util::ComputeImageDataSizesES3(width, height, depth,
                                              format, type,
                                              service_params,
                                              &size,
                                              nullptr,
                                              &service_padded_row_size,
                                              nullptr,
                                              nullptr)) {
-      SetGLError(GL_INVALID_VALUE, "glTexImage3D", "image size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "image size too large");
       return;
     }
   } else {
     service_padded_row_size = padded_row_size;
   }
   uint32_t src_height =
       unpack_image_height_ > 0 ? unpack_image_height_ : height;
 
   // advance pixels pointer past the skip images/rows/pixels
   pixels = reinterpret_cast<const int8_t*>(pixels) + skip_size;
@@ skipping 46 matching lines @@
   TexSubImage3DImpl(
       target, level, 0, 0, 0, width, height, depth, format, type,
       unpadded_row_size, pixels, padded_row_size, GL_TRUE, &transfer_alloc,
       service_padded_row_size);
   CheckGLError();
 }
 
 void GLES2Implementation::TexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, const void* pixels) {
+  const char* func_name = "glTexSubImage2D";
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexSubImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
 
   if (level < 0 || height < 0 || width < 0 || xoffset < 0 || yoffset < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "dimension < 0");
+    SetGLError(GL_INVALID_VALUE, func_name, "dimension < 0");
+    return;
+  }
+  if (unpack_skip_pixels_ + width >
+      (unpack_row_length_ ? unpack_row_length_ : width)) {
+    // This is WebGL 2 specific constraints, but we do it for all ES3 contexts.
+    SetGLError(GL_INVALID_OPERATION, func_name,
+               "invalid unpack params combination");
     return;
   }
 
   uint32_t size;
   uint32_t unpadded_row_size;
   uint32_t padded_row_size;
   uint32_t skip_size;
   PixelStoreParams params = GetUnpackParameters(k2D);
   if (!GLES2Util::ComputeImageDataSizesES3(width, height, 1,
                                            format, type,
                                            params,
                                            &size,
                                            &unpadded_row_size,
                                            &padded_row_size,
                                            &skip_size,
                                            nullptr)) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "image size to large");
+    SetGLError(GL_INVALID_VALUE, func_name, "image size to large");
     return;
   }
 
   if (bound_pixel_unpack_buffer_) {
     base::CheckedNumeric<uint32_t> offset = ToGLuint(pixels);
     offset += skip_size;
     if (!offset.IsValid()) {
-      SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "skip size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "skip size too large");
       return;
     }
     helper_->TexSubImage2D(target, level, xoffset, yoffset, width, height,
                            format, type, 0, offset.ValueOrDefault(0), false);
     CheckGLError();
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexSubImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     if (unpack_row_length_ > 0 || unpack_image_height_ > 0 ||
         unpack_skip_pixels_ > 0 || unpack_skip_rows_ > 0 ||
         unpack_skip_images_ > 0) {
-      SetGLError(GL_INVALID_OPERATION, "glTexSubImage2D",
+      SetGLError(GL_INVALID_OPERATION, func_name,
                  "No ES3 pack parameters with pixel unpack transfer buffer.");
       return;
     }
     DCHECK_EQ(0u, skip_size);
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelTransferBufferIfValid(
-        bound_pixel_unpack_transfer_buffer_id_,
-        "glTexSubImage2D", offset, size);
+        bound_pixel_unpack_transfer_buffer_id_, func_name, offset, size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->TexSubImage2D(
           target, level, xoffset, yoffset, width, height, format, type,
           buffer->shm_id(), buffer->shm_offset() + offset, false);
       buffer->set_last_usage_token(helper_->InsertToken());
       CheckGLError();
     }
     return;
   }
 
@@ skipping 14 matching lines @@
     PixelStoreParams service_params;
     service_params.alignment = unpack_alignment_;
     if (!GLES2Util::ComputeImageDataSizesES3(width, height, 1,
                                              format, type,
                                              service_params,
                                              &size,
                                              nullptr,
                                              &service_padded_row_size,
                                              nullptr,
                                              nullptr)) {
-      SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "image size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "image size too large");
       return;
     }
   } else {
     service_padded_row_size = padded_row_size;
   }
 
   // advance pixels pointer past the skip rows and skip pixels
   pixels = reinterpret_cast<const int8_t*>(pixels) + skip_size;
 
   ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
   TexSubImage2DImpl(
       target, level, xoffset, yoffset, width, height, format, type,
       unpadded_row_size, pixels, padded_row_size, GL_FALSE, &buffer,
       service_padded_row_size);
   CheckGLError();
 }
 
 void GLES2Implementation::TexSubImage3D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
     GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type,
     const void* pixels) {
+  const char* func_name = "glTexSubImage3D";
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexSubImage3D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << xoffset << ", " << yoffset << ", " << zoffset << ", "
       << width << ", " << height << ", " << depth << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
 
   if (level < 0 || height < 0 || width < 0 || depth < 0 ||
       xoffset < 0 || yoffset < 0 || zoffset < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage3D", "dimension < 0");
+    SetGLError(GL_INVALID_VALUE, func_name, "dimension < 0");
+    return;
+  }
+  if ((unpack_skip_pixels_ + width >
+       (unpack_row_length_ ? unpack_row_length_ : width)) ||
+      (unpack_skip_rows_ + height >
+       (unpack_image_height_ ? unpack_image_height_ : height))) {
+    // This is WebGL 2 specific constraints, but we do it for all ES3 contexts.
+    SetGLError(GL_INVALID_OPERATION, func_name,
+               "invalid unpack params combination");
     return;
   }
 
   uint32_t size;
   uint32_t unpadded_row_size;
   uint32_t padded_row_size;
   uint32_t skip_size;
   PixelStoreParams params = GetUnpackParameters(k3D);
   if (!GLES2Util::ComputeImageDataSizesES3(width, height, depth,
                                            format, type,
                                            params,
                                            &size,
                                            &unpadded_row_size,
                                            &padded_row_size,
                                            &skip_size,
                                            nullptr)) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage3D", "image size to large");
+    SetGLError(GL_INVALID_VALUE, func_name, "image size to large");
     return;
   }
 
   if (bound_pixel_unpack_buffer_) {
     base::CheckedNumeric<uint32_t> offset = ToGLuint(pixels);
     offset += skip_size;
     if (!offset.IsValid()) {
-      SetGLError(GL_INVALID_VALUE, "glTexSubImage3D", "skip size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "skip size too large");
       return;
     }
     helper_->TexSubImage3D(
         target, level, xoffset, yoffset, zoffset, width, height, depth,
         format, type, 0, offset.ValueOrDefault(0), false);
     CheckGLError();
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexSubImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     if (unpack_row_length_ > 0 || unpack_image_height_ > 0 ||
         unpack_skip_pixels_ > 0 || unpack_skip_rows_ > 0 ||
         unpack_skip_images_ > 0) {
-      SetGLError(GL_INVALID_OPERATION, "glTexSubImage2D",
+      SetGLError(GL_INVALID_OPERATION, func_name,
                  "No ES3 pack parameters with pixel unpack transfer buffer.");
       return;
     }
     DCHECK_EQ(0u, skip_size);
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelTransferBufferIfValid(
-        bound_pixel_unpack_transfer_buffer_id_,
-        "glTexSubImage3D", offset, size);
+        bound_pixel_unpack_transfer_buffer_id_, func_name, offset, size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->TexSubImage3D(
           target, level, xoffset, yoffset, zoffset, width, height, depth,
           format, type, buffer->shm_id(), buffer->shm_offset() + offset, false);
       buffer->set_last_usage_token(helper_->InsertToken());
       CheckGLError();
     }
     return;
   }
 
@@ skipping 13 matching lines @@
     PixelStoreParams service_params;
     service_params.alignment = unpack_alignment_;
     if (!GLES2Util::ComputeImageDataSizesES3(width, height, depth,
                                              format, type,
                                              service_params,
                                              &size,
                                              nullptr,
                                              &service_padded_row_size,
                                              nullptr,
                                              nullptr)) {
-      SetGLError(GL_INVALID_VALUE, "glTexSubImage3D", "image size too large");
+      SetGLError(GL_INVALID_VALUE, func_name, "image size too large");
       return;
     }
   } else {
     service_padded_row_size = padded_row_size;
   }
 
   // advance pixels pointer past the skip images/rows/pixels
   pixels = reinterpret_cast<const int8_t*>(pixels) + skip_size;
 
   ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
@@ skipping 805 matching lines @@
     for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::ReadPixels(
     GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
     GLenum type, void* pixels) {
+  const char* func_name = "glReadPixels";
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glReadPixels("
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringReadPixelFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (width < 0 || height < 0) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
+    SetGLError(GL_INVALID_VALUE, func_name, "dimensions < 0");
     return;
   }
 
+  if (pack_skip_pixels_ + width >
+      (pack_row_length_ ? pack_row_length_ : width)) {
+    // This is WebGL 2 specific constraints, but we do it for all ES3 contexts.
+    SetGLError(GL_INVALID_OPERATION, func_name,
+               "invalid pack params combination");
+    return;
+  }
+
   // glReadPixel pads the size of each row of pixels by an amount specified by
   // glPixelStorei. So, we have to take that into account both in the fact that
   // the pixels returned from the ReadPixel command will include that padding
   // and that when we copy the results to the user's buffer we need to not
   // write those padding bytes but leave them as they are.
 
   TRACE_EVENT0("gpu", "GLES2::ReadPixels");
   typedef cmds::ReadPixels::Result Result;
 
   uint32_t size;
   uint32_t unpadded_row_size;
   uint32_t padded_row_size;
   uint32_t skip_size;
   PixelStoreParams params;
   params.alignment = pack_alignment_;
   params.row_length = pack_row_length_;
   params.skip_pixels = pack_skip_pixels_;
   params.skip_rows = pack_skip_rows_;
   if (!GLES2Util::ComputeImageDataSizesES3(width, height, 1,
                                            format, type,
                                            params,
                                            &size,
                                            &unpadded_row_size,
                                            &padded_row_size,
                                            &skip_size,
                                            nullptr)) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
+    SetGLError(GL_INVALID_VALUE, func_name, "size too large.");
     return;
   }
 
   if (bound_pixel_pack_buffer_) {
     base::CheckedNumeric<GLuint> offset = ToGLuint(pixels);
     offset += skip_size;
     if (!offset.IsValid()) {
-      SetGLError(GL_INVALID_VALUE, "glReadPixels", "skip size too large.");
+      SetGLError(GL_INVALID_VALUE, func_name, "skip size too large.");
       return;
     }
     helper_->ReadPixels(xoffset, yoffset, width, height, format, type, 0,
                         offset.ValueOrDefault(0), 0, 0, false);
     CheckGLError();
     return;
   }
 
   uint32_t service_padded_row_size = 0;
   if (pack_row_length_ > 0 && pack_row_length_ != width) {
     if (!GLES2Util::ComputeImagePaddedRowSize(width,
                                               format, type,
                                               pack_alignment_,
                                               &service_padded_row_size)) {
-      SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
+      SetGLError(GL_INVALID_VALUE, func_name, "size too large.");
       return;
     }
   } else {
     service_padded_row_size = padded_row_size;
   }
 
   if (bound_pixel_pack_transfer_buffer_id_) {
     if (pack_row_length_ > 0 || pack_skip_pixels_ > 0 || pack_skip_rows_ > 0) {
-      SetGLError(GL_INVALID_OPERATION, "glReadPixels",
+      SetGLError(GL_INVALID_OPERATION, func_name,
                  "No ES3 pack parameters with pixel pack transfer buffer.");
       return;
     }
     DCHECK_EQ(0u, skip_size);
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelTransferBufferIfValid(
-        bound_pixel_pack_transfer_buffer_id_, "glReadPixels", offset, size);
+        bound_pixel_pack_transfer_buffer_id_, func_name, offset, size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->ReadPixels(xoffset, yoffset, width, height, format, type,
                           buffer->shm_id(), buffer->shm_offset() + offset,
                           0, 0, true);
       CheckGLError();
     }
     return;
   }
 
   if (!pixels) {
-    SetGLError(GL_INVALID_OPERATION, "glReadPixels", "pixels = NULL");
+    SetGLError(GL_INVALID_OPERATION, func_name, "pixels = NULL");
     return;
   }
 
   int8_t* dest = reinterpret_cast<int8_t*>(pixels);
   // Advance pixels pointer past the skip rows and skip pixels
   dest += skip_size;
 
   // Transfer by rows.
   // The max rows we can transfer.
   GLsizei remaining_rows = height;
@@ skipping 2948 matching lines @@
   cached_extensions_.clear();
 }
 
 // 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