wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 1050035 (part 4) - Make PL_DHashTableAdd() infallible by default, and add a fallible alternative. r=froydnj.

Browse Source 
I kept all the existing PL_DHashTableAdd() calls fallible, in order to be
conservative, except for the ones in nsAtomTable.cpp which already were
followed immediately by an abort on failure.
This commit is contained in:
Nicholas Nethercote 2015-02-02 14:48:58 -08:00
parent 3aa6fd7b3d
commit a40419dc43
39 changed files with 146 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
dom/base/nsContentList.cpp
View File

@ -224,7 +224,7 @@ NS_GetContentList(nsINode* aRootNode,
// First we look in our hashtable. Then we create a content list if needed
if (gContentListHashTable.IsInitialized()) {
entry = static_cast<ContentListHashEntry *>
(PL_DHashTableAdd(&gContentListHashTable, &hashKey));
(PL_DHashTableAdd(&gContentListHashTable, &hashKey, fallible));
if (entry)
list = entry->mContentList;
}
@ -332,8 +332,7 @@ GetFuncStringContentList(nsINode* aRootNode,
nsFuncStringCacheKey hashKey(aRootNode, aFunc, aString);
entry = static_cast<FuncStringContentListHashEntry *>
(PL_DHashTableAdd(&gFuncStringContentListHashTable,
&hashKey));
(PL_DHashTableAdd(&gFuncStringContentListHashTable, &hashKey, fallible));
if (entry) {
list = entry->mContentList;
#ifdef DEBUG

2
dom/base/nsContentUtils.cpp
View File

@ -3960,7 +3960,7 @@ nsContentUtils::GetListenerManagerForNode(nsINode *aNode)
EventListenerManagerMapEntry *entry =
static_cast<EventListenerManagerMapEntry *>
(PL_DHashTableAdd(&sEventListenerManagersHash, aNode));
(PL_DHashTableAdd(&sEventListenerManagersHash, aNode, fallible));
if (!entry) {
return nullptr;

5
dom/base/nsDocument.cpp
View File

@ -3990,9 +3990,8 @@ nsDocument::SetSubDocumentFor(Element* aElement, nsIDocument* aSubDoc)
}
// Add a mapping to the hash table
SubDocMapEntry *entry =
static_cast<SubDocMapEntry*>
(PL_DHashTableAdd(mSubDocuments, aElement));
SubDocMapEntry *entry = static_cast<SubDocMapEntry*>
(PL_DHashTableAdd(mSubDocuments, aElement, fallible));
if (!entry) {
return NS_ERROR_OUT_OF_MEMORY;

2
dom/base/nsPropertyTable.cpp
View File

@ -230,7 +230,7 @@ nsPropertyTable::SetPropertyInternal(nsPropertyOwner aObject,
// value is destroyed
nsresult result = NS_OK;
PropertyListMapEntry *entry = static_cast<PropertyListMapEntry*>
(PL_DHashTableAdd(&propertyList->mObjectValueMap, aObject));
(PL_DHashTableAdd(&propertyList->mObjectValueMap, aObject, fallible));
if (!entry)
return NS_ERROR_OUT_OF_MEMORY;
// A nullptr entry->key is the sign that the entry has just been allocated

5
dom/base/nsScriptNameSpaceManager.cpp
View File

@ -139,9 +139,8 @@ nsGlobalNameStruct *
nsScriptNameSpaceManager::AddToHash(PLDHashTable *aTable, const nsAString *aKey,
const char16_t **aClassName)
{
GlobalNameMapEntry *entry =
static_cast<GlobalNameMapEntry *>
(PL_DHashTableAdd(aTable, aKey));
GlobalNameMapEntry *entry = static_cast<GlobalNameMapEntry *>
(PL_DHashTableAdd(aTable, aKey, fallible));
if (!entry) {
return nullptr;

4
dom/plugins/base/nsJSNPRuntime.cpp
View File

@ -1872,7 +1872,7 @@ nsNPObjWrapper::GetNewOrUsed(NPP npp, JSContext *cx, NPObject *npobj)
}
NPObjWrapperHashEntry *entry = static_cast<NPObjWrapperHashEntry *>
(PL_DHashTableAdd(&sNPObjWrappers, npobj));
(PL_DHashTableAdd(&sNPObjWrappers, npobj, fallible));
if (!entry) {
// Out of memory
@ -2035,7 +2035,7 @@ LookupNPP(NPObject *npobj)
}
NPObjWrapperHashEntry *entry = static_cast<NPObjWrapperHashEntry *>
(PL_DHashTableAdd(&sNPObjWrappers, npobj));
(PL_DHashTableAdd(&sNPObjWrappers, npobj, fallible));
if (!entry) {
return nullptr;

5
dom/xul/XULDocument.cpp
View File

@ -778,9 +778,8 @@ XULDocument::AddBroadcastListenerFor(Element& aBroadcaster, Element& aListener,
(PL_DHashTableSearch(mBroadcasterMap, &aBroadcaster));
if (!entry) {
entry =
static_cast<BroadcasterMapEntry*>
(PL_DHashTableAdd(mBroadcasterMap, &aBroadcaster));
entry = static_cast<BroadcasterMapEntry*>
(PL_DHashTableAdd(mBroadcasterMap, &aBroadcaster, fallible));
if (! entry) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);

3
dom/xul/templates/nsContentSupportMap.h
View File

@ -28,7 +28,8 @@ public:
if (!mMap.IsInitialized())
return NS_ERROR_NOT_INITIALIZED;
PLDHashEntryHdr* hdr = PL_DHashTableAdd(&mMap, aElement);
PLDHashEntryHdr* hdr =
PL_DHashTableAdd(&mMap, aElement, mozilla::fallible);
if (!hdr)
return NS_ERROR_OUT_OF_MEMORY;

3
dom/xul/templates/nsTemplateMap.h
View File

@ -37,7 +37,8 @@ public:
NS_ASSERTION(!PL_DHashTableSearch(&mTable, aContent),
"aContent already in map");
Entry* entry = static_cast<Entry*>(PL_DHashTableAdd(&mTable, aContent));
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(&mTable, aContent, fallible));
if (entry) {
entry->mContent = aContent;

3
embedding/components/commandhandler/nsCommandParams.cpp
View File

@ -230,7 +230,8 @@ nsCommandParams::GetOrMakeEntry(const char* aName, uint8_t entryType)
return foundEntry;
}
foundEntry = (HashEntry *)PL_DHashTableAdd(&mValuesHash, (void *)aName);
foundEntry = static_cast<HashEntry*>
(PL_DHashTableAdd(&mValuesHash, (void *)aName, fallible));
if (!foundEntry) {
return nullptr;
}

10
gfx/thebes/gfxFT2FontList.cpp
View File

@ -687,9 +687,8 @@ public:
}
uint32_t filesize = strtoul(beginning, nullptr, 10);
FNCMapEntry* mapEntry =
static_cast<FNCMapEntry*>
(PL_DHashTableAdd(&mMap, filename.get()));
FNCMapEntry* mapEntry = static_cast<FNCMapEntry*>
(PL_DHashTableAdd(&mMap, filename.get(), fallible));
if (mapEntry) {
mapEntry->mFilename.Assign(filename);
mapEntry->mTimestamp = timestamp;
@ -736,9 +735,8 @@ public:
if (!mMap.IsInitialized()) {
return;
}
FNCMapEntry* entry =
static_cast<FNCMapEntry*>
(PL_DHashTableAdd(&mMap, aFileName.get()));
FNCMapEntry* entry = static_cast<FNCMapEntry*>
(PL_DHashTableAdd(&mMap, aFileName.get(), fallible));
if (entry) {
entry->mFilename.Assign(aFileName);
entry->mTimestamp = aTimestamp;

3
js/xpconnect/src/XPCMaps.cpp
View File

@ -593,7 +593,8 @@ XPCNativeScriptableSharedMap::GetNewOrUsed(uint32_t flags,
NS_PRECONDITION(si,"bad param");
XPCNativeScriptableShared key(flags, name);
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, &key);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, &key, fallible));
if (!entry)
return false;

26
js/xpconnect/src/XPCMaps.h
View File

@ -120,7 +120,8 @@ public:
NS_PRECONDITION(wrapper,"bad param");
nsISupports* obj = wrapper->GetIdentityObject();
MOZ_ASSERT(!Find(obj), "wrapper already in new scope!");
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, obj);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, obj, mozilla::fallible));
if (!entry)
return nullptr;
if (entry->key)
@ -185,7 +186,8 @@ public:
{
NS_PRECONDITION(clazz,"bad param");
const nsIID* iid = &clazz->GetIID();
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, iid);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, iid, mozilla::fallible));
if (!entry)
return nullptr;
if (entry->key)
@ -238,7 +240,8 @@ public:
{
NS_PRECONDITION(iface,"bad param");
const nsIID* iid = iface->GetIID();
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, iid);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, iid, mozilla::fallible));
if (!entry)
return nullptr;
if (entry->key)
@ -293,7 +296,8 @@ public:
inline XPCNativeSet* Add(nsIClassInfo* info, XPCNativeSet* set)
{
NS_PRECONDITION(info,"bad param");
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, info);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, info, mozilla::fallible));
if (!entry)
return nullptr;
if (entry->key)
@ -349,7 +353,8 @@ public:
inline XPCWrappedNativeProto* Add(nsIClassInfo* info, XPCWrappedNativeProto* proto)
{
NS_PRECONDITION(info,"bad param");
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, info);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, info, mozilla::fallible));
if (!entry)
return nullptr;
if (entry->key)
@ -411,7 +416,8 @@ public:
{
NS_PRECONDITION(key,"bad param");
NS_PRECONDITION(set,"bad param");
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, key);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, key, mozilla::fallible));
if (!entry)
return nullptr;
if (entry->key_value)
@ -483,8 +489,8 @@ public:
inline nsIXPCFunctionThisTranslator* Add(REFNSIID iid,
nsIXPCFunctionThisTranslator* obj)
{
Entry* entry = (Entry*) PL_DHashTableAdd(mTable, &iid);
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(mTable, &iid, mozilla::fallible));
if (!entry)
return nullptr;
entry->value = obj;
@ -555,8 +561,8 @@ public:
inline XPCWrappedNativeProto* Add(XPCWrappedNativeProto* proto)
{
NS_PRECONDITION(proto,"bad param");
PLDHashEntryStub* entry = (PLDHashEntryStub*)
PL_DHashTableAdd(mTable, proto);
PLDHashEntryStub* entry = static_cast<PLDHashEntryStub*>
(PL_DHashTableAdd(mTable, proto, mozilla::fallible));
if (!entry)
return nullptr;
if (entry->key)

5
layout/base/nsFrameManager.cpp
View File

@ -175,8 +175,9 @@ nsFrameManager::RegisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame)
PL_DHashTableInit(&mPlaceholderMap, &PlaceholderMapOps,
sizeof(PlaceholderMapEntry));
}
PlaceholderMapEntry *entry = static_cast<PlaceholderMapEntry*>(PL_DHashTableAdd(&mPlaceholderMap,
aPlaceholderFrame->GetOutOfFlowFrame()));
PlaceholderMapEntry *entry = static_cast<PlaceholderMapEntry*>
(PL_DHashTableAdd(&mPlaceholderMap,
aPlaceholderFrame->GetOutOfFlowFrame(), fallible));
if (!entry)
return NS_ERROR_OUT_OF_MEMORY;

20
layout/style/nsCSSRuleProcessor.cpp
View File

@ -573,7 +573,7 @@ void RuleHash::AppendRuleToTable(PLDHashTable* aTable, const void* aKey,
{
// Get a new or existing entry.
RuleHashTableEntry *entry = static_cast<RuleHashTableEntry*>
(PL_DHashTableAdd(aTable, aKey));
(PL_DHashTableAdd(aTable, aKey, fallible));
if (!entry)
return;
entry->mRules.AppendElement(RuleValue(aRuleInfo, mRuleCount++, mQuirksMode));
@ -585,7 +585,7 @@ AppendRuleToTagTable(PLDHashTable* aTable, nsIAtom* aKey,
{
// Get a new or exisiting entry
RuleHashTagTableEntry *entry = static_cast<RuleHashTagTableEntry*>
(PL_DHashTableAdd(aTable, aKey));
(PL_DHashTableAdd(aTable, aKey, fallible));
if (!entry)
return;
@ -1041,7 +1041,7 @@ RuleCascadeData::AttributeListFor(nsIAtom* aAttribute)
{
AtomSelectorEntry *entry =
static_cast<AtomSelectorEntry*>
(PL_DHashTableAdd(&mAttributeSelectors, aAttribute));
(PL_DHashTableAdd(&mAttributeSelectors, aAttribute, fallible));
if (!entry)
return nullptr;
return &entry->mSelectors;
@ -3134,9 +3134,8 @@ AddSelector(RuleCascadeData* aCascade,
if (negation == aSelectorInTopLevel) {
for (nsAtomList* curID = negation->mIDList; curID;
curID = curID->mNext) {
AtomSelectorEntry *entry =
static_cast<AtomSelectorEntry*>(PL_DHashTableAdd(&aCascade->mIdSelectors,
curID->mAtom));
AtomSelectorEntry *entry = static_cast<AtomSelectorEntry*>
(PL_DHashTableAdd(&aCascade->mIdSelectors, curID->mAtom, fallible));
if (entry) {
entry->mSelectors.AppendElement(aSelectorInTopLevel);
}
@ -3149,9 +3148,9 @@ AddSelector(RuleCascadeData* aCascade,
if (negation == aSelectorInTopLevel) {
for (nsAtomList* curClass = negation->mClassList; curClass;
curClass = curClass->mNext) {
AtomSelectorEntry *entry =
static_cast<AtomSelectorEntry*>(PL_DHashTableAdd(&aCascade->mClassSelectors,
curClass->mAtom));
AtomSelectorEntry *entry = static_cast<AtomSelectorEntry*>
(PL_DHashTableAdd(&aCascade->mClassSelectors, curClass->mAtom,
fallible));
if (entry) {
entry->mSelectors.AppendElement(aSelectorInTopLevel);
}
@ -3410,7 +3409,8 @@ CascadeRuleEnumFunc(css::Rule* aRule, void* aData)
sel; sel = sel->mNext) {
int32_t weight = sel->mWeight;
RuleByWeightEntry *entry = static_cast<RuleByWeightEntry*>(
PL_DHashTableAdd(&data->mRulesByWeight, NS_INT32_TO_PTR(weight)));
PL_DHashTableAdd(&data->mRulesByWeight, NS_INT32_TO_PTR(weight),
fallible));
if (!entry)
return false;
entry->data.mWeight = weight;

7
layout/style/nsHTMLStyleSheet.cpp
View File

@ -483,8 +483,9 @@ nsHTMLStyleSheet::UniqueMappedAttributes(nsMappedAttributes* aMapped)
PL_DHashTableInit(&mMappedAttrTable, &MappedAttrTable_Ops,
sizeof(MappedAttrTableEntry));
}
MappedAttrTableEntry *entry = static_cast<MappedAttrTableEntry*>
(PL_DHashTableAdd(&mMappedAttrTable, aMapped));
MappedAttrTableEntry *entry =
static_cast<MappedAttrTableEntry*>
(PL_DHashTableAdd(&mMappedAttrTable, aMapped, fallible));
if (!entry)
return nullptr;
if (!entry->mAttributes) {
@ -518,7 +519,7 @@ nsHTMLStyleSheet::LangRuleFor(const nsString& aLanguage)
sizeof(LangRuleTableEntry));
}
LangRuleTableEntry *entry = static_cast<LangRuleTableEntry*>
(PL_DHashTableAdd(&mLangRuleTable, &aLanguage));
(PL_DHashTableAdd(&mLangRuleTable, &aLanguage, fallible));
if (!entry) {
NS_ASSERTION(false, "out of memory");
return nullptr;

4
layout/style/nsRuleNode.cpp
View File

@ -1535,7 +1535,7 @@ nsRuleNode::Transition(nsIStyleRule* aRule, uint8_t aLevel,
if (ChildrenAreHashed()) {
ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>
(PL_DHashTableAdd(ChildrenHash(), &key));
(PL_DHashTableAdd(ChildrenHash(), &key, fallible));
if (!entry) {
NS_WARNING("out of memory");
return this;
@ -1611,7 +1611,7 @@ nsRuleNode::ConvertChildrenToHash(int32_t aNumKids)
for (nsRuleNode* curr = ChildrenList(); curr; curr = curr->mNextSibling) {
// This will never fail because of the initial size we gave the table.
ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>(
PL_DHashTableAdd(hash, curr->mRule));
PL_DHashTableAdd(hash, curr->mRule, fallible));
NS_ASSERTION(!entry->mRuleNode, "duplicate entries in list");
entry->mRuleNode = curr;
}

3
layout/tables/SpanningCellSorter.cpp
View File

@ -75,7 +75,8 @@ SpanningCellSorter::AddCell(int32_t aColSpan, int32_t aRow, int32_t aCol)
sizeof(HashTableEntry));
}
HashTableEntry *entry = static_cast<HashTableEntry*>
(PL_DHashTableAdd(&mHashTable, NS_INT32_TO_PTR(aColSpan)));
(PL_DHashTableAdd(&mHashTable, NS_INT32_TO_PTR(aColSpan),
fallible));
NS_ENSURE_TRUE(entry, false);
NS_ASSERTION(entry->mColSpan == 0 || entry->mColSpan == aColSpan,

3
modules/libpref/prefapi.cpp
View File

@ -735,7 +735,8 @@ nsresult pref_HashPref(const char *key, PrefValue value, PrefType type, uint32_t
if (!gHashTable.IsInitialized())
return NS_ERROR_OUT_OF_MEMORY;
PrefHashEntry* pref = static_cast<PrefHashEntry*>(PL_DHashTableAdd(&gHashTable, key));
PrefHashEntry* pref = static_cast<PrefHashEntry*>
(PL_DHashTableAdd(&gHashTable, key, fallible));
if (!pref)
return NS_ERROR_OUT_OF_MEMORY;

5
netwerk/base/nsLoadGroup.cpp
View File

@ -511,9 +511,8 @@ nsLoadGroup::AddRequest(nsIRequest *request, nsISupports* ctxt)
// Add the request to the list of active requests...
//
RequestMapEntry *entry =
static_cast<RequestMapEntry *>
(PL_DHashTableAdd(&mRequests, request));
RequestMapEntry *entry = static_cast<RequestMapEntry *>
(PL_DHashTableAdd(&mRequests, request, fallible));
if (!entry) {
return NS_ERROR_OUT_OF_MEMORY;

2
netwerk/cache/nsCacheEntry.cpp vendored
View File

@ -435,7 +435,7 @@ nsCacheEntryHashTable::AddEntry( nsCacheEntry *cacheEntry)
if (!table.IsInitialized()) return NS_ERROR_NOT_INITIALIZED;
if (!cacheEntry) return NS_ERROR_NULL_POINTER;
hashEntry = PL_DHashTableAdd(&table, &(cacheEntry->mKey));
hashEntry = PL_DHashTableAdd(&table, &(cacheEntry->mKey), fallible);
#ifndef DEBUG_dougt
NS_ASSERTION(((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry == 0,
"### nsCacheEntryHashTable::AddEntry - entry already used");

3
netwerk/cache/nsDiskCacheBinding.cpp vendored
View File

@ -236,7 +236,8 @@ nsDiskCacheBindery::AddBinding(nsDiskCacheBinding * binding)
HashTableEntry * hashEntry;
hashEntry = (HashTableEntry *)
PL_DHashTableAdd(&table,
(void *)(uintptr_t) binding->mRecord.HashNumber());
(void *)(uintptr_t) binding->mRecord.HashNumber(),
fallible);
if (!hashEntry) return NS_ERROR_OUT_OF_MEMORY;
if (hashEntry->mBinding == nullptr) {

2
netwerk/dns/nsHostResolver.cpp
View File

@ -764,7 +764,7 @@ nsHostResolver::ResolveHost(const char *host,
nsHostKey key = { host, flags, af };
nsHostDBEnt *he = static_cast<nsHostDBEnt *>
(PL_DHashTableAdd(&mDB, &key));
(PL_DHashTableAdd(&mDB, &key, fallible));
// if the record is null, the hash table OOM'd.
if (!he) {

4
netwerk/protocol/http/nsHttp.cpp
View File

@ -118,7 +118,7 @@ nsHttp::CreateAtomTable()
for (int i = 0; atoms[i]; ++i) {
PLDHashEntryStub *stub = reinterpret_cast<PLDHashEntryStub *>
(PL_DHashTableAdd(&sAtomTable, atoms[i]));
(PL_DHashTableAdd(&sAtomTable, atoms[i], fallible));
if (!stub)
return NS_ERROR_OUT_OF_MEMORY;
@ -166,7 +166,7 @@ nsHttp::ResolveAtom(const char *str)
MutexAutoLock lock(*sLock);
PLDHashEntryStub *stub = reinterpret_cast<PLDHashEntryStub *>
(PL_DHashTableAdd(&sAtomTable, str));
(PL_DHashTableAdd(&sAtomTable, str, fallible));
if (!stub)
return atom; // out of memory

5
parser/htmlparser/nsHTMLEntities.cpp
View File

@ -94,7 +94,7 @@ nsHTMLEntities::AddRefTable(void)
// add to Entity->Unicode table
EntityNodeEntry* entry =
static_cast<EntityNodeEntry*>
(PL_DHashTableAdd(&gEntityToUnicode, node->mStr));
(PL_DHashTableAdd(&gEntityToUnicode, node->mStr, fallible));
NS_ASSERTION(entry, "Error adding an entry");
// Prefer earlier entries when we have duplication.
if (!entry->node)
@ -103,7 +103,8 @@ nsHTMLEntities::AddRefTable(void)
// add to Unicode->Entity table
entry = static_cast<EntityNodeEntry*>
(PL_DHashTableAdd(&gUnicodeToEntity,
NS_INT32_TO_PTR(node->mUnicode)));
NS_INT32_TO_PTR(node->mUnicode),
fallible));
NS_ASSERTION(entry, "Error adding an entry");
// Prefer earlier entries when we have duplication.
if (!entry->node)

17
rdf/base/nsInMemoryDataSource.cpp
View File

@ -334,7 +334,8 @@ public:
void
SetForwardArcs(nsIRDFResource* u, Assertion* as) {
if (as) {
Entry* entry = static_cast<Entry*>(PL_DHashTableAdd(&mForwardArcs, u));
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(&mForwardArcs, u, mozilla::fallible));
if (entry) {
entry->mNode = u;
entry->mAssertions = as;
@ -348,7 +349,8 @@ public:
void
SetReverseArcs(nsIRDFNode* v, Assertion* as) {
if (as) {
Entry* entry = static_cast<Entry*>(PL_DHashTableAdd(&mReverseArcs, v));
Entry* entry = static_cast<Entry*>
(PL_DHashTableAdd(&mReverseArcs, v, mozilla::fallible));
if (entry) {
entry->mNode = v;
entry->mAssertions = as;
@ -1186,7 +1188,8 @@ InMemoryDataSource::LockedAssert(nsIRDFResource* aSource,
}
else
{
hdr = PL_DHashTableAdd(next->u.hash.mPropertyHash, aProperty);
hdr = PL_DHashTableAdd(next->u.hash.mPropertyHash, aProperty,
mozilla::fallible);
if (hdr)
{
Entry* entry = static_cast<Entry*>(hdr);
@ -1297,8 +1300,9 @@ InMemoryDataSource::LockedUnassert(nsIRDFResource* aSource,
PL_DHashTableRawRemove(root->u.hash.mPropertyHash, hdr);
if (next && next->mNext) {
PLDHashEntryHdr* hdr = PL_DHashTableAdd(root->u.hash.mPropertyHash,
aProperty);
PLDHashEntryHdr* hdr =
PL_DHashTableAdd(root->u.hash.mPropertyHash, aProperty,
mozilla::fallible);
if (hdr) {
Entry* entry = static_cast<Entry*>(hdr);
entry->mNode = aProperty;
@ -1742,7 +1746,8 @@ InMemoryDataSource::EnsureFastContainment(nsIRDFResource* aSource)
val->mNext = first;
}
else {
PLDHashEntryHdr* hdr = PL_DHashTableAdd(table, prop);
PLDHashEntryHdr* hdr = PL_DHashTableAdd(table, prop,
mozilla::fallible);
if (hdr) {
Entry* entry = static_cast<Entry*>(hdr);
entry->mNode = prop;

10
rdf/base/nsRDFService.cpp
View File

@ -1162,7 +1162,7 @@ RDFServiceImpl::RegisterResource(nsIRDFResource* aResource, bool aReplace)
aResource, (const char*) uri));
}
else {
hdr = PL_DHashTableAdd(&mResources, uri);
hdr = PL_DHashTableAdd(&mResources, uri, fallible);
if (! hdr)
return NS_ERROR_OUT_OF_MEMORY;
@ -1399,7 +1399,7 @@ RDFServiceImpl::RegisterLiteral(nsIRDFLiteral* aLiteral)
NS_ASSERTION(!PL_DHashTableSearch(&mLiterals, value),
"literal already registered");
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mLiterals, value);
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mLiterals, value, fallible);
if (! hdr)
return NS_ERROR_OUT_OF_MEMORY;
@ -1451,7 +1451,7 @@ RDFServiceImpl::RegisterInt(nsIRDFInt* aInt)
NS_ASSERTION(!PL_DHashTableSearch(&mInts, &value),
"int already registered");
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mInts, &value);
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mInts, &value, fallible);
if (! hdr)
return NS_ERROR_OUT_OF_MEMORY;
@ -1503,7 +1503,7 @@ RDFServiceImpl::RegisterDate(nsIRDFDate* aDate)
NS_ASSERTION(!PL_DHashTableSearch(&mDates, &value),
"date already registered");
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mDates, &value);
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mDates, &value, fallible);
if (! hdr)
return NS_ERROR_OUT_OF_MEMORY;
@ -1550,7 +1550,7 @@ RDFServiceImpl::RegisterBlob(BlobImpl *aBlob)
NS_ASSERTION(!PL_DHashTableSearch(&mBlobs, &aBlob->mData),
"blob already registered");
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mBlobs, &aBlob->mData);
PLDHashEntryHdr *hdr = PL_DHashTableAdd(&mBlobs, &aBlob->mData, fallible);
if (! hdr)
return NS_ERROR_OUT_OF_MEMORY;

4
security/manager/boot/src/nsSecureBrowserUIImpl.cpp
View File

@ -862,8 +862,8 @@ nsSecureBrowserUIImpl::OnStateChange(nsIWebProgress* aWebProgress,
// means, there has already been data transfered.
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
PL_DHashTableAdd(&mTransferringRequests, aRequest);
PL_DHashTableAdd(&mTransferringRequests, aRequest, fallible);
return NS_OK;
}

5
security/manager/ssl/src/nsCertTree.cpp
View File

@ -201,9 +201,8 @@ CompareCacheHashEntry *
nsCertTree::getCacheEntry(void *cache, void *aCert)
{
PLDHashTable &aCompareCache = *reinterpret_cast<PLDHashTable*>(cache);
CompareCacheHashEntryPtr *entryPtr =
static_cast<CompareCacheHashEntryPtr*>
(PL_DHashTableAdd(&aCompareCache, aCert));
CompareCacheHashEntryPtr *entryPtr = static_cast<CompareCacheHashEntryPtr*>
(PL_DHashTableAdd(&aCompareCache, aCert, fallible));
return entryPtr ? entryPtr->entry : nullptr;
}

4
security/manager/ssl/src/nsNSSShutDown.cpp
View File

@ -70,7 +70,7 @@ void nsNSSShutDownList::remember(nsNSSShutDownObject *o)
PR_ASSERT(o);
MutexAutoLock lock(singleton->mListLock);
PL_DHashTableAdd(&singleton->mObjects, o);
PL_DHashTableAdd(&singleton->mObjects, o, fallible);
}
void nsNSSShutDownList::forget(nsNSSShutDownObject *o)
@ -90,7 +90,7 @@ void nsNSSShutDownList::remember(nsOnPK11LogoutCancelObject *o)
PR_ASSERT(o);
MutexAutoLock lock(singleton->mListLock);
PL_DHashTableAdd(&singleton->mPK11LogoutCancelObjects, o);
PL_DHashTableAdd(&singleton->mPK11LogoutCancelObjects, o, fallible);
}
void nsNSSShutDownList::forget(nsOnPK11LogoutCancelObject *o)

2
uriloader/base/nsDocLoader.cpp
View File

@ -1340,7 +1340,7 @@ nsDocLoader::RefreshAttempted(nsIWebProgress* aWebProgress,
nsresult nsDocLoader::AddRequestInfo(nsIRequest *aRequest)
{
if (!PL_DHashTableAdd(&mRequestInfoHash, aRequest)) {
if (!PL_DHashTableAdd(&mRequestInfoHash, aRequest, mozilla::fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}

4
xpcom/base/nsCycleCollector.cpp
View File

@ -900,8 +900,8 @@ PtrToNodeEntry*
CCGraph::AddNodeToMap(void* aPtr)
{
JS::AutoSuppressGCAnalysis suppress;
PtrToNodeEntry* e =
static_cast<PtrToNodeEntry*>(PL_DHashTableAdd(&mPtrToNodeMap, aPtr));
PtrToNodeEntry* e = static_cast<PtrToNodeEntry*>
(PL_DHashTableAdd(&mPtrToNodeMap, aPtr, fallible));
if (!e) {
// Caller should track OOMs
return nullptr;

16
xpcom/ds/nsAtomTable.cpp
View File

@ -556,12 +556,8 @@ GetAtomHashEntry(const char* aString, uint32_t aLength, uint32_t* aHashOut)
MOZ_ASSERT(NS_IsMainThread(), "wrong thread");
EnsureTableExists();
AtomTableKey key(aString, aLength, aHashOut);
AtomTableEntry* e = static_cast<AtomTableEntry*>(
PL_DHashTableAdd(&gAtomTable, &key));
if (!e) {
NS_ABORT_OOM(gAtomTable.EntryCount() * gAtomTable.EntrySize());
}
return e;
// This is an infallible add.
return static_cast<AtomTableEntry*>(PL_DHashTableAdd(&gAtomTable, &key));
}
static inline AtomTableEntry*
@ -570,12 +566,8 @@ GetAtomHashEntry(const char16_t* aString, uint32_t aLength, uint32_t* aHashOut)
MOZ_ASSERT(NS_IsMainThread(), "wrong thread");
EnsureTableExists();
AtomTableKey key(aString, aLength, aHashOut);
AtomTableEntry* e = static_cast<AtomTableEntry*>(
PL_DHashTableAdd(&gAtomTable, &key));
if (!e) {
NS_ABORT_OOM(gAtomTable.EntryCount() * gAtomTable.EntrySize());
}
return e;
// This is an infallible add.
return static_cast<AtomTableEntry*>(PL_DHashTableAdd(&gAtomTable, &key));
}
class CheckStaticAtomSizes

2
xpcom/ds/nsPersistentProperties.cpp
View File

@ -528,7 +528,7 @@ nsPersistentProperties::SetStringProperty(const nsACString& aKey,
{
const nsAFlatCString& flatKey = PromiseFlatCString(aKey);
PropertyTableEntry* entry = static_cast<PropertyTableEntry*>(
PL_DHashTableAdd(&mTable, flatKey.get()));
PL_DHashTableAdd(&mTable, flatKey.get(), mozilla::fallible));
if (entry->mKey) {
aOldValue = entry->mValue;

4
xpcom/ds/nsStaticNameTable.cpp
View File

@ -161,8 +161,8 @@ nsStaticCaseInsensitiveNameTable::Init(const char* const aNames[],
NameTableKey key(strPtr);
NameTableEntry* entry =
static_cast<NameTableEntry*>(PL_DHashTableAdd(&mNameTable, &key));
NameTableEntry* entry = static_cast<NameTableEntry*>
(PL_DHashTableAdd(&mNameTable, &key, fallible));
if (!entry) {
continue;
}

22
xpcom/glue/nsTHashtable.h
View File

@ -149,19 +149,21 @@ public:
*/
EntryType* PutEntry(KeyType aKey)
{
EntryType* e = PutEntry(aKey, mozilla::fallible);
if (!e) {
NS_ABORT_OOM(mTable.EntrySize() * mTable.EntryCount());
}
return e;
}
EntryType* PutEntry(KeyType aKey, const fallible_t&) NS_WARN_UNUSED_RESULT {
NS_ASSERTION(mTable.IsInitialized(),
"nsTHashtable was not initialized properly.");
return static_cast<EntryType*>(PL_DHashTableAdd(
&mTable, EntryType::KeyToPointer(aKey)));
return static_cast<EntryType*> // infallible add
(PL_DHashTableAdd(&mTable, EntryType::KeyToPointer(aKey)));
}
EntryType* PutEntry(KeyType aKey, const fallible_t&) NS_WARN_UNUSED_RESULT
{
NS_ASSERTION(mTable.IsInitialized(),
"nsTHashtable was not initialized properly.");
return static_cast<EntryType*>
(PL_DHashTableAdd(&mTable, EntryType::KeyToPointer(aKey),
mozilla::fallible));
}
/**

18
xpcom/glue/pldhash.cpp
View File

@ -529,7 +529,7 @@ PLDHashTable::Search(const void* aKey)
}
MOZ_ALWAYS_INLINE PLDHashEntryHdr*
PLDHashTable::Add(const void* aKey)
PLDHashTable::Add(const void* aKey, const mozilla::fallible_t&)
{
PLDHashNumber keyHash;
PLDHashEntryHdr* entry;
@ -647,10 +647,24 @@ PL_DHashTableSearch(PLDHashTable* aTable, const void* aKey)
return aTable->Search(aKey);
}
PLDHashEntryHdr* PL_DHASH_FASTCALL
PL_DHashTableAdd(PLDHashTable* aTable, const void* aKey,
const fallible_t& aFallible)
{
return aTable->Add(aKey, aFallible);
}
PLDHashEntryHdr* PL_DHASH_FASTCALL
PL_DHashTableAdd(PLDHashTable* aTable, const void* aKey)
{
return aTable->Add(aKey);
PLDHashEntryHdr* entry = PL_DHashTableAdd(aTable, aKey, fallible);
if (!entry) {
// There are two ways the Add could fail: (a) a entry storage reallocation
// failed, or (b) mOps->initEntry failed. The number we're reporting here
// is the one for case (a), which is the more likely of the two.
NS_ABORT_OOM(aTable->EntrySize() * aTable->EntryCount());
}
return entry;
}
void PL_DHASH_FASTCALL

13
xpcom/glue/pldhash.h
View File

@ -10,6 +10,7 @@
* Double hashing, a la Knuth 6.
*/
#include "mozilla/Attributes.h" // for MOZ_ALWAYS_INLINE
#include "mozilla/fallible.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/Types.h"
#include "nscore.h"
@ -244,7 +245,7 @@ public:
void Finish();
PLDHashEntryHdr* Search(const void* aKey);
PLDHashEntryHdr* Add(const void* aKey);
PLDHashEntryHdr* Add(const void* aKey, const mozilla::fallible_t&);
void Remove(const void* aKey);
void RawRemove(PLDHashEntryHdr* aEntry);
@ -466,7 +467,7 @@ PL_DHashTableSearch(PLDHashTable* aTable, const void* aKey);
/*
* To add an entry identified by key to table, call:
*
* entry = PL_DHashTableAdd(table, key);
* entry = PL_DHashTableAdd(table, key, mozilla::fallible);
*
* If entry is null upon return, then either (a) the table is severely
* overloaded and memory can't be allocated for entry storage, or (b)
@ -480,6 +481,14 @@ PL_DHashTableSearch(PLDHashTable* aTable, const void* aKey);
* optional initEntry hook was not used).
*/
PLDHashEntryHdr* PL_DHASH_FASTCALL
PL_DHashTableAdd(PLDHashTable* aTable, const void* aKey,
const mozilla::fallible_t&);
/*
* This is like the other PL_DHashTableAdd() function, but infallible, and so
* never returns null.
*/
PLDHashEntryHdr* PL_DHASH_FASTCALL
PL_DHashTableAdd(PLDHashTable* aTable, const void* aKey);
/*

2
xpcom/tests/TestPLDHash.cpp
View File

@ -139,7 +139,7 @@ static bool test_pldhash_grow_to_max_capacity()
// Keep inserting elements until failure occurs because the table is full.
size_t numInserted = 0;
while (true) {
if (!PL_DHashTableAdd(&t, (const void*)numInserted)) {
if (!PL_DHashTableAdd(&t, (const void*)numInserted, mozilla::fallible)) {
break;
}
numInserted++;