Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 2772 insertions, 0 deletions

diff --git a/dom/cache/DBSchema.cpp b/dom/cache/DBSchema.cpp
new file mode 100644
index 0000000000..e52a3c4227
--- /dev/null
+++ b/dom/cache/DBSchema.cpp
@@ -0,0 +1,2772 @@
+/* -*- 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 "mozilla/dom/cache/DBSchema.h"
+
+#include "ipc/IPCMessageUtils.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/dom/HeadersBinding.h"
+#include "mozilla/dom/InternalHeaders.h"
+#include "mozilla/dom/InternalResponse.h"
+#include "mozilla/dom/RequestBinding.h"
+#include "mozilla/dom/ResponseBinding.h"
+#include "mozilla/dom/cache/CacheCommon.h"
+#include "mozilla/dom/cache/CacheTypes.h"
+#include "mozilla/dom/cache/SavedTypes.h"
+#include "mozilla/dom/cache/Types.h"
+#include "mozilla/dom/cache/TypeUtils.h"
+#include "mozilla/net/MozURL.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/StaticPrefs_extensions.h"
+#include "mozIStorageConnection.h"
+#include "mozIStorageStatement.h"
+#include "mozStorageHelper.h"
+#include "nsCharSeparatedTokenizer.h"
+#include "nsCOMPtr.h"
+#include "nsComponentManagerUtils.h"
+#include "nsHttp.h"
+#include "nsIContentPolicy.h"
+#include "nsICryptoHash.h"
+#include "nsNetCID.h"
+#include "nsPrintfCString.h"
+#include "nsTArray.h"
+
+namespace mozilla::dom::cache::db {
+const int32_t kFirstShippedSchemaVersion = 15;
+namespace {
+// ## Firefox 57 Cache API v25/v26/v27 Schema Hack Info
+// ### Overview
+// In Firefox 57 we introduced Cache API schema version 26 and Quota Manager
+// schema v3 to support tracking padding for opaque responses.  Unfortunately,
+// Firefox 57 is a big release that may potentially result in users downgrading
+// to Firefox 56 due to 57 retiring add-ons.  These schema changes have the
+// unfortunate side-effect of causing QuotaManager and all its clients to break
+// if the user downgrades to 56.  In order to avoid making a bad situation
+// worse, we're now retrofitting 57 so that Firefox 56 won't freak out.
+//
+// ### Implementation
+// We're introducing a new schema version 27 that uses an on-disk schema version
+// of v25.  We differentiate v25 from v27 by the presence of the column added
+// by v26.  This translates to:
+// - v25: on-disk schema=25, no "response_padding_size" column in table
+//   "entries".
+// - v26: on-disk schema=26, yes "response_padding_size" column in table
+//   "entries".
+// - v27: on-disk schema=25, yes "response_padding_size" column in table
+//   "entries".
+//
+// ### Fallout
+// Firefox 57 is happy because it sees schema 27 and everything is as it
+// expects.
+//
+// Firefox 56 non-DEBUG build is fine/happy, but DEBUG builds will not be.
+// - Our QuotaClient will invoke `NS_WARNING("Unknown Cache file found!");`
+//   at QuotaManager init time.  This is harmless but annoying and potentially
+//   misleading.
+// - The DEBUG-only Validate() call will error out whenever an attempt is made
+//   to open a DOM Cache database because it will notice the schema is broken
+//   and there is no attempt at recovery.
+//
+const int32_t kHackyDowngradeSchemaVersion = 25;
+const int32_t kHackyPaddingSizePresentVersion = 27;
+//
+// Update this whenever the DB schema is changed.
+const int32_t kLatestSchemaVersion = 27;
+// ---------
+// The following constants define the SQL schema.  These are defined in the
+// same order the SQL should be executed in CreateOrMigrateSchema().  They are
+// broken out as constants for convenient use in validation and migration.
+// ---------
+// The caches table is the single source of truth about what Cache
+// objects exist for the origin.  The contents of the Cache are stored
+// in the entries table that references back to caches.
+//
+// The caches table is also referenced from storage.  Rows in storage
+// represent named Cache objects.  There are cases, however, where
+// a Cache can still exist, but not be in a named Storage.  For example,
+// when content is still using the Cache after CacheStorage::Delete()
+// has been run.
+//
+// For now, the caches table mainly exists for data integrity with
+// foreign keys, but could be expanded to contain additional cache object
+// information.
+//
+// AUTOINCREMENT is necessary to prevent CacheId values from being reused.
+const char kTableCaches[] =
+    "CREATE TABLE caches ("
+    "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT "
+    ")";
+
+// Security blobs are quite large and duplicated for every Response from
+// the same https origin.  This table is used to de-duplicate this data.
+const char kTableSecurityInfo[] =
+    "CREATE TABLE security_info ("
+    "id INTEGER NOT NULL PRIMARY KEY, "
+    "hash BLOB NOT NULL, "  // first 8-bytes of the sha1 hash of data column
+    "data BLOB NOT NULL, "  // full security info data, usually a few KB
+    "refcount INTEGER NOT NULL"
+    ")";
+
+// Index the smaller hash value instead of the large security data blob.
+const char kIndexSecurityInfoHash[] =
+    "CREATE INDEX security_info_hash_index ON security_info (hash)";
+
+const char kTableEntries[] =
+    "CREATE TABLE entries ("
+    "id INTEGER NOT NULL PRIMARY KEY, "
+    "request_method TEXT NOT NULL, "
+    "request_url_no_query TEXT NOT NULL, "
+    "request_url_no_query_hash BLOB NOT NULL, "  // first 8-bytes of sha1 hash
+    "request_url_query TEXT NOT NULL, "
+    "request_url_query_hash BLOB NOT NULL, "  // first 8-bytes of sha1 hash
+    "request_referrer TEXT NOT NULL, "
+    "request_headers_guard INTEGER NOT NULL, "
+    "request_mode INTEGER NOT NULL, "
+    "request_credentials INTEGER NOT NULL, "
+    "request_contentpolicytype INTEGER NOT NULL, "
+    "request_cache INTEGER NOT NULL, "
+    "request_body_id TEXT NULL, "
+    "response_type INTEGER NOT NULL, "
+    "response_status INTEGER NOT NULL, "
+    "response_status_text TEXT NOT NULL, "
+    "response_headers_guard INTEGER NOT NULL, "
+    "response_body_id TEXT NULL, "
+    "response_security_info_id INTEGER NULL REFERENCES security_info(id), "
+    "response_principal_info TEXT NOT NULL, "
+    "cache_id INTEGER NOT NULL REFERENCES caches(id) ON DELETE CASCADE, "
+    "request_redirect INTEGER NOT NULL, "
+    "request_referrer_policy INTEGER NOT NULL, "
+    "request_integrity TEXT NOT NULL, "
+    "request_url_fragment TEXT NOT NULL, "
+    "response_padding_size INTEGER NULL "
+    // New columns must be added at the end of table to migrate and
+    // validate properly.
+    ")";
+// Create an index to support the QueryCache() matching algorithm.  This
+// needs to quickly find entries in a given Cache that match the request
+// URL.  The url query is separated in order to support the ignoreSearch
+// option.  Finally, we index hashes of the URL values instead of the
+// actual strings to avoid excessive disk bloat.  The index will duplicate
+// the contents of the columsn in the index.  The hash index will prune
+// the vast majority of values from the query result so that normal
+// scanning only has to be done on a few values to find an exact URL match.
+const char kIndexEntriesRequest[] =
+    "CREATE INDEX entries_request_match_index "
+    "ON entries (cache_id, request_url_no_query_hash, "
+    "request_url_query_hash)";
+
+const char kTableRequestHeaders[] =
+    "CREATE TABLE request_headers ("
+    "name TEXT NOT NULL, "
+    "value TEXT NOT NULL, "
+    "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE"
+    ")";
+
+const char kTableResponseHeaders[] =
+    "CREATE TABLE response_headers ("
+    "name TEXT NOT NULL, "
+    "value TEXT NOT NULL, "
+    "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE"
+    ")";
+
+// We need an index on response_headers, but not on request_headers,
+// because we quickly need to determine if a VARY header is present.
+const char kIndexResponseHeadersName[] =
+    "CREATE INDEX response_headers_name_index "
+    "ON response_headers (name)";
+
+const char kTableResponseUrlList[] =
+    "CREATE TABLE response_url_list ("
+    "url TEXT NOT NULL, "
+    "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE"
+    ")";
+
+// NOTE: key allows NULL below since that is how "" is represented
+//       in a BLOB column.  We use BLOB to avoid encoding issues
+//       with storing DOMStrings.
+const char kTableStorage[] =
+    "CREATE TABLE storage ("
+    "namespace INTEGER NOT NULL, "
+    "key BLOB NULL, "
+    "cache_id INTEGER NOT NULL REFERENCES caches(id), "
+    "PRIMARY KEY(namespace, key) "
+    ")";
+
+// ---------
+// End schema definition
+// ---------
+
+const int32_t kMaxEntriesPerStatement = 255;
+
+const uint32_t kPageSize = 4 * 1024;
+
+// Grow the database in chunks to reduce fragmentation
+const uint32_t kGrowthSize = 32 * 1024;
+const uint32_t kGrowthPages = kGrowthSize / kPageSize;
+static_assert(kGrowthSize % kPageSize == 0,
+              "Growth size must be multiple of page size");
+
+// Only release free pages when we have more than this limit
+const int32_t kMaxFreePages = kGrowthPages;
+
+// Limit WAL journal to a reasonable size
+const uint32_t kWalAutoCheckpointSize = 512 * 1024;
+const uint32_t kWalAutoCheckpointPages = kWalAutoCheckpointSize / kPageSize;
+static_assert(kWalAutoCheckpointSize % kPageSize == 0,
+              "WAL checkpoint size must be multiple of page size");
+
+}  // namespace
+
+// If any of the static_asserts below fail, it means that you have changed
+// the corresponding WebIDL enum in a way that may be incompatible with the
+// existing data stored in the DOM Cache.  You would need to update the Cache
+// database schema accordingly and adjust the failing static_assert.
+static_assert(int(HeadersGuardEnum::None) == 0 &&
+                  int(HeadersGuardEnum::Request) == 1 &&
+                  int(HeadersGuardEnum::Request_no_cors) == 2 &&
+                  int(HeadersGuardEnum::Response) == 3 &&
+                  int(HeadersGuardEnum::Immutable) == 4 &&
+                  HeadersGuardEnumValues::Count == 5,
+              "HeadersGuardEnum values are as expected");
+static_assert(int(ReferrerPolicy::_empty) == 0 &&
+                  int(ReferrerPolicy::No_referrer) == 1 &&
+                  int(ReferrerPolicy::No_referrer_when_downgrade) == 2 &&
+                  int(ReferrerPolicy::Origin) == 3 &&
+                  int(ReferrerPolicy::Origin_when_cross_origin) == 4 &&
+                  int(ReferrerPolicy::Unsafe_url) == 5 &&
+                  int(ReferrerPolicy::Same_origin) == 6 &&
+                  int(ReferrerPolicy::Strict_origin) == 7 &&
+                  int(ReferrerPolicy::Strict_origin_when_cross_origin) == 8 &&
+                  ReferrerPolicyValues::Count == 9,
+              "ReferrerPolicy values are as expected");
+static_assert(int(RequestMode::Same_origin) == 0 &&
+                  int(RequestMode::No_cors) == 1 &&
+                  int(RequestMode::Cors) == 2 &&
+                  int(RequestMode::Navigate) == 3 &&
+                  RequestModeValues::Count == 4,
+              "RequestMode values are as expected");
+static_assert(int(RequestCredentials::Omit) == 0 &&
+                  int(RequestCredentials::Same_origin) == 1 &&
+                  int(RequestCredentials::Include) == 2 &&
+                  RequestCredentialsValues::Count == 3,
+              "RequestCredentials values are as expected");
+static_assert(int(RequestCache::Default) == 0 &&
+                  int(RequestCache::No_store) == 1 &&
+                  int(RequestCache::Reload) == 2 &&
+                  int(RequestCache::No_cache) == 3 &&
+                  int(RequestCache::Force_cache) == 4 &&
+                  int(RequestCache::Only_if_cached) == 5 &&
+                  RequestCacheValues::Count == 6,
+              "RequestCache values are as expected");
+static_assert(int(RequestRedirect::Follow) == 0 &&
+                  int(RequestRedirect::Error) == 1 &&
+                  int(RequestRedirect::Manual) == 2 &&
+                  RequestRedirectValues::Count == 3,
+              "RequestRedirect values are as expected");
+static_assert(int(ResponseType::Basic) == 0 && int(ResponseType::Cors) == 1 &&
+                  int(ResponseType::Default) == 2 &&
+                  int(ResponseType::Error) == 3 &&
+                  int(ResponseType::Opaque) == 4 &&
+                  int(ResponseType::Opaqueredirect) == 5 &&
+                  ResponseTypeValues::Count == 6,
+              "ResponseType values are as expected");
+
+// If the static_asserts below fails, it means that you have changed the
+// Namespace enum in a way that may be incompatible with the existing data
+// stored in the DOM Cache.  You would need to update the Cache database schema
+// accordingly and adjust the failing static_assert.
+static_assert(DEFAULT_NAMESPACE == 0 && CHROME_ONLY_NAMESPACE == 1 &&
+                  NUMBER_OF_NAMESPACES == 2,
+              "Namespace values are as expected");
+
+// If the static_asserts below fails, it means that you have changed the
+// nsContentPolicy enum in a way that may be incompatible with the existing data
+// stored in the DOM Cache.  You would need to update the Cache database schema
+// accordingly and adjust the failing static_assert.
+static_assert(
+    nsIContentPolicy::TYPE_INVALID == 0 && nsIContentPolicy::TYPE_OTHER == 1 &&
+        nsIContentPolicy::TYPE_SCRIPT == 2 &&
+        nsIContentPolicy::TYPE_IMAGE == 3 &&
+        nsIContentPolicy::TYPE_STYLESHEET == 4 &&
+        nsIContentPolicy::TYPE_OBJECT == 5 &&
+        nsIContentPolicy::TYPE_DOCUMENT == 6 &&
+        nsIContentPolicy::TYPE_SUBDOCUMENT == 7 &&
+        nsIContentPolicy::TYPE_PING == 10 &&
+        nsIContentPolicy::TYPE_XMLHTTPREQUEST == 11 &&
+        nsIContentPolicy::TYPE_OBJECT_SUBREQUEST == 12 &&
+        nsIContentPolicy::TYPE_DTD == 13 && nsIContentPolicy::TYPE_FONT == 14 &&
+        nsIContentPolicy::TYPE_MEDIA == 15 &&
+        nsIContentPolicy::TYPE_WEBSOCKET == 16 &&
+        nsIContentPolicy::TYPE_CSP_REPORT == 17 &&
+        nsIContentPolicy::TYPE_XSLT == 18 &&
+        nsIContentPolicy::TYPE_BEACON == 19 &&
+        nsIContentPolicy::TYPE_FETCH == 20 &&
+        nsIContentPolicy::TYPE_IMAGESET == 21 &&
+        nsIContentPolicy::TYPE_WEB_MANIFEST == 22 &&
+        nsIContentPolicy::TYPE_INTERNAL_SCRIPT == 23 &&
+        nsIContentPolicy::TYPE_INTERNAL_WORKER == 24 &&
+        nsIContentPolicy::TYPE_INTERNAL_SHARED_WORKER == 25 &&
+        nsIContentPolicy::TYPE_INTERNAL_EMBED == 26 &&
+        nsIContentPolicy::TYPE_INTERNAL_OBJECT == 27 &&
+        nsIContentPolicy::TYPE_INTERNAL_FRAME == 28 &&
+        nsIContentPolicy::TYPE_INTERNAL_IFRAME == 29 &&
+        nsIContentPolicy::TYPE_INTERNAL_AUDIO == 30 &&
+        nsIContentPolicy::TYPE_INTERNAL_VIDEO == 31 &&
+        nsIContentPolicy::TYPE_INTERNAL_TRACK == 32 &&
+        nsIContentPolicy::TYPE_INTERNAL_XMLHTTPREQUEST == 33 &&
+        nsIContentPolicy::TYPE_INTERNAL_EVENTSOURCE == 34 &&
+        nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER == 35 &&
+        nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD == 36 &&
+        nsIContentPolicy::TYPE_INTERNAL_IMAGE == 37 &&
+        nsIContentPolicy::TYPE_INTERNAL_IMAGE_PRELOAD == 38 &&
+        nsIContentPolicy::TYPE_INTERNAL_STYLESHEET == 39 &&
+        nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD == 40 &&
+        nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON == 41 &&
+        nsIContentPolicy::TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS == 42 &&
+        nsIContentPolicy::TYPE_SAVEAS_DOWNLOAD == 43 &&
+        nsIContentPolicy::TYPE_SPECULATIVE == 44 &&
+        nsIContentPolicy::TYPE_INTERNAL_MODULE == 45 &&
+        nsIContentPolicy::TYPE_INTERNAL_MODULE_PRELOAD == 46 &&
+        nsIContentPolicy::TYPE_INTERNAL_DTD == 47 &&
+        nsIContentPolicy::TYPE_INTERNAL_FORCE_ALLOWED_DTD == 48 &&
+        nsIContentPolicy::TYPE_INTERNAL_AUDIOWORKLET == 49 &&
+        nsIContentPolicy::TYPE_INTERNAL_PAINTWORKLET == 50 &&
+        nsIContentPolicy::TYPE_INTERNAL_FONT_PRELOAD == 51 &&
+        nsIContentPolicy::TYPE_INTERNAL_CHROMEUTILS_COMPILED_SCRIPT == 52 &&
+        nsIContentPolicy::TYPE_INTERNAL_FRAME_MESSAGEMANAGER_SCRIPT == 53 &&
+        nsIContentPolicy::TYPE_INTERNAL_FETCH_PRELOAD == 54,
+    "nsContentPolicyType values are as expected");
+
+namespace {
+
+typedef int32_t EntryId;
+
+struct IdCount {
+  explicit IdCount(int32_t aId) : mId(aId), mCount(1) {}
+  int32_t mId;
+  int32_t mCount;
+};
+
+using EntryIds = AutoTArray<EntryId, 256>;
+
+static Result<EntryIds, nsresult> QueryAll(mozIStorageConnection& aConn,
+                                           CacheId aCacheId);
+static Result<EntryIds, nsresult> QueryCache(mozIStorageConnection& aConn,
+                                             CacheId aCacheId,
+                                             const CacheRequest& aRequest,
+                                             const CacheQueryParams& aParams,
+                                             uint32_t aMaxResults = UINT32_MAX);
+static Result<bool, nsresult> MatchByVaryHeader(mozIStorageConnection& aConn,
+                                                const CacheRequest& aRequest,
+                                                EntryId entryId);
+// Returns a success tuple containing the deleted body ids, deleted security ids
+// and deleted padding size.
+static Result<std::tuple<nsTArray<nsID>, AutoTArray<IdCount, 16>, int64_t>,
+              nsresult>
+DeleteEntries(mozIStorageConnection& aConn,
+              const nsTArray<EntryId>& aEntryIdList);
+static Result<int32_t, nsresult> InsertSecurityInfo(
+    mozIStorageConnection& aConn, nsICryptoHash& aCrypto,
+    const nsACString& aData);
+static nsresult DeleteSecurityInfo(mozIStorageConnection& aConn, int32_t aId,
+                                   int32_t aCount);
+static nsresult DeleteSecurityInfoList(
+    mozIStorageConnection& aConn,
+    const nsTArray<IdCount>& aDeletedStorageIdList);
+static nsresult InsertEntry(mozIStorageConnection& aConn, CacheId aCacheId,
+                            const CacheRequest& aRequest,
+                            const nsID* aRequestBodyId,
+                            const CacheResponse& aResponse,
+                            const nsID* aResponseBodyId);
+static Result<SavedResponse, nsresult> ReadResponse(
+    mozIStorageConnection& aConn, EntryId aEntryId);
+static Result<SavedRequest, nsresult> ReadRequest(mozIStorageConnection& aConn,
+                                                  EntryId aEntryId);
+
+static void AppendListParamsToQuery(nsACString& aQuery,
+                                    const nsTArray<EntryId>& aEntryIdList,
+                                    uint32_t aPos, int32_t aLen);
+static nsresult BindListParamsToQuery(mozIStorageStatement& aState,
+                                      const nsTArray<EntryId>& aEntryIdList,
+                                      uint32_t aPos, int32_t aLen);
+static nsresult BindId(mozIStorageStatement& aState, const nsACString& aName,
+                       const nsID* aId);
+static Result<nsID, nsresult> ExtractId(mozIStorageStatement& aState,
+                                        uint32_t aPos);
+static Result<NotNull<nsCOMPtr<mozIStorageStatement>>, nsresult>
+CreateAndBindKeyStatement(mozIStorageConnection& aConn,
+                          const char* aQueryFormat, const nsAString& aKey);
+static Result<nsAutoCString, nsresult> HashCString(nsICryptoHash& aCrypto,
+                                                   const nsACString& aIn);
+Result<int32_t, nsresult> GetEffectiveSchemaVersion(
+    mozIStorageConnection& aConn);
+nsresult Validate(mozIStorageConnection& aConn);
+nsresult Migrate(mozIStorageConnection& aConn);
+}  // namespace
+
+class MOZ_RAII AutoDisableForeignKeyChecking {
+ public:
+  explicit AutoDisableForeignKeyChecking(mozIStorageConnection* aConn)
+      : mConn(aConn), mForeignKeyCheckingDisabled(false) {
+    CACHE_TRY_INSPECT(const auto& state,
+                      quota::CreateAndExecuteSingleStepStatement(
+                          *mConn, "PRAGMA foreign_keys;"_ns),
+                      QM_VOID);
+
+    CACHE_TRY_INSPECT(const int32_t& mode,
+                      MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0), QM_VOID);
+
+    if (mode) {
+      CACHE_TRY(mConn->ExecuteSimpleSQL("PRAGMA foreign_keys = OFF;"_ns),
+                QM_VOID);
+      mForeignKeyCheckingDisabled = true;
+    }
+  }
+
+  ~AutoDisableForeignKeyChecking() {
+    if (mForeignKeyCheckingDisabled) {
+      CACHE_TRY(mConn->ExecuteSimpleSQL("PRAGMA foreign_keys = ON;"_ns),
+                QM_VOID);
+    }
+  }
+
+ private:
+  nsCOMPtr<mozIStorageConnection> mConn;
+  bool mForeignKeyCheckingDisabled;
+};
+
+nsresult CreateOrMigrateSchema(mozIStorageConnection& aConn) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_UNWRAP(int32_t schemaVersion, GetEffectiveSchemaVersion(aConn));
+
+  if (schemaVersion == kLatestSchemaVersion) {
+    // We already have the correct schema version.  Validate it matches
+    // our expected schema and then proceed.
+    CACHE_TRY(Validate(aConn));
+
+    return NS_OK;
+  }
+
+  // Turn off checking foreign keys before starting a transaction, and restore
+  // it once we're done.
+  AutoDisableForeignKeyChecking restoreForeignKeyChecking(&aConn);
+  mozStorageTransaction trans(&aConn, false,
+                              mozIStorageConnection::TRANSACTION_IMMEDIATE);
+
+  const bool migrating = schemaVersion != 0;
+
+  if (migrating) {
+    // A schema exists, but its not the current version.  Attempt to
+    // migrate it to our new schema.
+    CACHE_TRY(Migrate(aConn));
+  } else {
+    // There is no schema installed.  Create the database from scratch.
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableCaches)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableSecurityInfo)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexSecurityInfoHash)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableEntries)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexEntriesRequest)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableRequestHeaders)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableResponseHeaders)));
+    CACHE_TRY(
+        aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexResponseHeadersName)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableResponseUrlList)));
+    CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableStorage)));
+    CACHE_TRY(aConn.SetSchemaVersion(kHackyDowngradeSchemaVersion));
+    CACHE_TRY_UNWRAP(schemaVersion, GetEffectiveSchemaVersion(aConn));
+  }
+
+  CACHE_TRY(Validate(aConn));
+  CACHE_TRY(trans.Commit());
+
+  if (migrating) {
+    // Migrations happen infrequently and reflect a chance in DB structure.
+    // This is a good time to rebuild the database.  It also helps catch
+    // if a new migration is incorrect by fast failing on the corruption.
+    // Unfortunately, this must be performed outside of the transaction.
+
+    // XXX We don't propagate an error from vacuuming right now, due to Bug
+    // 1687685, contrary to the comment above saying we are failing fast.
+    CACHE_TRY(aConn.ExecuteSimpleSQL("VACUUM"_ns), NS_OK);
+  }
+
+  return NS_OK;
+}
+
+nsresult InitializeConnection(mozIStorageConnection& aConn) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // This function needs to perform per-connection initialization tasks that
+  // need to happen regardless of the schema.
+
+  // Note, the default encoding of UTF-8 is preferred.  mozStorage does all
+  // the work necessary to convert UTF-16 nsString values for us.  We don't
+  // need ordering and the binary equality operations are correct.  So, do
+  // NOT set PRAGMA encoding to UTF-16.
+
+  CACHE_TRY(aConn.ExecuteSimpleSQL(nsPrintfCString(
+      // Use a smaller page size to improve perf/footprint; default is too large
+      "PRAGMA page_size = %u; "
+      // Enable auto_vacuum; this must happen after page_size and before WAL
+      "PRAGMA auto_vacuum = INCREMENTAL; "
+      "PRAGMA foreign_keys = ON; ",
+      kPageSize)));
+
+  // Limit fragmentation by growing the database by many pages at once.
+  CACHE_TRY(
+      ToResult(aConn.SetGrowthIncrement(kGrowthSize, ""_ns))
+          .orElse([](const nsresult rv) -> Result<Ok, nsresult> {
+            if (rv == NS_ERROR_FILE_TOO_BIG) {
+              NS_WARNING(
+                  "Not enough disk space to set sqlite growth increment.");
+              return Ok{};
+            }
+            return Err(rv);
+          }));
+
+  // Enable WAL journaling.  This must be performed in a separate transaction
+  // after changing the page_size and enabling auto_vacuum.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(nsPrintfCString(
+      // WAL journal can grow to given number of *pages*
+      "PRAGMA wal_autocheckpoint = %u; "
+      // Always truncate the journal back to given number of *bytes*
+      "PRAGMA journal_size_limit = %u; "
+      // WAL must be enabled at the end to allow page size to be changed, etc.
+      "PRAGMA journal_mode = WAL; ",
+      kWalAutoCheckpointPages, kWalAutoCheckpointSize)));
+
+  // Verify that we successfully set the vacuum mode to incremental.  It
+  // is very easy to put the database in a state where the auto_vacuum
+  // pragma above fails silently.
+#ifdef DEBUG
+  {
+    CACHE_TRY_INSPECT(const auto& state,
+                      quota::CreateAndExecuteSingleStepStatement(
+                          aConn, "PRAGMA auto_vacuum;"_ns));
+
+    CACHE_TRY_INSPECT(const int32_t& mode,
+                      MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0));
+
+    // integer value 2 is incremental mode
+    CACHE_TRY(OkIf(mode == 2), NS_ERROR_UNEXPECTED);
+  }
+#endif
+
+  return NS_OK;
+}
+
+Result<CacheId, nsresult> CreateCacheId(mozIStorageConnection& aConn) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY(aConn.ExecuteSimpleSQL("INSERT INTO caches DEFAULT VALUES;"_ns));
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    quota::CreateAndExecuteSingleStepStatement<
+                        quota::SingleStepResult::ReturnNullIfNoResult>(
+                        aConn, "SELECT last_insert_rowid()"_ns));
+
+  CACHE_TRY(OkIf(state), Err(NS_ERROR_UNEXPECTED));
+
+  CACHE_TRY_INSPECT(const CacheId& id,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt64, 0));
+
+  return id;
+}
+
+Result<DeletionInfo, nsresult> DeleteCacheId(mozIStorageConnection& aConn,
+                                             CacheId aCacheId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // Delete the bodies explicitly as we need to read out the body IDs
+  // anyway.  These body IDs must be deleted one-by-one as content may
+  // still be referencing them invidivually.
+  CACHE_TRY_INSPECT(const auto& matches, QueryAll(aConn, aCacheId));
+
+  // XXX only deletedBodyIdList needs to be non-const
+  CACHE_TRY_UNWRAP(
+      (auto [deletedBodyIdList, deletedSecurityIdList, deletedPaddingSize]),
+      DeleteEntries(aConn, matches));
+
+  CACHE_TRY(DeleteSecurityInfoList(aConn, deletedSecurityIdList));
+
+  // Delete the remainder of the cache using cascade semantics.
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "DELETE FROM caches WHERE id=:id;"_ns));
+
+  CACHE_TRY(state->BindInt64ByName("id"_ns, aCacheId));
+
+  CACHE_TRY(state->Execute());
+
+  return DeletionInfo{std::move(deletedBodyIdList), deletedPaddingSize};
+}
+
+Result<AutoTArray<CacheId, 8>, nsresult> FindOrphanedCacheIds(
+    mozIStorageConnection& aConn) {
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "SELECT id FROM caches "
+                        "WHERE id NOT IN (SELECT cache_id from storage);"_ns));
+
+  CACHE_TRY_RETURN(
+      (quota::CollectElementsWhileHasResultTyped<AutoTArray<CacheId, 8>>(
+          *state, [](auto& stmt) {
+            CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 0));
+          })));
+}
+
+Result<int64_t, nsresult> FindOverallPaddingSize(mozIStorageConnection& aConn) {
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "SELECT response_padding_size FROM entries "
+                        "WHERE response_padding_size IS NOT NULL;"_ns));
+
+  int64_t overallPaddingSize = 0;
+
+  CACHE_TRY(quota::CollectWhileHasResult(
+      *state, [&overallPaddingSize](auto& stmt) -> Result<Ok, nsresult> {
+        CACHE_TRY_INSPECT(const int64_t& padding_size,
+                          MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 0));
+
+        MOZ_DIAGNOSTIC_ASSERT(padding_size >= 0);
+        MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - padding_size >= overallPaddingSize);
+        overallPaddingSize += padding_size;
+
+        return Ok{};
+      }));
+
+  return overallPaddingSize;
+}
+
+Result<nsTArray<nsID>, nsresult> GetKnownBodyIds(mozIStorageConnection& aConn) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& state,
+      MOZ_TO_RESULT_INVOKE_TYPED(
+          nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+          "SELECT request_body_id, response_body_id FROM entries;"_ns));
+
+  AutoTArray<nsID, 64> idList;
+
+  CACHE_TRY(quota::CollectWhileHasResult(
+      *state, [&idList](auto& stmt) -> Result<Ok, nsresult> {
+        // extract 0 to 2 nsID structs per row
+        for (uint32_t i = 0; i < 2; ++i) {
+          CACHE_TRY_INSPECT(const bool& isNull,
+                            MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, i));
+
+          if (!isNull) {
+            CACHE_TRY_INSPECT(const auto& id, ExtractId(stmt, i));
+
+            idList.AppendElement(id);
+          }
+        }
+
+        return Ok{};
+      }));
+
+  return std::move(idList);
+}
+
+Result<Maybe<SavedResponse>, nsresult> CacheMatch(
+    mozIStorageConnection& aConn, CacheId aCacheId,
+    const CacheRequest& aRequest, const CacheQueryParams& aParams) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(const auto& matches,
+                    QueryCache(aConn, aCacheId, aRequest, aParams, 1));
+
+  if (matches.IsEmpty()) {
+    return Maybe<SavedResponse>();
+  }
+
+  CACHE_TRY_UNWRAP(auto response, ReadResponse(aConn, matches[0]));
+
+  response.mCacheId = aCacheId;
+
+  return Some(std::move(response));
+}
+
+Result<nsTArray<SavedResponse>, nsresult> CacheMatchAll(
+    mozIStorageConnection& aConn, CacheId aCacheId,
+    const Maybe<CacheRequest>& aMaybeRequest, const CacheQueryParams& aParams) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& matches, ([&aConn, aCacheId, &aMaybeRequest, &aParams] {
+        if (aMaybeRequest.isNothing()) {
+          CACHE_TRY_RETURN(QueryAll(aConn, aCacheId));
+        }
+
+        CACHE_TRY_RETURN(
+            QueryCache(aConn, aCacheId, aMaybeRequest.ref(), aParams));
+      }()));
+
+  // TODO: replace this with a bulk load using SQL IN clause (bug 1110458)
+  CACHE_TRY_RETURN(TransformIntoNewArrayAbortOnErr(
+      matches,
+      [&aConn, aCacheId](const auto match) -> Result<SavedResponse, nsresult> {
+        CACHE_TRY_UNWRAP(auto savedResponse, ReadResponse(aConn, match));
+
+        savedResponse.mCacheId = aCacheId;
+        return savedResponse;
+      },
+      fallible));
+}
+
+Result<DeletionInfo, nsresult> CachePut(mozIStorageConnection& aConn,
+                                        CacheId aCacheId,
+                                        const CacheRequest& aRequest,
+                                        const nsID* aRequestBodyId,
+                                        const CacheResponse& aResponse,
+                                        const nsID* aResponseBodyId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& matches,
+      QueryCache(aConn, aCacheId, aRequest,
+                 CacheQueryParams(false, false, false, false, u""_ns)));
+
+  // XXX only deletedBodyIdList needs to be non-const
+  CACHE_TRY_UNWRAP(
+      (auto [deletedBodyIdList, deletedSecurityIdList, deletedPaddingSize]),
+      DeleteEntries(aConn, matches));
+
+  CACHE_TRY(InsertEntry(aConn, aCacheId, aRequest, aRequestBodyId, aResponse,
+                        aResponseBodyId));
+
+  // Delete the security values after doing the insert to avoid churning
+  // the security table when its not necessary.
+  CACHE_TRY(DeleteSecurityInfoList(aConn, deletedSecurityIdList));
+
+  return DeletionInfo{std::move(deletedBodyIdList), deletedPaddingSize};
+}
+
+Result<Maybe<DeletionInfo>, nsresult> CacheDelete(
+    mozIStorageConnection& aConn, CacheId aCacheId,
+    const CacheRequest& aRequest, const CacheQueryParams& aParams) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(const auto& matches,
+                    QueryCache(aConn, aCacheId, aRequest, aParams));
+
+  if (matches.IsEmpty()) {
+    return Maybe<DeletionInfo>();
+  }
+
+  // XXX only deletedBodyIdList needs to be non-const
+  CACHE_TRY_UNWRAP(
+      (auto [deletedBodyIdList, deletedSecurityIdList, deletedPaddingSize]),
+      DeleteEntries(aConn, matches));
+
+  CACHE_TRY(DeleteSecurityInfoList(aConn, deletedSecurityIdList));
+
+  return Some(DeletionInfo{std::move(deletedBodyIdList), deletedPaddingSize});
+}
+
+Result<nsTArray<SavedRequest>, nsresult> CacheKeys(
+    mozIStorageConnection& aConn, CacheId aCacheId,
+    const Maybe<CacheRequest>& aMaybeRequest, const CacheQueryParams& aParams) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& matches, ([&aConn, aCacheId, &aMaybeRequest, &aParams] {
+        if (aMaybeRequest.isNothing()) {
+          CACHE_TRY_RETURN(QueryAll(aConn, aCacheId));
+        }
+
+        CACHE_TRY_RETURN(
+            QueryCache(aConn, aCacheId, aMaybeRequest.ref(), aParams));
+      }()));
+
+  // TODO: replace this with a bulk load using SQL IN clause (bug 1110458)
+  CACHE_TRY_RETURN(TransformIntoNewArrayAbortOnErr(
+      matches,
+      [&aConn, aCacheId](const auto match) -> Result<SavedRequest, nsresult> {
+        CACHE_TRY_UNWRAP(auto savedRequest, ReadRequest(aConn, match));
+
+        savedRequest.mCacheId = aCacheId;
+        return savedRequest;
+      },
+      fallible));
+}
+
+Result<Maybe<SavedResponse>, nsresult> StorageMatch(
+    mozIStorageConnection& aConn, Namespace aNamespace,
+    const CacheRequest& aRequest, const CacheQueryParams& aParams) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // If we are given a cache to check, then simply find its cache ID
+  // and perform the match.
+  if (!aParams.cacheName().EqualsLiteral("")) {
+    CACHE_TRY_INSPECT(
+        const auto& maybeCacheId,
+        StorageGetCacheId(aConn, aNamespace, aParams.cacheName()));
+    if (maybeCacheId.isNothing()) {
+      return Maybe<SavedResponse>();
+    }
+
+    return CacheMatch(aConn, maybeCacheId.ref(), aRequest, aParams);
+  }
+
+  // Otherwise we need to get a list of all the cache IDs in this namespace.
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "SELECT cache_id FROM storage WHERE "
+                        "namespace=:namespace ORDER BY rowid;"_ns));
+
+  CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace));
+
+  CACHE_TRY_INSPECT(
+      const auto& cacheIdList,
+      (quota::CollectElementsWhileHasResultTyped<AutoTArray<CacheId, 32>>(
+          *state, [](auto& stmt) {
+            CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 0));
+          })));
+
+  // Now try to find a match in each cache in order
+  for (const auto cacheId : cacheIdList) {
+    CACHE_TRY_UNWRAP(auto matchedResponse,
+                     CacheMatch(aConn, cacheId, aRequest, aParams));
+
+    if (matchedResponse.isSome()) {
+      return matchedResponse;
+    }
+  }
+
+  return Maybe<SavedResponse>();
+}
+
+Result<Maybe<CacheId>, nsresult> StorageGetCacheId(mozIStorageConnection& aConn,
+                                                   Namespace aNamespace,
+                                                   const nsAString& aKey) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // How we constrain the key column depends on the value of our key.  Use
+  // a format string for the query and let CreateAndBindKeyStatement() fill
+  // it in for us.
+  const char* const query =
+      "SELECT cache_id FROM storage "
+      "WHERE namespace=:namespace AND %s "
+      "ORDER BY rowid;";
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    CreateAndBindKeyStatement(aConn, query, aKey));
+
+  CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace));
+
+  CACHE_TRY_INSPECT(const bool& hasMoreData,
+                    MOZ_TO_RESULT_INVOKE(*state, ExecuteStep));
+
+  if (!hasMoreData) {
+    return Maybe<CacheId>();
+  }
+
+  CACHE_TRY_RETURN(
+      MOZ_TO_RESULT_INVOKE(*state, GetInt64, 0).map(Some<CacheId>));
+}
+
+nsresult StoragePutCache(mozIStorageConnection& aConn, Namespace aNamespace,
+                         const nsAString& aKey, CacheId aCacheId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "INSERT INTO storage (namespace, key, cache_id) "
+                        "VALUES (:namespace, :key, :cache_id);"_ns));
+
+  CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace));
+  CACHE_TRY(state->BindStringAsBlobByName("key"_ns, aKey));
+  CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId));
+  CACHE_TRY(state->Execute());
+
+  return NS_OK;
+}
+
+nsresult StorageForgetCache(mozIStorageConnection& aConn, Namespace aNamespace,
+                            const nsAString& aKey) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // How we constrain the key column depends on the value of our key.  Use
+  // a format string for the query and let CreateAndBindKeyStatement() fill
+  // it in for us.
+  const char* const query =
+      "DELETE FROM storage WHERE namespace=:namespace AND %s;";
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    CreateAndBindKeyStatement(aConn, query, aKey));
+
+  CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace));
+
+  CACHE_TRY(state->Execute());
+
+  return NS_OK;
+}
+
+Result<nsTArray<nsString>, nsresult> StorageGetKeys(
+    mozIStorageConnection& aConn, Namespace aNamespace) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& state,
+      MOZ_TO_RESULT_INVOKE_TYPED(
+          nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+          "SELECT key FROM storage WHERE namespace=:namespace ORDER BY rowid;"_ns));
+
+  CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace));
+
+  CACHE_TRY_RETURN(quota::CollectElementsWhileHasResult(*state, [](auto& stmt) {
+    CACHE_TRY_RETURN(
+        MOZ_TO_RESULT_INVOKE_TYPED(nsString, stmt, GetBlobAsString, 0));
+  }));
+}
+
+namespace {
+
+Result<EntryIds, nsresult> QueryAll(mozIStorageConnection& aConn,
+                                    CacheId aCacheId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& state,
+      MOZ_TO_RESULT_INVOKE_TYPED(
+          nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+          "SELECT id FROM entries WHERE cache_id=:cache_id ORDER BY id;"_ns));
+
+  CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId));
+
+  CACHE_TRY_RETURN((quota::CollectElementsWhileHasResultTyped<EntryIds>(
+      *state, [](auto& stmt) {
+        CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(stmt, GetInt32, 0));
+      })));
+}
+
+Result<EntryIds, nsresult> QueryCache(mozIStorageConnection& aConn,
+                                      CacheId aCacheId,
+                                      const CacheRequest& aRequest,
+                                      const CacheQueryParams& aParams,
+                                      uint32_t aMaxResults) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT(aMaxResults > 0);
+
+  if (!aParams.ignoreMethod() &&
+      !aRequest.method().LowerCaseEqualsLiteral("get")) {
+    return Result<EntryIds, nsresult>{std::in_place};
+  }
+
+  nsAutoCString query(
+      "SELECT id, COUNT(response_headers.name) AS vary_count "
+      "FROM entries "
+      "LEFT OUTER JOIN response_headers ON "
+      "entries.id=response_headers.entry_id "
+      "AND response_headers.name='vary' COLLATE NOCASE "
+      "WHERE entries.cache_id=:cache_id "
+      "AND entries.request_url_no_query_hash=:url_no_query_hash ");
+
+  if (!aParams.ignoreSearch()) {
+    query.AppendLiteral("AND entries.request_url_query_hash=:url_query_hash ");
+  }
+
+  query.AppendLiteral("AND entries.request_url_no_query=:url_no_query ");
+
+  if (!aParams.ignoreSearch()) {
+    query.AppendLiteral("AND entries.request_url_query=:url_query ");
+  }
+
+  query.AppendLiteral("GROUP BY entries.id ORDER BY entries.id;");
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<mozIStorageStatement>,
+                                               aConn, CreateStatement, query));
+
+  CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId));
+
+  CACHE_TRY_INSPECT(
+      const auto& crypto,
+      ToResultGet<nsCOMPtr<nsICryptoHash>>(
+          MOZ_SELECT_OVERLOAD(do_CreateInstance), NS_CRYPTO_HASH_CONTRACTID));
+
+  CACHE_TRY_INSPECT(const auto& urlWithoutQueryHash,
+                    HashCString(*crypto, aRequest.urlWithoutQuery()));
+
+  CACHE_TRY(state->BindUTF8StringAsBlobByName("url_no_query_hash"_ns,
+                                              urlWithoutQueryHash));
+
+  if (!aParams.ignoreSearch()) {
+    CACHE_TRY_INSPECT(const auto& urlQueryHash,
+                      HashCString(*crypto, aRequest.urlQuery()));
+
+    CACHE_TRY(
+        state->BindUTF8StringAsBlobByName("url_query_hash"_ns, urlQueryHash));
+  }
+
+  CACHE_TRY(state->BindUTF8StringByName("url_no_query"_ns,
+                                        aRequest.urlWithoutQuery()));
+
+  if (!aParams.ignoreSearch()) {
+    CACHE_TRY(state->BindUTF8StringByName("url_query"_ns, aRequest.urlQuery()));
+  }
+
+  EntryIds entryIdList;
+
+  CACHE_TRY(CollectWhile(
+      [&state, &entryIdList, aMaxResults]() -> Result<bool, nsresult> {
+        if (entryIdList.Length() == aMaxResults) {
+          return false;
+        }
+        CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(state, ExecuteStep));
+      },
+      [&state, &entryIdList, ignoreVary = aParams.ignoreVary(), &aConn,
+       &aRequest]() -> Result<Ok, nsresult> {
+        CACHE_TRY_INSPECT(const EntryId& entryId,
+                          MOZ_TO_RESULT_INVOKE(state, GetInt32, 0));
+
+        CACHE_TRY_INSPECT(const int32_t& varyCount,
+                          MOZ_TO_RESULT_INVOKE(state, GetInt32, 1));
+
+        if (!ignoreVary && varyCount > 0) {
+          CACHE_TRY_INSPECT(const bool& matchedByVary,
+                            MatchByVaryHeader(aConn, aRequest, entryId));
+          if (!matchedByVary) {
+            return Ok{};
+          }
+        }
+
+        entryIdList.AppendElement(entryId);
+
+        return Ok{};
+      }));
+
+  return entryIdList;
+}
+
+Result<bool, nsresult> MatchByVaryHeader(mozIStorageConnection& aConn,
+                                         const CacheRequest& aRequest,
+                                         EntryId entryId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& varyValues,
+      ([&aConn, entryId]() -> Result<AutoTArray<nsCString, 8>, nsresult> {
+        CACHE_TRY_INSPECT(
+            const auto& state,
+            MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<mozIStorageStatement>, aConn,
+                                       CreateStatement,
+                                       "SELECT value FROM response_headers "
+                                       "WHERE name='vary' COLLATE NOCASE "
+                                       "AND entry_id=:entry_id;"_ns));
+
+        CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId));
+
+        CACHE_TRY_RETURN((
+            quota::CollectElementsWhileHasResultTyped<AutoTArray<nsCString, 8>>(
+                *state, [](auto& stmt) {
+                  CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE_TYPED(
+                      nsCString, stmt, GetUTF8String, 0));
+                })));
+      }()));
+
+  // Should not have called this function if this was not the case
+  MOZ_DIAGNOSTIC_ASSERT(!varyValues.IsEmpty());
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "SELECT name, value FROM request_headers "
+                        "WHERE entry_id=:entry_id;"_ns));
+
+  CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId));
+
+  RefPtr<InternalHeaders> cachedHeaders =
+      new InternalHeaders(HeadersGuardEnum::None);
+
+  CACHE_TRY(quota::CollectWhileHasResult(
+      *state, [&cachedHeaders](auto& stmt) -> Result<Ok, nsresult> {
+        CACHE_TRY_INSPECT(
+            const auto& name,
+            MOZ_TO_RESULT_INVOKE_TYPED(nsCString, stmt, GetUTF8String, 0));
+        CACHE_TRY_INSPECT(
+            const auto& value,
+            MOZ_TO_RESULT_INVOKE_TYPED(nsCString, stmt, GetUTF8String, 1));
+
+        ErrorResult errorResult;
+
+        cachedHeaders->Append(name, value, errorResult);
+        if (errorResult.Failed()) {
+          return Err(errorResult.StealNSResult());
+        }
+
+        return Ok{};
+      }));
+
+  RefPtr<InternalHeaders> queryHeaders =
+      TypeUtils::ToInternalHeaders(aRequest.headers());
+
+  // Assume the vary headers match until we find a conflict
+  bool varyHeadersMatch = true;
+
+  for (const auto& varyValue : varyValues) {
+    // Extract the header names inside the Vary header value.
+    bool bailOut = false;
+    for (const nsACString& header :
+         nsCCharSeparatedTokenizer(varyValue, NS_HTTP_HEADER_SEP).ToRange()) {
+      MOZ_DIAGNOSTIC_ASSERT(!header.EqualsLiteral("*"),
+                            "We should have already caught this in "
+                            "TypeUtils::ToPCacheResponseWithoutBody()");
+
+      ErrorResult errorResult;
+      nsAutoCString queryValue;
+      queryHeaders->Get(header, queryValue, errorResult);
+      if (errorResult.Failed()) {
+        errorResult.SuppressException();
+        MOZ_DIAGNOSTIC_ASSERT(queryValue.IsEmpty());
+      }
+
+      nsAutoCString cachedValue;
+      cachedHeaders->Get(header, cachedValue, errorResult);
+      if (errorResult.Failed()) {
+        errorResult.SuppressException();
+        MOZ_DIAGNOSTIC_ASSERT(cachedValue.IsEmpty());
+      }
+
+      if (queryValue != cachedValue) {
+        varyHeadersMatch = false;
+        bailOut = true;
+        break;
+      }
+    }
+
+    if (bailOut) {
+      break;
+    }
+  }
+
+  return varyHeadersMatch;
+}
+
+static nsresult DeleteEntriesInternal(
+    mozIStorageConnection& aConn, const nsTArray<EntryId>& aEntryIdList,
+    nsTArray<nsID>& aDeletedBodyIdListOut,
+    nsTArray<IdCount>& aDeletedSecurityIdListOut,
+    int64_t* aDeletedPaddingSizeOut, uint32_t aPos, uint32_t aLen) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT(aDeletedPaddingSizeOut);
+
+  if (aEntryIdList.IsEmpty()) {
+    return NS_OK;
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(aPos < aEntryIdList.Length());
+
+  // Sqlite limits the number of entries allowed for an IN clause,
+  // so split up larger operations.
+  if (aLen > kMaxEntriesPerStatement) {
+    int64_t overallDeletedPaddingSize = 0;
+    uint32_t curPos = aPos;
+    int32_t remaining = aLen;
+    while (remaining > 0) {
+      int64_t deletedPaddingSize = 0;
+      int32_t max = kMaxEntriesPerStatement;
+      int32_t curLen = std::min(max, remaining);
+      nsresult rv = DeleteEntriesInternal(
+          aConn, aEntryIdList, aDeletedBodyIdListOut, aDeletedSecurityIdListOut,
+          &deletedPaddingSize, curPos, curLen);
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+
+      MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - deletedPaddingSize >=
+                            overallDeletedPaddingSize);
+      overallDeletedPaddingSize += deletedPaddingSize;
+      curPos += curLen;
+      remaining -= curLen;
+    }
+
+    *aDeletedPaddingSizeOut += overallDeletedPaddingSize;
+    return NS_OK;
+  }
+
+  nsAutoCString query(
+      "SELECT "
+      "request_body_id, "
+      "response_body_id, "
+      "response_security_info_id, "
+      "response_padding_size "
+      "FROM entries WHERE id IN (");
+  AppendListParamsToQuery(query, aEntryIdList, aPos, aLen);
+  query.AppendLiteral(")");
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<mozIStorageStatement>,
+                                               aConn, CreateStatement, query));
+
+  CACHE_TRY(BindListParamsToQuery(*state, aEntryIdList, aPos, aLen));
+
+  int64_t overallPaddingSize = 0;
+
+  CACHE_TRY(quota::CollectWhileHasResult(
+      *state,
+      [&overallPaddingSize, &aDeletedBodyIdListOut,
+       &aDeletedSecurityIdListOut](auto& stmt) -> Result<Ok, nsresult> {
+        // extract 0 to 2 nsID structs per row
+        for (uint32_t i = 0; i < 2; ++i) {
+          CACHE_TRY_INSPECT(const bool& isNull,
+                            MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, i));
+
+          if (!isNull) {
+            CACHE_TRY_INSPECT(const auto& id, ExtractId(stmt, i));
+
+            aDeletedBodyIdListOut.AppendElement(id);
+          }
+        }
+
+        {  // and then a possible third entry for the security id
+          CACHE_TRY_INSPECT(const bool& isNull,
+                            MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, 2));
+
+          if (!isNull) {
+            CACHE_TRY_INSPECT(const int32_t& securityId,
+                              MOZ_TO_RESULT_INVOKE(stmt, GetInt32, 2));
+
+            // XXXtt: Consider using map for aDeletedSecuityIdListOut.
+            auto foundIt =
+                std::find_if(aDeletedSecurityIdListOut.begin(),
+                             aDeletedSecurityIdListOut.end(),
+                             [securityId](const auto& deletedSecurityId) {
+                               return deletedSecurityId.mId == securityId;
+                             });
+
+            if (foundIt == aDeletedSecurityIdListOut.end()) {
+              // Add a new entry for this ID with a count of 1, if it's not in
+              // the list
+              aDeletedSecurityIdListOut.AppendElement(IdCount(securityId));
+            } else {
+              // Otherwise, increment the count for this ID
+              foundIt->mCount += 1;
+            }
+          }
+        }
+
+        {
+          // It's possible to have null padding size for non-opaque response
+          CACHE_TRY_INSPECT(const bool& isNull,
+                            MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, 3));
+
+          if (!isNull) {
+            CACHE_TRY_INSPECT(const int64_t& paddingSize,
+                              MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 3));
+
+            MOZ_DIAGNOSTIC_ASSERT(paddingSize >= 0);
+            MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - overallPaddingSize >=
+                                  paddingSize);
+            overallPaddingSize += paddingSize;
+          }
+        }
+
+        return Ok{};
+      }));
+
+  *aDeletedPaddingSizeOut = overallPaddingSize;
+
+  // Dependent records removed via ON DELETE CASCADE
+
+  query = "DELETE FROM entries WHERE id IN ("_ns;
+  AppendListParamsToQuery(query, aEntryIdList, aPos, aLen);
+  query.AppendLiteral(")");
+
+  {
+    CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(
+                                             nsCOMPtr<mozIStorageStatement>,
+                                             aConn, CreateStatement, query));
+
+    CACHE_TRY(BindListParamsToQuery(*state, aEntryIdList, aPos, aLen));
+
+    CACHE_TRY(state->Execute());
+  }
+
+  return NS_OK;
+}
+
+Result<std::tuple<nsTArray<nsID>, AutoTArray<IdCount, 16>, int64_t>, nsresult>
+DeleteEntries(mozIStorageConnection& aConn,
+              const nsTArray<EntryId>& aEntryIdList) {
+  auto result =
+      std::make_tuple(nsTArray<nsID>{}, AutoTArray<IdCount, 16>{}, int64_t{0});
+  CACHE_TRY(DeleteEntriesInternal(aConn, aEntryIdList, std::get<0>(result),
+                                  std::get<1>(result), &std::get<2>(result), 0,
+                                  aEntryIdList.Length()));
+
+  return result;
+}
+
+Result<int32_t, nsresult> InsertSecurityInfo(mozIStorageConnection& aConn,
+                                             nsICryptoHash& aCrypto,
+                                             const nsACString& aData) {
+  MOZ_DIAGNOSTIC_ASSERT(!aData.IsEmpty());
+
+  // We want to use an index to find existing security blobs, but indexing
+  // the full blob would be quite expensive.  Instead, we index a small
+  // hash value.  Calculate this hash as the first 8 bytes of the SHA1 of
+  // the full data.
+  CACHE_TRY_INSPECT(const auto& hash, HashCString(aCrypto, aData));
+
+  // Next, search for an existing entry for this blob by comparing the hash
+  // value first and then the full data.  SQLite is smart enough to use
+  // the index on the hash to search the table before doing the expensive
+  // comparison of the large data column.  (This was verified with EXPLAIN.)
+  CACHE_TRY_INSPECT(
+      const auto& selectStmt,
+      quota::CreateAndExecuteSingleStepStatement<
+          quota::SingleStepResult::ReturnNullIfNoResult>(
+          aConn,
+          // Note that hash and data are blobs, but we can use = here since the
+          // columns are NOT NULL.
+          "SELECT id, refcount FROM security_info WHERE hash=:hash AND "
+          "data=:data;"_ns,
+          [&hash, &aData](auto& state) -> Result<Ok, nsresult> {
+            CACHE_TRY(state.BindUTF8StringAsBlobByName("hash"_ns, hash));
+            CACHE_TRY(state.BindUTF8StringAsBlobByName("data"_ns, aData));
+
+            return Ok{};
+          }));
+
+  // This security info blob is already in the database
+  if (selectStmt) {
+    // get the existing security blob id to return
+    CACHE_TRY_INSPECT(const int32_t& id,
+                      MOZ_TO_RESULT_INVOKE(selectStmt, GetInt32, 0));
+    CACHE_TRY_INSPECT(const int32_t& refcount,
+                      MOZ_TO_RESULT_INVOKE(selectStmt, GetInt32, 1));
+
+    // But first, update the refcount in the database.
+    CACHE_TRY_INSPECT(
+        const auto& state,
+        MOZ_TO_RESULT_INVOKE_TYPED(
+            nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+            "UPDATE security_info SET refcount=:refcount WHERE id=:id;"_ns));
+
+    CACHE_TRY(state->BindInt32ByName("refcount"_ns, refcount + 1));
+    CACHE_TRY(state->BindInt32ByName("id"_ns, id));
+    CACHE_TRY(state->Execute());
+
+    return id;
+  }
+
+  // This is a new security info blob.  Create a new row in the security table
+  // with an initial refcount of 1.
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "INSERT INTO security_info (hash, data, refcount) "
+                        "VALUES (:hash, :data, 1);"_ns));
+
+  CACHE_TRY(state->BindUTF8StringAsBlobByName("hash"_ns, hash));
+  CACHE_TRY(state->BindUTF8StringAsBlobByName("data"_ns, aData));
+  CACHE_TRY(state->Execute());
+
+  {
+    CACHE_TRY_INSPECT(const auto& state,
+                      quota::CreateAndExecuteSingleStepStatement(
+                          aConn, "SELECT last_insert_rowid()"_ns));
+
+    CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0));
+  }
+}
+
+nsresult DeleteSecurityInfo(mozIStorageConnection& aConn, int32_t aId,
+                            int32_t aCount) {
+  // First, we need to determine the current refcount for this security blob.
+  CACHE_TRY_INSPECT(
+      const int32_t& refcount, ([&aConn, aId]() -> Result<int32_t, nsresult> {
+        CACHE_TRY_INSPECT(
+            const auto& state,
+            quota::CreateAndExecuteSingleStepStatement(
+                aConn, "SELECT refcount FROM security_info WHERE id=:id;"_ns,
+                [aId](auto& state) -> Result<Ok, nsresult> {
+                  CACHE_TRY(state.BindInt32ByName("id"_ns, aId));
+                  return Ok{};
+                }));
+
+        CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0));
+      }()));
+
+  MOZ_DIAGNOSTIC_ASSERT(refcount >= aCount);
+
+  // Next, calculate the new refcount
+  int32_t newCount = refcount - aCount;
+
+  // If the last reference to this security blob was removed we can
+  // just remove the entire row.
+  if (newCount == 0) {
+    CACHE_TRY_INSPECT(
+        const auto& state,
+        MOZ_TO_RESULT_INVOKE_TYPED(
+            nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+            "DELETE FROM security_info WHERE id=:id;"_ns));
+
+    CACHE_TRY(state->BindInt32ByName("id"_ns, aId));
+    CACHE_TRY(state->Execute());
+
+    return NS_OK;
+  }
+
+  // Otherwise update the refcount in the table to reflect the reduced
+  // number of references to the security blob.
+  CACHE_TRY_INSPECT(
+      const auto& state,
+      MOZ_TO_RESULT_INVOKE_TYPED(
+          nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+          "UPDATE security_info SET refcount=:refcount WHERE id=:id;"_ns));
+
+  CACHE_TRY(state->BindInt32ByName("refcount"_ns, newCount));
+  CACHE_TRY(state->BindInt32ByName("id"_ns, aId));
+  CACHE_TRY(state->Execute());
+
+  return NS_OK;
+}
+
+nsresult DeleteSecurityInfoList(
+    mozIStorageConnection& aConn,
+    const nsTArray<IdCount>& aDeletedStorageIdList) {
+  for (const auto& deletedStorageId : aDeletedStorageIdList) {
+    CACHE_TRY(DeleteSecurityInfo(aConn, deletedStorageId.mId,
+                                 deletedStorageId.mCount));
+  }
+
+  return NS_OK;
+}
+
+nsresult InsertEntry(mozIStorageConnection& aConn, CacheId aCacheId,
+                     const CacheRequest& aRequest, const nsID* aRequestBodyId,
+                     const CacheResponse& aResponse,
+                     const nsID* aResponseBodyId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& crypto,
+      ToResultGet<nsCOMPtr<nsICryptoHash>>(
+          MOZ_SELECT_OVERLOAD(do_CreateInstance), NS_CRYPTO_HASH_CONTRACTID));
+
+  int32_t securityId = -1;
+  if (!aResponse.channelInfo().securityInfo().IsEmpty()) {
+    CACHE_TRY_UNWRAP(
+        securityId, InsertSecurityInfo(aConn, *crypto,
+                                       aResponse.channelInfo().securityInfo()));
+  }
+
+  {
+    CACHE_TRY_INSPECT(const auto& state,
+                      MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<mozIStorageStatement>,
+                                                 aConn, CreateStatement,
+                                                 "INSERT INTO entries ("
+                                                 "request_method, "
+                                                 "request_url_no_query, "
+                                                 "request_url_no_query_hash, "
+                                                 "request_url_query, "
+                                                 "request_url_query_hash, "
+                                                 "request_url_fragment, "
+                                                 "request_referrer, "
+                                                 "request_referrer_policy, "
+                                                 "request_headers_guard, "
+                                                 "request_mode, "
+                                                 "request_credentials, "
+                                                 "request_contentpolicytype, "
+                                                 "request_cache, "
+                                                 "request_redirect, "
+                                                 "request_integrity, "
+                                                 "request_body_id, "
+                                                 "response_type, "
+                                                 "response_status, "
+                                                 "response_status_text, "
+                                                 "response_headers_guard, "
+                                                 "response_body_id, "
+                                                 "response_security_info_id, "
+                                                 "response_principal_info, "
+                                                 "response_padding_size, "
+                                                 "cache_id "
+                                                 ") VALUES ("
+                                                 ":request_method, "
+                                                 ":request_url_no_query, "
+                                                 ":request_url_no_query_hash, "
+                                                 ":request_url_query, "
+                                                 ":request_url_query_hash, "
+                                                 ":request_url_fragment, "
+                                                 ":request_referrer, "
+                                                 ":request_referrer_policy, "
+                                                 ":request_headers_guard, "
+                                                 ":request_mode, "
+                                                 ":request_credentials, "
+                                                 ":request_contentpolicytype, "
+                                                 ":request_cache, "
+                                                 ":request_redirect, "
+                                                 ":request_integrity, "
+                                                 ":request_body_id, "
+                                                 ":response_type, "
+                                                 ":response_status, "
+                                                 ":response_status_text, "
+                                                 ":response_headers_guard, "
+                                                 ":response_body_id, "
+                                                 ":response_security_info_id, "
+                                                 ":response_principal_info, "
+                                                 ":response_padding_size, "
+                                                 ":cache_id "
+                                                 ");"_ns));
+
+    CACHE_TRY(
+        state->BindUTF8StringByName("request_method"_ns, aRequest.method()));
+
+    CACHE_TRY(state->BindUTF8StringByName("request_url_no_query"_ns,
+                                          aRequest.urlWithoutQuery()));
+
+    CACHE_TRY_INSPECT(const auto& urlWithoutQueryHash,
+                      HashCString(*crypto, aRequest.urlWithoutQuery()));
+
+    CACHE_TRY(state->BindUTF8StringAsBlobByName("request_url_no_query_hash"_ns,
+                                                urlWithoutQueryHash));
+
+    CACHE_TRY(state->BindUTF8StringByName("request_url_query"_ns,
+                                          aRequest.urlQuery()));
+
+    CACHE_TRY_INSPECT(const auto& urlQueryHash,
+                      HashCString(*crypto, aRequest.urlQuery()));
+
+    CACHE_TRY(state->BindUTF8StringAsBlobByName("request_url_query_hash"_ns,
+                                                urlQueryHash));
+
+    CACHE_TRY(state->BindUTF8StringByName("request_url_fragment"_ns,
+                                          aRequest.urlFragment()));
+
+    CACHE_TRY(
+        state->BindStringByName("request_referrer"_ns, aRequest.referrer()));
+
+    CACHE_TRY(state->BindInt32ByName(
+        "request_referrer_policy"_ns,
+        static_cast<int32_t>(aRequest.referrerPolicy())));
+
+    CACHE_TRY(
+        state->BindInt32ByName("request_headers_guard"_ns,
+                               static_cast<int32_t>(aRequest.headersGuard())));
+
+    CACHE_TRY(state->BindInt32ByName("request_mode"_ns,
+                                     static_cast<int32_t>(aRequest.mode())));
+
+    CACHE_TRY(
+        state->BindInt32ByName("request_credentials"_ns,
+                               static_cast<int32_t>(aRequest.credentials())));
+
+    CACHE_TRY(state->BindInt32ByName(
+        "request_contentpolicytype"_ns,
+        static_cast<int32_t>(aRequest.contentPolicyType())));
+
+    CACHE_TRY(state->BindInt32ByName(
+        "request_cache"_ns, static_cast<int32_t>(aRequest.requestCache())));
+
+    CACHE_TRY(state->BindInt32ByName(
+        "request_redirect"_ns,
+        static_cast<int32_t>(aRequest.requestRedirect())));
+
+    CACHE_TRY(
+        state->BindStringByName("request_integrity"_ns, aRequest.integrity()));
+
+    CACHE_TRY(BindId(*state, "request_body_id"_ns, aRequestBodyId));
+
+    CACHE_TRY(state->BindInt32ByName("response_type"_ns,
+                                     static_cast<int32_t>(aResponse.type())));
+
+    CACHE_TRY(state->BindInt32ByName("response_status"_ns, aResponse.status()));
+
+    CACHE_TRY(state->BindUTF8StringByName("response_status_text"_ns,
+                                          aResponse.statusText()));
+
+    CACHE_TRY(
+        state->BindInt32ByName("response_headers_guard"_ns,
+                               static_cast<int32_t>(aResponse.headersGuard())));
+
+    CACHE_TRY(BindId(*state, "response_body_id"_ns, aResponseBodyId));
+
+    if (aResponse.channelInfo().securityInfo().IsEmpty()) {
+      CACHE_TRY(state->BindNullByName("response_security_info_id"_ns));
+    } else {
+      CACHE_TRY(
+          state->BindInt32ByName("response_security_info_id"_ns, securityId));
+    }
+
+    nsAutoCString serializedInfo;
+    // We only allow content serviceworkers right now.
+    if (aResponse.principalInfo().isSome()) {
+      const mozilla::ipc::PrincipalInfo& principalInfo =
+          aResponse.principalInfo().ref();
+      MOZ_DIAGNOSTIC_ASSERT(principalInfo.type() ==
+                            mozilla::ipc::PrincipalInfo::TContentPrincipalInfo);
+      const mozilla::ipc::ContentPrincipalInfo& cInfo =
+          principalInfo.get_ContentPrincipalInfo();
+
+      serializedInfo.Append(cInfo.spec());
+
+      nsAutoCString suffix;
+      cInfo.attrs().CreateSuffix(suffix);
+      serializedInfo.Append(suffix);
+    }
+
+    CACHE_TRY(state->BindUTF8StringByName("response_principal_info"_ns,
+                                          serializedInfo));
+
+    if (aResponse.paddingSize() == InternalResponse::UNKNOWN_PADDING_SIZE) {
+      MOZ_DIAGNOSTIC_ASSERT(aResponse.type() != ResponseType::Opaque);
+      CACHE_TRY(state->BindNullByName("response_padding_size"_ns));
+    } else {
+      MOZ_DIAGNOSTIC_ASSERT(aResponse.paddingSize() >= 0);
+      MOZ_DIAGNOSTIC_ASSERT(aResponse.type() == ResponseType::Opaque);
+
+      CACHE_TRY(state->BindInt64ByName("response_padding_size"_ns,
+                                       aResponse.paddingSize()));
+    }
+
+    CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId));
+
+    CACHE_TRY(state->Execute());
+  }
+
+  CACHE_TRY_INSPECT(
+      const int32_t& entryId, ([&aConn]() -> Result<int32_t, nsresult> {
+        CACHE_TRY_INSPECT(const auto& state,
+                          quota::CreateAndExecuteSingleStepStatement(
+                              aConn, "SELECT last_insert_rowid()"_ns));
+
+        CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0));
+      }()));
+
+  {
+    CACHE_TRY_INSPECT(
+        const auto& state,
+        MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<mozIStorageStatement>, aConn,
+                                   CreateStatement,
+                                   "INSERT INTO request_headers ("
+                                   "name, "
+                                   "value, "
+                                   "entry_id "
+                                   ") VALUES (:name, :value, :entry_id)"_ns));
+
+    for (const auto& requestHeader : aRequest.headers()) {
+      CACHE_TRY(state->BindUTF8StringByName("name"_ns, requestHeader.name()));
+
+      CACHE_TRY(state->BindUTF8StringByName("value"_ns, requestHeader.value()));
+
+      CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId));
+
+      CACHE_TRY(state->Execute());
+    }
+  }
+
+  {
+    CACHE_TRY_INSPECT(
+        const auto& state,
+        MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<mozIStorageStatement>, aConn,
+                                   CreateStatement,
+                                   "INSERT INTO response_headers ("
+                                   "name, "
+                                   "value, "
+                                   "entry_id "
+                                   ") VALUES (:name, :value, :entry_id)"_ns));
+
+    for (const auto& responseHeader : aResponse.headers()) {
+      CACHE_TRY(state->BindUTF8StringByName("name"_ns, responseHeader.name()));
+      CACHE_TRY(
+          state->BindUTF8StringByName("value"_ns, responseHeader.value()));
+      CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId));
+      CACHE_TRY(state->Execute());
+    }
+  }
+
+  {
+    CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(
+                                             nsCOMPtr<mozIStorageStatement>,
+                                             aConn, CreateStatement,
+                                             "INSERT INTO response_url_list ("
+                                             "url, "
+                                             "entry_id "
+                                             ") VALUES (:url, :entry_id)"_ns));
+
+    for (const auto& responseUrl : aResponse.urlList()) {
+      CACHE_TRY(state->BindUTF8StringByName("url"_ns, responseUrl));
+      CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId));
+      CACHE_TRY(state->Execute());
+    }
+  }
+
+  return NS_OK;
+}
+
+/**
+ * Gets a HeadersEntry from a storage statement by retrieving the first column
+ * as the name and the second column as the value.
+ */
+Result<HeadersEntry, nsresult> GetHeadersEntryFromStatement(
+    mozIStorageStatement& aStmt) {
+  HeadersEntry header;
+
+  CACHE_TRY_UNWRAP(header.name(), MOZ_TO_RESULT_INVOKE_TYPED(nsCString, aStmt,
+                                                             GetUTF8String, 0));
+  CACHE_TRY_UNWRAP(header.value(), MOZ_TO_RESULT_INVOKE_TYPED(
+                                       nsCString, aStmt, GetUTF8String, 1));
+
+  return header;
+}
+
+Result<SavedResponse, nsresult> ReadResponse(mozIStorageConnection& aConn,
+                                             EntryId aEntryId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  SavedResponse savedResponse;
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    quota::CreateAndExecuteSingleStepStatement(
+                        aConn,
+                        "SELECT "
+                        "entries.response_type, "
+                        "entries.response_status, "
+                        "entries.response_status_text, "
+                        "entries.response_headers_guard, "
+                        "entries.response_body_id, "
+                        "entries.response_principal_info, "
+                        "entries.response_padding_size, "
+                        "security_info.data "
+                        "FROM entries "
+                        "LEFT OUTER JOIN security_info "
+                        "ON entries.response_security_info_id=security_info.id "
+                        "WHERE entries.id=:id;"_ns,
+                        [aEntryId](auto& state) -> Result<Ok, nsresult> {
+                          CACHE_TRY(state.BindInt32ByName("id"_ns, aEntryId));
+
+                          return Ok{};
+                        }));
+
+  CACHE_TRY_INSPECT(const int32_t& type,
+                    MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0));
+  savedResponse.mValue.type() = static_cast<ResponseType>(type);
+
+  CACHE_TRY_INSPECT(const int32_t& status,
+                    MOZ_TO_RESULT_INVOKE(*state, GetInt32, 1));
+  savedResponse.mValue.status() = static_cast<uint32_t>(status);
+
+  CACHE_TRY(state->GetUTF8String(2, savedResponse.mValue.statusText()));
+
+  CACHE_TRY_INSPECT(const int32_t& guard,
+                    MOZ_TO_RESULT_INVOKE(*state, GetInt32, 3));
+  savedResponse.mValue.headersGuard() = static_cast<HeadersGuardEnum>(guard);
+
+  CACHE_TRY_INSPECT(const bool& nullBody,
+                    MOZ_TO_RESULT_INVOKE(*state, GetIsNull, 4));
+  savedResponse.mHasBodyId = !nullBody;
+
+  if (savedResponse.mHasBodyId) {
+    CACHE_TRY_UNWRAP(savedResponse.mBodyId, ExtractId(*state, 4));
+  }
+
+  CACHE_TRY_INSPECT(
+      const auto& serializedInfo,
+      MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, *state, GetUTF8String, 5));
+
+  savedResponse.mValue.principalInfo() = Nothing();
+  if (!serializedInfo.IsEmpty()) {
+    nsAutoCString specNoSuffix;
+    OriginAttributes attrs;
+    if (!attrs.PopulateFromOrigin(serializedInfo, specNoSuffix)) {
+      NS_WARNING("Something went wrong parsing a serialized principal!");
+      return Err(NS_ERROR_FAILURE);
+    }
+
+    RefPtr<net::MozURL> url;
+    CACHE_TRY(net::MozURL::Init(getter_AddRefs(url), specNoSuffix));
+
+#ifdef DEBUG
+    nsDependentCSubstring scheme = url->Scheme();
+
+    MOZ_ASSERT(
+        scheme == "http" || scheme == "https" || scheme == "file" ||
+        // A cached response entry may have a moz-extension principal if:
+        //
+        // - This is an extension background service worker. The response for
+        //   the main script is expected tobe a moz-extension content principal
+        //   (the pref "extensions.backgroundServiceWorker.enabled" must be
+        //   enabled, if the pref is toggled to false at runtime then any
+        //   service worker registered for a moz-extension principal will be
+        //   unregistered on the next startup).
+        //
+        // - An extension is redirecting a script being imported info a worker
+        //   created from a regular webpage to a web-accessible extension
+        //   script. The reponse for these redirects will have a moz-extension
+        //   principal. Although extensions can attempt to redirect the main
+        //   script of service workers, this will always cause the install
+        //   process to fail.
+        scheme == "moz-extension");
+#endif
+
+    nsCString origin;
+    url->Origin(origin);
+
+    nsCString baseDomain;
+    CACHE_TRY(url->BaseDomain(baseDomain));
+
+    savedResponse.mValue.principalInfo() =
+        Some(mozilla::ipc::ContentPrincipalInfo(attrs, origin, specNoSuffix,
+                                                Nothing(), baseDomain));
+  }
+
+  CACHE_TRY_INSPECT(const bool& nullPadding,
+                    MOZ_TO_RESULT_INVOKE(*state, GetIsNull, 6));
+
+  if (nullPadding) {
+    MOZ_DIAGNOSTIC_ASSERT(savedResponse.mValue.type() != ResponseType::Opaque);
+    savedResponse.mValue.paddingSize() = InternalResponse::UNKNOWN_PADDING_SIZE;
+  } else {
+    MOZ_DIAGNOSTIC_ASSERT(savedResponse.mValue.type() == ResponseType::Opaque);
+    CACHE_TRY_INSPECT(const int64_t& paddingSize,
+                      MOZ_TO_RESULT_INVOKE(*state, GetInt64, 6));
+
+    MOZ_DIAGNOSTIC_ASSERT(paddingSize >= 0);
+    savedResponse.mValue.paddingSize() = paddingSize;
+  }
+
+  CACHE_TRY(state->GetBlobAsUTF8String(
+      7, savedResponse.mValue.channelInfo().securityInfo()));
+
+  {
+    CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(
+                                             nsCOMPtr<mozIStorageStatement>,
+                                             aConn, CreateStatement,
+                                             "SELECT "
+                                             "name, "
+                                             "value "
+                                             "FROM response_headers "
+                                             "WHERE entry_id=:entry_id;"_ns));
+
+    CACHE_TRY(state->BindInt32ByName("entry_id"_ns, aEntryId));
+
+    CACHE_TRY_UNWRAP(savedResponse.mValue.headers(),
+                     quota::CollectElementsWhileHasResult(
+                         *state, GetHeadersEntryFromStatement));
+  }
+
+  {
+    CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(
+                                             nsCOMPtr<mozIStorageStatement>,
+                                             aConn, CreateStatement,
+                                             "SELECT "
+                                             "url "
+                                             "FROM response_url_list "
+                                             "WHERE entry_id=:entry_id;"_ns));
+
+    CACHE_TRY(state->BindInt32ByName("entry_id"_ns, aEntryId));
+
+    CACHE_TRY_UNWRAP(savedResponse.mValue.urlList(),
+                     quota::CollectElementsWhileHasResult(
+                         *state, [](auto& stmt) -> Result<nsCString, nsresult> {
+                           CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE_TYPED(
+                               nsCString, stmt, GetUTF8String, 0));
+                         }));
+  }
+
+  return savedResponse;
+}
+
+Result<SavedRequest, nsresult> ReadRequest(mozIStorageConnection& aConn,
+                                           EntryId aEntryId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  SavedRequest savedRequest;
+
+  CACHE_TRY_INSPECT(const auto& state,
+                    quota::CreateAndExecuteSingleStepStatement<
+                        quota::SingleStepResult::ReturnNullIfNoResult>(
+                        aConn,
+                        "SELECT "
+                        "request_method, "
+                        "request_url_no_query, "
+                        "request_url_query, "
+                        "request_url_fragment, "
+                        "request_referrer, "
+                        "request_referrer_policy, "
+                        "request_headers_guard, "
+                        "request_mode, "
+                        "request_credentials, "
+                        "request_contentpolicytype, "
+                        "request_cache, "
+                        "request_redirect, "
+                        "request_integrity, "
+                        "request_body_id "
+                        "FROM entries "
+                        "WHERE id=:id;"_ns,
+                        [aEntryId](auto& state) -> Result<Ok, nsresult> {
+                          CACHE_TRY(state.BindInt32ByName("id"_ns, aEntryId));
+
+                          return Ok{};
+                        }));
+
+  CACHE_TRY(OkIf(state), Err(NS_ERROR_UNEXPECTED));
+
+  CACHE_TRY(state->GetUTF8String(0, savedRequest.mValue.method()));
+  CACHE_TRY(state->GetUTF8String(1, savedRequest.mValue.urlWithoutQuery()));
+  CACHE_TRY(state->GetUTF8String(2, savedRequest.mValue.urlQuery()));
+  CACHE_TRY(state->GetUTF8String(3, savedRequest.mValue.urlFragment()));
+  CACHE_TRY(state->GetString(4, savedRequest.mValue.referrer()));
+
+  CACHE_TRY_INSPECT(const int32_t& referrerPolicy,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt32, 5));
+  savedRequest.mValue.referrerPolicy() =
+      static_cast<ReferrerPolicy>(referrerPolicy);
+
+  CACHE_TRY_INSPECT(const int32_t& guard,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt32, 6));
+  savedRequest.mValue.headersGuard() = static_cast<HeadersGuardEnum>(guard);
+
+  CACHE_TRY_INSPECT(const int32_t& mode,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt32, 7));
+  savedRequest.mValue.mode() = static_cast<RequestMode>(mode);
+
+  CACHE_TRY_INSPECT(const int32_t& credentials,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt32, 8));
+  savedRequest.mValue.credentials() =
+      static_cast<RequestCredentials>(credentials);
+
+  CACHE_TRY_INSPECT(const int32_t& requestContentPolicyType,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt32, 9));
+  savedRequest.mValue.contentPolicyType() =
+      static_cast<nsContentPolicyType>(requestContentPolicyType);
+
+  CACHE_TRY_INSPECT(const int32_t& requestCache,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt32, 10));
+  savedRequest.mValue.requestCache() = static_cast<RequestCache>(requestCache);
+
+  CACHE_TRY_INSPECT(const int32_t& requestRedirect,
+                    MOZ_TO_RESULT_INVOKE(state, GetInt32, 11));
+  savedRequest.mValue.requestRedirect() =
+      static_cast<RequestRedirect>(requestRedirect);
+
+  CACHE_TRY(state->GetString(12, savedRequest.mValue.integrity()));
+
+  CACHE_TRY_INSPECT(const bool& nullBody,
+                    MOZ_TO_RESULT_INVOKE(state, GetIsNull, 13));
+  savedRequest.mHasBodyId = !nullBody;
+  if (savedRequest.mHasBodyId) {
+    CACHE_TRY_UNWRAP(savedRequest.mBodyId, ExtractId(*state, 13));
+  }
+
+  {
+    CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(
+                                             nsCOMPtr<mozIStorageStatement>,
+                                             aConn, CreateStatement,
+                                             "SELECT "
+                                             "name, "
+                                             "value "
+                                             "FROM request_headers "
+                                             "WHERE entry_id=:entry_id;"_ns));
+
+    CACHE_TRY(state->BindInt32ByName("entry_id"_ns, aEntryId));
+
+    CACHE_TRY_UNWRAP(savedRequest.mValue.headers(),
+                     quota::CollectElementsWhileHasResult(
+                         *state, GetHeadersEntryFromStatement));
+  }
+
+  return savedRequest;
+}
+
+void AppendListParamsToQuery(nsACString& aQuery,
+                             const nsTArray<EntryId>& aEntryIdList,
+                             uint32_t aPos, int32_t aLen) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT((aPos + aLen) <= aEntryIdList.Length());
+
+  // XXX This seems to be quite inefficient. Can't we do a BulkWrite?
+  for (int32_t i = aPos; i < aLen; ++i) {
+    if (i == 0) {
+      aQuery.AppendLiteral("?");
+    } else {
+      aQuery.AppendLiteral(",?");
+    }
+  }
+}
+
+nsresult BindListParamsToQuery(mozIStorageStatement& aState,
+                               const nsTArray<EntryId>& aEntryIdList,
+                               uint32_t aPos, int32_t aLen) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT((aPos + aLen) <= aEntryIdList.Length());
+  for (int32_t i = aPos; i < aLen; ++i) {
+    CACHE_TRY(aState.BindInt32ByIndex(i, aEntryIdList[i]));
+  }
+  return NS_OK;
+}
+
+nsresult BindId(mozIStorageStatement& aState, const nsACString& aName,
+                const nsID* aId) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  if (!aId) {
+    CACHE_TRY(aState.BindNullByName(aName));
+    return NS_OK;
+  }
+
+  char idBuf[NSID_LENGTH];
+  aId->ToProvidedString(idBuf);
+  CACHE_TRY(aState.BindUTF8StringByName(aName, nsDependentCString(idBuf)));
+
+  return NS_OK;
+}
+
+Result<nsID, nsresult> ExtractId(mozIStorageStatement& aState, uint32_t aPos) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_INSPECT(
+      const auto& idString,
+      MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, aState, GetUTF8String, aPos));
+
+  nsID id;
+  CACHE_TRY(OkIf(id.Parse(idString.get())), Err(NS_ERROR_UNEXPECTED));
+
+  return id;
+}
+
+Result<NotNull<nsCOMPtr<mozIStorageStatement>>, nsresult>
+CreateAndBindKeyStatement(mozIStorageConnection& aConn,
+                          const char* const aQueryFormat,
+                          const nsAString& aKey) {
+  MOZ_DIAGNOSTIC_ASSERT(aQueryFormat);
+
+  // The key is stored as a blob to avoid encoding issues.  An empty string
+  // is mapped to NULL for blobs.  Normally we would just write the query
+  // as "key IS :key" to do the proper NULL checking, but that prevents
+  // sqlite from using the key index.  Therefore use "IS NULL" explicitly
+  // if the key is empty, otherwise use "=:key" so that sqlite uses the
+  // index.
+
+  CACHE_TRY_UNWRAP(
+      auto state,
+      MOZ_TO_RESULT_INVOKE_TYPED(
+          nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+          nsPrintfCString(aQueryFormat,
+                          aKey.IsEmpty() ? "key IS NULL" : "key=:key")));
+
+  if (!aKey.IsEmpty()) {
+    CACHE_TRY(state->BindStringAsBlobByName("key"_ns, aKey));
+  }
+
+  return WrapNotNull(std::move(state));
+}
+
+Result<nsAutoCString, nsresult> HashCString(nsICryptoHash& aCrypto,
+                                            const nsACString& aIn) {
+  CACHE_TRY(aCrypto.Init(nsICryptoHash::SHA1));
+
+  CACHE_TRY(aCrypto.Update(reinterpret_cast<const uint8_t*>(aIn.BeginReading()),
+                           aIn.Length()));
+
+  nsAutoCString fullHash;
+  CACHE_TRY(aCrypto.Finish(false /* based64 result */, fullHash));
+
+  return Result<nsAutoCString, nsresult>{std::in_place,
+                                         Substring(fullHash, 0, 8)};
+}
+
+}  // namespace
+
+nsresult IncrementalVacuum(mozIStorageConnection& aConn) {
+  // Determine how much free space is in the database.
+  CACHE_TRY_INSPECT(const auto& state,
+                    quota::CreateAndExecuteSingleStepStatement(
+                        aConn, "PRAGMA freelist_count;"_ns));
+
+  CACHE_TRY_INSPECT(const int32_t& freePages,
+                    MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0));
+
+  // We have a relatively small page size, so we want to be careful to avoid
+  // fragmentation.  We already use a growth incremental which will cause
+  // sqlite to allocate and release multiple pages at the same time.  We can
+  // further reduce fragmentation by making our allocated chunks a bit
+  // "sticky".  This is done by creating some hysteresis where we allocate
+  // pages/chunks as soon as we need them, but we only release pages/chunks
+  // when we have a large amount of free space.  This helps with the case
+  // where a page is adding and remove resources causing it to dip back and
+  // forth across a chunk boundary.
+  //
+  // So only proceed with releasing pages if we have more than our constant
+  // threshold.
+  if (freePages <= kMaxFreePages) {
+    return NS_OK;
+  }
+
+  // Release the excess pages back to the sqlite VFS.  This may also release
+  // chunks of multiple pages back to the OS.
+  const int32_t pagesToRelease = freePages - kMaxFreePages;
+
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      nsPrintfCString("PRAGMA incremental_vacuum(%d);", pagesToRelease)));
+
+  // Verify that our incremental vacuum actually did something
+#ifdef DEBUG
+  {
+    CACHE_TRY_INSPECT(const auto& state,
+                      quota::CreateAndExecuteSingleStepStatement(
+                          aConn, "PRAGMA freelist_count;"_ns));
+
+    CACHE_TRY_INSPECT(const int32_t& freePages,
+                      MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0));
+
+    MOZ_ASSERT(freePages <= kMaxFreePages);
+  }
+#endif
+
+  return NS_OK;
+}
+
+namespace {
+
+// Wrapper around mozIStorageConnection::GetSchemaVersion() that compensates
+// for hacky downgrade schema version tricks.  See the block comments for
+// kHackyDowngradeSchemaVersion and kHackyPaddingSizePresentVersion.
+Result<int32_t, nsresult> GetEffectiveSchemaVersion(
+    mozIStorageConnection& aConn) {
+  CACHE_TRY_INSPECT(const int32_t& schemaVersion,
+                    MOZ_TO_RESULT_INVOKE(aConn, GetSchemaVersion));
+
+  if (schemaVersion == kHackyDowngradeSchemaVersion) {
+    // This is the special case.  Check for the existence of the
+    // "response_padding_size" colum in table "entries".
+    //
+    // (pragma_table_info is a table-valued function format variant of
+    // "PRAGMA table_info" supported since SQLite 3.16.0.  Firefox 53 shipped
+    // was the first release with this functionality, shipping 3.16.2.)
+    //
+    // If there are any result rows, then the column is present.
+    CACHE_TRY_INSPECT(const bool& hasColumn,
+                      quota::CreateAndExecuteSingleStepStatement<
+                          quota::SingleStepResult::ReturnNullIfNoResult>(
+                          aConn,
+                          "SELECT name FROM pragma_table_info('entries') WHERE "
+                          "name = 'response_padding_size'"_ns));
+
+    if (hasColumn) {
+      return kHackyPaddingSizePresentVersion;
+    }
+  }
+
+  return schemaVersion;
+}
+
+#ifdef DEBUG
+struct Expect {
+  // Expect exact SQL
+  Expect(const char* aName, const char* aType, const char* aSql)
+      : mName(aName), mType(aType), mSql(aSql), mIgnoreSql(false) {}
+
+  // Ignore SQL
+  Expect(const char* aName, const char* aType)
+      : mName(aName), mType(aType), mIgnoreSql(true) {}
+
+  const nsCString mName;
+  const nsCString mType;
+  const nsCString mSql;
+  const bool mIgnoreSql;
+};
+#endif
+
+nsresult Validate(mozIStorageConnection& aConn) {
+  CACHE_TRY_INSPECT(const int32_t& schemaVersion,
+                    GetEffectiveSchemaVersion(aConn));
+  CACHE_TRY(OkIf(schemaVersion == kLatestSchemaVersion), NS_ERROR_FAILURE);
+
+#ifdef DEBUG
+  // This is the schema we expect the database at the latest version to
+  // contain.  Update this list if you add a new table or index.
+  const Expect expects[] = {
+      Expect("caches", "table", kTableCaches),
+      Expect("sqlite_sequence", "table"),  // auto-gen by sqlite
+      Expect("security_info", "table", kTableSecurityInfo),
+      Expect("security_info_hash_index", "index", kIndexSecurityInfoHash),
+      Expect("entries", "table", kTableEntries),
+      Expect("entries_request_match_index", "index", kIndexEntriesRequest),
+      Expect("request_headers", "table", kTableRequestHeaders),
+      Expect("response_headers", "table", kTableResponseHeaders),
+      Expect("response_headers_name_index", "index", kIndexResponseHeadersName),
+      Expect("response_url_list", "table", kTableResponseUrlList),
+      Expect("storage", "table", kTableStorage),
+      Expect("sqlite_autoindex_storage_1", "index"),  // auto-gen by sqlite
+  };
+
+  // Read the schema from the sqlite_master table and compare.
+  CACHE_TRY_INSPECT(const auto& state,
+                    MOZ_TO_RESULT_INVOKE_TYPED(
+                        nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+                        "SELECT name, type, sql FROM sqlite_master;"_ns));
+
+  CACHE_TRY(quota::CollectWhileHasResult(
+      *state, [&expects](auto& stmt) -> Result<Ok, nsresult> {
+        CACHE_TRY_INSPECT(
+            const auto& name,
+            MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, stmt, GetUTF8String, 0));
+        CACHE_TRY_INSPECT(
+            const auto& type,
+            MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, stmt, GetUTF8String, 1));
+        CACHE_TRY_INSPECT(
+            const auto& sql,
+            MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, stmt, GetUTF8String, 2));
+
+        bool foundMatch = false;
+        for (const auto& expect : expects) {
+          if (name == expect.mName) {
+            if (type != expect.mType) {
+              NS_WARNING(
+                  nsPrintfCString("Unexpected type for Cache schema entry %s",
+                                  name.get())
+                      .get());
+              return Err(NS_ERROR_FAILURE);
+            }
+
+            if (!expect.mIgnoreSql && sql != expect.mSql) {
+              NS_WARNING(
+                  nsPrintfCString("Unexpected SQL for Cache schema entry %s",
+                                  name.get())
+                      .get());
+              return Err(NS_ERROR_FAILURE);
+            }
+
+            foundMatch = true;
+            break;
+          }
+        }
+
+        if (NS_WARN_IF(!foundMatch)) {
+          NS_WARNING(
+              nsPrintfCString("Unexpected schema entry %s in Cache database",
+                              name.get())
+                  .get());
+          return Err(NS_ERROR_FAILURE);
+        }
+
+        return Ok{};
+      }));
+#endif
+
+  return NS_OK;
+}
+
+// -----
+// Schema migration code
+// -----
+
+typedef nsresult (*MigrationFunc)(mozIStorageConnection&, bool&);
+struct Migration {
+  int32_t mFromVersion;
+  MigrationFunc mFunc;
+};
+
+// Declare migration functions here.  Each function should upgrade
+// the version by a single increment.  Don't skip versions.
+nsresult MigrateFrom15To16(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom16To17(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom17To18(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom18To19(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom19To20(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom20To21(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom21To22(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom22To23(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom23To24(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom24To25(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom25To26(mozIStorageConnection& aConn, bool& aRewriteSchema);
+nsresult MigrateFrom26To27(mozIStorageConnection& aConn, bool& aRewriteSchema);
+// Configure migration functions to run for the given starting version.
+constexpr Migration sMigrationList[] = {
+    Migration{15, MigrateFrom15To16}, Migration{16, MigrateFrom16To17},
+    Migration{17, MigrateFrom17To18}, Migration{18, MigrateFrom18To19},
+    Migration{19, MigrateFrom19To20}, Migration{20, MigrateFrom20To21},
+    Migration{21, MigrateFrom21To22}, Migration{22, MigrateFrom22To23},
+    Migration{23, MigrateFrom23To24}, Migration{24, MigrateFrom24To25},
+    Migration{25, MigrateFrom25To26}, Migration{26, MigrateFrom26To27},
+};
+nsresult RewriteEntriesSchema(mozIStorageConnection& aConn) {
+  CACHE_TRY(aConn.ExecuteSimpleSQL("PRAGMA writable_schema = ON"_ns));
+
+  CACHE_TRY_INSPECT(
+      const auto& state,
+      MOZ_TO_RESULT_INVOKE_TYPED(
+          nsCOMPtr<mozIStorageStatement>, aConn, CreateStatement,
+          "UPDATE sqlite_master SET sql=:sql WHERE name='entries'"_ns));
+
+  CACHE_TRY(
+      state->BindUTF8StringByName("sql"_ns, nsDependentCString(kTableEntries)));
+  CACHE_TRY(state->Execute());
+
+  CACHE_TRY(aConn.ExecuteSimpleSQL("PRAGMA writable_schema = OFF"_ns));
+
+  return NS_OK;
+}
+
+nsresult Migrate(mozIStorageConnection& aConn) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY_UNWRAP(int32_t currentVersion, GetEffectiveSchemaVersion(aConn));
+
+  bool rewriteSchema = false;
+
+  while (currentVersion < kLatestSchemaVersion) {
+    // Wiping old databases is handled in DBAction because it requires
+    // making a whole new mozIStorageConnection.  Make sure we don't
+    // accidentally get here for one of those old databases.
+    MOZ_DIAGNOSTIC_ASSERT(currentVersion >= kFirstShippedSchemaVersion);
+
+    for (const auto& migration : sMigrationList) {
+      if (migration.mFromVersion == currentVersion) {
+        bool shouldRewrite = false;
+        CACHE_TRY(migration.mFunc(aConn, shouldRewrite));
+        if (shouldRewrite) {
+          rewriteSchema = true;
+        }
+        break;
+      }
+    }
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+    int32_t lastVersion = currentVersion;
+#endif
+    CACHE_TRY_UNWRAP(currentVersion, GetEffectiveSchemaVersion(aConn));
+
+    MOZ_DIAGNOSTIC_ASSERT(currentVersion > lastVersion);
+  }
+
+  // Don't release assert this since people do sometimes share profiles
+  // across schema versions.  Our check in Validate() will catch it.
+  MOZ_ASSERT(currentVersion == kLatestSchemaVersion);
+
+  nsresult rv = NS_OK;
+  if (rewriteSchema) {
+    // Now overwrite the master SQL for the entries table to remove the column
+    // default value.  This is also necessary for our Validate() method to
+    // pass on this database.
+    rv = RewriteEntriesSchema(aConn);
+  }
+
+  return rv;
+}
+
+nsresult MigrateFrom15To16(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // Add the request_redirect column with a default value of "follow".  Note,
+  // we only use a default value here because its required by ALTER TABLE and
+  // we need to apply the default "follow" to existing records in the table.
+  // We don't actually want to keep the default in the schema for future
+  // INSERTs.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "ALTER TABLE entries "
+      "ADD COLUMN request_redirect INTEGER NOT NULL DEFAULT 0"_ns));
+
+  CACHE_TRY(aConn.SetSchemaVersion(16));
+
+  aRewriteSchema = true;
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom16To17(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // This migration path removes the response_redirected and
+  // response_redirected_url columns from the entries table.  sqlite doesn't
+  // support removing a column from a table using ALTER TABLE, so we need to
+  // create a new table without those columns, fill it up with the existing
+  // data, and then drop the original table and rename the new one to the old
+  // one.
+
+  // Create a new_entries table with the new fields as of version 17.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "CREATE TABLE new_entries ("
+      "id INTEGER NOT NULL PRIMARY KEY, "
+      "request_method TEXT NOT NULL, "
+      "request_url_no_query TEXT NOT NULL, "
+      "request_url_no_query_hash BLOB NOT NULL, "
+      "request_url_query TEXT NOT NULL, "
+      "request_url_query_hash BLOB NOT NULL, "
+      "request_referrer TEXT NOT NULL, "
+      "request_headers_guard INTEGER NOT NULL, "
+      "request_mode INTEGER NOT NULL, "
+      "request_credentials INTEGER NOT NULL, "
+      "request_contentpolicytype INTEGER NOT NULL, "
+      "request_cache INTEGER NOT NULL, "
+      "request_body_id TEXT NULL, "
+      "response_type INTEGER NOT NULL, "
+      "response_url TEXT NOT NULL, "
+      "response_status INTEGER NOT NULL, "
+      "response_status_text TEXT NOT NULL, "
+      "response_headers_guard INTEGER NOT NULL, "
+      "response_body_id TEXT NULL, "
+      "response_security_info_id INTEGER NULL REFERENCES security_info(id), "
+      "response_principal_info TEXT NOT NULL, "
+      "cache_id INTEGER NOT NULL REFERENCES caches(id) ON DELETE CASCADE, "
+      "request_redirect INTEGER NOT NULL"
+      ")"_ns));
+
+  // Copy all of the data to the newly created table.
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("INSERT INTO new_entries ("
+                             "id, "
+                             "request_method, "
+                             "request_url_no_query, "
+                             "request_url_no_query_hash, "
+                             "request_url_query, "
+                             "request_url_query_hash, "
+                             "request_referrer, "
+                             "request_headers_guard, "
+                             "request_mode, "
+                             "request_credentials, "
+                             "request_contentpolicytype, "
+                             "request_cache, "
+                             "request_redirect, "
+                             "request_body_id, "
+                             "response_type, "
+                             "response_url, "
+                             "response_status, "
+                             "response_status_text, "
+                             "response_headers_guard, "
+                             "response_body_id, "
+                             "response_security_info_id, "
+                             "response_principal_info, "
+                             "cache_id "
+                             ") SELECT "
+                             "id, "
+                             "request_method, "
+                             "request_url_no_query, "
+                             "request_url_no_query_hash, "
+                             "request_url_query, "
+                             "request_url_query_hash, "
+                             "request_referrer, "
+                             "request_headers_guard, "
+                             "request_mode, "
+                             "request_credentials, "
+                             "request_contentpolicytype, "
+                             "request_cache, "
+                             "request_redirect, "
+                             "request_body_id, "
+                             "response_type, "
+                             "response_url, "
+                             "response_status, "
+                             "response_status_text, "
+                             "response_headers_guard, "
+                             "response_body_id, "
+                             "response_security_info_id, "
+                             "response_principal_info, "
+                             "cache_id "
+                             "FROM entries;"_ns));
+
+  // Remove the old table.
+  CACHE_TRY(aConn.ExecuteSimpleSQL("DROP TABLE entries;"_ns));
+
+  // Rename new_entries to entries.
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("ALTER TABLE new_entries RENAME to entries;"_ns));
+
+  // Now, recreate our indices.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(nsDependentCString(kIndexEntriesRequest)));
+
+  // Revalidate the foreign key constraints, and ensure that there are no
+  // violations.
+  CACHE_TRY_INSPECT(const bool& hasResult,
+                    quota::CreateAndExecuteSingleStepStatement<
+                        quota::SingleStepResult::ReturnNullIfNoResult>(
+                        aConn, "PRAGMA foreign_key_check;"_ns));
+
+  CACHE_TRY(OkIf(!hasResult), NS_ERROR_FAILURE);
+
+  CACHE_TRY(aConn.SetSchemaVersion(17));
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom17To18(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // This migration is needed in order to remove "only-if-cached" RequestCache
+  // values from the database.  This enum value was removed from the spec in
+  // https://github.com/whatwg/fetch/issues/39 but we unfortunately happily
+  // accepted this value in the Request constructor.
+  //
+  // There is no good value to upgrade this to, so we just stick to "default".
+
+  static_assert(int(RequestCache::Default) == 0,
+                "This is where the 0 below comes from!");
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("UPDATE entries SET request_cache = 0 "
+                             "WHERE request_cache = 5;"_ns));
+
+  CACHE_TRY(aConn.SetSchemaVersion(18));
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom18To19(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // This migration is needed in order to update the RequestMode values for
+  // Request objects corresponding to a navigation content policy type to
+  // "navigate".
+
+  static_assert(int(nsIContentPolicy::TYPE_DOCUMENT) == 6 &&
+                    int(nsIContentPolicy::TYPE_SUBDOCUMENT) == 7 &&
+                    int(nsIContentPolicy::TYPE_INTERNAL_FRAME) == 28 &&
+                    int(nsIContentPolicy::TYPE_INTERNAL_IFRAME) == 29 &&
+                    int(RequestMode::Navigate) == 3,
+                "This is where the numbers below come from!");
+  // 8 is former TYPE_REFRESH.
+
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "UPDATE entries SET request_mode = 3 "
+      "WHERE request_contentpolicytype IN (6, 7, 28, 29, 8);"_ns));
+
+  CACHE_TRY(aConn.SetSchemaVersion(19));
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom19To20(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // Add the request_referrer_policy column with a default value of
+  // "no-referrer-when-downgrade".  Note, we only use a default value here
+  // because its required by ALTER TABLE and we need to apply the default
+  // "no-referrer-when-downgrade" to existing records in the table. We don't
+  // actually want to keep the default in the schema for future INSERTs.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "ALTER TABLE entries "
+      "ADD COLUMN request_referrer_policy INTEGER NOT NULL DEFAULT 2"_ns));
+
+  CACHE_TRY(aConn.SetSchemaVersion(20));
+
+  aRewriteSchema = true;
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom20To21(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // This migration creates response_url_list table to store response_url and
+  // removes the response_url column from the entries table.
+  // sqlite doesn't support removing a column from a table using ALTER TABLE,
+  // so we need to create a new table without those columns, fill it up with the
+  // existing data, and then drop the original table and rename the new one to
+  // the old one.
+
+  // Create a new_entries table with the new fields as of version 21.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "CREATE TABLE new_entries ("
+      "id INTEGER NOT NULL PRIMARY KEY, "
+      "request_method TEXT NOT NULL, "
+      "request_url_no_query TEXT NOT NULL, "
+      "request_url_no_query_hash BLOB NOT NULL, "
+      "request_url_query TEXT NOT NULL, "
+      "request_url_query_hash BLOB NOT NULL, "
+      "request_referrer TEXT NOT NULL, "
+      "request_headers_guard INTEGER NOT NULL, "
+      "request_mode INTEGER NOT NULL, "
+      "request_credentials INTEGER NOT NULL, "
+      "request_contentpolicytype INTEGER NOT NULL, "
+      "request_cache INTEGER NOT NULL, "
+      "request_body_id TEXT NULL, "
+      "response_type INTEGER NOT NULL, "
+      "response_status INTEGER NOT NULL, "
+      "response_status_text TEXT NOT NULL, "
+      "response_headers_guard INTEGER NOT NULL, "
+      "response_body_id TEXT NULL, "
+      "response_security_info_id INTEGER NULL REFERENCES security_info(id), "
+      "response_principal_info TEXT NOT NULL, "
+      "cache_id INTEGER NOT NULL REFERENCES caches(id) ON DELETE CASCADE, "
+      "request_redirect INTEGER NOT NULL, "
+      "request_referrer_policy INTEGER NOT NULL"
+      ")"_ns));
+
+  // Create a response_url_list table with the new fields as of version 21.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "CREATE TABLE response_url_list ("
+      "url TEXT NOT NULL, "
+      "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE"
+      ")"_ns));
+
+  // Copy all of the data to the newly created entries table.
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("INSERT INTO new_entries ("
+                             "id, "
+                             "request_method, "
+                             "request_url_no_query, "
+                             "request_url_no_query_hash, "
+                             "request_url_query, "
+                             "request_url_query_hash, "
+                             "request_referrer, "
+                             "request_headers_guard, "
+                             "request_mode, "
+                             "request_credentials, "
+                             "request_contentpolicytype, "
+                             "request_cache, "
+                             "request_redirect, "
+                             "request_referrer_policy, "
+                             "request_body_id, "
+                             "response_type, "
+                             "response_status, "
+                             "response_status_text, "
+                             "response_headers_guard, "
+                             "response_body_id, "
+                             "response_security_info_id, "
+                             "response_principal_info, "
+                             "cache_id "
+                             ") SELECT "
+                             "id, "
+                             "request_method, "
+                             "request_url_no_query, "
+                             "request_url_no_query_hash, "
+                             "request_url_query, "
+                             "request_url_query_hash, "
+                             "request_referrer, "
+                             "request_headers_guard, "
+                             "request_mode, "
+                             "request_credentials, "
+                             "request_contentpolicytype, "
+                             "request_cache, "
+                             "request_redirect, "
+                             "request_referrer_policy, "
+                             "request_body_id, "
+                             "response_type, "
+                             "response_status, "
+                             "response_status_text, "
+                             "response_headers_guard, "
+                             "response_body_id, "
+                             "response_security_info_id, "
+                             "response_principal_info, "
+                             "cache_id "
+                             "FROM entries;"_ns));
+
+  // Copy reponse_url to the newly created response_url_list table.
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("INSERT INTO response_url_list ("
+                             "url, "
+                             "entry_id "
+                             ") SELECT "
+                             "response_url, "
+                             "id "
+                             "FROM entries;"_ns));
+
+  // Remove the old table.
+  CACHE_TRY(aConn.ExecuteSimpleSQL("DROP TABLE entries;"_ns));
+
+  // Rename new_entries to entries.
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("ALTER TABLE new_entries RENAME to entries;"_ns));
+
+  // Now, recreate our indices.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexEntriesRequest)));
+
+  // Revalidate the foreign key constraints, and ensure that there are no
+  // violations.
+  CACHE_TRY_INSPECT(const bool& hasResult,
+                    quota::CreateAndExecuteSingleStepStatement<
+                        quota::SingleStepResult::ReturnNullIfNoResult>(
+                        aConn, "PRAGMA foreign_key_check;"_ns));
+
+  CACHE_TRY(OkIf(!hasResult), NS_ERROR_FAILURE);
+
+  CACHE_TRY(aConn.SetSchemaVersion(21));
+
+  aRewriteSchema = true;
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom21To22(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // Add the request_integrity column.
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("ALTER TABLE entries "
+                             "ADD COLUMN request_integrity TEXT NULL"_ns));
+
+  CACHE_TRY(aConn.SetSchemaVersion(22));
+
+  aRewriteSchema = true;
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom22To23(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // The only change between 22 and 23 was a different snappy compression
+  // format, but it's backwards-compatible.
+  CACHE_TRY(aConn.SetSchemaVersion(23));
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom23To24(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // Add the request_url_fragment column.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "ALTER TABLE entries "
+      "ADD COLUMN request_url_fragment TEXT NOT NULL DEFAULT ''"_ns));
+
+  CACHE_TRY(aConn.SetSchemaVersion(24));
+
+  aRewriteSchema = true;
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom24To25(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // The only change between 24 and 25 was a new nsIContentPolicy type.
+  CACHE_TRY(aConn.SetSchemaVersion(25));
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom25To26(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  // Add the response_padding_size column.
+  // Note: only opaque repsonse should be non-null interger.
+  CACHE_TRY(aConn.ExecuteSimpleSQL(
+      "ALTER TABLE entries "
+      "ADD COLUMN response_padding_size INTEGER NULL "_ns));
+
+  CACHE_TRY(
+      aConn.ExecuteSimpleSQL("UPDATE entries SET response_padding_size = 0 "
+                             "WHERE response_type = 4"_ns  // opaque response
+                             ));
+
+  CACHE_TRY(aConn.SetSchemaVersion(26));
+
+  aRewriteSchema = true;
+
+  return NS_OK;
+}
+
+nsresult MigrateFrom26To27(mozIStorageConnection& aConn, bool& aRewriteSchema) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  CACHE_TRY(aConn.SetSchemaVersion(kHackyDowngradeSchemaVersion));
+
+  return NS_OK;
+}
+
+}  // anonymous namespace
+}  // namespace mozilla::dom::cache::db