Check for identity before doing matrix math in more places in gfx::Transform

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 188 matching lines @@
   if (matrix_.isIdentity())
     matrix_.setDouble(3, 2, -1.0 / depth);
   else {
     SkMatrix44 m;
     m.setDouble(3, 2, -1.0 / depth);
     matrix_.preConcat(m);
   }
 }
 
 void Transform::PreconcatTransform(const Transform& transform) {
-  if (!transform.matrix_.isIdentity()) {
+  if (matrix_.isIdentity()) {
+    matrix_ = transform.matrix_;
+  } else if (!transform.matrix_.isIdentity()) {
     matrix_.preConcat(transform.matrix_);
   }
 }
 
 void Transform::ConcatTransform(const Transform& transform) {
-  if (!transform.matrix_.isIdentity()) {
+  if (matrix_.isIdentity()) {
+    matrix_ = transform.matrix_;
+  } else if (!transform.matrix_.isIdentity()) {
     matrix_.postConcat(transform.matrix_);
   }
 }
 
 bool Transform::IsIdentity() const {
   return matrix_.isIdentity();
 }
 
 bool Transform::IsIdentityOrTranslation() const {
+  if (matrix_.isIdentity())
+    return true;
+
   bool has_no_perspective = !matrix_.getDouble(3, 0) &&
                             !matrix_.getDouble(3, 1) &&
                             !matrix_.getDouble(3, 2) &&
                             (matrix_.getDouble(3, 3) == 1);
 
   bool has_no_rotation_or_skew = !matrix_.getDouble(0, 1) &&
                                  !matrix_.getDouble(0, 2) &&
                                  !matrix_.getDouble(1, 0) &&
                                  !matrix_.getDouble(1, 2) &&
                                  !matrix_.getDouble(2, 0) &&
                                  !matrix_.getDouble(2, 1);
 
   bool has_no_scale = matrix_.getDouble(0, 0) == 1 &&
                       matrix_.getDouble(1, 1) == 1 &&
                       matrix_.getDouble(2, 2) == 1;
 
   return has_no_perspective && has_no_rotation_or_skew && has_no_scale;
 }
 
 bool Transform::IsScaleOrTranslation() const {
+  if (matrix_.isIdentity())
+    return true;
+
   bool has_no_perspective = !matrix_.getDouble(3, 0) &&
                             !matrix_.getDouble(3, 1) &&
                             !matrix_.getDouble(3, 2) &&
                             (matrix_.getDouble(3, 3) == 1);
 
   bool has_no_rotation_or_skew = !matrix_.getDouble(0, 1) &&
                                  !matrix_.getDouble(0, 2) &&
                                  !matrix_.getDouble(1, 0) &&
                                  !matrix_.getDouble(1, 2) &&
                                  !matrix_.getDouble(2, 0) &&
                                  !matrix_.getDouble(2, 1);
 
   return has_no_perspective && has_no_rotation_or_skew;
 }
 
 bool Transform::HasPerspective() const {
-  return matrix_.getDouble(3, 0) ||
-         matrix_.getDouble(3, 1) ||
-         matrix_.getDouble(3, 2) ||
-         (matrix_.getDouble(3, 3) != 1);
+  return !matrix_.isIdentity() &&
+         (matrix_.getDouble(3, 0) ||
+          matrix_.getDouble(3, 1) ||
+          matrix_.getDouble(3, 2) ||
+          (matrix_.getDouble(3, 3) != 1));
 }
 
 bool Transform::IsInvertible() const {
   return std::abs(matrix_.determinant()) > kTooSmallForDeterminant;
 }
 
 bool Transform::IsBackFaceVisible() const {
   // Compute whether a layer with a forward-facing normal of (0, 0, 1, 0)
   // would have its back face visible after applying the transform.
-  //
+  if (matrix_.isIdentity())
+    return false;
+
   // This is done by transforming the normal and seeing if the resulting z
   // value is positive or negative. However, note that transforming a normal
   // actually requires using the inverse-transpose of the original transform.
   //
   // We can avoid inverting and transposing the matrix since we know we want
   // to transform only the specific normal vector (0, 0, 1, 0). In this case,
   // we only need the 3rd row, 3rd column of the inverse-transpose. We can
   // calculate only the 3rd row 3rd column element of the inverse, skipping
   // everything else.
   //
@@ skipping 82 matching lines @@
   // TODO(sad): Try to avoid trying to invert the matrix.
   SkMatrix44 inverse;
   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;
   if (!matrix_.invert(&inverse))
     return false;
+
   const SkMatrix& matrix = inverse;
   SkRect src = RectFToSkRect(*rect);
   matrix.mapRect(&src);
   *rect = SkRectToRectF(src);
   return true;
 }
 
 bool Transform::Blend(const Transform& from, double progress) {
   if (progress <= 0.0) {
     *this = from;
@@ skipping 10 matching lines @@
     return false;
 
   if (!BlendDecomposedTransforms(&to_decomp, to_decomp, from_decomp, progress))
     return false;
 
   matrix_ = ComposeTransform(to_decomp).matrix();
   return true;
 }
 
 Transform Transform::operator*(const Transform& other) const {
+  if (matrix_.isIdentity())
+    return other;
+  if (other.matrix_.isIdentity())
+    return *this;
   Transform to_return;
   to_return.matrix_.setConcat(matrix_, other.matrix_);
   return to_return;
 }
 
 Transform& Transform::operator*=(const Transform& other) {
-  matrix_.preConcat(other.matrix_);
+  PreconcatTransform(other);
   return *this;
 }
 
 void Transform::TransformPointInternal(const SkMatrix44& xform,
                                        Point3F& point) const {
+  if (xform.isIdentity())
+    return;
+
   SkMScalar p[4] = {
     SkDoubleToMScalar(point.x()),
     SkDoubleToMScalar(point.y()),
     SkDoubleToMScalar(point.z()),
     SkDoubleToMScalar(1)
   };
 
   xform.mapMScalars(p);
 
   if (p[3] != 1 && abs(p[3]) > 0) {
     point.SetPoint(p[0] / p[3], p[1] / p[3], p[2]/ p[3]);
   } else {
     point.SetPoint(p[0], p[1], p[2]);
   }
 }
 
 void Transform::TransformPointInternal(const SkMatrix44& xform,
                                        Point& point) const {
+  if (xform.isIdentity())
+    return;
+
   SkMScalar p[4] = {
     SkDoubleToMScalar(point.x()),
     SkDoubleToMScalar(point.y()),
     SkDoubleToMScalar(0),
     SkDoubleToMScalar(1)
   };
 
   xform.mapMScalars(p);
 
   point.SetPoint(ToRoundedInt(p[0]), ToRoundedInt(p[1]));
 }
 
 }  // namespace gfx