remove SK_SCALAR_IS_[FLOAT,FIXED] and assume floats

tests/DrawPathTest.cpp

 /*
  * Copyright 2012 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 "SkBitmap.h"
@@ skipping 163 matching lines @@
     canvas.get()->clipRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(19),
                                             SkIntToScalar(19), SkIntToScalar(11)));
 
     paint.setAntiAlias(false);
     canvas.get()->drawPath(path, paint);
     paint.setAntiAlias(true);
     canvas.get()->drawPath(path, paint);
 }
 
 static void test_bug533() {
-#ifdef SK_SCALAR_IS_FLOAT
     /*
         http://code.google.com/p/skia/issues/detail?id=533
         This particular test/bug only applies to the float case, where the
         coordinates are very large.
      */
     SkPath path;
     path.moveTo(64, 3);
     path.quadTo(-329936, -100000000, 1153, 330003);
 
     SkPaint paint;
     paint.setAntiAlias(true);
 
     SkAutoTUnref<SkCanvas> canvas(new_canvas(640, 480));
     canvas.get()->drawPath(path, paint);
-#endif
 }
 
 static void test_crbug_140642() {
     /*
      *  We used to see this construct, and due to rounding as we accumulated
      *  our length, the loop where we apply the phase would run off the end of
      *  the array, since it relied on just -= each interval value, which did not
      *  behave as "expected". Now the code explicitly checks for walking off the
      *  end of that array.
 
      *  A different (better) fix might be to rewrite dashing to do all of its
      *  length/phase/measure math using double, but this may need to be
      *  coordinated with SkPathMeasure, to be consistent between the two.
 
      <path stroke="mintcream" stroke-dasharray="27734 35660 2157846850 247"
            stroke-dashoffset="-248.135982067">
      */
 
-#ifdef SK_SCALAR_IS_FLOAT
     const SkScalar vals[] = { 27734, 35660, 2157846850.0f, 247 };
     SkDashPathEffect dontAssert(vals, 4, -248.135982067f);
-#endif
 }
 
 static void test_crbug_124652() {
-#ifdef SK_SCALAR_IS_FLOAT
     /*
         http://code.google.com/p/chromium/issues/detail?id=124652
         This particular test/bug only applies to the float case, where
         large values can "swamp" small ones.
      */
     SkScalar intervals[2] = {837099584, 33450};
     SkAutoTUnref<SkDashPathEffect> dash(
         new SkDashPathEffect(intervals, 2, -10, false));
-#endif
 }
 
 static void test_bigcubic() {
-#ifdef SK_SCALAR_IS_FLOAT
     SkPath path;
     path.moveTo(64, 3);
     path.cubicTo(-329936, -100000000, -329936, 100000000, 1153, 330003);
 
     SkPaint paint;
     paint.setAntiAlias(true);
 
     SkAutoTUnref<SkCanvas> canvas(new_canvas(640, 480));
     canvas.get()->drawPath(path, paint);
-#endif
 }
 
 // we used to assert if the bounds of the device (clip) was larger than 32K
 // even when the path itself was smaller. We just draw and hope in the debug
 // version to not assert.
 static void test_giantaa() {
     const int W = 400;
     const int H = 400;
     SkAutoTUnref<SkCanvas> canvas(new_canvas(33000, 10));
     canvas.get()->clear(SK_ColorTRANSPARENT);
@@ skipping 54 matching lines @@
     test_crbug_124652();
     test_crbug_140642();
     test_crbug_140803();
     test_inversepathwithclip();
     // why?
     if (false) test_crbug131181();
     test_infinite_dash(reporter);
     test_crbug_165432(reporter);
     test_big_aa_rect(reporter);
 }