Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 808 insertions, 0 deletions

diff --git a/dom/quota/QuotaManager.h b/dom/quota/QuotaManager.h
new file mode 100644
index 0000000000..42e5de961a
--- /dev/null
+++ b/dom/quota/QuotaManager.h
@@ -0,0 +1,808 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_quota_quotamanager_h__
+#define mozilla_dom_quota_quotamanager_h__
+
+#include <cstdint>
+#include <utility>
+#include "Client.h"
+#include "ErrorList.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/InitializedOnce.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Result.h"
+#include "mozilla/dom/Nullable.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/dom/quota/Assertions.h"
+#include "mozilla/dom/quota/CommonMetadata.h"
+#include "mozilla/dom/quota/DirectoryLockCategory.h"
+#include "mozilla/dom/quota/ForwardDecls.h"
+#include "mozilla/dom/quota/InitializationTypes.h"
+#include "mozilla/dom/quota/PersistenceType.h"
+#include "mozilla/dom/quota/QuotaCommon.h"
+#include "nsCOMPtr.h"
+#include "nsClassHashtable.h"
+#include "nsTHashMap.h"
+#include "nsDebug.h"
+#include "nsHashKeys.h"
+#include "nsISupports.h"
+#include "nsStringFwd.h"
+#include "nsTArray.h"
+#include "nsTStringRepr.h"
+#include "nscore.h"
+#include "prenv.h"
+
+#define QUOTA_MANAGER_CONTRACTID "@mozilla.org/dom/quota/manager;1"
+
+class mozIStorageConnection;
+class nsIEventTarget;
+class nsIFile;
+class nsIPrincipal;
+class nsIRunnable;
+class nsIThread;
+class nsITimer;
+class nsPIDOMWindowOuter;
+
+namespace mozilla {
+
+class OriginAttributes;
+class OriginAttributesPattern;
+
+namespace ipc {
+
+class PrincipalInfo;
+
+}  // namespace ipc
+
+}  // namespace mozilla
+
+namespace mozilla::dom::quota {
+
+class CanonicalQuotaObject;
+class ClientUsageArray;
+class ClientDirectoryLock;
+class DirectoryLockImpl;
+class GroupInfo;
+class GroupInfoPair;
+class NormalOriginOperationBase;
+class OriginDirectoryLock;
+class OriginInfo;
+class OriginScope;
+class QuotaObject;
+class UniversalDirectoryLock;
+
+class QuotaManager final : public BackgroundThreadObject {
+  friend class CanonicalQuotaObject;
+  friend class ClearStorageOp;
+  friend class DirectoryLockImpl;
+  friend class GroupInfo;
+  friend class InitOp;
+  friend class OriginInfo;
+  friend class ShutdownStorageOp;
+
+  using PrincipalInfo = mozilla::ipc::PrincipalInfo;
+  using DirectoryLockTable =
+      nsClassHashtable<nsCStringHashKey, nsTArray<NotNull<DirectoryLockImpl*>>>;
+
+  class Observer;
+
+ public:
+  QuotaManager(const nsAString& aBasePath, const nsAString& aStorageName);
+
+  NS_INLINE_DECL_REFCOUNTING(QuotaManager)
+
+  static nsresult Initialize();
+
+  static bool IsRunningXPCShellTests() {
+    static bool kRunningXPCShellTests =
+        !!PR_GetEnv("XPCSHELL_TEST_PROFILE_DIR");
+    return kRunningXPCShellTests;
+  }
+
+  static bool IsRunningGTests() {
+    static bool kRunningGTests = !!PR_GetEnv("MOZ_RUN_GTEST");
+    return kRunningGTests;
+  }
+
+  static const char kReplaceChars[];
+  static const char16_t kReplaceChars16[];
+
+  static Result<MovingNotNull<RefPtr<QuotaManager>>, nsresult> GetOrCreate();
+
+  static Result<Ok, nsresult> EnsureCreated();
+
+  // Returns a non-owning reference.
+  static QuotaManager* Get();
+
+  // Use only in gtests!
+  static nsIObserver* GetObserver();
+
+  // Returns true if we've begun the shutdown process.
+  static bool IsShuttingDown();
+
+  static void ShutdownInstance();
+
+  // Use only in gtests!
+  static void Reset();
+
+  static bool IsOSMetadata(const nsAString& aFileName);
+
+  static bool IsDotFile(const nsAString& aFileName);
+
+  void RegisterNormalOriginOp(NormalOriginOperationBase& aNormalOriginOp);
+
+  void UnregisterNormalOriginOp(NormalOriginOperationBase& aNormalOriginOp);
+
+  bool IsOriginInitialized(const nsACString& aOrigin) const {
+    AssertIsOnIOThread();
+
+    return mInitializedOrigins.Contains(aOrigin);
+  }
+
+  bool IsTemporaryStorageInitializedInternal() const {
+    AssertIsOnIOThread();
+
+    return mTemporaryStorageInitializedInternal;
+  }
+
+  /**
+   * For initialization of an origin where the directory already exists. This is
+   * used by EnsureTemporaryStorageIsInitializedInternal/InitializeRepository
+   * once it has tallied origin usage by calling each of the QuotaClient
+   * InitOrigin methods.
+   */
+  void InitQuotaForOrigin(const FullOriginMetadata& aFullOriginMetadata,
+                          const ClientUsageArray& aClientUsages,
+                          uint64_t aUsageBytes);
+
+  /**
+   * For use in special-cases like LSNG where we need to be able to know that
+   * there is no data stored for an origin. LSNG knows that there is 0 usage for
+   * its storage of an origin and wants to make sure there is a QuotaObject
+   * tracking this. This method will create a non-persisted, 0-usage,
+   * mDirectoryExists=false OriginInfo if there isn't already an OriginInfo. If
+   * an OriginInfo already exists, it will be left as-is, because that implies a
+   * different client has usages for the origin (and there's no need to add
+   * LSNG's 0 usage to the QuotaObject).
+   */
+  void EnsureQuotaForOrigin(const OriginMetadata& aOriginMetadata);
+
+  /**
+   * For use when creating an origin directory. It's possible that origin usage
+   * is already being tracked due to a call to EnsureQuotaForOrigin, and in that
+   * case we need to update the existing OriginInfo rather than create a new
+   * one.
+   *
+   * @return last access time of the origin.
+   */
+  int64_t NoteOriginDirectoryCreated(const OriginMetadata& aOriginMetadata,
+                                     bool aPersisted);
+
+  // XXX clients can use QuotaObject instead of calling this method directly.
+  void DecreaseUsageForClient(const ClientMetadata& aClientMetadata,
+                              int64_t aSize);
+
+  void ResetUsageForClient(const ClientMetadata& aClientMetadata);
+
+  UsageInfo GetUsageForClient(PersistenceType aPersistenceType,
+                              const OriginMetadata& aOriginMetadata,
+                              Client::Type aClientType);
+
+  void UpdateOriginAccessTime(PersistenceType aPersistenceType,
+                              const OriginMetadata& aOriginMetadata);
+
+  void RemoveQuota();
+
+  void RemoveQuotaForRepository(PersistenceType aPersistenceType) {
+    MutexAutoLock lock(mQuotaMutex);
+    LockedRemoveQuotaForRepository(aPersistenceType);
+  }
+
+  void RemoveQuotaForOrigin(PersistenceType aPersistenceType,
+                            const OriginMetadata& aOriginMetadata) {
+    MutexAutoLock lock(mQuotaMutex);
+    LockedRemoveQuotaForOrigin(aOriginMetadata);
+  }
+
+  nsresult LoadQuota();
+
+  void UnloadQuota();
+
+  already_AddRefed<QuotaObject> GetQuotaObject(
+      PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
+      Client::Type aClientType, nsIFile* aFile, int64_t aFileSize = -1,
+      int64_t* aFileSizeOut = nullptr);
+
+  already_AddRefed<QuotaObject> GetQuotaObject(
+      PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
+      Client::Type aClientType, const nsAString& aPath, int64_t aFileSize = -1,
+      int64_t* aFileSizeOut = nullptr);
+
+  already_AddRefed<QuotaObject> GetQuotaObject(const int64_t aDirectoryLockId,
+                                               const nsAString& aPath);
+
+  Nullable<bool> OriginPersisted(const OriginMetadata& aOriginMetadata);
+
+  void PersistOrigin(const OriginMetadata& aOriginMetadata);
+
+  using DirectoryLockIdTableArray =
+      AutoTArray<Client::DirectoryLockIdTable, Client::TYPE_MAX>;
+  void AbortOperationsForLocks(const DirectoryLockIdTableArray& aLockIds);
+
+  // Called when a process is being shot down. Aborts any running operations
+  // for the given process.
+  void AbortOperationsForProcess(ContentParentId aContentParentId);
+
+  Result<nsCOMPtr<nsIFile>, nsresult> GetOriginDirectory(
+      const OriginMetadata& aOriginMetadata) const;
+
+  static nsresult CreateDirectoryMetadata(
+      nsIFile& aDirectory, int64_t aTimestamp,
+      const OriginMetadata& aOriginMetadata);
+
+  static nsresult CreateDirectoryMetadata2(
+      nsIFile& aDirectory, int64_t aTimestamp, bool aPersisted,
+      const OriginMetadata& aOriginMetadata);
+
+  nsresult RestoreDirectoryMetadata2(nsIFile* aDirectory);
+
+  // XXX Remove aPersistenceType argument once the persistence type is stored
+  // in the metadata file.
+  Result<FullOriginMetadata, nsresult> LoadFullOriginMetadata(
+      nsIFile* aDirectory, PersistenceType aPersistenceType);
+
+  Result<FullOriginMetadata, nsresult> LoadFullOriginMetadataWithRestore(
+      nsIFile* aDirectory);
+
+  Result<OriginMetadata, nsresult> GetOriginMetadata(nsIFile* aDirectory);
+
+  Result<Ok, nsresult> RemoveOriginDirectory(nsIFile& aDirectory);
+
+  RefPtr<UniversalDirectoryLockPromise> OpenStorageDirectory(
+      const Nullable<PersistenceType>& aPersistenceType,
+      const OriginScope& aOriginScope,
+      const Nullable<Client::Type>& aClientType, bool aExclusive,
+      DirectoryLockCategory aCategory = DirectoryLockCategory::None,
+      Maybe<RefPtr<UniversalDirectoryLock>&> aPendingDirectoryLockOut =
+          Nothing());
+
+  // This is the main entry point into the QuotaManager API.
+  // Any storage API implementation (quota client) that participates in
+  // centralized quota and storage handling should call this method to get
+  // a directory lock which will protect client's files from being deleted
+  // while they are still in use.
+  // After a lock is acquired, client is notified by resolving the returned
+  // promise. If the lock couldn't be acquired, client is notified by rejecting
+  // the returned promise.
+  // A lock is a reference counted object and at the time the returned promise
+  // is resolved, there are no longer other strong references except the one
+  // held by the resolve value itself. So it's up to client to add a new
+  // reference in order to keep the lock alive.
+  // Unlocking is simply done by dropping all references to the lock object.
+  // In other words, protection which the lock represents dies with the lock
+  // object itself (Note that it's now possible to release directory locks
+  // sooner by calling newly added Drop method).
+  RefPtr<ClientDirectoryLockPromise> OpenClientDirectory(
+      const ClientMetadata& aClientMetadata,
+      Maybe<RefPtr<ClientDirectoryLock>&> aPendingDirectoryLockOut = Nothing());
+
+  RefPtr<ClientDirectoryLock> CreateDirectoryLock(
+      const ClientMetadata& aClientMetadata, bool aExclusive);
+
+  // XXX RemoveMe once bug 1170279 gets fixed.
+  RefPtr<UniversalDirectoryLock> CreateDirectoryLockInternal(
+      const Nullable<PersistenceType>& aPersistenceType,
+      const OriginScope& aOriginScope,
+      const Nullable<Client::Type>& aClientType, bool aExclusive,
+      DirectoryLockCategory aCategory = DirectoryLockCategory::None);
+
+  // Collect inactive and the least recently used origins.
+  uint64_t CollectOriginsForEviction(
+      uint64_t aMinSizeToBeFreed,
+      nsTArray<RefPtr<OriginDirectoryLock>>& aLocks);
+
+  /**
+   * Helper method to invoke the provided predicate on all "pending" OriginInfo
+   * instances. These are origins for which the origin directory has not yet
+   * been created but for which quota is already being tracked. This happens,
+   * for example, for the LocalStorage client where an origin that previously
+   * was not using LocalStorage can start issuing writes which it buffers until
+   * eventually flushing them. We defer creating the origin directory for as
+   * long as possible in that case, so the directory won't exist. Logic that
+   * would otherwise only consult the filesystem also needs to use this method.
+   */
+  template <typename P>
+  void CollectPendingOriginsForListing(P aPredicate);
+
+  RefPtr<BoolPromise> InitializeStorage();
+
+  RefPtr<BoolPromise> InitializeStorage(
+      RefPtr<UniversalDirectoryLock> aDirectoryLock);
+
+  RefPtr<BoolPromise> StorageInitialized();
+
+  bool IsStorageInitialized() const {
+    AssertIsOnOwningThread();
+
+    return mStorageInitialized;
+  }
+
+  bool IsStorageInitializedInternal() const {
+    AssertIsOnIOThread();
+    return static_cast<bool>(mStorageConnection);
+  }
+
+  void AssertStorageIsInitializedInternal() const
+#ifdef DEBUG
+      ;
+#else
+  {
+  }
+#endif
+
+  RefPtr<BoolPromise> TemporaryStorageInitialized();
+
+ private:
+  nsresult EnsureStorageIsInitializedInternal();
+
+ public:
+  // Returns a pair of an nsIFile object referring to the directory, and a bool
+  // indicating whether the directory was newly created.
+  Result<std::pair<nsCOMPtr<nsIFile>, bool>, nsresult>
+  EnsurePersistentOriginIsInitialized(const OriginMetadata& aOriginMetadata);
+
+  bool IsTemporaryOriginInitialized(
+      const OriginMetadata& aOriginMetadata) const;
+
+  // Returns a pair of an nsIFile object referring to the directory, and a bool
+  // indicating whether the directory was newly created.
+  Result<std::pair<nsCOMPtr<nsIFile>, bool>, nsresult>
+  EnsureTemporaryOriginIsInitialized(PersistenceType aPersistenceType,
+                                     const OriginMetadata& aOriginMetadata);
+
+  RefPtr<BoolPromise> InitializePersistentClient(
+      const PrincipalInfo& aPrincipalInfo, Client::Type aClientType);
+
+  // Returns a pair of an nsIFile object referring to the directory, and a bool
+  // indicating whether the directory was newly created.
+  Result<std::pair<nsCOMPtr<nsIFile>, bool>, nsresult>
+  EnsurePersistentClientIsInitialized(const ClientMetadata& aClientMetadata);
+
+  RefPtr<BoolPromise> InitializeTemporaryClient(
+      PersistenceType aPersistenceType, const PrincipalInfo& aPrincipalInfo,
+      Client::Type aClientType);
+
+  // Returns a pair of an nsIFile object referring to the directory, and a bool
+  // indicating whether the directory was newly created.
+  Result<std::pair<nsCOMPtr<nsIFile>, bool>, nsresult>
+  EnsureTemporaryClientIsInitialized(const ClientMetadata& aClientMetadata);
+
+  RefPtr<BoolPromise> InitializeTemporaryStorage();
+
+  RefPtr<BoolPromise> InitializeTemporaryStorage(
+      RefPtr<UniversalDirectoryLock> aDirectoryLock);
+
+  bool IsTemporaryStorageInitialized() const {
+    AssertIsOnOwningThread();
+
+    return mTemporaryStorageInitialized;
+  }
+
+  nsresult EnsureTemporaryStorageIsInitializedInternal();
+
+  RefPtr<BoolPromise> ClearStoragesForOrigin(
+      const Maybe<PersistenceType>& aPersistenceType,
+      const PrincipalInfo& aPrincipalInfo,
+      const Maybe<Client::Type>& aClientType);
+
+  RefPtr<BoolPromise> ClearStoragesForOriginPrefix(
+      const Maybe<PersistenceType>& aPersistenceType,
+      const PrincipalInfo& aPrincipalInfo);
+
+  RefPtr<BoolPromise> ClearStoragesForOriginAttributesPattern(
+      const OriginAttributesPattern& aPattern);
+
+  RefPtr<BoolPromise> ClearPrivateRepository();
+
+  RefPtr<BoolPromise> ClearStorage();
+
+  RefPtr<BoolPromise> ShutdownStorage();
+
+  void ShutdownStorageInternal();
+
+  // Returns a bool indicating whether the directory was newly created.
+  Result<bool, nsresult> EnsureOriginDirectory(nsIFile& aDirectory);
+
+  nsresult AboutToClearOrigins(
+      const Nullable<PersistenceType>& aPersistenceType,
+      const OriginScope& aOriginScope,
+      const Nullable<Client::Type>& aClientType);
+
+  void OriginClearCompleted(PersistenceType aPersistenceType,
+                            const nsACString& aOrigin,
+                            const Nullable<Client::Type>& aClientType);
+
+  void RepositoryClearCompleted(PersistenceType aPersistenceType);
+
+  void StartIdleMaintenance() {
+    AssertIsOnOwningThread();
+
+    for (const auto& client : *mClients) {
+      client->StartIdleMaintenance();
+    }
+  }
+
+  void StopIdleMaintenance() {
+    AssertIsOnOwningThread();
+
+    for (const auto& client : *mClients) {
+      client->StopIdleMaintenance();
+    }
+  }
+
+  void AssertCurrentThreadOwnsQuotaMutex() {
+    mQuotaMutex.AssertCurrentThreadOwns();
+  }
+
+  nsIThread* IOThread() { return mIOThread->get(); }
+
+  Client* GetClient(Client::Type aClientType);
+
+  const AutoTArray<Client::Type, Client::TYPE_MAX>& AllClientTypes();
+
+  const nsString& GetBasePath() const { return mBasePath; }
+
+  const nsString& GetStorageName() const { return mStorageName; }
+
+  const nsString& GetStoragePath() const { return *mStoragePath; }
+
+  const nsString& GetStoragePath(PersistenceType aPersistenceType) const {
+    if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
+      return *mPermanentStoragePath;
+    }
+
+    if (aPersistenceType == PERSISTENCE_TYPE_TEMPORARY) {
+      return *mTemporaryStoragePath;
+    }
+
+    if (aPersistenceType == PERSISTENCE_TYPE_DEFAULT) {
+      return *mDefaultStoragePath;
+    }
+
+    MOZ_ASSERT(aPersistenceType == PERSISTENCE_TYPE_PRIVATE);
+
+    return *mPrivateStoragePath;
+  }
+
+  uint64_t GetGroupLimit() const;
+
+  std::pair<uint64_t, uint64_t> GetUsageAndLimitForEstimate(
+      const OriginMetadata& aOriginMetadata);
+
+  uint64_t GetOriginUsage(const PrincipalMetadata& aPrincipalMetadata);
+
+  Maybe<FullOriginMetadata> GetFullOriginMetadata(
+      const OriginMetadata& aOriginMetadata);
+
+  void NotifyStoragePressure(uint64_t aUsage);
+
+  // Record a quota client shutdown step, if shutting down.
+  // Assumes that the QuotaManager singleton is alive.
+  static void MaybeRecordQuotaClientShutdownStep(
+      const Client::Type aClientType, const nsACString& aStepDescription);
+
+  // Record a quota client shutdown step, if shutting down.
+  // Checks if the QuotaManager singleton is alive.
+  static void SafeMaybeRecordQuotaClientShutdownStep(
+      Client::Type aClientType, const nsACString& aStepDescription);
+
+  // Record a quota manager shutdown step, use only if shutdown is active.
+  void RecordQuotaManagerShutdownStep(const nsACString& aStepDescription);
+
+  // Record a quota manager shutdown step, if shutting down.
+  void MaybeRecordQuotaManagerShutdownStep(const nsACString& aStepDescription);
+
+  template <typename F>
+  void MaybeRecordQuotaManagerShutdownStepWith(F&& aFunc);
+
+  static void GetStorageId(PersistenceType aPersistenceType,
+                           const nsACString& aOrigin, Client::Type aClientType,
+                           nsACString& aDatabaseId);
+
+  static bool IsPrincipalInfoValid(const PrincipalInfo& aPrincipalInfo);
+
+  Result<PrincipalMetadata, nsresult> GetInfoFromValidatedPrincipalInfo(
+      const PrincipalInfo& aPrincipalInfo);
+
+  static nsAutoCString GetOriginFromValidatedPrincipalInfo(
+      const PrincipalInfo& aPrincipalInfo);
+
+  static Result<PrincipalMetadata, nsresult> GetInfoFromPrincipal(
+      nsIPrincipal* aPrincipal);
+
+  static Result<PrincipalMetadata, nsresult> GetInfoFromWindow(
+      nsPIDOMWindowOuter* aWindow);
+
+  static Result<nsAutoCString, nsresult> GetOriginFromPrincipal(
+      nsIPrincipal* aPrincipal);
+
+  static Result<nsAutoCString, nsresult> GetOriginFromWindow(
+      nsPIDOMWindowOuter* aWindow);
+
+  static nsLiteralCString GetOriginForChrome();
+
+  static PrincipalMetadata GetInfoForChrome();
+
+  static bool IsOriginInternal(const nsACString& aOrigin);
+
+  static bool AreOriginsEqualOnDisk(const nsACString& aOrigin1,
+                                    const nsACString& aOrigin2);
+
+  // XXX This method currently expects the original origin string (not yet
+  // sanitized).
+  static Result<PrincipalInfo, nsresult> ParseOrigin(const nsACString& aOrigin);
+
+  static void InvalidateQuotaCache();
+
+ private:
+  virtual ~QuotaManager();
+
+  nsresult Init();
+
+  void Shutdown();
+
+  void RegisterDirectoryLock(DirectoryLockImpl& aLock);
+
+  void UnregisterDirectoryLock(DirectoryLockImpl& aLock);
+
+  void AddPendingDirectoryLock(DirectoryLockImpl& aLock);
+
+  void RemovePendingDirectoryLock(DirectoryLockImpl& aLock);
+
+  uint64_t LockedCollectOriginsForEviction(
+      uint64_t aMinSizeToBeFreed,
+      nsTArray<RefPtr<OriginDirectoryLock>>& aLocks);
+
+  void LockedRemoveQuotaForRepository(PersistenceType aPersistenceType);
+
+  void LockedRemoveQuotaForOrigin(const OriginMetadata& aOriginMetadata);
+
+  already_AddRefed<GroupInfo> LockedGetOrCreateGroupInfo(
+      PersistenceType aPersistenceType, const nsACString& aSuffix,
+      const nsACString& aGroup);
+
+  already_AddRefed<OriginInfo> LockedGetOriginInfo(
+      PersistenceType aPersistenceType,
+      const OriginMetadata& aOriginMetadata) const;
+
+  nsresult UpgradeFromIndexedDBDirectoryToPersistentStorageDirectory(
+      nsIFile* aIndexedDBDir);
+
+  nsresult UpgradeFromPersistentStorageDirectoryToDefaultStorageDirectory(
+      nsIFile* aPersistentStorageDir);
+
+  nsresult MaybeUpgradeToDefaultStorageDirectory(nsIFile& aStorageFile);
+
+  template <typename Helper>
+  nsresult UpgradeStorage(const int32_t aOldVersion, const int32_t aNewVersion,
+                          mozIStorageConnection* aConnection);
+
+  nsresult UpgradeStorageFrom0_0To1_0(mozIStorageConnection* aConnection);
+
+  nsresult UpgradeStorageFrom1_0To2_0(mozIStorageConnection* aConnection);
+
+  nsresult UpgradeStorageFrom2_0To2_1(mozIStorageConnection* aConnection);
+
+  nsresult UpgradeStorageFrom2_1To2_2(mozIStorageConnection* aConnection);
+
+  nsresult UpgradeStorageFrom2_2To2_3(mozIStorageConnection* aConnection);
+
+  nsresult MaybeCreateOrUpgradeStorage(mozIStorageConnection& aConnection);
+
+  OkOrErr MaybeRemoveLocalStorageArchiveTmpFile();
+
+  nsresult MaybeRemoveLocalStorageDataAndArchive(nsIFile& aLsArchiveFile);
+
+  nsresult MaybeRemoveLocalStorageDirectories();
+
+  Result<Ok, nsresult> CopyLocalStorageArchiveFromWebAppsStore(
+      nsIFile& aLsArchiveFile) const;
+
+  Result<nsCOMPtr<mozIStorageConnection>, nsresult>
+  CreateLocalStorageArchiveConnection(nsIFile& aLsArchiveFile) const;
+
+  Result<nsCOMPtr<mozIStorageConnection>, nsresult>
+  RecopyLocalStorageArchiveFromWebAppsStore(nsIFile& aLsArchiveFile);
+
+  Result<nsCOMPtr<mozIStorageConnection>, nsresult>
+  DowngradeLocalStorageArchive(nsIFile& aLsArchiveFile);
+
+  Result<nsCOMPtr<mozIStorageConnection>, nsresult>
+  UpgradeLocalStorageArchiveFromLessThan4To4(nsIFile& aLsArchiveFile);
+
+  /*
+  nsresult UpgradeLocalStorageArchiveFrom4To5();
+  */
+
+  Result<Ok, nsresult> MaybeCreateOrUpgradeLocalStorageArchive(
+      nsIFile& aLsArchiveFile);
+
+  Result<Ok, nsresult> CreateEmptyLocalStorageArchive(
+      nsIFile& aLsArchiveFile) const;
+
+  template <typename OriginFunc>
+  nsresult InitializeRepository(PersistenceType aPersistenceType,
+                                OriginFunc&& aOriginFunc);
+
+  nsresult InitializeOrigin(PersistenceType aPersistenceType,
+                            const OriginMetadata& aOriginMetadata,
+                            int64_t aAccessTime, bool aPersisted,
+                            nsIFile* aDirectory);
+
+  using OriginInfosFlatTraversable =
+      nsTArray<NotNull<RefPtr<const OriginInfo>>>;
+
+  using OriginInfosNestedTraversable =
+      nsTArray<nsTArray<NotNull<RefPtr<const OriginInfo>>>>;
+
+  OriginInfosNestedTraversable GetOriginInfosExceedingGroupLimit() const;
+
+  OriginInfosNestedTraversable GetOriginInfosExceedingGlobalLimit() const;
+
+  void ClearOrigins(const OriginInfosNestedTraversable& aDoomedOriginInfos);
+
+  void CleanupTemporaryStorage();
+
+  void DeleteOriginDirectory(const OriginMetadata& aOriginMetadata);
+
+  void FinalizeOriginEviction(nsTArray<RefPtr<OriginDirectoryLock>>&& aLocks);
+
+  Result<Ok, nsresult> ArchiveOrigins(
+      const nsTArray<FullOriginMetadata>& aFullOriginMetadatas);
+
+  void ReleaseIOThreadObjects() {
+    AssertIsOnIOThread();
+
+    for (Client::Type type : AllClientTypes()) {
+      (*mClients)[type]->ReleaseIOThreadObjects();
+    }
+  }
+
+  DirectoryLockTable& GetDirectoryLockTable(PersistenceType aPersistenceType);
+
+  void ClearDirectoryLockTables();
+
+  bool IsSanitizedOriginValid(const nsACString& aSanitizedOrigin);
+
+  Result<nsCString, nsresult> EnsureStorageOriginFromOrigin(
+      const nsACString& aOrigin);
+
+  Result<nsCString, nsresult> GetOriginFromStorageOrigin(
+      const nsACString& aStorageOrigin);
+
+  int64_t GenerateDirectoryLockId();
+
+  bool ShutdownStarted() const;
+
+  void RecordShutdownStep(Maybe<Client::Type> aClientType,
+                          const nsACString& aStepDescription);
+
+  template <typename Func>
+  auto ExecuteInitialization(Initialization aInitialization, Func&& aFunc)
+      -> std::invoke_result_t<Func, const FirstInitializationAttempt<
+                                        Initialization, StringGenerator>&>;
+
+  template <typename Func>
+  auto ExecuteInitialization(Initialization aInitialization,
+                             const nsACString& aContext, Func&& aFunc)
+      -> std::invoke_result_t<Func, const FirstInitializationAttempt<
+                                        Initialization, StringGenerator>&>;
+
+  template <typename Func>
+  auto ExecuteOriginInitialization(const nsACString& aOrigin,
+                                   const OriginInitialization aInitialization,
+                                   const nsACString& aContext, Func&& aFunc)
+      -> std::invoke_result_t<Func, const FirstInitializationAttempt<
+                                        Initialization, StringGenerator>&>;
+
+  template <typename Iterator>
+  static void MaybeInsertNonPersistedOriginInfos(
+      Iterator aDest, const RefPtr<GroupInfo>& aTemporaryGroupInfo,
+      const RefPtr<GroupInfo>& aDefaultGroupInfo,
+      const RefPtr<GroupInfo>& aPrivateGroupInfo);
+
+  template <typename Collect, typename Pred>
+  static OriginInfosFlatTraversable CollectLRUOriginInfosUntil(
+      Collect&& aCollect, Pred&& aPred);
+
+  // Thread on which IO is performed.
+  LazyInitializedOnceNotNull<const nsCOMPtr<nsIThread>> mIOThread;
+
+  nsCOMPtr<mozIStorageConnection> mStorageConnection;
+
+  EnumeratedArray<Client::Type, Client::TYPE_MAX, nsCString> mShutdownSteps;
+  LazyInitializedOnce<const TimeStamp> mShutdownStartedAt;
+
+  // Accesses to mQuotaManagerShutdownSteps must be protected by mQuotaMutex.
+  nsCString mQuotaManagerShutdownSteps;
+
+  mutable mozilla::Mutex mQuotaMutex MOZ_UNANNOTATED;
+
+  nsClassHashtable<nsCStringHashKey, GroupInfoPair> mGroupInfoPairs;
+
+  // Maintains a list of directory locks that are queued.
+  nsTArray<RefPtr<DirectoryLockImpl>> mPendingDirectoryLocks;
+
+  // Maintains a list of directory locks that are acquired or queued. It can be
+  // accessed on the owning (PBackground) thread only.
+  nsTArray<NotNull<DirectoryLockImpl*>> mDirectoryLocks;
+
+  // Only modifed on the owning thread, but read on multiple threads. Therefore
+  // all modifications (including those on the owning thread) and all reads off
+  // the owning thread must be protected by mQuotaMutex. In other words, only
+  // reads on the owning thread don't have to be protected by mQuotaMutex.
+  nsTHashMap<nsUint64HashKey, NotNull<DirectoryLockImpl*>>
+      mDirectoryLockIdTable;
+
+  // Directory lock tables that are used to update origin access time.
+  DirectoryLockTable mTemporaryDirectoryLockTable;
+  DirectoryLockTable mDefaultDirectoryLockTable;
+  DirectoryLockTable mPrivateDirectoryLockTable;
+
+  // A list of all successfully initialized persistent origins. This list isn't
+  // protected by any mutex but it is only ever touched on the IO thread.
+  nsTArray<nsCString> mInitializedOrigins;
+
+  // A hash table that is used to cache origin parser results for given
+  // sanitized origin strings. This hash table isn't protected by any mutex but
+  // it is only ever touched on the IO thread.
+  nsTHashMap<nsCStringHashKey, bool> mValidOrigins;
+
+  // These maps are protected by mQuotaMutex.
+  nsTHashMap<nsCStringHashKey, nsCString> mOriginToStorageOriginMap;
+  nsTHashMap<nsCStringHashKey, nsCString> mStorageOriginToOriginMap;
+
+  // This array is populated at initialization time and then never modified, so
+  // it can be iterated on any thread.
+  LazyInitializedOnce<const AutoTArray<RefPtr<Client>, Client::TYPE_MAX>>
+      mClients;
+
+  using ClientTypesArray = AutoTArray<Client::Type, Client::TYPE_MAX>;
+  LazyInitializedOnce<const ClientTypesArray> mAllClientTypes;
+  LazyInitializedOnce<const ClientTypesArray> mAllClientTypesExceptLS;
+
+  // This object isn't protected by any mutex but it is only ever touched on
+  // the IO thread.
+  InitializationInfo mInitializationInfo;
+
+  const nsString mBasePath;
+  const nsString mStorageName;
+  LazyInitializedOnce<const nsString> mIndexedDBPath;
+  LazyInitializedOnce<const nsString> mStoragePath;
+  LazyInitializedOnce<const nsString> mStorageArchivesPath;
+  LazyInitializedOnce<const nsString> mPermanentStoragePath;
+  LazyInitializedOnce<const nsString> mTemporaryStoragePath;
+  LazyInitializedOnce<const nsString> mDefaultStoragePath;
+  LazyInitializedOnce<const nsString> mPrivateStoragePath;
+  LazyInitializedOnce<const nsString> mToBeRemovedStoragePath;
+
+  uint64_t mTemporaryStorageLimit;
+  uint64_t mTemporaryStorageUsage;
+  int64_t mNextDirectoryLockId;
+  uint64_t mShutdownStorageOpCount;
+  bool mStorageInitialized;
+  bool mTemporaryStorageInitialized;
+  bool mTemporaryStorageInitializedInternal;
+  bool mCacheUsable;
+};
+
+}  // namespace mozilla::dom::quota
+
+#endif /* mozilla_dom_quota_quotamanager_h__ */