removing setVertexArraySource from drawtarget

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
@@ skipping 183 matching lines @@
      *                     out: a hint about the number of indices that can be
      *                     allocated cheaply. Negative means no hint.
      *                     Ignored if NULL.
      *
      * @return  true if target should be flushed based on the input values.
      */
     virtual bool geometryHints(int* vertexCount,
                                int* indexCount) const;
 
     /**
-     * Sets source of vertex data for the next draw. Array must contain
-     * the vertex data when this is called.
-     *
-     * @param vertexArray   cpu array containing vertex data.
-     * @param vertexCount   the number of vertices in the array. Vertex size is
-     *                      queried from the current GrDrawState.
-     */
-    void setVertexSourceToArray(const void* vertexArray, int vertexCount);
-
-    /**
-     * Sets source of index data for the next indexed draw. Array must contain
-     * the indices when this is called.
-     *
-     * @param indexArray    cpu array containing index data.
-     * @param indexCount    the number of indices in the array.
-     */
-    void setIndexSourceToArray(const void* indexArray, int indexCount);
-
-    /**
      * Sets source of vertex data for the next draw. Data does not have to be
      * in the buffer until drawIndexed, drawNonIndexed, or drawIndexedInstances.
      *
      * @param buffer        vertex buffer containing vertex data. Must be
      *                      unlocked before draw call. Vertex size is queried
      *                      from current GrDrawState.
      */
     void setVertexSourceToBuffer(const GrVertexBuffer* buffer);
 
     /**
@@ skipping 460 matching lines @@
 
 protected:
     // Extend access to GrDrawState::convertToPEndeingExec to subclasses.
     void convertDrawStateToPendingExec(GrDrawState* ds) {
         ds->convertToPendingExec();
     }
 
     enum GeometrySrcType {
         kNone_GeometrySrcType,     //<! src has not been specified
         kReserved_GeometrySrcType, //<! src was set using reserve*Space
-        kArray_GeometrySrcType,    //<! src was set using set*SourceToArray
         kBuffer_GeometrySrcType    //<! src was set using set*SourceToBuffer
     };
 
     struct GeometrySrcState {
         GeometrySrcType         fVertexSrc;
         union {
             // valid if src type is buffer
             const GrVertexBuffer*   fVertexBuffer;
             // valid if src type is reserved or array
             int                     fVertexCount;
         };
 
         GeometrySrcType         fIndexSrc;
         union {
             // valid if src type is buffer
             const GrIndexBuffer*    fIndexBuffer;
             // valid if src type is reserved or array
             int                     fIndexCount;
         };
 
         size_t                  fVertexSize;
     };
 
     int indexCountInCurrentSource() const {
         const GeometrySrcState& src = this->getGeomSrc();
         switch (src.fIndexSrc) {
             case kNone_GeometrySrcType:
                 return 0;
             case kReserved_GeometrySrcType:
-            case kArray_GeometrySrcType:
                 return src.fIndexCount;
             case kBuffer_GeometrySrcType:
                 return static_cast<int>(src.fIndexBuffer->gpuMemorySize() / sizeof(uint16_t));
             default:
                 SkFAIL("Unexpected Index Source.");
                 return 0;
         }
     }
 
     // This method is called by copySurface  The srcRect is guaranteed to be entirely within the
@@ skipping 121 matching lines @@
     // A subclass can optionally overload this function to be notified before
     // vertex and index space is reserved.
     virtual void willReserveVertexAndIndexSpace(int vertexCount, int indexCount) {}
 
     // implemented by subclass to allocate space for reserved geom
     virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) = 0;
     virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
     // implemented by subclass to handle release of reserved geom space
     virtual void releaseReservedVertexSpace() = 0;
     virtual void releaseReservedIndexSpace() = 0;
-    // subclass must consume array contents when set
-    virtual void onSetVertexSourceToArray(const void* vertexArray, int vertexCount) = 0;
-    virtual void onSetIndexSourceToArray(const void* indexArray, int indexCount) = 0;
-    // subclass is notified that geom source will be set away from an array
-    virtual void releaseVertexArray() = 0;
-    virtual void releaseIndexArray() = 0;
     // subclass overrides to be notified just before geo src state is pushed/popped.
     virtual void geometrySourceWillPush() = 0;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
     // subclass called to perform drawing
     virtual void onDraw(const DrawInfo&) = 0;
     // Implementation of drawRect. The geometry src and vertex attribs will already
     // be saved before this is called and restored afterwards. A subclass may override
     // this to perform more optimal rect rendering. Its draws should be funneled through
     // one of the public GrDrawTarget draw methods (e.g. drawNonIndexed,
     // drawIndexedInstances, ...). The base class draws a two triangle fan using
@@ skipping 85 matching lines @@
 protected:
     GrClipMaskManager           fClipMaskManager;
 
 private:
     GrClipMaskManager* getClipMaskManager() { return &fClipMaskManager; }
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif