stray malloc/free -> sk_malloc/sk_free

src/gpu/GrAALinearizingConvexPathRenderer.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 "GrAALinearizingConvexPathRenderer.h"
 
@@ skipping 36 matching lines @@
         return false;
     }
     if (!args.fPath->isConvex()) {
         return false;
     }
     if (args.fStroke->getStyle() == SkStrokeRec::kStroke_Style) {
         if (!args.fViewMatrix->isSimilarity()) {
             return false;
         }
         SkScalar strokeWidth = args.fViewMatrix->getMaxScale() * args.fStroke->getWidth();
-        return strokeWidth >= 1.0f && strokeWidth <= kMaxStrokeWidth && !args.fStroke->isDashed() && 
+        return strokeWidth >= 1.0f && strokeWidth <= kMaxStrokeWidth && !args.fStroke->isDashed() &&
                 SkPathPriv::LastVerbIsClose(*args.fPath) &&
                 args.fStroke->getJoin() != SkPaint::Join::kRound_Join;
     }
     return args.fStroke->getStyle() == SkStrokeRec::kFill_Style;
 }
 
 // extract the result vertices and indices from the GrAAConvexTessellator
 static void extract_verts(const GrAAConvexTessellator& tess,
                           void* vertices,
                           size_t vertexStride,
@@ skipping 10 matching lines @@
     // Make 'verts' point to the colors
     verts += sizeof(SkPoint);
     for (int i = 0; i < tess.numPts(); ++i) {
         if (tweakAlphaForCoverage) {
             SkASSERT(SkScalarRoundToInt(255.0f * tess.coverage(i)) <= 255);
             unsigned scale = SkScalarRoundToInt(255.0f * tess.coverage(i));
             GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
-            *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = 
+            *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) =
                     tess.coverage(i);
         }
     }
 
     for (int i = 0; i < tess.numIndices(); ++i) {
         idxs[i] = tess.index(i) + firstIndex;
     }
 }
 
 static const GrGeometryProcessor* create_fill_gp(bool tweakAlphaForCoverage,
@@ skipping 53 matching lines @@
 
         // setup batch properties
         fBatch.fColorIgnored = !opt.readsColor();
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = opt.readsLocalCoords();
         fBatch.fCoverageIgnored = !opt.readsCoverage();
         fBatch.fLinesOnly = SkPath::kLine_SegmentMask == fGeoData[0].fPath.getSegmentMasks();
         fBatch.fCanTweakAlphaForCoverage = opt.canTweakAlphaForCoverage();
     }
 
-    void draw(GrVertexBatch::Target* target, const GrPipeline* pipeline, int vertexCount, 
+    void draw(GrVertexBatch::Target* target, const GrPipeline* pipeline, int vertexCount,
             size_t vertexStride, void* vertices, int indexCount, uint16_t* indices) {
         if (vertexCount == 0 || indexCount == 0) {
             return;
         }
         const GrVertexBuffer* vertexBuffer;
         GrVertices info;
         int firstVertex;
-        void* verts = target->makeVertexSpace(vertexStride, vertexCount, &vertexBuffer, 
+        void* verts = target->makeVertexSpace(vertexStride, vertexCount, &vertexBuffer,
                                               &firstVertex);
         if (!verts) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
         memcpy(verts, vertices, vertexCount * vertexStride);
 
         const GrIndexBuffer* indexBuffer;
         int firstIndex;
         uint16_t* idxs = target->makeIndexSpace(indexCount, &indexBuffer, &firstIndex);
         if (!idxs) {
             SkDebugf("Could not allocate indices\n");
             return;
         }
         memcpy(idxs, indices, indexCount * sizeof(uint16_t));
-        info.initIndexed(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer, firstVertex, 
+        info.initIndexed(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer, firstVertex,
                 firstIndex, vertexCount, indexCount);
         target->draw(info);
     }
-    
+
     void onPrepareDraws(Target* target) override {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
         // Setup GrGeometryProcessor
         SkAutoTUnref<const GrGeometryProcessor> gp(create_fill_gp(canTweakAlphaForCoverage,
                                                                   this->viewMatrix(),
                                                                   this->usesLocalCoords(),
                                                                   this->coverageIgnored()));
         if (!gp) {
             SkDebugf("Couldn't create a GrGeometryProcessor\n");
             return;
         }
 
         target->initDraw(gp, this->pipeline());
 
         size_t vertexStride = gp->getVertexStride();
 
         SkASSERT(canTweakAlphaForCoverage ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
 
         int instanceCount = fGeoData.count();
 
         int vertexCount = 0;
         int indexCount = 0;
         int maxVertices = DEFAULT_BUFFER_SIZE;
         int maxIndices = DEFAULT_BUFFER_SIZE;
-        uint8_t* vertices = (uint8_t*) malloc(maxVertices * vertexStride);
-        uint16_t* indices = (uint16_t*) malloc(maxIndices * sizeof(uint16_t));
+        uint8_t* vertices = (uint8_t*) sk_malloc_throw(maxVertices * vertexStride);
+        uint16_t* indices = (uint16_t*) sk_malloc_throw(maxIndices * sizeof(uint16_t));
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
             GrAAConvexTessellator tess(args.fStrokeWidth, args.fJoin, args.fMiterLimit);
 
             if (!tess.tessellate(args.fViewMatrix, args.fPath)) {
                 continue;
             }
 
             int currentIndices = tess.numIndices();
             SkASSERT(currentIndices <= UINT16_MAX);
             if (indexCount + currentIndices > UINT16_MAX) {
-                // if we added the current instance, we would overflow the indices we can store in a 
+                // if we added the current instance, we would overflow the indices we can store in a
                 // uint16_t. Draw what we've got so far and reset.
-                draw(target, this->pipeline(), vertexCount, vertexStride, vertices, indexCount, 
+                draw(target, this->pipeline(), vertexCount, vertexStride, vertices, indexCount,
                      indices);
                 vertexCount = 0;
                 indexCount = 0;
             }
             int currentVertices = tess.numPts();
             if (vertexCount + currentVertices > maxVertices) {
                 maxVertices = SkTMax(vertexCount + currentVertices, maxVertices * 2);
-                vertices = (uint8_t*) realloc(vertices, maxVertices * vertexStride);
+                vertices = (uint8_t*) sk_realloc_throw(vertices, maxVertices * vertexStride);
             }
             if (indexCount + currentIndices > maxIndices) {
                 maxIndices = SkTMax(indexCount + currentIndices, maxIndices * 2);
-                indices = (uint16_t*) realloc(indices, maxIndices * sizeof(uint16_t));
+                indices = (uint16_t*) sk_realloc_throw(indices, maxIndices * sizeof(uint16_t));
             }
 
-            extract_verts(tess, vertices + vertexStride * vertexCount, vertexStride, args.fColor, 
+            extract_verts(tess, vertices + vertexStride * vertexCount, vertexStride, args.fColor,
                     vertexCount, indices + indexCount, canTweakAlphaForCoverage);
             vertexCount += currentVertices;
             indexCount += currentIndices;
         }
         draw(target, this->pipeline(), vertexCount, vertexStride, vertices, indexCount,
              indices);
-        free(vertices);
-        free(indices);
+        sk_free(vertices);
+        sk_free(indices);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
     AAFlatteningConvexPathBatch(const Geometry& geometry) {
         this->initClassID<AAFlatteningConvexPathBatch>();
         fGeoData.push_back(geometry);
 
         // compute bounds
         fBounds = geometry.fPath.getBounds();
@@ skipping 69 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAFlatteningConvexPathBatch) {
     AAFlatteningConvexPathBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
     geometry.fPath = GrTest::TestPathConvex(random);
 
     return AAFlatteningConvexPathBatch::Create(geometry);
 }
 
 #endif