Start using GrGpuCommandBuffer in GrDrawTarget.

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 36 matching lines @@
     GrGLStandard glStandard() const { return fGLContext->standard(); }
     GrGLVersion glVersion() const { return fGLContext->version(); }
     GrGLSLGeneration glslGeneration() const { return fGLContext->glslGeneration(); }
     const GrGLCaps& glCaps() const { return *fGLContext->caps(); }
 
     GrGLPathRendering* glPathRendering() {
         SkASSERT(glCaps().shaderCaps()->pathRenderingSupport());
         return static_cast<GrGLPathRendering*>(pathRendering());
     }
 
-    void discard(GrRenderTarget*) override;
+    void discard(GrRenderTarget*);
 
     // Used by GrGLProgram to configure OpenGL state.
     void bindTexture(int unitIdx, const GrTextureParams& params, bool allowSRGBInputs,
                      GrGLTexture* texture);
 
     void bindTexelBuffer(int unitIdx, GrPixelConfig, GrGLBuffer*);
 
     void generateMipmaps(const GrTextureParams& params, bool allowSRGBInputs, GrGLTexture* texture);
 
     bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
@@ skipping 20 matching lines @@
 
     // 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*);
 
     // Called by GrGLBuffer after its buffer object has been destroyed.
     void notifyBufferReleased(const GrGLBuffer*);
 
+    void draw(const GrPipeline&,

[bsalomon, 2016/06/20 16:51:14]

Maybe a comment on these that they are the passthrough functions that the faux
GL command buffer uses as its implementation?

[egdaniel, 2016/06/22 15:26:57]

Done.

+              const GrPrimitiveProcessor&,
+              const GrMesh*,
+              int meshCount);
+
+    /**
+    * Clear the passed in render target. Ignores the draw state and clip.
+    */
+    void clear(const SkIRect& rect, GrColor color, GrRenderTarget* renderTarget);
+
+    void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* renderTarget);
+
     const GrGLContext* glContextForTesting() const override {
         return &this->glContext();
     }
 
     void clearStencil(GrRenderTarget*) override;
 
-    GrGpuCommandBuffer* createCommandBuffer(const GrRenderTarget& target,
+    GrGpuCommandBuffer* createCommandBuffer(GrRenderTarget* target,
                                             GrGpuCommandBuffer::LoadAndStoreOp colorOp,
                                             GrColor colorClear,
                                             GrGpuCommandBuffer::LoadAndStoreOp stencilOp,
                                             GrColor stencilClear) override;
 
     void invalidateBoundRenderTarget() {
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
     }
 
     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget* rt,
@@ skipping 37 matching lines @@
 
 
     // Returns whether the texture is successfully created. On success, the
     // result is stored in |info|.
     // The texture is populated with |texels|, if it exists.
     // The texture parameters are cached in |initialTexParams|.
     bool createTextureImpl(const GrSurfaceDesc& desc, GrGLTextureInfo* info,
                            bool renderTarget, GrGLTexture::TexParams* initialTexParams,
                            const SkTArray<GrMipLevel>& texels);
 
-    void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) override;
-
-    void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override;
-
     bool onMakeCopyForTextureParams(GrTexture*, const GrTextureParams&,
                                     GrTextureProducer::CopyParams*) const override;
 
     // Checks whether glReadPixels can be called to get pixel values in readConfig from the
     // render target.
     bool readPixelsSupported(GrRenderTarget* target, GrPixelConfig readConfig);
 
     // Checks whether glReadPixels can be called to get pixel values in readConfig from a
     // render target that has renderTargetConfig. This may have to create a temporary
     // render target and thus is less preferable than the variant that takes a render target.
@@ skipping 16 matching lines @@
                        GrPixelConfig config,
                        const SkTArray<GrMipLevel>& texels) override;
 
     bool onTransferPixels(GrSurface*,
                           int left, int top, int width, int height,
                           GrPixelConfig config, GrBuffer* transferBuffer,
                           size_t offset, size_t rowBytes) override;
 
     void onResolveRenderTarget(GrRenderTarget* target) override;
 
-    void onDraw(const GrPipeline&,
-                const GrPrimitiveProcessor&,
-                const GrMesh*,
-                int meshCount) override;
-
     bool onCopySurface(GrSurface* dst,
                        GrSurface* src,
                        const SkIRect& srcRect,
                        const SkIPoint& dstPoint) override;
 
     void onGetMultisampleSpecs(GrRenderTarget*,
                                const GrStencilSettings&,
                                int* effectiveSampleCnt,
                                SkAutoTDeleteArray<SkPoint>* sampleLocations) override;
 
@@ skipping 369 matching lines @@
     bool fHWPLSEnabled;
     bool fPLSHasBeenUsed;
 
     float fHWMinSampleShading;
 
     typedef GrGpu INHERITED;
     friend class GrGLPathRendering; // For accessing setTextureUnit.
 };
 
 #endif