mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
e52329c788
The bulk of this commit was generated by running:
run-clang-tidy.py \
-checks='-*,llvm-namespace-comment' \
-header-filter=^/.../mozilla-central/.* \
-fix
412 lines
11 KiB
C++
412 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "IDBMutableFile.h"
|
|
|
|
#include "FileSnapshot.h"
|
|
#include "FileInfo.h"
|
|
#include "IDBDatabase.h"
|
|
#include "IDBFactory.h"
|
|
#include "IDBFileHandle.h"
|
|
#include "IDBFileRequest.h"
|
|
#include "IndexedDatabaseManager.h"
|
|
#include "MainThreadUtils.h"
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/ErrorResult.h"
|
|
#include "mozilla/dom/FileService.h"
|
|
#include "mozilla/dom/IDBMutableFileBinding.h"
|
|
#include "mozilla/dom/MetadataHelper.h"
|
|
#include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.h"
|
|
#include "mozilla/dom/quota/FileStreams.h"
|
|
#include "mozilla/dom/quota/QuotaManager.h"
|
|
#include "mozilla/ipc/BackgroundUtils.h"
|
|
#include "mozilla/ipc/PBackgroundSharedTypes.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsDebug.h"
|
|
#include "nsError.h"
|
|
#include "nsIPrincipal.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
namespace indexedDB {
|
|
|
|
using namespace mozilla::dom::quota;
|
|
using namespace mozilla::ipc;
|
|
|
|
namespace {
|
|
|
|
class GetFileHelper : public MetadataHelper
|
|
{
|
|
public:
|
|
GetFileHelper(FileHandleBase* aFileHandle,
|
|
FileRequestBase* aFileRequest,
|
|
MetadataParameters* aParams,
|
|
IDBMutableFile* aMutableFile)
|
|
: MetadataHelper(aFileHandle, aFileRequest, aParams),
|
|
mMutableFile(aMutableFile)
|
|
{ }
|
|
|
|
virtual nsresult
|
|
GetSuccessResult(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aVal) override;
|
|
|
|
virtual void
|
|
ReleaseObjects() override
|
|
{
|
|
mMutableFile = nullptr;
|
|
MetadataHelper::ReleaseObjects();
|
|
}
|
|
|
|
private:
|
|
nsRefPtr<IDBMutableFile> mMutableFile;
|
|
};
|
|
|
|
already_AddRefed<nsIFile>
|
|
GetFileFor(FileInfo* aFileInfo)
|
|
{
|
|
MOZ_ASSERT(IndexedDatabaseManager::IsMainProcess());
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(aFileInfo);
|
|
|
|
FileManager* fileManager = aFileInfo->Manager();
|
|
MOZ_ASSERT(fileManager);
|
|
|
|
nsCOMPtr<nsIFile> directory = fileManager->GetDirectory();
|
|
if (NS_WARN_IF(!directory)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> file =
|
|
fileManager->GetFileForId(directory, aFileInfo->Id());
|
|
if (NS_WARN_IF(!file)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return file.forget();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
IDBMutableFile::IDBMutableFile(IDBDatabase* aDatabase,
|
|
const nsAString& aName,
|
|
const nsAString& aType,
|
|
already_AddRefed<FileInfo> aFileInfo,
|
|
const nsACString& aGroup,
|
|
const nsACString& aOrigin,
|
|
const nsACString& aStorageId,
|
|
PersistenceType aPersistenceType,
|
|
already_AddRefed<nsIFile> aFile)
|
|
: DOMEventTargetHelper(aDatabase)
|
|
, mDatabase(aDatabase)
|
|
, mFileInfo(aFileInfo)
|
|
, mGroup(aGroup)
|
|
, mOrigin(aOrigin)
|
|
, mPersistenceType(aPersistenceType)
|
|
, mInvalidated(false)
|
|
{
|
|
MOZ_ASSERT(IndexedDatabaseManager::IsMainProcess());
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(mDatabase);
|
|
MOZ_ASSERT(mFileInfo);
|
|
|
|
mName = aName;
|
|
mType = aType;
|
|
mFile = aFile;
|
|
mStorageId = aStorageId;
|
|
mFileName.AppendInt(mFileInfo->Id());
|
|
|
|
MOZ_ASSERT(mFile);
|
|
|
|
mDatabase->NoteLiveMutableFile(this);
|
|
}
|
|
|
|
IDBMutableFile::~IDBMutableFile()
|
|
{
|
|
// XXX This is always in the main process but it sometimes happens too late in
|
|
// shutdown and the IndexedDatabaseManager has already been torn down.
|
|
// MOZ_ASSERT(IndexedDatabaseManager::IsMainProcess());
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (mDatabase) {
|
|
mDatabase->NoteFinishedMutableFile(this);
|
|
}
|
|
}
|
|
|
|
// static
|
|
already_AddRefed<IDBMutableFile>
|
|
IDBMutableFile::Create(IDBDatabase* aDatabase,
|
|
const nsAString& aName,
|
|
const nsAString& aType,
|
|
already_AddRefed<FileInfo> aFileInfo)
|
|
{
|
|
MOZ_ASSERT(IndexedDatabaseManager::IsMainProcess());
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsRefPtr<FileInfo> fileInfo(aFileInfo);
|
|
MOZ_ASSERT(fileInfo);
|
|
|
|
PrincipalInfo* principalInfo = aDatabase->Factory()->GetPrincipalInfo();
|
|
MOZ_ASSERT(principalInfo);
|
|
|
|
nsCOMPtr<nsIPrincipal> principal = PrincipalInfoToPrincipal(*principalInfo);
|
|
if (NS_WARN_IF(!principal)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCString group;
|
|
nsCString origin;
|
|
if (NS_WARN_IF(NS_FAILED(QuotaManager::GetInfoFromPrincipal(principal,
|
|
&group,
|
|
&origin,
|
|
nullptr)))) {
|
|
return nullptr;
|
|
}
|
|
|
|
const DatabaseSpec* spec = aDatabase->Spec();
|
|
MOZ_ASSERT(spec);
|
|
|
|
const DatabaseMetadata& metadata = spec->metadata();
|
|
|
|
PersistenceType persistenceType = metadata.persistenceType();
|
|
|
|
nsCString storageId;
|
|
QuotaManager::GetStorageId(persistenceType,
|
|
origin,
|
|
Client::IDB,
|
|
storageId);
|
|
|
|
storageId.Append('*');
|
|
storageId.Append(NS_ConvertUTF16toUTF8(metadata.name()));
|
|
|
|
nsCOMPtr<nsIFile> file = GetFileFor(fileInfo);
|
|
if (NS_WARN_IF(!file)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsRefPtr<IDBMutableFile> newFile =
|
|
new IDBMutableFile(aDatabase,
|
|
aName,
|
|
aType,
|
|
fileInfo.forget(),
|
|
group,
|
|
origin,
|
|
storageId,
|
|
persistenceType,
|
|
file.forget());
|
|
|
|
return newFile.forget();
|
|
}
|
|
|
|
void
|
|
IDBMutableFile::Invalidate()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(!mInvalidated);
|
|
|
|
mInvalidated = true;
|
|
}
|
|
|
|
NS_IMPL_ADDREF_INHERITED(IDBMutableFile, DOMEventTargetHelper)
|
|
NS_IMPL_RELEASE_INHERITED(IDBMutableFile, DOMEventTargetHelper)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(IDBMutableFile)
|
|
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(IDBMutableFile)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(IDBMutableFile,
|
|
DOMEventTargetHelper)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDatabase)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(IDBMutableFile,
|
|
DOMEventTargetHelper)
|
|
MOZ_ASSERT(tmp->mDatabase);
|
|
tmp->mDatabase->NoteFinishedMutableFile(tmp);
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mDatabase)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
bool
|
|
IDBMutableFile::IsInvalid()
|
|
{
|
|
return mInvalidated;
|
|
}
|
|
|
|
nsIOfflineStorage*
|
|
IDBMutableFile::Storage()
|
|
{
|
|
MOZ_CRASH("Don't call me!");
|
|
}
|
|
|
|
already_AddRefed<nsISupports>
|
|
IDBMutableFile::CreateStream(bool aReadOnly)
|
|
{
|
|
MOZ_ASSERT(IndexedDatabaseManager::IsMainProcess());
|
|
|
|
nsCOMPtr<nsISupports> result;
|
|
|
|
if (aReadOnly) {
|
|
nsRefPtr<FileInputStream> stream =
|
|
FileInputStream::Create(mPersistenceType,
|
|
mGroup,
|
|
mOrigin,
|
|
mFile,
|
|
-1,
|
|
-1,
|
|
nsIFileInputStream::DEFER_OPEN);
|
|
result = NS_ISUPPORTS_CAST(nsIFileInputStream*, stream);
|
|
} else {
|
|
nsRefPtr<FileStream> stream =
|
|
FileStream::Create(mPersistenceType,
|
|
mGroup,
|
|
mOrigin,
|
|
mFile,
|
|
-1,
|
|
-1,
|
|
nsIFileStream::DEFER_OPEN);
|
|
result = NS_ISUPPORTS_CAST(nsIFileStream*, stream);
|
|
}
|
|
|
|
if (NS_WARN_IF(!result)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return result.forget();
|
|
}
|
|
|
|
JSObject*
|
|
IDBMutableFile::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
|
|
{
|
|
MOZ_ASSERT(IndexedDatabaseManager::IsMainProcess());
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
return IDBMutableFileBinding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
IDBDatabase*
|
|
IDBMutableFile::Database() const
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
return mDatabase;
|
|
}
|
|
|
|
already_AddRefed<IDBFileHandle>
|
|
IDBMutableFile::Open(FileMode aMode, ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (QuotaManager::IsShuttingDown() || FileService::IsShuttingDown()) {
|
|
aError.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
if (mDatabase->IsClosed()) {
|
|
aError.Throw(NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
MOZ_ASSERT(GetOwner());
|
|
|
|
nsRefPtr<IDBFileHandle> fileHandle =
|
|
IDBFileHandle::Create(aMode, FileHandleBase::NORMAL, this);
|
|
if (!fileHandle) {
|
|
aError.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
return fileHandle.forget();
|
|
}
|
|
|
|
int64_t
|
|
IDBMutableFile::GetFileId() const
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(mFileInfo);
|
|
|
|
return mFileInfo->Id();
|
|
}
|
|
|
|
already_AddRefed<File>
|
|
IDBMutableFile::CreateFileObject(IDBFileHandle* aFileHandle,
|
|
MetadataParameters* aMetadataParams)
|
|
{
|
|
nsRefPtr<BlobImpl> impl =
|
|
new BlobImplSnapshot(mName,
|
|
mType,
|
|
aMetadataParams,
|
|
mFile,
|
|
aFileHandle,
|
|
mFileInfo);
|
|
|
|
nsRefPtr<File> file = File::Create(GetOwner(), impl);
|
|
MOZ_ASSERT(file);
|
|
|
|
return file.forget();
|
|
}
|
|
|
|
already_AddRefed<DOMRequest>
|
|
IDBMutableFile::GetFile(ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (QuotaManager::IsShuttingDown() || FileService::IsShuttingDown()) {
|
|
aError.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
if (mDatabase->IsClosed()) {
|
|
aError.Throw(NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
MOZ_ASSERT(GetOwner());
|
|
|
|
nsRefPtr<IDBFileHandle> fileHandle =
|
|
IDBFileHandle::Create(FileMode::Readonly, FileHandleBase::PARALLEL, this);
|
|
|
|
nsRefPtr<IDBFileRequest> request =
|
|
IDBFileRequest::Create(GetOwner(),
|
|
fileHandle,
|
|
/* aWrapAsDOMRequest */ true);
|
|
|
|
nsRefPtr<MetadataParameters> params = new MetadataParameters(true, true);
|
|
|
|
nsRefPtr<GetFileHelper> helper =
|
|
new GetFileHelper(fileHandle, request, params, this);
|
|
|
|
nsresult rv = helper->Enqueue();
|
|
if (NS_FAILED(rv)) {
|
|
aError.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
return request.forget();
|
|
}
|
|
|
|
nsresult
|
|
GetFileHelper::GetSuccessResult(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aVal)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
auto fileHandle = static_cast<IDBFileHandle*>(mFileHandle.get());
|
|
|
|
nsRefPtr<File> domFile =
|
|
mMutableFile->CreateFileObject(fileHandle, mParams);
|
|
|
|
if (!ToJSValue(aCx, domFile, aVal)) {
|
|
return NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
} // namespace indexedDB
|
|
} // namespace dom
|
|
} // namespace mozilla
|