Fix state management of transform feedback buffers.

third_party/WebKit/Source/modules/webgl/WebGLTransformFeedback.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/WebGLTransformFeedback.h"
 
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 namespace blink {
 
 WebGLTransformFeedback* WebGLTransformFeedback::create(
-    WebGL2RenderingContextBase* ctx) {
-  return new WebGLTransformFeedback(ctx);
+    WebGL2RenderingContextBase* ctx,
+    TFType type) {
+  return new WebGLTransformFeedback(ctx, type);
 }
 
-WebGLTransformFeedback::WebGLTransformFeedback(WebGL2RenderingContextBase* ctx)
-    : WebGLSharedPlatform3DObject(ctx), m_target(0), m_program(nullptr) {
-  GLuint tf;
-  ctx->contextGL()->GenTransformFeedbacks(1, &tf);
-  setObject(tf);
+WebGLTransformFeedback::WebGLTransformFeedback(WebGL2RenderingContextBase* ctx,
+                                               TFType type)
+    : WebGLSharedPlatform3DObject(ctx),
+      m_type(type),
+      m_target(0),
+      m_boundTransformFeedbackBuffer(this, nullptr),
+      m_program(nullptr) {
+  GLint maxAttribs = ctx->getMaxTransformFeedbackSeparateAttribs();
+  DCHECK_GE(maxAttribs, 0);
+  m_boundIndexedTransformFeedbackBuffers.resize(maxAttribs);
+
+  switch (m_type) {
+    case TFTypeDefault:
+      break;
+    default: {
+      GLuint tf;
+      ctx->contextGL()->GenTransformFeedbacks(1, &tf);
+      setObject(tf);
+      break;
+    }
+  }
 }
 
 WebGLTransformFeedback::~WebGLTransformFeedback() {
   runDestructor();
 }
 
 void WebGLTransformFeedback::deleteObjectImpl(gpu::gles2::GLES2Interface* gl) {
-  gl->DeleteTransformFeedbacks(1, &m_object);
-  m_object = 0;
+  switch (m_type) {
+    case TFTypeDefault:
+      break;
+    default:

[Kai Ninomiya, 2017/03/23 23:26:34]

"default:" seems unclear to me. Why not do either 2 explicit cases, or "if
(m_type == TFTypeUser)"?

[Ken Russell (switch to Gerrit), 2017/03/23 23:31:32]

Good point; this was sloppy on my part. I copied this from the VAO code. Done.

+      gl->DeleteTransformFeedbacks(1, &m_object);
+      m_object = 0;
+      break;
+  }
 }
 
 void WebGLTransformFeedback::setTarget(GLenum target) {
   if (m_target)
     return;
   if (target == GL_TRANSFORM_FEEDBACK)
     m_target = target;
 }
 
 void WebGLTransformFeedback::setProgram(WebGLProgram* program) {
   m_program = program;
 }
 
+void WebGLTransformFeedback::setBoundTransformFeedbackBuffer(
+    WebGLBuffer* buffer) {
+  m_boundTransformFeedbackBuffer = buffer;
+}
+
+WebGLBuffer* WebGLTransformFeedback::getBoundTransformFeedbackBuffer() const {
+  return m_boundTransformFeedbackBuffer;
+}
+
+bool WebGLTransformFeedback::setBoundIndexedTransformFeedbackBuffer(
+    GLuint index,
+    WebGLBuffer* buffer) {
+  if (index >= m_boundIndexedTransformFeedbackBuffers.size())
+    return false;
+  m_boundIndexedTransformFeedbackBuffers[index] =
+      TraceWrapperMember<WebGLBuffer>(this, buffer);
+  // This also sets the generic binding point in the OpenGL state.
+  m_boundTransformFeedbackBuffer = buffer;
+  return true;
+}
+
+bool WebGLTransformFeedback::getBoundIndexedTransformFeedbackBuffer(
+    GLuint index,
+    WebGLBuffer** outBuffer) const {
+  if (index >= m_boundIndexedTransformFeedbackBuffers.size())
+    return false;
+  *outBuffer = m_boundIndexedTransformFeedbackBuffers[index].get();
+  return true;
+}
+
+bool WebGLTransformFeedback::isBufferBoundToTransformFeedback(
+    WebGLBuffer* 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;
+}
+
 DEFINE_TRACE(WebGLTransformFeedback) {
+  visitor->trace(m_boundTransformFeedbackBuffer);
+  visitor->trace(m_boundIndexedTransformFeedbackBuffers);
   visitor->trace(m_program);
   WebGLSharedPlatform3DObject::trace(visitor);
 }
 
+DEFINE_TRACE_WRAPPERS(WebGLTransformFeedback) {
+  visitor->traceWrappers(m_boundTransformFeedbackBuffer);
+  for (auto& buf : m_boundIndexedTransformFeedbackBuffers) {
+    visitor->traceWrappers(buf);
+  }
+  WebGLSharedPlatform3DObject::traceWrappers(visitor);
+}
+
 }  // namespace blink