Change old PRG to be SkLCGRandom; change new one to SkRandom

bench/PathBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 165 matching lines @@
 class LongCurvedPathBench : public PathBench {
 public:
     LongCurvedPathBench(void * param, Flags flags)
         : INHERITED(param, flags) {
     }
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("long_curved");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
-        SkMWCRandom rand (12);
+        SkRandom rand (12);
         int i;
         for (i = 0; i < 100; i++) {
             path->quadTo(SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
                          SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)),
                          SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
                          SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)));
         }
         path->close();
     }
     virtual int complexity() SK_OVERRIDE { return 2; }
 private:
     typedef PathBench INHERITED;
 };
 
 class LongLinePathBench : public PathBench {
 public:
     LongLinePathBench(void * param, Flags flags)
         : INHERITED(param, flags) {
     }
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("long_line");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
-        SkMWCRandom rand;
+        SkRandom rand;
         path->moveTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         for (size_t i = 1; i < 100; i++) {
             path->lineTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         }
     }
     virtual int complexity() SK_OVERRIDE { return 2; }
 private:
     typedef PathBench INHERITED;
 };
 
@@ skipping 87 matching lines @@
         kNumVerbCnts = 1 << 5,
         kNumVerbs    = 1 << 5,
         kNumPoints   = 1 << 5,
     };
     SkAutoTArray<int>           fVerbCnts;
     SkAutoTArray<SkPath::Verb>  fVerbs;
     SkAutoTArray<SkPoint>       fPoints;
     int                         fCurrPath;
     int                         fCurrVerb;
     int                         fCurrPoint;
-    SkMWCRandom                 fRandom;
+    SkRandom                    fRandom;
     typedef SkBenchmark INHERITED;
 };
 
 class PathCreateBench : public RandomPathBench {
 public:
     PathCreateBench(void* param) : INHERITED(param) {
     }
 
 protected:
     enum { N = SkBENCHLOOP(5000) };
@@ skipping 316 matching lines @@
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
 
         paint.setColor(SK_ColorBLACK);
         paint.setAntiAlias(true);
         if (fFlags & kStroke_Flag) {
             paint.setStyle(SkPaint::kStroke_Style);
         }
 
-        SkMWCRandom rand;
+        SkRandom rand;
 
         SkRect r;
 
         for (int i = 0; i < 5000; ++i) {
             SkScalar radius = rand.nextUScalar1() * 3;
             r.fLeft = rand.nextUScalar1() * 300;
             r.fTop =  rand.nextUScalar1() * 300;
             r.fRight =  r.fLeft + 2 * radius;
             r.fBottom = r.fTop + 2 * radius;
 
@@ skipping 80 matching lines @@
         add_corner_arc(path, r, xCorner, yCorner, 270);
         add_corner_arc(path, r, xCorner, yCorner, 0);
         add_corner_arc(path, r, xCorner, yCorner, 90);
         add_corner_arc(path, r, xCorner, yCorner, 180);
         path->close();
 
         SkASSERT(path->isConvex());
     }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
-        SkMWCRandom rand;
+        SkRandom rand;
         SkRect r;
 
         for (int i = 0; i < 5000; ++i) {
             SkPaint paint;
             paint.setColor(0xff000000 | rand.nextU());
             paint.setAntiAlias(true);
 
             SkScalar size = rand.nextUScalar1() * 30;
             if (size < SK_Scalar1) {
                 continue;
@@ skipping 59 matching lines @@
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < N; ++i) {
             const SkRect& rect = fQueryRects[i % kQueryRectCnt];
             fParity = fParity != fPath.conservativelyContainsRect(rect);
         }
     }
 
     virtual void onPreDraw() SK_OVERRIDE {
         fQueryRects.setCount(kQueryRectCnt);
 
-        SkMWCRandom rand;
+        SkRandom rand;
         for (int i = 0; i < kQueryRectCnt; ++i) {
             SkSize size;
             SkPoint xy;
             size.fWidth = rand.nextRangeScalar(kQueryMin.fWidth,  kQueryMax.fWidth);
             size.fHeight = rand.nextRangeScalar(kQueryMin.fHeight, kQueryMax.fHeight);
             xy.fX = rand.nextRangeScalar(kBounds.fLeft, kBounds.fRight - size.fWidth);
             xy.fY = rand.nextRangeScalar(kBounds.fTop, kBounds.fBottom - size.fHeight);
 
             fQueryRects[i] = SkRect::MakeXYWH(xy.fX, xy.fY, size.fWidth, size.fHeight);
         }
@@ skipping 76 matching lines @@
         for (int i = 0; i < N; ++i) {
             fRQ.chop(dst);
         }
     }
 
     typedef SkBenchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void rand_conic(SkConic* conic, SkMWCRandom& rand) {
+static void rand_conic(SkConic* conic, SkRandom& rand) {
     for (int i = 0; i < 3; ++i) {
         conic->fPts[i].set(rand.nextUScalar1() * 100, rand.nextUScalar1() * 100);
     }
     if (rand.nextUScalar1() > 0.5f) {
         conic->fW = rand.nextUScalar1();
     } else {
         conic->fW = 1 + rand.nextUScalar1() * 4;
     }
 }
 
 class ConicBench : public SkBenchmark {
 public:
     ConicBench(void* param) : INHERITED(param) {
-        SkMWCRandom rand;
+        SkRandom rand;
         for (int i = 0; i < CONICS; ++i) {
             rand_conic(&fConics[i], rand);
         }
         fIsRendering = false;
     }
 
 protected:
     enum {
         N = 20000,
         CONICS = 100
@@ skipping 123 matching lines @@
 DEF_BENCH( return new ArbRoundRectBench(p, true); )
 DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kRect_Type); )
 DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kRoundRect_Type); )
 DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kOval_Type); )
 
 DEF_BENCH( return new ConicBench_Chop5(p) )
 DEF_BENCH( return new ConicBench_ChopHalf(p) )
 DEF_BENCH( return new ConicBench_ComputeError(p) )
 DEF_BENCH( return new ConicBench_asQuadTol(p) )
 DEF_BENCH( return new ConicBench_quadPow2(p) )