Move GrNonAAFillRectPerspectiveBatch to its own file

src/gpu/GrTestUtils.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 "GrTestUtils.h"
 #include "GrStyle.h"
 #include "SkDashPathPriv.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkRRect.h"
 
 #ifdef GR_TEST_UTILS
 
-static const SkMatrix& test_matrix(SkRandom* random, bool includePerspective) {
+static const SkMatrix& test_matrix(SkRandom* random,
+                                   bool includeNonPerspective,
+                                   bool includePerspective) {
     static SkMatrix gMatrices[5];
     static const int kPerspectiveCount = 1;
     static bool gOnce;
     if (!gOnce) {
         gOnce = true;
         gMatrices[0].reset();
         gMatrices[1].setTranslate(SkIntToScalar(-100), SkIntToScalar(100));
         gMatrices[2].setRotate(SkIntToScalar(17));
         gMatrices[3].setRotate(SkIntToScalar(185));
         gMatrices[3].postTranslate(SkIntToScalar(66), SkIntToScalar(-33));
         gMatrices[3].postScale(SkIntToScalar(2), SK_ScalarHalf);
 
         // Perspective matrices
         gMatrices[4].setRotate(SkIntToScalar(215));
         gMatrices[4].set(SkMatrix::kMPersp0, 0.00013f);
         gMatrices[4].set(SkMatrix::kMPersp1, -0.000039f);
     }
 
     uint32_t count = static_cast<uint32_t>(SK_ARRAY_COUNT(gMatrices));
-    if (includePerspective) {
+    if (includeNonPerspective && includePerspective) {
         return gMatrices[random->nextULessThan(count)];
+    } else if (!includeNonPerspective) {
+        return gMatrices[count - 1 - random->nextULessThan(kPerspectiveCount)];
     } else {
+        SkASSERT(includeNonPerspective && !includePerspective);
         return gMatrices[random->nextULessThan(count - kPerspectiveCount)];
     }
 }
 
 namespace GrTest {
-const SkMatrix& TestMatrix(SkRandom* random) { return test_matrix(random, true); }
+const SkMatrix& TestMatrix(SkRandom* random) { return test_matrix(random, true, true); }
 
 const SkMatrix& TestMatrixPreservesRightAngles(SkRandom* random) {
     static SkMatrix gMatrices[5];
     static bool gOnce;
     if (!gOnce) {
         gOnce = true;
         // identity
         gMatrices[0].reset();
         // translation
         gMatrices[1].setTranslate(SkIntToScalar(-100), SkIntToScalar(100));
@@ skipping 33 matching lines @@
         // 90 degress rotation
         gMatrices[5].setRotate(90);
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(gMatrices); i++) {
             SkASSERT(gMatrices[i].rectStaysRect());
         }
     }
     return gMatrices[random->nextULessThan(static_cast<uint32_t>(SK_ARRAY_COUNT(gMatrices)))];
 }
 
-const SkMatrix& TestMatrixInvertible(SkRandom* random) { return test_matrix(random, false); }
+const SkMatrix& TestMatrixInvertible(SkRandom* random) { return test_matrix(random, true, false); }
+const SkMatrix& TestMatrixPerspective(SkRandom* random) { return test_matrix(random, false, true); }
 
 const SkRect& TestRect(SkRandom* random) {
     static SkRect gRects[7];
     static bool gOnce;
     if (!gOnce) {
         gOnce = true;
         gRects[0] = SkRect::MakeWH(1.f, 1.f);
         gRects[1] = SkRect::MakeWH(1.0f, 256.0f);
         gRects[2] = SkRect::MakeWH(256.0f, 1.0f);
         gRects[3] = SkRect::MakeLargest();
@@ skipping 170 matching lines @@
         info->fCount = fCount;
         info->fPhase = fPhase;
     }
     return kDash_DashType;
 }
 
 
 }  // namespace GrTest
 
 #endif