Sane use of FcPatternGetXXX in SkFontConfigInterface.

src/ports/SkFontConfigInterface_direct.cpp

 /*
  * Copyright 2009-2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */
 
 #include "SkBuffer.h"
@@ skipping 143 matching lines @@
     SkASSERT(iden0 == iden1);
 
     test_writeToMemory(iden0, 0);
     test_writeToMemory(iden0, 0);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns the string from the pattern, or nullptr
-static const char* get_name(FcPattern* pattern, const char field[],
-                            int index = 0) {
+static const char* get_string(FcPattern* pattern, const char field[], int index = 0) {
     const char* name;
-    if (FcPatternGetString(pattern, field, index,
-                           (FcChar8**)&name) != FcResultMatch) {
+    if (FcPatternGetString(pattern, field, index, (FcChar8**)&name) != FcResultMatch) {
         name = nullptr;
     }
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 // Equivalence classes, used to match the Liberation and other fonts
@@ skipping 334 matching lines @@
 }
 
 bool SkFontConfigInterfaceDirect::isAccessible(const char* filename) {
     if (access(filename, R_OK) != 0) {
         return false;
     }
     return true;
 }
 
 bool SkFontConfigInterfaceDirect::isValidPattern(FcPattern* pattern) {
-#ifdef SK_FONT_CONFIG_ONLY_ALLOW_SCALABLE_FONTS
-    FcBool is_scalable;
-    if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &is_scalable) != FcResultMatch
-        || !is_scalable) {
-        return false;
-    }
-#endif
-
 #ifdef SK_FONT_CONFIG_INTERFACE_ONLY_ALLOW_SFNT_FONTS
-    const char* font_format = get_name(pattern, FC_FONTFORMAT);
+    const char* font_format = get_string(pattern, FC_FONTFORMAT);
     if (font_format
         && strcmp(font_format, kFontFormatTrueType) != 0
         && strcmp(font_format, kFontFormatCFF) != 0)
     {
         return false;
     }
 #endif
 
     // fontconfig can also return fonts which are unreadable
-    const char* c_filename = get_name(pattern, FC_FILE);
+    const char* c_filename = get_string(pattern, FC_FILE);
     if (!c_filename) {
         return false;
     }
     return this->isAccessible(c_filename);
 }
 
 // Find matching font from |font_set| for the given font family.
 FcPattern* SkFontConfigInterfaceDirect::MatchFont(FcFontSet* font_set,
                                                   const char* post_config_family,
                                                   const SkString& family) {
   // Older versions of fontconfig have a bug where they cannot select
   // only scalable fonts so we have to manually filter the results.
   FcPattern* match = nullptr;
   for (int i = 0; i < font_set->nfont; ++i) {
     FcPattern* current = font_set->fonts[i];
     if (this->isValidPattern(current)) {
       match = current;
       break;
     }
   }
 
   if (match && !IsFallbackFontAllowed(family)) {
     bool acceptable_substitute = false;
     for (int id = 0; id < 255; ++id) {
-      const char* post_match_family = get_name(match, FC_FAMILY, id);
+      const char* post_match_family = get_string(match, FC_FAMILY, id);
       if (!post_match_family)
         break;
       acceptable_substitute =
           (strcasecmp(post_config_family, post_match_family) == 0 ||
            // Workaround for Issue 12530:
            //   requested family: "Bitstream Vera Sans"
            //   post_config_family: "Arial"
            //   post_match_family: "Bitstream Vera Sans"
            // -> We should treat this case as a good match.
            strcasecmp(family.c_str(), post_match_family) == 0) ||
@@ skipping 59 matching lines @@
     //      -> good match
     //
     // and for a missing font:
     //    requested family: "Monaco"
     //    post_config_family: "Monaco"
     //    post_match_family: "Times New Roman"
     //      -> BAD match
     //
     // However, we special-case fallback fonts; see IsFallbackFontAllowed().
 
-    const char* post_config_family = get_name(pattern, FC_FAMILY);
+    const char* post_config_family = get_string(pattern, FC_FAMILY);
     if (!post_config_family) {
         // we can just continue with an empty name, e.g. default font
         post_config_family = "";
     }
 
     FcResult result;
     FcFontSet* font_set = FcFontSort(nullptr, pattern, 0, nullptr, &result);
     if (!font_set) {
         FcPatternDestroy(pattern);
         return false;
     }
 
     FcPattern* match = this->MatchFont(font_set, post_config_family, familyStr);
     if (!match) {
         FcPatternDestroy(pattern);
         FcFontSetDestroy(font_set);
         return false;
     }
 
     FcPatternDestroy(pattern);
 
     // From here out we just extract our results from 'match'
 
-    post_config_family = get_name(match, FC_FAMILY);
+    post_config_family = get_string(match, FC_FAMILY);
     if (!post_config_family) {
         FcFontSetDestroy(font_set);
         return false;
     }
 
-    const char* c_filename = get_name(match, FC_FILE);
+    const char* c_filename = get_string(match, FC_FILE);
     if (!c_filename) {
         FcFontSetDestroy(font_set);
         return false;
     }
 
-    int face_index;
-    if (FcPatternGetInteger(match, FC_INDEX, 0, &face_index) != FcResultMatch) {
-        FcFontSetDestroy(font_set);
-        return false;
-    }
+    int face_index = get_int(match, FC_INDEX, 0);
 
     FcFontSetDestroy(font_set);
 
     if (outIdentity) {
         outIdentity->fTTCIndex = face_index;
         outIdentity->fString.set(c_filename);
     }
     if (outFamilyName) {
         outFamilyName->set(post_config_family);
     }
@@ skipping 37 matching lines @@
     FcFontSet* fs = FcFontList(nullptr, pat, os);
     SkAutoTCallVProc<FcFontSet, FcFontSetDestroy> autoDestroyFs(fs);
     if (nullptr == fs) {
         return nullptr;
     }
 
     SkTDArray<const char*> names;
     SkTDArray<size_t> sizes;
     for (int i = 0; i < fs->nfont; ++i) {
         FcPattern* match = fs->fonts[i];
-        const char* famName = get_name(match, FC_FAMILY);
+        const char* famName = get_string(match, FC_FAMILY);
         if (famName && !find_name(names, famName)) {
             *names.append() = famName;
             *sizes.append() = strlen(famName) + 1;
         }
     }
 
     return SkDataTable::MakeCopyArrays((const void*const*)names.begin(),
                                        sizes.begin(), names.count());
 }