linux: be more conservative in Liberation 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();
-}
+namespace {
 
-bool FontConfigDirect::IsMetricCompatibleReplacement(const char* font_a,
-                                                     const char* font_b)
+// Equivalence classes, used to match the Liberation fonts with their
+// metric-compatible replacements.  See the discussion in
+// GetFontEquivClass().
+enum FontEquivClass
+{
+    OTHER,
+    SANS,
+    SERIF
+};
+
+// Match the font name against a whilelist of fonts, returning the equivalence
+// class.
+FontEquivClass GetFontEquivClass(const char* fontname)
 {
     // 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.
+    // So instead, we hardcode.  Initially this function emulated
+    //   /etc/fonts/conf.d/30-metric-aliases.conf
+    // from my Ubuntu system, but we're better off being very conservative.
 
-    // 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" },
+    if (strcasecmp(fontname, "Arial") == 0 ||
+        strcasecmp(fontname, "Liberation Sans") == 0) {
+        return SANS;
+    } else if (strcasecmp(fontname, "Times New Roman") == 0 ||
+               strcasecmp(fontname, "Liberation Serif") == 0) {
+        return SERIF;
+    }
+    return OTHER;
+}
 
-        { 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" },
+// Return true if |font_a| and |font_b| are visually and at the metrics
+// level interchangeable.
+bool IsMetricCompatibleReplacement(const char* font_a, const char* font_b)
+{
+    FontEquivClass class_a = GetFontEquivClass(font_a);
+    FontEquivClass class_b = GetFontEquivClass(font_b);
 
-        { 3, "Helvetica" },
-        { 3, "Nimbus Sans L" },
+    return class_a != OTHER && class_a == class_b;
+}
 
-        { 4, "Times" },
-        { 4, "Nimbus Roman No9 L" },
+}  // anonymous namespace
 
-        { 5, "Courier" },
-        { 5, "Nimbus Mono L" },
-    };
-    static const size_t kClassCount =
-        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;
+FontConfigDirect::FontConfigDirect()
+    : next_file_id_(0) {
+  FcInit();
 }
 
 // -----------------------------------------------------------------------------
 // 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)
 {
@@ skipping 210 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);
 }