Change type of SkGlyph::fAdvance[XY] to float.

BUG=skia:4632
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1737693006

Review URL: https://codereview.chromium.org/1737693006

17 files changed, 162 insertions, 161 deletions

diff --git a/src/core/SkAutoKern.h b/src/core/SkAutoKern.h
index 0b22e56413..27df6da22b 100644
--- a/src/core/SkAutoKern.h
+++ b/src/core/SkAutoKern.h
@@ -12,11 +12,10 @@
 
 #include "SkGlyph.h"
 
-#define SkAutoKern_AdjustF(prev, next)    (((next) - (prev) + 32) >> 6 << 16)
-#define SkAutoKern_AdjustS(prev, next)    SkIntToScalar(((next) - (prev) + 32) >> 6)
+#define SkAutoKern_Adjust(prev, next)    SkIntToScalar(((next) - (prev) + 32) >> 6)
 
 /* this is a helper class to perform auto-kerning
- * the adjust() method returns a SkFixed corresponding
+ * the adjust() method returns a SkScalar corresponding
  * to a +1/0/-1 pixel adjustment
  */
 
@@ -24,7 +23,7 @@ class SkAutoKern {
 public:
     SkAutoKern() : fPrevRsbDelta(0) {}
 
-    SkFixed  adjust(const SkGlyph&  glyph)
+    SkScalar  adjust(const SkGlyph&  glyph)
     {
 //        if (SkAbs32(glyph.fLsbDelta) > 47 || SkAbs32(glyph.fRsbDelta) > 47)
 //            printf("------- %d> L %d R %d\n", glyph.f_GlyphID, glyph.fLsbDelta, glyph.fRsbDelta);
@@ -35,13 +34,13 @@ public:
         fPrevRsbDelta = glyph.fRsbDelta;
 
         if (distort >= 32)
-            return -SK_Fixed1;
+            return -SK_Scalar1;
         else if (distort < -32)
-            return +SK_Fixed1;
+            return +SK_Scalar1;
         else
             return 0;
 #else
-        SkFixed adjust = SkAutoKern_AdjustF(fPrevRsbDelta, glyph.fLsbDelta);
+        SkScalar adjust = SkAutoKern_Adjust(fPrevRsbDelta, glyph.fLsbDelta);
         fPrevRsbDelta = glyph.fRsbDelta;
         return adjust;
 #endif
diff --git a/src/core/SkDrawProcs.h b/src/core/SkDrawProcs.h
index a861a0ad86..15c5cf866a 100644
--- a/src/core/SkDrawProcs.h
+++ b/src/core/SkDrawProcs.h
@@ -51,12 +51,12 @@ public:
         if (SkPaint::kLeft_Align == fAlign) {
             dst->set(loc.fX, loc.fY);
         } else if (SkPaint::kCenter_Align == fAlign) {
-            dst->set(loc.fX - SkFixedToScalar(glyph.fAdvanceX >> 1),
-                     loc.fY - SkFixedToScalar(glyph.fAdvanceY >> 1));
+            dst->set(loc.fX - SkFloatToScalar(glyph.fAdvanceX) / 2,
+                     loc.fY - SkFloatToScalar(glyph.fAdvanceY) / 2);
         } else {
             SkASSERT(SkPaint::kRight_Align == fAlign);
-            dst->set(loc.fX - SkFixedToScalar(glyph.fAdvanceX),
-                     loc.fY - SkFixedToScalar(glyph.fAdvanceY));
+            dst->set(loc.fX - SkFloatToScalar(glyph.fAdvanceX),
+                     loc.fY - SkFloatToScalar(glyph.fAdvanceY));
         }
     }
 private:
diff --git a/src/core/SkFDot6.h b/src/core/SkFDot6.h
index b536729829..91f3dda020 100644
--- a/src/core/SkFDot6.h
+++ b/src/core/SkFDot6.h
@@ -63,6 +63,7 @@ inline SkFixed SkFDot6ToFixed(SkFDot6 x) {
 
 #define SkScalarToFDot6(x)  (SkFDot6)((x) * 64)
 #define SkFDot6ToScalar(x)  ((SkScalar)(x) * 0.015625f)
+#define SkFDot6ToFloat      SkFDot6ToScalar
 
 inline SkFixed SkFDot6Div(SkFDot6 a, SkFDot6 b) {
     SkASSERT(b != 0);
diff --git a/src/core/SkFindAndPlaceGlyph.h b/src/core/SkFindAndPlaceGlyph.h
index 35ae77cfe3..48cc0fa144 100644
--- a/src/core/SkFindAndPlaceGlyph.h
+++ b/src/core/SkFindAndPlaceGlyph.h
@@ -347,11 +347,11 @@ private:
             case SkPaint::kLeft_Align:
                 return {0.0f, 0.0f};
             case SkPaint::kCenter_Align:
-                return {SkFixedToScalar(glyph.fAdvanceX >> 1),
-                        SkFixedToScalar(glyph.fAdvanceY >> 1)};
+                return {SkFloatToScalar(glyph.fAdvanceX) / 2,
+                        SkFloatToScalar(glyph.fAdvanceY) / 2};
             case SkPaint::kRight_Align:
-                return {SkFixedToScalar(glyph.fAdvanceX),
-                        SkFixedToScalar(glyph.fAdvanceY)};
+                return {SkFloatToScalar(glyph.fAdvanceX),
+                        SkFloatToScalar(glyph.fAdvanceY)};
         }
         // Even though the entire enum is covered above, MVSC doesn't think so. Make it happy.
         SkFAIL("Should never get here.");
@@ -447,8 +447,8 @@ private:
                 if (metricGlyph.fWidth <= 0) {
                     // Exiting early, be sure to update text pointer.
                     *text = tempText;
-                    return finalPosition + SkPoint{SkFixedToScalar(metricGlyph.fAdvanceX),
-                                                   SkFixedToScalar(metricGlyph.fAdvanceY)};
+                    return finalPosition + SkPoint{SkFloatToScalar(metricGlyph.fAdvanceX),
+                                                   SkFloatToScalar(metricGlyph.fAdvanceY)};
                 }
 
                 // Adjust the final position by the alignment adjustment.
@@ -465,8 +465,8 @@ private:
                 processOneGlyph(renderGlyph, finalPosition,
                                 SubpixelPositionRounding(kAxisAlignment));
             }
-            return finalPosition + SkPoint{SkFixedToScalar(renderGlyph.fAdvanceX),
-                                           SkFixedToScalar(renderGlyph.fAdvanceY)};
+            return finalPosition + SkPoint{SkFloatToScalar(renderGlyph.fAdvanceX),
+                                           SkFloatToScalar(renderGlyph.fAdvanceY)};
         }
 
     private:
@@ -497,14 +497,14 @@ private:
             SkPoint finalPosition = position;
             const SkGlyph& glyph = fGlyphFinder->lookupGlyph(text);
             if (kUseKerning) {
-                finalPosition += {SkFixedToScalar(fAutoKern.adjust(glyph)), 0.0f};
+                finalPosition += {fAutoKern.adjust(glyph), 0.0f};
             }
             if (glyph.fWidth > 0) {
                 finalPosition -= TextAlignmentAdjustment(kTextAlignment, glyph);
                 processOneGlyph(glyph, finalPosition, {SK_ScalarHalf, SK_ScalarHalf});
             }
-            return finalPosition + SkPoint{SkFixedToScalar(glyph.fAdvanceX),
-                                           SkFixedToScalar(glyph.fAdvanceY)};
+            return finalPosition + SkPoint{SkFloatToScalar(glyph.fAdvanceX),
+                                           SkFloatToScalar(glyph.fAdvanceY)};
         }
 
     private:
@@ -564,7 +564,7 @@ private:
     }
 
     static SkPoint MeasureText(LookupGlyph& glyphFinder, const char text[], size_t byteLength) {
-        SkFixed     x = 0, y = 0;
+        SkScalar    x = 0, y = 0;
         const char* stop = text + byteLength;
 
         SkAutoKern  autokern;
@@ -574,11 +574,11 @@ private:
             // same advance
             const SkGlyph& glyph = glyphFinder->lookupGlyph(&text);
 
-            x += autokern.adjust(glyph) + glyph.fAdvanceX;
-            y += glyph.fAdvanceY;
+            x += autokern.adjust(glyph) + SkFloatToScalar(glyph.fAdvanceX);
+            y += SkFloatToScalar(glyph.fAdvanceY);
         }
         SkASSERT(text == stop);
-        return {SkFixedToScalar(x), SkFixedToScalar(y)};
+        return {x, y};
     }
 };
 
diff --git a/src/core/SkGlyph.h b/src/core/SkGlyph.h
index 55d5ddcf05..91aa8429f9 100644
--- a/src/core/SkGlyph.h
+++ b/src/core/SkGlyph.h
@@ -56,7 +56,7 @@ public:
     static const uint32_t kImpossibleID = ~0;
     void*       fImage;
     PathData*   fPathData;
-    SkFixed     fAdvanceX, fAdvanceY;
+    float       fAdvanceX, fAdvanceY;
 
     uint16_t    fWidth, fHeight;
     int16_t     fTop, fLeft;
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 6fe9d7599d..2ced3f6bef 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -733,28 +733,26 @@ static void set_bounds(const SkGlyph& g, SkRect* bounds) {
                 SkIntToScalar(g.fTop + g.fHeight));
 }
 
-static void join_bounds_x(const SkGlyph& g, SkRect* bounds, Sk48Dot16 dx) {
-    SkScalar sx = Sk48Dot16ToScalar(dx);
-    bounds->join(SkIntToScalar(g.fLeft) + sx,
+static void join_bounds_x(const SkGlyph& g, SkRect* bounds, SkScalar dx) {
+    bounds->join(SkIntToScalar(g.fLeft) + dx,
                  SkIntToScalar(g.fTop),
-                 SkIntToScalar(g.fLeft + g.fWidth) + sx,
+                 SkIntToScalar(g.fLeft + g.fWidth) + dx,
                  SkIntToScalar(g.fTop + g.fHeight));
 }
 
-static void join_bounds_y(const SkGlyph& g, SkRect* bounds, Sk48Dot16 dy) {
-    SkScalar sy = Sk48Dot16ToScalar(dy);
+static void join_bounds_y(const SkGlyph& g, SkRect* bounds, SkScalar dy) {
     bounds->join(SkIntToScalar(g.fLeft),
-                 SkIntToScalar(g.fTop) + sy,
+                 SkIntToScalar(g.fTop) + dy,
                  SkIntToScalar(g.fLeft + g.fWidth),
-                 SkIntToScalar(g.fTop + g.fHeight) + sy);
+                 SkIntToScalar(g.fTop + g.fHeight) + dy);
 }
 
-typedef void (*JoinBoundsProc)(const SkGlyph&, SkRect*, Sk48Dot16);
+typedef void (*JoinBoundsProc)(const SkGlyph&, SkRect*, SkScalar);
 
 // xyIndex is 0 for fAdvanceX or 1 for fAdvanceY
-static SkFixed advance(const SkGlyph& glyph, int xyIndex) {
+static SkScalar advance(const SkGlyph& glyph, int xyIndex) {
     SkASSERT(0 == xyIndex || 1 == xyIndex);
-    return (&glyph.fAdvanceX)[xyIndex];
+    return SkFloatToScalar((&glyph.fAdvanceX)[xyIndex]);
 }
 
 SkScalar SkPaint::measure_text(SkGlyphCache* cache,
@@ -784,20 +782,14 @@ SkScalar SkPaint::measure_text(SkGlyphCache* cache,
     int         n = 1;
     const char* stop = (const char*)text + byteLength;
     const SkGlyph* g = &glyphCacheProc(cache, &text);
-    // our accumulated fixed-point advances might overflow 16.16, so we use
-    // a 48.16 (64bit) accumulator, and then convert that to scalar at the
-    // very end.
-    Sk48Dot16 x = advance(*g, xyIndex);
-
-    SkAutoKern  autokern;
+    SkScalar x = advance(*g, xyIndex);
 
     if (nullptr == bounds) {
         if (this->isDevKernText()) {
-            int rsb;
             for (; text < stop; n++) {
-                rsb = g->fRsbDelta;
+                const int rsb = g->fRsbDelta;
                 g = &glyphCacheProc(cache, &text);
-                x += SkAutoKern_AdjustF(rsb, g->fLsbDelta) + advance(*g, xyIndex);
+                x += SkAutoKern_Adjust(rsb, g->fLsbDelta) + advance(*g, xyIndex);
             }
         } else {
             for (; text < stop; n++) {
@@ -807,11 +799,10 @@ SkScalar SkPaint::measure_text(SkGlyphCache* cache,
     } else {
         set_bounds(*g, bounds);
         if (this->isDevKernText()) {
-            int rsb;
             for (; text < stop; n++) {
-                rsb = g->fRsbDelta;
+                const int rsb = g->fRsbDelta;
                 g = &glyphCacheProc(cache, &text);
-                x += SkAutoKern_AdjustF(rsb, g->fLsbDelta);
+                x += SkAutoKern_Adjust(rsb, g->fLsbDelta);
                 joinBoundsProc(*g, bounds, x);
                 x += advance(*g, xyIndex);
             }
@@ -826,7 +817,7 @@ SkScalar SkPaint::measure_text(SkGlyphCache* cache,
     SkASSERT(text == stop);
 
     *count = n;
-    return Sk48Dot16ToScalar(x);
+    return x;
 }
 
 SkScalar SkPaint::measureText(const void* textData, size_t length, SkRect* bounds) const {
@@ -896,19 +887,15 @@ size_t SkPaint::breakText(const void* textD, size_t length, SkScalar maxWidth,
 
     GlyphCacheProc   glyphCacheProc = paint.getGlyphCacheProc(false);
     const int        xyIndex = paint.isVerticalText() ? 1 : 0;
-    // use 64bits for our accumulator, to avoid overflowing 16.16
-    Sk48Dot16        max = SkScalarTo48Dot16(maxWidth);
-    Sk48Dot16        width = 0;
-
-    SkAutoKern  autokern;
+    SkScalar         width = 0;
 
     if (this->isDevKernText()) {
         int rsb = 0;
         while (text < stop) {
             const char* curr = text;
             const SkGlyph& g = glyphCacheProc(cache, &text);
-            SkFixed x = SkAutoKern_AdjustF(rsb, g.fLsbDelta) + advance(g, xyIndex);
-            if ((width += x) > max) {
+            SkScalar x = SkAutoKern_Adjust(rsb, g.fLsbDelta) + advance(g, xyIndex);
+            if ((width += x) > maxWidth) {
                 width -= x;
                 text = curr;
                 break;
@@ -918,8 +905,8 @@ size_t SkPaint::breakText(const void* textD, size_t length, SkScalar maxWidth,
     } else {
         while (text < stop) {
             const char* curr = text;
-            SkFixed x = advance(glyphCacheProc(cache, &text), xyIndex);
-            if ((width += x) > max) {
+            SkScalar x = advance(glyphCacheProc(cache, &text), xyIndex);
+            if ((width += x) > maxWidth) {
                 width -= x;
                 text = curr;
                 break;
@@ -928,11 +915,10 @@ size_t SkPaint::breakText(const void* textD, size_t length, SkScalar maxWidth,
     }
 
     if (measuredWidth) {
-        SkScalar scalarWidth = Sk48Dot16ToScalar(width);
         if (scale) {
-            scalarWidth = SkScalarMul(scalarWidth, scale);
+            width *= scale;
         }
-        *measuredWidth = scalarWidth;
+        *measuredWidth = width;
     }
 
     // return the number of bytes measured
@@ -1022,17 +1008,16 @@ int SkPaint::getTextWidths(const void* textData, size_t byteLength,
     if (this->isDevKernText()) {
         // we adjust the widths returned here through auto-kerning
         SkAutoKern  autokern;
-        SkFixed     prevWidth = 0;
+        SkScalar    prevWidth = 0;
 
         if (scale) {
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    SkFixed  adjust = autokern.adjust(g);
+                    SkScalar adjust = autokern.adjust(g);
 
                     if (count > 0) {
-                        SkScalar w = SkFixedToScalar(prevWidth + adjust);
-                        *widths++ = SkScalarMul(w, scale);
+                        *widths++ = SkScalarMul(prevWidth + adjust, scale);
                     }
                     prevWidth = advance(g, xyIndex);
                 }
@@ -1042,16 +1027,16 @@ int SkPaint::getTextWidths(const void* textData, size_t byteLength,
                 ++count;
             }
             if (count > 0 && widths) {
-                *widths = SkScalarMul(SkFixedToScalar(prevWidth), scale);
+                *widths = SkScalarMul(prevWidth, scale);
             }
         } else {
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    SkFixed  adjust = autokern.adjust(g);
+                    SkScalar adjust = autokern.adjust(g);
 
                     if (count > 0) {
-                        *widths++ = SkFixedToScalar(prevWidth + adjust);
+                        *widths++ = prevWidth + adjust;
                     }
                     prevWidth = advance(g, xyIndex);
                 }
@@ -1061,7 +1046,7 @@ int SkPaint::getTextWidths(const void* textData, size_t byteLength,
                 ++count;
             }
             if (count > 0 && widths) {
-                *widths = SkFixedToScalar(prevWidth);
+                *widths = prevWidth;
             }
         }
     } else {    // no devkern
@@ -1069,7 +1054,7 @@ int SkPaint::getTextWidths(const void* textData, size_t byteLength,
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    *widths++ = SkScalarMul(SkFixedToScalar(advance(g, xyIndex)),
+                    *widths++ = SkScalarMul(advance(g, xyIndex),
                                             scale);
                 }
                 if (bounds) {
@@ -1081,7 +1066,7 @@ int SkPaint::getTextWidths(const void* textData, size_t byteLength,
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    *widths++ = SkFixedToScalar(advance(g, xyIndex));
+                    *widths++ = advance(g, xyIndex);
                 }
                 if (bounds) {
                     set_bounds(g, bounds++);
@@ -2297,7 +2282,7 @@ bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
     if (fText < fStop) {
         const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
 
-        fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
+        fXPos += SkScalarMul(fPrevAdvance + fAutoKern.adjust(glyph), fScale);
         fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
 
         if (glyph.fWidth) {
@@ -2319,7 +2304,7 @@ bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
 
 bool SkTextInterceptsIter::next(SkScalar* array, int* count) {
     const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
-    fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
+    fXPos += SkScalarMul(fPrevAdvance + fAutoKern.adjust(glyph), fScale);
     fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
     if (fCache->findPath(glyph)) {
         fCache->findIntercepts(fBounds, fScale, fXPos, SkToBool(fXYIndex),
diff --git a/src/core/SkTextToPathIter.h b/src/core/SkTextToPathIter.h
index 435c1c79f0..dcd5a01cd3 100644
--- a/src/core/SkTextToPathIter.h
+++ b/src/core/SkTextToPathIter.h
@@ -22,7 +22,7 @@ protected:
     SkGlyphCache*   fCache;
     SkPaint         fPaint;
     SkScalar        fScale;
-    SkFixed         fPrevAdvance;
+    SkScalar        fPrevAdvance;
     const char*     fText;
     const char*     fStop;
     SkPaint::GlyphCacheProc fGlyphCacheProc;
@@ -75,7 +75,7 @@ public:
                 && fPaint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
             const char* text = fText;
             const SkGlyph& glyph = fGlyphCacheProc(fCache, &text);
-            SkScalar width = SkScalarMul(SkFixedToScalar((&glyph.fAdvanceX)[0]), fScale);
+            SkScalar width = SkScalarMul(SkFloatToScalar((&glyph.fAdvanceX)[0]), fScale);
             if (fPaint.getTextAlign() == SkPaint::kCenter_Align) {
                 width = SkScalarHalf(width);
             }
diff --git a/src/fonts/SkGScalerContext.cpp b/src/fonts/SkGScalerContext.cpp
index d2d0cacd0e..9766e34ff0 100644
--- a/src/fonts/SkGScalerContext.cpp
+++ b/src/fonts/SkGScalerContext.cpp
@@ -77,20 +77,20 @@ void SkGScalerContext::generateAdvance(SkGlyph* glyph) {
     fProxy->getAdvance(glyph);
 
     SkVector advance;
-    fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
-                  SkFixedToScalar(glyph->fAdvanceY), &advance);
-    glyph->fAdvanceX = SkScalarToFixed(advance.fX);
-    glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+    fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+                  SkFloatToScalar(glyph->fAdvanceY), &advance);
+    glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+    glyph->fAdvanceY = SkScalarToFloat(advance.fY);
 }
 
 void SkGScalerContext::generateMetrics(SkGlyph* glyph) {
     fProxy->getMetrics(glyph);
 
     SkVector advance;
-    fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
-                  SkFixedToScalar(glyph->fAdvanceY), &advance);
-    glyph->fAdvanceX = SkScalarToFixed(advance.fX);
-    glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+    fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+                  SkFloatToScalar(glyph->fAdvanceY), &advance);
+    glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+    glyph->fAdvanceY = SkScalarToFloat(advance.fY);
 
     SkPath path;
     fProxy->getPath(*glyph, &path);
diff --git a/src/fonts/SkTestScalerContext.cpp b/src/fonts/SkTestScalerContext.cpp
index 7afe6521a3..600e2de609 100644
--- a/src/fonts/SkTestScalerContext.cpp
+++ b/src/fonts/SkTestScalerContext.cpp
@@ -120,7 +120,8 @@ SkTestTypeface::SkTestTypeface(SkTestFont* testFont, const SkFontStyle& style)
 }
 
 void SkTestTypeface::getAdvance(SkGlyph* glyph) {
-    glyph->fAdvanceX = fTestFont->fWidths[glyph->getGlyphID()];
+    // TODO(benjaminwagner): Update users to use floats.
+    glyph->fAdvanceX = SkFixedToFloat(fTestFont->fWidths[glyph->getGlyphID()]);
     glyph->fAdvanceY = 0;
 }
 
@@ -129,7 +130,8 @@ void SkTestTypeface::getFontMetrics(SkPaint::FontMetrics* metrics) {
 }
 
 void SkTestTypeface::getMetrics(SkGlyph* glyph) {
-    glyph->fAdvanceX = fTestFont->fWidths[glyph->getGlyphID()];
+    // TODO(benjaminwagner): Update users to use floats.
+    glyph->fAdvanceX = SkFixedToFloat(fTestFont->fWidths[glyph->getGlyphID()]);
     glyph->fAdvanceY = 0;
 }
 
@@ -206,19 +208,19 @@ protected:
     void generateAdvance(SkGlyph* glyph) override {
         fFace->getAdvance(glyph);
 
-        const SkVector advance = fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
-                                               SkFixedToScalar(glyph->fAdvanceY));
-        glyph->fAdvanceX = SkScalarToFixed(advance.fX);
-        glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+        const SkVector advance = fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+                                               SkFloatToScalar(glyph->fAdvanceY));
+        glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+        glyph->fAdvanceY = SkScalarToFloat(advance.fY);
     }
 
     void generateMetrics(SkGlyph* glyph) override {
         fFace->getMetrics(glyph);
 
-        const SkVector advance = fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
-                                               SkFixedToScalar(glyph->fAdvanceY));
-        glyph->fAdvanceX = SkScalarToFixed(advance.fX);
-        glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+        const SkVector advance = fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+                                               SkFloatToScalar(glyph->fAdvanceY));
+        glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+        glyph->fAdvanceY = SkScalarToFloat(advance.fY);
 
         SkPath path;
         fFace->getPath(*glyph, &path);
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp
index 661f22512d..4c2a615a66 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.cpp
+++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp
@@ -457,8 +457,8 @@ void GrStencilAndCoverTextContext::TextRun::setText(const char text[], size_t by
 
     // Measure first if needed.
     if (fFont.getTextAlign() != SkPaint::kLeft_Align) {
-        SkFixed    stopX = 0;
-        SkFixed    stopY = 0;
+        SkScalar   stopX = 0;
+        SkScalar   stopY = 0;
 
         const char* textPtr = text;
         while (textPtr < stop) {
@@ -466,13 +466,13 @@ void GrStencilAndCoverTextContext::TextRun::setText(const char text[], size_t by
             // same advance.
             const SkGlyph& glyph = glyphCacheProc(glyphCache, &textPtr);
 
-            stopX += glyph.fAdvanceX;
-            stopY += glyph.fAdvanceY;
+            stopX += SkFloatToScalar(glyph.fAdvanceX);
+            stopY += SkFloatToScalar(glyph.fAdvanceY);
         }
         SkASSERT(textPtr == stop);
 
-        SkScalar alignX = SkFixedToScalar(stopX) * fTextRatio;
-        SkScalar alignY = SkFixedToScalar(stopY) * fTextRatio;
+        SkScalar alignX = stopX * fTextRatio;
+        SkScalar alignY = stopY * fTextRatio;
 
         if (fFont.getTextAlign() == SkPaint::kCenter_Align) {
             alignX = SkScalarHalf(alignX);
@@ -485,21 +485,16 @@ void GrStencilAndCoverTextContext::TextRun::setText(const char text[], size_t by
 
     SkAutoKern autokern;
 
-    SkFixed fixedSizeRatio = SkScalarToFixed(fTextRatio);
-
-    SkFixed fx = SkScalarToFixed(x);
-    SkFixed fy = SkScalarToFixed(y);
     FallbackBlobBuilder fallback;
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(glyphCache, &text);
-        fx += SkFixedMul(autokern.adjust(glyph), fixedSizeRatio);
+        x += autokern.adjust(glyph) * fTextRatio;
         if (glyph.fWidth) {
-            this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)),
-                              &fallback);
+            this->appendGlyph(glyph, SkPoint::Make(x, y), &fallback);
         }
 
-        fx += SkFixedMul(glyph.fAdvanceX, fixedSizeRatio);
-        fy += SkFixedMul(glyph.fAdvanceY, fixedSizeRatio);
+        x += SkFloatToScalar(glyph.fAdvanceX) * fTextRatio;
+        y += SkFloatToScalar(glyph.fAdvanceY) * fTextRatio;
     }
 
     fFallbackTextBlob.reset(fallback.buildIfNeeded(&fFallbackGlyphCount));
diff --git a/src/gpu/text/GrTextUtils.cpp b/src/gpu/text/GrTextUtils.cpp
index edf813dcc0..0b26c84168 100644
--- a/src/gpu/text/GrTextUtils.cpp
+++ b/src/gpu/text/GrTextUtils.cpp
@@ -267,12 +267,12 @@ void GrTextUtils::DrawDFText(GrAtlasTextBlob* blob, int runIndex,
     SkTArray<SkScalar> positions;
 
     const char* textPtr = text;
-    SkFixed stopX = 0;
-    SkFixed stopY = 0;
-    SkFixed origin = 0;
+    SkScalar stopX = 0;
+    SkScalar stopY = 0;
+    SkScalar origin = 0;
     switch (skPaint.getTextAlign()) {
-        case SkPaint::kRight_Align: origin = SK_Fixed1; break;
-        case SkPaint::kCenter_Align: origin = SK_FixedHalf; break;
+        case SkPaint::kRight_Align: origin = SK_Scalar1; break;
+        case SkPaint::kCenter_Align: origin = SK_ScalarHalf; break;
         case SkPaint::kLeft_Align: origin = 0; break;
     }
 
@@ -283,11 +283,11 @@ void GrTextUtils::DrawDFText(GrAtlasTextBlob* blob, int runIndex,
         // same advance
         const SkGlyph& glyph = glyphCacheProc(origPaintCache, &textPtr);
 
-        SkFixed width = glyph.fAdvanceX + autokern.adjust(glyph);
-        positions.push_back(SkFixedToScalar(stopX + SkFixedMul(origin, width)));
+        SkScalar width = SkFloatToScalar(glyph.fAdvanceX) + autokern.adjust(glyph);
+        positions.push_back(stopX + origin * width);
 
-        SkFixed height = glyph.fAdvanceY;
-        positions.push_back(SkFixedToScalar(stopY + SkFixedMul(origin, height)));
+        SkScalar height = SkFloatToScalar(glyph.fAdvanceY);
+        positions.push_back(stopY + origin * height);
 
         stopX += width;
         stopY += height;
@@ -297,8 +297,8 @@ void GrTextUtils::DrawDFText(GrAtlasTextBlob* blob, int runIndex,
     SkGlyphCache::AttachCache(origPaintCache);
 
     // now adjust starting point depending on alignment
-    SkScalar alignX = SkFixedToScalar(stopX);
-    SkScalar alignY = SkFixedToScalar(stopY);
+    SkScalar alignX = stopX;
+    SkScalar alignY = stopY;
     if (skPaint.getTextAlign() == SkPaint::kCenter_Align) {
         alignX = SkScalarHalf(alignX);
         alignY = SkScalarHalf(alignY);
@@ -387,8 +387,8 @@ void GrTextUtils::DrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
                 SkScalar x = offset.x() + pos[0];
                 SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
 
-                SkScalar advanceX = SkFixedToScalar(glyph.fAdvanceX) * alignMul * textRatio;
-                SkScalar advanceY = SkFixedToScalar(glyph.fAdvanceY) * alignMul * textRatio;
+                SkScalar advanceX = SkFloatToScalar(glyph.fAdvanceX) * alignMul * textRatio;
+                SkScalar advanceY = SkFloatToScalar(glyph.fAdvanceY) * alignMul * textRatio;
 
                 if (!DfAppendGlyph(blob,
                                    runIndex,
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 9ab3b0d7e0..0054143a9a 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -95,26 +95,24 @@ static void align_text(SkPaint::GlyphCacheProc glyphCacheProc, const SkPaint& pa
 
     const char* start = reinterpret_cast<const char*>(glyphs);
     const char* stop = reinterpret_cast<const char*>(glyphs + len);
-    SkFixed xAdv = 0, yAdv = 0;
+    SkScalar xAdv = 0, yAdv = 0;
 
     // TODO(vandebo): This probably needs to take kerning into account.
     while (start < stop) {
         const SkGlyph& glyph = glyphCacheProc(cache, &start);
-        xAdv += glyph.fAdvanceX;
-        yAdv += glyph.fAdvanceY;
+        xAdv += SkFloatToScalar(glyph.fAdvanceX);
+        yAdv += SkFloatToScalar(glyph.fAdvanceY);
     };
     if (paint.getTextAlign() == SkPaint::kLeft_Align) {
         return;
     }
 
-    SkScalar xAdj = SkFixedToScalar(xAdv);
-    SkScalar yAdj = SkFixedToScalar(yAdv);
     if (paint.getTextAlign() == SkPaint::kCenter_Align) {
-        xAdj = SkScalarHalf(xAdj);
-        yAdj = SkScalarHalf(yAdj);
+        xAdv = SkScalarHalf(xAdv);
+        yAdv = SkScalarHalf(yAdv);
     }
-    *x = *x - xAdj;
-    *y = *y - yAdj;
+    *x = *x - xAdv;
+    *y = *y - yAdv;
 }
 
 static int max_glyphid_for_typeface(SkTypeface* typeface) {
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index 27b5a4518a..cc84a67f70 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -1343,13 +1343,13 @@ bool SkPDFType3Font::populate(uint16_t glyphID) {
         encDiffs->appendName(characterName.c_str());
 
         const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
-        widthArray->appendScalar(SkFixedToScalar(glyph.fAdvanceX));
+        widthArray->appendScalar(SkFloatToScalar(glyph.fAdvanceX));
         SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
                                               glyph.fWidth, glyph.fHeight);
         bbox.join(glyphBBox);
 
         SkDynamicMemoryWStream content;
-        setGlyphWidthAndBoundingBox(SkFixedToScalar(glyph.fAdvanceX), glyphBBox,
+        setGlyphWidthAndBoundingBox(SkFloatToScalar(glyph.fAdvanceX), glyphBBox,
                                     &content);
         const SkPath* path = cache->findPath(glyph);
         if (path) {
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index e7cb6d2963..5c00d1b697 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -1006,6 +1006,10 @@ SkUnichar SkScalerContext_FreeType::generateGlyphToChar(uint16_t glyph) {
     return 0;
 }
 
+static SkScalar SkFT_FixedToScalar(FT_Fixed x) {
+  return SkFixedToScalar(x);
+}
+
 void SkScalerContext_FreeType::generateAdvance(SkGlyph* glyph) {
    /* unhinted and light hinted text have linearly scaled advances
     * which are very cheap to compute with some font formats...
@@ -1027,8 +1031,9 @@ void SkScalerContext_FreeType::generateAdvance(SkGlyph* glyph) {
         if (0 == error) {
             glyph->fRsbDelta = 0;
             glyph->fLsbDelta = 0;
-            glyph->fAdvanceX = SkFixedMul(fMatrix22.xx, advance);
-            glyph->fAdvanceY = - SkFixedMul(fMatrix22.yx, advance);
+            const SkScalar advanceScalar = SkFT_FixedToScalar(advance);
+            glyph->fAdvanceX = SkScalarToFloat(fMatrix22Scalar.getScaleX() * advanceScalar);
+            glyph->fAdvanceY = -SkScalarToFloat(fMatrix22Scalar.getSkewY() * advanceScalar);
             return;
         }
     }
@@ -1108,9 +1113,9 @@ inline void scaleGlyphMetrics(SkGlyph& glyph, SkScalar scale) {
     glyph.fTop *= scale;
     glyph.fLeft *= scale;
 
-    SkFixed fixedScale = SkScalarToFixed(scale);
-    glyph.fAdvanceX = SkFixedMul(glyph.fAdvanceX, fixedScale);
-    glyph.fAdvanceY = SkFixedMul(glyph.fAdvanceY, fixedScale);
+    float floatScale = SkScalarToFloat(scale);
+    glyph.fAdvanceX *= floatScale;
+    glyph.fAdvanceY *= floatScale;
 }
 
 void SkScalerContext_FreeType::generateMetrics(SkGlyph* glyph) {
@@ -1181,19 +1186,21 @@ void SkScalerContext_FreeType::generateMetrics(SkGlyph* glyph) {
 
     if (fRec.fFlags & SkScalerContext::kVertical_Flag) {
         if (fDoLinearMetrics) {
-            glyph->fAdvanceX = -SkFixedMul(fMatrix22.xy, fFace->glyph->linearVertAdvance);
-            glyph->fAdvanceY = SkFixedMul(fMatrix22.yy, fFace->glyph->linearVertAdvance);
+            const SkScalar advanceScalar = SkFT_FixedToScalar(fFace->glyph->linearVertAdvance);
+            glyph->fAdvanceX = -SkScalarToFloat(fMatrix22Scalar.getSkewX() * advanceScalar);
+            glyph->fAdvanceY = SkScalarToFloat(fMatrix22Scalar.getScaleY() * advanceScalar);
         } else {
-            glyph->fAdvanceX = -SkFDot6ToFixed(fFace->glyph->advance.x);
-            glyph->fAdvanceY = SkFDot6ToFixed(fFace->glyph->advance.y);
+            glyph->fAdvanceX = -SkFDot6ToFloat(fFace->glyph->advance.x);
+            glyph->fAdvanceY = SkFDot6ToFloat(fFace->glyph->advance.y);
         }
     } else {
         if (fDoLinearMetrics) {
-            glyph->fAdvanceX = SkFixedMul(fMatrix22.xx, fFace->glyph->linearHoriAdvance);
-            glyph->fAdvanceY = -SkFixedMul(fMatrix22.yx, fFace->glyph->linearHoriAdvance);
+            const SkScalar advanceScalar = SkFT_FixedToScalar(fFace->glyph->linearHoriAdvance);
+            glyph->fAdvanceX = SkScalarToFloat(fMatrix22Scalar.getScaleX() * advanceScalar);
+            glyph->fAdvanceY = -SkScalarToFloat(fMatrix22Scalar.getSkewY() * advanceScalar);
         } else {
-            glyph->fAdvanceX = SkFDot6ToFixed(fFace->glyph->advance.x);
-            glyph->fAdvanceY = -SkFDot6ToFixed(fFace->glyph->advance.y);
+            glyph->fAdvanceX = SkFDot6ToFloat(fFace->glyph->advance.x);
+            glyph->fAdvanceY = -SkFDot6ToFloat(fFace->glyph->advance.y);
 
             if (fRec.fFlags & kDevKernText_Flag) {
                 glyph->fRsbDelta = SkToS8(fFace->glyph->rsb_delta);
diff --git a/src/ports/SkFontHost_mac.cpp b/src/ports/SkFontHost_mac.cpp
index f47add0818..98eeaec09a 100644
--- a/src/ports/SkFontHost_mac.cpp
+++ b/src/ports/SkFontHost_mac.cpp
@@ -277,13 +277,22 @@ static CGFloat ScalarToCG(SkScalar scalar) {
 
 static SkScalar CGToScalar(CGFloat cgFloat) {
     if (sizeof(CGFloat) == sizeof(float)) {
-        return cgFloat;
+        return SkFloatToScalar(cgFloat);
     } else {
         SkASSERT(sizeof(CGFloat) == sizeof(double));
         return SkDoubleToScalar(cgFloat);
     }
 }
 
+static float CGToFloat(CGFloat cgFloat) {
+    if (sizeof(CGFloat) == sizeof(float)) {
+        return cgFloat;
+    } else {
+        SkASSERT(sizeof(CGFloat) == sizeof(double));
+        return static_cast<float>(cgFloat);
+    }
+}
+
 static CGAffineTransform MatrixToCGAffineTransform(const SkMatrix& matrix,
                                                    SkScalar sx = SK_Scalar1,
                                                    SkScalar sy = SK_Scalar1) {
@@ -1054,8 +1063,8 @@ void SkScalerContext_Mac::generateMetrics(SkGlyph* glyph) {
                                    &cgGlyph, &cgAdvance, 1);
     }
     cgAdvance = CGSizeApplyAffineTransform(cgAdvance, fTransform);
-    glyph->fAdvanceX =  SkFloatToFixed_Check(cgAdvance.width);
-    glyph->fAdvanceY = -SkFloatToFixed_Check(cgAdvance.height);
+    glyph->fAdvanceX =  CGToFloat(cgAdvance.width);
+    glyph->fAdvanceY = -CGToFloat(cgAdvance.height);
 
     // The following produces skBounds in SkGlyph units (pixels, y down),
     // or returns early if skBounds would be empty.
diff --git a/src/ports/SkFontHost_win.cpp b/src/ports/SkFontHost_win.cpp
index 8aefd1431a..f772d8c57e 100644
--- a/src/ports/SkFontHost_win.cpp
+++ b/src/ports/SkFontHost_win.cpp
@@ -584,6 +584,10 @@ static FIXED float2FIXED(float x) {
     return SkFixedToFIXED(SkFloatToFixed(x));
 }
 
+static inline float FIXED2float(FIXED x) {
+    return SkFixedToFloat(SkFIXEDToFixed(x));
+}
+
 static BYTE compute_quality(const SkScalerContext::Rec& rec) {
     switch (rec.fMaskFormat) {
         case SkMask::kBW_Format:
@@ -856,7 +860,7 @@ void SkScalerContext_GDI::generateMetrics(SkGlyph* glyph) {
         // Bitmap FON cannot underhang, but vector FON may.
         // There appears no means of determining underhang of vector FON.
         glyph->fLeft = SkToS16(0);
-        glyph->fAdvanceX = SkIntToFixed(glyph->fWidth);
+        glyph->fAdvanceX = glyph->fWidth;
         glyph->fAdvanceY = 0;
 
         // Vector FON will transform nicely, but bitmap FON do not.
@@ -876,8 +880,8 @@ void SkScalerContext_GDI::generateMetrics(SkGlyph* glyph) {
         }
 
         // Apply matrix to advance.
-        glyph->fAdvanceY = SkFixedMul(-SkFIXEDToFixed(fMat22.eM12), glyph->fAdvanceX);
-        glyph->fAdvanceX = SkFixedMul(SkFIXEDToFixed(fMat22.eM11), glyph->fAdvanceX);
+        glyph->fAdvanceY = -FIXED2float(fMat22.eM12) * glyph->fAdvanceX;
+        glyph->fAdvanceX *= FIXED2float(fMat22.eM11);
 
         return;
     }
@@ -922,8 +926,9 @@ void SkScalerContext_GDI::generateMetrics(SkGlyph* glyph) {
         glyph->fTop -= 2;
         glyph->fLeft -= 2;
     }
-    glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX);
-    glyph->fAdvanceY = SkIntToFixed(gm.gmCellIncY);
+    // TODO(benjaminwagner): What is the type of gm.gmCellInc[XY]?
+    glyph->fAdvanceX = (float)((int)gm.gmCellIncX);
+    glyph->fAdvanceY = (float)((int)gm.gmCellIncY);
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
 
@@ -933,16 +938,16 @@ void SkScalerContext_GDI::generateMetrics(SkGlyph* glyph) {
         if (GDI_ERROR != status) {
             SkPoint advance;
             fHiResMatrix.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
-            glyph->fAdvanceX = SkScalarToFixed(advance.fX);
-            glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+            glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+            glyph->fAdvanceY = SkScalarToFloat(advance.fY);
         }
     } else if (!isAxisAligned(this->fRec)) {
         status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, nullptr, &fGsA);
         if (GDI_ERROR != status) {
             SkPoint advance;
             fG_inv.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
-            glyph->fAdvanceX = SkScalarToFixed(advance.fX);
-            glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+            glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+            glyph->fAdvanceY = SkScalarToFloat(advance.fY);
         }
     }
 }
diff --git a/src/ports/SkScalerContext_win_dw.cpp b/src/ports/SkScalerContext_win_dw.cpp
index 097db865e1..f276762bbf 100644
--- a/src/ports/SkScalerContext_win_dw.cpp
+++ b/src/ports/SkScalerContext_win_dw.cpp
@@ -388,8 +388,8 @@ void SkScalerContext_DW::generateAdvance(SkGlyph* glyph) {
         fSkXform.mapVectors(vecs, SK_ARRAY_COUNT(vecs));
     }
 
-    glyph->fAdvanceX = SkScalarToFixed(vecs[0].fX);
-    glyph->fAdvanceY = SkScalarToFixed(vecs[0].fY);
+    glyph->fAdvanceX = SkScalarToFloat(vecs[0].fX);
+    glyph->fAdvanceY = SkScalarToFloat(vecs[0].fY);
 }
 
 HRESULT SkScalerContext_DW::getBoundingBox(SkGlyph* glyph,