void
nsContentSupportMap::Init()
{
if (!PL_DHashTableInit(&mMap, PL_DHashGetStubOps(), nsnull,
sizeof(Entry), PL_DHASH_MIN_SIZE))
mMap.ops = nsnull;
}
nsresult
nsStaticModuleLoader::Init(nsStaticModuleInfo const *aStaticModules,
PRUint32 aModuleCount)
{
if (!PL_DHashTableInit(&mInfoHash, &sInfoHashOps, nsnull,
sizeof(StaticModuleInfo), 1024)) {
mInfoHash.ops = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
if (! aStaticModules)
return NS_OK;
StaticModuleInfo *prev = nsnull;
for (PRUint32 i = 0; i < aModuleCount; ++i) {
StaticModuleInfo *info =
static_cast<StaticModuleInfo *>
(PL_DHashTableOperate(&mInfoHash, aStaticModules[i].name,
PL_DHASH_ADD));
if (!info)
return NS_ERROR_OUT_OF_MEMORY;
info->info = aStaticModules[i];
if (prev)
prev->next = info;
else
mFirst = info;
prev = info;
}
return NS_OK;
}
nsDocLoader::nsDocLoader()
: mParent(nullptr),
mCurrentSelfProgress(0),
mMaxSelfProgress(0),
mCurrentTotalProgress(0),
mMaxTotalProgress(0),
mCompletedTotalProgress(0),
mIsLoadingDocument(false),
mIsRestoringDocument(false),
mDontFlushLayout(false),
mIsFlushingLayout(false)
{
#if defined(PR_LOGGING)
if (nullptr == gDocLoaderLog) {
gDocLoaderLog = PR_NewLogModule("DocLoader");
}
#endif /* PR_LOGGING */
static const PLDHashTableOps hash_table_ops =
{
PL_DHashVoidPtrKeyStub,
PL_DHashMatchEntryStub,
PL_DHashMoveEntryStub,
RequestInfoHashClearEntry,
RequestInfoHashInitEntry
};
PL_DHashTableInit(&mRequestInfoHash, &hash_table_ops, sizeof(nsRequestInfo));
ClearInternalProgress();
PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
("DocLoader:%p: created.\n", this));
}
nsresult
nsDiskCacheBindery::Init()
{
nsresult rv = NS_OK;
PL_DHashTableInit(&table, &ops, sizeof(HashTableEntry), 0);
initialized = true;
return rv;
}
nsresult
nsDiskCacheBindery::Init()
{
nsresult rv = NS_OK;
initialized = PL_DHashTableInit(&table, &ops, nsnull, sizeof(HashTableEntry), 0);
if (!initialized) rv = NS_ERROR_OUT_OF_MEMORY;
return rv;
}
nsPersistentProperties::nsPersistentProperties()
: mIn(nullptr)
{
mSubclass = static_cast<nsIPersistentProperties*>(this);
PL_DHashTableInit(&mTable, &property_HashTableOps, nullptr,
sizeof(PropertyTableEntry), 16);
PL_INIT_ARENA_POOL(&mArena, "PersistentPropertyArena", 2048);
}
nsresult
nsPersistentProperties::Init()
{
if (!PL_DHashTableInit(&mTable, &property_HashTableOps, nsnull,
sizeof(PropertyTableEntry), 20)) {
mTable.ops = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
nsresult nsCertTree::InitCompareHash()
{
ClearCompareHash();
if (!PL_DHashTableInit(&mCompareCache, &gMapOps, nsnull,
sizeof(CompareCacheHashEntryPtr), 128)) {
mCompareCache.ops = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
PRBool
nsStaticCaseInsensitiveNameTable::Init(const char* const aNames[], PRInt32 Count)
{
NS_ASSERTION(!mNameArray, "double Init");
NS_ASSERTION(!mNameTable.ops, "double Init");
NS_ASSERTION(aNames, "null name table");
NS_ASSERTION(Count, "0 count");
mNameArray = (nsDependentCString*)
nsMemory::Alloc(Count * sizeof(nsDependentCString));
if (!mNameArray)
return PR_FALSE;
if (!PL_DHashTableInit(&mNameTable,
&nametable_CaseInsensitiveHashTableOps,
nsnull, sizeof(NameTableEntry), Count)) {
mNameTable.ops = nsnull;
return PR_FALSE;
}
for (PRInt32 index = 0; index < Count; ++index) {
const char* raw = aNames[index];
#ifdef DEBUG
{
// verify invariants of contents
nsCAutoString temp1(raw);
nsDependentCString temp2(raw);
ToLowerCase(temp1);
NS_ASSERTION(temp1.Equals(temp2), "upper case char in table");
NS_ASSERTION(nsCRT::IsAscii(raw),
"non-ascii string in table -- "
"case-insensitive matching won't work right");
}
#endif
// use placement-new to initialize the string object
nsDependentCString* strPtr = &mNameArray[index];
new (strPtr) nsDependentCString(raw);
NameTableKey key(strPtr);
NameTableEntry *entry =
static_cast<NameTableEntry*>
(PL_DHashTableOperate(&mNameTable, &key,
PL_DHASH_ADD));
if (!entry) continue;
NS_ASSERTION(entry->mString == 0, "Entry already exists!");
entry->mString = strPtr; // not owned!
entry->mIndex = index;
}
return PR_TRUE;
}
nsresult
nsCacheEntryHashTable::Init()
{
nsresult rv = NS_OK;
initialized = PL_DHashTableInit(&table, &ops, nsnull,
sizeof(nsCacheEntryHashTableEntry), 512);
if (!initialized) rv = NS_ERROR_OUT_OF_MEMORY;
return rv;
}
nsHashtable::nsHashtable(nsIObjectInputStream* aStream,
nsHashtableReadEntryFunc aReadEntryFunc,
nsHashtableFreeEntryFunc aFreeEntryFunc,
nsresult *aRetVal)
: mLock(nsnull),
mEnumerating(PR_FALSE)
{
MOZ_COUNT_CTOR(nsHashtable);
PRBool threadSafe;
nsresult rv = aStream->ReadBoolean(&threadSafe);
if (NS_SUCCEEDED(rv)) {
if (threadSafe) {
mLock = PR_NewLock();
if (!mLock)
rv = NS_ERROR_OUT_OF_MEMORY;
}
if (NS_SUCCEEDED(rv)) {
PRUint32 count;
rv = aStream->Read32(&count);
if (NS_SUCCEEDED(rv)) {
PRBool status =
PL_DHashTableInit(&mHashtable, &hashtableOps,
nsnull, sizeof(HTEntry), count);
if (!status) {
mHashtable.ops = nsnull;
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
for (PRUint32 i = 0; i < count; i++) {
nsHashKey* key;
void *data;
rv = aReadEntryFunc(aStream, &key, &data);
if (NS_SUCCEEDED(rv)) {
if (!Put(key, data)) {
rv = NS_ERROR_OUT_OF_MEMORY;
aFreeEntryFunc(aStream, key, data);
} else {
// XXXbe must we clone key? can't we hand off
aFreeEntryFunc(aStream, key, nsnull);
}
if (NS_FAILED(rv))
break;
}
}
}
}
}
}
*aRetVal = rv;
}
nsPropertyTable::PropertyList::PropertyList(nsIAtom *aName,
NSPropertyDtorFunc aDtorFunc,
void *aDtorData,
bool aTransfer)
: mName(aName),
mDtorFunc(aDtorFunc),
mDtorData(aDtorData),
mTransfer(aTransfer),
mNext(nullptr)
{
PL_DHashTableInit(&mObjectValueMap, PL_DHashGetStubOps(), this,
sizeof(PropertyListMapEntry), 16);
}
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);
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,
nsGlobalNameStruct::eTypeExternalConstructor, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_PROPERTY_CATEGORY,
nsGlobalNameStruct::eTypeProperty, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_PRIVILEGED_PROPERTY_CATEGORY,
nsGlobalNameStruct::eTypeProperty, PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_STATIC_NAMESET_CATEGORY,
nsGlobalNameStruct::eTypeStaticNameSet, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
rv = FillHash(cm, JAVASCRIPT_GLOBAL_DYNAMIC_NAMESET_CATEGORY,
nsGlobalNameStruct::eTypeDynamicNameSet, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
nsresult PREF_Init()
{
if (!gHashTable.ops) {
if (!PL_DHashTableInit(&gHashTable, &pref_HashTableOps, nsnull,
sizeof(PrefHashEntry), 1024)) {
gHashTable.ops = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
PL_INIT_ARENA_POOL(&gPrefNameArena, "PrefNameArena",
PREFNAME_ARENA_SIZE);
}
return NS_OK;
}
bool
SpanningCellSorter::AddCell(PRInt32 aColSpan, PRInt32 aRow, PRInt32 aCol)
{
NS_ASSERTION(mState == ADDING, "cannot call AddCell after GetNext");
NS_ASSERTION(aColSpan >= ARRAY_BASE, "cannot add cells with colspan<2");
Item *i = (Item*) mozilla::AutoStackArena::Allocate(sizeof(Item));
NS_ENSURE_TRUE(i != nsnull, false);
i->row = aRow;
i->col = aCol;
if (UseArrayForSpan(aColSpan)) {
PRInt32 index = SpanToIndex(aColSpan);
i->next = mArray[index];
mArray[index] = i;
} else {
if (!mHashTable.entryCount &&
!PL_DHashTableInit(&mHashTable, &HashTableOps, nsnull,
sizeof(HashTableEntry), PL_DHASH_MIN_SIZE)) {
NS_NOTREACHED("table init failed");
mHashTable.entryCount = 0;
return false;
}
HashTableEntry *entry = static_cast<HashTableEntry*>
(PL_DHashTableOperate(&mHashTable, NS_INT32_TO_PTR(aColSpan),
PL_DHASH_ADD));
NS_ENSURE_TRUE(entry, false);
NS_ASSERTION(entry->mColSpan == 0 || entry->mColSpan == aColSpan,
"wrong entry");
NS_ASSERTION((entry->mColSpan == 0) == (entry->mItems == nsnull),
"entry should be either new or properly initialized");
entry->mColSpan = aColSpan;
i->next = entry->mItems;
entry->mItems = i;
}
return true;
}
// We put the atoms in a hash table for speedy lookup.. see ResolveAtom.
nsresult
nsHttp::CreateAtomTable()
{
NS_ASSERTION(!sAtomTable.ops, "atom table already initialized");
if (!sLock) {
sLock = PR_NewLock();
if (!sLock)
return NS_ERROR_OUT_OF_MEMORY;
}
// The capacity for this table is initialized to a value greater than the
// number of known atoms (NUM_HTTP_ATOMS) because we expect to encounter a
// few random headers right off the bat.
if (!PL_DHashTableInit(&sAtomTable, &ops, nsnull, sizeof(PLDHashEntryStub),
NUM_HTTP_ATOMS + 10)) {
sAtomTable.ops = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
// fill the table with our known atoms
const char *const atoms[] = {
#define HTTP_ATOM(_name, _value) nsHttp::_name._val,
#include "nsHttpAtomList.h"
#undef HTTP_ATOM
nsnull
};
for (int i = 0; atoms[i]; ++i) {
PLDHashEntryStub *stub = reinterpret_cast<PLDHashEntryStub *>
(PL_DHashTableOperate(&sAtomTable, atoms[i], PL_DHASH_ADD));
if (!stub)
return NS_ERROR_OUT_OF_MEMORY;
NS_ASSERTION(!stub->key, "duplicate static atom");
stub->key = atoms[i];
}
return NS_OK;
}
static void
Log(void* addr)
{
static int initialized = 0;
addr = (void*) ((unsigned) addr - 5);
if (!initialized) {
initialized = PL_DHashTableInit(&Calls, &Ops, 0, sizeof(CallEntry), 16);
if (!initialized)
return;
}
entry = (CallEntry*) PL_DHashTableOperate(&Calls, addr, PL_DHASH_ADD);
if (!entry)
return; // OOM
if (!entry->addr)
entry->addr = addr;
//
// Another call recorded.
//
++entry->count;
//
// Only record a hit if the appropriate amount of time has passed.
//
DWORD curtick = GetTickCount();
if(curtick >= (entry->tick + HIT_INTERVAL))
{
//
// Record the interval hit.
// Update the tick.
//
entry->hits++;
entry->tick = curtick;
}
}
// We put the atoms in a hash table for speedy lookup.. see ResolveAtom.
nsresult
nsHttp::CreateAtomTable()
{
MOZ_ASSERT(!sAtomTable.ops, "atom table already initialized");
if (!sLock) {
sLock = new Mutex("nsHttp.sLock");
}
// The initial length for this table is a value greater than the number of
// known atoms (NUM_HTTP_ATOMS) because we expect to encounter a few random
// headers right off the bat.
if (!PL_DHashTableInit(&sAtomTable, &ops, nullptr,
sizeof(PLDHashEntryStub),
fallible_t(), NUM_HTTP_ATOMS + 10)) {
sAtomTable.ops = nullptr;
return NS_ERROR_OUT_OF_MEMORY;
}
// fill the table with our known atoms
const char *const atoms[] = {
#define HTTP_ATOM(_name, _value) nsHttp::_name._val,
#include "nsHttpAtomList.h"
#undef HTTP_ATOM
nullptr
};
for (int i = 0; atoms[i]; ++i) {
PLDHashEntryStub *stub = reinterpret_cast<PLDHashEntryStub *>
(PL_DHashTableOperate(&sAtomTable, atoms[i], PL_DHASH_ADD));
if (!stub)
return NS_ERROR_OUT_OF_MEMORY;
MOZ_ASSERT(!stub->key, "duplicate static atom");
stub->key = atoms[i];
}
return NS_OK;
}
nsresult nsLoadGroup::Init()
{
static PLDHashTableOps hash_table_ops =
{
PL_DHashAllocTable,
PL_DHashFreeTable,
PL_DHashVoidPtrKeyStub,
RequestHashMatchEntry,
PL_DHashMoveEntryStub,
RequestHashClearEntry,
PL_DHashFinalizeStub,
RequestHashInitEntry
};
if (!PL_DHashTableInit(&mRequests, &hash_table_ops, nsnull,
sizeof(RequestMapEntry), 16)) {
mRequests.ops = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
nsHashtable::nsHashtable(PRUint32 aInitSize, PRBool threadSafe)
: mLock(NULL), mEnumerating(PR_FALSE)
{
MOZ_COUNT_CTOR(nsHashtable);
PRBool result = PL_DHashTableInit(&mHashtable, &hashtableOps, nsnull,
sizeof(HTEntry), aInitSize);
NS_ASSERTION(result, "Hashtable failed to initialize");
// make sure we detect this later
if (!result)
mHashtable.ops = nsnull;
if (threadSafe) {
mLock = PR_NewLock();
if (mLock == NULL) {
// Cannot create a lock. If running on a multiprocessing system
// we are sure to die.
PR_ASSERT(mLock != NULL);
}
}
}
nsDocLoader::nsDocLoader()
: mListenerInfoList(8)
{
#if defined(PR_LOGGING)
if (nsnull == gDocLoaderLog) {
gDocLoaderLog = PR_NewLogModule("DocLoader");
}
#endif /* PR_LOGGING */
mParent = nsnull;
mIsLoadingDocument = PR_FALSE;
mIsRestoringDocument = PR_FALSE;
static PLDHashTableOps hash_table_ops =
{
PL_DHashAllocTable,
PL_DHashFreeTable,
PL_DHashGetKeyStub,
PL_DHashVoidPtrKeyStub,
PL_DHashMatchEntryStub,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub,
RequestInfoHashInitEntry
};
if (!PL_DHashTableInit(&mRequestInfoHash, &hash_table_ops, nsnull,
sizeof(nsRequestInfo), 16)) {
mRequestInfoHash.ops = nsnull;
}
ClearInternalProgress();
PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
("DocLoader:%p: created.\n", this));
}
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;
}
static PLDHashOperator PR_CALLBACK
ListCounts(PLDHashTable* table, PLDHashEntryHdr* hdr,
PRUint32 number, void* arg)
{
BOOL ok;
CallEntry* entry = (CallEntry*) hdr;
IMAGEHLP_MODULE module;
module.SizeOfStruct = sizeof(module);
ok = ::SymGetModuleInfo(::GetCurrentProcess(),
(unsigned) entry->addr,
&module);
char buf[sizeof(IMAGEHLP_SYMBOL) + 512];
PIMAGEHLP_SYMBOL symbol = (PIMAGEHLP_SYMBOL) buf;
symbol->SizeOfStruct = sizeof(buf);
symbol->MaxNameLength = 512;
DWORD displacement;
ok = ::SymGetSymFromAddr(::GetCurrentProcess(),
(unsigned) entry->addr,
&displacement,
symbol);
if (ok)
{
if (displacement > 0)
return PL_DHASH_NEXT;
static int modInitialized = 0;
if (!modInitialized) {
modInitialized = PL_DHashTableInit(&Modules, &ModOps, 0, sizeof(ModulesEntry), 16);
if (!modInitialized)
return PL_DHASH_NEXT;
}
ModulesEntry* mod
= (ModulesEntry*) PL_DHashTableOperate(&Modules,
module.ModuleName,
PL_DHASH_ADD);
if (!mod)
return PL_DHASH_STOP; // OOM
if (!mod->moduleName) {
mod->moduleName = strdup(module.ModuleName);
mod->byCount = new Node();
mod->byCount->function = strdup(symbol->Name);
mod->byCount->count = entry->count;
mod->byCount->hits = entry->hits;
} else {
// insertion sort.
Node* cur = mod->byCount;
Node* foo = new Node();
foo->function = strdup(symbol->Name);
foo->count = entry->count;
foo->hits = entry->hits;
if
#if defined(SORT_BY_CALL_COUNT)
(cur->count < entry->count)
#else
((cur->hits < entry->hits) || (cur->hits == entry->hits && cur->count < entry->count))
#endif
{
if (!strcmp(cur->function,symbol->Name))
return PL_DHASH_NEXT;
foo->next = mod->byCount;
mod->byCount = foo;
} else {
while (cur->next) {
if (!strcmp(cur->function,symbol->Name))
return PL_DHASH_NEXT;
if
#if defined(SORT_BY_CALL_COUNT)
(cur->next->count > entry->count)
#else
((cur->next->hits > entry->hits) || (cur->next->hits == entry->hits && cur->next->count > entry->count))
#endif
{ cur = cur->next; }
else { break; }
}
foo->next = cur->next;
cur->next = foo;
}
}
} // if (ok)
already_AddRefed<nsContentList>
NS_GetContentList(nsINode* aRootNode, nsIAtom* aMatchAtom,
PRInt32 aMatchNameSpaceId)
{
NS_ASSERTION(aRootNode, "content list has to have a root");
nsContentList* list = nsnull;
static PLDHashTableOps hash_table_ops =
{
PL_DHashAllocTable,
PL_DHashFreeTable,
ContentListHashtableHashKey,
ContentListHashtableMatchEntry,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// Initialize the hashtable if needed.
if (!gContentListHashTable.ops) {
PRBool success = PL_DHashTableInit(&gContentListHashTable,
&hash_table_ops, nsnull,
sizeof(ContentListHashEntry),
16);
if (!success) {
gContentListHashTable.ops = nsnull;
}
}
ContentListHashEntry *entry = nsnull;
// First we look in our hashtable. Then we create a content list if needed
if (gContentListHashTable.ops) {
nsContentListKey hashKey(aRootNode, aMatchAtom,
aMatchNameSpaceId);
// A PL_DHASH_ADD is equivalent to a PL_DHASH_LOOKUP for cases
// when the entry is already in the hashtable.
entry = static_cast<ContentListHashEntry *>
(PL_DHashTableOperate(&gContentListHashTable,
&hashKey,
PL_DHASH_ADD));
if (entry)
list = entry->mContentList;
}
if (!list) {
// We need to create a ContentList and add it to our new entry, if
// we have an entry
list = new nsContentList(aRootNode, aMatchAtom,
aMatchNameSpaceId);
if (entry) {
if (list)
entry->mContentList = list;
else
PL_DHashTableRawRemove(&gContentListHashTable, entry);
}
NS_ENSURE_TRUE(list, nsnull);
}
NS_ADDREF(list);
// Hold on to the last requested content list to avoid having it be
// removed from the cache immediately when it's released. Avoid
// bumping the refcount on the list if the requested list is the one
// that's already cached.
if (gCachedContentList != list) {
NS_IF_RELEASE(gCachedContentList);
gCachedContentList = list;
NS_ADDREF(gCachedContentList);
}
return list;
}
