add SK_ATTR_DEPRECATED -- will need to disable for chrome, since it triggers a warning

tests/Matrix44Test.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 "Test.h"
 #include "SkMatrix44.h"
 
@@ skipping 55 matching lines @@
             if (!nearly_equal_mscalar(a.get(i, j), b.get(i, j))) {
                 SkDebugf("not equal %g %g\n", a.get(i, j), b.get(i, j));
                 return false;
             }
         }
     }
     return true;
 }
 
 static bool is_identity(const SkMatrix44& m) {
-    SkMatrix44 identity;
-    identity.reset();
+    SkMatrix44 identity(SkMatrix44::kIdentity_Constructor);
     return nearly_equal(m, identity);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 static bool bits_isonly(int value, int mask) {
     return 0 == (value & ~mask);
 }
 
 static void test_constructor(skiatest::Reporter* reporter) {
     // Allocate a matrix on the heap
-    SkMatrix44* placeholderMatrix = new SkMatrix44();
+    SkMatrix44* placeholderMatrix = new SkMatrix44(SkMatrix44::kUninitialized_Constructor);
     SkAutoTDelete<SkMatrix44> deleteMe(placeholderMatrix);
 
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
             placeholderMatrix->setDouble(row, col, row * col);
         }
     }
 
     // Use placement-new syntax to trigger the constructor on top of the heap
     // address we already initialized. This allows us to check that the
     // constructor did avoid initializing the matrix contents.
     SkMatrix44* testMatrix = new(placeholderMatrix) SkMatrix44(SkMatrix44::kUninitialized_Constructor);
     REPORTER_ASSERT(reporter, testMatrix == placeholderMatrix);
     REPORTER_ASSERT(reporter, !testMatrix->isIdentity());
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
             REPORTER_ASSERT(reporter, nearly_equal_double(row * col, testMatrix->getDouble(row, col)));
         }
     }
 
     // Verify that kIdentity_Constructor really does initialize to an identity matrix.
     testMatrix = 0;
     testMatrix = new(placeholderMatrix) SkMatrix44(SkMatrix44::kIdentity_Constructor);
     REPORTER_ASSERT(reporter, testMatrix == placeholderMatrix);
     REPORTER_ASSERT(reporter, testMatrix->isIdentity());
     REPORTER_ASSERT(reporter, *testMatrix == SkMatrix44::I());
 }
 
 static void test_translate(skiatest::Reporter* reporter) {
-    SkMatrix44 mat, inverse;
+    SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
 
     mat.setTranslate(0, 0, 0);
     REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kIdentity_Mask));
     mat.setTranslate(1, 2, 3);
     REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kTranslate_Mask));
     REPORTER_ASSERT(reporter, mat.invert(&inverse));
     REPORTER_ASSERT(reporter, bits_isonly(inverse.getType(), SkMatrix44::kTranslate_Mask));
 
-    SkMatrix44 a, b, c;
+    SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 c(SkMatrix44::kUninitialized_Constructor);
     a.set3x3(1, 2, 3, 4, 5, 6, 7, 8, 9);
     b.setTranslate(10, 11, 12);
 
     c.setConcat(a, b);
     mat = a;
     mat.preTranslate(10, 11, 12);
     REPORTER_ASSERT(reporter, mat == c);
 
     c.setConcat(b, a);
     mat = a;
     mat.postTranslate(10, 11, 12);
     REPORTER_ASSERT(reporter, mat == c);
 }
 
 static void test_scale(skiatest::Reporter* reporter) {
-    SkMatrix44 mat, inverse;
+    SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
 
     mat.setScale(1, 1, 1);
     REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kIdentity_Mask));
     mat.setScale(1, 2, 3);
     REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kScale_Mask));
     REPORTER_ASSERT(reporter, mat.invert(&inverse));
     REPORTER_ASSERT(reporter, bits_isonly(inverse.getType(), SkMatrix44::kScale_Mask));
 
-    SkMatrix44 a, b, c;
+    SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 c(SkMatrix44::kUninitialized_Constructor);
     a.set3x3(1, 2, 3, 4, 5, 6, 7, 8, 9);
     b.setScale(10, 11, 12);
 
     c.setConcat(a, b);
     mat = a;
     mat.preScale(10, 11, 12);
     REPORTER_ASSERT(reporter, mat == c);
 
     c.setConcat(b, a);
     mat = a;
@@ skipping 37 matching lines @@
 
     mat.map2(src2, 1, dstA);
     mat.mapMScalars(src4, dstB);
 
     for (int i = 0; i < 4; ++i) {
         REPORTER_ASSERT(reporter, dstA[i] == dstB[i]);
     }
 }
 
 static void test_map2(skiatest::Reporter* reporter) {
-    SkMatrix44 mat;
+    SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gMakeProcs); ++i) {
         gMakeProcs[i](&mat);
         test_map2(reporter, mat);
     }
 }
 
 static void test_gettype(skiatest::Reporter* reporter) {
-    SkMatrix44 matrix;
+    SkMatrix44 matrix(SkMatrix44::kIdentity_Constructor);
 
     REPORTER_ASSERT(reporter, matrix.isIdentity());
     REPORTER_ASSERT(reporter, SkMatrix44::kIdentity_Mask == matrix.getType());
 
     int expectedMask;
 
     matrix.set(1, 1, 0);
     expectedMask = SkMatrix44::kScale_Mask;
     REPORTER_ASSERT(reporter, matrix.getType() == expectedMask);
 
@@ skipping 14 matching lines @@
     SkMScalar dz = 0;
     matrix.setTranslate(-dx, -dy, -dz);
     REPORTER_ASSERT(reporter, matrix.isIdentity());
     matrix.preTranslate(-dx, -dy, -dz);
     REPORTER_ASSERT(reporter, matrix.isIdentity());
     matrix.postTranslate(-dx, -dy, -dz);
     REPORTER_ASSERT(reporter, matrix.isIdentity());
 }
 
 static void test_common_angles(skiatest::Reporter* reporter) {
-    SkMatrix44 rot;
+    SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
     // Test precision of rotation in common cases
     int common_angles[] = { 0, 90, -90, 180, -180, 270, -270, 360, -360 };
     for (int i = 0; i < 9; ++i) {
         rot.setRotateDegreesAbout(0, 0, -1, SkIntToScalar(common_angles[i]));
 
         SkMatrix rot3x3 = rot;
         REPORTER_ASSERT(reporter, rot3x3.rectStaysRect());
     }
 }
 
 static void test_concat(skiatest::Reporter* reporter) {
     int i;
-    SkMatrix44 a, b, c, d;
+    SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 c(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 d(SkMatrix44::kUninitialized_Constructor);
 
     a.setTranslate(10, 10, 10);
     b.setScale(2, 2, 2);
 
     SkScalar src[8] = {
         0, 0, 0, 1,
         1, 1, 1, 1
     };
     SkScalar dst[8];
 
@@ skipping 16 matching lines @@
     REPORTER_ASSERT(reporter, d == c);
 
     c.mapScalars(src, dst); c.mapScalars(src + 4, dst + 4);
     for (i = 0; i < 3; ++i) {
         REPORTER_ASSERT(reporter, 20 == dst[i]);
         REPORTER_ASSERT(reporter, 22 == dst[i + 4]);
     }
 }
 
 static void test_determinant(skiatest::Reporter* reporter) {
-    SkMatrix44 a;
+    SkMatrix44 a(SkMatrix44::kIdentity_Constructor);
     REPORTER_ASSERT(reporter, nearly_equal_double(1, a.determinant()));
     a.set(1, 1, 2);
     REPORTER_ASSERT(reporter, nearly_equal_double(2, a.determinant()));
-    SkMatrix44 b;
+    SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
     REPORTER_ASSERT(reporter, a.invert(&b));
     REPORTER_ASSERT(reporter, nearly_equal_double(0.5, b.determinant()));
     SkMatrix44 c = b = a;
     c.set(0, 1, 4);
     b.set(1, 0, 4);
     REPORTER_ASSERT(reporter,
                     nearly_equal_double(a.determinant(),
                                         b.determinant()));
     SkMatrix44 d = a;
     d.set(0, 0, 8);
     REPORTER_ASSERT(reporter, nearly_equal_double(16, d.determinant()));
 
     SkMatrix44 e = a;
     e.postConcat(d);
     REPORTER_ASSERT(reporter, nearly_equal_double(32, e.determinant()));
     e.set(0, 0, 0);
     REPORTER_ASSERT(reporter, nearly_equal_double(0, e.determinant()));
 }
 
 static void test_invert(skiatest::Reporter* reporter) {
-    SkMatrix44 inverse;
+    SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
     double inverseData[16];
 
-    SkMatrix44 identity;
-    identity.setIdentity();
+    SkMatrix44 identity(SkMatrix44::kIdentity_Constructor);
     identity.invert(&inverse);
     inverse.asRowMajord(inverseData);
     assert16<double>(reporter, inverseData,
                      1, 0, 0, 0,
                      0, 1, 0, 0,
                      0, 0, 1, 0,
                      0, 0, 0, 1);
 
-    SkMatrix44 translation;
+    SkMatrix44 translation(SkMatrix44::kUninitialized_Constructor);
     translation.setTranslate(2, 3, 4);
     translation.invert(&inverse);
     inverse.asRowMajord(inverseData);
     assert16<double>(reporter, inverseData,
                      1, 0, 0, -2,
                      0, 1, 0, -3,
                      0, 0, 1, -4,
                      0, 0, 0, 1);
 
-    SkMatrix44 scale;
+    SkMatrix44 scale(SkMatrix44::kUninitialized_Constructor);
     scale.setScale(2, 4, 8);
     scale.invert(&inverse);
     inverse.asRowMajord(inverseData);
     assert16<double>(reporter, inverseData,
                      0.5, 0,    0,     0,
                      0,   0.25, 0,     0,
                      0,   0,    0.125, 0,
                      0,   0,    0,     1);
 
-    SkMatrix44 scaleTranslation;
+    SkMatrix44 scaleTranslation(SkMatrix44::kUninitialized_Constructor);
     scaleTranslation.setScale(10, 100, 1000);
     scaleTranslation.preTranslate(2, 3, 4);
     scaleTranslation.invert(&inverse);
     inverse.asRowMajord(inverseData);
     assert16<double>(reporter, inverseData,
                      0.1,  0,    0,   -2,
                      0,   0.01,  0,   -3,
                      0,    0,  0.001, -4,
                      0,    0,    0,   1);
 
-    SkMatrix44 rotation;
+    SkMatrix44 rotation(SkMatrix44::kUninitialized_Constructor);
     rotation.setRotateDegreesAbout(0, 0, 1, 90);
     rotation.invert(&inverse);
-    SkMatrix44 expected;
+    SkMatrix44 expected(SkMatrix44::kUninitialized_Constructor);
     double expectedInverseRotation[16] =
             {0,  1, 0, 0,
              -1, 0, 0, 0,
              0,  0, 1, 0,
              0,  0, 0, 1};
     expected.setRowMajord(expectedInverseRotation);
     REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
 
-    SkMatrix44 affine;
+    SkMatrix44 affine(SkMatrix44::kUninitialized_Constructor);
     affine.setRotateDegreesAbout(0, 0, 1, 90);
     affine.preScale(10, 20, 100);
     affine.preTranslate(2, 3, 4);
     affine.invert(&inverse);
     double expectedInverseAffine[16] =
             {0,    0.1,  0,   -2,
              -0.05, 0,   0,   -3,
              0,     0,  0.01, -4,
              0,     0,   0,   1};
     expected.setRowMajord(expectedInverseAffine);
     REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
 
-    SkMatrix44 perspective;
-    perspective.setIdentity();
+    SkMatrix44 perspective(SkMatrix44::kIdentity_Constructor);
     perspective.setDouble(3, 2, 1.0);
     perspective.invert(&inverse);
     double expectedInversePerspective[16] =
             {1, 0,  0, 0,
              0, 1,  0, 0,
              0, 0,  1, 0,
              0, 0, -1, 1};
     expected.setRowMajord(expectedInversePerspective);
     REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
 
-    SkMatrix44 affineAndPerspective;
-    affineAndPerspective.setIdentity();
+    SkMatrix44 affineAndPerspective(SkMatrix44::kIdentity_Constructor);
     affineAndPerspective.setDouble(3, 2, 1.0);
     affineAndPerspective.preScale(10, 20, 100);
     affineAndPerspective.preTranslate(2, 3, 4);
     affineAndPerspective.invert(&inverse);
     double expectedInverseAffineAndPerspective[16] =
             {0.1, 0,    2,   -2,
              0,  0.05,  3,   -3,
              0,   0,   4.01, -4,
              0,   0,   -1,    1};
     expected.setRowMajord(expectedInverseAffineAndPerspective);
     REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
 }
 
 static void test_transpose(skiatest::Reporter* reporter) {
-    SkMatrix44 a;
-    SkMatrix44 b;
+    SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
 
     int i = 0;
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
             a.setDouble(row, col, i);
             b.setDouble(col, row, i++);
         }
     }
 
     a.transpose();
     REPORTER_ASSERT(reporter, nearly_equal(a, b));
 }
 
 static void test_get_set_double(skiatest::Reporter* reporter) {
-    SkMatrix44 a;
+    SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
             a.setDouble(row, col, 3.141592653589793);
             REPORTER_ASSERT(reporter,
                             nearly_equal_double(3.141592653589793,
                                                 a.getDouble(row, col)));
             a.setDouble(row, col, 0);
             REPORTER_ASSERT(reporter,
                             nearly_equal_double(0, a.getDouble(row, col)));
         }
     }
 }
 
 static void test_set_row_col_major(skiatest::Reporter* reporter) {
-    SkMatrix44 a, b, c, d;
+    SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
+
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
             a.setDouble(row, col, row * 4 + col);
         }
     }
 
     double bufferd[16];
     float bufferf[16];
     a.asColMajord(bufferd);
     b.setColMajord(bufferd);
@@ skipping 14 matching lines @@
                                 5, 6, 7, 8,
                                 9, 10, 11, 12,
                                 13, 14, 15, 16 };
     SkScalar values3x3[9] = { 1, 2, 4,
                               5, 6, 8,
                               13, 14, 16 };
     SkMScalar values4x4flattened[16] = { 1, 2, 0, 4,
                                          5, 6, 0, 8,
                                          0, 0, 1, 0,
                                          13, 14, 0, 16 };
-    SkMatrix44 a44;
+    SkMatrix44 a44(SkMatrix44::kUninitialized_Constructor);
     a44.setRowMajor(values4x4);
 
     SkMatrix a33 = a44;
     SkMatrix expected33;
     for (int i = 0; i < 9; i++) expected33[i] = values3x3[i];
     REPORTER_ASSERT(reporter, expected33 == a33);
 
     SkMatrix44 a44flattened = a33;
-    SkMatrix44 expected44flattened;
+    SkMatrix44 expected44flattened(SkMatrix44::kUninitialized_Constructor);
     expected44flattened.setRowMajor(values4x4flattened);
     REPORTER_ASSERT(reporter, nearly_equal(a44flattened, expected44flattened));
 
     // Test that a point with a Z value of 0 is transformed the same way.
     SkScalar vec4[4] = { 2, 4, 0, 8 };
     SkScalar vec3[3] = { 2, 4, 8 };
 
     SkScalar vec4transformed[4];
     SkScalar vec3transformed[3];
     SkScalar vec4transformed2[4];
     a44.mapScalars(vec4, vec4transformed);
     a33.mapHomogeneousPoints(vec3transformed, vec3, 1);
     a44flattened.mapScalars(vec4, vec4transformed2);
     REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[0], vec3transformed[0]));
     REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[1], vec3transformed[1]));
     REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[3], vec3transformed[2]));
     REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[0], vec4transformed2[0]));
     REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[1], vec4transformed2[1]));
     REPORTER_ASSERT(reporter, !nearly_equal_scalar(vec4transformed[2], vec4transformed2[2]));
     REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[3], vec4transformed2[3]));
 }
 
 static void TestMatrix44(skiatest::Reporter* reporter) {
-    SkMatrix44 mat, inverse, iden1, iden2, rot;
+    SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 iden1(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 iden2(SkMatrix44::kUninitialized_Constructor);
+    SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
 
-    mat.reset();
     mat.setTranslate(1, 1, 1);
     mat.invert(&inverse);
     iden1.setConcat(mat, inverse);
     REPORTER_ASSERT(reporter, is_identity(iden1));
 
     mat.setScale(2, 2, 2);
     mat.invert(&inverse);
     iden1.setConcat(mat, inverse);
     REPORTER_ASSERT(reporter, is_identity(iden1));
 
@@ skipping 82 matching lines @@
     test_get_set_double(reporter);
     test_set_row_col_major(reporter);
     test_translate(reporter);
     test_scale(reporter);
     test_map2(reporter);
     test_3x3_conversion(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Matrix44", Matrix44TestClass, TestMatrix44)