Move DrawInfo out from GrDrawTarget and rename to GrVertices.

src/gpu/GrBatchTarget.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBatchBuffer_DEFINED
 #define GrBatchBuffer_DEFINED
 
 #include "GrBatchAtlas.h"
 #include "GrBufferAllocPool.h"
 #include "GrPendingProgramElement.h"
 #include "GrPipeline.h"
-#include "GrGpu.h"
 #include "GrTRecorder.h"
+#include "GrVertices.h"
 
 /*
  * GrBatch instances use this object to allocate space for their geometry and to issue the draws
  * that render their batch.
  */
 
 class GrIndexBufferAllocPool;
 class GrVertexBufferAllocPool;
 
 class GrBatchTarget : public SkNoncopyable {
 public:
     typedef GrBatchAtlas::BatchToken BatchToken;
     GrBatchTarget(GrGpu* gpu,
                   GrVertexBufferAllocPool* vpool,
                   GrIndexBufferAllocPool* ipool);
 
-    typedef GrDrawTarget::DrawInfo DrawInfo;
     void initDraw(const GrPrimitiveProcessor* primProc, const GrPipeline* pipeline) {
         GrNEW_APPEND_TO_RECORDER(fFlushBuffer, BufferedFlush, (primProc, pipeline));
         fNumberOfDraws++;
         fCurrentToken++;
     }
 
     class TextureUploader {
     public:
         TextureUploader(GrGpu* gpu) : fGpu(gpu) { SkASSERT(gpu); }
 
@@ skipping 32 matching lines @@
     };
 
     void upload(Uploader* upload) {
         if (this->asapToken() == upload->lastUploadToken()) {
             fAsapUploads.push_back().reset(SkRef(upload));
         } else {
             fInlineUploads.push_back().reset(SkRef(upload));
         }
     }
 
-    void draw(const GrDrawTarget::DrawInfo& draw) {
-        fFlushBuffer.back().fDraws.push_back(draw);
+    void draw(const GrVertices& vertices) {
+        fFlushBuffer.back().fVertexDraws.push_back(vertices);
     }
 
     bool isIssued(BatchToken token) const { return fLastFlushedToken >= token; }
     BatchToken currentToken() const { return fCurrentToken; }
     BatchToken asapToken() const { return fLastFlushedToken + 1; }
 
     // TODO much of this complexity goes away when batch is everywhere
     void resetNumberOfDraws() { fNumberOfDraws = 0; }
     int numberOfDraws() const { return fNumberOfDraws; }
     void preFlush() {
@@ skipping 40 matching lines @@
     typedef void* TBufferAlign; // This wouldn't be enough align if a command used long double.
 
     struct BufferedFlush {
         BufferedFlush(const GrPrimitiveProcessor* primProc, const GrPipeline* pipeline)
             : fPrimitiveProcessor(primProc)
             , fPipeline(pipeline) {}
         typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor;
         ProgramPrimitiveProcessor fPrimitiveProcessor;
         const GrPipeline* fPipeline;
         GrBatchTracker fBatchTracker;
-        SkSTArray<1, DrawInfo, true> fDraws;
+        SkSTArray<1, GrVertices, true> fVertexDraws;
     };
 
     enum {
         kFlushBufferInitialSizeInBytes = 8 * sizeof(BufferedFlush),
     };
 
     typedef GrTRecorder<BufferedFlush, TBufferAlign> FlushBuffer;
 
     FlushBuffer fFlushBuffer;
     // TODO this is temporary
     FlushBuffer::Iter fIter;
     int fNumberOfDraws;
     BatchToken fCurrentToken;
     BatchToken fLastFlushedToken; // The next token to be flushed
     SkTArray<SkAutoTUnref<Uploader>, true> fAsapUploads;
     SkTArray<SkAutoTUnref<Uploader>, true> fInlineUploads;
     int fInlineUpdatesIndex;
 };
 
 #endif