Revert of Preliminary attempt to remove batch tracker

src/gpu/GrRectBatch.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrRectBatch.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrBatchTest.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrTemplates.h"
 
 /** We always use per-vertex colors so that rects can be batched across color changes. Sometimes we
     have explicit local coords and sometimes not. We *could* always provide explicit local coords
     and just duplicate the positions when the caller hasn't provided a local coord rect, but we
     haven't seen a use case which frequently switches between local rect and no local rect draws.
 
     The color param is used to determine whether the opaque hint can be set on the draw state.
     The caller must populate the vertex colors itself.
 
     The vertex attrib order is always pos, color, [local coords].
  */
 static const GrGeometryProcessor* create_rect_gp(bool hasExplicitLocalCoords,
-                                                 const SkMatrix* localMatrix,
-                                                 bool usesLocalCoords,
-                                                 bool coverageIgnored) {
-    // TODO remove color when we have ignored color from the XP
+                                                 GrColor color,
+                                                 const SkMatrix* localMatrix) {
     uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType |
                      GrDefaultGeoProcFactory::kColor_GPType;
     flags |= hasExplicitLocalCoords ? GrDefaultGeoProcFactory::kLocalCoord_GPType : 0;
     if (localMatrix) {
-        return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords,
-                                               coverageIgnored, SkMatrix::I(), *localMatrix);
+        return GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), *localMatrix);
     } else {
-        return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords,
-                                               coverageIgnored, SkMatrix::I(), SkMatrix::I());
+        return GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), SkMatrix::I());
     }
 }
 
 class RectBatch : public GrBatch {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkRect fLocalRect;
         SkMatrix fLocalMatrix;
@@ skipping 44 matching lines @@
                 SkDebugf("Could not invert\n");
                 return;
             }
 
             if (this->hasLocalMatrix()) {
                 invert.preConcat(this->localMatrix());
             }
         }
 
         SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(hasExplicitLocalCoords,
-                                                                  &invert,
-                                                                  this->usesLocalCoords(),
-                                                                  this->coverageIgnored()));
+                                                                  this->color(),
+                                                                  &invert));
 
         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);
+
         int instanceCount = fGeoData.count();
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(hasExplicitLocalCoords ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
         QuadHelper helper;
         void* vertices = helper.init(batchTarget, vertexStride, instanceCount);
 
         if (!vertices) {
             return;
@@ skipping 43 matching lines @@
         geometry.fViewMatrix.mapRect(&fBounds);
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     const SkMatrix& localMatrix() const { return fGeoData[0].fLocalMatrix; }
     bool hasLocalRect() const { return fGeoData[0].fHasLocalRect; }
     bool hasLocalMatrix() const { return fGeoData[0].fHasLocalMatrix; }
-    bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t) override {
         RectBatch* that = t->cast<RectBatch>();
 
         if (this->hasLocalRect() != that->hasLocalRect()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (!this->hasLocalRect() && this->usesLocalCoords()) {
@@ skipping 84 matching lines @@
     if (hasLocalMatrix) {
         localMatrix = GrTest::TestMatrix(random);
     }
 
     return GrRectBatch::Create(color, viewMatrix, rect,
                                hasLocalRect ? &localRect : NULL,
                                hasLocalMatrix ? &localMatrix : NULL);
 }
 
 #endif