Add a base class for GrIODB that handles geometry data

src/gpu/GrInOrderDrawBuffer.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 GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
-#include "GrDrawTarget.h"
-#include "GrGpu.h"
-#include "GrIndexBuffer.h"
+#include "GrFlushToGpuDrawTarget.h"
 #include "GrOptDrawState.h"
 #include "GrPath.h"
-#include "GrPathRange.h"
-#include "GrRenderTarget.h"
-#include "GrSurface.h"
 #include "GrTRecorder.h"
-#include "GrVertexBuffer.h"
-
-#include "SkClipStack.h"
-#include "SkTemplates.h"
-#include "SkTypes.h"
-
-class GrIndexBufferAllocPool;
-class GrVertexBufferAllocPool;
 
 /**
  * GrInOrderDrawBuffer is an implementation of GrDrawTarget that queues up draws for eventual
  * playback into a GrGpu. In theory one draw buffer could playback into another. When index or
  * vertex buffers are used as geometry sources it is the callers the draw buffer only holds
  * references to the buffers. It is the callers responsibility to ensure that the data is still
  * valid when the draw buffer is played back into a GrGpu. Similarly, it is the caller's
  * responsibility to ensure that all referenced textures, buffers, and render-targets are associated
  * in the GrGpu object that the buffer is played back into. The buffer requires VB and IB pools to
  * store geometry.
  */
-class GrInOrderDrawBuffer : public GrClipTarget {
+class GrInOrderDrawBuffer : public GrFlushToGpuDrawTarget {
 public:
 
     /**
      * Creates a GrInOrderDrawBuffer
      *
      * @param gpu        the gpu object that this draw buffer flushes to.
      * @param vertexPool pool where vertices for queued draws will be saved when
      *                   the vertex source is either reserved or array.
      * @param indexPool  pool where indices for queued draws will be saved when
      *                   the index source is either reserved or array.
      */
     GrInOrderDrawBuffer(GrGpu* gpu,
                         GrVertexBufferAllocPool* vertexPool,
                         GrIndexBufferAllocPool* indexPool);
 
     ~GrInOrderDrawBuffer() SK_OVERRIDE;
 
-    /**
-     * Empties the draw buffer of any queued up draws. This must not be called while inside an
-     * unbalanced pushGeometrySource(). The current draw state and clip are preserved.
-     */
-    void reset();
-
-    /**
-     * This plays the queued up draws to its GrGpu target. It also resets this object (i.e. flushing
-     * is destructive). This buffer must not have an active reserved vertex or index source. Any
-     * reserved geometry on the target will be finalized because it's geometry source will be pushed
-     * before flushing and popped afterwards.
-     */
-    void flush();
-
     // tracking for draws
     DrawToken getCurrentDrawToken() { return DrawToken(this, fDrawID); }
 
-    // overrides from GrDrawTarget
-    bool geometryHints(size_t vertexStride,
-                       int* vertexCount,
-                       int* indexCount) const SK_OVERRIDE;
-
     void clearStencilClip(const SkIRect& rect,
                           bool insideClip,
                           GrRenderTarget* renderTarget) SK_OVERRIDE;
 
     void discard(GrRenderTarget*) SK_OVERRIDE;
 
 private:
     typedef GrClipMaskManager::ScissorState ScissorState;
     enum {
         kDraw_Cmd           = 1,
@@ skipping 121 matching lines @@
 
         void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) SK_OVERRIDE;
 
         const GrOptDrawState    fState;
         GrGpu::DrawType         fDrawType;
     };
 
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
+    void onReset() SK_OVERRIDE;
+    void onFlush() SK_OVERRIDE;
+
     // overrides from GrDrawTarget
     void onDraw(const GrDrawState&,
                 const DrawInfo&,
                 const ScissorState&,
                 const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE;
     void onDrawRect(GrDrawState*,
                     const SkRect& rect,
                     const SkRect* localRect,
                     const SkMatrix* localMatrix) SK_OVERRIDE;
 
@@ skipping 13 matching lines @@
                      const float transformValues[],
                      PathTransformType,
                      int count,
                      const ScissorState&,
                      const GrStencilSettings&,
                      const GrDeviceCoordTexture*) SK_OVERRIDE;
     void onClear(const SkIRect* rect,
                  GrColor color,
                  bool canIgnoreRect,
                  GrRenderTarget* renderTarget) SK_OVERRIDE;
-    void setDrawBuffers(DrawInfo*) SK_OVERRIDE;
-
-    bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE;
-    bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE;
-    void releaseReservedVertexSpace() SK_OVERRIDE;
-    void releaseReservedIndexSpace() SK_OVERRIDE;
-    void geometrySourceWillPush() SK_OVERRIDE;
-    void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE;
-    void willReserveVertexAndIndexSpace(int vertexCount,
-                                        size_t vertexStride,
-                                        int indexCount) SK_OVERRIDE;
     bool onCopySurface(GrSurface* dst,
                        GrSurface* src,
                        const SkIRect& srcRect,
                        const SkIPoint& dstPoint) SK_OVERRIDE;
     bool onCanCopySurface(const GrSurface* dst,
                           const GrSurface* src,
                           const SkIRect& srcRect,
                           const SkIPoint& dstPoint) SK_OVERRIDE;
     bool onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE;
 
@@ skipping 13 matching lines @@
     // Records any trace markers for a command after adding it to the buffer.
     void recordTraceMarkersIfNecessary();
 
     virtual bool isIssued(uint32_t drawID) { return drawID != fDrawID; }
 
     // TODO: Use a single allocator for commands and records
     enum {
         kCmdBufferInitialSizeInBytes = 8 * 1024,
         kPathIdxBufferMinReserve     = 2 * 64,  // 64 uint16_t's
         kPathXformBufferMinReserve   = 2 * 64,  // 64 two-float transforms
-        kGeoPoolStatePreAllocCnt     = 4,
     };
 
-    struct GeometryPoolState {
-        const GrVertexBuffer*   fPoolVertexBuffer;
-        int                     fPoolStartVertex;
-        const GrIndexBuffer*    fPoolIndexBuffer;
-        int                     fPoolStartIndex;
-        // caller may conservatively over reserve vertices / indices.
-        // we release unused space back to allocator if possible
-        // can only do this if there isn't an intervening pushGeometrySource()
-        size_t                  fUsedPoolVertexBytes;
-        size_t                  fUsedPoolIndexBytes;
-    };
-
-    typedef SkSTArray<kGeoPoolStatePreAllocCnt, GeometryPoolState> GeoPoolStateStack;
-
     CmdBuffer                           fCmdBuffer;
     const GrOptDrawState*               fPrevState;
     SkTArray<GrTraceMarkerSet, false>   fGpuCmdMarkers;
-    GrGpu*                              fDstGpu;
-    GrVertexBufferAllocPool&            fVertexPool;
-    GrIndexBufferAllocPool&             fIndexPool;
     SkTDArray<char>                     fPathIndexBuffer;
     SkTDArray<float>                    fPathTransformBuffer;
-    GeoPoolStateStack                   fGeoPoolStateStack;
-    bool                                fFlushing;
     uint32_t                            fDrawID;
 
-    typedef GrClipTarget INHERITED;
+    typedef GrFlushToGpuDrawTarget INHERITED;
 };
 
 #endif