Fix state management of transform feedback buffers.

third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp

 // Copyright 2015 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 "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include <memory>
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 136 matching lines @@
     : WebGLRenderingContextBase(passed_canvas,
                                 std::move(context_provider),
                                 requested_attributes,
                                 2),
       read_framebuffer_binding_(this, nullptr),
       transform_feedback_binding_(this, nullptr),
       bound_copy_read_buffer_(this, nullptr),
       bound_copy_write_buffer_(this, nullptr),
       bound_pixel_pack_buffer_(this, nullptr),
       bound_pixel_unpack_buffer_(this, nullptr),
-      bound_transform_feedback_buffer_(this, nullptr),
       bound_uniform_buffer_(this, nullptr),
       current_boolean_occlusion_query_(this, nullptr),
       current_transform_feedback_primitives_written_query_(this, nullptr),
       current_elapsed_query_(this, nullptr) {
   supported_internal_formats_storage_.insert(
       kSupportedInternalFormatsStorage,
       kSupportedInternalFormatsStorage +
           WTF_ARRAY_LENGTH(kSupportedInternalFormatsStorage));
 }
 
 WebGL2RenderingContextBase::WebGL2RenderingContextBase(
     OffscreenCanvas* passed_offscreen_canvas,
     std::unique_ptr<WebGraphicsContext3DProvider> context_provider,
     const CanvasContextCreationAttributes& requested_attributes)
     : WebGLRenderingContextBase(passed_offscreen_canvas,
                                 std::move(context_provider),
                                 requested_attributes,
                                 2),
       read_framebuffer_binding_(this, nullptr),
       transform_feedback_binding_(this, nullptr),
       bound_copy_read_buffer_(this, nullptr),
       bound_copy_write_buffer_(this, nullptr),
       bound_pixel_pack_buffer_(this, nullptr),
       bound_pixel_unpack_buffer_(this, nullptr),
-      bound_transform_feedback_buffer_(this, nullptr),
       bound_uniform_buffer_(this, nullptr),
       current_boolean_occlusion_query_(this, nullptr),
       current_transform_feedback_primitives_written_query_(this, nullptr),
       current_elapsed_query_(this, nullptr) {
   supported_internal_formats_storage_.insert(
       kSupportedInternalFormatsStorage,
       kSupportedInternalFormatsStorage +
           WTF_ARRAY_LENGTH(kSupportedInternalFormatsStorage));
 }
 
 void WebGL2RenderingContextBase::DestroyContext() {
   for (auto& callback : get_buffer_sub_data_async_callbacks_) {
     callback->Destroy();
   }
   get_buffer_sub_data_async_callbacks_.Clear();
 
   WebGLRenderingContextBase::DestroyContext();
 }
 
 void WebGL2RenderingContextBase::InitializeNewContext() {
   ASSERT(!isContextLost());
   ASSERT(GetDrawingBuffer());
 
   read_framebuffer_binding_ = nullptr;
 
   bound_copy_read_buffer_ = nullptr;
   bound_copy_write_buffer_ = nullptr;
   bound_pixel_pack_buffer_ = nullptr;
   bound_pixel_unpack_buffer_ = nullptr;
-  bound_transform_feedback_buffer_ = nullptr;
   bound_uniform_buffer_ = nullptr;
 
   current_boolean_occlusion_query_ = nullptr;
   current_transform_feedback_primitives_written_query_ = nullptr;
   current_elapsed_query_ = nullptr;
 
   GLint num_combined_texture_image_units = 0;
   ContextGL()->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                            &num_combined_texture_image_units);
   sampler_units_.clear();
   sampler_units_.Resize(num_combined_texture_image_units);
 
   max_transform_feedback_separate_attribs_ = 0;
+  // This must be queried before instantiating any transform feedback
+  // objects.
   ContextGL()->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
                            &max_transform_feedback_separate_attribs_);
-  bound_indexed_transform_feedback_buffers_.clear();
-  bound_indexed_transform_feedback_buffers_.Resize(
-      max_transform_feedback_separate_attribs_);
+  // Create a default transform feedback object so there is a place to
+  // hold any bound buffers.
+  default_transform_feedback_ = WebGLTransformFeedback::Create(
+      this, WebGLTransformFeedback::TFTypeDefault);
+  transform_feedback_binding_ = default_transform_feedback_;
 
   GLint max_uniform_buffer_bindings = 0;
   ContextGL()->GetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS,
                            &max_uniform_buffer_bindings);
   bound_indexed_uniform_buffers_.clear();
   bound_indexed_uniform_buffers_.Resize(max_uniform_buffer_bindings);
   max_bound_uniform_buffer_index_ = 0;
 
   pack_row_length_ = 0;
   pack_skip_pixels_ = 0;
@@ skipping 3904 matching lines @@
     default:
       SynthesizeGLError(GL_INVALID_ENUM, "getSyncParameter",
                         "invalid parameter name");
       return ScriptValue::CreateNull(script_state);
   }
 }
 
 WebGLTransformFeedback* WebGL2RenderingContextBase::createTransformFeedback() {
   if (isContextLost())
     return nullptr;
-  return WebGLTransformFeedback::Create(this);
+  return WebGLTransformFeedback::Create(this,
+                                        WebGLTransformFeedback::TFTypeUser);
 }
 
 void WebGL2RenderingContextBase::deleteTransformFeedback(
     WebGLTransformFeedback* feedback) {
   if (feedback == transform_feedback_binding_)
-    transform_feedback_binding_ = nullptr;
+    transform_feedback_binding_ = default_transform_feedback_;
 
   DeleteObject(feedback);
 }
 
 GLboolean WebGL2RenderingContextBase::isTransformFeedback(
     WebGLTransformFeedback* feedback) {
   if (isContextLost() || !feedback)
     return 0;
 
   if (!feedback->HasEverBeenBound())
@@ skipping 13 matching lines @@
                       "attempted to bind a deleted transform feedback object");
     return;
   }
 
   if (target != GL_TRANSFORM_FEEDBACK) {
     SynthesizeGLError(GL_INVALID_ENUM, "bindTransformFeedback",
                       "target must be TRANSFORM_FEEDBACK");
     return;
   }
 
-  transform_feedback_binding_ = feedback;
+  WebGLTransformFeedback* feedback_to_be_bound;
+  if (feedback) {
+    feedback_to_be_bound = feedback;
+    feedback_to_be_bound->SetTarget(target);
+  } else {
+    feedback_to_be_bound = default_transform_feedback_.Get();
+  }
 
-  ContextGL()->BindTransformFeedback(target, ObjectOrZero(feedback));
-  if (feedback) {
-    feedback->SetTarget(target);
-  }
+  transform_feedback_binding_ = feedback_to_be_bound;
+  ContextGL()->BindTransformFeedback(target,
+                                     ObjectOrZero(feedback_to_be_bound));
 }
 
 void WebGL2RenderingContextBase::beginTransformFeedback(GLenum primitive_mode) {
   if (isContextLost())
     return;
   if (!ValidateTransformFeedbackPrimitiveMode("beginTransformFeedback",
                                               primitive_mode))
     return;
 
   ContextGL()->BeginTransformFeedback(primitive_mode);
@@ skipping 181 matching lines @@
 }
 
 ScriptValue WebGL2RenderingContextBase::getIndexedParameter(
     ScriptState* script_state,
     GLenum target,
     GLuint index) {
   if (isContextLost())
     return ScriptValue::CreateNull(script_state);
 
   switch (target) {
-    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      if (index >= bound_indexed_transform_feedback_buffers_.size()) {
+    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: {
+      WebGLBuffer* buffer = nullptr;
+      if (!transform_feedback_binding_->GetBoundIndexedTransformFeedbackBuffer(
+              index, &buffer)) {
         SynthesizeGLError(GL_INVALID_VALUE, "getIndexedParameter",
                           "index out of range");
         return ScriptValue::CreateNull(script_state);
       }
-      return WebGLAny(script_state,
-                      bound_indexed_transform_feedback_buffers_[index].Get());
+      return WebGLAny(script_state, buffer);
+    }
     case GL_UNIFORM_BUFFER_BINDING:
       if (index >= bound_indexed_uniform_buffers_.size()) {
         SynthesizeGLError(GL_INVALID_VALUE, "getIndexedParameter",
                           "index out of range");
         return ScriptValue::CreateNull(script_state);
       }
       return WebGLAny(script_state,
                       bound_indexed_uniform_buffers_[index].Get());
     case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
     case GL_TRANSFORM_FEEDBACK_BUFFER_START:
@@ skipping 462 matching lines @@
       return WebGLAny(
           script_state,
           texture_units_[active_texture_unit_].texture2d_array_binding_.Get());
     case GL_TEXTURE_BINDING_3D:
       return WebGLAny(
           script_state,
           texture_units_[active_texture_unit_].texture3d_binding_.Get());
     case GL_TRANSFORM_FEEDBACK_ACTIVE:
       return GetBooleanParameter(script_state, pname);
     case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      return WebGLAny(script_state, bound_transform_feedback_buffer_.Get());
+      return WebGLAny(
+          script_state,
+          transform_feedback_binding_->GetBoundTransformFeedbackBuffer());
     case GL_TRANSFORM_FEEDBACK_BINDING:
-      return WebGLAny(script_state, transform_feedback_binding_.Get());
+      if (!transform_feedback_binding_->IsDefaultObject()) {
+        return WebGLAny(script_state, transform_feedback_binding_.Get());
+      }
+      return ScriptValue::CreateNull(script_state);
     case GL_TRANSFORM_FEEDBACK_PAUSED:
       return GetBooleanParameter(script_state, pname);
     case GL_UNIFORM_BUFFER_BINDING:
       return WebGLAny(script_state, bound_uniform_buffer_.Get());
     case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
       return GetIntParameter(script_state, pname);
     case GL_UNPACK_IMAGE_HEIGHT:
       return GetIntParameter(script_state, pname);
     case GL_UNPACK_ROW_LENGTH:
       return GetIntParameter(script_state, pname);
@@ skipping 40 matching lines @@
     case GL_RASTERIZER_DISCARD:
       return true;
     default:
       return WebGLRenderingContextBase::ValidateCapability(function_name, cap);
   }
 }
 
 bool WebGL2RenderingContextBase::IsBufferBoundToTransformFeedback(
     WebGLBuffer* buffer) {
   ASSERT(buffer);
-
-  if (bound_transform_feedback_buffer_ == buffer)
-    return true;
-
-  for (size_t i = 0; i < bound_indexed_transform_feedback_buffers_.size();
-       ++i) {
-    if (bound_indexed_transform_feedback_buffers_[i] == buffer)
-      return true;
-  }
-
-  return false;
+  return transform_feedback_binding_->IsBufferBoundToTransformFeedback(buffer);
 }
 
 bool WebGL2RenderingContextBase::IsBufferBoundToNonTransformFeedback(
     WebGLBuffer* buffer) {
   ASSERT(buffer);
 
   if (bound_array_buffer_ == buffer ||
       bound_vertex_array_object_->BoundElementArrayBuffer() == buffer ||
       bound_copy_read_buffer_ == buffer || bound_copy_write_buffer_ == buffer ||
       bound_pixel_pack_buffer_ == buffer ||
@@ skipping 109 matching lines @@
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_vertex_array_object_->SetElementArrayBuffer(buffer);
       break;
     case GL_PIXEL_PACK_BUFFER:
       bound_pixel_pack_buffer_ = buffer;
       break;
     case GL_PIXEL_UNPACK_BUFFER:
       bound_pixel_unpack_buffer_ = buffer;
       break;
     case GL_TRANSFORM_FEEDBACK_BUFFER:
-      bound_transform_feedback_buffer_ = buffer;
+      transform_feedback_binding_->SetBoundTransformFeedbackBuffer(buffer);
       break;
     case GL_UNIFORM_BUFFER:
       bound_uniform_buffer_ = buffer;
       break;
     default:
       NOTREACHED();
       break;
   }
 
   if (buffer && !buffer->GetInitialTarget())
@@ skipping 21 matching lines @@
     WebGLBuffer* buffer) {
   if (!ValidateBufferBaseTarget(function_name, target))
     return false;
 
   if (buffer &&
       !ValidateBufferTargetCompatibility(function_name, target, buffer))
     return false;
 
   switch (target) {
     case GL_TRANSFORM_FEEDBACK_BUFFER:
-      if (index >= bound_indexed_transform_feedback_buffers_.size()) {
+      if (!transform_feedback_binding_->SetBoundIndexedTransformFeedbackBuffer(
+              index, buffer)) {
         SynthesizeGLError(GL_INVALID_VALUE, function_name,
                           "index out of range");
         return false;
       }
-      bound_indexed_transform_feedback_buffers_[index] =
-          TraceWrapperMember<WebGLBuffer>(this, buffer);
-      bound_transform_feedback_buffer_ = buffer;
       break;
     case GL_UNIFORM_BUFFER:
       if (index >= bound_indexed_uniform_buffers_.size()) {
         SynthesizeGLError(GL_INVALID_VALUE, function_name,
                           "index out of range");
         return false;
       }
       bound_indexed_uniform_buffers_[index] =
           TraceWrapperMember<WebGLBuffer>(this, buffer);
       bound_uniform_buffer_ = buffer;
@@ skipping 329 matching lines @@
     default:
       break;
   }
   SynthesizeGLError(GL_INVALID_ENUM, kFunctionName, "invalid parameter name");
   return ScriptValue::CreateNull(script_state);
 }
 
 DEFINE_TRACE(WebGL2RenderingContextBase) {
   visitor->Trace(read_framebuffer_binding_);
   visitor->Trace(transform_feedback_binding_);
+  visitor->Trace(default_transform_feedback_);
   visitor->Trace(bound_copy_read_buffer_);
   visitor->Trace(bound_copy_write_buffer_);
   visitor->Trace(bound_pixel_pack_buffer_);
   visitor->Trace(bound_pixel_unpack_buffer_);
-  visitor->Trace(bound_transform_feedback_buffer_);
   visitor->Trace(bound_uniform_buffer_);
-  visitor->Trace(bound_indexed_transform_feedback_buffers_);
   visitor->Trace(bound_indexed_uniform_buffers_);
   visitor->Trace(current_boolean_occlusion_query_);
   visitor->Trace(current_transform_feedback_primitives_written_query_);
   visitor->Trace(current_elapsed_query_);
   visitor->Trace(sampler_units_);
   visitor->Trace(get_buffer_sub_data_async_callbacks_);
   WebGLRenderingContextBase::Trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(WebGL2RenderingContextBase) {
+  visitor->TraceWrappers(read_framebuffer_binding_);
   visitor->TraceWrappers(transform_feedback_binding_);
-  visitor->TraceWrappers(read_framebuffer_binding_);
   visitor->TraceWrappers(bound_copy_read_buffer_);
   visitor->TraceWrappers(bound_copy_write_buffer_);
   visitor->TraceWrappers(bound_pixel_pack_buffer_);
   visitor->TraceWrappers(bound_pixel_unpack_buffer_);
-  visitor->TraceWrappers(bound_transform_feedback_buffer_);
   visitor->TraceWrappers(bound_uniform_buffer_);
-  for (auto& buf : bound_indexed_transform_feedback_buffers_) {
-    visitor->TraceWrappers(buf);
-  }
   for (auto& buf : bound_indexed_uniform_buffers_) {
     visitor->TraceWrappers(buf);
   }
   visitor->TraceWrappers(current_boolean_occlusion_query_);
   visitor->TraceWrappers(current_transform_feedback_primitives_written_query_);
   visitor->TraceWrappers(current_elapsed_query_);
   for (auto& unit : sampler_units_) {
     visitor->TraceWrappers(unit);
   }
   WebGLRenderingContextBase::TraceWrappers(visitor);
@@ skipping 87 matching lines @@
     case GL_COPY_WRITE_BUFFER:
       buffer = bound_copy_write_buffer_.Get();
       break;
     case GL_PIXEL_PACK_BUFFER:
       buffer = bound_pixel_pack_buffer_.Get();
       break;
     case GL_PIXEL_UNPACK_BUFFER:
       buffer = bound_pixel_unpack_buffer_.Get();
       break;
     case GL_TRANSFORM_FEEDBACK_BUFFER:
-      buffer = bound_transform_feedback_buffer_.Get();
+      buffer = transform_feedback_binding_->GetBoundTransformFeedbackBuffer();
       break;
     case GL_UNIFORM_BUFFER:
       buffer = bound_uniform_buffer_.Get();
       break;
     default:
       SynthesizeGLError(GL_INVALID_ENUM, function_name, "invalid target");
       return nullptr;
   }
   if (!buffer) {
     SynthesizeGLError(GL_INVALID_OPERATION, function_name, "no buffer");
@@ skipping 78 matching lines @@
 
 void WebGL2RenderingContextBase::RemoveBoundBuffer(WebGLBuffer* buffer) {
   if (bound_copy_read_buffer_ == buffer)
     bound_copy_read_buffer_ = nullptr;
   if (bound_copy_write_buffer_ == buffer)
     bound_copy_write_buffer_ = nullptr;
   if (bound_pixel_pack_buffer_ == buffer)
     bound_pixel_pack_buffer_ = nullptr;
   if (bound_pixel_unpack_buffer_ == buffer)
     bound_pixel_unpack_buffer_ = nullptr;
-  if (bound_transform_feedback_buffer_ == buffer)
-    bound_transform_feedback_buffer_ = nullptr;
   if (bound_uniform_buffer_ == buffer)
     bound_uniform_buffer_ = nullptr;
 
+  if (transform_feedback_binding_)
+    transform_feedback_binding_->UnbindBuffer(buffer);
+
   WebGLRenderingContextBase::RemoveBoundBuffer(buffer);
 }
 
 void WebGL2RenderingContextBase::RestoreCurrentFramebuffer() {
   bindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer_binding_.Get());
   bindFramebuffer(GL_READ_FRAMEBUFFER, read_framebuffer_binding_.Get());
 }
 
+GLint WebGL2RenderingContextBase::GetMaxTransformFeedbackSeparateAttribs()
+    const {
+  return max_transform_feedback_separate_attribs_;
+}
+
 WebGLImageConversion::PixelStoreParams
 WebGL2RenderingContextBase::GetPackPixelStoreParams() {
   WebGLImageConversion::PixelStoreParams params;
   params.alignment = pack_alignment_;
   params.row_length = pack_row_length_;
   params.skip_pixels = pack_skip_pixels_;
   params.skip_rows = pack_skip_rows_;
   return params;
 }
 
@@ skipping 14 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!ContextGL())
     return;
   ContextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           ObjectOrZero(bound_pixel_unpack_buffer_.Get()));
 }
 
 }  // namespace blink