Add global fontconfig lock.

src/fonts/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontMgr.h"
 #include "SkFontStyle.h"
 #include "SkFontConfigInterface.h"
 #include "SkFontConfigTypeface.h"
 #include "SkMath.h"
 #include "SkString.h"
 #include "SkTDArray.h"
+#include "SkThread.h"
 
 // for now we pull these in directly. eventually we will solely rely on the
 // SkFontConfigInterface instance.
 #include <fontconfig/fontconfig.h>
 #include <unistd.h>
 
+namespace {
+
+// Fontconfig is not threadsafe before 2.10.91.  Before that, we lock with a global mutex.
+// See skia:1497 for background.
+SK_DECLARE_STATIC_MUTEX(gFCMutex);
+static bool gFCSafeToUse;
+
+struct FCLocker {
+    FCLocker() {
+        if (FcGetVersion() < 21091) {  // We assume FcGetVersion() has always been thread safe.
+            gFCMutex.acquire();
+            fUnlock = true;
+        } else {
+            fUnlock = false;
+        }
+        gFCSafeToUse = true;
+    }
+
+    ~FCLocker() {
+        gFCSafeToUse = false;
+        if (fUnlock) {
+            gFCMutex.release();
+        }
+    }
+
+private:
+    bool fUnlock;
+};
+
+} // namespace
+
+
 // Defined in SkFontHost_FreeType.cpp
 bool find_name_and_attributes(SkStream* stream, SkString* name,
                               SkTypeface::Style* style, bool* isFixedWidth);
 
 // borrow this global from SkFontHost_fontconfig. eventually that file should
 // go away, and be replaced with this one.
 extern SkFontConfigInterface* SkFontHost_fontconfig_ref_global();
 static SkFontConfigInterface* RefFCI() {
     return SkFontHost_fontconfig_ref_global();
 }
 
 // look for the last substring after a '/' and return that, or return null.
 static const char* find_just_name(const char* str) {
     const char* last = strrchr(str, '/');
     return last ? last + 1 : NULL;
 }
 
 static bool is_lower(char c) {
     return c >= 'a' && c <= 'z';
 }
 
 static int get_int(FcPattern* pattern, const char field[]) {
+    SkASSERT(gFCSafeToUse);
     int value;
     if (FcPatternGetInteger(pattern, field, 0, &value) != FcResultMatch) {
         value = SK_MinS32;
     }
     return value;
 }
 
 static const char* get_name(FcPattern* pattern, const char field[]) {
+    SkASSERT(gFCSafeToUse);
     const char* name;
     if (FcPatternGetString(pattern, field, 0, (FcChar8**)&name) != FcResultMatch) {
         name = "";
     }
     return name;
 }
 
 static bool valid_pattern(FcPattern* pattern) {
+    SkASSERT(gFCSafeToUse);
     FcBool is_scalable;
     if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &is_scalable) != FcResultMatch || !is_scalable) {
         return false;
     }
 
     // fontconfig can also return fonts which are unreadable
     const char* c_filename = get_name(pattern, FC_FILE);
     if (0 == *c_filename) {
         return false;
     }
@@ skipping 132 matching lines @@
 
     virtual void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
         familyName->set(fFamilyNames->atStr(index));
     }
 
     virtual SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
         return this->onMatchFamily(fFamilyNames->atStr(index));
     }
 
     virtual SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+        FCLocker lock;
+
         FcPattern* pattern = FcPatternCreate();
 
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
 #if 0
         FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 #endif
         FcConfigSubstitute(NULL, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         const char* post_config_family = get_name(pattern, FC_FAMILY);
@@ skipping 56 matching lines @@
         return face;
     }
 
     virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
         return stream.get() ? this->createFromStream(stream, ttcIndex) : NULL;
     }
 
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
                                                unsigned styleBits) const SK_OVERRIDE {
+        FCLocker lock;
         return FontConfigTypeface::LegacyCreateTypeface(NULL, familyName,
                                                   (SkTypeface::Style)styleBits);
     }
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     SkFontConfigInterface* fci = RefFCI();
     return fci ? SkNEW_ARGS(SkFontMgr_fontconfig, (fci)) : NULL;
 }