Track GL buffer state based on unique resource ID

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 "GrGLBuffer.h"
 #include "GrGLGLSL.h"
@@ skipping 170 matching lines @@
     if (glContext) {
         return new GrGLGpu(glContext, context);
     }
     return nullptr;
 }
 
 static bool gPrintStartupSpew;
 
 GrGLGpu::GrGLGpu(GrGLContext* ctx, GrContext* context)
     : GrGpu(context)
-    , fGLContext(ctx) {
+    , fGLContext(ctx)
+    , fProgramCache(new ProgramCache(this))
+    , fHWProgramID(0)
+    , fTempSrcFBOID(0)
+    , fTempDstFBOID(0)
+    , fStencilClearFBOID(0)
+    , fHWPLSEnabled(false)
+    , fPLSHasBeenUsed(false)
+    , fHWMinSampleShading(0.0) {
+    for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) {
+        fCopyPrograms[i].fProgram = 0;
+    }
+    fWireRectProgram.fProgram = 0;
+    fPLSSetupProgram.fProgram = 0;
+
     SkASSERT(ctx);
     fCaps.reset(SkRef(ctx->caps()));
 
     fHWBoundTextureUniqueIDs.reset(this->glCaps().glslCaps()->maxCombinedSamplers());
 
+    fHWBufferState[kVertex_GrBufferType].fGLTarget = GR_GL_ARRAY_BUFFER;
+    fHWBufferState[kIndex_GrBufferType].fGLTarget = GR_GL_ELEMENT_ARRAY_BUFFER;
+    fHWBufferState[kTexel_GrBufferType].fGLTarget = GR_GL_TEXTURE_BUFFER;
+    fHWBufferState[kDrawIndirect_GrBufferType].fGLTarget = GR_GL_DRAW_INDIRECT_BUFFER;
+    if (GrGLCaps::kChromium_TransferBufferType == this->glCaps().transferBufferType()) {
+        fHWBufferState[kXferCpuToGpu_GrBufferType].fGLTarget =
+            GR_GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM;
+        fHWBufferState[kXferGpuToCpu_GrBufferType].fGLTarget =
+            GR_GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM;
+    } else {
+        fHWBufferState[kXferCpuToGpu_GrBufferType].fGLTarget = GR_GL_PIXEL_UNPACK_BUFFER;
+        fHWBufferState[kXferGpuToCpu_GrBufferType].fGLTarget = GR_GL_PIXEL_PACK_BUFFER;
+    }
+    GR_STATIC_ASSERT(6 == SK_ARRAY_COUNT(fHWBufferState));
+
+    if (this->glCaps().shaderCaps()->pathRenderingSupport()) {
+        fPathRendering.reset(new GrGLPathRendering(this));
+    }
+
     GrGLClearErr(this->glInterface());
     if (gPrintStartupSpew) {
         const GrGLubyte* vendor;
         const GrGLubyte* renderer;
         const GrGLubyte* version;
         GL_CALL_RET(vendor, GetString(GR_GL_VENDOR));
         GL_CALL_RET(renderer, GetString(GR_GL_RENDERER));
         GL_CALL_RET(version, GetString(GR_GL_VERSION));
         SkDebugf("------------------------- create GrGLGpu %p --------------\n",
                  this);
         SkDebugf("------ VENDOR %s\n", vendor);
         SkDebugf("------ RENDERER %s\n", renderer);
         SkDebugf("------ VERSION %s\n",  version);
         SkDebugf("------ EXTENSIONS\n");
         this->glContext().extensions().print();
         SkDebugf("\n");
         SkDebugf("%s", this->glCaps().dump().c_str());
     }
-
-    fProgramCache = new ProgramCache(this);
-
-    fHWProgramID = 0;
-    fTempSrcFBOID = 0;
-    fTempDstFBOID = 0;
-    fStencilClearFBOID = 0;
-
-    if (this->glCaps().shaderCaps()->pathRenderingSupport()) {
-        fPathRendering.reset(new GrGLPathRendering(this));
-    }
-    this->createCopyPrograms();
-    fWireRectProgram.fProgram = 0;
-    fWireRectArrayBuffer = 0;
-    if (this->glCaps().shaderCaps()->plsPathRenderingSupport()) {
-        this->createPLSSetupProgram();
-    }
-    else {
-        memset(&fPLSSetupProgram, 0, sizeof(fPLSSetupProgram));
-    }
-    fHWPLSEnabled = false;
-    fPLSHasBeenUsed = false;
-    fHWMinSampleShading = 0.0;
 }
 
 GrGLGpu::~GrGLGpu() {
-    // Delete the path rendering explicitly, since it will need working gpu object to release the
-    // resources the object itself holds.
+    // Ensure any GrGpuResource objects get deleted first, since they will require a working GrGpu
+    // to release the resources held by the objects themselves.
     fPathRendering.reset();
+    fCopyProgramArrayBuffer.reset();

[bsalomon, 2016/04/05 15:17:28]

Should we go ahead and declare GrGLGpu final? I doubt it would ever get
subclassed, but if so this could be a problem.

[Chris Dalton, 2016/04/05 17:59:15]

Done.

+    fWireRectArrayBuffer.reset();
+    fPLSSetupProgram.fArrayBuffer.reset();
 
     if (0 != fHWProgramID) {
         // detach the current program so there is no confusion on OpenGL's part
         // that we want it to be deleted
         GL_CALL(UseProgram(0));
     }
 
     if (0 != fTempSrcFBOID) {
         GL_CALL(DeleteFramebuffers(1, &fTempSrcFBOID));
     }
     if (0 != fTempDstFBOID) {
         GL_CALL(DeleteFramebuffers(1, &fTempDstFBOID));
     }
     if (0 != fStencilClearFBOID) {
         GL_CALL(DeleteFramebuffers(1, &fStencilClearFBOID));
     }
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) {
         if (0 != fCopyPrograms[i].fProgram) {
             GL_CALL(DeleteProgram(fCopyPrograms[i].fProgram));
         }
     }
 
-    if (0 != fCopyProgramArrayBuffer) {
-        GL_CALL(DeleteBuffers(1, &fCopyProgramArrayBuffer));
-    }
-
     if (0 != fWireRectProgram.fProgram) {
         GL_CALL(DeleteProgram(fWireRectProgram.fProgram));
     }
 
-    if (0 != fWireRectArrayBuffer) {
-        GL_CALL(DeleteBuffers(1, &fWireRectArrayBuffer));
-    }
-
-    if (0 != fPLSSetupProgram.fArrayBuffer) {
-        GL_CALL(DeleteBuffers(1, &fPLSSetupProgram.fArrayBuffer));
-    }
-
     if (0 != fPLSSetupProgram.fProgram) {
         GL_CALL(DeleteProgram(fPLSSetupProgram.fProgram));
     }
 
     delete fProgramCache;
 }
 
+void GrGLGpu::initGpuResources() {

[bsalomon, 2016/04/05 15:17:28]

Could we eliminate the need for this deferred initializer by just doing these
things lazily the first time they are needed?

[Chris Dalton, 2016/04/05 17:59:15]

Done.

+    this->createCopyPrograms();
+
+    if (this->glCaps().shaderCaps()->plsPathRenderingSupport()) {
+        this->createPLSSetupProgram();
+    }
+}
+
 void GrGLGpu::createPLSSetupProgram() {
     const GrGLSLCaps* glslCaps = this->glCaps().glslCaps();
     const char* version = glslCaps->versionDeclString();
 
     GrGLSLShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
     GrGLSLShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType,
                                    GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar uPosXform("u_posXform", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar uTexture("u_texture", kSampler2D_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
@@ skipping 64 matching lines @@
     GL_CALL(LinkProgram(fPLSSetupProgram.fProgram));
 
     GL_CALL_RET(fPLSSetupProgram.fPosXformUniform, GetUniformLocation(fPLSSetupProgram.fProgram,
                                                                   "u_posXform"));
 
     GL_CALL(BindAttribLocation(fPLSSetupProgram.fProgram, 0, "a_vertex"));
 
     GL_CALL(DeleteShader(vshader));
     GL_CALL(DeleteShader(fshader));
 
-    GL_CALL(GenBuffers(1, &fPLSSetupProgram.fArrayBuffer));
-    fHWGeometryState.setVertexBufferID(this, fPLSSetupProgram.fArrayBuffer);
-    static const GrGLfloat vdata[] = {
-        0, 0,
-        0, 1,
-        1, 0,
-        1, 1
-    };
-    GL_ALLOC_CALL(this->glInterface(),
-                  BufferData(GR_GL_ARRAY_BUFFER,
-                             (GrGLsizeiptr) sizeof(vdata),
-                             vdata,  // data ptr
-                             GR_GL_STATIC_DRAW));
+    fPLSSetupProgram.fArrayBuffer.reset(
+        GrGLBuffer::Create(this, 4 * 2 * sizeof(GrGLfloat), kVertex_GrBufferType,
+                           kStatic_GrAccessPattern, (const GrGLfloat[4 * 2]) {
+            0, 0,
+            0, 1,
+            1, 0,
+            1, 1
+        })
+    );
 }
 
 void GrGLGpu::disconnect(DisconnectType type) {
     INHERITED::disconnect(type);
     if (DisconnectType::kCleanup == type) {
         if (fHWProgramID) {
             GL_CALL(UseProgram(0));
         }
         if (fTempSrcFBOID) {
             GL_CALL(DeleteFramebuffers(1, &fTempSrcFBOID));
         }
         if (fTempDstFBOID) {
             GL_CALL(DeleteFramebuffers(1, &fTempDstFBOID));
         }
         if (fStencilClearFBOID) {
             GL_CALL(DeleteFramebuffers(1, &fStencilClearFBOID));
         }
-        if (fCopyProgramArrayBuffer) {
-            GL_CALL(DeleteBuffers(1, &fCopyProgramArrayBuffer));
-        }
         for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) {
             if (fCopyPrograms[i].fProgram) {
                 GL_CALL(DeleteProgram(fCopyPrograms[i].fProgram));
             }
         }
         if (fWireRectProgram.fProgram) {
             GL_CALL(DeleteProgram(fWireRectProgram.fProgram));
         }
-        if (fWireRectArrayBuffer) {
-            GL_CALL(DeleteBuffers(1, &fWireRectArrayBuffer));
-        }
-
         if (fPLSSetupProgram.fProgram) {
             GL_CALL(DeleteProgram(fPLSSetupProgram.fProgram));
         }
-        if (fPLSSetupProgram.fArrayBuffer) {
-            GL_CALL(DeleteBuffers(1, &fPLSSetupProgram.fArrayBuffer));
-        }
     } else {
         if (fProgramCache) {
             fProgramCache->abandon();
         }
+        if (fCopyProgramArrayBuffer) {

[bsalomon, 2016/04/05 15:17:28]

We shouldn't ever call abandon outside of the cache. It is only public because
of some terrible issue in Chromium. The cache will abandon all the GrGpuResource
instances.

[Chris Dalton, 2016/04/05 17:59:15]

Done.

+            fCopyProgramArrayBuffer->abandon();
+        }
+        if (fWireRectArrayBuffer) {
+            fWireRectArrayBuffer->abandon();
+        }
+        if (fPLSSetupProgram.fArrayBuffer) {
+            fPLSSetupProgram.fArrayBuffer->abandon();
+        }
     }
 
     delete fProgramCache;
     fProgramCache = nullptr;
 
     fHWProgramID = 0;
     fTempSrcFBOID = 0;
     fTempDstFBOID = 0;
     fStencilClearFBOID = 0;
-    fCopyProgramArrayBuffer = 0;
+    fCopyProgramArrayBuffer.reset();
     for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) {
         fCopyPrograms[i].fProgram = 0;
     }
     fWireRectProgram.fProgram = 0;
-    fWireRectArrayBuffer = 0;
+    fWireRectArrayBuffer.reset();
     fPLSSetupProgram.fProgram = 0;
-    fPLSSetupProgram.fArrayBuffer = 0;
+    fPLSSetupProgram.fArrayBuffer.reset();
     if (this->glCaps().shaderCaps()->pathRenderingSupport()) {
         this->glPathRendering()->disconnect(type);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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;
+        fHWBufferState[kTexel_GrBufferType].invalidate();
+        fHWBufferState[kDrawIndirect_GrBufferType].invalidate();
+        fHWBufferState[kXferCpuToGpu_GrBufferType].invalidate();
+        fHWBufferState[kXferGpuToCpu_GrBufferType].invalidate();
 
         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));
@@ skipping 60 matching lines @@
         fHWViewport.invalidate();
     }
 
     if (resetBits & kStencil_GrGLBackendState) {
         fHWStencilSettings.invalidate();
         fHWStencilTestEnabled = kUnknown_TriState;
     }
 
     // Vertex
     if (resetBits & kVertex_GrGLBackendState) {
-        fHWGeometryState.invalidate();
+        fHWVertexArrayState.invalidate();
+        fHWBufferState[kVertex_GrBufferType].invalidate();
+        fHWBufferState[kIndex_GrBufferType].invalidate();
     }
 
     if (resetBits & kRenderTarget_GrGLBackendState) {
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
         fHWSRGBFramebuffer = kUnknown_TriState;
     }
 
     if (resetBits & kPathRendering_GrGLBackendState) {
         if (this->caps()->shaderCaps()->pathRenderingSupport()) {
             this->glPathRendering()->resetContext();
@@ skipping 341 matching lines @@
     }
 
     // For the moment, can't transfer compressed data
     if (GrPixelConfigIsCompressed(glTex->desc().fConfig)) {
         return false;
     }
 
     this->setScratchTextureUnit();
     GL_CALL(BindTexture(glTex->target(), glTex->textureID()));
 
-    SkASSERT(kXferCpuToGpu_GrBufferType == transferBuffer->type());
     SkASSERT(!transferBuffer->isMapped());
     SkASSERT(!transferBuffer->isCPUBacked());
     const GrGLBuffer* glBuffer = static_cast<const GrGLBuffer*>(transferBuffer);
-    this->bindBuffer(glBuffer->bufferID(), glBuffer->target());
+    this->bindBuffer(kXferCpuToGpu_GrBufferType, glBuffer);
 
     bool success = false;
     GrMipLevel mipLevel;
     mipLevel.fPixels = transferBuffer;
     mipLevel.fRowBytes = rowBytes;
     SkSTArray<1, GrMipLevel> texels;
     texels.push_back(mipLevel);
     success = this->uploadTexData(glTex->desc(), glTex->target(), kTransfer_UploadType,
                                   left, top, width, height, config, texels);
     if (success) {
@@ skipping 1049 matching lines @@
                                                                format);
     return stencil;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // GL_STREAM_DRAW triggers an optimization in Chromium's GPU process where a client's vertex buffer
 // objects are implemented as client-side-arrays on tile-deferred architectures.
 #define DYNAMIC_USAGE_PARAM GR_GL_STREAM_DRAW
 
-GrBuffer* GrGLGpu::onCreateBuffer(GrBufferType type, size_t size, GrAccessPattern accessPattern) {
-    return GrGLBuffer::Create(this, type, size, accessPattern);
+GrBuffer* GrGLGpu::onCreateBuffer(size_t size, GrBufferType intendedType,
+                                  GrAccessPattern accessPattern) {
+    return GrGLBuffer::Create(this, size, intendedType, accessPattern);
 }
 
 void GrGLGpu::flushScissor(const GrScissorState& scissorState,
                            const GrGLIRect& rtViewport,
                            GrSurfaceOrigin rtOrigin) {
     if (scissorState.enabled()) {
         GrGLIRect scissor;
         scissor.setRelativeTo(rtViewport,
                               scissorState.rect().fLeft,
                               scissorState.rect().fTop,
@@ skipping 83 matching lines @@
 }
 
 void GrGLGpu::setupGeometry(const GrPrimitiveProcessor& primProc,
                             const GrNonInstancedMesh& mesh,
                             size_t* indexOffsetInBytes) {
     const GrGLBuffer* vbuf;
     vbuf = static_cast<const GrGLBuffer*>(mesh.vertexBuffer());
 
     SkASSERT(vbuf);
     SkASSERT(!vbuf->isMapped());
-    SkASSERT(kVertex_GrBufferType == vbuf->type());
 
-    const GrGLBuffer* ibuf = nullptr;
+    GrGLAttribArrayState* attribState;
     if (mesh.isIndexed()) {
         SkASSERT(indexOffsetInBytes);
 
         *indexOffsetInBytes = 0;
-        ibuf = static_cast<const GrGLBuffer*>(mesh.indexBuffer());
+        const GrGLBuffer* ibuf = static_cast<const GrGLBuffer*>(mesh.indexBuffer());
 
         SkASSERT(ibuf);
         SkASSERT(!ibuf->isMapped());
-        SkASSERT(kIndex_GrBufferType == ibuf->type());
         *indexOffsetInBytes += ibuf->baseOffset();
+        attribState = fHWVertexArrayState.bindInternalVertexArray(this, ibuf);
+    } else {
+        attribState = fHWVertexArrayState.bindInternalVertexArray(this);
     }
-    GrGLAttribArrayState* attribState =
-        fHWGeometryState.bindArrayAndBuffersToDraw(this, vbuf, ibuf);
 
     int vaCount = primProc.numAttribs();
     if (vaCount > 0) {
 
         GrGLsizei stride = static_cast<GrGLsizei>(primProc.getVertexStride());
 
         size_t vertexOffsetInBytes = stride * mesh.startVertex();
 
         vertexOffsetInBytes += vbuf->baseOffset();
 
         uint32_t usedAttribArraysMask = 0;
         size_t offset = 0;
 
         for (int attribIndex = 0; attribIndex < vaCount; attribIndex++) {
             const GrGeometryProcessor::Attribute& attrib = primProc.getAttrib(attribIndex);
             usedAttribArraysMask |= (1 << attribIndex);
             GrVertexAttribType attribType = attrib.fType;
             attribState->set(this,
                              attribIndex,
-                             vbuf->bufferID(),
+                             vbuf,
                              attribType,
                              stride,
                              reinterpret_cast<GrGLvoid*>(vertexOffsetInBytes + offset));
             offset += attrib.fOffset;
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }
 
-void GrGLGpu::bindBuffer(GrGLuint id, GrGLenum type) {
+GrGLenum GrGLGpu::bindBuffer(GrBufferType type, const GrGLBuffer* buffer) {
     this->handleDirtyContext();
-    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;
+
+    // Index buffer state is tied to the vertex array.
+    if (kIndex_GrBufferType == type) {
+        this->bindVertexArray(0);
     }
-}
 
-void GrGLGpu::releaseBuffer(GrGLuint id, GrGLenum type) {
-    this->handleDirtyContext();
-    GL_CALL(DeleteBuffers(1, &id));
-    switch (type) {
-        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;
+    SkASSERT(type >= 0 && type <= kLast_GrBufferType);
+    auto& bufferState = fHWBufferState[type];
+
+    if (buffer->getUniqueID() != bufferState.fBoundBufferUniqueID) {
+        if (!buffer->isCPUBacked() || !bufferState.fBufferZeroKnownBound) {
+            GL_CALL(BindBuffer(bufferState.fGLTarget, buffer->bufferID()));
+            bufferState.fBufferZeroKnownBound = buffer->isCPUBacked();
+        }
+        bufferState.fBoundBufferUniqueID = buffer->getUniqueID();
     }
+
+    return bufferState.fGLTarget;
 }
 
 void GrGLGpu::disableScissor() {
     if (kNo_TriState != fHWScissorSettings.fEnabled) {
         GL_CALL(Disable(GR_GL_SCISSOR_TEST));
         fHWScissorSettings.fEnabled = kNo_TriState;
         return;
     }
 }
 
@@ skipping 649 matching lines @@
         aglSwapBuffers(aglGetCurrentContext());
     #elif defined(SK_BUILD_FOR_WIN32)
         SwapBuf();
         int set_a_break_pt_here = 9;
         SwapBuf();
     #endif
 #endif
 }
 
 void GrGLGpu::stampRectUsingProgram(GrGLuint program, const SkRect& bounds, GrGLint posXformUniform,
-                                    GrGLuint arrayBuffer) {
+                                    const GrGLBuffer* arrayBuffer) {
     GL_CALL(UseProgram(program));
-    this->fHWGeometryState.setVertexArrayID(this, 0);
+    this->fHWVertexArrayState.setVertexArrayID(this, 0);
 
-    GrGLAttribArrayState* attribs =
-            this->fHWGeometryState.bindArrayAndBufferToDraw(this, arrayBuffer);
+    GrGLAttribArrayState* attribs = this->fHWVertexArrayState.bindInternalVertexArray(this);
     attribs->set(this, 0, arrayBuffer, kVec2f_GrVertexAttribType, 2 * sizeof(GrGLfloat), 0);
     attribs->disableUnusedArrays(this, 0x1);
 
     GL_CALL(Uniform4f(posXformUniform, bounds.width(), bounds.height(), bounds.left(),
                       bounds.top()));
 
     GrXferProcessor::BlendInfo blendInfo;
     blendInfo.reset();
     this->flushBlend(blendInfo, GrSwizzle());
     this->flushColorWrite(true);
@@ skipping 835 matching lines @@
         GL_CALL_RET(fCopyPrograms[i].fPosXformUniform,
                     GetUniformLocation(fCopyPrograms[i].fProgram, "u_posXform"));
         GL_CALL_RET(fCopyPrograms[i].fTexCoordXformUniform,
                     GetUniformLocation(fCopyPrograms[i].fProgram, "u_texCoordXform"));
 
         GL_CALL(BindAttribLocation(fCopyPrograms[i].fProgram, 0, "a_vertex"));
 
         GL_CALL(DeleteShader(vshader));
         GL_CALL(DeleteShader(fshader));
     }
-    fCopyProgramArrayBuffer = 0;
-    GL_CALL(GenBuffers(1, &fCopyProgramArrayBuffer));
-    fHWGeometryState.setVertexBufferID(this, fCopyProgramArrayBuffer);
-    static const GrGLfloat vdata[] = {
-        0, 0,
-        0, 1,
-        1, 0,
-        1, 1
-    };
-    GL_ALLOC_CALL(this->glInterface(),
-                  BufferData(GR_GL_ARRAY_BUFFER,
-                             (GrGLsizeiptr) sizeof(vdata),
-                             vdata,  // data ptr
-                             GR_GL_STATIC_DRAW));
+    fCopyProgramArrayBuffer.reset(
+        GrGLBuffer::Create(this, 4 * 2 * sizeof(GrGLfloat), kVertex_GrBufferType,
+                           kStatic_GrAccessPattern, (const GrGLfloat[4 * 2]) {
+            0, 0,
+            0, 1,
+            1, 0,
+            1, 1
+        })
+    );
 }
 
 void GrGLGpu::createWireRectProgram() {
     SkASSERT(!fWireRectProgram.fProgram);
     GrGLSLShaderVar uColor("u_color", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar uRect("u_rect", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
     const char* version = this->glCaps().glslCaps()->versionDeclString();
 
     // The rect uniform specifies the rectangle in NDC space as a vec4 (left,top,right,bottom). The
@@ skipping 57 matching lines @@
     GL_CALL(LinkProgram(fWireRectProgram.fProgram));
 
     GL_CALL_RET(fWireRectProgram.fColorUniform,
                 GetUniformLocation(fWireRectProgram.fProgram, "u_color"));
     GL_CALL_RET(fWireRectProgram.fRectUniform,
                 GetUniformLocation(fWireRectProgram.fProgram, "u_rect"));
     GL_CALL(BindAttribLocation(fWireRectProgram.fProgram, 0, "a_vertex"));
 
     GL_CALL(DeleteShader(vshader));
     GL_CALL(DeleteShader(fshader));
-    GL_CALL(GenBuffers(1, &fWireRectArrayBuffer));
-    fHWGeometryState.setVertexBufferID(this, fWireRectArrayBuffer);
-    static const GrGLfloat vdata[] = {
-        0, 0,
-        0, 1,
-        1, 1,
-        1, 0,
-    };
-    GL_ALLOC_CALL(this->glInterface(),
-                  BufferData(GR_GL_ARRAY_BUFFER,
-                             (GrGLsizeiptr) sizeof(vdata),
-                             vdata,  // data ptr
-                             GR_GL_STATIC_DRAW));
+    fWireRectArrayBuffer.reset(
+        GrGLBuffer::Create(this, 4 * 2 * sizeof(GrGLfloat), kVertex_GrBufferType,
+                           kStatic_GrAccessPattern, (const GrGLfloat[4 * 2]) {
+            0, 0,
+            0, 1,
+            1, 1,
+            1, 0
+        })
+    );
 }
 
 void GrGLGpu::drawDebugWireRect(GrRenderTarget* rt, const SkIRect& rect, GrColor color) {
     // TODO: This should swizzle the output to match dst's config, though it is a debugging
     // visualization.
 
     this->handleDirtyContext();
     if (!fWireRectProgram.fProgram) {
         this->createWireRectProgram();
     }
@@ skipping 24 matching lines @@
     channels[1] = GrColorUnpackG(color) * scale255;
     channels[2] = GrColorUnpackB(color) * scale255;
     channels[3] = GrColorUnpackA(color) * scale255;
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(rt->asRenderTarget());
     this->flushRenderTarget(glRT, &rect);
 
     GL_CALL(UseProgram(fWireRectProgram.fProgram));
     fHWProgramID = fWireRectProgram.fProgram;
 
-    fHWGeometryState.setVertexArrayID(this, 0);
+    fHWVertexArrayState.setVertexArrayID(this, 0);
 
-    GrGLAttribArrayState* attribs =
-        fHWGeometryState.bindArrayAndBufferToDraw(this, fWireRectArrayBuffer);
+    GrGLAttribArrayState* attribs = fHWVertexArrayState.bindInternalVertexArray(this);
     attribs->set(this, 0, fWireRectArrayBuffer, kVec2f_GrVertexAttribType, 2 * sizeof(GrGLfloat),
                  0);
     attribs->disableUnusedArrays(this, 0x1);
 
     GL_CALL(Uniform4fv(fWireRectProgram.fRectUniform, 1, edges));
     GL_CALL(Uniform4fv(fWireRectProgram.fColorUniform, 1, channels));
 
     GrXferProcessor::BlendInfo blendInfo;
     blendInfo.reset();
     this->flushBlend(blendInfo, GrSwizzle::RGBA());
@@ skipping 25 matching lines @@
     this->flushViewport(dstVP);
     fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
 
     SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY, w, h);
 
     int progIdx = TextureTargetToCopyProgramIdx(srcTex->target());
 
     GL_CALL(UseProgram(fCopyPrograms[progIdx].fProgram));
     fHWProgramID = fCopyPrograms[progIdx].fProgram;
 
-    fHWGeometryState.setVertexArrayID(this, 0);
+    fHWVertexArrayState.setVertexArrayID(this, 0);
 
-    GrGLAttribArrayState* attribs =
-        fHWGeometryState.bindArrayAndBufferToDraw(this, fCopyProgramArrayBuffer);
+    GrGLAttribArrayState* attribs = fHWVertexArrayState.bindInternalVertexArray(this);
     attribs->set(this, 0, fCopyProgramArrayBuffer, kVec2f_GrVertexAttribType, 2 * sizeof(GrGLfloat),
                  0);
     attribs->disableUnusedArrays(this, 0x1);
 
     // dst rect edges in NDC (-1 to 1)
     int dw = dst->width();
     int dh = dst->height();
     GrGLfloat dx0 = 2.f * dstPoint.fX / dw - 1.f;
     GrGLfloat dx1 = 2.f * (dstPoint.fX + w) / dw - 1.f;
     GrGLfloat dy0 = 2.f * dstPoint.fY / dh - 1.f;
@@ skipping 272 matching lines @@
 #ifndef SK_IGNORE_GL_TEXTURE_TARGET
     delete info;
 #endif
 }
 
 void GrGLGpu::resetShaderCacheForTesting() const {
     fProgramCache->abandon();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-GrGLAttribArrayState* GrGLGpu::HWGeometryState::bindArrayAndBuffersToDraw(
-                                                GrGLGpu* gpu,
-                                                const GrGLBuffer* vbuffer,
-                                                const GrGLBuffer* ibuffer) {
-    SkASSERT(vbuffer);
-    GrGLuint vbufferID = vbuffer->bufferID();
-    GrGLuint* ibufferIDPtr = nullptr;
-    GrGLuint ibufferID;
-    if (ibuffer) {
-        ibufferID = ibuffer->bufferID();
-        ibufferIDPtr = &ibufferID;
-    }
-    return this->internalBind(gpu, vbufferID, ibufferIDPtr);
-}
 
-GrGLAttribArrayState* GrGLGpu::HWGeometryState::bindArrayAndBufferToDraw(GrGLGpu* gpu,
-                                                                         GrGLuint vbufferID) {
-    return this->internalBind(gpu, vbufferID, nullptr);
-}
-
-GrGLAttribArrayState* GrGLGpu::HWGeometryState::bindArrayAndBuffersToDraw(GrGLGpu* gpu,
-                                                                          GrGLuint vbufferID,
-                                                                          GrGLuint ibufferID) {
-    return this->internalBind(gpu, vbufferID, &ibufferID);
-}
-
-GrGLAttribArrayState* GrGLGpu::HWGeometryState::internalBind(GrGLGpu* gpu,
-                                                             GrGLuint vbufferID,
-                                                             GrGLuint* ibufferID) {
+GrGLAttribArrayState* GrGLGpu::HWVertexArrayState::bindInternalVertexArray(GrGLGpu* gpu,
+                                                                           const GrGLBuffer* ibuf) {
     GrGLAttribArrayState* attribState;
 
-    if (gpu->glCaps().isCoreProfile() && 0 != vbufferID) {
-        if (!fVBOVertexArray) {
+    if (gpu->glCaps().isCoreProfile()) {
+        if (!fCoreProfileVertexArray) {
             GrGLuint arrayID;
             GR_GL_CALL(gpu->glInterface(), GenVertexArrays(1, &arrayID));
             int attrCount = gpu->glCaps().maxVertexAttributes();
-            fVBOVertexArray = new GrGLVertexArray(arrayID, attrCount);
+            fCoreProfileVertexArray = new GrGLVertexArray(arrayID, attrCount);
         }
-        if (ibufferID) {
-            attribState = fVBOVertexArray->bindWithIndexBuffer(gpu, *ibufferID);
+        if (ibuf) {
+            attribState = fCoreProfileVertexArray->bindWithIndexBuffer(gpu, ibuf);
         } else {
-            attribState = fVBOVertexArray->bind(gpu);
+            attribState = fCoreProfileVertexArray->bind(gpu);
         }
     } else {
-        if (ibufferID) {
-            this->setIndexBufferIDOnDefaultVertexArray(gpu, *ibufferID);
+        if (ibuf) {
+            // bindBuffer implicitly binds VAO 0 when binding an index buffer.
+            gpu->bindBuffer(kIndex_GrBufferType, ibuf);
         } else {
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }
 
 bool GrGLGpu::onMakeCopyForTextureParams(GrTexture* texture, const GrTextureParams& textureParams,
                                          GrTextureProducer::CopyParams* copyParams) const {
     if (textureParams.isTiled() ||
         GrTextureParams::kMipMap_FilterMode == textureParams.filterMode()) {
         GrGLTexture* glTexture = static_cast<GrGLTexture*>(texture);
         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;
 }