Remove GrFontScaler class

src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextBlob.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 125 matching lines @@
         textureCoords[1] = (uint16_t)v0;
     }
 }
 
 template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs>
 void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target,
                                    GrBatchFontCache* fontCache,
                                    GrBlobRegenHelper *helper,
                                    Run* run,
                                    Run::SubRunInfo* info, SkGlyphCache** cache,
-                                   SkTypeface** typeface, GrFontScaler** scaler,
+                                   SkTypeface** typeface,
                                    const SkDescriptor** desc,
                                    int glyphCount, size_t vertexStride,
                                    GrColor color, SkScalar transX,
                                    SkScalar transY) const {
     static_assert(!regenGlyphs || regenTexCoords, "must regenTexCoords along regenGlyphs");
     GrBatchTextStrike* strike = nullptr;
     if (regenTexCoords) {
         info->resetBulkUseToken();
 
         // We can reuse if we have a valid strike and our descriptors / typeface are the
         // same.  The override descriptor is only for the non distance field text within
         // a run
         const SkDescriptor* newDesc = (run->fOverrideDescriptor && !info->drawAsDistanceFields()) ?
                                       run->fOverrideDescriptor->getDesc() :
                                       run->fDescriptor.getDesc();
         if (!*cache || !SkTypeface::Equal(*typeface, run->fTypeface) ||
             !(**desc == *newDesc)) {
             if (*cache) {
                 SkGlyphCache::AttachCache(*cache);
             }
             *desc = newDesc;
             *cache = SkGlyphCache::DetachCache(run->fTypeface, run->fEffects, *desc);
-            *scaler = GrTextUtils::GetGrFontScaler(*cache);
             *typeface = run->fTypeface;
         }
 
         if (regenGlyphs) {
-            strike = fontCache->getStrike(*scaler);
+            strike = fontCache->getStrike(*cache);
         } else {
             strike = info->strike();
         }
     }
 
     bool brokenRun = false;
     for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
         GrGlyph* glyph = nullptr;
         int log2Width = 0, log2Height = 0;
         if (regenTexCoords) {
             size_t glyphOffset = glyphIdx + info->glyphStartIndex();
 
             if (regenGlyphs) {
                 // Get the id from the old glyph, and use the new strike to lookup
                 // the glyph.
                 GrGlyph::PackedID id = fGlyphs[glyphOffset]->fPackedID;
-                fGlyphs[glyphOffset] = strike->getGlyph(id, info->maskFormat(), *scaler);
+                fGlyphs[glyphOffset] = strike->getGlyph(id, info->maskFormat(), *cache);
                 SkASSERT(id == fGlyphs[glyphOffset]->fPackedID);
             }
             glyph = fGlyphs[glyphOffset];
             SkASSERT(glyph && glyph->fMaskFormat == info->maskFormat());
 
             if (!fontCache->hasGlyph(glyph) &&
-                !strike->addGlyphToAtlas(target, glyph, *scaler, info->maskFormat())) {
+                !strike->addGlyphToAtlas(target, glyph, *cache, info->maskFormat())) {
                 helper->flush();
                 brokenRun = glyphIdx > 0;
 
                 SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(target,
                                                                     glyph,
-                                                                    *scaler,
+                                                                    *cache,
                                                                     info->maskFormat());
                 SkASSERT(success);
             }
             fontCache->addGlyphToBulkAndSetUseToken(info->bulkUseToken(), glyph,
                                                     target->nextDrawToken());
             log2Width = fontCache->log2Width(info->maskFormat());
             log2Height = fontCache->log2Height(info->maskFormat());
         }
 
         intptr_t vertex = reinterpret_cast<intptr_t>(fVertices);
@@ skipping 26 matching lines @@
     // combinations
         kRegenPosCol = kRegenPos | kRegenCol,
     kRegenPosTex = kRegenPos | kRegenTex,
     kRegenPosTexGlyph = kRegenPos | kRegenGlyph,
     kRegenPosColTex = kRegenPos | kRegenCol | kRegenTex,
     kRegenPosColTexGlyph = kRegenPos | kRegenCol | kRegenGlyph,
     kRegenColTex = kRegenCol | kRegenTex,
     kRegenColTexGlyph = kRegenCol | kRegenGlyph,
 };
 
-#define REGEN_ARGS target, fontCache, helper, &run, &info, cache, typeface, scaler, desc, \
+#define REGEN_ARGS target, fontCache, helper, &run, &info, cache, typeface, desc, \
                    *glyphCount, vertexStride, color, transX, transY
 
 void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target,
                                    GrBatchFontCache* fontCache,
                                    GrBlobRegenHelper *helper,
                                    int runIndex, int subRunIndex, SkGlyphCache** cache,
-                                   SkTypeface** typeface, GrFontScaler** scaler,
-                                   const SkDescriptor** desc, size_t vertexStride,
-                                   const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
-                                   GrColor color,
+                                   SkTypeface** typeface, const SkDescriptor** desc,
+                                   size_t vertexStride, const SkMatrix& viewMatrix,
+                                   SkScalar x, SkScalar y, GrColor color,
                                    void** vertices, size_t* byteCount, int* glyphCount) {
     Run& run = fRuns[runIndex];
     Run::SubRunInfo& info = run.fSubRunInfo[subRunIndex];
 
     uint64_t currentAtlasGen = fontCache->atlasGeneration(info.maskFormat());
 
     // Compute translation if any
     SkScalar transX, transY;
     info.computeTranslation(viewMatrix, x, y, &transX, &transY);
 
@@ skipping 40 matching lines @@
             // set use tokens for all of the glyphs in our subrun.  This is only valid if we
             // have a valid atlas generation
             fontCache->setUseTokenBulk(*info.bulkUseToken(), target->nextDrawToken(),
                                         info.maskFormat());
             break;
     }
 
     *byteCount = info.byteCount();
     *vertices = fVertices + info.vertexStartIndex();
 }