corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1749504 - Separate the reset functionality out of ResetOrClearOp; r=dom-storage-reviewers,jstutte

Browse Source 
The ResetOrClearOp currently supports both the resetting and clearing of
storage. However, there's already an operation for resetting storage called
ShutdownStorageOp which can be used separately.

Changes done in this patch:
- ResetOrClearOp renamed to ClearOp
- ClearOp converted to support only storage clearing
- QuotaManagerService::Reset reworked to use an asynchronous message instead of
creating a sub actor
- added generic helpers/callbacks for handling returned MozPromises

Differential Revision: https://phabricator.services.mozilla.com/D185545
This commit is contained in:
Jan Varga
2023-09-12 12:40:40 +00:00
parent 0ed0d8a213
commit fac8a7fe9f
9 changed files with 145 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
dom/quota/ActorsChild.cpp
View File

@@ -367,7 +367,6 @@ mozilla::ipc::IPCResult QuotaRequestChild::Recv__delete__(
case RequestResponse::TResetOriginResponse:
case RequestResponse::TClearDataResponse:
case RequestResponse::TClearAllResponse:
case RequestResponse::TResetAllResponse:
case RequestResponse::TPersistResponse:
HandleResponse();
break;

13
dom/quota/ForwardDecls.h
View File

@@ -8,6 +8,8 @@
#define DOM_QUOTA_FORWARD_DECLS_H_
#include <cstdint>
#include <functional>
#include "mozilla/dom/quota/Config.h"
enum class nsresult : uint32_t;
@@ -32,6 +34,17 @@ class MozPromise;
using BoolPromise = MozPromise<bool, nsresult, false>;
using Int64Promise = MozPromise<int64_t, nsresult, false>;
namespace ipc {
class BoolResponse;
enum class ResponseRejectReason;
using BoolResponsePromise =
MozPromise<BoolResponse, ResponseRejectReason, true>;
using BoolResponseResolver = std::function<void(const BoolResponse&)>;
} // namespace ipc
} // namespace mozilla
#endif // DOM_QUOTA_FORWARD_DECLS_H_

44
dom/quota/OriginOperations.cpp
View File

@@ -372,14 +372,12 @@ class GetFullOriginMetadataOp : public QuotaRequestBase {
void GetResponse(RequestResponse& aResponse) override;
};
class ResetOrClearOp final : public QuotaRequestBase {
const bool mClear;
class ClearOp final : public QuotaRequestBase {
public:
explicit ResetOrClearOp(bool aClear);
ClearOp();
private:
~ResetOrClearOp() = default;
~ClearOp() = default;
void DeleteFiles(QuotaManager& aQuotaManager);
@@ -594,9 +592,7 @@ RefPtr<QuotaRequestBase> CreateGetFullOriginMetadataOp(
return MakeRefPtr<GetFullOriginMetadataOp>(aParams);
}
RefPtr<QuotaRequestBase> CreateResetOrClearOp(bool aClear) {
return MakeRefPtr<ResetOrClearOp>(aClear);
}
RefPtr<QuotaRequestBase> CreateClearOp() { return MakeRefPtr<ClearOp>(); }
RefPtr<QuotaRequestBase> CreateClearOriginOp(const RequestParams& aParams) {
return MakeRefPtr<ClearOriginOp>(aParams);
@@ -1311,13 +1307,12 @@ void GetFullOriginMetadataOp::GetResponse(RequestResponse& aResponse) {
std::move(mMaybeFullOriginMetadata);
}
ResetOrClearOp::ResetOrClearOp(bool aClear)
: QuotaRequestBase("dom::quota::ResetOrClearOp", /* aExclusive */ true),
mClear(aClear) {
ClearOp::ClearOp()
: QuotaRequestBase("dom::quota::ClearOp", /* aExclusive */ true) {
AssertIsOnOwningThread();
}
void ResetOrClearOp::DeleteFiles(QuotaManager& aQuotaManager) {
void ClearOp::DeleteFiles(QuotaManager& aQuotaManager) {
AssertIsOnIOThread();
nsresult rv = aQuotaManager.AboutToClearOrigins(Nullable<PersistenceType>(),
@@ -1342,7 +1337,7 @@ void ResetOrClearOp::DeleteFiles(QuotaManager& aQuotaManager) {
}
}
void ResetOrClearOp::DeleteStorageFile(QuotaManager& aQuotaManager) {
void ClearOp::DeleteStorageFile(QuotaManager& aQuotaManager) {
AssertIsOnIOThread();
QM_TRY_INSPECT(const auto& storageFile,
@@ -1360,33 +1355,26 @@ void ResetOrClearOp::DeleteStorageFile(QuotaManager& aQuotaManager) {
}
}
nsresult ResetOrClearOp::DoDirectoryWork(QuotaManager& aQuotaManager) {
nsresult ClearOp::DoDirectoryWork(QuotaManager& aQuotaManager) {
AssertIsOnIOThread();
AUTO_PROFILER_LABEL("ResetOrClearOp::DoDirectoryWork", OTHER);
AUTO_PROFILER_LABEL("ClearOp::DoDirectoryWork", OTHER);
if (mClear) {
DeleteFiles(aQuotaManager);
DeleteFiles(aQuotaManager);
aQuotaManager.RemoveQuota();
}
aQuotaManager.RemoveQuota();
aQuotaManager.ShutdownStorageInternal();
if (mClear) {
DeleteStorageFile(aQuotaManager);
}
DeleteStorageFile(aQuotaManager);
return NS_OK;
}
void ResetOrClearOp::GetResponse(RequestResponse& aResponse) {
void ClearOp::GetResponse(RequestResponse& aResponse) {
AssertIsOnOwningThread();
if (mClear) {
aResponse = ClearAllResponse();
} else {
aResponse = ResetAllResponse();
}
aResponse = ClearAllResponse();
}
static Result<nsCOMPtr<nsIFile>, QMResult> OpenToBeRemovedDirectory(

2
dom/quota/OriginOperations.h
View File

@@ -66,7 +66,7 @@ RefPtr<QuotaRequestBase> CreateInitializeTemporaryOriginOp(
RefPtr<QuotaRequestBase> CreateGetFullOriginMetadataOp(
const GetFullOriginMetadataParams& aParams);
RefPtr<QuotaRequestBase> CreateResetOrClearOp(bool aClear);
RefPtr<QuotaRequestBase> CreateClearOp();
RefPtr<QuotaRequestBase> CreateClearOriginOp(const RequestParams& aParams);

25
dom/quota/PQuota.ipdl
View File

@@ -23,6 +23,17 @@ using mozilla::dom::ContentParentId
from "mozilla/dom/ipc/IdType.h";
namespace mozilla {
namespace ipc {
union BoolResponse
{
nsresult;
bool;
};
} // namespace ipc
namespace dom {
namespace quota {
@@ -109,10 +120,6 @@ struct ClearAllParams
{
};
struct ResetAllParams
{
};
struct PersistedParams
{
PrincipalInfo principalInfo;
@@ -146,19 +153,12 @@ union RequestParams
ResetOriginParams;
ClearDataParams;
ClearAllParams;
ResetAllParams;
PersistedParams;
PersistParams;
EstimateParams;
ListOriginsParams;
};
union BoolResponse
{
nsresult;
bool;
};
[ManualDealloc, ChildImpl=virtual, ParentImpl=virtual]
protocol PQuota
{
@@ -177,6 +177,9 @@ parent:
async ClearStoragesForPrivateBrowsing()
returns(BoolResponse response);
async ShutdownStorage()
returns(BoolResponse response);
async StartIdleMaintenance();
async StopIdleMaintenance();

5
dom/quota/PQuotaRequest.ipdl
View File

@@ -67,10 +67,6 @@ struct ClearAllResponse
{
};
struct ResetAllResponse
{
};
struct PersistedResponse
{
bool persisted;
@@ -106,7 +102,6 @@ union RequestResponse
ResetOriginResponse;
ClearDataResponse;
ClearAllResponse;
ResetAllResponse;
PersistedResponse;
PersistResponse;
EstimateResponse;

77
dom/quota/QuotaManagerService.cpp
View File

@@ -134,6 +134,44 @@ nsresult GetClearResetOriginParams(nsIPrincipal* aPrincipal,
return NS_OK;
}
class BoolResponsePromiseResolveOrRejectCallback {
public:
using PromiseType = BoolResponsePromise;
using RequestType = Request;
explicit BoolResponsePromiseResolveOrRejectCallback(
RefPtr<RequestType> aRequest)
: mRequest(std::move(aRequest)) {}
void operator()(const PromiseType::ResolveOrRejectValue& aValue) {
if (aValue.IsResolve()) {
const BoolResponse& response = aValue.ResolveValue();
switch (response.type()) {
case BoolResponse::Tnsresult:
mRequest->SetError(response.get_nsresult());
break;
case BoolResponse::Tbool: {
RefPtr<nsVariant> variant = new nsVariant();
variant->SetAsBool(response.get_bool());
mRequest->SetResult(variant);
break;
}
default:
MOZ_CRASH("Unknown response type!");
}
} else {
mRequest->SetError(NS_ERROR_FAILURE);
}
}
private:
RefPtr<RequestType> mRequest;
};
} // namespace
class QuotaManagerService::PendingRequestInfo {
@@ -728,31 +766,7 @@ QuotaManagerService::ClearStoragesForPrivateBrowsing(
mBackgroundActor->SendClearStoragesForPrivateBrowsing()->Then(
GetCurrentSerialEventTarget(), __func__,
[request](const PQuotaChild::ClearStoragesForPrivateBrowsingPromise::
ResolveOrRejectValue& aValue) {
if (aValue.IsResolve()) {
const BoolResponse& response = aValue.ResolveValue();
switch (response.type()) {
case BoolResponse::Tnsresult:
request->SetError(response.get_nsresult());
break;
case BoolResponse::Tbool: {
RefPtr<nsVariant> variant = new nsVariant();
variant->SetAsBool(response.get_bool());
request->SetResult(variant);
break;
}
default:
MOZ_CRASH("Unknown response type!");
}
} else {
request->SetError(NS_ERROR_FAILURE);
}
});
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;
@@ -832,16 +846,13 @@ QuotaManagerService::Reset(nsIQuotaRequest** _retval) {
return NS_ERROR_UNEXPECTED;
}
QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()));
RefPtr<Request> request = new Request();
ResetAllParams params;
RequestInfo info(request, params);
nsresult rv = InitiateRequest(info);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
mBackgroundActor->SendShutdownStorage()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolResponsePromiseResolveOrRejectCallback(request));
request.forget(_retval);
return NS_OK;

70
dom/quota/QuotaParent.cpp
View File

@@ -24,6 +24,36 @@ namespace mozilla::dom::quota {
using namespace mozilla::ipc;
namespace {
class BoolPromiseResolveOrRejectCallback {
public:
using PromiseType = BoolPromise;
using ResolverType = BoolResponseResolver;
BoolPromiseResolveOrRejectCallback(RefPtr<Quota> aQuota,
ResolverType&& aResolver)
: mQuota(std::move(aQuota)), mResolver(std::move(aResolver)) {}
void operator()(const PromiseType::ResolveOrRejectValue& aValue) {
if (!mQuota->CanSend()) {
return;
}
if (aValue.IsResolve()) {
mResolver(aValue.ResolveValue());
} else {
mResolver(aValue.RejectValue());
}
}
private:
RefPtr<Quota> mQuota;
ResolverType mResolver;
};
} // namespace
PQuotaParent* AllocPQuotaParent() {
AssertIsOnBackgroundThread();
@@ -204,7 +234,6 @@ bool Quota::VerifyRequestParams(const RequestParams& aParams) const {
}
case RequestParams::TClearAllParams:
case RequestParams::TResetAllParams:
case RequestParams::TListOriginsParams:
break;
@@ -390,10 +419,7 @@ PQuotaRequestParent* Quota::AllocPQuotaRequestParent(
return CreateClearDataOp(aParams);
case RequestParams::TClearAllParams:
return CreateResetOrClearOp(/* aClear */ true);
case RequestParams::TResetAllParams:
return CreateResetOrClearOp(/* aClear */ false);
return CreateClearOp();
case RequestParams::TPersistedParams:
return CreatePersistedOp(aParams);
@@ -466,18 +492,30 @@ mozilla::ipc::IPCResult Quota::RecvClearStoragesForPrivateBrowsing(
quotaManager->ClearPrivateRepository()->Then(
GetCurrentSerialEventTarget(), __func__,
[self = RefPtr{this}, resolver = std::move(aResolver)](
const BoolPromise::ResolveOrRejectValue& aValue) {
if (!self->CanSend()) {
return;
}
BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
if (aValue.IsResolve()) {
resolver(aValue.ResolveValue());
} else {
resolver(aValue.RejectValue());
}
});
return IPC_OK();
}
mozilla::ipc::IPCResult Quota::RecvShutdownStorage(
ShutdownStorageResolver&& aResolver) {
AssertIsOnBackgroundThread();
QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
([&aResolver](const auto rv) {
aResolver(rv);
return IPC_OK();
}));
QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
QuotaManager::GetOrCreate(), ([&aResolver](const auto rv) {
aResolver(rv);
return IPC_OK();
}));
quotaManager->ShutdownStorage()->Then(
GetCurrentSerialEventTarget(), __func__,
BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
return IPC_OK();
}

3
dom/quota/QuotaParent.h
View File

@@ -53,6 +53,9 @@ class Quota final : public PQuotaParent {
virtual mozilla::ipc::IPCResult RecvClearStoragesForPrivateBrowsing(
ClearStoragesForPrivateBrowsingResolver&& aResolver) override;
virtual mozilla::ipc::IPCResult RecvShutdownStorage(
ShutdownStorageResolver&& aResolver) override;
virtual mozilla::ipc::IPCResult RecvStartIdleMaintenance() override;
virtual mozilla::ipc::IPCResult RecvStopIdleMaintenance() override;