Minor cleanup in GrTessellatingPathRenderer.

src/gpu/GrTessellatingPathRenderer.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 "GrTessellatingPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 1319 matching lines @@
     for (Poly* poly = polys; poly; poly = poly->fNext) {
         if (apply_fill_type(fillType, poly->fWinding)) {
             d = poly->emit(d);
         }
     }
     return d;
 }
 
 struct TessInfo {
     SkScalar  fTolerance;
-    int       fCount;
+    int       fVertexCount;
 };
 
-bool cache_match(GrVertexBuffer* vertexBuffer, SkScalar tol, int* actualCount) {
+bool cache_match(GrVertexBuffer* vertexBuffer, SkScalar tol, int* vertexCount) {
     if (!vertexBuffer) {
         return false;
     }
     const SkData* data = vertexBuffer->getUniqueKey().getCustomData();
     SkASSERT(data);
     const TessInfo* info = static_cast<const TessInfo*>(data->data());
     if (info->fTolerance == 0 || info->fTolerance < 3.0f * tol) {
-        *actualCount = info->fCount;
+        *vertexCount = info->fVertexCount;
         return true;
     }
     return false;
 }
 
 };
 
 GrTessellatingPathRenderer::GrTessellatingPathRenderer() {
 }
 
@@ skipping 102 matching lines @@
 
         // For the initial size of the chunk allocator, estimate based on the point count:
         // one vertex per point for the initial passes, plus two for the vertices in the
         // resulting Polys, since the same point may end up in two Polys.  Assume minimal
         // connectivity of one Edge per Vertex (will grow for intersections).
         SkChunkAlloc alloc(maxPts * (3 * sizeof(Vertex) + sizeof(Edge)));
         bool isLinear;
         path_to_contours(path, tol, fClipBounds, contours.get(), alloc, &isLinear);
         Poly* polys;
         polys = contours_to_polys(contours.get(), contourCnt, c, alloc);
-        int count = 0;
+        int vertexCount = 0;
         for (Poly* poly = polys; poly; poly = poly->fNext) {
             if (apply_fill_type(fillType, poly->fWinding) && poly->fCount >= 3) {
-                count += (poly->fCount - 2) * (WIREFRAME ? 6 : 3);
+                vertexCount += (poly->fCount - 2) * (WIREFRAME ? 6 : 3);
             }
         }
-        if (0 == count) {
+        if (0 == vertexCount) {
             return 0;
         }
 
-        size_t size = count * sizeof(SkPoint);
+        size_t size = vertexCount * sizeof(SkPoint);
         if (!vertexBuffer.get() || vertexBuffer->gpuMemorySize() < size) {
             vertexBuffer.reset(resourceProvider->createVertexBuffer(
                 size, GrResourceProvider::kStatic_BufferUsage, 0));
         }
         if (!vertexBuffer.get()) {
             SkDebugf("Could not allocate vertices\n");
             return 0;
         }
         SkPoint* verts;
         if (canMapVB) {
             verts = static_cast<SkPoint*>(vertexBuffer->map());
         } else {
-            verts = new SkPoint[count];
+            verts = new SkPoint[vertexCount];
         }
-        SkPoint* end = polys_to_triangles(polys, fillType, verts);
-        int actualCount = static_cast<int>(end - verts);
-        LOG("actual count: %d\n", actualCount);
-        SkASSERT(actualCount <= count);
+        SkDEBUGCODE(SkPoint* end = ) polys_to_triangles(polys, fillType, verts);
+        SkASSERT(static_cast<int>(end - verts) == vertexCount);
+        LOG("vertex count: %d\n", vertexCount);
         if (canMapVB) {
             vertexBuffer->unmap();
         } else {
-            vertexBuffer->updateData(verts, actualCount * sizeof(SkPoint));
+            vertexBuffer->updateData(verts, vertexCount * sizeof(SkPoint));
             delete[] verts;
         }
 
 
         if (!fPath.isVolatile()) {
             TessInfo info;
             info.fTolerance = isLinear ? 0 : tol;
-            info.fCount = actualCount;
+            info.fVertexCount = vertexCount;
             SkAutoTUnref<SkData> data(SkData::NewWithCopy(&info, sizeof(info)));
             key->setCustomData(data.get());
             resourceProvider->assignUniqueKeyToResource(*key, vertexBuffer.get());
             SkPathPriv::AddGenIDChangeListener(fPath, new PathInvalidator(*key));
         }
-        return actualCount;
+        return vertexCount;
     }
 
     void onPrepareDraws(Target* target) override {
         // construct a cache key from the path's genID and the view matrix
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
         GrUniqueKey key;
         int clipBoundsSize32 =
             fPath.isInverseFillType() ? sizeof(fClipBounds) / sizeof(uint32_t) : 0;
         int strokeDataSize32 = fStroke.computeUniqueKeyFragmentData32Cnt();
         GrUniqueKey::Builder builder(&key, kDomain, 2 + clipBoundsSize32 + strokeDataSize32);
         builder[0] = fPath.getGenerationID();
         builder[1] = fPath.getFillType();
         // For inverse fills, the tessellation is dependent on clip bounds.
         if (fPath.isInverseFillType()) {
             memcpy(&builder[2], &fClipBounds, sizeof(fClipBounds));
         }
         fStroke.asUniqueKeyFragment(&builder[2 + clipBoundsSize32]);
         builder.finish();
         GrResourceProvider* rp = target->resourceProvider();
         SkAutoTUnref<GrVertexBuffer> vertexBuffer(rp->findAndRefTByUniqueKey<GrVertexBuffer>(key));
-        int actualCount;
+        int vertexCount;
         SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
         SkScalar tol = GrPathUtils::scaleToleranceToSrc(
             screenSpaceTol, fViewMatrix, fPath.getBounds());
-        if (!cache_match(vertexBuffer.get(), tol, &actualCount)) {
+        if (!cache_match(vertexBuffer.get(), tol, &vertexCount)) {
             bool canMapVB = GrCaps::kNone_MapFlags != target->caps().mapBufferFlags();
-            actualCount = tessellate(&key, rp, vertexBuffer, canMapVB);
+            vertexCount = tessellate(&key, rp, vertexBuffer, canMapVB);
         }
 
-        if (actualCount == 0) {
+        if (vertexCount == 0) {
             return;
         }
 
         SkAutoTUnref<const GrGeometryProcessor> gp;
         {
             using namespace GrDefaultGeoProcFactory;
 
             Color color(fColor);
             LocalCoords localCoords(fPipelineInfo.readsLocalCoords() ?
                                     LocalCoords::kUsePosition_Type :
                                     LocalCoords::kUnused_Type);
             Coverage::Type coverageType;
             if (fPipelineInfo.readsCoverage()) {
                 coverageType = Coverage::kSolid_Type;
             } else {
                 coverageType = Coverage::kNone_Type;
             }
             Coverage coverage(coverageType);
             gp.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords,
                                                      fViewMatrix));
         }
 
         target->initDraw(gp, this->pipeline());
         SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
 
         GrPrimitiveType primitiveType = WIREFRAME ? kLines_GrPrimitiveType
                                                   : kTriangles_GrPrimitiveType;
         GrVertices vertices;
-        vertices.init(primitiveType, vertexBuffer.get(), 0, actualCount);
+        vertices.init(primitiveType, vertexBuffer.get(), 0, vertexCount);
         target->draw(vertices);
     }
 
     bool onCombineIfPossible(GrBatch*, const GrCaps&) override { return false; }
 
     TessellatingPathBatch(const GrColor& color,
                           const SkPath& path,
                           const GrStrokeInfo& stroke,
                           const SkMatrix& viewMatrix,
                           const SkRect& clipBounds)
@@ skipping 62 matching lines @@
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
     GrStrokeInfo strokeInfo = GrTest::TestStrokeInfo(random);
     return TessellatingPathBatch::Create(color, path, strokeInfo, viewMatrix, clipBounds);
 }
 
 #endif