Introduce GrBatch subclasses GrDrawBatch and GrVertexBatch to prepare for non-drawing batches

src/gpu/GrPipelineBuilder.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 GrPipelineBuilder_DEFINED
 #define GrPipelineBuilder_DEFINED
 
 #include "GrBlend.h"
 #include "GrCaps.h"
 #include "GrClip.h"
 #include "GrGpuResourceRef.h"
 #include "GrStagedProcessor.h"
 #include "GrProcOptInfo.h"
 #include "GrProcessorDataManager.h"
 #include "GrRenderTarget.h"
 #include "GrStencil.h"
 #include "GrXferProcessor.h"
 #include "SkMatrix.h"
 #include "effects/GrCoverageSetOpXP.h"
 #include "effects/GrDisableColorXP.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrSimpleTextureEffect.h"
 
-class GrBatch;
+class GrDrawBatch;
 class GrCaps;
 class GrPaint;
 class GrTexture;
 
 class GrPipelineBuilder {
 public:
     GrPipelineBuilder();
 
     GrPipelineBuilder(const GrPipelineBuilder& pipelineBuilder) {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
@@ skipping 355 matching lines @@
     const GrProcOptInfo& colorProcInfo(const GrPrimitiveProcessor* pp) const {
         this->calcColorInvariantOutput(pp);
         return fColorProcInfo;
     }
 
     const GrProcOptInfo& coverageProcInfo(const GrPrimitiveProcessor* pp) const {
         this->calcCoverageInvariantOutput(pp);
         return fCoverageProcInfo;
     }
 
-    const GrProcOptInfo& colorProcInfo(const GrBatch* batch) const {
+    const GrProcOptInfo& colorProcInfo(const GrDrawBatch* batch) const {
         this->calcColorInvariantOutput(batch);
         return fColorProcInfo;
     }
 
-    const GrProcOptInfo& coverageProcInfo(const GrBatch* batch) const {
+    const GrProcOptInfo& coverageProcInfo(const GrDrawBatch* batch) const {
         this->calcCoverageInvariantOutput(batch);
         return fCoverageProcInfo;
     }
 
     void setClip(const GrClip& clip) { fClip = clip; }
     const GrClip& clip() const { return fClip; }
 
     GrProcessorDataManager* getProcessorDataManager() { return fProcDataManager.get(); }
     const GrProcessorDataManager* processorDataManager() const { return fProcDataManager.get(); }
 
 private:
     // Calculating invariant color / coverage information is expensive, so we partially cache the
     // results.
     //
     // canUseFracCoveragePrimProc() - Called in regular skia draw, caches results but only for a
     //                                specific color and coverage.  May be called multiple times
     // GrOptDrawState constructor - never caches results
 
     /**
      * Primproc variants of the calc functions
      * TODO remove these when batch is everywhere
      */
     void calcColorInvariantOutput(const GrPrimitiveProcessor*) const;
     void calcCoverageInvariantOutput(const GrPrimitiveProcessor*) const;
 
     /**
      * GrBatch provides the initial seed for these loops based off of its initial geometry data
      */
-    void calcColorInvariantOutput(const GrBatch*) const;
-    void calcCoverageInvariantOutput(const GrBatch*) const;
+    void calcColorInvariantOutput(const GrDrawBatch*) const;
+    void calcCoverageInvariantOutput(const GrDrawBatch*) const;
 
     /**
      * If fColorProcInfoValid is false, function calculates the invariant output for the color
      * processors and results are stored in fColorProcInfo.
      */
     void calcColorInvariantOutput(GrColor) const;
 
     /**
      * If fCoverageProcInfoValid is false, function calculates the invariant output for the coverage
      * processors and results are stored in fCoverageProcInfo.
@@ skipping 20 matching lines @@
     mutable GrProcOptInfo fCoverageProcInfo;
     mutable bool fColorProcInfoValid;
     mutable bool fCoverageProcInfoValid;
     mutable GrColor fColorCache;
     mutable GrColor fCoverageCache;
 
     friend class GrPipeline;
 };
 
 #endif