Begin tracking GL_TEXTURE_ and GL_DRAW_INDIRECT_ buffer bindings

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLGpu.h"
 #include "GrGLGLSL.h"
 #include "GrGLStencilAttachment.h"
@@ skipping 394 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLGpu::onResetContext(uint32_t resetBits) {
     // we don't use the zb at all
     if (resetBits & kMisc_GrGLBackendState) {
         GL_CALL(Disable(GR_GL_DEPTH_TEST));
         GL_CALL(DepthMask(GR_GL_FALSE));
 
+        fHWBoundTextureBufferIDIsValid = false;
+        fHWBoundDrawIndirectBufferIDIsValid = false;
+
         fHWDrawFace = GrPipelineBuilder::kInvalid_DrawFace;
 
         if (kGL_GrGLStandard == this->glStandard()) {
             // Desktop-only state that we never change
             if (!this->glCaps().isCoreProfile()) {
                 GL_CALL(Disable(GR_GL_POINT_SMOOTH));
                 GL_CALL(Disable(GR_GL_LINE_SMOOTH));
                 GL_CALL(Disable(GR_GL_POLYGON_SMOOTH));
                 GL_CALL(Disable(GR_GL_POLYGON_STIPPLE));
                 GL_CALL(Disable(GR_GL_COLOR_LOGIC_OP));
@@ skipping 1745 matching lines @@
 void GrGLGpu::buildProgramDesc(GrProgramDesc* desc,
                                const GrPrimitiveProcessor& primProc,
                                const GrPipeline& pipeline) const {
     if (!GrGLProgramDescBuilder::Build(desc, primProc, pipeline, *this->glCaps().glslCaps())) {
         SkDEBUGFAIL("Failed to generate GL program descriptor");
     }
 }
 
 void GrGLGpu::bindBuffer(GrGLuint id, GrGLenum type) {
     this->handleDirtyContext();
-    if (GR_GL_ARRAY_BUFFER == type) {
-        this->bindVertexBuffer(id);
-    } else if (GR_GL_ELEMENT_ARRAY_BUFFER == type) {
-        this->bindIndexBufferAndDefaultVertexArray(id);
-    } else {
-        GR_GL_CALL(this->glInterface(), BindBuffer(type, id));
+    switch (type) {
+        case GR_GL_ARRAY_BUFFER:
+            this->bindVertexBuffer(id);
+            break;
+        case GR_GL_ELEMENT_ARRAY_BUFFER:
+            this->bindIndexBufferAndDefaultVertexArray(id);
+            break;
+        case GR_GL_TEXTURE_BUFFER:
+            if (!fHWBoundTextureBufferIDIsValid || id != fHWBoundTextureBufferID) {
+                GR_GL_CALL(this->glInterface(), BindBuffer(type, id));
+                fHWBoundTextureBufferID = id;
+                fHWBoundTextureBufferIDIsValid = true;
+            }
+            break;
+        case GR_GL_DRAW_INDIRECT_BUFFER:
+            if (!fHWBoundDrawIndirectBufferIDIsValid || id != fHWBoundDrawIndirectBufferID) {
+                GR_GL_CALL(this->glInterface(), BindBuffer(type, id));
+                fHWBoundDrawIndirectBufferID = id;
+                fHWBoundDrawIndirectBufferIDIsValid = true;
+            }
+            break;
+        default:
+            SkDebugf("WARNING: buffer target 0x%x is not tracked by GrGLGpu.\n", type);
+            GR_GL_CALL(this->glInterface(), BindBuffer(type, id));
+            break;
     }
 }
 
 void GrGLGpu::releaseBuffer(GrGLuint id, GrGLenum type) {
     this->handleDirtyContext();
     GL_CALL(DeleteBuffers(1, &id));
-    if (GR_GL_ARRAY_BUFFER == type) {
-        this->notifyVertexBufferDelete(id);
-    } else if (GR_GL_ELEMENT_ARRAY_BUFFER == type) {
-        this->notifyIndexBufferDelete(id);
+    switch (type) {

[Chris Dalton, 2016/03/14 15:46:53]

This has technically been a bit dangerous because if the same buffer object is
bound to more than one target, the tracking state won't be updated properly for
the other targets.

[bsalomon, 2016/03/16 13:42:23]

Right now the buffer type is inherent to the Gr-object. So it seems safe. But
that brings up the question of whether it should be. We originally separated
index and vertex buffers because we had a D3D9 backend but that was deleted many
years ago.

+        case GR_GL_ARRAY_BUFFER:
+            this->notifyVertexBufferDelete(id);
+            break;
+        case GR_GL_ELEMENT_ARRAY_BUFFER:
+            this->notifyIndexBufferDelete(id);
+            break;
+        case GR_GL_TEXTURE_BUFFER:
+            if (fHWBoundTextureBufferIDIsValid && id == fHWBoundTextureBufferID) {
+                fHWBoundTextureBufferID = 0;
+            }
+            break;
+        case GR_GL_DRAW_INDIRECT_BUFFER:
+            if (fHWBoundDrawIndirectBufferIDIsValid && id == fHWBoundDrawIndirectBufferID) {
+                fHWBoundDrawIndirectBufferID = 0;
+            }
+            break;
     }
 }
 
 static GrGLenum get_gl_usage(GrGLBufferImpl::Usage usage) {
     static const GrGLenum grToGL[] = {
         GR_GL_STATIC_DRAW,   // GrGLBufferImpl::kStaticDraw_Usage
         DYNAMIC_USAGE_PARAM, // GrGLBufferImpl::kDynamicDraw_Usage
         GR_GL_STREAM_DRAW,   // GrGLBufferImpl::kStreamDraw_Usage
         GR_GL_STREAM_READ,   // GrGLBufferImpl::kStreamRead_Usage
     };
@@ skipping 2146 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }