linux: handle basic metric-compatibile font fallback

skia/ext/SkFontHost_fontconfig_direct.cpp

 /* libs/graphics/ports/SkFontHost_fontconfig_direct.cpp
 **
 ** Copyright 2009, Google Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
 #include "SkFontHost_fontconfig_direct.h"
 
 #include <unistd.h>
 #include <fcntl.h>
 
 #include <fontconfig/fontconfig.h>
 
 FontConfigDirect::FontConfigDirect()
     : next_file_id_(0) {
   FcInit();
 }
 
+bool FontConfigDirect::IsMetricCompatibleReplacement(const char* font_a,
+                                                     const char* font_b)
+{
+    // It would be nice for fontconfig to tell us whether a given suggested
+    // replacement is a "strong" match (that is, an equivalent font) or
+    // a "weak" match (that is, fontconfig's next-best attempt at finding a
+    // substitute).  However, I played around with the fontconfig API for
+    // a good few hours and could not make it reveal this information.
+    //
+    // So instead, we hardcode.  These are from
+    // /etc/fonts/conf.d/30-metric-aliases.conf on my Ubuntu Karmic
+    // system.
+
+    // We represent the data with a table. Two names with the same
+    // id are in the same class.
+    struct FontEquivClass {
+        char id;
+        const char name[20];
+    };
+    static const FontEquivClass kFontEquivClasses[] = {
+        { 0, "Arial" },
+        { 0, "Liberation Sans" },
+        { 0, "Albany" },
+        { 0, "Albany Amt" },
+
+        { 1, "Times New Roman" },
+        { 1, "Liberation Serif" },
+        { 1, "Thorndale" },
+        { 1, "Thorndale AMT" },
+
+        // Note that Liberation Mono doesn't much *look* like Courier New,
+        // but it's reportedly metric-compatible.
+        { 2, "Courier New" },
+        { 2, "Liberation Mono" },
+        { 2, "Cumberland" },
+        { 2, "Cumberland AMT" },
+
+        { 3, "Helvetica" },
+        { 3, "Nimbus Sans L" },
+
+        { 4, "Times" },
+        { 4, "Nimbus Roman No9 L" },
+
+        { 5, "Courier" },
+        { 5, "Nimbus Mono L" },
+    };
+    static const int kClassCount =

[agl, 2010/03/08 18:31:40]

s/int/size_t/

+        sizeof(kFontEquivClasses)/sizeof(kFontEquivClasses[0]);
+
+    int class_a = -1;
+    for (size_t i = 0; i < kClassCount; ++i) {
+        if (strcasecmp(kFontEquivClasses[i].name, font_a) == 0) {
+            class_a = kFontEquivClasses[i].id;
+            break;
+        }
+    }
+    if (class_a == -1)
+        return false;
+
+    int class_b = -1;
+    for (size_t i = 0; i < kClassCount; ++i) {
+        if (strcasecmp(kFontEquivClasses[i].name, font_b) == 0) {
+            class_b = kFontEquivClasses[i].id;
+            break;
+        }
+    }
+
+    return class_a == class_b;
+}
+
 // -----------------------------------------------------------------------------
 // Normally we only return exactly the font asked for. In last-resort cases,
 // the request is for one of the basic font names "Sans", "Serif" or
 // "Monospace". This function tells you whether a given request is for such a
 // fallback.
 // -----------------------------------------------------------------------------
 static bool IsFallbackFontAllowed(const std::string& family)
 {
     const char* family_cstr = family.c_str();
     return strcasecmp(family_cstr, "sans") == 0 ||
            strcasecmp(family_cstr, "serif") == 0 ||
            strcasecmp(family_cstr, "monospace") == 0 ||
            // This is a special case used for a layout test
            strcasecmp(family_cstr, "NonAntiAliasedSans") == 0;
 }
 
 bool FontConfigDirect::Match(std::string* result_family,
                              unsigned* result_fileid,
                              bool fileid_valid, unsigned fileid,
                              const std::string& family, bool* is_bold,
                              bool* is_italic) {
     if (family.length() > kMaxFontFamilyLength)
         return false;
 
     SkAutoMutexAcquire ac(mutex_);
     FcPattern* pattern = FcPatternCreate();
 
-    FcValue fcvalue;
     if (fileid_valid) {
         const std::map<unsigned, std::string>::const_iterator
             i = fileid_to_filename_.find(fileid);
         if (i == fileid_to_filename_.end()) {
             FcPatternDestroy(pattern);
             return false;
         }
 
-        fcvalue.type = FcTypeString;
-        fcvalue.u.s = (FcChar8*) i->second.c_str();
-        FcPatternAdd(pattern, FC_FILE, fcvalue, 0);
+        FcPatternAddString(pattern, FC_FILE, (FcChar8*) i->second.c_str());
     }
     if (!family.empty()) {
-        fcvalue.type = FcTypeString;
-        fcvalue.u.s = (FcChar8*) family.c_str();
-        FcPatternAdd(pattern, FC_FAMILY, fcvalue, 0);
+        FcPatternAddString(pattern, FC_FAMILY, (FcChar8*) family.c_str());
     }
 
-    fcvalue.type = FcTypeInteger;
-    fcvalue.u.i = is_bold && *is_bold ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL;
-    FcPatternAdd(pattern, FC_WEIGHT, fcvalue, 0);
+    FcPatternAddInteger(pattern, FC_WEIGHT,
+                        is_bold && *is_bold ? FC_WEIGHT_BOLD
+                                            : FC_WEIGHT_NORMAL);
+    FcPatternAddInteger(pattern, FC_SLANT,
+                        is_italic && *is_italic ? FC_SLANT_ITALIC
+                                                : FC_SLANT_ROMAN);
+    FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 
-    fcvalue.type = FcTypeInteger;
-    fcvalue.u.i = is_italic && *is_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN;
-    FcPatternAdd(pattern, FC_SLANT, fcvalue, 0);
-
-    fcvalue.type = FcTypeBool;
-    fcvalue.u.b = FcTrue;
-    FcPatternAdd(pattern, FC_SCALABLE, fcvalue, 0);
-
-    FcConfigSubstitute(0, pattern, FcMatchPattern);
+    FcConfigSubstitute(NULL, pattern, FcMatchPattern);
     FcDefaultSubstitute(pattern);
 
     // Font matching:
     // CSS often specifies a fallback list of families:
     //    font-family: a, b, c, serif;
     // However, fontconfig will always do its best to find *a* font when asked
     // for something so we need a way to tell if the match which it has found is
     // "good enough" for us. Otherwise, we can return NULL which gets piped up
     // and lets WebKit know to try the next CSS family name. However, fontconfig
     // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
@@ skipping 52 matching lines @@
       break;
     }
 
     if (!match) {
       FcPatternDestroy(pattern);
       FcFontSetDestroy(font_set);
       return false;
     }
 
     if (!IsFallbackFontAllowed(family)) {
-      bool family_names_match = false;
+      bool acceptable_substitute = false;
       for (int id = 0; id < 255; ++id) {
         FcChar8* post_match_family;
         if (FcPatternGetString(match, FC_FAMILY, id, &post_match_family) !=
             FcResultMatch)
           break;
-        family_names_match =
+        acceptable_substitute =
           family.empty() ?
           true :
           (strcasecmp((char *)post_config_family,
                       (char *)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(),
-                      (char *)post_match_family) == 0);
-        if (family_names_match)
+                      (char *)post_match_family) == 0) ||
+           IsMetricCompatibleReplacement(family.c_str(),
+                                         (char*)post_match_family);
+        if (acceptable_substitute)
           break;
       }
-      if (!family.empty() && !family_names_match) {
+      if (!acceptable_substitute) {
         FcPatternDestroy(pattern);
         FcFontSetDestroy(font_set);
         return false;
       }
     }
 
     FcPatternDestroy(pattern);
 
     FcChar8* c_filename;
     if (FcPatternGetString(match, FC_FILE, 0, &c_filename) != FcResultMatch) {
@@ skipping 62 matching lines @@
 
 int FontConfigDirect::Open(unsigned fileid) {
     SkAutoMutexAcquire ac(mutex_);
     const std::map<unsigned, std::string>::const_iterator
         i = fileid_to_filename_.find(fileid);
     if (i == fileid_to_filename_.end())
         return -1;
 
     return open(i->second.c_str(), O_RDONLY);
 }