dom/indexedDB/IDBTransaction.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "IDBTransaction.h"
   8
   9 #include "BackgroundChildImpl.h"
  10 #include "IDBDatabase.h"
  11 #include "IDBEvents.h"
  12 #include "IDBObjectStore.h"
  13 #include "IDBRequest.h"
  14 #include "mozilla/ErrorResult.h"
  15 #include "mozilla/EventDispatcher.h"
  16 #include "mozilla/HoldDropJSObjects.h"
  17 #include "mozilla/dom/DOMException.h"
  18 #include "mozilla/dom/DOMStringList.h"
  19 #include "mozilla/dom/WorkerRef.h"
  20 #include "mozilla/dom/WorkerPrivate.h"
  21 #include "mozilla/ipc/BackgroundChild.h"
  22 #include "mozilla/ScopeExit.h"
  23 #include "nsPIDOMWindow.h"
  24 #include "nsQueryObject.h"
  25 #include "nsServiceManagerUtils.h"
  26 #include "nsTHashtable.h"
  27 #include "ProfilerHelpers.h"
  28 #include "ReportInternalError.h"
  29 #include "ThreadLocal.h"
  30
  31 // Include this last to avoid path problems on Windows.
  32 #include "ActorsChild.h"
  33
  34 namespace {
  35 using namespace mozilla::dom::indexedDB;
  36 using namespace mozilla::ipc;
  37
  38 // TODO: Move this to xpcom/ds.
  39 template <typename T, typename Range, typename Transformation>
  40 nsTHashtable<T> TransformToHashtable(const Range& aRange,
  41                                      const Transformation& aTransformation) {
  42   // TODO: Determining the size of the range is not syntactically necessary (and
  43   // requires random access iterators if expressed this way). It is a
  44   // performance optimization. We could resort to std::distance to support any
  45   // iterator category, but this would lead to a double iteration of the range
  46   // in case of non-random-access iterators. It is hard to determine in general
  47   // if double iteration or reallocation is worse.
  48   auto res = nsTHashtable<T>(aRange.cend() - aRange.cbegin());
  49   // TOOD: std::transform could be used if nsTHashtable had an insert_iterator,
  50   // and this would also allow a more generic version not depending on
  51   // nsTHashtable at all.
  52   for (const auto& item : aRange) {
  53     res.PutEntry(aTransformation(item));
  54   }
  55   return res;
  56 }
  57
  58 ThreadLocal* GetIndexedDBThreadLocal() {
  59   BackgroundChildImpl::ThreadLocal* const threadLocal =
  60       BackgroundChildImpl::GetThreadLocalForCurrentThread();
  61   MOZ_ASSERT(threadLocal);
  62
  63   ThreadLocal* idbThreadLocal = threadLocal->mIndexedDBThreadLocal.get();
  64   MOZ_ASSERT(idbThreadLocal);
  65
  66   return idbThreadLocal;
  67 }
  68 }  // namespace
  69
  70 namespace mozilla::dom {
  71
  72 using namespace mozilla::dom::indexedDB;
  73 using namespace mozilla::ipc;
  74
  75 bool IDBTransaction::HasTransactionChild() const {
  76   return (mMode == Mode::VersionChange
  77               ? static_cast<void*>(
  78                     mBackgroundActor.mVersionChangeBackgroundActor)
  79               : mBackgroundActor.mNormalBackgroundActor) != nullptr;
  80 }
  81
  82 template <typename Func>
  83 auto IDBTransaction::DoWithTransactionChild(const Func& aFunc) const {
  84   MOZ_ASSERT(HasTransactionChild());
  85   return mMode == Mode::VersionChange
  86              ? aFunc(*mBackgroundActor.mVersionChangeBackgroundActor)
  87              : aFunc(*mBackgroundActor.mNormalBackgroundActor);
  88 }
  89
  90 IDBTransaction::IDBTransaction(IDBDatabase* const aDatabase,
  91                                const nsTArray<nsString>& aObjectStoreNames,
  92                                const Mode aMode, const Durability aDurability,
  93                                JSCallingLocation&& aCallerLocation,
  94                                CreatedFromFactoryFunction /*aDummy*/)
  95     : DOMEventTargetHelper(aDatabase),
  96       mDatabase(aDatabase),
  97       mObjectStoreNames(aObjectStoreNames.Clone()),
  98       mLoggingSerialNumber(GetIndexedDBThreadLocal()->NextTransactionSN(aMode)),
  99       mNextObjectStoreId(0),
 100       mNextIndexId(0),
 101       mNextRequestId(0),
 102       mAbortCode(NS_OK),
 103       mPendingRequestCount(0),
 104       mCallerLocation(std::move(aCallerLocation)),
 105       mMode(aMode),
 106       mDurability(aDurability),
 107       mRegistered(false),
 108       mNotedActiveTransaction(false) {
 109   MOZ_ASSERT(aDatabase);
 110   aDatabase->AssertIsOnOwningThread();
 111
 112   // This also nulls mBackgroundActor.mVersionChangeBackgroundActor, so this is
 113   // valid also for mMode == Mode::VersionChange.
 114   mBackgroundActor.mNormalBackgroundActor = nullptr;
 115
 116 #ifdef DEBUG
 117   if (!aObjectStoreNames.IsEmpty()) {
 118     // Make sure the array is properly sorted.
 119     MOZ_ASSERT(
 120         std::is_sorted(aObjectStoreNames.cbegin(), aObjectStoreNames.cend()));
 121
 122     // Make sure there are no duplicates in our objectStore names.
 123     MOZ_ASSERT(aObjectStoreNames.cend() ==
 124                std::adjacent_find(aObjectStoreNames.cbegin(),
 125                                   aObjectStoreNames.cend()));
 126   }
 127 #endif
 128
 129   mozilla::HoldJSObjects(this);
 130 }
 131
 132 IDBTransaction::~IDBTransaction() {
 133   AssertIsOnOwningThread();
 134   MOZ_ASSERT(!mPendingRequestCount);
 135   MOZ_ASSERT(mReadyState != ReadyState::Active);
 136   MOZ_ASSERT(mReadyState != ReadyState::Inactive);
 137   MOZ_ASSERT(mReadyState != ReadyState::Committing);
 138   MOZ_ASSERT(!mNotedActiveTransaction);
 139   MOZ_ASSERT(mSentCommitOrAbort);
 140   MOZ_ASSERT_IF(HasTransactionChild(), mFiredCompleteOrAbort);
 141
 142   if (mRegistered) {
 143     mDatabase->UnregisterTransaction(*this);
 144 #ifdef DEBUG
 145     mRegistered = false;
 146 #endif
 147   }
 148
 149   if (HasTransactionChild()) {
 150     if (mMode == Mode::VersionChange) {
 151       mBackgroundActor.mVersionChangeBackgroundActor->SendDeleteMeInternal(
 152           /* aFailedConstructor */ false);
 153     } else {
 154       mBackgroundActor.mNormalBackgroundActor->SendDeleteMeInternal();
 155     }
 156   }
 157   MOZ_ASSERT(!HasTransactionChild(),
 158              "SendDeleteMeInternal should have cleared!");
 159
 160   mozilla::DropJSObjects(this);
 161 }
 162
 163 // static
 164 SafeRefPtr<IDBTransaction> IDBTransaction::CreateVersionChange(
 165     IDBDatabase* const aDatabase,
 166     BackgroundVersionChangeTransactionChild* const aActor,
 167     const NotNull<IDBOpenDBRequest*> aOpenRequest,
 168     const int64_t aNextObjectStoreId, const int64_t aNextIndexId) {
 169   MOZ_ASSERT(aDatabase);
 170   aDatabase->AssertIsOnOwningThread();
 171   MOZ_ASSERT(aActor);
 172   MOZ_ASSERT(aNextObjectStoreId > 0);
 173   MOZ_ASSERT(aNextIndexId > 0);
 174
 175   const nsTArray<nsString> emptyObjectStoreNames;
 176
 177   // XXX: What should we have as durability hint here?
 178   auto transaction = MakeSafeRefPtr<IDBTransaction>(
 179       aDatabase, emptyObjectStoreNames, Mode::VersionChange,
 180       Durability::Default, JSCallingLocation(aOpenRequest->GetCallerLocation()),
 181       CreatedFromFactoryFunction{});
 182
 183   transaction->NoteActiveTransaction();
 184
 185   transaction->mBackgroundActor.mVersionChangeBackgroundActor = aActor;
 186   transaction->mNextObjectStoreId = aNextObjectStoreId;
 187   transaction->mNextIndexId = aNextIndexId;
 188
 189   aDatabase->RegisterTransaction(*transaction);
 190   transaction->mRegistered = true;
 191
 192   return transaction;
 193 }
 194
 195 // static
 196 SafeRefPtr<IDBTransaction> IDBTransaction::Create(
 197     JSContext* const aCx, IDBDatabase* const aDatabase,
 198     const nsTArray<nsString>& aObjectStoreNames, const Mode aMode,
 199     const Durability aDurability) {
 200   MOZ_ASSERT(aDatabase);
 201   aDatabase->AssertIsOnOwningThread();
 202   MOZ_ASSERT(!aObjectStoreNames.IsEmpty());
 203   MOZ_ASSERT(aMode == Mode::ReadOnly || aMode == Mode::ReadWrite ||
 204              aMode == Mode::ReadWriteFlush || aMode == Mode::Cleanup);
 205
 206   auto transaction = MakeSafeRefPtr<IDBTransaction>(
 207       aDatabase, aObjectStoreNames, aMode, aDurability,
 208       JSCallingLocation::Get(aCx), CreatedFromFactoryFunction{});
 209
 210   if (!NS_IsMainThread()) {
 211     WorkerPrivate* const workerPrivate = GetCurrentThreadWorkerPrivate();
 212     MOZ_ASSERT(workerPrivate);
 213
 214     workerPrivate->AssertIsOnWorkerThread();
 215
 216     RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create(
 217         workerPrivate, "IDBTransaction",
 218         [transaction = AsRefPtr(transaction.clonePtr())]() {
 219           transaction->AssertIsOnOwningThread();
 220           if (!transaction->IsCommittingOrFinished()) {
 221             IDB_REPORT_INTERNAL_ERR();
 222             transaction->AbortInternal(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR,
 223                                        nullptr);
 224           }
 225         });
 226     if (NS_WARN_IF(!workerRef)) {
 227 #ifdef DEBUG
 228       // Silence the destructor assertions if we never made this object live.
 229       transaction->mReadyState = ReadyState::Finished;
 230       transaction->mSentCommitOrAbort.Flip();
 231 #endif
 232       return nullptr;
 233     }
 234
 235     transaction->mWorkerRef = std::move(workerRef);
 236   }
 237
 238   nsCOMPtr<nsIRunnable> runnable =
 239       do_QueryObject(transaction.unsafeGetRawPtr());
 240   nsContentUtils::AddPendingIDBTransaction(runnable.forget());
 241
 242   aDatabase->RegisterTransaction(*transaction);
 243   transaction->mRegistered = true;
 244
 245   return transaction;
 246 }
 247
 248 // static
 249 Maybe<IDBTransaction&> IDBTransaction::MaybeCurrent() {
 250   using namespace mozilla::ipc;
 251
 252   MOZ_ASSERT(BackgroundChild::GetForCurrentThread());
 253
 254   return GetIndexedDBThreadLocal()->MaybeCurrentTransactionRef();
 255 }
 256
 257 #ifdef DEBUG
 258
 259 void IDBTransaction::AssertIsOnOwningThread() const {
 260   MOZ_ASSERT(mDatabase);
 261   mDatabase->AssertIsOnOwningThread();
 262 }
 263
 264 #endif  // DEBUG
 265
 266 void IDBTransaction::SetBackgroundActor(
 267     indexedDB::BackgroundTransactionChild* const aBackgroundActor) {
 268   AssertIsOnOwningThread();
 269   MOZ_ASSERT(aBackgroundActor);
 270   MOZ_ASSERT(!mBackgroundActor.mNormalBackgroundActor);
 271   MOZ_ASSERT(mMode != Mode::VersionChange);
 272
 273   NoteActiveTransaction();
 274
 275   mBackgroundActor.mNormalBackgroundActor = aBackgroundActor;
 276 }
 277
 278 BackgroundRequestChild* IDBTransaction::StartRequest(
 279     MovingNotNull<RefPtr<mozilla::dom::IDBRequest> > aRequest,
 280     const RequestParams& aParams) {
 281   AssertIsOnOwningThread();
 282   MOZ_ASSERT(aParams.type() != RequestParams::T__None);
 283
 284   BackgroundRequestChild* const actor =
 285       new BackgroundRequestChild(std::move(aRequest));
 286
 287   DoWithTransactionChild([this, actor, &aParams](auto& transactionChild) {
 288     transactionChild.SendPBackgroundIDBRequestConstructor(
 289         actor, NextRequestId(), aParams);
 290   });
 291
 292   // Balanced in BackgroundRequestChild::Recv__delete__().
 293   OnNewRequest();
 294
 295   return actor;
 296 }
 297
 298 void IDBTransaction::OpenCursor(PBackgroundIDBCursorChild& aBackgroundActor,
 299                                 const OpenCursorParams& aParams) {
 300   AssertIsOnOwningThread();
 301   MOZ_ASSERT(aParams.type() != OpenCursorParams::T__None);
 302
 303   DoWithTransactionChild([this, &aBackgroundActor, &aParams](auto& actor) {
 304     actor.SendPBackgroundIDBCursorConstructor(&aBackgroundActor,
 305                                               NextRequestId(), aParams);
 306   });
 307
 308   // Balanced in BackgroundCursorChild::RecvResponse().
 309   OnNewRequest();
 310 }
 311
 312 void IDBTransaction::RefreshSpec(const bool aMayDelete) {
 313   AssertIsOnOwningThread();
 314
 315   for (auto& objectStore : mObjectStores) {
 316     objectStore->RefreshSpec(aMayDelete);
 317   }
 318
 319   for (auto& objectStore : mDeletedObjectStores) {
 320     objectStore->RefreshSpec(false);
 321   }
 322 }
 323
 324 void IDBTransaction::OnNewRequest() {
 325   AssertIsOnOwningThread();
 326
 327   if (!mPendingRequestCount) {
 328     MOZ_ASSERT(ReadyState::Active == mReadyState);
 329     mStarted.Flip();
 330   }
 331
 332   ++mPendingRequestCount;
 333 }
 334
 335 void IDBTransaction::OnRequestFinished(
 336     const bool aRequestCompletedSuccessfully) {
 337   AssertIsOnOwningThread();
 338   MOZ_ASSERT(mReadyState != ReadyState::Active);
 339   MOZ_ASSERT_IF(mReadyState == ReadyState::Finished, !NS_SUCCEEDED(mAbortCode));
 340   MOZ_ASSERT(mPendingRequestCount);
 341
 342   --mPendingRequestCount;
 343
 344   if (!mPendingRequestCount) {
 345     if (mSentCommitOrAbort) {
 346       return;
 347     }
 348
 349     if (aRequestCompletedSuccessfully) {
 350       if (mReadyState == ReadyState::Inactive) {
 351         mReadyState = ReadyState::Committing;
 352       }
 353
 354       if (NS_SUCCEEDED(mAbortCode)) {
 355         SendCommit(true);
 356       } else {
 357         SendAbort(mAbortCode);
 358       }
 359     } else {
 360       // Don't try to send any more messages to the parent if the request actor
 361       // was killed. Set our state accordingly to Finished.
 362       mReadyState = ReadyState::Finished;
 363       mSentCommitOrAbort.Flip();
 364       IDB_LOG_MARK_CHILD_TRANSACTION(
 365           "Request actor was killed, transaction will be aborted",
 366           "IDBTransaction abort", LoggingSerialNumber());
 367     }
 368   }
 369 }
 370
 371 void IDBTransaction::SendCommit(const bool aAutoCommit) {
 372   AssertIsOnOwningThread();
 373   MOZ_ASSERT(NS_SUCCEEDED(mAbortCode));
 374   MOZ_ASSERT(IsCommittingOrFinished());
 375
 376   // Don't do this in the macro because we always need to increment the serial
 377   // number to keep in sync with the parent.
 378   const uint64_t requestSerialNumber = IDBRequest::NextSerialNumber();
 379
 380   IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
 381       "Committing transaction (%s)", "IDBTransaction commit (%s)",
 382       LoggingSerialNumber(), requestSerialNumber,
 383       aAutoCommit ? "automatically" : "explicitly");
 384
 385   const int64_t requestId = NextRequestId();
 386
 387   const auto lastRequestId = [this, aAutoCommit,
 388                               requestId]() -> Maybe<decltype(requestId)> {
 389     if (aAutoCommit) {
 390       return Nothing();
 391     }
 392
 393     // In case of an explicit commit, we need to note the id of the last
 394     // request to check if a request submitted before the commit request
 395     // failed. If we are currently in an event handler for a request on this
 396     // transaction, ignore this request. This is used to synchronize the
 397     // transaction's committing state with the parent side, to abort the
 398     // transaction in case of a request resulting in an error (see
 399     // https://w3c.github.io/IndexedDB/#async-execute-request, step 5.3.). With
 400     // automatic commit, this is not necessary, as the transaction's state will
 401     // only be set to committing after the last request completed.
 402     const auto maybeCurrentTransaction =
 403         BackgroundChildImpl::GetThreadLocalForCurrentThread()
 404             ->mIndexedDBThreadLocal->MaybeCurrentTransactionRef();
 405     const bool dispatchingEventForThisTransaction =
 406         maybeCurrentTransaction && &maybeCurrentTransaction.ref() == this;
 407
 408     return Some(requestId
 409                     ? (requestId - (dispatchingEventForThisTransaction ? 0 : 1))
 410                     : 0);
 411   }();
 412
 413   DoWithTransactionChild(
 414       [lastRequestId](auto& actor) { actor.SendCommit(lastRequestId); });
 415
 416   mSentCommitOrAbort.Flip();
 417 }
 418
 419 void IDBTransaction::SendAbort(const nsresult aResultCode) {
 420   AssertIsOnOwningThread();
 421   MOZ_ASSERT(NS_FAILED(aResultCode));
 422   MOZ_ASSERT(IsCommittingOrFinished());
 423
 424   // Don't do this in the macro because we always need to increment the serial
 425   // number to keep in sync with the parent.
 426   const uint64_t requestSerialNumber = IDBRequest::NextSerialNumber();
 427
 428   IDB_LOG_MARK_CHILD_TRANSACTION_REQUEST(
 429       "Aborting transaction with result 0x%" PRIx32,
 430       "IDBTransaction abort (0x%" PRIx32 ")", LoggingSerialNumber(),
 431       requestSerialNumber, static_cast<uint32_t>(aResultCode));
 432
 433   DoWithTransactionChild(
 434       [aResultCode](auto& actor) { actor.SendAbort(aResultCode); });
 435
 436   mSentCommitOrAbort.Flip();
 437 }
 438
 439 void IDBTransaction::NoteActiveTransaction() {
 440   AssertIsOnOwningThread();
 441   MOZ_ASSERT(!mNotedActiveTransaction);
 442
 443   mDatabase->NoteActiveTransaction();
 444   mNotedActiveTransaction = true;
 445 }
 446
 447 void IDBTransaction::MaybeNoteInactiveTransaction() {
 448   AssertIsOnOwningThread();
 449
 450   if (mNotedActiveTransaction) {
 451     mDatabase->NoteInactiveTransaction();
 452     mNotedActiveTransaction = false;
 453   }
 454 }
 455
 456 RefPtr<IDBObjectStore> IDBTransaction::CreateObjectStore(
 457     ObjectStoreSpec& aSpec) {
 458   AssertIsOnOwningThread();
 459   MOZ_ASSERT(aSpec.metadata().id());
 460   MOZ_ASSERT(Mode::VersionChange == mMode);
 461   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 462   MOZ_ASSERT(IsActive());
 463
 464 #ifdef DEBUG
 465   {
 466     // TODO: Bind name outside of lambda capture as a workaround for GCC 7 bug
 467     // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66735.
 468     const auto& name = aSpec.metadata().name();
 469     // TODO: Use #ifdef and local variable as a workaround for Bug 1583449.
 470     const bool objectStoreNameDoesNotYetExist =
 471         std::all_of(mObjectStores.cbegin(), mObjectStores.cend(),
 472                     [&name](const auto& objectStore) {
 473                       return objectStore->Name() != name;
 474                     });
 475     MOZ_ASSERT(objectStoreNameDoesNotYetExist);
 476   }
 477 #endif
 478
 479   MOZ_ALWAYS_TRUE(
 480       mBackgroundActor.mVersionChangeBackgroundActor->SendCreateObjectStore(
 481           aSpec.metadata()));
 482
 483   RefPtr<IDBObjectStore> objectStore = IDBObjectStore::Create(
 484       SafeRefPtr{this, AcquireStrongRefFromRawPtr{}}, aSpec);
 485   MOZ_ASSERT(objectStore);
 486
 487   mObjectStores.AppendElement(objectStore);
 488
 489   return objectStore;
 490 }
 491
 492 void IDBTransaction::DeleteObjectStore(const int64_t aObjectStoreId) {
 493   AssertIsOnOwningThread();
 494   MOZ_ASSERT(aObjectStoreId);
 495   MOZ_ASSERT(Mode::VersionChange == mMode);
 496   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 497   MOZ_ASSERT(IsActive());
 498
 499   MOZ_ALWAYS_TRUE(
 500       mBackgroundActor.mVersionChangeBackgroundActor->SendDeleteObjectStore(
 501           aObjectStoreId));
 502
 503   const auto foundIt =
 504       std::find_if(mObjectStores.begin(), mObjectStores.end(),
 505                    [aObjectStoreId](const auto& objectStore) {
 506                      return objectStore->Id() == aObjectStoreId;
 507                    });
 508   if (foundIt != mObjectStores.end()) {
 509     auto& objectStore = *foundIt;
 510     objectStore->NoteDeletion();
 511
 512     RefPtr<IDBObjectStore>* deletedObjectStore =
 513         mDeletedObjectStores.AppendElement();
 514     deletedObjectStore->swap(objectStore);
 515
 516     mObjectStores.RemoveElementAt(foundIt);
 517   }
 518 }
 519
 520 void IDBTransaction::RenameObjectStore(const int64_t aObjectStoreId,
 521                                        const nsAString& aName) const {
 522   AssertIsOnOwningThread();
 523   MOZ_ASSERT(aObjectStoreId);
 524   MOZ_ASSERT(Mode::VersionChange == mMode);
 525   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 526   MOZ_ASSERT(IsActive());
 527
 528   MOZ_ALWAYS_TRUE(
 529       mBackgroundActor.mVersionChangeBackgroundActor->SendRenameObjectStore(
 530           aObjectStoreId, nsString(aName)));
 531 }
 532
 533 void IDBTransaction::CreateIndex(
 534     IDBObjectStore* const aObjectStore,
 535     const indexedDB::IndexMetadata& aMetadata) const {
 536   AssertIsOnOwningThread();
 537   MOZ_ASSERT(aObjectStore);
 538   MOZ_ASSERT(aMetadata.id());
 539   MOZ_ASSERT(Mode::VersionChange == mMode);
 540   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 541   MOZ_ASSERT(IsActive());
 542
 543   MOZ_ALWAYS_TRUE(
 544       mBackgroundActor.mVersionChangeBackgroundActor->SendCreateIndex(
 545           aObjectStore->Id(), aMetadata));
 546 }
 547
 548 void IDBTransaction::DeleteIndex(IDBObjectStore* const aObjectStore,
 549                                  const int64_t aIndexId) const {
 550   AssertIsOnOwningThread();
 551   MOZ_ASSERT(aObjectStore);
 552   MOZ_ASSERT(aIndexId);
 553   MOZ_ASSERT(Mode::VersionChange == mMode);
 554   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 555   MOZ_ASSERT(IsActive());
 556
 557   MOZ_ALWAYS_TRUE(
 558       mBackgroundActor.mVersionChangeBackgroundActor->SendDeleteIndex(
 559           aObjectStore->Id(), aIndexId));
 560 }
 561
 562 void IDBTransaction::RenameIndex(IDBObjectStore* const aObjectStore,
 563                                  const int64_t aIndexId,
 564                                  const nsAString& aName) const {
 565   AssertIsOnOwningThread();
 566   MOZ_ASSERT(aObjectStore);
 567   MOZ_ASSERT(aIndexId);
 568   MOZ_ASSERT(Mode::VersionChange == mMode);
 569   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 570   MOZ_ASSERT(IsActive());
 571
 572   MOZ_ALWAYS_TRUE(
 573       mBackgroundActor.mVersionChangeBackgroundActor->SendRenameIndex(
 574           aObjectStore->Id(), aIndexId, nsString(aName)));
 575 }
 576
 577 void IDBTransaction::AbortInternal(const nsresult aAbortCode,
 578                                    RefPtr<DOMException> aError) {
 579   AssertIsOnOwningThread();
 580   MOZ_ASSERT(NS_FAILED(aAbortCode));
 581   MOZ_ASSERT(!IsCommittingOrFinished());
 582
 583   const bool isVersionChange = mMode == Mode::VersionChange;
 584   const bool needToSendAbort = !mStarted;
 585
 586   mAbortCode = aAbortCode;
 587   mReadyState = ReadyState::Finished;
 588   mError = std::move(aError);
 589
 590   if (isVersionChange) {
 591     // If a version change transaction is aborted, we must revert the world
 592     // back to its previous state unless we're being invalidated after the
 593     // transaction already completed.
 594     if (!mDatabase->IsInvalidated()) {
 595       mDatabase->RevertToPreviousState();
 596     }
 597
 598     // We do the reversion only for the mObjectStores/mDeletedObjectStores but
 599     // not for the mIndexes/mDeletedIndexes of each IDBObjectStore because it's
 600     // time-consuming(O(m*n)) and mIndexes/mDeletedIndexes won't be used anymore
 601     // in IDBObjectStore::(Create|Delete)Index() and IDBObjectStore::Index() in
 602     // which all the executions are returned earlier by
 603     // !transaction->IsActive().
 604
 605     const nsTArray<ObjectStoreSpec>& specArray =
 606         mDatabase->Spec()->objectStores();
 607
 608     if (specArray.IsEmpty()) {
 609       // This case is specially handled as a performance optimization, it is
 610       // equivalent to the else block.
 611       mObjectStores.Clear();
 612     } else {
 613       const auto validIds = TransformToHashtable<nsUint64HashKey>(
 614           specArray, [](const auto& spec) {
 615             const int64_t objectStoreId = spec.metadata().id();
 616             MOZ_ASSERT(objectStoreId);
 617             return static_cast<uint64_t>(objectStoreId);
 618           });
 619
 620       mObjectStores.RemoveLastElements(
 621           mObjectStores.end() -
 622           std::remove_if(mObjectStores.begin(), mObjectStores.end(),
 623                          [&validIds](const auto& objectStore) {
 624                            return !validIds.Contains(
 625                                uint64_t(objectStore->Id()));
 626                          }));
 627
 628       std::copy_if(std::make_move_iterator(mDeletedObjectStores.begin()),
 629                    std::make_move_iterator(mDeletedObjectStores.end()),
 630                    MakeBackInserter(mObjectStores),
 631                    [&validIds](const auto& deletedObjectStore) {
 632                      const int64_t objectStoreId = deletedObjectStore->Id();
 633                      MOZ_ASSERT(objectStoreId);
 634                      return validIds.Contains(uint64_t(objectStoreId));
 635                    });
 636     }
 637     mDeletedObjectStores.Clear();
 638   }
 639
 640   // Fire the abort event if there are no outstanding requests. Otherwise the
 641   // abort event will be fired when all outstanding requests finish.
 642   if (needToSendAbort) {
 643     SendAbort(aAbortCode);
 644   }
 645
 646   if (isVersionChange) {
 647     mDatabase->Close();
 648   }
 649 }
 650
 651 void IDBTransaction::Abort(IDBRequest* const aRequest) {
 652   AssertIsOnOwningThread();
 653   MOZ_ASSERT(aRequest);
 654
 655   if (IsCommittingOrFinished()) {
 656     // Already started (and maybe finished) the commit or abort so there is
 657     // nothing to do here.
 658     return;
 659   }
 660
 661   ErrorResult rv;
 662   RefPtr<DOMException> error = aRequest->GetError(rv);
 663
 664   // TODO: Do we deliberately ignore rv here? Isn't there a static analysis that
 665   // prevents that?
 666
 667   AbortInternal(aRequest->GetErrorCode(), std::move(error));
 668 }
 669
 670 void IDBTransaction::Abort(const nsresult aErrorCode) {
 671   AssertIsOnOwningThread();
 672
 673   if (IsCommittingOrFinished()) {
 674     // Already started (and maybe finished) the commit or abort so there is
 675     // nothing to do here.
 676     return;
 677   }
 678
 679   AbortInternal(aErrorCode, DOMException::Create(aErrorCode));
 680 }
 681
 682 // Specified by https://w3c.github.io/IndexedDB/#dom-idbtransaction-abort.
 683 void IDBTransaction::Abort(ErrorResult& aRv) {
 684   AssertIsOnOwningThread();
 685
 686   if (IsCommittingOrFinished()) {
 687     aRv = NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
 688     return;
 689   }
 690
 691   mReadyState = ReadyState::Inactive;
 692
 693   AbortInternal(NS_ERROR_DOM_INDEXEDDB_ABORT_ERR, nullptr);
 694
 695   mAbortedByScript.Flip();
 696 }
 697
 698 // Specified by https://w3c.github.io/IndexedDB/#dom-idbtransaction-commit.
 699 void IDBTransaction::Commit(ErrorResult& aRv) {
 700   AssertIsOnOwningThread();
 701
 702   if (mReadyState != ReadyState::Active || !mNotedActiveTransaction) {
 703     aRv = NS_ERROR_DOM_INVALID_STATE_ERR;
 704     return;
 705   }
 706
 707   MOZ_ASSERT(!mSentCommitOrAbort);
 708
 709   MOZ_ASSERT(mReadyState == ReadyState::Active);
 710   mReadyState = ReadyState::Committing;
 711   if (NS_WARN_IF(NS_FAILED(mAbortCode))) {
 712     SendAbort(mAbortCode);
 713     aRv = mAbortCode;
 714     return;
 715   }
 716
 717 #ifdef DEBUG
 718   mWasExplicitlyCommitted.Flip();
 719 #endif
 720
 721   SendCommit(false);
 722 }
 723
 724 void IDBTransaction::FireCompleteOrAbortEvents(const nsresult aResult) {
 725   AssertIsOnOwningThread();
 726   MOZ_ASSERT(!mFiredCompleteOrAbort);
 727
 728   mReadyState = ReadyState::Finished;
 729
 730 #ifdef DEBUG
 731   mFiredCompleteOrAbort.Flip();
 732 #endif
 733
 734   // Make sure we drop the WorkerRef when this function completes.
 735   const auto scopeExit = MakeScopeExit([&] { mWorkerRef = nullptr; });
 736
 737   RefPtr<Event> event;
 738   if (NS_SUCCEEDED(aResult)) {
 739     event = CreateGenericEvent(this, nsDependentString(kCompleteEventType),
 740                                eDoesNotBubble, eNotCancelable);
 741     MOZ_ASSERT(event);
 742
 743     // If we hit this assertion, it probably means transaction object on the
 744     // parent process doesn't propagate error properly.
 745     MOZ_ASSERT(NS_SUCCEEDED(mAbortCode));
 746   } else {
 747     if (aResult == NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR) {
 748       mDatabase->SetQuotaExceeded();
 749     }
 750
 751     if (!mError && !mAbortedByScript) {
 752       mError = DOMException::Create(aResult);
 753     }
 754
 755     event = CreateGenericEvent(this, nsDependentString(kAbortEventType),
 756                                eDoesBubble, eNotCancelable);
 757     MOZ_ASSERT(event);
 758
 759     if (NS_SUCCEEDED(mAbortCode)) {
 760       mAbortCode = aResult;
 761     }
 762   }
 763
 764   if (NS_SUCCEEDED(mAbortCode)) {
 765     IDB_LOG_MARK_CHILD_TRANSACTION("Firing 'complete' event",
 766                                    "IDBTransaction 'complete' event",
 767                                    mLoggingSerialNumber);
 768   } else {
 769     IDB_LOG_MARK_CHILD_TRANSACTION(
 770         "Firing 'abort' event with error 0x%" PRIx32,
 771         "IDBTransaction 'abort' event (0x%" PRIx32 ")", mLoggingSerialNumber,
 772         static_cast<uint32_t>(mAbortCode));
 773   }
 774
 775   IgnoredErrorResult rv;
 776   DispatchEvent(*event, rv);
 777   if (rv.Failed()) {
 778     NS_WARNING("DispatchEvent failed!");
 779   }
 780
 781   // Normally, we note inactive transaction here instead of
 782   // IDBTransaction::ClearBackgroundActor() because here is the earliest place
 783   // to know that it becomes non-blocking to allow the scheduler to start the
 784   // preemption as soon as it can.
 785   // Note: If the IDBTransaction object is held by the script,
 786   // ClearBackgroundActor() will be done in ~IDBTransaction() until garbage
 787   // collected after its window is closed which prevents us to preempt its
 788   // window immediately after committed.
 789   MaybeNoteInactiveTransaction();
 790 }
 791
 792 int64_t IDBTransaction::NextObjectStoreId() {
 793   AssertIsOnOwningThread();
 794   MOZ_ASSERT(Mode::VersionChange == mMode);
 795
 796   return mNextObjectStoreId++;
 797 }
 798
 799 int64_t IDBTransaction::NextIndexId() {
 800   AssertIsOnOwningThread();
 801   MOZ_ASSERT(Mode::VersionChange == mMode);
 802
 803   return mNextIndexId++;
 804 }
 805
 806 int64_t IDBTransaction::NextRequestId() {
 807   AssertIsOnOwningThread();
 808
 809   return mNextRequestId++;
 810 }
 811
 812 void IDBTransaction::InvalidateCursorCaches() {
 813   AssertIsOnOwningThread();
 814
 815   for (const auto& cursor : mCursors) {
 816     cursor->InvalidateCachedResponses();
 817   }
 818 }
 819
 820 void IDBTransaction::RegisterCursor(IDBCursor& aCursor) {
 821   AssertIsOnOwningThread();
 822
 823   mCursors.AppendElement(WrapNotNullUnchecked(&aCursor));
 824 }
 825
 826 void IDBTransaction::UnregisterCursor(IDBCursor& aCursor) {
 827   AssertIsOnOwningThread();
 828
 829   DebugOnly<bool> removed = mCursors.RemoveElement(&aCursor);
 830   MOZ_ASSERT(removed);
 831 }
 832
 833 nsIGlobalObject* IDBTransaction::GetParentObject() const {
 834   AssertIsOnOwningThread();
 835
 836   return mDatabase->GetParentObject();
 837 }
 838
 839 IDBTransactionMode IDBTransaction::GetMode(ErrorResult& aRv) const {
 840   AssertIsOnOwningThread();
 841
 842   switch (mMode) {
 843     case Mode::ReadOnly:
 844       return IDBTransactionMode::Readonly;
 845
 846     case Mode::ReadWrite:
 847       return IDBTransactionMode::Readwrite;
 848
 849     case Mode::ReadWriteFlush:
 850       return IDBTransactionMode::Readwriteflush;
 851
 852     case Mode::Cleanup:
 853       return IDBTransactionMode::Cleanup;
 854
 855     case Mode::VersionChange:
 856       return IDBTransactionMode::Versionchange;
 857
 858     case Mode::Invalid:
 859     default:
 860       MOZ_CRASH("Bad mode!");
 861   }
 862 }
 863
 864 IDBTransactionDurability IDBTransaction::GetDurability(ErrorResult& aRv) const {
 865   AssertIsOnOwningThread();
 866
 867   switch (mDurability) {
 868     case Durability::Default:
 869       return IDBTransactionDurability::Default;
 870
 871     case Durability::Strict:
 872       return IDBTransactionDurability::Strict;
 873
 874     case Durability::Relaxed:
 875       return IDBTransactionDurability::Relaxed;
 876
 877     default:
 878       MOZ_CRASH("Bad mode!");
 879   }
 880 }
 881
 882 DOMException* IDBTransaction::GetError() const {
 883   AssertIsOnOwningThread();
 884
 885   return mError;
 886 }
 887
 888 RefPtr<DOMStringList> IDBTransaction::ObjectStoreNames() const {
 889   AssertIsOnOwningThread();
 890
 891   if (mMode == Mode::VersionChange) {
 892     return mDatabase->ObjectStoreNames();
 893   }
 894
 895   auto list = MakeRefPtr<DOMStringList>();
 896   list->StringArray() = mObjectStoreNames.Clone();
 897   return list;
 898 }
 899
 900 RefPtr<IDBObjectStore> IDBTransaction::ObjectStore(const nsAString& aName,
 901                                                    ErrorResult& aRv) {
 902   AssertIsOnOwningThread();
 903
 904   if (IsCommittingOrFinished()) {
 905     aRv.ThrowInvalidStateError("Transaction is already committing or done.");
 906     return nullptr;
 907   }
 908
 909   auto* const spec = [this, &aName]() -> ObjectStoreSpec* {
 910     if (IDBTransaction::Mode::VersionChange == mMode ||
 911         mObjectStoreNames.Contains(aName)) {
 912       return mDatabase->LookupModifiableObjectStoreSpec(
 913           [&aName](const auto& objectStore) {
 914             return objectStore.metadata().name() == aName;
 915           });
 916     }
 917     return nullptr;
 918   }();
 919
 920   if (!spec) {
 921     aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR);
 922     return nullptr;
 923   }
 924
 925   RefPtr<IDBObjectStore> objectStore;
 926
 927   const auto foundIt = std::find_if(
 928       mObjectStores.cbegin(), mObjectStores.cend(),
 929       [desiredId = spec->metadata().id()](const auto& existingObjectStore) {
 930         return existingObjectStore->Id() == desiredId;
 931       });
 932   if (foundIt != mObjectStores.cend()) {
 933     objectStore = *foundIt;
 934   } else {
 935     objectStore = IDBObjectStore::Create(
 936         SafeRefPtr{this, AcquireStrongRefFromRawPtr{}}, *spec);
 937     MOZ_ASSERT(objectStore);
 938
 939     mObjectStores.AppendElement(objectStore);
 940   }
 941
 942   return objectStore;
 943 }
 944
 945 NS_IMPL_ADDREF_INHERITED(IDBTransaction, DOMEventTargetHelper)
 946 NS_IMPL_RELEASE_INHERITED(IDBTransaction, DOMEventTargetHelper)
 947
 948 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IDBTransaction)
 949   NS_INTERFACE_MAP_ENTRY(nsIRunnable)
 950 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 951
 952 NS_IMPL_CYCLE_COLLECTION_CLASS(IDBTransaction)
 953
 954 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(IDBTransaction,
 955                                                   DOMEventTargetHelper)
 956   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDatabase)
 957   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mError)
 958   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObjectStores)
 959   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDeletedObjectStores)
 960 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 961
 962 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(IDBTransaction,
 963                                                 DOMEventTargetHelper)
 964   // Don't unlink mDatabase!
 965   NS_IMPL_CYCLE_COLLECTION_UNLINK(mError)
 966   NS_IMPL_CYCLE_COLLECTION_UNLINK(mObjectStores)
 967   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDeletedObjectStores)
 968 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 969
 970 JSObject* IDBTransaction::WrapObject(JSContext* const aCx,
 971                                      JS::Handle<JSObject*> aGivenProto) {
 972   AssertIsOnOwningThread();
 973
 974   return IDBTransaction_Binding::Wrap(aCx, this, std::move(aGivenProto));
 975 }
 976
 977 void IDBTransaction::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
 978   AssertIsOnOwningThread();
 979
 980   aVisitor.mCanHandle = true;
 981   aVisitor.SetParentTarget(mDatabase, false);
 982 }
 983
 984 NS_IMETHODIMP
 985 IDBTransaction::Run() {
 986   AssertIsOnOwningThread();
 987
 988   // TODO: Instead of checking for Finished and Committing states here, we could
 989   // remove the transaction from the pending IDB transactions list on
 990   // abort/commit.
 991
 992   if (ReadyState::Finished == mReadyState) {
 993     // There are three cases where mReadyState is set to Finished: In
 994     // FileCompleteOrAbortEvents, AbortInternal and in CommitIfNotStarted. We
 995     // shouldn't get here after CommitIfNotStarted again.
 996     MOZ_ASSERT(mFiredCompleteOrAbort || IsAborted());
 997     return NS_OK;
 998   }
 999
1000   if (ReadyState::Committing == mReadyState) {
1001     MOZ_ASSERT(mSentCommitOrAbort);
1002     return NS_OK;
1003   }
1004   // We're back at the event loop, no longer newborn, so
1005   // return to Inactive state:
1006   // https://w3c.github.io/IndexedDB/#cleanup-indexed-database-transactions.
1007   MOZ_ASSERT(ReadyState::Active == mReadyState);
1008   mReadyState = ReadyState::Inactive;
1009
1010   CommitIfNotStarted();
1011
1012   return NS_OK;
1013 }
1014
1015 void IDBTransaction::CommitIfNotStarted() {
1016   AssertIsOnOwningThread();
1017
1018   MOZ_ASSERT(ReadyState::Inactive == mReadyState);
1019
1020   // Maybe commit if there were no requests generated.
1021   if (!mStarted) {
1022     MOZ_ASSERT(!mPendingRequestCount);
1023     mReadyState = ReadyState::Finished;
1024
1025     SendCommit(true);
1026   }
1027 }
1028
1029 }  // namespace mozilla::dom