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

gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h

Index: gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
===================================================================
--- gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h	(revision 49807)
+++ gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h	(working copy)
@@ -7,620 +7,507 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_VALIDATION_IMPLEMENTATION_AUTOGEN_H_  // NOLINT
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_VALIDATION_IMPLEMENTATION_AUTOGEN_H_  // NOLINT
 
-bool ValidateGLenumAttachment(GLenum value) {
-  switch (value) {
-    case GL_COLOR_ATTACHMENT0:
-    case GL_DEPTH_ATTACHMENT:
-    case GL_STENCIL_ATTACHMENT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_attachment_table[] = {
+  GL_COLOR_ATTACHMENT0,
+  GL_DEPTH_ATTACHMENT,
+  GL_STENCIL_ATTACHMENT,
+};
 
-bool ValidateGLenumBufferParameter(GLenum value) {
-  switch (value) {
-    case GL_BUFFER_SIZE:
-    case GL_BUFFER_USAGE:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_buffer_parameter_table[] = {
+  GL_BUFFER_SIZE,
+  GL_BUFFER_USAGE,
+};
 
-bool ValidateGLenumBufferTarget(GLenum value) {
-  switch (value) {
-    case GL_ARRAY_BUFFER:
-    case GL_ELEMENT_ARRAY_BUFFER:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_buffer_target_table[] = {
+  GL_ARRAY_BUFFER,
+  GL_ELEMENT_ARRAY_BUFFER,
+};
 
-bool ValidateGLenumBufferUsage(GLenum value) {
-  switch (value) {
-    case GL_STREAM_DRAW:
-    case GL_STATIC_DRAW:
-    case GL_DYNAMIC_DRAW:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_buffer_usage_table[] = {
+  GL_STREAM_DRAW,
+  GL_STATIC_DRAW,
+  GL_DYNAMIC_DRAW,
+};
 
-bool ValidateGLenumCapability(GLenum value) {
-  switch (value) {
-    case GL_BLEND:
-    case GL_CULL_FACE:
-    case GL_DEPTH_TEST:
-    case GL_DITHER:
-    case GL_POLYGON_OFFSET_FILL:
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-    case GL_SAMPLE_COVERAGE:
-    case GL_SCISSOR_TEST:
-    case GL_STENCIL_TEST:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_capability_table[] = {
+  GL_BLEND,
+  GL_CULL_FACE,
+  GL_DEPTH_TEST,
+  GL_DITHER,
+  GL_POLYGON_OFFSET_FILL,
+  GL_SAMPLE_ALPHA_TO_COVERAGE,
+  GL_SAMPLE_COVERAGE,
+  GL_SCISSOR_TEST,
+  GL_STENCIL_TEST,
+};
 
-bool ValidateGLenumCmpFunction(GLenum value) {
-  switch (value) {
-    case GL_NEVER:
-    case GL_LESS:
-    case GL_EQUAL:
-    case GL_LEQUAL:
-    case GL_GREATER:
-    case GL_NOTEQUAL:
-    case GL_GEQUAL:
-    case GL_ALWAYS:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_cmp_function_table[] = {
+  GL_NEVER,
+  GL_LESS,
+  GL_EQUAL,
+  GL_LEQUAL,
+  GL_GREATER,
+  GL_NOTEQUAL,
+  GL_GEQUAL,
+  GL_ALWAYS,
+};
 
-bool ValidateGLenumCompressedTextureFormat(GLenum value) {
-  switch (value) {
-    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_compressed_texture_format_table[] = {
+  GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+  GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+};
 
-bool ValidateGLenumDrawMode(GLenum value) {
-  switch (value) {
-    case GL_POINTS:
-    case GL_LINE_STRIP:
-    case GL_LINE_LOOP:
-    case GL_LINES:
-    case GL_TRIANGLE_STRIP:
-    case GL_TRIANGLE_FAN:
-    case GL_TRIANGLES:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_draw_mode_table[] = {
+  GL_POINTS,
+  GL_LINE_STRIP,
+  GL_LINE_LOOP,
+  GL_LINES,
+  GL_TRIANGLE_STRIP,
+  GL_TRIANGLE_FAN,
+  GL_TRIANGLES,
+};
 
-bool ValidateGLenumDstBlendFactor(GLenum value) {
-  switch (value) {
-    case GL_ZERO:
-    case GL_ONE:
-    case GL_SRC_COLOR:
-    case GL_ONE_MINUS_SRC_COLOR:
-    case GL_DST_COLOR:
-    case GL_ONE_MINUS_DST_COLOR:
-    case GL_SRC_ALPHA:
-    case GL_ONE_MINUS_SRC_ALPHA:
-    case GL_DST_ALPHA:
-    case GL_ONE_MINUS_DST_ALPHA:
-    case GL_CONSTANT_COLOR:
-    case GL_ONE_MINUS_CONSTANT_COLOR:
-    case GL_CONSTANT_ALPHA:
-    case GL_ONE_MINUS_CONSTANT_ALPHA:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_dst_blend_factor_table[] = {
+  GL_ZERO,
+  GL_ONE,
+  GL_SRC_COLOR,
+  GL_ONE_MINUS_SRC_COLOR,
+  GL_DST_COLOR,
+  GL_ONE_MINUS_DST_COLOR,
+  GL_SRC_ALPHA,
+  GL_ONE_MINUS_SRC_ALPHA,
+  GL_DST_ALPHA,
+  GL_ONE_MINUS_DST_ALPHA,
+  GL_CONSTANT_COLOR,
+  GL_ONE_MINUS_CONSTANT_COLOR,
+  GL_CONSTANT_ALPHA,
+  GL_ONE_MINUS_CONSTANT_ALPHA,
+};
 
-bool ValidateGLenumEquation(GLenum value) {
-  switch (value) {
-    case GL_FUNC_ADD:
-    case GL_FUNC_SUBTRACT:
-    case GL_FUNC_REVERSE_SUBTRACT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_equation_table[] = {
+  GL_FUNC_ADD,
+  GL_FUNC_SUBTRACT,
+  GL_FUNC_REVERSE_SUBTRACT,
+};
 
-bool ValidateGLenumFaceMode(GLenum value) {
-  switch (value) {
-    case GL_CW:
-    case GL_CCW:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_face_mode_table[] = {
+  GL_CW,
+  GL_CCW,
+};
 
-bool ValidateGLenumFaceType(GLenum value) {
-  switch (value) {
-    case GL_FRONT:
-    case GL_BACK:
-    case GL_FRONT_AND_BACK:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_face_type_table[] = {
+  GL_FRONT,
+  GL_BACK,
+  GL_FRONT_AND_BACK,
+};
 
-bool ValidateGLbooleanFalse(GLenum value) {
-  switch (value) {
-    case false:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLboolean valid_false_only_table[] = {
+  false,
+};
 
-bool ValidateGLenumFrameBufferParameter(GLenum value) {
-  switch (value) {
-    case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
-    case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
-    case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
-    case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_frame_buffer_parameter_table[] = {
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE,
+};
 
-bool ValidateGLenumFrameBufferTarget(GLenum value) {
-  switch (value) {
-    case GL_FRAMEBUFFER:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_frame_buffer_target_table[] = {
+  GL_FRAMEBUFFER,
+};
 
-bool ValidateGLenumGLState(GLenum value) {
-  switch (value) {
-    case GL_ACTIVE_TEXTURE:
-    case GL_ALIASED_LINE_WIDTH_RANGE:
-    case GL_ALIASED_POINT_SIZE_RANGE:
-    case GL_ALPHA_BITS:
-    case GL_ARRAY_BUFFER_BINDING:
-    case GL_BLEND:
-    case GL_BLEND_COLOR:
-    case GL_BLEND_DST_ALPHA:
-    case GL_BLEND_DST_RGB:
-    case GL_BLEND_EQUATION_ALPHA:
-    case GL_BLEND_EQUATION_RGB:
-    case GL_BLEND_SRC_ALPHA:
-    case GL_BLEND_SRC_RGB:
-    case GL_BLUE_BITS:
-    case GL_COLOR_CLEAR_VALUE:
-    case GL_COLOR_WRITEMASK:
-    case GL_COMPRESSED_TEXTURE_FORMATS:
-    case GL_CULL_FACE:
-    case GL_CULL_FACE_MODE:
-    case GL_CURRENT_PROGRAM:
-    case GL_DEPTH_BITS:
-    case GL_DEPTH_CLEAR_VALUE:
-    case GL_DEPTH_FUNC:
-    case GL_DEPTH_RANGE:
-    case GL_DEPTH_TEST:
-    case GL_DEPTH_WRITEMASK:
-    case GL_DITHER:
-    case GL_ELEMENT_ARRAY_BUFFER_BINDING:
-    case GL_FRAMEBUFFER_BINDING:
-    case GL_FRONT_FACE:
-    case GL_GENERATE_MIPMAP_HINT:
-    case GL_GREEN_BITS:
-    case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
-    case GL_IMPLEMENTATION_COLOR_READ_TYPE:
-    case GL_LINE_WIDTH:
-    case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
-    case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
-    case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
-    case GL_MAX_RENDERBUFFER_SIZE:
-    case GL_MAX_TEXTURE_IMAGE_UNITS:
-    case GL_MAX_TEXTURE_SIZE:
-    case GL_MAX_VARYING_VECTORS:
-    case GL_MAX_VERTEX_ATTRIBS:
-    case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
-    case GL_MAX_VERTEX_UNIFORM_VECTORS:
-    case GL_MAX_VIEWPORT_DIMS:
-    case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
-    case GL_NUM_SHADER_BINARY_FORMATS:
-    case GL_PACK_ALIGNMENT:
-    case GL_POLYGON_OFFSET_FACTOR:
-    case GL_POLYGON_OFFSET_FILL:
-    case GL_POLYGON_OFFSET_UNITS:
-    case GL_RED_BITS:
-    case GL_RENDERBUFFER_BINDING:
-    case GL_SAMPLE_BUFFERS:
-    case GL_SAMPLE_COVERAGE_INVERT:
-    case GL_SAMPLE_COVERAGE_VALUE:
-    case GL_SAMPLES:
-    case GL_SCISSOR_BOX:
-    case GL_SCISSOR_TEST:
-    case GL_SHADER_BINARY_FORMATS:
-    case GL_SHADER_COMPILER:
-    case GL_STENCIL_BACK_FAIL:
-    case GL_STENCIL_BACK_FUNC:
-    case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-    case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-    case GL_STENCIL_BACK_REF:
-    case GL_STENCIL_BACK_VALUE_MASK:
-    case GL_STENCIL_BACK_WRITEMASK:
-    case GL_STENCIL_BITS:
-    case GL_STENCIL_CLEAR_VALUE:
-    case GL_STENCIL_FAIL:
-    case GL_STENCIL_FUNC:
-    case GL_STENCIL_PASS_DEPTH_FAIL:
-    case GL_STENCIL_PASS_DEPTH_PASS:
-    case GL_STENCIL_REF:
-    case GL_STENCIL_TEST:
-    case GL_STENCIL_VALUE_MASK:
-    case GL_STENCIL_WRITEMASK:
-    case GL_SUBPIXEL_BITS:
-    case GL_TEXTURE_BINDING_2D:
-    case GL_TEXTURE_BINDING_CUBE_MAP:
-    case GL_UNPACK_ALIGNMENT:
-    case GL_VIEWPORT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_g_l_state_table[] = {
+  GL_ACTIVE_TEXTURE,
+  GL_ALIASED_LINE_WIDTH_RANGE,
+  GL_ALIASED_POINT_SIZE_RANGE,
+  GL_ALPHA_BITS,
+  GL_ARRAY_BUFFER_BINDING,
+  GL_BLEND,
+  GL_BLEND_COLOR,
+  GL_BLEND_DST_ALPHA,
+  GL_BLEND_DST_RGB,
+  GL_BLEND_EQUATION_ALPHA,
+  GL_BLEND_EQUATION_RGB,
+  GL_BLEND_SRC_ALPHA,
+  GL_BLEND_SRC_RGB,
+  GL_BLUE_BITS,
+  GL_COLOR_CLEAR_VALUE,
+  GL_COLOR_WRITEMASK,
+  GL_COMPRESSED_TEXTURE_FORMATS,
+  GL_CULL_FACE,
+  GL_CULL_FACE_MODE,
+  GL_CURRENT_PROGRAM,
+  GL_DEPTH_BITS,
+  GL_DEPTH_CLEAR_VALUE,
+  GL_DEPTH_FUNC,
+  GL_DEPTH_RANGE,
+  GL_DEPTH_TEST,
+  GL_DEPTH_WRITEMASK,
+  GL_DITHER,
+  GL_ELEMENT_ARRAY_BUFFER_BINDING,
+  GL_FRAMEBUFFER_BINDING,
+  GL_FRONT_FACE,
+  GL_GENERATE_MIPMAP_HINT,
+  GL_GREEN_BITS,
+  GL_IMPLEMENTATION_COLOR_READ_FORMAT,
+  GL_IMPLEMENTATION_COLOR_READ_TYPE,
+  GL_LINE_WIDTH,
+  GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE,
+  GL_MAX_FRAGMENT_UNIFORM_VECTORS,
+  GL_MAX_RENDERBUFFER_SIZE,
+  GL_MAX_TEXTURE_IMAGE_UNITS,
+  GL_MAX_TEXTURE_SIZE,
+  GL_MAX_VARYING_VECTORS,
+  GL_MAX_VERTEX_ATTRIBS,
+  GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,
+  GL_MAX_VERTEX_UNIFORM_VECTORS,
+  GL_MAX_VIEWPORT_DIMS,
+  GL_NUM_COMPRESSED_TEXTURE_FORMATS,
+  GL_NUM_SHADER_BINARY_FORMATS,
+  GL_PACK_ALIGNMENT,
+  GL_POLYGON_OFFSET_FACTOR,
+  GL_POLYGON_OFFSET_FILL,
+  GL_POLYGON_OFFSET_UNITS,
+  GL_RED_BITS,
+  GL_RENDERBUFFER_BINDING,
+  GL_SAMPLE_BUFFERS,
+  GL_SAMPLE_COVERAGE_INVERT,
+  GL_SAMPLE_COVERAGE_VALUE,
+  GL_SAMPLES,
+  GL_SCISSOR_BOX,
+  GL_SCISSOR_TEST,
+  GL_SHADER_BINARY_FORMATS,
+  GL_SHADER_COMPILER,
+  GL_STENCIL_BACK_FAIL,
+  GL_STENCIL_BACK_FUNC,
+  GL_STENCIL_BACK_PASS_DEPTH_FAIL,
+  GL_STENCIL_BACK_PASS_DEPTH_PASS,
+  GL_STENCIL_BACK_REF,
+  GL_STENCIL_BACK_VALUE_MASK,
+  GL_STENCIL_BACK_WRITEMASK,
+  GL_STENCIL_BITS,
+  GL_STENCIL_CLEAR_VALUE,
+  GL_STENCIL_FAIL,
+  GL_STENCIL_FUNC,
+  GL_STENCIL_PASS_DEPTH_FAIL,
+  GL_STENCIL_PASS_DEPTH_PASS,
+  GL_STENCIL_REF,
+  GL_STENCIL_TEST,
+  GL_STENCIL_VALUE_MASK,
+  GL_STENCIL_WRITEMASK,
+  GL_SUBPIXEL_BITS,
+  GL_TEXTURE_BINDING_2D,
+  GL_TEXTURE_BINDING_CUBE_MAP,
+  GL_UNPACK_ALIGNMENT,
+  GL_VIEWPORT,
+};
 
-bool ValidateGLenumGetMaxIndexType(GLenum value) {
-  switch (value) {
-    case GL_UNSIGNED_BYTE:
-    case GL_UNSIGNED_SHORT:
-    case GL_UNSIGNED_INT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_get_max_index_type_table[] = {
+  GL_UNSIGNED_BYTE,
+  GL_UNSIGNED_SHORT,
+  GL_UNSIGNED_INT,
+};
 
-bool ValidateGLenumHintMode(GLenum value) {
-  switch (value) {
-    case GL_FASTEST:
-    case GL_NICEST:
-    case GL_DONT_CARE:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_hint_mode_table[] = {
+  GL_FASTEST,
+  GL_NICEST,
+  GL_DONT_CARE,
+};
 
-bool ValidateGLenumHintTarget(GLenum value) {
-  switch (value) {
-    case GL_GENERATE_MIPMAP_HINT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_hint_target_table[] = {
+  GL_GENERATE_MIPMAP_HINT,
+};
 
-bool ValidateGLenumIndexType(GLenum value) {
-  switch (value) {
-    case GL_UNSIGNED_BYTE:
-    case GL_UNSIGNED_SHORT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_index_type_table[] = {
+  GL_UNSIGNED_BYTE,
+  GL_UNSIGNED_SHORT,
+};
 
-bool ValidateGLenumPixelStore(GLenum value) {
-  switch (value) {
-    case GL_PACK_ALIGNMENT:
-    case GL_UNPACK_ALIGNMENT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_pixel_store_table[] = {
+  GL_PACK_ALIGNMENT,
+  GL_UNPACK_ALIGNMENT,
+};
 
-bool ValidateGLintPixelStoreAlignment(GLenum value) {
-  switch (value) {
-    case 1:
-    case 2:
-    case 4:
-    case 8:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLint valid_pixel_store_alignment_table[] = {
+  1,
+  2,
+  4,
+  8,
+};
 
-bool ValidateGLenumPixelType(GLenum value) {
-  switch (value) {
-    case GL_UNSIGNED_BYTE:
-    case GL_UNSIGNED_SHORT_5_6_5:
-    case GL_UNSIGNED_SHORT_4_4_4_4:
-    case GL_UNSIGNED_SHORT_5_5_5_1:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_pixel_type_table[] = {
+  GL_UNSIGNED_BYTE,
+  GL_UNSIGNED_SHORT_5_6_5,
+  GL_UNSIGNED_SHORT_4_4_4_4,
+  GL_UNSIGNED_SHORT_5_5_5_1,
+};
 
-bool ValidateGLenumProgramParameter(GLenum value) {
-  switch (value) {
-    case GL_DELETE_STATUS:
-    case GL_LINK_STATUS:
-    case GL_VALIDATE_STATUS:
-    case GL_INFO_LOG_LENGTH:
-    case GL_ATTACHED_SHADERS:
-    case GL_ACTIVE_ATTRIBUTES:
-    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
-    case GL_ACTIVE_UNIFORMS:
-    case GL_ACTIVE_UNIFORM_MAX_LENGTH:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_program_parameter_table[] = {
+  GL_DELETE_STATUS,
+  GL_LINK_STATUS,
+  GL_VALIDATE_STATUS,
+  GL_INFO_LOG_LENGTH,
+  GL_ATTACHED_SHADERS,
+  GL_ACTIVE_ATTRIBUTES,
+  GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
+  GL_ACTIVE_UNIFORMS,
+  GL_ACTIVE_UNIFORM_MAX_LENGTH,
+};
 
-bool ValidateGLenumReadPixelFormat(GLenum value) {
-  switch (value) {
-    case GL_ALPHA:
-    case GL_RGB:
-    case GL_RGBA:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_read_pixel_format_table[] = {
+  GL_ALPHA,
+  GL_RGB,
+  GL_RGBA,
+};
 
-bool ValidateGLenumRenderBufferFormat(GLenum value) {
-  switch (value) {
-    case GL_RGBA4:
-    case GL_RGB565:
-    case GL_RGB5_A1:
-    case GL_DEPTH_COMPONENT16:
-    case GL_STENCIL_INDEX8:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_render_buffer_format_table[] = {
+  GL_RGBA4,
+  GL_RGB565,
+  GL_RGB5_A1,
+  GL_DEPTH_COMPONENT16,
+  GL_STENCIL_INDEX8,
+};
 
-bool ValidateGLenumRenderBufferParameter(GLenum value) {
-  switch (value) {
-    case GL_RENDERBUFFER_WIDTH:
-    case GL_RENDERBUFFER_HEIGHT:
-    case GL_RENDERBUFFER_INTERNAL_FORMAT:
-    case GL_RENDERBUFFER_RED_SIZE:
-    case GL_RENDERBUFFER_GREEN_SIZE:
-    case GL_RENDERBUFFER_BLUE_SIZE:
-    case GL_RENDERBUFFER_ALPHA_SIZE:
-    case GL_RENDERBUFFER_DEPTH_SIZE:
-    case GL_RENDERBUFFER_STENCIL_SIZE:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_render_buffer_parameter_table[] = {
+  GL_RENDERBUFFER_WIDTH,
+  GL_RENDERBUFFER_HEIGHT,
+  GL_RENDERBUFFER_INTERNAL_FORMAT,
+  GL_RENDERBUFFER_RED_SIZE,
+  GL_RENDERBUFFER_GREEN_SIZE,
+  GL_RENDERBUFFER_BLUE_SIZE,
+  GL_RENDERBUFFER_ALPHA_SIZE,
+  GL_RENDERBUFFER_DEPTH_SIZE,
+  GL_RENDERBUFFER_STENCIL_SIZE,
+};
 
-bool ValidateGLenumRenderBufferTarget(GLenum value) {
-  switch (value) {
-    case GL_RENDERBUFFER:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_render_buffer_target_table[] = {
+  GL_RENDERBUFFER,
+};
 
-bool ValidateGLenumShaderParameter(GLenum value) {
-  switch (value) {
-    case GL_SHADER_TYPE:
-    case GL_DELETE_STATUS:
-    case GL_COMPILE_STATUS:
-    case GL_INFO_LOG_LENGTH:
-    case GL_SHADER_SOURCE_LENGTH:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_shader_parameter_table[] = {
+  GL_SHADER_TYPE,
+  GL_DELETE_STATUS,
+  GL_COMPILE_STATUS,
+  GL_INFO_LOG_LENGTH,
+  GL_SHADER_SOURCE_LENGTH,
+};
 
-bool ValidateGLenumShaderPrecision(GLenum value) {
-  switch (value) {
-    case GL_LOW_FLOAT:
-    case GL_MEDIUM_FLOAT:
-    case GL_HIGH_FLOAT:
-    case GL_LOW_INT:
-    case GL_MEDIUM_INT:
-    case GL_HIGH_INT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_shader_precision_table[] = {
+  GL_LOW_FLOAT,
+  GL_MEDIUM_FLOAT,
+  GL_HIGH_FLOAT,
+  GL_LOW_INT,
+  GL_MEDIUM_INT,
+  GL_HIGH_INT,
+};
 
-bool ValidateGLenumShaderType(GLenum value) {
-  switch (value) {
-    case GL_VERTEX_SHADER:
-    case GL_FRAGMENT_SHADER:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_shader_type_table[] = {
+  GL_VERTEX_SHADER,
+  GL_FRAGMENT_SHADER,
+};
 
-bool ValidateGLenumSrcBlendFactor(GLenum value) {
-  switch (value) {
-    case GL_ZERO:
-    case GL_ONE:
-    case GL_SRC_COLOR:
-    case GL_ONE_MINUS_SRC_COLOR:
-    case GL_DST_COLOR:
-    case GL_ONE_MINUS_DST_COLOR:
-    case GL_SRC_ALPHA:
-    case GL_ONE_MINUS_SRC_ALPHA:
-    case GL_DST_ALPHA:
-    case GL_ONE_MINUS_DST_ALPHA:
-    case GL_CONSTANT_COLOR:
-    case GL_ONE_MINUS_CONSTANT_COLOR:
-    case GL_CONSTANT_ALPHA:
-    case GL_ONE_MINUS_CONSTANT_ALPHA:
-    case GL_SRC_ALPHA_SATURATE:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_src_blend_factor_table[] = {
+  GL_ZERO,
+  GL_ONE,
+  GL_SRC_COLOR,
+  GL_ONE_MINUS_SRC_COLOR,
+  GL_DST_COLOR,
+  GL_ONE_MINUS_DST_COLOR,
+  GL_SRC_ALPHA,
+  GL_ONE_MINUS_SRC_ALPHA,
+  GL_DST_ALPHA,
+  GL_ONE_MINUS_DST_ALPHA,
+  GL_CONSTANT_COLOR,
+  GL_ONE_MINUS_CONSTANT_COLOR,
+  GL_CONSTANT_ALPHA,
+  GL_ONE_MINUS_CONSTANT_ALPHA,
+  GL_SRC_ALPHA_SATURATE,
+};
 
-bool ValidateGLenumStencilOp(GLenum value) {
-  switch (value) {
-    case GL_KEEP:
-    case GL_ZERO:
-    case GL_REPLACE:
-    case GL_INCR:
-    case GL_INCR_WRAP:
-    case GL_DECR:
-    case GL_DECR_WRAP:
-    case GL_INVERT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_stencil_op_table[] = {
+  GL_KEEP,
+  GL_ZERO,
+  GL_REPLACE,
+  GL_INCR,
+  GL_INCR_WRAP,
+  GL_DECR,
+  GL_DECR_WRAP,
+  GL_INVERT,
+};
 
-bool ValidateGLenumStringType(GLenum value) {
-  switch (value) {
-    case GL_VENDOR:
-    case GL_RENDERER:
-    case GL_VERSION:
-    case GL_SHADING_LANGUAGE_VERSION:
-    case GL_EXTENSIONS:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_string_type_table[] = {
+  GL_VENDOR,
+  GL_RENDERER,
+  GL_VERSION,
+  GL_SHADING_LANGUAGE_VERSION,
+  GL_EXTENSIONS,
+};
 
-bool ValidateGLenumTextureBindTarget(GLenum value) {
-  switch (value) {
-    case GL_TEXTURE_2D:
-    case GL_TEXTURE_CUBE_MAP:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_texture_bind_target_table[] = {
+  GL_TEXTURE_2D,
+  GL_TEXTURE_CUBE_MAP,
+};
 
-bool ValidateGLintTextureBorder(GLenum value) {
-  switch (value) {
-    case 0:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLint valid_texture_border_table[] = {
+  0,
+};
 
-bool ValidateGLenumTextureFormat(GLenum value) {
-  switch (value) {
-    case GL_ALPHA:
-    case GL_LUMINANCE:
-    case GL_LUMINANCE_ALPHA:
-    case GL_RGB:
-    case GL_RGBA:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_texture_format_table[] = {
+  GL_ALPHA,
+  GL_LUMINANCE,
+  GL_LUMINANCE_ALPHA,
+  GL_RGB,
+  GL_RGBA,
+};
 
-bool ValidateGLenumTextureParameter(GLenum value) {
-  switch (value) {
-    case GL_TEXTURE_MAG_FILTER:
-    case GL_TEXTURE_MIN_FILTER:
-    case GL_TEXTURE_WRAP_S:
-    case GL_TEXTURE_WRAP_T:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_texture_parameter_table[] = {
+  GL_TEXTURE_MAG_FILTER,
+  GL_TEXTURE_MIN_FILTER,
+  GL_TEXTURE_WRAP_S,
+  GL_TEXTURE_WRAP_T,
+};
 
-bool ValidateGLenumTextureTarget(GLenum value) {
-  switch (value) {
-    case GL_TEXTURE_2D:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_texture_target_table[] = {
+  GL_TEXTURE_2D,
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
+};
 
-bool ValidateGLintVertexAttribSize(GLenum value) {
-  switch (value) {
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLint valid_vertex_attrib_size_table[] = {
+  1,
+  2,
+  3,
+  4,
+};
 
-bool ValidateGLenumVertexAttribType(GLenum value) {
-  switch (value) {
-    case GL_BYTE:
-    case GL_UNSIGNED_BYTE:
-    case GL_SHORT:
-    case GL_UNSIGNED_SHORT:
-    case GL_FLOAT:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_vertex_attrib_type_table[] = {
+  GL_BYTE,
+  GL_UNSIGNED_BYTE,
+  GL_SHORT,
+  GL_UNSIGNED_SHORT,
+  GL_FLOAT,
+};
 
-bool ValidateGLenumVertexAttribute(GLenum value) {
-  switch (value) {
-    case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
-    case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
-    case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
-    case GL_VERTEX_ATTRIB_ARRAY_SIZE:
-    case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
-    case GL_VERTEX_ATTRIB_ARRAY_TYPE:
-    case GL_CURRENT_VERTEX_ATTRIB:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_vertex_attribute_table[] = {
+  GL_VERTEX_ATTRIB_ARRAY_NORMALIZED,
+  GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
+  GL_VERTEX_ATTRIB_ARRAY_ENABLED,
+  GL_VERTEX_ATTRIB_ARRAY_SIZE,
+  GL_VERTEX_ATTRIB_ARRAY_STRIDE,
+  GL_VERTEX_ATTRIB_ARRAY_TYPE,
+  GL_CURRENT_VERTEX_ATTRIB,
+};
 
-bool ValidateGLenumVertexPointer(GLenum value) {
-  switch (value) {
-    case GL_VERTEX_ATTRIB_ARRAY_POINTER:
-      return true;
-    default:
-      return false;
-  }
-}
+static GLenum valid_vertex_pointer_table[] = {
+  GL_VERTEX_ATTRIB_ARRAY_POINTER,
+};
 
+Validators::Validators()
+    : attachment(
+        valid_attachment_table, arraysize(valid_attachment_table)),
+      buffer_parameter(
+        valid_buffer_parameter_table, arraysize(valid_buffer_parameter_table)),
+      buffer_target(
+        valid_buffer_target_table, arraysize(valid_buffer_target_table)),
+      buffer_usage(
+        valid_buffer_usage_table, arraysize(valid_buffer_usage_table)),
+      capability(
+        valid_capability_table, arraysize(valid_capability_table)),
+      cmp_function(
+        valid_cmp_function_table, arraysize(valid_cmp_function_table)),
+      compressed_texture_format(
+        valid_compressed_texture_format_table, arraysize(
+            valid_compressed_texture_format_table)),
+      draw_mode(
+        valid_draw_mode_table, arraysize(valid_draw_mode_table)),
+      dst_blend_factor(
+        valid_dst_blend_factor_table, arraysize(valid_dst_blend_factor_table)),
+      equation(
+        valid_equation_table, arraysize(valid_equation_table)),
+      face_mode(
+        valid_face_mode_table, arraysize(valid_face_mode_table)),
+      face_type(
+        valid_face_type_table, arraysize(valid_face_type_table)),
+      false_only(
+        valid_false_only_table, arraysize(valid_false_only_table)),
+      frame_buffer_parameter(
+        valid_frame_buffer_parameter_table, arraysize(
+            valid_frame_buffer_parameter_table)),
+      frame_buffer_target(
+        valid_frame_buffer_target_table, arraysize(
+            valid_frame_buffer_target_table)),
+      g_l_state(
+        valid_g_l_state_table, arraysize(valid_g_l_state_table)),
+      get_max_index_type(
+        valid_get_max_index_type_table, arraysize(
+            valid_get_max_index_type_table)),
+      hint_mode(
+        valid_hint_mode_table, arraysize(valid_hint_mode_table)),
+      hint_target(
+        valid_hint_target_table, arraysize(valid_hint_target_table)),
+      index_type(
+        valid_index_type_table, arraysize(valid_index_type_table)),
+      pixel_store(
+        valid_pixel_store_table, arraysize(valid_pixel_store_table)),
+      pixel_store_alignment(
+        valid_pixel_store_alignment_table, arraysize(
+            valid_pixel_store_alignment_table)),
+      pixel_type(
+        valid_pixel_type_table, arraysize(valid_pixel_type_table)),
+      program_parameter(
+        valid_program_parameter_table, arraysize(
+            valid_program_parameter_table)),
+      read_pixel_format(
+        valid_read_pixel_format_table, arraysize(
+            valid_read_pixel_format_table)),
+      render_buffer_format(
+        valid_render_buffer_format_table, arraysize(
+            valid_render_buffer_format_table)),
+      render_buffer_parameter(
+        valid_render_buffer_parameter_table, arraysize(
+            valid_render_buffer_parameter_table)),
+      render_buffer_target(
+        valid_render_buffer_target_table, arraysize(
+            valid_render_buffer_target_table)),
+      shader_parameter(
+        valid_shader_parameter_table, arraysize(valid_shader_parameter_table)),
+      shader_precision(
+        valid_shader_precision_table, arraysize(valid_shader_precision_table)),
+      shader_type(
+        valid_shader_type_table, arraysize(valid_shader_type_table)),
+      src_blend_factor(
+        valid_src_blend_factor_table, arraysize(valid_src_blend_factor_table)),
+      stencil_op(
+        valid_stencil_op_table, arraysize(valid_stencil_op_table)),
+      string_type(
+        valid_string_type_table, arraysize(valid_string_type_table)),
+      texture_bind_target(
+        valid_texture_bind_target_table, arraysize(
+            valid_texture_bind_target_table)),
+      texture_border(
+        valid_texture_border_table, arraysize(valid_texture_border_table)),
+      texture_format(
+        valid_texture_format_table, arraysize(valid_texture_format_table)),
+      texture_parameter(
+        valid_texture_parameter_table, arraysize(
+            valid_texture_parameter_table)),
+      texture_target(
+        valid_texture_target_table, arraysize(valid_texture_target_table)),
+      vertex_attrib_size(
+        valid_vertex_attrib_size_table, arraysize(
+            valid_vertex_attrib_size_table)),
+      vertex_attrib_type(
+        valid_vertex_attrib_type_table, arraysize(
+            valid_vertex_attrib_type_table)),
+      vertex_attribute(
+        valid_vertex_attribute_table, arraysize(valid_vertex_attribute_table)),
+      vertex_pointer(
+        valid_vertex_pointer_table, arraysize(valid_vertex_pointer_table)) {
+}
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_VALIDATION_IMPLEMENTATION_AUTOGEN_H_  // NOLINT