Allow setting of GrBatchFontCache atlas sizes

src/gpu/GrBatchFontCache.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 "GrBatchFontCache.h"
 #include "GrContext.h"
-#include "GrFontAtlasSizes.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrResourceProvider.h"
 #include "GrSurfacePriv.h"
 #include "SkString.h"
 
 #include "SkDistanceFieldGen.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrBatchFontCache::initAtlas(GrMaskFormat format) {
     int index = MaskFormatToAtlasIndex(format);
     if (!fAtlases[index]) {
         GrPixelConfig config = MaskFormatToPixelConfig(format);
-        int width = GR_FONT_ATLAS_TEXTURE_WIDTH;
-        int height = GR_FONT_ATLAS_TEXTURE_HEIGHT;
-        int numPlotsX = GR_FONT_ATLAS_NUM_PLOTS_X;
-        int numPlotsY = GR_FONT_ATLAS_NUM_PLOTS_Y;
+        int width = fAtlasConfigs[index].fWidth;
+        int height = fAtlasConfigs[index].fHeight;
+        int numPlotsX = fAtlasConfigs[index].numPlotsX();
+        int numPlotsY = fAtlasConfigs[index].numPlotsY();
 
-        if (kA8_GrMaskFormat == format) {
-            width = GR_FONT_ATLAS_A8_TEXTURE_WIDTH;
-            numPlotsX = GR_FONT_ATLAS_A8_NUM_PLOTS_X;
-        }
         fAtlases[index] =
                 fContext->resourceProvider()->createAtlas(config, width, height,
                                                           numPlotsX, numPlotsY,
                                                           &GrBatchFontCache::HandleEviction,
                                                           (void*)this);
         if (!fAtlases[index]) {
             return false;
         }
     }
     return true;
 }
 
 GrBatchFontCache::GrBatchFontCache(GrContext* context)
     : fContext(context)
     , fPreserveStrike(NULL) {
     for (int i = 0; i < kMaskFormatCount; ++i) {
         fAtlases[i] = NULL;
     }
+
+    // setup default atlas configs
+    fAtlasConfigs[kA8_GrMaskFormat].fWidth = 2048;
+    fAtlasConfigs[kA8_GrMaskFormat].fHeight = 2048;
+    fAtlasConfigs[kA8_GrMaskFormat].fPlotWidth = 512;
+    fAtlasConfigs[kA8_GrMaskFormat].fPlotHeight = 256;
+
+    fAtlasConfigs[kA565_GrMaskFormat].fWidth = 1024;
+    fAtlasConfigs[kA565_GrMaskFormat].fHeight = 2048;
+    fAtlasConfigs[kA565_GrMaskFormat].fPlotWidth = 256;
+    fAtlasConfigs[kA565_GrMaskFormat].fPlotHeight = 256;
+
+    fAtlasConfigs[kARGB_GrMaskFormat].fWidth = 1024;
+    fAtlasConfigs[kARGB_GrMaskFormat].fHeight = 2048;
+    fAtlasConfigs[kARGB_GrMaskFormat].fPlotWidth = 256;
+    fAtlasConfigs[kARGB_GrMaskFormat].fPlotHeight = 256;
 }
 
 GrBatchFontCache::~GrBatchFontCache() {
     SkTDynamicHash<GrBatchTextStrike, GrFontDescKey>::Iter iter(&fCache);
     while (!iter.done()) {
         (*iter).fIsAbandoned = true;
         (*iter).unref();
         ++iter;
     }
     for (int i = 0; i < kMaskFormatCount; ++i) {
@@ skipping 45 matching lines @@
 #else
                 filename.printf("fontcache_%d%d.png", gDumpCount, i);
 #endif
                 texture->surfacePriv().savePixels(filename.c_str());
             }
         }
     }
     ++gDumpCount;
 }
 
+void GrBatchFontCache::setAtlasSizes_ForTesting(const GrBatchAtlasConfig configs[3]) {
+    // delete any old atlases, this should be safe to do as long as we are not in the middle of a
+    // flush
+    for (int i = 0; i < kMaskFormatCount; i++) {
+        if (fAtlases[i]) {
+            SkDELETE(fAtlases[i]);
+            fAtlases[i] = NULL;
+        }
+    }
+    memcpy(fAtlasConfigs, configs, sizeof(fAtlasConfigs));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
     The text strike is specific to a given font/style/matrix setup, which is
     represented by the GrHostFontScaler object we are given in getGlyph().
 
     We map a 32bit glyphID to a GrGlyph record, which in turn points to a
     atlas and a position within that texture.
  */
 
@@ skipping 75 matching lines @@
 
     bool success = fBatchFontCache->addToAtlas(this, &glyph->fID, target, expectedMaskFormat,
                                                glyph->width(), glyph->height(),
                                                storage.get(), &glyph->fAtlasLocation);
     if (success) {
         SkASSERT(GrBatchAtlas::kInvalidAtlasID != glyph->fID);
         fAtlasedGlyphs++;
     }
     return success;
 }