Revert of 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 = fStrokeOnly ? SkPaint::kStroke_Style :
-        (SkPaint::Style) fRand.nextRangeU(SkPaint::kFill_Style, SkPaint::kStrokeAndFill_Style);
+    SkPaint::Style 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.nextRangeF(0, 10);
+    SkScalar width = fRand.nextF();
     paint.setStrokeWidth(width);
-    SkScalar miter = makeScalar();
+    SkScalar miter = fRand.nextF();
     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 + i;
-        states[i].fBitmap = bitmap;
-    }
-    SkTaskGroup tg;
-    tg.batch(test_fuzz, states, SK_ARRAY_COUNT(states));
-}
-
 class PathFuzzView : public SampleView {
 public:
-    PathFuzzView()
-        : fOneDraw(false)
-    {
+    PathFuzzView() {
+        fDots = 0;
     }
 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) {
-        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);
+        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);
         this->inval(NULL);
+        if (++fDots == 8000) {
+            SkDebugf("\n");
+            fDots = 0;
+        }
+        if ((fDots % 100) == 99) {
+            SkDebugf(".");
+        }
     }
 
 private:
-    int fIndex;
-    SkBitmap offscreen;
     FuzzPath fuzzPath;
-    bool fOneDraw;
+    int fDots;
     typedef SkView INHERITED;
 };
 
+//////////////////////////////////////////////////////////////////////////////
+
 static SkView* MyFactory() { return new PathFuzzView; }
 static SkViewRegister reg(MyFactory);
-
-