Expose SkFaceRec less.

src/ports/SkFontHost_FreeType.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 "SkAdvancedTypefaceMetrics.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 164 matching lines @@
         SkDEBUGCODE(gFTLibrary = NULL;)
     }
 }
 
 class SkScalerContext_FreeType : public SkScalerContext_FreeType_Base {
 public:
     SkScalerContext_FreeType(SkTypeface*, const SkDescriptor* desc);
     virtual ~SkScalerContext_FreeType();
 
     bool success() const {
-        return fFaceRec != NULL &&
-               fFTSize != NULL &&
-               fFace != NULL;
+        return fFTSize != NULL && fFace != NULL;
     }
 
 protected:
     unsigned generateGlyphCount() override;
     uint16_t generateCharToGlyph(SkUnichar uni) override;
     void generateAdvance(SkGlyph* glyph) override;
     void generateMetrics(SkGlyph* glyph) override;
     void generateImage(const SkGlyph& glyph) override;
     void generatePath(const SkGlyph& glyph, SkPath* path) override;
     void generateFontMetrics(SkPaint::FontMetrics*) override;
     SkUnichar generateGlyphToChar(uint16_t glyph) override;
 
 private:
-    SkFaceRec*  fFaceRec;
     FT_Face     fFace;              // reference to shared face in gFaceRecHead
     FT_Size     fFTSize;            // our own copy
     FT_Int      fStrikeIndex;
     SkFixed     fScaleX, fScaleY;
     FT_Matrix   fMatrix22;
     uint32_t    fLoadGlyphFlags;
     bool        fDoLinearMetrics;
     bool        fLCDIsVert;
 
     // Need scalar versions for generateFontMetrics
@@ skipping 82 matching lines @@
     }
     if (FT_Set_Var_Design_Coordinates(face, data.getAxisCount(), coords.get())) {
         SkDEBUGF(("INFO: font %s has variations, but specified variations could not be set.\n",
                   face->family_name));
         return;
     }
 }
 
 // Will return 0 on failure
 // Caller must lock gFTMutex before calling this function.
-static SkFaceRec* ref_ft_face(const SkTypeface* typeface) {
+static FT_Face ref_ft_face(const SkTypeface* typeface) {
     gFTMutex.assertHeld();
 
     const SkFontID fontID = typeface->uniqueID();
     SkFaceRec* rec = gFaceRecHead;
     while (rec) {
         if (rec->fFontID == fontID) {
             SkASSERT(rec->fFace);
             rec->fRefCnt += 1;
-            return rec;
+            return rec->fFace;
         }
         rec = rec->fNext;
     }
 
     SkAutoTDelete<SkFontData> data(typeface->createFontData());
     if (NULL == data || !data->hasStream()) {
         return NULL;
     }
 
     // this passes ownership of stream to the rec
@@ skipping 26 matching lines @@
     // However, "symbol" cmaps should also be considered "fallback unicode" cmaps
     // because they are effectively private use area only (even if they aren't).
     // This is the last on the fallback list at
     // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6cmap.html
     if (!rec->fFace->charmap) {
         FT_Select_Charmap(rec->fFace, FT_ENCODING_MS_SYMBOL);
     }
 
     rec->fNext = gFaceRecHead;
     gFaceRecHead = rec;
-    return rec;
+    return rec->fFace;
 }
 
 // Caller must lock gFTMutex before calling this function.
 static void unref_ft_face(FT_Face face) {
     gFTMutex.assertHeld();
 
     SkFaceRec*  rec = gFaceRecHead;
     SkFaceRec*  prev = NULL;
     while (rec) {
         SkFaceRec* next = rec->fNext;
@@ skipping 10 matching lines @@
             return;
         }
         prev = rec;
         rec = next;
     }
     SkDEBUGFAIL("shouldn't get here, face not in list");
 }
 
 class AutoFTAccess {
 public:
-    AutoFTAccess(const SkTypeface* tf) : fRec(NULL), fFace(NULL) {
+    AutoFTAccess(const SkTypeface* tf) : fFace(NULL) {
         gFTMutex.acquire();
         if (!ref_ft_library()) {
             sk_throw();
         }
-        fRec = ref_ft_face(tf);
-        if (fRec) {
-            fFace = fRec->fFace;
-        }
+        fFace = ref_ft_face(tf);
     }
 
     ~AutoFTAccess() {
         if (fFace) {
             unref_ft_face(fFace);
         }
         unref_ft_library();
         gFTMutex.release();
     }
 
-    SkFaceRec* rec() { return fRec; }
     FT_Face face() { return fFace; }
 
 private:
-    SkFaceRec*  fRec;
     FT_Face     fFace;
 };
 
 ///////////////////////////////////////////////////////////////////////////
 
 static bool canEmbed(FT_Face face) {
     FT_UShort fsType = FT_Get_FSType_Flags(face);
     return (fsType & (FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING |
                       FT_FSTYPE_BITMAP_EMBEDDING_ONLY)) == 0;
 }
@@ skipping 360 matching lines @@
         FT_Error err = FT_Select_Size(face, chosenStrikeIndex);
         if (err != 0) {
             SkDEBUGF(("FT_Select_Size(%s, %d) returned 0x%x\n", face->family_name,
                       chosenStrikeIndex, err));
             chosenStrikeIndex = -1;
         }
     }
     return chosenStrikeIndex;
 }
 
-SkScalerContext_FreeType::SkScalerContext_FreeType(SkTypeface* typeface,
-                                                   const SkDescriptor* desc)
-        : SkScalerContext_FreeType_Base(typeface, desc) {
+SkScalerContext_FreeType::SkScalerContext_FreeType(SkTypeface* typeface, const SkDescriptor* desc)
+    : SkScalerContext_FreeType_Base(typeface, desc)
+{
     SkAutoMutexAcquire  ac(gFTMutex);
 
     if (!ref_ft_library()) {
         sk_throw();
     }
 
     // load the font file
     fStrikeIndex = -1;
     fFTSize = NULL;
-    fFace = NULL;
-    fFaceRec = ref_ft_face(typeface);
-    if (NULL == fFaceRec) {
+    fFace = ref_ft_face(typeface);
+    if (NULL == fFace) {
         return;
     }
-    fFace = fFaceRec->fFace;
 
     fRec.computeMatrices(SkScalerContextRec::kFull_PreMatrixScale, &fScale, &fMatrix22Scalar);
     fMatrix22Scalar.setSkewX(-fMatrix22Scalar.getSkewX());
     fMatrix22Scalar.setSkewY(-fMatrix22Scalar.getSkewY());
 
     fScaleX = SkScalarToFixed(fScale.fX);
     fScaleY = SkScalarToFixed(fScale.fY);
     fMatrix22.xx = SkScalarToFixed(fMatrix22Scalar.getScaleX());
     fMatrix22.xy = SkScalarToFixed(fMatrix22Scalar.getSkewX());
     fMatrix22.yx = SkScalarToFixed(fMatrix22Scalar.getSkewY());
@@ skipping 131 matching lines @@
 
     unref_ft_library();
 }
 
 /*  We call this before each use of the fFace, since we may be sharing
     this face with other context (at different sizes).
 */
 FT_Error SkScalerContext_FreeType::setupSize() {
     FT_Error err = FT_Activate_Size(fFTSize);
     if (err != 0) {
-        SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%x, 0x%x, 0x%x) returned 0x%x\n",
-                  fFaceRec->fFontID, fScaleX, fScaleY, err));
+        SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%s %s, 0x%x, 0x%x) returned 0x%x\n",
+                  fFace->family_name, fFace->style_name, fScaleX, fScaleY, err));
         fFTSize = NULL;
         return err;
     }
 
     // seems we need to reset this every time (not sure why, but without it
     // I get random italics from some other fFTSize)
     FT_Set_Transform(fFace, &fMatrix22, NULL);
     return 0;
 }
 
@@ skipping 129 matching lines @@
 
 void SkScalerContext_FreeType::generateMetrics(SkGlyph* glyph) {
     SkAutoMutexAcquire  ac(gFTMutex);
 
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
 
     FT_Error    err;
 
     if (this->setupSize()) {
-        goto ERROR;
+        glyph->zeroMetrics();
+        return;
     }
 
     err = FT_Load_Glyph( fFace, glyph->getGlyphID(), fLoadGlyphFlags );
     if (err != 0) {
-#if 0
-        SkDEBUGF(("SkScalerContext_FreeType::generateMetrics(%x): FT_Load_Glyph(glyph:%d flags:%x) returned 0x%x\n",
-                    fFaceRec->fFontID, glyph->getGlyphID(), fLoadGlyphFlags, err));
-#endif
-    ERROR:
         glyph->zeroMetrics();
         return;
     }
     emboldenIfNeeded(fFace, fFace->glyph);
 
     switch ( fFace->glyph->format ) {
       case FT_GLYPH_FORMAT_OUTLINE:
         if (0 == fFace->glyph->outline.n_contours) {
             glyph->fWidth = 0;
             glyph->fHeight = 0;
@@ skipping 27 matching lines @@
         }
 
         glyph->fWidth   = SkToU16(fFace->glyph->bitmap.width);
         glyph->fHeight  = SkToU16(fFace->glyph->bitmap.rows);
         glyph->fTop     = -SkToS16(fFace->glyph->bitmap_top);
         glyph->fLeft    = SkToS16(fFace->glyph->bitmap_left);
         break;
 
       default:
         SkDEBUGFAIL("unknown glyph format");
-        goto ERROR;
+        glyph->zeroMetrics();
+        return;
     }
 
     if (fRec.fFlags & SkScalerContext::kVertical_Flag) {
         if (fDoLinearMetrics) {
             glyph->fAdvanceX = -SkFixedMul(fMatrix22.xy, fFace->glyph->linearVertAdvance);
             glyph->fAdvanceY = SkFixedMul(fMatrix22.yy, fFace->glyph->linearVertAdvance);
         } else {
             glyph->fAdvanceX = -SkFDot6ToFixed(fFace->glyph->advance.x);
             glyph->fAdvanceY = SkFDot6ToFixed(fFace->glyph->advance.y);
         }
@@ skipping 561 matching lines @@
             (*axes)[i].fTag = ftAxis.tag;
             (*axes)[i].fMinimum = ftAxis.minimum;
             (*axes)[i].fDefault = ftAxis.def;
             (*axes)[i].fMaximum = ftAxis.maximum;
         }
     }
 
     FT_Done_Face(face);
     return true;
 }