Adding WebFallbackFont and renaming SimpleFontFamily

Source/platform/exported/linux/WebFontInfo.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "public/platform/linux/WebFontInfo.h"
 
+#include "public/platform/linux/WebFallbackFont.h"
 #include "public/platform/linux/WebFontFamily.h"
 #include "public/platform/linux/WebFontRenderStyle.h"
 #include <fontconfig/fontconfig.h>
 #include <string.h>
 #include <unicode/utf16.h>
 
 namespace blink {
 
 static bool useSubpixelPositioning = false;
 
 void WebFontInfo::setSubpixelPositioning(bool subpixelPositioning)
 {
     useSubpixelPositioning = subpixelPositioning;
 }
 
+// TODO(dro): Remove this legacy version, kept until renames on the Chromium side are done. crbug.com/382411
 void WebFontInfo::familyForChar(WebUChar32 c, const char* preferredLocale, WebFontFamily* family)
 {
     FcCharSet* cset = FcCharSetCreate();
     FcCharSetAddChar(cset, c);
     FcPattern* pattern = FcPatternCreate();
 
     FcValue fcvalue;
     fcvalue.type = FcTypeCharSet;
     fcvalue.u.c = cset;
     FcPatternAdd(pattern, FC_CHARSET, fcvalue, FcFalse);
@@ skipping 56 matching lines @@
             family->isItalic = slant != FC_SLANT_ROMAN;
         else
             family->isItalic = false;
         FcFontSetDestroy(fontSet);
         return;
     }
 
     FcFontSetDestroy(fontSet);
 }
 
+void WebFontInfo::fallbackFontForChar(WebUChar32 c, const char* preferredLocale, WebFallbackFont* fallbackFont)
+{
+    FcCharSet* cset = FcCharSetCreate();
+    FcCharSetAddChar(cset, c);
+    FcPattern* pattern = FcPatternCreate();
+
+    FcValue fcvalue;
+    fcvalue.type = FcTypeCharSet;
+    fcvalue.u.c = cset;
+    FcPatternAdd(pattern, FC_CHARSET, fcvalue, FcFalse);

[behdad_google, 2014/06/09 22:27:58]

See "man FcPatternAdd-Type".  Use FcPatternAddCharSet, etc instead of building
fcvalues manually.

+
+    fcvalue.type = FcTypeBool;
+    fcvalue.u.b = FcTrue;
+    FcPatternAdd(pattern, FC_SCALABLE, fcvalue, FcFalse);
+
+    if (preferredLocale) {
+        FcLangSet* langset = FcLangSetCreate();
+        FcLangSetAdd(langset, reinterpret_cast<const FcChar8 *>(preferredLocale));
+        FcPatternAddLangSet(pattern, FC_LANG, langset);
+        FcLangSetDestroy(langset);
+    }
+
+    FcConfigSubstitute(0, pattern, FcMatchPattern);
+    FcDefaultSubstitute(pattern);
+
+    FcResult result;
+    FcFontSet* fontSet = FcFontSort(0, pattern, 0, 0, &result);
+    FcPatternDestroy(pattern);
+    FcCharSetDestroy(cset);
+
+    if (!fontSet) {
+        fallbackFont->name = WebCString();
+        fallbackFont->isBold = false;
+        fallbackFont->isItalic = false;
+        return;
+    }
+    // Older versions of fontconfig have a bug where they cannot select
+    // only scalable fonts so we have to manually filter the results.
+    for (int i = 0; i < fontSet->nfont; ++i) {
+        FcPattern* current = fontSet->fonts[i];
+        FcBool isScalable;
+
+        if (FcPatternGetBool(current, FC_SCALABLE, 0, &isScalable) != FcResultMatch
+            || !isScalable)
+            continue;
+
+        // fontconfig can also return fonts which are unreadable
+        FcChar8* cFilename;
+        if (FcPatternGetString(current, FC_FILE, 0, &cFilename) != FcResultMatch)
+            continue;
+
+        if (access(reinterpret_cast<char*>(cFilename), R_OK))
+            continue;
+
+        const char* fontFilename = reinterpret_cast<char*>(cFilename);
+        fallbackFont->filename = WebCString(fontFilename, strlen(fontFilename));
+
+        // Index into font collection.
+        int ttcIndex;
+        if (FcPatternGetInteger(current, FC_INDEX, 0, &ttcIndex) != FcResultMatch && ttcIndex < 0)
+            continue;
+        fallbackFont->ttcIndex = ttcIndex;
+
+        FcChar8* familyName;
+        if (FcPatternGetString(current, FC_FAMILY, 0, &familyName) == FcResultMatch) {
+            const char* charFamily = reinterpret_cast<char*>(familyName);
+            fallbackFont->name = WebCString(charFamily, strlen(charFamily));
+        }
+        int weight;
+        if (FcPatternGetInteger(current, FC_WEIGHT, 0, &weight) == FcResultMatch)
+            fallbackFont->isBold = weight >= FC_WEIGHT_BOLD;
+        else
+            fallbackFont->isBold = false;
+        int slant;
+        if (FcPatternGetInteger(current, FC_SLANT, 0, &slant) == FcResultMatch)
+            fallbackFont->isItalic = slant != FC_SLANT_ROMAN;
+        else
+            fallbackFont->isItalic = false;
+        FcFontSetDestroy(fontSet);
+        return;
+    }
+
+    FcFontSetDestroy(fontSet);
+}
+
 void WebFontInfo::renderStyleForStrike(const char* family, int sizeAndStyle, WebFontRenderStyle* out)
 {
     bool isBold = sizeAndStyle & 1;
     bool isItalic = sizeAndStyle & 2;
     int pixelSize = sizeAndStyle >> 2;
 
     FcPattern* pattern = FcPatternCreate();
     FcValue fcvalue;
 
     fcvalue.type = FcTypeString;
@@ skipping 64 matching lines @@
     }
 
     // FontConfig doesn't provide parameters to configure whether subpixel
     // positioning should be used or not, so we just use a global setting.
     out->useSubpixelPositioning = useSubpixelPositioning;
 
     FcPatternDestroy(match);
 }
 
 } // namespace blink