Hairline batch

src/gpu/GrBatch.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 GrBatch_DEFINED
 #define GrBatch_DEFINED
 
@@ skipping 28 matching lines @@
  * information will be communicated to the GrBatch prior to geometry generation.
  */
 
 struct GrBatchOpt {
   bool fCanTweakAlphaForCoverage;
 };
 
 class GrBatch : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrBatch)
-    GrBatch() { SkDEBUGCODE(fUsed = false;) }
+    GrBatch() : fBatchesGenerated(0) { SkDEBUGCODE(fUsed = false;) }
     virtual ~GrBatch() {}
 
     virtual const char* name() const = 0;
     virtual void getInvariantOutputColor(GrInitInvariantOutput* out) const = 0;
     virtual void getInvariantOutputCoverage(GrInitInvariantOutput* out) const = 0;
 
     /*
      * initBatchOpt is used to communicate possible optimizations to the GrBatch.  initBatchTracker
      * is a hook for the some additional overrides from the GrXferProcessor.  This is a bit
      * confusing but has to be like this until GrBatch is everywhere.
      *
      * TODO combine to a single init call when GrBatch is everywhere.
      */
     virtual void initBatchOpt(const GrBatchOpt&) = 0;
     virtual void initBatchTracker(const GrPipelineInfo& init) = 0;
 
     bool combineIfPossible(GrBatch* that) {
         if (this->classID() != that->classID()) {
             return false;
         }
 
         return onCombineIfPossible(that);
     }
 
     virtual bool onCombineIfPossible(GrBatch*) = 0;
 
     virtual void generateGeometry(GrBatchTarget*, const GrPipeline*) = 0;
 
+    // TODO this goes away when batches are everywhere
+    int batchesGenerated() const { return fBatchesGenerated; }
+
     void* operator new(size_t size);
     void operator delete(void* target);
 
     void* operator new(size_t size, void* placement) {
         return ::operator new(size, placement);
     }
     void operator delete(void* target, void* placement) {
         ::operator delete(target, placement);
     }
 
@@ skipping 10 matching lines @@
 
     SkDEBUGCODE(bool isUsed() const { return fUsed; })
 
 protected:
     template <typename PROC_SUBCLASS> void initClassID() {
          static uint32_t kClassID = GenClassID();
          fClassID = kClassID;
     }
 
     uint32_t fClassID;
+    int fBatchesGenerated;
 
 private:
     static uint32_t GenClassID() {
         // fCurrProcessorClassID has been initialized to kIllegalProcessorClassID. The
         // atomic inc returns the old value not the incremented value. So we add
         // 1 to the returned value.
         uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrBatchClassID)) + 1;
         if (!id) {
             SkFAIL("This should never wrap as it should only be called once for each GrBatch "
                    "subclass.");
         }
         return id;
     }
 
     enum {
         kIllegalBatchClassID = 0,
     };
     static int32_t gCurrBatchClassID;
 
     SkDEBUGCODE(bool fUsed;)
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif