Fix memory leak in FuzzGradients

fuzz/FuzzGradients.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Fuzz.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
@@ skipping 14 matching lines @@
             !fuzz->next<SkScalar>(&transY) ||
             !fuzz->next<SkScalar>(&persp0) ||
             !fuzz->next<SkScalar>(&persp1) ||
             !fuzz->next<SkScalar>(&persp2)) {
         return false;
     }
     m->setAll(scaleX, skewX, transX, skewY, scaleY, transY, persp0, persp1, persp2);
     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;
     }
 
     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));
     return true;
 }
 
 void fuzzLinearGradient(Fuzz* fuzz) {
         SkScalar a, b, c, d;
         bool useLocalMatrix, useGlobalMatrix;
         if (!fuzz->next<SkScalar>(&a)          ||
                 !fuzz->next<SkScalar>(&b)          ||
                 !fuzz->next<SkScalar>(&c)          ||
                 !fuzz->next<SkScalar>(&d)          ||
                 !fuzz->next(&useLocalMatrix) ||
                 !fuzz->next(&useGlobalMatrix)) {
             return;
         }
         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;
         }
 
         SkPaint p;
         uint32_t flags;
         if (!fuzz->next(&flags)) {
             return;
         }
 
         SkTLazy<SkMatrix> localMatrix;
         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) {
             SkMatrix gm;
             if (!makeMatrix(fuzz, &gm)) {
                 return;
             }
             SkCanvas* c = surface->getCanvas();
             c->setMatrix(gm);
             c->drawPaint(p);
         } else {
             surface->getCanvas()->drawPaint(p);
         }
 }
 
 void fuzzRadialGradient(Fuzz* fuzz) {
         SkScalar a, b, radius;
         bool useLocalMatrix, useGlobalMatrix;
         if (!fuzz->next<SkScalar>(&a)          ||
                 !fuzz->next<SkScalar>(&b)          ||
                 !fuzz->next<SkScalar>(&radius)     ||
                 !fuzz->next(&useLocalMatrix) ||
                 !fuzz->next(&useGlobalMatrix)) {
             return;
         }
         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;
         }
 
         SkPaint p;
         uint32_t flags;
         if (!fuzz->next(&flags)) {
             return;
         }
 
         SkTLazy<SkMatrix> localMatrix;
         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));
         if (useGlobalMatrix) {
             SkMatrix gm;
             if (!makeMatrix(fuzz, &gm)) {
                 return;
             }
             SkCanvas* c = surface->getCanvas();
             c->setMatrix(gm);
@@ skipping 13 matching lines @@
                 !fuzz->next<SkScalar>(&d)           ||
                 !fuzz->next<SkScalar>(&endRadius)   ||
                 !fuzz->next(&useLocalMatrix)  ||
                 !fuzz->next(&useGlobalMatrix)) {
             return;
         }
         SkPoint start = SkPoint::Make(a, b);
         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;
         }
 
         SkPaint p;
         uint32_t flags;
         if (!fuzz->next(&flags)) {
             return;
         }
 
         SkTLazy<SkMatrix> localMatrix;
         if (useLocalMatrix && !makeMatrix(fuzz, localMatrix.init())) {
             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) {
             SkMatrix gm;
             if (!makeMatrix(fuzz, &gm)) {
                 return;
             }
             SkCanvas* c = surface->getCanvas();
             c->setMatrix(gm);
             c->drawPaint(p);
         } else {
             surface->getCanvas()->drawPaint(p);
         }
 }
 
 void fuzzSweepGradient(Fuzz* fuzz) {
         SkScalar cx, cy;
         bool useLocalMatrix, useGlobalMatrix;
         if (!fuzz->next<SkScalar>(&cx)         ||
                 !fuzz->next<SkScalar>(&cy)         ||
                 !fuzz->next(&useLocalMatrix) ||
                 !fuzz->next(&useGlobalMatrix)) {
             return;
         }
 
         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;
         }
 
         SkPaint p;
         if (useLocalMatrix) {
             SkMatrix m;
             if (!makeMatrix(fuzz, &m)) {
                 return;
             }
             uint32_t flags;
             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));
         }
 
 
         sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
         if (useGlobalMatrix) {
             SkMatrix gm;
             if (!makeMatrix(fuzz, &gm)) {
                 return;
             }
             SkCanvas* c = surface->getCanvas();
@@ skipping 21 matching lines @@
             return;
         case 2:
             SkDebugf("TwoPointConicalGradient\n");
             fuzzTwoPointConicalGradient(fuzz);
             return;
     }
     SkDebugf("SweepGradient\n");
     fuzzSweepGradient(fuzz);
     return;
 }