From f71e8fd0c5d2da9795d00a5b81b716ae585be14a Mon Sep 17 00:00:00 2001 From: "commit-bot@chromium.org" Date: Sat, 31 May 2014 00:15:22 +0000 Subject: Revert of Port most uses of SkOnce to SkLazyPtr. (https://codereview.chromium.org/304383005/) Reason for revert: linux x86-64 release segfault in src/ports/SkFontHost_fontconfig.cpp:107 http://108.170.220.120:10117/builders/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Release/builds/905/steps/RunTests/logs/stdio Original issue's description: > Port most uses of SkOnce to SkLazyPtr. > > BUG=skia: > > Committed: http://code.google.com/p/skia/source/detail?r=15006 > > Committed: http://code.google.com/p/skia/source/detail?r=15014 R=reed@google.com, mtklein@chromium.org TBR=mtklein@chromium.org, reed@google.com NOTREECHECKS=true NOTRY=true BUG=skia: Author: mtklein@google.com Review URL: https://codereview.chromium.org/306063004 git-svn-id: http://skia.googlecode.com/svn/trunk@15015 2bbb7eff-a529-9590-31e7-b0007b416f81 --- src/core/SkFontHost.cpp | 17 ++++++++----- src/core/SkGlyphCache.cpp | 18 +++++++------- src/core/SkLazyPtr.h | 2 ++ src/core/SkMatrix.cpp | 40 ++++++++++++++---------------- src/core/SkMessageBus.h | 21 +++++++++------- src/core/SkPathRef.cpp | 16 ++++++------ src/core/SkTypeface.cpp | 37 +++++++++++++++++---------- src/fonts/SkRemotableFontMgr.cpp | 16 ++++++++---- src/lazy/SkDiscardableMemoryPool.cpp | 23 +++++++++++------ src/ports/SkFontConfigInterface_direct.cpp | 15 +++++------ 10 files changed, 119 insertions(+), 86 deletions(-) (limited to 'src') diff --git a/src/core/SkFontHost.cpp b/src/core/SkFontHost.cpp index a16a8c42e0..9e7eeb182d 100644 --- a/src/core/SkFontHost.cpp +++ b/src/core/SkFontHost.cpp @@ -6,7 +6,7 @@ */ #include "SkFontLCDConfig.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" static SkFontLCDConfig::LCDOrientation gLCDOrientation = SkFontLCDConfig::kHorizontal_LCDOrientation; static SkFontLCDConfig::LCDOrder gLCDOrder = SkFontLCDConfig::kRGB_LCDOrder; @@ -198,14 +198,19 @@ SkTypeface* SkFontMgr::legacyCreateTypeface(const char familyName[], return this->onLegacyCreateTypeface(familyName, styleBits); } -SkFontMgr* SkFontMgr::CreateDefault() { - SkFontMgr* fm = SkFontMgr::Factory(); - return fm ? fm : SkNEW(SkEmptyFontMgr); +void set_up_default(SkFontMgr** singleton) { + *singleton = SkFontMgr::Factory(); + // we never want to return NULL + if (NULL == *singleton) { + *singleton = SkNEW(SkEmptyFontMgr); + } } SkFontMgr* SkFontMgr::RefDefault() { - SK_DECLARE_STATIC_LAZY_PTR(SkFontMgr, singleton, CreateDefault); - return SkRef(singleton.get()); + static SkFontMgr* gFM = NULL; + SK_DECLARE_STATIC_ONCE(once); + SkOnce(&once, set_up_default, &gFM); + return SkRef(gFM); } ////////////////////////////////////////////////////////////////////////// diff --git a/src/core/SkGlyphCache.cpp b/src/core/SkGlyphCache.cpp index 2ab721aab4..699801d2db 100755 --- a/src/core/SkGlyphCache.cpp +++ b/src/core/SkGlyphCache.cpp @@ -11,7 +11,7 @@ #include "SkGlyphCache_Globals.h" #include "SkDistanceFieldGen.h" #include "SkGraphics.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" #include "SkPaint.h" #include "SkPath.h" #include "SkTemplates.h" @@ -21,18 +21,18 @@ //#define SPEW_PURGE_STATUS //#define RECORD_HASH_EFFICIENCY -namespace { - -SkGlyphCache_Globals* create_globals() { - return SkNEW_ARGS(SkGlyphCache_Globals, (SkGlyphCache_Globals::kYes_UseMutex)); +static void create_globals(SkGlyphCache_Globals** globals) { + *globals = SkNEW_ARGS(SkGlyphCache_Globals, (SkGlyphCache_Globals::kYes_UseMutex)); } -} // namespace - // Returns the shared globals static SkGlyphCache_Globals& getSharedGlobals() { - SK_DECLARE_STATIC_LAZY_PTR(SkGlyphCache_Globals, globals, create_globals); - return *globals.get(); + // we leak this, so we don't incur any shutdown cost of the destructor + static SkGlyphCache_Globals* gGlobals = NULL; + SK_DECLARE_STATIC_ONCE(once); + SkOnce(&once, create_globals, &gGlobals); + SkASSERT(NULL != gGlobals); + return *gGlobals; } // Returns the TLS globals (if set), or the shared globals diff --git a/src/core/SkLazyPtr.h b/src/core/SkLazyPtr.h index fa1a14e033..515086876c 100644 --- a/src/core/SkLazyPtr.h +++ b/src/core/SkLazyPtr.h @@ -64,6 +64,7 @@ // See FIXME below. class SkFontConfigInterface; +class SkTypeface; namespace Private { @@ -99,6 +100,7 @@ public: #ifdef SK_DEBUG // FIXME: We know we leak refs on some classes. For now, let them leak. void cleanup(SkFontConfigInterface*) {} + void cleanup(SkTypeface*) {} template void cleanup(U* ptr) { Destroy(ptr); } ~SkLazyPtr() { diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp index 8778f78f41..40f6e5298d 100644 --- a/src/core/SkMatrix.cpp +++ b/src/core/SkMatrix.cpp @@ -7,7 +7,7 @@ #include "SkMatrix.h" #include "SkFloatBits.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" #include "SkString.h" // In a few places, we performed the following @@ -1558,33 +1558,29 @@ bool SkMatrix::getMinMaxScales(SkScalar scaleFactors[2]) const { return get_scale_factor(this->getType(), fMat, scaleFactors); } -namespace { - -SkMatrix* create_identity() { - SkMatrix* m = SkNEW(SkMatrix); - m->reset(); - return m; -} - -SkMatrix* create_invalid() { - SkMatrix* m = SkNEW(SkMatrix); - m->setAll(SK_ScalarMax, SK_ScalarMax, SK_ScalarMax, - SK_ScalarMax, SK_ScalarMax, SK_ScalarMax, - SK_ScalarMax, SK_ScalarMax, SK_ScalarMax); - m->getType(); // Force the type to be computed. - return m; +static void reset_identity_matrix(SkMatrix* identity) { + identity->reset(); } -} // namespace - const SkMatrix& SkMatrix::I() { - SK_DECLARE_STATIC_LAZY_PTR(SkMatrix, identity, create_identity); - return *identity.get(); + // If you can use C++11 now, you might consider replacing this with a constexpr constructor. + static SkMatrix gIdentity; + SK_DECLARE_STATIC_ONCE(once); + SkOnce(&once, reset_identity_matrix, &gIdentity); + return gIdentity; } const SkMatrix& SkMatrix::InvalidMatrix() { - SK_DECLARE_STATIC_LAZY_PTR(SkMatrix, invalid, create_invalid); - return *invalid.get(); + static SkMatrix gInvalid; + static bool gOnce; + if (!gOnce) { + gInvalid.setAll(SK_ScalarMax, SK_ScalarMax, SK_ScalarMax, + SK_ScalarMax, SK_ScalarMax, SK_ScalarMax, + SK_ScalarMax, SK_ScalarMax, SK_ScalarMax); + gInvalid.getType(); // force the type to be computed + gOnce = true; + } + return gInvalid; } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/SkMessageBus.h b/src/core/SkMessageBus.h index f36c42b4c7..ddeac57ac1 100644 --- a/src/core/SkMessageBus.h +++ b/src/core/SkMessageBus.h @@ -8,7 +8,7 @@ #ifndef SkMessageBus_DEFINED #define SkMessageBus_DEFINED -#include "SkLazyPtr.h" +#include "SkOnce.h" #include "SkTDArray.h" #include "SkThread.h" #include "SkTypes.h" @@ -38,7 +38,7 @@ public: private: SkMessageBus(); static SkMessageBus* Get(); - static SkMessageBus* New(); + static void New(SkMessageBus**); SkTDArray fInboxes; SkMutex fInboxesMutex; @@ -46,11 +46,14 @@ private: // This must go in a single .cpp file, not some .h, or we risk creating more than one global // SkMessageBus per type when using shared libraries. -#define DECLARE_SKMESSAGEBUS_MESSAGE(Message) \ - template <> \ - SkMessageBus* SkMessageBus::Get() { \ - SK_DECLARE_STATIC_LAZY_PTR(SkMessageBus, bus, New); \ - return bus.get(); \ +#define DECLARE_SKMESSAGEBUS_MESSAGE(Message) \ + template <> \ + SkMessageBus* SkMessageBus::Get() { \ + static SkMessageBus* bus = NULL; \ + SK_DECLARE_STATIC_ONCE(once); \ + SkOnce(&once, &New, &bus); \ + SkASSERT(bus != NULL); \ + return bus; \ } // ----------------------- Implementation of SkMessageBus::Inbox ----------------------- @@ -97,8 +100,8 @@ template SkMessageBus::SkMessageBus() {} template -/*static*/ SkMessageBus* SkMessageBus::New() { - return SkNEW(SkMessageBus); +/*static*/ void SkMessageBus::New(SkMessageBus** bus) { + *bus = new SkMessageBus(); } template diff --git a/src/core/SkPathRef.cpp b/src/core/SkPathRef.cpp index de7a8f56ae..161eb80419 100644 --- a/src/core/SkPathRef.cpp +++ b/src/core/SkPathRef.cpp @@ -6,7 +6,7 @@ */ #include "SkBuffer.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" #include "SkPath.h" #include "SkPathRef.h" @@ -28,16 +28,18 @@ SkPathRef::Editor::Editor(SkAutoTUnref* pathRef, } ////////////////////////////////////////////////////////////////////////////// +static SkPathRef* gEmptyPathRef = NULL; +static void cleanup_gEmptyPathRef() { gEmptyPathRef->unref(); } -SkPathRef* SkPathRef::CreateEmptyImpl() { - SkPathRef* p = SkNEW(SkPathRef); - p->computeBounds(); // Preemptively avoid a race to clear fBoundsIsDirty. - return p; +void SkPathRef::CreateEmptyImpl(int) { + gEmptyPathRef = SkNEW(SkPathRef); + gEmptyPathRef->computeBounds(); // Preemptively avoid a race to clear fBoundsIsDirty. } SkPathRef* SkPathRef::CreateEmpty() { - SK_DECLARE_STATIC_LAZY_PTR(SkPathRef, empty, CreateEmptyImpl); - return SkRef(empty.get()); + SK_DECLARE_STATIC_ONCE(once); + SkOnce(&once, SkPathRef::CreateEmptyImpl, 0, cleanup_gEmptyPathRef); + return SkRef(gEmptyPathRef); } void SkPathRef::CreateTransformedCopy(SkAutoTUnref* dst, diff --git a/src/core/SkTypeface.cpp b/src/core/SkTypeface.cpp index 6139c1e411..cd3953ba98 100644 --- a/src/core/SkTypeface.cpp +++ b/src/core/SkTypeface.cpp @@ -8,7 +8,7 @@ #include "SkAdvancedTypefaceMetrics.h" #include "SkFontDescriptor.h" #include "SkFontHost.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" #include "SkStream.h" #include "SkTypeface.h" @@ -74,23 +74,34 @@ protected: } }; -SkTypeface* SkTypeface::CreateDefault(int style) { - SkTypeface* t = SkFontHost::CreateTypeface(NULL, NULL, (Style)style); - return t ? t : SkEmptyTypeface::Create(); -} +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 struct SkTIsPow2 { + static const bool value = (N & (N - 1)) == 0; +}; +SK_COMPILE_ASSERT(SkTIsPow2::value, FONT_STYLE_COUNT_not_power_of_2); -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); +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* SkTypeface::GetDefaultTypeface(Style style) { - SK_DECLARE_STATIC_LAZY_PTR_ARRAY(SkTypeface, defaults, 4, CreateDefault, DeleteDefault); + SkASSERT((size_t)style < FONT_STYLE_COUNT); + + // mask off any other bits to avoid a crash in SK_RELEASE + style = (Style)(style & (FONT_STYLE_COUNT - 1)); - SkASSERT((int)style < 4); - return defaults[style]; + SkOnce(&gDefaultTypefaceOnce[style], SkTypeface::create_default_typeface, style); + return gDefaultTypefaces[style]; } SkTypeface* SkTypeface::RefDefault(Style style) { diff --git a/src/fonts/SkRemotableFontMgr.cpp b/src/fonts/SkRemotableFontMgr.cpp index 633e91458b..1139972848 100644 --- a/src/fonts/SkRemotableFontMgr.cpp +++ b/src/fonts/SkRemotableFontMgr.cpp @@ -7,7 +7,7 @@ #include "SkRemotableFontMgr.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" SkRemotableFontIdentitySet::SkRemotableFontIdentitySet(int count, SkFontIdentity** data) : fCount(count), fData(count) @@ -16,11 +16,17 @@ SkRemotableFontIdentitySet::SkRemotableFontIdentitySet(int count, SkFontIdentity *data = fData; } -SkRemotableFontIdentitySet* SkRemotableFontIdentitySet::NewEmptyImpl() { - return SkNEW(SkRemotableFontIdentitySet); +static SkRemotableFontIdentitySet* gEmptyRemotableFontIdentitySet = NULL; +static void cleanup_gEmptyRemotableFontIdentitySet() { gEmptyRemotableFontIdentitySet->unref(); } + +void SkRemotableFontIdentitySet::NewEmptyImpl(int) { + gEmptyRemotableFontIdentitySet = new SkRemotableFontIdentitySet(); } SkRemotableFontIdentitySet* SkRemotableFontIdentitySet::NewEmpty() { - SK_DECLARE_STATIC_LAZY_PTR(SkRemotableFontIdentitySet, empty, NewEmptyImpl); - return SkRef(empty.get()); + SK_DECLARE_STATIC_ONCE(once); + SkOnce(&once, SkRemotableFontIdentitySet::NewEmptyImpl, 0, + cleanup_gEmptyRemotableFontIdentitySet); + gEmptyRemotableFontIdentitySet->ref(); + return gEmptyRemotableFontIdentitySet; } diff --git a/src/lazy/SkDiscardableMemoryPool.cpp b/src/lazy/SkDiscardableMemoryPool.cpp index 1d63a0bad7..4fb8ae4fe1 100644 --- a/src/lazy/SkDiscardableMemoryPool.cpp +++ b/src/lazy/SkDiscardableMemoryPool.cpp @@ -7,7 +7,7 @@ #include "SkDiscardableMemory.h" #include "SkDiscardableMemoryPool.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" #include "SkTInternalLList.h" #include "SkThread.h" @@ -248,20 +248,27 @@ void DiscardableMemoryPool::dumpPool() { //////////////////////////////////////////////////////////////////////////////// SK_DECLARE_STATIC_MUTEX(gMutex); -SkDiscardableMemoryPool* create_global_pool() { - return SkDiscardableMemoryPool::Create(SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE, - &gMutex); +SkDiscardableMemoryPool* gPool = NULL; +void create_global_pool(int) { + SkASSERT(NULL == gPool); + gPool = SkDiscardableMemoryPool::Create( + SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE, &gMutex); +} +void cleanup_global_pool() { + gPool->unref(); } - } // namespace -SkDiscardableMemoryPool* SkDiscardableMemoryPool::Create(size_t size, SkBaseMutex* mutex) { +SkDiscardableMemoryPool* SkDiscardableMemoryPool::Create( + size_t size, SkBaseMutex* mutex) { return SkNEW_ARGS(DiscardableMemoryPool, (size, mutex)); } SkDiscardableMemoryPool* SkGetGlobalDiscardableMemoryPool() { - SK_DECLARE_STATIC_LAZY_PTR(SkDiscardableMemoryPool, global, create_global_pool); - return global.get(); + SK_DECLARE_STATIC_ONCE(create_pool_once); + SkOnce(&create_pool_once, create_global_pool, 0, &cleanup_global_pool); + SkASSERT(NULL != gPool); + return gPool; } // defined in SkImageGenerator.h diff --git a/src/ports/SkFontConfigInterface_direct.cpp b/src/ports/SkFontConfigInterface_direct.cpp index bc3dede40d..80ee56e85c 100644 --- a/src/ports/SkFontConfigInterface_direct.cpp +++ b/src/ports/SkFontConfigInterface_direct.cpp @@ -15,7 +15,7 @@ #include "SkBuffer.h" #include "SkFontConfigInterface.h" -#include "SkLazyPtr.h" +#include "SkOnce.h" #include "SkStream.h" size_t SkFontConfigInterface::FontIdentity::writeToMemory(void* addr) const { @@ -124,13 +124,14 @@ private: SkMutex mutex_; }; -namespace { -SkFontConfigInterface* create_direct() { return SkNEW(SkFontConfigInterfaceDirect); } -} // namespace - +static void create_singleton_direct_interface(SkFontConfigInterface** singleton) { + *singleton = new SkFontConfigInterfaceDirect; +} SkFontConfigInterface* SkFontConfigInterface::GetSingletonDirectInterface() { - SK_DECLARE_STATIC_LAZY_PTR(SkFontConfigInterface, direct, create_direct); - return direct.get(); + static SkFontConfigInterface* gDirect; + SK_DECLARE_STATIC_ONCE(once); + SkOnce(&once, create_singleton_direct_interface, &gDirect); + return gDirect; } /////////////////////////////////////////////////////////////////////////////// -- cgit v1.2.3