remove SkFloatToScalar macro

src/utils/win/SkDWriteGeometrySink.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 "SkTypes.h"
 
 #include "SkDWriteGeometrySink.h"
@@ skipping 47 matching lines @@
     }
 }
 
 void STDMETHODCALLTYPE SkDWriteGeometrySink::SetSegmentFlags(D2D1_PATH_SEGMENT vertexFlags) {
     if (vertexFlags == D2D1_PATH_SEGMENT_NONE || vertexFlags == D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN) {
         SkDEBUGFAIL("Invalid D2D1_PATH_SEGMENT value.");
     }
 }
 
 void STDMETHODCALLTYPE SkDWriteGeometrySink::BeginFigure(D2D1_POINT_2F startPoint, D2D1_FIGURE_BEGIN figureBegin) {
-    fPath->moveTo(SkFloatToScalar(startPoint.x), SkFloatToScalar(startPoint.y));
+    fPath->moveTo(startPoint.x, startPoint.y);
     if (figureBegin == D2D1_FIGURE_BEGIN_HOLLOW) {
         SkDEBUGFAIL("Invalid D2D1_FIGURE_BEGIN value.");
     }
 }
 
 void STDMETHODCALLTYPE SkDWriteGeometrySink::AddLines(const D2D1_POINT_2F *points, UINT pointsCount) {
     for (const D2D1_POINT_2F *end = &points[pointsCount]; points < end; ++points) {
-        fPath->lineTo(SkFloatToScalar(points->x), SkFloatToScalar(points->y));
+        fPath->lineTo(points->x, points->y);
     }
 }
 
 static bool approximately_equal(float a, float b) {
     const SkFloatingPoint<float, 10> lhs(a), rhs(b);
     return lhs.AlmostEquals(rhs);
 }
 
 typedef struct {
     float x;
@@ skipping 27 matching lines @@
     fPath->getLastPt(&lastPt);
     D2D1_POINT_2F prevPt = { SkScalarToFloat(lastPt.fX), SkScalarToFloat(lastPt.fY) };
 
     for (const D2D1_BEZIER_SEGMENT *end = &beziers[beziersCount]; beziers < end; ++beziers) {
         Cubic cubic = { { prevPt.x, prevPt.y },
                         { beziers->point1.x, beziers->point1.y },
                         { beziers->point2.x, beziers->point2.y },
                         { beziers->point3.x, beziers->point3.y }, };
         Quadratic quadratic;
         if (check_quadratic(cubic, quadratic)) {
-            fPath->quadTo(SkFloatToScalar(quadratic[1].x), SkFloatToScalar(quadratic[1].y),
-                          SkFloatToScalar(quadratic[2].x), SkFloatToScalar(quadratic[2].y));
+            fPath->quadTo(quadratic[1].x, quadratic[1].y,
+                          quadratic[2].x, quadratic[2].y);
         } else {
-            fPath->cubicTo(SkFloatToScalar(beziers->point1.x), SkFloatToScalar(beziers->point1.y),
-                           SkFloatToScalar(beziers->point2.x), SkFloatToScalar(beziers->point2.y),
-                           SkFloatToScalar(beziers->point3.x), SkFloatToScalar(beziers->point3.y));
+            fPath->cubicTo(beziers->point1.x, beziers->point1.y,
+                           beziers->point2.x, beziers->point2.y,
+                           beziers->point3.x, beziers->point3.y);
         }
         prevPt = beziers->point3;
     }
 }
 
 void STDMETHODCALLTYPE SkDWriteGeometrySink::EndFigure(D2D1_FIGURE_END figureEnd) {
     fPath->close();
 }
 
 HRESULT SkDWriteGeometrySink::Close() {
     return S_OK;
 }
 
 HRESULT SkDWriteGeometrySink::Create(SkPath* path, IDWriteGeometrySink** geometryToPath) {
     *geometryToPath = new SkDWriteGeometrySink(path);
     return S_OK;
 }