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

bench/HairlinePathBench.cpp

 /*
  * Copyright 2013 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 "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
@@ skipping 67 matching lines @@
 };
 
 class LinePathBench : public HairlinePathBench {
 public:
     LinePathBench(void* param, Flags flags) : INHERITED(param, flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("line");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
-        SkMWCRandom rand;
+        SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
             int base1 = 2 * rand.nextULessThan(hSize);
             int base2 = 2 * rand.nextULessThan(hSize);
@@ skipping 11 matching lines @@
 };
 
 class QuadPathBench : public HairlinePathBench {
 public:
     QuadPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("quad");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
-        SkMWCRandom rand;
+        SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
             int base1 = 2 * rand.nextULessThan(hSize);
             int base2 = 2 * rand.nextULessThan(hSize);
@@ skipping 11 matching lines @@
 };
 
 class ConicPathBench : public HairlinePathBench {
 public:
     ConicPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("conic");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
-        SkMWCRandom rand;
-        SkMWCRandom randWeight;
+        SkRandom rand;
+        SkRandom randWeight;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
             int base1 = 2 * rand.nextULessThan(hSize);
             int base2 = 2 * rand.nextULessThan(hSize);
@@ skipping 13 matching lines @@
 };
 
 class CubicPathBench : public HairlinePathBench {
 public:
     CubicPathBench(void* param, Flags flags) : INHERITED(param, flags) {}
 
     virtual void appendName(SkString* name) SK_OVERRIDE {
         name->append("cubic");
     }
     virtual void makePath(SkPath* path) SK_OVERRIDE {
-        SkMWCRandom rand;
+        SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
             int base1 = 2 * rand.nextULessThan(hSize);
             int base2 = 2 * rand.nextULessThan(hSize);
@@ skipping 31 matching lines @@
 // Don't have default path renderer for conics yet on GPU, so must use AA
 // DEF_BENCH( return new ConicPathBench(p, FLAGS00); )
 // DEF_BENCH( return new ConicPathBench(p, FLAGS01); )
 DEF_BENCH( return new ConicPathBench(p, FLAGS10); )
 DEF_BENCH( return new ConicPathBench(p, FLAGS11); )
 
 DEF_BENCH( return new CubicPathBench(p, FLAGS00); )
 DEF_BENCH( return new CubicPathBench(p, FLAGS01); )
 DEF_BENCH( return new CubicPathBench(p, FLAGS10); )
 DEF_BENCH( return new CubicPathBench(p, FLAGS11); )