Add gl tests to make sure when a buffer is unmapped, all access path generates an INVALID_OPERATION.

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 3905 matching lines @@
 }
 
 void GLES2DecoderImpl::DeleteBuffersHelper(GLsizei n,
                                            const volatile GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     Buffer* buffer = GetBuffer(client_id);
     if (buffer && !buffer->IsDeleted()) {
       buffer->RemoveMappedRange();
       state_.RemoveBoundBuffer(buffer);
-      transform_feedback_manager_->RemoveBoundBuffer(buffer);
       RemoveBuffer(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n,
     const volatile GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
@@ skipping 1758 matching lines @@
                        "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 (state_.bound_transform_feedback->active()) {
+  TransformFeedback* transform_feedback = state_.bound_transform_feedback.get();
+  DCHECK(transform_feedback);
+  if (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);
+  if (!CheckCurrentProgram(function_name)) {
+    return;
+  }
+  Program* program = state_.current_program.get();
+  DCHECK(program);
+  size_t required_buffer_count =
+      program->effective_transform_feedback_varyings().size();
+  if (required_buffer_count == 0) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                       "no active transform feedback varyings");
+    return;
+  }
+  if (required_buffer_count > 1 &&
+      GL_INTERLEAVED_ATTRIBS ==
+          program->effective_transform_feedback_buffer_mode()) {
+    required_buffer_count = 1;
+  }
+  for (size_t ii = 0; ii < required_buffer_count; ++ii) {
+    Buffer* buffer = transform_feedback->GetBufferBinding(ii);
+    if (!buffer) {
+      std::string msg = base::StringPrintf("missing buffer bound at index %i",
+                                           static_cast<int>(ii));
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name, msg.c_str());
+      return;
+    }
+    if (buffer->GetMappedRange()) {
+      std::string msg = base::StringPrintf(
+          "bound buffer bound at index %i is mapped", static_cast<int>(ii));
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name, msg.c_str());
+      return;
+    }
+  }
+  transform_feedback->DoBeginTransformFeedback(primitive_mode);
 }
 
 void GLES2DecoderImpl::DoEndTransformFeedback() {
   const char* function_name = "glEndTransformFeedback";
   DCHECK(state_.bound_transform_feedback.get());
   if (!state_.bound_transform_feedback->active()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "transform feedback is not active");
     return;
   }
@@ skipping 3767 matching lines @@
     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;
   }
 
-  if (feature_info_->IsWebGL2OrES3Context() && !AttribsTypeMatch()) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
-        "vertexAttrib function must match shader attrib type");
-    return error::kNoError;
+  if (feature_info_->IsWebGL2OrES3Context()) {
+    if (!AttribsTypeMatch()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "vertexAttrib function must match shader attrib type");
+      return error::kNoError;
+    }
+    if (state_.bound_array_buffer.get() &&
+        state_.bound_array_buffer->GetMappedRange()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "bound ARRAY_BUFFER is mapped");
+      return error::kNoError;
+    }
   }
 
   base::CheckedNumeric<GLuint> checked_max_vertex = first;
   checked_max_vertex += count - 1;
   // first and count-1 are both a non-negative int, so their sum fits an
   // unsigned int.
   GLuint max_vertex_accessed = checked_max_vertex.ValueOrDie();
   if (IsDrawValid(function_name, max_vertex_accessed, instanced, primcount)) {
     if (!ClearUnclearedTextures()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "out of memory");
@@ skipping 114 matching lines @@
       !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;
   }
 
-  if (feature_info_->IsWebGL2OrES3Context() && !AttribsTypeMatch()) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
-        "vertexAttrib function must match shader attrib type");
-    return error::kNoError;
+  if (feature_info_->IsWebGL2OrES3Context()) {
+    if (!AttribsTypeMatch()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "vertexAttrib function must match shader attrib type");
+      return error::kNoError;
+    }
+    if (state_.bound_array_buffer.get() &&
+        state_.bound_array_buffer->GetMappedRange()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "bound ARRAY_BUFFER is mapped");
+      return error::kNoError;
+    }
+    if (state_.vertex_attrib_manager->element_array_buffer() &&
+        state_.vertex_attrib_manager->element_array_buffer()
+            ->GetMappedRange()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "bound ELEMENT_ARRAY_BUFFER is mapped");
+      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,
           state_.enable_flags.primitive_restart_fixed_index,
           &max_vertex_accessed)) {
@@ skipping 7266 matching lines @@
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "Incompatible access bits with MAP_READ_BIT");
     return error::kNoError;
   }
   if (AllBitsSet(access, GL_MAP_FLUSH_EXPLICIT_BIT) &&
       !AllBitsSet(access, GL_MAP_WRITE_BIT)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "MAP_FLUSH_EXPLICIT_BIT set without MAP_WRITE_BIT");
     return error::kNoError;
   }
+  if (target == GL_TRANSFORM_FEEDBACK_BUFFER &&
+      state_.bound_transform_feedback->active()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+                       "transform feedback is active");
+    return error::kNoError;
+  }
   if (AllBitsSet(access, GL_MAP_INVALIDATE_BUFFER_BIT)) {
     // To be on the safe side, always map GL_MAP_INVALIDATE_BUFFER_BIT to
     // GL_MAP_INVALIDATE_RANGE_BIT.
     access = (access & ~GL_MAP_INVALIDATE_BUFFER_BIT);
     access = (access | GL_MAP_INVALIDATE_RANGE_BIT);
   }
   // Always filter out GL_MAP_UNSYNCHRONIZED_BIT to get rid of undefined
   // behaviors.
   access = (access & ~GL_MAP_UNSYNCHRONIZED_BIT);
   if (AllBitsSet(access, GL_MAP_WRITE_BIT) &&
@@ skipping 1309 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