summaryrefslogtreecommitdiffstats
path: root/js/xpconnect/src/XPCMaps.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /js/xpconnect/src/XPCMaps.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/xpconnect/src/XPCMaps.h')
-rw-r--r--js/xpconnect/src/XPCMaps.h386
1 files changed, 386 insertions, 0 deletions
diff --git a/js/xpconnect/src/XPCMaps.h b/js/xpconnect/src/XPCMaps.h
new file mode 100644
index 0000000000..f1d32ab61c
--- /dev/null
+++ b/js/xpconnect/src/XPCMaps.h
@@ -0,0 +1,386 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Private maps (hashtables). */
+
+#ifndef xpcmaps_h___
+#define xpcmaps_h___
+
+#include "mozilla/AllocPolicy.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/HashTable.h"
+
+#include "js/GCHashTable.h"
+
+/***************************************************************************/
+// default initial sizes for maps (hashtables)
+
+#define XPC_JS_MAP_LENGTH 32
+
+#define XPC_NATIVE_MAP_LENGTH 8
+#define XPC_NATIVE_PROTO_MAP_LENGTH 8
+#define XPC_DYING_NATIVE_PROTO_MAP_LENGTH 8
+#define XPC_NATIVE_INTERFACE_MAP_LENGTH 32
+#define XPC_NATIVE_SET_MAP_LENGTH 32
+#define XPC_WRAPPER_MAP_LENGTH 8
+
+/*************************/
+
+class JSObject2WrappedJSMap {
+ using Map = js::HashMap<JS::Heap<JSObject*>, nsXPCWrappedJS*,
+ js::StableCellHasher<JS::Heap<JSObject*>>,
+ InfallibleAllocPolicy>;
+
+ public:
+ JSObject2WrappedJSMap() = default;
+
+ inline nsXPCWrappedJS* Find(JSObject* Obj) {
+ MOZ_ASSERT(Obj, "bad param");
+ Map::Ptr p = mTable.lookup(Obj);
+ return p ? p->value() : nullptr;
+ }
+
+#ifdef DEBUG
+ inline bool HasWrapper(nsXPCWrappedJS* wrapper) {
+ for (auto iter = mTable.iter(); !iter.done(); iter.next()) {
+ if (iter.get().value() == wrapper) {
+ return true;
+ }
+ }
+ return false;
+ }
+#endif
+
+ inline nsXPCWrappedJS* Add(JSContext* cx, nsXPCWrappedJS* wrapper) {
+ MOZ_ASSERT(wrapper, "bad param");
+ JSObject* obj = wrapper->GetJSObjectPreserveColor();
+ Map::AddPtr p = mTable.lookupForAdd(obj);
+ if (p) {
+ return p->value();
+ }
+ if (!mTable.add(p, obj, wrapper)) {
+ return nullptr;
+ }
+ return wrapper;
+ }
+
+ inline void Remove(nsXPCWrappedJS* wrapper) {
+ MOZ_ASSERT(wrapper, "bad param");
+ mTable.remove(wrapper->GetJSObjectPreserveColor());
+ }
+
+ inline uint32_t Count() { return mTable.count(); }
+
+ inline void Dump(int16_t depth) {
+ for (auto iter = mTable.iter(); !iter.done(); iter.next()) {
+ iter.get().value()->DebugDump(depth);
+ }
+ }
+
+ void UpdateWeakPointersAfterGC(JSTracer* trc);
+
+ void ShutdownMarker();
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+ // Report the sum of SizeOfIncludingThis() for all wrapped JS in the map.
+ // Each wrapped JS is only in one map.
+ size_t SizeOfWrappedJS(mozilla::MallocSizeOf mallocSizeOf) const;
+
+ private:
+ Map mTable{XPC_JS_MAP_LENGTH};
+};
+
+/*************************/
+
+class Native2WrappedNativeMap {
+ using Map = mozilla::HashMap<nsISupports*, XPCWrappedNative*,
+ mozilla::DefaultHasher<nsISupports*>,
+ mozilla::MallocAllocPolicy>;
+
+ public:
+ Native2WrappedNativeMap();
+
+ XPCWrappedNative* Find(nsISupports* obj) const {
+ MOZ_ASSERT(obj, "bad param");
+ Map::Ptr ptr = mMap.lookup(obj);
+ return ptr ? ptr->value() : nullptr;
+ }
+
+ XPCWrappedNative* Add(XPCWrappedNative* wrapper) {
+ MOZ_ASSERT(wrapper, "bad param");
+ nsISupports* obj = wrapper->GetIdentityObject();
+ Map::AddPtr ptr = mMap.lookupForAdd(obj);
+ MOZ_ASSERT(!ptr, "wrapper already in new scope!");
+ if (ptr) {
+ return ptr->value();
+ }
+ if (!mMap.add(ptr, obj, wrapper)) {
+ return nullptr;
+ }
+ return wrapper;
+ }
+
+ void Clear() { mMap.clear(); }
+
+ uint32_t Count() { return mMap.count(); }
+
+ Map::Iterator Iter() { return mMap.iter(); }
+ Map::ModIterator ModIter() { return mMap.modIter(); }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+ private:
+ Map mMap;
+};
+
+/*************************/
+
+struct IIDHasher {
+ using Key = const nsIID*;
+ using Lookup = Key;
+
+ // Note this is returning the hash of the bit pattern of the first part of the
+ // nsID, not the hash of the pointer to the nsID.
+ static mozilla::HashNumber hash(Lookup lookup) {
+ uintptr_t v;
+ memcpy(&v, lookup, sizeof(v));
+ return mozilla::HashGeneric(v);
+ }
+
+ static bool match(Key key, Lookup lookup) { return key->Equals(*lookup); }
+};
+
+class IID2NativeInterfaceMap {
+ using Map = mozilla::HashMap<const nsIID*, XPCNativeInterface*, IIDHasher,
+ mozilla::MallocAllocPolicy>;
+
+ public:
+ IID2NativeInterfaceMap();
+
+ XPCNativeInterface* Find(REFNSIID iid) const {
+ Map::Ptr ptr = mMap.lookup(&iid);
+ return ptr ? ptr->value() : nullptr;
+ }
+
+ bool AddNew(XPCNativeInterface* iface) {
+ MOZ_ASSERT(iface, "bad param");
+ const nsIID* iid = iface->GetIID();
+ return mMap.putNew(iid, iface);
+ }
+
+ void Remove(XPCNativeInterface* iface) {
+ MOZ_ASSERT(iface, "bad param");
+ mMap.remove(iface->GetIID());
+ }
+
+ uint32_t Count() { return mMap.count(); }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+ void Trace(JSTracer* trc);
+
+ private:
+ Map mMap;
+};
+
+/*************************/
+
+class ClassInfo2NativeSetMap {
+ using Map = mozilla::HashMap<nsIClassInfo*, RefPtr<XPCNativeSet>,
+ mozilla::DefaultHasher<nsIClassInfo*>,
+ mozilla::MallocAllocPolicy>;
+
+ public:
+ ClassInfo2NativeSetMap();
+
+ XPCNativeSet* Find(nsIClassInfo* info) const {
+ auto ptr = mMap.lookup(info);
+ return ptr ? ptr->value().get() : nullptr;
+ }
+
+ XPCNativeSet* Add(nsIClassInfo* info, XPCNativeSet* set) {
+ MOZ_ASSERT(info, "bad param");
+ auto ptr = mMap.lookupForAdd(info);
+ if (ptr) {
+ return ptr->value();
+ }
+ if (!mMap.add(ptr, info, set)) {
+ return nullptr;
+ }
+ return set;
+ }
+
+ void Remove(nsIClassInfo* info) {
+ MOZ_ASSERT(info, "bad param");
+ mMap.remove(info);
+ }
+
+ uint32_t Count() { return mMap.count(); }
+
+ // ClassInfo2NativeSetMap holds pointers to *some* XPCNativeSets.
+ // So we don't want to count those XPCNativeSets, because they are better
+ // counted elsewhere (i.e. in XPCJSContext::mNativeSetMap, which holds
+ // pointers to *all* XPCNativeSets). Hence the "Shallow".
+ size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
+
+ private:
+ Map mMap;
+};
+
+/*************************/
+
+class ClassInfo2WrappedNativeProtoMap {
+ using Map = mozilla::HashMap<nsIClassInfo*, XPCWrappedNativeProto*,
+ mozilla::DefaultHasher<nsIClassInfo*>,
+ mozilla::MallocAllocPolicy>;
+
+ public:
+ ClassInfo2WrappedNativeProtoMap();
+
+ XPCWrappedNativeProto* Find(nsIClassInfo* info) const {
+ auto ptr = mMap.lookup(info);
+ return ptr ? ptr->value() : nullptr;
+ }
+
+ XPCWrappedNativeProto* Add(nsIClassInfo* info, XPCWrappedNativeProto* proto) {
+ MOZ_ASSERT(info, "bad param");
+ auto ptr = mMap.lookupForAdd(info);
+ if (ptr) {
+ return ptr->value();
+ }
+ if (!mMap.add(ptr, info, proto)) {
+ return nullptr;
+ }
+ return proto;
+ }
+
+ void Clear() { mMap.clear(); }
+
+ uint32_t Count() { return mMap.count(); }
+
+ Map::Iterator Iter() { return mMap.iter(); }
+ Map::ModIterator ModIter() { return mMap.modIter(); }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+ private:
+ Map mMap;
+};
+
+/*************************/
+
+struct NativeSetHasher {
+ using Key = XPCNativeSet*;
+ using Lookup = const XPCNativeSetKey*;
+
+ static mozilla::HashNumber hash(Lookup lookup) { return lookup->Hash(); }
+ static bool match(Key key, Lookup lookup);
+};
+
+class NativeSetMap {
+ using Set = mozilla::HashSet<XPCNativeSet*, NativeSetHasher,
+ mozilla::MallocAllocPolicy>;
+
+ public:
+ NativeSetMap();
+
+ XPCNativeSet* Find(const XPCNativeSetKey* key) const {
+ auto ptr = mSet.lookup(key);
+ return ptr ? *ptr : nullptr;
+ }
+
+ XPCNativeSet* Add(const XPCNativeSetKey* key, XPCNativeSet* set) {
+ MOZ_ASSERT(key, "bad param");
+ MOZ_ASSERT(set, "bad param");
+ auto ptr = mSet.lookupForAdd(key);
+ if (ptr) {
+ return *ptr;
+ }
+ if (!mSet.add(ptr, set)) {
+ return nullptr;
+ }
+ return set;
+ }
+
+ bool AddNew(const XPCNativeSetKey* key, XPCNativeSet* set) {
+ XPCNativeSet* set2 = Add(key, set);
+ if (!set2) {
+ return false;
+ }
+#ifdef DEBUG
+ XPCNativeSetKey key2(set);
+ MOZ_ASSERT(key->Hash() == key2.Hash());
+ MOZ_ASSERT(set2 == set, "Should not have found an existing entry");
+#endif
+ return true;
+ }
+
+ void Remove(XPCNativeSet* set) {
+ MOZ_ASSERT(set, "bad param");
+
+ XPCNativeSetKey key(set);
+ mSet.remove(&key);
+ }
+
+ uint32_t Count() { return mSet.count(); }
+
+ Set::Iterator Iter() { return mSet.iter(); }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+ private:
+ Set mSet;
+};
+
+/***************************************************************************/
+
+class JSObject2JSObjectMap {
+ using Map = JS::GCHashMap<JS::Heap<JSObject*>, JS::Heap<JSObject*>,
+ js::StableCellHasher<JS::Heap<JSObject*>>,
+ js::SystemAllocPolicy>;
+
+ public:
+ JSObject2JSObjectMap() = default;
+
+ inline JSObject* Find(JSObject* key) {
+ MOZ_ASSERT(key, "bad param");
+ if (Map::Ptr p = mTable.lookup(key)) {
+ return p->value();
+ }
+ return nullptr;
+ }
+
+ /* Note: If the entry already exists, return the old value. */
+ inline JSObject* Add(JSContext* cx, JSObject* key, JSObject* value) {
+ MOZ_ASSERT(key, "bad param");
+ Map::AddPtr p = mTable.lookupForAdd(key);
+ if (p) {
+ JSObject* oldValue = p->value();
+ p->value() = value;
+ return oldValue;
+ }
+ if (!mTable.add(p, key, value)) {
+ return nullptr;
+ }
+ MOZ_ASSERT(xpc::ObjectScope(key)->mWaiverWrapperMap == this);
+ return value;
+ }
+
+ inline void Remove(JSObject* key) {
+ MOZ_ASSERT(key, "bad param");
+ mTable.remove(key);
+ }
+
+ inline uint32_t Count() { return mTable.count(); }
+
+ void UpdateWeakPointers(JSTracer* trc) { mTable.traceWeak(trc); }
+
+ private:
+ Map mTable{XPC_WRAPPER_MAP_LENGTH};
+};
+
+#endif /* xpcmaps_h___ */