Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 392 insertions, 0 deletions

diff --git a/dom/base/PlacesObservers.cpp b/dom/base/PlacesObservers.cpp
new file mode 100644
index 0000000000..bb92e4a072
--- /dev/null
+++ b/dom/base/PlacesObservers.cpp
@@ -0,0 +1,392 @@
+/* -*- 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/. */
+
+#include "PlacesObservers.h"
+
+#include "PlacesWeakCallbackWrapper.h"
+#include "nsIWeakReferenceUtils.h"
+#include "nsIXPConnect.h"
+#include "mozilla/ClearOnShutdown.h"
+
+namespace mozilla::dom {
+
+template <class T>
+struct Flagged {
+  Flagged(uint32_t aFlags, T&& aValue)
+      : flags(aFlags), value(std::forward<T>(aValue)) {}
+  Flagged(Flagged&& aOther)
+      : Flagged(std::move(aOther.flags), std::move(aOther.value)) {}
+  Flagged(const Flagged& aOther) = default;
+  ~Flagged() = default;
+
+  uint32_t flags;
+  T value;
+};
+
+template <class T>
+using FlaggedArray = nsTArray<Flagged<T>>;
+
+template <class T>
+struct ListenerCollection {
+  static StaticAutoPtr<FlaggedArray<T>> gListeners;
+  static StaticAutoPtr<FlaggedArray<T>> gListenersToRemove;
+
+  static FlaggedArray<T>* GetListeners(bool aDoNotInit = false) {
+    MOZ_ASSERT(NS_IsMainThread());
+    if (!gListeners && !aDoNotInit) {
+      gListeners = new FlaggedArray<T>();
+      ClearOnShutdown(&gListeners);
+    }
+    return gListeners;
+  }
+
+  static FlaggedArray<T>* GetListenersToRemove(bool aDoNotInit = false) {
+    MOZ_ASSERT(NS_IsMainThread());
+    if (!gListenersToRemove && !aDoNotInit) {
+      gListenersToRemove = new FlaggedArray<T>();
+      ClearOnShutdown(&gListenersToRemove);
+    }
+    return gListenersToRemove;
+  }
+};
+
+template <class T>
+StaticAutoPtr<FlaggedArray<T>> ListenerCollection<T>::gListeners;
+template <class T>
+StaticAutoPtr<FlaggedArray<T>> ListenerCollection<T>::gListenersToRemove;
+
+using JSListeners = ListenerCollection<RefPtr<PlacesEventCallback>>;
+using WeakJSListeners = ListenerCollection<WeakPtr<PlacesWeakCallbackWrapper>>;
+using WeakNativeListeners =
+    ListenerCollection<WeakPtr<places::INativePlacesEventCallback>>;
+
+// Even if NotifyListeners is called any timing, we mange the notifications with
+// adding to this queue, then sending in sequence. This avoids sending nested
+// notifications while previous ones are still being sent.
+static nsTArray<Sequence<OwningNonNull<PlacesEvent>>> gNotificationQueue;
+
+uint32_t GetEventTypeFlag(PlacesEventType aEventType) {
+  if (aEventType == PlacesEventType::None) {
+    return 0;
+  }
+  return 1 << ((uint32_t)aEventType - 1);
+}
+
+uint32_t GetFlagsForEventTypes(const nsTArray<PlacesEventType>& aEventTypes) {
+  uint32_t flags = 0;
+  for (PlacesEventType eventType : aEventTypes) {
+    flags |= GetEventTypeFlag(eventType);
+  }
+  return flags;
+}
+
+uint32_t GetFlagsForEvents(
+    const nsTArray<OwningNonNull<PlacesEvent>>& aEvents) {
+  uint32_t flags = 0;
+  for (const PlacesEvent& event : aEvents) {
+    flags |= GetEventTypeFlag(event.Type());
+  }
+  return flags;
+}
+
+template <class TWrapped, class TUnwrapped, class TListenerCollection>
+MOZ_CAN_RUN_SCRIPT void CallListeners(
+    uint32_t aEventFlags, const Sequence<OwningNonNull<PlacesEvent>>& aEvents,
+    unsigned long aListenersLengthToCall,
+    const std::function<TUnwrapped(TWrapped&)>& aUnwrapListener,
+    const std::function<void(TUnwrapped&,
+                             const Sequence<OwningNonNull<PlacesEvent>>&)>&
+        aCallListener) {
+  auto& listeners = *TListenerCollection::GetListeners();
+  for (uint32_t i = 0; i < aListenersLengthToCall; i++) {
+    Flagged<TWrapped>& listener = listeners[i];
+    TUnwrapped unwrapped = aUnwrapListener(listener.value);
+    if (!unwrapped) {
+      continue;
+    }
+
+    if ((listener.flags & aEventFlags) == aEventFlags) {
+      aCallListener(unwrapped, aEvents);
+    } else if (listener.flags & aEventFlags) {
+      Sequence<OwningNonNull<PlacesEvent>> filtered;
+      for (const OwningNonNull<PlacesEvent>& event : aEvents) {
+        if (listener.flags & GetEventTypeFlag(event->Type())) {
+          bool success = !!filtered.AppendElement(event, fallible);
+          MOZ_RELEASE_ASSERT(success);
+        }
+      }
+      aCallListener(unwrapped, filtered);
+    }
+  }
+}
+
+void PlacesObservers::AddListener(GlobalObject& aGlobal,
+                                  const nsTArray<PlacesEventType>& aEventTypes,
+                                  PlacesEventCallback& aCallback,
+                                  ErrorResult& rv) {
+  uint32_t flags = GetFlagsForEventTypes(aEventTypes);
+
+  FlaggedArray<RefPtr<PlacesEventCallback>>* listeners =
+      JSListeners::GetListeners();
+  Flagged<RefPtr<PlacesEventCallback>> pair(flags, &aCallback);
+  listeners->AppendElement(pair);
+}
+
+void PlacesObservers::AddListener(GlobalObject& aGlobal,
+                                  const nsTArray<PlacesEventType>& aEventTypes,
+                                  PlacesWeakCallbackWrapper& aCallback,
+                                  ErrorResult& rv) {
+  uint32_t flags = GetFlagsForEventTypes(aEventTypes);
+
+  FlaggedArray<WeakPtr<PlacesWeakCallbackWrapper>>* listeners =
+      WeakJSListeners::GetListeners();
+  WeakPtr<PlacesWeakCallbackWrapper> weakCb(&aCallback);
+  MOZ_ASSERT(weakCb.get());
+  Flagged<WeakPtr<PlacesWeakCallbackWrapper>> flagged(flags, std::move(weakCb));
+  listeners->AppendElement(flagged);
+}
+
+void PlacesObservers::AddListener(
+    const nsTArray<PlacesEventType>& aEventTypes,
+    places::INativePlacesEventCallback* aCallback) {
+  uint32_t flags = GetFlagsForEventTypes(aEventTypes);
+
+  FlaggedArray<WeakPtr<places::INativePlacesEventCallback>>* listeners =
+      WeakNativeListeners::GetListeners();
+  Flagged<WeakPtr<places::INativePlacesEventCallback>> pair(flags, aCallback);
+  listeners->AppendElement(pair);
+}
+
+void PlacesObservers::RemoveListener(
+    GlobalObject& aGlobal, const nsTArray<PlacesEventType>& aEventTypes,
+    PlacesEventCallback& aCallback, ErrorResult& rv) {
+  uint32_t flags = GetFlagsForEventTypes(aEventTypes);
+  if (!gNotificationQueue.IsEmpty()) {
+    FlaggedArray<RefPtr<PlacesEventCallback>>* listeners =
+        JSListeners::GetListenersToRemove();
+    Flagged<RefPtr<PlacesEventCallback>> pair(flags, &aCallback);
+    listeners->AppendElement(pair);
+  } else {
+    RemoveListener(flags, aCallback);
+  }
+}
+
+void PlacesObservers::RemoveListener(
+    GlobalObject& aGlobal, const nsTArray<PlacesEventType>& aEventTypes,
+    PlacesWeakCallbackWrapper& aCallback, ErrorResult& rv) {
+  uint32_t flags = GetFlagsForEventTypes(aEventTypes);
+  if (!gNotificationQueue.IsEmpty()) {
+    FlaggedArray<WeakPtr<PlacesWeakCallbackWrapper>>* listeners =
+        WeakJSListeners::GetListenersToRemove();
+    WeakPtr<PlacesWeakCallbackWrapper> weakCb(&aCallback);
+    MOZ_ASSERT(weakCb.get());
+    Flagged<WeakPtr<PlacesWeakCallbackWrapper>> flagged(flags,
+                                                        std::move(weakCb));
+    listeners->AppendElement(flagged);
+  } else {
+    RemoveListener(flags, aCallback);
+  }
+}
+
+void PlacesObservers::RemoveListener(
+    const nsTArray<PlacesEventType>& aEventTypes,
+    places::INativePlacesEventCallback* aCallback) {
+  uint32_t flags = GetFlagsForEventTypes(aEventTypes);
+  if (!gNotificationQueue.IsEmpty()) {
+    FlaggedArray<WeakPtr<places::INativePlacesEventCallback>>* listeners =
+        WeakNativeListeners::GetListenersToRemove();
+    Flagged<WeakPtr<places::INativePlacesEventCallback>> pair(flags, aCallback);
+    listeners->AppendElement(pair);
+  } else {
+    RemoveListener(flags, aCallback);
+  }
+}
+
+void PlacesObservers::RemoveListener(uint32_t aFlags,
+                                     PlacesEventCallback& aCallback) {
+  FlaggedArray<RefPtr<PlacesEventCallback>>* listeners =
+      JSListeners::GetListeners(/* aDoNotInit: */ true);
+  if (!listeners) {
+    return;
+  }
+  for (uint32_t i = 0; i < listeners->Length(); i++) {
+    Flagged<RefPtr<PlacesEventCallback>>& l = listeners->ElementAt(i);
+    if (!(*l.value == aCallback)) {
+      continue;
+    }
+    if (l.flags == (aFlags & l.flags)) {
+      listeners->RemoveElementAt(i);
+      i--;
+    } else {
+      l.flags &= ~aFlags;
+    }
+  }
+}
+
+void PlacesObservers::RemoveListener(uint32_t aFlags,
+                                     PlacesWeakCallbackWrapper& aCallback) {
+  FlaggedArray<WeakPtr<PlacesWeakCallbackWrapper>>* listeners =
+      WeakJSListeners::GetListeners(/* aDoNotInit: */ true);
+  if (!listeners) {
+    return;
+  }
+  for (uint32_t i = 0; i < listeners->Length(); i++) {
+    Flagged<WeakPtr<PlacesWeakCallbackWrapper>>& l = listeners->ElementAt(i);
+    RefPtr<PlacesWeakCallbackWrapper> unwrapped = l.value.get();
+    if (unwrapped != &aCallback) {
+      continue;
+    }
+    if (l.flags == (aFlags & l.flags)) {
+      listeners->RemoveElementAt(i);
+      i--;
+    } else {
+      l.flags &= ~aFlags;
+    }
+  }
+}
+
+void PlacesObservers::RemoveListener(
+    uint32_t aFlags, places::INativePlacesEventCallback* aCallback) {
+  FlaggedArray<WeakPtr<places::INativePlacesEventCallback>>* listeners =
+      WeakNativeListeners::GetListeners(/* aDoNotInit: */ true);
+  if (!listeners) {
+    return;
+  }
+  for (uint32_t i = 0; i < listeners->Length(); i++) {
+    Flagged<WeakPtr<places::INativePlacesEventCallback>>& l =
+        listeners->ElementAt(i);
+    RefPtr<places::INativePlacesEventCallback> unwrapped = l.value.get();
+    if (unwrapped != aCallback) {
+      continue;
+    }
+    if (l.flags == (aFlags & l.flags)) {
+      listeners->RemoveElementAt(i);
+      i--;
+    } else {
+      l.flags &= ~aFlags;
+    }
+  }
+}
+
+template <class TWrapped, class TUnwrapped, class TListenerCollection>
+void CleanupListeners(
+    const std::function<TUnwrapped(TWrapped&)>& aUnwrapListener,
+    const std::function<void(Flagged<TWrapped>&)>& aRemoveListener) {
+  auto& listeners = *TListenerCollection::GetListeners();
+  for (uint32_t i = 0; i < listeners.Length(); i++) {
+    Flagged<TWrapped>& listener = listeners[i];
+    TUnwrapped unwrapped = aUnwrapListener(listener.value);
+    if (!unwrapped) {
+      listeners.RemoveElementAt(i);
+      i--;
+    }
+  }
+
+  auto& listenersToRemove = *TListenerCollection::GetListenersToRemove();
+  for (auto& listener : listenersToRemove) {
+    aRemoveListener(listener);
+  }
+  listenersToRemove.Clear();
+}
+
+void PlacesObservers::NotifyListeners(
+    GlobalObject& aGlobal, const Sequence<OwningNonNull<PlacesEvent>>& aEvents,
+    ErrorResult& rv) {
+  NotifyListeners(aEvents);
+}
+
+void PlacesObservers::NotifyListeners(
+    const Sequence<OwningNonNull<PlacesEvent>>& aEvents) {
+  MOZ_ASSERT(aEvents.Length() > 0, "Must pass a populated array of events");
+  if (aEvents.Length() == 0) {
+    return;
+  }
+
+#ifdef DEBUG
+  if (!gNotificationQueue.IsEmpty()) {
+    NS_WARNING(
+        "Avoid nested Places notifications if possible, the order of events "
+        "cannot be guaranteed");
+    nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
+    Unused << xpc->DebugDumpJSStack(false, false, false);
+  }
+#endif
+
+  gNotificationQueue.AppendElement(aEvents);
+
+  // If gNotificationQueue has only the events we added now, start to notify.
+  // Otherwise, as it already started the notification processing,
+  // rely on the processing.
+  if (gNotificationQueue.Length() == 1) {
+    NotifyNext();
+  }
+}
+
+void PlacesObservers::NotifyNext() {
+  auto events = gNotificationQueue[0];
+  uint32_t flags = GetFlagsForEvents(events);
+
+  // Send up to the number of current listeners, to avoid handling listeners
+  // added during this notification.
+  unsigned long jsListenersLength = JSListeners::GetListeners()->Length();
+  unsigned long weakNativeListenersLength =
+      WeakNativeListeners::GetListeners()->Length();
+  unsigned long weakJSListenersLength =
+      WeakJSListeners::GetListeners()->Length();
+
+  CallListeners<RefPtr<PlacesEventCallback>, RefPtr<PlacesEventCallback>,
+                JSListeners>(
+      flags, events, jsListenersLength, [](auto& cb) { return cb; },
+      // MOZ_CAN_RUN_SCRIPT_BOUNDARY because on Windows this gets called from
+      // some internals of the std::function implementation that we can't
+      // annotate.  We handle this by annotating CallListeners and making sure
+      // it holds a strong ref to the callback.
+      [&](auto& cb, const auto& events)
+          MOZ_CAN_RUN_SCRIPT_BOUNDARY { MOZ_KnownLive(cb)->Call(events); });
+
+  CallListeners<WeakPtr<places::INativePlacesEventCallback>,
+                RefPtr<places::INativePlacesEventCallback>,
+                WeakNativeListeners>(
+      flags, events, weakNativeListenersLength,
+      [](auto& cb) { return cb.get(); },
+      [&](auto& cb, const Sequence<OwningNonNull<PlacesEvent>>& events) {
+        cb->HandlePlacesEvent(events);
+      });
+
+  CallListeners<WeakPtr<PlacesWeakCallbackWrapper>,
+                RefPtr<PlacesWeakCallbackWrapper>, WeakJSListeners>(
+      flags, events, weakJSListenersLength, [](auto& cb) { return cb.get(); },
+      // MOZ_CAN_RUN_SCRIPT_BOUNDARY because on Windows this gets called from
+      // some internals of the std::function implementation that we can't
+      // annotate.  We handle this by annotating CallListeners and making sure
+      // it holds a strong ref to the callback.
+      [&](auto& cb, const auto& events) MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+        RefPtr<PlacesEventCallback> callback(cb->mCallback);
+        callback->Call(events);
+      });
+
+  gNotificationQueue.RemoveElementAt(0);
+
+  CleanupListeners<RefPtr<PlacesEventCallback>, RefPtr<PlacesEventCallback>,
+                   JSListeners>(
+      [](auto& cb) { return cb; },
+      [&](auto& cb) { RemoveListener(cb.flags, *cb.value); });
+  CleanupListeners<WeakPtr<PlacesWeakCallbackWrapper>,
+                   RefPtr<PlacesWeakCallbackWrapper>, WeakJSListeners>(
+      [](auto& cb) { return cb.get(); },
+      [&](auto& cb) { RemoveListener(cb.flags, *cb.value.get()); });
+  CleanupListeners<WeakPtr<places::INativePlacesEventCallback>,
+                   RefPtr<places::INativePlacesEventCallback>,
+                   WeakNativeListeners>(
+      [](auto& cb) { return cb.get(); },
+      [&](auto& cb) { RemoveListener(cb.flags, cb.value.get()); });
+
+  if (!gNotificationQueue.IsEmpty()) {
+    NotifyNext();
+  }
+}
+
+}  // namespace mozilla::dom