Revert of Use uint16s for texture coordinates when rendering text.

src/gpu/GrFontCache.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrFontCache.h"
-#include "GrFontAtlasSizes.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrSurfacePriv.h"
 #include "SkString.h"
 
 #include "SkDistanceFieldGen.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#define GR_ATLAS_TEXTURE_WIDTH 1024
+#define GR_ATLAS_TEXTURE_HEIGHT 2048
+
+#define GR_PLOT_WIDTH  256
+#define GR_PLOT_HEIGHT 256
+
+#define GR_NUM_PLOTS_X   (GR_ATLAS_TEXTURE_WIDTH / GR_PLOT_WIDTH)
+#define GR_NUM_PLOTS_Y   (GR_ATLAS_TEXTURE_HEIGHT / GR_PLOT_HEIGHT)
+
 #define FONT_CACHE_STATS 0
 #if FONT_CACHE_STATS
 static int g_PurgeCount = 0;
 #endif
 
 GrFontCache::GrFontCache(GrGpu* gpu) : fGpu(gpu) {
     gpu->ref();
     for (int i = 0; i < kAtlasCount; ++i) {
         fAtlases[i] = NULL;
     }
@@ skipping 77 matching lines @@
     delete strike;
 }
 
 
 GrPlot* GrFontCache::addToAtlas(GrMaskFormat format, GrAtlas::ClientPlotUsage* usage,
                                 int width, int height, const void* image,
                                 SkIPoint16* loc) {
     GrPixelConfig config = mask_format_to_pixel_config(format);
     int atlasIndex = mask_format_to_atlas_index(format);
     if (NULL == fAtlases[atlasIndex]) {
-        SkISize textureSize = SkISize::Make(GR_FONT_ATLAS_TEXTURE_WIDTH,
-                                            GR_FONT_ATLAS_TEXTURE_HEIGHT);
+        SkISize textureSize = SkISize::Make(GR_ATLAS_TEXTURE_WIDTH,
+                                            GR_ATLAS_TEXTURE_HEIGHT);
         fAtlases[atlasIndex] = SkNEW_ARGS(GrAtlas, (fGpu, config, kNone_GrSurfaceFlags,
                                                     textureSize,
-                                                    GR_FONT_ATLAS_NUM_PLOTS_X,
-                                                    GR_FONT_ATLAS_NUM_PLOTS_Y,
+                                                    GR_NUM_PLOTS_X,
+                                                    GR_NUM_PLOTS_Y,
                                                     true));
     }
     return fAtlases[atlasIndex]->addToAtlas(usage, width, height, image, loc);
 }
 
 
 bool GrFontCache::freeUnusedPlot(GrTextStrike* preserveStrike, const GrGlyph* glyph) {
     SkASSERT(preserveStrike);
 
     int index = mask_format_to_atlas_index(glyph->fMaskFormat);
@@ skipping 142 matching lines @@
         ++iter;
     }
 
     GrAtlas::RemovePlot(&fPlotUsage, plot);
 }
 
 bool GrTextStrike::glyphTooLargeForAtlas(GrGlyph* glyph) {
     int width = glyph->fBounds.width();
     int height = glyph->fBounds.height();
     int pad = fUseDistanceField ? 2 * SK_DistanceFieldPad : 0;
-    if (width + pad > GR_FONT_ATLAS_PLOT_WIDTH) {
+    if (width + pad > GR_PLOT_WIDTH) {
         return true;
     }
-    if (height + pad > GR_FONT_ATLAS_PLOT_HEIGHT) {
+    if (height + pad > GR_PLOT_HEIGHT) {
         return true;
     }
 
     return false;
 }
 
 bool GrTextStrike::addGlyphToAtlas(GrGlyph* glyph, GrFontScaler* scaler) {
 #if 0   // testing hack to force us to flush our cache often
     static int gCounter;
     if ((++gCounter % 10) == 0) return false;
@@ skipping 30 matching lines @@
                                           glyph->width(), glyph->height(),
                                           storage.get(), &glyph->fAtlasLocation);
 
     if (NULL == plot) {
         return false;
     }
 
     glyph->fPlot = plot;
     return true;
 }