Bug 1681469 - Allow nsBaseHashtable to work with a non-default-constructible/non-movable DataType; r=nika

nsBaseHashtable now supports non-default-constructible DataType and
UserDataType, however not all methods can be instantiated.  All methods which
can't be instantiated with non-default-constructible DataType or UserDataType
are now described as such in method definitions.

The public API of PLDHashTable and nsBaseHashtable/nsDataHashtable was changed:
- A new method PLDHashTable::WithEntryHandle has been added. It allows to use a
  custom function for entry initialization (instead of the global hook).
- A new method nsBaseHashtable::MaybeGet has been added.
- A new overload nsBaseHashtable::Remove has been added.
- The nsDataHashtable::GetAndRemove method has been pulled up to
  nsBaseHashtable.

In addition, the following implementation details have changed:

PLDHashTable:
- The code from the Add method has been split into MakeEntryHandle and a helper
  object called EntryHandle. The Add method is now implemented on top of that.

nsTHashtable:
- A new (non-public) API for WithEntryHandle has been added.
- The InitEntry hook is no longer used. Instead of using the hook, PutEntry
  methods now use nsTHashtable::WithEntryHandle instead of PLDHashTable::Add.
  This change allows to do custom initialization in derived classes.

nsBaseHashtable:
- A new (non-public) API for WithEntryHandle has been added.
- Put methods no longer use nsTHashtable::PutEntry, they now use the new method
  nsBaseHashtable::WithEntryHandle.

Differential Revision: https://phabricator.services.mozilla.com/D99428

Author: janvarga

xpcom/ds/PLDHashTable.cpp

@@ -500,86 +500,24 @@ PLDHashEntryHdr* PLDHashTable::Search(const void* aKey) const {
 }
 
 PLDHashEntryHdr* PLDHashTable::Add(const void* aKey,
-                                   const mozilla::fallible_t&) {
-#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
-  AutoWriteOp op(mChecker);
-#endif
-
-  // Allocate the entry storage if it hasn't already been allocated.
-  if (!mEntryStore.IsAllocated()) {
-    uint32_t nbytes;
-    // We already checked this in the constructor, so it must still be true.
-    MOZ_RELEASE_ASSERT(
-        SizeOfEntryStore(CapacityFromHashShift(), mEntrySize, &nbytes));
-    mEntryStore.Set((char*)calloc(1, nbytes), &mGeneration);
-    if (!mEntryStore.IsAllocated()) {
-      return nullptr;
-    }
-  }
-
-  // If alpha is >= .75, grow or compress the table. If aKey is already in the
-  // table, we may grow once more than necessary, but only if we are on the
-  // edge of being overloaded.
-  uint32_t capacity = Capacity();
-  if (mEntryCount + mRemovedCount >= MaxLoad(capacity)) {
-    // Compress if a quarter or more of all entries are removed.
-    int deltaLog2;
-    if (mRemovedCount >= capacity >> 2) {
-      deltaLog2 = 0;
-    } else {
-      deltaLog2 = 1;
-    }
-
-    // Grow or compress the table. If ChangeTable() fails, allow overloading up
-    // to the secondary max. Once we hit the secondary max, return null.
-    if (!ChangeTable(deltaLog2) &&
-        mEntryCount + mRemovedCount >= MaxLoadOnGrowthFailure(capacity)) {
-      return nullptr;
-    }
+                                   const mozilla::fallible_t& aFallible) {
+  auto maybeEntryHandle = MakeEntryHandle(aKey, aFallible);
+  if (!maybeEntryHandle) {
+    return nullptr;
   }
-
-  // Look for entry after possibly growing, so we don't have to add it,
-  // then skip it while growing the table and re-add it after.
-  PLDHashNumber keyHash = ComputeKeyHash(aKey);
-  Slot slot = SearchTable<ForAdd>(
-      aKey, keyHash, [&](Slot& found) -> Slot { return found; },
-      [&]() -> Slot {
-        MOZ_CRASH("Nope");
-        return Slot(nullptr, nullptr);
-      });
-  if (!slot.IsLive()) {
-    // Initialize the slot, indicating that it's no longer free.
-    if (slot.IsRemoved()) {
-      mRemovedCount--;
-      keyHash |= kCollisionFlag;
-    }
+  return maybeEntryHandle->OrInsert([&aKey, this](PLDHashEntryHdr* entry) {
     if (mOps->initEntry) {
-      mOps->initEntry(slot.ToEntry(), aKey);
+      mOps->initEntry(entry, aKey);
     }
-    slot.SetKeyHash(keyHash);
-    mEntryCount++;
-  }
-
-  return slot.ToEntry();
+  });
 }
 
 PLDHashEntryHdr* PLDHashTable::Add(const void* aKey) {
-  PLDHashEntryHdr* entry = Add(aKey, fallible);
-  if (!entry) {
-    if (!mEntryStore.IsAllocated()) {
-      // We OOM'd while allocating the initial entry storage.
-      uint32_t nbytes;
-      (void)SizeOfEntryStore(CapacityFromHashShift(), mEntrySize, &nbytes);
-      NS_ABORT_OOM(nbytes);
-    } else {
-      // We failed to resize the existing entry storage, either due to OOM or
-      // because we exceeded the maximum table capacity or size; report it as
-      // an OOM. The multiplication by 2 gets us the size we tried to allocate,
-      // which is double the current size.
-      NS_ABORT_OOM(2 * EntrySize() * EntryCount());
+  return MakeEntryHandle(aKey).OrInsert([&aKey, this](PLDHashEntryHdr* entry) {
+    if (mOps->initEntry) {
+      mOps->initEntry(entry, aKey);
     }
-  }
-  return entry;
+  });
 }
 
 void PLDHashTable::Remove(const void* aKey) {
@@ -671,6 +609,129 @@ size_t PLDHashTable::ShallowSizeOfIncludingThis(
   return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
 }
 
+mozilla::Maybe<PLDHashTable::EntryHandle> PLDHashTable::MakeEntryHandle(
+    const void* aKey, const mozilla::fallible_t&) {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+  mChecker.StartWriteOp();
+  auto endWriteOp = MakeScopeExit([&] { mChecker.EndWriteOp(); });
+#endif
+
+  // Allocate the entry storage if it hasn't already been allocated.
+  if (!mEntryStore.IsAllocated()) {
+    uint32_t nbytes;
+    // We already checked this in the constructor, so it must still be true.
+    MOZ_RELEASE_ASSERT(
+        SizeOfEntryStore(CapacityFromHashShift(), mEntrySize, &nbytes));
+    mEntryStore.Set((char*)calloc(1, nbytes), &mGeneration);
+    if (!mEntryStore.IsAllocated()) {
+      return Nothing();
+    }
+  }
+
+  // If alpha is >= .75, grow or compress the table. If aKey is already in the
+  // table, we may grow once more than necessary, but only if we are on the
+  // edge of being overloaded.
+  uint32_t capacity = Capacity();
+  if (mEntryCount + mRemovedCount >= MaxLoad(capacity)) {
+    // Compress if a quarter or more of all entries are removed.
+    int deltaLog2 = 1;
+    if (mRemovedCount >= capacity >> 2) {
+      deltaLog2 = 0;
+    }
+
+    // Grow or compress the table. If ChangeTable() fails, allow overloading up
+    // to the secondary max. Once we hit the secondary max, return null.
+    if (!ChangeTable(deltaLog2) &&
+        mEntryCount + mRemovedCount >= MaxLoadOnGrowthFailure(capacity)) {
+      return Nothing();
+    }
+  }
+
+  // Look for entry after possibly growing, so we don't have to add it,
+  // then skip it while growing the table and re-add it after.
+  PLDHashNumber keyHash = ComputeKeyHash(aKey);
+  Slot slot = SearchTable<ForAdd>(
+      aKey, keyHash, [](Slot& found) -> Slot { return found; },
+      []() -> Slot {
+        MOZ_CRASH("Nope");
+        return Slot(nullptr, nullptr);
+      });
+
+  // The `EntryHandle` will handle ending the write op when it is destroyed.
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+  endWriteOp.release();
+#endif
+
+  return Some(EntryHandle{this, keyHash, slot});
+}
+
+PLDHashTable::EntryHandle PLDHashTable::MakeEntryHandle(const void* aKey) {
+  auto res = MakeEntryHandle(aKey, fallible);
+  if (!res) {
+    if (!mEntryStore.IsAllocated()) {
+      // We OOM'd while allocating the initial entry storage.
+      uint32_t nbytes;
+      (void)SizeOfEntryStore(CapacityFromHashShift(), mEntrySize, &nbytes);
+      NS_ABORT_OOM(nbytes);
+    } else {
+      // We failed to resize the existing entry storage, either due to OOM or
+      // because we exceeded the maximum table capacity or size; report it as
+      // an OOM. The multiplication by 2 gets us the size we tried to allocate,
+      // which is double the current size.
+      NS_ABORT_OOM(2 * EntrySize() * EntryCount());
+    }
+  }
+  return res.extract();
+}
+
+PLDHashTable::EntryHandle::EntryHandle(PLDHashTable* aTable,
+                                       PLDHashNumber aKeyHash, Slot aSlot)
+    : mTable(aTable), mKeyHash(aKeyHash), mSlot(aSlot) {}
+
+PLDHashTable::EntryHandle::EntryHandle(EntryHandle&& aOther) noexcept
+    : mTable(std::exchange(aOther.mTable, nullptr)),
+      mKeyHash(aOther.mKeyHash),
+      mSlot(aOther.mSlot) {}
+
+PLDHashTable::EntryHandle::~EntryHandle() {
+  if (!mTable) {
+    return;
+  }
+
+  // If our slot is empty when this `EntryHandle` is destroyed, we may want to
+  // resize our table, as we just removed an entry.
+  if (!HasEntry()) {
+    mTable->ShrinkIfAppropriate();
+  }
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+  mTable->mChecker.EndWriteOp();
+#endif
+}
+
+void PLDHashTable::EntryHandle::Remove() {
+  MOZ_ASSERT(HasEntry());
+
+  mTable->RawRemove(mSlot);
+}
+
+void PLDHashTable::EntryHandle::OrRemove() {
+  if (HasEntry()) {
+    Remove();
+  }
+}
+
+void PLDHashTable::EntryHandle::OccupySlot() {
+  MOZ_ASSERT(!HasEntry());
+
+  PLDHashNumber keyHash = mKeyHash;
+  if (mSlot.IsRemoved()) {
+    mTable->mRemovedCount--;
+    keyHash |= kCollisionFlag;
+  }
+  mSlot.SetKeyHash(keyHash);
+  mTable->mEntryCount++;
+}
+
 PLDHashTable::Iterator::Iterator(Iterator&& aOther)
     : mTable(aOther.mTable),
       mCurrent(aOther.mCurrent),

xpcom/ds/PLDHashTable.h

@@ -15,6 +15,7 @@
 #include "mozilla/Assertions.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/HashFunctions.h"
+#include "mozilla/Maybe.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/fallible.h"
 #include "nscore.h"
@@ -528,6 +529,74 @@ class PLDHashTable {
   static PLDHashNumber HashStringKey(const void* aKey);
   static bool MatchStringKey(const PLDHashEntryHdr* aEntry, const void* aKey);
 
+  class EntryHandle {
+   public:
+    EntryHandle(EntryHandle&& aOther) noexcept;
+    ~EntryHandle();
+
+    EntryHandle(const EntryHandle&) = delete;
+    EntryHandle& operator=(const EntryHandle&) = delete;
+    EntryHandle& operator=(EntryHandle&& aOther) = delete;
+
+    // Is this slot currently occupied?
+    bool HasEntry() const { return mSlot.IsLive(); }
+
+    explicit operator bool() const { return HasEntry(); }
+
+    // Get the entry stored in this slot. May not be called unless the slot is
+    // currently occupied.
+    PLDHashEntryHdr* Entry() {
+      MOZ_ASSERT(HasEntry());
+      return mSlot.ToEntry();
+    }
+
+    template <class F>
+    void Insert(F&& aInitEntry) {
+      MOZ_ASSERT(!HasEntry());
+      OccupySlot();
+      std::forward<F>(aInitEntry)(Entry());
+    }
+
+    // If the slot is currently vacant, the slot is occupied and `initEntry` is
+    // invoked to initialize the entry. Returns the entry stored in now-occupied
+    // slot.
+    template <class F>
+    PLDHashEntryHdr* OrInsert(F&& aInitEntry) {
+      if (!HasEntry()) {
+        Insert(std::forward<F>(aInitEntry));
+      }
+      return Entry();
+    }
+
+    void Remove();
+
+    void OrRemove();
+
+   private:
+    friend class PLDHashTable;
+
+    EntryHandle(PLDHashTable* aTable, PLDHashNumber aKeyHash, Slot aSlot);
+
+    void OccupySlot();
+
+    PLDHashTable* mTable;
+    PLDHashNumber mKeyHash;
+    Slot mSlot;
+  };
+
+  template <class F>
+  auto WithEntryHandle(const void* aKey, F&& aFunc)
+      -> std::invoke_result_t<F, EntryHandle&&> {
+    return std::forward<F>(aFunc)(MakeEntryHandle(aKey));
+  }
+
+  template <class F>
+  auto WithEntryHandle(const void* aKey, const mozilla::fallible_t& aFallible,
+                       F&& aFunc)
+      -> std::invoke_result_t<F, mozilla::Maybe<EntryHandle>&&> {
+    return std::forward<F>(aFunc)(MakeEntryHandle(aKey, aFallible));
+  }
+
   // This is an iterator for PLDHashtable. Assertions will detect some, but not
   // all, mid-iteration table modifications that might invalidate (e.g.
   // reallocate) the entry storage.
@@ -650,6 +719,11 @@ class PLDHashTable {
   void RawRemove(Slot& aSlot);
   void ShrinkIfAppropriate();
 
+  mozilla::Maybe<EntryHandle> MakeEntryHandle(const void* aKey,
+                                              const mozilla::fallible_t&);
+
+  EntryHandle MakeEntryHandle(const void* aKey);
+
   PLDHashTable(const PLDHashTable& aOther) = delete;
   PLDHashTable& operator=(const PLDHashTable& aOther) = delete;
 };