diff --git a/dom/indexedDB/ActorsChild.h b/dom/indexedDB/ActorsChild.h
index d82a188b8..04b176124 100644
--- a/dom/indexedDB/ActorsChild.h
+++ b/dom/indexedDB/ActorsChild.h
@@ -110,7 +110,7 @@ public:
     MOZ_ASSERT(mLoggingInfo.nextVersionChangeTransactionSerialNumber() >
                  INT64_MIN);
 
-    if (aMode == IDBTransaction::VERSION_CHANGE) {
+    if (aMode == IDBTransaction::Mode::VersionChange) {
       return mLoggingInfo.nextVersionChangeTransactionSerialNumber()--;
     }
 
diff --git a/dom/indexedDB/ActorsParent.cpp b/dom/indexedDB/ActorsParent.cpp
index 0238e27e4..c73ce3eec 100644
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -9039,7 +9039,7 @@ public:
     MOZ_ASSERT(mLoggingInfo.nextVersionChangeTransactionSerialNumber() >
                  INT64_MIN);
 
-    if (aMode == IDBTransaction::VERSION_CHANGE) {
+    if (aMode == IDBTransaction::Mode::VersionChange) {
       return mLoggingInfo.nextVersionChangeTransactionSerialNumber()--;
     }
 
@@ -11378,11 +11378,11 @@ AutoSavepoint::~AutoSavepoint()
   if (mConnection) {
     mConnection->AssertIsOnConnectionThread();
     MOZ_ASSERT(mDEBUGTransaction);
-    MOZ_ASSERT(mDEBUGTransaction->GetMode() == IDBTransaction::READ_WRITE ||
+    MOZ_ASSERT(mDEBUGTransaction->GetMode() == IDBTransaction::Mode::ReadWrite ||
                mDEBUGTransaction->GetMode() ==
-                 IDBTransaction::READ_WRITE_FLUSH ||
-               mDEBUGTransaction->GetMode() == IDBTransaction::CLEANUP ||
-               mDEBUGTransaction->GetMode() == IDBTransaction::VERSION_CHANGE);
+                 IDBTransaction::Mode::ReadWriteFlush ||
+               mDEBUGTransaction->GetMode() == IDBTransaction::Mode::Cleanup ||
+               mDEBUGTransaction->GetMode() == IDBTransaction::Mode::VersionChange);
 
     if (NS_FAILED(mConnection->RollbackSavepoint())) {
       NS_WARNING("Failed to rollback savepoint!");
@@ -11395,10 +11395,10 @@ DatabaseConnection::
 AutoSavepoint::Start(const TransactionBase* aTransaction)
 {
   MOZ_ASSERT(aTransaction);
-  MOZ_ASSERT(aTransaction->GetMode() == IDBTransaction::READ_WRITE ||
-             aTransaction->GetMode() == IDBTransaction::READ_WRITE_FLUSH ||
-             aTransaction->GetMode() == IDBTransaction::CLEANUP ||
-             aTransaction->GetMode() == IDBTransaction::VERSION_CHANGE);
+  MOZ_ASSERT(aTransaction->GetMode() == IDBTransaction::Mode::ReadWrite ||
+             aTransaction->GetMode() == IDBTransaction::Mode::ReadWriteFlush ||
+             aTransaction->GetMode() == IDBTransaction::Mode::Cleanup ||
+             aTransaction->GetMode() == IDBTransaction::Mode::VersionChange);
 
   DatabaseConnection* connection = aTransaction->GetDatabase()->GetConnection();
   MOZ_ASSERT(connection);
@@ -14537,19 +14537,19 @@ Database::AllocPBackgroundIDBTransactionParent(
     return nullptr;
   }
 
-  if (NS_WARN_IF(aMode != IDBTransaction::READ_ONLY &&
-                 aMode != IDBTransaction::READ_WRITE &&
-                 aMode != IDBTransaction::READ_WRITE_FLUSH &&
-                 aMode != IDBTransaction::CLEANUP)) {
+  if (NS_WARN_IF(aMode != IDBTransaction::Mode::ReadOnly &&
+                 aMode != IDBTransaction::Mode::ReadWrite &&
+                 aMode != IDBTransaction::Mode::ReadWriteFlush &&
+                 aMode != IDBTransaction::Mode::Cleanup)) {
     ASSERT_UNLESS_FUZZING();
     return nullptr;
   }
 
   // If this is a readwrite transaction to a chrome database make sure the child
   // has write access.
-  if (NS_WARN_IF((aMode == IDBTransaction::READ_WRITE ||
-                  aMode == IDBTransaction::READ_WRITE_FLUSH ||
-                  aMode == IDBTransaction::CLEANUP) &&
+  if (NS_WARN_IF((aMode == IDBTransaction::Mode::ReadWrite ||
+                  aMode == IDBTransaction::Mode::ReadWriteFlush ||
+                  aMode == IDBTransaction::Mode::Cleanup) &&
                  mPrincipalInfo.type() == PrincipalInfo::TSystemPrincipalInfo &&
                  !mChromeWriteAccessAllowed)) {
     return nullptr;
@@ -14612,10 +14612,10 @@ Database::RecvPBackgroundIDBTransactionConstructor(
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(aActor);
   MOZ_ASSERT(!aObjectStoreNames.IsEmpty());
-  MOZ_ASSERT(aMode == IDBTransaction::READ_ONLY ||
-             aMode == IDBTransaction::READ_WRITE ||
-             aMode == IDBTransaction::READ_WRITE_FLUSH ||
-             aMode == IDBTransaction::CLEANUP);
+  MOZ_ASSERT(aMode == IDBTransaction::Mode::ReadOnly ||
+             aMode == IDBTransaction::Mode::ReadWrite ||
+             aMode == IDBTransaction::Mode::ReadWriteFlush ||
+             aMode == IDBTransaction::Mode::Cleanup);
   MOZ_ASSERT(!mClosed);
 
   if (IsInvalidated()) {
@@ -14637,7 +14637,7 @@ Database::RecvPBackgroundIDBTransactionConstructor(
                                    mMetadata->mDatabaseId,
                                    transaction->LoggingSerialNumber(),
                                    aObjectStoreNames,
-                                   aMode != IDBTransaction::READ_ONLY);
+                                   aMode != IDBTransaction::Mode::ReadOnly);
 
   transaction->SetActive(transactionId);
 
@@ -14778,14 +14778,14 @@ StartTransactionOp::DoDatabaseWork(DatabaseConnection* aConnection)
 
   Transaction()->SetActiveOnConnectionThread();
 
-  if (Transaction()->GetMode() == IDBTransaction::CLEANUP) {
+  if (Transaction()->GetMode() == IDBTransaction::Mode::Cleanup) {
     nsresult rv = aConnection->DisableQuotaChecks();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
-  if (Transaction()->GetMode() != IDBTransaction::READ_ONLY) {
+  if (Transaction()->GetMode() != IDBTransaction::Mode::ReadOnly) {
     nsresult rv = aConnection->BeginWriteTransaction();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
@@ -15095,10 +15095,10 @@ TransactionBase::VerifyRequestParams(const RequestParams& aParams) const
     }
 
     case RequestParams::TObjectStoreDeleteParams: {
-      if (NS_WARN_IF(mMode != IDBTransaction::READ_WRITE &&
-                     mMode != IDBTransaction::READ_WRITE_FLUSH &&
-                     mMode != IDBTransaction::CLEANUP &&
-                     mMode != IDBTransaction::VERSION_CHANGE)) {
+      if (NS_WARN_IF(mMode != IDBTransaction::Mode::ReadWrite &&
+                     mMode != IDBTransaction::Mode::ReadWriteFlush &&
+                     mMode != IDBTransaction::Mode::Cleanup &&
+                     mMode != IDBTransaction::Mode::VersionChange)) {
         ASSERT_UNLESS_FUZZING();
         return false;
       }
@@ -15119,10 +15119,10 @@ TransactionBase::VerifyRequestParams(const RequestParams& aParams) const
     }
 
     case RequestParams::TObjectStoreClearParams: {
-      if (NS_WARN_IF(mMode != IDBTransaction::READ_WRITE &&
-                     mMode != IDBTransaction::READ_WRITE_FLUSH &&
-                     mMode != IDBTransaction::CLEANUP &&
-                     mMode != IDBTransaction::VERSION_CHANGE)) {
+      if (NS_WARN_IF(mMode != IDBTransaction::Mode::ReadWrite &&
+                     mMode != IDBTransaction::Mode::ReadWriteFlush &&
+                     mMode != IDBTransaction::Mode::Cleanup &&
+                     mMode != IDBTransaction::Mode::VersionChange)) {
         ASSERT_UNLESS_FUZZING();
         return false;
       }
@@ -15306,9 +15306,9 @@ TransactionBase::VerifyRequestParams(const ObjectStoreAddPutParams& aParams)
 {
   AssertIsOnBackgroundThread();
 
-  if (NS_WARN_IF(mMode != IDBTransaction::READ_WRITE &&
-                 mMode != IDBTransaction::READ_WRITE_FLUSH &&
-                 mMode != IDBTransaction::VERSION_CHANGE)) {
+  if (NS_WARN_IF(mMode != IDBTransaction::Mode::ReadWrite &&
+                 mMode != IDBTransaction::Mode::ReadWriteFlush &&
+                 mMode != IDBTransaction::Mode::VersionChange)) {
     ASSERT_UNLESS_FUZZING();
     return false;
   }
@@ -15943,7 +15943,7 @@ NormalTransaction::DeallocPBackgroundIDBCursorParent(
 VersionChangeTransaction::VersionChangeTransaction(
                                                 OpenDatabaseOp* aOpenDatabaseOp)
   : TransactionBase(aOpenDatabaseOp->mDatabase,
-                    IDBTransaction::VERSION_CHANGE)
+                    IDBTransaction::Mode::VersionChange)
   , mOpenDatabaseOp(aOpenDatabaseOp)
   , mActorWasAlive(false)
 {
@@ -22370,7 +22370,7 @@ OpenDatabaseOp::DispatchToWorkThread()
   MOZ_ASSERT(mState == State::WaitingForTransactionsToComplete);
   MOZ_ASSERT(mVersionChangeTransaction);
   MOZ_ASSERT(mVersionChangeTransaction->GetMode() ==
-               IDBTransaction::VERSION_CHANGE);
+               IDBTransaction::Mode::VersionChange);
   MOZ_ASSERT(mMaybeBlockedDatabases.IsEmpty());
 
   if (NS_WARN_IF(QuotaClient::IsShuttingDownOnBackgroundThread()) ||
@@ -23878,10 +23878,10 @@ CommitOp::WriteAutoIncrementCounts()
 {
   MOZ_ASSERT(mTransaction);
   mTransaction->AssertIsOnConnectionThread();
-  MOZ_ASSERT(mTransaction->GetMode() == IDBTransaction::READ_WRITE ||
-             mTransaction->GetMode() == IDBTransaction::READ_WRITE_FLUSH ||
-             mTransaction->GetMode() == IDBTransaction::CLEANUP ||
-             mTransaction->GetMode() == IDBTransaction::VERSION_CHANGE);
+  MOZ_ASSERT(mTransaction->GetMode() == IDBTransaction::Mode::ReadWrite ||
+             mTransaction->GetMode() == IDBTransaction::Mode::ReadWriteFlush ||
+             mTransaction->GetMode() == IDBTransaction::Mode::Cleanup ||
+             mTransaction->GetMode() == IDBTransaction::Mode::VersionChange);
 
   const nsTArray<RefPtr<FullObjectStoreMetadata>>& metadataArray =
     mTransaction->mModifiedAutoIncrementObjectStoreMetadataArray;
@@ -23946,10 +23946,10 @@ CommitOp::CommitOrRollbackAutoIncrementCounts()
 {
   MOZ_ASSERT(mTransaction);
   mTransaction->AssertIsOnConnectionThread();
-  MOZ_ASSERT(mTransaction->GetMode() == IDBTransaction::READ_WRITE ||
-             mTransaction->GetMode() == IDBTransaction::READ_WRITE_FLUSH ||
-             mTransaction->GetMode() == IDBTransaction::CLEANUP ||
-             mTransaction->GetMode() == IDBTransaction::VERSION_CHANGE);
+  MOZ_ASSERT(mTransaction->GetMode() == IDBTransaction::Mode::ReadWrite ||
+             mTransaction->GetMode() == IDBTransaction::Mode::ReadWriteFlush ||
+             mTransaction->GetMode() == IDBTransaction::Mode::Cleanup ||
+             mTransaction->GetMode() == IDBTransaction::Mode::VersionChange);
 
   nsTArray<RefPtr<FullObjectStoreMetadata>>& metadataArray =
     mTransaction->mModifiedAutoIncrementObjectStoreMetadataArray;
@@ -23980,7 +23980,7 @@ CommitOp::AssertForeignKeyConsistency(DatabaseConnection* aConnection)
   MOZ_ASSERT(aConnection);
   MOZ_ASSERT(mTransaction);
   mTransaction->AssertIsOnConnectionThread();
-  MOZ_ASSERT(mTransaction->GetMode() != IDBTransaction::READ_ONLY);
+  MOZ_ASSERT(mTransaction->GetMode() != IDBTransaction::Mode::ReadOnly);
 
   DatabaseConnection::CachedStatement pragmaStmt;
   MOZ_ALWAYS_SUCCEEDS(
@@ -24028,7 +24028,7 @@ CommitOp::Run()
                mTransaction->LoggingSerialNumber(),
                mLoggingSerialNumber);
 
-  if (mTransaction->GetMode() != IDBTransaction::READ_ONLY &&
+  if (mTransaction->GetMode() != IDBTransaction::Mode::ReadOnly &&
       mTransaction->mHasBeenActiveOnConnectionThread) {
     Database* database = mTransaction->GetDatabase();
     MOZ_ASSERT(database);
@@ -24057,7 +24057,8 @@ CommitOp::Run()
             NS_WARNING_ASSERTION(NS_SUCCEEDED(mResultCode), "Commit failed!");
 
             if (NS_SUCCEEDED(mResultCode) &&
-                mTransaction->GetMode() == IDBTransaction::READ_WRITE_FLUSH) {
+                mTransaction->GetMode() ==
+                    IDBTransaction::Mode::ReadWriteFlush) {
               mResultCode = connection->Checkpoint();
             }
 
@@ -24080,7 +24081,7 @@ CommitOp::Run()
 
       connection->FinishWriteTransaction();
 
-      if (mTransaction->GetMode() == IDBTransaction::CLEANUP) {
+      if (mTransaction->GetMode() == IDBTransaction::Mode::Cleanup) {
         connection->DoIdleProcessing(/* aNeedsCheckpoint */ true);
 
         connection->EnableQuotaChecks();
@@ -25906,7 +25907,7 @@ NormalTransactionOp::ObjectStoreHasIndexes(NormalTransactionOp* aOp,
   MOZ_ASSERT(aHasIndexes);
 
   bool hasIndexes;
-  if (aOp->Transaction()->GetMode() == IDBTransaction::VERSION_CHANGE &&
+  if (aOp->Transaction()->GetMode() == IDBTransaction::Mode::VersionChange &&
       aMayHaveIndexes) {
     // If this is a version change transaction then mObjectStoreMayHaveIndexes
     // could be wrong (e.g. if a unique index failed to be created due to a
diff --git a/dom/indexedDB/IDBCursor.cpp b/dom/indexedDB/IDBCursor.cpp
index 9d7936b42..696148043 100644
--- a/dom/indexedDB/IDBCursor.cpp
+++ b/dom/indexedDB/IDBCursor.cpp
@@ -686,7 +686,7 @@ IDBCursor::Update(JSContext* aCx, JS::Handle<JS::Value> aValue,
     return nullptr;
   }
 
-  if (mTransaction->GetMode() == IDBTransaction::CLEANUP ||
+  if (mTransaction->GetMode() == IDBTransaction::Mode::Cleanup ||
       IsSourceDeleted() ||
       !mHaveValue ||
       mType == Type_ObjectStoreKey ||
diff --git a/dom/indexedDB/IDBDatabase.cpp b/dom/indexedDB/IDBDatabase.cpp
index 9ee39b0bb..f5929b82c 100644
--- a/dom/indexedDB/IDBDatabase.cpp
+++ b/dom/indexedDB/IDBDatabase.cpp
@@ -428,7 +428,7 @@ IDBDatabase::CreateObjectStore(
   IDBTransaction* transaction = IDBTransaction::GetCurrent();
   if (!transaction ||
       transaction->Database() != this ||
-      transaction->GetMode() != IDBTransaction::VERSION_CHANGE) {
+      transaction->GetMode() != IDBTransaction::Mode::VersionChange) {
     aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
     return nullptr;
   }
@@ -506,7 +506,7 @@ IDBDatabase::DeleteObjectStore(const nsAString& aName, ErrorResult& aRv)
   IDBTransaction* transaction = IDBTransaction::GetCurrent();
   if (!transaction ||
       transaction->Database() != this ||
-      transaction->GetMode() != IDBTransaction::VERSION_CHANGE) {
+      transaction->GetMode() != IDBTransaction::Mode::VersionChange) {
     aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
     return;
   }
@@ -669,21 +669,21 @@ IDBDatabase::Transaction(JSContext* aCx,
   IDBTransaction::Mode mode;
   switch (aMode) {
     case IDBTransactionMode::Readonly:
-      mode = IDBTransaction::READ_ONLY;
+      mode = IDBTransaction::Mode::ReadOnly;
       break;
     case IDBTransactionMode::Readwrite:
       if (mQuotaExceeded) {
-        mode = IDBTransaction::CLEANUP;
+        mode = IDBTransaction::Mode::Cleanup;
         mQuotaExceeded = false;
       } else {
-        mode = IDBTransaction::READ_WRITE;
+        mode = IDBTransaction::Mode::ReadWrite;
       }
       break;
     case IDBTransactionMode::Readwriteflush:
-      mode = IDBTransaction::READ_WRITE_FLUSH;
+      mode = IDBTransaction::Mode::ReadWriteFlush;
       break;
     case IDBTransactionMode::Cleanup:
-      mode = IDBTransaction::CLEANUP;
+      mode = IDBTransaction::Mode::Cleanup;
       mQuotaExceeded = false;
       break;
     case IDBTransactionMode::Versionchange:
@@ -717,7 +717,7 @@ IDBDatabase::Transaction(JSContext* aCx,
 
   transaction->SetBackgroundActor(actor);
 
-  if (mode == IDBTransaction::CLEANUP) {
+  if (mode == IDBTransaction::Mode::Cleanup) {
     ExpireFileActors(/* aExpireAll */ true);
   }
 
@@ -864,14 +864,14 @@ IDBDatabase::AbortTransactions(bool aShouldWarn)
         if (aShouldWarn) {
           switch (transaction->GetMode()) {
             // We ignore transactions that could not have written any data.
-            case IDBTransaction::READ_ONLY:
+            case IDBTransaction::Mode::ReadOnly:
               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:
+            case IDBTransaction::Mode::ReadWrite:
+            case IDBTransaction::Mode::ReadWriteFlush:
+            case IDBTransaction::Mode::Cleanup:
+            case IDBTransaction::Mode::VersionChange:
               transactionsThatNeedWarning.AppendElement(transaction);
               break;
 
diff --git a/dom/indexedDB/IDBIndex.cpp b/dom/indexedDB/IDBIndex.cpp
index 55e000706..ed049bfc9 100644
--- a/dom/indexedDB/IDBIndex.cpp
+++ b/dom/indexedDB/IDBIndex.cpp
@@ -158,7 +158,7 @@ IDBIndex::SetName(const nsAString& aName, ErrorResult& aRv)
 
   IDBTransaction* transaction = mObjectStore->Transaction();
 
-  if (transaction->GetMode() != IDBTransaction::VERSION_CHANGE ||
+  if (transaction->GetMode() != IDBTransaction::Mode::VersionChange ||
       mDeletedMetadata) {
     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
diff --git a/dom/indexedDB/IDBObjectStore.cpp b/dom/indexedDB/IDBObjectStore.cpp
index 356425b12..464cfbb42 100644
--- a/dom/indexedDB/IDBObjectStore.cpp
+++ b/dom/indexedDB/IDBObjectStore.cpp
@@ -1546,7 +1546,7 @@ IDBObjectStore::AddOrPut(JSContext* aCx,
   MOZ_ASSERT(aCx);
   MOZ_ASSERT_IF(aFromCursor, aOverwrite);
 
-  if (mTransaction->GetMode() == IDBTransaction::CLEANUP ||
+  if (mTransaction->GetMode() == IDBTransaction::Mode::Cleanup ||
       mDeletedSpec) {
     aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
     return nullptr;
@@ -2129,7 +2129,7 @@ IDBObjectStore::CreateIndex(const nsAString& aName,
 {
   AssertIsOnOwningThread();
 
-  if (mTransaction->GetMode() != IDBTransaction::VERSION_CHANGE ||
+  if (mTransaction->GetMode() != IDBTransaction::Mode::VersionChange ||
       mDeletedSpec) {
     aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
     return nullptr;
@@ -2239,7 +2239,7 @@ IDBObjectStore::DeleteIndex(const nsAString& aName, ErrorResult& aRv)
 {
   AssertIsOnOwningThread();
 
-  if (mTransaction->GetMode() != IDBTransaction::VERSION_CHANGE ||
+  if (mTransaction->GetMode() != IDBTransaction::Mode::VersionChange ||
       mDeletedSpec) {
     aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
     return;
@@ -2562,7 +2562,7 @@ IDBObjectStore::SetName(const nsAString& aName, ErrorResult& aRv)
 {
   AssertIsOnOwningThread();
 
-  if (mTransaction->GetMode() != IDBTransaction::VERSION_CHANGE ||
+  if (mTransaction->GetMode() != IDBTransaction::Mode::VersionChange ||
       mDeletedSpec) {
     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
diff --git a/dom/indexedDB/IDBTransaction.cpp b/dom/indexedDB/IDBTransaction.cpp
index 4980cb426..d4a973142 100644
--- a/dom/indexedDB/IDBTransaction.cpp
+++ b/dom/indexedDB/IDBTransaction.cpp
@@ -83,7 +83,7 @@ IDBTransaction::IDBTransaction(IDBDatabase* aDatabase,
   , mPendingRequestCount(0)
   , mLineNo(0)
   , mColumn(0)
-  , mReadyState(IDBTransaction::INITIAL)
+  , mReadyState(IDBTransaction::ReadyState::Initial)
   , mMode(aMode)
   , mCreating(false)
   , mRegistered(false)
@@ -137,10 +137,10 @@ IDBTransaction::~IDBTransaction()
   MOZ_ASSERT(!mCreating);
   MOZ_ASSERT(!mNotedActiveTransaction);
   MOZ_ASSERT(mSentCommitOrAbort);
-  MOZ_ASSERT_IF(mMode == VERSION_CHANGE &&
+  MOZ_ASSERT_IF(mMode == Mode::VersionChange &&
                   mBackgroundActor.mVersionChangeBackgroundActor,
                 mFiredCompleteOrAbort);
-  MOZ_ASSERT_IF(mMode != VERSION_CHANGE &&
+  MOZ_ASSERT_IF(mMode != Mode::VersionChange &&
                   mBackgroundActor.mNormalBackgroundActor,
                 mFiredCompleteOrAbort);
 
@@ -151,7 +151,7 @@ IDBTransaction::~IDBTransaction()
 #endif
   }
 
-  if (mMode == VERSION_CHANGE) {
+  if (mMode == Mode::VersionChange) {
     if (auto* actor = mBackgroundActor.mVersionChangeBackgroundActor) {
       actor->SendDeleteMeInternal(/* aFailedConstructor */ false);
 
@@ -187,7 +187,7 @@ IDBTransaction::CreateVersionChange(
   RefPtr<IDBTransaction> transaction =
     new IDBTransaction(aDatabase,
                        emptyObjectStoreNames,
-                       VERSION_CHANGE);
+                       Mode::VersionChange);
   aOpenRequest->GetCallerLocation(transaction->mFilename,
                                   &transaction->mLineNo, &transaction->mColumn);
 
@@ -218,10 +218,10 @@ IDBTransaction::Create(JSContext* aCx, IDBDatabase* aDatabase,
   MOZ_ASSERT(aDatabase);
   aDatabase->AssertIsOnOwningThread();
   MOZ_ASSERT(!aObjectStoreNames.IsEmpty());
-  MOZ_ASSERT(aMode == READ_ONLY ||
-             aMode == READ_WRITE ||
-             aMode == READ_WRITE_FLUSH ||
-             aMode == CLEANUP);
+  MOZ_ASSERT(aMode == Mode::ReadOnly ||
+             aMode == Mode::ReadWrite ||
+             aMode == Mode::ReadWriteFlush ||
+             aMode == Mode::Cleanup);
 
   RefPtr<IDBTransaction> transaction =
     new IDBTransaction(aDatabase, aObjectStoreNames, aMode);
@@ -286,7 +286,7 @@ IDBTransaction::SetBackgroundActor(indexedDB::BackgroundTransactionChild* aBackg
   AssertIsOnOwningThread();
   MOZ_ASSERT(aBackgroundActor);
   MOZ_ASSERT(!mBackgroundActor.mNormalBackgroundActor);
-  MOZ_ASSERT(mMode != VERSION_CHANGE);
+  MOZ_ASSERT(mMode != Mode::VersionChange);
 
   NoteActiveTransaction();
 
@@ -302,7 +302,7 @@ IDBTransaction::StartRequest(IDBRequest* aRequest, const RequestParams& aParams)
 
   BackgroundRequestChild* actor = new BackgroundRequestChild(aRequest);
 
-  if (mMode == VERSION_CHANGE) {
+  if (mMode == Mode::VersionChange) {
     MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 
     mBackgroundActor.mVersionChangeBackgroundActor->
@@ -331,7 +331,7 @@ IDBTransaction::OpenCursor(BackgroundCursorChild* aBackgroundActor,
   MOZ_ASSERT(aBackgroundActor);
   MOZ_ASSERT(aParams.type() != OpenCursorParams::T__None);
 
-  if (mMode == VERSION_CHANGE) {
+  if (mMode == Mode::VersionChange) {
     MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
 
     mBackgroundActor.mVersionChangeBackgroundActor->
@@ -374,8 +374,8 @@ IDBTransaction::OnNewRequest()
   AssertIsOnOwningThread();
 
   if (!mPendingRequestCount) {
-    MOZ_ASSERT(INITIAL == mReadyState);
-    mReadyState = LOADING;
+    MOZ_ASSERT(ReadyState::Initial == mReadyState);
+    mReadyState = ReadyState::Loading;
   }
 
   ++mPendingRequestCount;
@@ -390,7 +390,7 @@ IDBTransaction::OnRequestFinished(bool aActorDestroyedNormally)
   --mPendingRequestCount;
 
   if (!mPendingRequestCount) {
-    mReadyState = COMMITTING;
+    mReadyState = ReadyState::Committing;
 
     if (aActorDestroyedNormally) {
       if (NS_SUCCEEDED(mAbortCode)) {
@@ -434,7 +434,7 @@ IDBTransaction::SendCommit()
                LoggingSerialNumber(),
                requestSerialNumber);
 
-  if (mMode == VERSION_CHANGE) {
+  if (mMode == Mode::VersionChange) {
     MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
     mBackgroundActor.mVersionChangeBackgroundActor->SendCommit();
   } else {
@@ -467,7 +467,7 @@ IDBTransaction::SendAbort(nsresult aResultCode)
                requestSerialNumber,
                aResultCode);
 
-  if (mMode == VERSION_CHANGE) {
+  if (mMode == Mode::VersionChange) {
     MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
     mBackgroundActor.mVersionChangeBackgroundActor->SendAbort(aResultCode);
   } else {
@@ -507,7 +507,7 @@ IDBTransaction::IsOpen() const
   AssertIsOnOwningThread();
 
   // If we haven't started anything then we're open.
-  if (mReadyState == IDBTransaction::INITIAL) {
+  if (mReadyState == IDBTransaction::ReadyState::Initial) {
     return true;
   }
 
@@ -516,7 +516,7 @@ IDBTransaction::IsOpen() const
   // from the time we were created) then we are open. Otherwise check the
   // currently running transaction to see if it's the same. We only allow other
   // requests to be made if this transaction is currently running.
-  if (mReadyState == IDBTransaction::LOADING &&
+  if (mReadyState == IDBTransaction::ReadyState::Loading &&
       (mCreating || GetCurrent() == this)) {
     return true;
   }
@@ -542,7 +542,7 @@ IDBTransaction::CreateObjectStore(const ObjectStoreSpec& aSpec)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(aSpec.metadata().id());
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
   MOZ_ASSERT(IsOpen());
 
@@ -574,7 +574,7 @@ IDBTransaction::DeleteObjectStore(int64_t aObjectStoreId)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(aObjectStoreId);
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
   MOZ_ASSERT(IsOpen());
 
@@ -605,7 +605,7 @@ IDBTransaction::RenameObjectStore(int64_t aObjectStoreId,
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(aObjectStoreId);
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
   MOZ_ASSERT(IsOpen());
 
@@ -620,7 +620,7 @@ IDBTransaction::CreateIndex(IDBObjectStore* aObjectStore,
   AssertIsOnOwningThread();
   MOZ_ASSERT(aObjectStore);
   MOZ_ASSERT(aMetadata.id());
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
   MOZ_ASSERT(IsOpen());
 
@@ -635,7 +635,7 @@ IDBTransaction::DeleteIndex(IDBObjectStore* aObjectStore,
   AssertIsOnOwningThread();
   MOZ_ASSERT(aObjectStore);
   MOZ_ASSERT(aIndexId);
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
   MOZ_ASSERT(IsOpen());
 
@@ -651,7 +651,7 @@ IDBTransaction::RenameIndex(IDBObjectStore* aObjectStore,
   AssertIsOnOwningThread();
   MOZ_ASSERT(aObjectStore);
   MOZ_ASSERT(aIndexId);
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
   MOZ_ASSERT(mBackgroundActor.mVersionChangeBackgroundActor);
   MOZ_ASSERT(IsOpen());
 
@@ -671,12 +671,12 @@ IDBTransaction::AbortInternal(nsresult aAbortCode,
 
   RefPtr<DOMException> error = aError;
 
-  const bool isVersionChange = mMode == VERSION_CHANGE;
+  const bool isVersionChange = mMode == Mode::VersionChange;
   const bool isInvalidated = mDatabase->IsInvalidated();
-  bool needToSendAbort = mReadyState == INITIAL;
+  bool needToSendAbort = mReadyState == ReadyState::Initial;
 
   mAbortCode = aAbortCode;
-  mReadyState = DONE;
+  mReadyState = ReadyState::Done;
   mError = error.forget();
 
   if (isVersionChange) {
@@ -809,7 +809,7 @@ IDBTransaction::FireCompleteOrAbortEvents(nsresult aResult)
   AssertIsOnOwningThread();
   MOZ_ASSERT(!mFiredCompleteOrAbort);
 
-  mReadyState = DONE;
+  mReadyState = ReadyState::Done;
 
 #ifdef DEBUG
   mFiredCompleteOrAbort = true;
@@ -876,7 +876,7 @@ int64_t
 IDBTransaction::NextObjectStoreId()
 {
   AssertIsOnOwningThread();
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
 
   return mNextObjectStoreId++;
 }
@@ -885,7 +885,7 @@ int64_t
 IDBTransaction::NextIndexId()
 {
   AssertIsOnOwningThread();
-  MOZ_ASSERT(VERSION_CHANGE == mMode);
+  MOZ_ASSERT(Mode::VersionChange == mMode);
 
   return mNextIndexId++;
 }
@@ -904,22 +904,22 @@ IDBTransaction::GetMode(ErrorResult& aRv) const
   AssertIsOnOwningThread();
 
   switch (mMode) {
-    case READ_ONLY:
+    case Mode::ReadOnly:
       return IDBTransactionMode::Readonly;
 
-    case READ_WRITE:
+    case Mode::ReadWrite:
       return IDBTransactionMode::Readwrite;
 
-    case READ_WRITE_FLUSH:
+    case Mode::ReadWriteFlush:
       return IDBTransactionMode::Readwriteflush;
 
-    case CLEANUP:
+    case Mode::Cleanup:
       return IDBTransactionMode::Cleanup;
 
-    case VERSION_CHANGE:
+    case Mode::VersionChange:
       return IDBTransactionMode::Versionchange;
 
-    case MODE_INVALID:
+    case Mode::Invalid:
     default:
       MOZ_CRASH("Bad mode!");
   }
@@ -938,7 +938,7 @@ IDBTransaction::ObjectStoreNames() const
 {
   AssertIsOnOwningThread();
 
-  if (mMode == IDBTransaction::VERSION_CHANGE) {
+  if (mMode == Mode::VersionChange) {
     return mDatabase->ObjectStoreNames();
   }
 
@@ -959,7 +959,7 @@ IDBTransaction::ObjectStore(const nsAString& aName, ErrorResult& aRv)
 
   const ObjectStoreSpec* spec = nullptr;
 
-  if (IDBTransaction::VERSION_CHANGE == mMode ||
+  if (IDBTransaction::Mode::VersionChange == mMode ||
       mObjectStoreNames.Contains(aName)) {
     const nsTArray<ObjectStoreSpec>& objectStores =
       mDatabase->Spec()->objectStores();
@@ -1056,8 +1056,8 @@ IDBTransaction::Run()
   mCreating = false;
 
   // Maybe commit if there were no requests generated.
-  if (mReadyState == IDBTransaction::INITIAL) {
-    mReadyState = DONE;
+  if (mReadyState == IDBTransaction::ReadyState::Initial) {
+    mReadyState = ReadyState::Done;
 
     SendCommit();
   }
diff --git a/dom/indexedDB/IDBTransaction.h b/dom/indexedDB/IDBTransaction.h
index bfbcc14b9..2b88b7770 100644
--- a/dom/indexedDB/IDBTransaction.h
+++ b/dom/indexedDB/IDBTransaction.h
@@ -54,24 +54,24 @@ class IDBTransaction final
   friend class WorkerHolder;
 
 public:
-  enum Mode
-  {
-    READ_ONLY = 0,
-    READ_WRITE,
-    READ_WRITE_FLUSH,
-    CLEANUP,
-    VERSION_CHANGE,
+  enum struct Mode {
+    ReadOnly = 0,
+    ReadWrite,
+    ReadWriteFlush,
+    Cleanup,
+    VersionChange,
 
     // Only needed for IPC serialization helper, should never be used in code.
-    MODE_INVALID
+    Invalid
   };
 
   enum ReadyState
   {
-    INITIAL = 0,
-    LOADING,
-    COMMITTING,
-    DONE
+    Initial = 0,
+    Loading,
+    Inactive,
+    Committing,
+    Done
   };
 
 private:
@@ -82,8 +82,8 @@ private:
   nsTArray<RefPtr<IDBObjectStore>> mDeletedObjectStores;
   nsAutoPtr<WorkerHolder> mWorkerHolder;
 
-  // Tagged with mMode. If mMode is VERSION_CHANGE then mBackgroundActor will be
-  // a BackgroundVersionChangeTransactionChild. Otherwise it will be a
+  // Tagged with mMode. If mMode is Mode::VersionChange then mBackgroundActor
+  // will be a BackgroundVersionChangeTransactionChild. Otherwise it will be a
   // BackgroundTransactionChild.
   union {
     indexedDB::BackgroundTransactionChild* mNormalBackgroundActor;
@@ -92,7 +92,7 @@ private:
 
   const int64_t mLoggingSerialNumber;
 
-  // Only used for VERSION_CHANGE transactions.
+  // Only used for Mode::VersionChange transactions.
   int64_t mNextObjectStoreId;
   int64_t mNextIndexId;
 
@@ -148,7 +148,7 @@ public:
   {
     AssertIsOnOwningThread();
 
-    if (mMode == VERSION_CHANGE) {
+    if (mMode == Mode::VersionChange) {
       mBackgroundActor.mVersionChangeBackgroundActor = nullptr;
     } else {
       mBackgroundActor.mNormalBackgroundActor = nullptr;
@@ -177,7 +177,8 @@ public:
   {
     AssertIsOnOwningThread();
 
-    return mReadyState == COMMITTING || mReadyState == DONE;
+    return mReadyState == ReadyState::Committing ||
+           mReadyState == ReadyState::Done;
   }
 
   bool
@@ -185,17 +186,15 @@ public:
   {
     AssertIsOnOwningThread();
 
-    return mReadyState == DONE;
+    return mReadyState == ReadyState::Done;
   }
 
   bool
   IsWriteAllowed() const
   {
     AssertIsOnOwningThread();
-    return mMode == READ_WRITE ||
-           mMode == READ_WRITE_FLUSH ||
-           mMode == CLEANUP ||
-           mMode == VERSION_CHANGE;
+    return mMode == Mode::ReadWrite || mMode == Mode::ReadWriteFlush ||
+           mMode == Mode::Cleanup || mMode == Mode::VersionChange;
   }
 
   bool
diff --git a/dom/indexedDB/ProfilerHelpers.h b/dom/indexedDB/ProfilerHelpers.h
index a54ac5c85..87670050b 100644
--- a/dom/indexedDB/ProfilerHelpers.h
+++ b/dom/indexedDB/ProfilerHelpers.h
@@ -121,19 +121,19 @@ public:
     Append(kCommaSpace);
 
     switch (aTransaction->GetMode()) {
-      case IDBTransaction::READ_ONLY:
+      case IDBTransaction::Mode::ReadOnly:
         AppendLiteral("\"readonly\"");
         break;
-      case IDBTransaction::READ_WRITE:
+      case IDBTransaction::Mode::ReadWrite:
         AppendLiteral("\"readwrite\"");
         break;
-      case IDBTransaction::READ_WRITE_FLUSH:
+      case IDBTransaction::Mode::ReadWriteFlush:
         AppendLiteral("\"readwriteflush\"");
         break;
-      case IDBTransaction::CLEANUP:
+      case IDBTransaction::Mode::Cleanup:
         AppendLiteral("\"cleanup\"");
         break;
-      case IDBTransaction::VERSION_CHANGE:
+      case IDBTransaction::Mode::VersionChange:
         AppendLiteral("\"versionchange\"");
         break;
       default:
diff --git a/dom/indexedDB/SerializationHelpers.h b/dom/indexedDB/SerializationHelpers.h
index 37e8c40ab..25552a6b0 100644
--- a/dom/indexedDB/SerializationHelpers.h
+++ b/dom/indexedDB/SerializationHelpers.h
@@ -87,8 +87,8 @@ template <>
 struct ParamTraits<mozilla::dom::IDBTransaction::Mode> :
   public ContiguousEnumSerializer<
                           mozilla::dom::IDBTransaction::Mode,
-                          mozilla::dom::IDBTransaction::READ_ONLY,
-                          mozilla::dom::IDBTransaction::MODE_INVALID>
+                          mozilla::dom::IDBTransaction::Mode::ReadOnly,
+                          mozilla::dom::IDBTransaction::Mode::Invalid>
 { };
 
 } // namespace IPC