Use explicit constructor-enums for SkMatrix44, either kUninitialized or kIdentity

ui/gfx/transform_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/transform_util.h"
 
 #include <cmath>
 
 #include "ui/gfx/point.h"
 
@@ skipping 148 matching lines @@
     // rhs is the right hand side of the equation.
     SkMScalar rhs[4] = {
       matrix.get(3, 0),
       matrix.get(3, 1),
       matrix.get(3, 2),
       matrix.get(3, 3)
     };
 
     // Solve the equation by inverting perspectiveMatrix and multiplying
     // rhs by the inverse.
-    SkMatrix44 inversePerspectiveMatrix;
+    SkMatrix44 inversePerspectiveMatrix(SkMatrix44::kUninitialized_Constructor);
     if (!perspectiveMatrix.invert(&inversePerspectiveMatrix))
       return false;
 
     SkMatrix44 transposedInversePerspectiveMatrix =
         inversePerspectiveMatrix;
 
     transposedInversePerspectiveMatrix.transpose();
     transposedInversePerspectiveMatrix.mapMScalars(rhs);
 
     for (int i = 0; i < 4; ++i)
@@ skipping 71 matching lines @@
   if (row[0][2] > row[2][0])
       decomp->quaternion[1] = -decomp->quaternion[1];
   if (row[1][0] > row[0][1])
       decomp->quaternion[2] = -decomp->quaternion[2];
 
   return true;
 }
 
 // Taken from http://www.w3.org/TR/css3-transforms/.
 Transform ComposeTransform(const DecomposedTransform& decomp) {
-  SkMatrix44 matrix;
+  SkMatrix44 matrix(SkMatrix44::kIdentity_Constructor);
   for (int i = 0; i < 4; i++)
     matrix.setDouble(3, i, decomp.perspective[i]);
 
-  SkMatrix44 tempTranslation;
-  tempTranslation.setTranslate(SkDoubleToMScalar(decomp.translate[0]),
-                               SkDoubleToMScalar(decomp.translate[1]),
-                               SkDoubleToMScalar(decomp.translate[2]));
-  matrix.preConcat(tempTranslation);
+  matrix.preTranslate(SkDoubleToMScalar(decomp.translate[0]),
+                      SkDoubleToMScalar(decomp.translate[1]),
+                      SkDoubleToMScalar(decomp.translate[2]));
 
   double x = decomp.quaternion[0];
   double y = decomp.quaternion[1];
   double z = decomp.quaternion[2];
   double w = decomp.quaternion[3];
 
-  SkMatrix44 rotation_matrix;
-  rotation_matrix.setDouble(0, 0, 1.0 - 2.0 * (y * y + z * z));
-  rotation_matrix.setDouble(0, 1, 2.0 * (x * y - z * w));
-  rotation_matrix.setDouble(0, 2, 2.0 * (x * z + y * w));
-  rotation_matrix.setDouble(1, 0, 2.0 * (x * y + z * w));
-  rotation_matrix.setDouble(1, 1, 1.0 - 2.0 * (x * x + z * z));
-  rotation_matrix.setDouble(1, 2, 2.0 * (y * z - x * w));
-  rotation_matrix.setDouble(2, 0, 2.0 * (x * z - y * w));
-  rotation_matrix.setDouble(2, 1, 2.0 * (y * z + x * w));
-  rotation_matrix.setDouble(2, 2, 1.0 - 2.0 * (x * x + y * y));
+  SkMatrix44 rotation_matrix(SkMatrix44::kUninitialized_Constructor);
+  rotation_matrix.set3x3(1.0 - 2.0 * (y * y + z * z),
+                         2.0 * (x * y + z * w),
+                         2.0 * (x * z - y * w),
+                         2.0 * (x * y - z * w),
+                         1.0 - 2.0 * (x * x + z * z),
+                         2.0 * (y * z + x * w),
+                         2.0 * (x * z + y * w),
+                         2.0 * (y * z - x * w),
+                         1.0 - 2.0 * (x * x + y * y));
 
   matrix.preConcat(rotation_matrix);
 
-  SkMatrix44 temp;
+  SkMatrix44 temp(SkMatrix44::kIdentity_Constructor);
   if (decomp.skew[2]) {
     temp.setDouble(1, 2, decomp.skew[2]);
     matrix.preConcat(temp);
   }
 
   if (decomp.skew[1]) {
     temp.setDouble(1, 2, 0);
     temp.setDouble(0, 2, decomp.skew[1]);
     matrix.preConcat(temp);
   }
 
   if (decomp.skew[0]) {
     temp.setDouble(0, 2, 0);
     temp.setDouble(0, 1, decomp.skew[0]);
     matrix.preConcat(temp);
   }
 
-  SkMatrix44 tempScale;
-  tempScale.setScale(SkDoubleToMScalar(decomp.scale[0]),
-                     SkDoubleToMScalar(decomp.scale[1]),
-                     SkDoubleToMScalar(decomp.scale[2]));
-  matrix.preConcat(tempScale);
+  matrix.preScale(SkDoubleToMScalar(decomp.scale[0]),
+                  SkDoubleToMScalar(decomp.scale[1]),
+                  SkDoubleToMScalar(decomp.scale[2]));
 
   Transform to_return;
   to_return.matrix() = matrix;
   return to_return;
 }
 
 }  // namespace ui