Don't pass pipeline to GrBatch::generateGeometry()

src/gpu/GrAADistanceFieldPathRenderer.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 149 matching lines @@
         fBatch.fCoverageIgnored = !init.readsCoverage();
     }
 
     struct FlushInfo {
         SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
         SkAutoTUnref<const GrIndexBuffer>  fIndexBuffer;
         int fVertexOffset;
         int fInstancesToFlush;
     };
 
-    void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
+    void generateGeometry(GrBatchTarget* batchTarget) override {
         int instanceCount = fGeoData.count();
 
         SkMatrix invert;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
             SkDebugf("Could not invert viewmatrix\n");
             return;
         }
 
         uint32_t flags = 0;
         flags |= this->viewMatrix().isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
 
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
 
         // Setup GrGeometryProcessor
         GrBatchAtlas* atlas = fAtlas;
         SkAutoTUnref<GrGeometryProcessor> dfProcessor(
                 GrDistanceFieldPathGeoProc::Create(this->color(),
                                                    this->viewMatrix(),
                                                    atlas->getTexture(),
                                                    params,
                                                    flags,
                                                    this->usesLocalCoords()));
 
-        batchTarget->initDraw(dfProcessor, pipeline);
+        batchTarget->initDraw(dfProcessor, this->pipeline());
 
         FlushInfo flushInfo;
 
         // allocate vertices
         size_t vertexStride = dfProcessor->getVertexStride();
         SkASSERT(vertexStride == 2 * sizeof(SkPoint));
 
         const GrVertexBuffer* vertexBuffer;
         void* vertices = batchTarget->makeVertSpace(vertexStride,
                                                     kVerticesPerQuad * instanceCount,
@@ skipping 32 matching lines @@
                 // Remove the stale cache entry
                 if (args.fPathData) {
                     fPathCache->remove(args.fPathData->fKey);
                     fPathList->remove(args.fPathData);
                     SkDELETE(args.fPathData);
                 }
                 SkScalar scale = desiredDimension/maxDim;
                 args.fPathData = SkNEW(PathData);
                 if (!this->addPathToAtlas(batchTarget,
                                           dfProcessor,
-                                          pipeline,
+                                          this->pipeline(),
                                           &flushInfo,
                                           atlas,
                                           args.fPathData,
                                           args.fPath,
                                           args.fStroke,
                                           args.fAntiAlias,
                                           desiredDimension,
                                           scale)) {
                     SkDebugf("Can't rasterize path\n");
                     return;
                 }
             }
 
             atlas->setLastUseToken(args.fPathData->fID, batchTarget->currentToken());
 
             // Now set vertices
             intptr_t offset = reinterpret_cast<intptr_t>(vertices);
             offset += i * kVerticesPerQuad * vertexStride;
             SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
             this->writePathVertices(batchTarget,
                                     atlas,
-                                    pipeline,
+                                    this->pipeline(),
                                     dfProcessor,
                                     positions,
                                     vertexStride,
                                     this->viewMatrix(),
                                     args.fPath,
                                     args.fPathData);
             flushInfo.fInstancesToFlush++;
         }
 
         this->flush(batchTarget, &flushInfo);
@@ skipping 345 matching lines @@
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
 
     return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif