diff --git a/js/xpconnect/src/XPCJSRuntime.cpp b/js/xpconnect/src/XPCJSRuntime.cpp
index 780aaa1820a1..b54e3a3ead20 100644
--- a/js/xpconnect/src/XPCJSRuntime.cpp
+++ b/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
 
diff --git a/js/xpconnect/src/XPCMaps.cpp b/js/xpconnect/src/XPCMaps.cpp
index c0dd0486909e..963c9960ef60 100644
--- a/js/xpconnect/src/XPCMaps.cpp
+++ b/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);
 }
 
 /***************************************************************************/
diff --git a/js/xpconnect/src/XPCMaps.h b/js/xpconnect/src/XPCMaps.h
index 4028e1a3fdd7..168acaec67c2 100644
--- a/js/xpconnect/src/XPCMaps.h
+++ b/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;
 };
 
 /***************************************************************************/
diff --git a/js/xpconnect/src/XPCWrappedNativeScope.cpp b/js/xpconnect/src/XPCWrappedNativeScope.cpp
index 4160c5c65fd1..d477f3049c69 100644
--- a/js/xpconnect/src/XPCWrappedNativeScope.cpp
+++ b/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
 
diff --git a/js/xpconnect/src/nsXPConnect.cpp b/js/xpconnect/src/nsXPConnect.cpp
index 352c443833f7..27d454e418d4 100644
--- a/js/xpconnect/src/nsXPConnect.cpp
+++ b/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); */
diff --git a/js/xpconnect/src/xpcprivate.h b/js/xpconnect/src/xpcprivate.h
index a407eb9e8eb8..3fb6172f90ee 100644
--- a/js/xpconnect/src/xpcprivate.h
+++ b/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