Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 312 insertions, 0 deletions

diff --git a/dom/base/EventSourceEventService.cpp b/dom/base/EventSourceEventService.cpp
new file mode 100644
index 0000000000..362c5fc658
--- /dev/null
+++ b/dom/base/EventSourceEventService.cpp
@@ -0,0 +1,312 @@
+/* -*- 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 "EventSourceEventService.h"
+#include "mozilla/StaticPtr.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIObserverService.h"
+#include "nsXULAppAPI.h"
+#include "nsSocketTransportService2.h"
+#include "nsThreadUtils.h"
+#include "mozilla/Services.h"
+
+namespace mozilla::dom {
+
+namespace {
+
+StaticRefPtr<EventSourceEventService> gEventSourceEventService;
+
+}  // anonymous namespace
+
+class EventSourceBaseRunnable : public Runnable {
+ public:
+  EventSourceBaseRunnable(uint64_t aHttpChannelId, uint64_t aInnerWindowID)
+      : Runnable("dom::EventSourceBaseRunnable"),
+        mHttpChannelId(aHttpChannelId),
+        mInnerWindowID(aInnerWindowID) {}
+
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(NS_IsMainThread());
+    RefPtr<EventSourceEventService> service =
+        EventSourceEventService::GetOrCreate();
+    MOZ_ASSERT(service);
+
+    EventSourceEventService::EventSourceListeners listeners;
+
+    service->GetListeners(mInnerWindowID, listeners);
+
+    for (uint32_t i = 0; i < listeners.Length(); ++i) {
+      DoWork(listeners[i]);
+    }
+
+    return NS_OK;
+  }
+
+ protected:
+  ~EventSourceBaseRunnable() = default;
+
+  virtual void DoWork(nsIEventSourceEventListener* aListener) = 0;
+
+  uint64_t mHttpChannelId;
+  uint64_t mInnerWindowID;
+};
+
+class EventSourceConnectionOpenedRunnable final
+    : public EventSourceBaseRunnable {
+ public:
+  EventSourceConnectionOpenedRunnable(uint64_t aHttpChannelId,
+                                      uint64_t aInnerWindowID)
+      : EventSourceBaseRunnable(aHttpChannelId, aInnerWindowID) {}
+
+ private:
+  virtual void DoWork(nsIEventSourceEventListener* aListener) override {
+    DebugOnly<nsresult> rv =
+        aListener->EventSourceConnectionOpened(mHttpChannelId);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "EventSourceConnectionOpened failed");
+  }
+};
+
+class EventSourceConnectionClosedRunnable final
+    : public EventSourceBaseRunnable {
+ public:
+  EventSourceConnectionClosedRunnable(uint64_t aHttpChannelId,
+                                      uint64_t aInnerWindowID)
+      : EventSourceBaseRunnable(aHttpChannelId, aInnerWindowID) {}
+
+ private:
+  virtual void DoWork(nsIEventSourceEventListener* aListener) override {
+    DebugOnly<nsresult> rv =
+        aListener->EventSourceConnectionClosed(mHttpChannelId);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "EventSourceConnectionClosed failed");
+  }
+};
+
+class EventSourceEventRunnable final : public EventSourceBaseRunnable {
+ public:
+  EventSourceEventRunnable(uint64_t aHttpChannelId, uint64_t aInnerWindowID,
+                           const nsAString& aEventName,
+                           const nsAString& aLastEventID,
+                           const nsAString& aData, uint32_t aRetry,
+                           DOMHighResTimeStamp aTimeStamp)
+      : EventSourceBaseRunnable(aHttpChannelId, aInnerWindowID),
+        mEventName(aEventName),
+        mLastEventID(aLastEventID),
+        mData(aData),
+        mRetry(aRetry),
+        mTimeStamp(aTimeStamp) {}
+
+ private:
+  virtual void DoWork(nsIEventSourceEventListener* aListener) override {
+    DebugOnly<nsresult> rv = aListener->EventReceived(
+        mHttpChannelId, mEventName, mLastEventID, mData, mRetry, mTimeStamp);
+
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Event op failed");
+  }
+
+  nsString mEventName;
+  nsString mLastEventID;
+  nsString mData;
+  uint32_t mRetry;
+  DOMHighResTimeStamp mTimeStamp;
+};
+
+/* static */
+already_AddRefed<EventSourceEventService>
+EventSourceEventService::GetOrCreate() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!gEventSourceEventService) {
+    gEventSourceEventService = new EventSourceEventService();
+  }
+
+  RefPtr<EventSourceEventService> service = gEventSourceEventService.get();
+  return service.forget();
+}
+
+NS_INTERFACE_MAP_BEGIN(EventSourceEventService)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIEventSourceEventService)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIEventSourceEventService)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(EventSourceEventService)
+NS_IMPL_RELEASE(EventSourceEventService)
+
+EventSourceEventService::EventSourceEventService() : mCountListeners(0) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->AddObserver(this, "xpcom-shutdown", false);
+    obs->AddObserver(this, "inner-window-destroyed", false);
+  }
+}
+
+EventSourceEventService::~EventSourceEventService() {
+  MOZ_ASSERT(NS_IsMainThread());
+}
+
+void EventSourceEventService::EventSourceConnectionOpened(
+    uint64_t aHttpChannelId, uint64_t aInnerWindowID) {
+  // Let's continue only if we have some listeners.
+  if (!HasListeners()) {
+    return;
+  }
+
+  RefPtr<EventSourceConnectionOpenedRunnable> runnable =
+      new EventSourceConnectionOpenedRunnable(aHttpChannelId, aInnerWindowID);
+  DebugOnly<nsresult> rv = NS_DispatchToMainThread(runnable);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
+}
+
+void EventSourceEventService::EventSourceConnectionClosed(
+    uint64_t aHttpChannelId, uint64_t aInnerWindowID) {
+  // Let's continue only if we have some listeners.
+  if (!HasListeners()) {
+    return;
+  }
+  RefPtr<EventSourceConnectionClosedRunnable> runnable =
+      new EventSourceConnectionClosedRunnable(aHttpChannelId, aInnerWindowID);
+  DebugOnly<nsresult> rv = NS_DispatchToMainThread(runnable);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
+}
+
+void EventSourceEventService::EventReceived(
+    uint64_t aHttpChannelId, uint64_t aInnerWindowID,
+    const nsAString& aEventName, const nsAString& aLastEventID,
+    const nsAString& aData, uint32_t aRetry, DOMHighResTimeStamp aTimeStamp) {
+  // Let's continue only if we have some listeners.
+  if (!HasListeners()) {
+    return;
+  }
+
+  RefPtr<EventSourceEventRunnable> runnable =
+      new EventSourceEventRunnable(aHttpChannelId, aInnerWindowID, aEventName,
+                                   aLastEventID, aData, aRetry, aTimeStamp);
+  DebugOnly<nsresult> rv = NS_DispatchToMainThread(runnable);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
+}
+
+NS_IMETHODIMP
+EventSourceEventService::AddListener(uint64_t aInnerWindowID,
+                                     nsIEventSourceEventListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!aListener) {
+    return NS_ERROR_FAILURE;
+  }
+  ++mCountListeners;
+
+  WindowListener* listener = mWindows.GetOrInsertNew(aInnerWindowID);
+
+  listener->mListeners.AppendElement(aListener);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+EventSourceEventService::RemoveListener(
+    uint64_t aInnerWindowID, nsIEventSourceEventListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!aListener) {
+    return NS_ERROR_FAILURE;
+  }
+
+  WindowListener* listener = mWindows.Get(aInnerWindowID);
+  if (!listener) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!listener->mListeners.RemoveElement(aListener)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // The last listener for this window.
+  if (listener->mListeners.IsEmpty()) {
+    mWindows.Remove(aInnerWindowID);
+  }
+
+  MOZ_ASSERT(mCountListeners);
+  --mCountListeners;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+EventSourceEventService::HasListenerFor(uint64_t aInnerWindowID,
+                                        bool* aResult) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  *aResult = mWindows.Get(aInnerWindowID);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+EventSourceEventService::Observe(nsISupports* aSubject, const char* aTopic,
+                                 const char16_t* aData) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!strcmp(aTopic, "xpcom-shutdown")) {
+    Shutdown();
+    return NS_OK;
+  }
+
+  if (!strcmp(aTopic, "inner-window-destroyed") && HasListeners()) {
+    nsCOMPtr<nsISupportsPRUint64> wrapper = do_QueryInterface(aSubject);
+    NS_ENSURE_TRUE(wrapper, NS_ERROR_FAILURE);
+
+    uint64_t innerID;
+    nsresult rv = wrapper->GetData(&innerID);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    WindowListener* listener = mWindows.Get(innerID);
+    if (!listener) {
+      return NS_OK;
+    }
+
+    MOZ_ASSERT(mCountListeners >= listener->mListeners.Length());
+    mCountListeners -= listener->mListeners.Length();
+    mWindows.Remove(innerID);
+  }
+
+  // This should not happen.
+  return NS_ERROR_FAILURE;
+}
+
+void EventSourceEventService::Shutdown() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (gEventSourceEventService) {
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    if (obs) {
+      obs->RemoveObserver(gEventSourceEventService, "xpcom-shutdown");
+      obs->RemoveObserver(gEventSourceEventService, "inner-window-destroyed");
+    }
+
+    mWindows.Clear();
+    gEventSourceEventService = nullptr;
+  }
+}
+
+bool EventSourceEventService::HasListeners() const { return !!mCountListeners; }
+
+void EventSourceEventService::GetListeners(
+    uint64_t aInnerWindowID,
+    EventSourceEventService::EventSourceListeners& aListeners) const {
+  aListeners.Clear();
+
+  WindowListener* listener = mWindows.Get(aInnerWindowID);
+  if (!listener) {
+    return;
+  }
+
+  aListeners.AppendElements(listener->mListeners);
+}
+
+}  // namespace mozilla::dom