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

src/gpu/text/GrTextUtils.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextUtils.h"
 
 #include "GrAtlasTextBlob.h"
@@ skipping 249 matching lines @@
 
     SkPaint::GlyphCacheProc glyphCacheProc = skPaint.getGlyphCacheProc(true);
     SkAutoDescriptor desc;
     skPaint.getScalerContextDescriptor(&desc, props, SkPaint::FakeGamma::Off, nullptr);
     SkGlyphCache* origPaintCache = SkGlyphCache::DetachCache(skPaint.getTypeface(),
                                                              desc.getDesc());
 
     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;
     }
 
     SkAutoKern autokern;
     const char* stop = text + byteLength;
     while (textPtr < stop) {
         // don't need x, y here, since all subpixel variants will have the
         // 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;
     }
     SkASSERT(textPtr == stop);
 
     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);
     } else if (skPaint.getTextAlign() == SkPaint::kLeft_Align) {
         alignX = 0;
         alignY = 0;
     }
     x -= alignX;
     y -= alignY;
     SkPoint offset = SkPoint::Make(x, y);
@@ skipping 68 matching lines @@
                                                                              : SK_Scalar1;
         while (text < stop) {
             const char* lastText = text;
             // the last 2 parameters are ignored
             const SkGlyph& glyph = glyphCacheProc(cache, &text);
 
             if (glyph.fWidth) {
                 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,
                                    fontCache,
                                    &currStrike,
                                    glyph,
                                    x - advanceX, y - advanceY, color,
                                    fontScaler,
                                    textRatio,
                                    viewMatrix)) {
@@ skipping 173 matching lines @@
     if (cache->getAuxProcData(glyph_cache_aux_proc, &auxData)) {
         scaler = (GrFontScaler*)auxData;
     }
     if (nullptr == scaler) {
         scaler = new GrFontScaler(cache);
         cache->setAuxProc(glyph_cache_aux_proc, scaler);
     }
 
     return scaler;
 }