Revert of Track GL buffer state based on unique resource ID

src/gpu/gl/GrGLGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLGpu_DEFINED
 #define GrGLGpu_DEFINED
 
@@ skipping 14 matching lines @@
 
 class GrGLBuffer;
 class GrPipeline;
 class GrNonInstancedMesh;
 class GrSwizzle;
 
 #ifdef SK_DEVELOPER
 #define PROGRAM_CACHE_STATS
 #endif
 
-class GrGLGpu final : public GrGpu {
+class GrGLGpu : public GrGpu {
 public:
     static GrGpu* Create(GrBackendContext backendContext, const GrContextOptions& options,
                          GrContext* context);
     ~GrGLGpu() override;
 
     void disconnect(DisconnectType) override;
 
     const GrGLContext& glContext() const { return *fGLContext; }
 
     const GrGLInterface* glInterface() const { return fGLContext->interface(); }
@@ skipping 20 matching lines @@
 
     bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
                               GrPixelConfig srcConfig, DrawPreference*,
                               WritePixelTempDrawInfo*) override;
 
     bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const override;
 
     // These functions should be used to bind GL objects. They track the GL state and skip redundant
     // bindings. Making the equivalent glBind calls directly will confuse the state tracking.
     void bindVertexArray(GrGLuint id) {
-        fHWVertexArrayState.setVertexArrayID(this, id);
+        fHWGeometryState.setVertexArrayID(this, id);
+    }
+    void bindIndexBufferAndDefaultVertexArray(GrGLuint id) {
+        fHWGeometryState.setIndexBufferIDOnDefaultVertexArray(this, id);
+    }
+    void bindVertexBuffer(GrGLuint id) {
+        fHWGeometryState.setVertexBufferID(this, id);
     }
 
     // These callbacks update state tracking when GL objects are deleted. They are called from
     // GrGLResource onRelease functions.
     void notifyVertexArrayDelete(GrGLuint id) {
-        fHWVertexArrayState.notifyVertexArrayDelete(id);
+        fHWGeometryState.notifyVertexArrayDelete(id);
+    }
+    void notifyVertexBufferDelete(GrGLuint id) {
+        fHWGeometryState.notifyVertexBufferDelete(id);
+    }
+    void notifyIndexBufferDelete(GrGLuint id) {
+        fHWGeometryState.notifyIndexBufferDelete(id);
     }
 
-    // Binds a buffer to the GL target corresponding to 'type', updates internal state tracking, and
-    // returns the GL target the buffer was bound to.
-    // When 'type' is kIndex_GrBufferType, this function will also implicitly bind the default VAO.
-    // If the caller wishes to bind an index buffer to a specific VAO, it can call glBind directly.
-    GrGLenum bindBuffer(GrBufferType type, const GrGLBuffer*);
+    // id and type (GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, etc.) of buffer to bind
+    void bindBuffer(GrGLuint id, GrGLenum type);
+
+    void releaseBuffer(GrGLuint id, GrGLenum type);
 
     const GrGLContext* glContextForTesting() const override {
         return &this->glContext();
     }
 
     void clearStencil(GrRenderTarget*) override;
 
     void invalidateBoundRenderTarget() {
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
     }
@@ skipping 20 matching lines @@
     void onResetContext(uint32_t resetBits) override;
 
     void xferBarrier(GrRenderTarget*, GrXferBarrierType) override;
 
     GrTexture* onCreateTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle lifeCycle,
                                const SkTArray<GrMipLevel>& texels) override;
     GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
                                          GrGpuResource::LifeCycle lifeCycle,
                                          const SkTArray<GrMipLevel>& texels) override;
 
-    GrBuffer* onCreateBuffer(size_t size, GrBufferType intendedType, GrAccessPattern) override;
+    GrBuffer* onCreateBuffer(GrBufferType, size_t size, GrAccessPattern) override;
     GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override;
     GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&,
                                               GrWrapOwnership) override;
     GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) override;
     // Given a GrPixelConfig return the index into the stencil format array on GrGLCaps to a
     // compatible stencil format, or negative if there is no compatible stencil format.
     int getCompatibleStencilIndex(GrPixelConfig config);
 
     // If |desc.fTextureStorageAllocator| exists, use that to create the
     // texture. Otherwise, create the texture directly.
@@ skipping 72 matching lines @@
     // an into the index buffer. It does not account for vertices.startIndex() but rather the start
     // index is relative to the returned offset.
     void setupGeometry(const GrPrimitiveProcessor&,
                        const GrNonInstancedMesh& mesh,
                        size_t* indexOffsetInBytes);
 
     void flushBlend(const GrXferProcessor::BlendInfo& blendInfo, const GrSwizzle&);
 
     bool hasExtension(const char* ext) const { return fGLContext->hasExtension(ext); }
 
-    bool copySurfaceAsDraw(GrSurface* dst,
+    void copySurfaceAsDraw(GrSurface* dst,
                            GrSurface* src,
                            const SkIRect& srcRect,
                            const SkIPoint& dstPoint);
     void copySurfaceAsCopyTexSubImage(GrSurface* dst,
                                       GrSurface* src,
                                       const SkIRect& srcRect,
                                       const SkIPoint& dstPoint);
     bool copySurfaceAsBlitFramebuffer(GrSurface* dst,
                                       GrSurface* src,
                                       const SkIRect& srcRect,
                                       const SkIPoint& dstPoint);
 
-    void stampPLSSetupRect(const SkRect& bounds);
+    void stampRectUsingProgram(GrGLuint program, const SkRect& bounds, GrGLint posXformUniform,
+                               GrGLuint arrayBuffer);
 
     void setupPixelLocalStorage(const GrPipeline&, const GrPrimitiveProcessor&);
 
     static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
 
     class ProgramCache : public ::SkNoncopyable {
     public:
         ProgramCache(GrGLGpu* gpu);
         ~ProgramCache();
 
@@ skipping 107 matching lines @@
     // that ID is bound. If not the surface is temporarily bound to a FBO and that FBO is bound.
     // This must be paired with a call to unbindSurfaceFBOForCopy().
     void bindSurfaceFBOForCopy(GrSurface* surface, GrGLenum fboTarget, GrGLIRect* viewport,
                               TempFBOTarget tempFBOTarget);
 
     // Must be called if bindSurfaceFBOForCopy was used to bind a surface for copying.
     void unbindTextureFBOForCopy(GrGLenum fboTarget, GrSurface* surface);
 
     SkAutoTUnref<GrGLContext>  fGLContext;
 
-    bool createCopyProgram(int progIdx);
-    bool createWireRectProgram();
-    bool createPLSSetupProgram();
+    void createCopyPrograms();
+    void createWireRectProgram();
+    void createUnitRectBuffer();
+
+    void createPLSSetupProgram();
 
     // GL program-related state
     ProgramCache*               fProgramCache;
 
     ///////////////////////////////////////////////////////////////////////////
     ///@name Caching of GL State
     ///@{
     int                         fHWActiveTextureUnitIdx;
     GrGLuint                    fHWProgramID;
 
@@ skipping 14 matching lines @@
         GrGLIRect   fRect;
         void invalidate() {
             fEnabled = kUnknown_TriState;
             fRect.invalidate();
         }
     } fHWScissorSettings;
 
     GrGLIRect                   fHWViewport;
 
     /**
-     * Tracks vertex attrib array state.
+     * Tracks bound vertex and index buffers and vertex attrib array state.
      */
-    class HWVertexArrayState {
+    class HWGeometryState {
     public:
-        HWVertexArrayState() : fCoreProfileVertexArray(nullptr) { this->invalidate(); }
+        HWGeometryState() { fVBOVertexArray = nullptr; this->invalidate(); }
 
-        ~HWVertexArrayState() { delete fCoreProfileVertexArray; }
+        ~HWGeometryState() { delete fVBOVertexArray; }
 
         void invalidate() {
             fBoundVertexArrayIDIsValid = false;
+            fBoundVertexBufferIDIsValid = false;
+            fDefaultVertexArrayBoundIndexBufferID = false;
+            fDefaultVertexArrayBoundIndexBufferIDIsValid = false;
             fDefaultVertexArrayAttribState.invalidate();
-            if (fCoreProfileVertexArray) {
-                fCoreProfileVertexArray->invalidateCachedState();
+            if (fVBOVertexArray) {
+                fVBOVertexArray->invalidateCachedState();
             }
         }
 
         void notifyVertexArrayDelete(GrGLuint id) {
             if (fBoundVertexArrayIDIsValid && fBoundVertexArrayID == id) {
                 // Does implicit bind to 0
                 fBoundVertexArrayID = 0;
             }
         }
 
         void setVertexArrayID(GrGLGpu* gpu, GrGLuint arrayID) {
             if (!gpu->glCaps().vertexArrayObjectSupport()) {
                 SkASSERT(0 == arrayID);
                 return;
             }
             if (!fBoundVertexArrayIDIsValid || arrayID != fBoundVertexArrayID) {
                 GR_GL_CALL(gpu->glInterface(), BindVertexArray(arrayID));
                 fBoundVertexArrayIDIsValid = true;
                 fBoundVertexArrayID = arrayID;
             }
         }
 
+        void notifyVertexBufferDelete(GrGLuint id) {
+            if (fBoundVertexBufferIDIsValid && id == fBoundVertexBufferID) {
+                fBoundVertexBufferID = 0;
+            }
+            if (fVBOVertexArray) {
+                fVBOVertexArray->notifyVertexBufferDelete(id);
+            }
+            fDefaultVertexArrayAttribState.notifyVertexBufferDelete(id);
+        }
+
+        void notifyIndexBufferDelete(GrGLuint id) {
+            if (fDefaultVertexArrayBoundIndexBufferIDIsValid &&
+                id == fDefaultVertexArrayBoundIndexBufferID) {
+                fDefaultVertexArrayBoundIndexBufferID = 0;
+            }
+            if (fVBOVertexArray) {
+                fVBOVertexArray->notifyIndexBufferDelete(id);
+            }
+        }
+
+        void setVertexBufferID(GrGLGpu* gpu, GrGLuint id) {
+            if (!fBoundVertexBufferIDIsValid || id != fBoundVertexBufferID) {
+                GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ARRAY_BUFFER, id));
+                fBoundVertexBufferIDIsValid = true;
+                fBoundVertexBufferID = id;
+            }
+        }
+
         /**
-         * Binds the vertex array that should be used for internal draws, and returns its attrib
-         * state. This binds the default VAO (ID=zero) unless we are on a core profile, in which
-         * case we use a dummy array instead.
-         *
-         * If an index buffer is privided, it will be bound to the vertex array. Otherwise the
-         * index buffer binding will be left unchanged.
-         *
-         * The returned GrGLAttribArrayState should be used to set vertex attribute arrays.
+         * Binds the default vertex array and binds the index buffer. This is used when binding
+         * an index buffer in order to update it.
          */
-        GrGLAttribArrayState* bindInternalVertexArray(GrGLGpu*, const GrGLBuffer* ibuff = nullptr);
+        void setIndexBufferIDOnDefaultVertexArray(GrGLGpu* gpu, GrGLuint id) {
+            this->setVertexArrayID(gpu, 0);
+            if (!fDefaultVertexArrayBoundIndexBufferIDIsValid ||
+                id != fDefaultVertexArrayBoundIndexBufferID) {
+                GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, id));
+                fDefaultVertexArrayBoundIndexBufferIDIsValid = true;
+                fDefaultVertexArrayBoundIndexBufferID = id;
+            }
+        }
+
+        /**
+         * Binds the vertex array object that should be used to render from the vertex buffer.
+         * The vertex array is bound and its attrib array state object is returned. The vertex
+         * buffer is bound. The index buffer (if non-nullptr) is bound to the vertex array. The
+         * returned GrGLAttribArrayState should be used to set vertex attribute arrays.
+         */
+        GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGLGpu* gpu,
+                                                        const GrGLBuffer* vbuffer,
+                                                        const GrGLBuffer* ibuffer);
+
+        /** Variants of the above that takes GL buffer IDs. Note that 0 does not imply that a
+            buffer won't be bound. The "default buffer" will be bound, which is used for client-side
+            array rendering. */
+        GrGLAttribArrayState* bindArrayAndBufferToDraw(GrGLGpu* gpu, GrGLuint vbufferID);
+        GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGLGpu* gpu,
+                                                        GrGLuint vbufferID,
+                                                        GrGLuint ibufferID);
 
     private:
+        GrGLAttribArrayState* internalBind(GrGLGpu* gpu, GrGLuint vbufferID, GrGLuint* ibufferID);
+
         GrGLuint                fBoundVertexArrayID;
+        GrGLuint                fBoundVertexBufferID;
         bool                    fBoundVertexArrayIDIsValid;
+        bool                    fBoundVertexBufferIDIsValid;
 
+        GrGLuint                fDefaultVertexArrayBoundIndexBufferID;
+        bool                    fDefaultVertexArrayBoundIndexBufferIDIsValid;
         // We return a non-const pointer to this from bindArrayAndBuffersToDraw when vertex array 0
         // is bound. However, this class is internal to GrGLGpu and this object never leaks out of
         // GrGLGpu.
         GrGLAttribArrayState    fDefaultVertexArrayAttribState;
 
-        // This is used when we're using a core profile.
-        GrGLVertexArray*        fCoreProfileVertexArray;
-    } fHWVertexArrayState;
+        // This is used when we're using a core profile and the vertices are in a VBO.
+        GrGLVertexArray*        fVBOVertexArray;
+    } fHWGeometryState;
 
-    struct {
-        GrGLenum   fGLTarget;
-        uint32_t   fBoundBufferUniqueID;
-        bool       fBufferZeroKnownBound;
-
-        void invalidate() {
-            fBoundBufferUniqueID = SK_InvalidUniqueID;
-            fBufferZeroKnownBound = false;
-        }
-    } fHWBufferState[kGrBufferTypeCount];
+    GrGLuint    fHWBoundTextureBufferID;
+    GrGLuint    fHWBoundDrawIndirectBufferID;
+    bool        fHWBoundTextureBufferIDIsValid;
+    bool        fHWBoundDrawIndirectBufferIDIsValid;
 
     struct {
         GrBlendEquation fEquation;
         GrBlendCoeff    fSrcCoeff;
         GrBlendCoeff    fDstCoeff;
         GrColor         fConstColor;
         bool            fConstColorValid;
         TriState        fEnabled;
 
         void invalidate() {
@@ skipping 22 matching lines @@
     int                         fHWNumRasterSamples;
     ///@}
 
     /** IDs for copy surface program. */
     struct {
         GrGLuint    fProgram;
         GrGLint     fTextureUniform;
         GrGLint     fTexCoordXformUniform;
         GrGLint     fPosXformUniform;
     }                           fCopyPrograms[3];
-    SkAutoTUnref<GrGLBuffer>    fCopyProgramArrayBuffer;
+    GrGLuint                    fCopyProgramArrayBuffer;
 
     struct {
         GrGLuint fProgram;
         GrGLint  fColorUniform;
         GrGLint  fRectUniform;
     }                           fWireRectProgram;
-    SkAutoTUnref<GrGLBuffer>    fWireRectArrayBuffer;
+    GrGLuint                    fWireRectArrayBuffer;
 
     static int TextureTargetToCopyProgramIdx(GrGLenum target) {
         switch (target) {
             case GR_GL_TEXTURE_2D:
                 return 0;
             case GR_GL_TEXTURE_EXTERNAL:
                 return 1;
             case GR_GL_TEXTURE_RECTANGLE:
                 return 2;
             default:
                 SkFAIL("Unexpected texture target type.");
                 return 0;
         }
     }
 
     struct {
-        GrGLuint                    fProgram;
-        GrGLint                     fPosXformUniform;
-        SkAutoTUnref<GrGLBuffer>    fArrayBuffer;
+        GrGLuint    fProgram;
+        GrGLint     fPosXformUniform;
+        GrGLuint    fArrayBuffer;
     } fPLSSetupProgram;
 
     bool fHWPLSEnabled;
     bool fPLSHasBeenUsed;
 
     float fHWMinSampleShading;
 
     typedef GrGpu INHERITED;
     friend class GrGLPathRendering; // For accessing setTextureUnit.
 };
 
 #endif