gecko-dev/dom/presentation/PresentationServiceBase.h

358 строки
12 KiB
C++

/* -*- 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/. */
#ifndef mozilla_dom_PresentationServiceBase_h
#define mozilla_dom_PresentationServiceBase_h
#include "mozilla/Unused.h"
#include "nsClassHashtable.h"
#include "nsCOMArray.h"
#include "nsIPresentationListener.h"
#include "nsIPresentationService.h"
#include "nsRefPtrHashtable.h"
#include "nsString.h"
#include "nsTArray.h"
namespace mozilla {
namespace dom {
template <class T>
class PresentationServiceBase {
public:
PresentationServiceBase() = default;
already_AddRefed<T> GetSessionInfo(const nsAString& aSessionId,
const uint8_t aRole) {
MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
aRole == nsIPresentationService::ROLE_RECEIVER);
RefPtr<T> info;
if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
return mSessionInfoAtController.Get(aSessionId, getter_AddRefs(info))
? info.forget()
: nullptr;
} else {
return mSessionInfoAtReceiver.Get(aSessionId, getter_AddRefs(info))
? info.forget()
: nullptr;
}
}
protected:
class SessionIdManager final {
public:
explicit SessionIdManager() { MOZ_COUNT_CTOR(SessionIdManager); }
~SessionIdManager() { MOZ_COUNT_DTOR(SessionIdManager); }
nsresult GetWindowId(const nsAString& aSessionId, uint64_t* aWindowId) {
MOZ_ASSERT(NS_IsMainThread());
if (mRespondingWindowIds.Get(aSessionId, aWindowId)) {
return NS_OK;
}
return NS_ERROR_NOT_AVAILABLE;
}
nsresult GetSessionIds(uint64_t aWindowId,
nsTArray<nsString>& aSessionIds) {
MOZ_ASSERT(NS_IsMainThread());
nsTArray<nsString>* sessionIdArray;
if (!mRespondingSessionIds.Get(aWindowId, &sessionIdArray)) {
return NS_ERROR_INVALID_ARG;
}
aSessionIds.Assign(*sessionIdArray);
return NS_OK;
}
void AddSessionId(uint64_t aWindowId, const nsAString& aSessionId) {
MOZ_ASSERT(NS_IsMainThread());
if (NS_WARN_IF(aWindowId == 0)) {
return;
}
nsTArray<nsString>* sessionIdArray;
if (!mRespondingSessionIds.Get(aWindowId, &sessionIdArray)) {
sessionIdArray = new nsTArray<nsString>();
mRespondingSessionIds.Put(aWindowId, sessionIdArray);
}
sessionIdArray->AppendElement(nsString(aSessionId));
mRespondingWindowIds.Put(aSessionId, aWindowId);
}
void RemoveSessionId(const nsAString& aSessionId) {
MOZ_ASSERT(NS_IsMainThread());
uint64_t windowId = 0;
if (mRespondingWindowIds.Get(aSessionId, &windowId)) {
mRespondingWindowIds.Remove(aSessionId);
nsTArray<nsString>* sessionIdArray;
if (mRespondingSessionIds.Get(windowId, &sessionIdArray)) {
sessionIdArray->RemoveElement(nsString(aSessionId));
if (sessionIdArray->IsEmpty()) {
mRespondingSessionIds.Remove(windowId);
}
}
}
}
nsresult UpdateWindowId(const nsAString& aSessionId,
const uint64_t aWindowId) {
MOZ_ASSERT(NS_IsMainThread());
RemoveSessionId(aSessionId);
AddSessionId(aWindowId, aSessionId);
return NS_OK;
}
void Clear() {
mRespondingSessionIds.Clear();
mRespondingWindowIds.Clear();
}
private:
nsClassHashtable<nsUint64HashKey, nsTArray<nsString>> mRespondingSessionIds;
nsDataHashtable<nsStringHashKey, uint64_t> mRespondingWindowIds;
};
class AvailabilityManager final {
public:
explicit AvailabilityManager() { MOZ_COUNT_CTOR(AvailabilityManager); }
~AvailabilityManager() { MOZ_COUNT_DTOR(AvailabilityManager); }
void AddAvailabilityListener(
const nsTArray<nsString>& aAvailabilityUrls,
nsIPresentationAvailabilityListener* aListener) {
nsTArray<nsString> dummy;
AddAvailabilityListener(aAvailabilityUrls, aListener, dummy);
}
void AddAvailabilityListener(const nsTArray<nsString>& aAvailabilityUrls,
nsIPresentationAvailabilityListener* aListener,
nsTArray<nsString>& aAddedUrls) {
if (!aListener) {
MOZ_ASSERT(false, "aListener should not be null.");
return;
}
if (aAvailabilityUrls.IsEmpty()) {
MOZ_ASSERT(false, "aAvailabilityUrls should not be empty.");
return;
}
aAddedUrls.Clear();
nsTArray<nsString> knownAvailableUrls;
for (const auto& url : aAvailabilityUrls) {
AvailabilityEntry* entry;
if (!mAvailabilityUrlTable.Get(url, &entry)) {
entry = new AvailabilityEntry();
mAvailabilityUrlTable.Put(url, entry);
aAddedUrls.AppendElement(url);
}
if (!entry->mListeners.Contains(aListener)) {
entry->mListeners.AppendElement(aListener);
}
if (entry->mAvailable) {
knownAvailableUrls.AppendElement(url);
}
}
if (!knownAvailableUrls.IsEmpty()) {
Unused << NS_WARN_IF(NS_FAILED(
aListener->NotifyAvailableChange(knownAvailableUrls, true)));
} else {
// If we can't find any known available url and there is no newly
// added url, we still need to notify the listener of the result.
// So, the promise returned by |getAvailability| can be resolved.
if (aAddedUrls.IsEmpty()) {
Unused << NS_WARN_IF(NS_FAILED(
aListener->NotifyAvailableChange(aAvailabilityUrls, false)));
}
}
}
void RemoveAvailabilityListener(
const nsTArray<nsString>& aAvailabilityUrls,
nsIPresentationAvailabilityListener* aListener) {
nsTArray<nsString> dummy;
RemoveAvailabilityListener(aAvailabilityUrls, aListener, dummy);
}
void RemoveAvailabilityListener(
const nsTArray<nsString>& aAvailabilityUrls,
nsIPresentationAvailabilityListener* aListener,
nsTArray<nsString>& aRemovedUrls) {
if (!aListener) {
MOZ_ASSERT(false, "aListener should not be null.");
return;
}
if (aAvailabilityUrls.IsEmpty()) {
MOZ_ASSERT(false, "aAvailabilityUrls should not be empty.");
return;
}
aRemovedUrls.Clear();
for (const auto& url : aAvailabilityUrls) {
AvailabilityEntry* entry;
if (mAvailabilityUrlTable.Get(url, &entry)) {
entry->mListeners.RemoveElement(aListener);
if (entry->mListeners.IsEmpty()) {
mAvailabilityUrlTable.Remove(url);
aRemovedUrls.AppendElement(url);
}
}
}
}
nsresult DoNotifyAvailableChange(
const nsTArray<nsString>& aAvailabilityUrls, bool aAvailable) {
typedef nsClassHashtable<nsISupportsHashKey, nsTArray<nsString>>
ListenerToUrlsMap;
ListenerToUrlsMap availabilityListenerTable;
// Create a mapping from nsIPresentationAvailabilityListener to
// availabilityUrls.
for (auto it = mAvailabilityUrlTable.ConstIter(); !it.Done(); it.Next()) {
if (aAvailabilityUrls.Contains(it.Key())) {
AvailabilityEntry* entry = it.UserData();
entry->mAvailable = aAvailable;
for (uint32_t i = 0; i < entry->mListeners.Length(); ++i) {
nsIPresentationAvailabilityListener* listener =
entry->mListeners.ObjectAt(i);
nsTArray<nsString>* urlArray;
if (!availabilityListenerTable.Get(listener, &urlArray)) {
urlArray = new nsTArray<nsString>();
availabilityListenerTable.Put(listener, urlArray);
}
urlArray->AppendElement(it.Key());
}
}
}
for (auto it = availabilityListenerTable.Iter(); !it.Done(); it.Next()) {
auto listener =
static_cast<nsIPresentationAvailabilityListener*>(it.Key());
Unused << NS_WARN_IF(NS_FAILED(
listener->NotifyAvailableChange(*it.UserData(), aAvailable)));
}
return NS_OK;
}
void GetAvailbilityUrlByAvailability(nsTArray<nsString>& aOutArray,
bool aAvailable) {
aOutArray.Clear();
for (auto it = mAvailabilityUrlTable.ConstIter(); !it.Done(); it.Next()) {
if (it.UserData()->mAvailable == aAvailable) {
aOutArray.AppendElement(it.Key());
}
}
}
void Clear() { mAvailabilityUrlTable.Clear(); }
private:
struct AvailabilityEntry {
explicit AvailabilityEntry() : mAvailable(false) {}
bool mAvailable;
nsCOMArray<nsIPresentationAvailabilityListener> mListeners;
};
nsClassHashtable<nsStringHashKey, AvailabilityEntry> mAvailabilityUrlTable;
};
virtual ~PresentationServiceBase() = default;
void Shutdown() {
mRespondingListeners.Clear();
mControllerSessionIdManager.Clear();
mReceiverSessionIdManager.Clear();
}
nsresult GetWindowIdBySessionIdInternal(const nsAString& aSessionId,
uint8_t aRole, uint64_t* aWindowId) {
MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
aRole == nsIPresentationService::ROLE_RECEIVER);
if (NS_WARN_IF(!aWindowId)) {
return NS_ERROR_INVALID_POINTER;
}
if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
return mControllerSessionIdManager.GetWindowId(aSessionId, aWindowId);
}
return mReceiverSessionIdManager.GetWindowId(aSessionId, aWindowId);
}
void AddRespondingSessionId(uint64_t aWindowId, const nsAString& aSessionId,
uint8_t aRole) {
MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
aRole == nsIPresentationService::ROLE_RECEIVER);
if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
mControllerSessionIdManager.AddSessionId(aWindowId, aSessionId);
} else {
mReceiverSessionIdManager.AddSessionId(aWindowId, aSessionId);
}
}
void RemoveRespondingSessionId(const nsAString& aSessionId, uint8_t aRole) {
MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
aRole == nsIPresentationService::ROLE_RECEIVER);
if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
mControllerSessionIdManager.RemoveSessionId(aSessionId);
} else {
mReceiverSessionIdManager.RemoveSessionId(aSessionId);
}
}
nsresult UpdateWindowIdBySessionIdInternal(const nsAString& aSessionId,
uint8_t aRole,
const uint64_t aWindowId) {
MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
aRole == nsIPresentationService::ROLE_RECEIVER);
if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
return mControllerSessionIdManager.UpdateWindowId(aSessionId, aWindowId);
}
return mReceiverSessionIdManager.UpdateWindowId(aSessionId, aWindowId);
}
// Store the responding listener based on the window ID of the (in-process or
// OOP) receiver page.
nsRefPtrHashtable<nsUint64HashKey, nsIPresentationRespondingListener>
mRespondingListeners;
// Store the mapping between the window ID of the in-process and OOP page and
// the ID of the responding session. It's used for both controller and
// receiver page to retrieve the correspondent session ID. Besides, also keep
// the mapping between the responding session ID and the window ID to help
// look up the window ID.
SessionIdManager mControllerSessionIdManager;
SessionIdManager mReceiverSessionIdManager;
nsRefPtrHashtable<nsStringHashKey, T> mSessionInfoAtController;
nsRefPtrHashtable<nsStringHashKey, T> mSessionInfoAtReceiver;
AvailabilityManager mAvailabilityManager;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_PresentationServiceBase_h