corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
071931b71650fedd376afb51c7e5df80d741dff6
tubestation/dom/quota/QuotaManagerService.cpp
Jan Varga 673d555d87 Bug 1933053 - QM: Cache thumbnail private identity id; r=dom-storage-reviewers,asuth 
The nsIQuotaUtilsService interface is restricted to the main thread, so the
thumbnail private identity id is retrieved on the main thread. Initially, this
was done in the handler for the sessionstore-windows-restored observer topic.

However, it was discovered that this topic is unsuitable because, at the time
it fires, the ContextualIdentityService has not yet loaded its data
asynchronously. Calling ContextualIdentityService.getPrivateIdentity too early
would result in main thread I/O, which must be avoided. To address this, the
contextual-identity-service-load-finished notification is now used. This
ensures that the thumbnail private identity id is retrieved only after the
ContextualIdentityService has completed loading its data.

In theory, if ContextualIdentityService used only asynchronous I/O, the id
could be retrieved in the profile-do-change or profile-after-change handlers.
However, these notifications occur very early during startup, while the
ContextualIdentityService can only be initialized after user events start being
handled (this is done for performance reasons and the start of user events
handling is signaled by firing the sessionstore-windows-restored notification).

Additionally, retrieving the id earlier could trigger the initialization of
many JS modules in background tasks, which we want to avoid.

Furthermore, some Necko-related tests expect that the cookies service remains
uninitialized after calling do_get_profile. If the id were retrieved during
profile-do-change, it would inadvertently initialize the cookies service, as
the ContextualIdentityService needs to traverse cookies while creating default
identities. This would conflict with test expectations.

So, for some time after startup, the thumbnail private identity id may not be
known. This is acceptable, as we do not expect specific origin operations to be
triggered early. Even if they are, it would only mean that some optimizations,
like counting thumbnail private identity temporary origins, are not utilized.

Xpcshell tests currently do not fire contextual-identity-service-load-finished
during do_get_profile, so the thumbnail private identity id will not be known
in those tests. However, this functionality can be added later if needed.

Differential Revision: https://phabricator.services.mozilla.com/D231265
2024-12-18 00:13:39 +00:00

1702 lines
50 KiB
C++
Raw Blame History

/* -*- 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 "QuotaManagerService.h"
// Local includes
#include "ActorsChild.h"
#include "Client.h"
#include "QuotaManager.h"
#include "QuotaRequests.h"
#include "QuotaResults.h"
// Global includes
#include <cstdint>
#include <cstring>
#include <utility>
#include "MainThreadUtils.h"
#include "mozilla/Assertions.h"
#include "mozilla/Atomics.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/Hal.h"
#include "mozilla/MacroForEach.h"
#include "mozilla/Maybe.h"
#include "mozilla/OriginAttributes.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Services.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/Unused.h"
#include "mozilla/Variant.h"
#include "mozilla/dom/quota/PrincipalUtils.h"
#include "mozilla/dom/quota/PQuota.h"
#include "mozilla/dom/quota/PersistenceType.h"
#include "mozilla/dom/quota/QuotaUsageRequestChild.h"
#include "mozilla/dom/quota/ResultExtensions.h"
#include "mozilla/fallible.h"
#include "mozilla/hal_sandbox/PHal.h"
#include "mozilla/ipc/BackgroundChild.h"
#include "mozilla/ipc/BackgroundUtils.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/PBackgroundChild.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
#include "nsDebug.h"
#include "nsError.h"
#include "nsIObserverService.h"
#include "nsIPrincipal.h"
#include "nsIUserIdleService.h"
#include "nsServiceManagerUtils.h"
#include "nsStringFwd.h"
#include "nsVariant.h"
#include "nsXULAppAPI.h"
#include "nscore.h"
#define PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID "profile-before-change-qm"
namespace mozilla::dom::quota {
using namespace mozilla::ipc;
namespace {
const char kIdleServiceContractId[] = "@mozilla.org/widget/useridleservice;1";
// The number of seconds we will wait after receiving the idle-daily
// notification before beginning maintenance.
const uint32_t kIdleObserverTimeSec = 1;
mozilla::StaticRefPtr<QuotaManagerService> gQuotaManagerService;
mozilla::Atomic<bool> gInitialized(false);
mozilla::Atomic<bool> gClosed(false);
nsresult CheckedPrincipalToPrincipalInfo(nsIPrincipal* aPrincipal,
PrincipalInfo& aPrincipalInfo) {
MOZ_ASSERT(aPrincipal);
nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &aPrincipalInfo);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (NS_WARN_IF(!IsPrincipalInfoValid(aPrincipalInfo))) {
return NS_ERROR_FAILURE;
}
if (aPrincipalInfo.type() != PrincipalInfo::TContentPrincipalInfo &&
aPrincipalInfo.type() != PrincipalInfo::TSystemPrincipalInfo) {
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
template <typename ResponseType>
struct ResponseTypeTraits;
template <>
struct ResponseTypeTraits<BoolResponse> {
static constexpr auto kType = BoolResponse::Tbool;
static RefPtr<nsVariant> CreateVariant(const BoolResponse& aResponse) {
auto variant = MakeRefPtr<nsVariant>();
variant->SetAsBool(aResponse.get_bool());
return variant;
}
};
template <>
struct ResponseTypeTraits<UInt64Response> {
static constexpr auto kType = UInt64Response::Tuint64_t;
static RefPtr<nsVariant> CreateVariant(const UInt64Response& aResponse) {
RefPtr<nsVariant> variant = new nsVariant();
variant->SetAsUint64(aResponse.get_uint64_t());
return variant;
}
};
template <>
struct ResponseTypeTraits<CStringArrayResponse> {
static constexpr auto kType = CStringArrayResponse::TArrayOfnsCString;
static RefPtr<nsVariant> CreateVariant(
const CStringArrayResponse& aResponse) {
const CStringArray& strings = aResponse.get_ArrayOfnsCString();
auto variant = MakeRefPtr<nsVariant>();
if (strings.IsEmpty()) {
MOZ_ALWAYS_SUCCEEDS(variant->SetAsEmptyArray());
} else {
nsTArray<const char*> stringPointers(strings.Length());
std::transform(strings.cbegin(), strings.cend(),
MakeBackInserter(stringPointers),
std::mem_fn(&nsCString::get));
QM_TRY(MOZ_TO_RESULT(variant->SetAsArray(
nsIDataType::VTYPE_CHAR_STR, /* aIID */ nullptr,
stringPointers.Length(), stringPointers.Elements())),
nullptr);
}
return variant;
}
};
template <>
struct ResponseTypeTraits<OriginUsageMetadataArrayResponse> {
static constexpr auto kType =
OriginUsageMetadataArrayResponse::TOriginUsageMetadataArray;
static RefPtr<nsVariant> CreateVariant(
const OriginUsageMetadataArrayResponse& aResponse) {
const OriginUsageMetadataArray& originUsages =
aResponse.get_OriginUsageMetadataArray();
auto variant = MakeRefPtr<nsVariant>();
if (originUsages.IsEmpty()) {
variant->SetAsEmptyArray();
} else {
nsTArray<RefPtr<UsageResult>> usageResults(originUsages.Length());
for (const auto& originUsage : originUsages) {
usageResults.AppendElement(MakeRefPtr<UsageResult>(
originUsage.mOrigin, originUsage.mPersisted, originUsage.mUsage,
originUsage.mLastAccessTime));
}
variant->SetAsArray(
nsIDataType::VTYPE_INTERFACE_IS, &NS_GET_IID(nsIQuotaUsageResult),
usageResults.Length(), static_cast<void*>(usageResults.Elements()));
}
return variant;
}
};
template <>
struct ResponseTypeTraits<UsageInfoResponse> {
static constexpr auto kType = UsageInfoResponse::TUsageInfo;
static RefPtr<nsVariant> CreateVariant(const UsageInfoResponse& aResponse) {
RefPtr<OriginUsageResult> result =
new OriginUsageResult(aResponse.get_UsageInfo());
auto variant = MakeRefPtr<nsVariant>();
variant->SetAsInterface(NS_GET_IID(nsIQuotaOriginUsageResult), result);
return variant;
}
};
template <typename RequestType, typename PromiseType, typename ResponseType>
class ResponsePromiseResolveOrRejectCallback {
public:
explicit ResponsePromiseResolveOrRejectCallback(RefPtr<RequestType> aRequest)
: mRequest(std::move(aRequest)) {}
void operator()(const typename PromiseType::ResolveOrRejectValue& aValue) {
if (aValue.IsResolve()) {
const ResponseType& response = aValue.ResolveValue();
switch (response.type()) {
case ResponseType::Tnsresult:
mRequest->SetError(response.get_nsresult());
break;
case ResponseTypeTraits<ResponseType>::kType: {
RefPtr<nsVariant> variant =
ResponseTypeTraits<ResponseType>::CreateVariant(response);
if (variant) {
mRequest->SetResult(variant);
} else {
mRequest->SetError(NS_ERROR_FAILURE);
}
break;
}
default:
MOZ_CRASH("Unknown response type!");
}
} else {
mRequest->SetError(NS_ERROR_FAILURE);
}
}
private:
RefPtr<RequestType> mRequest;
};
using BoolResponsePromiseResolveOrRejectCallback =
ResponsePromiseResolveOrRejectCallback<Request, BoolResponsePromise,
BoolResponse>;
using UInt64ResponsePromiseResolveOrRejectCallback =
ResponsePromiseResolveOrRejectCallback<Request, UInt64ResponsePromise,
UInt64Response>;
using CStringArrayResponsePromiseResolveOrRejectCallback =
ResponsePromiseResolveOrRejectCallback<Request, CStringArrayResponsePromise,
CStringArrayResponse>;
using OriginUsageMetadataArrayResponsePromiseResolveOrRejectCallback =
ResponsePromiseResolveOrRejectCallback<
UsageRequest, OriginUsageMetadataArrayResponsePromise,
OriginUsageMetadataArrayResponse>;
using UsageInfoResponsePromiseResolveOrRejectCallback =
ResponsePromiseResolveOrRejectCallback<
UsageRequest, UsageInfoResponsePromise, UsageInfoResponse>;
} // namespace
class QuotaManagerService::PendingRequestInfo {
protected:
RefPtr<RequestBase> mRequest;
public:
explicit PendingRequestInfo(RequestBase* aRequest) : mRequest(aRequest) {}
virtual ~PendingRequestInfo() = default;
RequestBase* GetRequest() const { return mRequest; }
virtual nsresult InitiateRequest(QuotaChild* aActor) = 0;
};
class QuotaManagerService::RequestInfo : public PendingRequestInfo {
RequestParams mParams;
public:
RequestInfo(Request* aRequest, const RequestParams& aParams)
: PendingRequestInfo(aRequest), mParams(aParams) {
MOZ_ASSERT(aRequest);
MOZ_ASSERT(aParams.type() != RequestParams::T__None);
}
virtual nsresult InitiateRequest(QuotaChild* aActor) override;
};
class QuotaManagerService::IdleMaintenanceInfo : public PendingRequestInfo {
const bool mStart;
public:
explicit IdleMaintenanceInfo(bool aStart)
: PendingRequestInfo(nullptr), mStart(aStart) {}
virtual nsresult InitiateRequest(QuotaChild* aActor) override;
};
QuotaManagerService::QuotaManagerService()
: mBackgroundActor(nullptr),
mBackgroundActorFailed(false),
mIdleObserverRegistered(false) {
MOZ_ASSERT(NS_IsMainThread());
}
QuotaManagerService::~QuotaManagerService() {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!mIdleObserverRegistered);
}
// static
QuotaManagerService* QuotaManagerService::GetOrCreate() {
MOZ_ASSERT(NS_IsMainThread());
if (gClosed) {
MOZ_ASSERT(false, "Calling GetOrCreate() after shutdown!");
return nullptr;
}
if (!gQuotaManagerService) {
RefPtr<QuotaManagerService> instance(new QuotaManagerService());
nsresult rv = instance->Init();
if (NS_WARN_IF(NS_FAILED(rv))) {
return nullptr;
}
if (gInitialized.exchange(true)) {
MOZ_ASSERT(false, "Initialized more than once?!");
}
gQuotaManagerService = instance;
ClearOnShutdown(&gQuotaManagerService);
}
return gQuotaManagerService;
}
// static
QuotaManagerService* QuotaManagerService::Get() {
// Does not return an owning reference.
return gQuotaManagerService;
}
// static
already_AddRefed<QuotaManagerService> QuotaManagerService::FactoryCreate() {
RefPtr<QuotaManagerService> quotaManagerService = GetOrCreate();
return quotaManagerService.forget();
}
void QuotaManagerService::ClearBackgroundActor() {
MOZ_ASSERT(NS_IsMainThread());
mBackgroundActor = nullptr;
}
void QuotaManagerService::AbortOperationsForProcess(
ContentParentId aContentParentId) {
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
nsresult rv = EnsureBackgroundActor();
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
if (NS_WARN_IF(
!mBackgroundActor->SendAbortOperationsForProcess(aContentParentId))) {
return;
}
}
nsresult QuotaManagerService::Init() {
MOZ_ASSERT(NS_IsMainThread());
if (XRE_IsParentProcess()) {
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (NS_WARN_IF(!observerService)) {
return NS_ERROR_FAILURE;
}
nsresult rv = observerService->AddObserver(
this, PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID, false);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
return NS_OK;
}
void QuotaManagerService::Destroy() {
// Setting the closed flag prevents the service from being recreated.
// Don't set it though if there's no real instance created.
if (gInitialized && gClosed.exchange(true)) {
MOZ_ASSERT(false, "Shutdown more than once?!");
}
delete this;
}
nsresult QuotaManagerService::EnsureBackgroundActor() {
MOZ_ASSERT(NS_IsMainThread());
// Nothing can be done here if we have previously failed to create a
// background actor.
if (mBackgroundActorFailed) {
return NS_ERROR_FAILURE;
}
if (!mBackgroundActor) {
PBackgroundChild* backgroundActor =
BackgroundChild::GetOrCreateForCurrentThread();
if (NS_WARN_IF(!backgroundActor)) {
mBackgroundActorFailed = true;
return NS_ERROR_FAILURE;
}
{
RefPtr<QuotaChild> actor = new QuotaChild(this);
mBackgroundActor = static_cast<QuotaChild*>(
backgroundActor->SendPQuotaConstructor(actor));
}
}
if (!mBackgroundActor) {
mBackgroundActorFailed = true;
return NS_ERROR_FAILURE;
}
return NS_OK;
}
nsresult QuotaManagerService::InitiateRequest(PendingRequestInfo& aInfo) {
nsresult rv = EnsureBackgroundActor();
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = aInfo.InitiateRequest(mBackgroundActor);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
void QuotaManagerService::PerformIdleMaintenance() {
using namespace mozilla::hal;
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
// If we're running on battery power then skip all idle maintenance since we
// would otherwise be doing lots of disk I/O.
BatteryInformation batteryInfo;
#ifdef MOZ_WIDGET_ANDROID
// Android XPCShell doesn't load the AndroidBridge that is needed to make
// GetCurrentBatteryInformation work...
if (!QuotaManager::IsRunningXPCShellTests())
#endif
{
// In order to give the correct battery level, hal must have registered
// battery observers.
RegisterBatteryObserver(this);
GetCurrentBatteryInformation(&batteryInfo);
UnregisterBatteryObserver(this);
}
// If we're running XPCShell because we always want to be able to test this
// code so pretend that we're always charging.
if (QuotaManager::IsRunningXPCShellTests()) {
batteryInfo.level() = 100;
batteryInfo.charging() = true;
}
if (NS_WARN_IF(!batteryInfo.charging())) {
return;
}
if (QuotaManager::IsRunningXPCShellTests()) {
// We don't want user activity to impact this code if we're running tests.
Unused << Observe(nullptr, OBSERVER_TOPIC_IDLE, nullptr);
} else if (!mIdleObserverRegistered) {
nsCOMPtr<nsIUserIdleService> idleService =
do_GetService(kIdleServiceContractId);
MOZ_ASSERT(idleService);
MOZ_ALWAYS_SUCCEEDS(
idleService->AddIdleObserver(this, kIdleObserverTimeSec));
mIdleObserverRegistered = true;
}
}
void QuotaManagerService::RemoveIdleObserver() {
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
if (mIdleObserverRegistered) {
nsCOMPtr<nsIUserIdleService> idleService =
do_GetService(kIdleServiceContractId);
MOZ_ASSERT(idleService);
// Ignore the return value of RemoveIdleObserver, it may fail if the
// observer has already been unregistered during shutdown.
Unused << idleService->RemoveIdleObserver(this, kIdleObserverTimeSec);
mIdleObserverRegistered = false;
}
}
NS_IMPL_ADDREF(QuotaManagerService)
NS_IMPL_RELEASE_WITH_DESTROY(QuotaManagerService, Destroy())
NS_IMPL_QUERY_INTERFACE(QuotaManagerService, nsIQuotaManagerService,
nsIQuotaManagerServiceInternal, nsIObserver)
NS_IMETHODIMP
QuotaManagerService::StorageName(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
RefPtr<Request> request = new Request();
StorageNameParams params;
RequestInfo info(request, params);
nsresult rv = InitiateRequest(info);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::StorageInitialized(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendStorageInitialized()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::PersistentStorageInitialized(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendPersistentStorageInitialized()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::TemporaryStorageInitialized(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendTemporaryStorageInitialized()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::TemporaryGroupInitialized(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendTemporaryGroupInitialized(principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::PersistentOriginInitialized(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendPersistentOriginInitialized(principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::TemporaryOriginInitialized(
const nsACString& aPersistenceType, nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<PersistenceType, nsresult> {
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
QM_TRY(
MOZ_TO_RESULT(IsBestEffortPersistenceType(persistenceType.ref())),
Err(NS_ERROR_INVALID_ARG));
return persistenceType.ref();
}()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor
->SendTemporaryOriginInitialized(persistenceType, principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::Init(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendInitializeStorage()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::InitializePersistentStorage(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendInitializePersistentStorage()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::InitTemporaryStorage(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendInitializeTemporaryStorage()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::InitializeTemporaryGroup(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendInitializeTemporaryGroup(principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::InitializePersistentOrigin(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
auto request = MakeRefPtr<Request>();
mBackgroundActor->SendInitializePersistentOrigin(principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::InitializeTemporaryOrigin(
const nsACString& aPersistenceType, nsIPrincipal* aPrincipal,
bool aCreateIfNonExistent, nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<PersistenceType, nsresult> {
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
QM_TRY(
MOZ_TO_RESULT(IsBestEffortPersistenceType(persistenceType.ref())),
Err(NS_ERROR_INVALID_ARG));
return persistenceType.ref();
}()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
auto request = MakeRefPtr<Request>();
mBackgroundActor
->SendInitializeTemporaryOrigin(persistenceType, principalInfo,
aCreateIfNonExistent)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::InitializePersistentClient(nsIPrincipal* aPrincipal,
const nsAString& aClientType,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
QM_TRY_INSPECT(const auto& clientType,
([&aClientType]() -> Result<Client::Type, nsresult> {
Client::Type clientType;
QM_TRY(MOZ_TO_RESULT(Client::TypeFromText(
aClientType, clientType, fallible)),
Err(NS_ERROR_INVALID_ARG));
return clientType;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendInitializePersistentClient(principalInfo, clientType)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::InitializeTemporaryClient(
const nsACString& aPersistenceType, nsIPrincipal* aPrincipal,
const nsAString& aClientType, nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(MOZ_TO_RESULT(StaticPrefs::dom_quotaManager_testing()),
NS_ERROR_UNEXPECTED);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<PersistenceType, nsresult> {
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
QM_TRY(
MOZ_TO_RESULT(IsBestEffortPersistenceType(persistenceType.ref())),
Err(NS_ERROR_INVALID_ARG));
return persistenceType.ref();
}()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
QM_TRY_INSPECT(const auto& clientType,
([&aClientType]() -> Result<Client::Type, nsresult> {
Client::Type clientType;
QM_TRY(MOZ_TO_RESULT(Client::TypeFromText(
aClientType, clientType, fallible)),
Err(NS_ERROR_INVALID_ARG));
return clientType;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor
->SendInitializeTemporaryClient(persistenceType, principalInfo,
clientType)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::GetFullOriginMetadata(const nsACString& aPersistenceType,
nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(nsContentUtils::IsCallerChrome());
QM_TRY(OkIf(StaticPrefs::dom_quotaManager_testing()), NS_ERROR_UNEXPECTED);
const auto maybePersistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(OkIf(maybePersistenceType.isSome()), NS_ERROR_INVALID_ARG);
QM_TRY(OkIf(IsBestEffortPersistenceType(*maybePersistenceType)),
NS_ERROR_INVALID_ARG);
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(OkIf(IsPrincipalInfoValid(principalInfo)), NS_ERROR_INVALID_ARG);
RefPtr<Request> request = new Request();
GetFullOriginMetadataParams params;
params.persistenceType() = *maybePersistenceType;
params.principalInfo() = std::move(principalInfo);
RequestInfo info(request, params);
QM_TRY(MOZ_TO_RESULT(InitiateRequest(info)));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::GetUsage(nsIQuotaUsageCallback* aCallback, bool aGetAll,
nsIQuotaUsageRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aCallback);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<UsageRequest> request = new UsageRequest(aCallback);
RefPtr<QuotaUsageRequestChild> usageRequestChild =
new QuotaUsageRequestChild(request);
ManagedEndpoint<PQuotaUsageRequestParent> usageRequestParentEndpoint =
mBackgroundActor->OpenPQuotaUsageRequestEndpoint(usageRequestChild);
QM_TRY(MOZ_TO_RESULT(usageRequestParentEndpoint.IsValid()));
mBackgroundActor->SendGetUsage(aGetAll, std::move(usageRequestParentEndpoint))
->Then(GetCurrentSerialEventTarget(), __func__,
OriginUsageMetadataArrayResponsePromiseResolveOrRejectCallback(
request));
request->SetBackgroundActor(usageRequestChild);
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::GetUsageForPrincipal(nsIPrincipal* aPrincipal,
nsIQuotaUsageCallback* aCallback,
nsIQuotaUsageRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(aCallback);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<UsageRequest> request = new UsageRequest(aPrincipal, aCallback);
RefPtr<QuotaUsageRequestChild> usageRequestChild =
new QuotaUsageRequestChild(request);
ManagedEndpoint<PQuotaUsageRequestParent> usageRequestParentEndpoint =
mBackgroundActor->OpenPQuotaUsageRequestEndpoint(usageRequestChild);
QM_TRY(MOZ_TO_RESULT(usageRequestParentEndpoint.IsValid()));
mBackgroundActor
->SendGetOriginUsage(principalInfo, std::move(usageRequestParentEndpoint))
->Then(GetCurrentSerialEventTarget(), __func__,
UsageInfoResponsePromiseResolveOrRejectCallback(request));
request->SetBackgroundActor(usageRequestChild);
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::GetCachedUsageForPrincipal(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendGetCachedOriginUsage(principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
UInt64ResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::Clear(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendClearStorage()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ClearStoragesForPrivateBrowsing(
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendClearStoragesForPrivateBrowsing()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ClearStoragesForOriginAttributesPattern(
const nsAString& aPattern, nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
OriginAttributesPattern pattern;
MOZ_ALWAYS_TRUE(pattern.Init(aPattern));
RefPtr<Request> request = new Request();
mBackgroundActor->SendClearStoragesForOriginAttributesPattern(pattern)->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ClearStoragesForPrincipal(
nsIPrincipal* aPrincipal, const nsACString& aPersistenceType,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<Maybe<PersistenceType>, nsresult> {
if (aPersistenceType.IsVoid()) {
return Maybe<PersistenceType>();
}
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
return persistenceType;
}()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendClearStoragesForOrigin(persistenceType, principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ClearStoragesForClient(nsIPrincipal* aPrincipal,
const nsAString& aClientType,
const nsACString& aPersistenceType,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<Maybe<PersistenceType>, nsresult> {
if (aPersistenceType.IsVoid()) {
return Maybe<PersistenceType>();
}
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
return persistenceType;
}()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
QM_TRY_INSPECT(const auto& clientType,
([&aClientType]() -> Result<Client::Type, nsresult> {
Client::Type clientType;
QM_TRY(MOZ_TO_RESULT(Client::TypeFromText(
aClientType, clientType, fallible)),
Err(NS_ERROR_INVALID_ARG));
return clientType;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor
->SendClearStoragesForClient(persistenceType, principalInfo, clientType)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ClearStoragesForOriginPrefix(
nsIPrincipal* aPrincipal, const nsACString& aPersistenceType,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<Maybe<PersistenceType>, nsresult> {
if (aPersistenceType.IsVoid()) {
return Maybe<PersistenceType>();
}
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
return persistenceType;
}()));
QM_TRY_INSPECT(
const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
if (principalInfo.type() == PrincipalInfo::TContentPrincipalInfo) {
nsCString suffix;
principalInfo.get_ContentPrincipalInfo().attrs().CreateSuffix(suffix);
QM_TRY(MOZ_TO_RESULT(suffix.IsEmpty()), Err(NS_ERROR_INVALID_ARG));
}
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor
->SendClearStoragesForOriginPrefix(persistenceType, principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::Reset(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
mBackgroundActor->SendShutdownStorage()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ResetStoragesForPrincipal(
nsIPrincipal* aPrincipal, const nsACString& aPersistenceType,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<Maybe<PersistenceType>, nsresult> {
if (aPersistenceType.IsVoid()) {
return Maybe<PersistenceType>();
}
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
return persistenceType;
}()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor
->SendShutdownStoragesForOrigin(persistenceType, principalInfo)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ResetStoragesForClient(nsIPrincipal* aPrincipal,
const nsAString& aClientType,
const nsACString& aPersistenceType,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
QM_TRY_INSPECT(
const auto& persistenceType,
([&aPersistenceType]() -> Result<Maybe<PersistenceType>, nsresult> {
if (aPersistenceType.IsVoid()) {
return Maybe<PersistenceType>();
}
const auto persistenceType =
PersistenceTypeFromString(aPersistenceType, fallible);
QM_TRY(MOZ_TO_RESULT(persistenceType.isSome()),
Err(NS_ERROR_INVALID_ARG));
return persistenceType;
}()));
QM_TRY_INSPECT(const auto& principalInfo,
([&aPrincipal]() -> Result<PrincipalInfo, nsresult> {
PrincipalInfo principalInfo;
QM_TRY(MOZ_TO_RESULT(
PrincipalToPrincipalInfo(aPrincipal, &principalInfo)));
QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(principalInfo)),
Err(NS_ERROR_INVALID_ARG));
return principalInfo;
}()));
QM_TRY_INSPECT(const auto& clientType,
([&aClientType]() -> Result<Client::Type, nsresult> {
Client::Type clientType;
QM_TRY(MOZ_TO_RESULT(Client::TypeFromText(
aClientType, clientType, fallible)),
Err(NS_ERROR_INVALID_ARG));
return clientType;
}()));
RefPtr<Request> request = new Request();
mBackgroundActor
->SendShutdownStoragesForClient(persistenceType, principalInfo,
clientType)
->Then(GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::Persisted(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(_retval);
RefPtr<Request> request = new Request(aPrincipal);
PersistedParams params;
nsresult rv =
CheckedPrincipalToPrincipalInfo(aPrincipal, params.principalInfo());
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
RequestInfo info(request, params);
rv = InitiateRequest(info);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::Persist(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(_retval);
RefPtr<Request> request = new Request(aPrincipal);
PersistParams params;
nsresult rv =
CheckedPrincipalToPrincipalInfo(aPrincipal, params.principalInfo());
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
RequestInfo info(request, params);
rv = InitiateRequest(info);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::Estimate(nsIPrincipal* aPrincipal,
nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aPrincipal);
RefPtr<Request> request = new Request(aPrincipal);
EstimateParams params;
nsresult rv =
CheckedPrincipalToPrincipalInfo(aPrincipal, params.principalInfo());
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
RequestInfo info(request, params);
rv = InitiateRequest(info);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ListOrigins(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
auto request = MakeRefPtr<Request>();
mBackgroundActor->SendListOrigins()->Then(
GetCurrentSerialEventTarget(), __func__,
CStringArrayResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::ListCachedOrigins(nsIQuotaRequest** _retval) {
MOZ_ASSERT(NS_IsMainThread());
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
auto request = MakeRefPtr<Request>();
mBackgroundActor->SendListCachedOrigins()->Then(
GetCurrentSerialEventTarget(), __func__,
CStringArrayResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::SetThumbnailPrivateIdentityId(
uint32_t aThumbnailPrivateIdentityId) {
MOZ_ASSERT(NS_IsMainThread());
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
mBackgroundActor->SendSetThumbnailPrivateIdentityId(
aThumbnailPrivateIdentityId);
return NS_OK;
}
NS_IMETHODIMP
QuotaManagerService::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aData) {
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
if (!strcmp(aTopic, PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID)) {
RemoveIdleObserver();
return NS_OK;
}
if (!strcmp(aTopic, OBSERVER_TOPIC_IDLE_DAILY)) {
PerformIdleMaintenance();
return NS_OK;
}
if (!strcmp(aTopic, OBSERVER_TOPIC_IDLE)) {
IdleMaintenanceInfo info(/* aStart */ true);
nsresult rv = InitiateRequest(info);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
if (!strcmp(aTopic, OBSERVER_TOPIC_ACTIVE)) {
RemoveIdleObserver();
IdleMaintenanceInfo info(/* aStart */ false);
nsresult rv = InitiateRequest(info);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
MOZ_ASSERT_UNREACHABLE("Should never get here!");
return NS_OK;
}
void QuotaManagerService::Notify(const hal::BatteryInformation& aBatteryInfo) {
// This notification is received when battery data changes. We don't need to
// deal with this notification.
}
nsresult QuotaManagerService::RequestInfo::InitiateRequest(QuotaChild* aActor) {
MOZ_ASSERT(aActor);
auto request = static_cast<Request*>(mRequest.get());
auto actor = new QuotaRequestChild(request);
if (!aActor->SendPQuotaRequestConstructor(actor, mParams)) {
request->SetError(NS_ERROR_FAILURE);
return NS_ERROR_FAILURE;
}
return NS_OK;
}
nsresult QuotaManagerService::IdleMaintenanceInfo::InitiateRequest(
QuotaChild* aActor) {
MOZ_ASSERT(aActor);
bool result;
if (mStart) {
result = aActor->SendStartIdleMaintenance();
} else {
result = aActor->SendStopIdleMaintenance();
}
if (!result) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
} // namespace mozilla::dom::quota
Reference in New Issue View Git Blame Copy Permalink