Style Change: NULL->nullptr

tests/MatrixTest.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 "SkMath.h"
 #include "SkMatrix.h"
 #include "SkMatrixUtils.h"
@@ skipping 124 matching lines @@
     dst.fRight = src.fRight * 2;
     matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
     REPORTER_ASSERT(reporter, SkMatrix::kScale_Mask == matrix.getType());
     REPORTER_ASSERT(reporter, matrix.rectStaysRect());
 }
 
 static void test_flatten(skiatest::Reporter* reporter, const SkMatrix& m) {
     // add 100 in case we have a bug, I don't want to kill my stack in the test
     static const size_t kBufferSize = SkMatrix::kMaxFlattenSize + 100;
     char buffer[kBufferSize];
-    size_t size1 = m.writeToMemory(NULL);
+    size_t size1 = m.writeToMemory(nullptr);
     size_t size2 = m.writeToMemory(buffer);
     REPORTER_ASSERT(reporter, size1 == size2);
     REPORTER_ASSERT(reporter, size1 <= SkMatrix::kMaxFlattenSize);
 
     SkMatrix m2;
     size_t size3 = m2.readFromMemory(buffer, kBufferSize);
     REPORTER_ASSERT(reporter, size1 == size3);
     REPORTER_ASSERT(reporter, are_equal(reporter, m, m2));
 
     char buffer2[kBufferSize];
@@ skipping 334 matching lines @@
     const float kRotation0 = 15.5f;
     const float kRotation1 = -50.f;
     const float kScale0 = 5000.f;
     const float kScale1 = 0.001f;
 
     // identity
     mat.reset();
     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
     // make sure it doesn't crash if we pass in NULLs
-    REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, NULL, NULL, NULL));
+    REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, nullptr, nullptr, nullptr));
 
     // rotation only
     mat.setRotate(kRotation0);
     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 
     // uniform scale only
     mat.setScale(kScale0, kScale0);
     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
@@ skipping 193 matching lines @@
     SkScalar zeros[3] = {0.f, 0.f, 0.f};
     for (int i = 0; i < kMatrixCount; ++i) {
         SkScalar dst[3];
         mats[i].mapHomogeneousPoints(dst, zeros, 1);
         REPORTER_ASSERT(reporter, scalar_array_nearly_equal_relative(dst, zeros, 3));
     }
     }
 
     // doesn't crash with null dst, src, count == 0
     {
-    mats[0].mapHomogeneousPoints(NULL, NULL, 0);
+    mats[0].mapHomogeneousPoints(nullptr, nullptr, 0);
     }
 
     // uniform scale of point
     {
     mat.setScale(kScale0, kScale0);
     SkScalar dst[3];
     SkScalar src[3] = {randTriples[0], randTriples[1], 1.f};
     SkPoint pnt;
     pnt.set(src[0], src[1]);
     mat.mapHomogeneousPoints(dst, src, 1);
@@ skipping 90 matching lines @@
     test_flatten(reporter, mat);
 
     mat.setScale(SK_Scalar1/2, SkIntToScalar(2));
     REPORTER_ASSERT(reporter, mat.invert(&inverse));
     iden1.setConcat(mat, inverse);
     REPORTER_ASSERT(reporter, is_identity(iden1));
     test_flatten(reporter, mat);
 
     mat.setScale(SkIntToScalar(3), SkIntToScalar(5), SkIntToScalar(20), 0);
     mat.postRotate(SkIntToScalar(25));
-    REPORTER_ASSERT(reporter, mat.invert(NULL));
+    REPORTER_ASSERT(reporter, mat.invert(nullptr));
     REPORTER_ASSERT(reporter, mat.invert(&inverse));
     iden1.setConcat(mat, inverse);
     REPORTER_ASSERT(reporter, is_identity(iden1));
     iden2.setConcat(inverse, mat);
     REPORTER_ASSERT(reporter, is_identity(iden2));
     test_flatten(reporter, mat);
     test_flatten(reporter, iden2);
 
     mat.setScale(0, SK_Scalar1);
-    REPORTER_ASSERT(reporter, !mat.invert(NULL));
+    REPORTER_ASSERT(reporter, !mat.invert(nullptr));
     REPORTER_ASSERT(reporter, !mat.invert(&inverse));
     mat.setScale(SK_Scalar1, 0);
-    REPORTER_ASSERT(reporter, !mat.invert(NULL));
+    REPORTER_ASSERT(reporter, !mat.invert(nullptr));
     REPORTER_ASSERT(reporter, !mat.invert(&inverse));
 
     // Inverting this matrix results in a non-finite matrix
     mat.setAll(0.0f, 1.0f, 2.0f,
                0.0f, 1.0f, -3.40277175e+38f,
                1.00003040f, 1.0f, 0.0f);
-    REPORTER_ASSERT(reporter, !mat.invert(NULL));
+    REPORTER_ASSERT(reporter, !mat.invert(nullptr));
     REPORTER_ASSERT(reporter, !mat.invert(&inverse));
 
     // rectStaysRect test
     {
         static const struct {
             SkScalar    m00, m01, m10, m11;
             bool        mStaysRect;
         }
         gRectStaysRectSamples[] = {
             {          0,          0,          0,           0, false },
@@ skipping 77 matching lines @@
     a.setTranslate(10, 20);
 
     SkMatrix b;
     b.setScale(3, 5);
 
     SkMatrix expected;
     expected.setConcat(a,b);
 
     REPORTER_ASSERT(r, expected == SkMatrix::Concat(a, b));
 }