Adding upstream version 115.8.0esr.upstream/115.8.0esr

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

1 files changed, 2859 insertions, 0 deletions

diff --git a/dom/indexedDB/ActorsChild.cpp b/dom/indexedDB/ActorsChild.cpp
new file mode 100644
index 0000000000..00d1f63b01
--- /dev/null
+++ b/dom/indexedDB/ActorsChild.cpp
@@ -0,0 +1,2859 @@
+/* -*- 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 <type_traits>
+
+#include "ActorsChild.h"
+#include "BackgroundChildImpl.h"
+#include "IDBDatabase.h"
+#include "IDBEvents.h"
+#include "IDBFactory.h"
+#include "IDBIndex.h"
+#include "IDBObjectStore.h"
+#include "IDBRequest.h"
+#include "IDBTransaction.h"
+#include "IndexedDatabase.h"
+#include "IndexedDatabaseInlines.h"
+#include "IndexedDBCommon.h"
+#include "js/Array.h"               // JS::NewArrayObject, JS::SetArrayLength
+#include "js/Date.h"                // JS::NewDateObject, JS::TimeClip
+#include "js/PropertyAndElement.h"  // JS_DefineElement, JS_DefineProperty
+#include <mozIRemoteLazyInputStream.h>
+#include "mozilla/ArrayAlgorithm.h"
+#include "mozilla/BasicEvents.h"
+#include "mozilla/CycleCollectedJSRuntime.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/PermissionMessageUtils.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileChild.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/dom/WorkerPrivate.h"
+#include "mozilla/dom/WorkerRunnable.h"
+#include "mozilla/dom/quota/ResultExtensions.h"
+#include "mozilla/Encoding.h"
+#include "mozilla/ipc/BackgroundUtils.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/TaskQueue.h"
+#include "nsCOMPtr.h"
+#include "nsContentUtils.h"
+#include "nsIAsyncInputStream.h"
+#include "nsIEventTarget.h"
+#include "nsIFileStreams.h"
+#include "nsNetCID.h"
+#include "nsPIDOMWindow.h"
+#include "nsThreadUtils.h"
+#include "nsTraceRefcnt.h"
+#include "ProfilerHelpers.h"
+#include "ReportInternalError.h"
+#include "ThreadLocal.h"
+
+#ifdef DEBUG
+#  include "IndexedDatabaseManager.h"
+#endif
+
+#define GC_ON_IPC_MESSAGES 0
+
+#if defined(DEBUG) || GC_ON_IPC_MESSAGES
+
+#  include "js/GCAPI.h"
+#  include "nsJSEnvironment.h"
+
+#  define BUILD_GC_ON_IPC_MESSAGES
+
+#endif  // DEBUG || GC_ON_IPC_MESSAGES
+
+namespace mozilla {
+
+using ipc::PrincipalInfo;
+
+namespace dom::indexedDB {
+
+/*******************************************************************************
+ * ThreadLocal
+ ******************************************************************************/
+
+ThreadLocal::ThreadLocal(const nsID& aBackgroundChildLoggingId)
+    : mLoggingInfo(aBackgroundChildLoggingId, 1, -1, 1),
+      mLoggingIdString(aBackgroundChildLoggingId) {
+  MOZ_COUNT_CTOR(mozilla::dom::indexedDB::ThreadLocal);
+}
+
+ThreadLocal::~ThreadLocal() {
+  MOZ_COUNT_DTOR(mozilla::dom::indexedDB::ThreadLocal);
+}
+
+/*******************************************************************************
+ * Helpers
+ ******************************************************************************/
+
+namespace {
+
+void MaybeCollectGarbageOnIPCMessage() {
+#ifdef BUILD_GC_ON_IPC_MESSAGES
+  static const bool kCollectGarbageOnIPCMessages =
+#  if GC_ON_IPC_MESSAGES
+      true;
+#  else
+      false;
+#  endif  // GC_ON_IPC_MESSAGES
+
+  if (!kCollectGarbageOnIPCMessages) {
+    return;
+  }
+
+  static bool haveWarnedAboutGC = false;
+  static bool haveWarnedAboutNonMainThread = false;
+
+  if (!haveWarnedAboutGC) {
+    haveWarnedAboutGC = true;
+    NS_WARNING("IndexedDB child actor GC debugging enabled!");
+  }
+
+  if (!NS_IsMainThread()) {
+    if (!haveWarnedAboutNonMainThread) {
+      haveWarnedAboutNonMainThread = true;
+      NS_WARNING("Don't know how to GC on a non-main thread yet.");
+    }
+    return;
+  }
+
+  nsJSContext::GarbageCollectNow(JS::GCReason::DOM_IPC);
+  nsJSContext::CycleCollectNow(CCReason::API);
+#endif  // BUILD_GC_ON_IPC_MESSAGES
+}
+
+class MOZ_STACK_CLASS AutoSetCurrentTransaction final {
+  using BackgroundChildImpl = mozilla::ipc::BackgroundChildImpl;
+
+  Maybe<IDBTransaction&> const mTransaction;
+  Maybe<IDBTransaction&> mPreviousTransaction;
+  ThreadLocal* mThreadLocal;
+
+ public:
+  AutoSetCurrentTransaction(const AutoSetCurrentTransaction&) = delete;
+  AutoSetCurrentTransaction(AutoSetCurrentTransaction&&) = delete;
+  AutoSetCurrentTransaction& operator=(const AutoSetCurrentTransaction&) =
+      delete;
+  AutoSetCurrentTransaction& operator=(AutoSetCurrentTransaction&&) = delete;
+
+  explicit AutoSetCurrentTransaction(Maybe<IDBTransaction&> aTransaction)
+      : mTransaction(aTransaction),
+        mPreviousTransaction(),
+        mThreadLocal(nullptr) {
+    if (aTransaction) {
+      BackgroundChildImpl::ThreadLocal* threadLocal =
+          BackgroundChildImpl::GetThreadLocalForCurrentThread();
+      MOZ_ASSERT(threadLocal);
+
+      // Hang onto this for resetting later.
+      mThreadLocal = threadLocal->mIndexedDBThreadLocal.get();
+      MOZ_ASSERT(mThreadLocal);
+
+      // Save the current value.
+      mPreviousTransaction = mThreadLocal->MaybeCurrentTransactionRef();
+
+      // Set the new value.
+      mThreadLocal->SetCurrentTransaction(aTransaction);
+    }
+  }
+
+  ~AutoSetCurrentTransaction() {
+    MOZ_ASSERT_IF(mThreadLocal, mTransaction);
+    MOZ_ASSERT_IF(mThreadLocal,
+                  ReferenceEquals(mThreadLocal->MaybeCurrentTransactionRef(),
+                                  mTransaction));
+
+    if (mThreadLocal) {
+      // Reset old value.
+      mThreadLocal->SetCurrentTransaction(mPreviousTransaction);
+    }
+  }
+};
+
+template <typename T>
+void SetResultAndDispatchSuccessEvent(
+    const NotNull<RefPtr<IDBRequest>>& aRequest,
+    const SafeRefPtr<IDBTransaction>& aTransaction, T& aPtr,
+    RefPtr<Event> aEvent = nullptr);
+
+namespace detail {
+void DispatchSuccessEvent(const NotNull<RefPtr<IDBRequest>>& aRequest,
+                          const SafeRefPtr<IDBTransaction>& aTransaction,
+                          const RefPtr<Event>& aEvent);
+
+template <class T>
+std::enable_if_t<std::is_same_v<T, IDBDatabase> || std::is_same_v<T, IDBCursor>,
+                 nsresult>
+GetResult(JSContext* aCx, T* aDOMObject, JS::MutableHandle<JS::Value> aResult) {
+  if (!aDOMObject) {
+    aResult.setNull();
+    return NS_OK;
+  }
+
+  const bool ok = GetOrCreateDOMReflector(aCx, aDOMObject, aResult);
+  if (NS_WARN_IF(!ok)) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+  }
+
+  return NS_OK;
+}
+
+nsresult GetResult(JSContext* aCx, const JS::Handle<JS::Value>* aValue,
+                   JS::MutableHandle<JS::Value> aResult) {
+  aResult.set(*aValue);
+  return NS_OK;
+}
+
+nsresult GetResult(JSContext* aCx, const uint64_t* aValue,
+                   JS::MutableHandle<JS::Value> aResult) {
+  aResult.set(JS::NumberValue(*aValue));
+  return NS_OK;
+}
+
+nsresult GetResult(JSContext* aCx, StructuredCloneReadInfoChild&& aCloneInfo,
+                   JS::MutableHandle<JS::Value> aResult) {
+  const bool ok =
+      IDBObjectStore::DeserializeValue(aCx, std::move(aCloneInfo), aResult);
+
+  if (NS_WARN_IF(!ok)) {
+    return NS_ERROR_DOM_DATA_CLONE_ERR;
+  }
+
+  return NS_OK;
+}
+
+nsresult GetResult(JSContext* aCx, StructuredCloneReadInfoChild* aCloneInfo,
+                   JS::MutableHandle<JS::Value> aResult) {
+  return GetResult(aCx, std::move(*aCloneInfo), aResult);
+}
+
+nsresult GetResult(JSContext* aCx,
+                   nsTArray<StructuredCloneReadInfoChild>* aCloneInfos,
+                   JS::MutableHandle<JS::Value> aResult) {
+  JS::Rooted<JSObject*> array(aCx, JS::NewArrayObject(aCx, 0));
+  if (NS_WARN_IF(!array)) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+  }
+
+  if (!aCloneInfos->IsEmpty()) {
+    const uint32_t count = aCloneInfos->Length();
+
+    if (NS_WARN_IF(!JS::SetArrayLength(aCx, array, count))) {
+      IDB_REPORT_INTERNAL_ERR();
+      return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+    }
+
+    for (uint32_t index = 0; index < count; index++) {
+      auto& cloneInfo = aCloneInfos->ElementAt(index);
+
+      JS::Rooted<JS::Value> value(aCx);
+
+      const nsresult rv = GetResult(aCx, std::move(cloneInfo), &value);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      if (NS_WARN_IF(
+              !JS_DefineElement(aCx, array, index, value, JSPROP_ENUMERATE))) {
+        IDB_REPORT_INTERNAL_ERR();
+        return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+      }
+    }
+  }
+
+  aResult.setObject(*array);
+  return NS_OK;
+}
+
+nsresult GetResult(JSContext* aCx, const Key* aKey,
+                   JS::MutableHandle<JS::Value> aResult) {
+  const nsresult rv = aKey->ToJSVal(aCx, aResult);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  return NS_OK;
+}
+
+nsresult GetResult(JSContext* aCx, const nsTArray<Key>* aKeys,
+                   JS::MutableHandle<JS::Value> aResult) {
+  JS::Rooted<JSObject*> array(aCx, JS::NewArrayObject(aCx, 0));
+  if (NS_WARN_IF(!array)) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+  }
+
+  if (!aKeys->IsEmpty()) {
+    const uint32_t count = aKeys->Length();
+
+    if (NS_WARN_IF(!JS::SetArrayLength(aCx, array, count))) {
+      IDB_REPORT_INTERNAL_ERR();
+      return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+    }
+
+    for (uint32_t index = 0; index < count; index++) {
+      const Key& key = aKeys->ElementAt(index);
+      MOZ_ASSERT(!key.IsUnset());
+
+      JS::Rooted<JS::Value> value(aCx);
+
+      const nsresult rv = GetResult(aCx, &key, &value);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      if (NS_WARN_IF(
+              !JS_DefineElement(aCx, array, index, value, JSPROP_ENUMERATE))) {
+        IDB_REPORT_INTERNAL_ERR();
+        return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+      }
+    }
+  }
+
+  aResult.setObject(*array);
+  return NS_OK;
+}
+}  // namespace detail
+
+auto DeserializeStructuredCloneFiles(
+    IDBDatabase* aDatabase,
+    const nsTArray<SerializedStructuredCloneFile>& aSerializedFiles,
+    bool aForPreprocess) {
+  MOZ_ASSERT_IF(aForPreprocess, aSerializedFiles.Length() == 1);
+
+  return TransformIntoNewArray(
+      aSerializedFiles,
+      [aForPreprocess, &database = *aDatabase](
+          const auto& serializedFile) -> StructuredCloneFileChild {
+        MOZ_ASSERT_IF(
+            aForPreprocess,
+            serializedFile.type() == StructuredCloneFileBase::eStructuredClone);
+
+        const NullableBlob& blob = serializedFile.file();
+
+        switch (serializedFile.type()) {
+          case StructuredCloneFileBase::eBlob: {
+            MOZ_ASSERT(blob.type() == NullableBlob::TIPCBlob);
+
+            const IPCBlob& ipcBlob = blob.get_IPCBlob();
+
+            const RefPtr<BlobImpl> blobImpl =
+                IPCBlobUtils::Deserialize(ipcBlob);
+            MOZ_ASSERT(blobImpl);
+
+            RefPtr<Blob> blob =
+                Blob::Create(database.GetOwnerGlobal(), blobImpl);
+            MOZ_ASSERT(blob);
+
+            return {StructuredCloneFileBase::eBlob, std::move(blob)};
+          }
+
+          case StructuredCloneFileBase::eStructuredClone: {
+            if (aForPreprocess) {
+              MOZ_ASSERT(blob.type() == NullableBlob::TIPCBlob);
+
+              const IPCBlob& ipcBlob = blob.get_IPCBlob();
+
+              const RefPtr<BlobImpl> blobImpl =
+                  IPCBlobUtils::Deserialize(ipcBlob);
+              MOZ_ASSERT(blobImpl);
+
+              RefPtr<Blob> blob =
+                  Blob::Create(database.GetOwnerGlobal(), blobImpl);
+              MOZ_ASSERT(blob);
+
+              return {StructuredCloneFileBase::eStructuredClone,
+                      std::move(blob)};
+            }
+            MOZ_ASSERT(blob.type() == NullableBlob::Tnull_t);
+
+            return StructuredCloneFileChild{
+                StructuredCloneFileBase::eStructuredClone};
+          }
+
+          case StructuredCloneFileBase::eMutableFile:
+          case StructuredCloneFileBase::eWasmBytecode:
+          case StructuredCloneFileBase::eWasmCompiled: {
+            MOZ_ASSERT(blob.type() == NullableBlob::Tnull_t);
+
+            return StructuredCloneFileChild{serializedFile.type()};
+
+            // Don't set mBlob, support for storing WebAssembly.Modules has been
+            // removed in bug 1469395. Support for de-serialization of
+            // WebAssembly.Modules has been removed in bug 1561876. Support for
+            // MutableFile has been removed in bug 1500343. Full removal is
+            // tracked in bug 1487479.
+          }
+
+          default:
+            MOZ_CRASH("Should never get here!");
+        }
+      });
+}
+
+JSStructuredCloneData PreprocessingNotSupported() {
+  MOZ_CRASH("Preprocessing not (yet) supported!");
+}
+
+template <typename PreprocessInfoAccessor>
+StructuredCloneReadInfoChild DeserializeStructuredCloneReadInfo(
+    SerializedStructuredCloneReadInfo&& aSerialized,
+    IDBDatabase* const aDatabase,
+    PreprocessInfoAccessor preprocessInfoAccessor) {
+  // XXX Make this a class invariant of SerializedStructuredCloneReadInfo.
+  MOZ_ASSERT_IF(aSerialized.hasPreprocessInfo(),
+                0 == aSerialized.data().data.Size());
+  return {aSerialized.hasPreprocessInfo() ? preprocessInfoAccessor()
+                                          : std::move(aSerialized.data().data),
+          DeserializeStructuredCloneFiles(aDatabase, aSerialized.files(),
+                                          /* aForPreprocess */ false),
+          aDatabase};
+}
+
+// TODO: Remove duplication between DispatchErrorEvent and DispatchSucessEvent.
+
+void DispatchErrorEvent(
+    MovingNotNull<RefPtr<IDBRequest>> aRequest, nsresult aErrorCode,
+    const SafeRefPtr<IDBTransaction>& aTransaction = nullptr,
+    RefPtr<Event> aEvent = nullptr) {
+  const RefPtr<IDBRequest> request = std::move(aRequest);
+
+  request->AssertIsOnOwningThread();
+  MOZ_ASSERT(NS_FAILED(aErrorCode));
+  MOZ_ASSERT(NS_ERROR_GET_MODULE(aErrorCode) == NS_ERROR_MODULE_DOM_INDEXEDDB);
+
+  AUTO_PROFILER_LABEL("IndexedDB:DispatchErrorEvent", DOM);
+
+  request->SetError(aErrorCode);
+
+  if (!aEvent) {
+    // Make an error event and fire it at the target.
+    aEvent = CreateGenericEvent(request, nsDependentString(kErrorEventType),
+                                eDoesBubble, eCancelable);
+  }
+  MOZ_ASSERT(aEvent);
+
+  // XXX This is redundant if we are called from
+  // DispatchSuccessEvent.
+  Maybe<AutoSetCurrentTransaction> asct;
+  if (aTransaction) {
+    asct.emplace(SomeRef(*aTransaction));
+  }
+
+  if (aTransaction && aTransaction->IsInactive()) {
+    aTransaction->TransitionToActive();
+  }
+
+  if (aTransaction) {
+    IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+        "Firing %s event with error 0x%x", "%s (0x%" PRIx32 ")",
+        aTransaction->LoggingSerialNumber(), request->LoggingSerialNumber(),
+        IDB_LOG_STRINGIFY(aEvent, kErrorEventType),
+        static_cast<uint32_t>(aErrorCode));
+  } else {
+    IDB_LOG_MARK_CHILD_REQUEST("Firing %s event with error 0x%x",
+                               "%s (0x%" PRIx32 ")",
+                               request->LoggingSerialNumber(),
+                               IDB_LOG_STRINGIFY(aEvent, kErrorEventType),
+                               static_cast<uint32_t>(aErrorCode));
+  }
+
+  IgnoredErrorResult rv;
+  const bool doDefault =
+      request->DispatchEvent(*aEvent, CallerType::System, rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    return;
+  }
+
+  MOZ_ASSERT(!aTransaction || aTransaction->IsActive() ||
+             aTransaction->IsAborted() ||
+             aTransaction->WasExplicitlyCommitted());
+
+  if (aTransaction && aTransaction->IsActive()) {
+    aTransaction->TransitionToInactive();
+
+    // Do not abort the transaction here if this request is failed due to the
+    // abortion of its transaction to ensure that the correct error cause of
+    // the abort event be set in IDBTransaction::FireCompleteOrAbortEvents()
+    // later.
+    if (aErrorCode != NS_ERROR_DOM_INDEXEDDB_ABORT_ERR) {
+      WidgetEvent* const internalEvent = aEvent->WidgetEventPtr();
+      MOZ_ASSERT(internalEvent);
+
+      if (internalEvent->mFlags.mExceptionWasRaised) {
+        aTransaction->Abort(NS_ERROR_DOM_INDEXEDDB_ABORT_ERR);
+      } else if (doDefault) {
+        aTransaction->Abort(request);
+      }
+    }
+  }
+}
+
+template <typename T>
+void SetResultAndDispatchSuccessEvent(
+    const NotNull<RefPtr<IDBRequest>>& aRequest,
+    const SafeRefPtr<IDBTransaction>& aTransaction, T& aPtr,
+    RefPtr<Event> aEvent) {
+  const auto autoTransaction =
+      AutoSetCurrentTransaction{aTransaction.maybeDeref()};
+
+  AUTO_PROFILER_LABEL("IndexedDB:SetResultAndDispatchSuccessEvent", DOM);
+
+  aRequest->AssertIsOnOwningThread();
+
+  if (aTransaction && aTransaction->IsAborted()) {
+    DispatchErrorEvent(aRequest, aTransaction->AbortCode(), aTransaction);
+    return;
+  }
+
+  if (!aEvent) {
+    aEvent =
+        CreateGenericEvent(aRequest.get(), nsDependentString(kSuccessEventType),
+                           eDoesNotBubble, eNotCancelable);
+  }
+  MOZ_ASSERT(aEvent);
+
+  aRequest->SetResult(
+      [&aPtr](JSContext* aCx, JS::MutableHandle<JS::Value> aResult) {
+        MOZ_ASSERT(aCx);
+        return detail::GetResult(aCx, &aPtr, aResult);
+      });
+
+  detail::DispatchSuccessEvent(aRequest, aTransaction, aEvent);
+}
+
+namespace detail {
+void DispatchSuccessEvent(const NotNull<RefPtr<IDBRequest>>& aRequest,
+                          const SafeRefPtr<IDBTransaction>& aTransaction,
+                          const RefPtr<Event>& aEvent) {
+  if (aTransaction && aTransaction->IsInactive()) {
+    aTransaction->TransitionToActive();
+  }
+
+  if (aTransaction) {
+    IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+        "Firing %s event", "%s", aTransaction->LoggingSerialNumber(),
+        aRequest->LoggingSerialNumber(),
+        IDB_LOG_STRINGIFY(aEvent, kSuccessEventType));
+  } else {
+    IDB_LOG_MARK_CHILD_REQUEST("Firing %s event", "%s",
+                               aRequest->LoggingSerialNumber(),
+                               IDB_LOG_STRINGIFY(aEvent, kSuccessEventType));
+  }
+
+  MOZ_ASSERT_IF(aTransaction && !aTransaction->WasExplicitlyCommitted(),
+                aTransaction->IsActive() && !aTransaction->IsAborted());
+
+  IgnoredErrorResult rv;
+  aRequest->DispatchEvent(*aEvent, rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    return;
+  }
+
+  WidgetEvent* const internalEvent = aEvent->WidgetEventPtr();
+  MOZ_ASSERT(internalEvent);
+
+  if (aTransaction && aTransaction->IsActive()) {
+    aTransaction->TransitionToInactive();
+
+    if (internalEvent->mFlags.mExceptionWasRaised) {
+      aTransaction->Abort(NS_ERROR_DOM_INDEXEDDB_ABORT_ERR);
+    } else {
+      // To handle upgrade transaction.
+      aTransaction->CommitIfNotStarted();
+    }
+  }
+}
+}  // namespace detail
+
+PRFileDesc* GetFileDescriptorFromStream(nsIInputStream* aStream) {
+  MOZ_ASSERT(aStream);
+
+  const nsCOMPtr<nsIFileMetadata> fileMetadata = do_QueryInterface(aStream);
+  if (NS_WARN_IF(!fileMetadata)) {
+    return nullptr;
+  }
+
+  PRFileDesc* fileDesc;
+  const nsresult rv = fileMetadata->GetFileDescriptor(&fileDesc);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return nullptr;
+  }
+
+  MOZ_ASSERT(fileDesc);
+
+  return fileDesc;
+}
+
+auto GetKeyOperator(const IDBCursorDirection aDirection) {
+  switch (aDirection) {
+    case IDBCursorDirection::Next:
+    case IDBCursorDirection::Nextunique:
+      return &Key::operator>=;
+    case IDBCursorDirection::Prev:
+    case IDBCursorDirection::Prevunique:
+      return &Key::operator<=;
+    default:
+      MOZ_CRASH("Should never get here.");
+  }
+}
+
+// Does not need to be threadsafe since this only runs on one thread, but
+// inheriting from CancelableRunnable is easy.
+template <typename T>
+class DelayedActionRunnable final : public CancelableRunnable {
+  using ActionFunc = void (T::*)();
+
+  SafeRefPtr<T> mActor;
+  RefPtr<IDBRequest> mRequest;
+  ActionFunc mActionFunc;
+
+ public:
+  explicit DelayedActionRunnable(SafeRefPtr<T> aActor, ActionFunc aActionFunc)
+      : CancelableRunnable("indexedDB::DelayedActionRunnable"),
+        mActor(std::move(aActor)),
+        mRequest(mActor->GetRequest()),
+        mActionFunc(aActionFunc) {
+    MOZ_ASSERT(mActor);
+    mActor->AssertIsOnOwningThread();
+    MOZ_ASSERT(mRequest);
+    MOZ_ASSERT(mActionFunc);
+  }
+
+ private:
+  ~DelayedActionRunnable() = default;
+
+  NS_DECL_NSIRUNNABLE
+  nsresult Cancel() override;
+};
+
+}  // namespace
+
+/*******************************************************************************
+ * Actor class declarations
+ ******************************************************************************/
+
+// DiscardableRunnable is used to make workers happy.
+class BackgroundRequestChild::PreprocessHelper final
+    : public DiscardableRunnable,
+      public nsIInputStreamCallback,
+      public nsIFileMetadataCallback {
+  enum class State {
+    // Just created on the owning thread, dispatched to the thread pool. Next
+    // step is either Finishing if stream was ready to be read or
+    // WaitingForStreamReady if the stream is not ready.
+    Initial,
+
+    // Waiting for stream to be ready on a thread pool thread. Next state is
+    // Finishing.
+    WaitingForStreamReady,
+
+    // Waiting to finish/finishing on the owning thread. Next step is Completed.
+    Finishing,
+
+    // All done.
+    Completed
+  };
+
+  const nsCOMPtr<nsIEventTarget> mOwningEventTarget;
+  RefPtr<TaskQueue> mTaskQueue;
+  nsCOMPtr<nsIInputStream> mStream;
+  UniquePtr<JSStructuredCloneData> mCloneData;
+  BackgroundRequestChild* mActor;
+  const uint32_t mCloneDataIndex;
+  nsresult mResultCode;
+  State mState;
+
+ public:
+  PreprocessHelper(uint32_t aCloneDataIndex, BackgroundRequestChild* aActor)
+      : DiscardableRunnable(
+            "indexedDB::BackgroundRequestChild::PreprocessHelper"),
+        mOwningEventTarget(aActor->GetActorEventTarget()),
+        mActor(aActor),
+        mCloneDataIndex(aCloneDataIndex),
+        mResultCode(NS_OK),
+        mState(State::Initial) {
+    AssertIsOnOwningThread();
+    MOZ_ASSERT(aActor);
+    aActor->AssertIsOnOwningThread();
+  }
+
+  bool IsOnOwningThread() const {
+    MOZ_ASSERT(mOwningEventTarget);
+
+    bool current;
+    return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) &&
+           current;
+  }
+
+  void AssertIsOnOwningThread() const { MOZ_ASSERT(IsOnOwningThread()); }
+
+  void ClearActor() {
+    AssertIsOnOwningThread();
+
+    mActor = nullptr;
+  }
+
+  nsresult Init(const StructuredCloneFileChild& aFile);
+
+  nsresult Dispatch();
+
+ private:
+  ~PreprocessHelper() {
+    MOZ_ASSERT(mState == State::Initial || mState == State::Completed);
+
+    if (mTaskQueue) {
+      mTaskQueue->BeginShutdown();
+    }
+  }
+
+  nsresult Start();
+
+  nsresult ProcessStream();
+
+  void Finish();
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIRUNNABLE
+  NS_DECL_NSIINPUTSTREAMCALLBACK
+  NS_DECL_NSIFILEMETADATACALLBACK
+};
+
+/*******************************************************************************
+ * BackgroundRequestChildBase
+ ******************************************************************************/
+
+BackgroundRequestChildBase::BackgroundRequestChildBase(
+    MovingNotNull<RefPtr<IDBRequest>> aRequest)
+    : mRequest(std::move(aRequest)) {
+  mRequest->AssertIsOnOwningThread();
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundRequestChildBase);
+}
+
+BackgroundRequestChildBase::~BackgroundRequestChildBase() {
+  AssertIsOnOwningThread();
+
+  MOZ_COUNT_DTOR(indexedDB::BackgroundRequestChildBase);
+}
+
+#ifdef DEBUG
+
+void BackgroundRequestChildBase::AssertIsOnOwningThread() const {
+  mRequest->AssertIsOnOwningThread();
+}
+
+#endif  // DEBUG
+
+/*******************************************************************************
+ * BackgroundFactoryChild
+ ******************************************************************************/
+
+BackgroundFactoryChild::BackgroundFactoryChild(IDBFactory& aFactory)
+    : mFactory(&aFactory) {
+  AssertIsOnOwningThread();
+  mFactory->AssertIsOnOwningThread();
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundFactoryChild);
+}
+
+BackgroundFactoryChild::~BackgroundFactoryChild() {
+  MOZ_COUNT_DTOR(indexedDB::BackgroundFactoryChild);
+}
+
+void BackgroundFactoryChild::SendDeleteMeInternal() {
+  AssertIsOnOwningThread();
+
+  if (mFactory) {
+    mFactory->ClearBackgroundActor();
+    mFactory = nullptr;
+
+    MOZ_ALWAYS_TRUE(PBackgroundIDBFactoryChild::SendDeleteMe());
+  }
+}
+
+void BackgroundFactoryChild::ActorDestroy(ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (mFactory) {
+    mFactory->ClearBackgroundActor();
+#ifdef DEBUG
+    mFactory = nullptr;
+#endif
+  }
+}
+
+PBackgroundIDBFactoryRequestChild*
+BackgroundFactoryChild::AllocPBackgroundIDBFactoryRequestChild(
+    const FactoryRequestParams& aParams) {
+  MOZ_CRASH(
+      "PBackgroundIDBFactoryRequestChild actors should be manually "
+      "constructed!");
+}
+
+bool BackgroundFactoryChild::DeallocPBackgroundIDBFactoryRequestChild(
+    PBackgroundIDBFactoryRequestChild* aActor) {
+  MOZ_ASSERT(aActor);
+
+  delete static_cast<BackgroundFactoryRequestChild*>(aActor);
+  return true;
+}
+
+PBackgroundIDBDatabaseChild*
+BackgroundFactoryChild::AllocPBackgroundIDBDatabaseChild(
+    const DatabaseSpec& aSpec,
+    PBackgroundIDBFactoryRequestChild* aRequest) const {
+  AssertIsOnOwningThread();
+
+  auto* const request = static_cast<BackgroundFactoryRequestChild*>(aRequest);
+  MOZ_ASSERT(request);
+
+  return new BackgroundDatabaseChild(aSpec, request);
+}
+
+bool BackgroundFactoryChild::DeallocPBackgroundIDBDatabaseChild(
+    PBackgroundIDBDatabaseChild* aActor) {
+  MOZ_ASSERT(aActor);
+
+  delete static_cast<BackgroundDatabaseChild*>(aActor);
+  return true;
+}
+
+mozilla::ipc::IPCResult
+BackgroundFactoryChild::RecvPBackgroundIDBDatabaseConstructor(
+    PBackgroundIDBDatabaseChild* aActor, const DatabaseSpec& aSpec,
+    NotNull<PBackgroundIDBFactoryRequestChild*> aRequest) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aActor);
+
+  return IPC_OK();
+}
+
+/*******************************************************************************
+ * BackgroundFactoryRequestChild
+ ******************************************************************************/
+
+BackgroundFactoryRequestChild::BackgroundFactoryRequestChild(
+    SafeRefPtr<IDBFactory> aFactory,
+    MovingNotNull<RefPtr<IDBOpenDBRequest>> aOpenRequest, bool aIsDeleteOp,
+    uint64_t aRequestedVersion)
+    : BackgroundRequestChildBase(std::move(aOpenRequest)),
+      mFactory(std::move(aFactory)),
+      mDatabaseActor(nullptr),
+      mRequestedVersion(aRequestedVersion),
+      mIsDeleteOp(aIsDeleteOp) {
+  // Can't assert owning thread here because IPDL has not yet set our manager!
+  MOZ_ASSERT(mFactory);
+  mFactory->AssertIsOnOwningThread();
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundFactoryRequestChild);
+}
+
+BackgroundFactoryRequestChild::~BackgroundFactoryRequestChild() {
+  MOZ_COUNT_DTOR(indexedDB::BackgroundFactoryRequestChild);
+}
+
+NotNull<IDBOpenDBRequest*> BackgroundFactoryRequestChild::GetOpenDBRequest()
+    const {
+  AssertIsOnOwningThread();
+
+  // XXX NotNull might provide something to encapsulate this
+  return WrapNotNullUnchecked(
+      static_cast<IDBOpenDBRequest*>(mRequest.get().get()));
+}
+
+void BackgroundFactoryRequestChild::SetDatabaseActor(
+    BackgroundDatabaseChild* aActor) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(!aActor || !mDatabaseActor);
+
+  mDatabaseActor = aActor;
+}
+
+void BackgroundFactoryRequestChild::HandleResponse(nsresult aResponse) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(NS_FAILED(aResponse));
+  MOZ_ASSERT(NS_ERROR_GET_MODULE(aResponse) == NS_ERROR_MODULE_DOM_INDEXEDDB);
+
+  mRequest->Reset();
+
+  DispatchErrorEvent(mRequest, aResponse);
+
+  if (mDatabaseActor) {
+    mDatabaseActor->ReleaseDOMObject();
+    MOZ_ASSERT(!mDatabaseActor);
+  }
+}
+
+void BackgroundFactoryRequestChild::HandleResponse(
+    const OpenDatabaseRequestResponse& aResponse) {
+  AssertIsOnOwningThread();
+
+  mRequest->Reset();
+
+  auto* databaseActor = static_cast<BackgroundDatabaseChild*>(
+      aResponse.database().AsChild().get());
+  MOZ_ASSERT(databaseActor);
+
+  IDBDatabase* const database = [this, databaseActor]() -> IDBDatabase* {
+    IDBDatabase* database = databaseActor->GetDOMObject();
+    if (!database) {
+      Unused << this;
+
+      if (NS_WARN_IF(!databaseActor->EnsureDOMObject())) {
+        return nullptr;
+      }
+      MOZ_ASSERT(mDatabaseActor);
+
+      database = databaseActor->GetDOMObject();
+      MOZ_ASSERT(database);
+
+      MOZ_ASSERT(!database->IsClosed());
+    }
+
+    return database;
+  }();
+
+  if (!database || database->IsClosed()) {
+    // If the database was closed already, which is only possible if we fired an
+    // "upgradeneeded" event, then we shouldn't fire a "success" event here.
+    // Instead we fire an error event with AbortErr.
+    DispatchErrorEvent(mRequest, NS_ERROR_DOM_INDEXEDDB_ABORT_ERR);
+  } else {
+    SetResultAndDispatchSuccessEvent(mRequest, nullptr, *database);
+  }
+
+  if (database) {
+    MOZ_ASSERT(mDatabaseActor == databaseActor);
+
+    databaseActor->ReleaseDOMObject();
+  } else {
+    databaseActor->SendDeleteMeInternal();
+  }
+  MOZ_ASSERT(!mDatabaseActor);
+}
+
+void BackgroundFactoryRequestChild::HandleResponse(
+    const DeleteDatabaseRequestResponse& aResponse) {
+  AssertIsOnOwningThread();
+
+  RefPtr<Event> successEvent = IDBVersionChangeEvent::Create(
+      mRequest.get(), nsDependentString(kSuccessEventType),
+      aResponse.previousVersion());
+  MOZ_ASSERT(successEvent);
+
+  SetResultAndDispatchSuccessEvent(mRequest, nullptr, JS::UndefinedHandleValue,
+                                   std::move(successEvent));
+
+  MOZ_ASSERT(!mDatabaseActor);
+}
+
+void BackgroundFactoryRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (aWhy != Deletion) {
+    GetOpenDBRequest()->NoteComplete();
+  }
+}
+
+mozilla::ipc::IPCResult BackgroundFactoryRequestChild::Recv__delete__(
+    const FactoryRequestResponse& aResponse) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  switch (aResponse.type()) {
+    case FactoryRequestResponse::Tnsresult:
+      HandleResponse(aResponse.get_nsresult());
+      break;
+
+    case FactoryRequestResponse::TOpenDatabaseRequestResponse:
+      HandleResponse(aResponse.get_OpenDatabaseRequestResponse());
+      break;
+
+    case FactoryRequestResponse::TDeleteDatabaseRequestResponse:
+      HandleResponse(aResponse.get_DeleteDatabaseRequestResponse());
+      break;
+
+    default:
+      return IPC_FAIL(this, "Unknown response type!");
+  }
+
+  auto request = GetOpenDBRequest();
+  request->NoteComplete();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BackgroundFactoryRequestChild::RecvBlocked(
+    const uint64_t aCurrentVersion) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  const nsDependentString type(kBlockedEventType);
+
+  RefPtr<Event> blockedEvent;
+  if (mIsDeleteOp) {
+    blockedEvent =
+        IDBVersionChangeEvent::Create(mRequest.get(), type, aCurrentVersion);
+    MOZ_ASSERT(blockedEvent);
+  } else {
+    blockedEvent = IDBVersionChangeEvent::Create(
+        mRequest.get(), type, aCurrentVersion, mRequestedVersion);
+    MOZ_ASSERT(blockedEvent);
+  }
+
+  RefPtr<IDBRequest> kungFuDeathGrip = mRequest;
+
+  IDB_LOG_MARK_CHILD_REQUEST("Firing \"blocked\" event", "\"blocked\"",
+                             kungFuDeathGrip->LoggingSerialNumber());
+
+  IgnoredErrorResult rv;
+  kungFuDeathGrip->DispatchEvent(*blockedEvent, rv);
+  if (rv.Failed()) {
+    NS_WARNING("Failed to dispatch event!");
+  }
+
+  return IPC_OK();
+}
+
+/*******************************************************************************
+ * BackgroundDatabaseChild
+ ******************************************************************************/
+
+BackgroundDatabaseChild::BackgroundDatabaseChild(
+    const DatabaseSpec& aSpec, BackgroundFactoryRequestChild* aOpenRequestActor)
+    : mSpec(MakeUnique<DatabaseSpec>(aSpec)),
+      mOpenRequestActor(aOpenRequestActor),
+      mDatabase(nullptr) {
+  // Can't assert owning thread here because IPDL has not yet set our manager!
+  MOZ_ASSERT(aOpenRequestActor);
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundDatabaseChild);
+}
+
+BackgroundDatabaseChild::~BackgroundDatabaseChild() {
+  MOZ_COUNT_DTOR(indexedDB::BackgroundDatabaseChild);
+}
+
+#ifdef DEBUG
+
+void BackgroundDatabaseChild::AssertIsOnOwningThread() const {
+  static_cast<BackgroundFactoryChild*>(Manager())->AssertIsOnOwningThread();
+}
+
+#endif  // DEBUG
+
+void BackgroundDatabaseChild::SendDeleteMeInternal() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(!mTemporaryStrongDatabase);
+  MOZ_ASSERT(!mOpenRequestActor);
+
+  if (mDatabase) {
+    mDatabase->ClearBackgroundActor();
+    mDatabase = nullptr;
+
+    MOZ_ALWAYS_TRUE(PBackgroundIDBDatabaseChild::SendDeleteMe());
+  }
+}
+
+bool BackgroundDatabaseChild::EnsureDOMObject() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mOpenRequestActor);
+
+  if (mTemporaryStrongDatabase) {
+    MOZ_ASSERT(!mSpec);
+    MOZ_ASSERT(mDatabase == mTemporaryStrongDatabase);
+    return true;
+  }
+
+  MOZ_ASSERT(mSpec);
+
+  const auto request = mOpenRequestActor->GetOpenDBRequest();
+
+  auto& factory =
+      static_cast<BackgroundFactoryChild*>(Manager())->GetDOMObject();
+
+  if (!factory.GetParentObject()) {
+    // Already disconnected from global.
+
+    // We need to clear mOpenRequestActor here, since that would otherwise be
+    // done by ReleaseDOMObject, which cannot be called if EnsureDOMObject
+    // failed.
+    mOpenRequestActor = nullptr;
+
+    return false;
+  }
+
+  // TODO: This AcquireStrongRefFromRawPtr looks suspicious. This should be
+  // changed or at least well explained, see also comment on
+  // BackgroundFactoryChild.
+  mTemporaryStrongDatabase = IDBDatabase::Create(
+      request, SafeRefPtr{&factory, AcquireStrongRefFromRawPtr{}}, this,
+      std::move(mSpec));
+
+  MOZ_ASSERT(mTemporaryStrongDatabase);
+  mTemporaryStrongDatabase->AssertIsOnOwningThread();
+
+  mDatabase = mTemporaryStrongDatabase;
+
+  mOpenRequestActor->SetDatabaseActor(this);
+
+  return true;
+}
+
+void BackgroundDatabaseChild::ReleaseDOMObject() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mTemporaryStrongDatabase);
+  mTemporaryStrongDatabase->AssertIsOnOwningThread();
+  MOZ_ASSERT(mOpenRequestActor);
+  MOZ_ASSERT(mDatabase == mTemporaryStrongDatabase);
+
+  mOpenRequestActor->SetDatabaseActor(nullptr);
+
+  mOpenRequestActor = nullptr;
+
+  // This may be the final reference to the IDBDatabase object so we may end up
+  // calling SendDeleteMeInternal() here. Make sure everything is cleaned up
+  // properly before proceeding.
+  mTemporaryStrongDatabase = nullptr;
+
+  // XXX Why isn't mDatabase set to nullptr here?
+}
+
+void BackgroundDatabaseChild::ActorDestroy(ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (mDatabase) {
+    mDatabase->ClearBackgroundActor();
+#ifdef DEBUG
+    mDatabase = nullptr;
+#endif
+  }
+}
+
+PBackgroundIDBDatabaseFileChild*
+BackgroundDatabaseChild::AllocPBackgroundIDBDatabaseFileChild(
+    const IPCBlob& aIPCBlob) {
+  MOZ_CRASH("PBackgroundIDBFileChild actors should be manually constructed!");
+}
+
+bool BackgroundDatabaseChild::DeallocPBackgroundIDBDatabaseFileChild(
+    PBackgroundIDBDatabaseFileChild* aActor) const {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aActor);
+
+  delete aActor;
+  return true;
+}
+
+already_AddRefed<PBackgroundIDBVersionChangeTransactionChild>
+BackgroundDatabaseChild::AllocPBackgroundIDBVersionChangeTransactionChild(
+    const uint64_t aCurrentVersion, const uint64_t aRequestedVersion,
+    const int64_t aNextObjectStoreId, const int64_t aNextIndexId) {
+  AssertIsOnOwningThread();
+
+  return RefPtr{new BackgroundVersionChangeTransactionChild(
+                    mOpenRequestActor->GetOpenDBRequest())}
+      .forget();
+}
+
+mozilla::ipc::IPCResult
+BackgroundDatabaseChild::RecvPBackgroundIDBVersionChangeTransactionConstructor(
+    PBackgroundIDBVersionChangeTransactionChild* aActor,
+    const uint64_t& aCurrentVersion, const uint64_t& aRequestedVersion,
+    const int64_t& aNextObjectStoreId, const int64_t& aNextIndexId) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aActor);
+  MOZ_ASSERT(mOpenRequestActor);
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  auto* const actor =
+      static_cast<BackgroundVersionChangeTransactionChild*>(aActor);
+
+  if (!EnsureDOMObject()) {
+    NS_WARNING("Factory is already disconnected from global");
+
+    actor->SendDeleteMeInternal(true);
+
+    // XXX This is a hack to ensure that transaction/request serial numbers stay
+    // in sync between parent and child. Actually, it might be better to create
+    // an IDBTransaction in the child and abort that.
+    Unused
+        << mozilla::ipc::BackgroundChildImpl::GetThreadLocalForCurrentThread()
+               ->mIndexedDBThreadLocal->NextTransactionSN(
+                   IDBTransaction::Mode::VersionChange);
+    Unused << IDBRequest::NextSerialNumber();
+
+    // No reason to IPC_FAIL here.
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(!mDatabase->IsInvalidated());
+
+  // XXX NotNull might encapsulate this
+  const auto request =
+      WrapNotNullUnchecked(RefPtr{mOpenRequestActor->GetOpenDBRequest().get()});
+
+  SafeRefPtr<IDBTransaction> transaction = IDBTransaction::CreateVersionChange(
+      mDatabase, actor, request, aNextObjectStoreId, aNextIndexId);
+  MOZ_ASSERT(transaction);
+
+  transaction->AssertIsOnOwningThread();
+
+  actor->SetDOMTransaction(transaction.clonePtr());
+
+  const auto database = WrapNotNull(mDatabase);
+
+  database->EnterSetVersionTransaction(aRequestedVersion);
+
+  request->SetTransaction(transaction.clonePtr());
+
+  RefPtr<Event> upgradeNeededEvent = IDBVersionChangeEvent::Create(
+      request.get(), nsDependentString(kUpgradeNeededEventType),
+      aCurrentVersion, aRequestedVersion);
+  MOZ_ASSERT(upgradeNeededEvent);
+
+  SetResultAndDispatchSuccessEvent(
+      WrapNotNullUnchecked<RefPtr<IDBRequest>>(request.get()), transaction,
+      *database, std::move(upgradeNeededEvent));
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BackgroundDatabaseChild::RecvVersionChange(
+    const uint64_t aOldVersion, const Maybe<uint64_t> aNewVersion) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (!mDatabase || mDatabase->IsClosed()) {
+    return IPC_OK();
+  }
+
+  RefPtr<IDBDatabase> kungFuDeathGrip = mDatabase;
+
+  // Handle bfcache'd windows.
+  if (nsPIDOMWindowInner* owner = kungFuDeathGrip->GetOwner()) {
+    // The database must be closed if the window is already frozen.
+    bool shouldAbortAndClose = owner->IsFrozen();
+
+    // Anything in the bfcache has to be evicted and then we have to close the
+    // database also.
+    if (owner->RemoveFromBFCacheSync()) {
+      shouldAbortAndClose = true;
+    }
+
+    if (shouldAbortAndClose) {
+      // Invalidate() doesn't close the database in the parent, so we have
+      // to call Close() and AbortTransactions() manually.
+      kungFuDeathGrip->AbortTransactions(/* aShouldWarn */ false);
+      kungFuDeathGrip->Close();
+      return IPC_OK();
+    }
+  }
+
+  // Otherwise fire a versionchange event.
+  const nsDependentString type(kVersionChangeEventType);
+
+  RefPtr<Event> versionChangeEvent;
+
+  if (aNewVersion.isNothing()) {
+    versionChangeEvent =
+        IDBVersionChangeEvent::Create(kungFuDeathGrip, type, aOldVersion);
+    MOZ_ASSERT(versionChangeEvent);
+  } else {
+    versionChangeEvent = IDBVersionChangeEvent::Create(
+        kungFuDeathGrip, type, aOldVersion, aNewVersion.value());
+    MOZ_ASSERT(versionChangeEvent);
+  }
+
+  IDB_LOG_MARK("Child : Firing \"versionchange\" event",
+               "C: IDBDatabase \"versionchange\" event", IDB_LOG_ID_STRING());
+
+  IgnoredErrorResult rv;
+  kungFuDeathGrip->DispatchEvent(*versionChangeEvent, rv);
+  if (rv.Failed()) {
+    NS_WARNING("Failed to dispatch event!");
+  }
+
+  if (!kungFuDeathGrip->IsClosed()) {
+    SendBlocked();
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BackgroundDatabaseChild::RecvInvalidate() {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (mDatabase) {
+    mDatabase->Invalidate();
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+BackgroundDatabaseChild::RecvCloseAfterInvalidationComplete() {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (mDatabase) {
+    mDatabase->DispatchTrustedEvent(nsDependentString(kCloseEventType));
+  }
+
+  return IPC_OK();
+}
+
+/*******************************************************************************
+ * BackgroundTransactionBase
+ ******************************************************************************/
+
+BackgroundTransactionBase::BackgroundTransactionBase(
+    SafeRefPtr<IDBTransaction> aTransaction)
+    : mTemporaryStrongTransaction(std::move(aTransaction)),
+      mTransaction(mTemporaryStrongTransaction.unsafeGetRawPtr()) {
+  MOZ_ASSERT(mTransaction);
+  mTransaction->AssertIsOnOwningThread();
+
+  MOZ_COUNT_CTOR(BackgroundTransactionBase);
+}
+
+#ifdef DEBUG
+
+void BackgroundTransactionBase::AssertIsOnOwningThread() const {
+  MOZ_ASSERT(mTransaction);
+  mTransaction->AssertIsOnOwningThread();
+}
+
+#endif  // DEBUG
+
+void BackgroundTransactionBase::NoteActorDestroyed() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT_IF(mTemporaryStrongTransaction, mTransaction);
+
+  if (mTransaction) {
+    mTransaction->ClearBackgroundActor();
+
+    // Normally this would be DEBUG-only but NoteActorDestroyed is also called
+    // from SendDeleteMeInternal. In that case we're going to receive an actual
+    // ActorDestroy call later and we don't want to touch a dead object.
+    mTemporaryStrongTransaction = nullptr;
+    mTransaction = nullptr;
+  }
+}
+
+void BackgroundTransactionBase::SetDOMTransaction(
+    SafeRefPtr<IDBTransaction> aTransaction) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aTransaction);
+  aTransaction->AssertIsOnOwningThread();
+  MOZ_ASSERT(!mTemporaryStrongTransaction);
+  MOZ_ASSERT(!mTransaction);
+
+  mTemporaryStrongTransaction = std::move(aTransaction);
+  mTransaction = mTemporaryStrongTransaction.unsafeGetRawPtr();
+}
+
+void BackgroundTransactionBase::NoteComplete() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT_IF(mTransaction, mTemporaryStrongTransaction);
+
+  mTemporaryStrongTransaction = nullptr;
+}
+
+/*******************************************************************************
+ * BackgroundTransactionChild
+ ******************************************************************************/
+
+BackgroundTransactionChild::BackgroundTransactionChild(
+    SafeRefPtr<IDBTransaction> aTransaction)
+    : BackgroundTransactionBase(std::move(aTransaction)) {
+  MOZ_COUNT_CTOR(indexedDB::BackgroundTransactionChild);
+}
+
+BackgroundTransactionChild::~BackgroundTransactionChild() {
+  MOZ_COUNT_DTOR(indexedDB::BackgroundTransactionChild);
+}
+
+#ifdef DEBUG
+
+void BackgroundTransactionChild::AssertIsOnOwningThread() const {
+  static_cast<BackgroundDatabaseChild*>(Manager())->AssertIsOnOwningThread();
+}
+
+#endif  // DEBUG
+
+void BackgroundTransactionChild::SendDeleteMeInternal() {
+  AssertIsOnOwningThread();
+
+  if (mTransaction) {
+    NoteActorDestroyed();
+
+    MOZ_ALWAYS_TRUE(PBackgroundIDBTransactionChild::SendDeleteMe());
+  }
+}
+
+void BackgroundTransactionChild::ActorDestroy(ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  NoteActorDestroyed();
+}
+
+mozilla::ipc::IPCResult BackgroundTransactionChild::RecvComplete(
+    const nsresult aResult) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mTransaction);
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  mTransaction->FireCompleteOrAbortEvents(aResult);
+
+  NoteComplete();
+  return IPC_OK();
+}
+
+PBackgroundIDBRequestChild*
+BackgroundTransactionChild::AllocPBackgroundIDBRequestChild(
+    const RequestParams& aParams) {
+  MOZ_CRASH(
+      "PBackgroundIDBRequestChild actors should be manually "
+      "constructed!");
+}
+
+bool BackgroundTransactionChild::DeallocPBackgroundIDBRequestChild(
+    PBackgroundIDBRequestChild* aActor) {
+  MOZ_ASSERT(aActor);
+
+  delete static_cast<BackgroundRequestChild*>(aActor);
+  return true;
+}
+
+PBackgroundIDBCursorChild*
+BackgroundTransactionChild::AllocPBackgroundIDBCursorChild(
+    const OpenCursorParams& aParams) {
+  AssertIsOnOwningThread();
+
+  MOZ_CRASH("PBackgroundIDBCursorChild actors should be manually constructed!");
+}
+
+bool BackgroundTransactionChild::DeallocPBackgroundIDBCursorChild(
+    PBackgroundIDBCursorChild* aActor) {
+  MOZ_ASSERT(aActor);
+
+  delete aActor;
+  return true;
+}
+
+/*******************************************************************************
+ * BackgroundVersionChangeTransactionChild
+ ******************************************************************************/
+
+BackgroundVersionChangeTransactionChild::
+    BackgroundVersionChangeTransactionChild(IDBOpenDBRequest* aOpenDBRequest)
+    : mOpenDBRequest(aOpenDBRequest) {
+  MOZ_ASSERT(aOpenDBRequest);
+  aOpenDBRequest->AssertIsOnOwningThread();
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundVersionChangeTransactionChild);
+}
+
+BackgroundVersionChangeTransactionChild::
+    ~BackgroundVersionChangeTransactionChild() {
+  AssertIsOnOwningThread();
+
+  MOZ_COUNT_DTOR(indexedDB::BackgroundVersionChangeTransactionChild);
+}
+
+#ifdef DEBUG
+
+void BackgroundVersionChangeTransactionChild::AssertIsOnOwningThread() const {
+  static_cast<BackgroundDatabaseChild*>(Manager())->AssertIsOnOwningThread();
+}
+
+#endif  // DEBUG
+
+void BackgroundVersionChangeTransactionChild::SendDeleteMeInternal(
+    bool aFailedConstructor) {
+  AssertIsOnOwningThread();
+
+  if (mTransaction || aFailedConstructor) {
+    NoteActorDestroyed();
+
+    MOZ_ALWAYS_TRUE(
+        PBackgroundIDBVersionChangeTransactionChild::SendDeleteMe());
+  }
+}
+
+void BackgroundVersionChangeTransactionChild::ActorDestroy(
+    ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  mOpenDBRequest = nullptr;
+
+  NoteActorDestroyed();
+}
+
+mozilla::ipc::IPCResult BackgroundVersionChangeTransactionChild::RecvComplete(
+    const nsresult aResult) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (!mTransaction) {
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(mOpenDBRequest);
+
+  IDBDatabase* database = mTransaction->Database();
+  MOZ_ASSERT(database);
+
+  database->ExitSetVersionTransaction();
+
+  if (NS_FAILED(aResult)) {
+    database->Close();
+  }
+
+  RefPtr<IDBOpenDBRequest> request = mOpenDBRequest;
+  MOZ_ASSERT(request);
+
+  mTransaction->FireCompleteOrAbortEvents(aResult);
+
+  request->SetTransaction(nullptr);
+  request = nullptr;
+
+  mOpenDBRequest = nullptr;
+
+  NoteComplete();
+  return IPC_OK();
+}
+
+PBackgroundIDBRequestChild*
+BackgroundVersionChangeTransactionChild::AllocPBackgroundIDBRequestChild(
+    const RequestParams& aParams) {
+  MOZ_CRASH(
+      "PBackgroundIDBRequestChild actors should be manually "
+      "constructed!");
+}
+
+bool BackgroundVersionChangeTransactionChild::DeallocPBackgroundIDBRequestChild(
+    PBackgroundIDBRequestChild* aActor) {
+  MOZ_ASSERT(aActor);
+
+  delete static_cast<BackgroundRequestChild*>(aActor);
+  return true;
+}
+
+PBackgroundIDBCursorChild*
+BackgroundVersionChangeTransactionChild::AllocPBackgroundIDBCursorChild(
+    const OpenCursorParams& aParams) {
+  AssertIsOnOwningThread();
+
+  MOZ_CRASH("PBackgroundIDBCursorChild actors should be manually constructed!");
+}
+
+bool BackgroundVersionChangeTransactionChild::DeallocPBackgroundIDBCursorChild(
+    PBackgroundIDBCursorChild* aActor) {
+  MOZ_ASSERT(aActor);
+
+  delete aActor;
+  return true;
+}
+
+/*******************************************************************************
+ * BackgroundRequestChild
+ ******************************************************************************/
+
+BackgroundRequestChild::BackgroundRequestChild(
+    MovingNotNull<RefPtr<IDBRequest>> aRequest)
+    : BackgroundRequestChildBase(std::move(aRequest)),
+      mTransaction(mRequest->AcquireTransaction()),
+      mRunningPreprocessHelpers(0),
+      mCurrentCloneDataIndex(0),
+      mPreprocessResultCode(NS_OK),
+      mGetAll(false) {
+  MOZ_ASSERT(mTransaction);
+  mTransaction->AssertIsOnOwningThread();
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundRequestChild);
+}
+
+BackgroundRequestChild::~BackgroundRequestChild() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(!mTransaction);
+
+  MOZ_COUNT_DTOR(indexedDB::BackgroundRequestChild);
+}
+
+void BackgroundRequestChild::MaybeSendContinue() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mRunningPreprocessHelpers > 0);
+
+  if (--mRunningPreprocessHelpers == 0) {
+    PreprocessResponse response;
+
+    if (NS_SUCCEEDED(mPreprocessResultCode)) {
+      if (mGetAll) {
+        response = ObjectStoreGetAllPreprocessResponse();
+      } else {
+        response = ObjectStoreGetPreprocessResponse();
+      }
+    } else {
+      response = mPreprocessResultCode;
+    }
+
+    MOZ_ALWAYS_TRUE(SendContinue(response));
+  }
+}
+
+void BackgroundRequestChild::OnPreprocessFinished(
+    uint32_t aCloneDataIndex, UniquePtr<JSStructuredCloneData> aCloneData) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aCloneDataIndex < mCloneInfos.Length());
+  MOZ_ASSERT(aCloneData);
+
+  auto& cloneInfo = mCloneInfos[aCloneDataIndex];
+  MOZ_ASSERT(cloneInfo.mPreprocessHelper);
+  MOZ_ASSERT(!cloneInfo.mCloneData);
+
+  cloneInfo.mCloneData = std::move(aCloneData);
+
+  MaybeSendContinue();
+
+  cloneInfo.mPreprocessHelper = nullptr;
+}
+
+void BackgroundRequestChild::OnPreprocessFailed(uint32_t aCloneDataIndex,
+                                                nsresult aErrorCode) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aCloneDataIndex < mCloneInfos.Length());
+  MOZ_ASSERT(NS_FAILED(aErrorCode));
+
+  auto& cloneInfo = mCloneInfos[aCloneDataIndex];
+  MOZ_ASSERT(cloneInfo.mPreprocessHelper);
+  MOZ_ASSERT(!cloneInfo.mCloneData);
+
+  if (NS_SUCCEEDED(mPreprocessResultCode)) {
+    mPreprocessResultCode = aErrorCode;
+  }
+
+  MaybeSendContinue();
+
+  cloneInfo.mPreprocessHelper = nullptr;
+}
+
+UniquePtr<JSStructuredCloneData> BackgroundRequestChild::GetNextCloneData() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mCurrentCloneDataIndex < mCloneInfos.Length());
+  MOZ_ASSERT(mCloneInfos[mCurrentCloneDataIndex].mCloneData);
+
+  return std::move(mCloneInfos[mCurrentCloneDataIndex++].mCloneData);
+}
+
+void BackgroundRequestChild::HandleResponse(nsresult aResponse) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(NS_FAILED(aResponse));
+  MOZ_ASSERT(NS_ERROR_GET_MODULE(aResponse) == NS_ERROR_MODULE_DOM_INDEXEDDB);
+  MOZ_ASSERT(mTransaction);
+
+  DispatchErrorEvent(mRequest, aResponse, mTransaction.clonePtr());
+}
+
+void BackgroundRequestChild::HandleResponse(const Key& aResponse) {
+  AssertIsOnOwningThread();
+
+  SetResultAndDispatchSuccessEvent(mRequest, AcquireTransaction(), aResponse);
+}
+
+void BackgroundRequestChild::HandleResponse(const nsTArray<Key>& aResponse) {
+  AssertIsOnOwningThread();
+
+  SetResultAndDispatchSuccessEvent(mRequest, AcquireTransaction(), aResponse);
+}
+
+void BackgroundRequestChild::HandleResponse(
+    SerializedStructuredCloneReadInfo&& aResponse) {
+  AssertIsOnOwningThread();
+
+  auto cloneReadInfo = DeserializeStructuredCloneReadInfo(
+      std::move(aResponse), mTransaction->Database(),
+      [this] { return std::move(*GetNextCloneData()); });
+
+  SetResultAndDispatchSuccessEvent(mRequest, AcquireTransaction(),
+                                   cloneReadInfo);
+}
+
+void BackgroundRequestChild::HandleResponse(
+    nsTArray<SerializedStructuredCloneReadInfo>&& aResponse) {
+  AssertIsOnOwningThread();
+
+  nsTArray<StructuredCloneReadInfoChild> cloneReadInfos;
+
+  QM_TRY(OkIf(cloneReadInfos.SetCapacity(aResponse.Length(), fallible)),
+         QM_VOID, ([&aResponse, this](const auto) {
+           // Since we are under memory pressure, release aResponse early.
+           aResponse.Clear();
+
+           DispatchErrorEvent(mRequest, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR,
+                              AcquireTransaction());
+
+           MOZ_ASSERT(mTransaction->IsAborted());
+         }));
+
+  std::transform(std::make_move_iterator(aResponse.begin()),
+                 std::make_move_iterator(aResponse.end()),
+                 MakeBackInserter(cloneReadInfos),
+                 [database = mTransaction->Database(), this](
+                     SerializedStructuredCloneReadInfo&& serializedCloneInfo) {
+                   return DeserializeStructuredCloneReadInfo(
+                       std::move(serializedCloneInfo), database,
+                       [this] { return std::move(*GetNextCloneData()); });
+                 });
+
+  SetResultAndDispatchSuccessEvent(mRequest, AcquireTransaction(),
+                                   cloneReadInfos);
+}
+
+void BackgroundRequestChild::HandleResponse(JS::Handle<JS::Value> aResponse) {
+  AssertIsOnOwningThread();
+
+  SetResultAndDispatchSuccessEvent(
+      mRequest, AcquireTransaction(),
+      const_cast<const JS::Handle<JS::Value>&>(aResponse));
+}
+
+void BackgroundRequestChild::HandleResponse(const uint64_t aResponse) {
+  AssertIsOnOwningThread();
+
+  SetResultAndDispatchSuccessEvent(mRequest, AcquireTransaction(), aResponse);
+}
+
+nsresult BackgroundRequestChild::HandlePreprocess(
+    const PreprocessInfo& aPreprocessInfo) {
+  return HandlePreprocessInternal(
+      AutoTArray<PreprocessInfo, 1>{aPreprocessInfo});
+}
+
+nsresult BackgroundRequestChild::HandlePreprocess(
+    const nsTArray<PreprocessInfo>& aPreprocessInfos) {
+  AssertIsOnOwningThread();
+  mGetAll = true;
+
+  return HandlePreprocessInternal(aPreprocessInfos);
+}
+
+nsresult BackgroundRequestChild::HandlePreprocessInternal(
+    const nsTArray<PreprocessInfo>& aPreprocessInfos) {
+  AssertIsOnOwningThread();
+
+  IDBDatabase* database = mTransaction->Database();
+
+  const uint32_t count = aPreprocessInfos.Length();
+
+  mCloneInfos.SetLength(count);
+
+  // TODO: Since we use the stream transport service, this can spawn 25 threads
+  //       and has the potential to cause some annoying browser hiccups.
+  //       Consider using a single thread or a very small threadpool.
+  for (uint32_t index = 0; index < count; index++) {
+    const PreprocessInfo& preprocessInfo = aPreprocessInfos[index];
+
+    const auto files =
+        DeserializeStructuredCloneFiles(database, preprocessInfo.files(),
+                                        /* aForPreprocess */ true);
+
+    MOZ_ASSERT(files.Length() == 1);
+
+    auto& preprocessHelper = mCloneInfos[index].mPreprocessHelper;
+    preprocessHelper = MakeRefPtr<PreprocessHelper>(index, this);
+
+    nsresult rv = preprocessHelper->Init(files[0]);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = preprocessHelper->Dispatch();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    mRunningPreprocessHelpers++;
+  }
+
+  return NS_OK;
+}
+
+void BackgroundRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  for (auto& cloneInfo : mCloneInfos) {
+    const auto& preprocessHelper = cloneInfo.mPreprocessHelper;
+
+    if (preprocessHelper) {
+      preprocessHelper->ClearActor();
+    }
+  }
+  mCloneInfos.Clear();
+
+  if (mTransaction) {
+    mTransaction->AssertIsOnOwningThread();
+
+    mTransaction->OnRequestFinished(/* aRequestCompletedSuccessfully */
+                                    aWhy == Deletion);
+#ifdef DEBUG
+    mTransaction = nullptr;
+#endif
+  }
+}
+
+mozilla::ipc::IPCResult BackgroundRequestChild::Recv__delete__(
+    RequestResponse&& aResponse) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mTransaction);
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (mTransaction->IsAborted()) {
+    // Always fire an "error" event with ABORT_ERR if the transaction was
+    // aborted, even if the request succeeded or failed with another error.
+    HandleResponse(NS_ERROR_DOM_INDEXEDDB_ABORT_ERR);
+  } else {
+    switch (aResponse.type()) {
+      case RequestResponse::Tnsresult:
+        HandleResponse(aResponse.get_nsresult());
+        break;
+
+      case RequestResponse::TObjectStoreAddResponse:
+        HandleResponse(aResponse.get_ObjectStoreAddResponse().key());
+        break;
+
+      case RequestResponse::TObjectStorePutResponse:
+        HandleResponse(aResponse.get_ObjectStorePutResponse().key());
+        break;
+
+      case RequestResponse::TObjectStoreGetResponse:
+        HandleResponse(
+            std::move(aResponse.get_ObjectStoreGetResponse().cloneInfo()));
+        break;
+
+      case RequestResponse::TObjectStoreGetKeyResponse:
+        HandleResponse(aResponse.get_ObjectStoreGetKeyResponse().key());
+        break;
+
+      case RequestResponse::TObjectStoreGetAllResponse:
+        HandleResponse(
+            std::move(aResponse.get_ObjectStoreGetAllResponse().cloneInfos()));
+        break;
+
+      case RequestResponse::TObjectStoreGetAllKeysResponse:
+        HandleResponse(aResponse.get_ObjectStoreGetAllKeysResponse().keys());
+        break;
+
+      case RequestResponse::TObjectStoreDeleteResponse:
+      case RequestResponse::TObjectStoreClearResponse:
+        HandleResponse(JS::UndefinedHandleValue);
+        break;
+
+      case RequestResponse::TObjectStoreCountResponse:
+        HandleResponse(aResponse.get_ObjectStoreCountResponse().count());
+        break;
+
+      case RequestResponse::TIndexGetResponse:
+        HandleResponse(std::move(aResponse.get_IndexGetResponse().cloneInfo()));
+        break;
+
+      case RequestResponse::TIndexGetKeyResponse:
+        HandleResponse(aResponse.get_IndexGetKeyResponse().key());
+        break;
+
+      case RequestResponse::TIndexGetAllResponse:
+        HandleResponse(
+            std::move(aResponse.get_IndexGetAllResponse().cloneInfos()));
+        break;
+
+      case RequestResponse::TIndexGetAllKeysResponse:
+        HandleResponse(aResponse.get_IndexGetAllKeysResponse().keys());
+        break;
+
+      case RequestResponse::TIndexCountResponse:
+        HandleResponse(aResponse.get_IndexCountResponse().count());
+        break;
+
+      default:
+        return IPC_FAIL(this, "Unknown response type!");
+    }
+  }
+
+  mTransaction->OnRequestFinished(/* aRequestCompletedSuccessfully */ true);
+
+  // Null this out so that we don't try to call OnRequestFinished() again in
+  // ActorDestroy.
+  mTransaction = nullptr;
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BackgroundRequestChild::RecvPreprocess(
+    const PreprocessParams& aParams) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mTransaction);
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  nsresult rv;
+
+  switch (aParams.type()) {
+    case PreprocessParams::TObjectStoreGetPreprocessParams: {
+      const auto& params = aParams.get_ObjectStoreGetPreprocessParams();
+
+      rv = HandlePreprocess(params.preprocessInfo());
+
+      break;
+    }
+
+    case PreprocessParams::TObjectStoreGetAllPreprocessParams: {
+      const auto& params = aParams.get_ObjectStoreGetAllPreprocessParams();
+
+      rv = HandlePreprocess(params.preprocessInfos());
+
+      break;
+    }
+
+    default:
+      return IPC_FAIL(this, "Unknown params type!");
+  }
+
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    QM_WARNONLY_TRY(OkIf(SendContinue(rv)));
+  }
+
+  return IPC_OK();
+}
+
+nsresult BackgroundRequestChild::PreprocessHelper::Init(
+    const StructuredCloneFileChild& aFile) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aFile.HasBlob());
+  MOZ_ASSERT(aFile.Type() == StructuredCloneFileBase::eStructuredClone);
+  MOZ_ASSERT(mState == State::Initial);
+
+  // The stream transport service is used for asynchronous processing. It has a
+  // threadpool with a high cap of 25 threads. Fortunately, the service can be
+  // used on workers too.
+  nsCOMPtr<nsIEventTarget> target =
+      do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
+  MOZ_ASSERT(target);
+
+  // We use a TaskQueue here in order to be sure that the events are dispatched
+  // in the correct order. This is not guaranteed in case we use the I/O thread
+  // directly.
+  mTaskQueue = TaskQueue::Create(target.forget(), "BackgroundRequestChild");
+
+  ErrorResult errorResult;
+
+  nsCOMPtr<nsIInputStream> stream;
+  // XXX After Bug 1620560, MutableBlob is not needed here anymore.
+  aFile.MutableBlob().CreateInputStream(getter_AddRefs(stream), errorResult);
+  if (NS_WARN_IF(errorResult.Failed())) {
+    return errorResult.StealNSResult();
+  }
+
+  mStream = std::move(stream);
+
+  mCloneData = MakeUnique<JSStructuredCloneData>(
+      JS::StructuredCloneScope::DifferentProcessForIndexedDB);
+
+  return NS_OK;
+}
+
+nsresult BackgroundRequestChild::PreprocessHelper::Dispatch() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mState == State::Initial);
+
+  nsresult rv = mTaskQueue->Dispatch(this, NS_DISPATCH_NORMAL);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult BackgroundRequestChild::PreprocessHelper::Start() {
+  MOZ_ASSERT(!IsOnOwningThread());
+  MOZ_ASSERT(mStream);
+  MOZ_ASSERT(mState == State::Initial);
+
+  nsresult rv;
+
+  PRFileDesc* fileDesc = GetFileDescriptorFromStream(mStream);
+  if (fileDesc) {
+    rv = ProcessStream();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  mState = State::WaitingForStreamReady;
+
+  nsCOMPtr<nsIAsyncFileMetadata> asyncFileMetadata = do_QueryInterface(mStream);
+  if (asyncFileMetadata) {
+    rv = asyncFileMetadata->AsyncFileMetadataWait(this, mTaskQueue);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mStream);
+  if (!asyncStream) {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  rv = asyncStream->AsyncWait(this, 0, 0, mTaskQueue);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult BackgroundRequestChild::PreprocessHelper::ProcessStream() {
+  MOZ_ASSERT(!IsOnOwningThread());
+  MOZ_ASSERT(mStream);
+  MOZ_ASSERT(mState == State::Initial ||
+             mState == State::WaitingForStreamReady);
+
+  // We need to get the internal stream (which is an nsFileInputStream) because
+  // SnappyUncompressInputStream doesn't support reading from async input
+  // streams.
+
+  nsCOMPtr<mozIRemoteLazyInputStream> blobInputStream =
+      do_QueryInterface(mStream);
+  MOZ_ASSERT(blobInputStream);
+
+  nsCOMPtr<nsIInputStream> internalInputStream;
+  MOZ_ALWAYS_SUCCEEDS(
+      blobInputStream->TakeInternalStream(getter_AddRefs(internalInputStream)));
+  MOZ_ASSERT(internalInputStream);
+
+  QM_TRY(MOZ_TO_RESULT(
+      SnappyUncompressStructuredCloneData(*internalInputStream, *mCloneData)));
+
+  mState = State::Finishing;
+
+  QM_TRY(MOZ_TO_RESULT(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL)));
+
+  return NS_OK;
+}
+
+void BackgroundRequestChild::PreprocessHelper::Finish() {
+  AssertIsOnOwningThread();
+
+  if (mActor) {
+    if (NS_SUCCEEDED(mResultCode)) {
+      mActor->OnPreprocessFinished(mCloneDataIndex, std::move(mCloneData));
+
+      MOZ_ASSERT(!mCloneData);
+    } else {
+      mActor->OnPreprocessFailed(mCloneDataIndex, mResultCode);
+    }
+  }
+
+  mState = State::Completed;
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(BackgroundRequestChild::PreprocessHelper,
+                            DiscardableRunnable, nsIInputStreamCallback,
+                            nsIFileMetadataCallback)
+
+NS_IMETHODIMP
+BackgroundRequestChild::PreprocessHelper::Run() {
+  nsresult rv;
+
+  switch (mState) {
+    case State::Initial:
+      rv = Start();
+      break;
+
+    case State::WaitingForStreamReady:
+      rv = ProcessStream();
+      break;
+
+    case State::Finishing:
+      Finish();
+      return NS_OK;
+
+    default:
+      MOZ_CRASH("Bad state!");
+  }
+
+  if (NS_WARN_IF(NS_FAILED(rv)) && mState != State::Finishing) {
+    if (NS_SUCCEEDED(mResultCode)) {
+      mResultCode = rv;
+    }
+
+    // Must set mState before dispatching otherwise we will race with the owning
+    // thread.
+    mState = State::Finishing;
+
+    if (IsOnOwningThread()) {
+      Finish();
+    } else {
+      MOZ_ALWAYS_SUCCEEDS(
+          mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BackgroundRequestChild::PreprocessHelper::OnInputStreamReady(
+    nsIAsyncInputStream* aStream) {
+  MOZ_ASSERT(!IsOnOwningThread());
+  MOZ_ASSERT(mState == State::WaitingForStreamReady);
+
+  MOZ_ALWAYS_SUCCEEDS(this->Run());
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BackgroundRequestChild::PreprocessHelper::OnFileMetadataReady(
+    nsIAsyncFileMetadata* aObject) {
+  MOZ_ASSERT(!IsOnOwningThread());
+  MOZ_ASSERT(mState == State::WaitingForStreamReady);
+
+  MOZ_ALWAYS_SUCCEEDS(this->Run());
+
+  return NS_OK;
+}
+
+/*******************************************************************************
+ * BackgroundCursorChild
+ ******************************************************************************/
+
+BackgroundCursorChildBase::BackgroundCursorChildBase(
+    const NotNull<IDBRequest*> aRequest, const Direction aDirection)
+    : mRequest(aRequest),
+      mTransaction(aRequest->MaybeTransactionRef()),
+      mStrongRequest(aRequest),
+      mDirection(aDirection) {
+  MOZ_ASSERT(mTransaction);
+}
+
+MovingNotNull<RefPtr<IDBRequest>> BackgroundCursorChildBase::AcquireRequest()
+    const {
+  AssertIsOnOwningThread();
+
+  // XXX This could be encapsulated by NotNull
+  return WrapNotNullUnchecked(RefPtr{mRequest->get()});
+}
+
+template <IDBCursorType CursorType>
+BackgroundCursorChild<CursorType>::BackgroundCursorChild(
+    const NotNull<IDBRequest*> aRequest, SourceType* aSource,
+    Direction aDirection)
+    : BackgroundCursorChildBase(aRequest, aDirection),
+      mSource(WrapNotNull(aSource)),
+      mCursor(nullptr),
+      mInFlightResponseInvalidationNeeded(false) {
+  aSource->AssertIsOnOwningThread();
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundCursorChild<CursorType>);
+}
+
+template <IDBCursorType CursorType>
+BackgroundCursorChild<CursorType>::~BackgroundCursorChild() {
+  MOZ_COUNT_DTOR(indexedDB::BackgroundCursorChild<CursorType>);
+}
+
+template <IDBCursorType CursorType>
+SafeRefPtr<BackgroundCursorChild<CursorType>>
+BackgroundCursorChild<CursorType>::SafeRefPtrFromThis() {
+  return BackgroundCursorChildBase::SafeRefPtrFromThis()
+      .template downcast<BackgroundCursorChild>();
+}
+
+template <IDBCursorType CursorType>
+void BackgroundCursorChild<CursorType>::SendContinueInternal(
+    const CursorRequestParams& aParams,
+    const CursorData<CursorType>& aCurrentData) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mRequest);
+  MOZ_ASSERT(mTransaction);
+  MOZ_ASSERT(mCursor);
+  MOZ_ASSERT(!mStrongRequest);
+  MOZ_ASSERT(!mStrongCursor);
+
+  // Make sure all our DOM objects stay alive.
+  mStrongCursor = mCursor;
+
+  MOZ_ASSERT(GetRequest()->ReadyState() == IDBRequestReadyState::Done);
+  GetRequest()->Reset();
+
+  mTransaction->OnNewRequest();
+
+  CursorRequestParams params = aParams;
+  Key currentKey = aCurrentData.mKey;
+  Key currentObjectStoreKey;
+  // TODO: This is still not nice.
+  if constexpr (!CursorTypeTraits<CursorType>::IsObjectStoreCursor) {
+    currentObjectStoreKey = aCurrentData.mObjectStoreKey;
+  }
+
+  switch (params.type()) {
+    case CursorRequestParams::TContinueParams: {
+      const auto& key = params.get_ContinueParams().key();
+      if (key.IsUnset()) {
+        break;
+      }
+
+      // Discard cache entries before the target key.
+      DiscardCachedResponses(
+          [&key, isLocaleAware = mCursor->IsLocaleAware(),
+           keyOperator = GetKeyOperator(mDirection),
+           transactionSerialNumber = mTransaction->LoggingSerialNumber(),
+           requestSerialNumber = GetRequest()->LoggingSerialNumber()](
+              const auto& currentCachedResponse) {
+            // This duplicates the logic from the parent. We could avoid this
+            // duplication if we invalidated the cached records always for any
+            // continue-with-key operation, but would lose the benefits of
+            // preloading then.
+            const auto& cachedSortKey =
+                currentCachedResponse.GetSortKey(isLocaleAware);
+            const bool discard = !(cachedSortKey.*keyOperator)(key);
+            if (discard) {
+              IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+                  "PRELOAD: Continue to key %s, discarding cached key %s/%s",
+                  "Continue, discarding%.0s%.0s%.0s", transactionSerialNumber,
+                  requestSerialNumber, key.GetBuffer().get(),
+                  cachedSortKey.GetBuffer().get(),
+                  currentCachedResponse.GetObjectStoreKeyForLogging());
+            } else {
+              IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+                  "PRELOAD: Continue to key %s, keeping cached key %s/%s and "
+                  "further",
+                  "Continue, keeping%.0s%.0s%.0s", transactionSerialNumber,
+                  requestSerialNumber, key.GetBuffer().get(),
+                  cachedSortKey.GetBuffer().get(),
+                  currentCachedResponse.GetObjectStoreKeyForLogging());
+            }
+
+            return discard;
+          });
+
+      break;
+    }
+
+    case CursorRequestParams::TContinuePrimaryKeyParams: {
+      if constexpr (!CursorTypeTraits<CursorType>::IsObjectStoreCursor) {
+        const auto& key = params.get_ContinuePrimaryKeyParams().key();
+        const auto& primaryKey =
+            params.get_ContinuePrimaryKeyParams().primaryKey();
+        if (key.IsUnset() || primaryKey.IsUnset()) {
+          break;
+        }
+
+        // Discard cache entries before the target key.
+        DiscardCachedResponses([&key, &primaryKey,
+                                isLocaleAware = mCursor->IsLocaleAware(),
+                                keyCompareOperator = GetKeyOperator(mDirection),
+                                transactionSerialNumber =
+                                    mTransaction->LoggingSerialNumber(),
+                                requestSerialNumber =
+                                    GetRequest()->LoggingSerialNumber()](
+                                   const auto& currentCachedResponse) {
+          // This duplicates the logic from the parent. We could avoid this
+          // duplication if we invalidated the cached records always for any
+          // continue-with-key operation, but would lose the benefits of
+          // preloading then.
+          const auto& cachedSortKey =
+              currentCachedResponse.GetSortKey(isLocaleAware);
+          const auto& cachedSortPrimaryKey =
+              currentCachedResponse.mObjectStoreKey;
+
+          const bool discard =
+              (cachedSortKey == key &&
+               !(cachedSortPrimaryKey.*keyCompareOperator)(primaryKey)) ||
+              !(cachedSortKey.*keyCompareOperator)(key);
+
+          if (discard) {
+            IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+                "PRELOAD: Continue to key %s with primary key %s, discarding "
+                "cached key %s with cached primary key %s",
+                "Continue, discarding%.0s%.0s%.0s%.0s", transactionSerialNumber,
+                requestSerialNumber, key.GetBuffer().get(),
+                primaryKey.GetBuffer().get(), cachedSortKey.GetBuffer().get(),
+                cachedSortPrimaryKey.GetBuffer().get());
+          } else {
+            IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+                "PRELOAD: Continue to key %s with primary key %s, keeping "
+                "cached key %s with cached primary key %s and further",
+                "Continue, keeping%.0s%.0s%.0s%.0s", transactionSerialNumber,
+                requestSerialNumber, key.GetBuffer().get(),
+                primaryKey.GetBuffer().get(), cachedSortKey.GetBuffer().get(),
+                cachedSortPrimaryKey.GetBuffer().get());
+          }
+
+          return discard;
+        });
+      } else {
+        MOZ_CRASH("Shouldn't get here");
+      }
+
+      break;
+    }
+
+    case CursorRequestParams::TAdvanceParams: {
+      uint32_t& advanceCount = params.get_AdvanceParams().count();
+      IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+          "PRELOAD: Advancing %" PRIu32 " records", "Advancing %" PRIu32,
+          mTransaction->LoggingSerialNumber(),
+          GetRequest()->LoggingSerialNumber(), advanceCount);
+
+      // Discard cache entries.
+      DiscardCachedResponses([&advanceCount, &currentKey,
+                              &currentObjectStoreKey](
+                                 const auto& currentCachedResponse) {
+        const bool res = advanceCount > 1;
+        if (res) {
+          --advanceCount;
+
+          // TODO: We only need to update currentKey on the last entry, the
+          // others are overwritten in the next iteration anyway.
+          currentKey = currentCachedResponse.mKey;
+          if constexpr (!CursorTypeTraits<CursorType>::IsObjectStoreCursor) {
+            currentObjectStoreKey = currentCachedResponse.mObjectStoreKey;
+          } else {
+            Unused << currentObjectStoreKey;
+          }
+        }
+        return res;
+      });
+      break;
+    }
+
+    default:
+      MOZ_CRASH("Should never get here!");
+  }
+
+  if (!mCachedResponses.empty()) {
+    // We need to remove the response here from mCachedResponses, since when
+    // requests are interleaved, other events may be processed before
+    // CompleteContinueRequestFromCache, which may modify mCachedResponses.
+    mDelayedResponses.emplace_back(std::move(mCachedResponses.front()));
+    mCachedResponses.pop_front();
+
+    // We cannot send the response right away, as we must preserve the request
+    // order. Dispatching a DelayedActionRunnable only partially addresses this.
+    // This is accompanied by invalidating cached entries at proper locations to
+    // make it correct. To avoid this, further changes are necessary, see Bug
+    // 1580499.
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(
+        MakeAndAddRef<DelayedActionRunnable<BackgroundCursorChild<CursorType>>>(
+            SafeRefPtrFromThis(),
+            &BackgroundCursorChild::CompleteContinueRequestFromCache)));
+
+    // TODO: Could we preload further entries in the background when the size of
+    // mCachedResponses falls under some threshold? Or does the response
+    // handling model disallow this?
+  } else {
+    MOZ_ALWAYS_TRUE(PBackgroundIDBCursorChild::SendContinue(
+        params, currentKey, currentObjectStoreKey));
+  }
+}
+
+template <IDBCursorType CursorType>
+void BackgroundCursorChild<CursorType>::CompleteContinueRequestFromCache() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mTransaction);
+  MOZ_ASSERT(mCursor);
+  MOZ_ASSERT(mStrongCursor);
+  MOZ_ASSERT(!mDelayedResponses.empty());
+  MOZ_ASSERT(mCursor->GetType() == CursorType);
+
+  const RefPtr<IDBCursor> cursor = std::move(mStrongCursor);
+
+  mCursor->Reset(std::move(mDelayedResponses.front()));
+  mDelayedResponses.pop_front();
+
+  IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+      "PRELOAD: Consumed 1 cached response, %zu cached responses remaining",
+      "Consumed cached response, %zu remaining",
+      mTransaction->LoggingSerialNumber(), GetRequest()->LoggingSerialNumber(),
+      mDelayedResponses.size() + mCachedResponses.size());
+
+  SetResultAndDispatchSuccessEvent(
+      GetRequest(),
+      mTransaction
+          ? SafeRefPtr{&mTransaction.ref(), AcquireStrongRefFromRawPtr{}}
+          : nullptr,
+      *cursor);
+
+  mTransaction->OnRequestFinished(/* aRequestCompletedSuccessfully */ true);
+}
+
+template <IDBCursorType CursorType>
+void BackgroundCursorChild<CursorType>::SendDeleteMeInternal() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(!mStrongRequest);
+  MOZ_ASSERT(!mStrongCursor);
+
+  mRequest.destroy();
+  mTransaction = Nothing();
+  // TODO: The things until here could be pulled up to
+  // BackgroundCursorChildBase.
+
+  mSource.destroy();
+
+  if (mCursor) {
+    mCursor->ClearBackgroundActor();
+    mCursor = nullptr;
+
+    MOZ_ALWAYS_TRUE(PBackgroundIDBCursorChild::SendDeleteMe());
+  }
+}
+
+template <IDBCursorType CursorType>
+void BackgroundCursorChild<CursorType>::InvalidateCachedResponses() {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mTransaction);
+  MOZ_ASSERT(mRequest);
+
+  // TODO: With more information on the reason for the invalidation, we might
+  // only selectively invalidate cached responses. If the reason is an updated
+  // value, we do not need to care for key-only cursors. If the key of the
+  // changed entry is not in the remaining range of the cursor, we also do not
+  // need to care, etc.
+
+  IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+      "PRELOAD: Invalidating all %zu cached responses", "Invalidating %zu",
+      mTransaction->LoggingSerialNumber(), GetRequest()->LoggingSerialNumber(),
+      mCachedResponses.size());
+
+  mCachedResponses.clear();
+
+  // We only hold a strong cursor reference in mStrongCursor when
+  // continue()/similar has been called. In those cases we expect a response
+  // that will be received in the future, and it may include prefetched data
+  // that needs to be discarded.
+  if (mStrongCursor) {
+    IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+        "PRELOAD: Setting flag to invalidate in-flight responses",
+        "Set flag to invalidate in-flight responses",
+        mTransaction->LoggingSerialNumber(),
+        GetRequest()->LoggingSerialNumber());
+
+    mInFlightResponseInvalidationNeeded = true;
+  }
+}
+
+template <IDBCursorType CursorType>
+template <typename Condition>
+void BackgroundCursorChild<CursorType>::DiscardCachedResponses(
+    const Condition& aConditionFunc) {
+  size_t discardedCount = 0;
+  while (!mCachedResponses.empty() &&
+         aConditionFunc(mCachedResponses.front())) {
+    mCachedResponses.pop_front();
+    ++discardedCount;
+  }
+  IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+      "PRELOAD: Discarded %zu cached responses, %zu remaining",
+      "Discarded %zu; remaining %zu", mTransaction->LoggingSerialNumber(),
+      GetRequest()->LoggingSerialNumber(), discardedCount,
+      mCachedResponses.size());
+}
+
+BackgroundCursorChildBase::~BackgroundCursorChildBase() = default;
+
+void BackgroundCursorChildBase::HandleResponse(nsresult aResponse) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(NS_FAILED(aResponse));
+  MOZ_ASSERT(NS_ERROR_GET_MODULE(aResponse) == NS_ERROR_MODULE_DOM_INDEXEDDB);
+  MOZ_ASSERT(mRequest);
+  MOZ_ASSERT(mTransaction);
+  MOZ_ASSERT(!mStrongRequest);
+  MOZ_ASSERT(!mStrongCursor);
+
+  DispatchErrorEvent(
+      GetRequest(), aResponse,
+      SafeRefPtr{&mTransaction.ref(), AcquireStrongRefFromRawPtr{}});
+}
+
+template <IDBCursorType CursorType>
+void BackgroundCursorChild<CursorType>::HandleResponse(
+    const void_t& aResponse) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mRequest);
+  MOZ_ASSERT(mTransaction);
+  MOZ_ASSERT(!mStrongRequest);
+  MOZ_ASSERT(!mStrongCursor);
+
+  if (mCursor) {
+    mCursor->Reset();
+  }
+
+  SetResultAndDispatchSuccessEvent(
+      GetRequest(),
+      mTransaction
+          ? SafeRefPtr{&mTransaction.ref(), AcquireStrongRefFromRawPtr{}}
+          : nullptr,
+      JS::NullHandleValue);
+
+  if (!mCursor) {
+    MOZ_ALWAYS_SUCCEEDS(this->GetActorEventTarget()->Dispatch(
+        MakeAndAddRef<DelayedActionRunnable<BackgroundCursorChild<CursorType>>>(
+            SafeRefPtrFromThis(), &BackgroundCursorChild::SendDeleteMeInternal),
+        NS_DISPATCH_NORMAL));
+  }
+}
+
+template <IDBCursorType CursorType>
+template <typename... Args>
+RefPtr<IDBCursor>
+BackgroundCursorChild<CursorType>::HandleIndividualCursorResponse(
+    const bool aUseAsCurrentResult, Args&&... aArgs) {
+  if (mCursor) {
+    if (aUseAsCurrentResult) {
+      mCursor->Reset(CursorData<CursorType>{std::forward<Args>(aArgs)...});
+    } else {
+      mCachedResponses.emplace_back(std::forward<Args>(aArgs)...);
+    }
+    return nullptr;
+  }
+
+  MOZ_ASSERT(aUseAsCurrentResult);
+
+  // TODO: This still looks quite dangerous to me. Why is mCursor not a
+  // RefPtr?
+  auto newCursor = IDBCursor::Create(this, std::forward<Args>(aArgs)...);
+  mCursor = newCursor;
+  return newCursor;
+}
+
+template <IDBCursorType CursorType>
+template <typename Func>
+void BackgroundCursorChild<CursorType>::HandleMultipleCursorResponses(
+    nsTArray<ResponseType>&& aResponses, const Func& aHandleRecord) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(mRequest);
+  MOZ_ASSERT(mTransaction);
+  MOZ_ASSERT(!mStrongRequest);
+  MOZ_ASSERT(!mStrongCursor);
+  MOZ_ASSERT(aResponses.Length() > 0);
+
+  IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+      "PRELOAD: Received %zu cursor responses", "Received %zu",
+      mTransaction->LoggingSerialNumber(), GetRequest()->LoggingSerialNumber(),
+      aResponses.Length());
+  MOZ_ASSERT_IF(aResponses.Length() > 1, mCachedResponses.empty());
+
+  // If a new cursor is created, we need to keep a reference to it until the
+  // SetResultAndDispatchSuccessEvent creates a DOM Binding.
+  RefPtr<IDBCursor> strongNewCursor;
+
+  bool isFirst = true;
+  for (auto& response : aResponses) {
+    IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+        "PRELOAD: Processing response for key %s", "Processing%.0s",
+        mTransaction->LoggingSerialNumber(),
+        GetRequest()->LoggingSerialNumber(), response.key().GetBuffer().get());
+
+    // TODO: At the moment, we only send a cursor request to the parent if
+    // requested by the user code. Therefore, the first result is always used
+    // as the current result, and the potential extra results are cached. If
+    // we extended this towards preloading in the background, all results
+    // might need to be cached.
+    auto maybeNewCursor =
+        aHandleRecord(/* aUseAsCurrentResult */ isFirst, std::move(response));
+    if (maybeNewCursor) {
+      MOZ_ASSERT(!strongNewCursor);
+      strongNewCursor = std::move(maybeNewCursor);
+    }
+    isFirst = false;
+
+    if (mInFlightResponseInvalidationNeeded) {
+      IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
+          "PRELOAD: Discarding remaining responses since "
+          "mInFlightResponseInvalidationNeeded is set",
+          "Discarding responses", mTransaction->LoggingSerialNumber(),
+          GetRequest()->LoggingSerialNumber());
+
+      mInFlightResponseInvalidationNeeded = false;
+      break;
+    }
+  }
+
+  SetResultAndDispatchSuccessEvent(
+      GetRequest(),
+      mTransaction
+          ? SafeRefPtr{&mTransaction.ref(), AcquireStrongRefFromRawPtr{}}
+          : nullptr,
+      *static_cast<IDBCursor*>(mCursor));
+}
+
+template <IDBCursorType CursorType>
+void BackgroundCursorChild<CursorType>::HandleResponse(
+    nsTArray<ResponseType>&& aResponses) {
+  AssertIsOnOwningThread();
+
+  if constexpr (CursorType == IDBCursorType::ObjectStore ||
+                CursorType == IDBCursorType::Index) {
+    MOZ_ASSERT(mTransaction);
+
+    if (!mTransaction->Database()->GetOwnerGlobal()) {
+      // Ignore the response, since we have already been disconnected from the
+      // global.
+      return;
+    }
+  }
+
+  if constexpr (CursorType == IDBCursorType::ObjectStore) {
+    HandleMultipleCursorResponses(
+        std::move(aResponses), [this](const bool useAsCurrentResult,
+                                      ObjectStoreCursorResponse&& response) {
+          // TODO: Maybe move the deserialization of the clone-read-info into
+          // the cursor, so that it is only done for records actually accessed,
+          // which might not be the case for all cached records.
+          return HandleIndividualCursorResponse(
+              useAsCurrentResult, std::move(response.key()),
+              DeserializeStructuredCloneReadInfo(
+                  std::move(response.cloneInfo()), mTransaction->Database(),
+                  PreprocessingNotSupported));
+        });
+  }
+  if constexpr (CursorType == IDBCursorType::ObjectStoreKey) {
+    HandleMultipleCursorResponses(
+        std::move(aResponses), [this](const bool useAsCurrentResult,
+                                      ObjectStoreKeyCursorResponse&& response) {
+          return HandleIndividualCursorResponse(useAsCurrentResult,
+                                                std::move(response.key()));
+        });
+  }
+  if constexpr (CursorType == IDBCursorType::Index) {
+    HandleMultipleCursorResponses(
+        std::move(aResponses),
+        [this](const bool useAsCurrentResult, IndexCursorResponse&& response) {
+          return HandleIndividualCursorResponse(
+              useAsCurrentResult, std::move(response.key()),
+              std::move(response.sortKey()), std::move(response.objectKey()),
+              DeserializeStructuredCloneReadInfo(
+                  std::move(response.cloneInfo()), mTransaction->Database(),
+                  PreprocessingNotSupported));
+        });
+  }
+  if constexpr (CursorType == IDBCursorType::IndexKey) {
+    HandleMultipleCursorResponses(
+        std::move(aResponses), [this](const bool useAsCurrentResult,
+                                      IndexKeyCursorResponse&& response) {
+          return HandleIndividualCursorResponse(
+              useAsCurrentResult, std::move(response.key()),
+              std::move(response.sortKey()), std::move(response.objectKey()));
+        });
+  }
+}
+
+template <IDBCursorType CursorType>
+void BackgroundCursorChild<CursorType>::ActorDestroy(ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT_IF(aWhy == Deletion, !mStrongRequest);
+  MOZ_ASSERT_IF(aWhy == Deletion, !mStrongCursor);
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  if (mStrongRequest && !mStrongCursor && mTransaction) {
+    mTransaction->OnRequestFinished(/* aRequestCompletedSuccessfully */
+                                    aWhy == Deletion);
+  }
+
+  if (mCursor) {
+    mCursor->ClearBackgroundActor();
+#ifdef DEBUG
+    mCursor = nullptr;
+#endif
+  }
+
+#ifdef DEBUG
+  mRequest.maybeDestroy();
+  mTransaction = Nothing();
+  mSource.maybeDestroy();
+#endif
+}
+
+template <IDBCursorType CursorType>
+mozilla::ipc::IPCResult BackgroundCursorChild<CursorType>::RecvResponse(
+    CursorResponse&& aResponse) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aResponse.type() != CursorResponse::T__None);
+  MOZ_ASSERT(mRequest);
+  MOZ_ASSERT(mTransaction);
+  MOZ_ASSERT_IF(mCursor, mStrongCursor);
+  MOZ_ASSERT_IF(!mCursor, mStrongRequest);
+
+  MaybeCollectGarbageOnIPCMessage();
+
+  const RefPtr<IDBRequest> request = std::move(mStrongRequest);
+  Unused << request;  // XXX see Bug 1605075
+  const RefPtr<IDBCursor> cursor = std::move(mStrongCursor);
+  Unused << cursor;  // XXX see Bug 1605075
+
+  const auto transaction =
+      SafeRefPtr{&mTransaction.ref(), AcquireStrongRefFromRawPtr{}};
+
+  switch (aResponse.type()) {
+    case CursorResponse::Tnsresult:
+      HandleResponse(aResponse.get_nsresult());
+      break;
+
+    case CursorResponse::Tvoid_t:
+      HandleResponse(aResponse.get_void_t());
+      break;
+
+    case CursorResponse::TArrayOfObjectStoreCursorResponse:
+      if constexpr (CursorType == IDBCursorType::ObjectStore) {
+        HandleResponse(
+            std::move(aResponse.get_ArrayOfObjectStoreCursorResponse()));
+      } else {
+        MOZ_CRASH("Response type mismatch");
+      }
+      break;
+
+    case CursorResponse::TArrayOfObjectStoreKeyCursorResponse:
+      if constexpr (CursorType == IDBCursorType::ObjectStoreKey) {
+        HandleResponse(
+            std::move(aResponse.get_ArrayOfObjectStoreKeyCursorResponse()));
+      } else {
+        MOZ_CRASH("Response type mismatch");
+      }
+      break;
+
+    case CursorResponse::TArrayOfIndexCursorResponse:
+      if constexpr (CursorType == IDBCursorType::Index) {
+        HandleResponse(std::move(aResponse.get_ArrayOfIndexCursorResponse()));
+      } else {
+        MOZ_CRASH("Response type mismatch");
+      }
+      break;
+
+    case CursorResponse::TArrayOfIndexKeyCursorResponse:
+      if constexpr (CursorType == IDBCursorType::IndexKey) {
+        HandleResponse(
+            std::move(aResponse.get_ArrayOfIndexKeyCursorResponse()));
+      } else {
+        MOZ_CRASH("Response type mismatch");
+      }
+      break;
+
+    default:
+      MOZ_CRASH("Should never get here!");
+  }
+
+  transaction->OnRequestFinished(/* aRequestCompletedSuccessfully */ true);
+
+  return IPC_OK();
+}
+
+template class BackgroundCursorChild<IDBCursorType::ObjectStore>;
+template class BackgroundCursorChild<IDBCursorType::ObjectStoreKey>;
+template class BackgroundCursorChild<IDBCursorType::Index>;
+template class BackgroundCursorChild<IDBCursorType::IndexKey>;
+
+template <typename T>
+NS_IMETHODIMP DelayedActionRunnable<T>::Run() {
+  MOZ_ASSERT(mActor);
+  mActor->AssertIsOnOwningThread();
+  MOZ_ASSERT(mRequest);
+  MOZ_ASSERT(mActionFunc);
+
+  ((*mActor).*mActionFunc)();
+
+  mActor = nullptr;
+  mRequest = nullptr;
+
+  return NS_OK;
+}
+
+template <typename T>
+nsresult DelayedActionRunnable<T>::Cancel() {
+  if (NS_WARN_IF(!mActor)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  // This must always run to clean up our state.
+  Run();
+
+  return NS_OK;
+}
+
+/*******************************************************************************
+ * BackgroundUtilsChild
+ ******************************************************************************/
+
+BackgroundUtilsChild::BackgroundUtilsChild(IndexedDatabaseManager* aManager)
+    : mManager(aManager) {
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aManager);
+
+  MOZ_COUNT_CTOR(indexedDB::BackgroundUtilsChild);
+}
+
+BackgroundUtilsChild::~BackgroundUtilsChild() {
+  MOZ_COUNT_DTOR(indexedDB::BackgroundUtilsChild);
+}
+
+void BackgroundUtilsChild::SendDeleteMeInternal() {
+  AssertIsOnOwningThread();
+
+  if (mManager) {
+    mManager->ClearBackgroundActor();
+    mManager = nullptr;
+
+    MOZ_ALWAYS_TRUE(PBackgroundIndexedDBUtilsChild::SendDeleteMe());
+  }
+}
+
+void BackgroundUtilsChild::ActorDestroy(ActorDestroyReason aWhy) {
+  AssertIsOnOwningThread();
+
+  if (mManager) {
+    mManager->ClearBackgroundActor();
+#ifdef DEBUG
+    mManager = nullptr;
+#endif
+  }
+}
+
+}  // namespace dom::indexedDB
+}  // namespace mozilla