allow both GDI and DW fontmgrs at the same time

src/ports/SkFontHost_win_dw.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 #undef GetGlyphIndices
 
@@ skipping 686 matching lines @@
 
     SkSMallocWCHAR dwFontFamilyNameChar(dwFontFamilyNameLength+1);
     SkSMallocWCHAR dwFontNameChar(dwFontNameLength+1);
     HRB(dwFontFamilyNames->GetString(0, dwFontFamilyNameChar.get(), dwFontFamilyNameLength+1));
     HRB(dwFontNames->GetString(0, dwFontNameChar.get(), dwFontNameLength+1));
 
     return wcscmp(dwFaceFontFamilyNameChar.get(), dwFontFamilyNameChar.get()) == 0 &&
            wcscmp(dwFaceFontNameChar.get(), dwFontNameChar.get()) == 0;
 }
 
-SkTypeface* SkCreateTypefaceFromDWriteFont(IDWriteFontFace* fontFace,
+SkTypeface* SkCreateTypefaceFromDWriteFont(SkTypefaceCache* cache,

[bungeman-skia, 2013/08/13 15:53:45]

This is really odd looking, I think what we logically want is not to pass a
cache, but to pass in the SkFontMgr to which we wish to add this guy. Actually,
should this sort of thing be part of the SkFontMgr?

+                                           IDWriteFontFace* fontFace,
                                            IDWriteFont* font,
                                            IDWriteFontFamily* fontFamily,
                                            StreamFontFileLoader* fontFileLoader = NULL,
                                            IDWriteFontCollectionLoader* fontCollectionLoader = NULL) {
-    SkTypeface* face = SkTypefaceCache::FindByProcAndRef(FindByDWriteFont, font);
+    SkTypeface* face = NULL;
+    if (cache) {
+        face = cache->findByProcAndRef(FindByDWriteFont, font);
+    }
     if (NULL == face) {
         face = DWriteFontTypeface::Create(fontFace, font, fontFamily,
                                           fontFileLoader, fontCollectionLoader);
-        SkTypefaceCache::Add(face, get_style(font), fontCollectionLoader != NULL);
+        if (face) {

[bungeman-skia, 2013/08/13 15:53:45]

&& cache

+            cache->add(face, get_style(font), fontCollectionLoader != NULL);
+        }
     }
     return face;
 }
 
 void SkDWriteFontFromTypeface(const SkTypeface* face, IDWriteFont** font) {
     if (NULL == face) {
         HRVM(get_default_font(font), "Could not get default font.");
     } else {
         *font = SkRefComPtr(static_cast<const DWriteFontTypeface*>(face)->fDWriteFont.get());
     }
@@ skipping 486 matching lines @@
     }
 
     HRESULT unregister(IDWriteFactory* factory, IDWriteFontCollectionLoader* unregister) {
         return factory->UnregisterFontCollectionLoader(unregister);
     }
 
     IDWriteFactory* fFactory;
     T* fUnregister;
 };
 
-static SkTypeface* create_from_stream(SkStream* stream, int ttcIndex) {
+static SkTypeface* create_from_stream(SkStream* stream, int ttcIndex,

[bungeman-skia, 2013/08/13 15:53:45]

I've been debating this for a while, but should this use the cache at all? If
the underlying font is a "local font" (provided by the OS/FontMrg) it makes
sense to cache those typefaces. However, does it make sense to try to cache
typefaces when the user says, "hey, here is some data, try to make a typeface
for me" (external font). If we already have a font of the same name somewhere
(either a "local font" or another "external font") I'm not sure we should be
returning the other one (unless we actually go and verify that the cached one is
byte identical).

+                                      SkTypefaceCache* cache) {
     IDWriteFactory* factory;
     HRN(get_dwrite_factory(&factory));
 
     SkTScopedComPtr<StreamFontFileLoader> fontFileLoader;
     HRN(StreamFontFileLoader::Create(stream, &fontFileLoader));
     HRN(factory->RegisterFontFileLoader(fontFileLoader.get()));
     SkAutoIDWriteUnregister<StreamFontFileLoader> autoUnregisterFontFileLoader(
         factory, fontFileLoader.get());
 
     SkTScopedComPtr<StreamFontCollectionLoader> fontCollectionLoader;
@@ skipping 17 matching lines @@
             HRN(fontFamily->GetFont(fontIndex, &font));
             if (font->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE) {
                 continue;
             }
 
             SkTScopedComPtr<IDWriteFontFace> fontFace;
             HRN(font->CreateFontFace(&fontFace));
 
             UINT32 faceIndex = fontFace->GetIndex();
             if (faceIndex == ttcIndex) {
-                return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get(),
+                return SkCreateTypefaceFromDWriteFont(cache, fontFace.get(), font.get(), fontFamily.get(),
                                                       autoUnregisterFontFileLoader.detatch(),
                                                       autoUnregisterFontCollectionLoader.detatch());
             }
         }
     }
 
     return NULL;
 }
 
 SkStream* DWriteFontTypeface::onOpenStream(int* ttcIndex) const {
@@ skipping 317 matching lines @@
                                glyphIDsCount,
                                getWidthAdvance));
         }
     }
 
     return info;
 }
 
 static SkTypeface* create_typeface(const SkTypeface* familyFace,
                                    const char familyName[],
-                                   unsigned style) {
+                                   unsigned style,
+                                   SkTypefaceCache* cache) {
     HRESULT hr;
     SkTScopedComPtr<IDWriteFontFamily> fontFamily;
     if (familyFace) {
         const DWriteFontTypeface* face = static_cast<const DWriteFontTypeface*>(familyFace);
         *(&fontFamily) = SkRefComPtr(face->fDWriteFontFamily.get());
 
     } else if (familyName) {
         hr = get_by_family_name(familyName, &fontFamily);
     }
 
@@ skipping 10 matching lines @@
                                  : DWRITE_FONT_WEIGHT_NORMAL;
     DWRITE_FONT_STRETCH stretch = DWRITE_FONT_STRETCH_UNDEFINED;
     DWRITE_FONT_STYLE italic = (style & SkTypeface::kItalic)
                                 ? DWRITE_FONT_STYLE_ITALIC
                                 : DWRITE_FONT_STYLE_NORMAL;
     hr = fontFamily->GetFirstMatchingFont(weight, stretch, italic, &font);
 
     SkTScopedComPtr<IDWriteFontFace> fontFace;
     hr = font->CreateFontFace(&fontFace);
 
-    return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get());
+    return SkCreateTypefaceFromDWriteFont(cache, fontFace.get(), font.get(), fontFamily.get());
 }
 
 SkTypeface* DWriteFontTypeface::onRefMatchingStyle(Style style) const {
-    return create_typeface(this, NULL, style);
+    SkTypefaceCache* cache = NULL;
+    // todo: should each typeface have a ref to its fontmgr/cache?
+    return create_typeface(this, NULL, style, cache);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkFontMgr.h"
 
 static void get_locale_string(IDWriteLocalizedStrings* names, const WCHAR* preferedLocale,
                               SkString* skname) {
     UINT32 nameIndex = 0;
     if (preferedLocale) {
@@ skipping 12 matching lines @@
     SkSMallocWCHAR name(nameLength);
     HRVM(names->GetString(nameIndex, name.get(), nameLength), "Could not get string.");
 
     HRV(wchar_to_skstring(name.get(), skname));
 }
 
 class SkFontMgr_DirectWrite;
 
 class SkFontStyleSet_DirectWrite : public SkFontStyleSet {
 public:
-    SkFontStyleSet_DirectWrite(const SkFontMgr_DirectWrite* fontMgr, IDWriteFontFamily* fontFamily)
+    SkFontStyleSet_DirectWrite(SkFontMgr_DirectWrite* fontMgr, IDWriteFontFamily* fontFamily)
         : fFontMgr(SkRef(fontMgr))
         , fFontFamily(SkRefComPtr(fontFamily))
     { }
 
-    virtual int count() SK_OVERRIDE {
-        return fFontFamily->GetFontCount();
-    }
-
-    virtual void getStyle(int index, SkFontStyle* fs, SkString* styleName);
-
-    virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
-        SkTScopedComPtr<IDWriteFont> font;
-        HRNM(fFontFamily->GetFont(index, &font), "Could not get font.");
-
-        SkTScopedComPtr<IDWriteFontFace> fontFace;
-        HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
-
-        return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fFontFamily.get());
-    }
-
-    virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
-        DWRITE_FONT_STYLE slant;
-        switch (pattern.slant()) {
-        case SkFontStyle::kUpright_Slant:
-            slant = DWRITE_FONT_STYLE_NORMAL;
-            break;
-        case SkFontStyle::kItalic_Slant:
-            slant = DWRITE_FONT_STYLE_ITALIC;
-            break;
-        default:
-            SkASSERT(false);
-        }
-
-        DWRITE_FONT_WEIGHT weight = (DWRITE_FONT_WEIGHT)pattern.weight();
-        DWRITE_FONT_STRETCH width = (DWRITE_FONT_STRETCH)pattern.width();
-
-        SkTScopedComPtr<IDWriteFont> font;
-        // TODO: perhaps use GetMatchingFonts and get the least simulated?
-        HRNM(fFontFamily->GetFirstMatchingFont(weight, width, slant, &font),
-             "Could not match font in family.");
-
-        SkTScopedComPtr<IDWriteFontFace> fontFace;
-        HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
-
-        return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fFontFamily.get());
-    }
+    virtual int count() SK_OVERRIDE;
+    virtual void getStyle(int index, SkFontStyle* fs, SkString* styleName) SK_OVERRIDE;
+    virtual SkTypeface* createTypeface(int index) SK_OVERRIDE;
+    virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE;
 
 private:
-    SkAutoTUnref<const SkFontMgr_DirectWrite> fFontMgr;
+    SkAutoTUnref<SkFontMgr_DirectWrite> fFontMgr;
     SkTScopedComPtr<IDWriteFontFamily> fFontFamily;
 };
 
 class SkFontMgr_DirectWrite : public SkFontMgr {
 public:
     /** localeNameLength must include the null terminator. */
     SkFontMgr_DirectWrite(IDWriteFontCollection* fontCollection,
                           WCHAR* localeName, int localeNameLength)
         : fFontCollection(SkRefComPtr(fontCollection))
         , fLocaleName(localeNameLength)
     {
         memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
     }
 
+    SkTypefaceCache* getTypefaceCache() { return &fTFCache; }
+
 private:
     friend class SkFontStyleSet_DirectWrite;
     SkTScopedComPtr<IDWriteFontCollection> fFontCollection;
     SkSMallocWCHAR fLocaleName;
+    SkTypefaceCache fTFCache;
 
 protected:
     virtual int onCountFamilies() SK_OVERRIDE {
         return fFontCollection->GetFontFamilyCount();
     }
     virtual void onGetFamilyName(int index, SkString* familyName) SK_OVERRIDE {
         SkTScopedComPtr<IDWriteFontFamily> fontFamily;
         HRVM(fFontCollection->GetFontFamily(index, &fontFamily), "Could not get requested family.");
 
         SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
@@ skipping 29 matching lines @@
     }
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
                                          const SkFontStyle& fontstyle) SK_OVERRIDE {
         SkString familyName;
         SkFontStyleSet_DirectWrite sset(
             this, ((DWriteFontTypeface*)familyMember)->fDWriteFontFamily.get()
         );
         return sset.matchStyle(fontstyle);
     }
     virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) SK_OVERRIDE {
-        return create_from_stream(stream, ttcIndex);
+        return create_from_stream(stream, ttcIndex, this->getTypefaceCache());
     }
     virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) SK_OVERRIDE {
         SkAutoTUnref<SkStream> stream(SkNEW_ARGS(SkMemoryStream, (data)));
         return this->createFromStream(stream, ttcIndex);
     }
     virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) SK_OVERRIDE {
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
         return this->createFromStream(stream, ttcIndex);
     }
 
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
                                                unsigned styleBits) SK_OVERRIDE {
-        return create_typeface(NULL, familyName, styleBits);
+        return create_typeface(NULL, familyName, styleBits, this->getTypefaceCache());
     }
 };
 
+///////////////////////////////////////////////////////////////////////////////
+
+int SkFontStyleSet_DirectWrite::count() {
+    return fFontFamily->GetFontCount();
+}
+
+SkTypeface* SkFontStyleSet_DirectWrite::createTypeface(int index) {
+    SkTScopedComPtr<IDWriteFont> font;
+    HRNM(fFontFamily->GetFont(index, &font), "Could not get font.");
+
+    SkTScopedComPtr<IDWriteFontFace> fontFace;
+    HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
+
+    return SkCreateTypefaceFromDWriteFont(fFontMgr->getTypefaceCache(),
+                                            fontFace.get(), font.get(), fFontFamily.get());
+}
+
 void SkFontStyleSet_DirectWrite::getStyle(int index, SkFontStyle* fs, SkString* styleName) {
     SkTScopedComPtr<IDWriteFont> font;
     HRVM(fFontFamily->GetFont(index, &font), "Could not get font.");
 
     SkFontStyle::Slant slant;
     switch (font->GetStyle()) {
     case DWRITE_FONT_STYLE_NORMAL:
         slant = SkFontStyle::kUpright_Slant;
         break;
     case DWRITE_FONT_STYLE_OBLIQUE:
     case DWRITE_FONT_STYLE_ITALIC:
         slant = SkFontStyle::kItalic_Slant;
         break;
     default:
         SkASSERT(false);
     }
 
     int weight = font->GetWeight();
     int width = font->GetStretch();
 
     *fs = SkFontStyle(weight, width, slant);
 
     SkTScopedComPtr<IDWriteLocalizedStrings> faceNames;
     if (SUCCEEDED(font->GetFaceNames(&faceNames))) {
         get_locale_string(faceNames.get(), fFontMgr->fLocaleName.get(), styleName);
     }
 }
 
+SkTypeface* SkFontStyleSet_DirectWrite::matchStyle(const SkFontStyle& pattern) {
+    DWRITE_FONT_STYLE slant;
+    switch (pattern.slant()) {
+    case SkFontStyle::kUpright_Slant:
+        slant = DWRITE_FONT_STYLE_NORMAL;
+        break;
+    case SkFontStyle::kItalic_Slant:
+        slant = DWRITE_FONT_STYLE_ITALIC;
+        break;
+    default:
+        SkASSERT(false);
+    }
+
+    DWRITE_FONT_WEIGHT weight = (DWRITE_FONT_WEIGHT)pattern.weight();
+    DWRITE_FONT_STRETCH width = (DWRITE_FONT_STRETCH)pattern.width();
+
+    SkTScopedComPtr<IDWriteFont> font;
+    // TODO: perhaps use GetMatchingFonts and get the least simulated?
+    HRNM(fFontFamily->GetFirstMatchingFont(weight, width, slant, &font),
+            "Could not match font in family.");
+
+    SkTScopedComPtr<IDWriteFontFace> fontFace;
+    HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
+
+    return SkCreateTypefaceFromDWriteFont(fFontMgr->getTypefaceCache(),
+                                            fontFace.get(), font.get(), fFontFamily.get());
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef SK_FONTHOST_USES_FONTMGR
 
 SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
                                        const char familyName[],
                                        SkTypeface::Style style) {
     return create_typeface(familyFace, familyName, style);
 }
 
 SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
     printf("SkFontHost::CreateTypefaceFromFile unimplemented");
     return NULL;
 }
 
 SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {
-    return create_from_stream(stream, 0);
+    return create_from_stream(stream, 0, NULL);
 }
 
 #endif
 
-SkFontMgr* SkFontMgr::Factory() {
+extern SkFontMgr* SkFontMgr_New_DirectWrite();
+SkFontMgr* SkFontMgr_New_DirectWrite() {
     IDWriteFactory* factory;
     HRNM(get_dwrite_factory(&factory), "Could not get factory.");
 
     SkTScopedComPtr<IDWriteFontCollection> sysFontCollection;
     HRNM(factory->GetSystemFontCollection(&sysFontCollection, FALSE),
          "Could not get system font collection.");
 
     WCHAR localeNameStorage[LOCALE_NAME_MAX_LENGTH];
     WCHAR* localeName = NULL;
     int localeNameLen = GetUserDefaultLocaleName(localeNameStorage, LOCALE_NAME_MAX_LENGTH);
     if (localeNameLen) {
         localeName = localeNameStorage;
     };
 
     return SkNEW_ARGS(SkFontMgr_DirectWrite, (sysFontCollection.get(), localeName, localeNameLen));
 }
+