Fix Google3 fonts.

src/ports/SkFontConfigInterfaceDirect.cpp

 /*
  * Copyright 2009 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */
 
+#include "SkFontConfigInterfaceDirect.h"
 #include "SkBuffer.h"
 #include "SkDataTable.h"
-#include "SkFontConfigInterface.h"
 #include "SkFontStyle.h"
 #include "SkMutex.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
 #include "SkTemplates.h"
 #include "SkTypeface.h"
 #include "SkTypes.h"
 
@@ skipping 77 matching lines @@
     SkASSERT(iden0 != iden1);
 
     make_iden(&iden1);
     SkASSERT(iden0 == iden1);
 
     test_writeToMemory(iden0, 0);
     test_writeToMemory(iden0, 0);
 }
 #endif
 
-class SkFontConfigInterfaceDirect : public SkFontConfigInterface {
-public:
-            SkFontConfigInterfaceDirect();
-    virtual ~SkFontConfigInterfaceDirect();
-
-    virtual bool matchFamilyName(const char familyName[],
-                                 SkTypeface::Style requested,
-                                 FontIdentity* outFontIdentifier,
-                                 SkString* outFamilyName,
-                                 SkTypeface::Style* outStyle) override;
-    SkStreamAsset* openStream(const FontIdentity&) override;
-
-    // new APIs
-    SkDataTable* getFamilyNames() override;
-    virtual bool matchFamilySet(const char inFamilyName[],
-                                SkString* outFamilyName,
-                                SkTArray<FontIdentity>*) override;
-
-private:
-    SkMutex mutex_;
-};
-
-SkFontConfigInterface* SkFontConfigInterface::GetSingletonDirectInterface(SkBaseMutex* mutex) {
-    SkAutoMutexAcquire ac(mutex);
-    static SkFontConfigInterfaceDirect* singleton = nullptr;
-    if (singleton == nullptr) {
-        singleton = new SkFontConfigInterfaceDirect;
-    }
-    return singleton;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns the string from the pattern, or nullptr
-static const char* get_name(FcPattern* pattern, const char field[],
-                            int index = 0) {
+const char* SkFontConfigInterfaceDirect::GetName(FcPattern* pattern, const char field[],
+                                                 int index) {
     const char* name;
     if (FcPatternGetString(pattern, field, index,
                            (FcChar8**)&name) != FcResultMatch) {
         name = nullptr;
     }
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 171 matching lines @@
 // basic font names like "Sans", "Serif" or "Monospace". This function
 // tells you whether a given request is for such a fallback.
 bool IsFallbackFontAllowed(const SkString& family) {
   const char* family_cstr = family.c_str();
   return family.isEmpty() ||
          strcasecmp(family_cstr, "sans") == 0 ||
          strcasecmp(family_cstr, "serif") == 0 ||
          strcasecmp(family_cstr, "monospace") == 0;
 }
 
-static bool valid_pattern(FcPattern* pattern) {
+// Retrieves |is_bold|, |is_italic| and |font_family| properties from |font|.
+SkTypeface::Style GetFontStyle(FcPattern* font) {
+    int resulting_bold;
+    if (FcPatternGetInteger(font, FC_WEIGHT, 0, &resulting_bold))
+        resulting_bold = FC_WEIGHT_NORMAL;
+
+    int resulting_italic;
+    if (FcPatternGetInteger(font, FC_SLANT, 0, &resulting_italic))
+        resulting_italic = FC_SLANT_ROMAN;
+
+    // If we ask for an italic font, fontconfig might take a roman font and set
+    // the undocumented property FC_MATRIX to a skew matrix. It'll then say
+    // that the font is italic or oblique. So, if we see a matrix, we don't
+    // believe that it's italic.
+    FcValue matrix;
+    const bool have_matrix = FcPatternGet(font, FC_MATRIX, 0, &matrix) == 0;
+
+    // If we ask for an italic font, fontconfig might take a roman font and set
+    // FC_EMBOLDEN.
+    FcValue embolden;
+    const bool have_embolden = FcPatternGet(font, FC_EMBOLDEN, 0, &embolden) == 0;
+
+    int styleBits = 0;
+    if (resulting_bold > FC_WEIGHT_MEDIUM && !have_embolden) {
+        styleBits |= SkTypeface::kBold;
+    }
+    if (resulting_italic > FC_SLANT_ROMAN && !have_matrix) {
+        styleBits |= SkTypeface::kItalic;
+    }
+
+    return (SkTypeface::Style)styleBits;
+}
+
+}  // anonymous namespace
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define kMaxFontFamilyLength    2048
+
+SkFontConfigInterfaceDirect::SkFontConfigInterfaceDirect() {
+    SkAutoMutexAcquire ac(mutex_);
+
+    FcInit();
+
+    SkDEBUGCODE(fontconfiginterface_unittest();)
+}
+
+SkFontConfigInterfaceDirect::~SkFontConfigInterfaceDirect() {
+}
+
+bool SkFontConfigInterfaceDirect::isValidPattern(FcPattern* pattern) {
 #ifdef SK_FONT_CONFIG_ONLY_ALLOW_SCALABLE_FONTS
     FcBool is_scalable;
     if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &is_scalable) != FcResultMatch
         || !is_scalable) {
         return false;
     }
 #endif
 
     // fontconfig can also return fonts which are unreadable
-    const char* c_filename = get_name(pattern, FC_FILE);
+    const char* c_filename = GetName(pattern, FC_FILE);
     if (!c_filename) {
         return false;
     }
     if (access(c_filename, R_OK) != 0) {
         return false;
     }
+
     return true;
 }
 
 // Find matching font from |font_set| for the given font family.
-FcPattern* MatchFont(FcFontSet* font_set,
-                     const char* post_config_family,
-                     const SkString& family) {
+FcPattern* SkFontConfigInterfaceDirect::MatchFont(FcFontSet* font_set,
+                                                  const char* post_config_family,
+                                                  const SkString& family) {
   // Older versions of fontconfig have a bug where they cannot select
   // only scalable fonts so we have to manually filter the results.
   FcPattern* match = nullptr;
   for (int i = 0; i < font_set->nfont; ++i) {
     FcPattern* current = font_set->fonts[i];
-    if (valid_pattern(current)) {
+    if (this->isValidPattern(current)) {
       match = current;
       break;
     }
   }
 
   if (match && !IsFallbackFontAllowed(family)) {
     bool acceptable_substitute = false;
     for (int id = 0; id < 255; ++id) {
-      const char* post_match_family = get_name(match, FC_FAMILY, id);
+      const char* post_match_family = GetName(match, FC_FAMILY, id);
       if (!post_match_family)
         break;
       acceptable_substitute =
           (strcasecmp(post_config_family, post_match_family) == 0 ||
            // Workaround for Issue 12530:
            //   requested family: "Bitstream Vera Sans"
            //   post_config_family: "Arial"
            //   post_match_family: "Bitstream Vera Sans"
            // -> We should treat this case as a good match.
            strcasecmp(family.c_str(), post_match_family) == 0) ||
            IsMetricCompatibleReplacement(family.c_str(), post_match_family);
       if (acceptable_substitute)
         break;
     }
     if (!acceptable_substitute)
       return nullptr;
   }
 
   return match;
 }
 
-// Retrieves |is_bold|, |is_italic| and |font_family| properties from |font|.
-SkTypeface::Style GetFontStyle(FcPattern* font) {
-    int resulting_bold;
-    if (FcPatternGetInteger(font, FC_WEIGHT, 0, &resulting_bold))
-        resulting_bold = FC_WEIGHT_NORMAL;
-
-    int resulting_italic;
-    if (FcPatternGetInteger(font, FC_SLANT, 0, &resulting_italic))
-        resulting_italic = FC_SLANT_ROMAN;
-
-    // If we ask for an italic font, fontconfig might take a roman font and set
-    // the undocumented property FC_MATRIX to a skew matrix. It'll then say
-    // that the font is italic or oblique. So, if we see a matrix, we don't
-    // believe that it's italic.
-    FcValue matrix;
-    const bool have_matrix = FcPatternGet(font, FC_MATRIX, 0, &matrix) == 0;
-
-    // If we ask for an italic font, fontconfig might take a roman font and set
-    // FC_EMBOLDEN.
-    FcValue embolden;
-    const bool have_embolden = FcPatternGet(font, FC_EMBOLDEN, 0, &embolden) == 0;
-
-    int styleBits = 0;
-    if (resulting_bold > FC_WEIGHT_MEDIUM && !have_embolden) {
-        styleBits |= SkTypeface::kBold;
-    }
-    if (resulting_italic > FC_SLANT_ROMAN && !have_matrix) {
-        styleBits |= SkTypeface::kItalic;
-    }
-
-    return (SkTypeface::Style)styleBits;
-}
-
-}  // anonymous namespace
-
-///////////////////////////////////////////////////////////////////////////////
-
-#define kMaxFontFamilyLength    2048
-
-SkFontConfigInterfaceDirect::SkFontConfigInterfaceDirect() {
-    SkAutoMutexAcquire ac(mutex_);
-
-    FcInit();
-
-    SkDEBUGCODE(fontconfiginterface_unittest();)
-}
-
-SkFontConfigInterfaceDirect::~SkFontConfigInterfaceDirect() {
-}
-
 bool SkFontConfigInterfaceDirect::matchFamilyName(const char familyName[],
                                                   SkTypeface::Style style,
                                                   FontIdentity* outIdentity,
                                                   SkString* outFamilyName,
                                                   SkTypeface::Style* outStyle) {
     SkString familyStr(familyName ? familyName : "");
     if (familyStr.size() > kMaxFontFamilyLength) {
         return false;
     }
 
@@ skipping 37 matching lines @@
     //      -> good match
     //
     // and for a missing font:
     //    requested family: "Monaco"
     //    post_config_family: "Monaco"
     //    post_match_family: "Times New Roman"
     //      -> BAD match
     //
     // However, we special-case fallback fonts; see IsFallbackFontAllowed().
 
-    const char* post_config_family = get_name(pattern, FC_FAMILY);
+    const char* post_config_family = GetName(pattern, FC_FAMILY);
     if (!post_config_family) {
         // we can just continue with an empty name, e.g. default font
         post_config_family = "";
     }
 
     FcResult result;
     FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result);
     if (!font_set) {
         FcPatternDestroy(pattern);
         return false;
     }
 
-    FcPattern* match = MatchFont(font_set, post_config_family, familyStr);
+    FcPattern* match = this->MatchFont(font_set, post_config_family, familyStr);
     if (!match) {
         FcPatternDestroy(pattern);
         FcFontSetDestroy(font_set);
         return false;
     }
 
     FcPatternDestroy(pattern);
 
     // From here out we just extract our results from 'match'
 
-    post_config_family = get_name(match, FC_FAMILY);
+    post_config_family = GetName(match, FC_FAMILY);
     if (!post_config_family) {
         FcFontSetDestroy(font_set);
         return false;
     }
 
-    const char* c_filename = get_name(match, FC_FILE);
+    const char* c_filename = GetName(match, FC_FILE);
     if (!c_filename) {
         FcFontSetDestroy(font_set);
         return false;
     }
 
     int face_index;
     if (FcPatternGetInteger(match, FC_INDEX, 0, &face_index) != FcResultMatch) {
         FcFontSetDestroy(font_set);
         return false;
     }
@@ skipping 47 matching lines @@
     FcFontSet* fs = FcFontList(nullptr, pat, os);
     SkAutoTCallVProc<FcFontSet, FcFontSetDestroy> autoDestroyFs(fs);
     if (nullptr == fs) {
         return nullptr;
     }
 
     SkTDArray<const char*> names;
     SkTDArray<size_t> sizes;
     for (int i = 0; i < fs->nfont; ++i) {
         FcPattern* match = fs->fonts[i];
-        const char* famName = get_name(match, FC_FAMILY);
+        const char* famName = GetName(match, FC_FAMILY);
         if (famName && !find_name(names, famName)) {
             *names.append() = famName;
             *sizes.append() = strlen(famName) + 1;
         }
     }
 
     return SkDataTable::NewCopyArrays((const void*const*)names.begin(),
                                       sizes.begin(), names.count());
 }
 
@@ skipping 42 matching lines @@
     //      -> good match
     //
     // and for a missing font:
     //    requested family: "Monaco"
     //    post_config_family: "Monaco"
     //    post_match_family: "Times New Roman"
     //      -> BAD match
     //
     // However, we special-case fallback fonts; see IsFallbackFontAllowed().
 
-    const char* post_config_family = get_name(pattern, FC_FAMILY);
+    const char* post_config_family = GetName(pattern, FC_FAMILY);
 
     FcResult result;
     FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result);
     if (!font_set) {
         FcPatternDestroy(pattern);
         return false;
     }
 
-    FcPattern* match = MatchFont(font_set, post_config_family, familyStr);
+    FcPattern* match = this->MatchFont(font_set, post_config_family, familyStr);
     if (!match) {
         FcPatternDestroy(pattern);
         FcFontSetDestroy(font_set);
         return false;
     }
 
     FcPatternDestroy(pattern);
 
     // From here out we just extract our results from 'match'
 
@@ skipping 24 matching lines @@
         outFamilyName->set((const char*)post_config_family);
     }
     if (outStyle) {
         *outStyle = GetFontStyle(match);
     }
     return true;
 
 ////////////////////
 
         int count;
-        FcPattern** match = MatchFont(font_set, post_config_family, &count);
+        FcPattern** match = this->MatchFont(font_set, post_config_family, &count);
         if (!match) {
             FcPatternDestroy(pattern);
             FcFontSetDestroy(font_set);
             return nullptr;
         }
 
         FcPatternDestroy(pattern);
 
         SkTDArray<FcPattern*> trimmedMatches;
         for (int i = 0; i < count; ++i) {
-            const char* justName = find_just_name(get_name(match[i], FC_FILE));
+            const char* justName = find_just_name(GetName(match[i], FC_FILE));
             if (!is_lower(*justName)) {
                 *trimmedMatches.append() = match[i];
             }
         }
 
         SkFontStyleSet_FC* sset = new SkFontStyleSet_FC                                               (trimmedMatches.begin(),                                               trimmedMatches.count());
 #endif
     return false;
 }