summaryrefslogtreecommitdiffstats
path: root/dom/indexedDB/IDBDatabase.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/indexedDB/IDBDatabase.cpp')
-rw-r--r--dom/indexedDB/IDBDatabase.cpp1435
1 files changed, 1435 insertions, 0 deletions
diff --git a/dom/indexedDB/IDBDatabase.cpp b/dom/indexedDB/IDBDatabase.cpp
new file mode 100644
index 000000000..5592e7f93
--- /dev/null
+++ b/dom/indexedDB/IDBDatabase.cpp
@@ -0,0 +1,1435 @@
+/* -*- 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 "IDBDatabase.h"
+
+#include "FileInfo.h"
+#include "IDBEvents.h"
+#include "IDBFactory.h"
+#include "IDBIndex.h"
+#include "IDBMutableFile.h"
+#include "IDBObjectStore.h"
+#include "IDBRequest.h"
+#include "IDBTransaction.h"
+#include "IDBFactory.h"
+#include "IndexedDatabaseManager.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/EventDispatcher.h"
+#include "MainThreadUtils.h"
+#include "mozilla/Services.h"
+#include "mozilla/storage.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/DOMStringList.h"
+#include "mozilla/dom/DOMStringListBinding.h"
+#include "mozilla/dom/Exceptions.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/IDBDatabaseBinding.h"
+#include "mozilla/dom/IDBObjectStoreBinding.h"
+#include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileChild.h"
+#include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/BackgroundUtils.h"
+#include "mozilla/dom/ipc/BlobChild.h"
+#include "mozilla/dom/ipc/nsIRemoteBlob.h"
+#include "mozilla/dom/quota/QuotaManager.h"
+#include "mozilla/ipc/FileDescriptor.h"
+#include "mozilla/ipc/InputStreamParams.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "nsAutoPtr.h"
+#include "nsCOMPtr.h"
+#include "nsIDocument.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsIScriptError.h"
+#include "nsISupportsPrimitives.h"
+#include "nsThreadUtils.h"
+#include "ProfilerHelpers.h"
+#include "ReportInternalError.h"
+#include "ScriptErrorHelper.h"
+#include "nsQueryObject.h"
+
+// Include this last to avoid path problems on Windows.
+#include "ActorsChild.h"
+
+namespace mozilla {
+namespace dom {
+
+using namespace mozilla::dom::quota;
+using namespace mozilla::ipc;
+using namespace mozilla::services;
+
+namespace {
+
+const char kCycleCollectionObserverTopic[] = "cycle-collector-end";
+const char kMemoryPressureObserverTopic[] = "memory-pressure";
+const char kWindowObserverTopic[] = "inner-window-destroyed";
+
+class CancelableRunnableWrapper final
+ : public CancelableRunnable
+{
+ nsCOMPtr<nsIRunnable> mRunnable;
+
+public:
+ explicit
+ CancelableRunnableWrapper(nsIRunnable* aRunnable)
+ : mRunnable(aRunnable)
+ {
+ MOZ_ASSERT(aRunnable);
+ }
+
+private:
+ ~CancelableRunnableWrapper()
+ { }
+
+ NS_DECL_NSIRUNNABLE
+ nsresult Cancel() override;
+};
+
+class DatabaseFile final
+ : public PBackgroundIDBDatabaseFileChild
+{
+ IDBDatabase* mDatabase;
+
+public:
+ explicit DatabaseFile(IDBDatabase* aDatabase)
+ : mDatabase(aDatabase)
+ {
+ MOZ_ASSERT(aDatabase);
+ aDatabase->AssertIsOnOwningThread();
+
+ MOZ_COUNT_CTOR(DatabaseFile);
+ }
+
+private:
+ ~DatabaseFile()
+ {
+ MOZ_ASSERT(!mDatabase);
+
+ MOZ_COUNT_DTOR(DatabaseFile);
+ }
+
+ virtual void
+ ActorDestroy(ActorDestroyReason aWhy) override
+ {
+ MOZ_ASSERT(mDatabase);
+ mDatabase->AssertIsOnOwningThread();
+
+ if (aWhy != Deletion) {
+ RefPtr<IDBDatabase> database = mDatabase;
+ database->NoteFinishedFileActor(this);
+ }
+
+#ifdef DEBUG
+ mDatabase = nullptr;
+#endif
+ }
+};
+
+} // namespace
+
+class IDBDatabase::Observer final
+ : public nsIObserver
+{
+ IDBDatabase* mWeakDatabase;
+ const uint64_t mWindowId;
+
+public:
+ Observer(IDBDatabase* aDatabase, uint64_t aWindowId)
+ : mWeakDatabase(aDatabase)
+ , mWindowId(aWindowId)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aDatabase);
+ }
+
+ void
+ Revoke()
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ mWeakDatabase = nullptr;
+ }
+
+ NS_DECL_ISUPPORTS
+
+private:
+ ~Observer()
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!mWeakDatabase);
+ }
+
+ NS_DECL_NSIOBSERVER
+};
+
+IDBDatabase::IDBDatabase(IDBOpenDBRequest* aRequest,
+ IDBFactory* aFactory,
+ BackgroundDatabaseChild* aActor,
+ DatabaseSpec* aSpec)
+ : IDBWrapperCache(aRequest)
+ , mFactory(aFactory)
+ , mSpec(aSpec)
+ , mBackgroundActor(aActor)
+ , mFileHandleDisabled(aRequest->IsFileHandleDisabled())
+ , mClosed(false)
+ , mInvalidated(false)
+ , mQuotaExceeded(false)
+{
+ MOZ_ASSERT(aRequest);
+ MOZ_ASSERT(aFactory);
+ aFactory->AssertIsOnOwningThread();
+ MOZ_ASSERT(aActor);
+ MOZ_ASSERT(aSpec);
+}
+
+IDBDatabase::~IDBDatabase()
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(!mBackgroundActor);
+}
+
+// static
+already_AddRefed<IDBDatabase>
+IDBDatabase::Create(IDBOpenDBRequest* aRequest,
+ IDBFactory* aFactory,
+ BackgroundDatabaseChild* aActor,
+ DatabaseSpec* aSpec)
+{
+ MOZ_ASSERT(aRequest);
+ MOZ_ASSERT(aFactory);
+ aFactory->AssertIsOnOwningThread();
+ MOZ_ASSERT(aActor);
+ MOZ_ASSERT(aSpec);
+
+ RefPtr<IDBDatabase> db =
+ new IDBDatabase(aRequest, aFactory, aActor, aSpec);
+
+ db->SetScriptOwner(aRequest->GetScriptOwner());
+
+ if (NS_IsMainThread()) {
+ if (nsPIDOMWindowInner* window = aFactory->GetParentObject()) {
+ uint64_t windowId = window->WindowID();
+
+ RefPtr<Observer> observer = new Observer(db, windowId);
+
+ nsCOMPtr<nsIObserverService> obsSvc = GetObserverService();
+ MOZ_ASSERT(obsSvc);
+
+ // This topic must be successfully registered.
+ if (NS_WARN_IF(NS_FAILED(
+ obsSvc->AddObserver(observer, kWindowObserverTopic, false)))) {
+ observer->Revoke();
+ return nullptr;
+ }
+
+ // These topics are not crucial.
+ if (NS_FAILED(obsSvc->AddObserver(observer,
+ kCycleCollectionObserverTopic,
+ false)) ||
+ NS_FAILED(obsSvc->AddObserver(observer,
+ kMemoryPressureObserverTopic,
+ false))) {
+ NS_WARNING("Failed to add additional memory observers!");
+ }
+
+ db->mObserver.swap(observer);
+ }
+ }
+
+ return db.forget();
+}
+
+#ifdef DEBUG
+
+void
+IDBDatabase::AssertIsOnOwningThread() const
+{
+ MOZ_ASSERT(mFactory);
+ mFactory->AssertIsOnOwningThread();
+}
+
+PRThread*
+IDBDatabase::OwningThread() const
+{
+ MOZ_ASSERT(mFactory);
+ return mFactory->OwningThread();
+}
+
+#endif // DEBUG
+
+void
+IDBDatabase::CloseInternal()
+{
+ AssertIsOnOwningThread();
+
+ if (!mClosed) {
+ mClosed = true;
+
+ ExpireFileActors(/* aExpireAll */ true);
+
+ if (mObserver) {
+ mObserver->Revoke();
+
+ nsCOMPtr<nsIObserverService> obsSvc = GetObserverService();
+ if (obsSvc) {
+ // These might not have been registered.
+ obsSvc->RemoveObserver(mObserver, kCycleCollectionObserverTopic);
+ obsSvc->RemoveObserver(mObserver, kMemoryPressureObserverTopic);
+
+ MOZ_ALWAYS_SUCCEEDS(
+ obsSvc->RemoveObserver(mObserver, kWindowObserverTopic));
+ }
+
+ mObserver = nullptr;
+ }
+
+ if (mBackgroundActor && !mInvalidated) {
+ mBackgroundActor->SendClose();
+ }
+ }
+}
+
+void
+IDBDatabase::InvalidateInternal()
+{
+ AssertIsOnOwningThread();
+
+ InvalidateMutableFiles();
+ AbortTransactions(/* aShouldWarn */ true);
+
+ CloseInternal();
+}
+
+void
+IDBDatabase::EnterSetVersionTransaction(uint64_t aNewVersion)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aNewVersion);
+ MOZ_ASSERT(!RunningVersionChangeTransaction());
+ MOZ_ASSERT(mSpec);
+ MOZ_ASSERT(!mPreviousSpec);
+
+ mPreviousSpec = new DatabaseSpec(*mSpec);
+
+ mSpec->metadata().version() = aNewVersion;
+}
+
+void
+IDBDatabase::ExitSetVersionTransaction()
+{
+ AssertIsOnOwningThread();
+
+ if (mPreviousSpec) {
+ mPreviousSpec = nullptr;
+ }
+}
+
+void
+IDBDatabase::RevertToPreviousState()
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(RunningVersionChangeTransaction());
+ MOZ_ASSERT(mPreviousSpec);
+
+ // Hold the current spec alive until RefreshTransactionsSpecEnumerator has
+ // finished!
+ nsAutoPtr<DatabaseSpec> currentSpec(mSpec.forget());
+
+ mSpec = mPreviousSpec.forget();
+
+ RefreshSpec(/* aMayDelete */ true);
+}
+
+void
+IDBDatabase::RefreshSpec(bool aMayDelete)
+{
+ AssertIsOnOwningThread();
+
+ for (auto iter = mTransactions.Iter(); !iter.Done(); iter.Next()) {
+ RefPtr<IDBTransaction> transaction = iter.Get()->GetKey();
+ MOZ_ASSERT(transaction);
+ transaction->AssertIsOnOwningThread();
+ transaction->RefreshSpec(aMayDelete);
+ }
+}
+
+nsPIDOMWindowInner*
+IDBDatabase::GetParentObject() const
+{
+ return mFactory->GetParentObject();
+}
+
+const nsString&
+IDBDatabase::Name() const
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mSpec);
+
+ return mSpec->metadata().name();
+}
+
+uint64_t
+IDBDatabase::Version() const
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mSpec);
+
+ return mSpec->metadata().version();
+}
+
+already_AddRefed<DOMStringList>
+IDBDatabase::ObjectStoreNames() const
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mSpec);
+
+ const nsTArray<ObjectStoreSpec>& objectStores = mSpec->objectStores();
+
+ RefPtr<DOMStringList> list = new DOMStringList();
+
+ if (!objectStores.IsEmpty()) {
+ nsTArray<nsString>& listNames = list->StringArray();
+ listNames.SetCapacity(objectStores.Length());
+
+ for (uint32_t index = 0; index < objectStores.Length(); index++) {
+ listNames.InsertElementSorted(objectStores[index].metadata().name());
+ }
+ }
+
+ return list.forget();
+}
+
+already_AddRefed<nsIDocument>
+IDBDatabase::GetOwnerDocument() const
+{
+ if (nsPIDOMWindowInner* window = GetOwner()) {
+ nsCOMPtr<nsIDocument> doc = window->GetExtantDoc();
+ return doc.forget();
+ }
+ return nullptr;
+}
+
+already_AddRefed<IDBObjectStore>
+IDBDatabase::CreateObjectStore(
+ const nsAString& aName,
+ const IDBObjectStoreParameters& aOptionalParameters,
+ ErrorResult& aRv)
+{
+ AssertIsOnOwningThread();
+
+ IDBTransaction* transaction = IDBTransaction::GetCurrent();
+ if (!transaction ||
+ transaction->Database() != this ||
+ transaction->GetMode() != IDBTransaction::VERSION_CHANGE) {
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
+ return nullptr;
+ }
+
+ if (!transaction->IsOpen()) {
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR);
+ return nullptr;
+ }
+
+ KeyPath keyPath(0);
+ if (NS_FAILED(KeyPath::Parse(aOptionalParameters.mKeyPath, &keyPath))) {
+ aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+ return nullptr;
+ }
+
+ nsTArray<ObjectStoreSpec>& objectStores = mSpec->objectStores();
+ for (uint32_t count = objectStores.Length(), index = 0;
+ index < count;
+ index++) {
+ if (aName == objectStores[index].metadata().name()) {
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR);
+ return nullptr;
+ }
+ }
+
+ if (!keyPath.IsAllowedForObjectStore(aOptionalParameters.mAutoIncrement)) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
+ return nullptr;
+ }
+
+ const ObjectStoreSpec* oldSpecElements =
+ objectStores.IsEmpty() ? nullptr : objectStores.Elements();
+
+ ObjectStoreSpec* newSpec = objectStores.AppendElement();
+ newSpec->metadata() =
+ ObjectStoreMetadata(transaction->NextObjectStoreId(), nsString(aName),
+ keyPath, aOptionalParameters.mAutoIncrement);
+
+ if (oldSpecElements &&
+ oldSpecElements != objectStores.Elements()) {
+ MOZ_ASSERT(objectStores.Length() > 1);
+
+ // Array got moved, update the spec pointers for all live objectStores and
+ // indexes.
+ RefreshSpec(/* aMayDelete */ false);
+ }
+
+ RefPtr<IDBObjectStore> objectStore =
+ transaction->CreateObjectStore(*newSpec);
+ MOZ_ASSERT(objectStore);
+
+ // Don't do this in the macro because we always need to increment the serial
+ // number to keep in sync with the parent.
+ const uint64_t requestSerialNumber = IDBRequest::NextSerialNumber();
+
+ IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
+ "database(%s).transaction(%s).createObjectStore(%s)",
+ "IndexedDB %s: C T[%lld] R[%llu]: "
+ "IDBDatabase.createObjectStore()",
+ IDB_LOG_ID_STRING(),
+ transaction->LoggingSerialNumber(),
+ requestSerialNumber,
+ IDB_LOG_STRINGIFY(this),
+ IDB_LOG_STRINGIFY(transaction),
+ IDB_LOG_STRINGIFY(objectStore));
+
+ return objectStore.forget();
+}
+
+void
+IDBDatabase::DeleteObjectStore(const nsAString& aName, ErrorResult& aRv)
+{
+ AssertIsOnOwningThread();
+
+ IDBTransaction* transaction = IDBTransaction::GetCurrent();
+ if (!transaction ||
+ transaction->Database() != this ||
+ transaction->GetMode() != IDBTransaction::VERSION_CHANGE) {
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
+ return;
+ }
+
+ if (!transaction->IsOpen()) {
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR);
+ return;
+ }
+
+ nsTArray<ObjectStoreSpec>& specArray = mSpec->objectStores();
+
+ int64_t objectStoreId = 0;
+
+ for (uint32_t specCount = specArray.Length(), specIndex = 0;
+ specIndex < specCount;
+ specIndex++) {
+ const ObjectStoreMetadata& metadata = specArray[specIndex].metadata();
+ MOZ_ASSERT(metadata.id());
+
+ if (aName == metadata.name()) {
+ objectStoreId = metadata.id();
+
+ // Must do this before altering the metadata array!
+ transaction->DeleteObjectStore(objectStoreId);
+
+ specArray.RemoveElementAt(specIndex);
+
+ RefreshSpec(/* aMayDelete */ false);
+ break;
+ }
+ }
+
+ if (!objectStoreId) {
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR);
+ return;
+ }
+
+ // Don't do this in the macro because we always need to increment the serial
+ // number to keep in sync with the parent.
+ const uint64_t requestSerialNumber = IDBRequest::NextSerialNumber();
+
+ IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
+ "database(%s).transaction(%s).deleteObjectStore(\"%s\")",
+ "IndexedDB %s: C T[%lld] R[%llu]: "
+ "IDBDatabase.deleteObjectStore()",
+ IDB_LOG_ID_STRING(),
+ transaction->LoggingSerialNumber(),
+ requestSerialNumber,
+ IDB_LOG_STRINGIFY(this),
+ IDB_LOG_STRINGIFY(transaction),
+ NS_ConvertUTF16toUTF8(aName).get());
+}
+
+already_AddRefed<IDBTransaction>
+IDBDatabase::Transaction(JSContext* aCx,
+ const StringOrStringSequence& aStoreNames,
+ IDBTransactionMode aMode,
+ ErrorResult& aRv)
+{
+ AssertIsOnOwningThread();
+
+ if ((aMode == IDBTransactionMode::Readwriteflush ||
+ aMode == IDBTransactionMode::Cleanup) &&
+ !IndexedDatabaseManager::ExperimentalFeaturesEnabled()) {
+ // Pretend that this mode doesn't exist. We don't have a way to annotate
+ // certain enum values as depending on preferences so we just duplicate the
+ // normal exception generation here.
+ aRv.ThrowTypeError<MSG_INVALID_ENUM_VALUE>(
+ NS_LITERAL_STRING("Argument 2 of IDBDatabase.transaction"),
+ NS_LITERAL_STRING("readwriteflush"),
+ NS_LITERAL_STRING("IDBTransactionMode"));
+ return nullptr;
+ }
+
+ RefPtr<IDBTransaction> transaction;
+ aRv = Transaction(aCx, aStoreNames, aMode, getter_AddRefs(transaction));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return transaction.forget();
+}
+
+nsresult
+IDBDatabase::Transaction(JSContext* aCx,
+ const StringOrStringSequence& aStoreNames,
+ IDBTransactionMode aMode,
+ IDBTransaction** aTransaction)
+{
+ AssertIsOnOwningThread();
+
+ if (NS_WARN_IF((aMode == IDBTransactionMode::Readwriteflush ||
+ aMode == IDBTransactionMode::Cleanup) &&
+ !IndexedDatabaseManager::ExperimentalFeaturesEnabled())) {
+ IDB_REPORT_INTERNAL_ERR();
+ return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+ }
+
+ if (QuotaManager::IsShuttingDown()) {
+ IDB_REPORT_INTERNAL_ERR();
+ return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+ }
+
+ if (mClosed || RunningVersionChangeTransaction()) {
+ return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
+ }
+
+ AutoTArray<nsString, 1> stackSequence;
+
+ if (aStoreNames.IsString()) {
+ stackSequence.AppendElement(aStoreNames.GetAsString());
+ } else {
+ MOZ_ASSERT(aStoreNames.IsStringSequence());
+ if (aStoreNames.GetAsStringSequence().IsEmpty()) {
+ return NS_ERROR_DOM_INVALID_ACCESS_ERR;
+ }
+ }
+
+ const nsTArray<nsString>& storeNames =
+ aStoreNames.IsString() ?
+ stackSequence :
+ static_cast<const nsTArray<nsString>&>(aStoreNames.GetAsStringSequence());
+ MOZ_ASSERT(!storeNames.IsEmpty());
+
+ const nsTArray<ObjectStoreSpec>& objectStores = mSpec->objectStores();
+ const uint32_t nameCount = storeNames.Length();
+
+ nsTArray<nsString> sortedStoreNames;
+ sortedStoreNames.SetCapacity(nameCount);
+
+ // Check to make sure the object store names we collected actually exist.
+ for (uint32_t nameIndex = 0; nameIndex < nameCount; nameIndex++) {
+ const nsString& name = storeNames[nameIndex];
+
+ bool found = false;
+
+ for (uint32_t objCount = objectStores.Length(), objIndex = 0;
+ objIndex < objCount;
+ objIndex++) {
+ if (objectStores[objIndex].metadata().name() == name) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found) {
+ return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR;
+ }
+
+ sortedStoreNames.InsertElementSorted(name);
+ }
+
+ // Remove any duplicates.
+ for (uint32_t nameIndex = nameCount - 1; nameIndex > 0; nameIndex--) {
+ if (sortedStoreNames[nameIndex] == sortedStoreNames[nameIndex - 1]) {
+ sortedStoreNames.RemoveElementAt(nameIndex);
+ }
+ }
+
+ IDBTransaction::Mode mode;
+ switch (aMode) {
+ case IDBTransactionMode::Readonly:
+ mode = IDBTransaction::READ_ONLY;
+ break;
+ case IDBTransactionMode::Readwrite:
+ if (mQuotaExceeded) {
+ mode = IDBTransaction::CLEANUP;
+ mQuotaExceeded = false;
+ } else {
+ mode = IDBTransaction::READ_WRITE;
+ }
+ break;
+ case IDBTransactionMode::Readwriteflush:
+ mode = IDBTransaction::READ_WRITE_FLUSH;
+ break;
+ case IDBTransactionMode::Cleanup:
+ mode = IDBTransaction::CLEANUP;
+ mQuotaExceeded = false;
+ break;
+ case IDBTransactionMode::Versionchange:
+ return NS_ERROR_DOM_TYPE_ERR;
+
+ default:
+ MOZ_CRASH("Unknown mode!");
+ }
+
+ RefPtr<IDBTransaction> transaction =
+ IDBTransaction::Create(aCx, this, sortedStoreNames, mode);
+ if (NS_WARN_IF(!transaction)) {
+ IDB_REPORT_INTERNAL_ERR();
+ return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+ }
+
+ BackgroundTransactionChild* actor =
+ new BackgroundTransactionChild(transaction);
+
+ IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld]: "
+ "database(%s).transaction(%s)",
+ "IndexedDB %s: C T[%lld]: IDBDatabase.transaction()",
+ IDB_LOG_ID_STRING(),
+ transaction->LoggingSerialNumber(),
+ IDB_LOG_STRINGIFY(this),
+ IDB_LOG_STRINGIFY(transaction));
+
+ MOZ_ALWAYS_TRUE(
+ mBackgroundActor->SendPBackgroundIDBTransactionConstructor(actor,
+ sortedStoreNames,
+ mode));
+
+ transaction->SetBackgroundActor(actor);
+
+ if (mode == IDBTransaction::CLEANUP) {
+ ExpireFileActors(/* aExpireAll */ true);
+ }
+
+ transaction.forget(aTransaction);
+ return NS_OK;
+}
+
+StorageType
+IDBDatabase::Storage() const
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mSpec);
+
+ return PersistenceTypeToStorage(mSpec->metadata().persistenceType());
+}
+
+already_AddRefed<IDBRequest>
+IDBDatabase::CreateMutableFile(JSContext* aCx,
+ const nsAString& aName,
+ const Optional<nsAString>& aType,
+ ErrorResult& aRv)
+{
+ AssertIsOnOwningThread();
+
+ if (QuotaManager::IsShuttingDown()) {
+ IDB_REPORT_INTERNAL_ERR();
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
+ return nullptr;
+ }
+
+ if (mClosed || mFileHandleDisabled) {
+ aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
+ return nullptr;
+ }
+
+ nsString type;
+ if (aType.WasPassed()) {
+ type = aType.Value();
+ }
+
+ CreateFileParams params(nsString(aName), type);
+
+ RefPtr<IDBRequest> request = IDBRequest::Create(aCx, this, nullptr);
+ MOZ_ASSERT(request);
+
+ BackgroundDatabaseRequestChild* actor =
+ new BackgroundDatabaseRequestChild(this, request);
+
+ IDB_LOG_MARK("IndexedDB %s: Child Request[%llu]: "
+ "database(%s).createMutableFile(%s)",
+ "IndexedDB %s: C R[%llu]: IDBDatabase.createMutableFile()",
+ IDB_LOG_ID_STRING(),
+ request->LoggingSerialNumber(),
+ IDB_LOG_STRINGIFY(this),
+ NS_ConvertUTF16toUTF8(aName).get());
+
+ mBackgroundActor->SendPBackgroundIDBDatabaseRequestConstructor(actor, params);
+
+ return request.forget();
+}
+
+void
+IDBDatabase::RegisterTransaction(IDBTransaction* aTransaction)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aTransaction);
+ aTransaction->AssertIsOnOwningThread();
+ MOZ_ASSERT(!mTransactions.Contains(aTransaction));
+
+ mTransactions.PutEntry(aTransaction);
+}
+
+void
+IDBDatabase::UnregisterTransaction(IDBTransaction* aTransaction)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aTransaction);
+ aTransaction->AssertIsOnOwningThread();
+ MOZ_ASSERT(mTransactions.Contains(aTransaction));
+
+ mTransactions.RemoveEntry(aTransaction);
+}
+
+void
+IDBDatabase::AbortTransactions(bool aShouldWarn)
+{
+ AssertIsOnOwningThread();
+
+ class MOZ_STACK_CLASS Helper final
+ {
+ typedef AutoTArray<RefPtr<IDBTransaction>, 20> StrongTransactionArray;
+ typedef AutoTArray<IDBTransaction*, 20> WeakTransactionArray;
+
+ public:
+ static void
+ AbortTransactions(IDBDatabase* aDatabase, const bool aShouldWarn)
+ {
+ MOZ_ASSERT(aDatabase);
+ aDatabase->AssertIsOnOwningThread();
+
+ nsTHashtable<nsPtrHashKey<IDBTransaction>>& transactionTable =
+ aDatabase->mTransactions;
+
+ if (!transactionTable.Count()) {
+ return;
+ }
+
+ StrongTransactionArray transactionsToAbort;
+ transactionsToAbort.SetCapacity(transactionTable.Count());
+
+ for (auto iter = transactionTable.Iter(); !iter.Done(); iter.Next()) {
+ IDBTransaction* transaction = iter.Get()->GetKey();
+ MOZ_ASSERT(transaction);
+
+ transaction->AssertIsOnOwningThread();
+
+ // Transactions that are already done can simply be ignored. Otherwise
+ // there is a race here and it's possible that the transaction has not
+ // been successfully committed yet so we will warn the user.
+ if (!transaction->IsDone()) {
+ transactionsToAbort.AppendElement(transaction);
+ }
+ }
+ MOZ_ASSERT(transactionsToAbort.Length() <= transactionTable.Count());
+
+ if (transactionsToAbort.IsEmpty()) {
+ return;
+ }
+
+ // We want to abort transactions as soon as possible so we iterate the
+ // transactions once and abort them all first, collecting the transactions
+ // that need to have a warning issued along the way. Those that need a
+ // warning will be a subset of those that are aborted, so we don't need
+ // additional strong references here.
+ WeakTransactionArray transactionsThatNeedWarning;
+
+ for (RefPtr<IDBTransaction>& transaction : transactionsToAbort) {
+ MOZ_ASSERT(transaction);
+ MOZ_ASSERT(!transaction->IsDone());
+
+ if (aShouldWarn) {
+ switch (transaction->GetMode()) {
+ // We ignore transactions that could not have written any data.
+ case IDBTransaction::READ_ONLY:
+ break;
+
+ // We warn for any transactions that could have written data.
+ case IDBTransaction::READ_WRITE:
+ case IDBTransaction::READ_WRITE_FLUSH:
+ case IDBTransaction::CLEANUP:
+ case IDBTransaction::VERSION_CHANGE:
+ transactionsThatNeedWarning.AppendElement(transaction);
+ break;
+
+ default:
+ MOZ_CRASH("Unknown mode!");
+ }
+ }
+
+ transaction->Abort(NS_ERROR_DOM_INDEXEDDB_ABORT_ERR);
+ }
+
+ static const char kWarningMessage[] =
+ "IndexedDBTransactionAbortNavigation";
+
+ for (IDBTransaction* transaction : transactionsThatNeedWarning) {
+ MOZ_ASSERT(transaction);
+
+ nsString filename;
+ uint32_t lineNo, column;
+ transaction->GetCallerLocation(filename, &lineNo, &column);
+
+ aDatabase->LogWarning(kWarningMessage, filename, lineNo, column);
+ }
+ }
+ };
+
+ Helper::AbortTransactions(this, aShouldWarn);
+}
+
+PBackgroundIDBDatabaseFileChild*
+IDBDatabase::GetOrCreateFileActorForBlob(Blob* aBlob)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aBlob);
+ MOZ_ASSERT(mBackgroundActor);
+
+ // We use the File's nsIWeakReference as the key to the table because
+ // a) it is unique per blob, b) it is reference-counted so that we can
+ // guarantee that it stays alive, and c) it doesn't hold the actual File
+ // alive.
+ nsCOMPtr<nsIDOMBlob> blob = aBlob;
+ nsCOMPtr<nsIWeakReference> weakRef = do_GetWeakReference(blob);
+ MOZ_ASSERT(weakRef);
+
+ PBackgroundIDBDatabaseFileChild* actor = nullptr;
+
+ if (!mFileActors.Get(weakRef, &actor)) {
+ BlobImpl* blobImpl = aBlob->Impl();
+ MOZ_ASSERT(blobImpl);
+
+ if (mReceivedBlobs.GetEntry(weakRef)) {
+ // This blob was previously retrieved from the database.
+ nsCOMPtr<nsIRemoteBlob> remoteBlob = do_QueryObject(blobImpl);
+ MOZ_ASSERT(remoteBlob);
+
+ BlobChild* blobChild = remoteBlob->GetBlobChild();
+ MOZ_ASSERT(blobChild);
+
+#ifdef DEBUG
+ {
+ PBackgroundChild* backgroundManager = blobChild->GetBackgroundManager();
+ MOZ_ASSERT(backgroundManager);
+
+ PBackgroundChild* thisManager = mBackgroundActor->Manager()->Manager();
+ MOZ_ASSERT(thisManager);
+
+ MOZ_ASSERT(thisManager == backgroundManager);
+ }
+#endif
+ auto* dbFile = new DatabaseFile(this);
+
+ actor =
+ mBackgroundActor->SendPBackgroundIDBDatabaseFileConstructor(dbFile,
+ blobChild);
+ if (NS_WARN_IF(!actor)) {
+ return nullptr;
+ }
+ } else {
+ // Make sure that the input stream we get here is one that can actually be
+ // serialized to PBackground.
+ PBackgroundChild* backgroundManager =
+ mBackgroundActor->Manager()->Manager();
+ MOZ_ASSERT(backgroundManager);
+
+ auto* blobChild =
+ static_cast<BlobChild*>(
+ BackgroundChild::GetOrCreateActorForBlob(backgroundManager, aBlob));
+ MOZ_ASSERT(blobChild);
+
+ auto* dbFile = new DatabaseFile(this);
+
+ actor =
+ mBackgroundActor->SendPBackgroundIDBDatabaseFileConstructor(dbFile,
+ blobChild);
+ if (NS_WARN_IF(!actor)) {
+ return nullptr;
+ }
+ }
+
+ MOZ_ASSERT(actor);
+
+ mFileActors.Put(weakRef, actor);
+ }
+
+ MOZ_ASSERT(actor);
+
+ return actor;
+}
+
+void
+IDBDatabase::NoteFinishedFileActor(PBackgroundIDBDatabaseFileChild* aFileActor)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aFileActor);
+
+ for (auto iter = mFileActors.Iter(); !iter.Done(); iter.Next()) {
+ MOZ_ASSERT(iter.Key());
+ PBackgroundIDBDatabaseFileChild* actor = iter.Data();
+ MOZ_ASSERT(actor);
+
+ if (actor == aFileActor) {
+ iter.Remove();
+ }
+ }
+}
+
+void
+IDBDatabase::NoteReceivedBlob(Blob* aBlob)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aBlob);
+ MOZ_ASSERT(mBackgroundActor);
+
+#ifdef DEBUG
+ {
+ RefPtr<BlobImpl> blobImpl = aBlob->Impl();
+ MOZ_ASSERT(blobImpl);
+
+ nsCOMPtr<nsIRemoteBlob> remoteBlob = do_QueryObject(blobImpl);
+ MOZ_ASSERT(remoteBlob);
+
+ BlobChild* blobChild = remoteBlob->GetBlobChild();
+ MOZ_ASSERT(blobChild);
+
+ PBackgroundChild* backgroundManager = blobChild->GetBackgroundManager();
+ MOZ_ASSERT(backgroundManager);
+
+ PBackgroundChild* thisManager = mBackgroundActor->Manager()->Manager();
+ MOZ_ASSERT(thisManager);
+
+ MOZ_ASSERT(thisManager == backgroundManager);
+ }
+#endif
+
+ nsCOMPtr<nsIDOMBlob> blob = aBlob;
+ nsCOMPtr<nsIWeakReference> weakRef = do_GetWeakReference(blob);
+ MOZ_ASSERT(weakRef);
+
+ // It's ok if this entry already exists in the table.
+ mReceivedBlobs.PutEntry(weakRef);
+}
+
+void
+IDBDatabase::DelayedMaybeExpireFileActors()
+{
+ AssertIsOnOwningThread();
+
+ if (!mBackgroundActor || !mFileActors.Count()) {
+ return;
+ }
+
+ nsCOMPtr<nsIRunnable> runnable =
+ NewRunnableMethod<bool>(this,
+ &IDBDatabase::ExpireFileActors,
+ /* aExpireAll */ false);
+ MOZ_ASSERT(runnable);
+
+ if (!NS_IsMainThread()) {
+ // Wrap as a nsICancelableRunnable to make workers happy.
+ nsCOMPtr<nsIRunnable> cancelable = new CancelableRunnableWrapper(runnable);
+ cancelable.swap(runnable);
+ }
+
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(runnable));
+}
+
+nsresult
+IDBDatabase::GetQuotaInfo(nsACString& aOrigin,
+ PersistenceType* aPersistenceType)
+{
+ using mozilla::dom::quota::QuotaManager;
+
+ MOZ_ASSERT(NS_IsMainThread(), "This can't work off the main thread!");
+
+ if (aPersistenceType) {
+ *aPersistenceType = mSpec->metadata().persistenceType();
+ MOZ_ASSERT(*aPersistenceType != PERSISTENCE_TYPE_INVALID);
+ }
+
+ PrincipalInfo* principalInfo = mFactory->GetPrincipalInfo();
+ MOZ_ASSERT(principalInfo);
+
+ switch (principalInfo->type()) {
+ case PrincipalInfo::TNullPrincipalInfo:
+ MOZ_CRASH("Is this needed?!");
+
+ case PrincipalInfo::TSystemPrincipalInfo:
+ QuotaManager::GetInfoForChrome(nullptr, nullptr, &aOrigin, nullptr);
+ return NS_OK;
+
+ case PrincipalInfo::TContentPrincipalInfo: {
+ nsresult rv;
+ nsCOMPtr<nsIPrincipal> principal =
+ PrincipalInfoToPrincipal(*principalInfo, &rv);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ rv = QuotaManager::GetInfoFromPrincipal(principal,
+ nullptr,
+ nullptr,
+ &aOrigin,
+ nullptr);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+ }
+
+ default:
+ MOZ_CRASH("Unknown PrincipalInfo type!");
+ }
+
+ MOZ_CRASH("Should never get here!");
+}
+
+void
+IDBDatabase::ExpireFileActors(bool aExpireAll)
+{
+ AssertIsOnOwningThread();
+
+ if (mBackgroundActor && mFileActors.Count()) {
+ for (auto iter = mFileActors.Iter(); !iter.Done(); iter.Next()) {
+ nsISupports* key = iter.Key();
+ PBackgroundIDBDatabaseFileChild* actor = iter.Data();
+ MOZ_ASSERT(key);
+ MOZ_ASSERT(actor);
+
+ bool shouldExpire = aExpireAll;
+ if (!shouldExpire) {
+ nsCOMPtr<nsIWeakReference> weakRef = do_QueryInterface(key);
+ MOZ_ASSERT(weakRef);
+
+ nsCOMPtr<nsISupports> referent = do_QueryReferent(weakRef);
+ shouldExpire = !referent;
+ }
+
+ if (shouldExpire) {
+ PBackgroundIDBDatabaseFileChild::Send__delete__(actor);
+
+ if (!aExpireAll) {
+ iter.Remove();
+ }
+ }
+ }
+ if (aExpireAll) {
+ mFileActors.Clear();
+ }
+ } else {
+ MOZ_ASSERT(!mFileActors.Count());
+ }
+
+ if (mReceivedBlobs.Count()) {
+ if (aExpireAll) {
+ mReceivedBlobs.Clear();
+ } else {
+ for (auto iter = mReceivedBlobs.Iter(); !iter.Done(); iter.Next()) {
+ nsISupports* key = iter.Get()->GetKey();
+ MOZ_ASSERT(key);
+
+ nsCOMPtr<nsIWeakReference> weakRef = do_QueryInterface(key);
+ MOZ_ASSERT(weakRef);
+
+ nsCOMPtr<nsISupports> referent = do_QueryReferent(weakRef);
+ if (!referent) {
+ iter.Remove();
+ }
+ }
+ }
+ }
+}
+
+void
+IDBDatabase::NoteLiveMutableFile(IDBMutableFile* aMutableFile)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aMutableFile);
+ aMutableFile->AssertIsOnOwningThread();
+ MOZ_ASSERT(!mLiveMutableFiles.Contains(aMutableFile));
+
+ mLiveMutableFiles.AppendElement(aMutableFile);
+}
+
+void
+IDBDatabase::NoteFinishedMutableFile(IDBMutableFile* aMutableFile)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aMutableFile);
+ aMutableFile->AssertIsOnOwningThread();
+
+ // It's ok if this is called after we cleared the array, so don't assert that
+ // aMutableFile is in the list.
+
+ mLiveMutableFiles.RemoveElement(aMutableFile);
+}
+
+void
+IDBDatabase::InvalidateMutableFiles()
+{
+ AssertIsOnOwningThread();
+
+ if (!mLiveMutableFiles.IsEmpty()) {
+ for (uint32_t count = mLiveMutableFiles.Length(), index = 0;
+ index < count;
+ index++) {
+ mLiveMutableFiles[index]->Invalidate();
+ }
+
+ mLiveMutableFiles.Clear();
+ }
+}
+
+void
+IDBDatabase::Invalidate()
+{
+ AssertIsOnOwningThread();
+
+ if (!mInvalidated) {
+ mInvalidated = true;
+
+ InvalidateInternal();
+ }
+}
+
+void
+IDBDatabase::LogWarning(const char* aMessageName,
+ const nsAString& aFilename,
+ uint32_t aLineNumber,
+ uint32_t aColumnNumber)
+{
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aMessageName);
+
+ ScriptErrorHelper::DumpLocalizedMessage(nsDependentCString(aMessageName),
+ aFilename,
+ aLineNumber,
+ aColumnNumber,
+ nsIScriptError::warningFlag,
+ mFactory->IsChrome(),
+ mFactory->InnerWindowID());
+}
+
+NS_IMPL_ADDREF_INHERITED(IDBDatabase, IDBWrapperCache)
+NS_IMPL_RELEASE_INHERITED(IDBDatabase, IDBWrapperCache)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(IDBDatabase)
+NS_INTERFACE_MAP_END_INHERITING(IDBWrapperCache)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(IDBDatabase)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(IDBDatabase, IDBWrapperCache)
+ tmp->AssertIsOnOwningThread();
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFactory)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(IDBDatabase, IDBWrapperCache)
+ tmp->AssertIsOnOwningThread();
+
+ // Don't unlink mFactory!
+
+ // We've been unlinked, at the very least we should be able to prevent further
+ // transactions from starting and unblock any other SetVersion callers.
+ tmp->CloseInternal();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+void
+IDBDatabase::LastRelease()
+{
+ AssertIsOnOwningThread();
+
+ CloseInternal();
+
+ if (mBackgroundActor) {
+ mBackgroundActor->SendDeleteMeInternal();
+ MOZ_ASSERT(!mBackgroundActor, "SendDeleteMeInternal should have cleared!");
+ }
+}
+
+nsresult
+IDBDatabase::PostHandleEvent(EventChainPostVisitor& aVisitor)
+{
+ nsresult rv =
+ IndexedDatabaseManager::CommonPostHandleEvent(aVisitor, mFactory);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+JSObject*
+IDBDatabase::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return IDBDatabaseBinding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMETHODIMP
+CancelableRunnableWrapper::Run()
+{
+ nsCOMPtr<nsIRunnable> runnable;
+ mRunnable.swap(runnable);
+
+ if (runnable) {
+ return runnable->Run();
+ }
+
+ return NS_OK;
+}
+
+nsresult
+CancelableRunnableWrapper::Cancel()
+{
+ if (mRunnable) {
+ mRunnable = nullptr;
+ return NS_OK;
+ }
+
+ return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMPL_ISUPPORTS(IDBDatabase::Observer, nsIObserver)
+
+NS_IMETHODIMP
+IDBDatabase::
+Observer::Observe(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* aData)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aTopic);
+
+ if (!strcmp(aTopic, kWindowObserverTopic)) {
+ if (mWeakDatabase) {
+ nsCOMPtr<nsISupportsPRUint64> supportsInt = do_QueryInterface(aSubject);
+ MOZ_ASSERT(supportsInt);
+
+ uint64_t windowId;
+ MOZ_ALWAYS_SUCCEEDS(supportsInt->GetData(&windowId));
+
+ if (windowId == mWindowId) {
+ RefPtr<IDBDatabase> database = mWeakDatabase;
+ mWeakDatabase = nullptr;
+
+ database->InvalidateInternal();
+ }
+ }
+
+ return NS_OK;
+ }
+
+ if (!strcmp(aTopic, kCycleCollectionObserverTopic) ||
+ !strcmp(aTopic, kMemoryPressureObserverTopic)) {
+ if (mWeakDatabase) {
+ RefPtr<IDBDatabase> database = mWeakDatabase;
+
+ database->ExpireFileActors(/* aExpireAll */ false);
+ }
+
+ return NS_OK;
+ }
+
+ NS_WARNING("Unknown observer topic!");
+ return NS_OK;
+}
+
+nsresult
+IDBDatabase::RenameObjectStore(int64_t aObjectStoreId, const nsAString& aName)
+{
+ MOZ_ASSERT(mSpec);
+
+ nsTArray<ObjectStoreSpec>& objectStores = mSpec->objectStores();
+
+ ObjectStoreSpec* foundObjectStoreSpec = nullptr;
+ // Find the matched object store spec and check if 'aName' is already used by
+ // another object store.
+ for (uint32_t objCount = objectStores.Length(), objIndex = 0;
+ objIndex < objCount;
+ objIndex++) {
+ const ObjectStoreSpec& objSpec = objectStores[objIndex];
+ if (objSpec.metadata().id() == aObjectStoreId) {
+ MOZ_ASSERT(!foundObjectStoreSpec);
+ foundObjectStoreSpec = &objectStores[objIndex];
+ continue;
+ }
+ if (aName == objSpec.metadata().name()) {
+ return NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR;
+ }
+ }
+
+ MOZ_ASSERT(foundObjectStoreSpec);
+
+ // Update the name of the matched object store.
+ foundObjectStoreSpec->metadata().name() = nsString(aName);
+
+ return NS_OK;
+}
+
+nsresult
+IDBDatabase::RenameIndex(int64_t aObjectStoreId,
+ int64_t aIndexId,
+ const nsAString& aName)
+{
+ MOZ_ASSERT(mSpec);
+
+ nsTArray<ObjectStoreSpec>& objectStores = mSpec->objectStores();
+
+ ObjectStoreSpec* foundObjectStoreSpec = nullptr;
+ // Find the matched index metadata and check if 'aName' is already used by
+ // another index.
+ for (uint32_t objCount = objectStores.Length(), objIndex = 0;
+ objIndex < objCount;
+ objIndex++) {
+ const ObjectStoreSpec& objSpec = objectStores[objIndex];
+ if (objSpec.metadata().id() == aObjectStoreId) {
+ foundObjectStoreSpec = &objectStores[objIndex];
+ break;
+ }
+ }
+
+ MOZ_ASSERT(foundObjectStoreSpec);
+
+ nsTArray<IndexMetadata>& indexes = foundObjectStoreSpec->indexes();
+ IndexMetadata* foundIndexMetadata = nullptr;
+ for (uint32_t idxCount = indexes.Length(), idxIndex = 0;
+ idxIndex < idxCount;
+ idxIndex++) {
+ const IndexMetadata& metadata = indexes[idxIndex];
+ if (metadata.id() == aIndexId) {
+ MOZ_ASSERT(!foundIndexMetadata);
+ foundIndexMetadata = &indexes[idxIndex];
+ continue;
+ }
+ if (aName == metadata.name()) {
+ return NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR;
+ }
+ }
+
+ MOZ_ASSERT(foundIndexMetadata);
+
+ // Update the name of the matched object store.
+ foundIndexMetadata->name() = nsString(aName);
+
+ return NS_OK;
+}
+
+} // namespace dom
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 02:42:38 +0000