static int32_t next_id() { int32_t id; do { id = sk_atomic_inc(&gNextID); } while (id == SK_InvalidGenID); return id; }
void AndroidPixelRef::globalRef(void* localref) { if (fWrappedPixelRef) { // delegate java obj management to the wrapped ref fWrappedPixelRef->globalRef(localref); // Note: we only ref and unref the wrapped AndroidPixelRef so that // bitmap->pixelRef()->globalRef() and globalUnref() can be used in a pair, even if // the bitmap has its underlying AndroidPixelRef swapped out/wrapped return; } if (fOnJavaHeap && sk_atomic_inc(&fGlobalRefCnt) == 0) { JNIEnv *env = vm2env(fVM); // If JNI ref was passed, it is always used if (localref) fStorageObj = (jbyteArray) localref; if (fStorageObj == NULL) { SkDebugf("No valid local ref to create a JNI global ref\n"); sk_throw(); } if (fHasGlobalRef) { // This should never happen SkDebugf("Already holding a JNI global ref"); sk_throw(); } fStorageObj = (jbyteArray) env->NewGlobalRef(fStorageObj); // TODO: Check for failure here fHasGlobalRef = true; } ref(); }
uint32_t GrGpuResource::CreateUniqueID() { static int32_t gUniqueID = SK_InvalidUniqueID; uint32_t id; do { id = static_cast<uint32_t>(sk_atomic_inc(&gUniqueID) + 1); } while (id == SK_InvalidUniqueID); return id; }
SkColorSpace::SkColorSpace(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50) : fColorLUT(colorLUT) , fGammas(gammas) , fToXYZD50(toXYZD50) , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID)) , fNamed(kUnknown_Named) {}
uint32_t GrProgramElement::CreateUniqueID() { static int32_t gUniqueID = SK_InvalidUniqueID; uint32_t id; do { id = static_cast<uint32_t>(sk_atomic_inc(&gUniqueID) + 1); } while (id == SK_InvalidUniqueID); return id; }
uint32_t GrDrawTargetCaps::CreateUniqueID() { static int32_t gUniqueID = SK_InvalidUniqueID; uint32_t id; do { id = static_cast<uint32_t>(sk_atomic_inc(&gUniqueID) + 1); } while (id == SK_InvalidUniqueID); return id; }
SkOSMenu::Item::Item(const char label[], SkOSMenu::Type type, const char slotName[], SkEvent* evt) { fLabel.set(label); fSlotName.set(slotName); fType = type; fEvent = evt; fKey = 0; fID = sk_atomic_inc(&gOSMenuCmd); }
static int32_t next_image_filter_unique_id() { static int32_t gImageFilterUniqueID; // Never return 0. int32_t id; do { id = sk_atomic_inc(&gImageFilterUniqueID) + 1; } while (0 == id); return id; }
SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() { static int32_t gNextID = 0; int32_t id = sk_atomic_inc(&gNextID); if (id >= 1 << (8 * sizeof(Domain))) { SK_CRASH(); } return static_cast<Domain>(id); }
GrCacheID::Domain GrCacheID::GenerateDomain() { static int32_t gNextDomain = kInvalid_Domain + 1; int32_t domain = sk_atomic_inc(&gNextDomain); if (domain >= 1 << (8 * sizeof(Domain))) { GrCrash("Too many Cache Domains"); } return static_cast<Domain>(domain); }
SkBaseMutex* get_default_mutex() { #ifdef PIXELREF_MUTEX_RING_COUNT // atomic_inc might be overkill here. It may be fine if once in a while // we hit a race-condition and two subsequent calls get the same index... int index = sk_atomic_inc(&gPixelRefMutexRingIndex); return &gPixelRefMutexRing[index & (PIXELREF_MUTEX_RING_COUNT - 1)]; #else return &gPixelRefMutex; #endif }
GrResourceKey::ResourceType GrResourceKey::GenerateResourceType() { static int32_t gNextType = 0; int32_t type = sk_atomic_inc(&gNextType); if (type >= (1 << 8 * sizeof(ResourceType))) { SkFAIL("Too many Resource Types"); } return static_cast<ResourceType>(type); }
uint32_t SkImage::NextUniqueID() { static int32_t gUniqueID; // never return 0; uint32_t id; do { id = sk_atomic_inc(&gUniqueID) + 1; } while (0 == id); return id; }
static SkBaseMutex* get_default_mutex() { static int32_t gPixelRefMutexRingIndex; SkASSERT(SkIsPow2(PIXELREF_MUTEX_RING_COUNT)); // atomic_inc might be overkill here. It may be fine if once in a while // we hit a race-condition and two subsequent calls get the same index... int index = sk_atomic_inc(&gPixelRefMutexRingIndex); return &gPixelRefMutexRing[index & (PIXELREF_MUTEX_RING_COUNT - 1)]; }
GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() { static int32_t gType = INHERITED::kInvalidDomain + 1; int32_t type = sk_atomic_inc(&gType); if (type > SK_MaxU16) { SkFAIL("Too many Resource Types"); } return static_cast<ResourceType>(type); }
GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() { static int32_t gType = INHERITED::kInvalidDomain + 1; int32_t type = sk_atomic_inc(&gType); if (type > SkTo<int32_t>(UINT16_MAX)) { SK_ABORT("Too many Resource Types"); } return static_cast<ResourceType>(type); }
GrUniqueKey::Domain GrUniqueKey::GenerateDomain() { static int32_t gDomain = INHERITED::kInvalidDomain + 1; int32_t domain = sk_atomic_inc(&gDomain); if (domain > SkTo<int32_t>(UINT16_MAX)) { SK_ABORT("Too many GrUniqueKey Domains"); } return static_cast<Domain>(domain); }
int32_t SkNextPixelRefGenerationID() { static int32_t gPixelRefGenerationID; // do a loop in case our global wraps around, as we never want to // return a 0 int32_t genID; do { genID = sk_atomic_inc(&gPixelRefGenerationID) + 1; } while (0 == genID); return genID; }
GrUniqueKey::Domain GrUniqueKey::GenerateDomain() { static int32_t gDomain = INHERITED::kInvalidDomain + 1; int32_t domain = sk_atomic_inc(&gDomain); if (domain > SK_MaxU16) { SkFAIL("Too many GrUniqueKey Domains"); } return static_cast<Domain>(domain); }
static int32_t next_generation_id() { static int32_t gCanvasDrawableGenerationID; // do a loop in case our global wraps around, as we never want to // return a 0 int32_t genID; do { genID = sk_atomic_inc(&gCanvasDrawableGenerationID) + 1; } while (0 == genID); return genID; }
FamilyTypeface(Style style, bool sysFont, FamilyRec* family, bool isFixedPitch) : INHERITED(style, sk_atomic_inc(&gUniqueFontID) + 1, isFixedPitch) { fIsSysFont = sysFont; SkAutoMutexAcquire ac(gFamilyMutex); if (NULL == family) { family = SkNEW(FamilyRec); } family->fFaces[style] = this; fFamilyRec = family; // just record it so we can return it if asked }
static void bumpCount(skiatest::Reporter* reporter, bool skipping) { if (reporter->verbose()) { static int threadTestCount; sk_atomic_inc(&threadTestCount); if (!skipping && threadTestCount % 100 == 0) { SkDebugf("#%d\n", threadTestCount); } if (skipping && threadTestCount % 10000 == 0) { SkDebugf("#%d\n", threadTestCount); } } }
static void testSkpClipMain(PathOpsThreadState* data) { SkString str(data->fSerialNo); testOne(str); if (data->fReporter->verbose()) { SkDebugf("."); static int threadTestCount; sk_atomic_inc(&threadTestCount); if (threadTestCount % 100 == 0) { SkDebugf("\n"); } } }
uint32_t SkPixelRef::getGenerationID() const { uint32_t genID = fGenerationID; if (0 == genID) { // do a loop in case our global wraps around, as we never want to // return a 0 do { genID = sk_atomic_inc(&gPixelRefGenerationID) + 1; } while (0 == genID); fGenerationID = genID; } return genID; }
SkColorSpace::SkColorSpace(const SkFloat3x3& toXYZD50, const SkFloat3& gamma, Named named) : fToXYZD50(toXYZD50) , fGamma(gamma) , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID)) , fNamed(named) { for (int i = 0; i < 3; ++i) { SkASSERT(SkFloatIsFinite(gamma.fVec[i])); for (int j = 0; j < 3; ++j) { SkASSERT(SkFloatIsFinite(toXYZD50.fMat[3*i + j])); } } }
GrTextureStripAtlas::GrTextureStripAtlas(GrTextureStripAtlas::Desc desc) : fCacheKey(sk_atomic_inc(&gCacheCount)) , fLockedRows(0) , fDesc(desc) , fNumRows(desc.fHeight / desc.fRowHeight) , fTexture(NULL) , fRows(SkNEW_ARRAY(AtlasRow, fNumRows)) , fLRUFront(NULL) , fLRUBack(NULL) { GrAssert(fNumRows * fDesc.fRowHeight == fDesc.fHeight); this->initLRU(); VALIDATE; }
GrTextureStripAtlas::GrTextureStripAtlas(GrTextureStripAtlas::Desc desc) : fCacheKey(sk_atomic_inc(&gCacheCount)) , fLockedRows(0) , fDesc(desc) , fNumRows(desc.fHeight / desc.fRowHeight) , fTexture(nullptr) , fRows(new AtlasRow[fNumRows]) , fLRUFront(nullptr) , fLRUBack(nullptr) { SkASSERT(fNumRows * fDesc.fRowHeight == fDesc.fHeight); this->initLRU(); fNormalizedYHeight = SK_Scalar1 / fDesc.fHeight; VALIDATE; }
FamilyTypeface(Style style, bool sysFont, SkTypeface* familyMember, bool isFixedPitch) : INHERITED(style, sk_atomic_inc(&gUniqueFontID) + 1, isFixedPitch) { fIsSysFont = sysFont; // our caller has acquired the gFamilyHeadAndNameListMutex so this is safe FamilyRec* rec = NULL; if (familyMember) { rec = find_family(familyMember); SkASSERT(rec); } else { rec = SkNEW(FamilyRec); } rec->fFaces[style] = this; }
FamilyTypeface(Style style, bool sysFont, SkTypeface* familyMember) : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1) { fIsSysFont = sysFont; SkAutoMutexAcquire ac(gFamilyMutex); FamilyRec* rec = NULL; if (familyMember) { rec = find_family(familyMember); SkASSERT(rec); } else { rec = SkNEW(FamilyRec); } rec->fFaces[style] = this; }
SkPathRef::Editor::Editor(SkAutoTUnref<SkPathRef>* pathRef, int incReserveVerbs, int incReservePoints) { if ((*pathRef)->unique()) { (*pathRef)->incReserve(incReserveVerbs, incReservePoints); } else { SkPathRef* copy = SkNEW(SkPathRef); copy->copy(**pathRef, incReserveVerbs, incReservePoints); pathRef->reset(copy); } fPathRef = *pathRef; fPathRef->fGenerationID = 0; SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);) }