Ensure only fractional floats are converted to SkFixed in SubpixelAlignment.

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 363 matching lines @@
                 return {kSubpixelRounding, kSubpixelRounding};
         }
         SkFAIL("Should not get here.");
         return {0.0f, 0.0f};
     }
 
     // The SubpixelAlignment function produces a suitable position for the glyph cache to
     // produce the correct sub-pixel alignment. If a position is aligned with an axis a shortcut
     // of 0 is used for the sub-pixel position.
     static SkIPoint SubpixelAlignment(SkAxisAlignment axisAlignment, SkPoint position) {
+        // Only the fractional part of position.fX and position.fY matter, because the result of
+        // this function will just be passed to FixedToSub.
         switch (axisAlignment) {
             case kX_SkAxisAlignment:
-                return {SkScalarToFixed(position.fX + kSubpixelRounding), 0};
+                return {SkScalarToFixed(SkScalarFraction(position.fX) + kSubpixelRounding), 0};

[bungeman-skia, 2016/03/10 20:55:58]

SkScalarFraction is currently really super slow. I'll see about speeding it up a
bit first... https://codereview.chromium.org/1783583003/

[dogben, 2016/03/10 21:16:22]

I maybe ought to always return positive numbers too. Or just return
SubpixelRound units.

[bungeman-skia, 2016/03/10 21:37:49]

Always returning positive numbers would just be extra work. I suppose if we had
SkSubpixelRound units we could save a shift since (in the big picture) we really
just want the fractional part * 2^SkGlyph::kSubBits as an int so we can
discretize. (These values are just passed along until they are shoved into a
call to SkGlyph::MakeID.) But that's more difficult to do.

             case kY_SkAxisAlignment:
-                return {0, SkScalarToFixed(position.fY + kSubpixelRounding)};
+                return {0, SkScalarToFixed(SkScalarFraction(position.fY) + kSubpixelRounding)};
             case kNone_SkAxisAlignment:
-                return {SkScalarToFixed(position.fX + kSubpixelRounding),
-                        SkScalarToFixed(position.fY + kSubpixelRounding)};
+                return {SkScalarToFixed(SkScalarFraction(position.fX) + kSubpixelRounding),
+                        SkScalarToFixed(SkScalarFraction(position.fY) + kSubpixelRounding)};
         }
         SkFAIL("Should not get here.");
         return {0, 0};
     }
 
     #undef kSubpixelRounding
 
     // GlyphFindAndPlaceInterface given the text and position finds the correct glyph and does
     // glyph specific position adjustment. The findAndPositionGlyph method takes text and
     // position and calls processOneGlyph with the correct glyph, final position and rounding
@@ skipping 323 matching lines @@
     SkPoint current = offset;
     while (text < stop) {
         current =
             findAndPosition->findAndPositionGlyph(
                 &text, current, std::forward<ProcessOneGlyph>(processOneGlyph));
 
     }
 }
 
 #endif  // SkFindAndPositionGlyph_DEFINED