Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 3020 insertions, 0 deletions

diff --git a/dom/indexedDB/SchemaUpgrades.cpp b/dom/indexedDB/SchemaUpgrades.cpp
new file mode 100644
index 0000000000..6066390740
--- /dev/null
+++ b/dom/indexedDB/SchemaUpgrades.cpp
@@ -0,0 +1,3020 @@
+/* -*- 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 "SchemaUpgrades.h"
+
+// local includes
+#include "ActorsParentCommon.h"
+#include "DatabaseFileInfo.h"
+#include "DatabaseFileManager.h"
+#include "DBSchema.h"
+#include "IndexedDatabase.h"
+#include "IndexedDatabaseInlines.h"
+#include "IndexedDBCommon.h"
+#include "ReportInternalError.h"
+
+// global includes
+#include <stdlib.h>
+#include <algorithm>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "ErrorList.h"
+#include "MainThreadUtils.h"
+#include "SafeRefPtr.h"
+#include "js/RootingAPI.h"
+#include "js/StructuredClone.h"
+#include "js/Value.h"
+#include "jsapi.h"
+#include "mozIStorageConnection.h"
+#include "mozIStorageFunction.h"
+#include "mozIStorageStatement.h"
+#include "mozIStorageValueArray.h"
+#include "mozStorageHelper.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/MacroForEach.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/OriginAttributes.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/SchedulerGroup.h"
+#include "mozilla/Span.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/indexedDB/IDBResult.h"
+#include "mozilla/dom/indexedDB/Key.h"
+#include "mozilla/dom/quota/Assertions.h"
+#include "mozilla/dom/quota/PersistenceType.h"
+#include "mozilla/dom/quota/QuotaCommon.h"
+#include "mozilla/dom/quota/ResultExtensions.h"
+#include "mozilla/fallible.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/mozalloc.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/storage/Variant.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsISupports.h"
+#include "nsIVariant.h"
+#include "nsLiteralString.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsTLiteralString.h"
+#include "nsTStringRepr.h"
+#include "nsThreadUtils.h"
+#include "nscore.h"
+#include "snappy/snappy.h"
+
+struct JSContext;
+class JSObject;
+
+#if defined(MOZ_WIDGET_ANDROID)
+#  define IDB_MOBILE
+#endif
+
+namespace mozilla::dom::indexedDB {
+
+using mozilla::ipc::IsOnBackgroundThread;
+using quota::AssertIsOnIOThread;
+using quota::PERSISTENCE_TYPE_INVALID;
+
+namespace {
+
+nsresult UpgradeSchemaFrom4To5(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom4To5", DOM);
+
+  nsresult rv;
+
+  // All we changed is the type of the version column, so lets try to
+  // convert that to an integer, and if we fail, set it to 0.
+  nsCOMPtr<mozIStorageStatement> stmt;
+  rv = aConnection.CreateStatement(
+      "SELECT name, version, dataVersion "
+      "FROM database"_ns,
+      getter_AddRefs(stmt));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsString name;
+  int32_t intVersion;
+  int64_t dataVersion;
+
+  {
+    mozStorageStatementScoper scoper(stmt);
+
+    QM_TRY_INSPECT(const bool& hasResults,
+                   MOZ_TO_RESULT_INVOKE_MEMBER(stmt, ExecuteStep));
+
+    if (NS_WARN_IF(!hasResults)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    nsString version;
+    rv = stmt->GetString(1, version);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    intVersion = version.ToInteger(&rv);
+    if (NS_FAILED(rv)) {
+      intVersion = 0;
+    }
+
+    rv = stmt->GetString(0, name);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = stmt->GetInt64(2, &dataVersion);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE database"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE database ("
+      "name TEXT NOT NULL, "
+      "version INTEGER NOT NULL DEFAULT 0, "
+      "dataVersion INTEGER NOT NULL"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // The parameter names are not used, parameters are bound by index only
+  // locally in the same function.
+  rv = aConnection.CreateStatement(
+      "INSERT INTO database (name, version, dataVersion) "
+      "VALUES (:name, :version, :dataVersion)"_ns,
+      getter_AddRefs(stmt));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  {
+    mozStorageStatementScoper scoper(stmt);
+
+    rv = stmt->BindStringByIndex(0, name);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = stmt->BindInt32ByIndex(1, intVersion);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = stmt->BindInt64ByIndex(2, dataVersion);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = stmt->Execute();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  rv = aConnection.SetSchemaVersion(5);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom5To6(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom5To6", DOM);
+
+  // First, drop all the indexes we're no longer going to use.
+  nsresult rv = aConnection.ExecuteSimpleSQL("DROP INDEX key_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP INDEX ai_key_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP INDEX value_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP INDEX ai_value_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Now, reorder the columns of object_data to put the blob data last. We do
+  // this by copying into a temporary table, dropping the original, then copying
+  // back into a newly created table.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "id INTEGER PRIMARY KEY, "
+      "object_store_id, "
+      "key_value, "
+      "data "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT id, object_store_id, key_value, data "
+      "FROM object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE object_data ("
+      "id INTEGER PRIMARY KEY, "
+      "object_store_id INTEGER NOT NULL, "
+      "key_value DEFAULT NULL, "
+      "data BLOB NOT NULL, "
+      "UNIQUE (object_store_id, key_value), "
+      "FOREIGN KEY (object_store_id) REFERENCES object_store(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_data "
+      "SELECT id, object_store_id, key_value, data "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // We need to add a unique constraint to our ai_object_data table. Copy all
+  // the data out of it using a temporary table as before.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "id INTEGER PRIMARY KEY, "
+      "object_store_id, "
+      "data "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT id, object_store_id, data "
+      "FROM ai_object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE ai_object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE ai_object_data ("
+      "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+      "object_store_id INTEGER NOT NULL, "
+      "data BLOB NOT NULL, "
+      "UNIQUE (object_store_id, id), "
+      "FOREIGN KEY (object_store_id) REFERENCES object_store(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO ai_object_data "
+      "SELECT id, object_store_id, data "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Fix up the index_data table. We're reordering the columns as well as
+  // changing the primary key from being a simple id to being a composite.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "index_id, "
+      "value, "
+      "object_data_key, "
+      "object_data_id "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT index_id, value, object_data_key, object_data_id "
+      "FROM index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE index_data ("
+      "index_id INTEGER NOT NULL, "
+      "value NOT NULL, "
+      "object_data_key NOT NULL, "
+      "object_data_id INTEGER NOT NULL, "
+      "PRIMARY KEY (index_id, value, object_data_key), "
+      "FOREIGN KEY (index_id) REFERENCES object_store_index(id) ON DELETE "
+      "CASCADE, "
+      "FOREIGN KEY (object_data_id) REFERENCES object_data(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT OR IGNORE INTO index_data "
+      "SELECT index_id, value, object_data_key, object_data_id "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX index_data_object_data_id_index "
+      "ON index_data (object_data_id);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Fix up the unique_index_data table. We're reordering the columns as well as
+  // changing the primary key from being a simple id to being a composite.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "index_id, "
+      "value, "
+      "object_data_key, "
+      "object_data_id "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT index_id, value, object_data_key, object_data_id "
+      "FROM unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE unique_index_data ("
+      "index_id INTEGER NOT NULL, "
+      "value NOT NULL, "
+      "object_data_key NOT NULL, "
+      "object_data_id INTEGER NOT NULL, "
+      "PRIMARY KEY (index_id, value, object_data_key), "
+      "UNIQUE (index_id, value), "
+      "FOREIGN KEY (index_id) REFERENCES object_store_index(id) ON DELETE "
+      "CASCADE "
+      "FOREIGN KEY (object_data_id) REFERENCES object_data(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO unique_index_data "
+      "SELECT index_id, value, object_data_key, object_data_id "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX unique_index_data_object_data_id_index "
+      "ON unique_index_data (object_data_id);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Fix up the ai_index_data table. We're reordering the columns as well as
+  // changing the primary key from being a simple id to being a composite.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "index_id, "
+      "value, "
+      "ai_object_data_id "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT index_id, value, ai_object_data_id "
+      "FROM ai_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE ai_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE ai_index_data ("
+      "index_id INTEGER NOT NULL, "
+      "value NOT NULL, "
+      "ai_object_data_id INTEGER NOT NULL, "
+      "PRIMARY KEY (index_id, value, ai_object_data_id), "
+      "FOREIGN KEY (index_id) REFERENCES object_store_index(id) ON DELETE "
+      "CASCADE, "
+      "FOREIGN KEY (ai_object_data_id) REFERENCES ai_object_data(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT OR IGNORE INTO ai_index_data "
+      "SELECT index_id, value, ai_object_data_id "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX ai_index_data_ai_object_data_id_index "
+      "ON ai_index_data (ai_object_data_id);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Fix up the ai_unique_index_data table. We're reordering the columns as well
+  // as changing the primary key from being a simple id to being a composite.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "index_id, "
+      "value, "
+      "ai_object_data_id "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT index_id, value, ai_object_data_id "
+      "FROM ai_unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE ai_unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE ai_unique_index_data ("
+      "index_id INTEGER NOT NULL, "
+      "value NOT NULL, "
+      "ai_object_data_id INTEGER NOT NULL, "
+      "UNIQUE (index_id, value), "
+      "PRIMARY KEY (index_id, value, ai_object_data_id), "
+      "FOREIGN KEY (index_id) REFERENCES object_store_index(id) ON DELETE "
+      "CASCADE, "
+      "FOREIGN KEY (ai_object_data_id) REFERENCES ai_object_data(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO ai_unique_index_data "
+      "SELECT index_id, value, ai_object_data_id "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX ai_unique_index_data_ai_object_data_id_index "
+      "ON ai_unique_index_data (ai_object_data_id);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(6);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom6To7(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom6To7", DOM);
+
+  nsresult rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "id, "
+      "name, "
+      "key_path, "
+      "auto_increment"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT id, name, key_path, auto_increment "
+      "FROM object_store;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE object_store;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE object_store ("
+      "id INTEGER PRIMARY KEY, "
+      "auto_increment INTEGER NOT NULL DEFAULT 0, "
+      "name TEXT NOT NULL, "
+      "key_path TEXT, "
+      "UNIQUE (name)"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_store "
+      "SELECT id, auto_increment, name, nullif(key_path, '') "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(7);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom7To8(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom7To8", DOM);
+
+  nsresult rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "id, "
+      "object_store_id, "
+      "name, "
+      "key_path, "
+      "unique_index, "
+      "object_store_autoincrement"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT id, object_store_id, name, key_path, "
+      "unique_index, object_store_autoincrement "
+      "FROM object_store_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE object_store_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE object_store_index ("
+      "id INTEGER, "
+      "object_store_id INTEGER NOT NULL, "
+      "name TEXT NOT NULL, "
+      "key_path TEXT NOT NULL, "
+      "unique_index INTEGER NOT NULL, "
+      "multientry INTEGER NOT NULL, "
+      "object_store_autoincrement INTERGER NOT NULL, "
+      "PRIMARY KEY (id), "
+      "UNIQUE (object_store_id, name), "
+      "FOREIGN KEY (object_store_id) REFERENCES object_store(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_store_index "
+      "SELECT id, object_store_id, name, key_path, "
+      "unique_index, 0, object_store_autoincrement "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(8);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+class CompressDataBlobsFunction final : public mozIStorageFunction {
+ public:
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~CompressDataBlobsFunction() = default;
+
+  NS_IMETHOD
+  OnFunctionCall(mozIStorageValueArray* aArguments,
+                 nsIVariant** aResult) override {
+    MOZ_ASSERT(aArguments);
+    MOZ_ASSERT(aResult);
+
+    AUTO_PROFILER_LABEL("CompressDataBlobsFunction::OnFunctionCall", DOM);
+
+    uint32_t argc;
+    nsresult rv = aArguments->GetNumEntries(&argc);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    if (argc != 1) {
+      NS_WARNING("Don't call me with the wrong number of arguments!");
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    int32_t type;
+    rv = aArguments->GetTypeOfIndex(0, &type);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    if (type != mozIStorageStatement::VALUE_TYPE_BLOB) {
+      NS_WARNING("Don't call me with the wrong type of arguments!");
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    const uint8_t* uncompressed;
+    uint32_t uncompressedLength;
+    rv = aArguments->GetSharedBlob(0, &uncompressedLength, &uncompressed);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    size_t compressedLength = snappy::MaxCompressedLength(uncompressedLength);
+    UniqueFreePtr<uint8_t> compressed(
+        static_cast<uint8_t*>(malloc(compressedLength)));
+    if (NS_WARN_IF(!compressed)) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    snappy::RawCompress(
+        reinterpret_cast<const char*>(uncompressed), uncompressedLength,
+        reinterpret_cast<char*>(compressed.get()), &compressedLength);
+
+    std::pair<uint8_t*, int> data(compressed.release(), int(compressedLength));
+
+    nsCOMPtr<nsIVariant> result =
+        new mozilla::storage::AdoptedBlobVariant(data);
+
+    result.forget(aResult);
+    return NS_OK;
+  }
+};
+
+nsresult UpgradeSchemaFrom8To9_0(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom8To9_0", DOM);
+
+  // We no longer use the dataVersion column.
+  nsresult rv =
+      aConnection.ExecuteSimpleSQL("UPDATE database SET dataVersion = 0;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsCOMPtr<mozIStorageFunction> compressor = new CompressDataBlobsFunction();
+
+  constexpr auto compressorName = "compress"_ns;
+
+  rv = aConnection.CreateFunction(compressorName, 1, compressor);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Turn off foreign key constraints before we do anything here.
+  rv = aConnection.ExecuteSimpleSQL(
+      "UPDATE object_data SET data = compress(data);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "UPDATE ai_object_data SET data = compress(data);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.RemoveFunction(compressorName);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(9, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom9_0To10_0(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom9_0To10_0", DOM);
+
+  nsresult rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE object_data ADD COLUMN file_ids TEXT;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE ai_object_data ADD COLUMN file_ids TEXT;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = CreateFileTables(aConnection);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(10, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom10_0To11_0(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom10_0To11_0", DOM);
+
+  nsresult rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "id, "
+      "object_store_id, "
+      "name, "
+      "key_path, "
+      "unique_index, "
+      "multientry"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT id, object_store_id, name, key_path, "
+      "unique_index, multientry "
+      "FROM object_store_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE object_store_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE object_store_index ("
+      "id INTEGER PRIMARY KEY, "
+      "object_store_id INTEGER NOT NULL, "
+      "name TEXT NOT NULL, "
+      "key_path TEXT NOT NULL, "
+      "unique_index INTEGER NOT NULL, "
+      "multientry INTEGER NOT NULL, "
+      "UNIQUE (object_store_id, name), "
+      "FOREIGN KEY (object_store_id) REFERENCES object_store(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_store_index "
+      "SELECT id, object_store_id, name, key_path, "
+      "unique_index, multientry "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "DROP TRIGGER object_data_insert_trigger;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_data (object_store_id, key_value, data, file_ids) "
+      "SELECT object_store_id, id, data, file_ids "
+      "FROM ai_object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_insert_trigger "
+      "AFTER INSERT ON object_data "
+      "FOR EACH ROW "
+      "WHEN NEW.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(NULL, NEW.file_ids); "
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO index_data (index_id, value, object_data_key, "
+      "object_data_id) "
+      "SELECT ai_index_data.index_id, ai_index_data.value, "
+      "ai_index_data.ai_object_data_id, object_data.id "
+      "FROM ai_index_data "
+      "INNER JOIN object_store_index ON "
+      "object_store_index.id = ai_index_data.index_id "
+      "INNER JOIN object_data ON "
+      "object_data.object_store_id = object_store_index.object_store_id AND "
+      "object_data.key_value = ai_index_data.ai_object_data_id;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO unique_index_data (index_id, value, object_data_key, "
+      "object_data_id) "
+      "SELECT ai_unique_index_data.index_id, ai_unique_index_data.value, "
+      "ai_unique_index_data.ai_object_data_id, object_data.id "
+      "FROM ai_unique_index_data "
+      "INNER JOIN object_store_index ON "
+      "object_store_index.id = ai_unique_index_data.index_id "
+      "INNER JOIN object_data ON "
+      "object_data.object_store_id = object_store_index.object_store_id AND "
+      "object_data.key_value = ai_unique_index_data.ai_object_data_id;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "UPDATE object_store "
+      "SET auto_increment = (SELECT max(id) FROM ai_object_data) + 1 "
+      "WHERE auto_increment;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE ai_unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE ai_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE ai_object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(11, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+class EncodeKeysFunction final : public mozIStorageFunction {
+ public:
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~EncodeKeysFunction() = default;
+
+  NS_IMETHOD
+  OnFunctionCall(mozIStorageValueArray* aArguments,
+                 nsIVariant** aResult) override {
+    MOZ_ASSERT(aArguments);
+    MOZ_ASSERT(aResult);
+
+    AUTO_PROFILER_LABEL("EncodeKeysFunction::OnFunctionCall", DOM);
+
+    uint32_t argc;
+    nsresult rv = aArguments->GetNumEntries(&argc);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    if (argc != 1) {
+      NS_WARNING("Don't call me with the wrong number of arguments!");
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    int32_t type;
+    rv = aArguments->GetTypeOfIndex(0, &type);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    QM_TRY_INSPECT(
+        const auto& key, ([type, aArguments]() -> Result<Key, nsresult> {
+          switch (type) {
+            case mozIStorageStatement::VALUE_TYPE_INTEGER: {
+              int64_t intKey;
+              aArguments->GetInt64(0, &intKey);
+
+              Key key;
+              QM_TRY(key.SetFromInteger(intKey));
+
+              return key;
+            }
+            case mozIStorageStatement::VALUE_TYPE_TEXT: {
+              nsString stringKey;
+              aArguments->GetString(0, stringKey);
+
+              Key key;
+              QM_TRY(key.SetFromString(stringKey));
+
+              return key;
+            }
+            default:
+              NS_WARNING("Don't call me with the wrong type of arguments!");
+              return Err(NS_ERROR_UNEXPECTED);
+          }
+        }()));
+
+    const nsCString& buffer = key.GetBuffer();
+
+    std::pair<const void*, int> data(static_cast<const void*>(buffer.get()),
+                                     int(buffer.Length()));
+
+    nsCOMPtr<nsIVariant> result = new mozilla::storage::BlobVariant(data);
+
+    result.forget(aResult);
+    return NS_OK;
+  }
+};
+
+nsresult UpgradeSchemaFrom11_0To12_0(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom11_0To12_0", DOM);
+
+  constexpr auto encoderName = "encode"_ns;
+
+  nsCOMPtr<mozIStorageFunction> encoder = new EncodeKeysFunction();
+
+  nsresult rv = aConnection.CreateFunction(encoderName, 1, encoder);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "id INTEGER PRIMARY KEY, "
+      "object_store_id, "
+      "key_value, "
+      "data, "
+      "file_ids "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT id, object_store_id, encode(key_value), data, file_ids "
+      "FROM object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE object_data ("
+      "id INTEGER PRIMARY KEY, "
+      "object_store_id INTEGER NOT NULL, "
+      "key_value BLOB DEFAULT NULL, "
+      "file_ids TEXT, "
+      "data BLOB NOT NULL, "
+      "UNIQUE (object_store_id, key_value), "
+      "FOREIGN KEY (object_store_id) REFERENCES object_store(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_data "
+      "SELECT id, object_store_id, key_value, file_ids, data "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_insert_trigger "
+      "AFTER INSERT ON object_data "
+      "FOR EACH ROW "
+      "WHEN NEW.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(NULL, NEW.file_ids); "
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_update_trigger "
+      "AFTER UPDATE OF file_ids ON object_data "
+      "FOR EACH ROW "
+      "WHEN OLD.file_ids IS NOT NULL OR NEW.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(OLD.file_ids, NEW.file_ids); "
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_delete_trigger "
+      "AFTER DELETE ON object_data "
+      "FOR EACH ROW WHEN OLD.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(OLD.file_ids, NULL); "
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "index_id, "
+      "value, "
+      "object_data_key, "
+      "object_data_id "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT index_id, encode(value), encode(object_data_key), object_data_id "
+      "FROM index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE index_data ("
+      "index_id INTEGER NOT NULL, "
+      "value BLOB NOT NULL, "
+      "object_data_key BLOB NOT NULL, "
+      "object_data_id INTEGER NOT NULL, "
+      "PRIMARY KEY (index_id, value, object_data_key), "
+      "FOREIGN KEY (index_id) REFERENCES object_store_index(id) ON DELETE "
+      "CASCADE, "
+      "FOREIGN KEY (object_data_id) REFERENCES object_data(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO index_data "
+      "SELECT index_id, value, object_data_key, object_data_id "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX index_data_object_data_id_index "
+      "ON index_data (object_data_id);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TABLE temp_upgrade ("
+      "index_id, "
+      "value, "
+      "object_data_key, "
+      "object_data_id "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO temp_upgrade "
+      "SELECT index_id, encode(value), encode(object_data_key), object_data_id "
+      "FROM unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TABLE unique_index_data ("
+      "index_id INTEGER NOT NULL, "
+      "value BLOB NOT NULL, "
+      "object_data_key BLOB NOT NULL, "
+      "object_data_id INTEGER NOT NULL, "
+      "PRIMARY KEY (index_id, value, object_data_key), "
+      "UNIQUE (index_id, value), "
+      "FOREIGN KEY (index_id) REFERENCES object_store_index(id) ON DELETE "
+      "CASCADE "
+      "FOREIGN KEY (object_data_id) REFERENCES object_data(id) ON DELETE "
+      "CASCADE"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO unique_index_data "
+      "SELECT index_id, value, object_data_key, object_data_id "
+      "FROM temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE temp_upgrade;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX unique_index_data_object_data_id_index "
+      "ON unique_index_data (object_data_id);"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.RemoveFunction(encoderName);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(12, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom12_0To13_0(mozIStorageConnection& aConnection,
+                                     bool* aVacuumNeeded) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom12_0To13_0", DOM);
+
+  nsresult rv;
+
+#ifdef IDB_MOBILE
+  int32_t defaultPageSize;
+  rv = aConnection.GetDefaultPageSize(&defaultPageSize);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Enable auto_vacuum mode and update the page size to the platform default.
+  nsAutoCString upgradeQuery("PRAGMA auto_vacuum = FULL; PRAGMA page_size = ");
+  upgradeQuery.AppendInt(defaultPageSize);
+
+  rv = aConnection.ExecuteSimpleSQL(upgradeQuery);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  *aVacuumNeeded = true;
+#endif
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(13, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom13_0To14_0(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  // The only change between 13 and 14 was a different structured
+  // clone format, but it's backwards-compatible.
+  nsresult rv = aConnection.SetSchemaVersion(MakeSchemaVersion(14, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom14_0To15_0(mozIStorageConnection& aConnection) {
+  // The only change between 14 and 15 was a different structured
+  // clone format, but it's backwards-compatible.
+  nsresult rv = aConnection.SetSchemaVersion(MakeSchemaVersion(15, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom15_0To16_0(mozIStorageConnection& aConnection) {
+  // The only change between 15 and 16 was a different structured
+  // clone format, but it's backwards-compatible.
+  nsresult rv = aConnection.SetSchemaVersion(MakeSchemaVersion(16, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom16_0To17_0(mozIStorageConnection& aConnection) {
+  // The only change between 16 and 17 was a different structured
+  // clone format, but it's backwards-compatible.
+  nsresult rv = aConnection.SetSchemaVersion(MakeSchemaVersion(17, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+class UpgradeSchemaFrom17_0To18_0Helper final {
+  class InsertIndexDataValuesFunction;
+  class UpgradeKeyFunction;
+
+ public:
+  static nsresult DoUpgrade(mozIStorageConnection& aConnection,
+                            const nsACString& aOrigin);
+
+ private:
+  static nsresult DoUpgradeInternal(mozIStorageConnection& aConnection,
+                                    const nsACString& aOrigin);
+
+  UpgradeSchemaFrom17_0To18_0Helper() = delete;
+  ~UpgradeSchemaFrom17_0To18_0Helper() = delete;
+};
+
+class UpgradeSchemaFrom17_0To18_0Helper::InsertIndexDataValuesFunction final
+    : public mozIStorageFunction {
+ public:
+  InsertIndexDataValuesFunction() = default;
+
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~InsertIndexDataValuesFunction() = default;
+
+  NS_DECL_MOZISTORAGEFUNCTION
+};
+
+NS_IMPL_ISUPPORTS(
+    UpgradeSchemaFrom17_0To18_0Helper::InsertIndexDataValuesFunction,
+    mozIStorageFunction);
+
+NS_IMETHODIMP
+UpgradeSchemaFrom17_0To18_0Helper::InsertIndexDataValuesFunction::
+    OnFunctionCall(mozIStorageValueArray* aValues, nsIVariant** _retval) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_ASSERT(!IsOnBackgroundThread());
+  MOZ_ASSERT(aValues);
+  MOZ_ASSERT(_retval);
+
+#ifdef DEBUG
+  {
+    uint32_t argCount;
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetNumEntries(&argCount));
+    MOZ_ASSERT(argCount == 4);
+
+    int32_t valueType;
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(0, &valueType));
+    MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_NULL ||
+               valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
+
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(1, &valueType));
+    MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_INTEGER);
+
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(2, &valueType));
+    MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_INTEGER);
+
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(3, &valueType));
+    MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
+  }
+#endif
+
+  // Read out the previous value. It may be NULL, in which case we'll just end
+  // up with an empty array.
+  QM_TRY_UNWRAP(auto indexValues, ReadCompressedIndexDataValues(*aValues, 0));
+
+  IndexOrObjectStoreId indexId;
+  nsresult rv = aValues->GetInt64(1, &indexId);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  int32_t unique;
+  rv = aValues->GetInt32(2, &unique);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  Key value;
+  rv = value.SetFromValueArray(aValues, 3);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Update the array with the new addition.
+  if (NS_WARN_IF(!indexValues.InsertElementSorted(
+          IndexDataValue(indexId, !!unique, value), fallible))) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // Compress the array.
+  QM_TRY_UNWRAP((auto [indexValuesBlob, indexValuesBlobLength]),
+                MakeCompressedIndexDataValues(indexValues));
+
+  // The compressed blob is the result of this function.
+  nsCOMPtr<nsIVariant> result = new storage::AdoptedBlobVariant(
+      std::pair(indexValuesBlob.release(), indexValuesBlobLength));
+
+  result.forget(_retval);
+  return NS_OK;
+}
+
+class UpgradeSchemaFrom17_0To18_0Helper::UpgradeKeyFunction final
+    : public mozIStorageFunction {
+ public:
+  UpgradeKeyFunction() = default;
+
+  static nsresult CopyAndUpgradeKeyBuffer(const uint8_t* aSource,
+                                          const uint8_t* aSourceEnd,
+                                          uint8_t* aDestination) {
+    return CopyAndUpgradeKeyBufferInternal(aSource, aSourceEnd, aDestination,
+                                           0 /* aTagOffset */,
+                                           0 /* aRecursionDepth */);
+  }
+
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~UpgradeKeyFunction() = default;
+
+  static nsresult CopyAndUpgradeKeyBufferInternal(const uint8_t*& aSource,
+                                                  const uint8_t* aSourceEnd,
+                                                  uint8_t*& aDestination,
+                                                  uint8_t aTagOffset,
+                                                  uint8_t aRecursionDepth);
+
+  static uint32_t AdjustedSize(uint32_t aMaxSize, const uint8_t* aSource,
+                               const uint8_t* aSourceEnd) {
+    MOZ_ASSERT(aMaxSize);
+    MOZ_ASSERT(aSource);
+    MOZ_ASSERT(aSourceEnd);
+    MOZ_ASSERT(aSource <= aSourceEnd);
+
+    return std::min(aMaxSize, uint32_t(aSourceEnd - aSource));
+  }
+
+  NS_DECL_MOZISTORAGEFUNCTION
+};
+
+// static
+nsresult UpgradeSchemaFrom17_0To18_0Helper::UpgradeKeyFunction::
+    CopyAndUpgradeKeyBufferInternal(const uint8_t*& aSource,
+                                    const uint8_t* aSourceEnd,
+                                    uint8_t*& aDestination, uint8_t aTagOffset,
+                                    uint8_t aRecursionDepth) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_ASSERT(!IsOnBackgroundThread());
+  MOZ_ASSERT(aSource);
+  MOZ_ASSERT(*aSource);
+  MOZ_ASSERT(aSourceEnd);
+  MOZ_ASSERT(aSource < aSourceEnd);
+  MOZ_ASSERT(aDestination);
+  MOZ_ASSERT(aTagOffset <= Key::kMaxArrayCollapse);
+
+  static constexpr uint8_t kOldNumberTag = 0x1;
+  static constexpr uint8_t kOldDateTag = 0x2;
+  static constexpr uint8_t kOldStringTag = 0x3;
+  static constexpr uint8_t kOldArrayTag = 0x4;
+  static constexpr uint8_t kOldMaxType = kOldArrayTag;
+
+  if (NS_WARN_IF(aRecursionDepth > Key::kMaxRecursionDepth)) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_FILE_CORRUPTED;
+  }
+
+  const uint8_t sourceTag = *aSource - (aTagOffset * kOldMaxType);
+  MOZ_ASSERT(sourceTag);
+
+  if (NS_WARN_IF(sourceTag > kOldMaxType * Key::kMaxArrayCollapse)) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_FILE_CORRUPTED;
+  }
+
+  if (sourceTag == kOldNumberTag || sourceTag == kOldDateTag) {
+    // Write the new tag.
+    *aDestination++ = (sourceTag == kOldNumberTag ? Key::eFloat : Key::eDate) +
+                      (aTagOffset * Key::eMaxType);
+    aSource++;
+
+    // Numbers and Dates are encoded as 64-bit integers, but trailing 0
+    // bytes have been removed.
+    const uint32_t byteCount =
+        AdjustedSize(sizeof(uint64_t), aSource, aSourceEnd);
+
+    aDestination = std::copy(aSource, aSource + byteCount, aDestination);
+    aSource += byteCount;
+
+    return NS_OK;
+  }
+
+  if (sourceTag == kOldStringTag) {
+    // Write the new tag.
+    *aDestination++ = Key::eString + (aTagOffset * Key::eMaxType);
+    aSource++;
+
+    while (aSource < aSourceEnd) {
+      const uint8_t byte = *aSource++;
+      *aDestination++ = byte;
+
+      if (!byte) {
+        // Just copied the terminator.
+        break;
+      }
+
+      // Maybe copy one or two extra bytes if the byte is tagged and we have
+      // enough source space.
+      if (byte & 0x80) {
+        const uint32_t byteCount =
+            AdjustedSize((byte & 0x40) ? 2 : 1, aSource, aSourceEnd);
+
+        aDestination = std::copy(aSource, aSource + byteCount, aDestination);
+        aSource += byteCount;
+      }
+    }
+
+    return NS_OK;
+  }
+
+  if (NS_WARN_IF(sourceTag < kOldArrayTag)) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_FILE_CORRUPTED;
+  }
+
+  aTagOffset++;
+
+  if (aTagOffset == Key::kMaxArrayCollapse) {
+    MOZ_ASSERT(sourceTag == kOldArrayTag);
+
+    *aDestination++ = (aTagOffset * Key::eMaxType);
+    aSource++;
+
+    aTagOffset = 0;
+  }
+
+  while (aSource < aSourceEnd &&
+         (*aSource - (aTagOffset * kOldMaxType)) != Key::eTerminator) {
+    nsresult rv = CopyAndUpgradeKeyBufferInternal(
+        aSource, aSourceEnd, aDestination, aTagOffset, aRecursionDepth + 1);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    aTagOffset = 0;
+  }
+
+  if (aSource < aSourceEnd) {
+    MOZ_ASSERT((*aSource - (aTagOffset * kOldMaxType)) == Key::eTerminator);
+    *aDestination++ = Key::eTerminator + (aTagOffset * Key::eMaxType);
+    aSource++;
+  }
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(UpgradeSchemaFrom17_0To18_0Helper::UpgradeKeyFunction,
+                  mozIStorageFunction);
+
+NS_IMETHODIMP
+UpgradeSchemaFrom17_0To18_0Helper::UpgradeKeyFunction::OnFunctionCall(
+    mozIStorageValueArray* aValues, nsIVariant** _retval) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_ASSERT(!IsOnBackgroundThread());
+  MOZ_ASSERT(aValues);
+  MOZ_ASSERT(_retval);
+
+#ifdef DEBUG
+  {
+    uint32_t argCount;
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetNumEntries(&argCount));
+    MOZ_ASSERT(argCount == 1);
+
+    int32_t valueType;
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(0, &valueType));
+    MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
+  }
+#endif
+
+  // Dig the old key out of the values.
+  const uint8_t* blobData;
+  uint32_t blobDataLength;
+  nsresult rv = aValues->GetSharedBlob(0, &blobDataLength, &blobData);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Upgrading the key doesn't change the amount of space needed to hold it.
+  UniqueFreePtr<uint8_t> upgradedBlobData(
+      static_cast<uint8_t*>(malloc(blobDataLength)));
+  if (NS_WARN_IF(!upgradedBlobData)) {
+    IDB_REPORT_INTERNAL_ERR();
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  rv = CopyAndUpgradeKeyBuffer(blobData, blobData + blobDataLength,
+                               upgradedBlobData.get());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // The upgraded key is the result of this function.
+  std::pair<uint8_t*, int> data(upgradedBlobData.release(),
+                                int(blobDataLength));
+
+  nsCOMPtr<nsIVariant> result = new mozilla::storage::AdoptedBlobVariant(data);
+
+  result.forget(_retval);
+  return NS_OK;
+}
+
+// static
+nsresult UpgradeSchemaFrom17_0To18_0Helper::DoUpgrade(
+    mozIStorageConnection& aConnection, const nsACString& aOrigin) {
+  MOZ_ASSERT(!aOrigin.IsEmpty());
+
+  // Register the |upgrade_key| function.
+  RefPtr<UpgradeKeyFunction> updateFunction = new UpgradeKeyFunction();
+
+  constexpr auto upgradeKeyFunctionName = "upgrade_key"_ns;
+
+  nsresult rv =
+      aConnection.CreateFunction(upgradeKeyFunctionName, 1, updateFunction);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Register the |insert_idv| function.
+  RefPtr<InsertIndexDataValuesFunction> insertIDVFunction =
+      new InsertIndexDataValuesFunction();
+
+  constexpr auto insertIDVFunctionName = "insert_idv"_ns;
+
+  rv = aConnection.CreateFunction(insertIDVFunctionName, 4, insertIDVFunction);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_ALWAYS_SUCCEEDS(aConnection.RemoveFunction(upgradeKeyFunctionName));
+    return rv;
+  }
+
+  rv = DoUpgradeInternal(aConnection, aOrigin);
+
+  MOZ_ALWAYS_SUCCEEDS(aConnection.RemoveFunction(upgradeKeyFunctionName));
+  MOZ_ALWAYS_SUCCEEDS(aConnection.RemoveFunction(insertIDVFunctionName));
+
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+// static
+nsresult UpgradeSchemaFrom17_0To18_0Helper::DoUpgradeInternal(
+    mozIStorageConnection& aConnection, const nsACString& aOrigin) {
+  MOZ_ASSERT(!aOrigin.IsEmpty());
+
+  nsresult rv = aConnection.ExecuteSimpleSQL(
+      // Drop these triggers to avoid unnecessary work during the upgrade
+      // process.
+      "DROP TRIGGER object_data_insert_trigger;"
+      "DROP TRIGGER object_data_update_trigger;"
+      "DROP TRIGGER object_data_delete_trigger;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // Drop these indexes before we do anything else to free disk space.
+      "DROP INDEX index_data_object_data_id_index;"
+      "DROP INDEX unique_index_data_object_data_id_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Create the new tables and triggers first.
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // This will eventually become the |database| table.
+      "CREATE TABLE database_upgrade "
+      "( name TEXT PRIMARY KEY"
+      ", origin TEXT NOT NULL"
+      ", version INTEGER NOT NULL DEFAULT 0"
+      ", last_vacuum_time INTEGER NOT NULL DEFAULT 0"
+      ", last_analyze_time INTEGER NOT NULL DEFAULT 0"
+      ", last_vacuum_size INTEGER NOT NULL DEFAULT 0"
+      ") WITHOUT ROWID;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // This will eventually become the |object_store| table.
+      "CREATE TABLE object_store_upgrade"
+      "( id INTEGER PRIMARY KEY"
+      ", auto_increment INTEGER NOT NULL DEFAULT 0"
+      ", name TEXT NOT NULL"
+      ", key_path TEXT"
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // This will eventually become the |object_store_index| table.
+      "CREATE TABLE object_store_index_upgrade"
+      "( id INTEGER PRIMARY KEY"
+      ", object_store_id INTEGER NOT NULL"
+      ", name TEXT NOT NULL"
+      ", key_path TEXT NOT NULL"
+      ", unique_index INTEGER NOT NULL"
+      ", multientry INTEGER NOT NULL"
+      ", FOREIGN KEY (object_store_id) "
+      "REFERENCES object_store(id) "
+      ");"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // This will eventually become the |object_data| table.
+      "CREATE TABLE object_data_upgrade"
+      "( object_store_id INTEGER NOT NULL"
+      ", key BLOB NOT NULL"
+      ", index_data_values BLOB DEFAULT NULL"
+      ", file_ids TEXT"
+      ", data BLOB NOT NULL"
+      ", PRIMARY KEY (object_store_id, key)"
+      ", FOREIGN KEY (object_store_id) "
+      "REFERENCES object_store(id) "
+      ") WITHOUT ROWID;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // This will eventually become the |index_data| table.
+      "CREATE TABLE index_data_upgrade"
+      "( index_id INTEGER NOT NULL"
+      ", value BLOB NOT NULL"
+      ", object_data_key BLOB NOT NULL"
+      ", object_store_id INTEGER NOT NULL"
+      ", PRIMARY KEY (index_id, value, object_data_key)"
+      ", FOREIGN KEY (index_id) "
+      "REFERENCES object_store_index(id) "
+      ", FOREIGN KEY (object_store_id, object_data_key) "
+      "REFERENCES object_data(object_store_id, key) "
+      ") WITHOUT ROWID;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // This will eventually become the |unique_index_data| table.
+      "CREATE TABLE unique_index_data_upgrade"
+      "( index_id INTEGER NOT NULL"
+      ", value BLOB NOT NULL"
+      ", object_store_id INTEGER NOT NULL"
+      ", object_data_key BLOB NOT NULL"
+      ", PRIMARY KEY (index_id, value)"
+      ", FOREIGN KEY (index_id) "
+      "REFERENCES object_store_index(id) "
+      ", FOREIGN KEY (object_store_id, object_data_key) "
+      "REFERENCES object_data(object_store_id, key) "
+      ") WITHOUT ROWID;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // Temporarily store |index_data_values| that we build during the upgrade
+      // of the index tables. We will later move this to the |object_data|
+      // table.
+      "CREATE TEMPORARY TABLE temp_index_data_values "
+      "( object_store_id INTEGER NOT NULL"
+      ", key BLOB NOT NULL"
+      ", index_data_values BLOB DEFAULT NULL"
+      ", PRIMARY KEY (object_store_id, key)"
+      ") WITHOUT ROWID;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // These two triggers help build the |index_data_values| blobs. The nested
+      // SELECT statements help us achieve an "INSERT OR UPDATE"-like behavior.
+      "CREATE TEMPORARY TRIGGER unique_index_data_upgrade_insert_trigger "
+      "AFTER INSERT ON unique_index_data_upgrade "
+      "BEGIN "
+      "INSERT OR REPLACE INTO temp_index_data_values "
+      "VALUES "
+      "( NEW.object_store_id"
+      ", NEW.object_data_key"
+      ", insert_idv("
+      "( SELECT index_data_values "
+      "FROM temp_index_data_values "
+      "WHERE object_store_id = NEW.object_store_id "
+      "AND key = NEW.object_data_key "
+      "), NEW.index_id"
+      ", 1" /* unique */
+      ", NEW.value"
+      ")"
+      ");"
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TEMPORARY TRIGGER index_data_upgrade_insert_trigger "
+      "AFTER INSERT ON index_data_upgrade "
+      "BEGIN "
+      "INSERT OR REPLACE INTO temp_index_data_values "
+      "VALUES "
+      "( NEW.object_store_id"
+      ", NEW.object_data_key"
+      ", insert_idv("
+      "("
+      "SELECT index_data_values "
+      "FROM temp_index_data_values "
+      "WHERE object_store_id = NEW.object_store_id "
+      "AND key = NEW.object_data_key "
+      "), NEW.index_id"
+      ", 0" /* not unique */
+      ", NEW.value"
+      ")"
+      ");"
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Update the |unique_index_data| table to change the column order, remove the
+  // ON DELETE CASCADE clauses, and to apply the WITHOUT ROWID optimization.
+  rv = aConnection.ExecuteSimpleSQL(
+      // Insert all the data.
+      "INSERT INTO unique_index_data_upgrade "
+      "SELECT "
+      "unique_index_data.index_id, "
+      "upgrade_key(unique_index_data.value), "
+      "object_data.object_store_id, "
+      "upgrade_key(unique_index_data.object_data_key) "
+      "FROM unique_index_data "
+      "JOIN object_data "
+      "ON unique_index_data.object_data_id = object_data.id;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // The trigger is no longer needed.
+      "DROP TRIGGER unique_index_data_upgrade_insert_trigger;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // The old table is no longer needed.
+      "DROP TABLE unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // Rename the table.
+      "ALTER TABLE unique_index_data_upgrade "
+      "RENAME TO unique_index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Update the |index_data| table to change the column order, remove the ON
+  // DELETE CASCADE clauses, and to apply the WITHOUT ROWID optimization.
+  rv = aConnection.ExecuteSimpleSQL(
+      // Insert all the data.
+      "INSERT INTO index_data_upgrade "
+      "SELECT "
+      "index_data.index_id, "
+      "upgrade_key(index_data.value), "
+      "upgrade_key(index_data.object_data_key), "
+      "object_data.object_store_id "
+      "FROM index_data "
+      "JOIN object_data "
+      "ON index_data.object_data_id = object_data.id;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // The trigger is no longer needed.
+      "DROP TRIGGER index_data_upgrade_insert_trigger;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // The old table is no longer needed.
+      "DROP TABLE index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // Rename the table.
+      "ALTER TABLE index_data_upgrade "
+      "RENAME TO index_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Update the |object_data| table to add the |index_data_values| column,
+  // remove the ON DELETE CASCADE clause, and apply the WITHOUT ROWID
+  // optimization.
+  rv = aConnection.ExecuteSimpleSQL(
+      // Insert all the data.
+      "INSERT INTO object_data_upgrade "
+      "SELECT "
+      "object_data.object_store_id, "
+      "upgrade_key(object_data.key_value), "
+      "temp_index_data_values.index_data_values, "
+      "object_data.file_ids, "
+      "object_data.data "
+      "FROM object_data "
+      "LEFT JOIN temp_index_data_values "
+      "ON object_data.object_store_id = "
+      "temp_index_data_values.object_store_id "
+      "AND upgrade_key(object_data.key_value) = "
+      "temp_index_data_values.key;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // The temporary table is no longer needed.
+      "DROP TABLE temp_index_data_values;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // The old table is no longer needed.
+      "DROP TABLE object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      // Rename the table.
+      "ALTER TABLE object_data_upgrade "
+      "RENAME TO object_data;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Update the |object_store_index| table to remove the UNIQUE constraint and
+  // the ON DELETE CASCADE clause.
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_store_index_upgrade "
+      "SELECT * "
+      "FROM object_store_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE object_store_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE object_store_index_upgrade "
+      "RENAME TO object_store_index;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Update the |object_store| table to remove the UNIQUE constraint.
+  rv = aConnection.ExecuteSimpleSQL(
+      "INSERT INTO object_store_upgrade "
+      "SELECT * "
+      "FROM object_store;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE object_store;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE object_store_upgrade "
+      "RENAME TO object_store;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Update the |database| table to include the origin, vacuum information, and
+  // apply the WITHOUT ROWID optimization.
+  nsCOMPtr<mozIStorageStatement> stmt;
+
+  // The parameter names are not used, parameters are bound by index only
+  // locally in the same function.
+  rv = aConnection.CreateStatement(
+      "INSERT INTO database_upgrade "
+      "SELECT name, :origin, version, 0, 0, 0 "
+      "FROM database;"_ns,
+      getter_AddRefs(stmt));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = stmt->BindUTF8StringByIndex(0, aOrigin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = stmt->Execute();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL("DROP TABLE database;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE database_upgrade "
+      "RENAME TO database;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+#ifdef DEBUG
+  {
+    // Make sure there's only one entry in the |database| table.
+    QM_TRY_INSPECT(const auto& stmt,
+                   quota::CreateAndExecuteSingleStepStatement(
+                       aConnection, "SELECT COUNT(*) FROM database;"_ns),
+                   QM_ASSERT_UNREACHABLE);
+
+    int64_t count;
+    MOZ_ASSERT(NS_SUCCEEDED(stmt->GetInt64(0, &count)));
+
+    MOZ_ASSERT(count == 1);
+  }
+#endif
+
+  // Recreate file table triggers.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_insert_trigger "
+      "AFTER INSERT ON object_data "
+      "WHEN NEW.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(NULL, NEW.file_ids);"
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_update_trigger "
+      "AFTER UPDATE OF file_ids ON object_data "
+      "WHEN OLD.file_ids IS NOT NULL OR NEW.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(OLD.file_ids, NEW.file_ids);"
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_delete_trigger "
+      "AFTER DELETE ON object_data "
+      "WHEN OLD.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(OLD.file_ids, NULL);"
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Finally, turn on auto_vacuum mode. We use full auto_vacuum mode to reclaim
+  // disk space on mobile devices (at the cost of some COMMIT speed), and
+  // incremental auto_vacuum mode on desktop builds.
+  rv = aConnection.ExecuteSimpleSQL(
+#ifdef IDB_MOBILE
+      "PRAGMA auto_vacuum = FULL;"_ns
+#else
+      "PRAGMA auto_vacuum = INCREMENTAL;"_ns
+#endif
+  );
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(18, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom17_0To18_0(mozIStorageConnection& aConnection,
+                                     const nsACString& aOrigin) {
+  MOZ_ASSERT(!aOrigin.IsEmpty());
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom17_0To18_0", DOM);
+
+  return UpgradeSchemaFrom17_0To18_0Helper::DoUpgrade(aConnection, aOrigin);
+}
+
+nsresult UpgradeSchemaFrom18_0To19_0(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  nsresult rv;
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom18_0To19_0", DOM);
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE object_store_index "
+      "ADD COLUMN locale TEXT;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE object_store_index "
+      "ADD COLUMN is_auto_locale BOOLEAN;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE index_data "
+      "ADD COLUMN value_locale BLOB;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "ALTER TABLE unique_index_data "
+      "ADD COLUMN value_locale BLOB;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX index_data_value_locale_index "
+      "ON index_data (index_id, value_locale, object_data_key, value) "
+      "WHERE value_locale IS NOT NULL;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE INDEX unique_index_data_value_locale_index "
+      "ON unique_index_data (index_id, value_locale, object_data_key, value) "
+      "WHERE value_locale IS NOT NULL;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(19, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+class UpgradeFileIdsFunction final : public mozIStorageFunction {
+  SafeRefPtr<DatabaseFileManager> mFileManager;
+
+ public:
+  UpgradeFileIdsFunction() { AssertIsOnIOThread(); }
+
+  nsresult Init(nsIFile* aFMDirectory, mozIStorageConnection& aConnection);
+
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~UpgradeFileIdsFunction() {
+    AssertIsOnIOThread();
+
+    if (mFileManager) {
+      mFileManager->Invalidate();
+    }
+  }
+
+  NS_IMETHOD
+  OnFunctionCall(mozIStorageValueArray* aArguments,
+                 nsIVariant** aResult) override;
+};
+
+nsresult UpgradeSchemaFrom19_0To20_0(nsIFile* aFMDirectory,
+                                     mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom19_0To20_0", DOM);
+
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = aConnection.CreateStatement(
+      "SELECT count(*) "
+      "FROM object_data "
+      "WHERE file_ids IS NOT NULL"_ns,
+      getter_AddRefs(stmt));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  int64_t count;
+
+  {
+    mozStorageStatementScoper scoper(stmt);
+
+    QM_TRY_INSPECT(const bool& hasResult,
+                   MOZ_TO_RESULT_INVOKE_MEMBER(stmt, ExecuteStep));
+
+    if (NS_WARN_IF(!hasResult)) {
+      MOZ_ASSERT(false, "This should never be possible!");
+      return NS_ERROR_FAILURE;
+    }
+
+    count = stmt->AsInt64(0);
+    if (NS_WARN_IF(count < 0)) {
+      MOZ_ASSERT(false, "This should never be possible!");
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  if (count == 0) {
+    // Nothing to upgrade.
+    rv = aConnection.SetSchemaVersion(MakeSchemaVersion(20, 0));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  RefPtr<UpgradeFileIdsFunction> function = new UpgradeFileIdsFunction();
+
+  rv = function->Init(aFMDirectory, aConnection);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  constexpr auto functionName = "upgrade"_ns;
+
+  rv = aConnection.CreateFunction(functionName, 2, function);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Disable update trigger.
+  rv = aConnection.ExecuteSimpleSQL(
+      "DROP TRIGGER object_data_update_trigger;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "UPDATE object_data "
+      "SET file_ids = upgrade(file_ids, data) "
+      "WHERE file_ids IS NOT NULL;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Enable update trigger.
+  rv = aConnection.ExecuteSimpleSQL(
+      "CREATE TRIGGER object_data_update_trigger "
+      "AFTER UPDATE OF file_ids ON object_data "
+      "FOR EACH ROW "
+      "WHEN OLD.file_ids IS NOT NULL OR NEW.file_ids IS NOT NULL "
+      "BEGIN "
+      "SELECT update_refcount(OLD.file_ids, NEW.file_ids); "
+      "END;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.RemoveFunction(functionName);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(20, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+class UpgradeIndexDataValuesFunction final : public mozIStorageFunction {
+ public:
+  UpgradeIndexDataValuesFunction() { AssertIsOnIOThread(); }
+
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~UpgradeIndexDataValuesFunction() { AssertIsOnIOThread(); }
+
+  using IndexDataValuesArray = IndexDataValuesAutoArray;
+  Result<IndexDataValuesArray, nsresult> ReadOldCompressedIDVFromBlob(
+      Span<const uint8_t> aBlobData);
+
+  NS_IMETHOD
+  OnFunctionCall(mozIStorageValueArray* aArguments,
+                 nsIVariant** aResult) override;
+};
+
+NS_IMPL_ISUPPORTS(UpgradeIndexDataValuesFunction, mozIStorageFunction)
+
+Result<UpgradeIndexDataValuesFunction::IndexDataValuesArray, nsresult>
+UpgradeIndexDataValuesFunction::ReadOldCompressedIDVFromBlob(
+    const Span<const uint8_t> aBlobData) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  MOZ_ASSERT(!IsOnBackgroundThread());
+
+  IndexOrObjectStoreId indexId;
+  bool unique;
+  bool nextIndexIdAlreadyRead = false;
+
+  IndexDataValuesArray result;
+  for (auto remainder = aBlobData; !remainder.IsEmpty();) {
+    if (!nextIndexIdAlreadyRead) {
+      QM_TRY_UNWRAP((std::tie(indexId, unique, remainder)),
+                    ReadCompressedIndexId(remainder));
+    }
+    nextIndexIdAlreadyRead = false;
+
+    if (NS_WARN_IF(remainder.IsEmpty())) {
+      IDB_REPORT_INTERNAL_ERR();
+      return Err(NS_ERROR_FILE_CORRUPTED);
+    }
+
+    // Read key buffer length.
+    QM_TRY_INSPECT(
+        (const auto& [keyBufferLength, remainderAfterKeyBufferLength]),
+        ReadCompressedNumber(remainder));
+
+    if (NS_WARN_IF(remainderAfterKeyBufferLength.IsEmpty()) ||
+        NS_WARN_IF(keyBufferLength > uint64_t(UINT32_MAX)) ||
+        NS_WARN_IF(keyBufferLength > remainderAfterKeyBufferLength.Length())) {
+      IDB_REPORT_INTERNAL_ERR();
+      return Err(NS_ERROR_FILE_CORRUPTED);
+    }
+
+    const auto [keyBuffer, remainderAfterKeyBuffer] =
+        remainderAfterKeyBufferLength.SplitAt(keyBufferLength);
+    if (NS_WARN_IF(!result.EmplaceBack(fallible, indexId, unique,
+                                       Key{nsCString{AsChars(keyBuffer)}}))) {
+      IDB_REPORT_INTERNAL_ERR();
+      return Err(NS_ERROR_OUT_OF_MEMORY);
+    }
+
+    remainder = remainderAfterKeyBuffer;
+    if (!remainder.IsEmpty()) {
+      // Read either a sort key buffer length or an index id.
+      QM_TRY_INSPECT((const auto& [maybeIndexId, remainderAfterIndexId]),
+                     ReadCompressedNumber(remainder));
+
+      // Locale-aware indexes haven't been around long enough to have any users,
+      // we can safely assume all sort key buffer lengths will be zero.
+      // XXX This duplicates logic from ReadCompressedIndexId.
+      if (maybeIndexId != 0) {
+        unique = maybeIndexId % 2 == 1;
+        indexId = maybeIndexId / 2;
+        nextIndexIdAlreadyRead = true;
+      }
+
+      remainder = remainderAfterIndexId;
+    }
+  }
+  result.Sort();
+
+  return result;
+}
+
+NS_IMETHODIMP
+UpgradeIndexDataValuesFunction::OnFunctionCall(
+    mozIStorageValueArray* aArguments, nsIVariant** aResult) {
+  MOZ_ASSERT(aArguments);
+  MOZ_ASSERT(aResult);
+
+  AUTO_PROFILER_LABEL("UpgradeIndexDataValuesFunction::OnFunctionCall", DOM);
+
+  uint32_t argc;
+  nsresult rv = aArguments->GetNumEntries(&argc);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (argc != 1) {
+    NS_WARNING("Don't call me with the wrong number of arguments!");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  int32_t type;
+  rv = aArguments->GetTypeOfIndex(0, &type);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (type != mozIStorageStatement::VALUE_TYPE_BLOB) {
+    NS_WARNING("Don't call me with the wrong type of arguments!");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  const uint8_t* oldBlob;
+  uint32_t oldBlobLength;
+  rv = aArguments->GetSharedBlob(0, &oldBlobLength, &oldBlob);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  QM_TRY_INSPECT(const auto& oldIdv,
+                 ReadOldCompressedIDVFromBlob(Span(oldBlob, oldBlobLength)));
+
+  QM_TRY_UNWRAP((auto [newIdv, newIdvLength]),
+                MakeCompressedIndexDataValues(oldIdv));
+
+  nsCOMPtr<nsIVariant> result = new storage::AdoptedBlobVariant(
+      std::pair(newIdv.release(), newIdvLength));
+
+  result.forget(aResult);
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom20_0To21_0(mozIStorageConnection& aConnection) {
+  // This should have been part of the 18 to 19 upgrade, where we changed the
+  // layout of the index_data_values blobs but didn't upgrade the existing data.
+  // See bug 1202788.
+
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom20_0To21_0", DOM);
+
+  RefPtr<UpgradeIndexDataValuesFunction> function =
+      new UpgradeIndexDataValuesFunction();
+
+  constexpr auto functionName = "upgrade_idv"_ns;
+
+  nsresult rv = aConnection.CreateFunction(functionName, 1, function);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "UPDATE object_data "
+      "SET index_data_values = upgrade_idv(index_data_values) "
+      "WHERE index_data_values IS NOT NULL;"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.RemoveFunction(functionName);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(21, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom21_0To22_0(mozIStorageConnection& aConnection) {
+  // The only change between 21 and 22 was a different structured clone format,
+  // but it's backwards-compatible.
+  nsresult rv = aConnection.SetSchemaVersion(MakeSchemaVersion(22, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom22_0To23_0(mozIStorageConnection& aConnection,
+                                     const nsACString& aOrigin) {
+  AssertIsOnIOThread();
+
+  MOZ_ASSERT(!aOrigin.IsEmpty());
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom22_0To23_0", DOM);
+
+  nsCOMPtr<mozIStorageStatement> stmt;
+  // The parameter names are not used, parameters are bound by index only
+  // locally in the same function.
+  nsresult rv = aConnection.CreateStatement(
+      "UPDATE database SET origin = :origin;"_ns, getter_AddRefs(stmt));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = stmt->BindUTF8StringByIndex(0, aOrigin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = stmt->Execute();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(23, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom23_0To24_0(mozIStorageConnection& aConnection) {
+  // The only change between 23 and 24 was a different structured clone format,
+  // but it's backwards-compatible.
+  nsresult rv = aConnection.SetSchemaVersion(MakeSchemaVersion(24, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult UpgradeSchemaFrom24_0To25_0(mozIStorageConnection& aConnection) {
+  // The changes between 24 and 25 were an upgraded snappy library, a different
+  // structured clone format and a different file_ds format. But everything is
+  // backwards-compatible.
+  nsresult rv = aConnection.SetSchemaVersion(MakeSchemaVersion(25, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+class StripObsoleteOriginAttributesFunction final : public mozIStorageFunction {
+ public:
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~StripObsoleteOriginAttributesFunction() = default;
+
+  NS_IMETHOD
+  OnFunctionCall(mozIStorageValueArray* aArguments,
+                 nsIVariant** aResult) override {
+    MOZ_ASSERT(aArguments);
+    MOZ_ASSERT(aResult);
+
+    AUTO_PROFILER_LABEL("StripObsoleteOriginAttributesFunction::OnFunctionCall",
+                        DOM);
+
+#ifdef DEBUG
+    {
+      uint32_t argCount;
+      MOZ_ALWAYS_SUCCEEDS(aArguments->GetNumEntries(&argCount));
+      MOZ_ASSERT(argCount == 1);
+
+      int32_t type;
+      MOZ_ALWAYS_SUCCEEDS(aArguments->GetTypeOfIndex(0, &type));
+      MOZ_ASSERT(type == mozIStorageValueArray::VALUE_TYPE_TEXT);
+    }
+#endif
+
+    nsCString origin;
+    nsresult rv = aArguments->GetUTF8String(0, origin);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    // Deserialize and re-serialize to automatically drop any obsolete origin
+    // attributes.
+    OriginAttributes oa;
+
+    nsCString originNoSuffix;
+    bool ok = oa.PopulateFromOrigin(origin, originNoSuffix);
+    if (NS_WARN_IF(!ok)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    nsCString suffix;
+    oa.CreateSuffix(suffix);
+
+    nsCOMPtr<nsIVariant> result =
+        new mozilla::storage::UTF8TextVariant(originNoSuffix + suffix);
+
+    result.forget(aResult);
+    return NS_OK;
+  }
+};
+
+nsresult UpgradeSchemaFrom25_0To26_0(mozIStorageConnection& aConnection) {
+  AssertIsOnIOThread();
+
+  AUTO_PROFILER_LABEL("UpgradeSchemaFrom25_0To26_0", DOM);
+
+  constexpr auto functionName = "strip_obsolete_attributes"_ns;
+
+  nsCOMPtr<mozIStorageFunction> stripObsoleteAttributes =
+      new StripObsoleteOriginAttributesFunction();
+
+  nsresult rv = aConnection.CreateFunction(functionName,
+                                           /* aNumArguments */ 1,
+                                           stripObsoleteAttributes);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.ExecuteSimpleSQL(
+      "UPDATE DATABASE "
+      "SET origin = strip_obsolete_attributes(origin) "
+      "WHERE origin LIKE '%^%';"_ns);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.RemoveFunction(functionName);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aConnection.SetSchemaVersion(MakeSchemaVersion(26, 0));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(CompressDataBlobsFunction, mozIStorageFunction)
+NS_IMPL_ISUPPORTS(EncodeKeysFunction, mozIStorageFunction)
+NS_IMPL_ISUPPORTS(StripObsoleteOriginAttributesFunction, mozIStorageFunction);
+
+class DeserializeUpgradeValueHelper final : public Runnable {
+ public:
+  explicit DeserializeUpgradeValueHelper(
+      StructuredCloneReadInfoParent& aCloneReadInfo)
+      : Runnable("DeserializeUpgradeValueHelper"),
+        mMonitor("DeserializeUpgradeValueHelper::mMonitor"),
+        mCloneReadInfo(aCloneReadInfo),
+        mStatus(NS_ERROR_FAILURE) {}
+
+  nsresult DispatchAndWait(nsAString& aFileIds) {
+    // We don't need to go to the main-thread and use the sandbox.
+    if (!mCloneReadInfo.Data().Size()) {
+      PopulateFileIds(aFileIds);
+      return NS_OK;
+    }
+
+    // The operation will continue on the main-thread.
+
+    MOZ_ASSERT(!(mCloneReadInfo.Data().Size() % sizeof(uint64_t)));
+
+    MonitorAutoLock lock(mMonitor);
+
+    RefPtr<Runnable> self = this;
+    const nsresult rv = SchedulerGroup::Dispatch(self.forget());
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    lock.Wait();
+
+    if (NS_FAILED(mStatus)) {
+      return mStatus;
+    }
+
+    PopulateFileIds(aFileIds);
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  Run() override {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    AutoJSAPI jsapi;
+    jsapi.Init();
+    JSContext* cx = jsapi.cx();
+
+    JS::Rooted<JSObject*> global(cx, GetSandbox(cx));
+    if (NS_WARN_IF(!global)) {
+      OperationCompleted(NS_ERROR_FAILURE);
+      return NS_OK;
+    }
+
+    const JSAutoRealm ar(cx, global);
+
+    JS::Rooted<JS::Value> value(cx);
+    const nsresult rv = DeserializeUpgradeValue(cx, &value);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      OperationCompleted(rv);
+      return NS_OK;
+    }
+
+    OperationCompleted(NS_OK);
+    return NS_OK;
+  }
+
+ private:
+  nsresult DeserializeUpgradeValue(JSContext* aCx,
+                                   JS::MutableHandle<JS::Value> aValue) {
+    static const JSStructuredCloneCallbacks callbacks = {
+        StructuredCloneReadCallback<StructuredCloneReadInfoParent>,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr};
+
+    if (!JS_ReadStructuredClone(
+            aCx, mCloneReadInfo.Data(), JS_STRUCTURED_CLONE_VERSION,
+            JS::StructuredCloneScope::DifferentProcessForIndexedDB, aValue,
+            JS::CloneDataPolicy(), &callbacks, &mCloneReadInfo)) {
+      return NS_ERROR_DOM_DATA_CLONE_ERR;
+    }
+
+    return NS_OK;
+  }
+
+  void PopulateFileIds(nsAString& aFileIds) {
+    for (uint32_t count = mCloneReadInfo.Files().Length(), index = 0;
+         index < count; index++) {
+      const StructuredCloneFileParent& file = mCloneReadInfo.Files()[index];
+
+      const int64_t id = file.FileInfo().Id();
+
+      if (index) {
+        aFileIds.Append(' ');
+      }
+      aFileIds.AppendInt(file.Type() == StructuredCloneFileBase::eBlob ? id
+                                                                       : -id);
+    }
+  }
+
+  void OperationCompleted(nsresult aStatus) {
+    mStatus = aStatus;
+
+    MonitorAutoLock lock(mMonitor);
+    lock.Notify();
+  }
+
+  Monitor mMonitor MOZ_UNANNOTATED;
+  StructuredCloneReadInfoParent& mCloneReadInfo;
+  nsresult mStatus;
+};
+
+nsresult DeserializeUpgradeValueToFileIds(
+    StructuredCloneReadInfoParent& aCloneReadInfo, nsAString& aFileIds) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  const RefPtr<DeserializeUpgradeValueHelper> helper =
+      new DeserializeUpgradeValueHelper(aCloneReadInfo);
+  return helper->DispatchAndWait(aFileIds);
+}
+
+nsresult UpgradeFileIdsFunction::Init(nsIFile* aFMDirectory,
+                                      mozIStorageConnection& aConnection) {
+  // This DatabaseFileManager doesn't need real origin info, etc. The only
+  // purpose is to store file ids without adding more complexity or code
+  // duplication.
+  auto fileManager = MakeSafeRefPtr<DatabaseFileManager>(
+      PERSISTENCE_TYPE_INVALID, quota::OriginMetadata{}, u""_ns, ""_ns, false,
+      false);
+
+  nsresult rv = fileManager->Init(aFMDirectory, aConnection);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mFileManager = std::move(fileManager);
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(UpgradeFileIdsFunction, mozIStorageFunction)
+
+NS_IMETHODIMP
+UpgradeFileIdsFunction::OnFunctionCall(mozIStorageValueArray* aArguments,
+                                       nsIVariant** aResult) {
+  MOZ_ASSERT(aArguments);
+  MOZ_ASSERT(aResult);
+  MOZ_ASSERT(mFileManager);
+
+  AUTO_PROFILER_LABEL("UpgradeFileIdsFunction::OnFunctionCall", DOM);
+
+  uint32_t argc;
+  nsresult rv = aArguments->GetNumEntries(&argc);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (argc != 2) {
+    NS_WARNING("Don't call me with the wrong number of arguments!");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  QM_TRY_UNWRAP(auto cloneInfo, GetStructuredCloneReadInfoFromValueArray(
+                                    aArguments, 1, 0, *mFileManager));
+
+  nsAutoString fileIds;
+  // XXX does this really need non-const cloneInfo?
+  rv = DeserializeUpgradeValueToFileIds(cloneInfo, fileIds);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return NS_ERROR_DOM_DATA_CLONE_ERR;
+  }
+
+  nsCOMPtr<nsIVariant> result = new mozilla::storage::TextVariant(fileIds);
+
+  result.forget(aResult);
+  return NS_OK;
+}
+
+}  // namespace
+
+Result<bool, nsresult> MaybeUpgradeSchema(mozIStorageConnection& aConnection,
+                                          const int32_t aSchemaVersion,
+                                          nsIFile& aFMDirectory,
+                                          const nsACString& aOrigin) {
+  bool vacuumNeeded = false;
+  int32_t schemaVersion = aSchemaVersion;
+
+  // This logic needs to change next time we change the schema!
+  static_assert(kSQLiteSchemaVersion == int32_t((26 << 4) + 0),
+                "Upgrade function needed due to schema version increase.");
+
+  while (schemaVersion != kSQLiteSchemaVersion) {
+    switch (schemaVersion) {
+      case 4:
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom4To5(aConnection)));
+        break;
+      case 5:
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom5To6(aConnection)));
+        break;
+      case 6:
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom6To7(aConnection)));
+        break;
+      case 7:
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom7To8(aConnection)));
+        break;
+      case 8:
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom8To9_0(aConnection)));
+        vacuumNeeded = true;
+        break;
+      case MakeSchemaVersion(9, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom9_0To10_0(aConnection)));
+        break;
+      case MakeSchemaVersion(10, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom10_0To11_0(aConnection)));
+        break;
+      case MakeSchemaVersion(11, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom11_0To12_0(aConnection)));
+        break;
+      case MakeSchemaVersion(12, 0):
+        QM_TRY(MOZ_TO_RESULT(
+            UpgradeSchemaFrom12_0To13_0(aConnection, &vacuumNeeded)));
+        break;
+      case MakeSchemaVersion(13, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom13_0To14_0(aConnection)));
+        break;
+      case MakeSchemaVersion(14, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom14_0To15_0(aConnection)));
+        break;
+      case MakeSchemaVersion(15, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom15_0To16_0(aConnection)));
+        break;
+      case MakeSchemaVersion(16, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom16_0To17_0(aConnection)));
+        break;
+      case MakeSchemaVersion(17, 0):
+        QM_TRY(
+            MOZ_TO_RESULT(UpgradeSchemaFrom17_0To18_0(aConnection, aOrigin)));
+        vacuumNeeded = true;
+        break;
+      case MakeSchemaVersion(18, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom18_0To19_0(aConnection)));
+        break;
+      case MakeSchemaVersion(19, 0):
+        QM_TRY(MOZ_TO_RESULT(
+            UpgradeSchemaFrom19_0To20_0(&aFMDirectory, aConnection)));
+        break;
+      case MakeSchemaVersion(20, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom20_0To21_0(aConnection)));
+        break;
+      case MakeSchemaVersion(21, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom21_0To22_0(aConnection)));
+        break;
+      case MakeSchemaVersion(22, 0):
+        QM_TRY(
+            MOZ_TO_RESULT(UpgradeSchemaFrom22_0To23_0(aConnection, aOrigin)));
+        break;
+      case MakeSchemaVersion(23, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom23_0To24_0(aConnection)));
+        break;
+      case MakeSchemaVersion(24, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom24_0To25_0(aConnection)));
+        break;
+      case MakeSchemaVersion(25, 0):
+        QM_TRY(MOZ_TO_RESULT(UpgradeSchemaFrom25_0To26_0(aConnection)));
+        break;
+      default:
+        QM_FAIL(Err(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR), []() {
+          IDB_WARNING(
+              "Unable to open IndexedDB database, no upgrade path is "
+              "available!");
+        });
+    }
+
+    QM_TRY_UNWRAP(schemaVersion,
+                  MOZ_TO_RESULT_INVOKE_MEMBER(aConnection, GetSchemaVersion));
+  }
+
+  MOZ_ASSERT(schemaVersion == kSQLiteSchemaVersion);
+
+  return vacuumNeeded;
+}
+
+}  // namespace mozilla::dom::indexedDB
+
+#undef IDB_MOBILE