Ensure we use the current locale when looking up fallback fonts per character

src/ports/SkFontConfigInterface_android.cpp

 
 /*
  * Copyright 2013 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 "SkFontConfigInterface.h"
 #include "SkTypeface_android.h"
@@ skipping 89 matching lines @@
      *
      */
     SkTypeface* getTypefaceForChar(SkUnichar uni, SkTypeface::Style style,
                                    SkPaintOptionsAndroid::FontVariant fontVariant);
     SkTypeface* nextLogicalTypeface(SkFontID currFontID, SkFontID origFontID,
                                     const SkPaintOptionsAndroid& options);
 
 private:
     void addFallbackFont(FontRecID fontRecID);
     SkTypeface* getTypefaceForFontRec(FontRecID fontRecID);
+    FallbackFontList* getCurrentLocaleFallbackFontList();
     FallbackFontList* findFallbackFontList(const SkLanguage& lang, bool isOriginal = true);
 
     SkTArray<FontRec> fFonts;
     SkTArray<FamilyRec> fFontFamilies;
     SkTDict<FamilyRecID> fFamilyNameDict;
     FamilyRecID fDefaultFamilyRecID;
 
     // (SkLanguage)<->(fallback chain index) translation
     SkTDict<FallbackFontList*> fFallbackFontDict;
     SkTDict<FallbackFontList*> fFallbackFontAliasDict;
     FallbackFontList fDefaultFallbackList;
+
+    // fallback info for current locale
+    SkMutex fLocaleMutex;
+    SkString fCachedLocale;
+    FallbackFontList* fLocaleFallbackFontList;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkFontConfigInterfaceAndroid* getSingletonInterface() {
     SK_DECLARE_STATIC_MUTEX(gMutex);
     static SkFontConfigInterfaceAndroid* gFontConfigInterface;
 
     SkAutoMutexAcquire ac(gMutex);
     if (NULL == gFontConfigInterface) {
@@ skipping 55 matching lines @@
                               SkTypeface::Style* style, bool* isFixedWidth);
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontConfigInterfaceAndroid::SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies) :
         fFonts(fontFamilies.count()),
         fFontFamilies(fontFamilies.count() / FamilyRec::FONT_STYLE_COUNT),
         fFamilyNameDict(1024),
         fDefaultFamilyRecID(INVALID_FAMILY_REC_ID),
         fFallbackFontDict(128),
-        fFallbackFontAliasDict(128) {
+        fFallbackFontAliasDict(128),
+        fLocaleFallbackFontList(NULL) {
 
     for (int i = 0; i < fontFamilies.count(); ++i) {
         FontFamily* family = fontFamilies[i];
 
         // defer initializing the familyRec until we can be sure that at least
         // one of it's children contains a valid font file
         FamilyRec* familyRec = NULL;
         FamilyRecID familyRecID = INVALID_FAMILY_REC_ID;
 
         for (int j = 0; j < family->fFontFiles.count(); ++j) {
@@ skipping 275 matching lines @@
         }
 
         // store the result for subsequent lookups
         fontRec.fTypeface = face;
     }
     SkASSERT(face);
     return face;
 }
 
 bool SkFontConfigInterfaceAndroid::getFallbackFamilyNameForChar(SkUnichar uni, SkString* name) {
-    for (int i = 0; i < fDefaultFallbackList.count(); i++) {
-        FontRecID fontRecID = fDefaultFallbackList[i];
+    FallbackFontList* fallbackFontList = this->getCurrentLocaleFallbackFontList();
+    for (int i = 0; i < fallbackFontList->count(); i++) {
+        FontRecID fontRecID = fallbackFontList->getAt(i);
         SkTypeface* face = this->getTypefaceForFontRec(fontRecID);
 
         SkPaint paint;
         paint.setTypeface(face);
         paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
 
         uint16_t glyphID;
         paint.textToGlyphs(&uni, sizeof(uni), &glyphID);
         if (glyphID != 0) {
             name->set(fFonts[fontRecID].fFileName);
@@ skipping 22 matching lines @@
     SkGlyphCache*    cache = autoCache.getCache();
 
     SkScalerContext* ctx = cache->getScalerContext();
     if (ctx) {
         SkFontID fontID = ctx->findTypefaceIdForChar(uni);
         return SkTypefaceCache::FindByID(fontID);
     }
     return NULL;
 }
 
+FallbackFontList* SkFontConfigInterfaceAndroid::getCurrentLocaleFallbackFontList() {
+    SkAutoMutexAcquire mutex(&fLocaleMutex);
+
+    SkString locale = SkFontConfigParser::GetLocale();
+    if (NULL == fLocaleFallbackFontList || locale != fCachedLocale) {
+        fCachedLocale = locale;
+        fLocaleFallbackFontList = this->findFallbackFontList(locale);

[reed1, 2013/06/25 16:28:45]

Does this leak the old fontlist?

[djsollen, 2013/06/25 16:38:20]

The short answer is no.  The fallbackfontlist is part of the object and as such
this pointer is guaranteed to be valid as long as the object is valid.  The
actual cleanup of the list takes place in the object's destructor.

On 2013/06/25 16:28:45, reed1 wrote:

[reed1, 2013/06/25 16:48:24]

In line 550 we assign into fLocalFallbackFontList. What if it was not null?

+    }
+
+    return fLocaleFallbackFontList;

[reed1, 2013/06/25 16:28:45]

the caller can manipulate this object outside of the mutex...

[djsollen, 2013/06/25 16:38:20]

removed the mutex in the next patch set.

On 2013/06/25 16:28:45, reed1 wrote:

+}
+
 FallbackFontList* SkFontConfigInterfaceAndroid::findFallbackFontList(const SkLanguage& lang,
                                                                      bool isOriginal) {
     const SkString& langTag = lang.getTag();
     if (langTag.isEmpty()) {
         return &fDefaultFallbackList;
     }
 
     FallbackFontList* fallbackFontList;
     if (fFallbackFontDict.find(langTag.c_str(), langTag.size(), &fallbackFontList) ||
         fFallbackFontAliasDict.find(langTag.c_str(), langTag.size(), &fallbackFontList)) {
@@ skipping 249 matching lines @@
     return SkCreateTypefaceForScriptNG(getHBScriptFromHBScriptOld(script), style, fontVariant);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return NULL;
 }