Refactor validation code so it can be modified at runtime....

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 1021 matching lines @@
 
   // Validates the program and location for a glGetUniform call and returns
   // a SizeResult setup to receive the result. Returns true if glGetUniform
   // should be called.
   bool GetUniformSetup(
       GLuint program, GLint location,
       uint32 shm_id, uint32 shm_offset,
       error::Error* error, GLuint* service_id, void** result,
       GLenum* result_type);
 
-  bool ValidateGLenumCompressedTextureInternalFormat(GLenum format);
-
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
        uint32 immediate_data_size,          \
        const gles2::name& args);            \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
@@ skipping 85 matching lines @@
   // The copy that is saved when SwapBuffers is called.
   scoped_ptr<Texture> offscreen_saved_color_texture_;
 
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
 
   // The last error message set.
   std::string last_error_;
 
   bool use_shader_translator_;
 
+  // Cached from the context group.
+  const Validators* validators_;
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   decoder_->ClearRealGLErrors();
@@ skipping 241 matching lines @@
       error_bits_(0),
       util_(0),  // TODO(gman): Set to actual num compress texture formats.
       pack_alignment_(4),
       unpack_alignment_(4),
       attrib_0_buffer_id_(0),
       attrib_0_size_(0),
       active_texture_unit_(0),
       black_2d_texture_id_(0),
       black_cube_texture_id_(0),
       anti_aliased_(false),
-      use_shader_translator_(true) {
+      use_shader_translator_(true),
+      validators_(group->validators()) {
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
 
   // The shader translator is not needed for EGL because it already uses the
   // GLSL ES syntax. It is translated for the unit tests because
   // GLES2DecoderWithShaderTest.GetShaderInfoLogValidArgs passes the empty
   // string to CompileShader and this is not a valid shader. TODO(apatrick):
   // fix this test.
@@ skipping 600 matching lines @@
   if (GetShaderInfo(client_id)) {
     return false;
   }
   GLuint service_id = glCreateShader(type);
   if (service_id != 0) {
     CreateShaderInfo(client_id, service_id, type);
   }
   return true;
 }
 
-bool GLES2DecoderImpl::ValidateGLenumCompressedTextureInternalFormat(GLenum) {
-  // TODO(gman): Add support for compressed texture formats.
-  return false;
-}
-
 void GLES2DecoderImpl::DoActiveTexture(GLenum texture_unit) {
   GLuint texture_index = texture_unit - GL_TEXTURE0;
   if (texture_index > group_->max_texture_units()) {
     SetGLError(GL_INVALID_ENUM, "glActiveTexture: texture_unit out of range.");
     return;
   }
   active_texture_unit_ = texture_index;
   glActiveTexture(texture_unit);
 }
 
@@ skipping 1102 matching lines @@
   GLenum type = c.type;
   int32 offset = c.index_offset;
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawElements: count < 0");
     return error::kNoError;
   }
   if (offset < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawElements: offset < 0");
     return error::kNoError;
   }
-  if (!ValidateGLenumDrawMode(mode)) {
+  if (!validators_->draw_mode.IsValid(mode)) {
     SetGLError(GL_INVALID_ENUM, "glDrawElements: mode GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLenumIndexType(type)) {
+  if (!validators_->index_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glDrawElements: type GL_INVALID_ENUM");
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
   if (!bound_element_array_buffer_->GetMaxValueForRange(
       offset, count, type, &max_vertex_accessed)) {
     SetGLError(GL_INVALID_OPERATION,
                "glDrawElements: range out of bounds for buffer");
     return error::kNoError;
@@ skipping 505 matching lines @@
     return error::kNoError;
   }
 
   GLuint indx = c.indx;
   GLint size = c.size;
   GLenum type = c.type;
   GLboolean normalized = c.normalized;
   GLsizei stride = c.stride;
   GLsizei offset = c.offset;
   const void* ptr = reinterpret_cast<const void*>(offset);
-  if (!ValidateGLenumVertexAttribType(type)) {
+  if (!validators_->vertex_attrib_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM,
                "glVertexAttribPointer: type GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLintVertexAttribSize(size)) {
+  if (!validators_->vertex_attrib_size.IsValid(size)) {
     SetGLError(GL_INVALID_ENUM,
                "glVertexAttribPointer: size GL_INVALID_VALUE");
     return error::kNoError;
   }
   if (indx >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttribPointer: index out of range");
     return error::kNoError;
   }
   if (stride < 0) {
     SetGLError(GL_INVALID_VALUE,
@@ skipping 48 matching lines @@
     return error::kOutOfBounds;
   }
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
   Result* result = GetSharedMemoryAs<Result*>(
         c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!pixels || !result) {
     return error::kOutOfBounds;
   }
 
-  if (!ValidateGLenumReadPixelFormat(format)) {
+  if (!validators_->read_pixel_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM, "glReadPixels: format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLenumPixelType(type)) {
+  if (!validators_->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glReadPixels: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   CopyRealGLErrorsToWrapper();
 
   // Get the size of the current fbo or backbuffer.
@@ skipping 62 matching lines @@
   } else {
     SetGLError(error, NULL);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePixelStorei(
     uint32 immediate_data_size, const gles2::PixelStorei& c) {
   GLenum pname = c.pname;
   GLenum param = c.param;
-  if (!ValidateGLenumPixelStore(pname)) {
+  if (!validators_->pixel_store.IsValid(pname)) {
     SetGLError(GL_INVALID_ENUM, "glPixelStorei: pname GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLintPixelStoreAlignment(param)) {
+  if (!validators_->pixel_store_alignment.IsValid(param)) {
     SetGLError(GL_INVALID_VALUE, "glPixelSTore: param GL_INVALID_VALUE");
     return error::kNoError;
   }
   glPixelStorei(pname, param);
   switch (pname) {
   case GL_PACK_ALIGNMENT:
       pack_alignment_ = param;
       break;
   case GL_UNPACK_ALIGNMENT:
       unpack_alignment_ = param;
@@ skipping 135 matching lines @@
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetString(
     uint32 immediate_data_size, const gles2::GetString& c) {
   GLenum name = static_cast<GLenum>(c.name);
-  if (!ValidateGLenumStringType(name)) {
+  if (!validators_->string_type.IsValid(name)) {
     SetGLError(GL_INVALID_ENUM, "glGetString: name GL_INVALID_ENUM");
     return error::kNoError;
   }
   const char* gl_str = reinterpret_cast<const char*>(glGetString(name));
   const char* str = NULL;
   switch (name) {
     case GL_VERSION:
       str = "OpenGL ES 2.0 Chromium";
       break;
     case GL_SHADING_LANGUAGE_VERSION:
       str = "OpenGL ES GLSL ES 1.0 Chromium";
       break;
     case GL_EXTENSIONS:
       str = "";
       break;
     default:
       str = gl_str;
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
   bucket->SetFromString(str);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBufferData(
     GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) {
-  if (!ValidateGLenumBufferTarget(target)) {
+  if (!validators_->buffer_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glBufferData: target GL_INVALID_ENUM");
     return;
   }
-  if (!ValidateGLenumBufferUsage(usage)) {
+  if (!validators_->buffer_usage.IsValid(usage)) {
     SetGLError(GL_INVALID_ENUM, "glBufferData: usage GL_INVALID_ENUM");
     return;
   }
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferData: size < 0");
     return;
   }
   BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glBufferData: unknown buffer");
@@ skipping 66 matching lines @@
 error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLsizei image_size,
   const void* data) {
   // TODO(gman): Validate image_size is correct for width, height and format.
-  if (!ValidateGLenumTextureTarget(target)) {
+  if (!validators_->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM,
                "glCompressedTexImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLenumCompressedTextureInternalFormat(internal_format)) {
+  if (!validators_->compressed_texture_format.IsValid(
+      internal_format)) {
     SetGLError(GL_INVALID_ENUM,
                "glCompressedTexImage2D: internal_format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D: dimensions out of range");
     return error::kNoError;
   }
@@ skipping 78 matching lines @@
   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);
   Bucket* bucket = GetBucket(c.bucket_id);
   uint32 data_size = bucket->size();
   GLsizei imageSize = data_size;
   const void* data = bucket->GetData(0, data_size);
-  if (!ValidateGLenumTextureTarget(target)) {
+  if (!validators_->texture_target.IsValid(target)) {
     SetGLError(
         GL_INVALID_ENUM, "glCompressedTexSubImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
+  if (!validators_->compressed_texture_format.IsValid(format)) {
+    SetGLError(GL_INVALID_ENUM,
+               "glCompressedTexSubImage2D: format GL_INVALID_ENUM");
+    return error::kNoError;
+  }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: height < 0");
     return error::kNoError;
   }
   if (imageSize < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: imageSize < 0");
     return error::kNoError;
   }
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::DoTexImage2D(
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLenum format,
   GLenum type,
   const void* pixels,
   uint32 pixels_size) {
-  if (!ValidateGLenumTextureTarget(target)) {
+  if (!validators_->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glTexImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLenumTextureFormat(internal_format)) {
+  if (!validators_->texture_format.IsValid(internal_format)) {
     SetGLError(GL_INVALID_ENUM,
                "glTexImage2D: internal_format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLenumTextureFormat(format)) {
+  if (!validators_->texture_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM, "glTexImage2D: format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLenumPixelType(type)) {
+  if (!validators_->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glTexImage2D: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D: dimensions out of range");
     return error::kNoError;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
@@ skipping 78 matching lines @@
   typedef gles2::GetVertexAttribPointerv::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
         c.pointer_shm_id, c.pointer_shm_offset, Result::ComputeSize(1));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
-  if (!ValidateGLenumVertexPointer(pname)) {
+  if (!validators_->vertex_pointer.IsValid(pname)) {
     SetGLError(GL_INVALID_ENUM,
                "glGetVertexAttribPointerv: pname GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetVertexAttribPointerv: index out of range.");
     return error::kNoError;
   }
   result->SetNumResults(1);
@@ skipping 109 matching lines @@
   typedef gles2::GetShaderPrecisionFormat::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
     return error::kInvalidArguments;
   }
-  if (!ValidateGLenumShaderType(shader_type)) {
+  if (!validators_->shader_type.IsValid(shader_type)) {
     SetGLError(GL_INVALID_ENUM,
                "glGetShaderPrecisionFormat: shader_type GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!ValidateGLenumShaderPrecision(precision_type)) {
+  if (!validators_->shader_precision.IsValid(precision_type)) {
     SetGLError(GL_INVALID_ENUM,
                "glGetShaderPrecisionFormat: precision_type GL_INVALID_ENUM");
     return error::kNoError;
   }
 
   result->success = 1;  // true
   switch (precision_type) {
     case GL_LOW_INT:
     case GL_MEDIUM_INT:
     case GL_HIGH_INT:
@@ skipping 224 matching lines @@
   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