Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-23 21:01:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1672140 - Rename cache::ClientMetadata to cache::CacheDirectoryMetadata; r=dom-storage-reviewers,janv

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D131590
This commit is contained in:
Haiyang Xu 2021-11-24 20:50:37 +00:00
parent 93316dde65
commit aafd5d8064
13 changed files with 254 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
dom/cache/Action.h vendored
View File

@ -55,9 +55,10 @@ class Action : public SafeRefCounted<Action> {
// Note: Action should hold Resolver ref until its ready to call Resolve().
// Note: The "target" thread is determined when the Action is scheduled on
// Context. The Action should not assume any particular thread is used.
virtual void RunOnTarget(SafeRefPtr<Resolver> aResolver,
const Maybe<ClientMetadata>& aClientMetadata,
Data* aOptionalData) = 0;
virtual void RunOnTarget(
SafeRefPtr<Resolver> aResolver,
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
Data* aOptionalData) = 0;
// Called on initiating thread when the Action is canceled. The Action is
// responsible for calling Resolver::Resolve() as normal; either with a

54
dom/cache/Context.cpp vendored
View File

@ -25,14 +25,14 @@
namespace {
using mozilla::dom::cache::Action;
using mozilla::dom::cache::ClientMetadata;
using mozilla::dom::cache::CacheDirectoryMetadata;
class NullAction final : public Action {
public:
NullAction() = default;
virtual void RunOnTarget(mozilla::SafeRefPtr<Resolver> aResolver,
const mozilla::Maybe<ClientMetadata>&,
const mozilla::Maybe<CacheDirectoryMetadata>&,
Data*) override {
// Resolve success immediately. This Action does no actual work.
MOZ_DIAGNOSTIC_ASSERT(aResolver);
@ -216,7 +216,7 @@ class Context::QuotaInitRunnable final : public nsIRunnable,
SafeRefPtr<Action> mInitAction;
nsCOMPtr<nsIEventTarget> mInitiatingEventTarget;
nsresult mResult;
Maybe<ClientMetadata> mClientMetadata;
Maybe<CacheDirectoryMetadata> mDirectoryMetadata;
RefPtr<DirectoryLock> mDirectoryLock;
State mState;
Atomic<bool> mCanceled;
@ -233,9 +233,10 @@ void Context::QuotaInitRunnable::OpenDirectory() {
MOZ_DIAGNOSTIC_ASSERT(QuotaManager::Get());
RefPtr<DirectoryLock> directoryLock =
QuotaManager::Get()->CreateDirectoryLock(
PERSISTENCE_TYPE_DEFAULT, *mClientMetadata, quota::Client::DOMCACHE,
/* aExclusive */ false);
QuotaManager::Get()->CreateDirectoryLock(PERSISTENCE_TYPE_DEFAULT,
*mDirectoryMetadata,
quota::Client::DOMCACHE,
/* aExclusive */ false);
// DirectoryLock::Acquire() will hold a reference to us as a listener. We will
// then get DirectoryLockAcquired() on the owning thread when it is safe to
@ -253,7 +254,7 @@ void Context::QuotaInitRunnable::DirectoryLockAcquired(DirectoryLock* aLock) {
mDirectoryLock = aLock;
MOZ_DIAGNOSTIC_ASSERT(mDirectoryLock->Id() >= 0);
mClientMetadata->mDirectoryLockId = mDirectoryLock->Id();
mDirectoryMetadata->mDirectoryLockId = mDirectoryLock->Id();
if (mCanceled) {
Complete(NS_ERROR_ABORT);
@ -353,7 +354,7 @@ Context::QuotaInitRunnable::Run() {
QM_TRY_UNWRAP(auto principalMetadata,
QuotaManager::GetInfoFromPrincipal(principal));
mClientMetadata.emplace(std::move(principalMetadata));
mDirectoryMetadata.emplace(std::move(principalMetadata));
mState = STATE_CREATE_QUOTA_MANAGER;
@ -416,10 +417,10 @@ Context::QuotaInitRunnable::Run() {
QM_TRY(
MOZ_TO_RESULT(quotaManager->EnsureTemporaryStorageIsInitialized()));
QM_TRY_UNWRAP(mClientMetadata->mDir,
QM_TRY_UNWRAP(mDirectoryMetadata->mDir,
quotaManager
->EnsureTemporaryOriginIsInitialized(
PERSISTENCE_TYPE_DEFAULT, *mClientMetadata)
PERSISTENCE_TYPE_DEFAULT, *mDirectoryMetadata)
.map([](const auto& res) { return res.first; }));
mState = STATE_RUN_ON_TARGET;
@ -444,7 +445,7 @@ Context::QuotaInitRunnable::Run() {
// Execute the provided initialization Action. The Action must Resolve()
// before returning.
mInitAction->RunOnTarget(resolver.clonePtr(), mClientMetadata, mData);
mInitAction->RunOnTarget(resolver.clonePtr(), mDirectoryMetadata, mData);
MOZ_DIAGNOSTIC_ASSERT(resolver->Resolved());
mData = nullptr;
@ -453,7 +454,7 @@ Context::QuotaInitRunnable::Run() {
// the marker file. If it wasn't opened successfully, then no need to
// create a marker file anyway.
if (NS_SUCCEEDED(resolver->Result())) {
MOZ_ALWAYS_SUCCEEDS(CreateMarkerFile(*mClientMetadata));
MOZ_ALWAYS_SUCCEEDS(CreateMarkerFile(*mDirectoryMetadata));
}
break;
@ -462,7 +463,8 @@ Context::QuotaInitRunnable::Run() {
case STATE_COMPLETING: {
NS_ASSERT_OWNINGTHREAD(QuotaInitRunnable);
mInitAction->CompleteOnInitiatingThread(mResult);
mContext->OnQuotaInit(mResult, mClientMetadata, mDirectoryLock.forget());
mContext->OnQuotaInit(mResult, mDirectoryMetadata,
mDirectoryLock.forget());
mState = STATE_COMPLETE;
// Explicitly cleanup here as the destructor could fire on any of
@ -493,12 +495,12 @@ class Context::ActionRunnable final : public nsIRunnable,
public:
ActionRunnable(SafeRefPtr<Context> aContext, Data* aData,
nsISerialEventTarget* aTarget, SafeRefPtr<Action> aAction,
const Maybe<ClientMetadata>& aClientMetadata)
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata)
: mContext(std::move(aContext)),
mData(aData),
mTarget(aTarget),
mAction(std::move(aAction)),
mClientMetadata(aClientMetadata),
mDirectoryMetadata(aDirectoryMetadata),
mInitiatingThread(GetCurrentEventTarget()),
mState(STATE_INIT),
mResult(NS_OK),
@ -507,7 +509,7 @@ class Context::ActionRunnable final : public nsIRunnable,
// mData may be nullptr
MOZ_DIAGNOSTIC_ASSERT(mTarget);
MOZ_DIAGNOSTIC_ASSERT(mAction);
// mClientMetadata.mDir may be nullptr if QuotaInitRunnable failed
// mDirectoryMetadata.mDir may be nullptr if QuotaInitRunnable failed
MOZ_DIAGNOSTIC_ASSERT(mInitiatingThread);
}
@ -587,7 +589,7 @@ class Context::ActionRunnable final : public nsIRunnable,
RefPtr<Data> mData;
nsCOMPtr<nsISerialEventTarget> mTarget;
SafeRefPtr<Action> mAction;
const Maybe<ClientMetadata> mClientMetadata;
const Maybe<CacheDirectoryMetadata> mDirectoryMetadata;
nsCOMPtr<nsIEventTarget> mInitiatingThread;
State mState;
nsresult mResult;
@ -649,7 +651,7 @@ Context::ActionRunnable::Run() {
mExecutingRunOnTarget = true;
mState = STATE_RUNNING;
mAction->RunOnTarget(SafeRefPtrFromThis(), mClientMetadata, mData);
mAction->RunOnTarget(SafeRefPtrFromThis(), mDirectoryMetadata, mData);
mData = nullptr;
@ -921,8 +923,8 @@ Context::~Context() {
// Note, this may set the mOrphanedData flag.
mManager->RemoveContext(*this);
if (mClientMetadata && mClientMetadata->mDir && !mOrphanedData) {
MOZ_ALWAYS_SUCCEEDS(DeleteMarkerFile(*mClientMetadata));
if (mDirectoryMetadata && mDirectoryMetadata->mDir && !mOrphanedData) {
MOZ_ALWAYS_SUCCEEDS(DeleteMarkerFile(*mDirectoryMetadata));
}
if (mNextContext) {
@ -979,7 +981,7 @@ void Context::DispatchAction(SafeRefPtr<Action> aAction, bool aDoomData) {
auto runnable =
MakeSafeRefPtr<ActionRunnable>(SafeRefPtrFromThis(), mData, mTarget,
std::move(aAction), mClientMetadata);
std::move(aAction), mDirectoryMetadata);
if (aDoomData) {
mData = nullptr;
@ -994,16 +996,16 @@ void Context::DispatchAction(SafeRefPtr<Action> aAction, bool aDoomData) {
AddActivity(*runnable);
}
void Context::OnQuotaInit(nsresult aRv,
const Maybe<ClientMetadata>& aClientMetadata,
already_AddRefed<DirectoryLock> aDirectoryLock) {
void Context::OnQuotaInit(
nsresult aRv, const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
already_AddRefed<DirectoryLock> aDirectoryLock) {
NS_ASSERT_OWNINGTHREAD(Context);
MOZ_DIAGNOSTIC_ASSERT(mInitRunnable);
mInitRunnable = nullptr;
if (aClientMetadata) {
mClientMetadata.emplace(*aClientMetadata);
if (aDirectoryMetadata) {
mDirectoryMetadata.emplace(*aDirectoryMetadata);
}
// Always save the directory lock to ensure QuotaManager does not shutdown

5
dom/cache/Context.h vendored
View File

@ -177,7 +177,8 @@ class Context final : public SafeRefCounted<Context> {
void Init(Maybe<Context&> aOldContext);
void Start();
void DispatchAction(SafeRefPtr<Action> aAction, bool aDoomData = false);
void OnQuotaInit(nsresult aRv, const Maybe<ClientMetadata>& aClientMetadata,
void OnQuotaInit(nsresult aRv,
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
already_AddRefed<DirectoryLock> aDirectoryLock);
SafeRefPtr<ThreadsafeHandle> CreateThreadsafeHandle();
@ -191,7 +192,7 @@ class Context final : public SafeRefCounted<Context> {
RefPtr<Data> mData;
State mState;
bool mOrphanedData;
Maybe<ClientMetadata> mClientMetadata;
Maybe<CacheDirectoryMetadata> mDirectoryMetadata;
RefPtr<QuotaInitRunnable> mInitRunnable;
SafeRefPtr<Action> mInitAction;
nsTArray<PendingAction> mPendingActions;

56
dom/cache/DBAction.cpp vendored
View File

@ -32,19 +32,20 @@ using mozilla::dom::quota::PersistenceType;
namespace {
nsresult WipeDatabase(const ClientMetadata& aClientMetadata, nsIFile& aDBFile) {
nsresult WipeDatabase(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile& aDBFile) {
QM_TRY_INSPECT(const auto& dbDir, MOZ_TO_RESULT_INVOKE_TYPED(
nsCOMPtr<nsIFile>, aDBFile, GetParent));
QM_TRY(MOZ_TO_RESULT(RemoveNsIFile(aClientMetadata, aDBFile)));
QM_TRY(MOZ_TO_RESULT(RemoveNsIFile(aDirectoryMetadata, aDBFile)));
// Note, the -wal journal file will be automatically deleted by sqlite when
// the new database is created. No need to explicitly delete it here.
// Delete the morgue as well.
QM_TRY(MOZ_TO_RESULT(BodyDeleteDir(aClientMetadata, *dbDir)));
QM_TRY(MOZ_TO_RESULT(BodyDeleteDir(aDirectoryMetadata, *dbDir)));
QM_TRY(MOZ_TO_RESULT(WipePaddingFile(aClientMetadata, dbDir)));
QM_TRY(MOZ_TO_RESULT(WipePaddingFile(aDirectoryMetadata, dbDir)));
return NS_OK;
}
@ -55,13 +56,14 @@ DBAction::DBAction(Mode aMode) : mMode(aMode) {}
DBAction::~DBAction() = default;
void DBAction::RunOnTarget(SafeRefPtr<Resolver> aResolver,
const Maybe<ClientMetadata>& aClientMetadata,
Data* aOptionalData) {
void DBAction::RunOnTarget(
SafeRefPtr<Resolver> aResolver,
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
Data* aOptionalData) {
MOZ_ASSERT(!NS_IsMainThread());
MOZ_DIAGNOSTIC_ASSERT(aResolver);
MOZ_DIAGNOSTIC_ASSERT(aClientMetadata);
MOZ_DIAGNOSTIC_ASSERT(aClientMetadata->mDir);
MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata);
MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata->mDir);
if (IsCanceled()) {
aResolver->Resolve(NS_ERROR_ABORT);
@ -73,7 +75,7 @@ void DBAction::RunOnTarget(SafeRefPtr<Resolver> aResolver,
};
QM_TRY_INSPECT(const auto& dbDir,
CloneFileAndAppend(*(aClientMetadata->mDir), u"cache"_ns),
CloneFileAndAppend(*(aDirectoryMetadata->mDir), u"cache"_ns),
QM_VOID, resolveErr);
nsCOMPtr<mozIStorageConnection> conn;
@ -85,7 +87,7 @@ void DBAction::RunOnTarget(SafeRefPtr<Resolver> aResolver,
// If there is no previous Action, then we must open one.
if (!conn) {
QM_TRY_UNWRAP(conn, OpenConnection(*aClientMetadata, *dbDir), QM_VOID,
QM_TRY_UNWRAP(conn, OpenConnection(*aDirectoryMetadata, *dbDir), QM_VOID,
resolveErr);
MOZ_DIAGNOSTIC_ASSERT(conn);
@ -101,13 +103,13 @@ void DBAction::RunOnTarget(SafeRefPtr<Resolver> aResolver,
}
}
RunWithDBOnTarget(std::move(aResolver), *aClientMetadata, dbDir, conn);
RunWithDBOnTarget(std::move(aResolver), *aDirectoryMetadata, dbDir, conn);
}
Result<nsCOMPtr<mozIStorageConnection>, nsresult> DBAction::OpenConnection(
const ClientMetadata& aClientMetadata, nsIFile& aDBDir) {
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aDBDir) {
MOZ_ASSERT(!NS_IsMainThread());
MOZ_DIAGNOSTIC_ASSERT(aClientMetadata.mDirectoryLockId >= 0);
MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata.mDirectoryLockId >= 0);
QM_TRY_INSPECT(const bool& exists, MOZ_TO_RESULT_INVOKE(aDBDir, Exists));
@ -119,30 +121,30 @@ Result<nsCOMPtr<mozIStorageConnection>, nsresult> DBAction::OpenConnection(
QM_TRY_INSPECT(const auto& dbFile,
CloneFileAndAppend(aDBDir, kCachesSQLiteFilename));
QM_TRY_RETURN(OpenDBConnection(aClientMetadata, *dbFile));
QM_TRY_RETURN(OpenDBConnection(aDirectoryMetadata, *dbFile));
}
SyncDBAction::SyncDBAction(Mode aMode) : DBAction(aMode) {}
SyncDBAction::~SyncDBAction() = default;
void SyncDBAction::RunWithDBOnTarget(SafeRefPtr<Resolver> aResolver,
const ClientMetadata& aClientMetadata,
nsIFile* aDBDir,
mozIStorageConnection* aConn) {
void SyncDBAction::RunWithDBOnTarget(
SafeRefPtr<Resolver> aResolver,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) {
MOZ_ASSERT(!NS_IsMainThread());
MOZ_DIAGNOSTIC_ASSERT(aResolver);
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
MOZ_DIAGNOSTIC_ASSERT(aConn);
nsresult rv = RunSyncWithDBOnTarget(aClientMetadata, aDBDir, aConn);
nsresult rv = RunSyncWithDBOnTarget(aDirectoryMetadata, aDBDir, aConn);
aResolver->Resolve(rv);
}
Result<nsCOMPtr<mozIStorageConnection>, nsresult> OpenDBConnection(
const ClientMetadata& aClientMetadata, nsIFile& aDBFile) {
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aDBFile) {
MOZ_ASSERT(!NS_IsMainThread());
MOZ_DIAGNOSTIC_ASSERT(aClientMetadata.mDirectoryLockId >= -1);
MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata.mDirectoryLockId >= -1);
// Use our default file:// protocol handler directly to construct the database
// URL. This avoids any problems if a plugin registers a custom file://
@ -156,9 +158,9 @@ Result<nsCOMPtr<mozIStorageConnection>, nsresult> OpenDBConnection(
NewFileURIMutator, &aDBFile));
const nsCString directoryLockIdClause =
aClientMetadata.mDirectoryLockId >= 0
aDirectoryMetadata.mDirectoryLockId >= 0
? "&directoryLockId="_ns +
IntToCString(aClientMetadata.mDirectoryLockId)
IntToCString(aDirectoryMetadata.mDirectoryLockId)
: EmptyCString();
nsCOMPtr<nsIFileURL> dbFileUrl;
@ -182,14 +184,14 @@ Result<nsCOMPtr<mozIStorageConnection>, nsresult> OpenDBConnection(
// Predicate.
IsDatabaseCorruptionError,
// Fallback.
([&aClientMetadata, &aDBFile, &storageService,
([&aDirectoryMetadata, &aDBFile, &storageService,
&dbFileUrl](const nsresult rv)
-> Result<nsCOMPtr<mozIStorageConnection>, nsresult> {
NS_WARNING("Cache database corrupted. Recreating empty database.");
// There is nothing else we can do to recover. Also, this data
// can be deleted by QuotaManager at any time anyways.
QM_TRY(MOZ_TO_RESULT(WipeDatabase(aClientMetadata, aDBFile)));
QM_TRY(MOZ_TO_RESULT(WipeDatabase(aDirectoryMetadata, aDBFile)));
QM_TRY_RETURN(MOZ_TO_RESULT_INVOKE_TYPED(
nsCOMPtr<mozIStorageConnection>, storageService,
@ -203,7 +205,7 @@ Result<nsCOMPtr<mozIStorageConnection>, nsresult> OpenDBConnection(
// Close existing connection before wiping database.
conn = nullptr;
QM_TRY(MOZ_TO_RESULT(WipeDatabase(aClientMetadata, aDBFile)));
QM_TRY(MOZ_TO_RESULT(WipeDatabase(aDirectoryMetadata, aDBFile)));
QM_TRY_UNWRAP(conn, MOZ_TO_RESULT_INVOKE_TYPED(
nsCOMPtr<mozIStorageConnection>, storageService,

28
dom/cache/DBAction.h vendored
View File

@ -19,7 +19,7 @@ namespace dom {
namespace cache {
Result<nsCOMPtr<mozIStorageConnection>, nsresult> OpenDBConnection(
const ClientMetadata& aClientMetadata, nsIFile& aDBFile);
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aDBFile);
class DBAction : public Action {
protected:
@ -35,18 +35,18 @@ class DBAction : public Action {
// Just as the resolver must be ref'd until resolve, you may also
// ref the DB connection. The connection can only be referenced from the
// target thread and must be released upon resolve.
virtual void RunWithDBOnTarget(SafeRefPtr<Resolver> aResolver,
const ClientMetadata& aClientMetadata,
nsIFile* aDBDir,
mozIStorageConnection* aConn) = 0;
virtual void RunWithDBOnTarget(
SafeRefPtr<Resolver> aResolver,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) = 0;
private:
void RunOnTarget(SafeRefPtr<Resolver> aResolver,
const Maybe<ClientMetadata>& aClientMetadata,
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
Data* aOptionalData) override;
Result<nsCOMPtr<mozIStorageConnection>, nsresult> OpenConnection(
const ClientMetadata& aClientMetadata, nsIFile& aDBDir);
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aDBDir);
const Mode mMode;
};
@ -58,15 +58,15 @@ class SyncDBAction : public DBAction {
// Action objects are deleted through their base pointer
virtual ~SyncDBAction();
virtual nsresult RunSyncWithDBOnTarget(const ClientMetadata& aClientMetadata,
nsIFile* aDBDir,
mozIStorageConnection* aConn) = 0;
virtual nsresult RunSyncWithDBOnTarget(
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) = 0;
private:
virtual void RunWithDBOnTarget(SafeRefPtr<Resolver> aResolver,
const ClientMetadata& aClientMetadata,
nsIFile* aDBDir,
mozIStorageConnection* aConn) override;
virtual void RunWithDBOnTarget(
SafeRefPtr<Resolver> aResolver,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override;
};
} // namespace cache

113
dom/cache/FileUtils.cpp vendored
View File

@ -116,18 +116,18 @@ nsresult BodyCreateDir(nsIFile& aBaseDir) {
return NS_OK;
}
nsresult BodyDeleteDir(const ClientMetadata& aClientMetadata,
nsresult BodyDeleteDir(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile& aBaseDir) {
QM_TRY_INSPECT(const auto& bodyDir,
CloneFileAndAppend(aBaseDir, kMorgueDirectory));
QM_TRY(MOZ_TO_RESULT(RemoveNsIFileRecursively(aClientMetadata, *bodyDir)));
QM_TRY(MOZ_TO_RESULT(RemoveNsIFileRecursively(aDirectoryMetadata, *bodyDir)));
return NS_OK;
}
Result<std::pair<nsID, nsCOMPtr<nsISupports>>, nsresult> BodyStartWriteStream(
const ClientMetadata& aClientMetadata, nsIFile& aBaseDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
nsIInputStream& aSource, void* aClosure, nsAsyncCopyCallbackFun aCallback) {
MOZ_DIAGNOSTIC_ASSERT(aClosure);
MOZ_DIAGNOSTIC_ASSERT(aCallback);
@ -155,7 +155,7 @@ Result<std::pair<nsID, nsCOMPtr<nsISupports>>, nsresult> BodyStartWriteStream(
QM_TRY_INSPECT(
const auto& fileStream,
CreateFileOutputStream(PERSISTENCE_TYPE_DEFAULT, aClientMetadata,
CreateFileOutputStream(PERSISTENCE_TYPE_DEFAULT, aDirectoryMetadata,
Client::DOMCACHE, tmpFile.get()));
const auto compressed =
@ -201,22 +201,22 @@ nsresult BodyFinalizeWrite(nsIFile& aBaseDir, const nsID& aId) {
}
Result<NotNull<nsCOMPtr<nsIInputStream>>, nsresult> BodyOpen(
const ClientMetadata& aClientMetadata, nsIFile& aBaseDir, const nsID& aId) {
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
const nsID& aId) {
QM_TRY_INSPECT(const auto& finalFile,
BodyIdToFile(aBaseDir, aId, BODY_FILE_FINAL));
QM_TRY_RETURN(CreateFileInputStream(PERSISTENCE_TYPE_DEFAULT, aClientMetadata,
Client::DOMCACHE, finalFile.get())
.map([](NotNull<RefPtr<FileInputStream>>&& stream) {
return WrapNotNullUnchecked(
nsCOMPtr<nsIInputStream>{stream.get()});
}));
QM_TRY_RETURN(
CreateFileInputStream(PERSISTENCE_TYPE_DEFAULT, aDirectoryMetadata,
Client::DOMCACHE, finalFile.get())
.map([](NotNull<RefPtr<FileInputStream>>&& stream) {
return WrapNotNullUnchecked(nsCOMPtr<nsIInputStream>{stream.get()});
}));
}
nsresult BodyMaybeUpdatePaddingSize(const ClientMetadata& aClientMetadata,
nsIFile& aBaseDir, const nsID& aId,
const uint32_t aPaddingInfo,
int64_t* aPaddingSizeInOut) {
nsresult BodyMaybeUpdatePaddingSize(
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
const nsID& aId, const uint32_t aPaddingInfo, int64_t* aPaddingSizeInOut) {
MOZ_DIAGNOSTIC_ASSERT(aPaddingSizeInOut);
QM_TRY_INSPECT(const auto& bodyFile,
@ -227,7 +227,7 @@ nsresult BodyMaybeUpdatePaddingSize(const ClientMetadata& aClientMetadata,
int64_t fileSize = 0;
RefPtr<QuotaObject> quotaObject = quotaManager->GetQuotaObject(
PERSISTENCE_TYPE_DEFAULT, aClientMetadata, Client::DOMCACHE,
PERSISTENCE_TYPE_DEFAULT, aDirectoryMetadata, Client::DOMCACHE,
bodyFile.get(), -1, &fileSize);
MOZ_DIAGNOSTIC_ASSERT(quotaObject);
MOZ_DIAGNOSTIC_ASSERT(fileSize >= 0);
@ -249,32 +249,33 @@ nsresult BodyMaybeUpdatePaddingSize(const ClientMetadata& aClientMetadata,
return NS_OK;
}
nsresult BodyDeleteFiles(const ClientMetadata& aClientMetadata,
nsresult BodyDeleteFiles(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile& aBaseDir, const nsTArray<nsID>& aIdList) {
for (const auto id : aIdList) {
QM_TRY_INSPECT(const auto& bodyDir, BodyGetCacheDir(aBaseDir, id));
const auto removeFileForId =
[&aClientMetadata, &id](
[&aDirectoryMetadata, &id](
nsIFile& bodyFile,
const nsACString& leafName) -> Result<bool, nsresult> {
nsID fileId;
QM_TRY(OkIf(fileId.Parse(leafName.BeginReading())), true,
([&aClientMetadata, &bodyFile](const auto) {
([&aDirectoryMetadata, &bodyFile](const auto) {
DebugOnly<nsresult> result = RemoveNsIFile(
aClientMetadata, bodyFile, /* aTrackQuota */ false);
aDirectoryMetadata, bodyFile, /* aTrackQuota */ false);
MOZ_ASSERT(NS_SUCCEEDED(result));
}));
if (id.Equals(fileId)) {
DebugOnly<nsresult> result = RemoveNsIFile(aClientMetadata, bodyFile);
DebugOnly<nsresult> result =
RemoveNsIFile(aDirectoryMetadata, bodyFile);
MOZ_ASSERT(NS_SUCCEEDED(result));
return true;
}
return false;
};
QM_TRY(MOZ_TO_RESULT(BodyTraverseFiles(aClientMetadata, *bodyDir,
QM_TRY(MOZ_TO_RESULT(BodyTraverseFiles(aDirectoryMetadata, *bodyDir,
removeFileForId,
/* aCanRemoveFiles */ false,
/* aTrackQuota */ true)));
@ -346,9 +347,9 @@ nsresult DirectoryPaddingWrite(nsIFile& aBaseDir,
} // namespace
nsresult BodyDeleteOrphanedFiles(const ClientMetadata& aClientMetadata,
nsIFile& aBaseDir,
const nsTArray<nsID>& aKnownBodyIdList) {
nsresult BodyDeleteOrphanedFiles(
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
const nsTArray<nsID>& aKnownBodyIdList) {
// body files are stored in a directory structure like:
//
// /morgue/01/{01fdddb2-884d-4c3d-95ba-0c8062f6c325}.final
@ -360,21 +361,21 @@ nsresult BodyDeleteOrphanedFiles(const ClientMetadata& aClientMetadata,
// Iterate over all the intermediate morgue subdirs
QM_TRY(quota::CollectEachFile(
*dir,
[&aClientMetadata, &aKnownBodyIdList](
[&aDirectoryMetadata, &aKnownBodyIdList](
const nsCOMPtr<nsIFile>& subdir) -> Result<Ok, nsresult> {
QM_TRY_INSPECT(const auto& dirEntryKind, GetDirEntryKind(*subdir));
switch (dirEntryKind) {
case nsIFileKind::ExistsAsDirectory: {
const auto removeOrphanedFiles =
[&aClientMetadata, &aKnownBodyIdList](
[&aDirectoryMetadata, &aKnownBodyIdList](
nsIFile& bodyFile,
const nsACString& leafName) -> Result<bool, nsresult> {
// Finally, parse the uuid out of the name. If it fails to parse,
// then ignore the file.
auto cleanup = MakeScopeExit([&aClientMetadata, &bodyFile] {
auto cleanup = MakeScopeExit([&aDirectoryMetadata, &bodyFile] {
DebugOnly<nsresult> result =
RemoveNsIFile(aClientMetadata, bodyFile);
RemoveNsIFile(aDirectoryMetadata, bodyFile);
MOZ_ASSERT(NS_SUCCEEDED(result));
});
@ -395,7 +396,7 @@ nsresult BodyDeleteOrphanedFiles(const ClientMetadata& aClientMetadata,
// a warning in the reports is not desired).
QM_TRY(QM_OR_ELSE_LOG_VERBOSE_IF(
// Expression.
MOZ_TO_RESULT(BodyTraverseFiles(aClientMetadata, *subdir,
MOZ_TO_RESULT(BodyTraverseFiles(aDirectoryMetadata, *subdir,
removeOrphanedFiles,
/* aCanRemoveFiles */ true,
/* aTrackQuota */ true)),
@ -409,8 +410,9 @@ nsresult BodyDeleteOrphanedFiles(const ClientMetadata& aClientMetadata,
case nsIFileKind::ExistsAsFile: {
// If a file got in here somehow, try to remove it and move on
DebugOnly<nsresult> result = RemoveNsIFile(aClientMetadata, *subdir,
/* aTrackQuota */ false);
DebugOnly<nsresult> result =
RemoveNsIFile(aDirectoryMetadata, *subdir,
/* aTrackQuota */ false);
MOZ_ASSERT(NS_SUCCEEDED(result));
break;
}
@ -429,9 +431,9 @@ nsresult BodyDeleteOrphanedFiles(const ClientMetadata& aClientMetadata,
namespace {
Result<nsCOMPtr<nsIFile>, nsresult> GetMarkerFileHandle(
const ClientMetadata& aClientMetadata) {
const CacheDirectoryMetadata& aDirectoryMetadata) {
QM_TRY_UNWRAP(auto marker,
CloneFileAndAppend(*aClientMetadata.mDir, u"cache"_ns));
CloneFileAndAppend(*aDirectoryMetadata.mDir, u"cache"_ns));
QM_TRY(MOZ_TO_RESULT(marker->Append(u"context_open.marker"_ns)));
@ -440,8 +442,8 @@ Result<nsCOMPtr<nsIFile>, nsresult> GetMarkerFileHandle(
} // namespace
nsresult CreateMarkerFile(const ClientMetadata& aClientMetadata) {
QM_TRY_INSPECT(const auto& marker, GetMarkerFileHandle(aClientMetadata));
nsresult CreateMarkerFile(const CacheDirectoryMetadata& aDirectoryMetadata) {
QM_TRY_INSPECT(const auto& marker, GetMarkerFileHandle(aDirectoryMetadata));
// Callers call this function without checking if the file already exists
// (idempotent usage). QM_OR_ELSE_WARN_IF is not used here since we just want
@ -474,11 +476,11 @@ nsresult CreateMarkerFile(const ClientMetadata& aClientMetadata) {
return NS_OK;
}
nsresult DeleteMarkerFile(const ClientMetadata& aClientMetadata) {
QM_TRY_INSPECT(const auto& marker, GetMarkerFileHandle(aClientMetadata));
nsresult DeleteMarkerFile(const CacheDirectoryMetadata& aDirectoryMetadata) {
QM_TRY_INSPECT(const auto& marker, GetMarkerFileHandle(aDirectoryMetadata));
DebugOnly<nsresult> result =
RemoveNsIFile(aClientMetadata, *marker, /* aTrackQuota */ false);
RemoveNsIFile(aDirectoryMetadata, *marker, /* aTrackQuota */ false);
MOZ_ASSERT(NS_SUCCEEDED(result));
// Again, no fsync is necessary. If the OS crashes before the file
@ -489,18 +491,19 @@ nsresult DeleteMarkerFile(const ClientMetadata& aClientMetadata) {
return NS_OK;
}
bool MarkerFileExists(const ClientMetadata& aClientMetadata) {
QM_TRY_INSPECT(const auto& marker, GetMarkerFileHandle(aClientMetadata),
bool MarkerFileExists(const CacheDirectoryMetadata& aDirectoryMetadata) {
QM_TRY_INSPECT(const auto& marker, GetMarkerFileHandle(aDirectoryMetadata),
false);
QM_TRY_RETURN(MOZ_TO_RESULT_INVOKE(marker, Exists), false);
}
nsresult RemoveNsIFileRecursively(const Maybe<ClientMetadata>& aClientMetadata,
nsIFile& aFile, const bool aTrackQuota) {
nsresult RemoveNsIFileRecursively(
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata, nsIFile& aFile,
const bool aTrackQuota) {
// XXX This assertion proves that we can remove aTrackQuota and just check
// aClientMetadata
MOZ_DIAGNOSTIC_ASSERT_IF(aTrackQuota, aClientMetadata);
MOZ_DIAGNOSTIC_ASSERT_IF(aTrackQuota, aDirectoryMetadata);
QM_TRY_INSPECT(const auto& dirEntryKind, GetDirEntryKind(aFile));
@ -511,10 +514,10 @@ nsresult RemoveNsIFileRecursively(const Maybe<ClientMetadata>& aClientMetadata,
// one to update their usages to the QuotaManager.
QM_TRY(quota::CollectEachFile(
aFile,
[&aClientMetadata, &aTrackQuota](
[&aDirectoryMetadata, &aTrackQuota](
const nsCOMPtr<nsIFile>& file) -> Result<Ok, nsresult> {
QM_TRY(MOZ_TO_RESULT(
RemoveNsIFileRecursively(aClientMetadata, *file, aTrackQuota)));
QM_TRY(MOZ_TO_RESULT(RemoveNsIFileRecursively(aDirectoryMetadata,
*file, aTrackQuota)));
return Ok{};
}));
@ -525,7 +528,7 @@ nsresult RemoveNsIFileRecursively(const Maybe<ClientMetadata>& aClientMetadata,
break;
case nsIFileKind::ExistsAsFile:
return RemoveNsIFile(aClientMetadata, aFile, aTrackQuota);
return RemoveNsIFile(aDirectoryMetadata, aFile, aTrackQuota);
case nsIFileKind::DoesNotExist:
// Ignore files that got removed externally while iterating.
@ -535,11 +538,11 @@ nsresult RemoveNsIFileRecursively(const Maybe<ClientMetadata>& aClientMetadata,
return NS_OK;
}
nsresult RemoveNsIFile(const Maybe<ClientMetadata>& aClientMetadata,
nsresult RemoveNsIFile(const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
nsIFile& aFile, const bool aTrackQuota) {
// XXX This assertion proves that we can remove aTrackQuota and just check
// aClientMetadata
MOZ_DIAGNOSTIC_ASSERT_IF(aTrackQuota, aClientMetadata);
MOZ_DIAGNOSTIC_ASSERT_IF(aTrackQuota, aDirectoryMetadata);
int64_t fileSize = 0;
if (aTrackQuota) {
@ -570,21 +573,23 @@ nsresult RemoveNsIFile(const Maybe<ClientMetadata>& aClientMetadata,
if (fileSize > 0) {
MOZ_ASSERT(aTrackQuota);
DecreaseUsageForClientMetadata(*aClientMetadata, fileSize);
DecreaseUsageForDirectoryMetadata(*aDirectoryMetadata, fileSize);
}
return NS_OK;
}
void DecreaseUsageForClientMetadata(const ClientMetadata& aClientMetadata,
const int64_t aUpdatingSize) {
void DecreaseUsageForDirectoryMetadata(
const CacheDirectoryMetadata& aDirectoryMetadata,
const int64_t aUpdatingSize) {
MOZ_DIAGNOSTIC_ASSERT(aUpdatingSize > 0);
QuotaManager* quotaManager = QuotaManager::Get();
MOZ_DIAGNOSTIC_ASSERT(quotaManager);
quotaManager->DecreaseUsageForClient(
quota::ClientMetadata{aClientMetadata, Client::DOMCACHE}, aUpdatingSize);
quota::ClientMetadata{aDirectoryMetadata, Client::DOMCACHE},
aUpdatingSize);
}
bool DirectoryPaddingFileExists(nsIFile& aBaseDir,

61
dom/cache/FileUtils.h vendored
View File

@ -31,13 +31,13 @@ nsresult BodyCreateDir(nsIFile& aBaseDir);
// Note that this function can only be used during the initialization of the
// database. We're unlikely to be able to delete the DB successfully past
// that point due to the file being in use.
nsresult BodyDeleteDir(const ClientMetadata& aClientMetadata,
nsresult BodyDeleteDir(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile& aBaseDir);
// Returns a Result with a success value with the body id and, optionally, the
// copy context.
Result<std::pair<nsID, nsCOMPtr<nsISupports>>, nsresult> BodyStartWriteStream(
const ClientMetadata& aClientMetadata, nsIFile& aBaseDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
nsIInputStream& aSource, void* aClosure, nsAsyncCopyCallbackFun aCallback);
void BodyCancelWrite(nsISupports& aCopyContext);
@ -45,19 +45,19 @@ void BodyCancelWrite(nsISupports& aCopyContext);
nsresult BodyFinalizeWrite(nsIFile& aBaseDir, const nsID& aId);
Result<NotNull<nsCOMPtr<nsIInputStream>>, nsresult> BodyOpen(
const ClientMetadata& aClientMetadata, nsIFile& aBaseDir, const nsID& aId);
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
const nsID& aId);
nsresult BodyMaybeUpdatePaddingSize(const ClientMetadata& aClientMetadata,
nsIFile& aBaseDir, const nsID& aId,
uint32_t aPaddingInfo,
int64_t* aPaddingSizeInOut);
nsresult BodyMaybeUpdatePaddingSize(
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
const nsID& aId, uint32_t aPaddingInfo, int64_t* aPaddingSizeInOut);
nsresult BodyDeleteFiles(const ClientMetadata& aClientMetadata,
nsresult BodyDeleteFiles(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile& aBaseDir, const nsTArray<nsID>& aIdList);
nsresult BodyDeleteOrphanedFiles(const ClientMetadata& aClientMetadata,
nsIFile& aBaseDir,
const nsTArray<nsID>& aKnownBodyIdList);
nsresult BodyDeleteOrphanedFiles(
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aBaseDir,
const nsTArray<nsID>& aKnownBodyIdList);
// If aCanRemoveFiles is true, that means we are safe to touch the files which
// can be accessed in other threads.
@ -65,53 +65,54 @@ nsresult BodyDeleteOrphanedFiles(const ClientMetadata& aClientMetadata,
// created by other threads. Note that if the files are not expected, we should
// be safe to remove them in any case.
template <typename Func>
nsresult BodyTraverseFiles(const Maybe<ClientMetadata>& aClientMetadata,
nsIFile& aBodyDir, const Func& aHandleFileFunc,
bool aCanRemoveFiles, bool aTrackQuota = true);
nsresult BodyTraverseFiles(
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata, nsIFile& aBodyDir,
const Func& aHandleFileFunc, bool aCanRemoveFiles, bool aTrackQuota = true);
// XXX Remove this method when all callers properly wrap aClientMetadata with
// Some/Nothing
template <typename Func>
nsresult BodyTraverseFiles(const ClientMetadata& aClientMetadata,
nsresult BodyTraverseFiles(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile& aBodyDir, const Func& aHandleFileFunc,
bool aCanRemoveFiles, bool aTrackQuota = true) {
return BodyTraverseFiles(Some(aClientMetadata), aBodyDir, aHandleFileFunc,
return BodyTraverseFiles(Some(aDirectoryMetadata), aBodyDir, aHandleFileFunc,
aCanRemoveFiles, aTrackQuota);
}
nsresult CreateMarkerFile(const ClientMetadata& aClientMetadata);
nsresult CreateMarkerFile(const CacheDirectoryMetadata& aDirectoryMetadata);
nsresult DeleteMarkerFile(const ClientMetadata& aClientMetadata);
nsresult DeleteMarkerFile(const CacheDirectoryMetadata& aDirectoryMetadata);
bool MarkerFileExists(const ClientMetadata& aClientMetadata);
bool MarkerFileExists(const CacheDirectoryMetadata& aDirectoryMetadata);
nsresult RemoveNsIFileRecursively(const Maybe<ClientMetadata>& aClientMetadata,
nsIFile& aFile, bool aTrackQuota = true);
nsresult RemoveNsIFileRecursively(
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata, nsIFile& aFile,
bool aTrackQuota = true);
// XXX Remove this method when all callers properly wrap aClientMetadata with
// Some/Nothing
inline nsresult RemoveNsIFileRecursively(const ClientMetadata& aClientMetadata,
nsIFile& aFile,
bool aTrackQuota = true) {
return RemoveNsIFileRecursively(Some(aClientMetadata), aFile, aTrackQuota);
inline nsresult RemoveNsIFileRecursively(
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile& aFile,
bool aTrackQuota = true) {
return RemoveNsIFileRecursively(Some(aDirectoryMetadata), aFile, aTrackQuota);
}
// Delete a file that you think exists. If the file doesn't exist, an error
// will not be returned, but warning telemetry will be generated! So only call
// this on files that you know exist (idempotent usage, but it's not
// recommended).
nsresult RemoveNsIFile(const Maybe<ClientMetadata>& aClientMetadata,
nsresult RemoveNsIFile(const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
nsIFile& aFile, bool aTrackQuota = true);
// XXX Remove this method when all callers properly wrap aClientMetadata with
// Some/Nothing
inline nsresult RemoveNsIFile(const ClientMetadata& aClientMetadata,
inline nsresult RemoveNsIFile(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile& aFile, bool aTrackQuota = true) {
return RemoveNsIFile(Some(aClientMetadata), aFile, aTrackQuota);
return RemoveNsIFile(Some(aDirectoryMetadata), aFile, aTrackQuota);
}
void DecreaseUsageForClientMetadata(const ClientMetadata& aClientMetadata,
int64_t aUpdatingSize);
void DecreaseUsageForDirectoryMetadata(
const CacheDirectoryMetadata& aDirectoryMetadata, int64_t aUpdatingSize);
/**
* This function is used to check if the directory padding file is existed.

19
dom/cache/FileUtilsImpl.h vendored
View File

@ -15,12 +15,13 @@ namespace dom {
namespace cache {
template <typename Func>
nsresult BodyTraverseFiles(const Maybe<ClientMetadata>& aClientMetadata,
nsIFile& aBodyDir, const Func& aHandleFileFunc,
const bool aCanRemoveFiles, const bool aTrackQuota) {
nsresult BodyTraverseFiles(
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata, nsIFile& aBodyDir,
const Func& aHandleFileFunc, const bool aCanRemoveFiles,
const bool aTrackQuota) {
// XXX This assertion proves that we can remove aTrackQuota and just check
// aClientMetadata.isSome()
MOZ_DIAGNOSTIC_ASSERT_IF(aTrackQuota, aClientMetadata);
MOZ_DIAGNOSTIC_ASSERT_IF(aTrackQuota, aDirectoryMetadata);
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
{
@ -40,7 +41,7 @@ nsresult BodyTraverseFiles(const Maybe<ClientMetadata>& aClientMetadata,
FlippedOnce<true> isEmpty;
QM_TRY(quota::CollectEachFile(
aBodyDir,
[&isEmpty, &aClientMetadata, aTrackQuota, &aHandleFileFunc,
[&isEmpty, &aDirectoryMetadata, aTrackQuota, &aHandleFileFunc,
aCanRemoveFiles](const nsCOMPtr<nsIFile>& file) -> Result<Ok, nsresult> {
QM_TRY_INSPECT(const auto& dirEntryKind, quota::GetDirEntryKind(*file));
@ -48,7 +49,7 @@ nsresult BodyTraverseFiles(const Maybe<ClientMetadata>& aClientMetadata,
case quota::nsIFileKind::ExistsAsDirectory: {
// If it's a directory somehow, try to remove it and move on
DebugOnly<nsresult> result = RemoveNsIFileRecursively(
aClientMetadata, *file, /* aTrackQuota */ false);
aDirectoryMetadata, *file, /* aTrackQuota */ false);
MOZ_ASSERT(NS_SUCCEEDED(result));
break;
}
@ -62,7 +63,7 @@ nsresult BodyTraverseFiles(const Maybe<ClientMetadata>& aClientMetadata,
if (StringEndsWith(leafName, ".tmp"_ns)) {
if (aCanRemoveFiles) {
DebugOnly<nsresult> result =
RemoveNsIFile(aClientMetadata, *file, aTrackQuota);
RemoveNsIFile(aDirectoryMetadata, *file, aTrackQuota);
MOZ_ASSERT(NS_SUCCEEDED(result));
return Ok{};
}
@ -75,7 +76,7 @@ nsresult BodyTraverseFiles(const Maybe<ClientMetadata>& aClientMetadata,
// If its not, try to remove it and move on.
if (!maybeEndingOk) {
DebugOnly<nsresult> result = RemoveNsIFile(
aClientMetadata, *file, /* aTrackQuota */ false);
aDirectoryMetadata, *file, /* aTrackQuota */ false);
MOZ_ASSERT(NS_SUCCEEDED(result));
return Ok{};
}
@ -101,7 +102,7 @@ nsresult BodyTraverseFiles(const Maybe<ClientMetadata>& aClientMetadata,
if (isEmpty && aCanRemoveFiles) {
DebugOnly<nsresult> result = RemoveNsIFileRecursively(
aClientMetadata, aBodyDir, /* aTrackQuota */ false);
aDirectoryMetadata, aBodyDir, /* aTrackQuota */ false);
MOZ_ASSERT(NS_SUCCEEDED(result));
}

117
dom/cache/Manager.cpp vendored
View File

@ -75,7 +75,7 @@ class SetupAction final : public SyncDBAction {
SetupAction() : SyncDBAction(DBAction::Create) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
@ -94,7 +94,7 @@ class SetupAction final : public SyncDBAction {
//
// Note, this must be done after any schema version updates to
// ensure our DBSchema methods work correctly.
if (MarkerFileExists(aClientMetadata)) {
if (MarkerFileExists(aDirectoryMetadata)) {
NS_WARNING("Cache not shutdown cleanly! Cleaning up stale data...");
mozStorageTransaction trans(aConn, false,
mozIStorageConnection::TRANSACTION_IMMEDIATE);
@ -109,19 +109,19 @@ class SetupAction final : public SyncDBAction {
const CheckedInt64& overallDeletedPaddingSize,
Reduce(
orphanedCacheIdList, CheckedInt64(0),
[aConn, &aClientMetadata, &aDBDir](
[aConn, &aDirectoryMetadata, &aDBDir](
CheckedInt64 oldValue, const Maybe<const CacheId&>& element)
-> Result<CheckedInt64, nsresult> {
QM_TRY_INSPECT(const auto& deletionInfo,
db::DeleteCacheId(*aConn, *element));
QM_TRY(MOZ_TO_RESULT(
BodyDeleteFiles(aClientMetadata, *aDBDir,
BodyDeleteFiles(aDirectoryMetadata, *aDBDir,
deletionInfo.mDeletedBodyIdList)));
if (deletionInfo.mDeletedPaddingSize > 0) {
DecreaseUsageForClientMetadata(
aClientMetadata, deletionInfo.mDeletedPaddingSize);
DecreaseUsageForDirectoryMetadata(
aDirectoryMetadata, deletionInfo.mDeletedPaddingSize);
}
return oldValue + deletionInfo.mDeletedPaddingSize;
@ -130,8 +130,8 @@ class SetupAction final : public SyncDBAction {
// Clean up orphaned body objects
QM_TRY_INSPECT(const auto& knownBodyIdList, db::GetKnownBodyIds(*aConn));
QM_TRY(MOZ_TO_RESULT(
BodyDeleteOrphanedFiles(aClientMetadata, *aDBDir, knownBodyIdList)));
QM_TRY(MOZ_TO_RESULT(BodyDeleteOrphanedFiles(aDirectoryMetadata, *aDBDir,
knownBodyIdList)));
// Commit() explicitly here, because we want to ensure the padding file
// has the correct content.
@ -172,11 +172,11 @@ class DeleteOrphanedBodyAction final : public Action {
: mDeletedBodyIdList{aBodyId} {}
void RunOnTarget(SafeRefPtr<Resolver> aResolver,
const Maybe<ClientMetadata>& aClientMetadata,
const Maybe<CacheDirectoryMetadata>& aDirectoryMetadata,
Data*) override {
MOZ_DIAGNOSTIC_ASSERT(aResolver);
MOZ_DIAGNOSTIC_ASSERT(aClientMetadata);
MOZ_DIAGNOSTIC_ASSERT(aClientMetadata->mDir);
MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata);
MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata->mDir);
// Note that since DeleteOrphanedBodyAction isn't used while the context is
// being initialized, we don't need to check for cancellation here.
@ -186,11 +186,11 @@ class DeleteOrphanedBodyAction final : public Action {
};
QM_TRY_INSPECT(const auto& dbDir,
CloneFileAndAppend(*aClientMetadata->mDir, u"cache"_ns),
CloneFileAndAppend(*aDirectoryMetadata->mDir, u"cache"_ns),
QM_VOID, resolve);
QM_TRY(MOZ_TO_RESULT(
BodyDeleteFiles(*aClientMetadata, *dbDir, mDeletedBodyIdList)),
QM_TRY(MOZ_TO_RESULT(BodyDeleteFiles(*aDirectoryMetadata, *dbDir,
mDeletedBodyIdList)),
QM_VOID, resolve);
aResolver->Resolve(NS_OK);
@ -527,9 +527,9 @@ class Manager::DeleteOrphanedCacheAction final : public SyncDBAction {
mCacheId(aCacheId) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
mClientMetadata.emplace(aClientMetadata);
mDirectoryMetadata.emplace(aDirectoryMetadata);
mozStorageTransaction trans(aConn, false,
mozIStorageConnection::TRANSACTION_IMMEDIATE);
@ -556,8 +556,8 @@ class Manager::DeleteOrphanedCacheAction final : public SyncDBAction {
mManager->NoteOrphanedBodyIdList(mDeletionInfo.mDeletedBodyIdList);
if (mDeletionInfo.mDeletedPaddingSize > 0) {
DecreaseUsageForClientMetadata(*mClientMetadata,
mDeletionInfo.mDeletedPaddingSize);
DecreaseUsageForDirectoryMetadata(*mDirectoryMetadata,
mDeletionInfo.mDeletedPaddingSize);
}
// ensure we release the manager on the initiating thread
@ -568,7 +568,7 @@ class Manager::DeleteOrphanedCacheAction final : public SyncDBAction {
SafeRefPtr<Manager> mManager;
const CacheId mCacheId;
DeletionInfo mDeletionInfo;
Maybe<ClientMetadata> mClientMetadata;
Maybe<CacheDirectoryMetadata> mDirectoryMetadata;
};
// ----------------------------------------------------------------------------
@ -585,7 +585,7 @@ class Manager::CacheMatchAction final : public Manager::BaseAction {
mFoundResponse(false) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
@ -607,7 +607,7 @@ class Manager::CacheMatchAction final : public Manager::BaseAction {
nsCOMPtr<nsIInputStream> stream;
if (mArgs.openMode() == OpenMode::Eager) {
QM_TRY_UNWRAP(stream,
BodyOpen(aClientMetadata, *aDBDir, mResponse.mBodyId));
BodyOpen(aDirectoryMetadata, *aDBDir, mResponse.mBodyId));
}
mStreamList->Add(mResponse.mBodyId, std::move(stream));
@ -651,7 +651,7 @@ class Manager::CacheMatchAllAction final : public Manager::BaseAction {
mStreamList(std::move(aStreamList)) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
@ -668,7 +668,7 @@ class Manager::CacheMatchAllAction final : public Manager::BaseAction {
nsCOMPtr<nsIInputStream> stream;
if (mArgs.openMode() == OpenMode::Eager) {
QM_TRY_UNWRAP(stream, BodyOpen(aClientMetadata, *aDBDir,
QM_TRY_UNWRAP(stream, BodyOpen(aDirectoryMetadata, *aDBDir,
mSavedResponses[i].mBodyId));
}
@ -734,10 +734,10 @@ class Manager::CachePutAllAction final : public DBAction {
private:
~CachePutAllAction() = default;
virtual void RunWithDBOnTarget(SafeRefPtr<Resolver> aResolver,
const ClientMetadata& aClientMetadata,
nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
virtual void RunWithDBOnTarget(
SafeRefPtr<Resolver> aResolver,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
MOZ_DIAGNOSTIC_ASSERT(aResolver);
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
MOZ_DIAGNOSTIC_ASSERT(aConn);
@ -757,20 +757,20 @@ class Manager::CachePutAllAction final : public DBAction {
mResolver = std::move(aResolver);
mDBDir = aDBDir;
mConn = aConn;
mClientMetadata.emplace(aClientMetadata);
mDirectoryMetadata.emplace(aDirectoryMetadata);
// File bodies are streamed to disk via asynchronous copying. Start
// this copying now. Each copy will eventually result in a call
// to OnAsyncCopyComplete().
const nsresult rv = [this, &aClientMetadata]() -> nsresult {
const nsresult rv = [this, &aDirectoryMetadata]() -> nsresult {
QM_TRY(CollectEachInRange(
mList, [this, &aClientMetadata](auto& entry) -> nsresult {
mList, [this, &aDirectoryMetadata](auto& entry) -> nsresult {
QM_TRY(MOZ_TO_RESULT(
StartStreamCopy(aClientMetadata, entry, RequestStream,
StartStreamCopy(aDirectoryMetadata, entry, RequestStream,
&mExpectedAsyncCopyCompletions)));
QM_TRY(MOZ_TO_RESULT(
StartStreamCopy(aClientMetadata, entry, ResponseStream,
StartStreamCopy(aDirectoryMetadata, entry, ResponseStream,
&mExpectedAsyncCopyCompletions)));
return NS_OK;
@ -858,7 +858,7 @@ class Manager::CachePutAllAction final : public DBAction {
if (e.mResponse.type() == ResponseType::Opaque) {
// It'll generate padding if we've not set it yet.
QM_TRY(MOZ_TO_RESULT(BodyMaybeUpdatePaddingSize(
*mClientMetadata, *mDBDir, e.mResponseBodyId,
*mDirectoryMetadata, *mDBDir, e.mResponseBodyId,
e.mResponse.paddingInfo(), &e.mResponse.paddingSize())));
MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - e.mResponse.paddingSize() >=
@ -915,7 +915,8 @@ class Manager::CachePutAllAction final : public DBAction {
mManager->NoteOrphanedBodyIdList(mDeletedBodyIdList);
if (mDeletedPaddingSize > 0) {
DecreaseUsageForClientMetadata(*mClientMetadata, mDeletedPaddingSize);
DecreaseUsageForDirectoryMetadata(*mDirectoryMetadata,
mDeletedPaddingSize);
}
Listener* listener = mManager->GetListener(mListenerId);
@ -950,8 +951,9 @@ class Manager::CachePutAllAction final : public DBAction {
enum StreamId { RequestStream, ResponseStream };
nsresult StartStreamCopy(const ClientMetadata& aClientMetadata, Entry& aEntry,
StreamId aStreamId, uint32_t* aCopyCountOut) {
nsresult StartStreamCopy(const CacheDirectoryMetadata& aDirectoryMetadata,
Entry& aEntry, StreamId aStreamId,
uint32_t* aCopyCountOut) {
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(aCopyCountOut);
@ -970,8 +972,8 @@ class Manager::CachePutAllAction final : public DBAction {
}
QM_TRY_INSPECT((const auto& [bodyId, copyContext]),
BodyStartWriteStream(aClientMetadata, *mDBDir, *source, this,
AsyncCopyCompleteFunc));
BodyStartWriteStream(aDirectoryMetadata, *mDBDir, *source,
this, AsyncCopyCompleteFunc));
if (aStreamId == RequestStream) {
aEntry.mRequestBodyId = bodyId;
@ -1034,9 +1036,10 @@ class Manager::CachePutAllAction final : public DBAction {
// Clean up any files we might have written before hitting the error.
if (NS_FAILED(aRv)) {
BodyDeleteFiles(*mClientMetadata, *mDBDir, mBodyIdWrittenList);
BodyDeleteFiles(*mDirectoryMetadata, *mDBDir, mBodyIdWrittenList);
if (mUpdatedPaddingSize > 0) {
DecreaseUsageForClientMetadata(*mClientMetadata, mUpdatedPaddingSize);
DecreaseUsageForDirectoryMetadata(*mDirectoryMetadata,
mUpdatedPaddingSize);
}
}
@ -1079,7 +1082,7 @@ class Manager::CachePutAllAction final : public DBAction {
Mutex mMutex;
nsTArray<nsCOMPtr<nsISupports>> mCopyContextList;
Maybe<ClientMetadata> mClientMetadata;
Maybe<CacheDirectoryMetadata> mDirectoryMetadata;
// Track how much pad amount has been added for new entries so that it can be
// removed if an error occurs.
int64_t mUpdatedPaddingSize;
@ -1099,9 +1102,9 @@ class Manager::CacheDeleteAction final : public Manager::BaseAction {
mSuccess(false) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
mClientMetadata.emplace(aClientMetadata);
mDirectoryMetadata.emplace(aDirectoryMetadata);
mozStorageTransaction trans(aConn, false,
mozIStorageConnection::TRANSACTION_IMMEDIATE);
@ -1137,8 +1140,8 @@ class Manager::CacheDeleteAction final : public Manager::BaseAction {
mManager->NoteOrphanedBodyIdList(mDeletionInfo.mDeletedBodyIdList);
if (mDeletionInfo.mDeletedPaddingSize > 0) {
DecreaseUsageForClientMetadata(*mClientMetadata,
mDeletionInfo.mDeletedPaddingSize);
DecreaseUsageForDirectoryMetadata(*mDirectoryMetadata,
mDeletionInfo.mDeletedPaddingSize);
}
aListener->OnOpComplete(std::move(aRv), CacheDeleteResult(mSuccess));
@ -1153,7 +1156,7 @@ class Manager::CacheDeleteAction final : public Manager::BaseAction {
const CacheDeleteArgs mArgs;
bool mSuccess;
DeletionInfo mDeletionInfo;
Maybe<ClientMetadata> mClientMetadata;
Maybe<CacheDirectoryMetadata> mDirectoryMetadata;
};
// ----------------------------------------------------------------------------
@ -1169,7 +1172,7 @@ class Manager::CacheKeysAction final : public Manager::BaseAction {
mStreamList(std::move(aStreamList)) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
@ -1186,7 +1189,7 @@ class Manager::CacheKeysAction final : public Manager::BaseAction {
nsCOMPtr<nsIInputStream> stream;
if (mArgs.openMode() == OpenMode::Eager) {
QM_TRY_UNWRAP(stream, BodyOpen(aClientMetadata, *aDBDir,
QM_TRY_UNWRAP(stream, BodyOpen(aDirectoryMetadata, *aDBDir,
mSavedRequests[i].mBodyId));
}
@ -1228,7 +1231,7 @@ class Manager::StorageMatchAction final : public Manager::BaseAction {
mFoundResponse(false) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
@ -1251,8 +1254,8 @@ class Manager::StorageMatchAction final : public Manager::BaseAction {
nsCOMPtr<nsIInputStream> stream;
if (mArgs.openMode() == OpenMode::Eager) {
QM_TRY_UNWRAP(stream,
BodyOpen(aClientMetadata, *aDBDir, mSavedResponse.mBodyId));
QM_TRY_UNWRAP(stream, BodyOpen(aDirectoryMetadata, *aDBDir,
mSavedResponse.mBodyId));
}
mStreamList->Add(mSavedResponse.mBodyId, std::move(stream));
@ -1291,7 +1294,7 @@ class Manager::StorageHasAction final : public Manager::BaseAction {
mCacheFound(false) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
QM_TRY_INSPECT(const auto& maybeCacheId,
db::StorageGetCacheId(*aConn, mNamespace, mArgs.key()));
@ -1323,7 +1326,7 @@ class Manager::StorageOpenAction final : public Manager::BaseAction {
mCacheId(INVALID_CACHE_ID) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
// Cache does not exist, create it instead
mozStorageTransaction trans(aConn, false,
@ -1378,7 +1381,7 @@ class Manager::StorageDeleteAction final : public Manager::BaseAction {
mCacheId(INVALID_CACHE_ID) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
mozStorageTransaction trans(aConn, false,
mozIStorageConnection::TRANSACTION_IMMEDIATE);
@ -1443,7 +1446,7 @@ class Manager::StorageKeysAction final : public Manager::BaseAction {
: BaseAction(std::move(aManager), aListenerId), mNamespace(aNamespace) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
QM_TRY_UNWRAP(mKeys, db::StorageGetKeys(*aConn, mNamespace));
@ -1473,11 +1476,11 @@ class Manager::OpenStreamAction final : public Manager::BaseAction {
mBodyId(aBodyId) {}
virtual nsresult RunSyncWithDBOnTarget(
const ClientMetadata& aClientMetadata, nsIFile* aDBDir,
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aDBDir,
mozIStorageConnection* aConn) override {
MOZ_DIAGNOSTIC_ASSERT(aDBDir);
QM_TRY_UNWRAP(mBodyStream, BodyOpen(aClientMetadata, *aDBDir, mBodyId));
QM_TRY_UNWRAP(mBodyStream, BodyOpen(aDirectoryMetadata, *aDBDir, mBodyId));
return NS_OK;
}

19
dom/cache/QuotaClient.cpp vendored
View File

@ -122,15 +122,15 @@ Result<UsageInfo, nsresult> GetBodyUsage(nsIFile& aMorgueDir,
Result<int64_t, nsresult> GetPaddingSizeFromDB(
nsIFile& aDir, nsIFile& aDBFile, const OriginMetadata& aOriginMetadata) {
ClientMetadata clientMetadata(aOriginMetadata);
// clientMetadata.mDirectoryLockId must be -1 (which is default for new
// ClientMetadata) because this method should only be called from
CacheDirectoryMetadata directoryMetadata(aOriginMetadata);
// directoryMetadata.mDirectoryLockId must be -1 (which is default for new
// CacheDirectoryMetadata) because this method should only be called from
// QuotaClient::InitOrigin when the temporary storage hasn't been initialized
// yet. At that time, the in-memory objects (e.g. OriginInfo) are only being
// created so it doesn't make sense to tunnel quota information to
// TelemetryVFS to get corresponding QuotaObject instance for the SQLite
// file).
MOZ_DIAGNOSTIC_ASSERT(clientMetadata.mDirectoryLockId == -1);
MOZ_DIAGNOSTIC_ASSERT(directoryMetadata.mDirectoryLockId == -1);
#ifdef DEBUG
{
@ -139,7 +139,8 @@ Result<int64_t, nsresult> GetPaddingSizeFromDB(
}
#endif
QM_TRY_INSPECT(const auto& conn, OpenDBConnection(clientMetadata, aDBFile));
QM_TRY_INSPECT(const auto& conn,
OpenDBConnection(directoryMetadata, aDBFile));
// Make sure that the database has the latest schema before we try to read
// from it. We have to do this because GetPaddingSizeFromDB is called
@ -434,7 +435,7 @@ nsresult CacheQuotaClient::RestorePaddingFileInternal(
}
nsresult CacheQuotaClient::WipePaddingFileInternal(
const ClientMetadata& aClientMetadata, nsIFile* aBaseDir) {
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aBaseDir) {
MOZ_ASSERT(!NS_IsMainThread());
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
@ -467,7 +468,7 @@ nsresult CacheQuotaClient::WipePaddingFileInternal(
}()));
if (paddingSize > 0) {
DecreaseUsageForClientMetadata(aClientMetadata, paddingSize);
DecreaseUsageForDirectoryMetadata(aDirectoryMetadata, paddingSize);
}
QM_TRY(MOZ_TO_RESULT(
@ -516,7 +517,7 @@ nsresult RestorePaddingFile(nsIFile* aBaseDir, mozIStorageConnection* aConn) {
}
// static
nsresult WipePaddingFile(const ClientMetadata& aClientMetadata,
nsresult WipePaddingFile(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile* aBaseDir) {
MOZ_ASSERT(!NS_IsMainThread());
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
@ -525,7 +526,7 @@ nsresult WipePaddingFile(const ClientMetadata& aClientMetadata,
MOZ_DIAGNOSTIC_ASSERT(cacheQuotaClient);
QM_TRY(MOZ_TO_RESULT(
cacheQuotaClient->WipePaddingFileInternal(aClientMetadata, aBaseDir)));
cacheQuotaClient->WipePaddingFileInternal(aDirectoryMetadata, aBaseDir)));
return NS_OK;
}

2
dom/cache/QuotaClient.h vendored
View File

@ -39,7 +39,7 @@ already_AddRefed<quota::Client> CreateQuotaClient();
nsresult RestorePaddingFile(nsIFile* aBaseDir, mozIStorageConnection* aConn);
nsresult WipePaddingFile(const ClientMetadata& aClientMetadata,
nsresult WipePaddingFile(const CacheDirectoryMetadata& aDirectoryMetadata,
nsIFile* aBaseDir);
extern const nsLiteralString kCachesSQLiteFilename;

4
dom/cache/QuotaClientImpl.h vendored
View File

@ -116,8 +116,8 @@ class CacheQuotaClient final : public quota::Client {
nsresult RestorePaddingFileInternal(nsIFile* aBaseDir,
mozIStorageConnection* aConn);
nsresult WipePaddingFileInternal(const ClientMetadata& aClientMetadata,
nsIFile* aBaseDir);
nsresult WipePaddingFileInternal(
const CacheDirectoryMetadata& aDirectoryMetadata, nsIFile* aBaseDir);
private:
~CacheQuotaClient();

6
dom/cache/Types.h vendored
View File

@ -29,17 +29,17 @@ static const Namespace INVALID_NAMESPACE = NUMBER_OF_NAMESPACES;
using CacheId = int64_t;
static const CacheId INVALID_CACHE_ID = -1;
struct ClientMetadata : quota::ClientMetadata {
struct CacheDirectoryMetadata : quota::ClientMetadata {
nsCOMPtr<nsIFile> mDir;
int64_t mDirectoryLockId = -1;
explicit ClientMetadata(quota::PrincipalMetadata aPrincipalMetadata)
explicit CacheDirectoryMetadata(quota::PrincipalMetadata aPrincipalMetadata)
: quota::ClientMetadata(
quota::OriginMetadata{std::move(aPrincipalMetadata),
quota::PERSISTENCE_TYPE_DEFAULT},
quota::Client::Type::DOMCACHE) {}
explicit ClientMetadata(quota::OriginMetadata aOriginMetadata)
explicit CacheDirectoryMetadata(quota::OriginMetadata aOriginMetadata)
: quota::ClientMetadata(std::move(aOriginMetadata),
quota::Client::Type::DOMCACHE) {
MOZ_DIAGNOSTIC_ASSERT(aOriginMetadata.mPersistenceType ==