remove SK_SCALAR_IS_[FLOAT,FIXED] and assume floats

tests/MatrixTest.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 "Test.h"
 #include "TestClassDef.h"
 #include "SkMath.h"
 #include "SkMatrix.h"
 #include "SkMatrixUtils.h"
 #include "SkRandom.h"
 
 static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
-    // Note that we get more compounded error for multiple operations when
-    // SK_SCALAR_IS_FIXED.
-#ifdef SK_SCALAR_IS_FLOAT
     const SkScalar tolerance = SK_Scalar1 / 200000;
-#else
-    const SkScalar tolerance = SK_Scalar1 / 1024;
-#endif
-
     return SkScalarAbs(a - b) <= tolerance;
 }
 
 static bool nearly_equal(const SkMatrix& a, const SkMatrix& b) {
     for (int i = 0; i < 9; i++) {
         if (!nearly_equal_scalar(a[i], b[i])) {
             SkDebugf("not equal %g %g\n", (float)a[i], (float)b[i]);
             return false;
         }
     }
     return true;
 }
 
 static bool are_equal(skiatest::Reporter* reporter,
                       const SkMatrix& a,
                       const SkMatrix& b) {
     bool equal = a == b;
     bool cheapEqual = a.cheapEqualTo(b);
     if (equal != cheapEqual) {
-#ifdef SK_SCALAR_IS_FLOAT
         if (equal) {
             bool foundZeroSignDiff = false;
             for (int i = 0; i < 9; ++i) {
                 float aVal = a.get(i);
                 float bVal = b.get(i);
                 int aValI = *SkTCast<int*>(&aVal);
                 int bValI = *SkTCast<int*>(&bVal);
                 if (0 == aVal && 0 == bVal && aValI != bValI) {
                     foundZeroSignDiff = true;
                 } else {
                     REPORTER_ASSERT(reporter, aVal == bVal && aValI == aValI);
                 }
             }
             REPORTER_ASSERT(reporter, foundZeroSignDiff);
         } else {
             bool foundNaN = false;
             for (int i = 0; i < 9; ++i) {
                 float aVal = a.get(i);
                 float bVal = b.get(i);
                 int aValI = *SkTCast<int*>(&aVal);
                 int bValI = *SkTCast<int*>(&bVal);
                 if (sk_float_isnan(aVal) && aValI == bValI) {
                     foundNaN = true;
                 } else {
                     REPORTER_ASSERT(reporter, aVal == bVal && aValI == bValI);
                 }
             }
             REPORTER_ASSERT(reporter, foundNaN);
         }
-#else
-        REPORTER_ASSERT(reporter, false);
-#endif
     }
     return equal;
 }
 
 static bool is_identity(const SkMatrix& m) {
     SkMatrix identity;
     identity.reset();
     return nearly_equal(m, identity);
 }
 
@@ skipping 206 matching lines @@
     // perspective x
     mat.reset();
     mat.setPerspX(SkScalarToPersp(SK_Scalar1 / 2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 
     // perspective y
     mat.reset();
     mat.setPerspY(SkScalarToPersp(SK_Scalar1 / 2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 
-#ifdef SK_SCALAR_IS_FLOAT
-    /* We bypass the following tests for SK_SCALAR_IS_FIXED build.
-     * The long discussion can be found in this issue:
-     *     http://codereview.appspot.com/5999050/
-     * In short, we haven't found a perfect way to fix the precision
-     * issue, i.e. the way we use tolerance in isSimilarityTransformation
-     * is incorrect. The situation becomes worse in fixed build, so
-     * we disabled rotation related tests for fixed build.
-     */
-
     // rotate
     for (int angle = 0; angle < 360; ++angle) {
         mat.reset();
         mat.setRotate(SkIntToScalar(angle));
         REPORTER_ASSERT(reporter, mat.isSimilarity());
     }
 
     // see if there are any accumulated precision issues
     mat.reset();
     for (int i = 1; i < 360; i++) {
@@ skipping 11 matching lines @@
     mat.reset();
     mat.setRotate(SkIntToScalar(30));
     mat.postScale(SkIntToScalar(2), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, mat.isSimilarity());
 
     // rotate + non-uniform scale
     mat.reset();
     mat.setRotate(SkIntToScalar(30));
     mat.postScale(SkIntToScalar(3), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
-#endif
 
     // all zero
     mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, 0);
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 
     // all zero except perspective
     mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, SK_Scalar1);
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 
     // scales zero, only skews
@@ skipping 439 matching lines @@
     mat2.reset();
     mat.reset();
     SkScalar zero = 0;
     mat.set(SkMatrix::kMSkewX, -zero);
     REPORTER_ASSERT(reporter, are_equal(reporter, mat, mat2));
 
     mat2.reset();
     mat.reset();
     mat.set(SkMatrix::kMSkewX, SK_ScalarNaN);
     mat2.set(SkMatrix::kMSkewX, SK_ScalarNaN);
-    // fixed pt doesn't have the property that NaN does not equal itself.
-#ifdef SK_SCALAR_IS_FIXED
-    REPORTER_ASSERT(reporter, are_equal(reporter, mat, mat2));
-#else
     REPORTER_ASSERT(reporter, !are_equal(reporter, mat, mat2));
-#endif
 
     test_matrix_min_max_stretch(reporter);
     test_matrix_is_similarity(reporter);
     test_matrix_recttorect(reporter);
     test_matrix_decomposition(reporter);
     test_matrix_homogeneous(reporter);
 }