Revert of Preliminary attempt to remove batch tracker

src/gpu/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrBatch.h"
@@ skipping 756 matching lines @@
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
     GrColor color() const { return fBatch.fColor; }
     uint8_t coverage() const { return fBatch.fCoverage; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
-    bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     struct BatchTracker {
         GrColor fColor;
         uint8_t fCoverage;
         SkRect fDevBounds;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
@@ skipping 21 matching lines @@
         toSrc = &invert;
     }
 
     // Setup geometry processors for worst case
     uint32_t gpFlags = GrDefaultGeoProcFactory::kPosition_GPType |
                        GrDefaultGeoProcFactory::kCoverage_GPType;
 
     SkAutoTUnref<const GrGeometryProcessor> lineGP(
             GrDefaultGeoProcFactory::Create(gpFlags,
                                             this->color(),
-                                            this->usesLocalCoords(),
-                                            this->coverageIgnored(),
                                             *geometryProcessorViewM,
                                             *geometryProcessorLocalM,
                                             this->coverage()));
 
     SkAutoTUnref<const GrGeometryProcessor> quadGP(
             GrQuadEffect::Create(this->color(),
                                  *geometryProcessorViewM,
                                  kHairlineAA_GrProcessorEdgeType,
                                  batchTarget->caps(),
                                  *geometryProcessorLocalM,
-                                 this->usesLocalCoords(),
                                  this->coverage()));
 
     SkAutoTUnref<const GrGeometryProcessor> conicGP(
             GrConicEffect::Create(this->color(),
                                   *geometryProcessorViewM,
                                   kHairlineAA_GrProcessorEdgeType,
                                   batchTarget->caps(),
                                   *geometryProcessorLocalM,
-                                  this->usesLocalCoords(),
                                   this->coverage()));
 
     // This is hand inlined for maximum performance.
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     PREALLOC_PTARRAY(128) conics;
     IntArray qSubdivs;
     FloatArray cWeights;
     int quadCount = 0;
 
     int instanceCount = fGeoData.count();
     for (int i = 0; i < instanceCount; i++) {
         const Geometry& args = fGeoData[i];
         quadCount += gather_lines_and_quads(args.fPath, args.fViewMatrix, args.fDevClipBounds,
                                             &lines, &quads, &conics, &qSubdivs, &cWeights);
     }
 
     int lineCount = lines.count() / 2;
     int conicCount = conics.count() / 3;
 
     // do lines first
     if (lineCount) {
         SkAutoTUnref<const GrIndexBuffer> linesIndexBuffer(
             ref_lines_index_buffer(batchTarget->resourceProvider()));
         batchTarget->initDraw(lineGP, pipeline);
 
+        // TODO remove this when batch is everywhere
+        GrPipelineInfo init;
+        init.fColorIgnored = fBatch.fColorIgnored;
+        init.fOverrideColor = GrColor_ILLEGAL;
+        init.fCoverageIgnored = fBatch.fCoverageIgnored;
+        init.fUsesLocalCoords = this->usesLocalCoords();
+        lineGP->initBatchTracker(batchTarget->currentBatchTracker(), init);
+
         const GrVertexBuffer* vertexBuffer;
         int firstVertex;
 
         size_t vertexStride = lineGP->getVertexStride();
         int vertexCount = kLineSegNumVertices * lineCount;
         LineVertex* verts = reinterpret_cast<LineVertex*>(
             batchTarget->makeVertSpace(vertexStride, vertexCount, &vertexBuffer, &firstVertex));
 
         if (!verts|| !linesIndexBuffer) {
             SkDebugf("Could not allocate vertices\n");
@@ skipping 42 matching lines @@
         }
 
         // Start Conics
         for (int i = 0; i < conicCount; ++i) {
             add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &verts);
         }
 
         if (quadCount > 0) {
             batchTarget->initDraw(quadGP, pipeline);
 
+            // TODO remove this when batch is everywhere
+            GrPipelineInfo init;
+            init.fColorIgnored = fBatch.fColorIgnored;
+            init.fOverrideColor = GrColor_ILLEGAL;
+            init.fCoverageIgnored = fBatch.fCoverageIgnored;
+            init.fUsesLocalCoords = this->usesLocalCoords();
+            quadGP->initBatchTracker(batchTarget->currentBatchTracker(), init);
+
             {
                 GrVertices verts;
                 verts.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
                                     firstVertex, kQuadNumVertices, kIdxsPerQuad, quadCount,
                                     kQuadsNumInIdxBuffer);
                 batchTarget->draw(verts);
                 firstVertex += quadCount * kQuadNumVertices;
            }
         }
 
         if (conicCount > 0) {
             batchTarget->initDraw(conicGP, pipeline);
 
+            // TODO remove this when batch is everywhere
+            GrPipelineInfo init;
+            init.fColorIgnored = fBatch.fColorIgnored;
+            init.fOverrideColor = GrColor_ILLEGAL;
+            init.fCoverageIgnored = fBatch.fCoverageIgnored;
+            init.fUsesLocalCoords = this->usesLocalCoords();
+            conicGP->initBatchTracker(batchTarget->currentBatchTracker(), init);
+
             {
                 GrVertices verts;
                 verts.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
                                     firstVertex, kQuadNumVertices, kIdxsPerQuad, conicCount,
                                     kQuadsNumInIdxBuffer);
                 batchTarget->draw(verts);
             }
         }
     }
 }
@@ skipping 45 matching lines @@
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrStrokeInfo stroke(SkStrokeRec::kHairline_InitStyle);
     SkPath path = GrTest::TestPath(random);
     SkIRect devClipBounds;
     devClipBounds.setEmpty();
     return create_hairline_batch(color, viewMatrix, path, stroke, devClipBounds);
 }
 
 #endif