Preliminary attempt to remove batch tracker

src/gpu/GrAtlasTextContext.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 "GrAtlasTextContext.h"
 
 #include "GrBatch.h"
 #include "GrBatchFontCache.h"
@@ skipping 1519 matching lines @@
         SkAutoTUnref<const GrGeometryProcessor> gp;
         if (fUseDistanceFields) {
             gp.reset(this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(),
                                             texture));
         } else {
             GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
             gp.reset(GrBitmapTextGeoProc::Create(this->color(),
                                                  texture,
                                                  params,
                                                  fMaskFormat,
-                                                 localMatrix));
+                                                 localMatrix,
+                                                 this->usesLocalCoords()));
         }
 
         FlushInfo flushInfo;
         flushInfo.fGlyphsToFlush = 0;
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(vertexStride == (fUseDistanceFields ?
                                   get_vertex_stride_df(fMaskFormat, fUseLCDText) :
                                   get_vertex_stride(fMaskFormat)));
 
-        this->initDraw(batchTarget, gp, pipeline);
+        batchTarget->initDraw(gp, pipeline);
 
         int glyphCount = this->numGlyphs();
         int instanceCount = fInstanceCount;
         const GrVertexBuffer* vertexBuffer;
 
         void* vertices = batchTarget->makeVertSpace(vertexStride,
                                                     glyphCount * kVerticesPerGlyph,
                                                     &vertexBuffer,
                                                     &flushInfo.fVertexOffset);
         flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
@@ skipping 89 matching lines @@
                             glyph = blob->fGlyphs[glyphOffset];
                             blob->fGlyphs[glyphOffset] = strike->getGlyph(glyph->fPackedID,
                                                                           scaler);
                         }
                         glyph = blob->fGlyphs[glyphOffset];
                         SkASSERT(glyph);
 
                         if (!fFontCache->hasGlyph(glyph) &&
                             !strike->addGlyphToAtlas(batchTarget, glyph, scaler)) {
                             this->flush(batchTarget, &flushInfo);
-                            this->initDraw(batchTarget, gp, pipeline);
+                            batchTarget->initDraw(gp, pipeline);
                             brokenRun = glyphIdx > 0;
 
                             SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget,
                                                                                 glyph,
                                                                                 scaler);
                             SkASSERT(success);
                         }
                         fFontCache->addGlyphToBulkAndSetUseToken(&info.fBulkUseToken, glyph,
                                                                  batchTarget->currentToken());
 
@@ skipping 171 matching lines @@
     void regeneratePositions(intptr_t vertex, size_t vertexStride, SkScalar transX,
                              SkScalar transY) {
         for (int i = 0; i < kVerticesPerGlyph; i++) {
             SkPoint* point = reinterpret_cast<SkPoint*>(vertex);
             point->fX += transX;
             point->fY += transY;
             vertex += vertexStride;
         }
     }
 
-    void initDraw(GrBatchTarget* batchTarget,
-                  const GrGeometryProcessor* gp,
-                  const GrPipeline* pipeline) {
-        batchTarget->initDraw(gp, 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();
-        gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
-    }
-
     void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) {
         GrVertices vertices;
         int maxGlyphsPerDraw = flushInfo->fIndexBuffer->maxQuads();
         vertices.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
                                flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
                                kVerticesPerGlyph, kIndicesPerGlyph, flushInfo->fGlyphsToFlush,
                                maxGlyphsPerDraw);
         batchTarget->draw(vertices);
         flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
         flushInfo->fGlyphsToFlush = 0;
@@ skipping 109 matching lines @@
             GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
                 GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(redCorrection,
                                                                     greenCorrection,
                                                                     blueCorrection);
 
             return GrDistanceFieldLCDTextGeoProc::Create(color,
                                                          viewMatrix,
                                                          texture,
                                                          params,
                                                          widthAdjust,
-                                                         flags);
+                                                         flags,
+                                                         this->usesLocalCoords());
         } else {
             flags |= kColorAttr_DistanceFieldEffectFlag;
 #ifdef SK_GAMMA_APPLY_TO_A8
             U8CPU lum = SkColorSpaceLuminance::computeLuminance(fGamma, filteredColor);
             float correction = (*fDistanceAdjustTable)[lum >> kDistanceAdjustLumShift];
             return GrDistanceFieldA8TextGeoProc::Create(color,
                                                         viewMatrix,
                                                         texture,
                                                         params,
                                                         correction,
-                                                        flags);
+                                                        flags,
+                                                        this->usesLocalCoords());
 #else
             return GrDistanceFieldA8TextGeoProc::Create(color,
                                                         viewMatrix,
                                                         texture,
                                                         params,
-                                                        flags);
+                                                        flags,
+                                                        this->usesLocalCoords());
 #endif
         }
 
     }
 
     struct BatchTracker {
         GrColor fColor;
         SkMatrix fViewMatrix;
         bool fUsesLocalCoords;
         bool fColorIgnored;
@@ skipping 249 matching lines @@
             gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextContext::BitmapTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif