Remove GrFontScaler class

src/gpu/text/GrTextUtils.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 "GrTextUtils.h"
 
 #include "GrAtlasTextBlob.h"
@@ skipping 38 matching lines @@
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     // Ensure the blob is set for bitmaptext
     blob->setHasBitmap();
 
     GrBatchTextStrike* currStrike = nullptr;
 
-    // Get GrFontScaler from cache
     SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, skPaint,
                                            &viewMatrix);
-    GrFontScaler* fontScaler = GrTextUtils::GetGrFontScaler(cache);
-
     SkFindAndPlaceGlyph::ProcessText(
         skPaint.getTextEncoding(), text, byteLength,
         {x, y}, viewMatrix, skPaint.getTextAlign(),
         cache,
         [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
             position += rounding;
             BmpAppendGlyph(
                 blob, runIndex, fontCache, &currStrike, glyph,
                 SkScalarFloorToInt(position.fX), SkScalarFloorToInt(position.fY),
-                color, fontScaler);
+                color, cache);
         }
     );
 
     SkGlyphCache::AttachCache(cache);
 }
 
 void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
                                  GrBatchFontCache* fontCache,
                                  const SkSurfaceProps& props, const SkPaint& skPaint,
                                  GrColor color, uint32_t scalerContextFlags,
                                  const SkMatrix& viewMatrix,
                                  const char text[], size_t byteLength,
                                  const SkScalar pos[], int scalarsPerPosition,
                                  const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     // Ensure the blob is set for bitmaptext
     blob->setHasBitmap();
 
     GrBatchTextStrike* currStrike = nullptr;
 
-    // Get GrFontScaler from cache
     SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, skPaint,
                                            &viewMatrix);
-    GrFontScaler* fontScaler = GrTextUtils::GetGrFontScaler(cache);
 
     SkFindAndPlaceGlyph::ProcessPosText(
         skPaint.getTextEncoding(), text, byteLength,
         offset, viewMatrix, pos, scalarsPerPosition,
         skPaint.getTextAlign(), cache,
         [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
             position += rounding;
             BmpAppendGlyph(
                 blob, runIndex, fontCache, &currStrike, glyph,
                 SkScalarFloorToInt(position.fX), SkScalarFloorToInt(position.fY),
-                color, fontScaler);
+                color, cache);
         }
     );
 
     SkGlyphCache::AttachCache(cache);
 }
 
 void GrTextUtils::BmpAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
                                  GrBatchFontCache* fontCache,
                                  GrBatchTextStrike** strike, const SkGlyph& skGlyph,
-                                 int vx, int vy, GrColor color, GrFontScaler* scaler) {
+                                 int vx, int vy, GrColor color, SkGlyphCache* cache) {
     if (!*strike) {
-        *strike = fontCache->getStrike(scaler);
+        *strike = fontCache->getStrike(cache);
     }
 
     GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
                                          skGlyph.getSubXFixed(),
                                          skGlyph.getSubYFixed(),
                                          GrGlyph::kCoverage_MaskStyle);
-    GrGlyph* glyph = (*strike)->getGlyph(skGlyph, id, scaler);
+    GrGlyph* glyph = (*strike)->getGlyph(skGlyph, id, cache);
     if (!glyph) {
         return;
     }
 
     int x = vx + glyph->fBounds.fLeft;
     int y = vy + glyph->fBounds.fTop;
 
     // keep them as ints until we've done the clip-test
     int width = glyph->fBounds.width();
     int height = glyph->fBounds.height();
 
     SkRect r;
     r.fLeft = SkIntToScalar(x);
     r.fTop = SkIntToScalar(y);
     r.fRight = r.fLeft + SkIntToScalar(width);
     r.fBottom = r.fTop + SkIntToScalar(height);
 
-    blob->appendGlyph(runIndex, r, color, *strike, glyph, scaler, skGlyph,
+    blob->appendGlyph(runIndex, r, color, *strike, glyph, cache, skGlyph,
                       SkIntToScalar(vx), SkIntToScalar(vy), 1.0f, false);
 }
 
 bool GrTextUtils::CanDrawAsDistanceFields(const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                           const SkSurfaceProps& props, const GrShaderCaps& caps) {
     // TODO: support perspective (need getMaxScale replacement)
     if (viewMatrix.hasPerspective()) {
         return false;
     }
 
@@ skipping 181 matching lines @@
     blob->setHasDistanceField();
     blob->setSubRunHasDistanceFields(runIndex, origPaint.isLCDRenderText());
 
     GrBatchTextStrike* currStrike = nullptr;
 
     // We apply the fake-gamma by altering the distance in the shader, so we ignore the
     // passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
     SkGlyphCache* cache = blob->setupCache(runIndex, props, SkPaint::kNone_ScalerContextFlags,
                                            dfPaint, nullptr);
     SkPaint::GlyphCacheProc glyphCacheProc = dfPaint.getGlyphCacheProc(true);
-    GrFontScaler* fontScaler = GrTextUtils::GetGrFontScaler(cache);
 
     const char* stop = text + byteLength;
 
     if (SkPaint::kLeft_Align == dfPaint.getTextAlign()) {
         while (text < stop) {
             const char* lastText = text;
             // the last 2 parameters are ignored
             const SkGlyph& glyph = glyphCacheProc(cache, &text);
 
             if (glyph.fWidth) {
                 SkScalar x = offset.x() + pos[0];
                 SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
 
                 if (!DfAppendGlyph(blob,
                                    runIndex,
                                    fontCache,
                                    &currStrike,
                                    glyph,
-                                   x, y, color, fontScaler,
+                                   x, y, color, cache,
                                    textRatio, viewMatrix)) {
                     // couldn't append, send to fallback
                     fallbackTxt.append(SkToInt(text-lastText), lastText);
                     *fallbackPos.append() = pos[0];
                     if (2 == scalarsPerPosition) {
                         *fallbackPos.append() = pos[1];
                     }
                 }
             }
             pos += scalarsPerPosition;
@@ skipping 12 matching lines @@
 
                 SkScalar advanceX = SkFloatToScalar(glyph.fAdvanceX) * alignMul * textRatio;
                 SkScalar advanceY = SkFloatToScalar(glyph.fAdvanceY) * alignMul * textRatio;
 
                 if (!DfAppendGlyph(blob,
                                    runIndex,
                                    fontCache,
                                    &currStrike,
                                    glyph,
                                    x - advanceX, y - advanceY, color,
-                                   fontScaler,
+                                   cache,
                                    textRatio,
                                    viewMatrix)) {
                     // couldn't append, send to fallback
                     fallbackTxt.append(SkToInt(text-lastText), lastText);
                     *fallbackPos.append() = pos[0];
                     if (2 == scalarsPerPosition) {
                         *fallbackPos.append() = pos[1];
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     }
 
     SkGlyphCache::AttachCache(cache);
     if (fallbackTxt.count()) {
         blob->initOverride(runIndex);
         GrTextUtils::DrawBmpPosText(blob, runIndex, fontCache, props,
                                     origPaint, origPaint.getColor(), scalerContextFlags, viewMatrix,
                                     fallbackTxt.begin(), fallbackTxt.count(),
                                     fallbackPos.begin(), scalarsPerPosition, offset);
     }
 }
 
 bool GrTextUtils::DfAppendGlyph(GrAtlasTextBlob* blob, int runIndex, GrBatchFontCache* cache,
                                 GrBatchTextStrike** strike, const SkGlyph& skGlyph,
                                 SkScalar sx, SkScalar sy, GrColor color,
-                                GrFontScaler* scaler,
+                                SkGlyphCache* glyphCache,
                                 SkScalar textRatio, const SkMatrix& viewMatrix) {
     if (!*strike) {
-        *strike = cache->getStrike(scaler);
+        *strike = cache->getStrike(glyphCache);
     }
 
     GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
                                          skGlyph.getSubXFixed(),
                                          skGlyph.getSubYFixed(),
                                          GrGlyph::kDistance_MaskStyle);
-    GrGlyph* glyph = (*strike)->getGlyph(skGlyph, id, scaler);
+    GrGlyph* glyph = (*strike)->getGlyph(skGlyph, id, glyphCache);
     if (!glyph) {
         return true;
     }
 
     // fallback to color glyph support
     if (kA8_GrMaskFormat != glyph->fMaskFormat) {
         return false;
     }
 
     SkScalar dx = SkIntToScalar(glyph->fBounds.fLeft + SK_DistanceFieldInset);
     SkScalar dy = SkIntToScalar(glyph->fBounds.fTop + SK_DistanceFieldInset);
     SkScalar width = SkIntToScalar(glyph->fBounds.width() - 2 * SK_DistanceFieldInset);
     SkScalar height = SkIntToScalar(glyph->fBounds.height() - 2 * SK_DistanceFieldInset);
 
     SkScalar scale = textRatio;
     dx *= scale;
     dy *= scale;
     width *= scale;
     height *= scale;
     sx += dx;
     sy += dy;
     SkRect glyphRect = SkRect::MakeXYWH(sx, sy, width, height);
 
-    blob->appendGlyph(runIndex, glyphRect, color, *strike, glyph, scaler, skGlyph,
+    blob->appendGlyph(runIndex, glyphRect, color, *strike, glyph, glyphCache, skGlyph,
                       sx - dx, sy - dy, scale, true);
     return true;
 }
 
 void GrTextUtils::DrawTextAsPath(GrContext* context, GrDrawContext* dc,
                                  const GrClip& clip,
                                  const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                  const char text[], size_t byteLength, SkScalar x, SkScalar y,
                                  const SkIRect& clipBounds) {
     SkTextToPathIter iter(text, byteLength, skPaint, true);
@@ skipping 83 matching lines @@
         return flags;
     }
 
     if (kUnknown_SkPixelGeometry == surfaceProps.pixelGeometry() || ShouldDisableLCD(paint)) {
         flags &= ~SkPaint::kLCDRenderText_Flag;
         flags |= SkPaint::kGenA8FromLCD_Flag;
     }
 
     return flags;
 }
-
-static void glyph_cache_aux_proc(void* data) {
-    GrFontScaler* scaler = (GrFontScaler*)data;
-    delete scaler;
-}
-
-GrFontScaler* GrTextUtils::GetGrFontScaler(SkGlyphCache* cache) {
-    void* auxData;
-    GrFontScaler* scaler = nullptr;
-
-    if (cache->getAuxProcData(glyph_cache_aux_proc, &auxData)) {
-        scaler = (GrFontScaler*)auxData;
-    }
-    if (nullptr == scaler) {
-        scaler = new GrFontScaler(cache);
-        cache->setAuxProc(glyph_cache_aux_proc, scaler);
-    }
-
-    return scaler;
-}