nsScriptNameSpaceManager::~nsScriptNameSpaceManager()
{
if (mIsInitialized) {
// Destroy the hash
PL_DHashTableFinish(&mGlobalNames);
PL_DHashTableFinish(&mNavigatorNames);
}
MOZ_COUNT_DTOR(nsScriptNameSpaceManager);
}
void nsCertTree::ClearCompareHash()
{
if (mCompareCache.ops) {
PL_DHashTableFinish(&mCompareCache);
mCompareCache.ops = nsnull;
}
}
nsPersistentProperties::~nsPersistentProperties()
{
PL_FinishArenaPool(&mArena);
if (mTable.ops) {
PL_DHashTableFinish(&mTable);
}
}
void
nsCacheEntryHashTable::Shutdown()
{
if (initialized) {
PL_DHashTableFinish(&table);
initialized = PR_FALSE;
}
}
void
nsDiskCacheBindery::Reset()
{
if (initialized) {
PL_DHashTableFinish(&table);
initialized = false;
}
}
SpanningCellSorter::~SpanningCellSorter()
{
if (mHashTable.entryCount) {
PL_DHashTableFinish(&mHashTable);
mHashTable.entryCount = 0;
}
delete [] mSortedHashTable;
}
/* Frees up all the objects except the callback list. */
void PREF_CleanupPrefs()
{
if (gHashTable.ops) {
PL_DHashTableFinish(&gHashTable);
gHashTable.ops = nsnull;
PL_FinishArenaPool(&gPrefNameArena);
}
}
SpanningCellSorter::~SpanningCellSorter()
{
if (mHashTable.entryCount) {
PL_DHashTableFinish(&mHashTable);
mHashTable.entryCount = 0;
}
delete [] mSortedHashTable;
mPresShell->PopStackMemory();
}
nsStaticCaseInsensitiveNameTable::~nsStaticCaseInsensitiveNameTable()
{
if (mNameArray) {
// manually call the destructor on placement-new'ed objects
for (PRUint32 index = 0; index < mNameTable.entryCount; index++) {
mNameArray[index].~nsDependentCString();
}
nsMemory::Free((void*)mNameArray);
}
if (mNameTable.ops)
PL_DHashTableFinish(&mNameTable);
MOZ_COUNT_DTOR(nsStaticCaseInsensitiveNameTable);
}
nsLoadGroup::~nsLoadGroup()
{
nsresult rv;
rv = Cancel(NS_BINDING_ABORTED);
NS_ASSERTION(NS_SUCCEEDED(rv), "Cancel failed");
if (mRequests.ops) {
PL_DHashTableFinish(&mRequests);
}
mDefaultLoadRequest = 0;
LOG(("LOADGROUP [%x]: Destroyed.\n", this));
}
void
nsHttp::DestroyAtomTable()
{
if (sAtomTable.ops) {
PL_DHashTableFinish(&sAtomTable);
sAtomTable.ops = nsnull;
}
while (sHeapAtoms) {
HttpHeapAtom *next = sHeapAtoms->next;
free(sHeapAtoms);
sHeapAtoms = next;
}
if (sLock) {
PR_DestroyLock(sLock);
sLock = nsnull;
}
}
void
nsContentList::RemoveFromHashtable()
{
if (mFunc) {
// This can't be in the table anyway
return;
}
if (!gContentListHashTable.ops)
return;
PL_DHashTableOperate(&gContentListHashTable,
GetKey(),
PL_DHASH_REMOVE);
if (gContentListHashTable.entryCount == 0) {
PL_DHashTableFinish(&gContentListHashTable);
gContentListHashTable.ops = nsnull;
}
}
nsDocLoader::~nsDocLoader()
{
/*
|ClearWeakReferences()| here is intended to prevent people holding weak references
from re-entering this destructor since |QueryReferent()| will |AddRef()| me, and the
subsequent |Release()| will try to destroy me. At this point there should be only
weak references remaining (otherwise, we wouldn't be getting destroyed).
An alternative would be incrementing our refcount (consider it a compressed flag
saying "Don't re-destroy."). I haven't yet decided which is better. [scc]
*/
// XXXbz now that NS_IMPL_RELEASE stabilizes by setting refcount to 1, is
// this needed?
ClearWeakReferences();
Destroy();
PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
("DocLoader:%p: deleted.\n", this));
if (mRequestInfoHash.IsInitialized()) {
PL_DHashTableFinish(&mRequestInfoHash);
}
}
~nsStaticComponentLoader() {
if (mInfoHash.ops)
PL_DHashTableFinish(&mInfoHash);
}
nsresult
nsScriptNameSpaceManager::Init()
{
static PLDHashTableOps hash_table_ops =
{
PL_DHashAllocTable,
PL_DHashFreeTable,
GlobalNameHashHashKey,
GlobalNameHashMatchEntry,
PL_DHashMoveEntryStub,
GlobalNameHashClearEntry,
PL_DHashFinalizeStub,
GlobalNameHashInitEntry
};
mIsInitialized = PL_DHashTableInit(&mGlobalNames, &hash_table_ops, nsnull,
sizeof(GlobalNameMapEntry),
GLOBALNAME_HASHTABLE_INITIAL_SIZE);
NS_ENSURE_TRUE(mIsInitialized, NS_ERROR_OUT_OF_MEMORY);
mIsInitialized = PL_DHashTableInit(&mNavigatorNames, &hash_table_ops, nsnull,
sizeof(GlobalNameMapEntry),
GLOBALNAME_HASHTABLE_INITIAL_SIZE);
if (!mIsInitialized) {
PL_DHashTableFinish(&mGlobalNames);
return NS_ERROR_OUT_OF_MEMORY;
}
nsresult rv = NS_OK;
rv = FillHashWithDOMInterfaces();
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsICategoryManager> cm =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_CONSTRUCTOR_CATEGORY);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_PROPERTY_CATEGORY);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_PRIVILEGED_PROPERTY_CATEGORY);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_STATIC_NAMESET_CATEGORY);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_DYNAMIC_NAMESET_CATEGORY);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_NAVIGATOR_PROPERTY_CATEGORY);
NS_ENSURE_SUCCESS(rv, rv);
// Initial filling of the has table has been done.
// Now, listen for changes.
nsCOMPtr<nsIObserverService> serv =
do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
if (serv) {
serv->AddObserver(this, NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID, true);
}
return NS_OK;
}
nsHashtable::~nsHashtable() {
MOZ_COUNT_DTOR(nsHashtable);
if (mHashtable.ops)
PL_DHashTableFinish(&mHashtable);
if (mLock) PR_DestroyLock(mLock);
}
void
nsContentSupportMap::Finish()
{
if (mMap.ops)
PL_DHashTableFinish(&mMap);
}
nsPropertyTable::PropertyList::~PropertyList()
{
PL_DHashTableFinish(&mObjectValueMap);
}