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 189 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()) {
+    *this = transform;

[danakj, 2012/11/30 01:29:26]

matrix_ = transform.matrix_; like below?

+  } 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);
 }
 
 bool Transform::IsInvertible() const {
   return std::abs(matrix_.determinant()) > kTooSmallForDeterminant;
 }
 
 bool Transform::IsBackFaceVisible() const {
+  if (matrix_.isIdentity())
+    return false;
+
   // Compute whether a layer with a forward-facing normal of (0, 0, 1) would
   // have its back face visible after applying the transform.
   //
   // 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.
 
   // TODO (shawnsingh) make this perform more efficiently - we do not
   // actually need to instantiate/invert/transpose any matrices, exploiting the
   // fact that we only need to transform (0, 0, 1, 0).
@@ skipping 78 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 {
   SkMScalar p[4] = {
     SkDoubleToMScalar(point.x()),
     SkDoubleToMScalar(point.y()),
     SkDoubleToMScalar(point.z()),
     SkDoubleToMScalar(1)
@@ skipping 16 matching lines @@
     SkDoubleToMScalar(0),
     SkDoubleToMScalar(1)
   };
 
   xform.mapMScalars(p);
 
   point.SetPoint(ToRoundedInt(p[0]), ToRoundedInt(p[1]));
 }
 
 }  // namespace gfx