Fix memory leak in FuzzGradients

fuzz/FuzzGradients.cpp

Index: fuzz/FuzzGradients.cpp
diff --git a/fuzz/FuzzGradients.cpp b/fuzz/FuzzGradients.cpp
index 98026b3e0da21b0c5c9c7d9f26a43567bd1539d9..d75484c1862f4047a4cc54251f513072fd5e5818 100644
--- a/fuzz/FuzzGradients.cpp
+++ b/fuzz/FuzzGradients.cpp
@@ -32,15 +32,12 @@ bool makeMatrix(Fuzz* fuzz, SkMatrix* m) {
     return true;
 }
 
-bool initGradientParams(Fuzz* fuzz, uint32_t* count, SkColor** colors, SkScalar** pos,
-    SkShader::TileMode* mode) {
+bool initGradientParams(Fuzz* fuzz, uint32_t* count, std::unique_ptr<SkColor[]>* colors,
+    std::unique_ptr<SkScalar[]>* pos, SkShader::TileMode* mode) {
     if (fuzz->remaining() < sizeof(uint32_t)) {
         return false;
     }
     uint32_t t_count;

[mtklein_C, 2016/10/24 17:51:11]

Out of curiosity, what is the t_ prefix for?

[kjlubick, 2016/10/24 19:11:46]

I don't recall.  It's been awhile since I wrote this.  Temp? 

-    SkColor* t_colors;
-    SkScalar* t_pos;
-
     t_count = fuzz->nextRangeU(0, MAX_COUNT);
     if (t_count == 1) {
         t_count = 2;
@@ -49,24 +46,23 @@ bool initGradientParams(Fuzz* fuzz, uint32_t* count, SkColor** colors, SkScalar*
     if (fuzz->remaining() < (1 + t_count * (sizeof(SkColor) + sizeof(SkScalar)))) {
         return false;
     }
-    t_colors = new SkColor[t_count];
-    t_pos = new SkScalar[t_count];
+    colors->reset(new SkColor[t_count]);
+    pos->reset(new SkScalar[t_count]);
+
     for (uint32_t i = 0; i < t_count; i++) {
-        fuzz->next<SkColor>(&t_colors[i]);
-        fuzz->next<SkScalar>(&t_pos[i]);
+        fuzz->next<SkColor>(&(*colors)[i]);
+        fuzz->next<SkScalar>(&(*pos)[i]);
     }
 
     if (t_count == 0) {
         *count = 0;
-        *colors = NULL;
-        *pos = NULL;
+        colors->reset();
+        pos->reset();
     } else {
-        std::sort(t_pos, t_pos + t_count);
-        t_pos[0] = 0;
-        t_pos[t_count - 1] = 1;
+        std::sort(pos->get(), pos->get() + t_count);
+        (*pos)[0] = 0;
+        (*pos)[t_count - 1] = 1;
         *count = t_count;
-        *colors = t_colors;
-        *pos = t_pos;
     }
 
     *mode = static_cast<SkShader::TileMode>(fuzz->nextRangeU(0, 3));
@@ -87,8 +83,8 @@ void fuzzLinearGradient(Fuzz* fuzz) {
         SkPoint pts[2] = {SkPoint::Make(a,b), SkPoint::Make(c, d)};
 
         uint32_t count;
-        SkColor* colors;
-        SkScalar* pos;
+        std::unique_ptr<SkColor[]> colors;

[mtklein_C, 2016/10/24 17:51:11]

This seems fine, but we'd normally use an SkTDArray or std::vector.  We usually
only resort to manually memory management when we have to for performance...
most of the time it's easier to just let a class with a friendlier interface
manage it.

Now, if performance really matters here, we should probably go all the way to
just putting an array of MAX_COUNT of each on the stack.

[kjlubick, 2016/10/24 19:11:46]

Done.  Vector used.  I don't care about the performance too much.

+        std::unique_ptr<SkScalar[]> pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
             return;
@@ -104,8 +100,8 @@ void fuzzLinearGradient(Fuzz* fuzz) {
         if (useLocalMatrix && !makeMatrix(fuzz, localMatrix.init())) {
             return;
         }
-        p.setShader(SkGradientShader::MakeLinear(pts, colors, pos, count, mode,
-            flags, localMatrix.getMaybeNull()));
+        p.setShader(SkGradientShader::MakeLinear(pts, colors.get(), pos.get(),
+            count, mode, flags, localMatrix.getMaybeNull()));
 
         sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
         if (useGlobalMatrix) {
@@ -134,8 +130,8 @@ void fuzzRadialGradient(Fuzz* fuzz) {
         SkPoint center = SkPoint::Make(a,b);
 
         uint32_t count;
-        SkColor* colors;
-        SkScalar* pos;
+        std::unique_ptr<SkColor[]> colors;
+        std::unique_ptr<SkScalar[]> pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
             return;
@@ -151,8 +147,8 @@ void fuzzRadialGradient(Fuzz* fuzz) {
         if (useLocalMatrix && !makeMatrix(fuzz, localMatrix.init())) {
             return;
         }
-        p.setShader(SkGradientShader::MakeRadial(center, radius, colors, pos,
-            count, mode, flags, localMatrix.getMaybeNull()));
+        p.setShader(SkGradientShader::MakeRadial(center, radius, colors.get(),
+            pos.get(), count, mode, flags, localMatrix.getMaybeNull()));
 
 
         sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
@@ -186,8 +182,8 @@ void fuzzTwoPointConicalGradient(Fuzz* fuzz) {
         SkPoint end = SkPoint::Make(c, d);
 
         uint32_t count;
-        SkColor* colors;
-        SkScalar* pos;
+        std::unique_ptr<SkColor[]> colors;
+        std::unique_ptr<SkScalar[]> pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
             return;
@@ -204,7 +200,8 @@ void fuzzTwoPointConicalGradient(Fuzz* fuzz) {
             return;
         }
         p.setShader(SkGradientShader::MakeTwoPointConical(start, startRadius, end,
-            endRadius, colors, pos, count, mode, flags, localMatrix.getMaybeNull()));
+            endRadius, colors.get(), pos.get(), count, mode, flags,
+            localMatrix.getMaybeNull()));
 
         sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
         if (useGlobalMatrix) {
@@ -231,8 +228,8 @@ void fuzzSweepGradient(Fuzz* fuzz) {
         }
 
         uint32_t count;
-        SkColor* colors;
-        SkScalar* pos;
+        std::unique_ptr<SkColor[]> colors;
+        std::unique_ptr<SkScalar[]> pos;
         SkShader::TileMode mode;
         if (!initGradientParams(fuzz, &count, &colors, &pos, &mode)) {
             return;
@@ -248,9 +245,11 @@ void fuzzSweepGradient(Fuzz* fuzz) {
             if (!fuzz->next(&flags)) {
                 return;
             }
-            p.setShader(SkGradientShader::MakeSweep(cx, cy, colors, pos, count, flags, &m));
+            p.setShader(SkGradientShader::MakeSweep(cx, cy, colors.get(),
+                pos.get(), count, flags, &m));
         } else {
-            p.setShader(SkGradientShader::MakeSweep(cx, cy, colors, pos, count));
+            p.setShader(SkGradientShader::MakeSweep(cx, cy, colors.get(),
+                pos.get(), count));
         }