/* -*- 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 "ActorsParentCommon.h"

// local includes
#include "DatabaseFileInfo.h"
#include "DatabaseFileManager.h"
#include "IndexedDatabase.h"  // for StructuredCloneFile...
#include "IndexedDatabaseInlines.h"
#include "IndexedDatabaseManager.h"
#include "IndexedDBCommon.h"
#include "ReportInternalError.h"

// global includes
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <numeric>
#include <type_traits>
#include "MainThreadUtils.h"
#include "SafeRefPtr.h"
#include "js/RootingAPI.h"
#include "js/StructuredClone.h"
#include "mozIStorageConnection.h"
#include "mozIStorageStatement.h"
#include "mozIStorageValueArray.h"
#include "mozilla/Assertions.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/JSObjectHolder.h"
#include "mozilla/NullPrincipal.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/RefPtr.h"
#include "mozilla/ResultExtensions.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/Telemetry.h"
#include "mozilla/TelemetryScalarEnums.h"
#include "mozilla/dom/quota/DecryptingInputStream_impl.h"
#include "mozilla/dom/quota/QuotaCommon.h"
#include "mozilla/dom/quota/ResultExtensions.h"
#include "mozilla/dom/quota/ScopedLogExtraInfo.h"
#include "mozilla/fallible.h"
#include "mozilla/ipc/BackgroundParent.h"
#include "mozilla/mozalloc.h"
#include "nsCOMPtr.h"
#include "nsCharSeparatedTokenizer.h"
#include "nsContentUtils.h"
#include "nsDebug.h"
#include "nsError.h"
#include "nsIInputStream.h"
#include "nsIPrincipal.h"
#include "nsIXPConnect.h"
#include "nsNetUtil.h"
#include "nsString.h"
#include "nsStringFlags.h"
#include "nsXULAppAPI.h"
#include "snappy/snappy.h"

class nsIFile;

namespace mozilla::dom::indexedDB {

static_assert(SNAPPY_VERSION == 0x010109);

using mozilla::ipc::IsOnBackgroundThread;

const nsLiteralString kJournalDirectoryName = u"journals"_ns;

namespace {

constexpr StructuredCloneFileBase::FileType ToStructuredCloneFileType(
    const char16_t aTag) {
  switch (aTag) {
    case char16_t('-'):
      return StructuredCloneFileBase::eMutableFile;

    case char16_t('.'):
      return StructuredCloneFileBase::eStructuredClone;

    case char16_t('/'):
      return StructuredCloneFileBase::eWasmBytecode;

    case char16_t('\\'):
      return StructuredCloneFileBase::eWasmCompiled;

    default:
      return StructuredCloneFileBase::eBlob;
  }
}

int32_t ToInteger(const nsAString& aStr, nsresult* const aRv) {
  return aStr.ToInteger(aRv);
}

Result<StructuredCloneFileParent, nsresult> DeserializeStructuredCloneFile(
    const DatabaseFileManager& aFileManager,
    const nsDependentSubstring& aText) {
  MOZ_ASSERT(!aText.IsEmpty());

  const StructuredCloneFileBase::FileType type =
      ToStructuredCloneFileType(aText.First());

  QM_TRY_INSPECT(const auto& id,
                 MOZ_TO_RESULT_GET_TYPED(
                     int32_t, ToInteger,
                     type == StructuredCloneFileBase::eBlob
                         ? aText
                         : static_cast<const nsAString&>(Substring(aText, 1))));

  SafeRefPtr<DatabaseFileInfo> fileInfo = aFileManager.GetFileInfo(id);
  MOZ_ASSERT(fileInfo);
  // XXX In bug 1432133, for some reasons DatabaseFileInfo object cannot be
  // got. This is just a short-term fix, and we are working on finding the real
  // cause in bug 1519859.
  QM_TRY(OkIf((bool)fileInfo), Err(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR));

  return StructuredCloneFileParent{type, std::move(fileInfo)};
}

// This class helps to create only 1 sandbox.
class SandboxHolder final {
 public:
  NS_INLINE_DECL_REFCOUNTING(SandboxHolder)

 private:
  friend JSObject* mozilla::dom::indexedDB::GetSandbox(JSContext* aCx);

  ~SandboxHolder() = default;

  static SandboxHolder* GetOrCreate() {
    MOZ_ASSERT(XRE_IsParentProcess());
    MOZ_ASSERT(NS_IsMainThread());

    static StaticRefPtr<SandboxHolder> sHolder;
    if (!sHolder) {
      sHolder = new SandboxHolder();
      ClearOnShutdown(&sHolder);
    }
    return sHolder;
  }

  JSObject* GetSandboxInternal(JSContext* aCx) {
    if (!mSandbox) {
      nsIXPConnect* const xpc = nsContentUtils::XPConnect();
      MOZ_ASSERT(xpc, "This should never be null!");

      // Let's use a null principal.
      const nsCOMPtr<nsIPrincipal> principal =
          NullPrincipal::CreateWithoutOriginAttributes();

      JS::Rooted<JSObject*> sandbox(aCx);
      QM_TRY(
          MOZ_TO_RESULT(xpc->CreateSandbox(aCx, principal, sandbox.address())),
          nullptr);

      mSandbox = new JSObjectHolder(aCx, sandbox);
    }

    return mSandbox->GetJSObject();
  }

  RefPtr<JSObjectHolder> mSandbox;
};

uint32_t CompressedByteCountForNumber(uint64_t aNumber) {
  // All bytes have 7 bits available.
  uint32_t count = 1;
  while ((aNumber >>= 7)) {
    count++;
  }

  return count;
}

uint32_t CompressedByteCountForIndexId(IndexOrObjectStoreId aIndexId) {
  MOZ_ASSERT(aIndexId);
  MOZ_ASSERT(UINT64_MAX - uint64_t(aIndexId) >= uint64_t(aIndexId),
             "Overflow!");

  return CompressedByteCountForNumber(uint64_t(aIndexId * 2));
}

void WriteCompressedNumber(uint64_t aNumber, uint8_t** aIterator) {
  MOZ_ASSERT(aIterator);
  MOZ_ASSERT(*aIterator);

  uint8_t*& buffer = *aIterator;

#ifdef DEBUG
  const uint8_t* const bufferStart = buffer;
  const uint64_t originalNumber = aNumber;
#endif

  while (true) {
    uint64_t shiftedNumber = aNumber >> 7;
    if (shiftedNumber) {
      *buffer++ = uint8_t(0x80 | (aNumber & 0x7f));
      aNumber = shiftedNumber;
    } else {
      *buffer++ = uint8_t(aNumber);
      break;
    }
  }

  MOZ_ASSERT(buffer > bufferStart);
  MOZ_ASSERT(uint32_t(buffer - bufferStart) ==
             CompressedByteCountForNumber(originalNumber));
}

void WriteCompressedIndexId(IndexOrObjectStoreId aIndexId, bool aUnique,
                            uint8_t** aIterator) {
  MOZ_ASSERT(aIndexId);
  MOZ_ASSERT(UINT64_MAX - uint64_t(aIndexId) >= uint64_t(aIndexId),
             "Overflow!");
  MOZ_ASSERT(aIterator);
  MOZ_ASSERT(*aIterator);

  const uint64_t indexId = (uint64_t(aIndexId * 2) | (aUnique ? 1 : 0));
  WriteCompressedNumber(indexId, aIterator);
}

// aOutIndexValues is an output parameter, since its storage is reused.
nsresult ReadCompressedIndexDataValuesFromBlob(
    const Span<const uint8_t> aBlobData,
    nsTArray<IndexDataValue>* aOutIndexValues) {
  MOZ_ASSERT(!NS_IsMainThread());
  MOZ_ASSERT(!IsOnBackgroundThread());
  MOZ_ASSERT(!aBlobData.IsEmpty());
  MOZ_ASSERT(aOutIndexValues);
  MOZ_ASSERT(aOutIndexValues->IsEmpty());

  AUTO_PROFILER_LABEL("ReadCompressedIndexDataValuesFromBlob", DOM);

  // XXX Is this check still necessary with a Span? Or should it rather be moved
  // to the caller?
  QM_TRY(OkIf(uintptr_t(aBlobData.Elements()) <=
              UINTPTR_MAX - aBlobData.LengthBytes()),
         NS_ERROR_FILE_CORRUPTED, IDB_REPORT_INTERNAL_ERR_LAMBDA);

  for (auto remainder = aBlobData; !remainder.IsEmpty();) {
    QM_TRY_INSPECT((const auto& [indexId, unique, remainderAfterIndexId]),
                   ReadCompressedIndexId(remainder));

    QM_TRY(OkIf(!remainderAfterIndexId.IsEmpty()), NS_ERROR_FILE_CORRUPTED,
           IDB_REPORT_INTERNAL_ERR_LAMBDA);

    // Read key buffer length.
    QM_TRY_INSPECT(
        (const auto& [keyBufferLength, remainderAfterKeyBufferLength]),
        ReadCompressedNumber(remainderAfterIndexId));

    QM_TRY(OkIf(!remainderAfterKeyBufferLength.IsEmpty()),
           NS_ERROR_FILE_CORRUPTED, IDB_REPORT_INTERNAL_ERR_LAMBDA);

    QM_TRY(OkIf(keyBufferLength <= uint64_t(UINT32_MAX)),
           NS_ERROR_FILE_CORRUPTED, IDB_REPORT_INTERNAL_ERR_LAMBDA);

    QM_TRY(OkIf(keyBufferLength <= remainderAfterKeyBufferLength.Length()),
           NS_ERROR_FILE_CORRUPTED, IDB_REPORT_INTERNAL_ERR_LAMBDA);

    const auto [keyBuffer, remainderAfterKeyBuffer] =
        remainderAfterKeyBufferLength.SplitAt(keyBufferLength);
    auto idv =
        IndexDataValue{indexId, unique, Key{nsCString{AsChars(keyBuffer)}}};

    // Read sort key buffer length.
    QM_TRY_INSPECT(
        (const auto& [sortKeyBufferLength, remainderAfterSortKeyBufferLength]),
        ReadCompressedNumber(remainderAfterKeyBuffer));

    remainder = remainderAfterSortKeyBufferLength;
    if (sortKeyBufferLength > 0) {
      QM_TRY(OkIf(!remainder.IsEmpty()), NS_ERROR_FILE_CORRUPTED,
             IDB_REPORT_INTERNAL_ERR_LAMBDA);

      QM_TRY(OkIf(sortKeyBufferLength <= uint64_t(UINT32_MAX)),
             NS_ERROR_FILE_CORRUPTED, IDB_REPORT_INTERNAL_ERR_LAMBDA);

      QM_TRY(OkIf(sortKeyBufferLength <= remainder.Length()),
             NS_ERROR_FILE_CORRUPTED, IDB_REPORT_INTERNAL_ERR_LAMBDA);

      const auto [sortKeyBuffer, remainderAfterSortKeyBuffer] =
          remainder.SplitAt(sortKeyBufferLength);
      idv.mLocaleAwarePosition = Key{nsCString{AsChars(sortKeyBuffer)}};
      remainder = remainderAfterSortKeyBuffer;
    }

    QM_TRY(OkIf(aOutIndexValues->AppendElement(std::move(idv), fallible)),
           NS_ERROR_OUT_OF_MEMORY, IDB_REPORT_INTERNAL_ERR_LAMBDA);
  }
  aOutIndexValues->Sort();

  return NS_OK;
}

// aOutIndexValues is an output parameter, since its storage is reused.
template <typename T>
nsresult ReadCompressedIndexDataValuesFromSource(
    T& aSource, uint32_t aColumnIndex,
    nsTArray<IndexDataValue>* aOutIndexValues) {
  MOZ_ASSERT(!NS_IsMainThread());
  MOZ_ASSERT(!IsOnBackgroundThread());
  MOZ_ASSERT(aOutIndexValues);
  MOZ_ASSERT(aOutIndexValues->IsEmpty());

  QM_TRY_INSPECT(
      const int32_t& columnType,
      MOZ_TO_RESULT_INVOKE_MEMBER(aSource, GetTypeOfIndex, aColumnIndex));

  switch (columnType) {
    case mozIStorageStatement::VALUE_TYPE_NULL:
      return NS_OK;

    case mozIStorageStatement::VALUE_TYPE_BLOB: {
      // XXX ToResultInvoke does not support multiple output parameters yet, so
      // we also can't use QM_TRY_UNWRAP/QM_TRY_INSPECT here.
      const uint8_t* blobData;
      uint32_t blobDataLength;
      QM_TRY(MOZ_TO_RESULT(
          aSource.GetSharedBlob(aColumnIndex, &blobDataLength, &blobData)));

      QM_TRY(OkIf(blobDataLength), NS_ERROR_FILE_CORRUPTED,
             IDB_REPORT_INTERNAL_ERR_LAMBDA);

      QM_TRY(MOZ_TO_RESULT(ReadCompressedIndexDataValuesFromBlob(
          Span(blobData, blobDataLength), aOutIndexValues)));

      return NS_OK;
    }

    default:
      return NS_ERROR_FILE_CORRUPTED;
  }
}

Result<StructuredCloneReadInfoParent, nsresult>
GetStructuredCloneReadInfoFromBlob(const uint8_t* aBlobData,
                                   uint32_t aBlobDataLength,
                                   const DatabaseFileManager& aFileManager,
                                   const nsAString& aFileIds,
                                   const Maybe<CipherKey>& aMaybeKey) {
  MOZ_ASSERT(!IsOnBackgroundThread());

  AUTO_PROFILER_LABEL("GetStructuredCloneReadInfoFromBlob", DOM);

  const char* const compressed = reinterpret_cast<const char*>(aBlobData);
  const size_t compressedLength = size_t(aBlobDataLength);

  size_t uncompressedLength;
  QM_TRY(OkIf(snappy::GetUncompressedLength(compressed, compressedLength,
                                            &uncompressedLength)),
         Err(NS_ERROR_FILE_CORRUPTED));

  // `data` (JSStructuredCloneData) currently uses 4k buffer internally.
  // For performance reasons, it's better to align `uncompressed` with that.
  AutoTArray<uint8_t, 4096> uncompressed;
  QM_TRY(OkIf(uncompressed.SetLength(uncompressedLength, fallible)),
         Err(NS_ERROR_OUT_OF_MEMORY));

  char* const uncompressedBuffer =
      reinterpret_cast<char*>(uncompressed.Elements());

  QM_TRY(OkIf(snappy::RawUncompress(compressed, compressedLength,
                                    uncompressedBuffer)),
         Err(NS_ERROR_FILE_CORRUPTED));

  JSStructuredCloneData data(JS::StructuredCloneScope::DifferentProcess);
  QM_TRY(OkIf(data.AppendBytes(uncompressedBuffer, uncompressed.Length())),
         Err(NS_ERROR_OUT_OF_MEMORY));

  nsTArray<StructuredCloneFileParent> files;
  if (!aFileIds.IsVoid()) {
    QM_TRY_UNWRAP(files,
                  DeserializeStructuredCloneFiles(aFileManager, aFileIds));
  }

  return StructuredCloneReadInfoParent{std::move(data), std::move(files),
                                       false};
}

Result<StructuredCloneReadInfoParent, nsresult>
GetStructuredCloneReadInfoFromExternalBlob(
    uint64_t aIntData, const DatabaseFileManager& aFileManager,
    const nsAString& aFileIds, const Maybe<CipherKey>& aMaybeKey) {
  MOZ_ASSERT(!IsOnBackgroundThread());

  AUTO_PROFILER_LABEL("GetStructuredCloneReadInfoFromExternalBlob", DOM);

  nsTArray<StructuredCloneFileParent> files;
  if (!aFileIds.IsVoid()) {
    QM_TRY_UNWRAP(files,
                  DeserializeStructuredCloneFiles(aFileManager, aFileIds));
  }

  // Higher and lower 32 bits described
  // in ObjectStoreAddOrPutRequestOp::DoDatabaseWork.
  const uint32_t index = uint32_t(aIntData & UINT32_MAX);

  QM_TRY(OkIf(index < files.Length()), Err(NS_ERROR_UNEXPECTED),
         [](const auto&) { MOZ_ASSERT(false, "Bad index value!"); });

  if (StaticPrefs::dom_indexedDB_preprocessing()) {
    return StructuredCloneReadInfoParent{
        JSStructuredCloneData{JS::StructuredCloneScope::DifferentProcess},
        std::move(files), true};
  }

  // XXX Why can there be multiple files, but we use only a single one here?
  const StructuredCloneFileParent& file = files[index];
  MOZ_ASSERT(file.Type() == StructuredCloneFileBase::eStructuredClone);

  auto data = JSStructuredCloneData{JS::StructuredCloneScope::DifferentProcess};

  {
    const nsCOMPtr<nsIFile> nativeFile = file.FileInfo().GetFileForFileInfo();
    QM_TRY(OkIf(nativeFile), Err(NS_ERROR_FAILURE));

    QM_TRY_INSPECT(
        const auto& fileInputStream,
        NS_NewLocalFileInputStream(nativeFile)
            .andThen([aMaybeKey](auto fileInputStream)
                         -> Result<nsCOMPtr<nsIInputStream>, nsresult> {
              if (aMaybeKey) {
                return nsCOMPtr<nsIInputStream>{MakeRefPtr<
                    quota::DecryptingInputStream<IndexedDBCipherStrategy>>(
                    WrapNotNull(std::move(fileInputStream)),
                    kEncryptedStreamBlockSize, *aMaybeKey)};
              }

              return fileInputStream;
            }));

    QM_TRY(MOZ_TO_RESULT(
        SnappyUncompressStructuredCloneData(*fileInputStream, data)));
  }

  return StructuredCloneReadInfoParent{std::move(data), std::move(files),
                                       false};
}

template <typename T>
Result<StructuredCloneReadInfoParent, nsresult>
GetStructuredCloneReadInfoFromSource(T* aSource, uint32_t aDataIndex,
                                     uint32_t aFileIdsIndex,
                                     const DatabaseFileManager& aFileManager,
                                     const Maybe<CipherKey>& aMaybeKey) {
  MOZ_ASSERT(!IsOnBackgroundThread());
  MOZ_ASSERT(aSource);

  QM_TRY_INSPECT(
      const int32_t& columnType,
      MOZ_TO_RESULT_INVOKE_MEMBER(aSource, GetTypeOfIndex, aDataIndex));

  QM_TRY_INSPECT(const bool& isNull, MOZ_TO_RESULT_INVOKE_MEMBER(
                                         aSource, GetIsNull, aFileIdsIndex));

  QM_TRY_INSPECT(const nsString& fileIds, ([aSource, aFileIdsIndex, isNull] {
                   return isNull ? Result<nsString, nsresult>{VoidString()}
                                 : MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
                                       nsString, aSource, GetString,
                                       aFileIdsIndex);
                 }()));

  switch (columnType) {
    case mozIStorageStatement::VALUE_TYPE_INTEGER: {
      QM_TRY_INSPECT(
          const int64_t& intData,
          MOZ_TO_RESULT_INVOKE_MEMBER(aSource, GetInt64, aDataIndex));

      uint64_t uintData;
      memcpy(&uintData, &intData, sizeof(uint64_t));

      return GetStructuredCloneReadInfoFromExternalBlob(uintData, aFileManager,
                                                        fileIds, aMaybeKey);
    }

    case mozIStorageStatement::VALUE_TYPE_BLOB: {
      const uint8_t* blobData;
      uint32_t blobDataLength;
      QM_TRY(MOZ_TO_RESULT(
          aSource->GetSharedBlob(aDataIndex, &blobDataLength, &blobData)));

      return GetStructuredCloneReadInfoFromBlob(
          blobData, blobDataLength, aFileManager, fileIds, aMaybeKey);
    }

    default:
      return Err(NS_ERROR_FILE_CORRUPTED);
  }
}

}  // namespace

IndexDataValue::IndexDataValue() : mIndexId(0), mUnique(false) {
  MOZ_COUNT_CTOR(IndexDataValue);
}

#ifdef NS_BUILD_REFCNT_LOGGING
IndexDataValue::IndexDataValue(IndexDataValue&& aOther)
    : mIndexId(aOther.mIndexId),
      mPosition(std::move(aOther.mPosition)),
      mLocaleAwarePosition(std::move(aOther.mLocaleAwarePosition)),
      mUnique(aOther.mUnique) {
  MOZ_ASSERT(!aOther.mPosition.IsUnset());

  MOZ_COUNT_CTOR(IndexDataValue);
}
#endif

IndexDataValue::IndexDataValue(IndexOrObjectStoreId aIndexId, bool aUnique,
                               const Key& aPosition)
    : mIndexId(aIndexId), mPosition(aPosition), mUnique(aUnique) {
  MOZ_ASSERT(!aPosition.IsUnset());

  MOZ_COUNT_CTOR(IndexDataValue);
}

IndexDataValue::IndexDataValue(IndexOrObjectStoreId aIndexId, bool aUnique,
                               const Key& aPosition,
                               const Key& aLocaleAwarePosition)
    : mIndexId(aIndexId),
      mPosition(aPosition),
      mLocaleAwarePosition(aLocaleAwarePosition),
      mUnique(aUnique) {
  MOZ_ASSERT(!aPosition.IsUnset());

  MOZ_COUNT_CTOR(IndexDataValue);
}

bool IndexDataValue::operator==(const IndexDataValue& aOther) const {
  if (mIndexId != aOther.mIndexId) {
    return false;
  }
  if (mLocaleAwarePosition.IsUnset()) {
    return mPosition == aOther.mPosition;
  }
  return mLocaleAwarePosition == aOther.mLocaleAwarePosition;
}

bool IndexDataValue::operator<(const IndexDataValue& aOther) const {
  if (mIndexId == aOther.mIndexId) {
    if (mLocaleAwarePosition.IsUnset()) {
      return mPosition < aOther.mPosition;
    }
    return mLocaleAwarePosition < aOther.mLocaleAwarePosition;
  }

  return mIndexId < aOther.mIndexId;
}

JSObject* GetSandbox(JSContext* aCx) {
  SandboxHolder* holder = SandboxHolder::GetOrCreate();
  return holder->GetSandboxInternal(aCx);
}

Result<std::pair<UniqueFreePtr<uint8_t>, uint32_t>, nsresult>
MakeCompressedIndexDataValues(const nsTArray<IndexDataValue>& aIndexValues) {
  MOZ_ASSERT(!NS_IsMainThread());
  MOZ_ASSERT(!IsOnBackgroundThread());

  AUTO_PROFILER_LABEL("MakeCompressedIndexDataValues", DOM);

  const uint32_t arrayLength = aIndexValues.Length();
  if (!arrayLength) {
    return std::pair{UniqueFreePtr<uint8_t>{}, 0u};
  }

  // First calculate the size of the final buffer.
  const auto blobDataLength = std::accumulate(
      aIndexValues.cbegin(), aIndexValues.cend(), CheckedUint32(0),
      [](CheckedUint32 sum, const IndexDataValue& info) {
        const nsCString& keyBuffer = info.mPosition.GetBuffer();
        const nsCString& sortKeyBuffer = info.mLocaleAwarePosition.GetBuffer();
        const uint32_t keyBufferLength = keyBuffer.Length();
        const uint32_t sortKeyBufferLength = sortKeyBuffer.Length();

        MOZ_ASSERT(!keyBuffer.IsEmpty());

        return sum + CompressedByteCountForIndexId(info.mIndexId) +
               CompressedByteCountForNumber(keyBufferLength) +
               CompressedByteCountForNumber(sortKeyBufferLength) +
               keyBufferLength + sortKeyBufferLength;
      });

  QM_TRY(OkIf(blobDataLength.isValid()),
         Err(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR),
         IDB_REPORT_INTERNAL_ERR_LAMBDA);

  UniqueFreePtr<uint8_t> blobData(
      static_cast<uint8_t*>(malloc(blobDataLength.value())));
  QM_TRY(OkIf(static_cast<bool>(blobData)), Err(NS_ERROR_OUT_OF_MEMORY),
         IDB_REPORT_INTERNAL_ERR_LAMBDA);

  uint8_t* blobDataIter = blobData.get();

  for (const IndexDataValue& info : aIndexValues) {
    const nsCString& keyBuffer = info.mPosition.GetBuffer();
    const nsCString& sortKeyBuffer = info.mLocaleAwarePosition.GetBuffer();
    const uint32_t keyBufferLength = keyBuffer.Length();
    const uint32_t sortKeyBufferLength = sortKeyBuffer.Length();

    WriteCompressedIndexId(info.mIndexId, info.mUnique, &blobDataIter);
    WriteCompressedNumber(keyBufferLength, &blobDataIter);

    memcpy(blobDataIter, keyBuffer.get(), keyBufferLength);
    blobDataIter += keyBufferLength;

    WriteCompressedNumber(sortKeyBufferLength, &blobDataIter);

    memcpy(blobDataIter, sortKeyBuffer.get(), sortKeyBufferLength);
    blobDataIter += sortKeyBufferLength;
  }

  MOZ_ASSERT(blobDataIter == blobData.get() + blobDataLength.value());

  return std::pair{std::move(blobData), blobDataLength.value()};
}

nsresult ReadCompressedIndexDataValues(
    mozIStorageStatement& aStatement, uint32_t aColumnIndex,
    nsTArray<IndexDataValue>& aOutIndexValues) {
  return ReadCompressedIndexDataValuesFromSource(aStatement, aColumnIndex,
                                                 &aOutIndexValues);
}

template <typename T>
Result<IndexDataValuesAutoArray, nsresult> ReadCompressedIndexDataValues(
    T& aValues, uint32_t aColumnIndex) {
  return MOZ_TO_RESULT_INVOKE_TYPED(IndexDataValuesAutoArray,
                                    &ReadCompressedIndexDataValuesFromSource<T>,
                                    aValues, aColumnIndex);
}

template Result<IndexDataValuesAutoArray, nsresult>
ReadCompressedIndexDataValues<mozIStorageValueArray>(mozIStorageValueArray&,
                                                     uint32_t);

template Result<IndexDataValuesAutoArray, nsresult>
ReadCompressedIndexDataValues<mozIStorageStatement>(mozIStorageStatement&,
                                                    uint32_t);

Result<std::tuple<IndexOrObjectStoreId, bool, Span<const uint8_t>>, nsresult>
ReadCompressedIndexId(const Span<const uint8_t> aData) {
  QM_TRY_INSPECT((const auto& [indexId, remainder]),
                 ReadCompressedNumber(aData));

  MOZ_ASSERT(UINT64_MAX / 2 >= uint64_t(indexId), "Bad index id!");

  return std::tuple{IndexOrObjectStoreId(indexId >> 1), indexId % 2 == 1,
                    remainder};
}

Result<std::pair<uint64_t, mozilla::Span<const uint8_t>>, nsresult>
ReadCompressedNumber(const Span<const uint8_t> aSpan) {
  uint8_t shiftCounter = 0;
  uint64_t result = 0;

  const auto end = aSpan.cend();

  const auto newPos =
      std::find_if(aSpan.cbegin(), end, [&result, &shiftCounter](uint8_t byte) {
        MOZ_ASSERT(shiftCounter <= 56, "Shifted too many bits!");

        result += (uint64_t(byte & 0x7f) << shiftCounter);
        shiftCounter += 7;

        return !(byte & 0x80);
      });

  QM_TRY(OkIf(newPos != end), Err(NS_ERROR_FILE_CORRUPTED), [](const auto&) {
    MOZ_ASSERT(false);
    IDB_REPORT_INTERNAL_ERR();
  });

  return std::pair{result, Span{newPos + 1, end}};
}

Result<StructuredCloneReadInfoParent, nsresult>
GetStructuredCloneReadInfoFromValueArray(
    mozIStorageValueArray* aValues, uint32_t aDataIndex, uint32_t aFileIdsIndex,
    const DatabaseFileManager& aFileManager,
    const Maybe<CipherKey>& aMaybeKey) {
  return GetStructuredCloneReadInfoFromSource(
      aValues, aDataIndex, aFileIdsIndex, aFileManager, aMaybeKey);
}

Result<StructuredCloneReadInfoParent, nsresult>
GetStructuredCloneReadInfoFromStatement(mozIStorageStatement* aStatement,
                                        uint32_t aDataIndex,
                                        uint32_t aFileIdsIndex,
                                        const DatabaseFileManager& aFileManager,
                                        const Maybe<CipherKey>& aMaybeKey) {
  return GetStructuredCloneReadInfoFromSource(
      aStatement, aDataIndex, aFileIdsIndex, aFileManager, aMaybeKey);
}

Result<nsTArray<StructuredCloneFileParent>, nsresult>
DeserializeStructuredCloneFiles(const DatabaseFileManager& aFileManager,
                                const nsAString& aText) {
  MOZ_ASSERT(!IsOnBackgroundThread());

  nsTArray<StructuredCloneFileParent> result;
  for (const auto& token :
       nsCharSeparatedTokenizerTemplate<NS_TokenizerIgnoreNothing>(aText, ' ')
           .ToRange()) {
    MOZ_ASSERT(!token.IsEmpty());

    QM_TRY_UNWRAP(auto structuredCloneFile,
                  DeserializeStructuredCloneFile(aFileManager, token));

    result.EmplaceBack(std::move(structuredCloneFile));
  }

  return result;
}

nsresult ExecuteSimpleSQLSequence(mozIStorageConnection& aConnection,
                                  Span<const nsLiteralCString> aSQLCommands) {
  for (const auto& aSQLCommand : aSQLCommands) {
    const auto extraInfo = quota::ScopedLogExtraInfo{
        quota::ScopedLogExtraInfo::kTagQuery, aSQLCommand};

    QM_TRY(MOZ_TO_RESULT(aConnection.ExecuteSimpleSQL(aSQLCommand)));
  }

  return NS_OK;
}

}  // namespace mozilla::dom::indexedDB