remove SkFloatToScalar macro

tests/ImageFilterTest.cpp

 
 /*
  * Copyright 2013 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 "SkBicubicImageFilter.h"
@@ skipping 40 matching lines @@
                 canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
                                                  SkIntToScalar(i),
                                                  SkIntToScalar(i),
                                                  SkIntToScalar(i)), darkPaint);
                 canvas.restore();
             }
         }
     }
 
     static SkImageFilter* make_scale(float amount, SkImageFilter* input = NULL) {
-        SkScalar s = SkFloatToScalar(amount);
+        SkScalar s = amount;
         SkScalar matrix[20] = { s, 0, 0, 0, 0,
                                 0, s, 0, 0, 0,
                                 0, 0, s, 0, 0,
                                 0, 0, 0, s, 0 };
         SkAutoTUnref<SkColorFilter> filter(new SkColorMatrixFilter(matrix));
         return SkColorFilterImageFilter::Create(filter, input);
     }
 
     static SkImageFilter* make_grayscale(SkImageFilter* input = NULL, const SkImageFilter::CropRect* cropRect = NULL) {
         SkScalar matrix[20];
         memset(matrix, 0, 20 * sizeof(SkScalar));
-        matrix[0] = matrix[5] = matrix[10] = SkFloatToScalar(0.2126f);
-        matrix[1] = matrix[6] = matrix[11] = SkFloatToScalar(0.7152f);
-        matrix[2] = matrix[7] = matrix[12] = SkFloatToScalar(0.0722f);
-        matrix[18] = SkFloatToScalar(1.0f);
+        matrix[0] = matrix[5] = matrix[10] = 0.2126f;
+        matrix[1] = matrix[6] = matrix[11] = 0.7152f;
+        matrix[2] = matrix[7] = matrix[12] = 0.0722f;
+        matrix[18] = 1.0f;
         SkAutoTUnref<SkColorFilter> filter(new SkColorMatrixFilter(matrix));
         return SkColorFilterImageFilter::Create(filter, input, cropRect);
     }
 
     static SkImageFilter* make_mode_blue(SkImageFilter* input = NULL) {
         SkAutoTUnref<SkColorFilter> filter(
             SkColorFilter::CreateModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode));
         return SkColorFilterImageFilter::Create(filter, input);
     }
 
@@ skipping 34 matching lines @@
             result.setConfig(SkBitmap::kARGB_8888_Config, kBitmapSize, kBitmapSize);
             result.allocPixels();
 
             {
                 // This tests for :
                 // 1 ) location at (0,0,1)
                 SkPoint3 location(0, 0, SK_Scalar1);
                 // 2 ) location and target at same value
                 SkPoint3 target(location.fX, location.fY, location.fZ);
                 // 3 ) large negative specular exponent value
-                SkScalar specularExponent = SkFloatToScalar(-1000);
+                SkScalar specularExponent = -1000;
 
                 SkAutoTUnref<SkImageFilter> bmSrc(new SkBitmapSource(bitmap));
                 SkPaint paint;
                 paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
-                        location, target, specularExponent, SkFloatToScalar(180),
+                        location, target, specularExponent, 180,
                         0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
                         bmSrc))->unref();
                 SkCanvas canvas(result);
                 SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                           SkIntToScalar(kBitmapSize));
                 canvas.drawRect(r, paint);
             }
 
             {
                 // This tests for scale bringing width to 0
-                SkSize scale = SkSize::Make(SkFloatToScalar(-0.001f), SK_Scalar1);
+                SkSize scale = SkSize::Make(-0.001f, SK_Scalar1);
                 SkAutoTUnref<SkImageFilter> bmSrc(new SkBitmapSource(bitmap));
                 SkAutoTUnref<SkBicubicImageFilter> bicubic(
                     SkBicubicImageFilter::CreateMitchell(scale, bmSrc));
                 SkBitmapDevice device(bitmap);
                 SkDeviceImageFilterProxy proxy(&device);
                 SkIPoint loc = SkIPoint::Make(0, 0);
                 // An empty input should early return and return false
                 REPORTER_ASSERT(reporter,
                     !bicubic->filterImage(&proxy, bitmap, SkMatrix::I(), &result, &loc));
             }
         }
     }
 };
 
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("ImageFilterTest", ImageFilterTestClass, ImageFilterTest::Test)