firefox-main/netwerk/protocol/webtransport/WebTransportEventService.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* 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 "WebTransportEventService.h"
#include "nsThreadUtils.h"
#include "nsIObserverService.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/Services.h"
#include "nsISupportsPrimitives.h"
#include "mozilla/StaticMutex.h"
namespace mozilla {
namespace net {
namespace {
StaticRefPtr<WebTransportEventService> gWebTransportEventService;
static StaticMutex sLock;
} // anonymous namespace
class WebTransportBaseRunnable : public Runnable {
public:
WebTransportBaseRunnable(uint64_t aInnerWindowID, uint64_t aHttpChannelId)
: Runnable("net::WebTransportBaseRunnable"),
mInnerWindowID(aInnerWindowID),
mHttpChannelId(aHttpChannelId),
mService(WebTransportEventService::GetOrCreate()) {}
NS_IMETHOD Run() override {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mService);
WebTransportEventService::WebTransportEventListeners listeners;
mService->GetListeners(mInnerWindowID, listeners);
for (uint32_t i = 0; i < listeners.Length(); ++i) {
DoWork(listeners[i]);
}
return NS_OK;
}
protected:
~WebTransportBaseRunnable() = default;
virtual void DoWork(nsIWebTransportEventListener* aListener) = 0;
uint64_t mInnerWindowID;
uint64_t mHttpChannelId;
RefPtr<WebTransportEventService> mService;
};
class WebTransportSessionCreatedRunnable final
: public WebTransportBaseRunnable {
public:
WebTransportSessionCreatedRunnable(uint64_t aInnerWindowID,
uint64_t aHttpChannelId)
: WebTransportBaseRunnable(aInnerWindowID, aHttpChannelId) {}
private:
virtual void DoWork(nsIWebTransportEventListener* aListener) override {
DebugOnly<nsresult> rv =
aListener->WebTransportSessionCreated(mHttpChannelId);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
"WebTransport Session Created failed");
}
};
class WebTransportSessionClosedRunnable final
: public WebTransportBaseRunnable {
public:
WebTransportSessionClosedRunnable(uint64_t aInnerWindowID,
uint64_t aHttpChannelId, uint32_t aCode,
const nsAString& aReason)
: WebTransportBaseRunnable(aInnerWindowID, aHttpChannelId),
mCode(aCode),
mReason(aReason) {}
private:
virtual void DoWork(nsIWebTransportEventListener* aListener) override {
DebugOnly<nsresult> rv =
aListener->WebTransportSessionClosed(mHttpChannelId, mCode, mReason);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
"WebTransport Session Closed failed");
}
uint32_t mCode;
const nsString mReason;
};
/* static */
already_AddRefed<WebTransportEventService>
WebTransportEventService::GetOrCreate() {
StaticMutexAutoLock lock(sLock);
if (!gWebTransportEventService) {
gWebTransportEventService = new WebTransportEventService();
}
RefPtr<WebTransportEventService> service = gWebTransportEventService.get();
return service.forget();
}
NS_INTERFACE_MAP_BEGIN(WebTransportEventService)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebTransportEventService)
NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_ENTRY(nsIWebTransportEventService)
NS_INTERFACE_MAP_END
NS_IMPL_ADDREF(WebTransportEventService)
NS_IMPL_RELEASE(WebTransportEventService)
WebTransportEventService::WebTransportEventService() : mCountListeners(0) {
if (NS_IsMainThread()) {
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->AddObserver(this, "xpcom-shutdown", false);
obs->AddObserver(this, "inner-window-destroyed", false);
}
} else {
gWebTransportEventService = nullptr;
}
}
void WebTransportEventService::WebTransportSessionCreated(
uint64_t aInnerWindowID, uint64_t aHttpChannelId) {
// Let's continue only if we have some listeners.
if (!HasListeners()) {
return;
}
RefPtr<WebTransportSessionCreatedRunnable> runnable =
new WebTransportSessionCreatedRunnable(aInnerWindowID, aHttpChannelId);
DebugOnly<nsresult> rv =
NS_IsMainThread() ? runnable->Run() : NS_DispatchToMainThread(runnable);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Dispatch failed");
}
void WebTransportEventService::WebTransportSessionClosed(
uint64_t aInnerWindowID, uint64_t aHttpChannelId, uint32_t aCode,
const nsAString& aReason) {
// Let's continue only if we have some listeners.
if (!HasListeners()) {
return;
}
RefPtr<WebTransportSessionClosedRunnable> runnable =
new WebTransportSessionClosedRunnable(aInnerWindowID, aHttpChannelId,
aCode, aReason);
DebugOnly<nsresult> rv =
NS_IsMainThread() ? runnable->Run() : NS_DispatchToMainThread(runnable);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Dispatch failed");
}
WebTransportEventService::~WebTransportEventService() {
MOZ_ASSERT(NS_IsMainThread());
}
NS_IMETHODIMP
WebTransportEventService::AddListener(uint64_t aInnerWindowID,
nsIWebTransportEventListener* aListener) {
MOZ_ASSERT(NS_IsMainThread());
if (!aListener) {
return NS_ERROR_INVALID_ARG;
}
++mCountListeners;
WindowListener* listener = mWindows.GetOrInsertNew(aInnerWindowID);
listener->mListeners.AppendElement(aListener);
return NS_OK;
}
NS_IMETHODIMP
WebTransportEventService::RemoveListener(
uint64_t aInnerWindowID, nsIWebTransportEventListener* aListener) {
MOZ_ASSERT(NS_IsMainThread());
if (!aListener) {
return NS_ERROR_INVALID_ARG;
}
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
WebTransportEventService::HasListenerFor(uint64_t aInnerWindowID,
bool* aResult) {
MOZ_ASSERT(NS_IsMainThread());
*aResult = mWindows.Get(aInnerWindowID);
return NS_OK;
}
NS_IMETHODIMP
WebTransportEventService::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 innerWindowID;
nsresult rv = wrapper->GetData(&innerWindowID);
NS_ENSURE_SUCCESS(rv, rv);
WindowListener* listener = mWindows.Get(innerWindowID);
if (!listener) {
return NS_OK;
}
MOZ_ASSERT(mCountListeners >= listener->mListeners.Length());
mCountListeners -= listener->mListeners.Length();
mWindows.Remove(innerWindowID);
return NS_OK;
}
return NS_ERROR_FAILURE;
}
bool WebTransportEventService::HasListeners() const {
return !!mCountListeners;
}
void WebTransportEventService::GetListeners(
uint64_t aInnerWindowID,
WebTransportEventService::WebTransportEventListeners& aListeners) const {
MOZ_ASSERT(NS_IsMainThread());
aListeners.Clear();
WindowListener* listener = mWindows.Get(aInnerWindowID);
if (!listener) {
return;
}
aListeners.AppendElements(listener->mListeners);
}
void WebTransportEventService::Shutdown() {
MOZ_ASSERT(NS_IsMainThread());
if (gWebTransportEventService) {
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->RemoveObserver(gWebTransportEventService, "xpcom-shutdown");
obs->RemoveObserver(gWebTransportEventService, "inner-window-destroyed");
}
mWindows.Clear();
StaticMutexAutoLock lock(sLock);
gWebTransportEventService = nullptr;
}
}
} // namespace net
} // namespace mozilla