remove SkFloatToScalar macro

tests/PathTest.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 "SkCanvas.h"
 #include "SkPaint.h"
@@ skipping 815 matching lines @@
 
     path.reset();
     path.addCircle(0, 0, SkIntToScalar(1), SkPath::kCW_Direction);
     path.addCircle(0, 0, SkIntToScalar(2), SkPath::kCCW_Direction);
     check_direction(reporter, path, SkPath::kCCW_Direction);
 
 #ifdef SK_SCALAR_IS_FLOAT
     // triangle with one point really far from the origin.
     path.reset();
     // the first point is roughly 1.05e10, 1.05e10
-    path.moveTo(SkFloatToScalar(SkBits2Float(0x501c7652)), SkFloatToScalar(SkBits2Float(0x501c7652)));
+    path.moveTo(SkBits2Float(0x501c7652), SkBits2Float(0x501c7652));
     path.lineTo(110 * SK_Scalar1, -10 * SK_Scalar1);
     path.lineTo(-10 * SK_Scalar1, 60 * SK_Scalar1);
     check_direction(reporter, path, SkPath::kCCW_Direction);
 #endif
 
     path.reset();
     path.conicTo(20, 0, 20, 20, 0.5f);
     path.close();
     check_direction(reporter, path, SkPath::kCW_Direction);
 
@@ skipping 420 matching lines @@
     static const struct SUPPRESS_VISIBILITY_WARNING {
         SkRect fQueryRect;
         bool   fInRect;
         bool   fInCircle;
         bool   fInRR;
         bool   fInCubicRR;
     } kQueries[] = {
         {kBaseRect, true, true, false, false},
 
         // rect well inside of kBaseRect
-        {SkRect::MakeLTRB(kBaseRect.fLeft + SkFloatToScalar(0.25f)*kBaseRect.width(),
-                          kBaseRect.fTop + SkFloatToScalar(0.25f)*kBaseRect.height(),
-                          kBaseRect.fRight - SkFloatToScalar(0.25f)*kBaseRect.width(),
-                          kBaseRect.fBottom - SkFloatToScalar(0.25f)*kBaseRect.height()),
+        {SkRect::MakeLTRB(kBaseRect.fLeft + 0.25f*kBaseRect.width(),
+                          kBaseRect.fTop + 0.25f*kBaseRect.height(),
+                          kBaseRect.fRight - 0.25f*kBaseRect.width(),
+                          kBaseRect.fBottom - 0.25f*kBaseRect.height()),
                           true, true, true, true},
 
         // rects with edges off by one from kBaseRect's edges
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,
                           kBaseRect.width(), kBaseRect.height() + 1),
          false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,
                           kBaseRect.width() + 1, kBaseRect.height()),
          false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,
@@ skipping 84 matching lines @@
                 path.lineTo(kBaseRect.fRight, kBaseRect.fBottom);
                 path.lineTo(kBaseRect.fRight, kBaseRect.fTop);
                 path.close();
                 REPORTER_ASSERT(reporter, kQueries[q].fInCubicRR ==
                                           path.conservativelyContainsRect(qRect));
 
             }
             // Slightly non-convex shape, shouldn't contain any rects.
             path.reset();
             path.moveTo(0, 0);
-            path.lineTo(SkIntToScalar(50), SkFloatToScalar(0.05f));
+            path.lineTo(SkIntToScalar(50), 0.05f);
             path.lineTo(SkIntToScalar(100), 0);
             path.lineTo(SkIntToScalar(100), SkIntToScalar(100));
             path.lineTo(0, SkIntToScalar(100));
             path.close();
             REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(qRect));
         }
     }
 
     // make sure a minimal convex shape works, a right tri with edges along pos x and y axes.
     path.reset();
@@ skipping 1559 matching lines @@
     SkRect oval = {1, 2, 3, 4};
     p.arcTo(oval, 0, 0, true);
     check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
     p.arcTo(oval, 0, 0, false);
     check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
     p.arcTo(oval, 360, 0, true);
     check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
     p.arcTo(oval, 360, 0, false);
     check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
     for (float sweep = 359, delta = 0.5f; sweep != (float) (sweep + delta); ) {
-        p.arcTo(oval, 0, SkFloatToScalar(sweep), false);
+        p.arcTo(oval, 0, sweep, false);
         REPORTER_ASSERT(reporter, p.getBounds() == oval);
         sweep += delta;
         delta /= 2;
     }
     for (float sweep = 361, delta = 0.5f; sweep != (float) (sweep - delta);) {
-        p.arcTo(oval, 0, SkFloatToScalar(sweep), false);
+        p.arcTo(oval, 0, sweep, false);
         REPORTER_ASSERT(reporter, p.getBounds() == oval);
         sweep -= delta;
         delta /= 2;
     }
     SkRect noOvalWidth = {1, 2, 0, 3};
     p.reset();
     p.arcTo(noOvalWidth, 0, 360, false);
     REPORTER_ASSERT(reporter, p.isEmpty());
 
     SkRect noOvalHeight = {1, 2, 3, 1};
@@ skipping 269 matching lines @@
     test_arcTo(reporter);
     test_addPath(reporter);
     test_conicTo_special_case(reporter);
     test_get_point(reporter);
     test_contains(reporter);
     PathTest_Private::TestPathTo(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Path", PathTestClass, TestPath)