Improve indexed gl state related GL commands.

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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 1528 matching lines @@
   // Wrapper for glGetFramebufferAttachmentParameteriv.
   void DoGetFramebufferAttachmentParameteriv(
       GLenum target, GLenum attachment, GLenum pname, GLint* params);
 
   // Wrapper for glGetInteger64v.
   void DoGetInteger64v(GLenum pname, GLint64* params);
 
   // Wrapper for glGetIntegerv.
   void DoGetIntegerv(GLenum pname, GLint* params);
 
+  // Helper for DoGetIntegeri_v and DoGetInteger64i_v.
+  template <typename TYPE>
+  void GetIndexedIntegerImpl(
+      const char* function_name, GLenum target, GLuint index, TYPE* data);
+
+  // Wrapper for glGetIntegeri_v.
+  void DoGetIntegeri_v(GLenum target, GLuint index, GLint* data);
+
+  // Wrapper for glGetInteger64i_v.
+  void DoGetInteger64i_v(GLenum target, GLuint index, GLint64* data);
+
   // Gets the max value in a range in a buffer.
   GLuint DoGetMaxValueInBufferCHROMIUM(
       GLuint buffer_id, GLsizei count, GLenum type, GLuint offset);
 
   // Wrapper for glGetBufferParameteri64v.
   void DoGetBufferParameteri64v(
       GLenum target, GLenum pname, GLint64* params);
 
   // Wrapper for glGetBufferParameteriv.
   void DoGetBufferParameteriv(
@@ skipping 1263 matching lines @@
 
     // Create a fake default transform feedback and bind to it.
     GLuint default_transform_feedback = 0;
     glGenTransformFeedbacks(1, &default_transform_feedback);
     state_.default_transform_feedback =
         transform_feedback_manager_->CreateTransformFeedback(
             0, default_transform_feedback);
     glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, default_transform_feedback);
     state_.bound_transform_feedback = state_.default_transform_feedback.get();
   }
+  state_.indexed_uniform_buffer_bindings = new IndexedBufferBindingHost(
+      group_->max_uniform_buffer_bindings(), needs_emulation);
 
   state_.attrib_values.resize(group_->max_vertex_attribs());
   vertex_array_manager_.reset(new VertexArrayManager());
 
   GLuint default_vertex_attrib_service_id = 0;
   if (features().native_vertex_array_object) {
     glGenVertexArraysOES(1, &default_vertex_attrib_service_id);
     glBindVertexArrayOES(default_vertex_attrib_service_id);
   }
 
@@ skipping 1354 matching lines @@
   state_.bound_copy_write_buffer = nullptr;
   state_.bound_pixel_pack_buffer = nullptr;
   state_.bound_pixel_unpack_buffer = nullptr;
   state_.bound_transform_feedback_buffer = nullptr;
   state_.bound_uniform_buffer = nullptr;
   framebuffer_state_.bound_read_framebuffer = nullptr;
   framebuffer_state_.bound_draw_framebuffer = nullptr;
   state_.bound_renderbuffer = nullptr;
   state_.bound_transform_feedback = nullptr;
   state_.default_transform_feedback = nullptr;
+  state_.indexed_uniform_buffer_bindings = nullptr;
 
   if (offscreen_saved_color_texture_info_.get()) {
     DCHECK(offscreen_target_color_texture_);
     DCHECK_EQ(offscreen_saved_color_texture_info_->service_id(),
               offscreen_saved_color_texture_->id());
     offscreen_saved_color_texture_->Invalidate();
     offscreen_saved_color_texture_info_ = NULL;
   }
   ReleaseAllBackTextures();
   if (have_context) {
@@ skipping 629 matching lines @@
     }
     case GL_UNIFORM_BUFFER: {
       if (index >= group_->max_uniform_buffer_bindings()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
                            "index out of range");
         return;
       }
       break;
     }
     default:
-      LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "invalid target");
-      return;
+      NOTREACHED();
+      break;
   }
 
   if (function_type == kBindBufferRange) {
     switch (target) {
       case GL_TRANSFORM_FEEDBACK_BUFFER:
         if ((size % 4 != 0) || (offset % 4 != 0)) {
           LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
                              "size or offset are not multiples of 4");
           return;
         }
@@ skipping 37 matching lines @@
       // It's a new id so make a buffer for it.
       glGenBuffersARB(1, &service_id);
       CreateBuffer(client_id, service_id);
       buffer = GetBuffer(client_id);
       DCHECK(buffer);
     }
     service_id = buffer->service_id();
   }
   LogClientServiceForInfo(buffer, client_id, function_name);
 
+  scoped_refptr<IndexedBufferBindingHost> bindings;
   switch (target) {
     case GL_TRANSFORM_FEEDBACK_BUFFER:
-      DCHECK(state_.bound_transform_feedback.get());
-      switch (function_type) {
-        case kBindBufferBase:
-          state_.bound_transform_feedback->DoBindBufferBase(
-              target, index, buffer);
-          break;
-        case kBindBufferRange:
-          state_.bound_transform_feedback->DoBindBufferRange(
-              target, index, buffer, offset, size);
-          break;
-      }
+      bindings = state_.bound_transform_feedback.get();
       break;
     case GL_UNIFORM_BUFFER:
-      // TODO(zmo): emulate Desktop GL 4.1 or lower behavior and keep track of
-      // indexed buffer bindings.
-      switch (function_type) {
-        case kBindBufferBase:
-          glBindBufferBase(target, index, service_id);
-          break;
-        case kBindBufferRange:
-          glBindBufferRange(target, index, service_id, offset, size);
-          break;
-      }
+      bindings = state_.indexed_uniform_buffer_bindings.get();
       break;
     default:
       NOTREACHED();
+      break;
+  }
+  DCHECK(bindings);
+  switch (function_type) {
+    case kBindBufferBase:
+      bindings->DoBindBufferBase(target, index, buffer);
+      break;
+    case kBindBufferRange:
+      bindings->DoBindBufferRange(target, index, buffer, offset, size);
+      break;
+    default:
+      NOTREACHED();
       break;
   }
 }
 
 void GLES2DecoderImpl::DoBindBufferBase(GLenum target, GLuint index,
                                         GLuint client_id) {
   BindIndexedBufferImpl(target, index, client_id, 0, 0,
                         kBindBufferBase, "glBindBufferBase");
 }
 
@@ skipping 310 matching lines @@
   } else {
     glBindSampler(unit, 0);
   }
 
   state_.sampler_units[unit] = sampler;
 }
 
 void GLES2DecoderImpl::DoBindTransformFeedback(
     GLenum target, GLuint client_id) {
   const char* function_name = "glBindTransformFeedback";
-  if (!validators_->transform_feedback_bind_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
-    return;
-  }
 
   TransformFeedback* transform_feedback = nullptr;
   if (client_id != 0) {
     transform_feedback = GetTransformFeedback(client_id);
     if (!transform_feedback) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                          "id not generated by glGenTransformFeedbacks");
       return;
     }
   } else {
     transform_feedback = state_.default_transform_feedback.get();
   }
   DCHECK(transform_feedback);
   if (transform_feedback == state_.bound_transform_feedback.get())
     return;
   if (state_.bound_transform_feedback->active() &&
       !state_.bound_transform_feedback->paused()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "currently bound transform feedback is active");
     return;
   }
   LogClientServiceForInfo(transform_feedback, client_id, function_name);
   transform_feedback->DoBindTransformFeedback(target);
   state_.bound_transform_feedback = transform_feedback;
 }
 
 void GLES2DecoderImpl::DoBeginTransformFeedback(GLenum primitive_mode) {
   const char* function_name = "glBeginTransformFeedback";
   DCHECK(state_.bound_transform_feedback.get());
-  if (!validators_->transform_feedback_primitive_mode.IsValid(primitive_mode)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(
-        function_name, primitive_mode, "primitiveMode");
-    return;
-  }
   if (state_.bound_transform_feedback->active()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "transform feedback is already active");
     return;
   }
   state_.bound_transform_feedback->DoBeginTransformFeedback(primitive_mode);
 }
 
 void GLES2DecoderImpl::DoEndTransformFeedback() {
   const char* function_name = "glEndTransformFeedback";
@@ skipping 38 matching lines @@
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDisableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::InvalidateFramebufferImpl(
     GLenum target, GLsizei count, const GLenum* attachments,
     GLint x, GLint y, GLsizei width, GLsizei height,
     const char* function_name, FramebufferOperation op) {
-  if (!validators_->frame_buffer_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
-    return;
-  }
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
 
   // Validates the attachments. If one of them fails, the whole command fails.
   GLenum thresh0 = GL_COLOR_ATTACHMENT0 + group_->max_color_attachments();
   GLenum thresh1 = GL_COLOR_ATTACHMENT15;
   for (GLsizei i = 0; i < count; ++i) {
     if (framebuffer) {
       if (attachments[i] >= thresh0 && attachments[i] <= thresh1) {
         LOCAL_SET_GL_ERROR(
             GL_INVALID_OPERATION, function_name, "invalid attachment");
@@ skipping 763 matching lines @@
 void GLES2DecoderImpl::DoGetIntegerv(GLenum pname, GLint* params) {
   DCHECK(params);
   GLsizei num_written;
   if (!state_.GetStateAsGLint(pname, params, &num_written) &&
       !GetHelper(pname, params, &num_written)) {
     pname = AdjustGetPname(pname);
     glGetIntegerv(pname, params);
   }
 }
 
+template <typename TYPE>
+void GLES2DecoderImpl::GetIndexedIntegerImpl(
+    const char* function_name, GLenum target, GLuint index, TYPE* data) {
+  DCHECK(data);
+  scoped_refptr<IndexedBufferBindingHost> bindings;
+  switch (target) {
+    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
+    case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
+    case GL_TRANSFORM_FEEDBACK_BUFFER_START:
+      if (index >= group_->max_transform_feedback_separate_attribs()) {
+        LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "invalid index");
+        return;
+      }
+      bindings = state_.bound_transform_feedback.get();
+      break;
+    case GL_UNIFORM_BUFFER_BINDING:
+    case GL_UNIFORM_BUFFER_SIZE:
+    case GL_UNIFORM_BUFFER_START:
+      if (index >= group_->max_uniform_buffer_bindings()) {
+        LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "invalid index");
+        return;
+      }
+      bindings = state_.indexed_uniform_buffer_bindings.get();
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+  DCHECK(bindings);
+  switch (target) {
+    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
+    case GL_UNIFORM_BUFFER_BINDING:
+      {
+        Buffer* buffer = bindings->GetBufferBinding(index);
+        *data = static_cast<TYPE>(buffer ? buffer->service_id() : 0);
+      }
+      break;
+    case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
+    case GL_UNIFORM_BUFFER_SIZE:
+      *data = static_cast<TYPE>(bindings->GetBufferSize(index));
+      break;
+    case GL_TRANSFORM_FEEDBACK_BUFFER_START:
+    case GL_UNIFORM_BUFFER_START:
+      *data = static_cast<TYPE>(bindings->GetBufferStart(index));
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void GLES2DecoderImpl::DoGetIntegeri_v(
+    GLenum target, GLuint index, GLint* data) {
+  GetIndexedIntegerImpl<GLint>("glGetIntegeri_v", target, index, data);
+}
+
+void GLES2DecoderImpl::DoGetInteger64i_v(
+    GLenum target, GLuint index, GLint64* data) {
+  GetIndexedIntegerImpl<GLint64>("glGetInteger64i_v", target, index, data);
+}
+
 void GLES2DecoderImpl::DoGetProgramiv(
     GLuint program_id, GLenum pname, GLint* params) {
   Program* program = GetProgramInfoNotShader(program_id, "glGetProgramiv");
   if (!program) {
     return;
   }
   program->GetProgramiv(pname, params);
 }
 
 void GLES2DecoderImpl::DoGetBufferParameteri64v(
@@ skipping 281 matching lines @@
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoClearBufferiv(
     GLenum buffer, GLint drawbuffer, const GLint* value) {
   // TODO(zmo): Set clear_uncleared_images=true once crbug.com/584059 is fixed.
   if (!CheckBoundDrawFramebufferValid(false, "glClearBufferiv"))
     return;
   ApplyDirtyState();
 
-  switch (buffer) {
-    case GL_COLOR:
-    case GL_STENCIL:
-      break;
-    default:
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_ENUM, "glClearBufferiv", "invalid buffer");
-      return;
-  }
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glClearBufferiv", "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
         GetBoundColorDrawBufferInternalFormat(drawbuffer);
     if (!GLES2Util::IsSignedIntegerFormat(internal_format)) {
@@ skipping 15 matching lines @@
   glClearBufferiv(buffer, drawbuffer, value);
 }
 
 void GLES2DecoderImpl::DoClearBufferuiv(
     GLenum buffer, GLint drawbuffer, const GLuint* value) {
   // TODO(zmo): Set clear_uncleared_images=true once crbug.com/584059 is fixed.
   if (!CheckBoundDrawFramebufferValid(false, "glClearBufferuiv"))
     return;
   ApplyDirtyState();
 
-  switch (buffer) {
-    case GL_COLOR:
-      break;
-    default:
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_ENUM, "glClearBufferuiv", "invalid buffer");
-      return;
-  }
   if (drawbuffer < 0 ||
       drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glClearBufferuiv", "invalid drawBuffer");
     return;
   }
   GLenum internal_format =
       GetBoundColorDrawBufferInternalFormat(drawbuffer);
   if (!GLES2Util::IsUnsignedIntegerFormat(internal_format)) {
     // To avoid undefined results, return without calling the gl function.
     return;
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
   glClearBufferuiv(buffer, drawbuffer, value);
 }
 
 void GLES2DecoderImpl::DoClearBufferfv(
     GLenum buffer, GLint drawbuffer, const GLfloat* value) {
   // TODO(zmo): Set clear_uncleared_images=true once crbug.com/584059 is fixed.
   if (!CheckBoundDrawFramebufferValid(false, "glClearBufferfv"))
     return;
   ApplyDirtyState();
 
-  switch (buffer) {
-    case GL_COLOR:
-    case GL_DEPTH:
-      break;
-    default:
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_ENUM, "glClearBufferfv", "invalid buffer");
-      return;
-  }
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glClearBufferfv", "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
         GetBoundColorDrawBufferInternalFormat(drawbuffer);
     if (GLES2Util::IsIntegerFormat(internal_format)) {
@@ skipping 15 matching lines @@
   glClearBufferfv(buffer, drawbuffer, value);
 }
 
 void GLES2DecoderImpl::DoClearBufferfi(
     GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
   // TODO(zmo): Set clear_uncleared_images=true once crbug.com/584059 is fixed.
   if (!CheckBoundDrawFramebufferValid(false, "glClearBufferfi"))
     return;
   ApplyDirtyState();
 
-  switch (buffer) {
-    case GL_DEPTH_STENCIL:
-      break;
-    default:
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_ENUM, "glClearBufferfi", "invalid buffer");
-      return;
-  }
   if (drawbuffer != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glClearBufferfi", "invalid drawBuffer");
     return;
   }
   if (!BoundFramebufferHasDepthAttachment() &&
       !BoundFramebufferHasStencilAttachment()) {
     return;
   }
   MarkDrawBufferAsCleared(GL_DEPTH, drawbuffer);
@@ skipping 275 matching lines @@
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoFramebufferTextureLayer(
     GLenum target, GLenum attachment, GLuint client_texture_id,
     GLint level, GLint layer) {
-  // TODO(zmo): Add full validation.
-  GLuint service_id = 0;
-  TextureRef* texture_ref = NULL;
+  const char* function_name = "glFramebufferTextureLayer";
+
+  TextureRef* texture_ref = nullptr;
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glFramebufferTextureLayer", "no framebuffer bound.");
+        GL_INVALID_OPERATION, function_name, "no framebuffer bound.");
     return;
   }
+  GLuint service_id = 0;
+  GLenum texture_target = 0;
   if (client_texture_id) {
     texture_ref = GetTexture(client_texture_id);
     if (!texture_ref) {
       LOCAL_SET_GL_ERROR(
-          GL_INVALID_OPERATION,
-          "glFramebufferTextureLayer", "unknown texture_ref");
+          GL_INVALID_VALUE, function_name, "unknown texture");
       return;
     }
     service_id = texture_ref->service_id();
+
+    texture_target = texture_ref->texture()->target();
+    switch (texture_target) {
+      case GL_TEXTURE_3D:
+      case GL_TEXTURE_2D_ARRAY:
+        break;
+      default:
+        LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+            "texture is neither TEXTURE_3D nor TEXTURE_2D_ARRAY");
+        return;
+    }
+    if (!texture_manager()->ValidForTarget(texture_target, level,
+                                           0, 0, layer)) {
+      LOCAL_SET_GL_ERROR(
+          GL_INVALID_VALUE, function_name, "invalid level or layer");
+      return;
+    }
   }
-  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glFramebufferTextureLayer");
   glFramebufferTextureLayer(target, attachment, service_id, level, layer);
-  GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferTextureLayer");
-  if (error == GL_NO_ERROR) {
-    framebuffer->AttachTextureLayer(attachment, texture_ref,
-        texture_ref ? texture_ref->texture()->target() : 0,
-        level, layer);
-  }
+  framebuffer->AttachTextureLayer(
+      attachment, texture_ref, texture_target, level, layer);
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   const char kFunctionName[] = "glGetFramebufferAttachmentParameteriv";
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
@@ skipping 478 matching lines @@
         program_manager()->ClearUniforms(program);
     }
   }
 
   // LinkProgram can be very slow.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 void GLES2DecoderImpl::DoReadBuffer(GLenum src) {
-  switch (src) {
-    case GL_NONE:
-    case GL_BACK:
-      break;
-    default:
-      {
-        GLenum upper_limit = static_cast<GLenum>(
-            group_->max_color_attachments() + GL_COLOR_ATTACHMENT0);
-        if (src < GL_COLOR_ATTACHMENT0 || src >= upper_limit) {
-          LOCAL_SET_GL_ERROR(
-              GL_INVALID_ENUM, "glReadBuffer", "invalid enum for src");
-          return;
-        }
-      }
-      break;
-  }
-
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
   if (framebuffer) {
     if (src == GL_BACK) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_ENUM, "glReadBuffer",
           "invalid src for a named framebuffer");
       return;
     }
     framebuffer->set_read_buffer(src);
   } else {
@@ skipping 1146 matching lines @@
   if (!CheckBoundDrawFramebufferValid(true, function_name)) {
     return error::kNoError;
   }
   // We have to check this here because the prototype for glDrawArrays
   // is GLint not GLsizei.
   if (first < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "first < 0");
     return error::kNoError;
   }
 
+  if (state_.bound_transform_feedback.get() &&
+      state_.bound_transform_feedback->active() &&
+      !state_.bound_transform_feedback->paused() &&
+      mode != state_.bound_transform_feedback->primitive_mode()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+        "mode is not identical with active transformfeedback's primitiveMode");
+    return error::kNoError;
+  }
+
   if (count == 0 || primcount == 0) {
     LOCAL_RENDER_WARNING("Render count or primcount is 0.");
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed = first + count - 1;
   if (IsDrawValid(function_name, max_vertex_accessed, instanced, primcount)) {
     if (!ClearUnclearedTextures()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "out of memory");
       return error::kNoError;
@@ skipping 93 matching lines @@
   }
   if (primcount < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
 
   if (!CheckBoundDrawFramebufferValid(true, function_name)) {
     return error::kNoError;
   }
 
+  if (state_.bound_transform_feedback.get() &&
+      state_.bound_transform_feedback->active() &&
+      !state_.bound_transform_feedback->paused()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+        "transformfeedback is active and not paused");
+    return error::kNoError;
+  }
+
   if (count == 0 || primcount == 0) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
   Buffer* element_array_buffer =
       state_.vertex_attrib_manager->element_array_buffer();
 
   if (!element_array_buffer->GetMaxValueForRange(
           offset, count, type,
@@ skipping 2976 matching lines @@
     }
   }
   return DoCompressedTexImage3D(target, level, internal_format, width, height,
                                 depth, border, imageSize, data);
 }
 
 void GLES2DecoderImpl::DoCompressedTexSubImage3D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
     GLsizei width, GLsizei height, GLsizei depth, GLenum format,
     GLsizei image_size, const void* data) {
-  if (!validators_->texture_3_d_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_ENUM, "glCompressedTexSubImage3D", "target");
-    return;
-  }
-  if (!validators_->compressed_texture_format.IsValid(format)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(
-        "glCompressedTexSubImage3D", format, "format");
-    return;
-  }
   if (!texture_manager()->ValidForTarget(target, level, width, height, depth)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glCompressedTexSubImage3D", "dimensions out of range");
     return;
   }
   if (image_size < 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCompressedTexSubImage3D", "imageSize < 0");
     return;
@@ skipping 3000 matching lines @@
       this, source_texture->target(), source_texture->service_id(),
       source_internal_format, dest_texture->target(),
       dest_texture->service_id(), GL_RGBA, source_width, source_height, false,
       false, false);
 }
 
 void GLES2DecoderImpl::TexStorageImpl(
     GLenum target, GLint levels, GLenum internal_format,
     GLsizei width, GLsizei height, GLsizei depth,
     ContextState::Dimension dimension, const char* function_name) {
-  if (dimension == ContextState::k2D) {
-    if (!validators_->texture_bind_target.IsValid(target)) {
-      LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
-      return;
-    }
-  } else {
-    if (!validators_->texture_3_d_target.IsValid(target)) {
-      LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
-      return;
-    }
-  }
   if (levels <= 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "levels <= 0");
     return;
   }
-  if (!validators_->texture_internal_format_storage.IsValid(internal_format)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(
-        function_name, internal_format, "internal_format");
-    return;
-  }
   bool is_compressed_format = IsCompressedTextureFormat(internal_format);
   if (is_compressed_format && target == GL_TEXTURE_3D) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "target invalid for format");
     return;
   }
   if (!texture_manager()->ValidForTarget(target, 0, width, height, depth) ||
       TextureManager::ComputeMipMapCount(
           target, width, height, depth) < levels) {
     LOCAL_SET_GL_ERROR(
@@ skipping 2018 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 "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu