Revert of Track GL buffer state based on unique resource ID

src/gpu/gl/GrGLVertexArray.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLVertexArray.h"
-#include "GrGLBuffer.h"
 #include "GrGLGpu.h"
 
 struct AttribLayout {
     GrGLint     fCount;
     GrGLenum    fType;
     GrGLboolean fNormalized;  // Only used by floating point types.
 };
 
 static const AttribLayout gLayouts[kGrVertexAttribTypeCount] = {
     {1, GR_GL_FLOAT, false},         // kFloat_GrVertexAttribType
@@ skipping 12 matching lines @@
 GR_STATIC_ASSERT(2 == kVec3f_GrVertexAttribType);
 GR_STATIC_ASSERT(3 == kVec4f_GrVertexAttribType);
 GR_STATIC_ASSERT(4 == kUByte_GrVertexAttribType);
 GR_STATIC_ASSERT(5 == kVec4ub_GrVertexAttribType);
 GR_STATIC_ASSERT(6 == kVec2us_GrVertexAttribType);
 GR_STATIC_ASSERT(7 == kInt_GrVertexAttribType);
 GR_STATIC_ASSERT(8 == kUint_GrVertexAttribType);
 
 void GrGLAttribArrayState::set(GrGLGpu* gpu,
                                int index,
-                               const GrGLBuffer* vertexBuffer,
+                               GrGLuint vertexBufferID,
                                GrVertexAttribType type,
                                GrGLsizei stride,
                                GrGLvoid* offset) {
     SkASSERT(index >= 0 && index < fAttribArrayStates.count());
     AttribArrayState* array = &fAttribArrayStates[index];
     if (!array->fEnableIsValid || !array->fEnabled) {
         GR_GL_CALL(gpu->glInterface(), EnableVertexAttribArray(index));
         array->fEnableIsValid = true;
         array->fEnabled = true;
     }
-    if (array->fVertexBufferUniqueID != vertexBuffer->getUniqueID() ||
+    if (!array->fAttribPointerIsValid ||
+        array->fVertexBufferID != vertexBufferID ||
         array->fType != type ||
         array->fStride != stride ||
         array->fOffset != offset) {
-        gpu->bindBuffer(kVertex_GrBufferType, vertexBuffer);
+
+        gpu->bindVertexBuffer(vertexBufferID);
         const AttribLayout& layout = gLayouts[type];
         if (!GrVertexAttribTypeIsIntType(type)) {
             GR_GL_CALL(gpu->glInterface(), VertexAttribPointer(index,
                                                                layout.fCount,
                                                                layout.fType,
                                                                layout.fNormalized,
                                                                stride,
                                                                offset));
         } else {
             SkASSERT(gpu->caps()->shaderCaps()->integerSupport());
             SkASSERT(!layout.fNormalized);
             GR_GL_CALL(gpu->glInterface(), VertexAttribIPointer(index,
                                                                 layout.fCount,
                                                                 layout.fType,
                                                                 stride,
                                                                 offset));
         }
-        array->fVertexBufferUniqueID = vertexBuffer->getUniqueID();
+        array->fAttribPointerIsValid = true;
+        array->fVertexBufferID = vertexBufferID;
         array->fType = type;
         array->fStride = stride;
         array->fOffset = offset;
     }
 }
 
 void GrGLAttribArrayState::disableUnusedArrays(const GrGLGpu* gpu, uint64_t usedMask) {
     int count = fAttribArrayStates.count();
     for (int i = 0; i < count; ++i) {
         if (!(usedMask & 0x1)) {
             if (!fAttribArrayStates[i].fEnableIsValid || fAttribArrayStates[i].fEnabled) {
                 GR_GL_CALL(gpu->glInterface(), DisableVertexAttribArray(i));
                 fAttribArrayStates[i].fEnableIsValid = true;
                 fAttribArrayStates[i].fEnabled = false;
             }
         } else {
             SkASSERT(fAttribArrayStates[i].fEnableIsValid && fAttribArrayStates[i].fEnabled);
         }
         // if the count is greater than 64 then this will become 0 and we will disable arrays 64+.
         usedMask >>= 1;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLVertexArray::GrGLVertexArray(GrGLint id, int attribCount)
     : fID(id)
     , fAttribArrays(attribCount)
-    , fIndexBufferUniqueID(SK_InvalidUniqueID) {
+    , fIndexBufferIDIsValid(false) {
 }
 
 GrGLAttribArrayState* GrGLVertexArray::bind(GrGLGpu* gpu) {
     if (0 == fID) {
         return nullptr;
     }
     gpu->bindVertexArray(fID);
     return &fAttribArrays;
 }
 
-GrGLAttribArrayState* GrGLVertexArray::bindWithIndexBuffer(GrGLGpu* gpu, const GrGLBuffer* ibuff) {
+GrGLAttribArrayState* GrGLVertexArray::bindWithIndexBuffer(GrGLGpu* gpu, GrGLuint ibufferID) {
     GrGLAttribArrayState* state = this->bind(gpu);
-    if (state && fIndexBufferUniqueID != ibuff->getUniqueID()) {
-        GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, ibuff->bufferID()));
-        fIndexBufferUniqueID = ibuff->getUniqueID();
+    if (state) {
+        if (!fIndexBufferIDIsValid || ibufferID != fIndexBufferID) {
+            GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, ibufferID));
+            fIndexBufferIDIsValid = true;
+            fIndexBufferID = ibufferID;
+        }
     }
     return state;
 }
 
+void GrGLVertexArray::notifyIndexBufferDelete(GrGLuint bufferID) {
+    if (fIndexBufferIDIsValid && bufferID == fIndexBufferID) {
+        fIndexBufferID = 0;
+    }
+ }
+
 void GrGLVertexArray::invalidateCachedState() {
     fAttribArrays.invalidate();
-    fIndexBufferUniqueID = SK_InvalidUniqueID;
+    fIndexBufferIDIsValid = false;
 }