Make SkMatrix44::invert() check for finite 1/det instead of magic value

src/utils/SkMatrix44.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix44.h"
 
 static inline bool eq4(const SkMScalar* SK_RESTRICT a,
@@ skipping 511 matching lines @@
     double b06 = a20 * a31 - a21 * a30;
     double b07 = a20 * a32 - a22 * a30;
     double b08 = a20 * a33 - a23 * a30;
     double b09 = a21 * a32 - a22 * a31;
     double b10 = a21 * a33 - a23 * a31;
     double b11 = a22 * a33 - a23 * a32;
 
     // Calculate the determinant
     double det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
 
-    if (dabs(det) < TOO_SMALL_FOR_DETERMINANT) {
+    double invdet = 1.0 / det;
+    // If det is zero, we want to return false. However, we also want to return false
+    // if 1/det overflows to infinity (i.e. det is denormalized). Both of these are
+    // handled by checking that 1/det is finite.
+    if (!sk_float_isfinite(invdet)) {
         return false;
     }
     if (NULL == inverse) {
         return true;
     }
-    double invdet = 1.0 / det;
 
     b00 *= invdet;
     b01 *= invdet;
     b02 *= invdet;
     b03 *= invdet;
     b04 *= invdet;
     b05 *= invdet;
     b06 *= invdet;
     b07 *= invdet;
     b08 *= invdet;
@@ skipping 12 matching lines @@
     inverse->fMat[2][0] = SkDoubleToMScalar(a10 * b10 - a11 * b08 + a13 * b06);
     inverse->fMat[2][1] = SkDoubleToMScalar(a01 * b08 - a00 * b10 - a03 * b06);
     inverse->fMat[2][2] = SkDoubleToMScalar(a30 * b04 - a31 * b02 + a33 * b00);
     inverse->fMat[2][3] = SkDoubleToMScalar(a21 * b02 - a20 * b04 - a23 * b00);
     inverse->fMat[3][0] = SkDoubleToMScalar(a11 * b07 - a10 * b09 - a12 * b06);
     inverse->fMat[3][1] = SkDoubleToMScalar(a00 * b09 - a01 * b07 + a02 * b06);
     inverse->fMat[3][2] = SkDoubleToMScalar(a31 * b01 - a30 * b03 - a32 * b00);
     inverse->fMat[3][3] = SkDoubleToMScalar(a20 * b03 - a21 * b01 + a22 * b00);
     inverse->dirtyTypeMask();
 
-    inverse->dirtyTypeMask();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix44::transpose() {
     SkTSwap(fMat[0][1], fMat[1][0]);
     SkTSwap(fMat[0][2], fMat[2][0]);
     SkTSwap(fMat[0][3], fMat[3][0]);
     SkTSwap(fMat[1][2], fMat[2][1]);
@@ skipping 263 matching lines @@
     dst[SkMatrix::kMScaleX]  = SkMScalarToScalar(fMat[0][0]);
     dst[SkMatrix::kMSkewX]  = SkMScalarToScalar(fMat[1][0]);
     dst[SkMatrix::kMTransX] = SkMScalarToScalar(fMat[3][0]);
 
     dst[SkMatrix::kMSkewY]  = SkMScalarToScalar(fMat[0][1]);
     dst[SkMatrix::kMScaleY] = SkMScalarToScalar(fMat[1][1]);
     dst[SkMatrix::kMTransY] = SkMScalarToScalar(fMat[3][1]);
 
     return dst;
 }