Linux: Do better font substitution for Chinese characters.

content/browser/renderer_host/render_sandbox_host_linux.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/render_sandbox_host_linux.h"
 
 #include <fcntl.h>
 #include <fontconfig/fontconfig.h>
 #include <stdint.h>
 #include <sys/poll.h>
@@ skipping 389 matching lines @@
     if (!pickle.ReadString(&iter, &face) ||
         face.empty() ||
         !pickle.ReadBool(&iter, &is_bold) ||
         !pickle.ReadBool(&iter, &is_italic) ||
         !pickle.ReadUInt32(&iter, &charset) ||
         !pickle.ReadUInt32(&iter, &fallback_family)) {
       return;
     }
 
     FcLangSet* langset = FcLangSetCreate();
-    MSCharSetToFontconfig(langset, charset);
+    bool is_lgc = MSCharSetToFontconfig(langset, charset);
 
     FcPattern* pattern = FcPatternCreate();
-    // TODO(agl): FC_FAMILy needs to change
     FcPatternAddString(pattern, FC_FAMILY,
                        reinterpret_cast<const FcChar8*>(face.c_str()));
 
+    // TODO(thestig) Check if we can access Chrome's per-script font preference
+    // here and select better default fonts for non-LGC case.
     std::string generic_font_name;
-    switch (fallback_family) {
-      case PP_BROWSERFONT_TRUSTED_FAMILY_SERIF:
-        generic_font_name = "Times New Roman";
-        break;
-      case PP_BROWSERFONT_TRUSTED_FAMILY_SANSSERIF:
-        generic_font_name = "Arial";
-        break;
-      case PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE:
-        generic_font_name = "Courier New";
-        break;
+    if (is_lgc) {
+      switch (fallback_family) {
+        case PP_BROWSERFONT_TRUSTED_FAMILY_SERIF:
+          generic_font_name = "Times New Roman";
+          break;
+        case PP_BROWSERFONT_TRUSTED_FAMILY_SANSSERIF:
+          generic_font_name = "Arial";
+          break;
+        case PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE:
+          generic_font_name = "Courier New";
+          break;
+      }
     }
     if (!generic_font_name.empty()) {
       const FcChar8* fc_generic_font_name =
           reinterpret_cast<const FcChar8*>(generic_font_name.c_str());
       FcPatternAddString(pattern, FC_FAMILY, fc_generic_font_name);
     }
 
     if (is_bold)
       FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
     if (is_italic)
@@ skipping 102 matching lines @@
     SendRendererReply(fds, reply, font_fd);
 
     if (font_fd >= 0) {
       if (IGNORE_EINTR(close(font_fd)) < 0)
         PLOG(ERROR) << "close";
     }
   }
 
   // MSCharSetToFontconfig translates a Microsoft charset identifier to a
   // fontconfig language set by appending to |langset|.
-  static void MSCharSetToFontconfig(FcLangSet* langset, unsigned fdwCharSet) {
+  // Returns true if |langset| is Latin/Greek/Cyrillic.
+  static bool MSCharSetToFontconfig(FcLangSet* langset, unsigned fdwCharSet) {
     // We have need to translate raw fdwCharSet values into terms that
     // fontconfig can understand. (See the description of fdwCharSet in the MSDN
     // documentation for CreateFont:
     // http://msdn.microsoft.com/en-us/library/dd183499(VS.85).aspx )
     //
     // Although the argument is /called/ 'charset', the actual values conflate
     // character sets (which are sets of Unicode code points) and character
     // encodings (which are algorithms for turning a series of bits into a
     // series of code points.) Sometimes the values will name a language,
     // sometimes they'll name an encoding. In the latter case I'm assuming that
     // they mean the set of code points in the domain of that encoding.
     //
     // fontconfig deals with ISO 639-1 language codes:
     //   http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
     //
     // So, for each of the documented fdwCharSet values I've had to take a
     // guess at the set of ISO 639-1 languages intended.
 
+    bool is_lgc = false;
     switch (fdwCharSet) {
       case NPCharsetAnsi:
       // These values I don't really know what to do with, so I'm going to map
       // them to English also.
       case NPCharsetDefault:
       case NPCharsetMac:
       case NPCharsetOEM:
       case NPCharsetSymbol:
+        is_lgc = true;
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("en"));
         break;
       case NPCharsetBaltic:
         // The three baltic languages.
+        is_lgc = true;
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("et"));
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("lv"));
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("lt"));
         break;
-      // TODO(jungshik): Would we be better off mapping Big5 to zh-tw
-      // and GB2312 to zh-cn? Fontconfig has 4 separate orthography
-      // files (zh-{cn,tw,hk,mo}.
       case NPCharsetChineseBIG5:
+        FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("zh-tw"));
+        break;
       case NPCharsetGB2312:
-        FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("zh"));
+        FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("zh-cn"));
         break;
       case NPCharsetEastEurope:
         // A scattering of eastern European languages.
+        is_lgc = true;
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("pl"));
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("cs"));
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("sk"));
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("hu"));
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("hr"));
         break;
       case NPCharsetGreek:
+        is_lgc = true;
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("el"));
         break;
       case NPCharsetHangul:
       case NPCharsetJohab:
         // Korean
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ko"));
         break;
       case NPCharsetRussian:
+        is_lgc = true;
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ru"));
         break;
       case NPCharsetShiftJIS:
         // Japanese
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ja"));
         break;
       case NPCharsetTurkish:
+        is_lgc = true;
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("tr"));
         break;
       case NPCharsetVietnamese:
+        is_lgc = true;
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("vi"));
         break;
       case NPCharsetArabic:
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("ar"));
         break;
       case NPCharsetHebrew:
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("he"));
         break;
       case NPCharsetThai:
         FcLangSetAdd(langset, reinterpret_cast<const FcChar8*>("th"));
         break;
       // default:
       // Don't add any languages in that case that we don't recognise the
       // constant.
     }
+    return is_lgc;
   }
 
   void SendRendererReply(const std::vector<int>& fds, const Pickle& reply,
                          int reply_fd) {
     struct msghdr msg;
     memset(&msg, 0, sizeof(msg));
     struct iovec iov = {const_cast<void*>(reply.data()), reply.size()};
     msg.msg_iov = &iov;
     msg.msg_iovlen = 1;
 
@@ skipping 111 matching lines @@
 RenderSandboxHostLinux::~RenderSandboxHostLinux() {
   if (initialized_) {
     if (IGNORE_EINTR(close(renderer_socket_)) < 0)
       PLOG(ERROR) << "close";
     if (IGNORE_EINTR(close(childs_lifeline_fd_)) < 0)
       PLOG(ERROR) << "close";
   }
 }
 
 }  // namespace content