Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "FileStreams.h"
// Local includes
#include "QuotaCommon.h"
#include "QuotaManager.h"
#include "QuotaObject.h"
#include "RemoteQuotaObject.h"
// Global includes
#include <utility>
#include "mozilla/Assertions.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/Result.h"
#include "mozilla/dom/quota/ResultExtensions.h"
#include "mozilla/ipc/RandomAccessStreamParams.h"
#include "nsDebug.h"
#include "prio.h"
namespace mozilla::dom::quota {
template <class FileStreamBase>
NS_IMETHODIMP FileQuotaStream<FileStreamBase>::SetEOF() {
// If the stream is not quota tracked, or on an early or late stage in the
// lifecycle, mQuotaObject is null. Under these circumstances,
// we don't check the quota limit in order to avoid breakage.
if (mQuotaObject) {
int64_t offset = 0;
QM_TRY(MOZ_TO_RESULT(FileStreamBase::Tell(&offset)));
QM_TRY(OkIf(mQuotaObject->MaybeUpdateSize(offset, /* aTruncate */ true)),
NS_ERROR_FILE_NO_DEVICE_SPACE);
}
QM_TRY(MOZ_TO_RESULT(FileStreamBase::SetEOF()));
return NS_OK;
}
template <class FileStreamBase>
NS_IMETHODIMP FileQuotaStream<FileStreamBase>::Close() {
QM_TRY(MOZ_TO_RESULT(FileStreamBase::Close()));
if (mQuotaObject) {
if (auto* remoteQuotaObject = mQuotaObject->AsRemoteQuotaObject()) {
remoteQuotaObject->Close();
}
mQuotaObject = nullptr;
}
return NS_OK;
}
template <class FileStreamBase>
nsresult FileQuotaStream<FileStreamBase>::DoOpen() {
MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
MOZ_RELEASE_ASSERT(!mDeserialized);
QuotaManager* quotaManager = QuotaManager::Get();
MOZ_ASSERT(quotaManager, "Shouldn't be null!");
MOZ_ASSERT(!mQuotaObject, "Creating quota object more than once?");
mQuotaObject = quotaManager->GetQuotaObject(
mPersistenceType, mOriginMetadata, mClientType,
FileStreamBase::mOpenParams.localFile);
QM_TRY(MOZ_TO_RESULT(FileStreamBase::DoOpen()));
if (mQuotaObject && (FileStreamBase::mOpenParams.ioFlags & PR_TRUNCATE)) {
DebugOnly<bool> res =
mQuotaObject->MaybeUpdateSize(0, /* aTruncate */ true);
MOZ_ASSERT(res);
}
return NS_OK;
}
template <class FileStreamBase>
NS_IMETHODIMP FileQuotaStreamWithWrite<FileStreamBase>::Write(
const char* aBuf, uint32_t aCount, uint32_t* _retval) {
if (FileQuotaStreamWithWrite::mQuotaObject) {
int64_t offset;
QM_TRY(MOZ_TO_RESULT(FileStreamBase::Tell(&offset)));
MOZ_ASSERT(INT64_MAX - offset >= int64_t(aCount));
if (!FileQuotaStreamWithWrite::mQuotaObject->MaybeUpdateSize(
offset + int64_t(aCount),
/* aTruncate */ false)) {
*_retval = 0;
return NS_ERROR_FILE_NO_DEVICE_SPACE;
}
}
QM_TRY(MOZ_TO_RESULT(FileStreamBase::Write(aBuf, aCount, _retval)));
return NS_OK;
}
mozilla::ipc::RandomAccessStreamParams FileRandomAccessStream::Serialize(
nsIInterfaceRequestor* aCallbacks) {
MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
MOZ_RELEASE_ASSERT(!mDeserialized);
MOZ_ASSERT(mOpenParams.localFile);
QuotaManager* quotaManager = QuotaManager::Get();
MOZ_ASSERT(quotaManager);
RefPtr<QuotaObject> quotaObject = quotaManager->GetQuotaObject(
mPersistenceType, mOriginMetadata, mClientType, mOpenParams.localFile);
MOZ_ASSERT(quotaObject);
IPCQuotaObject ipcQuotaObject = quotaObject->Serialize(aCallbacks);
mozilla::ipc::RandomAccessStreamParams randomAccessStreamParams =
nsFileRandomAccessStream::Serialize(aCallbacks);
MOZ_ASSERT(
randomAccessStreamParams.type() ==
mozilla::ipc::RandomAccessStreamParams::TFileRandomAccessStreamParams);
mozilla::ipc::LimitingFileRandomAccessStreamParams
limitingFileRandomAccessStreamParams;
limitingFileRandomAccessStreamParams.fileRandomAccessStreamParams() =
std::move(randomAccessStreamParams);
limitingFileRandomAccessStreamParams.quotaObject() =
std::move(ipcQuotaObject);
return limitingFileRandomAccessStreamParams;
}
bool FileRandomAccessStream::Deserialize(
mozilla::ipc::RandomAccessStreamParams& aParams) {
MOZ_ASSERT(aParams.type() == mozilla::ipc::RandomAccessStreamParams::
TLimitingFileRandomAccessStreamParams);
auto& params = aParams.get_LimitingFileRandomAccessStreamParams();
mozilla::ipc::RandomAccessStreamParams randomAccessStreamParams(
std::move(params.fileRandomAccessStreamParams()));
QM_TRY(MOZ_TO_RESULT(
nsFileRandomAccessStream::Deserialize(randomAccessStreamParams)),
false);
mQuotaObject = QuotaObject::Deserialize(params.quotaObject());
return true;
}
Result<MovingNotNull<nsCOMPtr<nsIInputStream>>, nsresult> CreateFileInputStream(
PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
Client::Type aClientType, nsIFile* aFile, int32_t aIOFlags, int32_t aPerm,
int32_t aBehaviorFlags) {
auto stream = MakeRefPtr<FileInputStream>(aPersistenceType, aOriginMetadata,
aClientType);
QM_TRY(MOZ_TO_RESULT(stream->Init(aFile, aIOFlags, aPerm, aBehaviorFlags)));
return WrapMovingNotNullUnchecked(
nsCOMPtr<nsIInputStream>(std::move(stream)));
}
Result<MovingNotNull<nsCOMPtr<nsIOutputStream>>, nsresult>
CreateFileOutputStream(PersistenceType aPersistenceType,
const OriginMetadata& aOriginMetadata,
Client::Type aClientType, nsIFile* aFile,
int32_t aIOFlags, int32_t aPerm,
int32_t aBehaviorFlags) {
auto stream = MakeRefPtr<FileOutputStream>(aPersistenceType, aOriginMetadata,
aClientType);
QM_TRY(MOZ_TO_RESULT(stream->Init(aFile, aIOFlags, aPerm, aBehaviorFlags)));
return WrapMovingNotNullUnchecked(
nsCOMPtr<nsIOutputStream>(std::move(stream)));
}
Result<MovingNotNull<nsCOMPtr<nsIRandomAccessStream>>, nsresult>
CreateFileRandomAccessStream(PersistenceType aPersistenceType,
const OriginMetadata& aOriginMetadata,
Client::Type aClientType, nsIFile* aFile,
int32_t aIOFlags, int32_t aPerm,
int32_t aBehaviorFlags) {
auto stream = MakeRefPtr<FileRandomAccessStream>(
aPersistenceType, aOriginMetadata, aClientType);
QM_TRY(MOZ_TO_RESULT(stream->Init(aFile, aIOFlags, aPerm, aBehaviorFlags)));
return WrapMovingNotNullUnchecked(
nsCOMPtr<nsIRandomAccessStream>(std::move(stream)));
}
} // namespace mozilla::dom::quota