Provide approximate type functions for SkMatrix44.

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 14 matching lines @@
 namespace {
 
 // Taken from SkMatrix44.
 const SkMScalar kEpsilon = 1e-8f;
 
 SkMScalar TanDegrees(double degrees) {
   double radians = degrees * M_PI / 180;
   return SkDoubleToMScalar(std::tan(radians));
 }
 
+inline bool ApproximatelyZero(SkMScalar x, SkMScalar tolerance) {
+  return std::abs(x) <= tolerance;
+}
+
+inline bool ApproximatelyOne(SkMScalar x, SkMScalar tolerance) {
+  return std::abs(x - SkDoubleToMScalar(1.0)) <= tolerance;
+}
+
 }  // namespace
 
 Transform::Transform(SkMScalar col1row1,
                      SkMScalar col2row1,
                      SkMScalar col3row1,
                      SkMScalar col4row1,
                      SkMScalar col1row2,
                      SkMScalar col2row2,
                      SkMScalar col3row2,
                      SkMScalar col4row2,
@@ skipping 158 matching lines @@
 }
 
 void Transform::PreconcatTransform(const Transform& transform) {
   matrix_.preConcat(transform.matrix_);
 }
 
 void Transform::ConcatTransform(const Transform& transform) {
   matrix_.postConcat(transform.matrix_);
 }
 
+bool Transform::IsApproximatelyIdentityOrTranslation(
+    SkMScalar tolerance) const {
+  DCHECK_GE(tolerance, 0);
+  return
+      ApproximatelyOne(matrix_.get(0, 0), tolerance) &&
+      ApproximatelyZero(matrix_.get(1, 0), tolerance) &&
+      ApproximatelyZero(matrix_.get(2, 0), tolerance) &&
+      matrix_.get(3, 0) == 0 &&
+      ApproximatelyZero(matrix_.get(0, 1), tolerance) &&
+      ApproximatelyOne(matrix_.get(1, 1), tolerance) &&
+      ApproximatelyZero(matrix_.get(2, 1), tolerance) &&
+      matrix_.get(3, 1) == 0 &&
+      ApproximatelyZero(matrix_.get(0, 2), tolerance) &&
+      ApproximatelyZero(matrix_.get(1, 2), tolerance) &&
+      ApproximatelyOne(matrix_.get(2, 2), tolerance) &&
+      matrix_.get(3, 2) == 0 &&
+      matrix_.get(3, 3) == 1;
+}
+
 bool Transform::IsIdentityOrIntegerTranslation() const {
   if (!IsIdentityOrTranslation())
     return false;
 
   bool no_fractional_translation =
       static_cast<int>(matrix_.get(0, 3)) == matrix_.get(0, 3) &&
       static_cast<int>(matrix_.get(1, 3)) == matrix_.get(1, 3) &&
       static_cast<int>(matrix_.get(2, 3)) == matrix_.get(2, 3);
 
   return no_fractional_translation;
@@ skipping 296 matching lines @@
       matrix_.get(2, 1),
       matrix_.get(2, 2),
       matrix_.get(2, 3),
       matrix_.get(3, 0),
       matrix_.get(3, 1),
       matrix_.get(3, 2),
       matrix_.get(3, 3));
 }
 
 }  // namespace gfx