Keep Big Glyph coordinates in float in GrAtlasTextContext

src/gpu/GrAtlasTextContext.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 "GrAtlasTextContext.h"
 
 #include "GrBatch.h"
 #include "GrBatchFontCache.h"
@@ skipping 1237 matching lines @@
     // We could store the cliprect in the key, but then we'd lose the ability to do integer scrolls
     // TODO verify this
     // check if we clipped out
     if (clipRect.quickReject(x, y, x + width, y + height)) {
         return;
     }
 #endif
 
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
-        this->appendGlyphPath(blob, glyph, scaler, vx, vy);
+        this->appendGlyphPath(blob, glyph, scaler, SkIntToScalar(vx), SkIntToScalar(vy));
         return;
     }
 
     GrMaskFormat format = glyph->fMaskFormat;
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
     if (run.fInitialized && subRun->fMaskFormat != format) {
         subRun = &run.fSubRunInfo.push_back();
     }
 
@@ skipping 55 matching lines @@
                              SkScalarTruncToInt(dstRect.top()),
                              SkScalarTruncToInt(dstRect.right()),
                              SkScalarTruncToInt(dstRect.bottom()))) {
         return true;
     }
 #endif
 
     // TODO combine with the above
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
-        this->appendGlyphPath(blob, glyph, scaler, SkScalarRoundToInt(sx - dx),
-                                                   SkScalarRoundToInt(sy - dy));
+        this->appendGlyphPath(blob, glyph, scaler, sx - dx, sy - dy);
         return true;
     }
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
     SkASSERT(glyph->fMaskFormat == kA8_GrMaskFormat);
     subRun->fMaskFormat = kA8_GrMaskFormat;
 
     size_t vertexStride = get_vertex_stride_df(kA8_GrMaskFormat, subRun->fUseLCDText);
 
     bool useColorVerts = !subRun->fUseLCDText;
     this->appendGlyphCommon(blob, &run, subRun, glyphRect, color, vertexStride, useColorVerts,
                             glyph);
     return true;
 }
 
 inline void GrAtlasTextContext::appendGlyphPath(BitmapTextBlob* blob, GrGlyph* glyph,
-                                                GrFontScaler* scaler, int x, int y) {
+                                                GrFontScaler* scaler, SkScalar x, SkScalar y) {
     if (NULL == glyph->fPath) {
         SkPath* path = SkNEW(SkPath);
         if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
             // flag the glyph as being dead?
             SkDELETE(path);
             return;
         }
         glyph->fPath = path;
     }
     SkASSERT(glyph->fPath);
@@ skipping 780 matching lines @@
         target->drawBatch(pipelineBuilder, batch);
     }
 }
 
 inline void GrAtlasTextContext::flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget* rt,
                                                const SkPaint& skPaint,
                                                SkScalar transX, SkScalar transY,
                                                const SkIRect& clipBounds) {
     for (int i = 0; i < cacheBlob->fBigGlyphs.count(); i++) {
         BitmapTextBlob::BigGlyph& bigGlyph = cacheBlob->fBigGlyphs[i];
-        bigGlyph.fVx += SkScalarTruncToInt(transX);
-        bigGlyph.fVy += SkScalarTruncToInt(transY);
+        bigGlyph.fVx += transX;
+        bigGlyph.fVy += transY;
         SkMatrix translate;
-        translate.setTranslate(SkIntToScalar(bigGlyph.fVx),
-                               SkIntToScalar(bigGlyph.fVy));
-        GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
+        translate.setTranslate(bigGlyph.fVx, bigGlyph.fVy);
         fGpuDevice->internalDrawPath(bigGlyph.fPath, skPaint, SkMatrix::I(), &translate, clipBounds,
                                      false);
     }
 }
 
 void GrAtlasTextContext::flush(GrDrawTarget* target,
                                const SkTextBlob* blob,
                                BitmapTextBlob* cacheBlob,
                                GrRenderTarget* rt,
                                const SkPaint& skPaint,
@@ skipping 102 matching lines @@
             gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextContext::BitmapTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif