Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 759 insertions, 0 deletions

diff --git a/dom/indexedDB/IndexedDatabaseManager.cpp b/dom/indexedDB/IndexedDatabaseManager.cpp
new file mode 100644
index 0000000000..0e4b1f25ad
--- /dev/null
+++ b/dom/indexedDB/IndexedDatabaseManager.cpp
@@ -0,0 +1,759 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "IndexedDatabaseManager.h"
+
+#include "chrome/common/ipc_channel.h"  // for IPC::Channel::kMaximumMessageSize
+#include "nsIScriptError.h"
+#include "nsIScriptGlobalObject.h"
+
+#include "jsapi.h"
+#include "js/Object.h"              // JS::GetClass
+#include "js/PropertyAndElement.h"  // JS_DefineProperty
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ContentEvents.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/ErrorEvent.h"
+#include "mozilla/dom/ErrorEventBinding.h"
+#include "mozilla/dom/WorkerScope.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/quota/Assertions.h"
+#include "mozilla/dom/quota/ResultExtensions.h"
+#include "mozilla/intl/LocaleCanonicalizer.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/PBackgroundChild.h"
+#include "nsContentUtils.h"
+#include "nsGlobalWindow.h"
+#include "mozilla/Logging.h"
+
+#include "ActorsChild.h"
+#include "DatabaseFileManager.h"
+#include "IDBEvents.h"
+#include "IDBFactory.h"
+#include "IDBKeyRange.h"
+#include "IDBRequest.h"
+#include "IndexedDBCommon.h"
+#include "ProfilerHelpers.h"
+#include "ScriptErrorHelper.h"
+#include "nsCharSeparatedTokenizer.h"
+
+// Bindings for ResolveConstructors
+#include "mozilla/dom/IDBCursorBinding.h"
+#include "mozilla/dom/IDBDatabaseBinding.h"
+#include "mozilla/dom/IDBFactoryBinding.h"
+#include "mozilla/dom/IDBIndexBinding.h"
+#include "mozilla/dom/IDBKeyRangeBinding.h"
+#include "mozilla/dom/IDBObjectStoreBinding.h"
+#include "mozilla/dom/IDBOpenDBRequestBinding.h"
+#include "mozilla/dom/IDBRequestBinding.h"
+#include "mozilla/dom/IDBTransactionBinding.h"
+#include "mozilla/dom/IDBVersionChangeEventBinding.h"
+
+#define IDB_STR "indexedDB"
+
+namespace mozilla::dom {
+namespace indexedDB {
+
+using namespace mozilla::dom::quota;
+using namespace mozilla::ipc;
+
+class FileManagerInfo {
+ public:
+  [[nodiscard]] SafeRefPtr<DatabaseFileManager> GetFileManager(
+      PersistenceType aPersistenceType, const nsAString& aName) const;
+
+  void AddFileManager(SafeRefPtr<DatabaseFileManager> aFileManager);
+
+  bool HasFileManagers() const {
+    AssertIsOnIOThread();
+
+    return !mPersistentStorageFileManagers.IsEmpty() ||
+           !mTemporaryStorageFileManagers.IsEmpty() ||
+           !mDefaultStorageFileManagers.IsEmpty() ||
+           !mPrivateStorageFileManagers.IsEmpty();
+  }
+
+  void InvalidateAllFileManagers() const;
+
+  void InvalidateAndRemoveFileManagers(PersistenceType aPersistenceType);
+
+  void InvalidateAndRemoveFileManager(PersistenceType aPersistenceType,
+                                      const nsAString& aName);
+
+ private:
+  nsTArray<SafeRefPtr<DatabaseFileManager> >& GetArray(
+      PersistenceType aPersistenceType);
+
+  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;
+};
+
+}  // namespace indexedDB
+
+using namespace mozilla::dom::indexedDB;
+
+namespace {
+
+// The threshold we use for structured clone data storing.
+// Anything smaller than the threshold is compressed and stored in the database.
+// Anything larger is compressed and stored outside the database.
+const int32_t kDefaultDataThresholdBytes = 1024 * 1024;  // 1MB
+
+// The maximal size of a serialized object to be transfered through IPC.
+const int32_t kDefaultMaxSerializedMsgSize = IPC::Channel::kMaximumMessageSize;
+
+// The maximum number of records to preload (in addition to the one requested by
+// the child).
+//
+// TODO: The current number was chosen for no particular reason. Telemetry
+// should be added to determine whether this is a reasonable number for an
+// overwhelming majority of cases.
+const int32_t kDefaultMaxPreloadExtraRecords = 64;
+
+#define IDB_PREF_BRANCH_ROOT "dom.indexedDB."
+
+const char kDataThresholdPref[] = IDB_PREF_BRANCH_ROOT "dataThreshold";
+const char kPrefMaxSerilizedMsgSize[] =
+    IDB_PREF_BRANCH_ROOT "maxSerializedMsgSize";
+const char kPrefMaxPreloadExtraRecords[] =
+    IDB_PREF_BRANCH_ROOT "maxPreloadExtraRecords";
+
+#define IDB_PREF_LOGGING_BRANCH_ROOT IDB_PREF_BRANCH_ROOT "logging."
+
+const char kPrefLoggingEnabled[] = IDB_PREF_LOGGING_BRANCH_ROOT "enabled";
+const char kPrefLoggingDetails[] = IDB_PREF_LOGGING_BRANCH_ROOT "details";
+
+const char kPrefLoggingProfiler[] =
+    IDB_PREF_LOGGING_BRANCH_ROOT "profiler-marks";
+
+#undef IDB_PREF_LOGGING_BRANCH_ROOT
+#undef IDB_PREF_BRANCH_ROOT
+
+StaticMutex gDBManagerMutex;
+StaticRefPtr<IndexedDatabaseManager> gDBManager MOZ_GUARDED_BY(gDBManagerMutex);
+bool gInitialized MOZ_GUARDED_BY(gDBManagerMutex) = false;
+bool gClosed MOZ_GUARDED_BY(gDBManagerMutex) = false;
+
+Atomic<int32_t> gDataThresholdBytes(0);
+Atomic<int32_t> gMaxSerializedMsgSize(0);
+Atomic<int32_t> gMaxPreloadExtraRecords(0);
+
+void DataThresholdPrefChangedCallback(const char* aPrefName, void* aClosure) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!strcmp(aPrefName, kDataThresholdPref));
+  MOZ_ASSERT(!aClosure);
+
+  int32_t dataThresholdBytes =
+      Preferences::GetInt(aPrefName, kDefaultDataThresholdBytes);
+
+  // The magic -1 is for use only by tests that depend on stable blob file id's.
+  if (dataThresholdBytes == -1) {
+    dataThresholdBytes = INT32_MAX;
+  }
+
+  gDataThresholdBytes = dataThresholdBytes;
+}
+
+void MaxSerializedMsgSizePrefChangeCallback(const char* aPrefName,
+                                            void* aClosure) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!strcmp(aPrefName, kPrefMaxSerilizedMsgSize));
+  MOZ_ASSERT(!aClosure);
+
+  gMaxSerializedMsgSize =
+      Preferences::GetInt(aPrefName, kDefaultMaxSerializedMsgSize);
+  MOZ_ASSERT(gMaxSerializedMsgSize > 0);
+}
+
+void MaxPreloadExtraRecordsPrefChangeCallback(const char* aPrefName,
+                                              void* aClosure) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!strcmp(aPrefName, kPrefMaxPreloadExtraRecords));
+  MOZ_ASSERT(!aClosure);
+
+  gMaxPreloadExtraRecords =
+      Preferences::GetInt(aPrefName, kDefaultMaxPreloadExtraRecords);
+  MOZ_ASSERT(gMaxPreloadExtraRecords >= 0);
+
+  // TODO: We could also allow setting a negative value to preload all available
+  // records, but this doesn't seem to be too useful in general, and it would
+  // require adaptations in ActorsParent.cpp
+}
+
+auto DatabaseNameMatchPredicate(const nsAString* const aName) {
+  MOZ_ASSERT(aName);
+  return [aName](const auto& fileManager) {
+    return fileManager->DatabaseName() == *aName;
+  };
+}
+
+}  // namespace
+
+IndexedDatabaseManager::IndexedDatabaseManager() : mBackgroundActor(nullptr) {
+  NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+}
+
+IndexedDatabaseManager::~IndexedDatabaseManager() {
+  NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+
+  if (mBackgroundActor) {
+    mBackgroundActor->SendDeleteMeInternal();
+    MOZ_ASSERT(!mBackgroundActor, "SendDeleteMeInternal should have cleared!");
+  }
+}
+
+bool IndexedDatabaseManager::sIsMainProcess = false;
+bool IndexedDatabaseManager::sFullSynchronousMode = false;
+
+mozilla::LazyLogModule IndexedDatabaseManager::sLoggingModule("IndexedDB");
+
+Atomic<IndexedDatabaseManager::LoggingMode>
+    IndexedDatabaseManager::sLoggingMode(
+        IndexedDatabaseManager::Logging_Disabled);
+
+// static
+IndexedDatabaseManager* IndexedDatabaseManager::GetOrCreate() {
+  NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+
+  StaticMutexAutoLock lock(gDBManagerMutex);
+
+  if (gClosed) {
+    NS_ERROR("Calling GetOrCreate() after shutdown!");
+    return nullptr;
+  }
+
+  if (!gDBManager) {
+    sIsMainProcess = XRE_IsParentProcess();
+
+    if (gInitialized) {
+      NS_ERROR("Initialized more than once?!");
+    }
+
+    RefPtr<IndexedDatabaseManager> instance(new IndexedDatabaseManager());
+
+    {
+      StaticMutexAutoUnlock unlock(gDBManagerMutex);
+
+      QM_TRY(MOZ_TO_RESULT(instance->Init()), nullptr);
+    }
+
+    gDBManager = instance;
+
+    ClearOnShutdown(&gDBManager);
+
+    gInitialized = true;
+  }
+
+  return gDBManager;
+}
+
+// static
+IndexedDatabaseManager* IndexedDatabaseManager::Get() {
+  StaticMutexAutoLock lock(gDBManagerMutex);
+
+  // Does not return an owning reference.
+  return gDBManager;
+}
+
+nsresult IndexedDatabaseManager::Init() {
+  NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+
+  // By default IndexedDB uses SQLite with PRAGMA synchronous = NORMAL. This
+  // guarantees (unlike synchronous = OFF) atomicity and consistency, but not
+  // necessarily durability in situations such as power loss. This preference
+  // allows enabling PRAGMA synchronous = FULL on SQLite, which does guarantee
+  // durability, but with an extra fsync() and the corresponding performance
+  // hit.
+  sFullSynchronousMode = Preferences::GetBool("dom.indexedDB.fullSynchronous");
+
+  Preferences::RegisterCallback(LoggingModePrefChangedCallback,
+                                kPrefLoggingDetails);
+
+  Preferences::RegisterCallback(LoggingModePrefChangedCallback,
+                                kPrefLoggingProfiler);
+
+  Preferences::RegisterCallbackAndCall(LoggingModePrefChangedCallback,
+                                       kPrefLoggingEnabled);
+
+  Preferences::RegisterCallbackAndCall(DataThresholdPrefChangedCallback,
+                                       kDataThresholdPref);
+
+  Preferences::RegisterCallbackAndCall(MaxSerializedMsgSizePrefChangeCallback,
+                                       kPrefMaxSerilizedMsgSize);
+
+  Preferences::RegisterCallbackAndCall(MaxPreloadExtraRecordsPrefChangeCallback,
+                                       kPrefMaxPreloadExtraRecords);
+
+  nsAutoCString acceptLang;
+  Preferences::GetLocalizedCString("intl.accept_languages", acceptLang);
+
+  // Split values on commas.
+  for (const auto& lang :
+       nsCCharSeparatedTokenizer(acceptLang, ',').ToRange()) {
+    mozilla::intl::LocaleCanonicalizer::Vector asciiString{};
+    auto result = mozilla::intl::LocaleCanonicalizer::CanonicalizeICULevel1(
+        PromiseFlatCString(lang).get(), asciiString);
+    if (result.isOk()) {
+      mLocale.AssignASCII(asciiString);
+      break;
+    }
+  }
+
+  if (mLocale.IsEmpty()) {
+    mLocale.AssignLiteral("en_US");
+  }
+
+  return NS_OK;
+}
+
+void IndexedDatabaseManager::Destroy() {
+  {
+    StaticMutexAutoLock lock(gDBManagerMutex);
+
+    // Setting the closed flag prevents the service from being recreated.
+    // Don't set it though if there's no real instance created.
+    if (gInitialized && gClosed) {
+      NS_ERROR("Shutdown more than once?!");
+    }
+
+    gClosed = true;
+  }
+
+  Preferences::UnregisterCallback(LoggingModePrefChangedCallback,
+                                  kPrefLoggingDetails);
+
+  Preferences::UnregisterCallback(LoggingModePrefChangedCallback,
+                                  kPrefLoggingProfiler);
+
+  Preferences::UnregisterCallback(LoggingModePrefChangedCallback,
+                                  kPrefLoggingEnabled);
+
+  Preferences::UnregisterCallback(DataThresholdPrefChangedCallback,
+                                  kDataThresholdPref);
+
+  Preferences::UnregisterCallback(MaxSerializedMsgSizePrefChangeCallback,
+                                  kPrefMaxSerilizedMsgSize);
+
+  delete this;
+}
+
+// static
+bool IndexedDatabaseManager::ResolveSandboxBinding(JSContext* aCx) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(
+      JS::GetClass(JS::CurrentGlobalOrNull(aCx))->flags & JSCLASS_DOM_GLOBAL,
+      "Passed object is not a global object!");
+
+  // We need to ensure that the manager has been created already here so that we
+  // load preferences that may control which properties are exposed.
+  if (NS_WARN_IF(!GetOrCreate())) {
+    return false;
+  }
+
+  if (!IDBCursor_Binding::GetConstructorObject(aCx) ||
+      !IDBCursorWithValue_Binding::GetConstructorObject(aCx) ||
+      !IDBDatabase_Binding::GetConstructorObject(aCx) ||
+      !IDBFactory_Binding::GetConstructorObject(aCx) ||
+      !IDBIndex_Binding::GetConstructorObject(aCx) ||
+      !IDBKeyRange_Binding::GetConstructorObject(aCx) ||
+      !IDBLocaleAwareKeyRange_Binding::GetConstructorObject(aCx) ||
+      !IDBObjectStore_Binding::GetConstructorObject(aCx) ||
+      !IDBOpenDBRequest_Binding::GetConstructorObject(aCx) ||
+      !IDBRequest_Binding::GetConstructorObject(aCx) ||
+      !IDBTransaction_Binding::GetConstructorObject(aCx) ||
+      !IDBVersionChangeEvent_Binding::GetConstructorObject(aCx)) {
+    return false;
+  }
+
+  return true;
+}
+
+// static
+bool IndexedDatabaseManager::DefineIndexedDB(JSContext* aCx,
+                                             JS::Handle<JSObject*> aGlobal) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(JS::GetClass(aGlobal)->flags & JSCLASS_DOM_GLOBAL,
+             "Passed object is not a global object!");
+
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
+  if (NS_WARN_IF(!global)) {
+    return false;
+  }
+
+  QM_TRY_UNWRAP(auto factory, IDBFactory::CreateForMainThreadJS(global), false);
+
+  MOZ_ASSERT(factory, "This should never fail for chrome!");
+
+  JS::Rooted<JS::Value> indexedDB(aCx);
+  js::AssertSameCompartment(aCx, aGlobal);
+  if (!GetOrCreateDOMReflector(aCx, factory, &indexedDB)) {
+    return false;
+  }
+
+  return JS_DefineProperty(aCx, aGlobal, IDB_STR, indexedDB, JSPROP_ENUMERATE);
+}
+
+// static
+bool IndexedDatabaseManager::IsClosed() {
+  StaticMutexAutoLock lock(gDBManagerMutex);
+
+  return gClosed;
+}
+
+#ifdef DEBUG
+// static
+bool IndexedDatabaseManager::IsMainProcess() {
+  NS_ASSERTION(Get(),
+               "IsMainProcess() called before indexedDB has been initialized!");
+  NS_ASSERTION((XRE_IsParentProcess()) == sIsMainProcess,
+               "XRE_GetProcessType changed its tune!");
+  return sIsMainProcess;
+}
+
+// static
+IndexedDatabaseManager::LoggingMode IndexedDatabaseManager::GetLoggingMode() {
+  MOZ_ASSERT(Get(),
+             "GetLoggingMode called before IndexedDatabaseManager has been "
+             "initialized!");
+
+  return sLoggingMode;
+}
+
+// static
+mozilla::LogModule* IndexedDatabaseManager::GetLoggingModule() {
+  MOZ_ASSERT(Get(),
+             "GetLoggingModule called before IndexedDatabaseManager has been "
+             "initialized!");
+
+  return sLoggingModule;
+}
+
+#endif  // DEBUG
+
+// static
+bool IndexedDatabaseManager::FullSynchronous() {
+  MOZ_ASSERT(Get(),
+             "FullSynchronous() called before indexedDB has been initialized!");
+
+  return sFullSynchronousMode;
+}
+
+// static
+uint32_t IndexedDatabaseManager::DataThreshold() {
+  MOZ_ASSERT(Get(),
+             "DataThreshold() called before indexedDB has been initialized!");
+
+  return gDataThresholdBytes;
+}
+
+// static
+uint32_t IndexedDatabaseManager::MaxSerializedMsgSize() {
+  MOZ_ASSERT(
+      Get(),
+      "MaxSerializedMsgSize() called before indexedDB has been initialized!");
+  MOZ_ASSERT(gMaxSerializedMsgSize > 0);
+
+  return gMaxSerializedMsgSize;
+}
+
+// static
+int32_t IndexedDatabaseManager::MaxPreloadExtraRecords() {
+  MOZ_ASSERT(Get(),
+             "MaxPreloadExtraRecords() called before indexedDB has been "
+             "initialized!");
+
+  return gMaxPreloadExtraRecords;
+}
+
+void IndexedDatabaseManager::ClearBackgroundActor() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mBackgroundActor = nullptr;
+}
+
+SafeRefPtr<DatabaseFileManager> IndexedDatabaseManager::GetFileManager(
+    PersistenceType aPersistenceType, const nsACString& aOrigin,
+    const nsAString& aDatabaseName) {
+  AssertIsOnIOThread();
+
+  FileManagerInfo* info;
+  if (!mFileManagerInfos.Get(aOrigin, &info)) {
+    return nullptr;
+  }
+
+  return info->GetFileManager(aPersistenceType, aDatabaseName);
+}
+
+void IndexedDatabaseManager::AddFileManager(
+    SafeRefPtr<DatabaseFileManager> aFileManager) {
+  AssertIsOnIOThread();
+  MOZ_ASSERT(aFileManager);
+
+  const auto& origin = aFileManager->Origin();
+  mFileManagerInfos.GetOrInsertNew(origin)->AddFileManager(
+      std::move(aFileManager));
+}
+
+void IndexedDatabaseManager::InvalidateAllFileManagers() {
+  AssertIsOnIOThread();
+
+  for (const auto& fileManagerInfo : mFileManagerInfos.Values()) {
+    fileManagerInfo->InvalidateAllFileManagers();
+  }
+
+  mFileManagerInfos.Clear();
+}
+
+void IndexedDatabaseManager::InvalidateFileManagers(
+    PersistenceType aPersistenceType) {
+  AssertIsOnIOThread();
+
+  for (auto iter = mFileManagerInfos.Iter(); !iter.Done(); iter.Next()) {
+    iter.Data()->InvalidateAndRemoveFileManagers(aPersistenceType);
+
+    if (!iter.Data()->HasFileManagers()) {
+      iter.Remove();
+    }
+  }
+}
+
+void IndexedDatabaseManager::InvalidateFileManagers(
+    PersistenceType aPersistenceType, const nsACString& aOrigin) {
+  AssertIsOnIOThread();
+  MOZ_ASSERT(!aOrigin.IsEmpty());
+
+  FileManagerInfo* info;
+  if (!mFileManagerInfos.Get(aOrigin, &info)) {
+    return;
+  }
+
+  info->InvalidateAndRemoveFileManagers(aPersistenceType);
+
+  if (!info->HasFileManagers()) {
+    mFileManagerInfos.Remove(aOrigin);
+  }
+}
+
+void IndexedDatabaseManager::InvalidateFileManager(
+    PersistenceType aPersistenceType, const nsACString& aOrigin,
+    const nsAString& aDatabaseName) {
+  AssertIsOnIOThread();
+
+  FileManagerInfo* info;
+  if (!mFileManagerInfos.Get(aOrigin, &info)) {
+    return;
+  }
+
+  info->InvalidateAndRemoveFileManager(aPersistenceType, aDatabaseName);
+
+  if (!info->HasFileManagers()) {
+    mFileManagerInfos.Remove(aOrigin);
+  }
+}
+
+nsresult IndexedDatabaseManager::BlockAndGetFileReferences(
+    PersistenceType aPersistenceType, const nsACString& aOrigin,
+    const nsAString& aDatabaseName, int64_t aFileId, int32_t* aRefCnt,
+    int32_t* aDBRefCnt, bool* aResult) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!StaticPrefs::dom_indexedDB_testing())) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  if (!mBackgroundActor) {
+    PBackgroundChild* bgActor = BackgroundChild::GetForCurrentThread();
+    if (NS_WARN_IF(!bgActor)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    BackgroundUtilsChild* actor = new BackgroundUtilsChild(this);
+
+    // We don't set event target for BackgroundUtilsChild because:
+    // 1. BackgroundUtilsChild is a singleton.
+    // 2. SendGetFileReferences is a sync operation to be returned asap if
+    // unlabeled.
+    // 3. The rest operations like DeleteMe/__delete__ only happens at shutdown.
+    // Hence, we should keep it unlabeled.
+    mBackgroundActor = static_cast<BackgroundUtilsChild*>(
+        bgActor->SendPBackgroundIndexedDBUtilsConstructor(actor));
+  }
+
+  if (NS_WARN_IF(!mBackgroundActor)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!mBackgroundActor->SendGetFileReferences(
+          aPersistenceType, nsCString(aOrigin), nsString(aDatabaseName),
+          aFileId, aRefCnt, aDBRefCnt, aResult)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+nsresult IndexedDatabaseManager::FlushPendingFileDeletions() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!StaticPrefs::dom_indexedDB_testing())) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  PBackgroundChild* bgActor = BackgroundChild::GetForCurrentThread();
+  if (NS_WARN_IF(!bgActor)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!bgActor->SendFlushPendingFileDeletions()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+// static
+void IndexedDatabaseManager::LoggingModePrefChangedCallback(
+    const char* /* aPrefName */, void* /* aClosure */) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!Preferences::GetBool(kPrefLoggingEnabled)) {
+    sLoggingMode = Logging_Disabled;
+    return;
+  }
+
+  bool useProfiler = Preferences::GetBool(kPrefLoggingProfiler);
+#if !defined(MOZ_GECKO_PROFILER)
+  if (useProfiler) {
+    NS_WARNING(
+        "IndexedDB cannot create profiler marks because this build does "
+        "not have profiler extensions enabled!");
+    useProfiler = false;
+  }
+#endif
+
+  const bool logDetails = Preferences::GetBool(kPrefLoggingDetails);
+
+  if (useProfiler) {
+    sLoggingMode = logDetails ? Logging_DetailedProfilerMarks
+                              : Logging_ConciseProfilerMarks;
+  } else {
+    sLoggingMode = logDetails ? Logging_Detailed : Logging_Concise;
+  }
+}
+
+// static
+const nsCString& IndexedDatabaseManager::GetLocale() {
+  IndexedDatabaseManager* idbManager = Get();
+  MOZ_ASSERT(idbManager, "IDBManager is not ready!");
+
+  return idbManager->mLocale;
+}
+
+SafeRefPtr<DatabaseFileManager> FileManagerInfo::GetFileManager(
+    PersistenceType aPersistenceType, const nsAString& aName) const {
+  AssertIsOnIOThread();
+
+  const auto& managers = GetImmutableArray(aPersistenceType);
+
+  const auto end = managers.cend();
+  const auto foundIt =
+      std::find_if(managers.cbegin(), end, DatabaseNameMatchPredicate(&aName));
+
+  return foundIt != end ? foundIt->clonePtr() : nullptr;
+}
+
+void FileManagerInfo::AddFileManager(
+    SafeRefPtr<DatabaseFileManager> aFileManager) {
+  AssertIsOnIOThread();
+
+  nsTArray<SafeRefPtr<DatabaseFileManager> >& managers =
+      GetArray(aFileManager->Type());
+
+  NS_ASSERTION(!managers.Contains(aFileManager), "Adding more than once?!");
+
+  managers.AppendElement(std::move(aFileManager));
+}
+
+void FileManagerInfo::InvalidateAllFileManagers() const {
+  AssertIsOnIOThread();
+
+  uint32_t i;
+
+  for (i = 0; i < mPersistentStorageFileManagers.Length(); i++) {
+    mPersistentStorageFileManagers[i]->Invalidate();
+  }
+
+  for (i = 0; i < mTemporaryStorageFileManagers.Length(); i++) {
+    mTemporaryStorageFileManagers[i]->Invalidate();
+  }
+
+  for (i = 0; i < mDefaultStorageFileManagers.Length(); i++) {
+    mDefaultStorageFileManagers[i]->Invalidate();
+  }
+
+  for (i = 0; i < mPrivateStorageFileManagers.Length(); i++) {
+    mPrivateStorageFileManagers[i]->Invalidate();
+  }
+}
+
+void FileManagerInfo::InvalidateAndRemoveFileManagers(
+    PersistenceType aPersistenceType) {
+  AssertIsOnIOThread();
+
+  nsTArray<SafeRefPtr<DatabaseFileManager> >& managers =
+      GetArray(aPersistenceType);
+
+  for (uint32_t i = 0; i < managers.Length(); i++) {
+    managers[i]->Invalidate();
+  }
+
+  managers.Clear();
+}
+
+void FileManagerInfo::InvalidateAndRemoveFileManager(
+    PersistenceType aPersistenceType, const nsAString& aName) {
+  AssertIsOnIOThread();
+
+  auto& managers = GetArray(aPersistenceType);
+  const auto end = managers.cend();
+  const auto foundIt =
+      std::find_if(managers.cbegin(), end, DatabaseNameMatchPredicate(&aName));
+
+  if (foundIt != end) {
+    (*foundIt)->Invalidate();
+    managers.RemoveElementAt(foundIt.GetIndex());
+  }
+}
+
+nsTArray<SafeRefPtr<DatabaseFileManager> >& FileManagerInfo::GetArray(
+    PersistenceType aPersistenceType) {
+  switch (aPersistenceType) {
+    case PERSISTENCE_TYPE_PERSISTENT:
+      return mPersistentStorageFileManagers;
+    case PERSISTENCE_TYPE_TEMPORARY:
+      return mTemporaryStorageFileManagers;
+    case PERSISTENCE_TYPE_DEFAULT:
+      return mDefaultStorageFileManagers;
+    case PERSISTENCE_TYPE_PRIVATE:
+      return mPrivateStorageFileManagers;
+
+    case PERSISTENCE_TYPE_INVALID:
+    default:
+      MOZ_CRASH("Bad storage type value!");
+  }
+}
+
+}  // namespace mozilla::dom