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

ui/gfx/transform.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/gfx/transform.h"
 
 #include <cmath>
@@ skipping 65 matching lines @@
 
 void Transform::RotateAboutXAxis(double degrees) {
   double radians = degrees * M_PI / 180;
   double cosTheta = std::cos(radians);
   double sinTheta = std::sin(radians);
   if (matrix_.isIdentity()) {
       matrix_.set3x3(1, 0, 0,
                      0, cosTheta, sinTheta,
                      0, -sinTheta, cosTheta);
   } else {
-    SkMatrix44 rot;
+    SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
     rot.set3x3(1, 0, 0,
                0, cosTheta, sinTheta,
                0, -sinTheta, cosTheta);
     matrix_.preConcat(rot);
   }
 }
 
 void Transform::RotateAboutYAxis(double degrees) {
   double radians = degrees * M_PI / 180;
   double cosTheta = std::cos(radians);
   double sinTheta = std::sin(radians);
   if (matrix_.isIdentity()) {
       // Note carefully the placement of the -sinTheta for rotation about
       // y-axis is different than rotation about x-axis or z-axis.
       matrix_.set3x3(cosTheta, 0, -sinTheta,
                      0, 1, 0,
                      sinTheta, 0, cosTheta);
   } else {
-    SkMatrix44 rot;
+    SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
     rot.set3x3(cosTheta, 0, -sinTheta,
                0, 1, 0,
                sinTheta, 0, cosTheta);
     matrix_.preConcat(rot);
   }
 }
 
 void Transform::RotateAboutZAxis(double degrees) {
   double radians = degrees * M_PI / 180;
   double cosTheta = std::cos(radians);
   double sinTheta = std::sin(radians);
   if (matrix_.isIdentity()) {
       matrix_.set3x3(cosTheta, sinTheta, 0,
                      -sinTheta, cosTheta, 0,
                      0, 0, 1);
   } else {
-    SkMatrix44 rot;
+    SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
     rot.set3x3(cosTheta, sinTheta, 0,
                -sinTheta, cosTheta, 0,
                0, 0, 1);
     matrix_.preConcat(rot);
   }
 }
 
 void Transform::RotateAbout(const Vector3dF& axis, double degrees) {
   if (matrix_.isIdentity()) {
     matrix_.setRotateDegreesAbout(SkDoubleToMScalar(axis.x()),
                                   SkDoubleToMScalar(axis.y()),
                                   SkDoubleToMScalar(axis.z()),
                                   SkDoubleToMScalar(degrees));
   } else {
-    SkMatrix44 rot;
+    SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
     rot.setRotateDegreesAbout(SkDoubleToMScalar(axis.x()),
                               SkDoubleToMScalar(axis.y()),
                               SkDoubleToMScalar(axis.z()),
                               SkDoubleToMScalar(degrees));
     matrix_.preConcat(rot);
   }
 }
 
 void Transform::Scale(double x, double y) {
   matrix_.preScale(SkDoubleToMScalar(x), SkDoubleToMScalar(y), 1);
@@ skipping 12 matching lines @@
 void Transform::Translate3d(double x, double y, double z) {
   matrix_.preTranslate(SkDoubleToMScalar(x),
                        SkDoubleToMScalar(y),
                        SkDoubleToMScalar(z));
 }
 
 void Transform::SkewX(double angle_x) {
   if (matrix_.isIdentity())
     matrix_.setDouble(0, 1, TanDegrees(angle_x));
   else {
-    SkMatrix44 skew;
+    SkMatrix44 skew(SkMatrix44::kIdentity_Constructor);
     skew.setDouble(0, 1, TanDegrees(angle_x));
     matrix_.preConcat(skew);
   }
 }
 
 void Transform::SkewY(double angle_y) {
   if (matrix_.isIdentity())
     matrix_.setDouble(1, 0, TanDegrees(angle_y));
   else {
-    SkMatrix44 skew;
+    SkMatrix44 skew(SkMatrix44::kIdentity_Constructor);
     skew.setDouble(1, 0, TanDegrees(angle_y));
     matrix_.preConcat(skew);
   }
 }
 
 void Transform::ApplyPerspectiveDepth(double depth) {
   if (depth == 0)
     return;
   if (matrix_.isIdentity())
     matrix_.setDouble(3, 2, -1.0 / depth);
   else {
-    SkMatrix44 m;
+    SkMatrix44 m(SkMatrix44::kIdentity_Constructor);
     m.setDouble(3, 2, -1.0 / depth);
     matrix_.preConcat(m);
   }
 }
 
 void Transform::PreconcatTransform(const Transform& transform) {
   matrix_.preConcat(transform.matrix_);
 }
 
 void Transform::ConcatTransform(const Transform& transform) {
@@ skipping 111 matching lines @@
 void Transform::TransformPoint(Point& point) const {
   TransformPointInternal(matrix_, point);
 }
 
 void Transform::TransformPoint(Point3F& point) const {
   TransformPointInternal(matrix_, point);
 }
 
 bool Transform::TransformPointReverse(Point& point) const {
   // TODO(sad): Try to avoid trying to invert the matrix.
-  SkMatrix44 inverse;
+  SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
   if (!matrix_.invert(&inverse))
     return false;
 
   TransformPointInternal(inverse, point);
   return true;
 }
 
 bool Transform::TransformPointReverse(Point3F& point) const {
   // TODO(sad): Try to avoid trying to invert the matrix.
-  SkMatrix44 inverse;
+  SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
   if (!matrix_.invert(&inverse))
     return false;
 
   TransformPointInternal(inverse, point);
   return true;
 }
 
 void Transform::TransformRect(RectF* rect) const {
   if (matrix_.isIdentity())
     return;
 
   SkRect src = RectFToSkRect(*rect);
   const SkMatrix& matrix = matrix_;
   matrix.mapRect(&src);
   *rect = SkRectToRectF(src);
 }
 
 bool Transform::TransformRectReverse(RectF* rect) const {
   if (matrix_.isIdentity())
     return true;
 
-  SkMatrix44 inverse;
+  SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
   if (!matrix_.invert(&inverse))
     return false;
 
   const SkMatrix& matrix = inverse;
   SkRect src = RectFToSkRect(*rect);
   matrix.mapRect(&src);
   *rect = SkRectToRectF(src);
   return true;
 }
 
@@ skipping 75 matching lines @@
       matrix_.getDouble(2, 1),
       matrix_.getDouble(2, 2),
       matrix_.getDouble(2, 3),
       matrix_.getDouble(3, 0),
       matrix_.getDouble(3, 1),
       matrix_.getDouble(3, 2),
       matrix_.getDouble(3, 3));
 }
 
 }  // namespace gfx