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

src/core/SkFindAndPlaceGlyph.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkFindAndPositionGlyph_DEFINED
 #define SkFindAndPositionGlyph_DEFINED
 
@@ skipping 329 matching lines @@
 
     typedef PolymorphicVariant<
         MapperInterface, TranslationMapper, XScaleMapper, GeneralMapper> Mapper;
 
     // TextAlignmentAdjustment handles shifting the glyph based on its width.
     static SkPoint TextAlignmentAdjustment(SkPaint::Align textAlignment, const SkGlyph& glyph) {
         switch (textAlignment) {
             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.");
         return {0.0f, 0.0f};
     }
 
     // The "call" to SkFixedToScalar is actually a macro. It's macros all the way down.
     // Needs to be a macro because you can't have a const float unless you make it constexpr.
     #define kSubpixelRounding (SkFixedToScalar(SkGlyph::kSubpixelRound))
 
@@ skipping 75 matching lines @@
             if (kTextAlignment != SkPaint::kLeft_Align) {
                 // Get the width of an un-sub-pixel positioned glyph for calculating the
                 // alignment. This is not needed for kLeftAlign because its adjustment is
                 // always {0, 0}.
                 const char* tempText = *text;
                 const SkGlyph &metricGlyph = fGlyphFinder->lookupGlyph(&tempText);
 
                 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.
                 finalPosition -= TextAlignmentAdjustment(kTextAlignment, metricGlyph);
             }
 
             // Find the glyph.
             SkIPoint lookupPosition = SubpixelAlignment(kAxisAlignment, finalPosition);
             const SkGlyph& renderGlyph =
                 fGlyphFinder->lookupGlyphXY(text, lookupPosition.fX, lookupPosition.fY);
 
             // If the glyph has no width (no pixels) then don't bother processing it.
             if (renderGlyph.fWidth > 0) {
                 processOneGlyph(renderGlyph, finalPosition,
                                 SubpixelPositionRounding(kAxisAlignment));
             }
-            return finalPosition + SkPoint{SkFixedToScalar(renderGlyph.fAdvanceX),
-                                           SkFixedToScalar(renderGlyph.fAdvanceY)};
+            return finalPosition + SkPoint{SkFloatToScalar(renderGlyph.fAdvanceX),
+                                           SkFloatToScalar(renderGlyph.fAdvanceY)};
         }
 
     private:
         LookupGlyph& fGlyphFinder;
     };
 
     enum SelectKerning {
         kNoKerning = false,
         kUseKerning = true
     };
@@ skipping 10 matching lines @@
             // Kerning can only be used with SkPaint::kLeft_Align
             static_assert(!kUseKerning || SkPaint::kLeft_Align == kTextAlignment,
                           "Kerning can only be used with left aligned text.");
         }
 
         SkPoint findAndPositionGlyph(
             const char** text, SkPoint position, ProcessOneGlyph&& processOneGlyph) override {
             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:
         LookupGlyph& fGlyphFinder;
 
         SkAutoKern fAutoKern;
     };
 
     // GlyphFindAndPlace is a large variant that encapsulates the multiple types of finding and
     // placing a glyph. There are three factors that go into the different factors.
@@ skipping 39 matching lines @@
                     ProcessOneGlyph, kTextAlignment, kNone_SkAxisAlignment>>(glyphFinder);
                 break;
             case kY_SkAxisAlignment:
                 to_init->template initialize<GlyphFindAndPlaceSubpixel<
                     ProcessOneGlyph, kTextAlignment, kY_SkAxisAlignment>>(glyphFinder);
                 break;
         }
     }
 
     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;
 
         while (text < stop) {
             // don't need x, y here, since all subpixel variants will have the
             // 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};
     }
 };
 
 template<typename ProcessOneGlyph>
 inline void SkFindAndPlaceGlyph::ProcessPosText(
     SkPaint::TextEncoding textEncoding, const char text[], size_t byteLength,
     SkPoint offset, const SkMatrix& matrix, const SkScalar pos[], int scalarsPerPosition,
     SkPaint::Align textAlignment,
     SkGlyphCache* cache, ProcessOneGlyph&& processOneGlyph) {
 
@@ skipping 135 matching lines @@
     SkPoint current = offset;
     while (text < stop) {
         current =
             findAndPosition->findAndPositionGlyph(
                 &text, current, std::forward<ProcessOneGlyph>(processOneGlyph));
 
     }
 }
 
 #endif  // SkFindAndPositionGlyph_DEFINED