Make onPrepareDraws const

src/gpu/batches/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 125 matching lines @@
                     fStroke.setStrokeStyle(-1.0f);
                 }
             }
         }
         SkPath fPath;
         // The unique ID of the path involved in this draw. This may be different than the ID
         // in fPath since that path may have resulted from a SkStrokeRec::applyToPath call.
         uint32_t fGenID;
         SkStrokeRec fStroke;
         bool fAntiAlias;
-        PathData* fPathData;
     };
 
     static GrDrawBatch* Create(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
                                GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
         return new AADistanceFieldPathBatch(geometry, color, viewMatrix, atlas, pathCache,
                                             pathList);
     }
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
@@ skipping 19 matching lines @@
         fBatch.fCoverageIgnored = !overrides.readsCoverage();
     }
 
     struct FlushInfo {
         SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
         SkAutoTUnref<const GrIndexBuffer>  fIndexBuffer;
         int fVertexOffset;
         int fInstancesToFlush;
     };
 
-    void onPrepareDraws(Target* target) override {
+    void onPrepareDraws(Target* target) const 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;
@@ skipping 25 matching lines @@
                                                  &flushInfo.fVertexOffset);
         flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
         flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
         if (!vertices || !flushInfo.fIndexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         flushInfo.fInstancesToFlush = 0;
         for (int i = 0; i < instanceCount; i++) {
-            Geometry& args = fGeoData[i];
+            const Geometry& args = fGeoData[i];
 
             // get mip level
             SkScalar maxScale = this->viewMatrix().getMaxScale();
             const SkRect& bounds = args.fPath.getBounds();
             SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
             SkScalar size = maxScale * maxDim;
             uint32_t desiredDimension;
             if (size <= kSmallMIP) {
                 desiredDimension = kSmallMIP;
             } else if (size <= kMediumMIP) {
                 desiredDimension = kMediumMIP;
             } else {
                 desiredDimension = kLargeMIP;
             }
 
             // check to see if path is cached
             PathData::Key key(args.fGenID, desiredDimension, args.fStroke);
-            args.fPathData = fPathCache->find(key);
-            if (nullptr == args.fPathData || !atlas->hasID(args.fPathData->fID)) {
+            PathData* pathData = fPathCache->find(key);
+            if (nullptr == pathData || !atlas->hasID(pathData->fID)) {
                 // Remove the stale cache entry
-                if (args.fPathData) {
-                    fPathCache->remove(args.fPathData->fKey);
-                    fPathList->remove(args.fPathData);
-                    delete args.fPathData;
+                if (pathData) {
+                    fPathCache->remove(pathData->fKey);
+                    fPathList->remove(pathData);
+                    delete pathData;
                 }
                 SkScalar scale = desiredDimension/maxDim;
-                args.fPathData = new PathData;
+                pathData = new PathData;
                 if (!this->addPathToAtlas(target,
                                           dfProcessor,
                                           this->pipeline(),
                                           &flushInfo,
                                           atlas,
-                                          args.fPathData,
+                                          pathData,
                                           args.fPath,
                                           args.fGenID,
                                           args.fStroke,
                                           args.fAntiAlias,
                                           desiredDimension,
                                           scale)) {
                     SkDebugf("Can't rasterize path\n");
                     return;
                 }
             }
 
-            atlas->setLastUseToken(args.fPathData->fID, target->currentToken());
+            atlas->setLastUseToken(pathData->fID, target->currentToken());
 
             // Now set vertices
             intptr_t offset = reinterpret_cast<intptr_t>(vertices);
             offset += i * kVerticesPerQuad * vertexStride;
             SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
             this->writePathVertices(target,
                                     atlas,
                                     this->pipeline(),
                                     dfProcessor,
                                     positions,
                                     vertexStride,
                                     this->viewMatrix(),
                                     args.fPath,
-                                    args.fPathData);
+                                    pathData);
             flushInfo.fInstancesToFlush++;
         }
 
         this->flush(target, &flushInfo);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
     AADistanceFieldPathBatch(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
                              GrBatchAtlas* atlas,
                              PathCache* pathCache, PathDataList* pathList)
         : INHERITED(ClassID()) {
         fBatch.fColor = color;
         fBatch.fViewMatrix = viewMatrix;
         fGeoData.push_back(geometry);
-        fGeoData.back().fPathData = nullptr;
 
         fAtlas = atlas;
         fPathCache = pathCache;
         fPathList = pathList;
 
         // Compute bounds
         fBounds = geometry.fPath.getBounds();
         viewMatrix.mapRect(&fBounds);
     }
 
     bool addPathToAtlas(GrVertexBatch::Target* target,
                         const GrGeometryProcessor* dfProcessor,
                         const GrPipeline* pipeline,
                         FlushInfo* flushInfo,
                         GrBatchAtlas* atlas,
                         PathData* pathData,
                         const SkPath& path,
                         uint32_t genID,
                         const SkStrokeRec& stroke,
                         bool antiAlias,
                         uint32_t dimension,
-                        SkScalar scale) {
+                        SkScalar scale) const {
         const SkRect& bounds = path.getBounds();
 
         // generate bounding rect for bitmap draw
         SkRect scaledBounds = bounds;
         // scale to mip level size
         scaledBounds.fLeft *= scale;
         scaledBounds.fTop *= scale;
         scaledBounds.fRight *= scale;
         scaledBounds.fBottom *= scale;
         // move the origin to an integer boundary (gives better results)
@@ skipping 96 matching lines @@
     }
 
     void writePathVertices(GrDrawBatch::Target* target,
                            GrBatchAtlas* atlas,
                            const GrPipeline* pipeline,
                            const GrGeometryProcessor* gp,
                            SkPoint* positions,
                            size_t vertexStride,
                            const SkMatrix& viewMatrix,
                            const SkPath& path,
-                           const PathData* pathData) {
+                           const PathData* pathData) const {
         GrTexture* texture = atlas->getTexture();
 
         SkScalar dx = pathData->fBounds.fLeft;
         SkScalar dy = pathData->fBounds.fTop;
         SkScalar width = pathData->fBounds.width();
         SkScalar height = pathData->fBounds.height();
 
         SkScalar invScale = 1.0f / pathData->fScale;
         dx *= invScale;
         dy *= invScale;
@@ skipping 12 matching lines @@
 
         // vertex texture coords
         SkPoint* textureCoords = positions + 1;
         textureCoords->setRectFan(SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx + tw)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty + th)),
                                   vertexStride);
     }
 
-    void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) {
+    void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
         GrVertices vertices;
         int maxInstancesPerDraw = flushInfo->fIndexBuffer->maxQuads();
         vertices.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
             flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
             kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw);
         target->draw(vertices);
         flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
         flushInfo->fInstancesToFlush = 0;
     }
 
@@ skipping 145 matching lines @@
     geometry.fAntiAlias = random->nextBool();
     geometry.fGenID = random->nextU();
 
     return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif