Linux: fix fake italics for font's without italic variants.

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
 **
@@ skipping 25 matching lines @@
 static bool IsFallbackFontAllowed(const std::string& family)
 {
     return family == "Sans" ||
            family == "Serif" ||
            family == "Monospace";
 }
 
 bool FontConfigDirect::Match(std::string* result_family,
                              unsigned* result_fileid,
                              bool fileid_valid, unsigned fileid,
-                             const std::string& family, int is_bold,
-                             int is_italic) {
+                             const std::string& family, bool* is_bold,
+                             bool* is_italic) {
     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);
     }
     if (!family.empty()) {
         fcvalue.type = FcTypeString;
         fcvalue.u.s = (FcChar8*) family.c_str();
         FcPatternAdd(pattern, FC_FAMILY, fcvalue, 0);
     }
-    if (is_bold > 0) {
-        fcvalue.type = FcTypeInteger;
-        fcvalue.u.i = is_bold ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL;
-        FcPatternAdd(pattern, FC_WEIGHT, fcvalue, 0);
-    }
-    if (is_italic > 0) {
-        fcvalue.type = FcTypeInteger;
-        fcvalue.u.i = is_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN;
-        FcPatternAdd(pattern, FC_SLANT, fcvalue, 0);
-    }
+
+    fcvalue.type = FcTypeInteger;
+    fcvalue.u.i = is_bold && *is_bold ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL;
+    FcPatternAdd(pattern, FC_WEIGHT, fcvalue, 0);
+
+    fcvalue.type = FcTypeInteger;
+    fcvalue.u.i = is_italic && *is_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN;
+    FcPatternAdd(pattern, FC_SLANT, fcvalue, 0);
 
     FcConfigSubstitute(0, 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
@@ skipping 77 matching lines @@
 
     if (result_fileid)
         *result_fileid = out_fileid;
 
     FcChar8* c_family;
     if (FcPatternGetString(match, FC_FAMILY, 0, &c_family)) {
         FcPatternDestroy(match);
         return NULL;
     }
 
+    int resulting_bold;
+    if (FcPatternGetInteger(match, FC_WEIGHT, 0, &resulting_bold))
+      resulting_bold = FC_WEIGHT_NORMAL;
+
+    int resulting_italic;
+    if (FcPatternGetInteger(match, FC_SLANT, 0, &resulting_italic))
+      resulting_italic = FC_SLANT_ROMAN;
+
+    if (is_bold)
+      *is_bold = resulting_bold >= FC_WEIGHT_BOLD;
+    if (is_italic)
+      *is_italic = resulting_italic == FC_SLANT_ITALIC;
+
     if (result_family)
         *result_family = (char *) c_family;
 
     FcPatternDestroy(match);
 
     return true;
 }
 
 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);
 }