Simplify and combine SkDrawCacheProc and SkMeasureCacheProc to SkPaint::GlyphCacheProc.

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 240 matching lines @@
                              const SkMatrix& viewMatrix,
                              const char text[], size_t byteLength,
                              SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != nullptr);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
-    SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
+    SkPaint::GlyphCacheProc glyphCacheProc = skPaint.getGlyphCacheProc(true);
     SkAutoDescriptor desc;
     skPaint.getScalerContextDescriptor(&desc, props, SkPaint::FakeGamma::Off, nullptr);
     SkGlyphCache* origPaintCache = SkGlyphCache::DetachCache(skPaint.getTypeface(),
                                                              desc.getDesc());
 
     SkTArray<SkScalar> positions;
 
     const char* textPtr = text;
     SkFixed stopX = 0;
     SkFixed stopY = 0;
     SkFixed origin = 0;
     switch (skPaint.getTextAlign()) {
         case SkPaint::kRight_Align: origin = SK_Fixed1; break;
         case SkPaint::kCenter_Align: origin = SK_FixedHalf; break;
         case SkPaint::kLeft_Align: origin = 0; break;
     }
 
     SkAutoKern autokern;
     const char* stop = text + byteLength;
     while (textPtr < stop) {
         // don't need x, y here, since all subpixel variants will have the
         // same advance
-        const SkGlyph& glyph = glyphCacheProc(origPaintCache, &textPtr, 0, 0);
+        const SkGlyph& glyph = glyphCacheProc(origPaintCache, &textPtr);
 
         SkFixed width = glyph.fAdvanceX + autokern.adjust(glyph);
         positions.push_back(SkFixedToScalar(stopX + SkFixedMul(origin, width)));
 
         SkFixed height = glyph.fAdvanceY;
         positions.push_back(SkFixedToScalar(stopY + SkFixedMul(origin, height)));
 
         stopX += width;
         stopY += height;
     }
@@ skipping 41 matching lines @@
     SkScalar textRatio;
     SkPaint dfPaint(origPaint);
     GrTextUtils::InitDistanceFieldPaint(blob, &dfPaint, &textRatio, viewMatrix);
     blob->setHasDistanceField();
     blob->setSubRunHasDistanceFields(runIndex, origPaint.isLCDRenderText());
 
     GrBatchTextStrike* currStrike = nullptr;
 
     SkGlyphCache* cache = blob->setupCache(runIndex, props, SkPaint::FakeGamma::Off,
                                            dfPaint, nullptr);
-    SkDrawCacheProc glyphCacheProc = dfPaint.getDrawCacheProc();
+    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, 0, 0);
+            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,
                                    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;
         }
     } else {
         SkScalar alignMul = SkPaint::kCenter_Align == dfPaint.getTextAlign() ? SK_ScalarHalf
                                                                              : SK_Scalar1;
         while (text < stop) {
             const char* lastText = text;
             // the last 2 parameters are ignored
-            const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
+            const SkGlyph& glyph = glyphCacheProc(cache, &text);
 
             if (glyph.fWidth) {
                 SkScalar x = offset.x() + pos[0];
                 SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
 
                 SkScalar advanceX = SkFixedToScalar(glyph.fAdvanceX) * alignMul * textRatio;
                 SkScalar advanceY = SkFixedToScalar(glyph.fAdvanceY) * alignMul * textRatio;
 
                 if (!DfAppendGlyph(blob,
                                    runIndex,
@@ skipping 105 matching lines @@
     SkPaint paint(origPaint);
     SkScalar matrixScale = paint.setupForAsPaths();
 
     SkMatrix matrix;
     matrix.setScale(matrixScale, matrixScale);
 
     // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache.
     paint.setStyle(SkPaint::kFill_Style);
     paint.setPathEffect(nullptr);
 
-    SkDrawCacheProc     glyphCacheProc = paint.getDrawCacheProc();
-    SkAutoGlyphCache    autoCache(paint, &props, nullptr);
-    SkGlyphCache*       cache = autoCache.getCache();
+    SkPaint::GlyphCacheProc    glyphCacheProc = paint.getGlyphCacheProc(true);
+    SkAutoGlyphCache           autoCache(paint, &props, nullptr);
+    SkGlyphCache*              cache = autoCache.getCache();
 
     const char*        stop = text + byteLength;
     SkTextAlignProc    alignProc(paint.getTextAlign());
     SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition);
 
     // Now restore the original settings, so we "draw" with whatever style/stroking.
     paint.setStyle(origPaint.getStyle());
     paint.setPathEffect(origPaint.getPathEffect());
 
     while (text < stop) {
-        const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
+        const SkGlyph& glyph = glyphCacheProc(cache, &text);
         if (glyph.fWidth) {
             const SkPath* path = cache->findPath(glyph);
             if (path) {
                 SkPoint tmsLoc;
                 tmsProc(pos, &tmsLoc);
                 SkPoint loc;
                 alignProc(tmsLoc, glyph, &loc);
 
                 matrix[SkMatrix::kMTransX] = loc.fX;
                 matrix[SkMatrix::kMTransY] = loc.fY;
@@ skipping 41 matching lines @@
     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;
 }