Implements Validation for all GLenum arguments and ...

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2006-2009 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 <vector>
 #include <string>
 #include <map>
 #include <build/build_config.h>
 #include "base/scoped_ptr.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/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "gpu/command_buffer/service/gles2_cmd_validation.h"
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 // Returns the address of the first byte after a struct.
 template <typename T>
 const void* AddressAfterStruct(const T& pod) {
   return reinterpret_cast<const uint8*>(&pod) + sizeof(pod);
@@ skipping 247 matching lines @@
 
   // Wrapper for glCreateProgram
   void CreateProgramHelper(GLuint client_id);
 
   // Wrapper for glCreateShader
   void CreateShaderHelper(GLenum type, GLuint client_id);
 
   // Wrapper for glBindBuffer since we need to track the current targets.
   void DoBindBuffer(GLenum target, GLuint buffer);
 
-  // Wrapper for glDeleteProgram.
-  void DoDeleteProgram(GLuint program);
-
-  // Wrapper for glDeleteShader.
-  void DoDeleteShader(GLuint shader);
-
   // Swaps the buffers (copies/renders to the current window).
   void DoSwapBuffers();
 
   // Gets the GLError through our wrapper.
   GLenum GetGLError();
 
   // Sets our wrapper for the GLError.
   void SetGLError(GLenum error);
 
   // Generate a member function prototype for each command in an automated and
@@ skipping 391 matching lines @@
       }
     } else {
       result = parse_error::kParseInvalidArguments;
     }
   } else {
     result = DoCommonCommand(command, arg_count, cmd_data);
   }
   return result;
 }
 
-}  // namespace gles2
-}  // namespace gpu
-
-// This is included so the compiler will make these inline.
-#include "gpu/command_buffer/service/gles2_cmd_decoder_validate.h"
-
-namespace gpu {
-namespace gles2 {
-
 void GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
   // TODO(gman): verify client_id is unused.
   GLuint service_id = glCreateProgram();
   if (service_id) {
     id_map_.AddMapping(client_id, service_id);
   }
 }
 
 void GLES2DecoderImpl::CreateShaderHelper(GLenum type, GLuint client_id) {
   // TODO(gman): verify client_id is unused.
@@ skipping 10 matching lines @@
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_ = buffer;
       break;
     default:
       break;
   }
   glBindBuffer(target, buffer);
 }
 
-void GLES2DecoderImpl::DoDeleteProgram(GLuint program) {
+parse_error::ParseError GLES2DecoderImpl::HandleDeleteShader(
+    uint32 immediate_data_size, const gles2::DeleteShader& c) {
+  GLuint shader = c.shader;
   GLuint service_id;
-  if (id_map_.GetServiceId(program, &service_id)) {
-    glDeleteProgram(service_id);
-    id_map_.RemoveMapping(program, service_id);
+  if (!id_map_.GetServiceId(shader, &service_id)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
   }
+  glDeleteProgram(service_id);
+  id_map_.RemoveMapping(shader, service_id);
+  return parse_error::kParseNoError;
 }
 
-void GLES2DecoderImpl::DoDeleteShader(GLuint shader) {
+parse_error::ParseError GLES2DecoderImpl::HandleDeleteProgram(
+    uint32 immediate_data_size, const gles2::DeleteProgram& c) {
+  GLuint program = c.program;
   GLuint service_id;
-  if (id_map_.GetServiceId(shader, &service_id)) {
-    glDeleteProgram(service_id);
-    id_map_.RemoveMapping(shader, service_id);
+  if (!id_map_.GetServiceId(program, &service_id)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
   }
+  glDeleteProgram(service_id);
+  id_map_.RemoveMapping(program, service_id);
+  return parse_error::kParseNoError;
 }
 
 // NOTE: If you need to know the results of SwapBuffers (like losing
 //    the context) then add a new command. Do NOT make SwapBuffers synchronous.
 void GLES2DecoderImpl::DoSwapBuffers() {
 #ifdef OS_WIN
   ::SwapBuffers(device_context_);
 #endif
 
 #ifdef OS_LINUX
@@ skipping 25 matching lines @@
 void GLES2DecoderImpl::SetGLError(GLenum error) {
   error_bits_ |= GLErrorToErrorBit(error);
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDrawElements(
     uint32 immediate_data_size, const gles2::DrawElements& c) {
   if (bound_element_array_buffer_ != 0) {
     GLenum mode = c.mode;
     GLsizei count = c.count;
     GLenum type = c.type;
-    const GLvoid* indices = reinterpret_cast<const GLvoid*>(c.index_offset);
-    glDrawElements(mode, count, type, indices);
+    if (!ValidateGLenumDrawMode(mode) ||
+        !ValidateGLenumIndexType(type)) {
+      SetGLError(GL_INVALID_VALUE);
+    } else {
+      const GLvoid* indices = reinterpret_cast<const GLvoid*>(c.index_offset);
+      // TODO(gman): Validate indices
+      // TOOD(gman): Validate all attribs current program needs are setup.
+      glDrawElements(mode, count, type, indices);
+    }
   } else {
     SetGLError(GL_INVALID_VALUE);
   }
   return parse_error::kParseNoError;
 }
 
 namespace {
 
 // Calls glShaderSource for the various versions of the ShaderSource command.
 // Assumes that data / data_size points to a piece of memory that is in range
@@ skipping 28 matching lines @@
     uint32 immediate_data_size, const gles2::ShaderSource& c) {
   GLuint shader;
   if (!id_map_.GetServiceId(c.shader, &shader)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLsizei count = c.count;
   uint32 data_size = c.data_size;
   const char** data = GetSharedMemoryAs<const char**>(
       c.data_shm_id, c.data_shm_offset, data_size);
-  parse_error::ParseError result =
-      // TODO(gman): Manually implement validation.
-      ValidateShaderSource(
-          this, immediate_data_size, shader, count, data,
-          reinterpret_cast<const GLint*>(1));
-  if (result != parse_error::kParseNoError) {
-    return result;
+  if (!data) {
+    return parse_error::kParseOutOfBounds;
   }
   return ShaderSourceHelper(
       shader, count, reinterpret_cast<const char*>(data), data_size);
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleShaderSourceImmediate(
   uint32 immediate_data_size, const gles2::ShaderSourceImmediate& c) {
   GLuint shader;
   if (!id_map_.GetServiceId(c.shader, &shader)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLsizei count = c.count;
   uint32 data_size = c.data_size;
   // TODO(gman): need to check that data_size is in range for arg_count.
   const char** data = GetImmediateDataAs<const char**>(c);
-  parse_error::ParseError result =
-      ValidateShaderSourceImmediate(
-          this, immediate_data_size, shader, count, data, NULL);
-  if (result != parse_error::kParseNoError) {
-    return result;
+  if (!data) {
+    return parse_error::kParseOutOfBounds;
   }
   return ShaderSourceHelper(
       shader, count, reinterpret_cast<const char*>(data), data_size);
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleVertexAttribPointer(
     uint32 immediate_data_size, const gles2::VertexAttribPointer& c) {
   if (bound_array_buffer_ != 0) {
     GLuint indx = c.indx;
     GLint size = c.size;
     GLenum type = c.type;
     GLboolean normalized = c.normalized;
     GLsizei stride = c.stride;
     GLuint offset = c.offset;
     const void* ptr = reinterpret_cast<const void*>(c.offset);
     // TODO(gman): Do manual validation.
-    parse_error::ParseError result =
-        ValidateVertexAttribPointer(
-            this, immediate_data_size, indx, size, type, normalized, stride,
-            reinterpret_cast<const void*>(1));
-    if (result != parse_error::kParseNoError) {
-      return result;
+    if (!ptr) {
+      return parse_error::kParseOutOfBounds;
+    }
+    if (!ValidateGLenumVertexAttribType(type) ||
+        !ValidateGLenumVertexAttribSize(size)) {
+      SetGLError(GL_INVALID_VALUE);
+      return parse_error::kParseNoError;
     }
     glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
   } else {
     SetGLError(GL_INVALID_VALUE);
   }
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleReadPixels(
     uint32 immediate_data_size, const gles2::ReadPixels& c) {
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   uint32 pixels_size = GLES2Util::ComputeImageDataSize(
       width, height, format, type, pack_alignment_);
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
-  parse_error::ParseError result = ValidateReadPixels(
-      this, immediate_data_size, x, y, width, height, format, type, pixels);
-  if (result != parse_error::kParseNoError) {
-    return result;
+  if (!pixels) {
+    return parse_error::kParseOutOfBounds;
+  }
+  if (!ValidateGLenumReadPixelFormat(format) ||
+      !ValidateGLenumPixelType(type)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
   }
   glReadPixels(x, y, width, height, format, type, pixels);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandlePixelStorei(
     uint32 immediate_data_size, const gles2::PixelStorei& c) {
   GLenum pname = c.pname;
   GLenum param = c.param;
-  parse_error::ParseError result =
-    ValidatePixelStorei(this, immediate_data_size, pname, param);
-  if (result != parse_error::kParseNoError) {
-    return result;
+  if (!ValidateGLenumPixelStore(pname) ||
+      !ValidateGLenumPixelStoreAlignment(param)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
   }
   glPixelStorei(pname, param);
   switch (pname) {
   case GL_PACK_ALIGNMENT:
       pack_alignment_ = param;
       break;
   case GL_UNPACK_ALIGNMENT:
       unpack_alignment_ = param;
       break;
   default:
@@ skipping 89 matching lines @@
 parse_error::ParseError 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);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(data_shm_id, data_shm_offset, size);
-    parse_error::ParseError result =
-        ValidateBufferData(this, immediate_data_size, target, size, data,
-                           usage);
-    if (result != parse_error::kParseNoError) {
-      return result;
+    if (!data) {
+      return parse_error::kParseOutOfBounds;
     }
   }
   // TODO(gman): Validate case where data is NULL.
+  if (!ValidateGLenumBufferTarget(target) ||
+      !ValidateGLenumBufferUsage(usage)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
+  }
   glBufferData(target, size, data, usage);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleBufferDataImmediate(
     uint32 immediate_data_size, const gles2::BufferDataImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   const void* data = GetImmediateDataAs<const void*>(c);
   GLenum usage = static_cast<GLenum>(c.usage);
-  // Immediate version.
+  if (!ValidateGLenumBufferTarget(target) ||
+      !ValidateGLenumBufferUsage(usage)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
+  }
   // TODO(gman): Handle case where data is NULL.
-  parse_error::ParseError result =
-      ValidateBufferDataImmediate(this, immediate_data_size, target, size, data,
-                                  usage);
-  if (result != parse_error::kParseNoError) {
-    return result;
-  }
   glBufferData(target, size, data, usage);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCompressedTexImage2D(
     uint32 immediate_data_size, const gles2::CompressedTexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
   uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
   uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(
         data_shm_id, data_shm_offset, image_size);
-    parse_error::ParseError result =
-        ValidateCompressedTexImage2D(
-            this, immediate_data_size, target, level, internal_format, width,
-            height, border, image_size, data);
-    if (result != parse_error::kParseNoError) {
-      return result;
+    if (!data) {
+      return parse_error::kParseOutOfBounds;
     }
   }
+  // TODO(gman): Validate internal_format
+  if (!ValidateGLenumTextureTarget(target)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
+  }
   // TODO(gman): Validate case where data is NULL.
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCompressedTexImage2DImmediate(
     uint32 immediate_data_size, const gles2::CompressedTexImage2DImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
   const void* data = GetImmediateDataAs<const void*>(c);
   // Immediate version.
   // TODO(gman): Handle case where data is NULL.
-  parse_error::ParseError result =
-      ValidateCompressedTexImage2DImmediate(
-          this, immediate_data_size, target, level, internal_format, width,
-          height, border, image_size, data);
-  if (result != parse_error::kParseNoError) {
-    return result;
+  if (!data) {
+    return parse_error::kParseOutOfBounds;
+  }
+  // TODO(gman): Validate internal_format
+  if (!ValidateGLenumTextureTarget(target)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
   }
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleTexImage2D(
     uint32 immediate_data_size, const gles2::TexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   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 = GLES2Util::ComputeImageDataSize(
       width, height, format, type, unpack_alignment_);
   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);
-    parse_error::ParseError result =
-        ValidateTexImage2D(
-            this, immediate_data_size, target, level, internal_format, width,
-            height, border, format, type, pixels);
-    if (result != parse_error::kParseNoError) {
-      return result;
+    if (!pixels) {
+      return parse_error::kParseOutOfBounds;
     }
   }
+  if (!ValidateGLenumTextureTarget(target) ||
+      !ValidateGLenumTextureFormat(internal_format) ||
+      !ValidateGLenumTextureFormat(format) ||
+      !ValidateGLenumPixelType(type)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
+  }
   // TODO(gman): Validate case where data is NULL.
   glTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleTexImage2DImmediate(
     uint32 immediate_data_size, const gles2::TexImage2DImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
-  GLint internalformat = static_cast<GLint>(c.internalformat);
+  GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   const void* pixels = GetImmediateDataAs<const void*>(c);
   // Immediate version.
   // TODO(gman): Handle case where data is NULL.
-  parse_error::ParseError result =
-      ValidateTexImage2DImmediate(
-          this, immediate_data_size, target, level, internalformat, width,
-          height, border, format, type, pixels);
-  if (result != parse_error::kParseNoError) {
-    return result;
+  if (!pixels) {
+    return parse_error::kParseOutOfBounds;
+  }
+  if (!ValidateGLenumTextureTarget(target) ||
+      !ValidateGLenumTextureFormat(internal_format) ||
+      !ValidateGLenumTextureFormat(format) ||
+      !ValidateGLenumPixelType(type)) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
   }
   glTexImage2D(
-      target, level, internalformat, width, height, border, format, type,
+      target, level, internal_format, width, height, border, format, type,
       pixels);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetVertexAttribPointerv(
     uint32 immediate_data_size, const gles2::GetVertexAttribPointerv& c) {
   // TODO(gman): Implement.
   return parse_error::kParseNoError;
 }
 
@@ skipping 34 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