Add font-equivalent mapping for a few Chinese/Japanese fonts for CrOS....

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>
 
 #include "unicode/utf16.h"
 
 namespace {
 
-// Equivalence classes, used to match the Liberation and Ascender fonts
+// Equivalence classes, used to match the Liberation and other fonts
 // with their metric-compatible replacements.  See the discussion in
 // GetFontEquivClass().
 enum FontEquivClass
 {
     OTHER,
     SANS,
     SERIF,
-    MONO
+    MONO,
+    PMINCHO,
+    MINCHO,
+    PGOTHIC,
+    GOTHIC,
+    SIMSUN,
+    NSIMSUN,
 };
 
 // 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.  Initially this function emulated
     //   /etc/fonts/conf.d/30-metric-aliases.conf
     // from my Ubuntu system, but we're better off being very conservative.
 
-    // "Ascender Sans", "Ascender Serif" and "Ascender Sans Mono" are the
-    // tentative names of another set of fonts metric-compatible with
+    // Arimo, Tinos and Cousine are a set of fonts metric-compatible with
     // Arial, Times New Roman and Courier New  with a character repertoire
-    // much larger than Liberation. Note that Ascender Sans Mono
-    // is metrically compatible with Courier New, but the former
-    // is sans-serif while ther latter is serif.
-    // Arimo, Tinos and Cousine are the names of new fonts derived from and
-    // expanded upon Ascender Sans, Ascender Serif and Ascender Sans Mono.
-    if (strcasecmp(fontname, "Arial") == 0 ||
-        strcasecmp(fontname, "Liberation Sans") == 0 ||
-        strcasecmp(fontname, "Arimo") == 0 ||
-        strcasecmp(fontname, "Ascender Sans") == 0) {
-        return SANS;
-    } else if (strcasecmp(fontname, "Times New Roman") == 0 ||
-               strcasecmp(fontname, "Liberation Serif") == 0 ||
-               strcasecmp(fontname, "Tinos") == 0 ||
-               strcasecmp(fontname, "Ascender Serif") == 0) {
-        return SERIF;
-    } else if (strcasecmp(fontname, "Courier New") == 0 ||
-               strcasecmp(fontname, "Cousine") == 0 ||
-               strcasecmp(fontname, "Ascender Sans Mono") == 0) {
-        return MONO;
+    // much larger than Liberation. Note that Cousine is metrically
+    // compatible with Courier New, but the former is sans-serif while
+    // the latter is serif.
+
+
+    struct FontEquivMap {
+        FontEquivClass clazz;
+        const char name[40];
+    };
+
+    static const FontEquivMap kFontEquivMap[] = {
+        { SANS, "Arial" },
+        { SANS, "Arimo" },
+        { SANS, "Liberation Sans" },
+
+        { SERIF, "Times New Roman" },
+        { SERIF, "Tinos" },
+        { SERIF, "Liberation Serif" },
+
+        { MONO, "Courier New" },
+        { MONO, "Cousine" },
+        { MONO, "Liberation Mono" },
+
+        { PMINCHO, "MS PMincho" },
+        { PMINCHO, "ＭＳ Ｐ明朝" },

[Evan Martin, 2010/12/14 18:04:21]

I worry that people's editors will eat these UTF-8 strings.
If the font name really is in UTF-8, maybe it'd be better to use
"\xA3\x12" etc in the quotes and then add a comment with the real UTF-8.

+        { PMINCHO, "IPAPMincho" },
+
+        { MINCHO, "MS Mincho" },
+        { MINCHO, "ＭＳ 明朝" },
+        { MINCHO, "IPAMincho" },
+
+        { PGOTHIC, "MS PGothic" },
+        { PGOTHIC, "ＭＳ Ｐゴシック" },
+        { PGOTHIC, "IPAPGothic" },
+
+        { GOTHIC, "MS Gothic" },
+        { GOTHIC, "ＭＳ ゴシック" },
+        { GOTHIC, "IPAGothic" },
+
+        { SIMSUN, "Simsun" },
+        { SIMSUN, "宋体" },
+        { SIMSUN, "Song ASC" },
+
+        { NSIMSUN, "NSimsun" },
+        { NSIMSUN, "新宋体" },
+        { NSIMSUN, "N Song ASC" },
+    };
+
+    static const size_t kFontCount =
+        sizeof(kFontEquivMap)/sizeof(kFontEquivMap[0]);
+
+    for (size_t i = 0; i < kFontCount; ++i) {

[jungshik at Google, 2010/12/11 01:10:50]

Evan, do you think I'd better make a (hash)map once (with locking) and use that
instead of looping through the list everytime? This can be a hot spot, but I'm
not sure which would be better. One way is to land the CL and see if there's any
page cycler perf regression. Or, I can run page cycler tests locally with two
alternatives. 

[Evan Martin, 2010/12/14 18:04:21]

I think whichever implementation is simpler would be better.  I agree this loop
is getting too large.

+        if (strcasecmp(kFontEquivMap[i].name, fontname) == 0)
+            return kFontEquivMap[i].clazz;
     }
     return OTHER;
 }
 
 
 // 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);
@@ skipping 278 matching lines @@
 
 int FontConfigDirect::Open(unsigned filefaceid) {
     SkAutoMutexAcquire ac(mutex_);
     const std::map<unsigned, std::string>::const_iterator
         i = fileid_to_filename_.find(FileFaceIdToFileId(filefaceid));
     if (i == fileid_to_filename_.end())
         return -1;
 
     return open(i->second.c_str(), O_RDONLY);
 }