Fix append_fallback_font_families_for_locale.

src/ports/SkFontConfigParser_android.cpp

 /*
  * Copyright 2011 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 "SkFontConfigParser_android.h"
 #include "SkFontMgr_android.h"
 #include "SkStream.h"
@@ skipping 484 matching lines @@
  */
 static void append_fallback_font_families_for_locale(SkTDArray<FontFamily*>& fallbackFonts,
                                                      const char* dir,
                                                      const SkString& basePath)
 {
 #if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
     // The framework is beyond Android 4.2 and can therefore skip this function
     return;
 #endif
 
-    DIR* fontDirectory = opendir(dir);
-    if (fontDirectory != NULL){
-        struct dirent* dirEntry = readdir(fontDirectory);
-        while (dirEntry) {
+    SkAutoTCallIProc<DIR, closedir> fontDirectory(opendir(dir));
+    if (NULL == fontDirectory) {
+        return;
+    }
 
-            // The size of both the prefix, suffix, and a minimum valid language code
-            static const size_t minSize = strlen(LOCALE_FALLBACK_FONTS_PREFIX) +
-                                          strlen(LOCALE_FALLBACK_FONTS_SUFFIX) + 2;
+    for (struct dirent* dirEntry; (dirEntry = readdir(fontDirectory));) {
+        // The size of both the prefix, suffix, and a minimum valid language code
+        static const size_t minSize = sizeof(LOCALE_FALLBACK_FONTS_PREFIX) - 1
+                                    + sizeof(LOCALE_FALLBACK_FONTS_SUFFIX) - 1
+                                    + 2;
 
-            SkString fileName(dirEntry->d_name);
-            if (fileName.size() >= minSize &&
-                    fileName.startsWith(LOCALE_FALLBACK_FONTS_PREFIX) &&
-                    fileName.endsWith(LOCALE_FALLBACK_FONTS_SUFFIX)) {
+        SkString fileName(dirEntry->d_name);
+        if (fileName.size() < minSize ||
+            !fileName.startsWith(LOCALE_FALLBACK_FONTS_PREFIX) ||
+            !fileName.endsWith(LOCALE_FALLBACK_FONTS_SUFFIX))
+        {
+            continue;
+        }
 
-                static const size_t fixedLen = strlen(LOCALE_FALLBACK_FONTS_PREFIX) -
-                                               strlen(LOCALE_FALLBACK_FONTS_SUFFIX);
+        static const size_t fixedLen = sizeof(LOCALE_FALLBACK_FONTS_PREFIX) - 1
+                                     + sizeof(LOCALE_FALLBACK_FONTS_SUFFIX) - 1;
 
-                SkString locale(fileName.c_str() - strlen(LOCALE_FALLBACK_FONTS_PREFIX),
-                                fileName.size() - fixedLen);
+        SkString locale(fileName.c_str() + sizeof(LOCALE_FALLBACK_FONTS_PREFIX) - 1,
+                        fileName.size() - fixedLen);
 
-                SkString absoluteFilename;
-                absoluteFilename.printf("%s/%s", dir, fileName.c_str());
+        SkString absoluteFilename;
+        absoluteFilename.printf("%s/%s", dir, fileName.c_str());
 
-                SkTDArray<FontFamily*> langSpecificFonts;
-                parse_config_file(absoluteFilename.c_str(), langSpecificFonts, basePath, true);
+        SkTDArray<FontFamily*> langSpecificFonts;
+        parse_config_file(absoluteFilename.c_str(), langSpecificFonts, basePath, true);
 
-                for (int i = 0; i < langSpecificFonts.count(); ++i) {
-                    FontFamily* family = langSpecificFonts[i];
-                    family->fLanguage = SkLanguage(locale);
-                    *fallbackFonts.append() = family;
-                }
-            }
-
-            // proceed to the next entry in the directory
-            dirEntry = readdir(fontDirectory);
+        for (int i = 0; i < langSpecificFonts.count(); ++i) {
+            FontFamily* family = langSpecificFonts[i];
+            family->fLanguage = SkLanguage(locale);
+            *fallbackFonts.append() = family;
         }
-        // cleanup the directory reference
-        closedir(fontDirectory);
     }
 }
 
 static void append_system_fallback_font_families(SkTDArray<FontFamily*>& fallbackFonts,
                                                  const SkString& basePath)
 {
     parse_config_file(FALLBACK_FONTS_FILE, fallbackFonts, basePath, true);
     append_fallback_font_families_for_locale(fallbackFonts,
                                              LOCALE_FALLBACK_FONTS_SYSTEM_DIR,
                                              basePath);
@@ skipping 44 matching lines @@
     // Append all the fallback fonts to system fonts
     SkTDArray<FontFamily*> fallbackFonts;
     append_system_fallback_font_families(fallbackFonts, basePath);
     mixin_vendor_fallback_font_families(fallbackFonts, basePath);
     fontFamilies.append(fallbackFonts.count(), fallbackFonts.begin());
 }
 
 void SkFontConfigParser::GetCustomFontFamilies(SkTDArray<FontFamily*>& fontFamilies,
                                                const SkString& basePath,
                                                const char* fontsXml,
-                                               const char* fallbackFontsXml)
+                                               const char* fallbackFontsXml,
+                                               const char* langFallbackFontsDir)
 {
     if (fontsXml) {
         parse_config_file(fontsXml, fontFamilies, basePath, false);
     }
     if (fallbackFontsXml) {
         parse_config_file(fallbackFontsXml, fontFamilies, basePath, true);
     }
+    if (langFallbackFontsDir) {
+        append_fallback_font_families_for_locale(fontFamilies,
+                                                 langFallbackFontsDir,
+                                                 basePath);
+    }
 }
 
 SkLanguage SkLanguage::getParent() const {
     SkASSERT(!fTag.isEmpty());
     const char* tag = fTag.c_str();
 
     // strip off the rightmost "-.*"
     const char* parentTagEnd = strrchr(tag, '-');
     if (parentTagEnd == NULL) {
         return SkLanguage();
     }
     size_t parentTagLen = parentTagEnd - tag;
     return SkLanguage(tag, parentTagLen);
 }