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

src/core/SkPaint.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
@@ skipping 664 matching lines @@
     SkASSERT(cache != nullptr);
     SkASSERT(text != nullptr);
 
     const uint16_t* ptr = *(const uint16_t**)text;
     unsigned glyphID = *ptr;
     ptr += 1;
     *text = (const char*)ptr;
     return cache->getGlyphIDAdvance(glyphID);
 }
 
-SkMeasureCacheProc SkPaint::getMeasureCacheProc(bool needFullMetrics) const {
-    static const SkMeasureCacheProc gMeasureCacheProcs[] = {
+SkPaint::GlyphCacheProc SkPaint::getGlyphCacheProc(bool needFullMetrics) const {
+    static const GlyphCacheProc gGlyphCacheProcs[] = {
         sk_getMetrics_utf8_next,
         sk_getMetrics_utf16_next,
         sk_getMetrics_utf32_next,
         sk_getMetrics_glyph_next,
 
         sk_getAdvance_utf8_next,
         sk_getAdvance_utf16_next,
         sk_getAdvance_utf32_next,
         sk_getAdvance_glyph_next,
     };
 
     unsigned index = this->getTextEncoding();
 
     if (!needFullMetrics && !this->isDevKernText()) {
         index += 4;
     }
 
-    SkASSERT(index < SK_ARRAY_COUNT(gMeasureCacheProcs));
-    return gMeasureCacheProcs[index];
+    SkASSERT(index < SK_ARRAY_COUNT(gGlyphCacheProcs));
+    return gGlyphCacheProcs[index];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
-static const SkGlyph& sk_getMetrics_utf8_00(SkGlyphCache* cache,
-                                        const char** text, SkFixed, SkFixed) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    return cache->getUnicharMetrics(SkUTF8_NextUnichar(text));
-}
-
-static const SkGlyph& sk_getMetrics_utf8_xy(SkGlyphCache* cache,
-                                    const char** text, SkFixed x, SkFixed y) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    return cache->getUnicharMetrics(SkUTF8_NextUnichar(text), x, y);
-}
-
-static const SkGlyph& sk_getMetrics_utf16_00(SkGlyphCache* cache,
-                                        const char** text, SkFixed, SkFixed) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text));
-}
-
-static const SkGlyph& sk_getMetrics_utf16_xy(SkGlyphCache* cache,
-                                     const char** text, SkFixed x, SkFixed y) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text),
-                                    x, y);
-}
-
-static const SkGlyph& sk_getMetrics_utf32_00(SkGlyphCache* cache,
-                                    const char** text, SkFixed, SkFixed) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    const int32_t* ptr = *(const int32_t**)text;
-    SkUnichar uni = *ptr++;
-    *text = (const char*)ptr;
-    return cache->getUnicharMetrics(uni);
-}
-
-static const SkGlyph& sk_getMetrics_utf32_xy(SkGlyphCache* cache,
-                                    const char** text, SkFixed x, SkFixed y) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    const int32_t* ptr = *(const int32_t**)text;
-    SkUnichar uni = *ptr++;
-    *text = (const char*)ptr;
-    return cache->getUnicharMetrics(uni, x, y);
-}
-
-static const SkGlyph& sk_getMetrics_glyph_00(SkGlyphCache* cache,
-                                         const char** text, SkFixed, SkFixed) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    const uint16_t* ptr = *(const uint16_t**)text;
-    unsigned glyphID = *ptr;
-    ptr += 1;
-    *text = (const char*)ptr;
-    return cache->getGlyphIDMetrics(glyphID);
-}
-
-static const SkGlyph& sk_getMetrics_glyph_xy(SkGlyphCache* cache,
-                                     const char** text, SkFixed x, SkFixed y) {
-    SkASSERT(cache != nullptr);
-    SkASSERT(text != nullptr);
-
-    const uint16_t* ptr = *(const uint16_t**)text;
-    unsigned glyphID = *ptr;
-    ptr += 1;
-    *text = (const char*)ptr;
-    return cache->getGlyphIDMetrics(glyphID, x, y);
-}
-
-SkDrawCacheProc SkPaint::getDrawCacheProc() const {
-    static const SkDrawCacheProc gDrawCacheProcs[] = {
-        sk_getMetrics_utf8_00,
-        sk_getMetrics_utf16_00,
-        sk_getMetrics_utf32_00,
-        sk_getMetrics_glyph_00,
-
-        sk_getMetrics_utf8_xy,
-        sk_getMetrics_utf16_xy,
-        sk_getMetrics_utf32_xy,
-        sk_getMetrics_glyph_xy
-    };
-
-    unsigned index = this->getTextEncoding();
-    if (fBitfields.fFlags & kSubpixelText_Flag) {
-        index += 4;
-    }
-
-    SkASSERT(index < SK_ARRAY_COUNT(gDrawCacheProcs));
-    return gDrawCacheProcs[index];
-}
-
-///////////////////////////////////////////////////////////////////////////////
 
 #define TEXT_AS_PATHS_PAINT_FLAGS_TO_IGNORE (   \
 SkPaint::kDevKernText_Flag          |       \
 SkPaint::kLinearText_Flag           |       \
 SkPaint::kLCDRenderText_Flag        |       \
 SkPaint::kEmbeddedBitmapText_Flag   |       \
 SkPaint::kAutoHinting_Flag          |       \
 SkPaint::kGenA8FromLCD_Flag )
 
 SkScalar SkPaint::setupForAsPaths() {
@@ skipping 71 matching lines @@
                                int* count, SkRect* bounds) const {
     SkASSERT(count);
     if (byteLength == 0) {
         *count = 0;
         if (bounds) {
             bounds->setEmpty();
         }
         return 0;
     }
 
-    SkMeasureCacheProc glyphCacheProc = this->getMeasureCacheProc(nullptr != bounds);
+    GlyphCacheProc glyphCacheProc = this->getGlyphCacheProc(nullptr != bounds);
 
     int xyIndex;
     JoinBoundsProc joinBoundsProc;
     if (this->isVerticalText()) {
         xyIndex = 1;
         joinBoundsProc = join_bounds_y;
     } else {
         xyIndex = 0;
         joinBoundsProc = join_bounds_x;
     }
@@ skipping 104 matching lines @@
     SkScalar scale = canon.getScale();
 
     // adjust max in case we changed the textSize in paint
     if (scale) {
         maxWidth /= scale;
     }
 
     SkAutoGlyphCache    autoCache(paint, nullptr, nullptr);
     SkGlyphCache*       cache = autoCache.getCache();
 
-    SkMeasureCacheProc glyphCacheProc = paint.getMeasureCacheProc(false);
+    GlyphCacheProc   glyphCacheProc = paint.getGlyphCacheProc(false);
     const int        xyIndex = paint.isVerticalText() ? 1 : 0;
     // use 64bits for our accumulator, to avoid overflowing 16.16
     Sk48Dot16        max = SkScalarToFixed(maxWidth);
     Sk48Dot16        width = 0;
 
     SkAutoKern  autokern;
 
     if (this->isDevKernText()) {
         int rsb = 0;
         while (text < stop) {
@@ skipping 97 matching lines @@
     if (nullptr == widths && nullptr == bounds) {
         return this->countText(textData, byteLength);
     }
 
     SkCanonicalizePaint canon(*this);
     const SkPaint& paint = canon.getPaint();
     SkScalar scale = canon.getScale();
 
     SkAutoGlyphCache    autoCache(paint, nullptr, nullptr);
     SkGlyphCache*       cache = autoCache.getCache();
-    SkMeasureCacheProc  glyphCacheProc;
-    glyphCacheProc = paint.getMeasureCacheProc(nullptr != bounds);
+    GlyphCacheProc      glyphCacheProc = paint.getGlyphCacheProc(nullptr != bounds);
 
     const char* text = (const char*)textData;
     const char* stop = text + byteLength;
     int         count = 0;
     const int   xyIndex = paint.isVerticalText() ? 1 : 0;
 
     if (this->isDevKernText()) {
         // we adjust the widths returned here through auto-kerning
         SkAutoKern  autokern;
         SkFixed     prevWidth = 0;
@@ skipping 1232 matching lines @@
 
 static bool has_thick_frame(const SkPaint& paint) {
     return  paint.getStrokeWidth() > 0 &&
             paint.getStyle() != SkPaint::kFill_Style;
 }
 
 SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
                                    const SkPaint& paint,
                                    bool applyStrokeAndPathEffects)
     : fPaint(paint) {
-    fGlyphCacheProc = paint.getMeasureCacheProc(true);
+    fGlyphCacheProc = paint.getGlyphCacheProc(true);
 
     fPaint.setLinearText(true);
     fPaint.setMaskFilter(nullptr);   // don't want this affecting our path-cache lookup
 
     if (fPaint.getPathEffect() == nullptr && !has_thick_frame(fPaint)) {
         applyStrokeAndPathEffects = false;
     }
 
     // can't use our canonical size if we need to apply patheffects
     if (fPaint.getPathEffect() == nullptr) {
@@ skipping 124 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     static_assert(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
                   "SkPaint_notPackedTightly");
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }