Remove batchtracker

src/gpu/GrPrimitiveProcessor.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPrimitiveProcessor_DEFINED
 #define GrPrimitiveProcessor_DEFINED
 
@@ skipping 24 matching lines @@
  *
  * In a deferred geometry world, the GrPrimitiveProcessor can always 'batch'  To do this, each
  * primitive type is associated with one GrPrimitiveProcessor, who has complete control of how
  * it draws.  Each primitive draw will bundle all required data to perform the draw, and these
  * bundles of data will be owned by an instance of the associated GrPrimitiveProcessor.  Bundles
  * can be updated alongside the GrBatchTracker struct itself, ultimately allowing the
  * GrPrimitiveProcessor complete control of how it gets data into the fragment shader as long as
  * it emits the appropriate color, or none at all, as directed.
  */
 
-/*
- * A struct for tracking batching decisions.  While this lives on GrOptState, it is managed
- * entirely by the derived classes of the GP.
- * // TODO this was an early attempt at handling out of order batching.  It should be
- * used carefully as it is being replaced by GrBatch
- */
-class GrBatchTracker {
-public:
-    template <typename T> const T& cast() const {
-        SkASSERT(sizeof(T) <= kMaxSize);
-        return *reinterpret_cast<const T*>(fData.get());
-    }
-
-    template <typename T> T* cast() {
-        SkASSERT(sizeof(T) <= kMaxSize);
-        return reinterpret_cast<T*>(fData.get());
-    }
-
-    static const size_t kMaxSize = 32;
-
-private:
-    SkAlignedSStorage<kMaxSize> fData;
-};
-
 class GrGLSLCaps;
 class GrGLPrimitiveProcessor;
 
 struct GrInitInvariantOutput;
 
 /*
  * This class allows the GrPipeline to communicate information about the pipeline to a
  * GrBatch which should be forwarded to the GrPrimitiveProcessor(s) created by the batch.
  * These are not properly part of the pipeline because they assume the specific inputs
  * that the batch provided when it created the pipeline. Identical pipelines may be
@@ skipping 86 matching lines @@
     kIgnored_GrGPInput,
 };
 
 /*
  * GrPrimitiveProcessor defines an interface which all subclasses must implement.  All
  * GrPrimitiveProcessors must proivide seed color and coverage for the Ganesh color / coverage
  * pipelines, and they must provide some notion of equality
  */
 class GrPrimitiveProcessor : public GrProcessor {
 public:
-    virtual void initBatchTracker(GrBatchTracker*, const GrPipelineOptimizations&) const = 0;
-
-    virtual void getInvariantOutputColor(GrInitInvariantOutput* out) const = 0;
-    virtual void getInvariantOutputCoverage(GrInitInvariantOutput* out) const = 0;
-
     // Only the GrGeometryProcessor subclass actually has a geo shader or vertex attributes, but
     // we put these calls on the base class to prevent having to cast
     virtual bool willUseGeoShader() const = 0;
 
     /*
      * This is a safeguard to prevent GrPrimitiveProcessor's from going beyond platform specific
      * attribute limits. This number can almost certainly be raised if required.
      */
     static const int kMaxVertexAttribs = 6;
 
@@ skipping 33 matching lines @@
      */
     uint32_t getTransformKey(const SkTArray<const GrCoordTransform*, true>& coords,
                              int numCoords) const;
 
     /**
      * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this geometry
      * processor's GL backend implementation.
      *
      * TODO: A better name for this function  would be "compute" instead of "get".
      */
-    virtual void getGLProcessorKey(const GrBatchTracker& bt,
-                                   const GrGLSLCaps& caps,
+    virtual void getGLProcessorKey(const GrGLSLCaps& caps,
                                    GrProcessorKeyBuilder* b) const = 0;
 
 
     /** Returns a new instance of the appropriate *GL* implementation class
         for the given GrProcessor; caller is responsible for deleting
         the object. */
-    virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
-                                                     const GrGLSLCaps& caps) const = 0;
+    virtual GrGLPrimitiveProcessor* createGLInstance(const GrGLSLCaps& caps) const = 0;
 
     bool isPathRendering() const { return fIsPathRendering; }
 
     /**
      * No Local Coord Transformation is needed in the shader, instead transformed local coords will
      * be provided via vertex attribute.
      */
     virtual bool hasTransformedLocalCoords() const = 0;
 
 protected:
     GrPrimitiveProcessor(bool isPathRendering)
         : fNumAttribs(0)
         , fVertexStride(0)
         , fIsPathRendering(isPathRendering) {}
 
     Attribute fAttribs[kMaxVertexAttribs];
     int fNumAttribs;
     size_t fVertexStride;
 
 private:
     void notifyRefCntIsZero() const final {};
     virtual bool hasExplicitLocalCoords() const = 0;
 
     bool fIsPathRendering;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif