add a ClassID function to GrBatch

src/gpu/batches/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 23 matching lines @@
  */
 #define GR_BATCH_SPEW 0
 #if GR_BATCH_SPEW
     #define GrBATCH_INFO(...) SkDebugf(__VA_ARGS__)
     #define GrBATCH_SPEW(code) code
 #else
     #define GrBATCH_SPEW(code)
     #define GrBATCH_INFO(...)
 #endif
 
+// A helper macro to generate a class static id

[robertphillips, 2015/09/17 14:56:06]

DEFINE_BATCH_CLASS_ID ?

+#define BATCH_CLASS_ID \
+    static uint32_t ClassID() { \
+        static uint32_t kClassID = GenID(&gCurrBatchClassID); \
+        return kClassID; \
+    }
+
 class GrBatch : public GrNonAtomicRef {
 public:
     GrBatch();
     ~GrBatch() override;
 
     virtual const char* name() const = 0;
 
     bool combineIfPossible(GrBatch* that, const GrCaps& caps) {
         if (this->classID() != that->classID()) {
             return false;
         }
 
         return this->onCombineIfPossible(that, caps);
     }
 
     const SkRect& bounds() const { return fBounds; }
 
     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);
     }
 
     /**
-     * Helper for down-casting to a GrBatch subclass
+     * Helper for safely down-casting to a GrBatch subclass
      */
-    template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
-    template <typename T> T* cast() { return static_cast<T*>(this); }
+    template <typename T> const T& cast() const {
+        SkASSERT(T::ClassID() == this->classID());
+        return *static_cast<const T*>(this);
+    }
+
+    template <typename T> T* cast() {
+        SkASSERT(T::ClassID() == this->classID());
+        return static_cast<T*>(this);
+    }
 
     uint32_t classID() const { SkASSERT(kIllegalBatchID != fClassID); return fClassID; }
 
 #if GR_BATCH_SPEW
     uint32_t uniqueID() const { return fUniqueID; }
 #endif
     SkDEBUGCODE(bool isUsed() const { return fUsed; })
 
     /** Called prior to drawing. The batch should perform any resource creation necessary to
         to quickly issue its draw when draw is called. */
     void prepare(GrBatchFlushState* state) { this->onPrepare(state); }
 
     /** Issues the batches commands to GrGpu. */
     void draw(GrBatchFlushState* state) { this->onDraw(state); }
 
     /** Used to block batching across render target changes. Remove this once we store
         GrBatches for different RTs in different targets. */
     virtual uint32_t renderTargetUniqueID() const = 0;
 
     /** Used for spewing information about batches when debugging. */
     virtual SkString dumpInfo() const = 0;
 
 protected:

[robertphillips, 2015/09/17 14:56:06]

// (via BATCH_CLASS_ID macro) ?

We can't do this in the ctor (and make 'fClassID' const) ?

-    template <typename PROC_SUBCLASS> void initClassID() {
-         static uint32_t kClassID = GenID(&gCurrBatchClassID);
-         fClassID = kClassID;
+    // Caller must have already defined BATCH_SUBCLASS::ClassID()
+    template <class BATCH_SUBCLASS> void initClassID() {
+        SkASSERT(kIllegalBatchID == fClassID);
+        fClassID = BATCH_SUBCLASS::ClassID();
     }
 
     // NOTE, compute some bounds, even if extremely conservative.  Do *NOT* setLargest on the bounds
     // rect because we outset it for dst copy textures
     void setBounds(const SkRect& newBounds) { fBounds = newBounds; }
 
     void joinBounds(const SkRect& otherBounds) {
         return fBounds.joinPossiblyEmptyRect(otherBounds);
     }
 
-    SkRect                              fBounds;
-
-private:
-    virtual bool onCombineIfPossible(GrBatch*, const GrCaps& caps) = 0;
-
-    virtual void onPrepare(GrBatchFlushState*) = 0;
-    virtual void onDraw(GrBatchFlushState*) = 0;
-
     static uint32_t GenID(int32_t* idCounter) {

[robertphillips, 2015/09/17 14:56:06]

fCurrProcessorClassID -> idCounter ?

         // 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(idCounter)) + 1;
         if (!id) {
             SkFAIL("This should never wrap as it should only be called once for each GrBatch "
                    "subclass.");
         }
         return id;
     }
 
+    SkRect                              fBounds;
+    uint32_t                            fClassID;

[robertphillips, 2015/09/17 14:56:06]

= kIllegalBatchID; ?

+    static int32_t                      gCurrBatchClassID;
+
+private:
+    virtual bool onCombineIfPossible(GrBatch*, const GrCaps& caps) = 0;
+
+    virtual void onPrepare(GrBatchFlushState*) = 0;
+    virtual void onDraw(GrBatchFlushState*) = 0;
+
     enum {
         kIllegalBatchID = 0,
     };
 
-    uint32_t                            fClassID;
     SkDEBUGCODE(bool                    fUsed;)
 #if GR_BATCH_SPEW
     uint32_t                            fUniqueID;
     static int32_t gCurrBatchUniqueID;
 #endif
-    static int32_t gCurrBatchClassID;
     typedef GrNonAtomicRef INHERITED;
 };
 
 #endif