Refactor SkGrFontScaler and SkGrFontKey into non-virtual versions.

src/gpu/GrFontScaler.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrTemplates.h"
-#include "SkGr.h"
+#include "GrFontScaler.h"
 #include "SkDescriptor.h"
 #include "SkDistanceFieldGen.h"
 #include "SkGlyphCache.h"
 
-class SkGrDescKey : public GrKey {
-public:
-    explicit SkGrDescKey(const SkDescriptor& desc);
-    virtual ~SkGrDescKey();
-
-protected:
-    // overrides
-    virtual bool lt(const GrKey& rh) const;
-    virtual bool eq(const GrKey& rh) const;
-
-private:
-    SkDescriptor* fDesc;
-    enum {
-        kMaxStorageInts = 16
-    };
-    uint32_t fStorage[kMaxStorageInts];
-};
-
 ///////////////////////////////////////////////////////////////////////////////
 
-SkGrDescKey::SkGrDescKey(const SkDescriptor& desc) : GrKey(desc.getChecksum()) {
+GrFontDescKey::GrFontDescKey(const SkDescriptor& desc) : fHash(desc.getChecksum()) {
     size_t size = desc.getLength();
     if (size <= sizeof(fStorage)) {
         fDesc = GrTCast<SkDescriptor*>(fStorage);
     } else {
         fDesc = SkDescriptor::Alloc(size);
     }
     memcpy(fDesc, &desc, size);
 }
 
-SkGrDescKey::~SkGrDescKey() {
+GrFontDescKey::~GrFontDescKey() {
     if (fDesc != GrTCast<SkDescriptor*>(fStorage)) {
         SkDescriptor::Free(fDesc);
     }
 }
 
-bool SkGrDescKey::lt(const GrKey& rh) const {
-    const SkDescriptor* srcDesc = ((const SkGrDescKey*)&rh)->fDesc;
+bool GrFontDescKey::lt(const GrFontDescKey& rh) const {
+    const SkDescriptor* srcDesc = (&rh)->fDesc;
     size_t lenLH = fDesc->getLength();
     size_t lenRH = srcDesc->getLength();
     int cmp = memcmp(fDesc, srcDesc, SkTMin<size_t>(lenLH, lenRH));
     if (0 == cmp) {
         return lenLH < lenRH;
     } else {
         return cmp < 0;
     }
 }
 
-bool SkGrDescKey::eq(const GrKey& rh) const {
-    const SkDescriptor* srcDesc = ((const SkGrDescKey*)&rh)->fDesc;
+bool GrFontDescKey::eq(const GrFontDescKey& rh) const {
+    const SkDescriptor* srcDesc = (&rh)->fDesc;
     return fDesc->equals(*srcDesc);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkGrFontScaler::SkGrFontScaler(SkGlyphCache* strike) {
+GrFontScaler::GrFontScaler(SkGlyphCache* strike) {
     fStrike = strike;
     fKey = NULL;
 }
 
-SkGrFontScaler::~SkGrFontScaler() {
+GrFontScaler::~GrFontScaler() {
     SkSafeUnref(fKey);
 }
 
-GrMaskFormat SkGrFontScaler::getMaskFormat() {
+GrMaskFormat GrFontScaler::getMaskFormat() {
     SkMask::Format format = fStrike->getMaskFormat();
     switch (format) {
         case SkMask::kBW_Format:
             // fall through to kA8 -- we store BW glyphs in our 8-bit cache
         case SkMask::kA8_Format:
             return kA8_GrMaskFormat;
         case SkMask::kLCD16_Format:
             return kA565_GrMaskFormat;
         case SkMask::kLCD32_Format:
             return kA888_GrMaskFormat;
         case SkMask::kARGB32_Format:
             return kARGB_GrMaskFormat;
         default:
             SkDEBUGFAIL("unsupported SkMask::Format");
             return kA8_GrMaskFormat;
     }
 }
 
-const GrKey* SkGrFontScaler::getKey() {
+const GrFontDescKey* GrFontScaler::getKey() {
     if (NULL == fKey) {
-        fKey = SkNEW_ARGS(SkGrDescKey, (fStrike->getDescriptor()));
+        fKey = SkNEW_ARGS(GrFontDescKey, (fStrike->getDescriptor()));
     }
     return fKey;
 }
 
-bool SkGrFontScaler::getPackedGlyphBounds(GrGlyph::PackedID packed, SkIRect* bounds) {
+bool GrFontScaler::getPackedGlyphBounds(GrGlyph::PackedID packed, SkIRect* bounds) {
     const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
                                                       GrGlyph::UnpackFixedX(packed),
                                                       GrGlyph::UnpackFixedY(packed));
     bounds->setXYWH(glyph.fLeft, glyph.fTop, glyph.fWidth, glyph.fHeight);
 
     return true;
 }
 
-bool SkGrFontScaler::getPackedGlyphDFBounds(GrGlyph::PackedID packed, SkIRect* bounds) {
+bool GrFontScaler::getPackedGlyphDFBounds(GrGlyph::PackedID packed, SkIRect* bounds) {
     const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
                                                       GrGlyph::UnpackFixedX(packed),
                                                       GrGlyph::UnpackFixedY(packed));
     bounds->setXYWH(glyph.fLeft, glyph.fTop, glyph.fWidth, glyph.fHeight);
     bounds->outset(SK_DistanceFieldPad, SK_DistanceFieldPad);
 
     return true;
 }
 
 namespace {
@@ skipping 15 matching lines @@
             for (int i = 7; i >= 0 && rowWritesLeft; --i, --rowWritesLeft) {
                 *d++ = (mask & (1 << i)) ? (INT_TYPE)(~0UL) : 0;
             }
         }
         dst = reinterpret_cast<INT_TYPE*>(reinterpret_cast<intptr_t>(dst) + dstRowBytes);
         src += srcRowBytes;
     }
 }
 }
 
-bool SkGrFontScaler::getPackedGlyphImage(GrGlyph::PackedID packed,
+bool GrFontScaler::getPackedGlyphImage(GrGlyph::PackedID packed,
                                          int width, int height,
                                          int dstRB, void* dst) {
     const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
                                                       GrGlyph::UnpackFixedX(packed),
                                                       GrGlyph::UnpackFixedY(packed));
     SkASSERT(glyph.fWidth == width);
     SkASSERT(glyph.fHeight == height);
     const void* src = fStrike->findImage(glyph);
     if (NULL == src) {
         return false;
@@ skipping 31 matching lines @@
         const int bbp = GrMaskFormatBytesPerPixel(this->getMaskFormat());
         for (int y = 0; y < height; y++) {
             memcpy(dst, src, width * bbp);
             src = (const char*)src + srcRB;
             dst = (char*)dst + dstRB;
         }
     }
     return true;
 }
 
-bool SkGrFontScaler::getPackedGlyphDFImage(GrGlyph::PackedID packed,
+bool GrFontScaler::getPackedGlyphDFImage(GrGlyph::PackedID packed,
                                            int width, int height,
                                            void* dst) {
     const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
                                                       GrGlyph::UnpackFixedX(packed),
                                                       GrGlyph::UnpackFixedY(packed));
     SkASSERT(glyph.fWidth + 2*SK_DistanceFieldPad == width);
     SkASSERT(glyph.fHeight + 2*SK_DistanceFieldPad == height);
     const void* src = fStrike->findDistanceField(glyph);
     if (NULL == src) {
         return false;
     }
 
     memcpy(dst, src, width * height);
 
     return true;
 }
 
 // we should just return const SkPath* (NULL means false)
-bool SkGrFontScaler::getGlyphPath(uint16_t glyphID, SkPath* path) {
+bool GrFontScaler::getGlyphPath(uint16_t glyphID, SkPath* path) {
 
     const SkGlyph& glyph = fStrike->getGlyphIDMetrics(glyphID);
     const SkPath* skPath = fStrike->findPath(glyph);
     if (skPath) {
         *path = *skPath;
         return true;
     }
     return false;
 }