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 "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 136 matching lines @@
     : WebGLRenderingContextBase(passedCanvas,
                                 std::move(contextProvider),
                                 requestedAttributes,
                                 2),
       m_readFramebufferBinding(this, nullptr),
       m_transformFeedbackBinding(this, nullptr),
       m_boundCopyReadBuffer(this, nullptr),
       m_boundCopyWriteBuffer(this, nullptr),
       m_boundPixelPackBuffer(this, nullptr),
       m_boundPixelUnpackBuffer(this, nullptr),
-      m_boundTransformFeedbackBuffer(this, nullptr),
       m_boundUniformBuffer(this, nullptr),
       m_currentBooleanOcclusionQuery(this, nullptr),
       m_currentTransformFeedbackPrimitivesWrittenQuery(this, nullptr),
       m_currentElapsedQuery(this, nullptr) {
   m_supportedInternalFormatsStorage.insert(
       kSupportedInternalFormatsStorage,
       kSupportedInternalFormatsStorage +
           WTF_ARRAY_LENGTH(kSupportedInternalFormatsStorage));
 }
 
 WebGL2RenderingContextBase::WebGL2RenderingContextBase(
     OffscreenCanvas* passedOffscreenCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes)
     : WebGLRenderingContextBase(passedOffscreenCanvas,
                                 std::move(contextProvider),
                                 requestedAttributes,
                                 2),
       m_readFramebufferBinding(this, nullptr),
       m_transformFeedbackBinding(this, nullptr),
       m_boundCopyReadBuffer(this, nullptr),
       m_boundCopyWriteBuffer(this, nullptr),
       m_boundPixelPackBuffer(this, nullptr),
       m_boundPixelUnpackBuffer(this, nullptr),
-      m_boundTransformFeedbackBuffer(this, nullptr),
       m_boundUniformBuffer(this, nullptr),
       m_currentBooleanOcclusionQuery(this, nullptr),
       m_currentTransformFeedbackPrimitivesWrittenQuery(this, nullptr),
       m_currentElapsedQuery(this, nullptr) {
   m_supportedInternalFormatsStorage.insert(
       kSupportedInternalFormatsStorage,
       kSupportedInternalFormatsStorage +
           WTF_ARRAY_LENGTH(kSupportedInternalFormatsStorage));
 }
 
 void WebGL2RenderingContextBase::destroyContext() {
   for (auto& callback : m_getBufferSubDataAsyncCallbacks) {
     callback->destroy();
   }
   m_getBufferSubDataAsyncCallbacks.clear();
 
   WebGLRenderingContextBase::destroyContext();
 }
 
 void WebGL2RenderingContextBase::initializeNewContext() {
   ASSERT(!isContextLost());
   ASSERT(drawingBuffer());
 
   m_readFramebufferBinding = nullptr;
 
   m_boundCopyReadBuffer = nullptr;
   m_boundCopyWriteBuffer = nullptr;
   m_boundPixelPackBuffer = nullptr;
   m_boundPixelUnpackBuffer = nullptr;
-  m_boundTransformFeedbackBuffer = nullptr;
   m_boundUniformBuffer = nullptr;
 
   m_currentBooleanOcclusionQuery = nullptr;
   m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
   m_currentElapsedQuery = nullptr;
 
   GLint numCombinedTextureImageUnits = 0;
   contextGL()->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                            &numCombinedTextureImageUnits);
   m_samplerUnits.clear();
   m_samplerUnits.resize(numCombinedTextureImageUnits);
 
   m_maxTransformFeedbackSeparateAttribs = 0;
+  // This must be queried before instantiating any transform feedback
+  // objects.
   contextGL()->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
                            &m_maxTransformFeedbackSeparateAttribs);
-  m_boundIndexedTransformFeedbackBuffers.clear();
-  m_boundIndexedTransformFeedbackBuffers.resize(
-      m_maxTransformFeedbackSeparateAttribs);
+  // Create a default transform feedback object so there is a place to
+  // hold any bound buffers.
+  m_defaultTransformFeedback = WebGLTransformFeedback::create(
+      this, WebGLTransformFeedback::TFTypeDefault);
+  m_transformFeedbackBinding = m_defaultTransformFeedback;
 
   GLint maxUniformBufferBindings = 0;
   contextGL()->GetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS,
                            &maxUniformBufferBindings);
   m_boundIndexedUniformBuffers.clear();
   m_boundIndexedUniformBuffers.resize(maxUniformBufferBindings);
   m_maxBoundUniformBufferIndex = 0;
 
   m_packRowLength = 0;
   m_packSkipPixels = 0;
@@ skipping 3812 matching lines @@
     default:
       synthesizeGLError(GL_INVALID_ENUM, "getSyncParameter",
                         "invalid parameter name");
       return ScriptValue::createNull(scriptState);
   }
 }
 
 WebGLTransformFeedback* WebGL2RenderingContextBase::createTransformFeedback() {
   if (isContextLost())
     return nullptr;
-  return WebGLTransformFeedback::create(this);
+  return WebGLTransformFeedback::create(this,
+                                        WebGLTransformFeedback::TFTypeUser);
 }
 
 void WebGL2RenderingContextBase::deleteTransformFeedback(
     WebGLTransformFeedback* feedback) {
   if (feedback == m_transformFeedbackBinding)
-    m_transformFeedbackBinding = nullptr;
+    m_transformFeedbackBinding = m_defaultTransformFeedback;
 
   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;
   }
 
-  m_transformFeedbackBinding = feedback;
+  WebGLTransformFeedback* feedbackToBeBound;
+  if (feedback) {
+    feedbackToBeBound = feedback;
+    feedbackToBeBound->setTarget(target);
+  } else {
+    feedbackToBeBound = m_defaultTransformFeedback.get();
+  }
 
-  contextGL()->BindTransformFeedback(target, objectOrZero(feedback));
-  if (feedback) {
-    feedback->setTarget(target);
-  }
+  m_transformFeedbackBinding = feedbackToBeBound;
+  contextGL()->BindTransformFeedback(target, objectOrZero(feedbackToBeBound));
 }
 
 void WebGL2RenderingContextBase::beginTransformFeedback(GLenum primitiveMode) {
   if (isContextLost())
     return;
   if (!validateTransformFeedbackPrimitiveMode("beginTransformFeedback",
                                               primitiveMode))
     return;
 
   contextGL()->BeginTransformFeedback(primitiveMode);
@@ skipping 181 matching lines @@
 }
 
 ScriptValue WebGL2RenderingContextBase::getIndexedParameter(
     ScriptState* scriptState,
     GLenum target,
     GLuint index) {
   if (isContextLost())
     return ScriptValue::createNull(scriptState);
 
   switch (target) {
-    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      if (index >= m_boundIndexedTransformFeedbackBuffers.size()) {
+    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: {
+      WebGLBuffer* buffer = nullptr;
+      if (!m_transformFeedbackBinding->getBoundIndexedTransformFeedbackBuffer(
+              index, &buffer)) {
         synthesizeGLError(GL_INVALID_VALUE, "getIndexedParameter",
                           "index out of range");
         return ScriptValue::createNull(scriptState);
       }
-      return WebGLAny(scriptState,
-                      m_boundIndexedTransformFeedbackBuffers[index].get());
+      return WebGLAny(scriptState, buffer);
+    }
     case GL_UNIFORM_BUFFER_BINDING:
       if (index >= m_boundIndexedUniformBuffers.size()) {
         synthesizeGLError(GL_INVALID_VALUE, "getIndexedParameter",
                           "index out of range");
         return ScriptValue::createNull(scriptState);
       }
       return WebGLAny(scriptState, m_boundIndexedUniformBuffers[index].get());
     case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
     case GL_TRANSFORM_FEEDBACK_BUFFER_START:
     case GL_UNIFORM_BUFFER_SIZE:
@@ skipping 458 matching lines @@
       return WebGLAny(
           scriptState,
           m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding.get());
     case GL_TEXTURE_BINDING_3D:
       return WebGLAny(
           scriptState,
           m_textureUnits[m_activeTextureUnit].m_texture3DBinding.get());
     case GL_TRANSFORM_FEEDBACK_ACTIVE:
       return getBooleanParameter(scriptState, pname);
     case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      return WebGLAny(scriptState, m_boundTransformFeedbackBuffer.get());
+      return WebGLAny(
+          scriptState,
+          m_transformFeedbackBinding->getBoundTransformFeedbackBuffer());
     case GL_TRANSFORM_FEEDBACK_BINDING:
-      return WebGLAny(scriptState, m_transformFeedbackBinding.get());
+      if (!m_transformFeedbackBinding->isDefaultObject()) {
+        return WebGLAny(scriptState, m_transformFeedbackBinding.get());
+      }
+      return ScriptValue::createNull(scriptState);
     case GL_TRANSFORM_FEEDBACK_PAUSED:
       return getBooleanParameter(scriptState, pname);
     case GL_UNIFORM_BUFFER_BINDING:
       return WebGLAny(scriptState, m_boundUniformBuffer.get());
     case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
       return getIntParameter(scriptState, pname);
     case GL_UNPACK_IMAGE_HEIGHT:
       return getIntParameter(scriptState, pname);
     case GL_UNPACK_ROW_LENGTH:
       return getIntParameter(scriptState, pname);
@@ skipping 40 matching lines @@
     case GL_RASTERIZER_DISCARD:
       return true;
     default:
       return WebGLRenderingContextBase::validateCapability(functionName, cap);
   }
 }
 
 bool WebGL2RenderingContextBase::isBufferBoundToTransformFeedback(
     WebGLBuffer* buffer) {
   ASSERT(buffer);
-
-  if (m_boundTransformFeedbackBuffer == buffer)
-    return true;
-
-  for (size_t i = 0; i < m_boundIndexedTransformFeedbackBuffers.size(); ++i) {
-    if (m_boundIndexedTransformFeedbackBuffers[i] == buffer)
-      return true;
-  }
-
-  return false;
+  return m_transformFeedbackBinding->isBufferBoundToTransformFeedback(buffer);
 }
 
 bool WebGL2RenderingContextBase::isBufferBoundToNonTransformFeedback(
     WebGLBuffer* buffer) {
   ASSERT(buffer);
 
   if (m_boundArrayBuffer == buffer ||
       m_boundVertexArrayObject->boundElementArrayBuffer() == buffer ||
       m_boundCopyReadBuffer == buffer || m_boundCopyWriteBuffer == buffer ||
       m_boundPixelPackBuffer == buffer || m_boundPixelUnpackBuffer == buffer ||
@@ skipping 109 matching lines @@
     case GL_ELEMENT_ARRAY_BUFFER:
       m_boundVertexArrayObject->setElementArrayBuffer(buffer);
       break;
     case GL_PIXEL_PACK_BUFFER:
       m_boundPixelPackBuffer = buffer;
       break;
     case GL_PIXEL_UNPACK_BUFFER:
       m_boundPixelUnpackBuffer = buffer;
       break;
     case GL_TRANSFORM_FEEDBACK_BUFFER:
-      m_boundTransformFeedbackBuffer = buffer;
+      m_transformFeedbackBinding->setBoundTransformFeedbackBuffer(buffer);
       break;
     case GL_UNIFORM_BUFFER:
       m_boundUniformBuffer = buffer;
       break;
     default:
       ASSERT_NOT_REACHED();
       break;
   }
 
   if (buffer && !buffer->getInitialTarget())
@@ skipping 21 matching lines @@
     WebGLBuffer* buffer) {
   if (!validateBufferBaseTarget(functionName, target))
     return false;
 
   if (buffer &&
       !validateBufferTargetCompatibility(functionName, target, buffer))
     return false;
 
   switch (target) {
     case GL_TRANSFORM_FEEDBACK_BUFFER:
-      if (index >= m_boundIndexedTransformFeedbackBuffers.size()) {
+      if (!m_transformFeedbackBinding->setBoundIndexedTransformFeedbackBuffer(
+              index, buffer)) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "index out of range");
         return false;
       }
-      m_boundIndexedTransformFeedbackBuffers[index] =
-          TraceWrapperMember<WebGLBuffer>(this, buffer);
-      m_boundTransformFeedbackBuffer = buffer;
       break;
     case GL_UNIFORM_BUFFER:
       if (index >= m_boundIndexedUniformBuffers.size()) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "index out of range");
         return false;
       }
       m_boundIndexedUniformBuffers[index] =
           TraceWrapperMember<WebGLBuffer>(this, buffer);
       m_boundUniformBuffer = buffer;
 
@@ skipping 329 matching lines @@
     default:
       break;
   }
   synthesizeGLError(GL_INVALID_ENUM, kFunctionName, "invalid parameter name");
   return ScriptValue::createNull(scriptState);
 }
 
 DEFINE_TRACE(WebGL2RenderingContextBase) {
   visitor->trace(m_readFramebufferBinding);
   visitor->trace(m_transformFeedbackBinding);
+  visitor->trace(m_defaultTransformFeedback);
   visitor->trace(m_boundCopyReadBuffer);
   visitor->trace(m_boundCopyWriteBuffer);
   visitor->trace(m_boundPixelPackBuffer);
   visitor->trace(m_boundPixelUnpackBuffer);
-  visitor->trace(m_boundTransformFeedbackBuffer);
   visitor->trace(m_boundUniformBuffer);
-  visitor->trace(m_boundIndexedTransformFeedbackBuffers);
   visitor->trace(m_boundIndexedUniformBuffers);
   visitor->trace(m_currentBooleanOcclusionQuery);
   visitor->trace(m_currentTransformFeedbackPrimitivesWrittenQuery);
   visitor->trace(m_currentElapsedQuery);
   visitor->trace(m_samplerUnits);
   visitor->trace(m_getBufferSubDataAsyncCallbacks);
   WebGLRenderingContextBase::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(WebGL2RenderingContextBase) {
+  visitor->traceWrappers(m_readFramebufferBinding);
   visitor->traceWrappers(m_transformFeedbackBinding);
-  visitor->traceWrappers(m_readFramebufferBinding);
   visitor->traceWrappers(m_boundCopyReadBuffer);
   visitor->traceWrappers(m_boundCopyWriteBuffer);
   visitor->traceWrappers(m_boundPixelPackBuffer);
   visitor->traceWrappers(m_boundPixelUnpackBuffer);
-  visitor->traceWrappers(m_boundTransformFeedbackBuffer);
   visitor->traceWrappers(m_boundUniformBuffer);
-  for (auto& buf : m_boundIndexedTransformFeedbackBuffers) {
-    visitor->traceWrappers(buf);
-  }
   for (auto& buf : m_boundIndexedUniformBuffers) {
     visitor->traceWrappers(buf);
   }
   visitor->traceWrappers(m_currentBooleanOcclusionQuery);
   visitor->traceWrappers(m_currentTransformFeedbackPrimitivesWrittenQuery);
   visitor->traceWrappers(m_currentElapsedQuery);
   for (auto& unit : m_samplerUnits) {
     visitor->traceWrappers(unit);
   }
   WebGLRenderingContextBase::traceWrappers(visitor);
@@ skipping 87 matching lines @@
     case GL_COPY_WRITE_BUFFER:
       buffer = m_boundCopyWriteBuffer.get();
       break;
     case GL_PIXEL_PACK_BUFFER:
       buffer = m_boundPixelPackBuffer.get();
       break;
     case GL_PIXEL_UNPACK_BUFFER:
       buffer = m_boundPixelUnpackBuffer.get();
       break;
     case GL_TRANSFORM_FEEDBACK_BUFFER:
-      buffer = m_boundTransformFeedbackBuffer.get();
+      buffer = m_transformFeedbackBinding->getBoundTransformFeedbackBuffer();
       break;
     case GL_UNIFORM_BUFFER:
       buffer = m_boundUniformBuffer.get();
       break;
     default:
       synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid target");
       return nullptr;
   }
   if (!buffer) {
     synthesizeGLError(GL_INVALID_OPERATION, functionName, "no buffer");
@@ skipping 78 matching lines @@
 
 void WebGL2RenderingContextBase::removeBoundBuffer(WebGLBuffer* buffer) {
   if (m_boundCopyReadBuffer == buffer)
     m_boundCopyReadBuffer = nullptr;
   if (m_boundCopyWriteBuffer == buffer)
     m_boundCopyWriteBuffer = nullptr;
   if (m_boundPixelPackBuffer == buffer)
     m_boundPixelPackBuffer = nullptr;
   if (m_boundPixelUnpackBuffer == buffer)
     m_boundPixelUnpackBuffer = nullptr;
-  if (m_boundTransformFeedbackBuffer == buffer)
-    m_boundTransformFeedbackBuffer = nullptr;
   if (m_boundUniformBuffer == buffer)
     m_boundUniformBuffer = nullptr;
 
   WebGLRenderingContextBase::removeBoundBuffer(buffer);
 }
 
 void WebGL2RenderingContextBase::restoreCurrentFramebuffer() {
   bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_framebufferBinding.get());
   bindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding.get());
 }
 
+GLint WebGL2RenderingContextBase::getMaxTransformFeedbackSeparateAttribs()
+    const {
+  return m_maxTransformFeedbackSeparateAttribs;
+}
+
 WebGLImageConversion::PixelStoreParams
 WebGL2RenderingContextBase::getPackPixelStoreParams() {
   WebGLImageConversion::PixelStoreParams params;
   params.alignment = m_packAlignment;
   params.rowLength = m_packRowLength;
   params.skipPixels = m_packSkipPixels;
   params.skipRows = m_packSkipRows;
   return params;
 }
 
@@ skipping 14 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!contextGL())
     return;
   contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           objectOrZero(m_boundPixelUnpackBuffer.get()));
 }
 
 }  // namespace blink