diff options
Diffstat (limited to 'dom/indexedDB')
36 files changed, 1505 insertions, 435 deletions
diff --git a/dom/indexedDB/ActorsChild.cpp b/dom/indexedDB/ActorsChild.cpp index a6f3ef7789..1a122ea3c1 100644 --- a/dom/indexedDB/ActorsChild.cpp +++ b/dom/indexedDB/ActorsChild.cpp @@ -1429,7 +1429,7 @@ mozilla::ipc::IPCResult BackgroundTransactionChild::RecvComplete( PBackgroundIDBRequestChild* BackgroundTransactionChild::AllocPBackgroundIDBRequestChild( - const RequestParams& aParams) { + const int64_t& aRequestId, const RequestParams& aParams) { MOZ_CRASH( "PBackgroundIDBRequestChild actors should be manually " "constructed!"); @@ -1445,7 +1445,7 @@ bool BackgroundTransactionChild::DeallocPBackgroundIDBRequestChild( PBackgroundIDBCursorChild* BackgroundTransactionChild::AllocPBackgroundIDBCursorChild( - const OpenCursorParams& aParams) { + const int64_t& aRequestId, const OpenCursorParams& aParams) { AssertIsOnOwningThread(); MOZ_CRASH("PBackgroundIDBCursorChild actors should be manually constructed!"); @@ -1547,7 +1547,7 @@ mozilla::ipc::IPCResult BackgroundVersionChangeTransactionChild::RecvComplete( PBackgroundIDBRequestChild* BackgroundVersionChangeTransactionChild::AllocPBackgroundIDBRequestChild( - const RequestParams& aParams) { + const int64_t& aRequestId, const RequestParams& aParams) { MOZ_CRASH( "PBackgroundIDBRequestChild actors should be manually " "constructed!"); @@ -1563,7 +1563,7 @@ bool BackgroundVersionChangeTransactionChild::DeallocPBackgroundIDBRequestChild( PBackgroundIDBCursorChild* BackgroundVersionChangeTransactionChild::AllocPBackgroundIDBCursorChild( - const OpenCursorParams& aParams) { + const int64_t& aRequestId, const OpenCursorParams& aParams) { AssertIsOnOwningThread(); MOZ_CRASH("PBackgroundIDBCursorChild actors should be manually constructed!"); @@ -2211,7 +2211,7 @@ BackgroundCursorChild<CursorType>::SafeRefPtrFromThis() { template <IDBCursorType CursorType> void BackgroundCursorChild<CursorType>::SendContinueInternal( - const CursorRequestParams& aParams, + const int64_t aRequestId, const CursorRequestParams& aParams, const CursorData<CursorType>& aCurrentData) { AssertIsOnOwningThread(); MOZ_ASSERT(mRequest); @@ -2394,7 +2394,7 @@ void BackgroundCursorChild<CursorType>::SendContinueInternal( // handling model disallow this? } else { MOZ_ALWAYS_TRUE(PBackgroundIDBCursorChild::SendContinue( - params, currentKey, currentObjectStoreKey)); + aRequestId, params, currentKey, currentObjectStoreKey)); } } diff --git a/dom/indexedDB/ActorsChild.h b/dom/indexedDB/ActorsChild.h index e3e204be0b..194ed28878 100644 --- a/dom/indexedDB/ActorsChild.h +++ b/dom/indexedDB/ActorsChild.h @@ -347,12 +347,12 @@ class BackgroundTransactionChild final : public BackgroundTransactionBase, mozilla::ipc::IPCResult RecvComplete(nsresult aResult); PBackgroundIDBRequestChild* AllocPBackgroundIDBRequestChild( - const RequestParams& aParams); + const int64_t& aRequestId, const RequestParams& aParams); bool DeallocPBackgroundIDBRequestChild(PBackgroundIDBRequestChild* aActor); PBackgroundIDBCursorChild* AllocPBackgroundIDBCursorChild( - const OpenCursorParams& aParams); + const int64_t& aRequestId, const OpenCursorParams& aParams); bool DeallocPBackgroundIDBCursorChild(PBackgroundIDBCursorChild* aActor); }; @@ -393,12 +393,12 @@ class BackgroundVersionChangeTransactionChild final mozilla::ipc::IPCResult RecvComplete(nsresult aResult); PBackgroundIDBRequestChild* AllocPBackgroundIDBRequestChild( - const RequestParams& aParams); + const int64_t& aRequestId, const RequestParams& aParams); bool DeallocPBackgroundIDBRequestChild(PBackgroundIDBRequestChild* aActor); PBackgroundIDBCursorChild* AllocPBackgroundIDBCursorChild( - const OpenCursorParams& aParams); + const int64_t& aRequestId, const OpenCursorParams& aParams); bool DeallocPBackgroundIDBCursorChild(PBackgroundIDBCursorChild* aActor); }; @@ -548,7 +548,8 @@ class BackgroundCursorChild final : public BackgroundCursorChildBase { BackgroundCursorChild(NotNull<IDBRequest*> aRequest, SourceType* aSource, Direction aDirection); - void SendContinueInternal(const CursorRequestParams& aParams, + void SendContinueInternal(const int64_t aRequestId, + const CursorRequestParams& aParams, const CursorData<CursorType>& aCurrentData); void InvalidateCachedResponses(); @@ -594,7 +595,8 @@ class BackgroundCursorChild final : public BackgroundCursorChildBase { mozilla::ipc::IPCResult RecvResponse(CursorResponse&& aResponse) override; // Force callers to use SendContinueInternal. - bool SendContinue(const CursorRequestParams& aParams, const Key& aCurrentKey, + bool SendContinue(const int64_t& aRequestId, + const CursorRequestParams& aParams, const Key& aCurrentKey, const Key& aCurrentObjectStoreKey) = delete; bool SendDeleteMe() = delete; diff --git a/dom/indexedDB/ActorsParent.cpp b/dom/indexedDB/ActorsParent.cpp index 47360094ca..6609ea5b81 100644 --- a/dom/indexedDB/ActorsParent.cpp +++ b/dom/indexedDB/ActorsParent.cpp @@ -94,6 +94,7 @@ #include "mozilla/dom/FileBlobImpl.h" #include "mozilla/dom/FlippedOnce.h" #include "mozilla/dom/IDBCursorBinding.h" +#include "mozilla/dom/IDBFactory.h" #include "mozilla/dom/IPCBlob.h" #include "mozilla/dom/IPCBlobUtils.h" #include "mozilla/dom/IndexedDatabase.h" @@ -122,6 +123,7 @@ #include "mozilla/dom/quota/CheckedUnsafePtr.h" #include "mozilla/dom/quota/Client.h" #include "mozilla/dom/quota/ClientImpl.h" +#include "mozilla/dom/quota/DebugOnlyMacro.h" #include "mozilla/dom/quota/DirectoryLock.h" #include "mozilla/dom/quota/DecryptingInputStream_impl.h" #include "mozilla/dom/quota/EncryptingOutputStream_impl.h" @@ -1973,6 +1975,10 @@ class TransactionDatabaseOperationBase : public DatabaseOperationBase { }; InitializedOnce<const NotNull<SafeRefPtr<TransactionBase>>> mTransaction; + // Unique request id within the context of the transaction, allocated by the + // transaction in the content process starting from 0. Values less than 0 are + // impossible and forbidden. Used to support the explicit commit() request. + const int64_t mRequestId; InternalState mInternalState = InternalState::Initial; bool mWaitingForContinue = false; const bool mTransactionIsAborted; @@ -2034,10 +2040,11 @@ class TransactionDatabaseOperationBase : public DatabaseOperationBase { virtual void Cleanup(); protected: - explicit TransactionDatabaseOperationBase( - SafeRefPtr<TransactionBase> aTransaction); + TransactionDatabaseOperationBase(SafeRefPtr<TransactionBase> aTransaction, + int64_t aRequestId); TransactionDatabaseOperationBase(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, uint64_t aLoggingSerialNumber); ~TransactionDatabaseOperationBase() override; @@ -2141,6 +2148,14 @@ class Factory final : public PBackgroundIDBFactoryParent, bool DeallocPBackgroundIDBFactoryRequestParent( PBackgroundIDBFactoryRequestParent* aActor) override; + + mozilla::ipc::IPCResult RecvGetDatabases( + const PersistenceType& aPersistenceType, + const PrincipalInfo& aPrincipalInfo, + GetDatabasesResolver&& aResolve) override; + + private: + Maybe<ContentParentId> GetContentParentId() const; }; class WaitForTransactionsHelper final : public Runnable { @@ -2395,11 +2410,13 @@ class Database final already_AddRefed<PBackgroundIDBTransactionParent> AllocPBackgroundIDBTransactionParent( - const nsTArray<nsString>& aObjectStoreNames, const Mode& aMode) override; + const nsTArray<nsString>& aObjectStoreNames, const Mode& aMode, + const Durability& aDurability) override; mozilla::ipc::IPCResult RecvPBackgroundIDBTransactionConstructor( PBackgroundIDBTransactionParent* aActor, - nsTArray<nsString>&& aObjectStoreNames, const Mode& aMode) override; + nsTArray<nsString>&& aObjectStoreNames, const Mode& aMode, + const Durability& aDurability) override; mozilla::ipc::IPCResult RecvDeleteMe() override; @@ -2418,6 +2435,7 @@ class Database::StartTransactionOp final private: explicit StartTransactionOp(SafeRefPtr<TransactionBase> aTransaction) : TransactionDatabaseOperationBase(std::move(aTransaction), + /* aRequestId */ 0, /* aLoggingSerialNumber */ 0) {} ~StartTransactionOp() override = default; @@ -2591,6 +2609,7 @@ class TransactionBase : public AtomicSafeRefCounted<TransactionBase> { protected: using Mode = IDBTransaction::Mode; + using Durability = IDBTransaction::Durability; private: const SafeRefPtr<Database> mDatabase; @@ -2602,6 +2621,7 @@ class TransactionBase : public AtomicSafeRefCounted<TransactionBase> { uint64_t mActiveRequestCount; Atomic<bool> mInvalidatedOnAnyThread; const Mode mMode; + const Durability mDurability; // TODO: See bug 1883045 FlippedOnce<false> mInitialized; FlippedOnce<false> mHasBeenActiveOnConnectionThread; FlippedOnce<false> mActorDestroyed; @@ -2661,6 +2681,8 @@ class TransactionBase : public AtomicSafeRefCounted<TransactionBase> { Mode GetMode() const { return mMode; } + Durability GetDurability() const { return mDurability; } + const Database& GetDatabase() const { MOZ_ASSERT(mDatabase); @@ -2723,7 +2745,8 @@ class TransactionBase : public AtomicSafeRefCounted<TransactionBase> { virtual ~TransactionBase(); protected: - TransactionBase(SafeRefPtr<Database> aDatabase, Mode aMode); + TransactionBase(SafeRefPtr<Database> aDatabase, Mode aMode, + Durability aDurability); void NoteActorDestroyed() { AssertIsOnBackgroundThread(); @@ -2765,7 +2788,8 @@ class TransactionBase : public AtomicSafeRefCounted<TransactionBase> { CommitOrAbort(); } - PBackgroundIDBRequestParent* AllocRequest(RequestParams&& aParams, + PBackgroundIDBRequestParent* AllocRequest(const int64_t aRequestId, + RequestParams&& aParams, bool aTrustParams); bool StartRequest(PBackgroundIDBRequestParent* aActor); @@ -2775,7 +2799,7 @@ class TransactionBase : public AtomicSafeRefCounted<TransactionBase> { already_AddRefed<PBackgroundIDBCursorParent> AllocCursor( const OpenCursorParams& aParams, bool aTrustParams); - bool StartCursor(PBackgroundIDBCursorParent* aActor, + bool StartCursor(PBackgroundIDBCursorParent* aActor, const int64_t aRequestId, const OpenCursorParams& aParams); virtual void UpdateMetadata(nsresult aResult) {} @@ -2858,26 +2882,27 @@ class NormalTransaction final : public TransactionBase, mozilla::ipc::IPCResult RecvAbort(const nsresult& aResultCode) override; PBackgroundIDBRequestParent* AllocPBackgroundIDBRequestParent( - const RequestParams& aParams) override; + const int64_t& aRequestId, const RequestParams& aParams) override; mozilla::ipc::IPCResult RecvPBackgroundIDBRequestConstructor( - PBackgroundIDBRequestParent* aActor, + PBackgroundIDBRequestParent* aActor, const int64_t& aRequestId, const RequestParams& aParams) override; bool DeallocPBackgroundIDBRequestParent( PBackgroundIDBRequestParent* aActor) override; already_AddRefed<PBackgroundIDBCursorParent> AllocPBackgroundIDBCursorParent( - const OpenCursorParams& aParams) override; + const int64_t& aRequestId, const OpenCursorParams& aParams) override; mozilla::ipc::IPCResult RecvPBackgroundIDBCursorConstructor( - PBackgroundIDBCursorParent* aActor, + PBackgroundIDBCursorParent* aActor, const int64_t& aRequestId, const OpenCursorParams& aParams) override; public: // This constructor is only called by Database. NormalTransaction( SafeRefPtr<Database> aDatabase, TransactionBase::Mode aMode, + TransactionBase::Durability aDurability, nsTArray<SafeRefPtr<FullObjectStoreMetadata>>&& aObjectStores); MOZ_INLINE_DECL_SAFEREFCOUNTING_INHERITED(NormalTransaction, TransactionBase) @@ -2950,26 +2975,25 @@ class VersionChangeTransaction final const IndexOrObjectStoreId& aIndexId, const nsAString& aName) override; PBackgroundIDBRequestParent* AllocPBackgroundIDBRequestParent( - const RequestParams& aParams) override; + const int64_t& aRequestId, const RequestParams& aParams) override; mozilla::ipc::IPCResult RecvPBackgroundIDBRequestConstructor( - PBackgroundIDBRequestParent* aActor, + PBackgroundIDBRequestParent* aActor, const int64_t& aRequestId, const RequestParams& aParams) override; bool DeallocPBackgroundIDBRequestParent( PBackgroundIDBRequestParent* aActor) override; already_AddRefed<PBackgroundIDBCursorParent> AllocPBackgroundIDBCursorParent( - const OpenCursorParams& aParams) override; + const int64_t& aRequestId, const OpenCursorParams& aParams) override; mozilla::ipc::IPCResult RecvPBackgroundIDBCursorConstructor( - PBackgroundIDBCursorParent* aActor, + PBackgroundIDBCursorParent* aActor, const int64_t& aRequestId, const OpenCursorParams& aParams) override; }; class FactoryOp : public DatabaseOperationBase, - public PBackgroundIDBFactoryRequestParent, public SupportsCheckedUnsafePtr<CheckIf<DiagnosticAssertEnabled>> { public: struct MaybeBlockedDatabaseInfo final { @@ -3008,9 +3032,20 @@ class FactoryOp // Waiting for directory open allowed on the PBackground thread. The next // step is either SendingResults if directory lock failed to acquire, or - // DatabaseOpenPending if directory lock is acquired. + // DirectoryWorkOpen if the factory operation is not tied up to a specific + // database, or DatabaseOpenPending otherwise. DirectoryOpenPending, + // Waiting to do/doing directory work on the QuotaManager IO thread. Its + // next step is DirectoryWorkDone if directory work was successful or + // SendingResults if directory work failed. + DirectoryWorkOpen, + + // Checking if database work can be started. If the database is not blocked + // by other factory operations then the next step is DatabaseWorkOpen. + // Otherwise the next step is DatabaseOpenPending. + DirectoryWorkDone, + // Waiting for database open allowed on the PBackground thread. The next // step is DatabaseWorkOpen. DatabaseOpenPending, @@ -3060,14 +3095,18 @@ class FactoryOp // Must be released on the main thread! RefPtr<DirectoryLock> mDirectoryLock; - RefPtr<FactoryOp> mDelayedOp; + nsTArray<NotNull<RefPtr<FactoryOp>>> mBlocking; + nsTArray<NotNull<RefPtr<FactoryOp>>> mBlockedOn; + nsTArray<MaybeBlockedDatabaseInfo> mMaybeBlockedDatabases; - const CommonFactoryRequestParams mCommonParams; + const PrincipalInfo mPrincipalInfo; OriginMetadata mOriginMetadata; - nsCString mDatabaseId; - nsString mDatabaseFilePath; + Maybe<nsString> mDatabaseName; + Maybe<nsCString> mDatabaseId; + Maybe<nsString> mDatabaseFilePath; int64_t mDirectoryLockId; + const PersistenceType mPersistenceType; State mState; bool mWaitingForPermissionRetry; bool mEnforcingQuota; @@ -3081,17 +3120,23 @@ class FactoryOp return mOriginMetadata.mOrigin; } + const Maybe<nsString>& DatabaseNameRef() const { + AssertIsOnOwningThread(); + + return mDatabaseName; + } + bool DatabaseFilePathIsKnown() const { AssertIsOnOwningThread(); - return !mDatabaseFilePath.IsEmpty(); + return mDatabaseFilePath.isSome(); } const nsAString& DatabaseFilePath() const { AssertIsOnOwningThread(); - MOZ_ASSERT(!mDatabaseFilePath.IsEmpty()); + MOZ_ASSERT(mDatabaseFilePath); - return mDatabaseFilePath; + return mDatabaseFilePath.ref(); } void NoteDatabaseBlocked(Database* aDatabase); @@ -3109,7 +3154,9 @@ class FactoryOp protected: FactoryOp(SafeRefPtr<Factory> aFactory, const Maybe<ContentParentId>& aContentParentId, - const CommonFactoryRequestParams& aCommonParams, bool aDeleting); + const PersistenceType aPersistenceType, + const PrincipalInfo& aPrincipalInfo, + const Maybe<nsString>& aDatabaseName, bool aDeleting); ~FactoryOp() override { // Normally this would be out-of-line since it is a virtual function but @@ -3122,6 +3169,8 @@ class FactoryOp nsresult DirectoryOpen(); + nsresult DirectoryWorkDone(); + nsresult SendToIOThread(); void WaitForTransactions(); @@ -3136,6 +3185,8 @@ class FactoryOp const Maybe<uint64_t>& aNewVersion); // Methods that subclasses must implement. + virtual nsresult DoDirectoryWork() = 0; + virtual nsresult DatabaseOpen() = 0; virtual nsresult DoDatabaseWork() = 0; @@ -3157,17 +3208,56 @@ class FactoryOp void DirectoryLockFailed(); - // IPDL methods. - void ActorDestroy(ActorDestroyReason aWhy) override; - virtual void SendBlockedNotification() = 0; private: // Test whether this FactoryOp needs to wait for the given op. bool MustWaitFor(const FactoryOp& aExistingOp); + + void AddBlockingOp(FactoryOp& aOp) { + AssertIsOnOwningThread(); + + mBlocking.AppendElement(WrapNotNull(&aOp)); + } + + void AddBlockedOnOp(FactoryOp& aOp) { + AssertIsOnOwningThread(); + + mBlockedOn.AppendElement(WrapNotNull(&aOp)); + } + + void MaybeUnblock(FactoryOp& aOp) { + AssertIsOnOwningThread(); + + mBlockedOn.RemoveElement(&aOp); + if (mBlockedOn.IsEmpty()) { + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(this)); + } + } +}; + +class FactoryRequestOp : public FactoryOp, + public PBackgroundIDBFactoryRequestParent { + protected: + const CommonFactoryRequestParams mCommonParams; + + FactoryRequestOp(SafeRefPtr<Factory> aFactory, + const Maybe<ContentParentId>& aContentParentId, + const CommonFactoryRequestParams& aCommonParams, + bool aDeleting) + : FactoryOp(std::move(aFactory), aContentParentId, + aCommonParams.metadata().persistenceType(), + aCommonParams.principalInfo(), + Some(aCommonParams.metadata().name()), aDeleting), + mCommonParams(aCommonParams) {} + + nsresult DoDirectoryWork() override; + + // IPDL methods. + void ActorDestroy(ActorDestroyReason aWhy) override; }; -class OpenDatabaseOp final : public FactoryOp { +class OpenDatabaseOp final : public FactoryRequestOp { friend class Database; friend class VersionChangeTransaction; @@ -3249,7 +3339,7 @@ class OpenDatabaseOp::VersionChangeOp final explicit VersionChangeOp(OpenDatabaseOp* aOpenDatabaseOp) : TransactionDatabaseOperationBase( aOpenDatabaseOp->mVersionChangeTransaction.clonePtr(), - aOpenDatabaseOp->LoggingSerialNumber()), + /* aRequestId */ 0, aOpenDatabaseOp->LoggingSerialNumber()), mOpenDatabaseOp(aOpenDatabaseOp), mRequestedVersion(aOpenDatabaseOp->mRequestedVersion), mPreviousVersion( @@ -3269,7 +3359,7 @@ class OpenDatabaseOp::VersionChangeOp final void Cleanup() override; }; -class DeleteDatabaseOp final : public FactoryOp { +class DeleteDatabaseOp final : public FactoryRequestOp { class VersionChangeOp; nsString mDatabaseDirectoryPath; @@ -3280,8 +3370,8 @@ class DeleteDatabaseOp final : public FactoryOp { DeleteDatabaseOp(SafeRefPtr<Factory> aFactory, const Maybe<ContentParentId>& aContentParentId, const CommonFactoryRequestParams& aParams) - : FactoryOp(std::move(aFactory), aContentParentId, aParams, - /* aDeleting */ true), + : FactoryRequestOp(std::move(aFactory), aContentParentId, aParams, + /* aDeleting */ true), mPreviousVersion(0) {} private: @@ -3327,6 +3417,43 @@ class DeleteDatabaseOp::VersionChangeOp final : public DatabaseOperationBase { NS_DECL_NSIRUNNABLE }; +class GetDatabasesOp final : public FactoryOp { + nsTHashMap<nsStringHashKey, DatabaseMetadata> mDatabaseMetadataTable; + nsTArray<DatabaseMetadata> mDatabaseMetadataArray; + Factory::GetDatabasesResolver mResolver; + + public: + GetDatabasesOp(SafeRefPtr<Factory> aFactory, + const Maybe<ContentParentId>& aContentParentId, + const PersistenceType aPersistenceType, + const PrincipalInfo& aPrincipalInfo, + Factory::GetDatabasesResolver&& aResolver) + : FactoryOp(std::move(aFactory), aContentParentId, aPersistenceType, + aPrincipalInfo, Nothing(), /* aDeleting */ false), + mResolver(std::move(aResolver)) {} + + private: + ~GetDatabasesOp() override = default; + + nsresult DatabasesNotAvailable(); + + nsresult DoDirectoryWork() override; + + nsresult DatabaseOpen() override; + + nsresult DoDatabaseWork() override; + + nsresult BeginVersionChange() override; + + bool AreActorsAlive() override; + + void SendBlockedNotification() override; + + nsresult DispatchToWorkThread() override; + + void SendResults() override; +}; + class VersionChangeTransactionOp : public TransactionDatabaseOperationBase { public: void Cleanup() override; @@ -3334,7 +3461,8 @@ class VersionChangeTransactionOp : public TransactionDatabaseOperationBase { protected: explicit VersionChangeTransactionOp( SafeRefPtr<VersionChangeTransaction> aTransaction) - : TransactionDatabaseOperationBase(std::move(aTransaction)) {} + : TransactionDatabaseOperationBase(std::move(aTransaction), + /* aRequestId */ 0) {} ~VersionChangeTransactionOp() override = default; @@ -3519,8 +3647,9 @@ class NormalTransactionOp : public TransactionDatabaseOperationBase, void Cleanup() override; protected: - explicit NormalTransactionOp(SafeRefPtr<TransactionBase> aTransaction) - : TransactionDatabaseOperationBase(std::move(aTransaction)) + NormalTransactionOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId) + : TransactionDatabaseOperationBase(std::move(aTransaction), aRequestId) #ifdef DEBUG , mResponseSent(false) @@ -3628,7 +3757,7 @@ class ObjectStoreAddOrPutRequestOp final : public NormalTransactionOp { }; class SCInputStream; - const ObjectStoreAddPutParams mParams; + ObjectStoreAddPutParams mParams; Maybe<UniqueIndexTable> mUniqueIndexTable; // This must be non-const so that we can update the mNextAutoIncrementId field @@ -3647,6 +3776,7 @@ class ObjectStoreAddOrPutRequestOp final : public NormalTransactionOp { private: // Only created by TransactionBase. ObjectStoreAddOrPutRequestOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, RequestParams&& aParams); ~ObjectStoreAddOrPutRequestOp() override = default; @@ -3883,6 +4013,7 @@ class ObjectStoreGetRequestOp final : public NormalTransactionOp { private: // Only created by TransactionBase. ObjectStoreGetRequestOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, const RequestParams& aParams, bool aGetAll); ~ObjectStoreGetRequestOp() override = default; @@ -3912,6 +4043,7 @@ class ObjectStoreGetKeyRequestOp final : public NormalTransactionOp { private: // Only created by TransactionBase. ObjectStoreGetKeyRequestOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, const RequestParams& aParams, bool aGetAll); ~ObjectStoreGetKeyRequestOp() override = default; @@ -3930,6 +4062,7 @@ class ObjectStoreDeleteRequestOp final : public NormalTransactionOp { private: ObjectStoreDeleteRequestOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, const ObjectStoreDeleteParams& aParams); ~ObjectStoreDeleteRequestOp() override = default; @@ -3951,6 +4084,7 @@ class ObjectStoreClearRequestOp final : public NormalTransactionOp { private: ObjectStoreClearRequestOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, const ObjectStoreClearParams& aParams); ~ObjectStoreClearRequestOp() override = default; @@ -3971,8 +4105,10 @@ class ObjectStoreCountRequestOp final : public NormalTransactionOp { private: ObjectStoreCountRequestOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, const ObjectStoreCountParams& aParams) - : NormalTransactionOp(std::move(aTransaction)), mParams(aParams) {} + : NormalTransactionOp(std::move(aTransaction), aRequestId), + mParams(aParams) {} ~ObjectStoreCountRequestOp() override = default; @@ -3990,8 +4126,8 @@ class IndexRequestOpBase : public NormalTransactionOp { protected: IndexRequestOpBase(SafeRefPtr<TransactionBase> aTransaction, - const RequestParams& aParams) - : NormalTransactionOp(std::move(aTransaction)), + const int64_t aRequestId, const RequestParams& aParams) + : NormalTransactionOp(std::move(aTransaction), aRequestId), mMetadata(IndexMetadataForParams(Transaction(), aParams)) {} ~IndexRequestOpBase() override = default; @@ -4014,7 +4150,8 @@ class IndexGetRequestOp final : public IndexRequestOpBase { private: // Only created by TransactionBase. IndexGetRequestOp(SafeRefPtr<TransactionBase> aTransaction, - const RequestParams& aParams, bool aGetAll); + const int64_t aRequestId, const RequestParams& aParams, + bool aGetAll); ~IndexGetRequestOp() override = default; @@ -4034,7 +4171,8 @@ class IndexGetKeyRequestOp final : public IndexRequestOpBase { private: // Only created by TransactionBase. IndexGetKeyRequestOp(SafeRefPtr<TransactionBase> aTransaction, - const RequestParams& aParams, bool aGetAll); + const int64_t aRequestId, const RequestParams& aParams, + bool aGetAll); ~IndexGetKeyRequestOp() override = default; @@ -4052,8 +4190,8 @@ class IndexCountRequestOp final : public IndexRequestOpBase { private: // Only created by TransactionBase. IndexCountRequestOp(SafeRefPtr<TransactionBase> aTransaction, - const RequestParams& aParams) - : IndexRequestOpBase(std::move(aTransaction), aParams), + const int64_t aRequestId, const RequestParams& aParams) + : IndexRequestOpBase(std::move(aTransaction), aRequestId, aParams), mParams(aParams.get_IndexCountParams()) {} ~IndexCountRequestOp() override = default; @@ -4153,7 +4291,8 @@ class CursorBase : public PBackgroundIDBCursorParent { ~CursorBase() override { MOZ_ASSERT(!mObjectStoreMetadata); } private: - virtual bool Start(const OpenCursorParams& aParams) = 0; + virtual bool Start(const int64_t aRequestId, + const OpenCursorParams& aParams) = 0; }; class IndexCursorBase : public CursorBase { @@ -4311,7 +4450,7 @@ class Cursor final LazyInitializedOnce<const typename Base::ContinueQueries> mContinueQueries; // Only called by TransactionBase. - bool Start(const OpenCursorParams& aParams) final; + bool Start(const int64_t aRequestId, const OpenCursorParams& aParams) final; void SendResponseInternal(CursorResponse& aResponse, const FilesArrayT<CursorType>& aFiles); @@ -4325,8 +4464,8 @@ class Cursor final mozilla::ipc::IPCResult RecvDeleteMe() override; mozilla::ipc::IPCResult RecvContinue( - const CursorRequestParams& aParams, const Key& aCurrentKey, - const Key& aCurrentObjectStoreKey) override; + const int64_t& aRequestId, const CursorRequestParams& aParams, + const Key& aCurrentKey, const Key& aCurrentObjectStoreKey) override; public: Cursor(SafeRefPtr<TransactionBase> aTransaction, @@ -4373,8 +4512,9 @@ class Cursor<CursorType>::CursorOpBase #endif protected: - explicit CursorOpBase(Cursor* aCursor) - : TransactionDatabaseOperationBase(aCursor->mTransaction.clonePtr()), + explicit CursorOpBase(Cursor* aCursor, const int64_t aRequestId) + : TransactionDatabaseOperationBase(aCursor->mTransaction.clonePtr(), + /* aRequestId */ aRequestId), mCursor(aCursor) #ifdef DEBUG , @@ -4552,9 +4692,10 @@ class Cursor<CursorType>::OpenOp final : public CursorOpBase { using CursorOpBase::mResponse; // Only created by Cursor. - OpenOp(Cursor* const aCursor, + OpenOp(Cursor* const aCursor, const int64_t aRequestId, const Maybe<SerializedKeyRange>& aOptionalKeyRange) - : CursorOpBase(aCursor), mOptionalKeyRange(aOptionalKeyRange) {} + : CursorOpBase(aCursor, aRequestId), + mOptionalKeyRange(aOptionalKeyRange) {} // Reference counted. ~OpenOp() override = default; @@ -4572,9 +4713,9 @@ class Cursor<CursorType>::ContinueOp final const CursorRequestParams mParams; // Only created by Cursor. - ContinueOp(Cursor* const aCursor, CursorRequestParams aParams, - CursorPosition<CursorType> aPosition) - : CursorOpBase(aCursor), + ContinueOp(Cursor* const aCursor, int64_t aRequestId, + CursorRequestParams aParams, CursorPosition<CursorType> aPosition) + : CursorOpBase(aCursor, aRequestId), mParams(std::move(aParams)), mCurrentPosition{std::move(aPosition)} { MOZ_ASSERT(mParams.type() != CursorRequestParams::T__None); @@ -4691,6 +4832,8 @@ class DatabaseLoggingInfo final { }; class QuotaClient final : public mozilla::dom::quota::Client { + friend class GetDatabasesOp; + static QuotaClient* sInstance; nsCOMPtr<nsIEventTarget> mBackgroundThread; @@ -4824,8 +4967,9 @@ class QuotaClient final : public mozilla::dom::quota::Client { // checks those unfinished deletion and clean them up after that. template <ObsoleteFilenamesHandling ObsoleteFilenames = ObsoleteFilenamesHandling::Omit> - Result<GetDatabaseFilenamesResult<ObsoleteFilenames>, nsresult> - GetDatabaseFilenames(nsIFile& aDirectory, const AtomicBool& aCanceled); + Result<GetDatabaseFilenamesResult<ObsoleteFilenames>, + nsresult> static GetDatabaseFilenames(nsIFile& aDirectory, + const AtomicBool& aCanceled); nsresult GetUsageForOriginInternal(PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata, @@ -4866,6 +5010,9 @@ class DeleteFilesRunnable final : public Runnable { RefPtr<DirectoryLock> mDirectoryLock; nsTArray<int64_t> mFileIds; State mState; + DEBUGONLY(bool mDEBUGCountsAsPending = false); + + static uint64_t sPendingRunnables; public: DeleteFilesRunnable(SafeRefPtr<DatabaseFileManager> aFileManager, @@ -4873,8 +5020,14 @@ class DeleteFilesRunnable final : public Runnable { void RunImmediately(); + static bool IsDeletionPending() { return sPendingRunnables > 0; } + private: +#ifdef DEBUG + ~DeleteFilesRunnable(); +#else ~DeleteFilesRunnable() = default; +#endif void Open(); @@ -4953,6 +5106,7 @@ class Maintenance final : public Runnable { PRTime mStartTime; RefPtr<UniversalDirectoryLock> mPendingDirectoryLock; RefPtr<UniversalDirectoryLock> mDirectoryLock; + nsTArray<nsCOMPtr<nsIRunnable>> mCompleteCallbacks; nsTArray<DirectoryInfo> mDirectoryInfos; nsTHashMap<nsStringHashKey, DatabaseMaintenance*> mDatabaseMaintenances; nsresult mResultCode; @@ -4994,6 +5148,8 @@ class Maintenance final : public Runnable { void UnregisterDatabaseMaintenance(DatabaseMaintenance* aDatabaseMaintenance); + bool HasDatabaseMaintenances() const { return mDatabaseMaintenances.Count(); } + RefPtr<DatabaseMaintenance> GetDatabaseMaintenance( const nsAString& aDatabasePath) const { AssertIsOnBackgroundThread(); @@ -5001,6 +5157,13 @@ class Maintenance final : public Runnable { return mDatabaseMaintenances.Get(aDatabasePath); } + void WaitForCompletion(nsIRunnable* aCallback) { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(mDatabaseMaintenances.Count()); + + mCompleteCallbacks.AppendElement(aCallback); + } + void Stringify(nsACString& aResult) const; private: @@ -6410,9 +6573,9 @@ class DeserializeIndexValueHelper final : public Runnable { value.setUndefined(); ErrorResult rv; - IDBObjectStore::AppendIndexUpdateInfo(mIndexID, mKeyPath, mMultiEntry, - mLocale, jsapi.cx(), value, - &mUpdateInfoArray, &rv); + IDBObjectStore::AppendIndexUpdateInfo( + mIndexID, mKeyPath, mMultiEntry, &mUpdateInfoArray, + /* aAutoIncrementedObjectStoreKeyPath */ VoidString(), &rv); return rv.Failed() ? rv.StealNSResult() : NS_OK; } #endif @@ -6450,9 +6613,9 @@ class DeserializeIndexValueHelper final : public Runnable { [this](const nsresult rv) { OperationCompleted(rv); }); ErrorResult errorResult; - IDBObjectStore::AppendIndexUpdateInfo(mIndexID, mKeyPath, mMultiEntry, - mLocale, cx, value, &mUpdateInfoArray, - &errorResult); + IDBObjectStore::AppendIndexUpdateInfo( + mIndexID, mKeyPath, mMultiEntry, mLocale, cx, value, &mUpdateInfoArray, + /* aAutoIncrementedObjectStoreKeyPath */ VoidString(), &errorResult); QM_TRY(OkIf(!errorResult.Failed()), NS_OK, ([this, &errorResult](const NotOk) { OperationCompleted(errorResult.StealNSResult()); @@ -9111,20 +9274,9 @@ Factory::AllocPBackgroundIDBFactoryRequestParent( return nullptr; } - Maybe<ContentParentId> contentParentId; - - uint64_t childID = BackgroundParent::GetChildID(Manager()); - if (childID) { - // If childID is not zero we are dealing with an other-process actor. We - // want to initialize OpenDatabaseOp/DeleteDatabaseOp here with the ID - // (and later also Database) in that case, so Database::IsOwnedByProcess - // can find Databases belonging to a particular content process when - // QuotaClient::AbortOperationsForProcess is called which is currently used - // to abort operations for content processes only. - contentParentId = Some(ContentParentId(childID)); - } + Maybe<ContentParentId> contentParentId = GetContentParentId(); - auto actor = [&]() -> RefPtr<FactoryOp> { + auto actor = [&]() -> RefPtr<FactoryRequestOp> { if (aParams.type() == FactoryRequestParams::TOpenDatabaseRequestParams) { return MakeRefPtr<OpenDatabaseOp>(SafeRefPtrFromThis(), contentParentId, *commonParams); @@ -9151,7 +9303,7 @@ mozilla::ipc::IPCResult Factory::RecvPBackgroundIDBFactoryRequestConstructor( MOZ_ASSERT(aParams.type() != FactoryRequestParams::T__None); MOZ_ASSERT(!QuotaClient::IsShuttingDownOnBackgroundThread()); - auto* op = static_cast<FactoryOp*>(aActor); + auto* op = static_cast<FactoryRequestOp*>(aActor); MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(op)); return IPC_OK(); @@ -9163,10 +9315,69 @@ bool Factory::DeallocPBackgroundIDBFactoryRequestParent( MOZ_ASSERT(aActor); // Transfer ownership back from IPDL. - RefPtr<FactoryOp> op = dont_AddRef(static_cast<FactoryOp*>(aActor)); + RefPtr<FactoryRequestOp> op = + dont_AddRef(static_cast<FactoryRequestOp*>(aActor)); return true; } +mozilla::ipc::IPCResult Factory::RecvGetDatabases( + const PersistenceType& aPersistenceType, + const PrincipalInfo& aPrincipalInfo, GetDatabasesResolver&& aResolve) { + AssertIsOnBackgroundThread(); + + auto ResolveGetDatabasesAndReturn = [&aResolve](const nsresult rv) { + aResolve(rv); + return IPC_OK(); + }; + + QM_TRY(MOZ_TO_RESULT(!QuotaClient::IsShuttingDownOnBackgroundThread()), + ResolveGetDatabasesAndReturn); + + QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(aPersistenceType)), + QM_IPC_FAIL(this)); + + QM_TRY(MOZ_TO_RESULT(QuotaManager::IsPrincipalInfoValid(aPrincipalInfo)), + QM_IPC_FAIL(this)); + + MOZ_ASSERT(aPrincipalInfo.type() == PrincipalInfo::TSystemPrincipalInfo || + aPrincipalInfo.type() == PrincipalInfo::TContentPrincipalInfo); + + PersistenceType persistenceType = + IDBFactory::GetPersistenceType(aPrincipalInfo); + + QM_TRY(MOZ_TO_RESULT(aPersistenceType == persistenceType), QM_IPC_FAIL(this)); + + Maybe<ContentParentId> contentParentId = GetContentParentId(); + + auto op = MakeRefPtr<GetDatabasesOp>(SafeRefPtrFromThis(), contentParentId, + aPersistenceType, aPrincipalInfo, + std::move(aResolve)); + + gFactoryOps->AppendElement(op); + + // Balanced in CleanupMetadata() which is/must always called by SendResults(). + IncreaseBusyCount(); + + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(op)); + + return IPC_OK(); +} + +Maybe<ContentParentId> Factory::GetContentParentId() const { + uint64_t childID = BackgroundParent::GetChildID(Manager()); + if (childID) { + // If childID is not zero we are dealing with an other-process actor. We + // want to initialize OpenDatabaseOp/DeleteDatabaseOp here with the ID + // (and later also Database) in that case, so Database::IsOwnedByProcess + // can find Databases belonging to a particular content process when + // QuotaClient::AbortOperationsForProcess is called which is currently used + // to abort operations for content processes only. + return Some(ContentParentId(childID)); + } + + return Nothing(); +} + /******************************************************************************* * WaitForTransactionsHelper ******************************************************************************/ @@ -9608,7 +9819,8 @@ bool Database::DeallocPBackgroundIDBDatabaseFileParent( already_AddRefed<PBackgroundIDBTransactionParent> Database::AllocPBackgroundIDBTransactionParent( - const nsTArray<nsString>& aObjectStoreNames, const Mode& aMode) { + const nsTArray<nsString>& aObjectStoreNames, const Mode& aMode, + const Durability& aDurability) { AssertIsOnBackgroundThread(); // Once a database is closed it must not try to open new transactions. @@ -9628,6 +9840,12 @@ Database::AllocPBackgroundIDBTransactionParent( return nullptr; } + if (NS_AUUF_OR_WARN_IF(aDurability != IDBTransaction::Durability::Default && + aDurability != IDBTransaction::Durability::Strict && + aDurability != IDBTransaction::Durability::Relaxed)) { + return nullptr; + } + const ObjectStoreTable& objectStores = mMetadata->mObjectStores; const uint32_t nameCount = aObjectStoreNames.Length(); @@ -9670,13 +9888,15 @@ Database::AllocPBackgroundIDBTransactionParent( nullptr); return MakeSafeRefPtr<NormalTransaction>(SafeRefPtrFromThis(), aMode, + aDurability, std::move(objectStoreMetadatas)) .forget(); } mozilla::ipc::IPCResult Database::RecvPBackgroundIDBTransactionConstructor( PBackgroundIDBTransactionParent* aActor, - nsTArray<nsString>&& aObjectStoreNames, const Mode& aMode) { + nsTArray<nsString>&& aObjectStoreNames, const Mode& aMode, + const Durability& aDurability) { // TODO: See bug 1883045 AssertIsOnBackgroundThread(); MOZ_ASSERT(aActor); MOZ_ASSERT(!aObjectStoreNames.IsEmpty()); @@ -9684,6 +9904,9 @@ mozilla::ipc::IPCResult Database::RecvPBackgroundIDBTransactionConstructor( aMode == IDBTransaction::Mode::ReadWrite || aMode == IDBTransaction::Mode::ReadWriteFlush || aMode == IDBTransaction::Mode::Cleanup); + MOZ_ASSERT(aDurability == IDBTransaction::Durability::Default || + aDurability == IDBTransaction::Durability::Strict || + aDurability == IDBTransaction::Durability::Relaxed); MOZ_ASSERT(!mClosed); if (IsInvalidated()) { @@ -9815,7 +10038,8 @@ void Database::StartTransactionOp::Cleanup() { * TransactionBase ******************************************************************************/ -TransactionBase::TransactionBase(SafeRefPtr<Database> aDatabase, Mode aMode) +TransactionBase::TransactionBase(SafeRefPtr<Database> aDatabase, Mode aMode, + Durability aDurability) : mDatabase(std::move(aDatabase)), mDatabaseId(mDatabase->Id()), mLoggingSerialNumber( @@ -9823,6 +10047,7 @@ TransactionBase::TransactionBase(SafeRefPtr<Database> aDatabase, Mode aMode) mActiveRequestCount(0), mInvalidatedOnAnyThread(false), mMode(aMode), + mDurability(aDurability), mResultCode(NS_OK) { AssertIsOnBackgroundThread(); MOZ_ASSERT(mDatabase); @@ -9899,14 +10124,13 @@ void TransactionBase::CommitOrAbort() { return; } - // In case of a failed request that was started after committing was - // initiated, abort (cf. - // https://w3c.github.io/IndexedDB/#async-execute-request step 5.3 vs. 5.4). - // Note this can only happen here when we are committing explicitly, otherwise - // the decision is made by the child. + // In case of a failed request and explicitly committed transaction, abort + // (cf. https://w3c.github.io/IndexedDB/#async-execute-request step 5.3 + // vs. 5.4). It's worth emphasizing this can only happen here when we are + // committing explicitly, otherwise the decision is made by the child. if (NS_SUCCEEDED(mResultCode) && mLastFailedRequest && *mLastRequestBeforeCommit && - *mLastFailedRequest >= **mLastRequestBeforeCommit) { + *mLastFailedRequest == **mLastRequestBeforeCommit) { mResultCode = NS_ERROR_DOM_INDEXEDDB_ABORT_ERR; } @@ -10360,7 +10584,7 @@ void TransactionBase::Invalidate() { } PBackgroundIDBRequestParent* TransactionBase::AllocRequest( - RequestParams&& aParams, bool aTrustParams) { + const int64_t aRequestId, RequestParams&& aParams, bool aTrustParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aParams.type() != RequestParams::T__None); @@ -10382,67 +10606,77 @@ PBackgroundIDBRequestParent* TransactionBase::AllocRequest( switch (aParams.type()) { case RequestParams::TObjectStoreAddParams: case RequestParams::TObjectStorePutParams: - actor = new ObjectStoreAddOrPutRequestOp(SafeRefPtrFromThis(), + actor = new ObjectStoreAddOrPutRequestOp(SafeRefPtrFromThis(), aRequestId, std::move(aParams)); break; case RequestParams::TObjectStoreGetParams: - actor = new ObjectStoreGetRequestOp(SafeRefPtrFromThis(), aParams, - /* aGetAll */ false); + actor = + new ObjectStoreGetRequestOp(SafeRefPtrFromThis(), aRequestId, aParams, + /* aGetAll */ false); break; case RequestParams::TObjectStoreGetAllParams: - actor = new ObjectStoreGetRequestOp(SafeRefPtrFromThis(), aParams, - /* aGetAll */ true); + actor = + new ObjectStoreGetRequestOp(SafeRefPtrFromThis(), aRequestId, aParams, + /* aGetAll */ true); break; case RequestParams::TObjectStoreGetKeyParams: - actor = new ObjectStoreGetKeyRequestOp(SafeRefPtrFromThis(), aParams, + actor = new ObjectStoreGetKeyRequestOp(SafeRefPtrFromThis(), aRequestId, + aParams, /* aGetAll */ false); break; case RequestParams::TObjectStoreGetAllKeysParams: - actor = new ObjectStoreGetKeyRequestOp(SafeRefPtrFromThis(), aParams, + actor = new ObjectStoreGetKeyRequestOp(SafeRefPtrFromThis(), aRequestId, + aParams, /* aGetAll */ true); break; case RequestParams::TObjectStoreDeleteParams: - actor = new ObjectStoreDeleteRequestOp( - SafeRefPtrFromThis(), aParams.get_ObjectStoreDeleteParams()); + actor = + new ObjectStoreDeleteRequestOp(SafeRefPtrFromThis(), aRequestId, + aParams.get_ObjectStoreDeleteParams()); break; case RequestParams::TObjectStoreClearParams: - actor = new ObjectStoreClearRequestOp( - SafeRefPtrFromThis(), aParams.get_ObjectStoreClearParams()); + actor = + new ObjectStoreClearRequestOp(SafeRefPtrFromThis(), aRequestId, + aParams.get_ObjectStoreClearParams()); break; case RequestParams::TObjectStoreCountParams: - actor = new ObjectStoreCountRequestOp( - SafeRefPtrFromThis(), aParams.get_ObjectStoreCountParams()); + actor = + new ObjectStoreCountRequestOp(SafeRefPtrFromThis(), aRequestId, + aParams.get_ObjectStoreCountParams()); break; case RequestParams::TIndexGetParams: - actor = new IndexGetRequestOp(SafeRefPtrFromThis(), aParams, + actor = new IndexGetRequestOp(SafeRefPtrFromThis(), aRequestId, aParams, /* aGetAll */ false); break; case RequestParams::TIndexGetKeyParams: - actor = new IndexGetKeyRequestOp(SafeRefPtrFromThis(), aParams, - /* aGetAll */ false); + actor = + new IndexGetKeyRequestOp(SafeRefPtrFromThis(), aRequestId, aParams, + /* aGetAll */ false); break; case RequestParams::TIndexGetAllParams: - actor = new IndexGetRequestOp(SafeRefPtrFromThis(), aParams, + actor = new IndexGetRequestOp(SafeRefPtrFromThis(), aRequestId, aParams, /* aGetAll */ true); break; case RequestParams::TIndexGetAllKeysParams: - actor = new IndexGetKeyRequestOp(SafeRefPtrFromThis(), aParams, - /* aGetAll */ true); + actor = + new IndexGetKeyRequestOp(SafeRefPtrFromThis(), aRequestId, aParams, + /* aGetAll */ true); break; case RequestParams::TIndexCountParams: - actor = new IndexCountRequestOp(SafeRefPtrFromThis(), aParams); + actor = + new IndexCountRequestOp(SafeRefPtrFromThis(), aRequestId, aParams); break; default: @@ -10552,6 +10786,7 @@ already_AddRefed<PBackgroundIDBCursorParent> TransactionBase::AllocCursor( } bool TransactionBase::StartCursor(PBackgroundIDBCursorParent* const aActor, + const int64_t aRequestId, const OpenCursorParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aActor); @@ -10559,7 +10794,7 @@ bool TransactionBase::StartCursor(PBackgroundIDBCursorParent* const aActor, auto* const op = static_cast<CursorBase*>(aActor); - if (NS_WARN_IF(!op->Start(aParams))) { + if (NS_WARN_IF(!op->Start(aRequestId, aParams))) { return false; } @@ -10572,8 +10807,9 @@ bool TransactionBase::StartCursor(PBackgroundIDBCursorParent* const aActor, NormalTransaction::NormalTransaction( SafeRefPtr<Database> aDatabase, TransactionBase::Mode aMode, + TransactionBase::Durability aDurability, nsTArray<SafeRefPtr<FullObjectStoreMetadata>>&& aObjectStores) - : TransactionBase(std::move(aDatabase), aMode), + : TransactionBase(std::move(aDatabase), aMode, aDurability), mObjectStores{std::move(aObjectStores)} { AssertIsOnBackgroundThread(); MOZ_ASSERT(!mObjectStores.IsEmpty()); @@ -10638,16 +10874,18 @@ mozilla::ipc::IPCResult NormalTransaction::RecvAbort( PBackgroundIDBRequestParent* NormalTransaction::AllocPBackgroundIDBRequestParent( - const RequestParams& aParams) { + const int64_t& aRequestId, const RequestParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aParams.type() != RequestParams::T__None); - return AllocRequest(std::move(const_cast<RequestParams&>(aParams)), + return AllocRequest(aRequestId, + std::move(const_cast<RequestParams&>(aParams)), IsSameProcessActor()); } mozilla::ipc::IPCResult NormalTransaction::RecvPBackgroundIDBRequestConstructor( - PBackgroundIDBRequestParent* const aActor, const RequestParams& aParams) { + PBackgroundIDBRequestParent* const aActor, const int64_t& aRequestId, + const RequestParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aActor); MOZ_ASSERT(aParams.type() != RequestParams::T__None); @@ -10668,19 +10906,20 @@ bool NormalTransaction::DeallocPBackgroundIDBRequestParent( already_AddRefed<PBackgroundIDBCursorParent> NormalTransaction::AllocPBackgroundIDBCursorParent( - const OpenCursorParams& aParams) { + const int64_t& aRequestId, const OpenCursorParams& aParams) { AssertIsOnBackgroundThread(); return AllocCursor(aParams, IsSameProcessActor()); } mozilla::ipc::IPCResult NormalTransaction::RecvPBackgroundIDBCursorConstructor( - PBackgroundIDBCursorParent* const aActor, const OpenCursorParams& aParams) { + PBackgroundIDBCursorParent* const aActor, const int64_t& aRequestId, + const OpenCursorParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aActor); MOZ_ASSERT(aParams.type() != OpenCursorParams::T__None); - if (!StartCursor(aActor, aParams)) { + if (!StartCursor(aActor, aRequestId, aParams)) { return IPC_FAIL(this, "StartCursor failed!"); } return IPC_OK(); @@ -10693,7 +10932,9 @@ mozilla::ipc::IPCResult NormalTransaction::RecvPBackgroundIDBCursorConstructor( VersionChangeTransaction::VersionChangeTransaction( OpenDatabaseOp* aOpenDatabaseOp) : TransactionBase(aOpenDatabaseOp->mDatabase.clonePtr(), - IDBTransaction::Mode::VersionChange), + IDBTransaction::Mode::VersionChange, + // VersionChange must not change durability. + IDBTransaction::Durability::Default), // Not used. mOpenDatabaseOp(aOpenDatabaseOp) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aOpenDatabaseOp); @@ -10755,7 +10996,7 @@ void VersionChangeTransaction::UpdateMetadata(nsresult aResult) { AssertIsOnBackgroundThread(); MOZ_ASSERT(mOpenDatabaseOp); MOZ_ASSERT(!!mActorWasAlive == !!mOpenDatabaseOp->mDatabase); - MOZ_ASSERT_IF(mActorWasAlive, !mOpenDatabaseOp->mDatabaseId.IsEmpty()); + MOZ_ASSERT_IF(mActorWasAlive, !mOpenDatabaseOp->mDatabaseId.ref().IsEmpty()); if (IsActorDestroyed() || !mActorWasAlive) { return; @@ -11224,17 +11465,19 @@ mozilla::ipc::IPCResult VersionChangeTransaction::RecvRenameIndex( PBackgroundIDBRequestParent* VersionChangeTransaction::AllocPBackgroundIDBRequestParent( - const RequestParams& aParams) { + const int64_t& aRequestId, const RequestParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aParams.type() != RequestParams::T__None); - return AllocRequest(std::move(const_cast<RequestParams&>(aParams)), + return AllocRequest(aRequestId, + std::move(const_cast<RequestParams&>(aParams)), IsSameProcessActor()); } mozilla::ipc::IPCResult VersionChangeTransaction::RecvPBackgroundIDBRequestConstructor( - PBackgroundIDBRequestParent* aActor, const RequestParams& aParams) { + PBackgroundIDBRequestParent* aActor, const int64_t& aRequestId, + const RequestParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aActor); MOZ_ASSERT(aParams.type() != RequestParams::T__None); @@ -11255,7 +11498,7 @@ bool VersionChangeTransaction::DeallocPBackgroundIDBRequestParent( already_AddRefed<PBackgroundIDBCursorParent> VersionChangeTransaction::AllocPBackgroundIDBCursorParent( - const OpenCursorParams& aParams) { + const int64_t& aRequestId, const OpenCursorParams& aParams) { AssertIsOnBackgroundThread(); return AllocCursor(aParams, IsSameProcessActor()); @@ -11263,12 +11506,13 @@ VersionChangeTransaction::AllocPBackgroundIDBCursorParent( mozilla::ipc::IPCResult VersionChangeTransaction::RecvPBackgroundIDBCursorConstructor( - PBackgroundIDBCursorParent* aActor, const OpenCursorParams& aParams) { + PBackgroundIDBCursorParent* aActor, const int64_t& aRequestId, + const OpenCursorParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aActor); MOZ_ASSERT(aParams.type() != OpenCursorParams::T__None); - if (!StartCursor(aActor, aParams)) { + if (!StartCursor(aActor, aRequestId, aParams)) { return IPC_FAIL(this, "StartCursor failed!"); } return IPC_OK(); @@ -11417,7 +11661,8 @@ bool Cursor<CursorType>::VerifyRequestParams( } template <IDBCursorType CursorType> -bool Cursor<CursorType>::Start(const OpenCursorParams& aParams) { +bool Cursor<CursorType>::Start(const int64_t aRequestId, + const OpenCursorParams& aParams) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aParams.type() == ToOpenCursorParamsType(CursorType)); MOZ_ASSERT(this->mObjectStoreMetadata); @@ -11429,7 +11674,7 @@ bool Cursor<CursorType>::Start(const OpenCursorParams& aParams) { const Maybe<SerializedKeyRange>& optionalKeyRange = GetCommonOpenCursorParams(aParams).optionalKeyRange(); - const RefPtr<OpenOp> openOp = new OpenOp(this, optionalKeyRange); + const RefPtr<OpenOp> openOp = new OpenOp(this, aRequestId, optionalKeyRange); if (NS_WARN_IF(!openOp->Init(*mTransaction))) { openOp->Cleanup(); @@ -11553,8 +11798,8 @@ mozilla::ipc::IPCResult Cursor<CursorType>::RecvDeleteMe() { template <IDBCursorType CursorType> mozilla::ipc::IPCResult Cursor<CursorType>::RecvContinue( - const CursorRequestParams& aParams, const Key& aCurrentKey, - const Key& aCurrentObjectStoreKey) { + const int64_t& aRequestId, const CursorRequestParams& aParams, + const Key& aCurrentKey, const Key& aCurrentObjectStoreKey) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aParams.type() != CursorRequestParams::T__None); MOZ_ASSERT(this->mObjectStoreMetadata); @@ -11604,7 +11849,7 @@ mozilla::ipc::IPCResult Cursor<CursorType>::RecvContinue( } const RefPtr<ContinueOp> continueOp = - new ContinueOp(this, aParams, std::move(position)); + new ContinueOp(this, aRequestId, aParams, std::move(position)); if (NS_WARN_IF(!continueOp->Init(*mTransaction))) { continueOp->Cleanup(); return IPC_FAIL(this, "ContinueOp initialization failed!"); @@ -11626,15 +11871,18 @@ DatabaseFileManager::DatabaseFileManager( PersistenceType aPersistenceType, const quota::OriginMetadata& aOriginMetadata, const nsAString& aDatabaseName, const nsCString& aDatabaseID, - bool aEnforcingQuota, bool aIsInPrivateBrowsingMode) + const nsAString& aDatabaseFilePath, bool aEnforcingQuota, + bool aIsInPrivateBrowsingMode) : mPersistenceType(aPersistenceType), mOriginMetadata(aOriginMetadata), mDatabaseName(aDatabaseName), mDatabaseID(aDatabaseID), + mDatabaseFilePath(aDatabaseFilePath), mCipherKeyManager( aIsInPrivateBrowsingMode ? new IndexedDBCipherKeyManager("IndexedDBCipherKeyManager") : nullptr), + mDatabaseVersion(0), mEnforcingQuota(aEnforcingQuota), mIsInPrivateBrowsingMode(aIsInPrivateBrowsingMode) {} @@ -12488,6 +12736,17 @@ void QuotaClient::StopIdleMaintenance() { void QuotaClient::InitiateShutdown() { AssertIsOnBackgroundThread(); + MOZ_ASSERT(IsShuttingDownOnBackgroundThread()); + + if (mDeleteTimer) { + // QuotaClient::AsyncDeleteFile will not schedule new timers beyond + // shutdown. And we expect all critical (PBM) deletions to have been + // triggered before this point via ClearPrivateRepository (w/out using + // DeleteFilesRunnable at all). + mDeleteTimer->Cancel(); + mDeleteTimer = nullptr; + mPendingDeleteInfos.Clear(); + } AbortAllOperations(); } @@ -12495,7 +12754,7 @@ void QuotaClient::InitiateShutdown() { bool QuotaClient::IsShutdownCompleted() const { return (!gFactoryOps || gFactoryOps->IsEmpty()) && (!gLiveDatabaseHashtable || !gLiveDatabaseHashtable->Count()) && - !mCurrentMaintenance; + !mCurrentMaintenance && !DeleteFilesRunnable::IsDeletionPending(); } void QuotaClient::ForceKillActors() { @@ -12575,17 +12834,20 @@ void QuotaClient::FinalizeShutdown() { mMaintenanceThreadPool->Shutdown(); mMaintenanceThreadPool = nullptr; } - - if (mDeleteTimer) { - MOZ_ALWAYS_SUCCEEDS(mDeleteTimer->Cancel()); - mDeleteTimer = nullptr; - } } void QuotaClient::DeleteTimerCallback(nsITimer* aTimer, void* aClosure) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aTimer); + // Even though we do not schedule new timers after shutdown has started, + // an already existing one might fire afterwards (actually we think it + // shouldn't, but there is no reason to enforce this invariant). We can + // just ignore it, the cleanup work is done in InitiateShutdown. + if (NS_WARN_IF(IsShuttingDownOnBackgroundThread())) { + return; + } + auto* const self = static_cast<QuotaClient*>(aClosure); MOZ_ASSERT(self); MOZ_ASSERT(self->mDeleteTimer); @@ -12728,6 +12990,8 @@ void QuotaClient::ProcessMaintenanceQueue() { * DeleteFilesRunnable ******************************************************************************/ +uint64_t DeleteFilesRunnable::sPendingRunnables = 0; + DeleteFilesRunnable::DeleteFilesRunnable( SafeRefPtr<DatabaseFileManager> aFileManager, nsTArray<int64_t>&& aFileIds) : Runnable("dom::indexeddb::DeleteFilesRunnable"), @@ -12736,6 +13000,12 @@ DeleteFilesRunnable::DeleteFilesRunnable( mFileIds(std::move(aFileIds)), mState(State_Initial) {} +#ifdef DEBUG +DeleteFilesRunnable::~DeleteFilesRunnable() { + MOZ_ASSERT(!mDEBUGCountsAsPending); +} +#endif + void DeleteFilesRunnable::RunImmediately() { AssertIsOnBackgroundThread(); MOZ_ASSERT(mState == State_Initial); @@ -12747,6 +13017,10 @@ void DeleteFilesRunnable::Open() { AssertIsOnBackgroundThread(); MOZ_ASSERT(mState == State_Initial); + MOZ_ASSERT(!mDEBUGCountsAsPending); + sPendingRunnables++; + DEBUGONLY(mDEBUGCountsAsPending = true); + QuotaManager* const quotaManager = QuotaManager::Get(); if (NS_WARN_IF(!quotaManager)) { Finish(); @@ -12800,6 +13074,9 @@ void DeleteFilesRunnable::UnblockOpen() { MOZ_ASSERT(mState == State_UnblockingOpen); mDirectoryLock = nullptr; + MOZ_ASSERT(mDEBUGCountsAsPending); + sPendingRunnables--; + DEBUGONLY(mDEBUGCountsAsPending = false); mState = State_Completed; } @@ -12892,6 +13169,11 @@ void Maintenance::UnregisterDatabaseMaintenance( return; } + for (const auto& completeCallback : mCompleteCallbacks) { + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(completeCallback)); + } + mCompleteCallbacks.Clear(); + mState = State::Finishing; Finish(); } @@ -13289,6 +13571,10 @@ nsresult Maintenance::BeginDatabaseMaintenance() { for (uint32_t index = gFactoryOps->Length(); index > 0; index--) { CheckedUnsafePtr<FactoryOp>& existingOp = (*gFactoryOps)[index - 1]; + if (existingOp->DatabaseNameRef().isNothing()) { + return false; + } + if (!existingOp->DatabaseFilePathIsKnown()) { continue; } @@ -14448,14 +14734,17 @@ void DatabaseOperationBase::AutoSetProgressHandler::Unregister() { FactoryOp::FactoryOp(SafeRefPtr<Factory> aFactory, const Maybe<ContentParentId>& aContentParentId, - const CommonFactoryRequestParams& aCommonParams, - bool aDeleting) + const PersistenceType aPersistenceType, + const PrincipalInfo& aPrincipalInfo, + const Maybe<nsString>& aDatabaseName, bool aDeleting) : DatabaseOperationBase(aFactory->GetLoggingInfo()->Id(), aFactory->GetLoggingInfo()->NextRequestSN()), mFactory(std::move(aFactory)), mContentParentId(aContentParentId), - mCommonParams(aCommonParams), + mPrincipalInfo(aPrincipalInfo), + mDatabaseName(aDatabaseName), mDirectoryLockId(-1), + mPersistenceType(aPersistenceType), mState(State::Initial), mWaitingForPermissionRetry(false), mEnforcingQuota(true), @@ -14506,7 +14795,7 @@ void FactoryOp::NoteDatabaseClosed(Database* const aDatabase) { } DatabaseActorInfo* info; - MOZ_ALWAYS_TRUE(gLiveDatabaseHashtable->Get(mDatabaseId, &info)); + MOZ_ALWAYS_TRUE(gLiveDatabaseHashtable->Get(mDatabaseId.ref(), &info)); MOZ_ASSERT(info->mWaitingFactoryOp == this); if (AreActorsAlive()) { @@ -14547,6 +14836,14 @@ void FactoryOp::StringifyState(nsACString& aResult) const { aResult.AppendLiteral("DirectoryOpenPending"); return; + case State::DirectoryWorkOpen: + aResult.AppendLiteral("DirectoryWorkOpen"); + return; + + case State::DirectoryWorkDone: + aResult.AppendLiteral("DirectoryWorkDone"); + return; + case State::DatabaseOpenPending: aResult.AppendLiteral("DatabaseOpenPending"); return; @@ -14588,8 +14885,7 @@ void FactoryOp::Stringify(nsACString& aResult) const { AssertIsOnOwningThread(); aResult.AppendLiteral("PersistenceType:"); - aResult.Append( - PersistenceTypeToString(mCommonParams.metadata().persistenceType())); + aResult.Append(PersistenceTypeToString(mPersistenceType)); aResult.Append(kQuotaGenericDelimiter); aResult.AppendLiteral("Origin:"); @@ -14617,32 +14913,25 @@ nsresult FactoryOp::Open() { QuotaManager* const quotaManager = QuotaManager::Get(); MOZ_ASSERT(quotaManager); - const DatabaseMetadata& metadata = mCommonParams.metadata(); - - const PersistenceType persistenceType = metadata.persistenceType(); - - const PrincipalInfo& principalInfo = mCommonParams.principalInfo(); - - QM_TRY_UNWRAP(auto principalMetadata, - quotaManager->GetInfoFromValidatedPrincipalInfo(principalInfo)); + QM_TRY_UNWRAP( + auto principalMetadata, + quotaManager->GetInfoFromValidatedPrincipalInfo(mPrincipalInfo)); - mOriginMetadata = {std::move(principalMetadata), persistenceType}; + mOriginMetadata = {std::move(principalMetadata), mPersistenceType}; - if (principalInfo.type() == PrincipalInfo::TSystemPrincipalInfo) { - MOZ_ASSERT(mCommonParams.metadata().persistenceType() == - PERSISTENCE_TYPE_PERSISTENT); + if (mPrincipalInfo.type() == PrincipalInfo::TSystemPrincipalInfo) { + MOZ_ASSERT(mPersistenceType == PERSISTENCE_TYPE_PERSISTENT); mEnforcingQuota = false; - } else if (principalInfo.type() == PrincipalInfo::TContentPrincipalInfo) { + } else if (mPrincipalInfo.type() == PrincipalInfo::TContentPrincipalInfo) { const ContentPrincipalInfo& contentPrincipalInfo = - principalInfo.get_ContentPrincipalInfo(); + mPrincipalInfo.get_ContentPrincipalInfo(); MOZ_ASSERT_IF( QuotaManager::IsOriginInternal(contentPrincipalInfo.originNoSuffix()), - mCommonParams.metadata().persistenceType() == - PERSISTENCE_TYPE_PERSISTENT); + mPersistenceType == PERSISTENCE_TYPE_PERSISTENT); - mEnforcingQuota = persistenceType != PERSISTENCE_TYPE_PERSISTENT; + mEnforcingQuota = mPersistenceType != PERSISTENCE_TYPE_PERSISTENT; if (mOriginMetadata.mIsPrivate) { if (StaticPrefs::dom_indexedDB_privateBrowsing_enabled()) { @@ -14663,31 +14952,39 @@ nsresult FactoryOp::Open() { MOZ_ASSERT(false); } - QuotaManager::GetStorageId(persistenceType, mOriginMetadata.mOrigin, - Client::IDB, mDatabaseId); + if (mDatabaseName.isSome()) { + nsCString databaseId; - mDatabaseId.Append('*'); - mDatabaseId.Append(NS_ConvertUTF16toUTF8(metadata.name())); + QuotaManager::GetStorageId(mPersistenceType, mOriginMetadata.mOrigin, + Client::IDB, databaseId); - // Need to get database file path before opening the directory. - // XXX: For what reason? - QM_TRY_UNWRAP( - mDatabaseFilePath, - ([this, metadata, quotaManager]() -> mozilla::Result<nsString, nsresult> { - QM_TRY_INSPECT(const auto& dbFile, - quotaManager->GetOriginDirectory(mOriginMetadata)); + databaseId.Append('*'); + databaseId.Append(NS_ConvertUTF16toUTF8(mDatabaseName.ref())); - QM_TRY(MOZ_TO_RESULT(dbFile->Append( - NS_LITERAL_STRING_FROM_CSTRING(IDB_DIRECTORY_NAME)))); + mDatabaseId = Some(std::move(databaseId)); - QM_TRY(MOZ_TO_RESULT( - dbFile->Append(GetDatabaseFilenameBase(metadata.name(), - mOriginMetadata.mIsPrivate) + - kSQLiteSuffix))); + // Need to get database file path before opening the directory. + // XXX: For what reason? + QM_TRY_UNWRAP( + auto databaseFilePath, + ([this, quotaManager]() -> mozilla::Result<nsString, nsresult> { + QM_TRY_INSPECT(const auto& dbFile, + quotaManager->GetOriginDirectory(mOriginMetadata)); - QM_TRY_RETURN( - MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, dbFile, GetPath)); - }())); + QM_TRY(MOZ_TO_RESULT(dbFile->Append( + NS_LITERAL_STRING_FROM_CSTRING(IDB_DIRECTORY_NAME)))); + + QM_TRY(MOZ_TO_RESULT(dbFile->Append( + GetDatabaseFilenameBase(mDatabaseName.ref(), + mOriginMetadata.mIsPrivate) + + kSQLiteSuffix))); + + QM_TRY_RETURN( + MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, dbFile, GetPath)); + }())); + + mDatabaseFilePath = Some(std::move(databaseFilePath)); + } // Open directory mState = State::DirectoryOpenPending; @@ -14711,47 +15008,77 @@ nsresult FactoryOp::DirectoryOpen() { AssertIsOnOwningThread(); MOZ_ASSERT(mState == State::DirectoryOpenPending); MOZ_ASSERT(mDirectoryLock); - MOZ_ASSERT(!mDatabaseFilePath.IsEmpty()); + + if (mDatabaseName.isNothing()) { + QuotaManager* const quotaManager = QuotaManager::Get(); + MOZ_ASSERT(quotaManager); + + // Must set this before dispatching otherwise we will race with the IO + // thread. + mState = State::DirectoryWorkOpen; + + QM_TRY(MOZ_TO_RESULT( + quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL)), + NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR, IDB_REPORT_INTERNAL_ERR_LAMBDA); + + return NS_OK; + } + + mState = State::DirectoryWorkDone; + MOZ_ALWAYS_SUCCEEDS(Run()); + + return NS_OK; +} + +nsresult FactoryOp::DirectoryWorkDone() { + AssertIsOnOwningThread(); + MOZ_ASSERT(mState == State::DirectoryWorkDone); + MOZ_ASSERT(mDirectoryLock); MOZ_ASSERT(gFactoryOps); // See if this FactoryOp needs to wait. - const bool delayed = - std::any_of( - gFactoryOps->rbegin(), gFactoryOps->rend(), - [foundThis = false, &self = *this](const auto& existingOp) mutable { - if (existingOp == &self) { - foundThis = true; - return false; - } + const bool blocked = [&self = *this] { + bool foundThis = false; + bool blocked = false; - if (foundThis && self.MustWaitFor(*existingOp)) { - // Only one op can be delayed. - MOZ_ASSERT(!existingOp->mDelayedOp); - existingOp->mDelayedOp = &self; - return true; - } + for (const auto& existingOp : Reversed(*gFactoryOps)) { + if (existingOp == &self) { + foundThis = true; + continue; + } - return false; - }) || - [&self = *this] { - QuotaClient* quotaClient = QuotaClient::GetInstance(); - MOZ_ASSERT(quotaClient); - - if (RefPtr<Maintenance> currentMaintenance = - quotaClient->GetCurrentMaintenance()) { - if (RefPtr<DatabaseMaintenance> databaseMaintenance = - currentMaintenance->GetDatabaseMaintenance( - self.mDatabaseFilePath)) { - databaseMaintenance->WaitForCompletion(&self); - return true; - } + if (foundThis && self.MustWaitFor(*existingOp)) { + existingOp->AddBlockingOp(self); + self.AddBlockedOnOp(*existingOp); + blocked = true; + } + } + + return blocked; + }() || [&self = *this] { + QuotaClient* quotaClient = QuotaClient::GetInstance(); + MOZ_ASSERT(quotaClient); + + if (RefPtr<Maintenance> currentMaintenance = + quotaClient->GetCurrentMaintenance()) { + if (self.mDatabaseName.isSome()) { + if (RefPtr<DatabaseMaintenance> databaseMaintenance = + currentMaintenance->GetDatabaseMaintenance( + self.mDatabaseFilePath.ref())) { + databaseMaintenance->WaitForCompletion(&self); + return true; } + } else if (currentMaintenance->HasDatabaseMaintenances()) { + currentMaintenance->WaitForCompletion(&self); + return true; + } + } - return false; - }(); + return false; + }(); mState = State::DatabaseOpenPending; - if (!delayed) { + if (!blocked) { QM_TRY(MOZ_TO_RESULT(DatabaseOpen())); } @@ -14785,22 +15112,23 @@ void FactoryOp::WaitForTransactions() { AssertIsOnOwningThread(); MOZ_ASSERT(mState == State::BeginVersionChange || mState == State::WaitingForOtherDatabasesToClose); - MOZ_ASSERT(!mDatabaseId.IsEmpty()); + MOZ_ASSERT(!mDatabaseId.ref().IsEmpty()); MOZ_ASSERT(!IsActorDestroyed()); mState = State::WaitingForTransactionsToComplete; RefPtr<WaitForTransactionsHelper> helper = - new WaitForTransactionsHelper(mDatabaseId, this); + new WaitForTransactionsHelper(mDatabaseId.ref(), this); helper->WaitForTransactions(); } void FactoryOp::CleanupMetadata() { AssertIsOnOwningThread(); - if (mDelayedOp) { - MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(mDelayedOp.forget())); + for (const NotNull<RefPtr<FactoryOp>>& blockingOp : mBlocking) { + blockingOp->MaybeUnblock(*this); } + mBlocking.Clear(); MOZ_ASSERT(gFactoryOps); gFactoryOps->RemoveElement(this); @@ -14868,12 +15196,23 @@ nsresult FactoryOp::SendVersionChangeMessages( bool FactoryOp::MustWaitFor(const FactoryOp& aExistingOp) { AssertIsOnOwningThread(); - // Things for the same persistence type, the same origin and the same - // database must wait. - return aExistingOp.mCommonParams.metadata().persistenceType() == - mCommonParams.metadata().persistenceType() && - aExistingOp.mOriginMetadata.mOrigin == mOriginMetadata.mOrigin && - aExistingOp.mDatabaseId == mDatabaseId; + // If the persistence types don't overlap, the op can proceed. + if (aExistingOp.mPersistenceType != mPersistenceType) { + return false; + } + + // If the origins don't overlap, the op can proceed. + if (aExistingOp.mOriginMetadata.mOrigin != mOriginMetadata.mOrigin) { + return false; + } + + // If the database ids don't overlap, the op can proceed. + if (!aExistingOp.mDatabaseId.isNothing() && !mDatabaseId.isNothing() && + aExistingOp.mDatabaseId.ref() != mDatabaseId.ref()) { + return false; + } + + return true; } // Run() assumes that the caller holds a strong reference to the object that @@ -14905,6 +15244,14 @@ FactoryOp::Run() { QM_WARNONLY_TRY(MOZ_TO_RESULT(Open()), handleError); break; + case State::DirectoryWorkOpen: + QM_WARNONLY_TRY(MOZ_TO_RESULT(DoDirectoryWork()), handleError); + break; + + case State::DirectoryWorkDone: + QM_WARNONLY_TRY(MOZ_TO_RESULT(DirectoryWorkDone()), handleError); + break; + case State::DatabaseOpenPending: QM_WARNONLY_TRY(MOZ_TO_RESULT(DatabaseOpen()), handleError); break; @@ -14971,7 +15318,11 @@ void FactoryOp::DirectoryLockFailed() { MOZ_ALWAYS_SUCCEEDS(Run()); } -void FactoryOp::ActorDestroy(ActorDestroyReason aWhy) { +nsresult FactoryRequestOp::DoDirectoryWork() { + MOZ_CRASH("Not implemented because this should be unreachable."); +} + +void FactoryRequestOp::ActorDestroy(ActorDestroyReason aWhy) { AssertIsOnBackgroundThread(); NoteActorDestroyed(); @@ -14980,8 +15331,8 @@ void FactoryOp::ActorDestroy(ActorDestroyReason aWhy) { OpenDatabaseOp::OpenDatabaseOp(SafeRefPtr<Factory> aFactory, const Maybe<ContentParentId>& aContentParentId, const CommonFactoryRequestParams& aParams) - : FactoryOp(std::move(aFactory), aContentParentId, aParams, - /* aDeleting */ false), + : FactoryRequestOp(std::move(aFactory), aContentParentId, aParams, + /* aDeleting */ false), mMetadata(MakeSafeRefPtr<FullDatabaseMetadata>(aParams.metadata())), mRequestedVersion(aParams.metadata().version()), mVersionChangeOp(nullptr), @@ -14990,7 +15341,7 @@ OpenDatabaseOp::OpenDatabaseOp(SafeRefPtr<Factory> aFactory, void OpenDatabaseOp::ActorDestroy(ActorDestroyReason aWhy) { AssertIsOnOwningThread(); - FactoryOp::ActorDestroy(aWhy); + FactoryRequestOp::ActorDestroy(aWhy); if (mVersionChangeOp) { mVersionChangeOp->NoteActorDestroyed(); @@ -15097,7 +15448,7 @@ nsresult OpenDatabaseOp::DoDatabaseWork() { const auto& databaseFilePath, MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, dbFile, GetPath)); - MOZ_ASSERT(databaseFilePath == mDatabaseFilePath); + MOZ_ASSERT(databaseFilePath == mDatabaseFilePath.ref()); } #endif @@ -15114,8 +15465,8 @@ nsresult OpenDatabaseOp::DoDatabaseWork() { if (!fileManager) { fileManager = MakeSafeRefPtr<DatabaseFileManager>( - persistenceType, mOriginMetadata, databaseName, mDatabaseId, - mEnforcingQuota, mInPrivateBrowsing); + persistenceType, mOriginMetadata, databaseName, mDatabaseId.ref(), + mDatabaseFilePath.ref(), mEnforcingQuota, mInPrivateBrowsing); } Maybe<const CipherKey> maybeKey = @@ -15555,7 +15906,7 @@ nsresult OpenDatabaseOp::BeginVersionChange() { MOZ_ASSERT(!mDatabase->IsClosed()); DatabaseActorInfo* info; - MOZ_ALWAYS_TRUE(gLiveDatabaseHashtable->Get(mDatabaseId, &info)); + MOZ_ALWAYS_TRUE(gLiveDatabaseHashtable->Get(mDatabaseId.ref(), &info)); MOZ_ASSERT(info->mLiveDatabases.Contains(mDatabase.unsafeGetRawPtr())); MOZ_ASSERT(!info->mWaitingFactoryOp); @@ -15699,9 +16050,9 @@ void OpenDatabaseOp::SendResults() { MOZ_ASSERT_IF(!HasFailed(), !mVersionChangeTransaction); DebugOnly<DatabaseActorInfo*> info = nullptr; - MOZ_ASSERT_IF( - gLiveDatabaseHashtable && gLiveDatabaseHashtable->Get(mDatabaseId, &info), - !info->mWaitingFactoryOp); + MOZ_ASSERT_IF(mDatabaseId.isSome() && gLiveDatabaseHashtable && + gLiveDatabaseHashtable->Get(mDatabaseId.ref(), &info), + !info->mWaitingFactoryOp); if (mVersionChangeTransaction) { MOZ_ASSERT(HasFailed()); @@ -15720,6 +16071,8 @@ void OpenDatabaseOp::SendResults() { // need to update the version in our metadata. mMetadata->mCommonMetadata.version() = mRequestedVersion; + mFileManager->UpdateDatabaseVersion(mRequestedVersion); + nsresult rv = EnsureDatabaseActorIsAlive(); if (NS_SUCCEEDED(rv)) { // We successfully opened a database so use its actor as the success @@ -15767,7 +16120,7 @@ void OpenDatabaseOp::SendResults() { &OpenDatabaseOp::ConnectionClosedCallback); RefPtr<WaitForTransactionsHelper> helper = - new WaitForTransactionsHelper(mDatabaseId, callback); + new WaitForTransactionsHelper(mDatabaseId.ref(), callback); helper->WaitForTransactions(); } else { CleanupMetadata(); @@ -15792,7 +16145,7 @@ void OpenDatabaseOp::EnsureDatabaseActor() { mState == State::DatabaseWorkVersionChange || mState == State::SendingResults); MOZ_ASSERT(!HasFailed()); - MOZ_ASSERT(!mDatabaseFilePath.IsEmpty()); + MOZ_ASSERT(mDatabaseFilePath.isSome()); MOZ_ASSERT(!IsActorDestroyed()); if (mDatabase) { @@ -15800,13 +16153,13 @@ void OpenDatabaseOp::EnsureDatabaseActor() { } MOZ_ASSERT(mMetadata->mDatabaseId.IsEmpty()); - mMetadata->mDatabaseId = mDatabaseId; + mMetadata->mDatabaseId = mDatabaseId.ref(); MOZ_ASSERT(mMetadata->mFilePath.IsEmpty()); - mMetadata->mFilePath = mDatabaseFilePath; + mMetadata->mFilePath = mDatabaseFilePath.ref(); DatabaseActorInfo* info; - if (gLiveDatabaseHashtable->Get(mDatabaseId, &info)) { + if (gLiveDatabaseHashtable->Get(mDatabaseId.ref(), &info)) { AssertMetadataConsistency(*info->mMetadata); mMetadata = info->mMetadata.clonePtr(); } @@ -15833,7 +16186,7 @@ void OpenDatabaseOp::EnsureDatabaseActor() { // XXX Maybe use LookupOrInsertWith above, to avoid a second lookup here? info = gLiveDatabaseHashtable ->InsertOrUpdate( - mDatabaseId, + mDatabaseId.ref(), MakeUnique<DatabaseActorInfo>( mMetadata.clonePtr(), WrapNotNullUnchecked(mDatabase.unsafeGetRawPtr()))) @@ -16128,8 +16481,8 @@ void DeleteDatabaseOp::LoadPreviousVersion(nsIFile& aDatabaseFile) { if (!fileManager) { fileManager = MakeSafeRefPtr<DatabaseFileManager>( - persistenceType, mOriginMetadata, databaseName, mDatabaseId, - mEnforcingQuota, mInPrivateBrowsing); + persistenceType, mOriginMetadata, databaseName, mDatabaseId.ref(), + mDatabaseFilePath.ref(), mEnforcingQuota, mInPrivateBrowsing); } const auto maybeKey = @@ -16237,7 +16590,7 @@ nsresult DeleteDatabaseOp::DoDatabaseWork() { const auto& databaseFilePath, MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, dbFile, GetPath)); - MOZ_ASSERT(databaseFilePath == mDatabaseFilePath); + MOZ_ASSERT(databaseFilePath == mDatabaseFilePath.ref()); } #endif @@ -16271,7 +16624,7 @@ nsresult DeleteDatabaseOp::BeginVersionChange() { } DatabaseActorInfo* info; - if (gLiveDatabaseHashtable->Get(mDatabaseId, &info)) { + if (gLiveDatabaseHashtable->Get(mDatabaseId.ref(), &info)) { MOZ_ASSERT(!info->mWaitingFactoryOp); nsresult rv = @@ -16345,9 +16698,9 @@ void DeleteDatabaseOp::SendResults() { MOZ_ASSERT(mMaybeBlockedDatabases.IsEmpty()); DebugOnly<DatabaseActorInfo*> info = nullptr; - MOZ_ASSERT_IF( - gLiveDatabaseHashtable && gLiveDatabaseHashtable->Get(mDatabaseId, &info), - !info->mWaitingFactoryOp); + MOZ_ASSERT_IF(mDatabaseId.isSome() && gLiveDatabaseHashtable && + gLiveDatabaseHashtable->Get(mDatabaseId.ref(), &info), + !info->mWaitingFactoryOp); if (!IsActorDestroyed()) { FactoryRequestResponse response; @@ -16428,7 +16781,7 @@ void DeleteDatabaseOp::VersionChangeOp::RunOnOwningThread() { // Inform all the other databases that they are now invalidated. That // should remove the previous metadata from our table. - if (gLiveDatabaseHashtable->Get(deleteOp->mDatabaseId, &info)) { + if (gLiveDatabaseHashtable->Get(deleteOp->mDatabaseId.ref(), &info)) { MOZ_ASSERT(!info->mLiveDatabases.IsEmpty()); MOZ_ASSERT(!info->mWaitingFactoryOp); @@ -16454,7 +16807,7 @@ void DeleteDatabaseOp::VersionChangeOp::RunOnOwningThread() { database->Invalidate(); } - MOZ_ASSERT(!gLiveDatabaseHashtable->Get(deleteOp->mDatabaseId)); + MOZ_ASSERT(!gLiveDatabaseHashtable->Get(deleteOp->mDatabaseId.ref())); } } } @@ -16491,21 +16844,257 @@ nsresult DeleteDatabaseOp::VersionChangeOp::Run() { return NS_OK; } +nsresult GetDatabasesOp::DatabasesNotAvailable() { + AssertIsOnIOThread(); + MOZ_ASSERT(mState == State::DatabaseWorkOpen); + + mState = State::SendingResults; + + QM_TRY(MOZ_TO_RESULT(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL))); + + return NS_OK; +} + +nsresult GetDatabasesOp::DoDirectoryWork() { + AssertIsOnIOThread(); + MOZ_ASSERT(mState == State::DirectoryWorkOpen); + + // This state (DirectoryWorkOpen) runs immediately on the I/O thread, before + // waiting for existing factory operations to complete (at which point + // DoDatabaseWork will be invoked). To match the spec, we must snapshot the + // current state of any databases that are being created (version = 0) or + // upgraded (version >= 1) now. If we only sampled these values in + // DoDatabaseWork, we would only see their post-creation/post-upgrade + // versions, which would be incorrect. + + IndexedDatabaseManager* const idm = IndexedDatabaseManager::Get(); + MOZ_ASSERT(idm); + + const auto& fileManagers = + idm->GetFileManagers(mPersistenceType, mOriginMetadata.mOrigin); + + for (const auto& fileManager : fileManagers) { + auto& metadata = + mDatabaseMetadataTable.LookupOrInsert(fileManager->DatabaseFilePath()); + metadata.name() = fileManager->DatabaseName(); + metadata.version() = fileManager->DatabaseVersion(); + } + + // Must set this before dispatching otherwise we will race with the IO thread. + mState = State::DirectoryWorkDone; + + QM_TRY(MOZ_TO_RESULT(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL))); + + return NS_OK; +} + +nsresult GetDatabasesOp::DatabaseOpen() { + AssertIsOnOwningThread(); + MOZ_ASSERT(mState == State::DatabaseOpenPending); + + nsresult rv = SendToIOThread(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +nsresult GetDatabasesOp::DoDatabaseWork() { + AssertIsOnIOThread(); + MOZ_ASSERT(mState == State::DatabaseWorkOpen); + + AUTO_PROFILER_LABEL("GetDatabasesOp::DoDatabaseWork", DOM); + + if (NS_WARN_IF(QuotaClient::IsShuttingDownOnNonBackgroundThread()) || + !OperationMayProceed()) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + + QuotaManager* const quotaManager = QuotaManager::Get(); + MOZ_ASSERT(quotaManager); + + if (mPersistenceType != PERSISTENCE_TYPE_PERSISTENT) { + QM_TRY(MOZ_TO_RESULT( + quotaManager->EnsureTemporaryStorageIsInitializedInternal())); + } + + { + QM_TRY_INSPECT(const bool& exists, + quotaManager->DoesOriginDirectoryExist(mOriginMetadata)); + if (!exists) { + return DatabasesNotAvailable(); + } + } + + QM_TRY((["aManager, this]() + -> mozilla::Result<std::pair<nsCOMPtr<nsIFile>, bool>, nsresult> { + if (mPersistenceType == PERSISTENCE_TYPE_PERSISTENT) { + QM_TRY_RETURN( + quotaManager->EnsurePersistentOriginIsInitialized(mOriginMetadata)); + } + + QM_TRY_RETURN(quotaManager->EnsureTemporaryOriginIsInitialized( + mPersistenceType, mOriginMetadata)); + }() + .map([](const auto& res) { return Ok{}; }))); + + { + QM_TRY_INSPECT(const bool& exists, + quotaManager->DoesClientDirectoryExist( + ClientMetadata{mOriginMetadata, Client::IDB})); + if (!exists) { + return DatabasesNotAvailable(); + } + } + + QM_TRY_INSPECT( + const auto& clientDirectory, + (["aManager, this]() + -> mozilla::Result<std::pair<nsCOMPtr<nsIFile>, bool>, nsresult> { + if (mPersistenceType == PERSISTENCE_TYPE_PERSISTENT) { + QM_TRY_RETURN(quotaManager->EnsurePersistentClientIsInitialized( + ClientMetadata{mOriginMetadata, Client::IDB})); + } + + QM_TRY_RETURN(quotaManager->EnsureTemporaryClientIsInitialized( + ClientMetadata{mOriginMetadata, Client::IDB})); + }() + .map([](const auto& res) { return res.first; }))); + + QM_TRY_INSPECT( + (const auto& [subdirsToProcess, databaseFilenames]), + QuotaClient::GetDatabaseFilenames(*clientDirectory, + /* aCanceled */ Atomic<bool>{false})); + + for (const auto& databaseFilename : databaseFilenames) { + QM_TRY_INSPECT( + const auto& databaseFile, + CloneFileAndAppend(*clientDirectory, databaseFilename + kSQLiteSuffix)); + + nsString path; + databaseFile->GetPath(path); + + // Use the snapshotted values from DoDirectoryWork which correctly + // snapshotted the state of any pending creations/upgrades. This does mean + // that we need to skip reporting databases that had a version of 0 at that + // time because they were still being created. In the event that any other + // creation or upgrade requests are made after our operation is created, + // this operation will block those, so it's not possible for this set of + // data to get out of sync. The snapshotting (using cached database name + // and version in DatabaseFileManager) also guarantees that we are not + // touching the SQLite database here on the QuotaManager I/O thread which + // is already open on the connection thread. + + auto metadata = mDatabaseMetadataTable.Lookup(path); + if (metadata) { + if (metadata->version() != 0) { + mDatabaseMetadataArray.AppendElement(DatabaseMetadata( + metadata->name(), metadata->version(), mPersistenceType)); + } + + continue; + } + + // Since the database is not already open (there was no DatabaseFileManager + // for snapshotting in DoDirectoryWork which could provide us with the + // database name and version without needing to open the SQLite database), + // it is safe and necessary for us to open the database on this thread and + // retrieve its name and version. We do not need to worry about racing a + // database open because database opens can only be processed on this + // thread and we are performing the steps below synchronously. + + QM_TRY_INSPECT( + const auto& fmDirectory, + CloneFileAndAppend(*clientDirectory, + databaseFilename + kFileManagerDirectoryNameSuffix)); + + QM_TRY_UNWRAP( + const NotNull<nsCOMPtr<mozIStorageConnection>> connection, + CreateStorageConnection(*databaseFile, *fmDirectory, VoidString(), + mOriginMetadata.mOrigin, mDirectoryLockId, + TelemetryIdForFile(databaseFile), Nothing{})); + + { + // Load version information. + QM_TRY_INSPECT(const auto& stmt, + CreateAndExecuteSingleStepStatement< + SingleStepResult::ReturnNullIfNoResult>( + *connection, "SELECT name, version FROM database"_ns)); + + QM_TRY(OkIf(stmt), NS_ERROR_FILE_CORRUPTED); + + QM_TRY_INSPECT( + const auto& databaseName, + MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, stmt, GetString, 0)); + + QM_TRY_INSPECT(const int64_t& version, + MOZ_TO_RESULT_INVOKE_MEMBER(stmt, GetInt64, 1)); + + mDatabaseMetadataArray.AppendElement( + DatabaseMetadata(databaseName, version, mPersistenceType)); + } + } + + mState = State::SendingResults; + + QM_TRY(MOZ_TO_RESULT(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL))); + + return NS_OK; +} + +nsresult GetDatabasesOp::BeginVersionChange() { + MOZ_CRASH("Not implemented because this should be unreachable."); +} + +bool GetDatabasesOp::AreActorsAlive() { + MOZ_CRASH("Not implemented because this should be unreachable."); +} + +void GetDatabasesOp::SendBlockedNotification() { + MOZ_CRASH("Not implemented because this should be unreachable."); +} + +nsresult GetDatabasesOp::DispatchToWorkThread() { + MOZ_CRASH("Not implemented because this should be unreachable."); +} + +void GetDatabasesOp::SendResults() { + AssertIsOnOwningThread(); + MOZ_ASSERT(mState == State::SendingResults); + +#ifdef DEBUG + NoteActorDestroyed(); +#endif + + mResolver(mDatabaseMetadataArray); + + mDirectoryLock = nullptr; + + CleanupMetadata(); + + FinishSendResults(); +} + TransactionDatabaseOperationBase::TransactionDatabaseOperationBase( - SafeRefPtr<TransactionBase> aTransaction) + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId) : DatabaseOperationBase(aTransaction->GetLoggingInfo()->Id(), aTransaction->GetLoggingInfo()->NextRequestSN()), mTransaction(WrapNotNull(std::move(aTransaction))), + mRequestId(aRequestId), mTransactionIsAborted((*mTransaction)->IsAborted()), mTransactionLoggingSerialNumber((*mTransaction)->LoggingSerialNumber()) { MOZ_ASSERT(LoggingSerialNumber()); } TransactionDatabaseOperationBase::TransactionDatabaseOperationBase( - SafeRefPtr<TransactionBase> aTransaction, uint64_t aLoggingSerialNumber) + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId, + uint64_t aLoggingSerialNumber) : DatabaseOperationBase(aTransaction->GetLoggingInfo()->Id(), aLoggingSerialNumber), mTransaction(WrapNotNull(std::move(aTransaction))), + mRequestId(aRequestId), mTransactionIsAborted((*mTransaction)->IsAborted()), mTransactionLoggingSerialNumber((*mTransaction)->LoggingSerialNumber()) {} @@ -16729,7 +17318,7 @@ void TransactionDatabaseOperationBase::SendPreprocessInfoOrResults( mWaitingForContinue = true; } else { if (mLoggingSerialNumber) { - (*mTransaction)->NoteFinishedRequest(mLoggingSerialNumber, ResultCode()); + (*mTransaction)->NoteFinishedRequest(mRequestId, ResultCode()); } Cleanup(); @@ -18199,8 +18788,9 @@ mozilla::ipc::IPCResult NormalTransactionOp::RecvContinue( } ObjectStoreAddOrPutRequestOp::ObjectStoreAddOrPutRequestOp( - SafeRefPtr<TransactionBase> aTransaction, RequestParams&& aParams) - : NormalTransactionOp(std::move(aTransaction)), + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId, + RequestParams&& aParams) + : NormalTransactionOp(std::move(aTransaction), aRequestId), mParams( std::move(aParams.type() == RequestParams::TObjectStoreAddParams ? aParams.get_ObjectStoreAddParams().commonParams() @@ -18429,6 +19019,11 @@ nsresult ObjectStoreAddOrPutRequestOp::DoDatabaseWork( } QM_TRY(key.SetFromInteger(autoIncrementNum)); + + // Update index keys if primary key is preserved in child. + for (auto& updateInfo : mParams.indexUpdateInfos()) { + updateInfo.value().MaybeUpdateAutoIncrementKey(autoIncrementNum); + } } else if (key.IsFloat()) { double numericKey = key.ToFloat(); numericKey = std::min(numericKey, double(1LL << 53)); @@ -18715,9 +19310,9 @@ ObjectStoreAddOrPutRequestOp::SCInputStream::IsNonBlocking(bool* _retval) { } ObjectStoreGetRequestOp::ObjectStoreGetRequestOp( - SafeRefPtr<TransactionBase> aTransaction, const RequestParams& aParams, - bool aGetAll) - : NormalTransactionOp(std::move(aTransaction)), + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId, + const RequestParams& aParams, bool aGetAll) + : NormalTransactionOp(std::move(aTransaction), aRequestId), mObjectStoreId(aGetAll ? aParams.get_ObjectStoreGetAllParams().objectStoreId() : aParams.get_ObjectStoreGetParams().objectStoreId()), @@ -18887,9 +19482,9 @@ void ObjectStoreGetRequestOp::GetResponse(RequestResponse& aResponse, } ObjectStoreGetKeyRequestOp::ObjectStoreGetKeyRequestOp( - SafeRefPtr<TransactionBase> aTransaction, const RequestParams& aParams, - bool aGetAll) - : NormalTransactionOp(std::move(aTransaction)), + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId, + const RequestParams& aParams, bool aGetAll) + : NormalTransactionOp(std::move(aTransaction), aRequestId), mObjectStoreId( aGetAll ? aParams.get_ObjectStoreGetAllKeysParams().objectStoreId() : aParams.get_ObjectStoreGetKeyParams().objectStoreId()), @@ -18975,9 +19570,9 @@ void ObjectStoreGetKeyRequestOp::GetResponse(RequestResponse& aResponse, } ObjectStoreDeleteRequestOp::ObjectStoreDeleteRequestOp( - SafeRefPtr<TransactionBase> aTransaction, + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId, const ObjectStoreDeleteParams& aParams) - : NormalTransactionOp(std::move(aTransaction)), + : NormalTransactionOp(std::move(aTransaction), aRequestId), mParams(aParams), mObjectStoreMayHaveIndexes(false) { AssertIsOnBackgroundThread(); @@ -19036,9 +19631,9 @@ nsresult ObjectStoreDeleteRequestOp::DoDatabaseWork( } ObjectStoreClearRequestOp::ObjectStoreClearRequestOp( - SafeRefPtr<TransactionBase> aTransaction, + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId, const ObjectStoreClearParams& aParams) - : NormalTransactionOp(std::move(aTransaction)), + : NormalTransactionOp(std::move(aTransaction), aRequestId), mParams(aParams), mObjectStoreMayHaveIndexes(false) { AssertIsOnBackgroundThread(); @@ -19209,8 +19804,9 @@ SafeRefPtr<FullIndexMetadata> IndexRequestOpBase::IndexMetadataForParams( } IndexGetRequestOp::IndexGetRequestOp(SafeRefPtr<TransactionBase> aTransaction, + const int64_t aRequestId, const RequestParams& aParams, bool aGetAll) - : IndexRequestOpBase(std::move(aTransaction), aParams), + : IndexRequestOpBase(std::move(aTransaction), aRequestId, aParams), mDatabase(Transaction().GetDatabasePtr()), mOptionalKeyRange(aGetAll ? aParams.get_IndexGetAllParams().optionalKeyRange() @@ -19339,9 +19935,9 @@ void IndexGetRequestOp::GetResponse(RequestResponse& aResponse, } IndexGetKeyRequestOp::IndexGetKeyRequestOp( - SafeRefPtr<TransactionBase> aTransaction, const RequestParams& aParams, - bool aGetAll) - : IndexRequestOpBase(std::move(aTransaction), aParams), + SafeRefPtr<TransactionBase> aTransaction, const int64_t aRequestId, + const RequestParams& aParams, bool aGetAll) + : IndexRequestOpBase(std::move(aTransaction), aRequestId, aParams), mOptionalKeyRange( aGetAll ? aParams.get_IndexGetAllKeysParams().optionalKeyRange() : Some(aParams.get_IndexGetKeyParams().keyRange())), diff --git a/dom/indexedDB/ActorsParentCommon.cpp b/dom/indexedDB/ActorsParentCommon.cpp index 1b92e15dad..5f25bd8ad6 100644 --- a/dom/indexedDB/ActorsParentCommon.cpp +++ b/dom/indexedDB/ActorsParentCommon.cpp @@ -66,7 +66,7 @@ class nsIFile; namespace mozilla::dom::indexedDB { -static_assert(SNAPPY_VERSION == 0x010109); +static_assert(SNAPPY_VERSION == 0x010200); using mozilla::ipc::IsOnBackgroundThread; diff --git a/dom/indexedDB/DatabaseFileManager.h b/dom/indexedDB/DatabaseFileManager.h index 62d11e95a5..fdfea06ba1 100644 --- a/dom/indexedDB/DatabaseFileManager.h +++ b/dom/indexedDB/DatabaseFileManager.h @@ -31,12 +31,15 @@ class DatabaseFileManager final const quota::OriginMetadata mOriginMetadata; const nsString mDatabaseName; const nsCString mDatabaseID; + const nsString mDatabaseFilePath; RefPtr<IndexedDBCipherKeyManager> mCipherKeyManager; LazyInitializedOnce<const nsString> mDirectoryPath; LazyInitializedOnce<const nsString> mJournalDirectoryPath; + uint64_t mDatabaseVersion; + const bool mEnforcingQuota; const bool mIsInPrivateBrowsingMode; @@ -68,7 +71,8 @@ class DatabaseFileManager final DatabaseFileManager(PersistenceType aPersistenceType, const quota::OriginMetadata& aOriginMetadata, const nsAString& aDatabaseName, - const nsCString& aDatabaseID, bool aEnforcingQuota, + const nsCString& aDatabaseID, + const nsAString& aDatabaseFilePath, bool aEnforcingQuota, bool aIsInPrivateBrowsingMode); PersistenceType Type() const { return mPersistenceType; } @@ -83,6 +87,14 @@ class DatabaseFileManager final const nsCString& DatabaseID() const { return mDatabaseID; } + const nsAString& DatabaseFilePath() const { return mDatabaseFilePath; } + + uint64_t DatabaseVersion() const { return mDatabaseVersion; } + + void UpdateDatabaseVersion(uint64_t aDatabaseVersion) { + mDatabaseVersion = aDatabaseVersion; + } + IndexedDBCipherKeyManager& MutableCipherKeyManagerRef() const { MOZ_ASSERT(mIsInPrivateBrowsingMode); MOZ_ASSERT(mCipherKeyManager); diff --git a/dom/indexedDB/IDBCursor.cpp b/dom/indexedDB/IDBCursor.cpp index 2fb6e98715..65234bf792 100644 --- a/dom/indexedDB/IDBCursor.cpp +++ b/dom/indexedDB/IDBCursor.cpp @@ -417,7 +417,8 @@ void IDBTypedCursor<CursorType>::Continue(JSContext* const aCx, IDB_LOG_STRINGIFY(key)); } - GetTypedBackgroundActorRef().SendContinueInternal(ContinueParams(key), mData); + GetTypedBackgroundActorRef().SendContinueInternal( + mTransaction->NextRequestId(), ContinueParams(key), mData); mContinueCalled = true; } @@ -523,6 +524,7 @@ void IDBTypedCursor<CursorType>::ContinuePrimaryKey( IDB_LOG_STRINGIFY(key), IDB_LOG_STRINGIFY(primaryKey)); GetTypedBackgroundActorRef().SendContinueInternal( + mTransaction->NextRequestId(), ContinuePrimaryKeyParams(key, primaryKey), mData); mContinueCalled = true; @@ -573,8 +575,8 @@ void IDBTypedCursor<CursorType>::Advance(const uint32_t aCount, IDB_LOG_STRINGIFY(mSource), IDB_LOG_STRINGIFY(mDirection), aCount); } - GetTypedBackgroundActorRef().SendContinueInternal(AdvanceParams(aCount), - mData); + GetTypedBackgroundActorRef().SendContinueInternal( + mTransaction->NextRequestId(), AdvanceParams(aCount), mData); mContinueCalled = true; } diff --git a/dom/indexedDB/IDBDatabase.cpp b/dom/indexedDB/IDBDatabase.cpp index 4bbc0fc68a..c1a70e9401 100644 --- a/dom/indexedDB/IDBDatabase.cpp +++ b/dom/indexedDB/IDBDatabase.cpp @@ -20,6 +20,7 @@ #include "MainThreadUtils.h" #include "mozilla/ResultExtensions.h" #include "mozilla/Services.h" +#include "mozilla/dom/IDBTransactionBinding.h" #include "mozilla/storage.h" #include "mozilla/Telemetry.h" #include "mozilla/dom/BindingDeclarations.h" @@ -474,7 +475,8 @@ void IDBDatabase::DeleteObjectStore(const nsAString& aName, ErrorResult& aRv) { RefPtr<IDBTransaction> IDBDatabase::Transaction( JSContext* aCx, const StringOrStringSequence& aStoreNames, - IDBTransactionMode aMode, ErrorResult& aRv) { + IDBTransactionMode aMode, const IDBTransactionOptions& aOptions, + ErrorResult& aRv) { AssertIsOnOwningThread(); if ((aMode == IDBTransactionMode::Readwriteflush || @@ -598,8 +600,26 @@ RefPtr<IDBTransaction> IDBDatabase::Transaction( MOZ_CRASH("Unknown mode!"); } + auto durability = IDBTransaction::Durability::Default; + if (aOptions.IsAnyMemberPresent()) { + switch (aOptions.mDurability) { + case mozilla::dom::IDBTransactionDurability::Default: + durability = IDBTransaction::Durability::Default; + break; + case mozilla::dom::IDBTransactionDurability::Strict: + durability = IDBTransaction::Durability::Strict; + break; + case mozilla::dom::IDBTransactionDurability::Relaxed: + durability = IDBTransaction::Durability::Relaxed; + break; + + default: + MOZ_CRASH("Unknown durability hint!"); + } + } + SafeRefPtr<IDBTransaction> transaction = - IDBTransaction::Create(aCx, this, sortedStoreNames, mode); + IDBTransaction::Create(aCx, this, sortedStoreNames, mode, durability); if (NS_WARN_IF(!transaction)) { IDB_REPORT_INTERNAL_ERR(); MOZ_ASSERT(!NS_IsMainThread(), @@ -617,7 +637,7 @@ RefPtr<IDBTransaction> IDBDatabase::Transaction( IDB_LOG_STRINGIFY(*transaction)); if (!mBackgroundActor->SendPBackgroundIDBTransactionConstructor( - actor, sortedStoreNames, mode)) { + actor, sortedStoreNames, mode, durability)) { IDB_REPORT_INTERNAL_ERR(); aRv.ThrowUnknownError("Failed to create IndexedDB transaction"); return nullptr; diff --git a/dom/indexedDB/IDBDatabase.h b/dom/indexedDB/IDBDatabase.h index 3f7c4aa63c..6d96aaa35d 100644 --- a/dom/indexedDB/IDBDatabase.h +++ b/dom/indexedDB/IDBDatabase.h @@ -166,7 +166,8 @@ class IDBDatabase final : public DOMEventTargetHelper { // This will be called from the DOM. [[nodiscard]] RefPtr<IDBTransaction> Transaction( JSContext* aCx, const StringOrStringSequence& aStoreNames, - IDBTransactionMode aMode, ErrorResult& aRv); + IDBTransactionMode aMode, const IDBTransactionOptions& aOptions, + ErrorResult& aRv); IMPL_EVENT_HANDLER(abort) IMPL_EVENT_HANDLER(close) diff --git a/dom/indexedDB/IDBFactory.cpp b/dom/indexedDB/IDBFactory.cpp index 81dce07d7e..51d4c4df23 100644 --- a/dom/indexedDB/IDBFactory.cpp +++ b/dom/indexedDB/IDBFactory.cpp @@ -15,8 +15,9 @@ #include "mozilla/dom/BindingDeclarations.h" #include "mozilla/dom/Document.h" #include "mozilla/dom/IDBFactoryBinding.h" -#include "mozilla/dom/quota/PersistenceType.h" +#include "mozilla/dom/Promise.h" #include "mozilla/dom/quota/QuotaManager.h" +#include "mozilla/dom/quota/ResultExtensions.h" #include "mozilla/dom/BrowserChild.h" #include "mozilla/dom/WorkerPrivate.h" #include "mozilla/ipc/BackgroundChild.h" @@ -378,6 +379,32 @@ bool IDBFactory::AllowedForPrincipal(nsIPrincipal* aPrincipal, return !aPrincipal->GetIsNullPrincipal(); } +// static +PersistenceType IDBFactory::GetPersistenceType( + const PrincipalInfo& aPrincipalInfo) { + if (aPrincipalInfo.type() == PrincipalInfo::TSystemPrincipalInfo) { + // Chrome privilege always gets persistent storage. + return PERSISTENCE_TYPE_PERSISTENT; + } + + if (aPrincipalInfo.type() == PrincipalInfo::TContentPrincipalInfo) { + nsCString origin = + aPrincipalInfo.get_ContentPrincipalInfo().originNoSuffix(); + + if (QuotaManager::IsOriginInternal(origin)) { + // Internal origins always get persistent storage. + return PERSISTENCE_TYPE_PERSISTENT; + } + + if (aPrincipalInfo.get_ContentPrincipalInfo().attrs().mPrivateBrowsingId > + 0) { + return PERSISTENCE_TYPE_PRIVATE; + } + } + + return PERSISTENCE_TYPE_DEFAULT; +} + void IDBFactory::UpdateActiveTransactionCount(int32_t aDelta) { AssertIsOnOwningThread(); MOZ_DIAGNOSTIC_ASSERT(aDelta > 0 || (mActiveTransactionCount + aDelta) < @@ -443,6 +470,71 @@ RefPtr<IDBOpenDBRequest> IDBFactory::DeleteDatabase( /* aDeleting */ true, aCallerType, aRv); } +already_AddRefed<Promise> IDBFactory::Databases(JSContext* const aCx) { + RefPtr<Promise> promise = Promise::CreateInfallible(GetOwnerGlobal()); + + // Nothing can be done here if we have previously failed to create a + // background actor. + if (mBackgroundActorFailed) { + promise->MaybeReject(NS_ERROR_FAILURE); + return promise.forget(); + } + + PersistenceType persistenceType = GetPersistenceType(*mPrincipalInfo); + + QM_TRY(MOZ_TO_RESULT(EnsureBackgroundActor()), [&promise](const nsresult rv) { + promise->MaybeReject(rv); + return promise.forget(); + }); + + mBackgroundActor->SendGetDatabases(persistenceType, *mPrincipalInfo) + ->Then( + GetCurrentSerialEventTarget(), __func__, + [promise](const PBackgroundIDBFactoryChild::GetDatabasesPromise:: + ResolveOrRejectValue& aValue) { + if (aValue.IsReject()) { + promise->MaybeReject(NS_ERROR_FAILURE); + return; + } + + const GetDatabasesResponse& response = aValue.ResolveValue(); + + switch (response.type()) { + case GetDatabasesResponse::Tnsresult: + promise->MaybeReject(response.get_nsresult()); + + break; + + case GetDatabasesResponse::TArrayOfDatabaseMetadata: { + const auto& array = response.get_ArrayOfDatabaseMetadata(); + + Sequence<IDBDatabaseInfo> databaseInfos; + + for (const auto& databaseMetadata : array) { + IDBDatabaseInfo databaseInfo; + + databaseInfo.mName.Construct(databaseMetadata.name()); + databaseInfo.mVersion.Construct(databaseMetadata.version()); + + if (!databaseInfos.AppendElement(std::move(databaseInfo), + fallible)) { + promise->MaybeRejectWithTypeError("Out of memory"); + return; + } + } + + promise->MaybeResolve(databaseInfos); + + break; + } + default: + MOZ_CRASH("Unknown response type!"); + } + }); + + return promise.forget(); +} + int16_t IDBFactory::Cmp(JSContext* aCx, JS::Handle<JS::Value> aFirst, JS::Handle<JS::Value> aSecond, ErrorResult& aRv) { Key first, second; @@ -512,6 +604,63 @@ RefPtr<IDBOpenDBRequest> IDBFactory::DeleteForPrincipal( /* aDeleting */ true, aGuarantee, aRv); } +nsresult IDBFactory::EnsureBackgroundActor() { + if (mBackgroundActor) { + return NS_OK; + } + + BackgroundChildImpl::ThreadLocal* threadLocal = + BackgroundChildImpl::GetThreadLocalForCurrentThread(); + + UniquePtr<ThreadLocal> newIDBThreadLocal; + ThreadLocal* idbThreadLocal; + + if (threadLocal && threadLocal->mIndexedDBThreadLocal) { + idbThreadLocal = threadLocal->mIndexedDBThreadLocal.get(); + } else { + nsCOMPtr<nsIUUIDGenerator> uuidGen = + do_GetService("@mozilla.org/uuid-generator;1"); + MOZ_ASSERT(uuidGen); + + nsID id{}; + MOZ_ALWAYS_SUCCEEDS(uuidGen->GenerateUUIDInPlace(&id)); + + newIDBThreadLocal = WrapUnique(new ThreadLocal(id)); + idbThreadLocal = newIDBThreadLocal.get(); + } + + PBackgroundChild* backgroundActor = + BackgroundChild::GetOrCreateForCurrentThread(); + if (NS_WARN_IF(!backgroundActor)) { + return NS_ERROR_FAILURE; + } + + { + BackgroundFactoryChild* actor = new BackgroundFactoryChild(*this); + + mBackgroundActor = static_cast<BackgroundFactoryChild*>( + backgroundActor->SendPBackgroundIDBFactoryConstructor( + actor, idbThreadLocal->GetLoggingInfo(), + IndexedDatabaseManager::GetLocale())); + + if (NS_WARN_IF(!mBackgroundActor)) { + return NS_ERROR_FAILURE; + } + } + + if (newIDBThreadLocal) { + if (!threadLocal) { + threadLocal = BackgroundChildImpl::GetThreadLocalForCurrentThread(); + } + MOZ_ASSERT(threadLocal); + MOZ_ASSERT(!threadLocal->mIndexedDBThreadLocal); + + threadLocal->mIndexedDBThreadLocal = std::move(newIDBThreadLocal); + } + + return NS_OK; +} + RefPtr<IDBOpenDBRequest> IDBFactory::OpenInternal( JSContext* aCx, nsIPrincipal* aPrincipal, const nsAString& aName, const Optional<uint64_t>& aVersion, bool aDeleting, CallerType aCallerType, @@ -590,29 +739,7 @@ RefPtr<IDBOpenDBRequest> IDBFactory::OpenInternal( return nullptr; } - PersistenceType persistenceType; - - bool isPersistent = - principalInfo.type() == PrincipalInfo::TSystemPrincipalInfo; - if (!isPersistent && - principalInfo.type() == PrincipalInfo::TContentPrincipalInfo) { - nsCString origin = - principalInfo.get_ContentPrincipalInfo().originNoSuffix(); - isPersistent = QuotaManager::IsOriginInternal(origin); - } - - const bool isPrivate = - principalInfo.type() == PrincipalInfo::TContentPrincipalInfo && - principalInfo.get_ContentPrincipalInfo().attrs().mPrivateBrowsingId > 0; - - if (isPersistent) { - // Chrome privilege and internal origins always get persistent storage. - persistenceType = PERSISTENCE_TYPE_PERSISTENT; - } else if (isPrivate) { - persistenceType = PERSISTENCE_TYPE_PRIVATE; - } else { - persistenceType = PERSISTENCE_TYPE_DEFAULT; - } + PersistenceType persistenceType = GetPersistenceType(principalInfo); DatabaseMetadata& metadata = commonParams.metadata(); metadata.name() = aName; @@ -627,60 +754,11 @@ RefPtr<IDBOpenDBRequest> IDBFactory::OpenInternal( params = OpenDatabaseRequestParams(commonParams); } - if (!mBackgroundActor) { - BackgroundChildImpl::ThreadLocal* threadLocal = - BackgroundChildImpl::GetThreadLocalForCurrentThread(); - - UniquePtr<ThreadLocal> newIDBThreadLocal; - ThreadLocal* idbThreadLocal; - - if (threadLocal && threadLocal->mIndexedDBThreadLocal) { - idbThreadLocal = threadLocal->mIndexedDBThreadLocal.get(); - } else { - nsCOMPtr<nsIUUIDGenerator> uuidGen = - do_GetService("@mozilla.org/uuid-generator;1"); - MOZ_ASSERT(uuidGen); - - nsID id; - MOZ_ALWAYS_SUCCEEDS(uuidGen->GenerateUUIDInPlace(&id)); - - newIDBThreadLocal = WrapUnique(new ThreadLocal(id)); - idbThreadLocal = newIDBThreadLocal.get(); - } - - PBackgroundChild* backgroundActor = - BackgroundChild::GetOrCreateForCurrentThread(); - if (NS_WARN_IF(!backgroundActor)) { - IDB_REPORT_INTERNAL_ERR(); - aRv.Throw(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); - return nullptr; - } - - { - BackgroundFactoryChild* actor = new BackgroundFactoryChild(*this); - - mBackgroundActor = static_cast<BackgroundFactoryChild*>( - backgroundActor->SendPBackgroundIDBFactoryConstructor( - actor, idbThreadLocal->GetLoggingInfo(), - IndexedDatabaseManager::GetLocale())); - - if (NS_WARN_IF(!mBackgroundActor)) { - mBackgroundActorFailed = true; - IDB_REPORT_INTERNAL_ERR(); - aRv.Throw(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); - return nullptr; - } - } - - if (newIDBThreadLocal) { - if (!threadLocal) { - threadLocal = BackgroundChildImpl::GetThreadLocalForCurrentThread(); - } - MOZ_ASSERT(threadLocal); - MOZ_ASSERT(!threadLocal->mIndexedDBThreadLocal); - - threadLocal->mIndexedDBThreadLocal = std::move(newIDBThreadLocal); - } + nsresult rv = EnsureBackgroundActor(); + if (NS_WARN_IF(NS_FAILED(rv))) { + IDB_REPORT_INTERNAL_ERR(); + aRv.Throw(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); + return nullptr; } RefPtr<IDBOpenDBRequest> request = IDBOpenDBRequest::Create( @@ -704,7 +782,7 @@ RefPtr<IDBOpenDBRequest> IDBFactory::OpenInternal( IDB_LOG_STRINGIFY(aVersion)); } - nsresult rv = InitiateRequest(WrapNotNull(request), params); + rv = InitiateRequest(WrapNotNull(request), params); if (NS_WARN_IF(NS_FAILED(rv))) { IDB_REPORT_INTERNAL_ERR(); aRv.Throw(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); diff --git a/dom/indexedDB/IDBFactory.h b/dom/indexedDB/IDBFactory.h index 488f885ae7..7139b26f9c 100644 --- a/dom/indexedDB/IDBFactory.h +++ b/dom/indexedDB/IDBFactory.h @@ -9,6 +9,7 @@ #include "mozilla/Attributes.h" #include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/quota/PersistenceType.h" #include "mozilla/GlobalTeardownObserver.h" #include "mozilla/UniquePtr.h" #include "nsCOMPtr.h" @@ -59,6 +60,7 @@ class IDBFactory final : public GlobalTeardownObserver, public nsWrapperCache { UniquePtr<PrincipalInfo> mPrincipalInfo; + // TODO: Unused, remove me! nsCOMPtr<nsIGlobalObject> mGlobal; // This will only be set if the factory belongs to a window in a child @@ -96,6 +98,9 @@ class IDBFactory final : public GlobalTeardownObserver, public nsWrapperCache { static bool AllowedForPrincipal(nsIPrincipal* aPrincipal, bool* aIsSystemPrincipal = nullptr); + static quota::PersistenceType GetPersistenceType( + const PrincipalInfo& aPrincipalInfo); + void AssertIsOnOwningThread() const { NS_ASSERT_OWNINGTHREAD(IDBFactory); } nsISerialEventTarget* EventTarget() const { @@ -157,6 +162,8 @@ class IDBFactory final : public GlobalTeardownObserver, public nsWrapperCache { JSContext* aCx, const nsAString& aName, const IDBOpenDBOptions& aOptions, CallerType aCallerType, ErrorResult& aRv); + already_AddRefed<Promise> Databases(JSContext* aCx); + int16_t Cmp(JSContext* aCx, JS::Handle<JS::Value> aFirst, JS::Handle<JS::Value> aSecond, ErrorResult& aRv); @@ -194,6 +201,8 @@ class IDBFactory final : public GlobalTeardownObserver, public nsWrapperCache { static nsresult AllowedForWindowInternal(nsPIDOMWindowInner* aWindow, nsCOMPtr<nsIPrincipal>* aPrincipal); + nsresult EnsureBackgroundActor(); + [[nodiscard]] RefPtr<IDBOpenDBRequest> OpenInternal( JSContext* aCx, nsIPrincipal* aPrincipal, const nsAString& aName, const Optional<uint64_t>& aVersion, bool aDeleting, diff --git a/dom/indexedDB/IDBObjectStore.cpp b/dom/indexedDB/IDBObjectStore.cpp index e6464d2410..728f10b105 100644 --- a/dom/indexedDB/IDBObjectStore.cpp +++ b/dom/indexedDB/IDBObjectStore.cpp @@ -410,13 +410,20 @@ RefPtr<IDBObjectStore> IDBObjectStore::Create( void IDBObjectStore::AppendIndexUpdateInfo( const int64_t aIndexID, const KeyPath& aKeyPath, const bool aMultiEntry, const nsCString& aLocale, JSContext* const aCx, JS::Handle<JS::Value> aVal, - nsTArray<IndexUpdateInfo>* const aUpdateInfoArray, ErrorResult* const aRv) { + nsTArray<IndexUpdateInfo>* const aUpdateInfoArray, + const VoidOrObjectStoreKeyPathString& aAutoIncrementedObjectStoreKeyPath, + ErrorResult* const aRv) { // This precondition holds when `aVal` is the result of a structured clone. js::AutoAssertNoContentJS noContentJS(aCx); + static_assert(std::is_same_v<IDBObjectStore::VoidOrObjectStoreKeyPathString, + KeyPath::VoidOrObjectStoreKeyPathString>, + "Inconsistent types"); + if (!aMultiEntry) { Key key; - *aRv = aKeyPath.ExtractKey(aCx, aVal, key); + *aRv = + aKeyPath.ExtractKey(aCx, aVal, key, aAutoIncrementedObjectStoreKeyPath); // If an index's keyPath doesn't match an object, we ignore that object. if (aRv->ErrorCodeIs(NS_ERROR_DOM_INDEXEDDB_DATA_ERR) || key.IsUnset()) { @@ -625,6 +632,21 @@ void IDBObjectStore::GetAddInfo(JSContext* aCx, ValueWrapper& aValueWrapper, const nsTArray<IndexMetadata>& indexes = mSpec->indexes(); const uint32_t idxCount = indexes.Length(); + const auto& autoIncrementedObjectStoreKeyPath = + [this]() -> const nsAString& { + if (AutoIncrement() && GetKeyPath().IsValid()) { + // By https://w3c.github.io/IndexedDB/#database-interface , + // createObjectStore algorithm, step 8, neither arrays nor empty paths + // are allowed for autoincremented object stores. + // See also KeyPath::IsAllowedForObjectStore. + MOZ_ASSERT(GetKeyPath().IsString()); + MOZ_ASSERT(!GetKeyPath().IsEmpty()); + return GetKeyPath().mStrings[0]; + } + + return VoidString(); + }(); + aUpdateInfoArray.SetCapacity(idxCount); // Pretty good estimate for (uint32_t idxIndex = 0; idxIndex < idxCount; idxIndex++) { @@ -632,7 +654,8 @@ void IDBObjectStore::GetAddInfo(JSContext* aCx, ValueWrapper& aValueWrapper, AppendIndexUpdateInfo(metadata.id(), metadata.keyPath(), metadata.multiEntry(), metadata.locale(), aCx, - aValueWrapper.Value(), &aUpdateInfoArray, &aRv); + aValueWrapper.Value(), &aUpdateInfoArray, + autoIncrementedObjectStoreKeyPath, &aRv); if (NS_WARN_IF(aRv.Failed())) { return; } diff --git a/dom/indexedDB/IDBObjectStore.h b/dom/indexedDB/IDBObjectStore.h index dc79fa3616..99bec23327 100644 --- a/dom/indexedDB/IDBObjectStore.h +++ b/dom/indexedDB/IDBObjectStore.h @@ -48,6 +48,7 @@ class IDBObjectStore final : public nsISupports, public nsWrapperCache { using KeyPath = indexedDB::KeyPath; using ObjectStoreSpec = indexedDB::ObjectStoreSpec; using StructuredCloneReadInfoChild = indexedDB::StructuredCloneReadInfoChild; + using VoidOrObjectStoreKeyPathString = nsAString; // For AddOrPut() and DeleteInternal(). // TODO Consider removing this, and making the functions public? @@ -98,11 +99,12 @@ class IDBObjectStore final : public nsISupports, public nsWrapperCache { [[nodiscard]] static RefPtr<IDBObjectStore> Create( SafeRefPtr<IDBTransaction> aTransaction, ObjectStoreSpec& aSpec); - static void AppendIndexUpdateInfo(int64_t aIndexID, const KeyPath& aKeyPath, - bool aMultiEntry, const nsCString& aLocale, - JSContext* aCx, JS::Handle<JS::Value> aVal, - nsTArray<IndexUpdateInfo>* aUpdateInfoArray, - ErrorResult* aRv); + static void AppendIndexUpdateInfo( + int64_t aIndexID, const KeyPath& aKeyPath, bool aMultiEntry, + const nsCString& aLocale, JSContext* aCx, JS::Handle<JS::Value> aVal, + nsTArray<IndexUpdateInfo>* aUpdateInfoArray, + const VoidOrObjectStoreKeyPathString& aAutoIncrementedObjectStoreKeyPath, + ErrorResult* aRv); static void ClearCloneReadInfo( indexedDB::StructuredCloneReadInfoChild& aReadInfo); diff --git a/dom/indexedDB/IDBTransaction.cpp b/dom/indexedDB/IDBTransaction.cpp index d984bcacdf..b35bea6eff 100644 --- a/dom/indexedDB/IDBTransaction.cpp +++ b/dom/indexedDB/IDBTransaction.cpp @@ -89,8 +89,9 @@ auto IDBTransaction::DoWithTransactionChild(const Func& aFunc) const { IDBTransaction::IDBTransaction(IDBDatabase* const aDatabase, const nsTArray<nsString>& aObjectStoreNames, - const Mode aMode, nsString aFilename, - const uint32_t aLineNo, const uint32_t aColumn, + const Mode aMode, const Durability aDurability, + nsString aFilename, const uint32_t aLineNo, + const uint32_t aColumn, CreatedFromFactoryFunction /*aDummy*/) : DOMEventTargetHelper(aDatabase), mDatabase(aDatabase), @@ -98,12 +99,14 @@ IDBTransaction::IDBTransaction(IDBDatabase* const aDatabase, mLoggingSerialNumber(GetIndexedDBThreadLocal()->NextTransactionSN(aMode)), mNextObjectStoreId(0), mNextIndexId(0), + mNextRequestId(0), mAbortCode(NS_OK), mPendingRequestCount(0), mFilename(std::move(aFilename)), mLineNo(aLineNo), mColumn(aColumn), mMode(aMode), + mDurability(aDurability), mRegistered(false), mNotedActiveTransaction(false) { MOZ_ASSERT(aDatabase); @@ -177,9 +180,11 @@ SafeRefPtr<IDBTransaction> IDBTransaction::CreateVersionChange( nsString filename; uint32_t lineNo, column; aOpenRequest->GetCallerLocation(filename, &lineNo, &column); + // XXX: What should we have as durability hint here? auto transaction = MakeSafeRefPtr<IDBTransaction>( aDatabase, emptyObjectStoreNames, Mode::VersionChange, - std::move(filename), lineNo, column, CreatedFromFactoryFunction{}); + Durability::Default, std::move(filename), lineNo, column, + CreatedFromFactoryFunction{}); transaction->NoteActiveTransaction(); @@ -196,7 +201,8 @@ SafeRefPtr<IDBTransaction> IDBTransaction::CreateVersionChange( // static SafeRefPtr<IDBTransaction> IDBTransaction::Create( JSContext* const aCx, IDBDatabase* const aDatabase, - const nsTArray<nsString>& aObjectStoreNames, const Mode aMode) { + const nsTArray<nsString>& aObjectStoreNames, const Mode aMode, + const Durability aDurability) { MOZ_ASSERT(aDatabase); aDatabase->AssertIsOnOwningThread(); MOZ_ASSERT(!aObjectStoreNames.IsEmpty()); @@ -207,8 +213,8 @@ SafeRefPtr<IDBTransaction> IDBTransaction::Create( uint32_t lineNo, column; IDBRequest::CaptureCaller(aCx, filename, &lineNo, &column); auto transaction = MakeSafeRefPtr<IDBTransaction>( - aDatabase, aObjectStoreNames, aMode, std::move(filename), lineNo, column, - CreatedFromFactoryFunction{}); + aDatabase, aObjectStoreNames, aMode, aDurability, std::move(filename), + lineNo, column, CreatedFromFactoryFunction{}); if (!NS_IsMainThread()) { WorkerPrivate* const workerPrivate = GetCurrentThreadWorkerPrivate(); @@ -287,8 +293,9 @@ BackgroundRequestChild* IDBTransaction::StartRequest( BackgroundRequestChild* const actor = new BackgroundRequestChild(std::move(aRequest)); - DoWithTransactionChild([actor, &aParams](auto& transactionChild) { - transactionChild.SendPBackgroundIDBRequestConstructor(actor, aParams); + DoWithTransactionChild([this, actor, &aParams](auto& transactionChild) { + transactionChild.SendPBackgroundIDBRequestConstructor( + actor, NextRequestId(), aParams); }); // Balanced in BackgroundRequestChild::Recv__delete__(). @@ -302,8 +309,9 @@ void IDBTransaction::OpenCursor(PBackgroundIDBCursorChild& aBackgroundActor, AssertIsOnOwningThread(); MOZ_ASSERT(aParams.type() != OpenCursorParams::T__None); - DoWithTransactionChild([&aBackgroundActor, &aParams](auto& actor) { - actor.SendPBackgroundIDBCursorConstructor(&aBackgroundActor, aParams); + DoWithTransactionChild([this, &aBackgroundActor, &aParams](auto& actor) { + actor.SendPBackgroundIDBCursorConstructor(&aBackgroundActor, + NextRequestId(), aParams); }); // Balanced in BackgroundCursorChild::RecvResponse(). @@ -383,15 +391,16 @@ void IDBTransaction::SendCommit(const bool aAutoCommit) { LoggingSerialNumber(), requestSerialNumber, aAutoCommit ? "automatically" : "explicitly"); - const auto lastRequestSerialNumber = - [this, aAutoCommit, - requestSerialNumber]() -> Maybe<decltype(requestSerialNumber)> { + const int64_t requestId = NextRequestId(); + + const auto lastRequestId = [this, aAutoCommit, + requestId]() -> Maybe<decltype(requestId)> { if (aAutoCommit) { return Nothing(); } - // In case of an explicit commit, we need to note the serial number of the - // last request to check if a request submitted before the commit request + // In case of an explicit commit, we need to note the id of the last + // request to check if a request submitted before the commit request // failed. If we are currently in an event handler for a request on this // transaction, ignore this request. This is used to synchronize the // transaction's committing state with the parent side, to abort the @@ -405,15 +414,13 @@ void IDBTransaction::SendCommit(const bool aAutoCommit) { const bool dispatchingEventForThisTransaction = maybeCurrentTransaction && &maybeCurrentTransaction.ref() == this; - return Some(requestSerialNumber - ? (requestSerialNumber - - (dispatchingEventForThisTransaction ? 0 : 1)) + return Some(requestId + ? (requestId - (dispatchingEventForThisTransaction ? 0 : 1)) : 0); }(); - DoWithTransactionChild([lastRequestSerialNumber](auto& actor) { - actor.SendCommit(lastRequestSerialNumber); - }); + DoWithTransactionChild( + [lastRequestId](auto& actor) { actor.SendCommit(lastRequestId); }); mSentCommitOrAbort.Flip(); } @@ -817,6 +824,12 @@ int64_t IDBTransaction::NextIndexId() { return mNextIndexId++; } +int64_t IDBTransaction::NextRequestId() { + AssertIsOnOwningThread(); + + return mNextRequestId++; +} + void IDBTransaction::InvalidateCursorCaches() { AssertIsOnOwningThread(); @@ -869,6 +882,24 @@ IDBTransactionMode IDBTransaction::GetMode(ErrorResult& aRv) const { } } +IDBTransactionDurability IDBTransaction::GetDurability(ErrorResult& aRv) const { + AssertIsOnOwningThread(); + + switch (mDurability) { + case Durability::Default: + return IDBTransactionDurability::Default; + + case Durability::Strict: + return IDBTransactionDurability::Strict; + + case Durability::Relaxed: + return IDBTransactionDurability::Relaxed; + + default: + MOZ_CRASH("Bad mode!"); + } +} + DOMException* IDBTransaction::GetError() const { AssertIsOnOwningThread(); diff --git a/dom/indexedDB/IDBTransaction.h b/dom/indexedDB/IDBTransaction.h index 65fefddfe5..9feafb3c68 100644 --- a/dom/indexedDB/IDBTransaction.h +++ b/dom/indexedDB/IDBTransaction.h @@ -63,6 +63,15 @@ class IDBTransaction final Invalid }; + enum struct Durability { + Default = 0, + Strict, + Relaxed, + + // Only needed for IPC serialization helper, should never be used in code. + Invalid + }; + enum struct ReadyState { Active, Inactive, Committing, Finished }; private: @@ -90,6 +99,11 @@ class IDBTransaction final int64_t mNextObjectStoreId; int64_t mNextIndexId; + // Request ids are issued starting from 0 and incremented by one as we send + // actor creation messages to the parent process. Used to support the + // explicit commit() request. + int64_t mNextRequestId; + nsresult mAbortCode; ///< The result that caused the transaction to be ///< aborted, or NS_OK if not aborted. ///< NS_ERROR_DOM_INDEXEDDB_ABORT_ERR indicates that the @@ -108,6 +122,7 @@ class IDBTransaction final ReadyState mReadyState = ReadyState::Active; FlippedOnce<false> mStarted; const Mode mMode; + const Durability mDurability; bool mRegistered; ///< Whether mDatabase->RegisterTransaction() has been ///< called (which may not be the case if construction was @@ -130,7 +145,8 @@ class IDBTransaction final [[nodiscard]] static SafeRefPtr<IDBTransaction> Create( JSContext* aCx, IDBDatabase* aDatabase, - const nsTArray<nsString>& aObjectStoreNames, Mode aMode); + const nsTArray<nsString>& aObjectStoreNames, Mode aMode, + Durability aDurability); static Maybe<IDBTransaction&> MaybeCurrent(); @@ -232,6 +248,11 @@ class IDBTransaction final return mMode; } + Durability GetDurability() const { + AssertIsOnOwningThread(); + return mDurability; + } + uint32_t GetPendingRequestCount() const { return mPendingRequestCount; } IDBDatabase* Database() const { @@ -280,6 +301,9 @@ class IDBTransaction final // Only for Mode::VersionChange transactions. int64_t NextIndexId(); + // See the comment for mNextRequestId. + int64_t NextRequestId(); + void InvalidateCursorCaches(); void RegisterCursor(IDBCursor& aCursor); void UnregisterCursor(IDBCursor& aCursor); @@ -299,6 +323,8 @@ class IDBTransaction final IDBTransactionMode GetMode(ErrorResult& aRv) const; + IDBTransactionDurability GetDurability(ErrorResult& aRv) const; + DOMException* GetError() const; [[nodiscard]] RefPtr<IDBObjectStore> ObjectStore(const nsAString& aName, @@ -323,8 +349,8 @@ class IDBTransaction final public: IDBTransaction(IDBDatabase* aDatabase, const nsTArray<nsString>& aObjectStoreNames, Mode aMode, - nsString aFilename, uint32_t aLineNo, uint32_t aColumn, - CreatedFromFactoryFunction aDummy); + Durability aDurability, nsString aFilename, uint32_t aLineNo, + uint32_t aColumn, CreatedFromFactoryFunction aDummy); private: ~IDBTransaction(); diff --git a/dom/indexedDB/IndexedDatabase.cpp b/dom/indexedDB/IndexedDatabase.cpp index a73d9fbf5a..538aea5280 100644 --- a/dom/indexedDB/IndexedDatabase.cpp +++ b/dom/indexedDB/IndexedDatabase.cpp @@ -391,7 +391,8 @@ JSObject* CommonStructuredCloneReadCallback( !StructuredCloneHolder::ReadString(aReader, value)) { return nullptr; } - params->Append(key, value); + params->Append(NS_ConvertUTF16toUTF8(key), + NS_ConvertUTF16toUTF8(value)); } if (!WrapAsJSObject(aCx, params, &result)) { diff --git a/dom/indexedDB/IndexedDatabaseManager.cpp b/dom/indexedDB/IndexedDatabaseManager.cpp index 0558c38826..e63dd793cf 100644 --- a/dom/indexedDB/IndexedDatabaseManager.cpp +++ b/dom/indexedDB/IndexedDatabaseManager.cpp @@ -67,6 +67,13 @@ class FileManagerInfo { [[nodiscard]] SafeRefPtr<DatabaseFileManager> GetFileManager( PersistenceType aPersistenceType, const nsAString& aName) const; + [[nodiscard]] SafeRefPtr<DatabaseFileManager> + GetFileManagerByDatabaseFilePath(PersistenceType aPersistenceType, + const nsAString& aDatabaseFilePath) const; + + const nsTArray<SafeRefPtr<DatabaseFileManager>>& GetFileManagers( + PersistenceType aPersistenceType) const; + void AddFileManager(SafeRefPtr<DatabaseFileManager> aFileManager); bool HasFileManagers() const { @@ -86,18 +93,18 @@ class FileManagerInfo { const nsAString& aName); private: - nsTArray<SafeRefPtr<DatabaseFileManager> >& GetArray( + nsTArray<SafeRefPtr<DatabaseFileManager>>& GetArray( PersistenceType aPersistenceType); - const nsTArray<SafeRefPtr<DatabaseFileManager> >& GetImmutableArray( + const nsTArray<SafeRefPtr<DatabaseFileManager>>& GetImmutableArray( PersistenceType aPersistenceType) const { return const_cast<FileManagerInfo*>(this)->GetArray(aPersistenceType); } - nsTArray<SafeRefPtr<DatabaseFileManager> > mPersistentStorageFileManagers; - nsTArray<SafeRefPtr<DatabaseFileManager> > mTemporaryStorageFileManagers; - nsTArray<SafeRefPtr<DatabaseFileManager> > mDefaultStorageFileManagers; - nsTArray<SafeRefPtr<DatabaseFileManager> > mPrivateStorageFileManagers; + nsTArray<SafeRefPtr<DatabaseFileManager>> mPersistentStorageFileManagers; + nsTArray<SafeRefPtr<DatabaseFileManager>> mTemporaryStorageFileManagers; + nsTArray<SafeRefPtr<DatabaseFileManager>> mDefaultStorageFileManagers; + nsTArray<SafeRefPtr<DatabaseFileManager>> mPrivateStorageFileManagers; }; } // namespace indexedDB @@ -199,6 +206,13 @@ auto DatabaseNameMatchPredicate(const nsAString* const aName) { }; } +auto DatabaseFilePathMatchPredicate(const nsAString* const aDatabaseFilePath) { + MOZ_ASSERT(aDatabaseFilePath); + return [aDatabaseFilePath](const auto& fileManager) { + return fileManager->DatabaseFilePath() == *aDatabaseFilePath; + }; +} + } // namespace IndexedDatabaseManager::IndexedDatabaseManager() : mBackgroundActor(nullptr) { @@ -476,6 +490,35 @@ SafeRefPtr<DatabaseFileManager> IndexedDatabaseManager::GetFileManager( return info->GetFileManager(aPersistenceType, aDatabaseName); } +SafeRefPtr<DatabaseFileManager> +IndexedDatabaseManager::GetFileManagerByDatabaseFilePath( + PersistenceType aPersistenceType, const nsACString& aOrigin, + const nsAString& aDatabaseFilePath) { + AssertIsOnIOThread(); + + FileManagerInfo* info; + if (!mFileManagerInfos.Get(aOrigin, &info)) { + return nullptr; + } + + return info->GetFileManagerByDatabaseFilePath(aPersistenceType, + aDatabaseFilePath); +} + +const nsTArray<SafeRefPtr<DatabaseFileManager>>& +IndexedDatabaseManager::GetFileManagers(PersistenceType aPersistenceType, + const nsACString& aOrigin) { + AssertIsOnIOThread(); + + FileManagerInfo* info; + if (!mFileManagerInfos.Get(aOrigin, &info)) { + static nsTArray<SafeRefPtr<DatabaseFileManager>> emptyArray; + return emptyArray; + } + + return info->GetFileManagers(aPersistenceType); +} + void IndexedDatabaseManager::AddFileManager( SafeRefPtr<DatabaseFileManager> aFileManager) { AssertIsOnIOThread(); @@ -680,11 +723,34 @@ SafeRefPtr<DatabaseFileManager> FileManagerInfo::GetFileManager( return foundIt != end ? foundIt->clonePtr() : nullptr; } +SafeRefPtr<DatabaseFileManager> +FileManagerInfo::GetFileManagerByDatabaseFilePath( + PersistenceType aPersistenceType, + const nsAString& aDatabaseFilePath) const { + AssertIsOnIOThread(); + + const auto& managers = GetImmutableArray(aPersistenceType); + + const auto end = managers.cend(); + const auto foundIt = + std::find_if(managers.cbegin(), end, + DatabaseFilePathMatchPredicate(&aDatabaseFilePath)); + + return foundIt != end ? foundIt->clonePtr() : nullptr; +} + +const nsTArray<SafeRefPtr<DatabaseFileManager>>& +FileManagerInfo::GetFileManagers(PersistenceType aPersistenceType) const { + AssertIsOnIOThread(); + + return GetImmutableArray(aPersistenceType); +} + void FileManagerInfo::AddFileManager( SafeRefPtr<DatabaseFileManager> aFileManager) { AssertIsOnIOThread(); - nsTArray<SafeRefPtr<DatabaseFileManager> >& managers = + nsTArray<SafeRefPtr<DatabaseFileManager>>& managers = GetArray(aFileManager->Type()); NS_ASSERTION(!managers.Contains(aFileManager), "Adding more than once?!"); @@ -718,7 +784,7 @@ void FileManagerInfo::InvalidateAndRemoveFileManagers( PersistenceType aPersistenceType) { AssertIsOnIOThread(); - nsTArray<SafeRefPtr<DatabaseFileManager> >& managers = + nsTArray<SafeRefPtr<DatabaseFileManager>>& managers = GetArray(aPersistenceType); for (uint32_t i = 0; i < managers.Length(); i++) { @@ -743,7 +809,7 @@ void FileManagerInfo::InvalidateAndRemoveFileManager( } } -nsTArray<SafeRefPtr<DatabaseFileManager> >& FileManagerInfo::GetArray( +nsTArray<SafeRefPtr<DatabaseFileManager>>& FileManagerInfo::GetArray( PersistenceType aPersistenceType) { switch (aPersistenceType) { case PERSISTENCE_TYPE_PERSISTENT: diff --git a/dom/indexedDB/IndexedDatabaseManager.h b/dom/indexedDB/IndexedDatabaseManager.h index 0766143dd6..3d0f467368 100644 --- a/dom/indexedDB/IndexedDatabaseManager.h +++ b/dom/indexedDB/IndexedDatabaseManager.h @@ -99,6 +99,14 @@ class IndexedDatabaseManager final { PersistenceType aPersistenceType, const nsACString& aOrigin, const nsAString& aDatabaseName); + [[nodiscard]] SafeRefPtr<DatabaseFileManager> + GetFileManagerByDatabaseFilePath(PersistenceType aPersistenceType, + const nsACString& aOrigin, + const nsAString& aDatabaseFilePath); + + const nsTArray<SafeRefPtr<DatabaseFileManager>>& GetFileManagers( + PersistenceType aPersistenceType, const nsACString& aOrigin); + void AddFileManager(SafeRefPtr<DatabaseFileManager> aFileManager); void InvalidateAllFileManagers(); diff --git a/dom/indexedDB/Key.cpp b/dom/indexedDB/Key.cpp index 6f96023a54..7e0c607617 100644 --- a/dom/indexedDB/Key.cpp +++ b/dom/indexedDB/Key.cpp @@ -560,6 +560,51 @@ Result<Ok, nsresult> Key::EncodeString(const Span<const T> aInput, #define KEY_MAXIMUM_BUFFER_LENGTH \ ::mozilla::detail::nsTStringLengthStorage<char>::kMax +void Key::ReserveAutoIncrementKey(bool aFirstOfArray) { + // Allocate memory for the new size + uint32_t oldLen = mBuffer.Length(); + char* buffer; + if (!mBuffer.GetMutableData(&buffer, oldLen + 1 + sizeof(double))) { + return; + } + + // Remember the offset of the buffer to be updated later. + mAutoIncrementKeyOffsets.AppendElement(oldLen + 1); + + // Fill the type. + buffer += oldLen; + *(buffer++) = aFirstOfArray ? (eMaxType + eFloat) : eFloat; + + // Fill up with 0xFF to reserve the buffer in fixed size because the encoded + // string could be trimmed if ended with padding zeros. + mozilla::BigEndian::writeUint64(buffer, UINT64_MAX); +} + +void Key::MaybeUpdateAutoIncrementKey(int64_t aKey) { + if (mAutoIncrementKeyOffsets.IsEmpty()) { + return; + } + + for (uint32_t offset : mAutoIncrementKeyOffsets) { + char* buffer; + MOZ_ALWAYS_TRUE(mBuffer.GetMutableData(&buffer)); + buffer += offset; + WriteDoubleToUint64(buffer, double(aKey)); + } + + TrimBuffer(); +} + +void Key::WriteDoubleToUint64(char* aBuffer, double aValue) { + MOZ_ASSERT(aBuffer); + + uint64_t bits = BitwiseCast<uint64_t>(aValue); + const uint64_t signbit = FloatingPoint<double>::kSignBit; + uint64_t number = bits & signbit ? (-bits) : (bits | signbit); + + mozilla::BigEndian::writeUint64(aBuffer, number); +} + template <typename T> Result<Ok, nsresult> Key::EncodeAsString(const Span<const T> aInput, uint8_t aType) { @@ -797,13 +842,8 @@ Result<Ok, nsresult> Key::EncodeNumber(double aFloat, uint8_t aType) { *(buffer++) = aType; - uint64_t bits = BitwiseCast<uint64_t>(aFloat); - // Note: The subtraction from 0 below is necessary to fix - // MSVC build warning C4146 (negating an unsigned value). - const uint64_t signbit = FloatingPoint<double>::kSignBit; - uint64_t number = bits & signbit ? (0 - bits) : (bits | signbit); + WriteDoubleToUint64(buffer, aFloat); - mozilla::BigEndian::writeUint64(buffer, number); return Ok(); } diff --git a/dom/indexedDB/Key.h b/dom/indexedDB/Key.h index d19bc94e53..25ddd3e0b1 100644 --- a/dom/indexedDB/Key.h +++ b/dom/indexedDB/Key.h @@ -25,6 +25,7 @@ class Key { friend struct IPC::ParamTraits<Key>; nsCString mBuffer; + CopyableTArray<uint32_t> mAutoIncrementKeyOffsets; public: enum { @@ -86,7 +87,10 @@ class Key { return Compare(mBuffer, aOther.mBuffer) >= 0; } - void Unset() { mBuffer.SetIsVoid(true); } + void Unset() { + mBuffer.SetIsVoid(true); + mAutoIncrementKeyOffsets.Clear(); + } bool IsUnset() const { return mBuffer.IsVoid(); } @@ -174,6 +178,10 @@ class Key { return 0; } + void ReserveAutoIncrementKey(bool aFirstOfArray); + + void MaybeUpdateAutoIncrementKey(int64_t aKey); + private: class MOZ_STACK_CLASS ArrayValueEncoder; @@ -273,6 +281,8 @@ class Key { template <typename T> nsresult SetFromSource(T* aSource, uint32_t aIndex); + + void WriteDoubleToUint64(char* aBuffer, double aValue); }; } // namespace mozilla::dom::indexedDB diff --git a/dom/indexedDB/KeyPath.cpp b/dom/indexedDB/KeyPath.cpp index 5cad164296..f27ddd007a 100644 --- a/dom/indexedDB/KeyPath.cpp +++ b/dom/indexedDB/KeyPath.cpp @@ -329,8 +329,9 @@ bool KeyPath::AppendStringWithValidation(const nsAString& aString) { return false; } -nsresult KeyPath::ExtractKey(JSContext* aCx, const JS::Value& aValue, - Key& aKey) const { +nsresult KeyPath::ExtractKey(JSContext* aCx, const JS::Value& aValue, Key& aKey, + const VoidOrObjectStoreKeyPathString& + aAutoIncrementedObjectStoreKeyPath) const { uint32_t len = mStrings.Length(); JS::Rooted<JS::Value> value(aCx); @@ -341,6 +342,17 @@ nsresult KeyPath::ExtractKey(JSContext* aCx, const JS::Value& aValue, GetJSValFromKeyPathString(aCx, aValue, mStrings[i], value.address(), DoNotCreateProperties, nullptr, nullptr); if (NS_FAILED(rv)) { + if (!aAutoIncrementedObjectStoreKeyPath.IsVoid() && + mStrings[i].Equals(aAutoIncrementedObjectStoreKeyPath)) { + // We are extracting index keys of an object to be added if + // object store key path for a string key is provided. + // Because the autoIncrement primary key is part of + // this index key but is not defined in |aValue|, so we reserve + // the space here to update the key later in parent. + aKey.ReserveAutoIncrementKey(IsArray() && i == 0); + continue; + } + return rv; } diff --git a/dom/indexedDB/KeyPath.h b/dom/indexedDB/KeyPath.h index 4e1042650f..5fac30ecf8 100644 --- a/dom/indexedDB/KeyPath.h +++ b/dom/indexedDB/KeyPath.h @@ -45,6 +45,8 @@ class KeyPath { KeyPath() : mType(KeyPathType::NonExistent) { MOZ_COUNT_CTOR(KeyPath); } public: + using VoidOrObjectStoreKeyPathString = nsAString; + enum class KeyPathType { NonExistent, String, Array, EndGuard }; void SetType(KeyPathType aType); @@ -76,7 +78,10 @@ class KeyPath { static Result<KeyPath, nsresult> Parse( const Nullable<OwningStringOrStringSequence>& aValue); - nsresult ExtractKey(JSContext* aCx, const JS::Value& aValue, Key& aKey) const; + nsresult ExtractKey( + JSContext* aCx, const JS::Value& aValue, Key& aKey, + const VoidOrObjectStoreKeyPathString& aAutoIncrementedObjectStoreKeyPath = + VoidString()) const; nsresult ExtractKeyAsJSVal(JSContext* aCx, const JS::Value& aValue, JS::Value* aOutVal) const; diff --git a/dom/indexedDB/PBackgroundIDBCursor.ipdl b/dom/indexedDB/PBackgroundIDBCursor.ipdl index 60c8d2ca7b..e7669f2554 100644 --- a/dom/indexedDB/PBackgroundIDBCursor.ipdl +++ b/dom/indexedDB/PBackgroundIDBCursor.ipdl @@ -87,8 +87,8 @@ protocol PBackgroundIDBCursor parent: async DeleteMe(); - async Continue(CursorRequestParams params, Key currentKey, - Key currentObjectStoreKey); + async Continue(int64_t requestId, CursorRequestParams params, + Key currentKey, Key currentObjectStoreKey); child: async __delete__(); diff --git a/dom/indexedDB/PBackgroundIDBDatabase.ipdl b/dom/indexedDB/PBackgroundIDBDatabase.ipdl index f9262ebadf..88d5e79392 100644 --- a/dom/indexedDB/PBackgroundIDBDatabase.ipdl +++ b/dom/indexedDB/PBackgroundIDBDatabase.ipdl @@ -19,6 +19,9 @@ using struct mozilla::null_t from "mozilla/ipc/IPCCore.h"; using mozilla::dom::IDBTransaction::Mode from "mozilla/dom/IDBTransaction.h"; +using mozilla::dom::IDBTransaction::Durability + from "mozilla/dom/IDBTransaction.h"; + namespace mozilla { namespace dom { namespace indexedDB { @@ -41,7 +44,7 @@ parent: async PBackgroundIDBDatabaseFile(IPCBlob blob); - async PBackgroundIDBTransaction(nsString[] objectStoreNames, Mode mode); + async PBackgroundIDBTransaction(nsString[] objectStoreNames, Mode mode, Durability durability); child: async __delete__(); diff --git a/dom/indexedDB/PBackgroundIDBFactory.ipdl b/dom/indexedDB/PBackgroundIDBFactory.ipdl index ef2a88e55b..c838189b2b 100644 --- a/dom/indexedDB/PBackgroundIDBFactory.ipdl +++ b/dom/indexedDB/PBackgroundIDBFactory.ipdl @@ -40,6 +40,12 @@ union FactoryRequestParams DeleteDatabaseRequestParams; }; +union GetDatabasesResponse +{ + nsresult; + DatabaseMetadata[]; +}; + [ChildImpl="indexedDB::BackgroundFactoryChild", ParentImpl=virtual] sync protocol PBackgroundIDBFactory { @@ -53,6 +59,10 @@ parent: async PBackgroundIDBFactoryRequest(FactoryRequestParams params); + async GetDatabases(PersistenceType persistenceType, + PrincipalInfo principalInfo) + returns(GetDatabasesResponse response); + child: async __delete__(); diff --git a/dom/indexedDB/PBackgroundIDBTransaction.ipdl b/dom/indexedDB/PBackgroundIDBTransaction.ipdl index 85a9f76265..071e031cb2 100644 --- a/dom/indexedDB/PBackgroundIDBTransaction.ipdl +++ b/dom/indexedDB/PBackgroundIDBTransaction.ipdl @@ -34,9 +34,9 @@ parent: async Commit(int64_t? lastRequest); async Abort(nsresult resultCode); - async PBackgroundIDBCursor(OpenCursorParams params); + async PBackgroundIDBCursor(int64_t requestId, OpenCursorParams params); - async PBackgroundIDBRequest(RequestParams params); + async PBackgroundIDBRequest(int64_t requestId, RequestParams params); child: async __delete__(); diff --git a/dom/indexedDB/PBackgroundIDBVersionChangeTransaction.ipdl b/dom/indexedDB/PBackgroundIDBVersionChangeTransaction.ipdl index e139f0f1c3..c096c28996 100644 --- a/dom/indexedDB/PBackgroundIDBVersionChangeTransaction.ipdl +++ b/dom/indexedDB/PBackgroundIDBVersionChangeTransaction.ipdl @@ -36,9 +36,9 @@ parent: async DeleteIndex(int64_t objectStoreId, int64_t indexId); async RenameIndex(int64_t objectStoreId, int64_t indexId, nsString name); - async PBackgroundIDBCursor(OpenCursorParams params); + async PBackgroundIDBCursor(int64_t requestId, OpenCursorParams params); - async PBackgroundIDBRequest(RequestParams params); + async PBackgroundIDBRequest(int64_t requestId, RequestParams params); child: async __delete__(); diff --git a/dom/indexedDB/SchemaUpgrades.cpp b/dom/indexedDB/SchemaUpgrades.cpp index 234c4c9f04..17230e247f 100644 --- a/dom/indexedDB/SchemaUpgrades.cpp +++ b/dom/indexedDB/SchemaUpgrades.cpp @@ -2863,7 +2863,7 @@ nsresult UpgradeFileIdsFunction::Init(nsIFile* aFMDirectory, auto fileManager = MakeSafeRefPtr<DatabaseFileManager>( PERSISTENCE_TYPE_INVALID, quota::OriginMetadata{}, /* aDatabaseName */ u""_ns, /* aDatabaseID */ ""_ns, - /* aEnforcingQuota */ false, + /* aDatabaseFilePath */ u""_ns, /* aEnforcingQuota */ false, /* aIsInPrivateBrowsingMode */ false); nsresult rv = fileManager->Init(aFMDirectory, aConnection); diff --git a/dom/indexedDB/SerializationHelpers.h b/dom/indexedDB/SerializationHelpers.h index 488c1eb044..a79c6cefb4 100644 --- a/dom/indexedDB/SerializationHelpers.h +++ b/dom/indexedDB/SerializationHelpers.h @@ -31,10 +31,12 @@ struct ParamTraits<mozilla::dom::indexedDB::Key> { static void Write(MessageWriter* aWriter, const paramType& aParam) { WriteParam(aWriter, aParam.mBuffer); + WriteParam(aWriter, aParam.mAutoIncrementKeyOffsets); } static bool Read(MessageReader* aReader, paramType* aResult) { - return ReadParam(aReader, &aResult->mBuffer); + return ReadParam(aReader, &aResult->mBuffer) && + ReadParam(aReader, &aResult->mAutoIncrementKeyOffsets); } }; @@ -72,6 +74,13 @@ struct ParamTraits<mozilla::dom::IDBTransaction::Mode> mozilla::dom::IDBTransaction::Mode::ReadOnly, mozilla::dom::IDBTransaction::Mode::Invalid> {}; +template <> +struct ParamTraits<mozilla::dom::IDBTransaction::Durability> + : public ContiguousEnumSerializer< + mozilla::dom::IDBTransaction::Durability, + mozilla::dom::IDBTransaction::Durability::Default, + mozilla::dom::IDBTransaction::Durability::Invalid> {}; + } // namespace IPC #endif // mozilla_dom_indexeddb_serializationhelpers_h__ diff --git a/dom/indexedDB/test/mochitest-common.toml b/dom/indexedDB/test/mochitest-common.toml index d42228da45..0959f36e13 100644 --- a/dom/indexedDB/test/mochitest-common.toml +++ b/dom/indexedDB/test/mochitest-common.toml @@ -73,6 +73,7 @@ support-files = [ "unit/test_objectStore_remove_values.js", "unit/test_object_identity.js", "unit/test_odd_result_order.js", + "unit/test_open_and_databases.js", "unit/test_open_empty_db.js", "unit/test_open_for_principal.js", "unit/test_open_objectStore.js", @@ -299,6 +300,8 @@ skip-if = [ ["test_odd_result_order.html"] +["test_open_and_databases.html"] + ["test_open_empty_db.html"] ["test_open_for_principal.html"] diff --git a/dom/indexedDB/test/test_open_and_databases.html b/dom/indexedDB/test/test_open_and_databases.html new file mode 100644 index 0000000000..9d0113136e --- /dev/null +++ b/dom/indexedDB/test/test_open_and_databases.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Indexed Database Property Test</title> + + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + + <script type="text/javascript" src="unit/test_open_and_databases.js"></script> + <script type="text/javascript" src="helpers.js"></script> + +</head> + +<body onload="runTest();"></body> + +</html> diff --git a/dom/indexedDB/test/test_third_party.html b/dom/indexedDB/test/test_third_party.html index ee90de8dac..439f50d754 100644 --- a/dom/indexedDB/test/test_third_party.html +++ b/dom/indexedDB/test/test_third_party.html @@ -25,12 +25,12 @@ { host: "http://sub1.test2.example.org:8000", cookieBehavior: BEHAVIOR_REJECT, expectedResultFrame1: false, expectedResultFrame2: false }, { host: "http://" + window.location.host, cookieBehavior: BEHAVIOR_REJECTFOREIGN, expectedResultFrame1: true, expectedResultFrame2: true }, - { host: "http://example.com", cookieBehavior: BEHAVIOR_REJECTFOREIGN, expectedResultFrame1: false, expectedResultFrame2: true }, - { host: "http://sub1.test2.example.org:8000", cookieBehavior: BEHAVIOR_REJECTFOREIGN, expectedResultFrame1: false, expectedResultFrame2: true }, + { host: "http://example.com", cookieBehavior: BEHAVIOR_REJECTFOREIGN, expectedResultFrame1: false, expectedResultFrame2: false }, + { host: "http://sub1.test2.example.org:8000", cookieBehavior: BEHAVIOR_REJECTFOREIGN, expectedResultFrame1: false, expectedResultFrame2: false }, { host: "http://" + window.location.host, cookieBehavior: BEHAVIOR_LIMITFOREIGN, expectedResultFrame1: true, expectedResultFrame2: true }, - { host: "http://example.com", cookieBehavior: BEHAVIOR_LIMITFOREIGN, expectedResultFrame1: false, expectedResultFrame2: true }, - { host: "http://sub1.test2.example.org:8000", cookieBehavior: BEHAVIOR_LIMITFOREIGN, expectedResultFrame1: false, expectedResultFrame2: true }, + { host: "http://example.com", cookieBehavior: BEHAVIOR_LIMITFOREIGN, expectedResultFrame1: false, expectedResultFrame2: false }, + { host: "http://sub1.test2.example.org:8000", cookieBehavior: BEHAVIOR_LIMITFOREIGN, expectedResultFrame1: false, expectedResultFrame2: false }, ]; const iframe1Path = diff --git a/dom/indexedDB/test/unit/test_connection_idle_maintenance.js b/dom/indexedDB/test/unit/test_connection_idle_maintenance.js index 288f656c65..819b0b61bb 100644 --- a/dom/indexedDB/test/unit/test_connection_idle_maintenance.js +++ b/dom/indexedDB/test/unit/test_connection_idle_maintenance.js @@ -8,7 +8,7 @@ async function testSteps() { // A constant used to deal with small decrease in usage when transactions are // transferred from the WAL file back into the original database, also called // as checkpointing. - const cosmologicalConstant = 31768; + const cosmologicalConstant = 20000; // The length of time that database connections will be held open after all // transactions have completed before doing idle maintenance. diff --git a/dom/indexedDB/test/unit/test_connection_idle_maintenance_stop.js b/dom/indexedDB/test/unit/test_connection_idle_maintenance_stop.js index 33dc69b210..5453e4dc4e 100644 --- a/dom/indexedDB/test/unit/test_connection_idle_maintenance_stop.js +++ b/dom/indexedDB/test/unit/test_connection_idle_maintenance_stop.js @@ -8,7 +8,7 @@ async function testSteps() { // A constant used to deal with small decrease in usage when transactions are // transferred from the WAL file back into the original database, also called // as checkpointing. - const cosmologicalConstant = 32768; + const cosmologicalConstant = 35000; // The maximum number of threads that can be used for database activity at a // single time. diff --git a/dom/indexedDB/test/unit/test_open_and_databases.js b/dom/indexedDB/test/unit/test_open_and_databases.js new file mode 100644 index 0000000000..b13cba067a --- /dev/null +++ b/dom/indexedDB/test/unit/test_open_and_databases.js @@ -0,0 +1,76 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +/* exported testSteps */ +async function testSteps() { + const openInfos = [ + { name: "foo-a", version: 1 }, + { name: "foo-b", version: 1 }, + ]; + + info("Creating databases"); + + for (let index = 0; index < openInfos.length; index++) { + const openInfo = openInfos[index]; + + const request = indexedDB.open(openInfo.name, openInfo.version); + + await expectingUpgrade(request); + + const event = await expectingSuccess(request); + + const database = event.target.result; + + database.close(); + } + + info("Getting databases"); + + const databasesPromise = indexedDB.databases(); + + info("Opening databases"); + + const openPromises = []; + + for (let index = 0; index < openInfos.length; index++) { + const openInfo = openInfos[index]; + + const request = indexedDB.open(openInfo.name, openInfo.version); + + const promise = expectingSuccess(request); + + openPromises.push(promise); + } + + info("Waiting for databases operation to complete"); + + const databaseInfos = await databasesPromise; + + info("Verifying databases"); + + is( + databaseInfos.length, + openInfos.length, + "The result of databases() should contain one result per database" + ); + + for (let index = 0; index < openInfos.length; index++) { + const openInfo = openInfos[index]; + + ok( + databaseInfos.some(function (element) { + return ( + element.name === openInfo.name && element.version === openInfo.version + ); + }), + "The result of databases() should be a sequence of the correct names " + + "and versions of all databases for the origin" + ); + } + + info("Waiting for open operations to complete"); + + await Promise.all(openPromises); +} diff --git a/dom/indexedDB/test/unit/xpcshell-head-parent-process.js b/dom/indexedDB/test/unit/xpcshell-head-parent-process.js index f6bd2608ef..840eef7908 100644 --- a/dom/indexedDB/test/unit/xpcshell-head-parent-process.js +++ b/dom/indexedDB/test/unit/xpcshell-head-parent-process.js @@ -56,7 +56,11 @@ if (!this.runTest) { if (testSteps.constructor.name === "AsyncFunction") { // Do run our existing cleanup function that would normally be called by // the generator's call to finishTest(). - registerCleanupFunction(resetTesting); + registerCleanupFunction(function () { + if (SpecialPowers.isMainProcess()) { + resetTesting(); + } + }); add_task(testSteps); @@ -644,7 +648,7 @@ var SpecialPowers = { clearUserPref(prefName) { Services.prefs.clearUserPref(prefName); }, - // Copied (and slightly adjusted) from testing/specialpowers/content/SpecialPowersAPI.jsm + // Copied (and slightly adjusted) from testing/specialpowers/api.js exactGC(callback) { let count = 0; diff --git a/dom/indexedDB/test/unit/xpcshell-shared.toml b/dom/indexedDB/test/unit/xpcshell-shared.toml index ac1183ab2d..f967236a9e 100644 --- a/dom/indexedDB/test/unit/xpcshell-shared.toml +++ b/dom/indexedDB/test/unit/xpcshell-shared.toml @@ -111,6 +111,8 @@ skip-if = ["os == 'android'"] # bug 864843 ["test_odd_result_order.js"] +["test_open_and_databases.js"] + ["test_open_empty_db.js"] ["test_open_for_principal.js"] |