Revert of Preliminary attempt to remove batch tracker

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
@@ skipping 13 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
 
 static const GrGeometryProcessor* create_fill_rect_gp(bool tweakAlphaForCoverage,
-                                                      const SkMatrix& localMatrix,
-                                                      bool usesLocalCoords,
-                                                      bool coverageIgnored) {
+                                                      const SkMatrix& localMatrix) {
     uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType;
     const GrGeometryProcessor* gp;
     if (tweakAlphaForCoverage) {
-        gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, coverageIgnored,
-                                             SkMatrix::I(), localMatrix);
+        gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, SkMatrix::I(), localMatrix);
     } else {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
-        gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, coverageIgnored,
-                                             SkMatrix::I(), localMatrix);
+        gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, SkMatrix::I(), localMatrix);
     }
     return gp;
 }
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
 
 class AAFillRectBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
@@ skipping 36 matching lines @@
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
         SkMatrix localMatrix;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
             SkDebugf("Cannot invert\n");
             return;
         }
 
         SkAutoTUnref<const GrGeometryProcessor> gp(create_fill_rect_gp(canTweakAlphaForCoverage,
-                                                                       localMatrix,
-                                                                       this->usesLocalCoords(),
-                                                                       this->coverageIgnored()));
+                                                                       localMatrix));
 
         batchTarget->initDraw(gp, pipeline);
 
+        // TODO this is hacky, but the only way we have to initialize the GP is to use the
+        // GrPipelineInfo struct so we can generate the correct shader.  Once we have GrBatch
+        // everywhere we can remove this nastiness
+        GrPipelineInfo init;
+        init.fColorIgnored = fBatch.fColorIgnored;
+        init.fOverrideColor = GrColor_ILLEGAL;
+        init.fCoverageIgnored = fBatch.fCoverageIgnored;
+        init.fUsesLocalCoords = this->usesLocalCoords();
+        gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
+
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(canTweakAlphaForCoverage ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         int instanceCount = fGeoData.count();
 
         SkAutoTUnref<const GrIndexBuffer> indexBuffer(this->getIndexBuffer(
             batchTarget->resourceProvider()));
         InstancedHelper helper;
         void* vertices = helper.init(batchTarget, kTriangles_GrPrimitiveType, vertexStride,
@@ skipping 47 matching lines @@
         return resourceProvider->refOrCreateInstancedIndexBuffer(gFillAARectIdx,
             kIndicesPerAAFillRect, kNumAAFillRectsInIndexBuffer, kVertsPerAAFillRect,
             gAAFillRectIndexBufferKey);
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
-    bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t) override {
         AAFillRectBatch* that = t->cast<AAFillRectBatch>();
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
         // local coords then we won't be able to batch.  We could actually upload the viewmatrix
         // using vertex attributes in these cases, but haven't investigated that
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
@@ skipping 257 matching lines @@
 
         // Local matrix is ignored if we don't have local coords.  If we have localcoords we only
         // batch with identical view matrices
         SkMatrix localMatrix;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
             SkDebugf("Cannot invert\n");
             return;
         }
 
         SkAutoTUnref<const GrGeometryProcessor> gp(create_fill_rect_gp(canTweakAlphaForCoverage,
-                                                                       localMatrix,
-                                                                       this->usesLocalCoords(),
-                                                                       this->coverageIgnored()));
+                                                                       localMatrix));
 
         batchTarget->initDraw(gp, pipeline);
 
+        // TODO this is hacky, but the only way we have to initialize the GP is to use the
+        // GrPipelineInfo struct so we can generate the correct shader.  Once we have GrBatch
+        // everywhere we can remove this nastiness
+        GrPipelineInfo init;
+        init.fColorIgnored = fBatch.fColorIgnored;
+        init.fOverrideColor = GrColor_ILLEGAL;
+        init.fCoverageIgnored = fBatch.fCoverageIgnored;
+        init.fUsesLocalCoords = this->usesLocalCoords();
+        gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
+
         size_t vertexStride = gp->getVertexStride();
 
         SkASSERT(canTweakAlphaForCoverage ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         int innerVertexNum = 4;
         int outerVertexNum = this->miterStroke() ? 4 : 8;
         int verticesPerInstance = (outerVertexNum + innerVertexNum) * 2;
         int indicesPerInstance = this->miterStroke() ? kMiterIndexCnt : kBevelIndexCnt;
         int instanceCount = fGeoData.count();
@@ skipping 139 matching lines @@
                 gBevelIndexBufferKey);
         }
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
     bool miterStroke() const { return fBatch.fMiterStroke; }
-    bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t) override {
         AAStrokeRectBatch* that = t->cast<AAStrokeRectBatch>();
 
         // TODO batch across miterstroke changes
         if (this->miterStroke() != that->miterStroke()) {
             return false;
         }
 
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
@@ skipping 214 matching lines @@
     geo.fColor = GrRandomColor(random);
     geo.fDevOutside = outside;
     geo.fDevOutsideAssist = outsideAssist;
     geo.fDevInside = inside;
     geo.fMiterStroke = miterStroke;
 
     return AAStrokeRectBatch::Create(geo, GrTest::TestMatrix(random));
 }
 
 #endif