Make onPrepareDraws const

src/gpu/batches/GrDefaultPathRenderer.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 "GrDefaultPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 232 matching lines @@
         }
         opt.getOverrideColorIfSet(&fGeoData[0].fColor);
 
         // setup batch properties
         fBatch.fColorIgnored = !opt.readsColor();
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = opt.readsLocalCoords();
         fBatch.fCoverageIgnored = !opt.readsCoverage();
     }
 
-    void onPrepareDraws(Target* target) override {
+    void onPrepareDraws(Target* target) const override {
         SkAutoTUnref<const GrGeometryProcessor> gp;
         {
             using namespace GrDefaultGeoProcFactory;
             Color color(this->color());
             Coverage coverage(this->coverage());
             if (this->coverageIgnored()) {
                 coverage.fType = Coverage::kNone_Type;
             }
             LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
                                                               LocalCoords::kUnused_Type);
             gp.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords,
                                                      this->viewMatrix()));
         }
 
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(vertexStride == sizeof(SkPoint));
 
         target->initDraw(gp, this->pipeline());
 
         int instanceCount = fGeoData.count();
 
         // compute number of vertices
         int maxVertices = 0;
 
         // We will use index buffers if we have multiple paths or one path with multiple contours
         bool isIndexed = instanceCount > 1;
         for (int i = 0; i < instanceCount; i++) {
-            Geometry& args = fGeoData[i];
+            const Geometry& args = fGeoData[i];
 
             int contourCount;
             maxVertices += GrPathUtils::worstCasePointCount(args.fPath, &contourCount,
                                                             args.fTolerance);
 
             isIndexed = isIndexed || contourCount > 1;
         }
 
         if (maxVertices == 0 || maxVertices > ((int)SK_MaxU16 + 1)) {
             SkDebugf("Cannot render path (%d)\n", maxVertices);
@@ skipping 41 matching lines @@
             if (!indices) {
                 SkDebugf("Could not allocate indices\n");
                 return;
             }
         }
 
         // fill buffers
         int vertexOffset = 0;
         int indexOffset = 0;
         for (int i = 0; i < instanceCount; i++) {
-            Geometry& args = fGeoData[i];
+            const Geometry& args = fGeoData[i];
 
             int vertexCnt = 0;
             int indexCnt = 0;
             if (!this->createGeom(verts,
                                   vertexOffset,
                                   indices,
                                   indexOffset,
                                   &vertexCnt,
                                   &indexCnt,
                                   args.fPath,
@@ skipping 69 matching lines @@
     }
 
     bool createGeom(void* vertices,
                     size_t vertexOffset,
                     void* indices,
                     size_t indexOffset,
                     int* vertexCnt,
                     int* indexCnt,
                     const SkPath& path,
                     SkScalar srcSpaceTol,
-                    bool isIndexed)  {
+                    bool isIndexed) const {
         {
             SkScalar srcSpaceTolSqd = SkScalarMul(srcSpaceTol, srcSpaceTol);
 
             uint16_t indexOffsetU16 = (uint16_t)indexOffset;
             uint16_t vertexOffsetU16 = (uint16_t)vertexOffset;
 
             uint16_t* idxBase = reinterpret_cast<uint16_t*>(indices) + indexOffsetU16;
             uint16_t* idx = idxBase;
             uint16_t subpathIdxStart = vertexOffsetU16;
 
@@ skipping 319 matching lines @@
     geometry.fColor = color;
     geometry.fPath = path;
     geometry.fTolerance = srcSpaceTol;
 
     viewMatrix.mapRect(&bounds);
     uint8_t coverage = GrRandomCoverage(random);
     return DefaultPathBatch::Create(geometry, coverage, viewMatrix, true, bounds);
 }
 
 #endif