Clean up DirectWrite typeface cache matching.

src/ports/SkFontMgr_win_dw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDWrite.h"
 #include "SkDWriteFontFileStream.h"
 #include "SkFontMgr.h"
@@ skipping 241 matching lines @@
     /** localeNameLength must include the null terminator. */
     SkFontMgr_DirectWrite(IDWriteFactory* factory, IDWriteFontCollection* fontCollection,
                           WCHAR* localeName, int localeNameLength)
         : fFactory(SkRefComPtr(factory))
         , fFontCollection(SkRefComPtr(fontCollection))
         , fLocaleName(localeNameLength)
     {
         memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
     }
 
-    /** Creates a typeface using a typeface cache. */
-    SkTypeface* createTypefaceFromDWriteFont(IDWriteFontFace* fontFace,
-                                             IDWriteFont* font,
-                                             IDWriteFontFamily* fontFamily) const;
-
 protected:
     virtual int onCountFamilies() const SK_OVERRIDE;
     virtual void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE;
     virtual SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE;
     virtual SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE;
     virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
                                            const SkFontStyle& fontstyle) const SK_OVERRIDE;
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
                                          const SkFontStyle& fontstyle) const SK_OVERRIDE;
     virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) const SK_OVERRIDE;
     virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE;
     virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE;
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
                                                unsigned styleBits) const SK_OVERRIDE;
 
 private:
     HRESULT getByFamilyName(const WCHAR familyName[], IDWriteFontFamily** fontFamily) const;
     HRESULT getDefaultFontFamily(IDWriteFontFamily** fontFamily) const;
 
-    void Add(SkTypeface* face, SkTypeface::Style requestedStyle, bool strong) const {
-        SkAutoMutexAcquire ama(fTFCacheMutex);
-        fTFCache.add(face, requestedStyle, strong);
-    }
-
-    SkTypeface* FindByProcAndRef(SkTypefaceCache::FindProc proc, void* ctx) const {
-        SkAutoMutexAcquire ama(fTFCacheMutex);
-        SkTypeface* typeface = fTFCache.findByProcAndRef(proc, ctx);
-        return typeface;
-    }
+    /** Creates a typeface using a typeface cache. */
+    SkTypeface* createTypefaceFromDWriteFont(IDWriteFontFace* fontFace,
+                                             IDWriteFont* font,
+                                             IDWriteFontFamily* fontFamily) const;
 
     SkTScopedComPtr<IDWriteFactory> fFactory;
     SkTScopedComPtr<IDWriteFontCollection> fFontCollection;
     SkSMallocWCHAR fLocaleName;
     mutable SkMutex fTFCacheMutex;
     mutable SkTypefaceCache fTFCache;
 
     friend class SkFontStyleSet_DirectWrite;
 };
 
 class SkFontStyleSet_DirectWrite : public SkFontStyleSet {
 public:
     SkFontStyleSet_DirectWrite(const SkFontMgr_DirectWrite* fontMgr,
                                IDWriteFontFamily* fontFamily)
         : fFontMgr(SkRef(fontMgr))
         , fFontFamily(SkRefComPtr(fontFamily))
     { }
 
     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;
     SkTScopedComPtr<IDWriteFontFamily> fFontFamily;
 };
 
-static bool are_same(IUnknown* a, IUnknown* b) {
+static HRESULT are_same(IUnknown* a, IUnknown* b, bool& same) {
     SkTScopedComPtr<IUnknown> iunkA;
-    if (FAILED(a->QueryInterface(&iunkA))) {
-        return false;
+    HRM(a->QueryInterface(&iunkA), "Failed to QI<IUnknown> for a.");
+
+    SkTScopedComPtr<IUnknown> iunkB;
+    HRM(b->QueryInterface(&iunkB), "Failed to QI<IUnknown> for b.");
+
+    same = (iunkA.get() == iunkB.get());
+    return S_OK;
+}
+
+struct ProtoDWriteTypeface {
+    IDWriteFontFace* fDWriteFontFace;
+    IDWriteFont* fDWriteFont;
+    IDWriteFontFamily* fDWriteFontFamily;
+};
+
+static bool FindByDWriteFont(SkTypeface* cached, SkTypeface::Style, void* ctx) {
+    DWriteFontTypeface* cshFace = reinterpret_cast<DWriteFontTypeface*>(cached);
+    ProtoDWriteTypeface* ctxFace = reinterpret_cast<ProtoDWriteTypeface*>(ctx);
+    bool same;
+
+    //Check to see if the two fonts are identical.
+    HRB(are_same(cshFace->fDWriteFont.get(), ctxFace->fDWriteFont, same));
+    if (same) {
+        return true;
     }
 
-    SkTScopedComPtr<IUnknown> iunkB;
-    if (FAILED(b->QueryInterface(&iunkB))) {
-        return false;
-    }
-
-    return iunkA.get() == iunkB.get();
-}
-
-static bool FindByDWriteFont(SkTypeface* face, SkTypeface::Style, void* ctx) {
-    //Check to see if the two fonts are identical.
-    DWriteFontTypeface* dwFace = reinterpret_cast<DWriteFontTypeface*>(face);
-    IDWriteFont* dwFont = reinterpret_cast<IDWriteFont*>(ctx);
-    if (are_same(dwFace->fDWriteFont.get(), dwFont)) {
+    HRB(are_same(cshFace->fDWriteFontFace.get(), ctxFace->fDWriteFontFace, same));
+    if (same) {
         return true;
     }
 
     //Check if the two fonts share the same loader and have the same key.
-    SkTScopedComPtr<IDWriteFontFace> dwFaceFontFace;
-    SkTScopedComPtr<IDWriteFontFace> dwFontFace;
-    HRB(dwFace->fDWriteFont->CreateFontFace(&dwFaceFontFace));
-    HRB(dwFont->CreateFontFace(&dwFontFace));
-    if (are_same(dwFaceFontFace.get(), dwFontFace.get())) {
-        return true;
-    }
-
-    UINT32 dwFaceNumFiles;
-    UINT32 dwNumFiles;
-    HRB(dwFaceFontFace->GetFiles(&dwFaceNumFiles, NULL));
-    HRB(dwFontFace->GetFiles(&dwNumFiles, NULL));
-    if (dwFaceNumFiles != dwNumFiles) {
+    UINT32 cshNumFiles;
+    UINT32 ctxNumFiles;
+    HRB(cshFace->fDWriteFontFace->GetFiles(&cshNumFiles, NULL));
+    HRB(ctxFace->fDWriteFontFace->GetFiles(&ctxNumFiles, NULL));
+    if (cshNumFiles != ctxNumFiles) {
         return false;
     }
 
-    SkTScopedComPtr<IDWriteFontFile> dwFaceFontFile;
-    SkTScopedComPtr<IDWriteFontFile> dwFontFile;
-    HRB(dwFaceFontFace->GetFiles(&dwFaceNumFiles, &dwFaceFontFile));
-    HRB(dwFontFace->GetFiles(&dwNumFiles, &dwFontFile));
+    SkTScopedComPtr<IDWriteFontFile> cshFontFile;
+    SkTScopedComPtr<IDWriteFontFile> ctxFontFile;
+    HRB(cshFace->fDWriteFontFace->GetFiles(&cshNumFiles, &cshFontFile));
+    HRB(ctxFace->fDWriteFontFace->GetFiles(&ctxNumFiles, &ctxFontFile));
 
     //for (each file) { //we currently only admit fonts from one file.
-    SkTScopedComPtr<IDWriteFontFileLoader> dwFaceFontFileLoader;
-    SkTScopedComPtr<IDWriteFontFileLoader> dwFontFileLoader;
-    HRB(dwFaceFontFile->GetLoader(&dwFaceFontFileLoader));
-    HRB(dwFontFile->GetLoader(&dwFontFileLoader));
-    if (!are_same(dwFaceFontFileLoader.get(), dwFontFileLoader.get())) {
+    SkTScopedComPtr<IDWriteFontFileLoader> cshFontFileLoader;
+    SkTScopedComPtr<IDWriteFontFileLoader> ctxFontFileLoader;
+    HRB(cshFontFile->GetLoader(&cshFontFileLoader));
+    HRB(ctxFontFile->GetLoader(&ctxFontFileLoader));
+    HRB(are_same(cshFontFileLoader.get(), ctxFontFileLoader.get(), same));
+    if (!same) {
         return false;
     }
     //}
 
-    const void* dwFaceFontRefKey;
-    UINT32 dwFaceFontRefKeySize;
-    const void* dwFontRefKey;
-    UINT32 dwFontRefKeySize;
-    HRB(dwFaceFontFile->GetReferenceKey(&dwFaceFontRefKey, &dwFaceFontRefKeySize));
-    HRB(dwFontFile->GetReferenceKey(&dwFontRefKey, &dwFontRefKeySize));
-    if (dwFaceFontRefKeySize != dwFontRefKeySize) {
+    const void* cshRefKey;
+    UINT32 cshRefKeySize;
+    const void* ctxRefKey;
+    UINT32 ctxRefKeySize;
+    HRB(cshFontFile->GetReferenceKey(&cshRefKey, &cshRefKeySize));
+    HRB(ctxFontFile->GetReferenceKey(&ctxRefKey, &ctxRefKeySize));
+    if (cshRefKeySize != ctxRefKeySize) {
         return false;
     }
-    if (0 != memcmp(dwFaceFontRefKey, dwFontRefKey, dwFontRefKeySize)) {
+    if (0 != memcmp(cshRefKey, ctxRefKey, ctxRefKeySize)) {
         return false;
     }
 
     //TODO: better means than comparing name strings?
-    //NOTE: .tfc and fake bold/italic will end up here.
-    SkTScopedComPtr<IDWriteFontFamily> dwFaceFontFamily;
-    SkTScopedComPtr<IDWriteFontFamily> dwFontFamily;
-    HRB(dwFace->fDWriteFont->GetFontFamily(&dwFaceFontFamily));
-    HRB(dwFont->GetFontFamily(&dwFontFamily));
+    //NOTE: .ttc and fake bold/italic will end up here.
+    SkTScopedComPtr<IDWriteLocalizedStrings> cshFamilyNames;
+    SkTScopedComPtr<IDWriteLocalizedStrings> cshFaceNames;
+    HRB(cshFace->fDWriteFontFamily->GetFamilyNames(&cshFamilyNames));
+    HRB(cshFace->fDWriteFont->GetFaceNames(&cshFaceNames));
+    UINT32 cshFamilyNameLength;
+    UINT32 cshFaceNameLength;
+    HRB(cshFamilyNames->GetStringLength(0, &cshFamilyNameLength));
+    HRB(cshFaceNames->GetStringLength(0, &cshFaceNameLength));
 
-    SkTScopedComPtr<IDWriteLocalizedStrings> dwFaceFontFamilyNames;
-    SkTScopedComPtr<IDWriteLocalizedStrings> dwFaceFontNames;
-    HRB(dwFaceFontFamily->GetFamilyNames(&dwFaceFontFamilyNames));
-    HRB(dwFace->fDWriteFont->GetFaceNames(&dwFaceFontNames));
+    SkTScopedComPtr<IDWriteLocalizedStrings> ctxFamilyNames;
+    SkTScopedComPtr<IDWriteLocalizedStrings> ctxFaceNames;
+    HRB(ctxFace->fDWriteFontFamily->GetFamilyNames(&ctxFamilyNames));
+    HRB(ctxFace->fDWriteFont->GetFaceNames(&ctxFaceNames));
+    UINT32 ctxFamilyNameLength;
+    UINT32 ctxFaceNameLength;
+    HRB(ctxFamilyNames->GetStringLength(0, &ctxFamilyNameLength));
+    HRB(ctxFaceNames->GetStringLength(0, &ctxFaceNameLength));
 
-    SkTScopedComPtr<IDWriteLocalizedStrings> dwFontFamilyNames;
-    SkTScopedComPtr<IDWriteLocalizedStrings> dwFontNames;
-    HRB(dwFontFamily->GetFamilyNames(&dwFontFamilyNames));
-    HRB(dwFont->GetFaceNames(&dwFontNames));
-
-    UINT32 dwFaceFontFamilyNameLength;
-    UINT32 dwFaceFontNameLength;
-    HRB(dwFaceFontFamilyNames->GetStringLength(0, &dwFaceFontFamilyNameLength));
-    HRB(dwFaceFontNames->GetStringLength(0, &dwFaceFontNameLength));
-
-    UINT32 dwFontFamilyNameLength;
-    UINT32 dwFontNameLength;
-    HRB(dwFontFamilyNames->GetStringLength(0, &dwFontFamilyNameLength));
-    HRB(dwFontNames->GetStringLength(0, &dwFontNameLength));
-
-    if (dwFaceFontFamilyNameLength != dwFontFamilyNameLength ||
-        dwFaceFontNameLength != dwFontNameLength)
+    if (cshFamilyNameLength != ctxFamilyNameLength ||
+        cshFaceNameLength != ctxFaceNameLength)
     {
         return false;
     }
 
-    SkSMallocWCHAR dwFaceFontFamilyNameChar(dwFaceFontFamilyNameLength+1);
-    SkSMallocWCHAR dwFaceFontNameChar(dwFaceFontNameLength+1);
-    HRB(dwFaceFontFamilyNames->GetString(0, dwFaceFontFamilyNameChar.get(), dwFaceFontFamilyNameLength+1));
-    HRB(dwFaceFontNames->GetString(0, dwFaceFontNameChar.get(), dwFaceFontNameLength+1));
+    SkSMallocWCHAR cshFamilyName(cshFamilyNameLength+1);
+    SkSMallocWCHAR cshFaceName(cshFaceNameLength+1);
+    HRB(cshFamilyNames->GetString(0, cshFamilyName.get(), cshFamilyNameLength+1));
+    HRB(cshFaceNames->GetString(0, cshFaceName.get(), cshFaceNameLength+1));
 
-    SkSMallocWCHAR dwFontFamilyNameChar(dwFontFamilyNameLength+1);
-    SkSMallocWCHAR dwFontNameChar(dwFontNameLength+1);
-    HRB(dwFontFamilyNames->GetString(0, dwFontFamilyNameChar.get(), dwFontFamilyNameLength+1));
-    HRB(dwFontNames->GetString(0, dwFontNameChar.get(), dwFontNameLength+1));
+    SkSMallocWCHAR ctxFamilyName(ctxFamilyNameLength+1);
+    SkSMallocWCHAR ctxFaceName(ctxFaceNameLength+1);
+    HRB(ctxFamilyNames->GetString(0, ctxFamilyName.get(), ctxFamilyNameLength+1));
+    HRB(ctxFaceNames->GetString(0, ctxFaceName.get(), ctxFaceNameLength+1));
 
-    return wcscmp(dwFaceFontFamilyNameChar.get(), dwFontFamilyNameChar.get()) == 0 &&
-           wcscmp(dwFaceFontNameChar.get(), dwFontNameChar.get()) == 0;
+    return wcscmp(cshFamilyName.get(), ctxFamilyName.get()) == 0 &&
+           wcscmp(cshFaceName.get(), ctxFaceName.get()) == 0;
 }
 
 SkTypeface* SkFontMgr_DirectWrite::createTypefaceFromDWriteFont(
         IDWriteFontFace* fontFace,
         IDWriteFont* font,
         IDWriteFontFamily* fontFamily) const {
-    SkTypeface* face = FindByProcAndRef(FindByDWriteFont, font);
+    SkAutoMutexAcquire ama(fTFCacheMutex);
+    ProtoDWriteTypeface spec = { fontFace, font, fontFamily };
+    SkTypeface* face = fTFCache.findByProcAndRef(FindByDWriteFont, &spec);
     if (NULL == face) {
         face = DWriteFontTypeface::Create(fFactory.get(), fontFace, font, fontFamily);
         if (face) {
-            Add(face, get_style(font), true);
+            fTFCache.add(face, get_style(font), true);
         }
     }
     return face;
 }
 
 int SkFontMgr_DirectWrite::onCountFamilies() const {
     return fFontCollection->GetFontFamilyCount();
 }
 
 void SkFontMgr_DirectWrite::onGetFamilyName(int index, SkString* familyName) const {
@@ skipping 306 matching lines @@
 }
 
 #include "SkFontMgr_indirect.h"
 SK_API SkFontMgr* SkFontMgr_New_DirectWriteRenderer(SkRemotableFontMgr* proxy) {
     SkAutoTUnref<SkFontMgr> impl(SkFontMgr_New_DirectWrite());
     if (impl.get() == NULL) {
         return NULL;
     }
     return SkNEW_ARGS(SkFontMgr_Indirect, (impl.get(), proxy));
 }