Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 621 insertions, 0 deletions

diff --git a/storage/QuotaVFS.cpp b/storage/QuotaVFS.cpp
new file mode 100644
index 0000000000..a736953fa2
--- /dev/null
+++ b/storage/QuotaVFS.cpp
@@ -0,0 +1,621 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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 "sqlite3.h"
+#include "mozilla/dom/quota/PersistenceType.h"
+#include "mozilla/dom/quota/QuotaManager.h"
+#include "mozilla/dom/quota/QuotaObject.h"
+#include "mozilla/dom/quota/ResultExtensions.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsEscape.h"
+#include "mozilla/StaticPrefs_storage.h"
+
+#if defined(XP_WIN) || defined(XP_UNIX)
+#  include "mozilla/StaticPrefs_dom.h"
+#endif
+
+// The last VFS version for which this file has been updated.
+#define LAST_KNOWN_VFS_VERSION 3
+
+// The last io_methods version for which this file has been updated.
+#define LAST_KNOWN_IOMETHODS_VERSION 3
+
+namespace {
+
+using namespace mozilla;
+using namespace mozilla::dom::quota;
+
+struct QuotaFile {
+  // Base class.  Must be first
+  sqlite3_file base;
+
+  // quota object for this file
+  RefPtr<QuotaObject> quotaObject;
+
+  // The chunk size for this file. See the documentation for
+  // sqlite3_file_control() and FCNTL_CHUNK_SIZE.
+  int fileChunkSize;
+
+  // This contains the vfs that actually does work
+  sqlite3_file pReal[1];
+};
+
+already_AddRefed<QuotaObject> GetQuotaObjectFromName(const char* zName) {
+  MOZ_ASSERT(zName);
+
+  const char* directoryLockIdParam =
+      sqlite3_uri_parameter(zName, "directoryLockId");
+  if (!directoryLockIdParam) {
+    return nullptr;
+  }
+
+  nsresult rv;
+  const int64_t directoryLockId =
+      nsDependentCString(directoryLockIdParam).ToInteger64(&rv);
+  MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+
+  QuotaManager* quotaManager = QuotaManager::Get();
+  MOZ_ASSERT(quotaManager);
+
+  return quotaManager->GetQuotaObject(directoryLockId,
+                                      NS_ConvertUTF8toUTF16(zName));
+}
+
+void MaybeEstablishQuotaControl(const char* zName, QuotaFile* pFile,
+                                int flags) {
+  MOZ_ASSERT(pFile);
+  MOZ_ASSERT(!pFile->quotaObject);
+
+  if (!(flags & (SQLITE_OPEN_URI | SQLITE_OPEN_WAL))) {
+    return;
+  }
+  pFile->quotaObject = GetQuotaObjectFromName(zName);
+}
+
+/*
+** Close a QuotaFile.
+*/
+int QuotaClose(sqlite3_file* pFile) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xClose(p->pReal);
+  if (rc == SQLITE_OK) {
+    delete p->base.pMethods;
+    p->base.pMethods = nullptr;
+    p->quotaObject = nullptr;
+#ifdef DEBUG
+    p->fileChunkSize = 0;
+#endif
+  }
+  return rc;
+}
+
+/*
+** Read data from a QuotaFile.
+*/
+int QuotaRead(sqlite3_file* pFile, void* zBuf, int iAmt, sqlite_int64 iOfst) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
+  return rc;
+}
+
+/*
+** Return the current file-size of a QuotaFile.
+*/
+int QuotaFileSize(sqlite3_file* pFile, sqlite_int64* pSize) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
+  return rc;
+}
+
+/*
+** Write data to a QuotaFile.
+*/
+int QuotaWrite(sqlite3_file* pFile, const void* zBuf, int iAmt,
+               sqlite_int64 iOfst) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  if (p->quotaObject) {
+    MOZ_ASSERT(INT64_MAX - iOfst >= iAmt);
+    if (!p->quotaObject->MaybeUpdateSize(iOfst + iAmt, /* aTruncate */ false)) {
+      return SQLITE_FULL;
+    }
+  }
+  rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
+  if (p->quotaObject && rc != SQLITE_OK) {
+    NS_WARNING(
+        "xWrite failed on a quota-controlled file, attempting to "
+        "update its current size...");
+    sqlite_int64 currentSize;
+    if (QuotaFileSize(pFile, &currentSize) == SQLITE_OK) {
+      DebugOnly<bool> res =
+          p->quotaObject->MaybeUpdateSize(currentSize, /* aTruncate */ true);
+      MOZ_ASSERT(res);
+    }
+  }
+  return rc;
+}
+
+/*
+** Truncate a QuotaFile.
+*/
+int QuotaTruncate(sqlite3_file* pFile, sqlite_int64 size) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  if (p->quotaObject) {
+    if (p->fileChunkSize > 0) {
+      // Round up to the smallest multiple of the chunk size that will hold all
+      // the data.
+      size =
+          ((size + p->fileChunkSize - 1) / p->fileChunkSize) * p->fileChunkSize;
+    }
+    if (!p->quotaObject->MaybeUpdateSize(size, /* aTruncate */ true)) {
+      return SQLITE_FULL;
+    }
+  }
+  rc = p->pReal->pMethods->xTruncate(p->pReal, size);
+  if (p->quotaObject) {
+    if (rc == SQLITE_OK) {
+#ifdef DEBUG
+      // Make sure xTruncate set the size exactly as we calculated above.
+      sqlite_int64 newSize;
+      MOZ_ASSERT(QuotaFileSize(pFile, &newSize) == SQLITE_OK);
+      MOZ_ASSERT(newSize == size);
+#endif
+    } else {
+      NS_WARNING(
+          "xTruncate failed on a quota-controlled file, attempting to "
+          "update its current size...");
+      if (QuotaFileSize(pFile, &size) == SQLITE_OK) {
+        DebugOnly<bool> res =
+            p->quotaObject->MaybeUpdateSize(size, /* aTruncate */ true);
+        MOZ_ASSERT(res);
+      }
+    }
+  }
+  return rc;
+}
+
+/*
+** Sync a QuotaFile.
+*/
+int QuotaSync(sqlite3_file* pFile, int flags) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  return p->pReal->pMethods->xSync(p->pReal, flags);
+}
+
+/*
+** Lock a QuotaFile.
+*/
+int QuotaLock(sqlite3_file* pFile, int eLock) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xLock(p->pReal, eLock);
+  return rc;
+}
+
+/*
+** Unlock a QuotaFile.
+*/
+int QuotaUnlock(sqlite3_file* pFile, int eLock) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xUnlock(p->pReal, eLock);
+  return rc;
+}
+
+/*
+** Check if another file-handle holds a RESERVED lock on a QuotaFile.
+*/
+int QuotaCheckReservedLock(sqlite3_file* pFile, int* pResOut) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
+  return rc;
+}
+
+/*
+** File control method. For custom operations on a QuotaFile.
+*/
+int QuotaFileControl(sqlite3_file* pFile, int op, void* pArg) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  // Hook SQLITE_FCNTL_SIZE_HINT for quota-controlled files and do the necessary
+  // work before passing to the SQLite VFS.
+  if (op == SQLITE_FCNTL_SIZE_HINT && p->quotaObject) {
+    sqlite3_int64 hintSize = *static_cast<sqlite3_int64*>(pArg);
+    sqlite3_int64 currentSize;
+    rc = QuotaFileSize(pFile, &currentSize);
+    if (rc != SQLITE_OK) {
+      return rc;
+    }
+    if (hintSize > currentSize) {
+      rc = QuotaTruncate(pFile, hintSize);
+      if (rc != SQLITE_OK) {
+        return rc;
+      }
+    }
+  }
+  rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
+  // Grab the file chunk size after the SQLite VFS has approved.
+  if (op == SQLITE_FCNTL_CHUNK_SIZE && rc == SQLITE_OK) {
+    p->fileChunkSize = *static_cast<int*>(pArg);
+  }
+#ifdef DEBUG
+  if (op == SQLITE_FCNTL_SIZE_HINT && p->quotaObject && rc == SQLITE_OK) {
+    sqlite3_int64 hintSize = *static_cast<sqlite3_int64*>(pArg);
+    if (p->fileChunkSize > 0) {
+      hintSize = ((hintSize + p->fileChunkSize - 1) / p->fileChunkSize) *
+                 p->fileChunkSize;
+    }
+    sqlite3_int64 currentSize;
+    MOZ_ASSERT(QuotaFileSize(pFile, &currentSize) == SQLITE_OK);
+    MOZ_ASSERT(currentSize >= hintSize);
+  }
+#endif
+  return rc;
+}
+
+/*
+** Return the sector-size in bytes for a QuotaFile.
+*/
+int QuotaSectorSize(sqlite3_file* pFile) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xSectorSize(p->pReal);
+  return rc;
+}
+
+/*
+** Return the device characteristic flags supported by a QuotaFile.
+*/
+int QuotaDeviceCharacteristics(sqlite3_file* pFile) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
+  return rc;
+}
+
+/*
+** Shared-memory operations.
+*/
+int QuotaShmLock(sqlite3_file* pFile, int ofst, int n, int flags) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  return p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
+}
+
+int QuotaShmMap(sqlite3_file* pFile, int iRegion, int szRegion, int isWrite,
+                void volatile** pp) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
+  return rc;
+}
+
+void QuotaShmBarrier(sqlite3_file* pFile) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  p->pReal->pMethods->xShmBarrier(p->pReal);
+}
+
+int QuotaShmUnmap(sqlite3_file* pFile, int delFlag) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  int rc;
+  rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
+  return rc;
+}
+
+int QuotaFetch(sqlite3_file* pFile, sqlite3_int64 iOff, int iAmt, void** pp) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  MOZ_ASSERT(p->pReal->pMethods->iVersion >= 3);
+  return p->pReal->pMethods->xFetch(p->pReal, iOff, iAmt, pp);
+}
+
+int QuotaUnfetch(sqlite3_file* pFile, sqlite3_int64 iOff, void* pResOut) {
+  QuotaFile* p = (QuotaFile*)pFile;
+  MOZ_ASSERT(p->pReal->pMethods->iVersion >= 3);
+  return p->pReal->pMethods->xUnfetch(p->pReal, iOff, pResOut);
+}
+
+int QuotaOpen(sqlite3_vfs* vfs, const char* zName, sqlite3_file* pFile,
+              int flags, int* pOutFlags) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  int rc;
+  QuotaFile* p = (QuotaFile*)pFile;
+
+  MaybeEstablishQuotaControl(zName, p, flags);
+
+  rc = orig_vfs->xOpen(orig_vfs, zName, p->pReal, flags, pOutFlags);
+  if (rc != SQLITE_OK) return rc;
+  if (p->pReal->pMethods) {
+    sqlite3_io_methods* pNew = new sqlite3_io_methods;
+    const sqlite3_io_methods* pSub = p->pReal->pMethods;
+    memset(pNew, 0, sizeof(*pNew));
+    // If the io_methods version is higher than the last known one, you should
+    // update this VFS adding appropriate IO methods for any methods added in
+    // the version change.
+    pNew->iVersion = pSub->iVersion;
+    MOZ_ASSERT(pNew->iVersion <= LAST_KNOWN_IOMETHODS_VERSION);
+    pNew->xClose = QuotaClose;
+    pNew->xRead = QuotaRead;
+    pNew->xWrite = QuotaWrite;
+    pNew->xTruncate = QuotaTruncate;
+    pNew->xSync = QuotaSync;
+    pNew->xFileSize = QuotaFileSize;
+    pNew->xLock = QuotaLock;
+    pNew->xUnlock = QuotaUnlock;
+    pNew->xCheckReservedLock = QuotaCheckReservedLock;
+    pNew->xFileControl = QuotaFileControl;
+    pNew->xSectorSize = QuotaSectorSize;
+    pNew->xDeviceCharacteristics = QuotaDeviceCharacteristics;
+    if (pNew->iVersion >= 2) {
+      // Methods added in version 2.
+      pNew->xShmMap = pSub->xShmMap ? QuotaShmMap : nullptr;
+      pNew->xShmLock = pSub->xShmLock ? QuotaShmLock : nullptr;
+      pNew->xShmBarrier = pSub->xShmBarrier ? QuotaShmBarrier : nullptr;
+      pNew->xShmUnmap = pSub->xShmUnmap ? QuotaShmUnmap : nullptr;
+    }
+    if (pNew->iVersion >= 3) {
+      // Methods added in version 3.
+      // SQLite 3.7.17 calls these methods without checking for nullptr first,
+      // so we always define them.  Verify that we're not going to call
+      // nullptrs, though.
+      MOZ_ASSERT(pSub->xFetch);
+      pNew->xFetch = QuotaFetch;
+      MOZ_ASSERT(pSub->xUnfetch);
+      pNew->xUnfetch = QuotaUnfetch;
+    }
+    pFile->pMethods = pNew;
+  }
+  return rc;
+}
+
+int QuotaDelete(sqlite3_vfs* vfs, const char* zName, int syncDir) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  int rc;
+  RefPtr<QuotaObject> quotaObject;
+
+  if (StringEndsWith(nsDependentCString(zName), "-wal"_ns)) {
+    quotaObject = GetQuotaObjectFromName(zName);
+  }
+
+  rc = orig_vfs->xDelete(orig_vfs, zName, syncDir);
+  if (rc == SQLITE_OK && quotaObject) {
+    MOZ_ALWAYS_TRUE(quotaObject->MaybeUpdateSize(0, /* aTruncate */ true));
+  }
+
+  return rc;
+}
+
+int QuotaAccess(sqlite3_vfs* vfs, const char* zName, int flags, int* pResOut) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xAccess(orig_vfs, zName, flags, pResOut);
+}
+
+int QuotaFullPathname(sqlite3_vfs* vfs, const char* zName, int nOut,
+                      char* zOut) {
+#if defined(XP_WIN)
+  // SQLite uses GetFullPathnameW which also normailizes file path. If a file
+  // component ends with a dot, it would be removed. However, it's not desired.
+  //
+  // And that would result SQLite uses wrong database and quotaObject.
+  // Note that we are safe to avoid the GetFullPathnameW call for \\?\ prefixed
+  // paths.
+  // And note that this hack will be removed once the issue is fixed directly in
+  // SQLite.
+
+  // zName that starts with "//?/" is the case when a file URI was passed and
+  // zName that starts with "\\?\" is the case when a normal path was passed
+  // (not file URI).
+  if (StaticPrefs::dom_quotaManager_overrideXFullPathname() &&
+      ((zName[0] == '/' && zName[1] == '/' && zName[2] == '?' &&
+        zName[3] == '/') ||
+       (zName[0] == '\\' && zName[1] == '\\' && zName[2] == '?' &&
+        zName[3] == '\\'))) {
+    MOZ_ASSERT(nOut >= vfs->mxPathname);
+    MOZ_ASSERT(static_cast<size_t>(nOut) > strlen(zName));
+
+    size_t index = 0;
+    while (zName[index] != '\0') {
+      if (zName[index] == '/') {
+        zOut[index] = '\\';
+      } else {
+        zOut[index] = zName[index];
+      }
+
+      index++;
+    }
+    zOut[index] = '\0';
+
+    return SQLITE_OK;
+  }
+#elif defined(XP_UNIX)
+  // SQLite canonicalizes (resolves path components) file paths on Unix which
+  // doesn't work well with file path sanity checks in quota manager. This is
+  // especially a problem on mac where /var is a symlink to /private/var.
+  // Since QuotaVFS is used only by quota clients which never access databases
+  // outside of PROFILE/storage, we override Unix xFullPathname with own
+  // implementation that doesn't do any canonicalization.
+
+  if (StaticPrefs::dom_quotaManager_overrideXFullPathnameUnix()) {
+    if (nOut < 0) {
+      // Match the return code used by SQLite's xFullPathname implementation
+      // here and below.
+      return SQLITE_CANTOPEN;
+    }
+
+    QM_TRY_INSPECT(
+        const auto& path, ([&zName]() -> Result<nsString, nsresult> {
+          NS_ConvertUTF8toUTF16 name(zName);
+
+          if (name.First() == '/') {
+            return std::move(name);
+          }
+
+          QM_TRY_INSPECT(const auto& file,
+                         MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<nsIFile>,
+                                                    NS_GetSpecialDirectory,
+                                                    NS_OS_CURRENT_WORKING_DIR));
+
+          QM_TRY(MOZ_TO_RESULT(file->Append(name)));
+
+          QM_TRY_RETURN(
+              MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, file, GetPath));
+        }()),
+        SQLITE_CANTOPEN);
+
+    QM_TRY_INSPECT(const auto& quotaFile, QM_NewLocalFile(path),
+                   SQLITE_CANTOPEN);
+
+    QM_TRY_INSPECT(
+        const auto& quotaPath,
+        MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, quotaFile, GetPath),
+        SQLITE_CANTOPEN);
+
+    NS_ConvertUTF16toUTF8 sqlitePath(quotaPath);
+
+    if (sqlitePath.Length() > (unsigned int)nOut) {
+      return SQLITE_CANTOPEN;
+    }
+
+    nsCharTraits<char>::copy(zOut, sqlitePath.get(), sqlitePath.Length());
+    zOut[sqlitePath.Length()] = '\0';
+
+    return SQLITE_OK;
+  }
+#endif
+
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xFullPathname(orig_vfs, zName, nOut, zOut);
+}
+
+void* QuotaDlOpen(sqlite3_vfs* vfs, const char* zFilename) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xDlOpen(orig_vfs, zFilename);
+}
+
+void QuotaDlError(sqlite3_vfs* vfs, int nByte, char* zErrMsg) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  orig_vfs->xDlError(orig_vfs, nByte, zErrMsg);
+}
+
+void (*QuotaDlSym(sqlite3_vfs* vfs, void* pHdle, const char* zSym))(void) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xDlSym(orig_vfs, pHdle, zSym);
+}
+
+void QuotaDlClose(sqlite3_vfs* vfs, void* pHandle) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  orig_vfs->xDlClose(orig_vfs, pHandle);
+}
+
+int QuotaRandomness(sqlite3_vfs* vfs, int nByte, char* zOut) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xRandomness(orig_vfs, nByte, zOut);
+}
+
+int QuotaSleep(sqlite3_vfs* vfs, int microseconds) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xSleep(orig_vfs, microseconds);
+}
+
+int QuotaCurrentTime(sqlite3_vfs* vfs, double* prNow) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xCurrentTime(orig_vfs, prNow);
+}
+
+int QuotaGetLastError(sqlite3_vfs* vfs, int nBuf, char* zBuf) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xGetLastError(orig_vfs, nBuf, zBuf);
+}
+
+int QuotaCurrentTimeInt64(sqlite3_vfs* vfs, sqlite3_int64* piNow) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xCurrentTimeInt64(orig_vfs, piNow);
+}
+
+static int QuotaSetSystemCall(sqlite3_vfs* vfs, const char* zName,
+                              sqlite3_syscall_ptr pFunc) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xSetSystemCall(orig_vfs, zName, pFunc);
+}
+
+static sqlite3_syscall_ptr QuotaGetSystemCall(sqlite3_vfs* vfs,
+                                              const char* zName) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xGetSystemCall(orig_vfs, zName);
+}
+
+static const char* QuotaNextSystemCall(sqlite3_vfs* vfs, const char* zName) {
+  sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+  return orig_vfs->xNextSystemCall(orig_vfs, zName);
+}
+
+}  // namespace
+
+namespace mozilla {
+namespace storage {
+
+const char* GetQuotaVFSName() { return "quotavfs"; }
+
+UniquePtr<sqlite3_vfs> ConstructQuotaVFS(const char* aBaseVFSName) {
+  MOZ_ASSERT(aBaseVFSName);
+
+  if (sqlite3_vfs_find(GetQuotaVFSName()) != nullptr) {
+    return nullptr;
+  }
+  sqlite3_vfs* vfs = sqlite3_vfs_find(aBaseVFSName);
+  if (!vfs) {
+    return nullptr;
+  }
+
+  auto qvfs = MakeUnique<sqlite3_vfs>();
+  memset(qvfs.get(), 0, sizeof(::sqlite3_vfs));
+  // If the VFS version is higher than the last known one, you should update
+  // this VFS adding appropriate methods for any methods added in the version
+  // change.
+  qvfs->iVersion = vfs->iVersion;
+  MOZ_ASSERT(vfs->iVersion <= LAST_KNOWN_VFS_VERSION);
+  qvfs->szOsFile = static_cast<int>(sizeof(QuotaFile) - sizeof(sqlite3_file) +
+                                    vfs->szOsFile);
+  qvfs->mxPathname = vfs->mxPathname;
+  qvfs->zName = GetQuotaVFSName();
+  qvfs->pAppData = vfs;
+  qvfs->xOpen = QuotaOpen;
+  qvfs->xDelete = QuotaDelete;
+  qvfs->xAccess = QuotaAccess;
+  qvfs->xFullPathname = QuotaFullPathname;
+  qvfs->xDlOpen = QuotaDlOpen;
+  qvfs->xDlError = QuotaDlError;
+  qvfs->xDlSym = QuotaDlSym;
+  qvfs->xDlClose = QuotaDlClose;
+  qvfs->xRandomness = QuotaRandomness;
+  qvfs->xSleep = QuotaSleep;
+  qvfs->xCurrentTime = QuotaCurrentTime;
+  qvfs->xGetLastError = QuotaGetLastError;
+  if (qvfs->iVersion >= 2) {
+    // Methods added in version 2.
+    qvfs->xCurrentTimeInt64 = QuotaCurrentTimeInt64;
+  }
+  if (qvfs->iVersion >= 3) {
+    // Methods added in version 3.
+    qvfs->xSetSystemCall = QuotaSetSystemCall;
+    qvfs->xGetSystemCall = QuotaGetSystemCall;
+    qvfs->xNextSystemCall = QuotaNextSystemCall;
+  }
+  return qvfs;
+}
+
+already_AddRefed<QuotaObject> GetQuotaObjectForFile(sqlite3_file* pFile) {
+  MOZ_ASSERT(pFile);
+
+  QuotaFile* p = (QuotaFile*)pFile;
+  RefPtr<QuotaObject> result = p->quotaObject;
+  return result.forget();
+}
+
+}  // namespace storage
+}  // namespace mozilla