Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
#ifndef DOM_QUOTA_DIRECTORYLOCKIMPL_H_
#define DOM_QUOTA_DIRECTORYLOCKIMPL_H_
#include <cstdint>
#include <functional>
#include <utility>
#include "nsISupportsImpl.h"
#include "nsTArray.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/MozPromise.h"
#include "mozilla/NotNull.h"
#include "mozilla/RefPtr.h"
#include "mozilla/dom/FlippedOnce.h"
#include "mozilla/dom/Nullable.h"
#include "mozilla/dom/quota/Client.h"
#include "mozilla/dom/quota/CommonMetadata.h"
#include "mozilla/dom/quota/DirectoryLockCategory.h"
#include "mozilla/dom/quota/ForwardDecls.h"
#include "mozilla/dom/quota/OriginScope.h"
#include "mozilla/dom/quota/PersistenceScope.h"
#include "mozilla/dom/quota/PersistenceType.h"
#include "nsCOMPtr.h"
class nsITimer;
namespace mozilla::dom::quota {
struct OriginMetadata;
class QuotaManager;
enum class ShouldUpdateLockIdTableFlag { No, Yes };
// XXX Rename to DirectoryLockBase.
class DirectoryLockImpl {
public:
class PrepareInfo;
private:
friend class ClientDirectoryLock;
friend class OriginDirectoryLock;
friend class QuotaManager;
friend class UniversalDirectoryLock;
const NotNull<RefPtr<QuotaManager>> mQuotaManager;
const PersistenceScope mPersistenceScope;
const OriginScope mOriginScope;
const Nullable<Client::Type> mClientType;
MozPromiseHolder<BoolPromise> mAcquirePromiseHolder;
nsCOMPtr<nsITimer> mAcquireTimer;
nsTArray<NotNull<DirectoryLockImpl*>> mBlocking;
nsTArray<NotNull<DirectoryLockImpl*>> mBlockedOn;
std::function<void()> mInvalidateCallback;
const int64_t mId;
const bool mExclusive;
// Internal quota manager operations use this flag to prevent directory lock
// registraction/unregistration from updating origin access time, etc.
const bool mInternal;
const bool mShouldUpdateLockIdTable;
const DirectoryLockCategory mCategory;
bool mRegistered;
FlippedOnce<true> mPending;
FlippedOnce<false> mAcquired;
FlippedOnce<false> mInvalidated;
FlippedOnce<false> mDropped;
public:
DirectoryLockImpl(MovingNotNull<RefPtr<QuotaManager>> aQuotaManager,
const PersistenceScope& aPersistenceScope,
const OriginScope& aOriginScope,
const Nullable<Client::Type>& aClientType, bool aExclusive,
bool aInternal,
ShouldUpdateLockIdTableFlag aShouldUpdateLockIdTableFlag,
DirectoryLockCategory aCategory);
NS_INLINE_DECL_REFCOUNTING(DirectoryLockImpl)
int64_t Id() const { return mId; }
const PersistenceScope& PersistenceScopeRef() const {
return mPersistenceScope;
}
const OriginScope& GetOriginScope() const { return mOriginScope; }
const Nullable<Client::Type>& NullableClientType() const {
return mClientType;
}
DirectoryLockCategory Category() const { return mCategory; }
bool Acquired() const { return mAcquired; }
bool MustWait() const;
nsTArray<RefPtr<DirectoryLockImpl>> LocksMustWaitFor() const;
bool Invalidated() const { return mInvalidated; }
bool Dropped() const { return mDropped; }
PrepareInfo Prepare() const;
RefPtr<BoolPromise> Acquire();
RefPtr<BoolPromise> Acquire(PrepareInfo&& aPrepareInfo);
void AcquireImmediately();
void AssertIsAcquiredExclusively()
#ifdef DEBUG
;
#else
{
}
#endif
RefPtr<BoolPromise> Drop();
void OnInvalidate(std::function<void()>&& aCallback);
void Log() const;
private:
virtual ~DirectoryLockImpl();
void AssertIsOnOwningThread() const
#ifdef DEBUG
;
#else
{
}
#endif
PersistenceType GetPersistenceType() const {
MOZ_DIAGNOSTIC_ASSERT(mPersistenceScope.IsValue());
return mPersistenceScope.GetValue();
}
quota::OriginMetadata OriginMetadata() const {
MOZ_DIAGNOSTIC_ASSERT(mOriginScope.IsOrigin());
return quota::OriginMetadata{mOriginScope.GetPrincipalMetadata(),
GetPersistenceType()};
}
const nsACString& Origin() const {
MOZ_DIAGNOSTIC_ASSERT(mOriginScope.IsOrigin());
MOZ_DIAGNOSTIC_ASSERT(!mOriginScope.GetOrigin().IsEmpty());
return mOriginScope.GetOrigin();
}
Client::Type ClientType() const {
MOZ_DIAGNOSTIC_ASSERT(!mClientType.IsNull());
MOZ_DIAGNOSTIC_ASSERT(mClientType.Value() < Client::TypeMax());
return mClientType.Value();
}
bool IsInternal() const { return mInternal; }
void SetRegistered(bool aRegistered) { mRegistered = aRegistered; }
bool IsPending() const { return mPending; }
// Ideally, we would have just one table (instead of these two:
// QuotaManager::mDirectoryLocks and QuotaManager::mDirectoryLockIdTable) for
// all registered locks. However, some directory locks need to be accessed off
// the PBackground thread, so the access must be protected by the quota mutex.
// The problem is that directory locks for eviction must be currently created
// while the mutex lock is already acquired. So we decided to have two tables
// for now and to not register directory locks for eviction in
// QuotaManager::mDirectoryLockIdTable. This can be improved in future after
// some refactoring of the mutex locking.
bool ShouldUpdateLockIdTable() const { return mShouldUpdateLockIdTable; }
bool ShouldUpdateLockTable() {
return !mInternal &&
mPersistenceScope.GetValue() != PERSISTENCE_TYPE_PERSISTENT;
}
bool Overlaps(const DirectoryLockImpl& aLock) const;
// Test whether this DirectoryLock needs to wait for the given lock.
bool MustWaitFor(const DirectoryLockImpl& aLock) const;
void AddBlockingLock(DirectoryLockImpl& aLock) {
AssertIsOnOwningThread();
mBlocking.AppendElement(WrapNotNull(&aLock));
}
const nsTArray<NotNull<DirectoryLockImpl*>>& GetBlockedOnLocks() {
return mBlockedOn;
}
void AddBlockedOnLock(DirectoryLockImpl& aLock) {
AssertIsOnOwningThread();
mBlockedOn.AppendElement(WrapNotNull(&aLock));
}
void MaybeUnblock(DirectoryLockImpl& aLock) {
AssertIsOnOwningThread();
mBlockedOn.RemoveElement(&aLock);
if (mBlockedOn.IsEmpty()) {
NotifyOpenListener();
}
}
void NotifyOpenListener();
template <typename T>
nsTArray<T> LocksMustWaitForInternal() const;
void AcquireInternal(PrepareInfo&& aPrepareInfo);
void Invalidate();
void Unregister();
};
class MOZ_RAII DirectoryLockImpl::PrepareInfo {
friend class DirectoryLockImpl;
nsTArray<NotNull<DirectoryLockImpl*>> mBlockedOn;
public:
// Disable copy constructor and assignment operator
PrepareInfo(const PrepareInfo&) = delete;
PrepareInfo& operator=(const PrepareInfo&) = delete;
// Move constructor and move assignment operator
PrepareInfo(PrepareInfo&&) noexcept = default;
PrepareInfo& operator=(PrepareInfo&&) noexcept = default;
const nsTArray<NotNull<DirectoryLockImpl*>>& BlockedOnRef() const {
return mBlockedOn;
}
private:
explicit PrepareInfo(const DirectoryLockImpl& aDirectoryLock)
: mBlockedOn(
aDirectoryLock
.LocksMustWaitForInternal<NotNull<DirectoryLockImpl*>>()) {}
};
} // namespace mozilla::dom::quota
#endif // DOM_QUOTA_DIRECTORYLOCKIMPL_H_