Port most uses of SkOnce to SkLazyPtr.

src/core/SkTypeface.cpp

 /*
  * Copyright 2011 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAdvancedTypefaceMetrics.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost.h"
-#include "SkOnce.h"
+#include "SkLazyPtr.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 
 //#define TRACE_LIFECYCLE
 
 #ifdef TRACE_LIFECYCLE
     static int32_t gTypefaceCounter;
 #endif
 
 SkTypeface::SkTypeface(Style style, SkFontID fontID, bool isFixedPitch)
@@ skipping 45 matching lines @@
     };
     virtual SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE {
         return SkNEW(EmptyLocalizedStrings);
     };
     virtual int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE { return 0; }
     virtual size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const SK_OVERRIDE {
         return 0;
     }
 };
 
-static SkTypeface* gDefaultTypefaces[] = { NULL, NULL, NULL, NULL };
-static const size_t FONT_STYLE_COUNT = SK_ARRAY_COUNT(gDefaultTypefaces);
-static SkOnceFlag gDefaultTypefaceOnce[FONT_STYLE_COUNT] = {
-    SK_ONCE_INIT, SK_ONCE_INIT, SK_ONCE_INIT, SK_ONCE_INIT
-};
-template <uintmax_t N> struct SkTIsPow2 {
-    static const bool value = (N & (N - 1)) == 0;
-};
-SK_COMPILE_ASSERT(SkTIsPow2<FONT_STYLE_COUNT>::value, FONT_STYLE_COUNT_not_power_of_2);
+SkTypeface* SkTypeface::CreateDefault(int style) {
+    // If backed by fontconfig, it's not safe to call SkFontHost::CreateTypeface concurrently.
+    // To be safe, we serialize here with a mutex so only one call to
+    // CreateTypeface is happening at any given time.
+    // TODO(bungeman, mtklein): This is sad.  Make our fontconfig code safe?
+    SK_DECLARE_STATIC_MUTEX(mutex);
+    SkAutoMutexAcquire lock(&mutex);
 
-void SkTypeface::create_default_typeface(Style style) {
-    if (NULL == gDefaultTypefaces[style]) {
-        gDefaultTypefaces[style] = SkFontHost::CreateTypeface(NULL, NULL, style);
-    }
-    if (NULL == gDefaultTypefaces[style]) {
-        // FIXME: Use a singleton for SkEmptyTypeface.
-        gDefaultTypefaces[style] = SkEmptyTypeface::Create();
-    }
+    SkTypeface* t = SkFontHost::CreateTypeface(NULL, NULL, (Style)style);
+    return t ? t : SkEmptyTypeface::Create();
+}
+
+void SkTypeface::DeleteDefault(SkTypeface* t) {
+    // The SkTypeface returned by SkFontHost::CreateTypeface may _itself_ be a
+    // cleverly-shared singleton.  This is less than ideal.  This means we
+    // cannot just assert our ownership and SkDELETE(t) like we'd want to.
+    SkSafeUnref(t);
 }
 
 SkTypeface* SkTypeface::GetDefaultTypeface(Style style) {
-    SkASSERT((size_t)style < FONT_STYLE_COUNT);
+    SK_DECLARE_STATIC_LAZY_PTR_ARRAY(SkTypeface, defaults, 4, CreateDefault, DeleteDefault);
 
-    // mask off any other bits to avoid a crash in SK_RELEASE
-    style = (Style)(style & (FONT_STYLE_COUNT - 1));
-
-    SkOnce(&gDefaultTypefaceOnce[style], SkTypeface::create_default_typeface, style);
-    return gDefaultTypefaces[style];
+    SkASSERT((int)style < 4);
+    return defaults[style];
 }
 
 SkTypeface* SkTypeface::RefDefault(Style style) {
     return SkRef(GetDefaultTypeface(style));
 }
 
 uint32_t SkTypeface::UniqueID(const SkTypeface* face) {
     if (NULL == face) {
         face = GetDefaultTypeface();
     }
@@ skipping 160 matching lines @@
                                 uint32_t glyphIDsCount) const {
     return this->onGetAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkTypeface::onGetKerningPairAdjustments(const uint16_t glyphs[], int count,
                                              int32_t adjustments[]) const {
     return false;
 }