Bug 1688833 - Migrate LookupForAdd to WithEntryHandle in dom/base. r=smaug

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

dom/base/CustomElementRegistry.cpp

@@ -1105,14 +1105,12 @@ already_AddRefed<Promise> CustomElementRegistry::WhenDefined(
     return promise.forget();
   }
 
-  auto entry = mWhenDefinedPromiseMap.LookupForAdd(nameAtom);
+  return mWhenDefinedPromiseMap
-  if (entry) {
+      .WithEntryHandle(nameAtom,
-    promise = entry.Data();
+                       [&promise](auto&& entry) -> RefPtr<Promise> {
-  } else {
+                         return entry.OrInsert(std::move(promise));
-    entry.OrInsert([&promise]() { return promise; });
+                       })
-  }
+      .forget();
-
-  return promise.forget();
 }
 
 namespace {

dom/base/Document.cpp

@@ -11827,11 +11827,17 @@ void Document::MaybePreconnect(nsIURI* aOrigURI, mozilla::CORSMode aCORSMode) {
     return;
   }
 
-  auto entry = mPreloadedPreconnects.LookupForAdd(uri);
+  const bool existingEntryFound =
-  if (entry) {
+      mPreloadedPreconnects.WithEntryHandle(uri, [](auto&& entry) {
-    return;  // we found an existing entry
+        if (entry) {
+          return true;
+        }
+        entry.Insert(true);
+        return false;
+      });
+  if (existingEntryFound) {
+    return;
   }
-  entry.OrInsert([]() { return true; });
 
   nsCOMPtr<nsISpeculativeConnect> speculator(
       do_QueryInterface(nsContentUtils::GetIOService()));

dom/base/Document.h

@@ -1633,9 +1633,13 @@ class Document : public nsINode,
     // If we have an entry and the selector list returned has a null
     // RawServoSelectorList*, that indicates that aSelector has already been
     // parsed and is not a syntactically valid selector.
-    Table::EntryPtr GetList(const nsACString& aSelector) {
+    template <typename F>
+    RawServoSelectorList* GetListOrInsertFrom(const nsACString& aSelector,
+                                              F&& aFrom) {
       MOZ_ASSERT(NS_IsMainThread());
-      return mTable.LookupForAdd(aSelector);
+      return mTable.WithEntryHandle(aSelector, [&aFrom](auto&& entry) {
+        return entry.OrInsertWith(std::forward<F>(aFrom)).get();
+      });
     }
 
     ~SelectorCache();

dom/base/DocumentOrShadowRoot.cpp

@@ -218,8 +218,11 @@ void DocumentOrShadowRoot::CloneAdoptedSheetsFrom(
   MOZ_ASSERT(clonedSheetMap);
 
   for (const StyleSheet* sheet : aSource.mAdoptedStyleSheets) {
-    RefPtr<StyleSheet> clone = clonedSheetMap->LookupForAdd(sheet).OrInsert(
+    RefPtr<StyleSheet> clone = clonedSheetMap->WithEntryHandle(
-        [&] { return sheet->CloneAdoptedSheet(ownerDoc); });
+        sheet, [&sheet, &ownerDoc](auto&& entry) {
+          return entry.OrInsertWith(
+              [&] { return sheet->CloneAdoptedSheet(ownerDoc); });
+        });
     MOZ_ASSERT(clone);
     MOZ_DIAGNOSTIC_ASSERT(clone->ConstructorDocumentMatches(ownerDoc));
     DebugOnly<bool> succeeded = list.AppendElement(std::move(clone), fallible);
@@ -752,9 +755,9 @@ nsRadioGroupStruct* DocumentOrShadowRoot::GetRadioGroup(
 
 nsRadioGroupStruct* DocumentOrShadowRoot::GetOrCreateRadioGroup(
     const nsAString& aName) {
-  return mRadioGroups.LookupForAdd(aName)
+  return mRadioGroups.WithEntryHandle(aName, [](auto&& entry) {
-      .OrInsert([]() { return new nsRadioGroupStruct(); })
+    return entry.OrInsertWith([] { return new nsRadioGroupStruct(); }).get();
-      .get();
+  });
 }
 
 int32_t DocumentOrShadowRoot::StyleOrderIndexOfSheet(

dom/base/Element.cpp

@@ -3954,13 +3954,13 @@ void Element::RegisterIntersectionObserver(DOMIntersectionObserver* aObserver) {
     return;
   }
 
-  observers->LookupForAdd(aObserver).OrInsert([]() {
+  observers->WithEntryHandle(aObserver, [](auto&& entry) {
     // Value can be:
     //   -2:   Makes sure next calculated threshold always differs, leading to a
     //         notification task being scheduled.
     //   -1:   Non-intersecting.
     //   >= 0: Intersecting, valid index of aObserver->mThresholds.
-    return eUninitialized;
+    entry.OrInsert(eUninitialized);
   });
 }
 

dom/base/ImageTracker.cpp

@@ -23,28 +23,31 @@ ImageTracker::~ImageTracker() { SetLockingState(false); }
 nsresult ImageTracker::Add(imgIRequest* aImage) {
   MOZ_ASSERT(aImage);
 
-  nsresult rv = NS_OK;
+  const nsresult rv = mImages.WithEntryHandle(aImage, [&](auto&& entry) {
-  auto entry = mImages.LookupForAdd(aImage);
+    nsresult rv = NS_OK;
-  if (entry) {
+    if (entry) {
-    // The image is already in the hashtable.  Increment its count.
+      // The image is already in the hashtable.  Increment its count.
-    uint32_t oldCount = entry.Data();
+      uint32_t oldCount = entry.Data();
-    MOZ_ASSERT(oldCount > 0, "Entry in the image tracker with count 0!");
+      MOZ_ASSERT(oldCount > 0, "Entry in the image tracker with count 0!");
-    entry.Data() = oldCount + 1;
+      entry.Data() = oldCount + 1;
-  } else {
+    } else {
-    // A new entry was inserted - set the count to 1.
+      // A new entry was inserted - set the count to 1.
-    entry.OrInsert([]() { return 1; });
+      entry.Insert(1);
 
-    // If we're locking images, lock this image too.
+      // If we're locking images, lock this image too.
-    if (mLocking) {
+      if (mLocking) {
-      rv = aImage->LockImage();
+        rv = aImage->LockImage();
+      }
+
+      // If we're animating images, request that this image be animated too.
+      if (mAnimating) {
+        nsresult rv2 = aImage->IncrementAnimationConsumers();
+        rv = NS_SUCCEEDED(rv) ? rv2 : rv;
+      }
     }
 
-    // If we're animating images, request that this image be animated too.
+    return rv;
-    if (mAnimating) {
+  });
-      nsresult rv2 = aImage->IncrementAnimationConsumers();
-      rv = NS_SUCCEEDED(rv) ? rv2 : rv;
-    }
-  }
 
   return rv;
 }

dom/base/ResizeObserver.cpp

@@ -150,8 +150,10 @@ void ResizeObserver::Observe(Element& aTarget,
     mDocument->AddResizeObserver(*this);
   }
 
-  RefPtr<ResizeObservation>& observation =
+  auto& observation = mObservationMap.WithEntryHandle(
-      mObservationMap.LookupForAdd(&aTarget).OrInsert([] { return nullptr; });
+      &aTarget, [](auto&& entry) -> RefPtr<ResizeObservation>& {
+        return entry.OrInsert(nullptr);
+      });
   if (observation) {
     if (observation->BoxOptions() == aOptions.mBox) {
       // Already observed this target and the observed box is the same, so

dom/base/nsDOMMutationObserver.cpp

@@ -319,11 +319,15 @@ void nsMutationReceiver::ContentRemoved(nsIContent* aChild,
     if (Observer()->GetReceiverFor(aChild, false, false) != orig) {
       bool transientExists = false;
       bool isNewEntry = false;
-      const auto& transientReceivers =
+      auto* const transientReceivers =
-          Observer()->mTransientReceivers.LookupForAdd(aChild).OrInsert(
+          Observer()->mTransientReceivers.WithEntryHandle(
-              [&isNewEntry]() {
+              aChild, [&isNewEntry](auto&& entry) {
-                isNewEntry = true;
+                return entry
-                return new nsCOMArray<nsMutationReceiver>();
+                    .OrInsertWith([&isNewEntry] {
+                      isNewEntry = true;
+                      return new nsCOMArray<nsMutationReceiver>();
+                    })
+                    .get();
               });
       if (!isNewEntry) {
         for (int32_t i = 0; i < transientReceivers->Count(); ++i) {
@@ -1034,9 +1038,13 @@ void nsAutoMutationBatch::Done() {
       }
 
       if (allObservers.Length()) {
-        const auto& transientReceivers =
+        auto* const transientReceivers =
-            ob->mTransientReceivers.LookupForAdd(removed).OrInsert(
+            ob->mTransientReceivers.WithEntryHandle(removed, [](auto&& entry) {
-                []() { return new nsCOMArray<nsMutationReceiver>(); });
+              return entry
+                  .OrInsertWith(
+                      [] { return new nsCOMArray<nsMutationReceiver>(); })
+                  .get();
+            });
         for (uint32_t k = 0; k < allObservers.Length(); ++k) {
           nsMutationReceiver* r = allObservers[k];
           nsMutationReceiver* orig = r->GetParent() ? r->GetParent() : r;

dom/base/nsFrameMessageManager.cpp

@@ -239,9 +239,14 @@ void nsFrameMessageManager::AddMessageListener(const nsAString& aMessageName,
                                                MessageListener& aListener,
                                                bool aListenWhenClosed,
                                                ErrorResult& aError) {
-  auto& listeners = mListeners.LookupForAdd(aMessageName).OrInsert([]() {
+  auto* const listeners =
-    return new nsAutoTObserverArray<nsMessageListenerInfo, 1>();
+      mListeners.WithEntryHandle(aMessageName, [](auto&& entry) {
-  });
+        return entry
+            .OrInsertWith([] {
+              return new nsAutoTObserverArray<nsMessageListenerInfo, 1>();
+            })
+            .get();
+      });
   uint32_t len = listeners->Length();
   for (uint32_t i = 0; i < len; ++i) {
     MessageListener* strongListener = listeners->ElementAt(i).mStrongListener;
@@ -308,9 +313,14 @@ void nsFrameMessageManager::AddWeakMessageListener(
   }
 #endif
 
-  auto& listeners = mListeners.LookupForAdd(aMessageName).OrInsert([]() {
+  auto* const listeners =
-    return new nsAutoTObserverArray<nsMessageListenerInfo, 1>();
+      mListeners.WithEntryHandle(aMessageName, [](auto&& entry) {
-  });
+        return entry
+            .OrInsertWith([] {
+              return new nsAutoTObserverArray<nsMessageListenerInfo, 1>();
+            })
+            .get();
+      });
   uint32_t len = listeners->Length();
   for (uint32_t i = 0; i < len; ++i) {
     if (listeners->ElementAt(i).mWeakListener == weak) {

dom/base/nsGlobalWindowInner.cpp

@@ -7151,10 +7151,13 @@ ChromeMessageBroadcaster* nsGlobalWindowInner::GetGroupMessageManager(
     const nsAString& aGroup) {
   MOZ_ASSERT(IsChromeWindow());
 
-  RefPtr<ChromeMessageBroadcaster> messageManager =
+  return mChromeFields.mGroupMessageManagers.WithEntryHandle(
-      mChromeFields.mGroupMessageManagers.LookupForAdd(aGroup).OrInsert(
+      aGroup, [&](auto&& entry) {
-          [this]() { return new ChromeMessageBroadcaster(MessageManager()); });
+        return entry
-  return messageManager;
+            .OrInsertWith(
+                [&] { return new ChromeMessageBroadcaster(MessageManager()); })
+            .get();
+      });
 }
 
 void nsGlobalWindowInner::InitWasOffline() { mWasOffline = NS_IsOffline(); }

dom/base/nsINode.cpp

@@ -2859,14 +2859,11 @@ const RawServoSelectorList* nsINode::ParseSelectorList(
   Document* doc = OwnerDoc();
 
   Document::SelectorCache& cache = doc->GetSelectorCache();
-  RawServoSelectorList* list =
+  RawServoSelectorList* list = cache.GetListOrInsertFrom(aSelectorString, [&] {
-      cache.GetList(aSelectorString)
+    // Note that we want to cache even if null was returned, because we
-          .OrInsert([&] {
+    // want to cache the "This is not a valid selector" result.
-            // Note that we want to cache even if null was returned, because we
+    return Servo_SelectorList_Parse(&aSelectorString).Consume();
-            // want to cache the "This is not a valid selector" result.
+  });
-            return Servo_SelectorList_Parse(&aSelectorString).Consume();
-          })
-          .get();
 
   if (!list) {
     // Invalid selector.