mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 884649 (part 1) - Used PLDHash instead of JSDHash in xpconnect. r=mccr8. 

--HG--
extra : rebase_source : 7a206a6dfba19d8678ef9aee7517b4833c2a4f00
This commit is contained in:
Nicholas Nethercote 2013-06-19 16:15:21 -07:00
Родитель 7be7aa926c
Коммит cef32afe0b
6 изменённых файлов: 265 добавлений и 265 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

90
js/xpconnect/src/XPCJSRuntime.cpp
Просмотреть файл

@ -86,18 +86,18 @@ struct CX_AND_XPCRT_Data
static void * const UNMARK_ONLY = nullptr;
static void * const UNMARK_AND_SWEEP = (void *)1;
static JSDHashOperator
NativeInterfaceSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
NativeInterfaceSweeper(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCNativeInterface* iface = ((IID2NativeInterfaceMap::Entry*)hdr)->value;
if (iface->IsMarked()) {
iface->Unmark();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
if (arg == UNMARK_ONLY)
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
#ifdef XPC_REPORT_NATIVE_INTERFACE_AND_SET_FLUSHING
fputs("- Destroying XPCNativeInterface for ", stdout);
@ -106,7 +106,7 @@ NativeInterfaceSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
#endif
XPCNativeInterface::DestroyInstance(iface);
return JS_DHASH_REMOVE;
return PL_DHASH_REMOVE;
}
// *Some* NativeSets are referenced from mClassInfo2NativeSetMap.
@ -114,28 +114,28 @@ NativeInterfaceSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
// So, in mClassInfo2NativeSetMap we just clear references to the unmarked.
// In mNativeSetMap we clear the references to the unmarked *and* delete them.
static JSDHashOperator
NativeUnMarkedSetRemover(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
NativeUnMarkedSetRemover(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCNativeSet* set = ((ClassInfo2NativeSetMap::Entry*)hdr)->value;
if (set->IsMarked())
return JS_DHASH_NEXT;
return JS_DHASH_REMOVE;
return PL_DHASH_NEXT;
return PL_DHASH_REMOVE;
}
static JSDHashOperator
NativeSetSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
NativeSetSweeper(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCNativeSet* set = ((NativeSetMap::Entry*)hdr)->key_value;
if (set->IsMarked()) {
set->Unmark();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
if (arg == UNMARK_ONLY)
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
#ifdef XPC_REPORT_NATIVE_INTERFACE_AND_SET_FLUSHING
printf("- Destroying XPCNativeSet for:\n");
@ -149,11 +149,11 @@ NativeSetSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
#endif
XPCNativeSet::DestroyInstance(set);
return JS_DHASH_REMOVE;
return PL_DHASH_REMOVE;
}
static JSDHashOperator
JSClassSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
JSClassSweeper(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCNativeScriptableShared* shared =
@ -165,11 +165,11 @@ JSClassSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
shared->GetJSClass());
#endif
shared->Unmark();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
if (arg == UNMARK_ONLY)
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
#ifdef XPC_REPORT_JSCLASS_FLUSHING
printf("- Destroying XPCNativeScriptableShared for: %s @ %x\n",
@ -178,28 +178,28 @@ JSClassSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
#endif
delete shared;
return JS_DHASH_REMOVE;
return PL_DHASH_REMOVE;
}
static JSDHashOperator
DyingProtoKiller(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
DyingProtoKiller(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNativeProto* proto =
(XPCWrappedNativeProto*)((JSDHashEntryStub*)hdr)->key;
(XPCWrappedNativeProto*)((PLDHashEntryStub*)hdr)->key;
delete proto;
return JS_DHASH_REMOVE;
return PL_DHASH_REMOVE;
}
static JSDHashOperator
DetachedWrappedNativeProtoMarker(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
DetachedWrappedNativeProtoMarker(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNativeProto* proto =
(XPCWrappedNativeProto*)((JSDHashEntryStub*)hdr)->key;
(XPCWrappedNativeProto*)((PLDHashEntryStub*)hdr)->key;
proto->Mark();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
// GCCallback calls are chained
@ -1178,26 +1178,26 @@ XPCJSRuntime::DeleteString(nsAString *string)
/***************************************************************************/
#ifdef XPC_CHECK_WRAPPERS_AT_SHUTDOWN
static JSDHashOperator
DEBUG_WrapperChecker(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
DEBUG_WrapperChecker(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNative* wrapper = (XPCWrappedNative*)((JSDHashEntryStub*)hdr)->key;
XPCWrappedNative* wrapper = (XPCWrappedNative*)((PLDHashEntryStub*)hdr)->key;
NS_ASSERTION(!wrapper->IsValid(), "found a 'valid' wrapper!");
++ *((int*)arg);
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
#endif
static JSDHashOperator
DetachedWrappedNativeProtoShutdownMarker(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
DetachedWrappedNativeProtoShutdownMarker(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNativeProto* proto =
(XPCWrappedNativeProto*)((JSDHashEntryStub*)hdr)->key;
(XPCWrappedNativeProto*)((PLDHashEntryStub*)hdr)->key;
proto->SystemIsBeingShutDown();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
void XPCJSRuntime::DestroyJSContextStack()
@ -1318,11 +1318,11 @@ XPCJSRuntime::~XPCJSRuntime()
#ifdef XPC_CHECK_WRAPPERS_AT_SHUTDOWN
if (DEBUG_WrappedNativeHashtable) {
int LiveWrapperCount = 0;
JS_DHashTableEnumerate(DEBUG_WrappedNativeHashtable,
PL_DHashTableEnumerate(DEBUG_WrappedNativeHashtable,
DEBUG_WrapperChecker, &LiveWrapperCount);
if (LiveWrapperCount)
printf("deleting XPCJSRuntime with %d live XPCWrappedNative (found in wrapper check)\n", (int)LiveWrapperCount);
JS_DHashTableDestroy(DEBUG_WrappedNativeHashtable);
PL_DHashTableDestroy(DEBUG_WrappedNativeHashtable);
}
#endif
@ -2677,8 +2677,8 @@ XPCJSRuntime::XPCJSRuntime(nsXPConnect* aXPConnect)
{
#ifdef XPC_CHECK_WRAPPERS_AT_SHUTDOWN
DEBUG_WrappedNativeHashtable =
JS_NewDHashTable(JS_DHashGetStubOps(), nullptr,
sizeof(JSDHashEntryStub), 128);
PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
sizeof(PLDHashEntryStub), 128);
#endif
DOM_InitInterfaces();
@ -2912,19 +2912,19 @@ XPCJSRuntime::DeferredRelease(nsISupports *obj)
/***************************************************************************/
#ifdef DEBUG
static JSDHashOperator
WrappedJSClassMapDumpEnumerator(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedJSClassMapDumpEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((IID2WrappedJSClassMap::Entry*)hdr)->value->DebugDump(*(int16_t*)arg);
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
static JSDHashOperator
NativeSetDumpEnumerator(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
NativeSetDumpEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((NativeSetMap::Entry*)hdr)->key_value->DebugDump(*(int16_t*)arg);
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
#endif

164
js/xpconnect/src/XPCMaps.cpp
Просмотреть файл

@ -16,27 +16,27 @@
// Note this is returning the bit pattern of the first part of the nsID, not
// the pointer to the nsID.
static JSDHashNumber
HashIIDPtrKey(JSDHashTable *table, const void *key)
static PLDHashNumber
HashIIDPtrKey(PLDHashTable *table, const void *key)
{
return *((js::HashNumber*)key);
}
static JSBool
MatchIIDPtrKey(JSDHashTable *table,
const JSDHashEntryHdr *entry,
static bool
MatchIIDPtrKey(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
return ((const nsID*)key)->
Equals(*((const nsID*)((JSDHashEntryStub*)entry)->key));
Equals(*((const nsID*)((PLDHashEntryStub*)entry)->key));
}
static JSDHashNumber
HashNativeKey(JSDHashTable *table, const void *key)
static PLDHashNumber
HashNativeKey(PLDHashTable *table, const void *key)
{
XPCNativeSetKey* Key = (XPCNativeSetKey*) key;
JSDHashNumber h = 0;
PLDHashNumber h = 0;
XPCNativeSet* Set;
XPCNativeInterface* Addition;
@ -127,14 +127,14 @@ Native2WrappedNativeMap::newMap(int size)
Native2WrappedNativeMap::Native2WrappedNativeMap(int size)
{
mTable = JS_NewDHashTable(JS_DHashGetStubOps(), nullptr,
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
sizeof(Entry), size);
}
Native2WrappedNativeMap::~Native2WrappedNativeMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
size_t
@ -142,12 +142,12 @@ Native2WrappedNativeMap::SizeOfIncludingThis(nsMallocSizeOfFun mallocSizeOf)
{
size_t n = 0;
n += mallocSizeOf(this);
n += mTable ? JS_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
n += mTable ? PL_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
return n;
}
/* static */ size_t
Native2WrappedNativeMap::SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr,
Native2WrappedNativeMap::SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr,
JSMallocSizeOfFun mallocSizeOf, void *)
{
return mallocSizeOf(((Native2WrappedNativeMap::Entry*)hdr)->value);
@ -156,15 +156,15 @@ Native2WrappedNativeMap::SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr,
/***************************************************************************/
// implement IID2WrappedJSClassMap...
struct JSDHashTableOps IID2WrappedJSClassMap::Entry::sOps =
struct PLDHashTableOps IID2WrappedJSClassMap::Entry::sOps =
{
JS_DHashAllocTable,
JS_DHashFreeTable,
PL_DHashAllocTable,
PL_DHashFreeTable,
HashIIDPtrKey,
MatchIIDPtrKey,
JS_DHashMoveEntryStub,
JS_DHashClearEntryStub,
JS_DHashFinalizeStub
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
@ -180,28 +180,28 @@ IID2WrappedJSClassMap::newMap(int size)
IID2WrappedJSClassMap::IID2WrappedJSClassMap(int size)
{
mTable = JS_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
}
IID2WrappedJSClassMap::~IID2WrappedJSClassMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
/***************************************************************************/
// implement IID2NativeInterfaceMap...
struct JSDHashTableOps IID2NativeInterfaceMap::Entry::sOps =
struct PLDHashTableOps IID2NativeInterfaceMap::Entry::sOps =
{
JS_DHashAllocTable,
JS_DHashFreeTable,
PL_DHashAllocTable,
PL_DHashFreeTable,
HashIIDPtrKey,
MatchIIDPtrKey,
JS_DHashMoveEntryStub,
JS_DHashClearEntryStub,
JS_DHashFinalizeStub
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
@ -217,13 +217,13 @@ IID2NativeInterfaceMap::newMap(int size)
IID2NativeInterfaceMap::IID2NativeInterfaceMap(int size)
{
mTable = JS_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
}
IID2NativeInterfaceMap::~IID2NativeInterfaceMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
size_t
@ -231,12 +231,12 @@ IID2NativeInterfaceMap::SizeOfIncludingThis(nsMallocSizeOfFun mallocSizeOf)
{
size_t n = 0;
n += mallocSizeOf(this);
n += mTable ? JS_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
n += mTable ? PL_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
return n;
}
/* static */ size_t
IID2NativeInterfaceMap::SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr,
IID2NativeInterfaceMap::SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr,
JSMallocSizeOfFun mallocSizeOf, void *)
{
XPCNativeInterface *iface = ((IID2NativeInterfaceMap::Entry*)hdr)->value;
@ -259,14 +259,14 @@ ClassInfo2NativeSetMap::newMap(int size)
ClassInfo2NativeSetMap::ClassInfo2NativeSetMap(int size)
{
mTable = JS_NewDHashTable(JS_DHashGetStubOps(), nullptr,
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
sizeof(Entry), size);
}
ClassInfo2NativeSetMap::~ClassInfo2NativeSetMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
size_t
@ -274,8 +274,8 @@ ClassInfo2NativeSetMap::ShallowSizeOfIncludingThis(nsMallocSizeOfFun mallocSizeO
{
size_t n = 0;
n += mallocSizeOf(this);
// The second arg is NULL because this is a "shallow" measurement of the map.
n += mTable ? JS_DHashTableSizeOfIncludingThis(mTable, NULL, mallocSizeOf) : 0;
// The second arg is nullptr because this is a "shallow" measurement of the map.
n += mTable ? PL_DHashTableSizeOfIncludingThis(mTable, nullptr, mallocSizeOf) : 0;
return n;
}
@ -299,14 +299,14 @@ ClassInfo2WrappedNativeProtoMap::newMap(int size)
ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int size)
{
mTable = JS_NewDHashTable(JS_DHashGetStubOps(), nullptr,
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
sizeof(Entry), size);
}
ClassInfo2WrappedNativeProtoMap::~ClassInfo2WrappedNativeProtoMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
size_t
@ -314,12 +314,12 @@ ClassInfo2WrappedNativeProtoMap::SizeOfIncludingThis(nsMallocSizeOfFun mallocSiz
{
size_t n = 0;
n += mallocSizeOf(this);
n += mTable ? JS_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
n += mTable ? PL_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
return n;
}
/* static */ size_t
ClassInfo2WrappedNativeProtoMap::SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr,
ClassInfo2WrappedNativeProtoMap::SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr,
JSMallocSizeOfFun mallocSizeOf, void *)
{
return mallocSizeOf(((ClassInfo2WrappedNativeProtoMap::Entry*)hdr)->value);
@ -328,9 +328,9 @@ ClassInfo2WrappedNativeProtoMap::SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr,
/***************************************************************************/
// implement NativeSetMap...
JSBool
NativeSetMap::Entry::Match(JSDHashTable *table,
const JSDHashEntryHdr *entry,
bool
NativeSetMap::Entry::Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
XPCNativeSetKey* Key = (XPCNativeSetKey*) key;
@ -400,15 +400,15 @@ NativeSetMap::Entry::Match(JSDHashTable *table,
return true;
}
struct JSDHashTableOps NativeSetMap::Entry::sOps =
struct PLDHashTableOps NativeSetMap::Entry::sOps =
{
JS_DHashAllocTable,
JS_DHashFreeTable,
PL_DHashAllocTable,
PL_DHashFreeTable,
HashNativeKey,
Match,
JS_DHashMoveEntryStub,
JS_DHashClearEntryStub,
JS_DHashFinalizeStub
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
@ -424,13 +424,13 @@ NativeSetMap::newMap(int size)
NativeSetMap::NativeSetMap(int size)
{
mTable = JS_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
}
NativeSetMap::~NativeSetMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
size_t
@ -438,12 +438,12 @@ NativeSetMap::SizeOfIncludingThis(nsMallocSizeOfFun mallocSizeOf)
{
size_t n = 0;
n += mallocSizeOf(this);
n += mTable ? JS_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
n += mTable ? PL_DHashTableSizeOfIncludingThis(mTable, SizeOfEntryExcludingThis, mallocSizeOf) : 0;
return n;
}
/* static */ size_t
NativeSetMap::SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *)
NativeSetMap::SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *)
{
XPCNativeSet *set = ((NativeSetMap::Entry*)hdr)->key_value;
return set->SizeOfIncludingThis(mallocSizeOf);
@ -452,30 +452,30 @@ NativeSetMap::SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr, JSMallocSizeOfFun m
/***************************************************************************/
// implement IID2ThisTranslatorMap...
JSBool
IID2ThisTranslatorMap::Entry::Match(JSDHashTable *table,
const JSDHashEntryHdr *entry,
bool
IID2ThisTranslatorMap::Entry::Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
return ((const nsID*)key)->Equals(((Entry*)entry)->key);
}
void
IID2ThisTranslatorMap::Entry::Clear(JSDHashTable *table, JSDHashEntryHdr *entry)
IID2ThisTranslatorMap::Entry::Clear(PLDHashTable *table, PLDHashEntryHdr *entry)
{
NS_IF_RELEASE(((Entry*)entry)->value);
memset(entry, 0, table->entrySize);
}
struct JSDHashTableOps IID2ThisTranslatorMap::Entry::sOps =
struct PLDHashTableOps IID2ThisTranslatorMap::Entry::sOps =
{
JS_DHashAllocTable,
JS_DHashFreeTable,
PL_DHashAllocTable,
PL_DHashFreeTable,
HashIIDPtrKey,
Match,
JS_DHashMoveEntryStub,
PL_DHashMoveEntryStub,
Clear,
JS_DHashFinalizeStub
PL_DHashFinalizeStub
};
// static
@ -491,21 +491,21 @@ IID2ThisTranslatorMap::newMap(int size)
IID2ThisTranslatorMap::IID2ThisTranslatorMap(int size)
{
mTable = JS_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
}
IID2ThisTranslatorMap::~IID2ThisTranslatorMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
/***************************************************************************/
JSDHashNumber
XPCNativeScriptableSharedMap::Entry::Hash(JSDHashTable *table, const void *key)
PLDHashNumber
XPCNativeScriptableSharedMap::Entry::Hash(PLDHashTable *table, const void *key)
{
JSDHashNumber h;
PLDHashNumber h;
const unsigned char *s;
XPCNativeScriptableShared* obj =
@ -515,15 +515,15 @@ XPCNativeScriptableSharedMap::Entry::Hash(JSDHashTable *table, const void *key)
// bitmap since it's very rare that it's different when flags and classname
// are the same.
h = (JSDHashNumber) obj->GetFlags();
h = (PLDHashNumber) obj->GetFlags();
for (s = (const unsigned char*) obj->GetJSClass()->name; *s != '\0'; s++)
h = JS_ROTATE_LEFT32(h, 4) ^ *s;
return h;
}
JSBool
XPCNativeScriptableSharedMap::Entry::Match(JSDHashTable *table,
const JSDHashEntryHdr *entry,
bool
XPCNativeScriptableSharedMap::Entry::Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
XPCNativeScriptableShared* obj1 =
@ -547,15 +547,15 @@ XPCNativeScriptableSharedMap::Entry::Match(JSDHashTable *table,
return 0 == strcmp(name1, name2);
}
struct JSDHashTableOps XPCNativeScriptableSharedMap::Entry::sOps =
struct PLDHashTableOps XPCNativeScriptableSharedMap::Entry::sOps =
{
JS_DHashAllocTable,
JS_DHashFreeTable,
PL_DHashAllocTable,
PL_DHashFreeTable,
Hash,
Match,
JS_DHashMoveEntryStub,
JS_DHashClearEntryStub,
JS_DHashFinalizeStub
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
@ -572,13 +572,13 @@ XPCNativeScriptableSharedMap::newMap(int size)
XPCNativeScriptableSharedMap::XPCNativeScriptableSharedMap(int size)
{
mTable = JS_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
}
XPCNativeScriptableSharedMap::~XPCNativeScriptableSharedMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
JSBool
@ -592,7 +592,7 @@ XPCNativeScriptableSharedMap::GetNewOrUsed(uint32_t flags,
XPCNativeScriptableShared key(flags, name, interfacesBitmap);
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, &key, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, &key, PL_DHASH_ADD);
if (!entry)
return false;
@ -626,14 +626,14 @@ XPCWrappedNativeProtoMap::newMap(int size)
XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int size)
{
mTable = JS_NewDHashTable(JS_DHashGetStubOps(), nullptr,
sizeof(JSDHashEntryStub), size);
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
sizeof(PLDHashEntryStub), size);
}
XPCWrappedNativeProtoMap::~XPCWrappedNativeProtoMap()
{
if (mTable)
JS_DHashTableDestroy(mTable);
PL_DHashTableDestroy(mTable);
}
/***************************************************************************/

176
js/xpconnect/src/XPCMaps.h
Просмотреть файл

@ -15,7 +15,7 @@
// Note that most of the declarations for hash table entries begin with
// a pointer to something or another. This makes them look enough like
// the JSDHashEntryStub struct that the default OPs (JS_DHashGetStubOps())
// the PLDHashEntryStub struct that the default OPs (PL_DHashGetStubOps())
// just do the right thing for most of our needs.
// no virtuals in the maps - all the common stuff inlined
@ -85,7 +85,7 @@ private:
class Native2WrappedNativeMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
nsISupports* key;
XPCWrappedNative* value;
@ -97,8 +97,8 @@ public:
{
NS_PRECONDITION(Obj,"bad param");
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, Obj, JS_DHASH_LOOKUP);
if (JS_DHASH_ENTRY_IS_FREE(entry))
PL_DHashTableOperate(mTable, Obj, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
}
@ -109,7 +109,7 @@ public:
nsISupports* obj = wrapper->GetIdentityObject();
MOZ_ASSERT(!Find(obj), "wrapper already in new scope!");
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, obj, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, obj, PL_DHASH_ADD);
if (!entry)
return nullptr;
if (entry->key)
@ -129,12 +129,12 @@ public:
"nsISupports identity! This will most likely cause serious "
"problems!");
#endif
JS_DHashTableOperate(mTable, wrapper->GetIdentityObject(), JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, wrapper->GetIdentityObject(), PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
size_t SizeOfIncludingThis(nsMallocSizeOfFun mallocSizeOf);
@ -143,10 +143,10 @@ private:
Native2WrappedNativeMap(); // no implementation
Native2WrappedNativeMap(int size);
static size_t SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
static size_t SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/*************************/
@ -154,12 +154,12 @@ private:
class IID2WrappedJSClassMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
const nsIID* key;
nsXPCWrappedJSClass* value;
static struct JSDHashTableOps sOps;
static struct PLDHashTableOps sOps;
};
static IID2WrappedJSClassMap* newMap(int size);
@ -167,8 +167,8 @@ public:
inline nsXPCWrappedJSClass* Find(REFNSIID iid)
{
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, &iid, JS_DHASH_LOOKUP);
if (JS_DHASH_ENTRY_IS_FREE(entry))
PL_DHashTableOperate(mTable, &iid, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
}
@ -178,7 +178,7 @@ public:
NS_PRECONDITION(clazz,"bad param");
const nsIID* iid = &clazz->GetIID();
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, iid, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, iid, PL_DHASH_ADD);
if (!entry)
return nullptr;
if (entry->key)
@ -191,19 +191,19 @@ public:
inline void Remove(nsXPCWrappedJSClass* clazz)
{
NS_PRECONDITION(clazz,"bad param");
JS_DHashTableOperate(mTable, &clazz->GetIID(), JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, &clazz->GetIID(), PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
~IID2WrappedJSClassMap();
private:
IID2WrappedJSClassMap(); // no implementation
IID2WrappedJSClassMap(int size);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/*************************/
@ -211,12 +211,12 @@ private:
class IID2NativeInterfaceMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
const nsIID* key;
XPCNativeInterface* value;
static struct JSDHashTableOps sOps;
static struct PLDHashTableOps sOps;
};
static IID2NativeInterfaceMap* newMap(int size);
@ -224,8 +224,8 @@ public:
inline XPCNativeInterface* Find(REFNSIID iid)
{
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, &iid, JS_DHASH_LOOKUP);
if (JS_DHASH_ENTRY_IS_FREE(entry))
PL_DHashTableOperate(mTable, &iid, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
}
@ -235,7 +235,7 @@ public:
NS_PRECONDITION(iface,"bad param");
const nsIID* iid = iface->GetIID();
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, iid, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, iid, PL_DHASH_ADD);
if (!entry)
return nullptr;
if (entry->key)
@ -248,12 +248,12 @@ public:
inline void Remove(XPCNativeInterface* iface)
{
NS_PRECONDITION(iface,"bad param");
JS_DHashTableOperate(mTable, iface->GetIID(), JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, iface->GetIID(), PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
size_t SizeOfIncludingThis(nsMallocSizeOfFun mallocSizeOf);
@ -262,10 +262,10 @@ private:
IID2NativeInterfaceMap(); // no implementation
IID2NativeInterfaceMap(int size);
static size_t SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
static size_t SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/*************************/
@ -273,7 +273,7 @@ private:
class ClassInfo2NativeSetMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
nsIClassInfo* key;
XPCNativeSet* value;
@ -284,8 +284,8 @@ public:
inline XPCNativeSet* Find(nsIClassInfo* info)
{
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, info, JS_DHASH_LOOKUP);
if (JS_DHASH_ENTRY_IS_FREE(entry))
PL_DHashTableOperate(mTable, info, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
}
@ -294,7 +294,7 @@ public:
{
NS_PRECONDITION(info,"bad param");
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, info, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, info, PL_DHASH_ADD);
if (!entry)
return nullptr;
if (entry->key)
@ -307,12 +307,12 @@ public:
inline void Remove(nsIClassInfo* info)
{
NS_PRECONDITION(info,"bad param");
JS_DHashTableOperate(mTable, info, JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, info, PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
// ClassInfo2NativeSetMap holds pointers to *some* XPCNativeSets.
// So we don't want to count those XPCNativeSets, because they are better
@ -325,7 +325,7 @@ private:
ClassInfo2NativeSetMap(); // no implementation
ClassInfo2NativeSetMap(int size);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/*************************/
@ -333,7 +333,7 @@ private:
class ClassInfo2WrappedNativeProtoMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
nsIClassInfo* key;
XPCWrappedNativeProto* value;
@ -344,8 +344,8 @@ public:
inline XPCWrappedNativeProto* Find(nsIClassInfo* info)
{
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, info, JS_DHASH_LOOKUP);
if (JS_DHASH_ENTRY_IS_FREE(entry))
PL_DHashTableOperate(mTable, info, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
}
@ -354,7 +354,7 @@ public:
{
NS_PRECONDITION(info,"bad param");
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, info, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, info, PL_DHASH_ADD);
if (!entry)
return nullptr;
if (entry->key)
@ -367,12 +367,12 @@ public:
inline void Remove(nsIClassInfo* info)
{
NS_PRECONDITION(info,"bad param");
JS_DHashTableOperate(mTable, info, JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, info, PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
size_t SizeOfIncludingThis(nsMallocSizeOfFun mallocSizeOf);
@ -381,10 +381,10 @@ private:
ClassInfo2WrappedNativeProtoMap(); // no implementation
ClassInfo2WrappedNativeProtoMap(int size);
static size_t SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
static size_t SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/*************************/
@ -392,16 +392,16 @@ private:
class NativeSetMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
XPCNativeSet* key_value;
static JSBool
Match(JSDHashTable *table,
const JSDHashEntryHdr *entry,
static bool
Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
static struct JSDHashTableOps sOps;
static struct PLDHashTableOps sOps;
};
static NativeSetMap* newMap(int size);
@ -409,8 +409,8 @@ public:
inline XPCNativeSet* Find(XPCNativeSetKey* key)
{
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, key, JS_DHASH_LOOKUP);
if (JS_DHASH_ENTRY_IS_FREE(entry))
PL_DHashTableOperate(mTable, key, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->key_value;
}
@ -420,7 +420,7 @@ public:
NS_PRECONDITION(key,"bad param");
NS_PRECONDITION(set,"bad param");
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, key, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, key, PL_DHASH_ADD);
if (!entry)
return nullptr;
if (entry->key_value)
@ -440,12 +440,12 @@ public:
NS_PRECONDITION(set,"bad param");
XPCNativeSetKey key(set, nullptr, 0);
JS_DHashTableOperate(mTable, &key, JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, &key, PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
size_t SizeOfIncludingThis(nsMallocSizeOfFun mallocSizeOf);
@ -454,10 +454,10 @@ private:
NativeSetMap(); // no implementation
NativeSetMap(int size);
static size_t SizeOfEntryExcludingThis(JSDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
static size_t SizeOfEntryExcludingThis(PLDHashEntryHdr *hdr, JSMallocSizeOfFun mallocSizeOf, void *);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/***************************************************************************/
@ -465,20 +465,20 @@ private:
class IID2ThisTranslatorMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
nsIID key;
nsIXPCFunctionThisTranslator* value;
static JSBool
Match(JSDHashTable *table,
const JSDHashEntryHdr *entry,
static bool
Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
static void
Clear(JSDHashTable *table, JSDHashEntryHdr *entry);
Clear(PLDHashTable *table, PLDHashEntryHdr *entry);
static struct JSDHashTableOps sOps;
static struct PLDHashTableOps sOps;
};
static IID2ThisTranslatorMap* newMap(int size);
@ -486,8 +486,8 @@ public:
inline nsIXPCFunctionThisTranslator* Find(REFNSIID iid)
{
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, &iid, JS_DHASH_LOOKUP);
if (JS_DHASH_ENTRY_IS_FREE(entry))
PL_DHashTableOperate(mTable, &iid, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
}
@ -497,7 +497,7 @@ public:
{
Entry* entry = (Entry*)
JS_DHashTableOperate(mTable, &iid, JS_DHASH_ADD);
PL_DHashTableOperate(mTable, &iid, PL_DHASH_ADD);
if (!entry)
return nullptr;
NS_IF_ADDREF(obj);
@ -509,19 +509,19 @@ public:
inline void Remove(REFNSIID iid)
{
JS_DHashTableOperate(mTable, &iid, JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, &iid, PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
~IID2ThisTranslatorMap();
private:
IID2ThisTranslatorMap(); // no implementation
IID2ThisTranslatorMap(int size);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/***************************************************************************/
@ -529,19 +529,19 @@ private:
class XPCNativeScriptableSharedMap
{
public:
struct Entry : public JSDHashEntryHdr
struct Entry : public PLDHashEntryHdr
{
XPCNativeScriptableShared* key;
static JSDHashNumber
Hash(JSDHashTable *table, const void *key);
static PLDHashNumber
Hash(PLDHashTable *table, const void *key);
static JSBool
Match(JSDHashTable *table,
const JSDHashEntryHdr *entry,
static bool
Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
static struct JSDHashTableOps sOps;
static struct PLDHashTableOps sOps;
};
static XPCNativeScriptableSharedMap* newMap(int size);
@ -550,15 +550,15 @@ public:
XPCNativeScriptableInfo* si);
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
~XPCNativeScriptableSharedMap();
private:
XPCNativeScriptableSharedMap(); // no implementation
XPCNativeScriptableSharedMap(int size);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/***************************************************************************/
@ -571,8 +571,8 @@ public:
inline XPCWrappedNativeProto* Add(XPCWrappedNativeProto* proto)
{
NS_PRECONDITION(proto,"bad param");
JSDHashEntryStub* entry = (JSDHashEntryStub*)
JS_DHashTableOperate(mTable, proto, JS_DHASH_ADD);
PLDHashEntryStub* entry = (PLDHashEntryStub*)
PL_DHashTableOperate(mTable, proto, PL_DHASH_ADD);
if (!entry)
return nullptr;
if (entry->key)
@ -584,19 +584,19 @@ public:
inline void Remove(XPCWrappedNativeProto* proto)
{
NS_PRECONDITION(proto,"bad param");
JS_DHashTableOperate(mTable, proto, JS_DHASH_REMOVE);
PL_DHashTableOperate(mTable, proto, PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(JSDHashEnumerator f, void *arg)
{return JS_DHashTableEnumerate(mTable, f, arg);}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
~XPCWrappedNativeProtoMap();
private:
XPCWrappedNativeProtoMap(); // no implementation
XPCWrappedNativeProtoMap(int size);
private:
JSDHashTable *mTable;
PLDHashTable *mTable;
};
/***************************************************************************/

78
js/xpconnect/src/XPCWrappedNativeScope.cpp
Просмотреть файл

@ -324,15 +324,15 @@ XPCWrappedNativeScope::~XPCWrappedNativeScope()
mGlobalJSObject.finalize(rt);
}
static JSDHashOperator
WrappedNativeJSGCThingTracer(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeJSGCThingTracer(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNative* wrapper = ((Native2WrappedNativeMap::Entry*)hdr)->value;
if (wrapper->HasExternalReference() && !wrapper->IsWrapperExpired())
wrapper->TraceSelf((JSTracer *)arg);
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
// static
@ -354,8 +354,8 @@ XPCWrappedNativeScope::TraceWrappedNativesInAllScopes(JSTracer* trc, XPCJSRuntim
}
}
static JSDHashOperator
WrappedNativeSuspecter(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeSuspecter(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNative* wrapper = ((Native2WrappedNativeMap::Entry*)hdr)->value;
@ -366,7 +366,7 @@ WrappedNativeSuspecter(JSDHashTable *table, JSDHashEntryHdr *hdr,
XPCJSRuntime::SuspectWrappedNative(wrapper, *cb);
}
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
static void
@ -447,22 +447,22 @@ XPCWrappedNativeScope::FinishedFinalizationPhaseOfGC()
KillDyingScopes();
}
static JSDHashOperator
WrappedNativeMarker(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeMarker(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number_t, void *arg)
{
((Native2WrappedNativeMap::Entry*)hdr)->value->Mark();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
// We need to explicitly mark all the protos too because some protos may be
// alive in the hashtable but not currently in use by any wrapper
static JSDHashOperator
WrappedNativeProtoMarker(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeProtoMarker(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((ClassInfo2WrappedNativeProtoMap::Entry*)hdr)->value->Mark();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
// static
@ -479,20 +479,20 @@ XPCWrappedNativeScope::MarkAllWrappedNativesAndProtos()
}
#ifdef DEBUG
static JSDHashOperator
ASSERT_WrappedNativeSetNotMarked(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
ASSERT_WrappedNativeSetNotMarked(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((Native2WrappedNativeMap::Entry*)hdr)->value->ASSERT_SetsNotMarked();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
static JSDHashOperator
ASSERT_WrappedNativeProtoSetNotMarked(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
ASSERT_WrappedNativeProtoSetNotMarked(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((ClassInfo2WrappedNativeProtoMap::Entry*)hdr)->value->ASSERT_SetNotMarked();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
// static
@ -507,12 +507,12 @@ XPCWrappedNativeScope::ASSERT_NoInterfaceSetsAreMarked()
}
#endif
static JSDHashOperator
WrappedNativeTearoffSweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeTearoffSweeper(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((Native2WrappedNativeMap::Entry*)hdr)->value->SweepTearOffs();
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
// static
@ -548,8 +548,8 @@ struct ShutdownData
int protoCount;
};
static JSDHashOperator
WrappedNativeShutdownEnumerator(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeShutdownEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
ShutdownData* data = (ShutdownData*) arg;
@ -559,18 +559,18 @@ WrappedNativeShutdownEnumerator(JSDHashTable *table, JSDHashEntryHdr *hdr,
wrapper->SystemIsBeingShutDown();
data->wrapperCount++;
}
return JS_DHASH_REMOVE;
return PL_DHASH_REMOVE;
}
static JSDHashOperator
WrappedNativeProtoShutdownEnumerator(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeProtoShutdownEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
ShutdownData* data = (ShutdownData*) arg;
((ClassInfo2WrappedNativeProtoMap::Entry*)hdr)->value->
SystemIsBeingShutDown();
data->protoCount++;
return JS_DHASH_REMOVE;
return PL_DHASH_REMOVE;
}
//static
@ -636,14 +636,14 @@ XPCWrappedNativeScope::SystemIsBeingShutDown()
/***************************************************************************/
static JSDHashOperator
WNProtoSecPolicyClearer(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WNProtoSecPolicyClearer(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNativeProto* proto =
((ClassInfo2WrappedNativeProtoMap::Entry*)hdr)->value;
*(proto->GetSecurityInfoAddr()) = nullptr;
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
// static
@ -663,8 +663,8 @@ XPCWrappedNativeScope::ClearAllWrappedNativeSecurityPolicies()
return NS_OK;
}
static JSDHashOperator
WNProtoRemover(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WNProtoRemover(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNativeProtoMap* detachedMap = (XPCWrappedNativeProtoMap*)arg;
@ -674,7 +674,7 @@ WNProtoRemover(JSDHashTable *table, JSDHashEntryHdr *hdr,
detachedMap->Add(proto);
return JS_DHASH_REMOVE;
return PL_DHASH_REMOVE;
}
void
@ -714,19 +714,19 @@ XPCWrappedNativeScope::DebugDumpAllScopes(int16_t depth)
}
#ifdef DEBUG
static JSDHashOperator
WrappedNativeMapDumpEnumerator(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeMapDumpEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((Native2WrappedNativeMap::Entry*)hdr)->value->DebugDump(*(int16_t*)arg);
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
static JSDHashOperator
WrappedNativeProtoMapDumpEnumerator(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
WrappedNativeProtoMapDumpEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
((ClassInfo2WrappedNativeProtoMap::Entry*)hdr)->value->DebugDump(*(int16_t*)arg);
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
#endif

6
js/xpconnect/src/nsXPConnect.cpp
Просмотреть файл

@ -725,8 +725,8 @@ nsXPConnect::ReparentWrappedNativeIfFound(JSContext * aJSContext,
ReparentWrapperIfFound(scope, scope2, newParent, aCOMObj);
}
static JSDHashOperator
MoveableWrapperFinder(JSDHashTable *table, JSDHashEntryHdr *hdr,
static PLDHashOperator
MoveableWrapperFinder(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
nsTArray<nsRefPtr<XPCWrappedNative> > *array =
@ -737,7 +737,7 @@ MoveableWrapperFinder(JSDHashTable *table, JSDHashEntryHdr *hdr,
// we don't have to move it.
if (!wn->IsWrapperExpired())
array->AppendElement(wn);
return JS_DHASH_NEXT;
return PL_DHASH_NEXT;
}
/* void rescueOrphansInScope(in JSContextPtr aJSContext, in JSObjectPtr aScope); */

16
js/xpconnect/src/xpcprivate.h
Просмотреть файл

@ -86,8 +86,8 @@
#include <math.h>
#include "xpcpublic.h"
#include "jsapi.h"
#include "jsdhash.h"
#include "jsprf.h"
#include "pldhash.h"
#include "prprf.h"
#include "jsdbgapi.h"
#include "jsfriendapi.h"
@ -816,17 +816,17 @@ public:
#ifdef XPC_CHECK_WRAPPERS_AT_SHUTDOWN
void DEBUG_AddWrappedNative(nsIXPConnectWrappedNative* wrapper)
{XPCAutoLock lock(GetMapLock());
JSDHashEntryHdr *entry =
JS_DHashTableOperate(DEBUG_WrappedNativeHashtable,
wrapper, JS_DHASH_ADD);
if (entry) ((JSDHashEntryStub *)entry)->key = wrapper;}
PLDHashEntryHdr *entry =
PL_DHashTableOperate(DEBUG_WrappedNativeHashtable,
wrapper, PL_DHASH_ADD);
if (entry) ((PLDHashEntryStub *)entry)->key = wrapper;}
void DEBUG_RemoveWrappedNative(nsIXPConnectWrappedNative* wrapper)
{XPCAutoLock lock(GetMapLock());
JS_DHashTableOperate(DEBUG_WrappedNativeHashtable,
wrapper, JS_DHASH_REMOVE);}
PL_DHashTableOperate(DEBUG_WrappedNativeHashtable,
wrapper, PL_DHASH_REMOVE);}
private:
JSDHashTable* DEBUG_WrappedNativeHashtable;
PLDHashTable* DEBUG_WrappedNativeHashtable;
public:
#endif