fix casts

samplecode/SamplePathFuzz.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 "SampleCode.h"
 #include "SkView.h"
 #include "SkCanvas.h"
@@ skipping 113 matching lines @@
     "kSetSkewY",
     "kSetRotate",
     "kSetRotateTranslate",
     "kSetPerspectiveX",
     "kSetPerspectiveY",
     "kSetAll",
 };
 
 class FuzzPath {
 public:
-    FuzzPath() 
+    FuzzPath()
         : fFloatMin(0)
         , fFloatMax(800)
         , fAddCount(0)
         , fPrintName(false)
+        , fStrokeOnly(false)
         , fValidate(false)
     {
         fTab = "                                                                                  ";
     }
     void randomize() {
         fPathDepth = 0;
         fPathDepthLimit = fRand.nextRangeU(1, 2);
         fPathContourCount = fRand.nextRangeU(1, 4);
         fPathSegmentLimit = fRand.nextRangeU(1, 8);
         fClip = makePath();
@@ skipping 16 matching lines @@
     }
 
     const SkPaint& getPaint() const {
         return fPaint;
     }
 
     const SkPath& getPath() const {
         return fPath;
     }
 
+    void setSeed(int seed) {
+        fRand.setSeed(seed);
+    }
+
+    void setStrokeOnly() {
+        fStrokeOnly = true;
+    }
+
 private:
 
 SkPath::AddPathMode makeAddPathMode() {
     return (SkPath::AddPathMode) fRand.nextRangeU(SkPath::kAppend_AddPathMode,
         SkPath::kExtend_AddPathMode);
 }
 
 RandomAddPath makeAddPathType() {
     return (RandomAddPath) fRand.nextRangeU(0, kRandomAddPath_Last);
 }
@@ skipping 73 matching lines @@
                           makeScalar(), makeScalar(), makeScalar());
             break;
     }
     return matrix;
 }
 
 SkPaint makePaint() {
     SkPaint paint;
     bool antiAlias = fRand.nextBool();
     paint.setAntiAlias(antiAlias);
-    SkPaint::Style style = (SkPaint::Style) fRand.nextRangeU(SkPaint::kFill_Style,
-        SkPaint::kStrokeAndFill_Style);
+    SkPaint::Style style = fStrokeOnly ? SkPaint::kStroke_Style :
+        (SkPaint::Style) fRand.nextRangeU(SkPaint::kFill_Style, SkPaint::kStrokeAndFill_Style);
     paint.setStyle(style);
     SkColor color = (SkColor) fRand.nextU();
     paint.setColor(color);
-    SkScalar width = fRand.nextF();
+    SkScalar width = fRand.nextRangeF(0, 10);
     paint.setStrokeWidth(width);
-    SkScalar miter = fRand.nextF();
+    SkScalar miter = makeScalar();
     paint.setStrokeMiter(miter);
     SkPaint::Cap cap = (SkPaint::Cap) fRand.nextRangeU(SkPaint::kButt_Cap, SkPaint::kSquare_Cap);
     paint.setStrokeCap(cap);
     SkPaint::Join join = (SkPaint::Join) fRand.nextRangeU(SkPaint::kMiter_Join,
         SkPaint::kBevel_Join);
     paint.setStrokeJoin(join);
     return paint;
 }
 
 SkPoint makePoint() {
@@ skipping 115 matching lines @@
                     if (fPathDepth < fPathDepthLimit) {
                         ++fPathDepth;
                         SkPath src = makePath();
                         validate(src);
                         SkScalar dx = makeScalar();
                         SkScalar dy = makeScalar();
                         SkPath::AddPathMode mode = makeAddPathMode();
                         path.addPath(src, dx, dy, mode);
                         --fPathDepth;
                         validate(path);
-                    } 
+                    }
                     break;
                 case kAddPath2:
                     if (fPathDepth < fPathDepthLimit) {
                         ++fPathDepth;
                         SkPath src = makePath();
                         validate(src);
                         SkPath::AddPathMode mode = makeAddPathMode();
                         path.addPath(src, mode);
                         --fPathDepth;
                         validate(path);
@@ skipping 152 matching lines @@
 SkPaint fPaint;
 SkPath fPath;
 SkScalar fFloatMin;
 SkScalar fFloatMax;
 uint32_t fPathContourCount;
 int fPathDepth;
 int fPathDepthLimit;
 uint32_t fPathSegmentLimit;
 int fAddCount;
 bool fPrintName;
+bool fStrokeOnly;
 bool fValidate;
 const char* fTab;
 };
 
-//////////////////////////////////////////////////////////////////////////////
 static bool contains_only_moveTo(const SkPath& path) {
     int verbCount = path.countVerbs();
     if (verbCount == 0) {
         return true;
     }
     SkTDArray<uint8_t> verbs;
     verbs.setCount(verbCount);
     SkDEBUGCODE(int getVerbResult = ) path.getVerbs(verbs.begin(), verbCount);
     SkASSERT(getVerbResult == verbCount);
     for (int index = 0; index < verbCount; ++index) {
         if (verbs[index] != SkPath::kMove_Verb) {
             return false;
         }
     }
     return true;
 }
 
+#include "SkGraphics.h"
+#include "SkSurface.h"
+#include "SkTaskGroup.h"
+#include "SkTDArray.h"
+
+struct ThreadState {
+    int fSeed;
+    const SkBitmap* fBitmap;
+};
+
+static void test_fuzz(ThreadState* data) {
+    FuzzPath fuzzPath;
+    fuzzPath.setStrokeOnly();
+    fuzzPath.setSeed(data->fSeed);
+    fuzzPath.randomize();
+    const SkPath& path = fuzzPath.getPath();
+    const SkPaint& paint = fuzzPath.getPaint();
+    const SkImageInfo& info = data->fBitmap->info();
+    SkCanvas* canvas(SkCanvas::NewRasterDirect(info, data->fBitmap->getPixels(),
+            data->fBitmap->rowBytes()));
+    int w = info.width() / 4;
+    int h = info.height() / 4;
+    int x = data->fSeed / 4 % 4;
+    int y = data->fSeed % 4;
+    SkRect clipBounds = SkRect::MakeXYWH(SkIntToScalar(x) * w, SkIntToScalar(y) * h, 
+        SkIntToScalar(w), SkIntToScalar(h));
+    canvas->save();
+        canvas->clipRect(clipBounds);
+        canvas->translate(SkIntToScalar(x) * w, SkIntToScalar(y) * h);
+        canvas->drawPath(path, paint);
+    canvas->restore();
+}
+
+static void path_fuzz_stroker(SkBitmap* bitmap, int seed) {
+    ThreadState states[100];
+    for (size_t i = 0; i < SK_ARRAY_COUNT(states); i++) {
+        states[i].fSeed   = seed + (int) i;
+        states[i].fBitmap = bitmap;
+    }
+    SkTaskGroup tg;
+    tg.batch(test_fuzz, states, SK_ARRAY_COUNT(states));
+}
+
 class PathFuzzView : public SampleView {
 public:
-    PathFuzzView() {
-        fDots = 0;
+    PathFuzzView()
+        : fOneDraw(false)
+    {
     }
 protected:
     // overrides from SkEventSink
     virtual bool onQuery(SkEvent* evt) {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "PathFuzzer");
             return true;
         }
         return this->INHERITED::onQuery(evt);
     }
 
+    void onOnceBeforeDraw() SK_OVERRIDE {
+        fIndex = 0;
+        SkImageInfo info(SkImageInfo::MakeN32Premul(SkScalarRoundToInt(width()), 
+                SkScalarRoundToInt(height())));
+        offscreen.allocPixels(info);
+        path_fuzz_stroker(&offscreen, fIndex);
+    }
+
     virtual void onDrawContent(SkCanvas* canvas) {
-        fuzzPath.randomize();
-        const SkPath& path = fuzzPath.getPath();
-        const SkPaint& paint = fuzzPath.getPaint();
-        const SkPath& clip = fuzzPath.getClip();
-        const SkMatrix& matrix = fuzzPath.getMatrix();
-        if (!contains_only_moveTo(clip)) {
-            canvas->clipPath(clip);
+        if (fOneDraw) {
+            fuzzPath.randomize();
+            const SkPath& path = fuzzPath.getPath();
+            const SkPaint& paint = fuzzPath.getPaint();
+            const SkPath& clip = fuzzPath.getClip();
+            const SkMatrix& matrix = fuzzPath.getMatrix();
+            if (!contains_only_moveTo(clip)) {
+                canvas->clipPath(clip);
+            }
+            canvas->setMatrix(matrix);
+            canvas->drawPath(path, paint);
+        } else {
+            path_fuzz_stroker(&offscreen, fIndex += 100);
+            canvas->drawBitmap(offscreen, 0, 0);
         }
-        canvas->setMatrix(matrix);
-        canvas->drawPath(path, paint);
         this->inval(NULL);
-        if (++fDots == 8000) {
-            SkDebugf("\n");
-            fDots = 0;
-        }
-        if ((fDots % 100) == 99) {
-            SkDebugf(".");
-        }
     }
 
 private:
+    int fIndex;
+    SkBitmap offscreen;
     FuzzPath fuzzPath;
-    int fDots;
+    bool fOneDraw;
     typedef SkView INHERITED;
 };
 
-//////////////////////////////////////////////////////////////////////////////
-
 static SkView* MyFactory() { return new PathFuzzView; }
 static SkViewRegister reg(MyFactory);
+
+