Use function-ptr instead of SkFontHost api to allow client to handle

src/ports/SkFontHost_win.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 "SkBase64.h"
@@ skipping 17 matching lines @@
 #include <tchar.h>
 #include <usp10.h>
 #include <objbase.h>
 
 static void (*gEnsureLOGFONTAccessibleProc)(const LOGFONT&);
 
 void SkTypeface_SetEnsureLOGFONTAccessibleProc(void (*proc)(const LOGFONT&)) {
     gEnsureLOGFONTAccessibleProc = proc;
 }
 
+static void call_ensure_accessible(const LOGFONT& lf) {
+    if (gEnsureLOGFONTAccessibleProc) {
+        gEnsureLOGFONTAccessibleProc(lf);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 // always packed xxRRGGBB
 typedef uint32_t SkGdiRGB;
 
 template <typename T> T* SkTAddByteOffset(T* ptr, size_t byteOffset) {
     return (T*)((char*)ptr + byteOffset);
 }
 
 // define this in your Makefile or .gyp to enforce AA requests
 // which GDI ignores at small sizes. This flag guarantees AA
 // for rotated text, regardless of GDI's notions.
@@ skipping 113 matching lines @@
         SkTypeface(style, fontID, false), fLogFont(lf), fSerializeAsStream(serializeAsStream) {
 
         // If the font has cubic outlines, it will not be rendered with ClearType.
         HFONT font = CreateFontIndirect(&lf);
 
         HDC deviceContext = ::CreateCompatibleDC(NULL);
         HFONT savefont = (HFONT)SelectObject(deviceContext, font);
 
         TEXTMETRIC textMetric;
         if (0 == GetTextMetrics(deviceContext, &textMetric)) {
-            SkFontHost::EnsureTypefaceAccessible(*this);
+            call_ensure_accessible(lf);
             if (0 == GetTextMetrics(deviceContext, &textMetric)) {
                 textMetric.tmPitchAndFamily = TMPF_TRUETYPE;
             }
         }
         if (deviceContext) {
             ::SelectObject(deviceContext, savefont);
             ::DeleteDC(deviceContext);
         }
         if (font) {
             ::DeleteObject(font);
         }
 
         // Used a logfont on a memory context, should never get a device font.
         // Therefore all TMPF_DEVICE will be PostScript (cubic) fonts.
         fCanBeLCD = !((textMetric.tmPitchAndFamily & TMPF_VECTOR) &&
                       (textMetric.tmPitchAndFamily & TMPF_DEVICE));
     }
 
     LOGFONT fLogFont;
     bool fSerializeAsStream;
     bool fCanBeLCD;
 
     static LogFontTypeface* Create(const LOGFONT& lf) {
         SkTypeface::Style style = get_style(lf);
         SkFontID fontID = SkTypefaceCache::NewFontID();
         return new LogFontTypeface(style, fontID, lf);
     }
 
+    static void EnsureAccessible(const SkTypeface* face) {
+        call_ensure_accessible(static_cast<const LogFontTypeface*>(face)->fLogFont);
+    }
+
 protected:
     virtual SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE;
     virtual void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
     virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
                                 SkAdvancedTypefaceMetrics::PerGlyphInfo,
                                 const uint32_t*, uint32_t) const SK_OVERRIDE;
 };
 
 class FontMemResourceTypeface : public LogFontTypeface {
 public:
@@ skipping 77 matching lines @@
     }
 }
 
 SkTypeface* SkFontHost::NextLogicalTypeface(SkFontID currFontID, SkFontID origFontID) {
   // Zero means that we don't have any fallback fonts for this fontID.
   // This function is implemented on Android, but doesn't have much
   // meaning here.
   return NULL;
 }
 
-static void ensure_typeface_accessible(SkFontID fontID) {
-    LogFontTypeface* face = static_cast<LogFontTypeface*>(SkTypefaceCache::FindByID(fontID));
-    if (face) {
-        SkFontHost::EnsureTypefaceAccessible(*face);
-    }
-}
-
 static void GetLogFontByID(SkFontID fontID, LOGFONT* lf) {
     LogFontTypeface* face = static_cast<LogFontTypeface*>(SkTypefaceCache::FindByID(fontID));
     if (face) {
         *lf = face->fLogFont;
     } else {
         sk_bzero(lf, sizeof(LOGFONT));
     }
 }
 
 // Construct Glyph to Unicode table.
@@ skipping 241 matching lines @@
             return CLEARTYPE_QUALITY;
         default:
             if (rec.fFlags & SkScalerContext::kGenA8FromLCD_Flag) {
                 return CLEARTYPE_QUALITY;
             } else {
                 return ANTIALIASED_QUALITY;
             }
     }
 }
 
-SkScalerContext_Windows::SkScalerContext_Windows(SkTypeface* typeface,
+SkScalerContext_Windows::SkScalerContext_Windows(SkTypeface* rawTypeface,
                                                  const SkDescriptor* desc)
-        : SkScalerContext(typeface, desc), fDDC(0), fFont(0), fSavefont(0), fSC(0)
+        : SkScalerContext(rawTypeface, desc)
+        , fDDC(0)
+        , fFont(0)
+        , fSavefont(0)
+        , fSC(0)
         , fGlyphCount(-1) {
     SkAutoMutexAcquire  ac(gFTMutex);
 
+    LogFontTypeface* typeface = reinterpret_cast<LogFontTypeface*>(rawTypeface);
+
     fDDC = ::CreateCompatibleDC(NULL);
     SetGraphicsMode(fDDC, GM_ADVANCED);
     SetBkMode(fDDC, TRANSPARENT);
 
     // Scaling by the DPI is inconsistent with how Skia draws elsewhere
     //SkScalar height = -(fRec.fTextSize * GetDeviceCaps(ddc, LOGPIXELSY) / 72);
-    LOGFONT lf;
-    GetLogFontByID(fRec.fFontID, &lf);
+    LOGFONT lf = typeface->fLogFont;
     lf.lfHeight = -gCanonicalTextSize;
     lf.lfQuality = compute_quality(fRec);
     fFont = CreateFontIndirect(&lf);
 
     // if we're rotated, or want fractional widths, create a hires font
     fHiResFont = 0;
     if (needHiResMetrics(fRec.fPost2x2)) {
         lf.lfHeight = -HIRES_TEXTSIZE;
         fHiResFont = CreateFontIndirect(&lf);
 
         fMat22Identity.eM11 = fMat22Identity.eM22 = SkFixedToFIXED(SK_Fixed1);
         fMat22Identity.eM12 = fMat22Identity.eM21 = SkFixedToFIXED(0);
 
         // construct a matrix to go from HIRES logical units to our device units
         fRec.getSingleMatrix(&fHiResMatrix);
         SkScalar scale = SkScalarInvert(SkIntToScalar(HIRES_TEXTSIZE));
         fHiResMatrix.preScale(scale, scale);
     }
     fSavefont = (HFONT)SelectObject(fDDC, fFont);
 
     if (0 == GetTextMetrics(fDDC, &fTM)) {
-        ensure_typeface_accessible(fRec.fFontID);
+        call_ensure_accessible(lf);
         if (0 == GetTextMetrics(fDDC, &fTM)) {
             fTM.tmPitchAndFamily = TMPF_TRUETYPE;
         }
     }
     // Used a logfont on a memory context, should never get a device font.
     // Therefore all TMPF_DEVICE will be PostScript fonts.
 
     // If TMPF_VECTOR is set, one of TMPF_TRUETYPE or TMPF_DEVICE must be set,
     // otherwise we have a vector FON, which we don't support.
     // This was determined by testing with Type1 PFM/PFB and OpenTypeCFF OTF,
@@ skipping 46 matching lines @@
         fMat22.eM21 = SkScalarToFIXED(-fRec.fPost2x2[0][1]);
         fMat22.eM22 = SkScalarToFIXED(fRec.fPost2x2[1][1]);
 
         lf.lfHeight = -SkScalarCeilToInt(fRec.fTextSize);
         HFONT bitmapFont = CreateFontIndirect(&lf);
         SelectObject(fDDC, bitmapFont);
         ::DeleteObject(fFont);
         fFont = bitmapFont;
 
         if (0 == GetTextMetrics(fDDC, &fTM)) {
-            ensure_typeface_accessible(fRec.fFontID);
+            call_ensure_accessible(lf);
             //if the following fails, we'll just draw at gCanonicalTextSize.
             GetTextMetrics(fDDC, &fTM);
         }
     }
 
     fOffscreen.init(fFont, xform);
 }
 
 SkScalerContext_Windows::~SkScalerContext_Windows() {
     if (fDDC) {
@@ skipping 75 matching lines @@
         return;
     }
 
     UINT glyphId = glyph->getGlyphID(0);
 
     GLYPHMETRICS gm;
     sk_bzero(&gm, sizeof(gm));
 
     DWORD status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22);
     if (GDI_ERROR == status) {
-        ensure_typeface_accessible(fRec.fFontID);
+        LogFontTypeface::EnsureAccessible(this->getTypeface());
         status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22);
         if (GDI_ERROR == status) {
             glyph->zeroMetrics();
             return;
         }
     }
 
     bool empty = false;
     // The black box is either the embedded bitmap size or the outline extent.
     // It is 1x1 if nothing is to be drawn, but will also be 1x1 if something very small
@@ skipping 64 matching lines @@
             my->fLeading = SkIntToScalar(fTM.tmInternalLeading
                                          + fTM.tmExternalLeading);
         }
         return;
     }
 
     OUTLINETEXTMETRIC otm;
 
     uint32_t ret = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
     if (GDI_ERROR == ret) {
-        ensure_typeface_accessible(fRec.fFontID);
+        LogFontTypeface::EnsureAccessible(this->getTypeface());
         ret = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
     }
     if (sizeof(otm) != ret) {
         return;
     }
 
     if (mx) {
         mx->fTop = -fScale * otm.otmTextMetrics.tmAscent;
         mx->fAscent = -fScale * otm.otmAscent;
         mx->fDescent = -fScale * otm.otmDescent;
@@ skipping 222 matching lines @@
 void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
     SkAutoMutexAcquire ac(gFTMutex);
     SkASSERT(fDDC);
 
     const bool isBW = SkMask::kBW_Format == fRec.fMaskFormat;
     const bool isAA = !isLCD(fRec);
 
     size_t srcRB;
     const void* bits = fOffscreen.draw(glyph, isBW, &srcRB);
     if (NULL == bits) {
-        ensure_typeface_accessible(fRec.fFontID);
+        LogFontTypeface::EnsureAccessible(this->getTypeface());
         bits = fOffscreen.draw(glyph, isBW, &srcRB);
         if (NULL == bits) {
             sk_bzero(glyph.fImage, glyph.computeImageSize());
             return;
         }
     }
 
     if (!isBW) {
         const uint8_t* table;
         //The offscreen contains a GDI blit if isAA and kGenA8FromLCD_Flag is not set.
@@ skipping 72 matching lines @@
     SkAutoMutexAcquire ac(gFTMutex);
 
     SkASSERT(&glyph && path);
     SkASSERT(fDDC);
 
     path->reset();
 
     GLYPHMETRICS gm;
     uint32_t total_size = GetGlyphOutlineW(fDDC, glyph.fID, GGO_NATIVE | GGO_GLYPH_INDEX, &gm, BUFFERSIZE, glyphbuf, &fMat22);
     if (GDI_ERROR == total_size) {
-        ensure_typeface_accessible(fRec.fFontID);
+        LogFontTypeface::EnsureAccessible(this->getTypeface());
         total_size = GetGlyphOutlineW(fDDC, glyph.fID, GGO_NATIVE | GGO_GLYPH_INDEX, &gm, BUFFERSIZE, glyphbuf, &fMat22);
         if (GDI_ERROR == total_size) {
             SkASSERT(false);
             return;
         }
     }
 
     const uint8_t* cur_glyph = glyphbuf;
     const uint8_t* end_glyph = glyphbuf + total_size;
 
@@ skipping 78 matching lines @@
     SkFontDescriptor descriptor(face->style());
 
     // Get the actual name of the typeface. The logfont may not know this.
     HFONT font = CreateFontIndirect(&face->fLogFont);
 
     HDC deviceContext = ::CreateCompatibleDC(NULL);
     HFONT savefont = (HFONT)SelectObject(deviceContext, font);
 
     int fontNameLen; //length of fontName in TCHARS.
     if (0 == (fontNameLen = GetTextFace(deviceContext, 0, NULL))) {
-        SkFontHost::EnsureTypefaceAccessible(*rawFace);
+        LogFontTypeface::EnsureAccessible(rawFace);
         if (0 == (fontNameLen = GetTextFace(deviceContext, 0, NULL))) {
             fontNameLen = 0;
         }
     }
 
     SkAutoSTArray<LF_FULLFACESIZE, TCHAR> fontName(fontNameLen+1);
     if (0 == GetTextFace(deviceContext, fontNameLen, fontName.get())) {
-        SkFontHost::EnsureTypefaceAccessible(*rawFace);
+        LogFontTypeface::EnsureAccessible(rawFace);
         if (0 == GetTextFace(deviceContext, fontNameLen, fontName.get())) {
             fontName[0] = 0;
         }
     }
 
     if (deviceContext) {
         ::SelectObject(deviceContext, savefont);
         ::DeleteDC(deviceContext);
     }
     if (font) {
@@ skipping 62 matching lines @@
 
     const char stem_chars[] = {'i', 'I', '!', '1'};
     int16_t min_width;
     unsigned glyphCount;
 
     // To request design units, create a logical font whose height is specified
     // as unitsPerEm.
     OUTLINETEXTMETRIC otm;
     unsigned int otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
     if (0 == otmRet) {
-        ensure_typeface_accessible(this->uniqueID());
+        call_ensure_accessible(lf);
         otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
     }
     if (!otmRet || !GetTextFace(hdc, LF_FACESIZE, lf.lfFaceName)) {
         goto Error;
     }
     lf.lfHeight = -SkToS32(otm.otmEMSquare);
     designFont = CreateFontIndirect(&lf);
     SelectObject(hdc, designFont);
     if (!GetOutlineTextMetrics(hdc, sizeof(otm), &otm)) {
         goto Error;
@@ skipping 201 matching lines @@
 
     HDC hdc = ::CreateCompatibleDC(NULL);
     HFONT font = CreateFontIndirect(&lf);
     HFONT savefont = (HFONT)SelectObject(hdc, font);
 
     SkMemoryStream* stream = NULL;
     DWORD tables[2] = {kTTCTag, 0};
     for (int i = 0; i < SK_ARRAY_COUNT(tables); i++) {
         size_t bufferSize = GetFontData(hdc, tables[i], 0, NULL, 0);
         if (bufferSize == GDI_ERROR) {
-            ensure_typeface_accessible(uniqueID);
+            call_ensure_accessible(lf);
             bufferSize = GetFontData(hdc, tables[i], 0, NULL, 0);
         }
         if (bufferSize != GDI_ERROR) {
             stream = new SkMemoryStream(bufferSize);
             if (GetFontData(hdc, tables[i], 0, (void*)stream->getMemoryBase(),
                             bufferSize)) {
                 break;
             } else {
                 delete stream;
                 stream = NULL;
@@ skipping 84 matching lines @@
     if (isLCD(*rec) && !isAxisAligned(*rec)) {
         rec->fMaskFormat = SkMask::kA8_Format;
     }
 #endif
 
     if (!fCanBeLCD && isLCD(*rec)) {
         rec->fMaskFormat = SkMask::kA8_Format;
         rec->fFlags &= ~SkScalerContext::kGenA8FromLCD_Flag;
     }
 }