void CFPreferencesFlushCaches(void) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
__CFSpinLock(&__CFApplicationPreferencesLock);
if (__CFStandardUserPreferences) {
_CFApplicationPreferences **prefsArray, *prefsBuf[32];
CFIndex idx, count = CFDictionaryGetCount(__CFStandardUserPreferences);
if (count < 32) {
prefsArray = prefsBuf;
} else {
prefsArray = (_CFApplicationPreferences **)CFAllocatorAllocate(alloc, count * sizeof(_CFApplicationPreferences *), 0);
}
CFDictionaryGetKeysAndValues(__CFStandardUserPreferences, NULL, (const void **)prefsArray);
__CFSpinUnlock(&__CFApplicationPreferencesLock);
// DeallocateApplicationPreferences needs the lock
for (idx = 0; idx < count; idx ++) {
_CFApplicationPreferences *appPrefs = prefsArray[idx];
_CFApplicationPreferencesSynchronize(appPrefs);
_CFDeallocateApplicationPreferences(appPrefs);
}
__CFSpinLock(&__CFApplicationPreferencesLock);
CFRelease(__CFStandardUserPreferences);
__CFStandardUserPreferences = NULL;
if(prefsArray != prefsBuf) CFAllocatorDeallocate(alloc, prefsArray);
}
__CFSpinUnlock(&__CFApplicationPreferencesLock);
_CFPreferencesPurgeDomainCache();
}
static void _CFPFactoryRemoveFromTable(_CFPFactoryRef factory) {
__CFSpinLock(&factory->_lock);
CFUUIDRef uuid = factory->_uuid;
if (uuid) CFRetain(uuid);
__CFSpinUnlock(&factory->_lock);
__CFSpinLock(&CFPlugInGlobalDataLock);
if (uuid && _factoriesByTypeID) CFDictionaryRemoveValue(_factoriesByFactoryID, uuid);
__CFSpinUnlock(&CFPlugInGlobalDataLock);
if (uuid) CFRelease(uuid);
}
// Exclusively for Foundation's use
void _CFApplicationPreferencesSetCacheForApp(_CFApplicationPreferences *appPrefs, CFStringRef appName) {
__CFSpinLock(&__CFApplicationPreferencesLock);
if (!__CFStandardUserPreferences) {
__CFStandardUserPreferences = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, NULL);
CFDictionarySetValue(__CFStandardUserPreferences, appName, appPrefs);
__CFSpinUnlock(&__CFApplicationPreferencesLock);
} else {
_CFApplicationPreferences *oldPrefs = (_CFApplicationPreferences *)CFDictionaryGetValue(__CFStandardUserPreferences, appName);
CFDictionarySetValue(__CFStandardUserPreferences, appName, appPrefs);
__CFSpinUnlock(&__CFApplicationPreferencesLock);
if (oldPrefs) {
_CFDeallocateApplicationPreferences(oldPrefs);
}
}
}
__private_extern__ CFPlugInRef _CFPFactoryCopyPlugIn(_CFPFactoryRef factory) {
__CFSpinLock(&factory->_lock);
CFPlugInRef result = factory->_plugIn;
if (result) CFRetain(result);
__CFSpinUnlock(&factory->_lock);
return result;
}
void CFMessagePortInvalidate(CFMessagePortRef ms) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
if (!__CFMessagePortIsDeallocing(ms)) {
CFRetain(ms);
}
__CFMessagePortLock(ms);
if (__CFMessagePortIsValid(ms)) {
CFMessagePortInvalidationCallBack callout = ms->_icallout;
CFRunLoopSourceRef source = ms->_source;
CFMachPortRef replyPort = ms->_replyPort;
CFMachPortRef port = ms->_port;
CFStringRef name = ms->_name;
void *info = NULL;
__CFMessagePortUnsetValid(ms);
if (!__CFMessagePortIsRemote(ms)) {
info = ms->_context.info;
ms->_context.info = NULL;
}
ms->_source = NULL;
ms->_replyPort = NULL;
__CFMessagePortUnlock(ms);
__CFSpinLock(&__CFAllMessagePortsLock);
if (NULL != (__CFMessagePortIsRemote(ms) ? __CFAllRemoteMessagePorts : __CFAllLocalMessagePorts)) {
CFDictionaryRemoveValue(__CFMessagePortIsRemote(ms) ? __CFAllRemoteMessagePorts : __CFAllLocalMessagePorts, name);
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
if (NULL != callout) {
callout(ms, info);
}
// We already know we're going invalid, don't need this callback
// anymore; plus, this solves a reentrancy deadlock; also, this
// must be done before the deallocate of the Mach port, to
// avoid a race between the notification message which could be
// handled in another thread, and this NULL'ing out.
CFMachPortSetInvalidationCallBack(port, NULL);
// For hashing and equality purposes, cannot get rid of _port here
if (!__CFMessagePortIsRemote(ms) && NULL != ms->_context.release) {
ms->_context.release(info);
}
if (NULL != source) {
CFRunLoopSourceInvalidate(source);
CFRelease(source);
}
if (NULL != replyPort) {
CFMachPortInvalidate(replyPort);
CFRelease(replyPort);
}
if (__CFMessagePortIsRemote(ms)) {
// Get rid of our extra ref on the Mach port gotten from bs server
mach_port_deallocate(mach_task_self(), CFMachPortGetPort(port));
}
} else {
__CFMessagePortUnlock(ms);
}
if (!__CFMessagePortIsDeallocing(ms)) {
CFRelease(ms);
}
}
__private_extern__ void _CFPFactoryFlushFunctionCache(_CFPFactoryRef factory) {
/* MF:!!! Assert that this factory belongs to a plugIn. */
/* This is called by the factory's plugIn when the plugIn unloads its code. */
__CFSpinLock(&factory->_lock);
factory->_func = NULL;
__CFSpinUnlock(&factory->_lock);
}
CF_PRIVATE CFUUIDRef _CFPFactoryCopyFactoryID(_CFPFactoryRef factory) {
__CFSpinLock(&factory->_lock);
CFUUIDRef uuid = factory->_uuid;
if (uuid) CFRetain(uuid);
__CFSpinUnlock(&factory->_lock);
return uuid;
}
__private_extern__ CFErrorRef _CFErrorFromStreamError(CFAllocatorRef alloc, CFStreamError *streamError) {
CFErrorRef result;
Boolean canUpCall;
__CFSpinLock(&(CFNetworkSupport.lock));
if (!__CFBitIsSet(CFNetworkSupport.flags, kTriedToLoad)) initializeCFNetworkSupport();
canUpCall = (CFNetworkSupport._CFErrorCreateWithStreamError != NULL);
__CFSpinUnlock(&(CFNetworkSupport.lock));
if (canUpCall) {
result = CFNETWORK_CALL(_CFErrorCreateWithStreamError, (alloc, streamError));
} else {
if (streamError->domain == kCFStreamErrorDomainPOSIX) {
return CFErrorCreate(alloc, kCFErrorDomainPOSIX, streamError->error, NULL);
} else if (streamError->domain == kCFStreamErrorDomainMacOSStatus) {
return CFErrorCreate(alloc, kCFErrorDomainOSStatus, streamError->error, NULL);
} else {
CFStringRef key = CFSTR("CFStreamErrorDomainKey");
CFNumberRef value = CFNumberCreate(alloc, kCFNumberCFIndexType, &streamError->domain);
CFDictionaryRef dict = CFDictionaryCreate(alloc, (const void **)(&key), (const void **)(&value), 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
result = CFErrorCreate(alloc, CFSTR("BogusCFStreamErrorCompatibilityDomain"), streamError->error, dict);
CFRelease(value);
CFRelease(dict);
}
}
return result;
}
__private_extern__ CFStreamError _CFStreamErrorFromError(CFErrorRef error) {
CFStreamError result;
Boolean canUpCall;
__CFSpinLock(&(CFNetworkSupport.lock));
if (!__CFBitIsSet(CFNetworkSupport.flags, kTriedToLoad)) initializeCFNetworkSupport();
canUpCall = (CFNetworkSupport._CFStreamErrorFromCFError != NULL);
__CFSpinUnlock(&(CFNetworkSupport.lock));
if (canUpCall) {
result = CFNETWORK_CALL(_CFStreamErrorFromCFError, (error));
} else {
CFStringRef domain = CFErrorGetDomain(error);
if (CFEqual(domain, kCFErrorDomainPOSIX)) {
result.domain = kCFStreamErrorDomainPOSIX;
} else if (CFEqual(domain, kCFErrorDomainOSStatus)) {
result.domain = kCFStreamErrorDomainMacOSStatus;
} else if (CFEqual(domain, kCFErrorDomainMach)) {
result.domain = 11; // kCFStreamErrorDomainMach, but that symbol is in CFNetwork
} else {
result.domain = kCFStreamErrorDomainCustom;
}
result.error = CFErrorGetCode(error);
}
return result;
}
CFErrorUserInfoKeyCallBack CFErrorGetCallBackForDomain(CFStringRef domainName) {
if (!_CFErrorCallBackTable) _CFErrorInitializeCallBackTable();
__CFSpinLock(&_CFErrorSpinlock);
CFErrorUserInfoKeyCallBack callBack = (CFErrorUserInfoKeyCallBack)CFDictionaryGetValue(_CFErrorCallBackTable, domainName);
__CFSpinUnlock(&_CFErrorSpinlock);
return callBack;
}
__private_extern__ CFUUIDRef _CFPFactoryCopyFactoryID(_CFPFactoryRef factory) {
__CFSpinLock(&factory->_lock);
CFUUIDRef uuid = factory->_uuid;
if (uuid) CFRetain(uuid);
__CFSpinUnlock(&factory->_lock);
return uuid;
}
Boolean _CFApplicationPreferencesSynchronize(_CFApplicationPreferences *self) {
Boolean result;
__CFSpinLock(&__CFApplicationPreferencesLock);
result = _CFApplicationPreferencesSynchronizeNoLock(self);
__CFSpinUnlock(&__CFApplicationPreferencesLock);
return result;
}
static Boolean synchronizeXMLDomain(CFTypeRef context, void *xmlDomain) {
_CFXMLPreferencesDomain *domain = (_CFXMLPreferencesDomain *)xmlDomain;
CFMutableDictionaryRef cachedDict;
CFMutableArrayRef changedKeys;
SInt32 idx, count;
Boolean success, tryAgain;
__CFSpinLock(&domain->_lock);
cachedDict = domain->_domainDict;
changedKeys = domain->_dirtyKeys;
count = CFArrayGetCount(changedKeys);
if (count == 0) {
// no changes were made to this domain; just remove it from the cache to guarantee it will be taken from disk next access
if (cachedDict) {
CFRelease(cachedDict);
domain->_domainDict = NULL;
}
__CFSpinUnlock(&domain->_lock);
return true;
}
domain->_domainDict = NULL; // This forces a reload. Note that we now have a retain on cachedDict
do {
_loadXMLDomainIfStale((CFURLRef )context, domain);
// now cachedDict holds our changes; domain->_domainDict has the latest version from the disk
for (idx = 0; idx < count; idx ++) {
CFStringRef key = (CFStringRef) CFArrayGetValueAtIndex(changedKeys, idx);
CFTypeRef value = CFDictionaryGetValue(cachedDict, key);
if (value)
CFDictionarySetValue(domain->_domainDict, key, value);
else
CFDictionaryRemoveValue(domain->_domainDict, key);
}
success = _writeXMLFile((CFURLRef )context, domain->_domainDict, domain->_isWorldReadable, &tryAgain);
if (tryAgain) {
__CFMilliSleep((((uint32_t)__CFReadTSR() & 0xf) + 1) * 50);
}
} while (tryAgain);
CFRelease(cachedDict);
if (success) {
CFArrayRemoveAllValues(domain->_dirtyKeys);
}
domain->_lastReadTime = CFAbsoluteTimeGetCurrent();
__CFSpinUnlock(&domain->_lock);
return success;
}
static void _CFPFactoryAddToTable(_CFPFactoryRef factory) {
__CFSpinLock(&factory->_lock);
CFUUIDRef uuid = (CFUUIDRef)CFRetain(factory->_uuid);
CFRetain(factory);
__CFSpinUnlock(&factory->_lock);
__CFSpinLock(&CFPlugInGlobalDataLock);
if (!_factoriesByFactoryID) {
CFDictionaryValueCallBacks _factoryDictValueCallbacks = {0, NULL, NULL, NULL, NULL};
_factoriesByFactoryID = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, &_factoryDictValueCallbacks);
}
CFDictionarySetValue(_factoriesByFactoryID, uuid, factory);
__CFSpinUnlock(&CFPlugInGlobalDataLock);
if (uuid) CFRelease(uuid);
CFRelease(factory);
}
/* This initialize function is meant to be called lazily, the first time a callback is registered or requested. It creates the table and registers the built-in callbacks. Clearly doing this non-lazily in _CFErrorInitialize() would be simpler, but this is a fine example of something that should not have to happen at launch time.
*/
static void _CFErrorInitializeCallBackTable(void) {
// Create the table outside the lock
CFMutableDictionaryRef table = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFCopyStringDictionaryKeyCallBacks, NULL);
__CFSpinLock(&_CFErrorSpinlock);
if (!_CFErrorCallBackTable) {
_CFErrorCallBackTable = table;
__CFSpinUnlock(&_CFErrorSpinlock);
} else {
__CFSpinUnlock(&_CFErrorSpinlock);
CFRelease(table);
// Note, even though the table looks like it was initialized, we go on to register the items on this thread as well, since otherwise we might consult the table before the items are actually registered.
}
CFErrorSetCallBackForDomain(kCFErrorDomainPOSIX, _CFErrorPOSIXCallBack);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
CFErrorSetCallBackForDomain(kCFErrorDomainMach, _CFErrorMachCallBack);
#endif
}
__private_extern__ void _CFPreferencesPurgeDomainCache(void) {
_CFSynchronizeDomainCache();
__CFSpinLock(&domainCacheLock);
if (domainCache) {
CFRelease(domainCache);
domainCache = NULL;
}
__CFSpinUnlock(&domainCacheLock);
}
__private_extern__ Boolean _CFSynchronizeDomainCache(void) {
Boolean result = true;
__CFSpinLock(&domainCacheLock);
if (domainCache) {
CFDictionaryApplyFunction(domainCache, __CFPreferencesPerformSynchronize, &result);
}
__CFSpinUnlock(&domainCacheLock);
return result;
}
__private_extern__ Boolean _CFPFactorySupportsType(_CFPFactoryRef factory, CFUUIDRef typeID) {
SInt32 idx;
__CFSpinLock(&factory->_lock);
idx = CFArrayGetFirstIndexOfValue(factory->_types, CFRangeMake(0, CFArrayGetCount(factory->_types)), typeID);
__CFSpinUnlock(&factory->_lock);
return (idx >= 0 ? true : false);
}
CF_PRIVATE void _CFPreferencesPurgeDomainCache(void) {
_CFSynchronizeDomainCache();
__CFSpinLock(&domainCacheLock);
if (domainCache) {
CFRelease(domainCache);
domainCache = NULL;
}
__CFSpinUnlock(&domainCacheLock);
}
__private_extern__ CFArrayRef _CFPFactoryFindForType(CFUUIDRef typeID) {
CFArrayRef result = NULL;
__CFSpinLock(&CFPlugInGlobalDataLock);
if (_factoriesByTypeID) result = (CFArrayRef)CFDictionaryGetValue(_factoriesByTypeID, typeID);
__CFSpinUnlock(&CFPlugInGlobalDataLock);
return result;
}
CFPreferencesDomainRef _CFPreferencesStandardDomain(CFStringRef domainName, CFStringRef userName, CFStringRef hostName) {
CFPreferencesDomainRef domain;
CFStringRef domainKey;
Boolean shouldReleaseDomain = true;
domainKey = _CFPreferencesStandardDomainCacheKey(domainName, userName, hostName);
__CFSpinLock(&domainCacheLock);
if (!domainCache) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
domainCache = CFDictionaryCreateMutable(alloc, 0, & kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
domain = (CFPreferencesDomainRef)CFDictionaryGetValue(domainCache, domainKey);
__CFSpinUnlock(&domainCacheLock);
if (!domain) {
// Domain's not in the cache; load from permanent storage
CFURLRef theURL = _CFPreferencesURLForStandardDomain(domainName, userName, hostName);
if (theURL) {
domain = _CFPreferencesDomainCreate(theURL, &__kCFXMLPropertyListDomainCallBacks);
if (userName == kCFPreferencesAnyUser) {
_CFPreferencesDomainSetIsWorldReadable(domain, true);
}
CFRelease(theURL);
}
__CFSpinLock(&domainCacheLock);
if (domain && domainCache) {
// We've just synthesized a domain & we're about to throw it in the domain cache. The problem is that someone else might have gotten in here behind our backs, so we can't just blindly set the domain (3021920). We'll need to check to see if this happened, and compensate.
CFPreferencesDomainRef checkDomain = (CFPreferencesDomainRef)CFDictionaryGetValue(domainCache, domainKey);
if(checkDomain) {
// Someone got in here ahead of us, so we shouldn't smash the domain we're given. checkDomain is the current version, we should use that.
// checkDomain was retrieved with a Get, so we don't want to over-release.
shouldReleaseDomain = false;
CFRelease(domain); // release the domain we synthesized earlier.
domain = checkDomain; // repoint it at the domain picked up out of the cache.
} else {
// We must not have found the domain in the cache, so it's ok for us to put this in.
CFDictionarySetValue(domainCache, domainKey, domain);
}
if(shouldReleaseDomain) CFRelease(domain);
}
__CFSpinUnlock(&domainCacheLock);
}
CFRelease(domainKey);
return domain;
}
void CFErrorSetCallBackForDomain(CFStringRef domainName, CFErrorUserInfoKeyCallBack callBack) {
if (!_CFErrorCallBackTable) _CFErrorInitializeCallBackTable();
__CFSpinLock(&_CFErrorSpinlock);
if (callBack) {
CFDictionarySetValue(_CFErrorCallBackTable, domainName, callBack);
} else {
CFDictionaryRemoveValue(_CFErrorCallBackTable, domainName);
}
__CFSpinUnlock(&_CFErrorSpinlock);
}
Boolean CFMessagePortSetName(CFMessagePortRef ms, CFStringRef name) {
CFAllocatorRef allocator = CFGetAllocator(ms);
uint8_t *utfname = NULL;
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
// if (__CFMessagePortIsRemote(ms)) return false;
//#warning CF: make this an assertion
// and assert than newName is non-NULL
name = __CFMessagePortSanitizeStringName(allocator, name, &utfname, NULL);
if (NULL == name) {
return false;
}
__CFSpinLock(&__CFAllMessagePortsLock);
if (NULL != name) {
CFMessagePortRef existing;
if (NULL != __CFAllLocalMessagePorts && CFDictionaryGetValueIfPresent(__CFAllLocalMessagePorts, name, (const void **)&existing)) {
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(name);
CFAllocatorDeallocate(allocator, utfname);
return false;
}
}
if (NULL != name && (NULL == ms->_name || !CFEqual(ms->_name, name))) {
if (!__CFMessagePortNativeSetNameLocal(ms->_port, utfname)) {
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(name);
CFAllocatorDeallocate(allocator, utfname);
return false;
}
if (NULL == __CFAllLocalMessagePorts) {
__CFAllLocalMessagePorts = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, NULL);
}
if (NULL != ms->_name) {
CFDictionaryRemoveValue(__CFAllLocalMessagePorts, ms->_name);
CFRelease(ms->_name);
}
ms->_name = name;
CFDictionaryAddValue(__CFAllLocalMessagePorts, name, ms);
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFAllocatorDeallocate(allocator, utfname);
return true;
}
void _CFApplicationPreferencesAddDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef domain, Boolean addAtTop) {
__CFSpinLock(&__CFApplicationPreferencesLock);
if (addAtTop) {
CFArrayInsertValueAtIndex(self->_search, 0, domain);
} else {
CFArrayAppendValue(self->_search, domain);
}
updateDictRep(self);
__CFSpinUnlock(&__CFApplicationPreferencesLock);
}
__private_extern__ void _CFPFactoryAddType(_CFPFactoryRef factory, CFUUIDRef typeID) {
/* Add the factory to the type's array of factories */
__CFSpinLock(&factory->_lock);
/* Add the type to the factory's type list */
CFArrayAppendValue(factory->_types, typeID);
__CFSpinUnlock(&factory->_lock);
__CFSpinLock(&CFPlugInGlobalDataLock);
if (!_factoriesByTypeID) _factoriesByTypeID = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFMutableArrayRef array = (CFMutableArrayRef)CFDictionaryGetValue(_factoriesByTypeID, typeID);
if (!array) {
CFArrayCallBacks _factoryArrayCallbacks = {0, NULL, NULL, NULL, NULL};
// Create this from default allocator
array = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &_factoryArrayCallbacks);
CFDictionarySetValue(_factoriesByTypeID, typeID, array);
CFRelease(array);
}
CFArrayAppendValue(array, factory);
__CFSpinUnlock(&CFPlugInGlobalDataLock);
}
static void _CFApplicationPreferencesSetSearchList(_CFApplicationPreferences *self, CFArrayRef newSearchList) {
CFIndex idx, count;
__CFSpinLock(&__CFApplicationPreferencesLock);
CFArrayRemoveAllValues(self->_search);
count = CFArrayGetCount(newSearchList);
for (idx = 0; idx < count; idx ++) {
CFArrayAppendValue(self->_search, CFArrayGetValueAtIndex(newSearchList, idx));
}
updateDictRep(self);
__CFSpinUnlock(&__CFApplicationPreferencesLock);
}
/* Returns a shared empty dictionary (unless the allocator is not kCFAllocatorSystemDefault, in which case returns a newly allocated one).
*/
static CFDictionaryRef _CFErrorCreateEmptyDictionary(CFAllocatorRef allocator) {
if (allocator == NULL) allocator = __CFGetDefaultAllocator();
if (_CFAllocatorIsSystemDefault(allocator)) {
static CFDictionaryRef emptyErrorDictionary = NULL;
if (emptyErrorDictionary == NULL) {
CFDictionaryRef tmp = CFDictionaryCreate(allocator, NULL, NULL, 0, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
__CFSpinLock(&_CFErrorSpinlock);
if (emptyErrorDictionary == NULL) {
emptyErrorDictionary = tmp;
__CFSpinUnlock(&_CFErrorSpinlock);
} else {
__CFSpinUnlock(&_CFErrorSpinlock);
CFRelease(tmp);
}
}
return (CFDictionaryRef)CFRetain(emptyErrorDictionary);
} else {
return CFDictionaryCreate(allocator, NULL, NULL, 0, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
}
__private_extern__ _CFPFactoryRef _CFPFactoryCreate(CFAllocatorRef allocator, CFUUIDRef factoryID, CFPlugInFactoryFunction func) {
_CFPFactoryRef factory = _CFPFactoryCommonCreate(allocator, factoryID);
__CFSpinLock(&factory->_lock);
factory->_func = func;
factory->_plugIn = NULL;
factory->_funcName = NULL;
__CFSpinUnlock(&factory->_lock);
return factory;
}
__private_extern__ void _CFPFactoryRemoveInstance(_CFPFactoryRef factory) {
__CFSpinLock(&factory->_lock);
CFPlugInRef plugin = factory->_plugIn;
if (plugin) CFRetain(plugin);
__CFSpinUnlock(&factory->_lock);
if (plugin) {
_CFPlugInRemovePlugInInstance(factory->_plugIn);
CFRelease(plugin);
}
CFRelease(factory);
}
__private_extern__ _CFPFactory *_CFPFactoryFind(CFUUIDRef factoryID, Boolean enabled) {
_CFPFactory *result = NULL;
__CFSpinLock(&CFPlugInGlobalDataLock);
if (_factoriesByFactoryID) {
result = (_CFPFactory *)CFDictionaryGetValue(_factoriesByFactoryID, factoryID);
if (result && result->_enabled != enabled) result = NULL;
}
__CFSpinUnlock(&CFPlugInGlobalDataLock);
return result;
}
