Bug 1259294: Part 2 - Use MOZ_ALWAYS_SUCCEEDS. r=froydnj
authorKyle Huey <khuey@kylehuey.com>
Mon, 28 Mar 2016 10:28:15 -0700
changeset 290681 af8611a7b88ceb68413da8c6c0b3010d82e5fc5c
parent 290680 932e732dedfed03fcaff46b699ac3c6efb50738d
child 290682 b94bf7ac393dcfdb1a2fedd3073b3a247ab70d51
push idunknown
push userunknown
push dateunknown
reviewersfroydnj
bugs1259294
milestone48.0a1
Bug 1259294: Part 2 - Use MOZ_ALWAYS_SUCCEEDS. r=froydnj
docshell/base/LoadContext.cpp
dom/asmjscache/AsmJSCache.cpp
dom/base/DOMRequest.cpp
dom/base/StructuredCloneHolder.cpp
dom/base/nsContentIterator.cpp
dom/base/nsContentUtils.cpp
dom/cache/Connection.cpp
dom/cache/Context.cpp
dom/cache/Manager.cpp
dom/cache/PrincipalVerifier.cpp
dom/cache/ReadStream.cpp
dom/fetch/Fetch.cpp
dom/fetch/InternalRequest.cpp
dom/filehandle/ActorsParent.cpp
dom/html/HTMLOptionElement.cpp
dom/html/HTMLSelectElement.cpp
dom/indexedDB/ActorsChild.cpp
dom/indexedDB/ActorsParent.cpp
dom/indexedDB/FileInfo.cpp
dom/indexedDB/FileSnapshot.cpp
dom/indexedDB/IDBDatabase.cpp
dom/indexedDB/IDBFactory.cpp
dom/indexedDB/IndexedDatabaseManager.cpp
dom/indexedDB/PermissionRequestBase.cpp
dom/indexedDB/ProfilerHelpers.h
dom/indexedDB/ScriptErrorHelper.cpp
dom/ipc/Blob.cpp
dom/ipc/NuwaChild.cpp
dom/ipc/NuwaParent.cpp
dom/ipc/TabChild.cpp
dom/media/MediaResource.cpp
dom/media/gmp/GMPService.cpp
dom/media/gmp/GMPServiceParent.cpp
dom/messagechannel/MessagePort.cpp
dom/notification/Notification.cpp
dom/push/PushManager.cpp
dom/quota/ActorsParent.cpp
dom/quota/QuotaManagerService.cpp
dom/workers/RuntimeService.cpp
dom/workers/ScriptLoader.cpp
dom/workers/ServiceWorkerClients.cpp
dom/workers/ServiceWorkerEvents.cpp
dom/workers/ServiceWorkerManager.cpp
dom/workers/ServiceWorkerManagerParent.cpp
dom/workers/ServiceWorkerManagerService.cpp
dom/workers/ServiceWorkerPrivate.cpp
dom/workers/ServiceWorkerRegistration.cpp
dom/workers/ServiceWorkerWindowClient.cpp
dom/workers/WorkerDebuggerManager.cpp
dom/workers/WorkerPrivate.cpp
dom/workers/WorkerScope.cpp
dom/workers/WorkerThread.cpp
editor/libeditor/nsEditor.cpp
editor/libeditor/nsHTMLCSSUtils.cpp
extensions/cookie/nsPermissionManager.cpp
hal/gonk/UeventPoller.cpp
ipc/glue/BackgroundImpl.cpp
ipc/glue/BackgroundParentImpl.cpp
ipc/glue/BackgroundUtils.cpp
ipc/glue/GeckoChildProcessHost.cpp
ipc/glue/MessagePump.cpp
layout/ipc/VsyncParent.cpp
media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
netwerk/base/nsILoadInfo.idl
netwerk/base/nsStandardURL.cpp
netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp
netwerk/protocol/data/DataChannelParent.cpp
netwerk/protocol/websocket/WebSocketChannelChild.cpp
security/manager/ssl/PSMContentListener.cpp
storage/mozStorageService.cpp
toolkit/components/places/AsyncFaviconHelpers.cpp
toolkit/components/places/History.cpp
toolkit/components/places/Shutdown.cpp
toolkit/components/places/nsNavBookmarks.cpp
toolkit/components/places/nsNavHistoryResult.cpp
toolkit/components/places/tests/cpp/places_test_harness.h
widget/android/PrefsHelper.h
widget/android/nsWindow.cpp
xpcom/base/nsConsoleService.cpp
xpcom/tests/TestHarness.h
xpcom/tests/gtest/TestPipes.cpp
--- a/docshell/base/LoadContext.cpp
+++ b/docshell/base/LoadContext.cpp
@@ -52,21 +52,19 @@ LoadContext::LoadContext(nsIPrincipal* a
 {
   PrincipalOriginAttributes poa = BasePrincipal::Cast(aPrincipal)->OriginAttributesRef();
   mOriginAttributes.InheritFromDocToChildDocShell(poa);
 
   if (!aOptionalBase) {
     return;
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aOptionalBase->GetIsContent(&mIsContent)));
-  MOZ_ALWAYS_TRUE(
-    NS_SUCCEEDED(aOptionalBase->GetUsePrivateBrowsing(&mUsePrivateBrowsing)));
-  MOZ_ALWAYS_TRUE(
-    NS_SUCCEEDED(aOptionalBase->GetUseRemoteTabs(&mUseRemoteTabs)));
+  MOZ_ALWAYS_SUCCEEDS(aOptionalBase->GetIsContent(&mIsContent));
+  MOZ_ALWAYS_SUCCEEDS(aOptionalBase->GetUsePrivateBrowsing(&mUsePrivateBrowsing));
+  MOZ_ALWAYS_SUCCEEDS(aOptionalBase->GetUseRemoteTabs(&mUseRemoteTabs));
 }
 
 //-----------------------------------------------------------------------------
 // LoadContext::nsILoadContext
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
 LoadContext::GetAssociatedWindow(mozIDOMWindowProxy**)
--- a/dom/asmjscache/AsmJSCache.cpp
+++ b/dom/asmjscache/AsmJSCache.cpp
@@ -459,18 +459,17 @@ private:
   FailOnNonOwningThread()
   {
     AssertIsOnNonOwningThread();
     MOZ_ASSERT(mState != eOpened &&
                mState != eFailing &&
                mState != eFinished);
 
     mState = eFailing;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                         NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
   }
 
   void
   InitPersistenceType();
 
   nsresult
   InitOnMainThread();
 
@@ -911,18 +910,17 @@ ParentRunnable::Run()
 
       rv = InitOnMainThread();
       if (NS_FAILED(rv)) {
         FailOnNonOwningThread();
         return NS_OK;
       }
 
       mState = eWaitingToFinishInit;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 
       return NS_OK;
     }
 
     case eWaitingToFinishInit: {
       AssertIsOnOwningThread();
 
       if (QuotaManager::IsShuttingDown()) {
@@ -954,38 +952,35 @@ ParentRunnable::Run()
     }
 
     case eReadyToReadMetadata: {
       AssertIsOnIOThread();
 
       rv = ReadMetadata();
       if (NS_FAILED(rv)) {
         mState = eFailedToReadMetadata;
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-          mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+        MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
         return NS_OK;
       }
 
       if (mOpenMode == eOpenForRead) {
         mState = eSendingMetadataForRead;
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-          mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+        MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 
         return NS_OK;
       }
 
       rv = OpenCacheFileForWrite();
       if (NS_FAILED(rv)) {
         FailOnNonOwningThread();
         return NS_OK;
       }
 
       mState = eSendingCacheFile;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
       return NS_OK;
     }
 
     case eFailedToReadMetadata: {
       AssertIsOnOwningThread();
 
       if (mOpenMode == eOpenForRead) {
         CacheMiss();
@@ -1017,18 +1012,17 @@ ParentRunnable::Run()
 
       rv = OpenCacheFileForRead();
       if (NS_FAILED(rv)) {
         FailOnNonOwningThread();
         return NS_OK;
       }
 
       mState = eSendingCacheFile;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
       return NS_OK;
     }
 
     case eSendingCacheFile: {
       AssertIsOnOwningThread();
 
       mState = eOpened;
 
--- a/dom/base/DOMRequest.cpp
+++ b/dom/base/DOMRequest.cpp
@@ -311,17 +311,17 @@ public:
   // can't fetch a js context), set up an initiatization function to make sure
   // we can return the failure appropriately
   static nsresult
   Dispatch(DOMRequest* aRequest,
            const JS::Value& aResult)
   {
     RefPtr<FireSuccessAsyncTask> asyncTask =
       new FireSuccessAsyncTask(aRequest, aResult);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(asyncTask)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(asyncTask));
     return NS_OK;
   }
 
   NS_IMETHODIMP
   Run()
   {
     mReq->FireSuccess(JS::Handle<JS::Value>::fromMarkedLocation(mResult.address()));
     return NS_OK;
@@ -363,17 +363,17 @@ DOMRequestService::FireSuccessAsync(nsID
 
 NS_IMETHODIMP
 DOMRequestService::FireErrorAsync(nsIDOMDOMRequest* aRequest,
                                   const nsAString& aError)
 {
   NS_ENSURE_STATE(aRequest);
   nsCOMPtr<nsIRunnable> asyncTask =
     new FireErrorAsyncTask(static_cast<DOMRequest*>(aRequest), aError);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(asyncTask)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(asyncTask));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DOMRequestService::FireDone(nsIDOMDOMCursor* aCursor) {
   NS_ENSURE_STATE(aCursor);
   static_cast<DOMCursor*>(aCursor)->FireDone();
 
--- a/dom/base/StructuredCloneHolder.cpp
+++ b/dom/base/StructuredCloneHolder.cpp
@@ -584,17 +584,17 @@ EnsureBlobForBackgroundManager(BlobImpl*
 
       blobImpl = blobChild->GetBlobImpl();
       MOZ_ASSERT(blobImpl);
 
       DebugOnly<bool> isMutable;
       MOZ_ASSERT(NS_SUCCEEDED(blobImpl->GetMutable(&isMutable)));
       MOZ_ASSERT(!isMutable);
     } else {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(blobImpl->SetMutable(false)));
+      MOZ_ALWAYS_SUCCEEDS(blobImpl->SetMutable(false));
     }
 
     return blobImpl.forget();
   }
 
   const uint32_t subBlobCount = subBlobImpls->Length();
   MOZ_ASSERT(subBlobCount);
 
@@ -634,17 +634,17 @@ EnsureBlobForBackgroundManager(BlobImpl*
     } else {
       blobImpl = MultipartBlobImpl::Create(newSubBlobImpls, contentType, aRv);
     }
 
     if (NS_WARN_IF(aRv.Failed())) {
       return nullptr;
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(blobImpl->SetMutable(false)));
+    MOZ_ALWAYS_SUCCEEDS(blobImpl->SetMutable(false));
   }
 
   return blobImpl.forget();
 }
 
 JSObject*
 ReadBlob(JSContext* aCx,
          uint32_t aIndex,
@@ -693,17 +693,17 @@ WriteBlob(JSStructuredCloneWriter* aWrit
     EnsureBlobForBackgroundManager(aBlob->Impl(), nullptr, rv);
   if (NS_WARN_IF(rv.Failed())) {
     rv.SuppressException();
     return false;
   }
 
   MOZ_ASSERT(blobImpl);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(blobImpl->SetMutable(false)));
+  MOZ_ALWAYS_SUCCEEDS(blobImpl->SetMutable(false));
 
   // We store the position of the blobImpl in the array as index.
   if (JS_WriteUint32Pair(aWriter, SCTAG_DOM_BLOB,
                          aHolder->BlobImpls().Length())) {
     aHolder->BlobImpls().AppendElement(blobImpl);
     return true;
   }
 
--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -1324,18 +1324,18 @@ nsContentSubtreeIterator::Init(nsIDOMRan
   }
 
   firstCandidate = GetDeepFirstChild(firstCandidate);
 
   // confirm that this first possible contained node is indeed contained.  Else
   // we have a range that does not fully contain any node.
 
   bool nodeBefore, nodeAfter;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    nsRange::CompareNodeToRange(firstCandidate, mRange, &nodeBefore, &nodeAfter)));
+  MOZ_ALWAYS_SUCCEEDS(
+    nsRange::CompareNodeToRange(firstCandidate, mRange, &nodeBefore, &nodeAfter));
 
   if (nodeBefore || nodeAfter) {
     MakeEmpty();
     return NS_OK;
   }
 
   // cool, we have the first node in the range.  Now we walk up its ancestors
   // to find the most senior that is still in the range.  That's the real first
@@ -1368,18 +1368,18 @@ nsContentSubtreeIterator::Init(nsIDOMRan
     return NS_OK;
   }
 
   lastCandidate = GetDeepLastChild(lastCandidate);
 
   // confirm that this last possible contained node is indeed contained.  Else
   // we have a range that does not fully contain any node.
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    nsRange::CompareNodeToRange(lastCandidate, mRange, &nodeBefore, &nodeAfter)));
+  MOZ_ALWAYS_SUCCEEDS(
+    nsRange::CompareNodeToRange(lastCandidate, mRange, &nodeBefore, &nodeAfter));
 
   if (nodeBefore || nodeAfter) {
     MakeEmpty();
     return NS_OK;
   }
 
   // cool, we have the last node in the range.  Now we walk up its ancestors to
   // find the most senior that is still in the range.  That's the real first
@@ -1521,18 +1521,18 @@ nsContentSubtreeIterator::GetTopAncestor
     // i.e., either it's not content, or it is content but its own parent is
     // null -- then we're finished, since we don't go up to the root.
     //
     // We have to special-case this because CompareNodeToRange treats the root
     // node differently -- see bug 765205.
     if (!parent || !parent->GetParentNode()) {
       return content;
     }
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      nsRange::CompareNodeToRange(parent, mRange, &nodeBefore, &nodeAfter)));
+    MOZ_ALWAYS_SUCCEEDS(
+      nsRange::CompareNodeToRange(parent, mRange, &nodeBefore, &nodeAfter));
 
     if (nodeBefore || nodeAfter) {
       return content;
     }
     content = parent;
   }
 
   MOZ_CRASH("This should only be possible if aNode was null");
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -8134,17 +8134,17 @@ nsContentUtils::InternalStorageAllowedFo
   // This means that behavior for storage with internal about: URIs should not be
   // affected, which is desireable due to the lack of automated testing for about:
   // URIs with these preferences set, and the importance of the correct functioning
   // of these URIs even with custom preferences.
   nsCOMPtr<nsIURI> uri;
   nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
   if (NS_SUCCEEDED(rv) && uri) {
     bool isAbout = false;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(uri->SchemeIs("about", &isAbout)));
+    MOZ_ALWAYS_SUCCEEDS(uri->SchemeIs("about", &isAbout));
     if (isAbout) {
       return access;
     }
   }
 
   // We don't want to prompt for every attempt to access permissions.
   if (sCookiesBehavior == nsICookieService::BEHAVIOR_REJECT) {
     return StorageAccess::eDeny;
--- a/dom/cache/Connection.cpp
+++ b/dom/cache/Connection.cpp
@@ -23,32 +23,32 @@ Connection::Connection(mozIStorageConnec
   , mClosed(false)
 {
   MOZ_ASSERT(mBase);
 }
 
 Connection::~Connection()
 {
   NS_ASSERT_OWNINGTHREAD(Connection);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Close()));
+  MOZ_ALWAYS_SUCCEEDS(Close());
 }
 
 NS_IMETHODIMP
 Connection::Close()
 {
   NS_ASSERT_OWNINGTHREAD(Connection);
 
   if (mClosed) {
     return NS_OK;
   }
   mClosed = true;
 
   // If we are closing here, then Cache must not have a transaction
   // open anywhere else.  This should be guaranteed to succeed.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(db::IncrementalVacuum(this)));
+  MOZ_ALWAYS_SUCCEEDS(db::IncrementalVacuum(this));
 
   return mBase->Close();
 }
 
 // The following methods are all boilerplate that either forward to the
 // base connection or block the method.  All the async execution methods
 // are blocked because Cache does not use them and they would require more
 // work to wrap properly.
--- a/dom/cache/Context.cpp
+++ b/dom/cache/Context.cpp
@@ -211,18 +211,18 @@ private:
   void Complete(nsresult aResult)
   {
     MOZ_ASSERT(mState == STATE_RUNNING || NS_FAILED(aResult));
 
     MOZ_ASSERT(NS_SUCCEEDED(mResult));
     mResult = aResult;
 
     mState = STATE_COMPLETING;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL));
   }
 
   void Clear()
   {
     NS_ASSERT_OWNINGTHREAD(QuotaInitRunnable);
     MOZ_ASSERT(mContext);
     mContext = nullptr;
     mManager = nullptr;
@@ -381,18 +381,18 @@ Context::QuotaInitRunnable::Run()
                                                        &mQuotaInfo.mOrigin,
                                                        &mQuotaInfo.mIsApp);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         resolver->Resolve(rv);
         break;
       }
 
       mState = STATE_CREATE_QUOTA_MANAGER;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(
+        mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL));
       break;
     }
     // ----------------------------------
     case STATE_CREATE_QUOTA_MANAGER:
     {
       NS_ASSERT_OWNINGTHREAD(QuotaInitRunnable);
 
       if (mCanceled || QuotaManager::IsShuttingDown()) {
@@ -441,18 +441,18 @@ Context::QuotaInitRunnable::Run()
                                                   getter_AddRefs(mQuotaInfo.mDir));
       if (NS_FAILED(rv)) {
         resolver->Resolve(rv);
         break;
       }
 
       mState = STATE_RUN_ON_TARGET;
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(
+        mTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL));
       break;
     }
     // -------------------
     case STATE_RUN_ON_TARGET:
     {
       MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
 
       mState = STATE_RUNNING;
@@ -463,17 +463,17 @@ Context::QuotaInitRunnable::Run()
       MOZ_ASSERT(resolver->Resolved());
 
       mData = nullptr;
 
       // If the database was opened, then we should always succeed when creating
       // the marker file.  If it wasn't opened successfully, then no need to
       // create a marker file anyway.
       if (NS_SUCCEEDED(resolver->Result())) {
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(CreateMarkerFile(mQuotaInfo)));
+        MOZ_ALWAYS_SUCCEEDS(CreateMarkerFile(mQuotaInfo));
       }
 
       break;
     }
     // -------------------
     case STATE_COMPLETING:
     {
       NS_ASSERT_OWNINGTHREAD(QuotaInitRunnable);
@@ -574,18 +574,18 @@ public:
     // The Run() method will handle this by looking at mState after
     // RunOnTarget() returns.
     if (mExecutingRunOnTarget) {
       return;
     }
 
     // Otherwise we are in an asynchronous resolve.  And must perform a thread
     // bounce to run on the target thread again.
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      mTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      mTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL));
   }
 
 private:
   ~ActionRunnable()
   {
     MOZ_ASSERT(mState == STATE_COMPLETE);
     MOZ_ASSERT(!mContext);
     MOZ_ASSERT(!mAction);
@@ -699,18 +699,18 @@ Context::ActionRunnable::Run()
     {
       MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
       // The call to Action::RunOnTarget() must have returned now if we
       // are running on the target thread again.  We may now proceed
       // with completion.
       mState = STATE_COMPLETING;
       // Shutdown must be delayed until all Contexts are destroyed.  Crash
       // for this invariant violation.
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(
+        mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL));
       break;
     }
     // -------------------
     case STATE_COMPLETING:
     {
       NS_ASSERT_OWNINGTHREAD(ActionRunnable);
       mAction->CompleteOnInitiatingThread(mResult);
       mState = STATE_COMPLETE;
@@ -736,34 +736,34 @@ Context::ThreadsafeHandle::AllowToClose(
     AllowToCloseOnOwningThread();
     return;
   }
 
   // Dispatch is guaranteed to succeed here because we block shutdown until
   // all Contexts have been destroyed.
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewRunnableMethod(this, &ThreadsafeHandle::AllowToCloseOnOwningThread);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
 }
 
 void
 Context::ThreadsafeHandle::InvalidateAndAllowToClose()
 {
   if (mOwningThread == NS_GetCurrentThread()) {
     InvalidateAndAllowToCloseOnOwningThread();
     return;
   }
 
   // Dispatch is guaranteed to succeed here because we block shutdown until
   // all Contexts have been destroyed.
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewRunnableMethod(this, &ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
 }
 
 Context::ThreadsafeHandle::ThreadsafeHandle(Context* aContext)
   : mStrongRef(aContext)
   , mWeakRef(aContext)
   , mOwningThread(NS_GetCurrentThread())
 {
 }
@@ -777,18 +777,18 @@ Context::ThreadsafeHandle::~ThreadsafeHa
   if (!mStrongRef || mOwningThread == NS_GetCurrentThread()) {
     return;
   }
 
   // Dispatch is guaranteed to succeed here because we block shutdown until
   // all Contexts have been destroyed.
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewNonOwningRunnableMethod(mStrongRef.forget().take(), &Context::Release);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
 }
 
 void
 Context::ThreadsafeHandle::AllowToCloseOnOwningThread()
 {
   MOZ_ASSERT(mOwningThread == NS_GetCurrentThread());
 
   // A Context "closes" when its ref count drops to zero.  Dropping this
@@ -960,17 +960,17 @@ Context::~Context()
   if (mThreadsafeHandle) {
     mThreadsafeHandle->ContextDestroyed(this);
   }
 
   // Note, this may set the mOrphanedData flag.
   mManager->RemoveContext(this);
 
   if (mQuotaInfo.mDir && !mOrphanedData) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(DeleteMarkerFile(mQuotaInfo)));
+    MOZ_ALWAYS_SUCCEEDS(DeleteMarkerFile(mQuotaInfo));
   }
 
   if (mNextContext) {
     mNextContext->Start();
   }
 }
 
 void
--- a/dom/cache/Manager.cpp
+++ b/dom/cache/Manager.cpp
@@ -909,18 +909,18 @@ private:
   void
   CallOnAsyncCopyCompleteOnTargetThread(nsresult aRv)
   {
     // May be on any thread, including STS event target.  Non-owning runnable
     // here since we are guaranteed the Action will survive until
     // CompleteOnInitiatingThread is called.
     nsCOMPtr<nsIRunnable> runnable = NS_NewNonOwningRunnableMethodWithArgs<nsresult>(
       this, &CachePutAllAction::OnAsyncCopyComplete, aRv);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      mTargetThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      mTargetThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
   }
 
   void
   DoResolve(nsresult aRv)
   {
     MOZ_ASSERT(mTargetThread == NS_GetCurrentThread());
 
     // DoResolve() must not be called until all async copying has completed.
@@ -1758,17 +1758,17 @@ Manager::~Manager()
 
   nsCOMPtr<nsIThread> ioThread;
   mIOThread.swap(ioThread);
 
   // Don't spin the event loop in the destructor waiting for the thread to
   // shutdown.  Defer this to the main thread, instead.
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewRunnableMethod(ioThread, &nsIThread::Shutdown);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 }
 
 void
 Manager::Init(Manager* aOldManager)
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
 
   RefPtr<Context> oldContext;
--- a/dom/cache/PrincipalVerifier.cpp
+++ b/dom/cache/PrincipalVerifier.cpp
@@ -36,17 +36,17 @@ PrincipalVerifier::CreateAndDispatch(Lis
   // We must get the ContentParent actor from the PBackgroundParent.  This
   // only works on the PBackground thread.
   AssertIsOnBackgroundThread();
 
   RefPtr<PrincipalVerifier> verifier = new PrincipalVerifier(aListener,
                                                                aActor,
                                                                aPrincipalInfo);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(verifier)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(verifier));
 
   return verifier.forget();
 }
 
 void
 PrincipalVerifier::AddListener(Listener* aListener)
 {
   AssertIsOnBackgroundThread();
--- a/dom/cache/ReadStream.cpp
+++ b/dom/cache/ReadStream.cpp
@@ -353,36 +353,36 @@ ReadStream::Inner::NoteClosed()
   }
 
   if (NS_GetCurrentThread() == mOwningThread) {
     NoteClosedOnOwningThread();
     return;
   }
 
   nsCOMPtr<nsIRunnable> runnable = new NoteClosedRunnable(this);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
 }
 
 void
 ReadStream::Inner::Forget()
 {
   // Any thread
   if (mState == Closed) {
     return;
   }
 
   if (NS_GetCurrentThread() == mOwningThread) {
     ForgetOnOwningThread();
     return;
   }
 
   nsCOMPtr<nsIRunnable> runnable = new ForgetRunnable(this);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
 }
 
 void
 ReadStream::Inner::NoteClosedOnOwningThread()
 {
   MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
 
   // Mark closed and do nothing if we were already closed
--- a/dom/fetch/Fetch.cpp
+++ b/dom/fetch/Fetch.cpp
@@ -216,17 +216,17 @@ FetchRequest(nsIGlobalObject* aGlobal, c
     RefPtr<WorkerFetchResolver> resolver = WorkerFetchResolver::Create(worker, p);
     if (!resolver) {
       NS_WARNING("Could not add WorkerFetchResolver feature to worker");
       aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
       return nullptr;
     }
 
     RefPtr<MainThreadFetchRunnable> run = new MainThreadFetchRunnable(resolver, r);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(run)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(run));
   }
 
   return p.forget();
 }
 
 MainThreadFetchResolver::MainThreadFetchResolver(Promise* aPromise)
   : mPromise(aPromise)
 {
--- a/dom/fetch/InternalRequest.cpp
+++ b/dom/fetch/InternalRequest.cpp
@@ -270,30 +270,30 @@ InternalRequest::IsClientRequest() const
 
 // static
 RequestMode
 InternalRequest::MapChannelToRequestMode(nsIChannel* aChannel)
 {
   MOZ_ASSERT(aChannel);
 
   nsCOMPtr<nsILoadInfo> loadInfo;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aChannel->GetLoadInfo(getter_AddRefs(loadInfo))));
+  MOZ_ALWAYS_SUCCEEDS(aChannel->GetLoadInfo(getter_AddRefs(loadInfo)));
 
   nsContentPolicyType contentPolicy = loadInfo->InternalContentPolicyType();
   if (IsNavigationContentPolicy(contentPolicy)) {
     return RequestMode::Navigate;
   }
 
   // TODO: remove the worker override once securityMode is fully implemented (bug 1189945)
   if (IsWorkerContentPolicy(contentPolicy)) {
     return RequestMode::Same_origin;
   }
 
   uint32_t securityMode;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(loadInfo->GetSecurityMode(&securityMode)));
+  MOZ_ALWAYS_SUCCEEDS(loadInfo->GetSecurityMode(&securityMode));
 
   switch(securityMode) {
     case nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS:
     case nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED:
       return RequestMode::Same_origin;
     case nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS:
     case nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL:
       return RequestMode::No_cors;
@@ -306,34 +306,34 @@ InternalRequest::MapChannelToRequestMode
       break;
   }
 
   // TODO: remove following code once securityMode is fully implemented (bug 1189945)
 
   nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
 
   uint32_t corsMode;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(httpChannel->GetCorsMode(&corsMode)));
+  MOZ_ALWAYS_SUCCEEDS(httpChannel->GetCorsMode(&corsMode));
   MOZ_ASSERT(corsMode != nsIHttpChannelInternal::CORS_MODE_NAVIGATE);
 
   // This cast is valid due to static asserts in ServiceWorkerManager.cpp.
   return static_cast<RequestMode>(corsMode);
 }
 
 // static
 RequestCredentials
 InternalRequest::MapChannelToRequestCredentials(nsIChannel* aChannel)
 {
   MOZ_ASSERT(aChannel);
 
   nsCOMPtr<nsILoadInfo> loadInfo;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aChannel->GetLoadInfo(getter_AddRefs(loadInfo))));
+  MOZ_ALWAYS_SUCCEEDS(aChannel->GetLoadInfo(getter_AddRefs(loadInfo)));
 
   uint32_t securityMode;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(loadInfo->GetSecurityMode(&securityMode)));
+  MOZ_ALWAYS_SUCCEEDS(loadInfo->GetSecurityMode(&securityMode));
 
   // TODO: Remove following code after stylesheet and image support cookie policy
   if (securityMode == nsILoadInfo::SEC_NORMAL) {
     uint32_t loadFlags;
     aChannel->GetLoadFlags(&loadFlags);
 
     if (loadFlags & nsIRequest::LOAD_ANONYMOUS) {
       return RequestCredentials::Omit;
--- a/dom/filehandle/ActorsParent.cpp
+++ b/dom/filehandle/ActorsParent.cpp
@@ -816,17 +816,17 @@ FileHandleThreadPool::Create()
 #ifdef DEBUG
 
 void
 FileHandleThreadPool::AssertIsOnOwningThread() const
 {
   MOZ_ASSERT(mOwningThread);
 
   bool current;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->IsOnCurrentThread(&current));
   MOZ_ASSERT(current);
 }
 
 nsIEventTarget*
 FileHandleThreadPool::GetThreadPoolEventTarget() const
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mThreadPool);
@@ -986,17 +986,17 @@ void
 FileHandleThreadPool::Cleanup()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mThreadPool);
   MOZ_ASSERT(mShutdownRequested);
   MOZ_ASSERT(!mShutdownComplete);
   MOZ_ASSERT(!mDirectoryInfos.Count());
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mThreadPool->Shutdown()));
+  MOZ_ALWAYS_SUCCEEDS(mThreadPool->Shutdown());
 
   if (!mCompleteCallbacks.IsEmpty()) {
     // Run all callbacks manually now.
     for (uint32_t count = mCompleteCallbacks.Length(), index = 0;
          index < count;
          index++) {
       nsAutoPtr<StoragesCompleteCallback> completeCallback(
         mCompleteCallbacks[index].forget());
@@ -1007,17 +1007,17 @@ FileHandleThreadPool::Cleanup()
     }
 
     mCompleteCallbacks.Clear();
 
     // And make sure they get processed.
     nsIThread* currentThread = NS_GetCurrentThread();
     MOZ_ASSERT(currentThread);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_ProcessPendingEvents(currentThread)));
+    MOZ_ALWAYS_SUCCEEDS(NS_ProcessPendingEvents(currentThread));
   }
 
   mShutdownComplete = true;
 }
 
 void
 FileHandleThreadPool::FinishFileHandle(FileHandle* aFileHandle)
 {
@@ -1130,17 +1130,17 @@ FileHandleQueue::ProcessQueue()
   }
 
   mCurrentOp = mQueue[0];
   mQueue.RemoveElementAt(0);
 
   nsCOMPtr<nsIThreadPool> threadPool = mOwningFileHandleThreadPool->mThreadPool;
   MOZ_ASSERT(threadPool);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(threadPool->Dispatch(this, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(threadPool->Dispatch(this, NS_DISPATCH_NORMAL));
 }
 
 NS_IMETHODIMP
 FileHandleThreadPool::
 FileHandleQueue::Run()
 {
   MOZ_ASSERT(mCurrentOp);
 
@@ -1151,18 +1151,18 @@ FileHandleQueue::Run()
     ProcessQueue();
 
     currentOp->RunOnOwningThread();
   } else {
     mCurrentOp->RunOnThreadPool();
 
     nsCOMPtr<nsIEventTarget> backgroundThread = mCurrentOp->OwningThread();
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      backgroundThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      backgroundThread->Dispatch(this, NS_DISPATCH_NORMAL));
   }
 
   return NS_OK;
 }
 
 auto
 FileHandleThreadPool::
 DirectoryInfo::CreateFileHandleQueue(FileHandle* aFileHandle)
@@ -1999,17 +1999,17 @@ FinishOp::RunOnThreadPool()
 
   if (!stream) {
     return;
   }
 
   nsCOMPtr<nsIInputStream> inputStream = do_QueryInterface(stream);
   MOZ_ASSERT(inputStream);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(inputStream->Close()));
+  MOZ_ALWAYS_SUCCEEDS(inputStream->Close());
 
   stream = nullptr;
 }
 
 void
 FileHandle::
 FinishOp::RunOnOwningThread()
 {
@@ -2251,19 +2251,19 @@ CopyFileHandleOp::DoFileWork(FileHandle*
       new ProgressRunnable(this, mOffset, mSize);
 
     mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
   } while (true);
 
   MOZ_ASSERT(mOffset == mSize);
 
   if (mRead) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(outputStream->Close()));
+    MOZ_ALWAYS_SUCCEEDS(outputStream->Close());
   } else {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(inputStream->Close()));
+    MOZ_ALWAYS_SUCCEEDS(inputStream->Close());
   }
 
   return NS_OK;
 }
 
 void
 CopyFileHandleOp::Cleanup()
 {
--- a/dom/html/HTMLOptionElement.cpp
+++ b/dom/html/HTMLOptionElement.cpp
@@ -139,18 +139,17 @@ HTMLOptionElement::Index()
   }
 
   HTMLOptionsCollection* options = selectElement->GetOptions();
   if (!options) {
     return defaultIndex;
   }
 
   int32_t index = defaultIndex;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    options->GetOptionIndex(this, 0, true, &index)));
+  MOZ_ALWAYS_SUCCEEDS(options->GetOptionIndex(this, 0, true, &index));
   return index;
 }
 
 bool
 HTMLOptionElement::Selected() const
 {
   // If we haven't been explictly selected or deselected, use our default value
   if (!mSelectedChanged) {
--- a/dom/html/HTMLSelectElement.cpp
+++ b/dom/html/HTMLSelectElement.cpp
@@ -689,17 +689,17 @@ HTMLSelectElement::SetLength(uint32_t aL
 
 void
 HTMLSelectElement::SetLength(uint32_t aLength, ErrorResult& aRv)
 {
   uint32_t curlen = Length();
 
   if (curlen > aLength) { // Remove extra options
     for (uint32_t i = curlen; i > aLength; --i) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Remove(i - 1)));
+      MOZ_ALWAYS_SUCCEEDS(Remove(i - 1));
     }
   } else if (aLength > curlen) {
     if (aLength > MAX_DYNAMIC_SELECT_LENGTH) {
       aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return;
     }
 
     RefPtr<mozilla::dom::NodeInfo> nodeInfo;
@@ -1692,17 +1692,17 @@ HTMLSelectElement::SubmitNamesValues(nsF
       continue;
     }
 
     if (!option->Selected()) {
       continue;
     }
 
     nsString value;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(option->GetValue(value)));
+    MOZ_ALWAYS_SUCCEEDS(option->GetValue(value));
 
     if (keyGenProcessor) {
       nsString tmp(value);
       if (NS_SUCCEEDED(keyGenProcessor->ProcessValue(this, name, tmp))) {
         value = tmp;
       }
     }
 
@@ -1778,17 +1778,17 @@ HTMLSelectElement::IsValueMissing()
       continue;
     }
 
     if (IsOptionDisabled(option)) {
       continue;
     }
 
     nsAutoString value;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(option->GetValue(value)));
+    MOZ_ALWAYS_SUCCEEDS(option->GetValue(value));
     if (!value.IsEmpty()) {
       return false;
     }
   }
 
   return true;
 }
 
--- a/dom/indexedDB/ActorsChild.cpp
+++ b/dom/indexedDB/ActorsChild.cpp
@@ -1410,17 +1410,17 @@ BackgroundFactoryRequestChild::RecvPermi
     RefPtr<WorkerPermissionChallenge> challenge =
       new WorkerPermissionChallenge(workerPrivate, this, mFactory,
                                     aPrincipalInfo);
 
     if (NS_WARN_IF(!workerPrivate->AddFeature(challenge))) {
       return false;
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(challenge)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(challenge));
     return true;
   }
 
   nsresult rv;
   nsCOMPtr<nsIPrincipal> principal =
     mozilla::ipc::PrincipalInfoToPrincipal(aPrincipalInfo, &rv);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return false;
@@ -2672,17 +2672,17 @@ BackgroundCursorChild::SendContinueInter
 
     default:
       MOZ_CRASH("Should never get here!");
   }
 
   if (!mCachedResponses.IsEmpty()) {
     nsCOMPtr<nsIRunnable> continueRunnable = new DelayedActionRunnable(
       this, &BackgroundCursorChild::SendDelayedContinueInternal);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(continueRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(continueRunnable));
   } else {
     MOZ_ALWAYS_TRUE(PBackgroundIDBCursorChild::SendContinue(params, key));
   }
 }
 
 void
 BackgroundCursorChild::SendDelayedContinueInternal()
 {
@@ -2761,17 +2761,17 @@ BackgroundCursorChild::HandleResponse(co
   }
 
   ResultHelper helper(mRequest, mTransaction, &JS::NullHandleValue);
   DispatchSuccessEvent(&helper);
 
   if (!mCursor) {
     nsCOMPtr<nsIRunnable> deleteRunnable = new DelayedActionRunnable(
       this, &BackgroundCursorChild::SendDeleteMeInternal);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(deleteRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(deleteRunnable));
   }
 }
 
 void
 BackgroundCursorChild::HandleResponse(
     const nsTArray<ObjectStoreCursorResponse>& aResponses)
 {
   AssertIsOnOwningThread();
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -2732,31 +2732,31 @@ InsertIndexDataValuesFunction::OnFunctio
   MOZ_ASSERT(!NS_IsMainThread());
   MOZ_ASSERT(!IsOnBackgroundThread());
   MOZ_ASSERT(aValues);
   MOZ_ASSERT(_retval);
 
 #ifdef DEBUG
   {
     uint32_t argCount;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetNumEntries(&argCount)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetNumEntries(&argCount));
     MOZ_ASSERT(argCount == 4);
 
     int32_t valueType;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(0, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(0, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_NULL ||
                valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(1, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(1, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_INTEGER);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(2, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(2, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_INTEGER);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(3, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(3, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
   }
 #endif
 
   // Read out the previous value. It may be NULL, in which case we'll just end
   // up with an empty array.
   AutoTArray<IndexDataValue, 32> indexValues;
   nsresult rv = ReadCompressedIndexDataValues(aValues, 0, indexValues);
@@ -2997,21 +2997,21 @@ UpgradeKeyFunction::OnFunctionCall(mozIS
   MOZ_ASSERT(!NS_IsMainThread());
   MOZ_ASSERT(!IsOnBackgroundThread());
   MOZ_ASSERT(aValues);
   MOZ_ASSERT(_retval);
 
 #ifdef DEBUG
   {
     uint32_t argCount;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetNumEntries(&argCount)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetNumEntries(&argCount));
     MOZ_ASSERT(argCount == 1);
 
     int32_t valueType;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(0, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(0, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
   }
 #endif
 
   // Dig the old key out of the values.
   const uint8_t* blobData;
   uint32_t blobDataLength;
   nsresult rv = aValues->GetSharedBlob(0, &blobDataLength, &blobData);
@@ -3066,27 +3066,24 @@ UpgradeSchemaFrom17_0To18_0Helper::DoUpg
   // Register the |insert_idv| function.
   RefPtr<InsertIndexDataValuesFunction> insertIDVFunction =
     new InsertIndexDataValuesFunction();
 
   NS_NAMED_LITERAL_CSTRING(insertIDVFunctionName, "insert_idv");
 
   rv = aConnection->CreateFunction(insertIDVFunctionName, 4, insertIDVFunction);
   if (NS_WARN_IF(NS_FAILED(rv))) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->RemoveFunction(upgradeKeyFunctionName)));
+    MOZ_ALWAYS_SUCCEEDS(aConnection->RemoveFunction(upgradeKeyFunctionName));
     return rv;
   }
 
   rv = DoUpgradeInternal(aConnection, aOrigin);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    aConnection->RemoveFunction(upgradeKeyFunctionName)));
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    aConnection->RemoveFunction(insertIDVFunctionName)));
+  MOZ_ALWAYS_SUCCEEDS(aConnection->RemoveFunction(upgradeKeyFunctionName));
+  MOZ_ALWAYS_SUCCEEDS(aConnection->RemoveFunction(insertIDVFunctionName));
 
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   return NS_OK;
 }
 
@@ -4238,17 +4235,17 @@ struct StorageOpenTraits<nsIFileURL*>
   {
     return aStorageService->OpenDatabaseWithFileURL(aFileURL, aConnection);
   }
 
 #ifdef DEBUG
   static void
   GetPath(nsIFileURL* aFileURL, nsCString& aPath)
   {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aFileURL->GetFileName(aPath)));
+    MOZ_ALWAYS_SUCCEEDS(aFileURL->GetFileName(aPath));
   }
 #endif
 };
 
 template <>
 struct StorageOpenTraits<nsIFile*>
 {
   static nsresult
@@ -4259,17 +4256,17 @@ struct StorageOpenTraits<nsIFile*>
     return aStorageService->OpenUnsharedDatabase(aFile, aConnection);
   }
 
 #ifdef DEBUG
   static void
   GetPath(nsIFile* aFile, nsCString& aPath)
   {
     nsString path;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aFile->GetPath(path)));
+    MOZ_ALWAYS_SUCCEEDS(aFile->GetPath(path));
 
     aPath.AssignWithConversion(path);
   }
 #endif
 };
 
 template <template <class> class SmartPtr, class FileOrURLType>
 struct StorageOpenTraits<SmartPtr<FileOrURLType>>
@@ -4498,19 +4495,19 @@ CreateStorageConnection(nsIFile* aDBFile
         return rv;
       }
 
       journalModeSet = true;
     } else {
 #ifdef DEBUG
     // Disable foreign key support while upgrading. This has to be done before
     // starting a transaction.
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       connection->ExecuteSimpleSQL(
-        NS_LITERAL_CSTRING("PRAGMA foreign_keys = OFF;"))));
+        NS_LITERAL_CSTRING("PRAGMA foreign_keys = OFF;")));
 #endif
     }
 
     bool vacuumNeeded = false;
 
     mozStorageTransaction transaction(connection, false,
                                   mozIStorageConnection::TRANSACTION_IMMEDIATE);
 
@@ -4618,28 +4615,28 @@ CreateStorageConnection(nsIFile* aDBFile
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
 #ifdef DEBUG
     if (!newDatabase) {
       // Re-enable foreign key support after doing a foreign key check.
       nsCOMPtr<mozIStorageStatement> checkStmt;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+      MOZ_ALWAYS_SUCCEEDS(
         connection->CreateStatement(
           NS_LITERAL_CSTRING("PRAGMA foreign_key_check;"),
-          getter_AddRefs(checkStmt))));
+          getter_AddRefs(checkStmt)));
 
       bool hasResult;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(checkStmt->ExecuteStep(&hasResult)));
+      MOZ_ALWAYS_SUCCEEDS(checkStmt->ExecuteStep(&hasResult));
       MOZ_ASSERT(!hasResult, "Database has inconsisistent foreign keys!");
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+      MOZ_ALWAYS_SUCCEEDS(
         connection->ExecuteSimpleSQL(
-          NS_LITERAL_CSTRING("PRAGMA foreign_keys = OFF;"))));
+          NS_LITERAL_CSTRING("PRAGMA foreign_keys = OFF;")));
     }
 #endif
 
     if (kSQLitePageSizeOverride && !newDatabase) {
       nsCOMPtr<mozIStorageStatement> stmt;
       rv = connection->CreateStatement(NS_LITERAL_CSTRING(
         "PRAGMA page_size;"
       ), getter_AddRefs(stmt));
@@ -9582,56 +9579,56 @@ TelemetryIdForFile(nsIFile* aFile)
   // The storage directory is structured like this:
   //
   //   <profile>/storage/<persistence>/<origin>/idb/<filename>.sqlite
   //
   // For the purposes of this function we're only concerned with the
   // <persistence>, <origin>, and <filename> pieces.
 
   nsString filename;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aFile->GetLeafName(filename)));
+  MOZ_ALWAYS_SUCCEEDS(aFile->GetLeafName(filename));
 
   // Make sure we were given a database file.
   NS_NAMED_LITERAL_STRING(sqliteExtension, ".sqlite");
 
   MOZ_ASSERT(StringEndsWith(filename, sqliteExtension));
 
   filename.Truncate(filename.Length() - sqliteExtension.Length());
 
   // Get the "idb" directory.
   nsCOMPtr<nsIFile> idbDirectory;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aFile->GetParent(getter_AddRefs(idbDirectory))));
+  MOZ_ALWAYS_SUCCEEDS(aFile->GetParent(getter_AddRefs(idbDirectory)));
 
   DebugOnly<nsString> idbLeafName;
   MOZ_ASSERT(NS_SUCCEEDED(idbDirectory->GetLeafName(idbLeafName)));
   MOZ_ASSERT(static_cast<nsString&>(idbLeafName).EqualsLiteral("idb"));
 
   // Get the <origin> directory.
   nsCOMPtr<nsIFile> originDirectory;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    idbDirectory->GetParent(getter_AddRefs(originDirectory))));
+  MOZ_ALWAYS_SUCCEEDS(
+    idbDirectory->GetParent(getter_AddRefs(originDirectory)));
 
   nsString origin;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(originDirectory->GetLeafName(origin)));
+  MOZ_ALWAYS_SUCCEEDS(originDirectory->GetLeafName(origin));
 
   // Any databases in these directories are owned by the application and should
   // not have their filenames masked. Hopefully they also appear in the
   // Telemetry.cpp whitelist.
   if (origin.EqualsLiteral("chrome") ||
       origin.EqualsLiteral("moz-safe-about+home")) {
     return 0;
   }
 
   // Get the <persistence> directory.
   nsCOMPtr<nsIFile> persistenceDirectory;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    originDirectory->GetParent(getter_AddRefs(persistenceDirectory))));
+  MOZ_ALWAYS_SUCCEEDS(
+    originDirectory->GetParent(getter_AddRefs(persistenceDirectory)));
 
   nsString persistence;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(persistenceDirectory->GetLeafName(persistence)));
+  MOZ_ALWAYS_SUCCEEDS(persistenceDirectory->GetLeafName(persistence));
 
   NS_NAMED_LITERAL_STRING(separator, "*");
 
   uint32_t hashValue = HashString(persistence + separator +
                                   origin + separator +
                                   filename);
 
   MutexAutoLock lock(*gTelemetryIdMutex);
@@ -9725,17 +9722,17 @@ DeallocPBackgroundIndexedDBUtilsParent(P
 bool
 RecvFlushPendingFileDeletions()
 {
   AssertIsOnBackgroundThread();
 
   RefPtr<FlushPendingFileDeletionsRunnable> runnable =
     new FlushPendingFileDeletionsRunnable();
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
   return true;
 }
 
 PIndexedDBPermissionRequestParent*
 AllocPIndexedDBPermissionRequestParent(Element* aOwnerElement,
                                        nsIPrincipal* aPrincipal)
 {
@@ -9878,18 +9875,17 @@ DatabaseConnection::GetCachedStatement(c
   nsCOMPtr<mozIStorageStatement> stmt;
 
   if (!mCachedStatements.Get(aQuery, getter_AddRefs(stmt))) {
     nsresult rv =
       mStorageConnection->CreateStatement(aQuery, getter_AddRefs(stmt));
     if (NS_FAILED(rv)) {
 #ifdef DEBUG
       nsCString msg;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mStorageConnection->GetLastErrorString(msg)));
+      MOZ_ALWAYS_SUCCEEDS(mStorageConnection->GetLastErrorString(msg));
 
       nsAutoCString error =
         NS_LITERAL_CSTRING("The statement '") + aQuery +
         NS_LITERAL_CSTRING("' failed to compile with the error message '") +
         msg + NS_LITERAL_CSTRING("'.");
 
       NS_WARNING(error.get());
 #endif
@@ -10469,25 +10465,25 @@ DatabaseConnection::Close(uintptr_t aCal
     MOZ_RELEASE_ASSERT(!mInWriteTransaction);
   }
 
   PROFILER_LABEL("IndexedDB",
                  "DatabaseConnection::Close",
                  js::ProfileEntry::Category::STORAGE);
 
   if (mUpdateRefcountFunction) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       mStorageConnection->RemoveFunction(
-        NS_LITERAL_CSTRING("update_refcount"))));
+        NS_LITERAL_CSTRING("update_refcount")));
     mUpdateRefcountFunction = nullptr;
   }
 
   mCachedStatements.Clear();
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mStorageConnection->Close()));
+  MOZ_ALWAYS_SUCCEEDS(mStorageConnection->Close());
   mStorageConnection = nullptr;
 
   mFileManager = nullptr;
 }
 
 nsresult
 DatabaseConnection::DisableQuotaChecks()
 {
@@ -11589,18 +11585,18 @@ ConnectionPool::Dispatch(uint64_t aTrans
     DatabaseInfo* dbInfo = transactionInfo->mDatabaseInfo;
     MOZ_ASSERT(dbInfo);
     MOZ_ASSERT(dbInfo->mThreadInfo.mThread);
     MOZ_ASSERT(dbInfo->mThreadInfo.mRunnable);
     MOZ_ASSERT(!dbInfo->mClosing);
     MOZ_ASSERT_IF(transactionInfo->mIsWriteTransaction,
                   dbInfo->mRunningWriteTransaction == transactionInfo);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      dbInfo->mThreadInfo.mThread->Dispatch(aRunnable, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      dbInfo->mThreadInfo.mThread->Dispatch(aRunnable, NS_DISPATCH_NORMAL));
   } else {
     transactionInfo->mQueuedRunnables.AppendElement(aRunnable);
   }
 }
 
 void
 ConnectionPool::Finish(uint64_t aTransactionId, FinishCallback* aCallback)
 {
@@ -11729,17 +11725,17 @@ ConnectionPool::Cleanup()
     }
 
     mCompleteCallbacks.Clear();
 
     // And make sure they get processed.
     nsIThread* currentThread = NS_GetCurrentThread();
     MOZ_ASSERT(currentThread);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_ProcessPendingEvents(currentThread)));
+    MOZ_ALWAYS_SUCCEEDS(NS_ProcessPendingEvents(currentThread));
   }
 
   mShutdownComplete = true;
 }
 
 void
 ConnectionPool::AdjustIdleTimer()
 {
@@ -11785,34 +11781,34 @@ ConnectionPool::AdjustIdleTimer()
 
     uint32_t delay;
     if (delta > 0) {
       delay = uint32_t(std::min(delta, double(UINT32_MAX)));
     } else {
       delay = 0;
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       mIdleTimer->InitWithFuncCallback(IdleTimerCallback,
                                        this,
                                        delay,
-                                       nsITimer::TYPE_ONE_SHOT)));
+                                       nsITimer::TYPE_ONE_SHOT));
 
     mTargetIdleTime = newTargetIdleTime;
   }
 }
 
 void
 ConnectionPool::CancelIdleTimer()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mIdleTimer);
 
   if (!mTargetIdleTime.IsNull()) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mIdleTimer->Cancel()));
+    MOZ_ALWAYS_SUCCEEDS(mIdleTimer->Cancel());
 
     mTargetIdleTime = TimeStamp();
     MOZ_ASSERT(mTargetIdleTime.IsNull());
   }
 }
 
 void
 ConnectionPool::ShutdownThread(ThreadInfo& aThreadInfo)
@@ -11827,21 +11823,21 @@ ConnectionPool::ShutdownThread(ThreadInf
 
   nsCOMPtr<nsIThread> thread;
   aThreadInfo.mThread.swap(thread);
 
   IDB_DEBUG_LOG(("ConnectionPool shutting down thread %lu",
                  runnable->SerialNumber()));
 
   // This should clean up the thread with the profiler.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->Dispatch(runnable, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(thread->Dispatch(runnable, NS_DISPATCH_NORMAL));
 
   nsCOMPtr<nsIRunnable> shutdownRunnable =
     NS_NewRunnableMethod(thread, &nsIThread::Shutdown);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(shutdownRunnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(shutdownRunnable));
 
   mTotalThreadCount--;
 }
 
 void
 ConnectionPool::CloseIdleDatabases()
 {
   AssertIsOnOwningThread();
@@ -11945,19 +11941,19 @@ ConnectionPool::ScheduleTransaction(Tran
 
         for (uint32_t index = mDatabasesPerformingIdleMaintenance.Length();
              index > 0;
              index--) {
           DatabaseInfo* dbInfo = mDatabasesPerformingIdleMaintenance[index - 1];
           MOZ_ASSERT(dbInfo);
           MOZ_ASSERT(dbInfo->mThreadInfo.mThread);
 
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+          MOZ_ALWAYS_SUCCEEDS(
             dbInfo->mThreadInfo.mThread->Dispatch(runnable,
-                                                  NS_DISPATCH_NORMAL)));
+                                                  NS_DISPATCH_NORMAL));
         }
       }
 
       if (!created) {
         if (!aFromQueuedTransactions) {
           MOZ_ASSERT(!mQueuedTransactions.Contains(aTransactionInfo));
           mQueuedTransactions.AppendElement(aTransactionInfo);
         }
@@ -12003,18 +11999,18 @@ ConnectionPool::ScheduleTransaction(Tran
 
   if (!queuedRunnables.IsEmpty()) {
     for (uint32_t index = 0, count = queuedRunnables.Length();
          index < count;
          index++) {
       nsCOMPtr<nsIRunnable> runnable;
       queuedRunnables[index].swap(runnable);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        dbInfo->mThreadInfo.mThread->Dispatch(runnable, NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(
+        dbInfo->mThreadInfo.mThread->Dispatch(runnable, NS_DISPATCH_NORMAL));
     }
 
     queuedRunnables.Clear();
   }
 
   return true;
 }
 
@@ -12337,19 +12333,19 @@ ConnectionPool::PerformIdleDatabaseMaint
   nsCOMPtr<nsIRunnable> runnable =
     new IdleConnectionRunnable(aDatabaseInfo, aDatabaseInfo->mNeedsCheckpoint);
 
   aDatabaseInfo->mNeedsCheckpoint = false;
   aDatabaseInfo->mIdle = false;
 
   mDatabasesPerformingIdleMaintenance.AppendElement(aDatabaseInfo);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+  MOZ_ALWAYS_SUCCEEDS(
     aDatabaseInfo->mThreadInfo.mThread->Dispatch(runnable,
-                                                 NS_DISPATCH_NORMAL)));
+                                                 NS_DISPATCH_NORMAL));
 }
 
 void
 ConnectionPool::CloseDatabase(DatabaseInfo* aDatabaseInfo,
                               uintptr_t aCallsite)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(aDatabaseInfo);
@@ -12360,19 +12356,19 @@ ConnectionPool::CloseDatabase(DatabaseIn
 
   aDatabaseInfo->mIdle = false;
   aDatabaseInfo->mNeedsCheckpoint = false;
   aDatabaseInfo->mClosing = true;
 
   nsCOMPtr<nsIRunnable> runnable = new CloseConnectionRunnable(aDatabaseInfo,
                                                                aCallsite);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+  MOZ_ALWAYS_SUCCEEDS(
     aDatabaseInfo->mThreadInfo.mThread->Dispatch(runnable,
-                                                 NS_DISPATCH_NORMAL)));
+                                                 NS_DISPATCH_NORMAL));
 }
 
 bool
 ConnectionPool::CloseDatabaseWhenIdleInternal(const nsACString& aDatabaseId,
                                               uintptr_t aCallsite)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(!aDatabaseId.IsEmpty());
@@ -12421,18 +12417,18 @@ IdleConnectionRunnable::Run()
   nsCOMPtr<nsIEventTarget> owningThread;
   mOwningThread.swap(owningThread);
 
   if (owningThread) {
     mDatabaseInfo->AssertIsOnConnectionThread();
     MOZ_ASSERT(mDatabaseInfo->mConnection);
     mDatabaseInfo->mConnection->DoIdleProcessing(mNeedsCheckpoint);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      owningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      owningThread->Dispatch(this, NS_DISPATCH_NORMAL));
     return NS_OK;
   }
 
   RefPtr<ConnectionPool> connectionPool = mDatabaseInfo->mConnectionPool;
   MOZ_ASSERT(connectionPool);
 
   if (mDatabaseInfo->mClosing) {
     MOZ_ASSERT(!connectionPool->
@@ -12479,18 +12475,18 @@ CloseConnectionRunnable::Run()
 
       mDatabaseInfo->mConnection = nullptr;
 
 #ifdef DEBUG
       mDatabaseInfo->mDEBUGConnectionThread = nullptr;
 #endif
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      owningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      owningThread->Dispatch(this, NS_DISPATCH_NORMAL));
     return NS_OK;
   }
 
   RefPtr<ConnectionPool> connectionPool = mDatabaseInfo->mConnectionPool;
   MOZ_ASSERT(connectionPool);
 
   connectionPool->NoteClosedDatabase(mDatabaseInfo);
   return NS_OK;
@@ -12595,18 +12591,18 @@ FinishCallbackWrapper::Run()
 
   if (!mHasRunOnce) {
     MOZ_ASSERT(!IsOnBackgroundThread());
 
     mHasRunOnce = true;
 
     Unused << mCallback->Run();
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(
+      mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 
     return NS_OK;
   }
 
   mConnectionPool->AssertIsOnOwningThread();
   MOZ_ASSERT(mHasRunOnce);
 
   RefPtr<ConnectionPool> connectionPool = Move(mConnectionPool);
@@ -12684,18 +12680,18 @@ ThreadRunnable::Run()
     if (kDEBUGTransactionThreadPriority !=
           nsISupportsPriority::PRIORITY_NORMAL) {
       NS_WARNING("ConnectionPool thread debugging enabled, priority has been "
                  "modified!");
 
       nsCOMPtr<nsISupportsPriority> thread = do_QueryInterface(currentThread);
       MOZ_ASSERT(thread);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        thread->SetPriority(kDEBUGTransactionThreadPriority)));
+      MOZ_ALWAYS_SUCCEEDS(
+        thread->SetPriority(kDEBUGTransactionThreadPriority));
     }
 
     if (kDEBUGTransactionThreadSleepMS) {
       NS_WARNING("TransactionThreadPool thread debugging enabled, sleeping "
                  "after every event!");
     }
 #endif // DEBUG
 
@@ -13047,29 +13043,29 @@ Factory::Create(const LoggingInfo& aLogg
 #ifdef DEBUG
     if (kDEBUGThreadPriority != nsISupportsPriority::PRIORITY_NORMAL) {
       NS_WARNING("PBackground thread debugging enabled, priority has been "
                  "modified!");
       nsCOMPtr<nsISupportsPriority> thread =
         do_QueryInterface(NS_GetCurrentThread());
       MOZ_ASSERT(thread);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->SetPriority(kDEBUGThreadPriority)));
+      MOZ_ALWAYS_SUCCEEDS(thread->SetPriority(kDEBUGThreadPriority));
     }
 
     if (kDEBUGThreadSleepMS) {
       NS_WARNING("PBackground thread debugging enabled, sleeping after every "
                  "event!");
       nsCOMPtr<nsIThreadInternal> thread =
         do_QueryInterface(NS_GetCurrentThread());
       MOZ_ASSERT(thread);
 
       gDEBUGThreadSlower = new DEBUGThreadSlower();
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->AddObserver(gDEBUGThreadSlower)));
+      MOZ_ALWAYS_SUCCEEDS(thread->AddObserver(gDEBUGThreadSlower));
     }
 #endif // DEBUG
   }
 
   RefPtr<DatabaseLoggingInfo> loggingInfo =
     gLoggingInfoHashtable->Get(aLoggingInfo.backgroundChildLoggingId());
   if (loggingInfo) {
     MOZ_ASSERT(aLoggingInfo.backgroundChildLoggingId() == loggingInfo->Id());
@@ -13122,28 +13118,28 @@ Factory::ActorDestroy(ActorDestroyReason
     gFactoryOps = nullptr;
 
 #ifdef DEBUG
     if (kDEBUGThreadPriority != nsISupportsPriority::PRIORITY_NORMAL) {
       nsCOMPtr<nsISupportsPriority> thread =
         do_QueryInterface(NS_GetCurrentThread());
       MOZ_ASSERT(thread);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        thread->SetPriority(nsISupportsPriority::PRIORITY_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(
+        thread->SetPriority(nsISupportsPriority::PRIORITY_NORMAL));
     }
 
     if (kDEBUGThreadSleepMS) {
       MOZ_ASSERT(gDEBUGThreadSlower);
 
       nsCOMPtr<nsIThreadInternal> thread =
         do_QueryInterface(NS_GetCurrentThread());
       MOZ_ASSERT(thread);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->RemoveObserver(gDEBUGThreadSlower)));
+      MOZ_ALWAYS_SUCCEEDS(thread->RemoveObserver(gDEBUGThreadSlower));
 
       gDEBUGThreadSlower = nullptr;
     }
 #endif // DEBUG
   }
 }
 
 bool
@@ -13242,17 +13238,17 @@ Factory::RecvPBackgroundIDBFactoryReques
 {
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(aActor);
   MOZ_ASSERT(aParams.type() != FactoryRequestParams::T__None);
   MOZ_ASSERT(!QuotaClient::IsShuttingDownOnBackgroundThread());
 
   auto* op = static_cast<FactoryOp*>(aActor);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(op)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(op));
   return true;
 }
 
 bool
 Factory::DeallocPBackgroundIDBFactoryRequestParent(
                                      PBackgroundIDBFactoryRequestParent* aActor)
 {
   AssertIsOnBackgroundThread();
@@ -15410,17 +15406,17 @@ VersionChangeTransaction::SendCompleteNo
   }
 
   openDatabaseOp->mState = OpenDatabaseOp::State::SendingResults;
 
   if (!IsActorDestroyed()) {
     Unused << SendComplete(aResult);
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(openDatabaseOp->Run()));
+  MOZ_ALWAYS_SUCCEEDS(openDatabaseOp->Run());
 }
 
 void
 VersionChangeTransaction::ActorDestroy(ActorDestroyReason aWhy)
 {
   AssertIsOnBackgroundThread();
 
   NoteActorDestroyed();
@@ -16704,29 +16700,25 @@ QuotaClient::GetOrCreateThreadPool()
 
     // PR_GetNumberOfProcessors() can return -1 on error, so make sure we
     // don't set some huge number here. We add 2 in case some threads block on
     // the disk I/O.
     const uint32_t threadCount =
       std::max(int32_t(PR_GetNumberOfProcessors()), int32_t(1)) +
       2;
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      threadPool->SetThreadLimit(threadCount)));
+    MOZ_ALWAYS_SUCCEEDS(threadPool->SetThreadLimit(threadCount));
 
     // Don't keep more than one idle thread.
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      threadPool->SetIdleThreadLimit(1)));
+    MOZ_ALWAYS_SUCCEEDS(threadPool->SetIdleThreadLimit(1));
 
     // Don't keep idle threads alive very long.
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      threadPool->SetIdleThreadTimeout(5 * PR_MSEC_PER_SEC)));
-
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      threadPool->SetName(NS_LITERAL_CSTRING("IndexedDB Mnt"))));
+    MOZ_ALWAYS_SUCCEEDS(threadPool->SetIdleThreadTimeout(5 * PR_MSEC_PER_SEC));
+
+    MOZ_ALWAYS_SUCCEEDS(threadPool->SetName(NS_LITERAL_CSTRING("IndexedDB Mnt")));
 
     mMaintenanceThreadPool = Move(threadPool);
   }
 
   return mMaintenanceThreadPool;
 }
 
 mozilla::dom::quota::Client::Type
@@ -17002,24 +16994,24 @@ QuotaClient::InitOrigin(PersistenceType 
 
   // We have to do this after file manager initialization.
   if (!unknownFiles.IsEmpty()) {
 #ifdef DEBUG
     for (uint32_t count = unknownFiles.Length(), i = 0; i < count; i++) {
       nsCOMPtr<nsIFile>& unknownFile = unknownFiles[i];
 
       nsString leafName;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(unknownFile->GetLeafName(leafName)));
+      MOZ_ALWAYS_SUCCEEDS(unknownFile->GetLeafName(leafName));
 
       MOZ_ASSERT(!StringEndsWith(leafName, journalSuffix));
       MOZ_ASSERT(!StringEndsWith(leafName, shmSuffix));
       MOZ_ASSERT(!StringEndsWith(leafName, walSuffix));
 
       nsString path;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(unknownFile->GetPath(path)));
+      MOZ_ALWAYS_SUCCEEDS(unknownFile->GetPath(path));
       MOZ_ASSERT(!path.IsEmpty());
 
       nsPrintfCString warning("Refusing to open databases for \"%s\" because "
                               "an unexpected file exists in the storage "
                               "area: \"%s\"",
                               PromiseFlatCString(aOrigin).get(),
                               NS_ConvertUTF16toUTF8(path).get());
       NS_WARNING(warning.get());
@@ -17378,17 +17370,17 @@ Maintenance::Start()
   // for low disk space mode.
 
   if (IndexedDatabaseManager::Get()) {
     OpenDirectory();
     return NS_OK;
   }
 
   mState = State::CreateIndexedDatabaseManager;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(this)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
 
   return NS_OK;
 }
 
 nsresult
 Maintenance::CreateIndexedDatabaseManager()
 {
   MOZ_ASSERT(NS_IsMainThread());
@@ -17399,18 +17391,18 @@ Maintenance::CreateIndexedDatabaseManage
   }
 
   IndexedDatabaseManager* mgr = IndexedDatabaseManager::GetOrCreate();
   if (NS_WARN_IF(!mgr)) {
     return NS_ERROR_FAILURE;
   }
 
   mState = State::IndexedDatabaseManagerOpen;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mQuotaClient->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mQuotaClient->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL));
 
   return NS_OK;
 }
 
 nsresult
 Maintenance::OpenDirectory()
 {
   AssertIsOnBackgroundThread();
@@ -17479,23 +17471,23 @@ Maintenance::DirectoryWork()
 
   QuotaManager* quotaManager = QuotaManager::Get();
   MOZ_ASSERT(quotaManager);
 
   nsCOMPtr<nsIFile> storageDir = GetFileForPath(quotaManager->GetStoragePath());
   MOZ_ASSERT(storageDir);
 
   bool exists;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(storageDir->Exists(&exists)));
+  MOZ_ALWAYS_SUCCEEDS(storageDir->Exists(&exists));
   if (!exists) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   bool isDirectory;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(storageDir->IsDirectory(&isDirectory)));
+  MOZ_ALWAYS_SUCCEEDS(storageDir->IsDirectory(&isDirectory));
   if (NS_WARN_IF(!isDirectory)) {
     return NS_ERROR_FAILURE;
   }
 
   // There are currently only 3 persistence types, and we want to iterate them
   // in this order:
   static const PersistenceType kPersistenceTypes[] = {
     PERSISTENCE_TYPE_PERSISTENT,
@@ -17520,126 +17512,126 @@ Maintenance::DirectoryWork()
     if (persistenceType == PERSISTENCE_TYPE_PERSISTENT) {
       // XXX This shouldn't be a special case...
       persistenceTypeString.AssignLiteral("permanent");
     } else {
       PersistenceTypeToText(persistenceType, persistenceTypeString);
     }
 
     nsCOMPtr<nsIFile> persistenceDir;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      storageDir->Clone(getter_AddRefs(persistenceDir))));
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      persistenceDir->Append(NS_ConvertASCIItoUTF16(persistenceTypeString))));
-
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(persistenceDir->Exists(&exists)));
+    MOZ_ALWAYS_SUCCEEDS(
+      storageDir->Clone(getter_AddRefs(persistenceDir)));
+    MOZ_ALWAYS_SUCCEEDS(
+      persistenceDir->Append(NS_ConvertASCIItoUTF16(persistenceTypeString)));
+
+    MOZ_ALWAYS_SUCCEEDS(persistenceDir->Exists(&exists));
     if (!exists) {
       continue;
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(persistenceDir->IsDirectory(&isDirectory)));
+    MOZ_ALWAYS_SUCCEEDS(persistenceDir->IsDirectory(&isDirectory));
     if (NS_WARN_IF(!isDirectory)) {
       continue;
     }
 
     nsCOMPtr<nsISimpleEnumerator> persistenceDirEntries;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       persistenceDir->GetDirectoryEntries(
-        getter_AddRefs(persistenceDirEntries))));
+        getter_AddRefs(persistenceDirEntries)));
     if (!persistenceDirEntries) {
       continue;
     }
 
     while (true) {
       // Loop over "<origin>/idb" directories.
       if (IsAborted()) {
         return NS_ERROR_ABORT;
       }
 
       bool persistenceDirHasMoreEntries;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        persistenceDirEntries->HasMoreElements(&persistenceDirHasMoreEntries)));
+      MOZ_ALWAYS_SUCCEEDS(
+        persistenceDirEntries->HasMoreElements(&persistenceDirHasMoreEntries));
 
       if (!persistenceDirHasMoreEntries) {
         break;
       }
 
       nsCOMPtr<nsISupports> persistenceDirEntry;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        persistenceDirEntries->GetNext(getter_AddRefs(persistenceDirEntry))));
+      MOZ_ALWAYS_SUCCEEDS(
+        persistenceDirEntries->GetNext(getter_AddRefs(persistenceDirEntry)));
 
       nsCOMPtr<nsIFile> originDir = do_QueryInterface(persistenceDirEntry);
       MOZ_ASSERT(originDir);
 
       MOZ_ASSERT(NS_SUCCEEDED(originDir->Exists(&exists)));
       MOZ_ASSERT(exists);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(originDir->IsDirectory(&isDirectory)));
+      MOZ_ALWAYS_SUCCEEDS(originDir->IsDirectory(&isDirectory));
       if (!isDirectory) {
         continue;
       }
 
       nsCOMPtr<nsIFile> idbDir;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(originDir->Clone(getter_AddRefs(idbDir))));
-
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(idbDir->Append(idbDirName)));
-
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(idbDir->Exists(&exists)));
+      MOZ_ALWAYS_SUCCEEDS(originDir->Clone(getter_AddRefs(idbDir)));
+
+      MOZ_ALWAYS_SUCCEEDS(idbDir->Append(idbDirName));
+
+      MOZ_ALWAYS_SUCCEEDS(idbDir->Exists(&exists));
       if (!exists) {
         continue;
       }
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(idbDir->IsDirectory(&isDirectory)));
+      MOZ_ALWAYS_SUCCEEDS(idbDir->IsDirectory(&isDirectory));
       if (NS_WARN_IF(!isDirectory)) {
         continue;
       }
 
       nsCOMPtr<nsISimpleEnumerator> idbDirEntries;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        idbDir->GetDirectoryEntries(getter_AddRefs(idbDirEntries))));
+      MOZ_ALWAYS_SUCCEEDS(
+        idbDir->GetDirectoryEntries(getter_AddRefs(idbDirEntries)));
       if (!idbDirEntries) {
         continue;
       }
 
       nsCString group;
       nsCString origin;
       nsTArray<nsString> databasePaths;
 
       while (true) {
         // Loop over files in the "idb" directory.
         if (IsAborted()) {
           return NS_ERROR_ABORT;
         }
 
         bool idbDirHasMoreEntries;
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-          idbDirEntries->HasMoreElements(&idbDirHasMoreEntries)));
+        MOZ_ALWAYS_SUCCEEDS(
+          idbDirEntries->HasMoreElements(&idbDirHasMoreEntries));
 
         if (!idbDirHasMoreEntries) {
           break;
         }
 
         nsCOMPtr<nsISupports> idbDirEntry;
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-          idbDirEntries->GetNext(getter_AddRefs(idbDirEntry))));
+        MOZ_ALWAYS_SUCCEEDS(
+          idbDirEntries->GetNext(getter_AddRefs(idbDirEntry)));
 
         nsCOMPtr<nsIFile> idbDirFile = do_QueryInterface(idbDirEntry);
         MOZ_ASSERT(idbDirFile);
 
         nsString idbFilePath;
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(idbDirFile->GetPath(idbFilePath)));
+        MOZ_ALWAYS_SUCCEEDS(idbDirFile->GetPath(idbFilePath));
 
         if (!StringEndsWith(idbFilePath, sqliteExtension)) {
           continue;
         }
 
         MOZ_ASSERT(NS_SUCCEEDED(idbDirFile->Exists(&exists)));
         MOZ_ASSERT(exists);
 
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(idbDirFile->IsDirectory(&isDirectory)));
+        MOZ_ALWAYS_SUCCEEDS(idbDirFile->IsDirectory(&isDirectory));
         if (isDirectory) {
           continue;
         }
 
         // Found a database.
         if (databasePaths.IsEmpty()) {
           MOZ_ASSERT(group.IsEmpty());
           MOZ_ASSERT(origin.IsEmpty());
@@ -17668,18 +17660,18 @@ Maintenance::DirectoryWork()
                                                     origin,
                                                     Move(databasePaths)));
       }
     }
   }
 
   mState = State::BeginDatabaseMaintenance;
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mQuotaClient->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mQuotaClient->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL));
 
   return NS_OK;
 }
 
 nsresult
 Maintenance::BeginDatabaseMaintenance()
 {
   AssertIsOnBackgroundThread();
@@ -17730,18 +17722,18 @@ Maintenance::BeginDatabaseMaintenance()
                                   directoryInfo.mOrigin,
                                   databasePath);
 
         if (!threadPool) {
           threadPool = mQuotaClient->GetOrCreateThreadPool();
           MOZ_ASSERT(threadPool);
         }
 
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-          threadPool->Dispatch(databaseMaintenance, NS_DISPATCH_NORMAL)));
+        MOZ_ALWAYS_SUCCEEDS(
+          threadPool->Dispatch(databaseMaintenance, NS_DISPATCH_NORMAL));
 
         RegisterDatabaseMaintenance(databaseMaintenance);
       }
     }
   }
 
   mDirectoryInfos.Clear();
 
@@ -17809,18 +17801,18 @@ Maintenance::Run()
   if (NS_WARN_IF(NS_FAILED(rv)) && mState != State::Finishing) {
     // Must set mState before dispatching otherwise we will race with the owning
     // thread.
     mState = State::Finishing;
 
     if (IsOnBackgroundThread()) {
       Finish();
     } else {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mQuotaClient->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(
+        mQuotaClient->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL));
     }
   }
 
   return NS_OK;
 }
 
 void
 Maintenance::DirectoryLockAcquired(DirectoryLock* aLock)
@@ -17872,17 +17864,17 @@ DatabaseMaintenance::PerformMaintenanceO
     {
       MOZ_ASSERT(aConnection);
     }
 
     ~AutoClose()
     {
       MOZ_ASSERT(mConnection);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mConnection->Close()));
+      MOZ_ALWAYS_SUCCEEDS(mConnection->Close());
     }
   };
 
   nsCOMPtr<nsIFile> databaseFile = GetFileForPath(mDatabasePath);
   MOZ_ASSERT(databaseFile);
 
   nsCOMPtr<mozIStorageConnection> connection;
   nsresult rv = GetStorageConnection(databaseFile,
@@ -18347,34 +18339,33 @@ DatabaseMaintenance::FullVacuum(mozIStor
 }
 
 void
 DatabaseMaintenance::RunOnOwningThread()
 {
   AssertIsOnBackgroundThread();
 
   if (mCompleteCallback) {
-    MOZ_ALWAYS_TRUE(
-      NS_SUCCEEDED(NS_DispatchToCurrentThread(mCompleteCallback)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(mCompleteCallback));
     mCompleteCallback = nullptr;
   }
 
   mMaintenance->UnregisterDatabaseMaintenance(this);
 }
 
 void
 DatabaseMaintenance::RunOnConnectionThread()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   MOZ_ASSERT(!IsOnBackgroundThread());
 
   PerformMaintenanceOnDatabase();
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mMaintenance->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mMaintenance->BackgroundThread()->Dispatch(this, NS_DISPATCH_NORMAL));
 }
 
 NS_IMETHODIMP
 DatabaseMaintenance::Run()
 {
   if (IsOnBackgroundThread()) {
     RunOnOwningThread();
   } else {
@@ -19258,17 +19249,17 @@ DatabaseOperationBase::DeleteObjectStore
     }
 
     rv = DeleteIndexDataTableRows(aConnection, objectStoreKey, indexValues);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     if (deleteStmt) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(deleteStmt->Reset()));
+      MOZ_ALWAYS_SUCCEEDS(deleteStmt->Reset());
     } else {
       rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
         "DELETE FROM object_data "
           "WHERE object_store_id = :object_store_id "
           "AND key = :key;"),
         &deleteStmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
@@ -19442,18 +19433,18 @@ AutoSetProgressHandler::AutoSetProgressH
 
 DatabaseOperationBase::
 AutoSetProgressHandler::~AutoSetProgressHandler()
 {
   MOZ_ASSERT(!IsOnBackgroundThread());
 
   if (mConnection) {
     nsCOMPtr<mozIStorageProgressHandler> oldHandler;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      mConnection->RemoveProgressHandler(getter_AddRefs(oldHandler))));
+    MOZ_ALWAYS_SUCCEEDS(
+      mConnection->RemoveProgressHandler(getter_AddRefs(oldHandler)));
     MOZ_ASSERT(oldHandler == mDEBUGDatabaseOp);
   }
 }
 
 nsresult
 DatabaseOperationBase::
 AutoSetProgressHandler::Register(mozIStorageConnection* aConnection,
                                  DatabaseOperationBase* aDatabaseOp)
@@ -19722,26 +19713,24 @@ FactoryOp::Open()
                              Client::IDB,
                              mDatabaseId);
 
   mDatabaseId.Append('*');
   mDatabaseId.Append(NS_ConvertUTF16toUTF8(metadata.name()));
 
   if (permission == PermissionRequestBase::kPermissionPrompt) {
     mState = State::PermissionChallenge;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                         NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
     return NS_OK;
   }
 
   MOZ_ASSERT(permission == PermissionRequestBase::kPermissionAllowed);
 
   mState = State::FinishOpen;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 
   return NS_OK;
 }
 
 nsresult
 FactoryOp::ChallengePermission()
 {
   AssertIsOnOwningThread();
@@ -19788,18 +19777,17 @@ FactoryOp::RetryCheckPermission()
   if (permission == PermissionRequestBase::kPermissionDenied ||
       permission == PermissionRequestBase::kPermissionPrompt) {
     return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
   }
 
   MOZ_ASSERT(permission == PermissionRequestBase::kPermissionAllowed);
 
   mState = State::FinishOpen;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 
   return NS_OK;
 }
 
 nsresult
 FactoryOp::DirectoryOpen()
 {
   AssertIsOnOwningThread();
@@ -19908,17 +19896,17 @@ FactoryOp::FinishSendResults()
   MOZ_ASSERT(mFactory);
 
   // Make sure to release the factory on this thread.
   RefPtr<Factory> factory;
   mFactory.swap(factory);
 
   if (mBlockedDatabaseOpen) {
     if (mDelayedOp) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(mDelayedOp)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(mDelayedOp));
       mDelayedOp = nullptr;
     }
 
     MOZ_ASSERT(gFactoryOps);
     gFactoryOps->RemoveElement(this);
   }
 
   mState = State::Completed;
@@ -20402,18 +20390,17 @@ FactoryOp::Run()
 
     // Must set mState before dispatching otherwise we will race with the owning
     // thread.
     mState = State::SendingResults;
 
     if (IsOnOwningThread()) {
       SendResults();
     } else {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
     }
   }
 
   return NS_OK;
 }
 
 void
 FactoryOp::DirectoryLockAcquired(DirectoryLock* aLock)
@@ -20466,17 +20453,17 @@ FactoryOp::RecvPermissionRetry()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(!IsActorDestroyed());
   MOZ_ASSERT(mState == State::PermissionChallenge);
 
   mContentParent = BackgroundParent::GetContentParent(Manager()->Manager());
 
   mState = State::PermissionRetry;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(this)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
 
   return true;
 }
 
 OpenDatabaseOp::OpenDatabaseOp(Factory* aFactory,
                                already_AddRefed<ContentParent> aContentParent,
                                const CommonFactoryRequestParams& aParams)
   : FactoryOp(aFactory, Move(aContentParent), aParams, /* aDeleting */ false)
@@ -21247,17 +21234,17 @@ OpenDatabaseOp::NoteDatabaseClosed(Datab
   }
 
   if (NS_WARN_IF(NS_FAILED(rv))) {
     if (NS_SUCCEEDED(mResultCode)) {
       mResultCode = rv;
     }
 
     mState = State::SendingResults;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Run()));
+    MOZ_ALWAYS_SUCCEEDS(Run());
   }
 }
 
 void
 OpenDatabaseOp::SendBlockedNotification()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mState == State::WaitingForOtherDatabasesToClose);
@@ -21752,17 +21739,17 @@ VersionChangeOp::SendFailureResult(nsres
   AssertIsOnOwningThread();
   MOZ_ASSERT(mOpenDatabaseOp);
   MOZ_ASSERT(mOpenDatabaseOp->mState == State::DatabaseWorkVersionChange);
   MOZ_ASSERT(mOpenDatabaseOp->mVersionChangeOp == this);
 
   mOpenDatabaseOp->SetFailureCode(aResultCode);
   mOpenDatabaseOp->mState = State::SendingResults;
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOpenDatabaseOp->Run()));
+  MOZ_ALWAYS_SUCCEEDS(mOpenDatabaseOp->Run());
 
   return false;
 }
 
 void
 OpenDatabaseOp::
 VersionChangeOp::Cleanup()
 {
@@ -21807,27 +21794,27 @@ DeleteDatabaseOp::LoadPreviousVersion(ns
   rv = OpenDatabaseAndHandleBusy(ss, aDatabaseFile, getter_AddRefs(connection));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return;
   }
 
 #ifdef DEBUG
   {
     nsCOMPtr<mozIStorageStatement> stmt;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       connection->CreateStatement(NS_LITERAL_CSTRING(
         "SELECT name "
           "FROM database"
-        ), getter_AddRefs(stmt))));
+        ), getter_AddRefs(stmt)));
 
     bool hasResult;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
+    MOZ_ALWAYS_SUCCEEDS(stmt->ExecuteStep(&hasResult));
 
     nsString databaseName;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->GetString(0, databaseName)));
+    MOZ_ALWAYS_SUCCEEDS(stmt->GetString(0, databaseName));
 
     MOZ_ASSERT(mCommonParams.metadata().name() == databaseName);
   }
 #endif
 
   nsCOMPtr<mozIStorageStatement> stmt;
   rv = connection->CreateStatement(NS_LITERAL_CSTRING(
     "SELECT version "
@@ -22063,17 +22050,17 @@ DeleteDatabaseOp::NoteDatabaseClosed(Dat
   }
 
   if (NS_WARN_IF(NS_FAILED(rv))) {
     if (NS_SUCCEEDED(mResultCode)) {
       mResultCode = rv;
     }
 
     mState = State::SendingResults;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Run()));
+    MOZ_ALWAYS_SUCCEEDS(Run());
   }
 }
 
 void
 DeleteDatabaseOp::SendBlockedNotification()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mState == State::WaitingForOtherDatabasesToClose);
@@ -22388,17 +22375,17 @@ VersionChangeOp::RunOnOwningThread()
 
           MOZ_ASSERT(!gLiveDatabaseHashtable->Get(deleteOp->mDatabaseId));
         }
       }
     }
   }
 
   deleteOp->mState = State::SendingResults;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(deleteOp->Run()));
+  MOZ_ALWAYS_SUCCEEDS(deleteOp->Run());
 
 #ifdef DEBUG
   // A bit hacky but the DeleteDatabaseOp::VersionChangeOp is not really a
   // normal database operation that is tied to an actor. Do this to make our
   // assertions happy.
   NoteActorDestroyed();
 #endif
 }
@@ -22416,18 +22403,17 @@ VersionChangeOp::Run()
     rv = NS_OK;
   }
 
   if (NS_WARN_IF(NS_FAILED(rv))) {
     if (NS_SUCCEEDED(mResultCode)) {
       mResultCode = rv;
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                         NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
   }
 
   return NS_OK;
 }
 
 TransactionDatabaseOperationBase::TransactionDatabaseOperationBase(
                                                   TransactionBase* aTransaction)
   : DatabaseOperationBase(aTransaction->GetLoggingInfo()->Id(),
@@ -22548,18 +22534,17 @@ TransactionDatabaseOperationBase::RunOnC
 
         if (NS_FAILED(rv)) {
           mResultCode = rv;
         }
       }
     }
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 }
 
 void
 TransactionDatabaseOperationBase::RunOnOwningThread()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mTransaction);
 
@@ -22670,17 +22655,17 @@ CommitOp::WriteAutoIncrementCounts()
     for (uint32_t count = metadataArray.Length(), index = 0;
          index < count;
          index++) {
       const RefPtr<FullObjectStoreMetadata>& metadata = metadataArray[index];
       MOZ_ASSERT(!metadata->mDeleted);
       MOZ_ASSERT(metadata->mNextAutoIncrementId > 1);
 
       if (stmt) {
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->Reset()));
+        MOZ_ALWAYS_SUCCEEDS(stmt->Reset());
       } else {
         rv = connection->GetCachedStatement(
           NS_LITERAL_CSTRING("UPDATE object_store "
                              "SET auto_increment = :") + ai +
           NS_LITERAL_CSTRING(" WHERE id = :") + osid +
           NS_LITERAL_CSTRING(";"),
           &stmt);
         if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -22746,37 +22731,37 @@ TransactionBase::
 CommitOp::AssertForeignKeyConsistency(DatabaseConnection* aConnection)
 {
   MOZ_ASSERT(aConnection);
   MOZ_ASSERT(mTransaction);
   mTransaction->AssertIsOnConnectionThread();
   MOZ_ASSERT(mTransaction->GetMode() != IDBTransaction::READ_ONLY);
 
   DatabaseConnection::CachedStatement pragmaStmt;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+  MOZ_ALWAYS_SUCCEEDS(
     aConnection->GetCachedStatement(NS_LITERAL_CSTRING("PRAGMA foreign_keys;"),
-                                    &pragmaStmt)));
+                                    &pragmaStmt));
 
   bool hasResult;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(pragmaStmt->ExecuteStep(&hasResult)));
+  MOZ_ALWAYS_SUCCEEDS(pragmaStmt->ExecuteStep(&hasResult));
 
   MOZ_ASSERT(hasResult);
 
   int32_t foreignKeysEnabled;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(pragmaStmt->GetInt32(0, &foreignKeysEnabled)));
+  MOZ_ALWAYS_SUCCEEDS(pragmaStmt->GetInt32(0, &foreignKeysEnabled));
 
   MOZ_ASSERT(foreignKeysEnabled, "Database doesn't have foreign keys enabled!");
 
   DatabaseConnection::CachedStatement checkStmt;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+  MOZ_ALWAYS_SUCCEEDS(
     aConnection->GetCachedStatement(
       NS_LITERAL_CSTRING("PRAGMA foreign_key_check;"),
-      &checkStmt)));
-
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(checkStmt->ExecuteStep(&hasResult)));
+      &checkStmt));
+
+  MOZ_ALWAYS_SUCCEEDS(checkStmt->ExecuteStep(&hasResult));
 
   MOZ_ASSERT(!hasResult, "Database has inconsisistent foreign keys!");
 }
 
 #endif // DEBUG
 
 NS_IMPL_ISUPPORTS_INHERITED0(TransactionBase::CommitOp, DatabaseOperationBase)
 
@@ -22984,18 +22969,17 @@ DatabaseOp::Run()
     if (NS_SUCCEEDED(mResultCode)) {
       mResultCode = rv;
     }
 
     // Must set mState before dispatching otherwise we will race with the owning
     // thread.
     mState = State::SendingResults;
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                         NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
   }
 
   return NS_OK;
 }
 
 void
 DatabaseOp::ActorDestroy(ActorDestroyReason aWhy)
 {
@@ -23202,28 +23186,28 @@ CreateObjectStoreOp::DoDatabaseWork(Data
   }
 
 #ifdef DEBUG
   {
     // Make sure that we're not creating an object store with the same name as
     // another that already exists. This should be impossible because we should
     // have thrown an error long before now...
     DatabaseConnection::CachedStatement stmt;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
         "SELECT name "
           "FROM object_store "
           "WHERE name = :name;"),
-        &stmt)));
-
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      stmt->BindStringByName(NS_LITERAL_CSTRING("name"), mMetadata.name())));
+        &stmt));
+
+    MOZ_ALWAYS_SUCCEEDS(
+      stmt->BindStringByName(NS_LITERAL_CSTRING("name"), mMetadata.name()));
 
     bool hasResult;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
+    MOZ_ALWAYS_SUCCEEDS(stmt->ExecuteStep(&hasResult));
     MOZ_ASSERT(!hasResult);
   }
 #endif
 
   DatabaseConnection::AutoSavepoint autoSave;
   nsresult rv = autoSave.Start(Transaction());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -23272,18 +23256,18 @@ CreateObjectStoreOp::DoDatabaseWork(Data
   rv = stmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
 #ifdef DEBUG
   {
     int64_t id;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->GetStorageConnection()->GetLastInsertRowID(&id)));
+    MOZ_ALWAYS_SUCCEEDS(
+      aConnection->GetStorageConnection()->GetLastInsertRowID(&id));
     MOZ_ASSERT(mMetadata.id() == id);
   }
 #endif
 
   rv = autoSave.Commit();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -23302,35 +23286,35 @@ DeleteObjectStoreOp::DoDatabaseWork(Data
                  js::ProfileEntry::Category::STORAGE);
 
   NS_NAMED_LITERAL_CSTRING(objectStoreIdString, "object_store_id");
 
 #ifdef DEBUG
   {
     // Make sure |mIsLastObjectStore| is telling the truth.
     DatabaseConnection::CachedStatement stmt;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
         "SELECT id "
           "FROM object_store;"),
-        &stmt)));
+        &stmt));
 
     bool foundThisObjectStore = false;
     bool foundOtherObjectStore = false;
 
     while (true) {
       bool hasResult;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
+      MOZ_ALWAYS_SUCCEEDS(stmt->ExecuteStep(&hasResult));
 
       if (!hasResult) {
         break;
       }
 
       int64_t id;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->GetInt64(0, &id)));
+      MOZ_ALWAYS_SUCCEEDS(stmt->GetInt64(0, &id));
 
       if (id == mMetadata->mCommonMetadata.id()) {
         foundThisObjectStore = true;
       } else {
         foundOtherObjectStore = true;
       }
     }
 
@@ -23489,19 +23473,19 @@ DeleteObjectStoreOp::DoDatabaseWork(Data
     rv = stmt->Execute();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
 #ifdef DEBUG
     {
       int32_t deletedRowCount;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+      MOZ_ALWAYS_SUCCEEDS(
         aConnection->GetStorageConnection()->
-          GetAffectedRows(&deletedRowCount)));
+          GetAffectedRows(&deletedRowCount));
       MOZ_ASSERT(deletedRowCount == 1);
     }
 #endif
   }
 
   rv = autoSave.Commit();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -23567,18 +23551,17 @@ CreateIndexOp::InsertDataFromObjectStore
                                       4,
                                       updateFunction);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = InsertDataFromObjectStoreInternal(aConnection);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    storageConnection->RemoveFunction(updateFunctionName)));
+  MOZ_ALWAYS_SUCCEEDS(storageConnection->RemoveFunction(updateFunctionName));
 
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   return NS_OK;
 }
 
@@ -23671,30 +23654,30 @@ CreateIndexOp::DoDatabaseWork(DatabaseCo
   }
 
 #ifdef DEBUG
   {
     // Make sure that we're not creating an index with the same name and object
     // store as another that already exists. This should be impossible because
     // we should have thrown an error long before now...
     DatabaseConnection::CachedStatement stmt;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
         "SELECT name "
           "FROM object_store_index "
           "WHERE object_store_id = :osid "
           "AND name = :name;"),
-        &stmt)));
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      stmt->BindInt64ByName(NS_LITERAL_CSTRING("osid"), mObjectStoreId)));
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      stmt->BindStringByName(NS_LITERAL_CSTRING("name"), mMetadata.name())));
+        &stmt));
+    MOZ_ALWAYS_SUCCEEDS(
+      stmt->BindInt64ByName(NS_LITERAL_CSTRING("osid"), mObjectStoreId));
+    MOZ_ALWAYS_SUCCEEDS(
+      stmt->BindStringByName(NS_LITERAL_CSTRING("name"), mMetadata.name()));
 
     bool hasResult;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
+    MOZ_ALWAYS_SUCCEEDS(stmt->ExecuteStep(&hasResult));
 
     MOZ_ASSERT(!hasResult);
   }
 #endif
 
   DatabaseConnection::AutoSavepoint autoSave;
   nsresult rv = autoSave.Start(Transaction());
   if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -23767,18 +23750,18 @@ CreateIndexOp::DoDatabaseWork(DatabaseCo
   rv = stmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
 #ifdef DEBUG
   {
     int64_t id;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->GetStorageConnection()->GetLastInsertRowID(&id)));
+    MOZ_ALWAYS_SUCCEEDS(
+      aConnection->GetStorageConnection()->GetLastInsertRowID(&id));
     MOZ_ASSERT(mMetadata.id() == id);
   }
 #endif
 
   rv = InsertDataFromObjectStore(aConnection);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -23898,32 +23881,32 @@ UpdateIndexDataValuesFunction::OnFunctio
 
   PROFILER_LABEL("IndexedDB",
                  "CreateIndexOp::UpdateIndexDataValuesFunction::OnFunctionCall",
                  js::ProfileEntry::Category::STORAGE);
 
 #ifdef DEBUG
   {
     uint32_t argCount;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetNumEntries(&argCount)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetNumEntries(&argCount));
     MOZ_ASSERT(argCount == 4); // key, index_data_values, file_ids, data
 
     int32_t valueType;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(0, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(0, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(1, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(1, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_NULL ||
                valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(2, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(2, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_NULL ||
                valueType == mozIStorageValueArray::VALUE_TYPE_TEXT);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aValues->GetTypeOfIndex(3, &valueType)));
+    MOZ_ALWAYS_SUCCEEDS(aValues->GetTypeOfIndex(3, &valueType));
     MOZ_ASSERT(valueType == mozIStorageValueArray::VALUE_TYPE_BLOB);
   }
 #endif
 
   StructuredCloneReadInfo cloneInfo;
   nsresult rv =
     GetStructuredCloneReadInfoFromValueArray(aValues,
                                              /* aDataIndex */ 3,
@@ -24233,40 +24216,40 @@ DeleteIndexOp::DoDatabaseWork(DatabaseCo
 {
   MOZ_ASSERT(aConnection);
   aConnection->AssertIsOnConnectionThread();
 
 #ifdef DEBUG
   {
     // Make sure |mIsLastIndex| is telling the truth.
     DatabaseConnection::CachedStatement stmt;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
         "SELECT id "
           "FROM object_store_index "
           "WHERE object_store_id = :object_store_id;"),
-        &stmt)));
-
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+        &stmt));
+
+    MOZ_ALWAYS_SUCCEEDS(
       stmt->BindInt64ByName(NS_LITERAL_CSTRING("object_store_id"),
-                            mObjectStoreId)));
+                            mObjectStoreId));
 
     bool foundThisIndex = false;
     bool foundOtherIndex = false;
 
     while (true) {
       bool hasResult;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
+      MOZ_ALWAYS_SUCCEEDS(stmt->ExecuteStep(&hasResult));
 
       if (!hasResult) {
         break;
       }
 
       int64_t id;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->GetInt64(0, &id)));
+      MOZ_ALWAYS_SUCCEEDS(stmt->GetInt64(0, &id));
 
       if (id == mIndexId) {
         foundThisIndex = true;
       } else {
         foundOtherIndex = true;
       }
     }
 
@@ -24427,17 +24410,17 @@ DeleteIndexOp::DoDatabaseWork(DatabaseCo
           IDB_REPORT_INTERNAL_ERR();
           return NS_ERROR_FILE_CORRUPTED;
         }
       }
     }
 
     // Now delete the index row.
     if (deleteIndexRowStmt) {
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(deleteIndexRowStmt->Reset()));
+        MOZ_ALWAYS_SUCCEEDS(deleteIndexRowStmt->Reset());
     } else {
       if (mUnique) {
         rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
           "DELETE FROM unique_index_data "
             "WHERE index_id = :index_id "
             "AND value = :value;"),
           &deleteIndexRowStmt);
       } else {
@@ -24509,18 +24492,18 @@ DeleteIndexOp::DoDatabaseWork(DatabaseCo
   rv = deleteStmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
 #ifdef DEBUG
   {
     int32_t deletedRowCount;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->GetStorageConnection()->GetAffectedRows(&deletedRowCount)));
+    MOZ_ALWAYS_SUCCEEDS(
+      aConnection->GetStorageConnection()->GetAffectedRows(&deletedRowCount));
     MOZ_ASSERT(deletedRowCount == 1);
   }
 #endif
 
   rv = autoSave.Commit();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
--- a/dom/indexedDB/FileInfo.cpp
+++ b/dom/indexedDB/FileInfo.cpp
@@ -211,17 +211,17 @@ FileInfo::Cleanup()
 {
   int64_t id = Id();
 
   // IndexedDatabaseManager is main-thread only.
   if (!NS_IsMainThread()) {
     RefPtr<CleanupFileRunnable> cleaner =
       new CleanupFileRunnable(mFileManager, id);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(cleaner)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(cleaner));
     return;
   }
 
   CleanupFileRunnable::DoCleanup(mFileManager, id);
 }
 
 // static
 void
--- a/dom/indexedDB/FileSnapshot.cpp
+++ b/dom/indexedDB/FileSnapshot.cpp
@@ -84,18 +84,18 @@ private:
     if (IsOnOwningThread()) {
       delete this;
       return;
     }
 
     nsCOMPtr<nsIRunnable> destroyRunnable =
       NS_NewNonOwningRunnableMethod(this, &StreamWrapper::Destroy);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(destroyRunnable,
-                                                         NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(destroyRunnable,
+                                                NS_DISPATCH_NORMAL));
   }
 
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIINPUTSTREAM
   NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
 };
 
 class StreamWrapper::CloseRunnable final
@@ -214,18 +214,18 @@ NS_IMPL_QUERY_INTERFACE(StreamWrapper,
 
 NS_IMETHODIMP
 StreamWrapper::Close()
 {
   MOZ_ASSERT(!IsOnOwningThread());
 
   RefPtr<CloseRunnable> closeRunnable = new CloseRunnable(this);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(closeRunnable,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(closeRunnable,
+                                              NS_DISPATCH_NORMAL));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 StreamWrapper::Available(uint64_t* _retval)
 {
   // Can't assert here, this method is sometimes called on the owning thread
--- a/dom/indexedDB/IDBDatabase.cpp
+++ b/dom/indexedDB/IDBDatabase.cpp
@@ -274,18 +274,18 @@ IDBDatabase::CloseInternal()
       mObserver->Revoke();
 
       nsCOMPtr<nsIObserverService> obsSvc = GetObserverService();
       if (obsSvc) {
         // These might not have been registered.
         obsSvc->RemoveObserver(mObserver, kCycleCollectionObserverTopic);
         obsSvc->RemoveObserver(mObserver, kMemoryPressureObserverTopic);
 
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-          obsSvc->RemoveObserver(mObserver, kWindowObserverTopic)));
+        MOZ_ALWAYS_SUCCEEDS(
+          obsSvc->RemoveObserver(mObserver, kWindowObserverTopic));
       }
 
       mObserver = nullptr;
     }
 
     if (mBackgroundActor && !mInvalidated) {
       mBackgroundActor->SendClose();
     }
@@ -1037,17 +1037,17 @@ IDBDatabase::DelayedMaybeExpireFileActor
   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_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(runnable));
 }
 
 nsresult
 IDBDatabase::GetQuotaInfo(nsACString& aOrigin,
                           PersistenceType* aPersistenceType)
 {
   using mozilla::dom::quota::QuotaManager;
 
@@ -1313,17 +1313,17 @@ Observer::Observe(nsISupports* aSubject,
   MOZ_ASSERT(aTopic);
 
   if (!strcmp(aTopic, kWindowObserverTopic)) {
     if (mWeakDatabase) {
       nsCOMPtr<nsISupportsPRUint64> supportsInt = do_QueryInterface(aSubject);
       MOZ_ASSERT(supportsInt);
 
       uint64_t windowId;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(supportsInt->GetData(&windowId)));
+      MOZ_ALWAYS_SUCCEEDS(supportsInt->GetData(&windowId));
 
       if (windowId == mWindowId) {
         RefPtr<IDBDatabase> database = mWeakDatabase;
         mWeakDatabase = nullptr;
 
         database->InvalidateInternal();
       }
     }
--- a/dom/indexedDB/IDBFactory.cpp
+++ b/dom/indexedDB/IDBFactory.cpp
@@ -380,21 +380,21 @@ IDBFactory::AllowedForWindowInternal(nsP
   if (nsContentUtils::IsSystemPrincipal(principal)) {
     principal.forget(aPrincipal);
     return NS_OK;
   }
 
   // About URIs shouldn't be able to access IndexedDB unless they have the
   // nsIAboutModule::ENABLE_INDEXED_DB flag set on them.
   nsCOMPtr<nsIURI> uri;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(principal->GetURI(getter_AddRefs(uri))));
+  MOZ_ALWAYS_SUCCEEDS(principal->GetURI(getter_AddRefs(uri)));
   MOZ_ASSERT(uri);
 
   bool isAbout = false;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(uri->SchemeIs("about", &isAbout)));
+  MOZ_ALWAYS_SUCCEEDS(uri->SchemeIs("about", &isAbout));
 
   if (isAbout) {
     nsCOMPtr<nsIAboutModule> module;
     if (NS_SUCCEEDED(NS_GetAboutModule(uri, getter_AddRefs(module)))) {
       uint32_t flags;
       if (NS_SUCCEEDED(module->GetURIFlags(uri, &flags))) {
         if (!(flags & nsIAboutModule::ENABLE_INDEXED_DB)) {
           return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
@@ -702,17 +702,17 @@ IDBFactory::OpenInternal(JSContext* aCx,
     if (threadLocal && threadLocal->mIndexedDBThreadLocal) {
       idbThreadLocal = threadLocal->mIndexedDBThreadLocal;
     } else {
       nsCOMPtr<nsIUUIDGenerator> uuidGen =
         do_GetService("@mozilla.org/uuid-generator;1");
       MOZ_ASSERT(uuidGen);
 
       nsID id;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(uuidGen->GenerateUUIDInPlace(&id)));
+      MOZ_ALWAYS_SUCCEEDS(uuidGen->GenerateUUIDInPlace(&id));
 
       newIDBThreadLocal = idbThreadLocal = new ThreadLocal(id);
     }
 
     if (PBackgroundChild* actor = BackgroundChild::GetForCurrentThread()) {
       BackgroundActorCreated(actor, idbThreadLocal->GetLoggingInfo());
     } else {
       // We need to start the sequence to create a background actor for this
--- a/dom/indexedDB/IndexedDatabaseManager.cpp
+++ b/dom/indexedDB/IndexedDatabaseManager.cpp
@@ -455,17 +455,17 @@ IndexedDatabaseManager::CommonPostHandle
   Event* internalEvent = aVisitor.mDOMEvent->InternalDOMEvent();
   MOZ_ASSERT(internalEvent);
 
   if (!internalEvent->IsTrusted()) {
     return NS_OK;
   }
 
   nsString type;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(internalEvent->GetType(type)));
+  MOZ_ALWAYS_SUCCEEDS(internalEvent->GetType(type));
 
   MOZ_ASSERT(nsDependentString(kErrorEventType).EqualsLiteral("error"));
   if (!type.EqualsLiteral("error")) {
     return NS_OK;
   }
 
   nsCOMPtr<EventTarget> eventTarget = internalEvent->GetTarget();
   MOZ_ASSERT(eventTarget);
@@ -1141,18 +1141,17 @@ DeleteFilesRunnable::DeleteFilesRunnable
 }
 
 void
 DeleteFilesRunnable::Dispatch()
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(mState == State_Initial);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL));
 }
 
 NS_IMPL_ISUPPORTS(DeleteFilesRunnable, nsIRunnable)
 
 NS_IMETHODIMP
 DeleteFilesRunnable::Run()
 {
   nsresult rv;
@@ -1307,18 +1306,17 @@ DeleteFilesRunnable::DoDatabaseWork()
 
 void
 DeleteFilesRunnable::Finish()
 {
   // Must set mState before dispatching otherwise we will race with the main
   // thread.
   mState = State_UnblockingOpen;
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL));
 }
 
 void
 DeleteFilesRunnable::UnblockOpen()
 {
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(mState == State_UnblockingOpen);
 
--- a/dom/indexedDB/PermissionRequestBase.cpp
+++ b/dom/indexedDB/PermissionRequestBase.cpp
@@ -224,17 +224,17 @@ PermissionRequestBase::Observe(nsISuppor
   nsCOMPtr<Element> element;
   element.swap(mOwnerElement);
 
   nsCOMPtr<nsIPrincipal> principal;
   mPrincipal.swap(principal);
 
   nsresult rv;
   uint32_t promptResult = nsDependentString(aData).ToInteger(&rv);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(rv);
 
   // The UI prompt code will only return one of these three values. We have to
   // transform it to our values.
   MOZ_ASSERT(promptResult == kPermissionDefault ||
              promptResult == kPermissionAllowed ||
              promptResult == kPermissionDenied);
 
   if (promptResult != kPermissionDefault) {
--- a/dom/indexedDB/ProfilerHelpers.h
+++ b/dom/indexedDB/ProfilerHelpers.h
@@ -260,17 +260,17 @@ public:
   LoggingString(nsIDOMEvent* aEvent, const char16_t* aDefault)
     : nsAutoCString(kQuote)
   {
     MOZ_ASSERT(aDefault);
 
     nsString eventType;
 
     if (aEvent) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aEvent->GetType(eventType)));
+      MOZ_ALWAYS_SUCCEEDS(aEvent->GetType(eventType));
     } else {
       eventType = nsDependentString(aDefault);
     }
 
     AppendUTF16toUTF8(eventType, *this);
     Append(kQuote);
   }
 };
--- a/dom/indexedDB/ScriptErrorHelper.cpp
+++ b/dom/indexedDB/ScriptErrorHelper.cpp
@@ -118,37 +118,37 @@ public:
       do_GetService(NS_CONSOLESERVICE_CONTRACTID);
     MOZ_ASSERT(consoleService);
 
     nsCOMPtr<nsIScriptError> scriptError =
       do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
     MOZ_ASSERT(scriptError);
 
     if (aInnerWindowID) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+      MOZ_ALWAYS_SUCCEEDS(
         scriptError->InitWithWindowID(aMessage,
                                       aFilename,
                                       /* aSourceLine */ EmptyString(),
                                       aLineNumber,
                                       aColumnNumber,
                                       aSeverityFlag,
                                       category,
-                                      aInnerWindowID)));
+                                      aInnerWindowID));
     } else {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+      MOZ_ALWAYS_SUCCEEDS(
         scriptError->Init(aMessage,
                           aFilename,
                           /* aSourceLine */ EmptyString(),
                           aLineNumber,
                           aColumnNumber,
                           aSeverityFlag,
-                          category.get())));
+                          category.get()));
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(consoleService->LogMessage(scriptError)));
+    MOZ_ALWAYS_SUCCEEDS(consoleService->LogMessage(scriptError));
   }
 
   NS_IMETHOD
   Run() override
   {
     MOZ_ASSERT(NS_IsMainThread());
     MOZ_ASSERT(mMessage.IsVoid() != mMessageName.IsVoid());
 
@@ -205,17 +205,17 @@ ScriptErrorHelper::Dump(const nsAString&
     RefPtr<ScriptErrorRunnable> runnable =
       new ScriptErrorRunnable(aMessage,
                               aFilename,
                               aLineNumber,
                               aColumnNumber,
                               aSeverityFlag,
                               aIsChrome,
                               aInnerWindowID);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
   }
 }
 
 /*static*/ void
 ScriptErrorHelper::DumpLocalizedMessage(const nsACString& aMessageName,
                                         const nsAString& aFilename,
                                         uint32_t aLineNumber,
                                         uint32_t aColumnNumber,
@@ -235,15 +235,15 @@ ScriptErrorHelper::DumpLocalizedMessage(
     RefPtr<ScriptErrorRunnable> runnable =
       new ScriptErrorRunnable(aMessageName,
                               aFilename,
                               aLineNumber,
                               aColumnNumber,
                               aSeverityFlag,
                               aIsChrome,
                               aInnerWindowID);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
   }
 }
 
 } // namespace indexedDB
 } // namespace dom
-} // namespace mozilla
\ No newline at end of file
+} // namespace mozilla
--- a/dom/ipc/Blob.cpp
+++ b/dom/ipc/Blob.cpp
@@ -201,17 +201,17 @@ ActorManagerIsSameProcess(PBackgroundPar
 bool
 EventTargetIsOnCurrentThread(nsIEventTarget* aEventTarget)
 {
   if (!aEventTarget) {
     return NS_IsMainThread();
   }
 
   bool current;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aEventTarget->IsOnCurrentThread(&current)));
+  MOZ_ALWAYS_SUCCEEDS(aEventTarget->IsOnCurrentThread(&current));
 
   return current;
 }
 
 class CancelableRunnableWrapper final
   : public nsCancelableRunnable
 {
   nsCOMPtr<nsIRunnable> mRunnable;
@@ -296,20 +296,20 @@ ReleaseOnTarget(SmartPtr<T>& aDoomed, ns
     NS_NewNonOwningRunnableMethod(doomedSupports, &nsISupports::Release);
   MOZ_ASSERT(releaseRunnable);
 
   if (aTarget) {
     // If we're targeting a non-main thread then make sure the runnable is
     // cancelable.
     releaseRunnable = new CancelableRunnableWrapper(releaseRunnable, aTarget);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aTarget->Dispatch(releaseRunnable,
-                                                   NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(aTarget->Dispatch(releaseRunnable,
+                                          NS_DISPATCH_NORMAL));
   } else {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(releaseRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(releaseRunnable));
   }
 }
 
 template <class ManagerType>
 void
 ConstructFileDescriptorSet(ManagerType* aManager,
                            nsTArray<FileDescriptor>& aFDs,
                            OptionalFileDescriptorSet& aOptionalFDSet)
@@ -806,17 +806,17 @@ CreateBlobImpl(const nsTArray<uint8_t>& 
     blobImpl =
       new EmptyBlobImpl(aMetadata.mName,
                         aMetadata.mContentType,
                         aMetadata.mLastModifiedDate);
   } else {
     blobImpl = new EmptyBlobImpl(aMetadata.mContentType);
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(blobImpl->SetMutable(false)));
+  MOZ_ALWAYS_SUCCEEDS(blobImpl->SetMutable(false));
 
   return blobImpl.forget();
 }
 
 already_AddRefed<BlobImpl>
 CreateBlobImpl(const nsTArray<BlobData>& aBlobData,
                CreateBlobImplMetadata& aMetadata);
 
@@ -909,17 +909,17 @@ CreateBlobImpl(const nsTArray<BlobData>&
   } else {
     blobImpl = MultipartBlobImpl::Create(blobImpls, aMetadata.mContentType, rv);
   }
 
   if (NS_WARN_IF(rv.Failed())) {
     return nullptr;
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(blobImpl->SetMutable(false)));
+  MOZ_ALWAYS_SUCCEEDS(blobImpl->SetMutable(false));
 
   return blobImpl.forget();
 }
 
 already_AddRefed<BlobImpl>
 CreateBlobImpl(const ParentBlobConstructorParams& aParams,
                const BlobData& aBlobData,
                bool aIsSameProcessActor)
@@ -1008,31 +1008,31 @@ BlobDataFromBlobImpl(BlobImpl* aBlobImpl
   aBlobImpl->GetInternalStream(getter_AddRefs(inputStream), rv);
   MOZ_ALWAYS_TRUE(!rv.Failed());
 
   DebugOnly<bool> isNonBlocking;
   MOZ_ASSERT(NS_SUCCEEDED(inputStream->IsNonBlocking(&isNonBlocking)));
   MOZ_ASSERT(isNonBlocking);
 
   uint64_t available;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(inputStream->Available(&available)));
+  MOZ_ALWAYS_SUCCEEDS(inputStream->Available(&available));
 
   MOZ_ASSERT(available <= uint64_t(UINT32_MAX));
 
   aBlobData = nsTArray<uint8_t>();
 
   nsTArray<uint8_t>& blobData = aBlobData.get_ArrayOfuint8_t();
 
   blobData.SetLength(size_t(available));
 
   uint32_t readCount;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+  MOZ_ALWAYS_SUCCEEDS(
     inputStream->Read(reinterpret_cast<char*>(blobData.Elements()),
                       uint32_t(available),
-                      &readCount)));
+                      &readCount));
 }
 
 RemoteInputStream::RemoteInputStream(BlobImpl* aBlobImpl,
                                      uint64_t aStart,
                                      uint64_t aLength)
   : mMonitor("RemoteInputStream.mMonitor")
   , mActor(nullptr)
   , mBlobImpl(aBlobImpl)
@@ -1626,17 +1626,17 @@ private:
     if (NS_FAILED(mStream->Available(&available))) {
       NS_WARNING("Available failed on this stream!");
     }
 
     if (mActorTarget) {
       nsresult rv = mActorTarget->Dispatch(this, NS_DISPATCH_NORMAL);
       NS_ENSURE_SUCCESS(rv, rv);
     } else {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(this)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
     }
 
     return NS_OK;
   }
 
   nsresult
   CloseStream()
   {
@@ -1651,17 +1651,17 @@ private:
     mIOTarget.swap(ioTarget);
 
     NS_WARN_IF_FALSE(NS_SUCCEEDED(stream->Close()), "Failed to close stream!");
 
     nsCOMPtr<nsIRunnable> shutdownRunnable =
       NS_NewRunnableMethod(ioTarget, &nsIThread::Shutdown);
     MOZ_ASSERT(shutdownRunnable);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(shutdownRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(shutdownRunnable));
 
     return NS_OK;
   }
 
   nsresult
   SendResponse()
   {
     AssertIsOnOwningThread();
@@ -2191,20 +2191,20 @@ RemoteBlobImpl::Destroy()
 
   nsCOMPtr<nsIRunnable> destroyRunnable =
     NS_NewNonOwningRunnableMethod(this, &RemoteBlobImpl::Destroy);
 
   if (mActorTarget) {
     destroyRunnable =
       new CancelableRunnableWrapper(destroyRunnable, mActorTarget);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mActorTarget->Dispatch(destroyRunnable,
-                                                        NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mActorTarget->Dispatch(destroyRunnable,
+                                               NS_DISPATCH_NORMAL));
   } else {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(destroyRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(destroyRunnable));
   }
 }
 
 NS_IMPL_ADDREF(BlobChild::RemoteBlobImpl)
 NS_IMPL_RELEASE_WITH_DESTROY(BlobChild::RemoteBlobImpl, Destroy())
 NS_IMPL_QUERY_INTERFACE_INHERITED(BlobChild::RemoteBlobImpl,
                                   BlobImpl,
                                   nsIRemoteBlob)
@@ -2539,17 +2539,17 @@ RemoteBlobSliceImpl::EnsureActorWasCreat
 
   mActorWasCreated = true;
 
   BlobChild* baseActor = mParent->GetActor();
   MOZ_ASSERT(baseActor);
   MOZ_ASSERT(baseActor->HasManager());
 
   nsID id;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(gUUIDGenerator->GenerateUUIDInPlace(&id)));
+  MOZ_ALWAYS_SUCCEEDS(gUUIDGenerator->GenerateUUIDInPlace(&id));
 
   ParentBlobConstructorParams params(
     SlicedBlobConstructorParams(nullptr /* sourceParent */,
                                 baseActor /* sourceChild */,
                                 id /* id */,
                                 mStart /* begin */,
                                 mStart + mLength /* end */,
                                 mContentType /* contentType */));
@@ -2619,20 +2619,20 @@ RemoteBlobImpl::Destroy()
 
   nsCOMPtr<nsIRunnable> destroyRunnable =
     NS_NewNonOwningRunnableMethod(this, &RemoteBlobImpl::Destroy);
 
   if (mActorTarget) {
     destroyRunnable =
       new CancelableRunnableWrapper(destroyRunnable, mActorTarget);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mActorTarget->Dispatch(destroyRunnable,
-                                                        NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mActorTarget->Dispatch(destroyRunnable,
+                                               NS_DISPATCH_NORMAL));
   } else {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(destroyRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(destroyRunnable));
   }
 }
 
 NS_IMPL_ADDREF(BlobParent::RemoteBlobImpl)
 NS_IMPL_RELEASE_WITH_DESTROY(BlobParent::RemoteBlobImpl, Destroy())
 NS_IMPL_QUERY_INTERFACE_INHERITED(BlobParent::RemoteBlobImpl,
                                   BlobImpl,
                                   nsIRemoteBlob)
@@ -3474,20 +3474,20 @@ BlobChild::NoteDyingRemoteBlobImpl()
   // on the owning thread, so we proxy here if necessary.
   if (!IsOnOwningThread()) {
     nsCOMPtr<nsIRunnable> runnable =
       NS_NewNonOwningRunnableMethod(this, &BlobChild::NoteDyingRemoteBlobImpl);
 
     if (mEventTarget) {
       runnable = new CancelableRunnableWrapper(runnable, mEventTarget);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mEventTarget->Dispatch(runnable,
-                                                          NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(mEventTarget->Dispatch(runnable,
+                                                 NS_DISPATCH_NORMAL));
     } else {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
     }
 
     return;
   }
 
   // Must do this before calling Send__delete__ or we'll crash there trying to
   // access a dangling pointer.
   mBlobImpl = nullptr;
@@ -3805,17 +3805,17 @@ BlobParent::GetOrCreateFromImpl(ParentMa
                                     void_t());
       } else {
         blobParams = NormalBlobConstructorParams(contentType, length, void_t());
       }
     }
   }
 
   nsID id;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(gUUIDGenerator->GenerateUUIDInPlace(&id)));
+  MOZ_ALWAYS_SUCCEEDS(gUUIDGenerator->GenerateUUIDInPlace(&id));
 
   RefPtr<IDTableEntry> idTableEntry =
     IDTableEntry::GetOrCreate(id, ActorManagerProcessID(aManager), aBlobImpl);
   MOZ_ASSERT(idTableEntry);
 
   BlobParent* actor = new BlobParent(aManager, idTableEntry);
 
   ChildBlobConstructorParams params(id, blobParams);
@@ -3861,17 +3861,17 @@ BlobParent::CreateFromParams(ParentManag
                        optionalBlobData.get_BlobData(),
                        ActorManagerIsSameProcess(aManager));
       if (NS_WARN_IF(!blobImpl)) {
         ASSERT_UNLESS_FUZZING();
         return nullptr;
       }
 
       nsID id;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(gUUIDGenerator->GenerateUUIDInPlace(&id)));
+      MOZ_ALWAYS_SUCCEEDS(gUUIDGenerator->GenerateUUIDInPlace(&id));
 
       RefPtr<IDTableEntry> idTableEntry =
         IDTableEntry::Create(id, ActorManagerProcessID(aManager), blobImpl);
       if (NS_WARN_IF(!idTableEntry)) {
         ASSERT_UNLESS_FUZZING();
         return nullptr;
       }
 
@@ -3901,17 +3901,17 @@ BlobParent::CreateFromParams(ParentManag
                             params.end() - params.begin(),
                             params.contentType(),
                             rv);
       if (NS_WARN_IF(rv.Failed())) {
         ASSERT_UNLESS_FUZZING();
         return nullptr;
       }
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(slice->SetMutable(false)));
+      MOZ_ALWAYS_SUCCEEDS(slice->SetMutable(false));
 
       RefPtr<IDTableEntry> idTableEntry =
         IDTableEntry::Create(params.id(),
                              ActorManagerProcessID(aManager),
                              slice);
       if (NS_WARN_IF(!idTableEntry)) {
         ASSERT_UNLESS_FUZZING();
         return nullptr;
@@ -3943,17 +3943,17 @@ BlobParent::CreateFromParams(ParentManag
       const SameProcessBlobConstructorParams& params =
         blobParams.get_SameProcessBlobConstructorParams();
 
       RefPtr<BlobImpl> blobImpl =
         dont_AddRef(reinterpret_cast<BlobImpl*>(params.addRefedBlobImpl()));
       MOZ_ASSERT(blobImpl);
 
       nsID id;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(gUUIDGenerator->GenerateUUIDInPlace(&id)));
+      MOZ_ALWAYS_SUCCEEDS(gUUIDGenerator->GenerateUUIDInPlace(&id));
 
       RefPtr<IDTableEntry> idTableEntry =
         IDTableEntry::Create(id, ActorManagerProcessID(aManager), blobImpl);
       MOZ_ASSERT(idTableEntry);
 
       return new BlobParent(aManager, blobImpl, idTableEntry);
     }
 
@@ -4053,20 +4053,20 @@ BlobParent::NoteDyingRemoteBlobImpl()
   // on the main thread, so we proxy here if necessary.
   if (!IsOnOwningThread()) {
     nsCOMPtr<nsIRunnable> runnable =
       NS_NewNonOwningRunnableMethod(this, &BlobParent::NoteDyingRemoteBlobImpl);
 
     if (mEventTarget) {
       runnable = new CancelableRunnableWrapper(runnable, mEventTarget);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mEventTarget->Dispatch(runnable,
-                                                          NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(mEventTarget->Dispatch(runnable,
+                                                 NS_DISPATCH_NORMAL));
     } else {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
     }
 
     return;
   }
 
   // Must do this before calling Send__delete__ or we'll crash there trying to
   // access a dangling pointer.
   mBlobImpl = nullptr;
--- a/dom/ipc/NuwaChild.cpp
+++ b/dom/ipc/NuwaChild.cpp
@@ -130,17 +130,17 @@ NuwaChild::RecvFork()
         "Terminating child process %d for unauthorized IPC message: "
           "RecvFork(%d)", getpid()).get());
     return false;
   }
 
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewRunnableFunction(&NuwaFork);
   MOZ_ASSERT(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
   return true;
 #else
   NS_ERROR("NuwaChild::RecvFork() not implemented!");
   return false;
 #endif
 }
 
--- a/dom/ipc/NuwaParent.cpp
+++ b/dom/ipc/NuwaParent.cpp
@@ -96,18 +96,17 @@ NuwaParent::CloneProtocol(Channel* aChan
   {
     MonitorAutoLock lock(self->mMonitor);
     // XXX Calling NuwaParent::Alloc() leads to a compilation error. Use
     // self->Alloc() as a workaround.
     self->mClonedActor = self->Alloc();
     lock.Notify();
   });
   MOZ_ASSERT(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mWorkerThread->Dispatch(runnable,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mWorkerThread->Dispatch(runnable, NS_DISPATCH_NORMAL));
 
   while (!mClonedActor) {
     lock.Wait();
   }
   RefPtr<NuwaParent> actor = mClonedActor;
   mClonedActor = nullptr;
 
   // mManager of the cloned actor is assigned after returning from this method.
@@ -123,22 +122,21 @@ NuwaParent::CloneProtocol(Channel* aChan
 
       // Call NuwaParent::ActorConstructed() on the worker thread.
       actor->ActorConstructed();
 
       // The actor can finally be deleted after fully constructed.
       mozilla::Unused << actor->Send__delete__(actor);
     });
     MOZ_ASSERT(nested);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      actor->mWorkerThread->Dispatch(nested, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(actor->mWorkerThread->Dispatch(nested, NS_DISPATCH_NORMAL));
   });
 
   MOZ_ASSERT(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
   return actor;
 }
 
 void
 NuwaParent::ActorDestroy(ActorDestroyReason aWhy)
 {
   AssertIsOnWorkerThread();
@@ -150,17 +148,17 @@ NuwaParent::ActorDestroy(ActorDestroyRea
     // deletion in breaking the ref cycle.
     RefPtr<ContentParent> contentParent = self->mContentParent;
 
     contentParent->SetNuwaParent(nullptr);
     // Need to clear the ref to ContentParent on the main thread.
     self->mContentParent = nullptr;
   });
   MOZ_ASSERT(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 }
 
 bool
 NuwaParent::RecvNotifyReady()
 {
 #ifdef MOZ_NUWA_PROCESS
   if (!mContentParent || !mContentParent->IsNuwaProcess()) {
     NS_ERROR("Received NotifyReady() message from a non-Nuwa process.");
@@ -169,17 +167,17 @@ NuwaParent::RecvNotifyReady()
 
   // Creating a NonOwningRunnableMethod here is safe because refcount changes of
   // mContentParent have to go the the main thread. The mContentParent will
   // be alive when the runnable runs.
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewNonOwningRunnableMethod(mContentParent.get(),
                                   &ContentParent::OnNuwaReady);
   MOZ_ASSERT(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
   return true;
 #else
   NS_ERROR("NuwaParent::RecvNotifyReady() not implemented!");
   return false;
 #endif
 }
 
@@ -205,17 +203,17 @@ NuwaParent::RecvAddNewProcess(const uint
       NS_NewNonOwningRunnableMethodWithArgs<
         uint32_t,
         UniquePtr<nsTArray<ProtocolFdMapping>>&& >(
           mContentParent.get(),
           &ContentParent::OnNewProcessCreated,
           mNewProcessPid,
           Move(mNewProcessFds));
     MOZ_ASSERT(runnable);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
   }
   return true;
 #else
   NS_ERROR("NuwaParent::RecvAddNewProcess() not implemented!");
   return false;
 #endif
 }
 
@@ -230,18 +228,17 @@ NuwaParent::ForkNewProcess(uint32_t& aPi
   mNewProcessFds = Move(aFds);
 
   RefPtr<NuwaParent> self = this;
   nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction([self] () -> void
   {
     mozilla::Unused << self->SendFork();
   });
   MOZ_ASSERT(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mWorkerThread->Dispatch(runnable,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mWorkerThread->Dispatch(runnable, NS_DISPATCH_NORMAL));
   if (!aBlocking) {
     return false;
   }
 
   MonitorAutoLock lock(mMonitor);
   mBlocked = true;
   while (mBlocked) {
     // This will be notified in NuwaParent::RecvAddNewProcess().
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -2408,17 +2408,17 @@ TabChild::RecvDestroy()
   }
 
   // XXX what other code in ~TabChild() should we be running here?
   DestroyWindow();
 
   // Bounce through the event loop once to allow any delayed teardown runnables
   // that were just generated to have a chance to run.
   nsCOMPtr<nsIRunnable> deleteRunnable = new DelayedDeleteRunnable(this);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(deleteRunnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(deleteRunnable));
 
   return true;
 }
 
 bool
 TabChild::RecvSetUpdateHitRegion(const bool& aEnabled)
 {
     mUpdateHitRegion = aEnabled;
--- a/dom/media/MediaResource.cpp
+++ b/dom/media/MediaResource.cpp
@@ -53,17 +53,17 @@ MediaResource::Destroy()
 {
   // Ensures we only delete the MediaResource on the main thread.
   if (NS_IsMainThread()) {
     delete this;
     return;
   }
   nsCOMPtr<nsIRunnable> destroyRunnable =
     NS_NewNonOwningRunnableMethod(this, &MediaResource::Destroy);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(destroyRunnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(destroyRunnable));
 }
 
 NS_IMPL_ADDREF(MediaResource)
 NS_IMPL_RELEASE_WITH_DESTROY(MediaResource, Destroy())
 NS_IMPL_QUERY_INTERFACE0(MediaResource)
 
 ChannelMediaResource::ChannelMediaResource(MediaResourceCallback* aCallback,
                                            nsIChannel* aChannel,
--- a/dom/media/gmp/GMPService.cpp
+++ b/dom/media/gmp/GMPService.cpp
@@ -297,17 +297,17 @@ GeckoMediaPluginService::RunPluginCrashC
 
 nsresult
 GeckoMediaPluginService::Init()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsCOMPtr<nsIObserverService> obsService = mozilla::services::GetObserverService();
   MOZ_ASSERT(obsService);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(obsService->AddObserver(this, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID, false)));
+  MOZ_ALWAYS_SUCCEEDS(obsService->AddObserver(this, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID, false));
 
   // Kick off scanning for plugins
   nsCOMPtr<nsIThread> thread;
   return GetThread(getter_AddRefs(thread));
 }
 
 void
 GeckoMediaPluginService::ShutdownGMPThread()
--- a/dom/media/gmp/GMPServiceParent.cpp
+++ b/dom/media/gmp/GMPServiceParent.cpp
@@ -118,22 +118,22 @@ GeckoMediaPluginServiceParent::AsyncShut
 
 nsresult
 GeckoMediaPluginServiceParent::Init()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsCOMPtr<nsIObserverService> obsService = mozilla::services::GetObserverService();
   MOZ_ASSERT(obsService);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(obsService->AddObserver(this, "profile-change-teardown", false)));
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(obsService->AddObserver(this, "last-pb-context-exited", false)));
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(obsService->AddObserver(this, "browser:purge-session-history", false)));
+  MOZ_ALWAYS_SUCCEEDS(obsService->AddObserver(this, "profile-change-teardown", false));
+  MOZ_ALWAYS_SUCCEEDS(obsService->AddObserver(this, "last-pb-context-exited", false));
+  MOZ_ALWAYS_SUCCEEDS(obsService->AddObserver(this, "browser:purge-session-history", false));
 
 #ifdef DEBUG
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(obsService->AddObserver(this, "mediakeys-request", false)));
+  MOZ_ALWAYS_SUCCEEDS(obsService->AddObserver(this, "mediakeys-request", false));
 #endif
 
   nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
   if (prefs) {
     prefs->AddObserver("media.gmp.plugin.crash", this, false);
   }
 
   nsresult rv = InitStorage();
--- a/dom/messagechannel/MessagePort.cpp
+++ b/dom/messagechannel/MessagePort.cpp
@@ -563,17 +563,17 @@ MessagePort::Dispatch()
       break;
   }
 
   RefPtr<SharedMessagePortMessage> data = mMessages.ElementAt(0);
   mMessages.RemoveElementAt(0);
 
   mPostMessageRunnable = new PostMessageRunnable(this, data);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(mPostMessageRunnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(mPostMessageRunnable));
 }
 
 void
 MessagePort::Close()
 {
   CloseInternal(true /* aSoftly */);
 }
 
--- a/dom/notification/Notification.cpp
+++ b/dom/notification/Notification.cpp
@@ -2240,17 +2240,17 @@ Notification::WorkerGet(WorkerPrivate* a
     aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
     return nullptr;
   }
 
   RefPtr<WorkerGetRunnable> r =
     new WorkerGetRunnable(proxy, aFilter.mTag, aScope);
   // Since this is called from script via
   // ServiceWorkerRegistration::GetNotifications, we can assert dispatch.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
   return p.forget();
 }
 
 JSObject*
 Notification::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
   return mozilla::dom::NotificationBinding::Wrap(aCx, this, aGivenProto);
 }
--- a/dom/push/PushManager.cpp
+++ b/dom/push/PushManager.cpp
@@ -526,17 +526,17 @@ WorkerPushSubscription::Unsubscribe(Erro
   RefPtr<PromiseWorkerProxy> proxy = PromiseWorkerProxy::Create(worker, p);
   if (!proxy) {
     p->MaybeReject(NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE);
     return p.forget();
   }
 
   RefPtr<UnsubscribeRunnable> r =
     new UnsubscribeRunnable(proxy, mScope);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 
   return p.forget();
 }
 
 void
 WorkerPushSubscription::ToJSON(PushSubscriptionJSON& aJSON)
 {
   SubscriptionToJSON(aJSON, mEndpoint, mRawP256dhKey, mAuthSecret);
@@ -823,17 +823,17 @@ WorkerPushManager::PerformSubscriptionAc
   RefPtr<PromiseWorkerProxy> proxy = PromiseWorkerProxy::Create(worker, p);
   if (!proxy) {
     p->MaybeReject(NS_ERROR_DOM_PUSH_ABORT_ERR);
     return p.forget();
   }
 
   RefPtr<GetSubscriptionRunnable> r =
     new GetSubscriptionRunnable(proxy, mScope, aAction);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 
   return p.forget();
 }
 
 already_AddRefed<Promise>
 WorkerPushManager::Subscribe(ErrorResult& aRv)
 {
   return PerformSubscriptionAction(SubscribeAction, aRv);
--- a/dom/quota/ActorsParent.cpp
+++ b/dom/quota/ActorsParent.cpp
@@ -840,17 +840,17 @@ protected:
   const bool mExclusive;
 
 public:
   void
   RunImmediately()
   {
     MOZ_ASSERT(GetState() == State_Initial);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(this->Run()));
+    MOZ_ALWAYS_SUCCEEDS(this->Run());
   }
 
 protected:
   NormalOriginOperationBase(Nullable<PersistenceType> aPersistenceType,
                             const OriginScope& aOriginScope,
                             bool aExclusive)
     : mPersistenceType(aPersistenceType)
     , mOriginScope(aOriginScope)
@@ -2276,17 +2276,17 @@ CreateRunnable::Run()
 
     mState = State::CallingCallbacks;
     thread = mOwningThread;
   } else {
     mState = GetNextState(thread);
   }
 
   if (thread) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->Dispatch(this, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(thread->Dispatch(this, NS_DISPATCH_NORMAL));
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 QuotaManager::
 ShutdownRunnable::Run()
@@ -2306,17 +2306,17 @@ ShutdownRunnable::Run()
 
   RefPtr<QuotaManager> quotaManager = gInstance.get();
   if (quotaManager) {
     quotaManager->Shutdown();
 
     gInstance = nullptr;
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(this)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
 
   return NS_OK;
 }
 
 NS_IMPL_ISUPPORTS(QuotaManager::ShutdownObserver, nsIObserver)
 
 NS_IMETHODIMP
 QuotaManager::
@@ -2325,18 +2325,18 @@ ShutdownObserver::Observe(nsISupports* a
                           const char16_t* aData)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!strcmp(aTopic, PROFILE_BEFORE_CHANGE_OBSERVER_ID));
 
   bool done = false;
 
   RefPtr<ShutdownRunnable> shutdownRunnable = new ShutdownRunnable(done);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mBackgroundThread->Dispatch(shutdownRunnable, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mBackgroundThread->Dispatch(shutdownRunnable, NS_DISPATCH_NORMAL));
 
   nsIThread* currentThread = NS_GetCurrentThread();
   MOZ_ASSERT(currentThread);
 
   while (!done) {
     MOZ_ALWAYS_TRUE(NS_ProcessNextEvent(currentThread));
   }
 
@@ -2636,21 +2636,21 @@ QuotaManager::GetOrCreate(nsIRunnable* a
     MOZ_ASSERT(false, "Calling GetOrCreate() after shutdown!");
     return;
   }
 
   if (gInstance || gCreateFailed) {
     MOZ_ASSERT(!gCreateRunnable);
     MOZ_ASSERT_IF(gCreateFailed, !gInstance);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(aCallback)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(aCallback));
   } else {
     if (!gCreateRunnable) {
       gCreateRunnable = new CreateRunnable();
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(gCreateRunnable)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(gCreateRunnable));
     }
 
     gCreateRunnable->AddCallback(aCallback);
   }
 }
 
 // static
 QuotaManager*
@@ -3062,21 +3062,21 @@ QuotaManager::Shutdown()
   // further storagess from being created.
   if (gShutdown.exchange(true)) {
     NS_ERROR("Shutdown more than once?!");
   }
 
   StopIdleMaintenance();
 
   // Kick off the shutdown timer.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+  MOZ_ALWAYS_SUCCEEDS(
     mShutdownTimer->InitWithFuncCallback(&ShutdownTimerCallback,
                                          this,
                                          DEFAULT_SHUTDOWN_TIMER_MS,
-                                         nsITimer::TYPE_ONE_SHOT)));
+                                         nsITimer::TYPE_ONE_SHOT));
 
   // Each client will spin the event loop while we wait on all the threads
   // to close. Our timer may fire during that loop.
   for (uint32_t index = 0; index < Client::TYPE_MAX; index++) {
     mClients[index]->ShutdownWorkThreads();
   }
 
   // Cancel the timer regardless of whether it actually fired.
@@ -4331,18 +4331,17 @@ QuotaManager::LockedCollectOriginsForEvi
 
   // Unlock while calling out to XPCOM (code behind the dispatch method needs
   // to acquire its own lock which can potentially lead to a deadlock and it
   // also calls an observer that can do various stuff like IO, so it's better
   // to not hold our mutex while that happens).
   {
     MutexAutoUnlock autoUnlock(mQuotaMutex);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(helper,
-                                                         NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(helper, NS_DISPATCH_NORMAL));
   }
 
   return helper->BlockAndReturnOriginsForEviction(aLocks);
 }
 
 void
 QuotaManager::LockedRemoveQuotaForOrigin(PersistenceType aPersistenceType,
                                          const nsACString& aGroup,
@@ -4876,33 +4875,32 @@ OriginOperationBase::Finish(nsresult aRe
   if (NS_SUCCEEDED(mResultCode)) {
     mResultCode = aResult;
   }
 
   // Must set mState before dispatching otherwise we will race with the main
   // thread.
   mState = State_UnblockingOpen;
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 }
 
 nsresult
 OriginOperationBase::Init()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mState == State_Initial);
 
   AdvanceState();
 
   if (mNeedsMainThreadInit) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(this)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
   } else {
     AdvanceState();
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Run()));
+    MOZ_ALWAYS_SUCCEEDS(Run());
   }
 
   return NS_OK;
 }
 
 nsresult
 OriginOperationBase::InitOnMainThread()
 {
@@ -4911,18 +4909,17 @@ OriginOperationBase::InitOnMainThread()
 
   nsresult rv = DoInitOnMainThread();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   AdvanceState();
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 
   return NS_OK;
 }
 
 nsresult
 OriginOperationBase::FinishInit()
 {
   AssertIsOnOwningThread();
@@ -4973,43 +4970,41 @@ OriginOperationBase::DirectoryWork()
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // Must set mState before dispatching otherwise we will race with the owning
   // thread.
   AdvanceState();
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 
   return NS_OK;
 }
 
 void
 FinalizeOriginEvictionOp::Dispatch()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   MOZ_ASSERT(GetState() == State_Initial);
 
   SetState(State_DirectoryOpenPending);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mOwningThread->Dispatch(this,
-                                                       NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
 }
 
 void
 FinalizeOriginEvictionOp::RunOnIOThreadImmediately()
 {
   AssertIsOnIOThread();
   MOZ_ASSERT(GetState() == State_Initial);
 
   SetState(State_DirectoryWorkOpen);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(this->Run()));
+  MOZ_ALWAYS_SUCCEEDS(this->Run());
 }
 
 void
 FinalizeOriginEvictionOp::Open()
 {
   MOZ_CRASH("Shouldn't get here!");
 }
 
@@ -6041,17 +6036,17 @@ StorageDirectoryHelper::AddOriginDirecto
 }
 
 nsresult
 StorageDirectoryHelper::ProcessOriginDirectories(bool aMove)
 {
   AssertIsOnIOThread();
   MOZ_ASSERT(!mOriginProps.IsEmpty());
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(this)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
 
   {
     mozilla::MutexAutoLock autolock(mMutex);
     while (mWaiting) {
       mCondVar.Wait();
     }
   }
 
--- a/dom/quota/QuotaManagerService.cpp
+++ b/dom/quota/QuotaManagerService.cpp
@@ -274,18 +274,18 @@ QuotaManagerService::AbortOperationsForP
 
   if (!mBackgroundThread) {
     return;
   }
 
   RefPtr<AbortOperationsRunnable> runnable =
     new AbortOperationsRunnable(aContentParentId);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    mBackgroundThread->Dispatch(runnable, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(
+    mBackgroundThread->Dispatch(runnable, NS_DISPATCH_NORMAL));
 }
 
 nsresult
 QuotaManagerService::Init()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (XRE_IsParentProcess()) {
@@ -458,36 +458,36 @@ QuotaManagerService::PerformIdleMaintena
   if (QuotaManager::kRunningXPCShellTests) {
     // We don't want user activity to impact this code if we're running tests.
     Unused << Observe(nullptr, OBSERVER_TOPIC_IDLE, nullptr);
   } else if (!mIdleObserverRegistered) {
     nsCOMPtr<nsIIdleService> idleService =
       do_GetService(kIdleServiceContractId);
     MOZ_ASSERT(idleService);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      idleService->AddIdleObserver(this, kIdleObserverTimeSec)));
+    MOZ_ALWAYS_SUCCEEDS(
+      idleService->AddIdleObserver(this, kIdleObserverTimeSec));
 
     mIdleObserverRegistered = true;
   }
 }
 
 void
 QuotaManagerService::RemoveIdleObserver()
 {
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(NS_IsMainThread());
 
   if (mIdleObserverRegistered) {
     nsCOMPtr<nsIIdleService> idleService =
       do_GetService(kIdleServiceContractId);
     MOZ_ASSERT(idleService);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      idleService->RemoveIdleObserver(this, kIdleObserverTimeSec)));
+    MOZ_ALWAYS_SUCCEEDS(
+      idleService->RemoveIdleObserver(this, kIdleObserverTimeSec));
 
     mIdleObserverRegistered = false;
   }
 }
 
 NS_IMPL_ADDREF(QuotaManagerService)
 NS_IMPL_RELEASE_WITH_DESTROY(QuotaManagerService, Destroy())
 NS_IMPL_QUERY_INTERFACE(QuotaManagerService,
--- a/dom/workers/RuntimeService.cpp
+++ b/dom/workers/RuntimeService.cpp
@@ -1772,21 +1772,21 @@ RuntimeService::ShutdownIdleThreads(nsIT
     }
   }
 
   if (!nextExpiration.IsNull()) {
     TimeDuration delta = nextExpiration - TimeStamp::NowLoRes();
     uint32_t delay(delta > TimeDuration(0) ? delta.ToMilliseconds() : 0);
 
     // Reschedule the timer.
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       aTimer->InitWithFuncCallback(ShutdownIdleThreads,
                                    nullptr,
                                    delay,
-                                   nsITimer::TYPE_ONE_SHOT)));
+                                   nsITimer::TYPE_ONE_SHOT));
   }
 
   for (uint32_t index = 0; index < expiredThreads.Length(); index++) {
     if (NS_FAILED(expiredThreads[index]->Shutdown())) {
       NS_WARNING("Failed to shutdown thread!");
     }
   }
 }
@@ -2381,23 +2381,23 @@ RuntimeService::NoteIdleThread(WorkerThr
     }
   }
 
   MOZ_ASSERT_IF(shutdownThread, !scheduleTimer);
   MOZ_ASSERT_IF(scheduleTimer, !shutdownThread);
 
   // Too many idle threads, just shut this one down.
   if (shutdownThread) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aThread->Shutdown()));
+    MOZ_ALWAYS_SUCCEEDS(aThread->Shutdown());
   } else if (scheduleTimer) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+    MOZ_ALWAYS_SUCCEEDS(
       mIdleThreadTimer->InitWithFuncCallback(ShutdownIdleThreads,
                                              nullptr,
                                              IDLE_THREAD_TIMEOUT_SEC * 1000,
-                                             nsITimer::TYPE_ONE_SHOT)));
+                                             nsITimer::TYPE_ONE_SHOT));
   }
 }
 
 void
 RuntimeService::UpdateAllWorkerRuntimeOptions()
 {
   BROADCAST_ALL_WORKERS(UpdateRuntimeOptions, sDefaultJSSettings.runtimeOptions);
 }
@@ -2725,18 +2725,18 @@ WorkerThreadPrimaryRunnable::Run()
   mWorkerPrivate = nullptr;
 
   // Now recycle this thread.
   nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
   MOZ_ASSERT(mainThread);
 
   RefPtr<FinishedRunnable> finishedRunnable =
     new FinishedRunnable(mThread.forget());
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mainThread->Dispatch(finishedRunnable,
-                                                    NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mainThread->Dispatch(finishedRunnable,
+                                           NS_DISPATCH_NORMAL));
 
   profiler_unregister_thread();
   return NS_OK;
 }
 
 nsresult
 WorkerThreadPrimaryRunnable::SynchronouslyCreatePBackground()
 {
@@ -2776,13 +2776,13 @@ WorkerThreadPrimaryRunnable::FinishedRun
   RefPtr<WorkerThread> thread;
   mThread.swap(thread);
 
   RuntimeService* rts = RuntimeService::GetService();
   if (rts) {
     rts->NoteIdleThread(thread);
   }
   else if (thread->ShutdownRequired()) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->Shutdown()));
+    MOZ_ALWAYS_SUCCEEDS(thread->Shutdown());
   }
 
   return NS_OK;
 }
--- a/dom/workers/ScriptLoader.cpp
+++ b/dom/workers/ScriptLoader.cpp
@@ -714,17 +714,17 @@ private:
 
     if (aStatus >= Terminating && !mCanceled) {
       mCanceled = true;
 
       nsCOMPtr<nsIRunnable> runnable =
         NS_NewRunnableMethod(this,
           &ScriptLoaderRunnable::CancelMainThreadWithBindingAborted);
       NS_ASSERTION(runnable, "This should never fail!");
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
     }
 
     return true;
   }
 
   bool
   IsMainWorkerScript() const
   {
@@ -1429,17 +1429,17 @@ void
 CacheCreator::ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue)
 {
   AssertIsOnMainThread();
   MOZ_ASSERT(aValue.isObject());
 
   JS::Rooted<JSObject*> obj(aCx, &aValue.toObject());
   Cache* cache = nullptr;
   nsresult rv = UNWRAP_OBJECT(Cache, obj, cache);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(rv);
 
   mCache = cache;
   MOZ_ASSERT(mCache);
 
   // If the worker is canceled, CancelMainThread() will have cleared the
   // loaders.
   for (uint32_t i = 0, len = mLoaders.Length(); i < len; ++i) {
     mLoaders[i]->Load(cache);
--- a/dom/workers/ServiceWorkerClients.cpp
+++ b/dom/workers/ServiceWorkerClients.cpp
@@ -665,17 +665,17 @@ ServiceWorkerClients::Get(const nsAStrin
     PromiseWorkerProxy::Create(workerPrivate, promise);
   if (!promiseProxy) {
     promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR);
     return promise.forget();
   }
 
   RefPtr<GetRunnable> r =
     new GetRunnable(promiseProxy, aClientId);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 ServiceWorkerClients::MatchAll(const ClientQueryOptions& aOptions,
                                ErrorResult& aRv)
 {
   WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
@@ -701,17 +701,17 @@ ServiceWorkerClients::MatchAll(const Cli
     promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR);
     return promise.forget();
   }
 
   RefPtr<MatchAllRunnable> r =
     new MatchAllRunnable(promiseProxy,
                          NS_ConvertUTF16toUTF8(scope),
                          aOptions.mIncludeUncontrolled);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 ServiceWorkerClients::OpenWindow(const nsAString& aUrl,
                                  ErrorResult& aRv)
 {
   WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
@@ -742,17 +742,17 @@ ServiceWorkerClients::OpenWindow(const n
     return nullptr;
   }
 
   nsString scope;
   mWorkerScope->GetScope(scope);
 
   RefPtr<OpenWindowRunnable> r = new OpenWindowRunnable(promiseProxy,
                                                           aUrl, scope);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 ServiceWorkerClients::Claim(ErrorResult& aRv)
 {
   WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
@@ -771,11 +771,11 @@ ServiceWorkerClients::Claim(ErrorResult&
   }
 
   nsString scope;
   mWorkerScope->GetScope(scope);
 
   RefPtr<ClaimRunnable> runnable =
     new ClaimRunnable(promiseProxy, NS_ConvertUTF16toUTF8(scope));
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
   return promise.forget();
 }
--- a/dom/workers/ServiceWorkerEvents.cpp
+++ b/dom/workers/ServiceWorkerEvents.cpp
@@ -381,17 +381,17 @@ void RespondWithCopyComplete(void* aClos
                                       NS_ERROR_INTERCEPTION_FAILED);
   } else {
     event = new FinishResponse(data->mInterceptedChannel,
                                data->mInternalResponse,
                                data->mWorkerChannelInfo,
                                data->mScriptSpec,
                                data->mResponseURLSpec);
   }
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(event)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(event));
 }
 
 namespace {
 
 void
 ExtractErrorValues(JSContext* aCx, JS::Handle<JS::Value> aValue,
                   nsACString& aSourceSpecOut, uint32_t *aLineOut,
                   uint32_t *aColumnOut, nsString& aMessageOut)
@@ -836,18 +836,17 @@ public:
     if (!spec.IsEmpty()) {
       mSourceSpec = spec;
       mLine = line;
       mColumn = column;
     }
 
     nsCOMPtr<nsIRunnable> runnable =
       NS_NewRunnableMethod(this, &WaitUntilHandler::ReportOnMainThread);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      NS_DispatchToMainThread(runnable.forget())));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable.forget()));
   }
 
   void
   ReportOnMainThread()
   {
     AssertIsOnMainThread();
     RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
 
--- a/dom/workers/ServiceWorkerManager.cpp
+++ b/dom/workers/ServiceWorkerManager.cpp
@@ -1124,17 +1124,17 @@ public:
   }
 
   void
   Start()
   {
     AssertIsOnMainThread();
     nsCOMPtr<nsIRunnable> r =
       NS_NewRunnableMethod(this, &ServiceWorkerInstallJob::Install);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
   }
 
   void
   Install()
   {
     RefPtr<ServiceWorkerJob> kungFuDeathGrip = this;
 
     if (mCanceled) {
@@ -1335,17 +1335,17 @@ public:
           Succeed();
 
           // Done() must always be called async from Start()
           nsCOMPtr<nsIRunnable> runnable =
             NS_NewRunnableMethodWithArg<nsresult>(
               this,
               &ServiceWorkerRegisterJob::Done,
               NS_OK);
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(runnable)));
+          MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(runnable));
 
           return;
         }
       } else {
         mRegistration = swm->CreateNewRegistration(mScope, mPrincipal);
       }
     } else {
       MOZ_ASSERT(mJobType == UpdateJob);
@@ -1359,17 +1359,17 @@ public:
 
       // "If registration's uninstalling flag is set, abort these steps."
       if (mRegistration && mRegistration->mPendingUninstall) {
         nsCOMPtr<nsIRunnable> runnable =
           NS_NewRunnableMethodWithArg<nsresult>(
             this,
             &ServiceWorkerRegisterJob::Fail,
             NS_ERROR_DOM_INVALID_STATE_ERR);
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(runnable)));
+          MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(runnable));
 
         return;
       }
 
       // If a different script spec has been registered between when this update
       // was scheduled and it running now, then simply abort.
       RefPtr<ServiceWorkerInfo> newest = mRegistration ? mRegistration->Newest()
                                                        : nullptr;
@@ -1377,17 +1377,17 @@ public:
           (newest && !mScriptSpec.Equals(newest->ScriptSpec()))) {
 
         // Done() must always be called async from Start()
         nsCOMPtr<nsIRunnable> runnable =
           NS_NewRunnableMethodWithArg<nsresult>(
             this,
             &ServiceWorkerRegisterJob::Fail,
             NS_ERROR_DOM_ABORT_ERR);
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(runnable)));
+          MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(runnable));
 
         return;
       }
     }
 
     Update();
   }
 
@@ -1820,18 +1820,17 @@ ServiceWorkerManager::Register(mozIDOMWi
   RefPtr<WorkerLoadInfo::InterfaceRequestor> ir =
     new WorkerLoadInfo::InterfaceRequestor(documentPrincipal, docLoadGroup);
   ir->MaybeAddTabChild(docLoadGroup);
 
   // Create a load group that is separate from, yet related to, the document's load group.
   // This allows checks for interfaces like nsILoadContext to yield the values used by the
   // the document, yet will not cancel the update job if the document's load group is cancelled.
   nsCOMPtr<nsILoadGroup> loadGroup = do_CreateInstance(NS_LOADGROUP_CONTRACTID);
-  rv = loadGroup->SetNotificationCallbacks(ir);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(loadGroup->SetNotificationCallbacks(ir));
 
   RefPtr<ServiceWorkerRegisterJob> job =
     new ServiceWorkerRegisterJob(queue, documentPrincipal, cleanedScope, spec,
                                  cb, loadGroup);
   queue->Append(job);
 
   AssertIsOnMainThread();
   Telemetry::Accumulate(Telemetry::SERVICE_WORKER_REGISTRATIONS, 1);
@@ -1868,17 +1867,17 @@ ServiceWorkerManager::AppendPendingOpera
 }
 
 void
 ServiceWorkerRegistrationInfo::TryToActivateAsync()
 {
   nsCOMPtr<nsIRunnable> r =
   NS_NewRunnableMethod(this,
                        &ServiceWorkerRegistrationInfo::TryToActivate);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 }
 
 /*
  * TryToActivate should not be called directly, use TryToACtivateAsync instead.
  */
 void
 ServiceWorkerRegistrationInfo::TryToActivate()
 {
@@ -1950,17 +1949,17 @@ ServiceWorkerRegistrationInfo::Activate(
     new nsMainThreadPtrHolder<ContinueLifecycleTask>(new ContinueActivateTask(this)));
   RefPtr<LifeCycleEventCallback> callback =
     new ContinueLifecycleRunnable(continueActivateTask);
 
   ServiceWorkerPrivate* workerPrivate = mActiveWorker->WorkerPrivate();
   nsresult rv = workerPrivate->SendLifeCycleEvent(NS_LITERAL_STRING("activate"),
                                                   callback, failRunnable);
   if (NS_WARN_IF(NS_FAILED(rv))) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(failRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(failRunnable));
     return;
   }
 }
 
 /*
  * Implements the async aspects of the getRegistrations algorithm.
  */
 class GetRegistrationsRunnable final : public nsRunnable
@@ -2478,17 +2477,17 @@ public:
   }
 
   void
   Start() override
   {
     AssertIsOnMainThread();
     nsCOMPtr<nsIRunnable> r =
       NS_NewRunnableMethod(this, &ServiceWorkerUnregisterJob::UnregisterAndDone);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
   }
 
 private:
   // You probably want UnregisterAndDone().
   nsresult
   Unregister()
   {
     AssertIsOnMainThread();
@@ -3724,17 +3723,17 @@ ServiceWorkerManager::DispatchFetchEvent
   if (NS_WARN_IF(aRv.Failed())) {
     return;
   }
 
   nsCOMPtr<nsIUploadChannel2> uploadChannel = do_QueryInterface(innerChannel);
 
   // If there is no upload stream, then continue immediately
   if (!uploadChannel) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(continueRunnable->Run()));
+    MOZ_ALWAYS_SUCCEEDS(continueRunnable->Run());
     return;
   }
   // Otherwise, ensure the upload stream can be cloned directly.  This may
   // require some async copying, so provide a callback.
   aRv = uploadChannel->EnsureUploadStreamIsCloneable(continueRunnable);
 }
 
 bool
@@ -5229,17 +5228,17 @@ ServiceWorkerInfo::UpdateState(ServiceWo
   // activated state.
   // TODO: Do we care that these events will race with the propagation of the
   //       state change?
   if (aState == ServiceWorkerState::Activated && mState != aState) {
     mServiceWorkerPrivate->Activated();
   }
   mState = aState;
   nsCOMPtr<nsIRunnable> r = new ChangeStateUpdater(mInstances, mState);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r.forget())));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r.forget()));
 }
 
 ServiceWorkerInfo::ServiceWorkerInfo(nsIPrincipal* aPrincipal,
                                      const nsACString& aScope,
                                      const nsACString& aScriptSpec,
                                      const nsAString& aCacheName)
   : mPrincipal(aPrincipal)
   , mScope(aScope)
--- a/dom/workers/ServiceWorkerManagerParent.cpp
+++ b/dom/workers/ServiceWorkerManagerParent.cpp
@@ -201,18 +201,17 @@ ServiceWorkerManagerParent::RecvRegister
   if (!parent) {
     callback->Run();
     return true;
   }
 
   RefPtr<CheckPrincipalWithCallbackRunnable> runnable =
     new CheckPrincipalWithCallbackRunnable(parent.forget(), aData.principal(),
                                            callback);
-  nsresult rv = NS_DispatchToMainThread(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
   return true;
 }
 
 bool
 ServiceWorkerManagerParent::RecvUnregister(const PrincipalInfo& aPrincipalInfo,
                                            const nsString& aScope)
 {
@@ -236,18 +235,17 @@ ServiceWorkerManagerParent::RecvUnregist
   if (!parent) {
     callback->Run();
     return true;
   }
 
   RefPtr<CheckPrincipalWithCallbackRunnable> runnable =
     new CheckPrincipalWithCallbackRunnable(parent.forget(), aPrincipalInfo,
                                            callback);
-  nsresult rv = NS_DispatchToMainThread(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
   return true;
 }
 
 bool
 ServiceWorkerManagerParent::RecvPropagateSoftUpdate(const PrincipalOriginAttributes& aOriginAttributes,
                                                     const nsString& aScope)
 {
--- a/dom/workers/ServiceWorkerManagerService.cpp
+++ b/dom/workers/ServiceWorkerManagerService.cpp
@@ -71,18 +71,18 @@ public:
           if ((contextArray[j].OwnOrContainingAppId() == mOriginAttributes.mAppId) &&
               (contextArray[j].IsIsolatedMozBrowserElement() == mOriginAttributes.mInIsolatedMozBrowser)) {
             continue;
           }
           // Array entries with no mParent won't receive any notification.
           data.mParent = nullptr;
         }
       }
-      nsresult rv = mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL);
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+
+      MOZ_ALWAYS_SUCCEEDS(mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL));
       return NS_OK;
     }
 
     AssertIsOnBackgroundThread();
 
     for (uint32_t i = 0; i < mData->Length(); ++i) {
       NotifySoftUpdateData& data = mData->ElementAt(i);
       MOZ_ASSERT(!(data.mContentParent));
@@ -226,18 +226,17 @@ ServiceWorkerManagerService::PropagateSo
   if (notifySoftUpdateDataArray->IsEmpty()) {
     return;
   }
 
   RefPtr<NotifySoftUpdateIfPrincipalOkRunnable> runnable =
     new NotifySoftUpdateIfPrincipalOkRunnable(notifySoftUpdateDataArray,
                                               aOriginAttributes, aScope);
   MOZ_ASSERT(!notifySoftUpdateDataArray);
-  nsresult rv = NS_DispatchToMainThread(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
 #ifdef DEBUG
   MOZ_ASSERT(parentFound);
 #endif
 }
 
 void
 ServiceWorkerManagerService::PropagateUnregister(
--- a/dom/workers/ServiceWorkerPrivate.cpp
+++ b/dom/workers/ServiceWorkerPrivate.cpp
@@ -168,17 +168,17 @@ public:
 private:
   void
   Done(bool aResult)
   {
 #ifdef DEBUG
     mDone = true;
 #endif
     mCallback->SetResult(aResult);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(mCallback)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(mCallback));
   }
 };
 
 } // anonymous namespace
 
 nsresult
 ServiceWorkerPrivate::CheckScriptEvaluation(LifeCycleEventCallback* aCallback)
 {
@@ -374,17 +374,17 @@ public:
     MOZ_ASSERT(aWorkerPrivate);
     return DispatchLifecycleEvent(aCx, aWorkerPrivate);
   }
 
   NS_IMETHOD
   Cancel() override
   {
     mCallback->SetResult(false);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(mCallback)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(mCallback));
 
     return WorkerRunnable::Cancel();
   }
 
 private:
   bool
   DispatchLifecycleEvent(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
 
@@ -1287,17 +1287,17 @@ private:
         nsCOMPtr<nsIRunnable> updateRunnable =
           new RegistrationUpdateRunnable(mRegistration, false /* time check */);
         NS_DispatchToMainThread(runnable.forget());
 
         runnable = new CancelChannelRunnable(mInterceptedChannel,
                                              NS_ERROR_INTERCEPTION_FAILED);
       }
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
     }
 
     RefPtr<Promise> waitUntilPromise = event->GetPromise();
     if (waitUntilPromise) {
       RefPtr<KeepAliveHandler> keepAliveHandler =
         new KeepAliveHandler(mKeepAliveToken);
       waitUntilPromise->AppendNativeHandler(keepAliveHandler);
     }
--- a/dom/workers/ServiceWorkerRegistration.cpp
+++ b/dom/workers/ServiceWorkerRegistration.cpp
@@ -993,17 +993,17 @@ ServiceWorkerRegistrationWorkerThread::U
 
   RefPtr<PromiseWorkerProxy> proxy = PromiseWorkerProxy::Create(worker, promise);
   if (!proxy) {
     aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
     return nullptr;
   }
 
   RefPtr<UpdateRunnable> r = new UpdateRunnable(proxy, mScope);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 ServiceWorkerRegistrationWorkerThread::Unregister(ErrorResult& aRv)
 {
   WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
@@ -1025,17 +1025,17 @@ ServiceWorkerRegistrationWorkerThread::U
 
   RefPtr<PromiseWorkerProxy> proxy = PromiseWorkerProxy::Create(worker, promise);
   if (!proxy) {
     aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
     return nullptr;
   }
 
   RefPtr<StartUnregisterRunnable> r = new StartUnregisterRunnable(proxy, mScope);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 
   return promise.forget();
 }
 
 class StartListeningRunnable final : public nsRunnable
 {
   RefPtr<WorkerListener> mListener;
 public:
@@ -1063,17 +1063,17 @@ ServiceWorkerRegistrationWorkerThread::I
   if (!worker->AddFeature(this)) {
     mListener = nullptr;
     NS_WARNING("Could not add feature");
     return;
   }
 
   RefPtr<StartListeningRunnable> r =
     new StartListeningRunnable(mListener);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 }
 
 class AsyncStopListeningRunnable final : public nsRunnable
 {
   RefPtr<WorkerListener> mListener;
 public:
   explicit AsyncStopListeningRunnable(WorkerListener* aListener)
     : mListener(aListener)
@@ -1120,17 +1120,17 @@ ServiceWorkerRegistrationWorkerThread::R
   mWorkerPrivate->AssertIsOnWorkerThread();
   mWorkerPrivate->RemoveFeature(this);
 
   mListener->ClearRegistration();
 
   if (aReason == RegistrationIsGoingAway) {
     RefPtr<AsyncStopListeningRunnable> r =
       new AsyncStopListeningRunnable(mListener);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
   } else if (aReason == WorkerIsGoingAway) {
     RefPtr<SyncStopListeningRunnable> r =
       new SyncStopListeningRunnable(mWorkerPrivate, mListener);
     ErrorResult rv;
     r->Dispatch(rv);
     if (rv.Failed()) {
       NS_ERROR("Failed to dispatch stop listening runnable!");
       // And now what?
--- a/dom/workers/ServiceWorkerWindowClient.cpp
+++ b/dom/workers/ServiceWorkerWindowClient.cpp
@@ -143,17 +143,17 @@ ServiceWorkerWindowClient::Focus(ErrorRe
   }
 
   if (workerPrivate->GlobalScope()->WindowInteractionAllowed()) {
     RefPtr<PromiseWorkerProxy> promiseProxy =
       PromiseWorkerProxy::Create(workerPrivate, promise);
     if (promiseProxy) {
       RefPtr<ClientFocusRunnable> r = new ClientFocusRunnable(mWindowId,
                                                                 promiseProxy);
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
     } else {
       promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR);
     }
 
   } else {
     promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);
   }
 
--- a/dom/workers/WorkerDebuggerManager.cpp
+++ b/dom/workers/WorkerDebuggerManager.cpp
@@ -268,18 +268,17 @@ WorkerDebuggerManager::RegisterDebugger(
     {
       MutexAutoLock lock(mMutex);
 
       hasListeners = !mListeners.IsEmpty();
     }
 
     nsCOMPtr<nsIRunnable> runnable =
       new RegisterDebuggerMainThreadRunnable(aWorkerPrivate, hasListeners);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL));
 
     if (hasListeners) {
       aWorkerPrivate->WaitForIsDebuggerRegistered(true);
     }
   }
 }
 
 void
@@ -287,18 +286,17 @@ WorkerDebuggerManager::UnregisterDebugge
 {
   aWorkerPrivate->AssertIsOnParentThread();
 
   if (NS_IsMainThread()) {
     UnregisterDebuggerMainThread(aWorkerPrivate);
   } else {
     nsCOMPtr<nsIRunnable> runnable =
       new UnregisterDebuggerMainThreadRunnable(aWorkerPrivate);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL));
 
     aWorkerPrivate->WaitForIsDebuggerRegistered(false);
   }
 }
 
 void
 WorkerDebuggerManager::RegisterDebuggerMainThread(WorkerPrivate* aWorkerPrivate,
                                                   bool aNotifyListeners)
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -1705,17 +1705,17 @@ private:
 };
 
 PRThread*
 PRThreadFromThread(nsIThread* aThread)
 {
   MOZ_ASSERT(aThread);
 
   PRThread* result;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aThread->GetPRThread(&result)));
+  MOZ_ALWAYS_SUCCEEDS(aThread->GetPRThread(&result));
   MOZ_ASSERT(result);
 
   return result;
 }
 
 } /* anonymous namespace */
 
 NS_IMPL_ISUPPORTS_INHERITED0(MainThreadReleaseRunnable, nsRunnable)
@@ -3477,18 +3477,18 @@ WorkerPrivateParent<Derived>::SetPrincip
     mLoadInfo.mReportCSPViolations = false;
   }
 
   mLoadInfo.mLoadGroup = aLoadGroup;
 
   mLoadInfo.mPrincipalInfo = new PrincipalInfo();
   mLoadInfo.mPrivateBrowsing = nsContentUtils::IsInPrivateBrowsing(aLoadGroup);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    PrincipalToPrincipalInfo(aPrincipal, mLoadInfo.mPrincipalInfo)));
+  MOZ_ALWAYS_SUCCEEDS(
+    PrincipalToPrincipalInfo(aPrincipal, mLoadInfo.mPrincipalInfo));
 }
 
 template <class Derived>
 JSContext*
 WorkerPrivateParent<Derived>::ParentJSContext() const
 {
   AssertIsOnParentThread();
 
@@ -4400,17 +4400,17 @@ WorkerPrivate::OverrideLoadInfoLoadGroup
   //  - private browsing = false
   //  - content = true
   //  - use remote tabs = false
   nsCOMPtr<nsILoadGroup> loadGroup =
     do_CreateInstance(NS_LOADGROUP_CONTRACTID);
 
   nsresult rv =
     loadGroup->SetNotificationCallbacks(aLoadInfo.mInterfaceRequestor);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(rv);
 
   aLoadInfo.mLoadGroup = loadGroup.forget();
 }
 
 void
 WorkerPrivate::DoRunLoop(JSContext* aCx)
 {
   AssertIsOnWorkerThread();
@@ -4593,17 +4593,17 @@ WorkerPrivate::MaybeDispatchLoadFailedRu
 {
   AssertIsOnWorkerThread();
 
   nsCOMPtr<nsIRunnable> runnable = StealLoadFailedAsyncRunnable();
   if (!runnable) {
     return;
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable.forget())));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable.forget()));
 }
 
 void
 WorkerPrivate::InitializeGCTimers()
 {
   AssertIsOnWorkerThread();
 
   // We need a timer for GC. The basic plan is to run a non-shrinking GC
@@ -4633,17 +4633,17 @@ WorkerPrivate::SetGCTimerMode(GCTimerMod
   MOZ_ASSERT(mPeriodicGCTimerTarget);
   MOZ_ASSERT(mIdleGCTimerTarget);
 
   if ((aMode == PeriodicTimer && mPeriodicGCTimerRunning) ||
       (aMode == IdleTimer && mIdleGCTimerRunning)) {
     return;
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mGCTimer->Cancel()));
+  MOZ_ALWAYS_SUCCEEDS(mGCTimer->Cancel());
 
   mPeriodicGCTimerRunning = false;
   mIdleGCTimerRunning = false;
   LOG(WorkerLog(),
       ("Worker %p canceled GC timer because %s\n", this,
        aMode == PeriodicTimer ?
        "periodic" :
        aMode == IdleTimer ? "idle" : "none"));
@@ -4664,20 +4664,20 @@ WorkerPrivate::SetGCTimerMode(GCTimerMod
     type = nsITimer::TYPE_REPEATING_SLACK;
   }
   else {
     target = mIdleGCTimerTarget;
     delay = IDLE_GC_TIMER_DELAY_SEC * 1000;
     type = nsITimer::TYPE_ONE_SHOT;
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mGCTimer->SetTarget(target)));
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+  MOZ_ALWAYS_SUCCEEDS(mGCTimer->SetTarget(target));
+  MOZ_ALWAYS_SUCCEEDS(
     mGCTimer->InitWithNamedFuncCallback(DummyCallback, nullptr, delay, type,
-                                        "dom::workers::DummyCallback(2)")));
+                                        "dom::workers::DummyCallback(2)"));
 
   if (aMode == PeriodicTimer) {
     LOG(WorkerLog(), ("Worker %p scheduled periodic GC timer\n", this));
     mPeriodicGCTimerRunning = true;
   }
   else {
     LOG(WorkerLog(), ("Worker %p scheduled idle GC timer\n", this));
     mIdleGCTimerRunning = true;
@@ -4687,17 +4687,17 @@ WorkerPrivate::SetGCTimerMode(GCTimerMod
 void
 WorkerPrivate::ShutdownGCTimers()
 {
   AssertIsOnWorkerThread();
 
   MOZ_ASSERT(mGCTimer);
 
   // Always make sure the timer is canceled.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mGCTimer->Cancel()));
+  MOZ_ALWAYS_SUCCEEDS(mGCTimer->Cancel());
 
   LOG(WorkerLog(), ("Worker %p killed the GC timer\n", this));
 
   mGCTimer = nullptr;
   mPeriodicGCTimerTarget = nullptr;
   mIdleGCTimerTarget = nullptr;
   mPeriodicGCTimerRunning = false;
   mIdleGCTimerRunning = false;
@@ -5266,18 +5266,17 @@ already_AddRefed<nsIEventTarget>
 WorkerPrivate::CreateNewSyncLoop()
 {
   AssertIsOnWorkerThread();
 
   nsCOMPtr<nsIThreadInternal> thread = do_QueryInterface(NS_GetCurrentThread());
   MOZ_ASSERT(thread);
 
   nsCOMPtr<nsIEventTarget> realEventTarget;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->PushEventQueue(
-                                             getter_AddRefs(realEventTarget))));
+  MOZ_ALWAYS_SUCCEEDS(thread->PushEventQueue(getter_AddRefs(realEventTarget)));
 
   RefPtr<EventTarget> workerEventTarget =
     new EventTarget(this, realEventTarget);
 
   {
     // Modifications must be protected by mMutex in DEBUG builds, see comment
     // about mSyncLoopStack in WorkerPrivate.h.
 #ifdef DEBUG
@@ -5384,17 +5383,17 @@ WorkerPrivate::DestroySyncLoop(uint32_t 
 #ifdef DEBUG
     MutexAutoLock lock(mMutex);
 #endif
 
     // This will delete |loopInfo|!
     mSyncLoopStack.RemoveElementAt(aLoopIndex);
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aThread->PopEventQueue(nestedEventTarget)));
+  MOZ_ALWAYS_SUCCEEDS(aThread->PopEventQueue(nestedEventTarget));
 
   if (!mSyncLoopStack.Length() && mPendingEventQueueClearing) {
     ClearMainEventQueue(WorkerRan);
     mPendingEventQueueClearing = false;
   }
 
   return result;
 }
@@ -5710,17 +5709,17 @@ WorkerPrivate::NotifyInternal(JSContext*
   }
 
   // If this is the first time our status has changed we also need to schedule
   // the close handler unless we're being shut down.
   if (previousStatus == Running && aStatus != Killing) {
     MOZ_ASSERT(!mCloseHandlerStarted && !mCloseHandlerFinished);
 
     RefPtr<CloseEventRunnable> closeRunnable = new CloseEventRunnable(this);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(closeRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(closeRunnable));
   }
 
   if (aStatus == Closing) {
     // Notify parent to stop sending us messages and balance our busy count.
     RefPtr<CloseRunnable> runnable = new CloseRunnable(this);
     if (!runnable->Dispatch()) {
       return false;
     }
@@ -5773,18 +5772,17 @@ WorkerPrivate::ScheduleKillCloseEventRun
   MOZ_ASSERT(!mKillTime.IsNull());
 
   RefPtr<KillCloseEventRunnable> killCloseEventRunnable =
     new KillCloseEventRunnable(this);
   if (!killCloseEventRunnable->SetTimeout(RemainingRunTimeMS())) {
     return false;
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(
-                                                      killCloseEventRunnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(killCloseEventRunnable));
 
   return true;
 }
 
 void
 WorkerPrivate::ReportError(JSContext* aCx, const char* aFallbackMessage,
                            JSErrorReport* aReport)
 {
@@ -6352,18 +6350,18 @@ WorkerPrivate::SetThread(WorkerThread* a
       MOZ_ASSERT(!mThread);
       MOZ_ASSERT(mStatus == Pending);
 
       mThread = aThread;
       mThread->SetWorker(friendKey, this);
 
       if (!mPreStartRunnables.IsEmpty()) {
         for (uint32_t index = 0; index < mPreStartRunnables.Length(); index++) {
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-            mThread->DispatchAnyThread(friendKey, mPreStartRunnables[index].forget())));
+          MOZ_ALWAYS_SUCCEEDS(
+            mThread->DispatchAnyThread(friendKey, mPreStartRunnables[index].forget()));
         }
         mPreStartRunnables.Clear();
       }
     }
     else {
       MOZ_ASSERT(mThread);
 
       mThread->SetWorker(friendKey, nullptr);
--- a/dom/workers/WorkerScope.cpp
+++ b/dom/workers/WorkerScope.cpp
@@ -627,17 +627,17 @@ ServiceWorkerGlobalScope::SkipWaiting(Er
     promise->MaybeResolve(JS::UndefinedHandleValue);
     return promise.forget();
   }
 
   RefPtr<WorkerScopeSkipWaitingRunnable> runnable =
     new WorkerScopeSkipWaitingRunnable(promiseProxy,
                                        NS_ConvertUTF16toUTF8(mScope));
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
   return promise.forget();
 }
 
 bool
 ServiceWorkerGlobalScope::OpenWindowEnabled(JSContext* aCx, JSObject* aObj)
 {
   WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
   MOZ_ASSERT(worker);
--- a/dom/workers/WorkerThread.cpp
+++ b/dom/workers/WorkerThread.cpp
@@ -112,19 +112,19 @@ WorkerThread::SetWorker(const WorkerThre
 
       mWorkerPrivate = aWorkerPrivate;
 #ifdef DEBUG
       mAcceptingNonWorkerRunnables = false;
 #endif
     }
 
     mObserver = new Observer(aWorkerPrivate);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(AddObserver(mObserver)));
+    MOZ_ALWAYS_SUCCEEDS(AddObserver(mObserver));
   } else {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(RemoveObserver(mObserver)));
+    MOZ_ALWAYS_SUCCEEDS(RemoveObserver(mObserver));
     mObserver = nullptr;
 
     {
       MutexAutoLock lock(mLock);
 
       MOZ_ASSERT(mWorkerPrivate);
       MOZ_ASSERT(!mAcceptingNonWorkerRunnables);
       MOZ_ASSERT(!mOtherThreadsDispatchingViaEventTarget,
--- a/editor/libeditor/nsEditor.cpp
+++ b/editor/libeditor/nsEditor.cpp
@@ -2969,18 +2969,17 @@ already_AddRefed<nsIDOMNode>
 nsEditor::GetNodeLocation(nsIDOMNode* aChild, int32_t* outOffset)
 {
   MOZ_ASSERT(aChild && outOffset);
   NS_ENSURE_TRUE(aChild && outOffset, nullptr);
   *outOffset = -1;
 
   nsCOMPtr<nsIDOMNode> parent;
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    aChild->GetParentNode(getter_AddRefs(parent))));
+  MOZ_ALWAYS_SUCCEEDS(aChild->GetParentNode(getter_AddRefs(parent)));
   if (parent) {
     *outOffset = GetChildOffset(aChild, parent);
   }
 
   return parent.forget();
 }
 
 nsINode*
@@ -4143,51 +4142,47 @@ nsEditor::DeleteSelectionAndPrepareToCre
 }
 
 
 
 void
 nsEditor::DoAfterDoTransaction(nsITransaction *aTxn)
 {
   bool isTransientTransaction;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    aTxn->GetIsTransient(&isTransientTransaction)));
+  MOZ_ALWAYS_SUCCEEDS(aTxn->GetIsTransient(&isTransientTransaction));
 
   if (!isTransientTransaction)
   {
     // we need to deal here with the case where the user saved after some
     // edits, then undid one or more times. Then, the undo count is -ve,
     // but we can't let a do take it back to zero. So we flip it up to
     // a +ve number.
     int32_t modCount;
     GetModificationCount(&modCount);
     if (modCount < 0)
       modCount = -modCount;
 
     // don't count transient transactions
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      IncrementModificationCount(1)));
+    MOZ_ALWAYS_SUCCEEDS(IncrementModificationCount(1));
   }
 }
 
 
 void
 nsEditor::DoAfterUndoTransaction()
 {
   // all undoable transactions are non-transient
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    IncrementModificationCount(-1)));
+  MOZ_ALWAYS_SUCCEEDS(IncrementModificationCount(-1));
 }
 
 void
 nsEditor::DoAfterRedoTransaction()
 {
   // all redoable transactions are non-transient
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    IncrementModificationCount(1)));
+  MOZ_ALWAYS_SUCCEEDS(IncrementModificationCount(1));
 }
 
 already_AddRefed<ChangeAttributeTxn>
 nsEditor::CreateTxnForSetAttribute(Element& aElement, nsIAtom& aAttribute,
                                    const nsAString& aValue)
 {
   RefPtr<ChangeAttributeTxn> txn =
     new ChangeAttributeTxn(aElement, aAttribute, &aValue);
--- a/editor/libeditor/nsHTMLCSSUtils.cpp
+++ b/editor/libeditor/nsHTMLCSSUtils.cpp
@@ -504,18 +504,18 @@ nsHTMLCSSUtils::GetCSSInlinePropertyBase
   NS_ENSURE_TRUE(element, NS_ERROR_NULL_POINTER);
 
   if (aStyleType == eComputed) {
     // Get the all the computed css styles attached to the element node
     RefPtr<nsComputedDOMStyle> cssDecl = GetComputedStyle(element);
     NS_ENSURE_STATE(cssDecl);
 
     // from these declarations, get the one we want and that one only
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      cssDecl->GetPropertyValue(nsDependentAtomString(aProperty), aValue)));
+    MOZ_ALWAYS_SUCCEEDS(
+      cssDecl->GetPropertyValue(nsDependentAtomString(aProperty), aValue));
 
     return NS_OK;
   }
 
   MOZ_ASSERT(aStyleType == eSpecified);
   RefPtr<css::Declaration> decl = element->GetInlineStyleDeclaration();
   if (!decl) {
     return NS_OK;
--- a/extensions/cookie/nsPermissionManager.cpp
+++ b/extensions/cookie/nsPermissionManager.cpp
@@ -575,17 +575,17 @@ IsExpandedPrincipal(nsIPrincipal* aPrinc
 }
 
 } // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 nsPermissionManager::PermissionKey::PermissionKey(nsIPrincipal* aPrincipal)
 {
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aPrincipal->GetOrigin(mOrigin)));
+  MOZ_ALWAYS_SUCCEEDS(aPrincipal->GetOrigin(mOrigin));
 }
 
 /**
  * Simple callback used by |AsyncClose| to trigger a treatment once
  * the database is closed.
  *
  * Note: Beware that, if you hold onto a |CloseDatabaseListener| from a
  * |nsPermissionManager|, this will create a cycle.
--- a/hal/gonk/UeventPoller.cpp
+++ b/hal/gonk/UeventPoller.cpp
@@ -242,18 +242,18 @@ public:
       ShutdownNetlinkPoller* shutdownPoller = new ShutdownNetlinkPoller();
 
       nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction([=] () -> void
       {
         sShutdownPoller = shutdownPoller;
         ClearOnShutdown(&sShutdownPoller); // Must run on the main thread.
       });
       MOZ_ASSERT(runnable);
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL)));
+      MOZ_ALWAYS_SUCCEEDS(
+        NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL));
     }
   }
 private:
   ShutdownNetlinkPoller() = default;
   static void ShutdownUeventIOThread()
   {
     MonitorAutoLock l(*sMonitor);
     ShutdownUevent(); // Must run on the IO thread.
--- a/ipc/glue/BackgroundImpl.cpp
+++ b/ipc/glue/BackgroundImpl.cpp
@@ -430,17 +430,17 @@ private:
         // Since the actor is created on the main thread it must only
         // be released on the main thread as well.
         if (!NS_IsMainThread()) {
           ChildImpl* actor;
           threadLocalInfo->mActor.forget(&actor);
 
           nsCOMPtr<nsIRunnable> releaser =
             NS_NewNonOwningRunnableMethod(actor, &ChildImpl::Release);
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(releaser)));
+          MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(releaser));
         }
       }
       delete threadLocalInfo;
     }
   }
 
   static void
   DispatchFailureCallback(nsIEventTarget* aEventTarget);
@@ -1021,17 +1021,17 @@ ParentImpl::GetContentParent(PBackground
     // not threadsafe so instead we dispatch a runnable to the main thread to do
     // it for us. This is safe since we are guaranteed that our AddRef runnable
     // will run before the reference we hand out can be released, and the
     // ContentParent can't die as long as the existing reference is maintained.
     nsCOMPtr<nsIRunnable> runnable =
       NS_NewNonOwningRunnableMethod(actor->mContent, &ContentParent::AddRef);
     MOZ_ASSERT(runnable);
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
   }
 
   return already_AddRefed<ContentParent>(actor->mContent.get());
 }
 
 // static
 intptr_t
 ParentImpl::GetRawContentParentForComparison(
@@ -1104,17 +1104,17 @@ ParentImpl::CreateActorForSameProcess(Cr
 
   MOZ_ASSERT(!sShutdownHasStarted);
 
   sLiveActorCount++;
 
   if (sBackgroundThreadMessageLoop) {
     nsCOMPtr<nsIRunnable> callbackRunnable =
       new CreateCallbackRunnable(aCallback);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(callbackRunnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(callbackRunnable));
     return true;
   }
 
   if (!sPendingCallbacks) {
     sPendingCallbacks = new nsTArray<RefPtr<CreateCallback>>();
   }
 
   sPendingCallbacks->AppendElement(aCallback);
@@ -1229,41 +1229,40 @@ ParentImpl::ShutdownBackgroundThread()
 
     MOZ_ASSERT_IF(!sShutdownHasStarted, !sLiveActorCount);
 
     if (sLiveActorCount) {
       // We need to spin the event loop while we wait for all the actors to be
       // cleaned up. We also set a timeout to force-kill any hanging actors.
       TimerCallbackClosure closure(thread, liveActors);
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+      MOZ_ALWAYS_SUCCEEDS(
         shutdownTimer->InitWithFuncCallback(&ShutdownTimerCallback,
                                             &closure,
                                             kShutdownTimerDelayMS,
-                                            nsITimer::TYPE_ONE_SHOT)));
+                                            nsITimer::TYPE_ONE_SHOT));
 
       nsIThread* currentThread = NS_GetCurrentThread();
       MOZ_ASSERT(currentThread);
 
       while (sLiveActorCount) {
         NS_ProcessNextEvent(currentThread);
       }
 
       MOZ_ASSERT(liveActors->IsEmpty());
 
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(shutdownTimer->Cancel()));
+      MOZ_ALWAYS_SUCCEEDS(shutdownTimer->Cancel());
     }
 
     // Dispatch this runnable to unregister the thread from the profiler.
     nsCOMPtr<nsIRunnable> shutdownRunnable =
       new ShutdownBackgroundThreadRunnable();
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->Dispatch(shutdownRunnable,
-                                                  NS_DISPATCH_NORMAL)));
+    MOZ_ALWAYS_SUCCEEDS(thread->Dispatch(shutdownRunnable, NS_DISPATCH_NORMAL));
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->Shutdown()));
+    MOZ_ALWAYS_SUCCEEDS(thread->Shutdown());
   }
 }
 
 // static
 void
 ParentImpl::ShutdownTimerCallback(nsITimer* aTimer, void* aClosure)
 {
   AssertIsInMainProcess();
@@ -1275,32 +1274,32 @@ ParentImpl::ShutdownTimerCallback(nsITim
   MOZ_ASSERT(closure);
 
   // Don't let the stack unwind until the ForceCloseBackgroundActorsRunnable has
   // finished.
   sLiveActorCount++;
 
   nsCOMPtr<nsIRunnable> forceCloseRunnable =
     new ForceCloseBackgroundActorsRunnable(closure->mLiveActors);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(closure->mThread->Dispatch(forceCloseRunnable,
-                                                          NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(closure->mThread->Dispatch(forceCloseRunnable,
+						 NS_DISPATCH_NORMAL));
 }
 
 void
 ParentImpl::Destroy()
 {
   // May be called on any thread!
 
   AssertIsInMainProcess();
 
   nsCOMPtr<nsIRunnable> destroyRunnable =
     NS_NewNonOwningRunnableMethod(this, &ParentImpl::MainThreadActorDestroy);
   MOZ_ASSERT(destroyRunnable);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(destroyRunnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(destroyRunnable));
 }
 
 void
 ParentImpl::MainThreadActorDestroy()
 {
   AssertIsInMainProcess();
   AssertIsOnMainThread();
   MOZ_ASSERT_IF(mIsOtherProcessActor, mContent);
@@ -1382,17 +1381,17 @@ ParentImpl::ActorDestroy(ActorDestroyRea
   // it runs it will destroy 'this' and our associated MessageChannel. However,
   // IPDL is about to call MessageChannel::Clear() on this thread! To avoid
   // racing with the main thread we must ensure that the MessageChannel lives
   // long enough to be cleared in this call stack.
   nsCOMPtr<nsIRunnable> destroyRunnable =
     NS_NewNonOwningRunnableMethod(this, &ParentImpl::Destroy);
   MOZ_ASSERT(destroyRunnable);
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(destroyRunnable)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(destroyRunnable));
 }
 
 NS_IMPL_ISUPPORTS(ParentImpl::ShutdownObserver, nsIObserver)
 
 NS_IMETHODIMP
 ParentImpl::ShutdownObserver::Observe(nsISupports* aSubject,
                                       const char* aTopic,
                                       const char16_t* aData)
@@ -1521,17 +1520,17 @@ ParentImpl::ForceCloseBackgroundActorsRu
     // Copy the array since calling Close() could mutate the actual array.
     nsTArray<ParentImpl*> actorsToClose(*mActorArray);
 
     for (uint32_t index = 0; index < actorsToClose.Length(); index++) {
       actorsToClose[index]->Close();
     }
   }
 
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(this)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
 
   return NS_OK;
 }
 
 NS_IMPL_ISUPPORTS_INHERITED0(ParentImpl::CreateCallbackRunnable, nsRunnable)
 
 NS_IMETHODIMP
 ParentImpl::CreateCallbackRunnable::Run()
@@ -1710,17 +1709,17 @@ ChildImpl::GetOrCreateForCurrentThread(
     created = true;
     threadLocalInfo = newInfo.forget();
   }
 
   if (threadLocalInfo->mActor) {
     // Runnable will use GetForCurrentThread() to retrieve actor again.  This
     // allows us to avoid addref'ing on the wrong thread.
     nsCOMPtr<nsIRunnable> runnable = new AlreadyCreatedCallbackRunnable();
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(runnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(runnable));
 
     return true;
   }
 
   if (!created) {
     // We have already started the sequence for opening the actor so there's
     // nothing else we need to do here. This callback will be called after the
     // first callback in the schedule runnable.
--- a/ipc/glue/BackgroundParentImpl.cpp
+++ b/ipc/glue/BackgroundParentImpl.cpp
@@ -543,18 +543,17 @@ BackgroundParentImpl::RecvPBroadcastChan
   // If the ContentParent is null we are dealing with a same-process actor.
   if (!parent) {
     MOZ_ASSERT(aPrincipalInfo.type() != PrincipalInfo::TNullPrincipalInfo);
     return true;
   }
 
   RefPtr<CheckPrincipalRunnable> runnable =
     new CheckPrincipalRunnable(parent.forget(), aPrincipalInfo, aOrigin);
-  nsresult rv = NS_DispatchToMainThread(runnable);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
 
   return true;
 }
 
 bool
 BackgroundParentImpl::DeallocPBroadcastChannelParent(
                                                 PBroadcastChannelParent* aActor)
 {
--- a/ipc/glue/BackgroundUtils.cpp
+++ b/ipc/glue/BackgroundUtils.cpp
@@ -161,17 +161,17 @@ PrincipalToPrincipalInfo(nsIPrincipal* a
   nsCOMPtr<nsIExpandedPrincipal> expanded =
     do_QueryInterface(aPrincipal);
 
   if (expanded) {
     nsTArray<PrincipalInfo> whitelistInfo;
     PrincipalInfo info;
 
     nsTArray< nsCOMPtr<nsIPrincipal> >* whitelist;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(expanded->GetWhiteList(&whitelist)));
+    MOZ_ALWAYS_SUCCEEDS(expanded->GetWhiteList(&whitelist));
 
     for (uint32_t i = 0; i < whitelist->Length(); i++) {
       rv = PrincipalToPrincipalInfo((*whitelist)[i], &info);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
       // append that spec to the whitelist
       whitelistInfo.AppendElement(info);
--- a/ipc/glue/GeckoChildProcessHost.cpp
+++ b/ipc/glue/GeckoChildProcessHost.cpp
@@ -565,23 +565,23 @@ AddAppDirToCommandLine(std::vector<std::
       // NS_XPCOM_CURRENT_PROCESS_DIR really means the app dir, not the
       // current process dir.
       nsresult rv = directoryService->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
                                           NS_GET_IID(nsIFile),
                                           getter_AddRefs(appDir));
       if (NS_SUCCEEDED(rv)) {
 #if defined(XP_WIN)
         nsString path;
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(appDir->GetPath(path)));
+        MOZ_ALWAYS_SUCCEEDS(appDir->GetPath(path));
         aCmdLine.AppendLooseValue(UTF8ToWide("-appdir"));
         std::wstring wpath(path.get());
         aCmdLine.AppendLooseValue(wpath);
 #else
         nsAutoCString path;
-        MOZ_ALWAYS_TRUE(NS_SUCCEEDED(appDir->GetNativePath(path)));
+        MOZ_ALWAYS_SUCCEEDS(appDir->GetNativePath(path));
         aCmdLine.push_back("-appdir");
         aCmdLine.push_back(path.get());
 #endif
       }
     }
   }
 }
 
--- a/ipc/glue/MessagePump.cpp
+++ b/ipc/glue/MessagePump.cpp
@@ -241,17 +241,17 @@ DoWorkRunnable::Cancel()
 {
   // Workers require cancelable runnables, but we can't really cancel cleanly
   // here.  If we don't process this runnable then we will leave something
   // unprocessed in the message_loop.  Therefore, eagerly complete our work
   // instead by immediately calling Run().  Run() should be called separately
   // after this.  Unfortunately we cannot use flags to verify this because
   // DoWorkRunnable is a stateless singleton that can be in the event queue
   // multiple times simultaneously.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Run()));
+  MOZ_ALWAYS_SUCCEEDS(Run());
   return NS_OK;
 }
 
 void
 MessagePumpForChildProcess::Run(base::MessagePump::Delegate* aDelegate)
 {
   if (mFirstRun) {
     MOZ_ASSERT(aDelegate && !gFirstDelegate);
--- a/layout/ipc/VsyncParent.cpp
+++ b/layout/ipc/VsyncParent.cpp
@@ -48,17 +48,17 @@ bool
 VsyncParent::NotifyVsync(TimeStamp aTimeStamp)
 {
   // Called on hardware vsync thread. We should post to current ipc thread.
   MOZ_ASSERT(!IsOnBackgroundThread());
   nsCOMPtr<nsIRunnable> vsyncEvent =
     NS_NewRunnableMethodWithArg<TimeStamp>(this,
                                            &VsyncParent::DispatchVsyncEvent,
                                            aTimeStamp);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mBackgroundThread->Dispatch(vsyncEvent, NS_DISPATCH_NORMAL)));
+  MOZ_ALWAYS_SUCCEEDS(mBackgroundThread->Dispatch(vsyncEvent, NS_DISPATCH_NORMAL));
   return true;
 }
 
 void
 VsyncParent::DispatchVsyncEvent(TimeStamp aTimeStamp)
 {
   AssertIsOnBackgroundThread();
 
--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
@@ -50,17 +50,17 @@ public:
         return;
 
       nsresult rv = NS_OK;
 
 #ifdef MOZILLA_INTERNAL_API
       rv = observerService->AddObserver(this,
                                         NS_XPCOM_SHUTDOWN_OBSERVER_ID,
                                         false);
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+      MOZ_ALWAYS_SUCCEEDS(rv);
 #endif
       (void) rv;
     }
 
   NS_IMETHODIMP Observe(nsISupports* aSubject, const char* aTopic,
                         const char16_t* aData) override {
     if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
       CSFLogDebug(logTag, "Shutting down PeerConnectionCtx");
@@ -68,17 +68,17 @@ public:
 
       nsCOMPtr<nsIObserverService> observerService =
         services::GetObserverService();
       if (!observerService)
         return NS_ERROR_FAILURE;
 
       nsresult rv = observerService->RemoveObserver(this,
                                                     NS_XPCOM_SHUTDOWN_OBSERVER_ID);
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(rv));
+      MOZ_ALWAYS_SUCCEEDS(rv);
 
       // Make sure we're not deleted while still inside ::Observe()
       RefPtr<PeerConnectionCtxShutdown> kungFuDeathGrip(this);
       PeerConnectionCtx::gPeerConnectionCtxShutdown = nullptr;
     }
     return NS_OK;
   }
 
--- a/netwerk/base/nsILoadInfo.idl
+++ b/netwerk/base/nsILoadInfo.idl
@@ -529,19 +529,19 @@ interface nsILoadInfo : nsISupports
   static_assert(TAINTING_CORS == static_cast<uint32_t>(mozilla::LoadTainting::CORS),
                 "cors tainting enums should match");
   static_assert(TAINTING_OPAQUE == static_cast<uint32_t>(mozilla::LoadTainting::Opaque),
                 "opaque tainting enums should match");
 
   mozilla::LoadTainting GetTainting()
   {
     uint32_t tainting = TAINTING_BASIC;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(GetTainting(&tainting)));
+    MOZ_ALWAYS_SUCCEEDS(GetTainting(&tainting));
     return static_cast<mozilla::LoadTainting>(tainting);
   }
 
   void MaybeIncreaseTainting(mozilla::LoadTainting aTainting)
   {
     uint32_t tainting = static_cast<uint32_t>(aTainting);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(MaybeIncreaseTainting(tainting)));
+    MOZ_ALWAYS_SUCCEEDS(MaybeIncreaseTainting(tainting));
   }
 %}
 };
--- a/netwerk/base/nsStandardURL.cpp
+++ b/netwerk/base/nsStandardURL.cpp
@@ -1112,33 +1112,33 @@ nsStandardURL::GetAsciiSpec(nsACString &
     result.SetCapacity(mSpec.Length() + std::min<uint32_t>(32, mSpec.Length()/10));
 
     result = Substring(mSpec, 0, mScheme.mLen + 3);
 
     NS_EscapeURL(Userpass(true), esc_OnlyNonASCII | esc_AlwaysCopy, result);
 
     // get the hostport
     nsAutoCString hostport;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(GetAsciiHostPort(hostport)));
+    MOZ_ALWAYS_SUCCEEDS(GetAsciiHostPort(hostport));
     result += hostport;
 
     NS_EscapeURL(Path(), esc_OnlyNonASCII | esc_AlwaysCopy, result);
     return NS_OK;
 }
 
 // result is ASCII
 NS_IMETHODIMP
 nsStandardURL::GetAsciiHostPort(nsACString &result)
 {
     if (mHostEncoding == eEncoding_ASCII) {
         result = Hostport();
         return NS_OK;
     }
 
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(GetAsciiHost(result)));
+    MOZ_ALWAYS_SUCCEEDS(GetAsciiHost(result));
 
     // As our mHostEncoding is not eEncoding_ASCII, we know that
     // the our host is not ipv6, and we can avoid looking at it.
     MOZ_ASSERT(result.FindChar(':') == -1, "The host must not be ipv6");
 
     // hostport = "hostA" + ":port"
     uint32_t pos = mHost.mPos + mHost.mLen;
     if (pos < mPath.mPos)
--- a/netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp
+++ b/netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp
@@ -444,24 +444,24 @@ RegisterOperator::Start()
         attributes->GetEnumerator(getter_AddRefs(enumerator))))) {
       return rv;
     }
 
     bool hasMoreElements;
     while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) &&
            hasMoreElements) {
       nsCOMPtr<nsISupports> element;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(enumerator->GetNext(getter_AddRefs(element))));
+      MOZ_ALWAYS_SUCCEEDS(enumerator->GetNext(getter_AddRefs(element)));
       nsCOMPtr<nsIProperty> property = do_QueryInterface(element);
       MOZ_ASSERT(property);
 
       nsAutoString name;
       nsCOMPtr<nsIVariant> value;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(property->GetName(name)));
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(property->GetValue(getter_AddRefs(value))));
+      MOZ_ALWAYS_SUCCEEDS(property->GetName(name));
+      MOZ_ALWAYS_SUCCEEDS(property->GetValue(getter_AddRefs(value)));
 
       nsAutoCString str;
       if (NS_WARN_IF(NS_FAILED(value->GetAsACString(str)))) {
         continue;
       }
 
       TXTRecordSetValue(&txtRecord,
                         /* it's safe because key name is ASCII only. */
--- a/netwerk/protocol/data/DataChannelParent.cpp
+++ b/netwerk/protocol/data/DataChannelParent.cpp
@@ -17,18 +17,18 @@ NS_IMPL_ISUPPORTS(DataChannelParent, nsI
 DataChannelParent::~DataChannelParent()
 {
 }
 
 bool
 DataChannelParent::Init(const uint32_t &channelId)
 {
     nsCOMPtr<nsIChannel> channel;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-        NS_LinkRedirectChannels(channelId, this, getter_AddRefs(channel))));
+    MOZ_ALWAYS_SUCCEEDS(
+        NS_LinkRedirectChannels(channelId, this, getter_AddRefs(channel)));
 
     return true;
 }
 
 NS_IMETHODIMP
 DataChannelParent::SetParentListener(HttpChannelParentListener* aListener)
 {
     // Nothing to do.
--- a/netwerk/protocol/websocket/WebSocketChannelChild.cpp
+++ b/netwerk/protocol/websocket/WebSocketChannelChild.cpp
@@ -104,17 +104,17 @@ WebSocketChannelChild::MaybeReleaseIPCOb
     }
 
     mIPCState = Closing;
   }
 
   if (!NS_IsMainThread()) {
     nsCOMPtr<nsIRunnable> runnable =
       NS_NewRunnableMethod(this, &WebSocketChannelChild::MaybeReleaseIPCObject);
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
+    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
     return;
   }
 
   SendDeleteSelf();
 }
 
 void
 WebSocketChannelChild::GetEffectiveURL(nsAString& aEffectiveURL) const
--- a/security/manager/ssl/PSMContentListener.cpp
+++ b/security/manager/ssl/PSMContentListener.cpp
@@ -148,17 +148,17 @@ PSMContentStreamListener::OnStopRequest(
                                         nsresult aStatus)
 {
   MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("CertDownloader::OnStopRequest\n"));
 
   // Because importing the cert can spin the event loop (via alerts), we can't
   // do it here. Do it off the event loop instead.
   nsCOMPtr<nsIRunnable> r =
     NS_NewRunnableMethod(this, &PSMContentStreamListener::ImportCertificate);
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(r)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
 
   return NS_OK;
 }
 
 void
 PSMContentStreamListener::ImportCertificate()
 {
   nsCOMPtr<nsIX509CertDB> certdb;
--- a/storage/mozStorageService.cpp
+++ b/storage/mozStorageService.cpp
@@ -702,17 +702,17 @@ public:
                                : mConnection->initialize();
     if (NS_FAILED(rv)) {
       nsCOMPtr<nsIRunnable> closeRunnable =
         NS_NewRunnableMethodWithArg<mozIStorageCompletionCallback*>(
           mConnection.get(),
           &Connection::AsyncClose,
           nullptr);
       MOZ_ASSERT(closeRunnable);
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(closeRunnable)));
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(closeRunnable));
 
       return DispatchResult(rv, nullptr);
     }
 
     if (mGrowthIncrement >= 0) {
       // Ignore errors. In the future, we might wish to log them.
       (void)mConnection->SetGrowthIncrement(mGrowthIncrement, EmptyCString());
     }
--- a/toolkit/components/places/AsyncFaviconHelpers.cpp
+++ b/toolkit/components/places/AsyncFaviconHelpers.cpp
@@ -1070,17 +1070,17 @@ NotifyIconObservers::~NotifyIconObserver
 NS_IMETHODIMP
 NotifyIconObservers::Run()
 {
   NS_PRECONDITION(NS_IsMainThread(),
                   "This should be called on the main thread");
 
   nsCOMPtr<nsIURI> iconURI;
   if (!mIcon.spec.IsEmpty()) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(iconURI), mIcon.spec)));
+    MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(iconURI), mIcon.spec));
     if (iconURI)
     {
       // Notify observers only if something changed.
       if (mIcon.status & ICON_STATUS_SAVED ||
           mIcon.status & ICON_STATUS_ASSOCIATED) {
         SendGlobalNotifications(iconURI);
       }
     }
@@ -1093,17 +1093,17 @@ NotifyIconObservers::Run()
 
   return NS_OK;
 }
 
 void
 NotifyIconObservers::SendGlobalNotifications(nsIURI* aIconURI)
 {
   nsCOMPtr<nsIURI> pageURI;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(pageURI), mPage.spec)));
+  MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(pageURI), mPage.spec));
   if (pageURI) {
     nsFaviconService* favicons = nsFaviconService::GetFaviconService();
     MOZ_ASSERT(favicons);
     if (favicons) {
       (void)favicons->SendFaviconNotifications(pageURI, aIconURI, mPage.guid);
     }
   }
 
--- a/toolkit/components/places/History.cpp
+++ b/toolkit/components/places/History.cpp
@@ -645,17 +645,17 @@ public:
 
     nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
     if (!navHistory) {
       NS_WARNING("Trying to notify about a visit but cannot get the history service!");
       return NS_OK;
     }
 
     nsCOMPtr<nsIURI> uri;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), mPlace.spec)));
+    MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), mPlace.spec));
     if (!uri) {
       return NS_ERROR_UNEXPECTED;
     }
 
     // Notify the visit.  Note that TRANSITION_EMBED visits are never added
     // to the database, thus cannot be queried and we don't notify them.
     if (mPlace.transitionType != nsINavHistoryService::TRANSITION_EMBED) {
       navHistory->NotifyOnVisit(uri, mPlace.visitId, mPlace.visitTime,
@@ -709,17 +709,17 @@ public:
 
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
 
     nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
     NS_ENSURE_TRUE(navHistory, NS_ERROR_OUT_OF_MEMORY);
     nsCOMPtr<nsIURI> uri;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), mSpec)));
+    MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), mSpec));
     if (!uri) {
       return NS_ERROR_UNEXPECTED;
     }
 
     navHistory->NotifyTitleChange(uri, mTitle, mGUID);
 
     return NS_OK;
   }
@@ -750,22 +750,22 @@ public:
 
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
 
     bool hasValidURIs = true;
     nsCOMPtr<nsIURI> referrerURI;
     if (!mPlace.referrerSpec.IsEmpty()) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(referrerURI), mPlace.referrerSpec)));
+      MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(referrerURI), mPlace.referrerSpec));
       hasValidURIs = !!referrerURI;
     }
 
     nsCOMPtr<nsIURI> uri;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), mPlace.spec)));
+    MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), mPlace.spec));
     hasValidURIs = hasValidURIs && !!uri;
 
     nsCOMPtr<mozIPlaceInfo> place;
     if (mIsSingleVisit) {
       nsCOMPtr<mozIVisitInfo> visit =
         new VisitInfo(mPlace.visitId, mPlace.visitTime, mPlace.transitionType,
                       referrerURI.forget());
       PlaceInfo::VisitsArray visits;
@@ -1631,17 +1631,17 @@ public:
     // Wrap all notifications in a batch, so the view can handle changes in a
     // more performant way, by initiating a refresh after a limited number of
     // single changes.
     (void)navHistory->BeginUpdateBatch();
     for (auto iter = mPlaces.Iter(); !iter.Done(); iter.Next()) {
       PlaceHashKey* entry = iter.Get();
       const nsTArray<VisitData>& visits = entry->mVisits;
       nsCOMPtr<nsIURI> uri;
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), visits[0].spec)));
+      MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), visits[0].spec));
       // Notify an expiration only if we have a valid uri, otherwise
       // the observer couldn't gather any useful data from the notification.
       // This should be false only if there's a bug in the code preceding us.
       if (uri) {
         bool removingPage = visits.Length() == entry->VisitCount() &&
                             !entry->IsBookmarked();
 
         // FindRemovableVisits only sets the transition type on the VisitData
@@ -1934,17 +1934,17 @@ void
 StoreAndNotifyEmbedVisit(VisitData& aPlace,
                          mozIVisitInfoCallback* aCallback = nullptr)
 {
   MOZ_ASSERT(aPlace.transitionType == nsINavHistoryService::TRANSITION_EMBED,
              "Must only pass TRANSITION_EMBED visits to this!");
   MOZ_ASSERT(NS_IsMainThread(), "Must be called on the main thread!");
 
   nsCOMPtr<nsIURI> uri;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), aPlace.spec)));
+  MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), aPlace.spec));
 
   nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
   if (!navHistory || !uri) {
     return;
   }
 
   navHistory->registerEmbedVisit(uri, aPlace.visitTime);
 
--- a/toolkit/components/places/Shutdown.cpp
+++ b/toolkit/components/places/Shutdown.cpp
@@ -87,27 +87,27 @@ ClientsShutdownBlocker::ClientsShutdownB
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Create a barrier that will be exposed to clients through GetClient(), so
   // they can block Places shutdown.
   nsCOMPtr<nsIAsyncShutdownService> asyncShutdown = services::GetAsyncShutdown();
   MOZ_ASSERT(asyncShutdown);
   if (asyncShutdown) {
     nsCOMPtr<nsIAsyncShutdownBarrier> barrier;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(asyncShutdown->MakeBarrier(mName, getter_AddRefs(barrier))));
+    MOZ_ALWAYS_SUCCEEDS(asyncShutdown->MakeBarrier(mName, getter_AddRefs(barrier)));
     mBarrier = new nsMainThreadPtrHolder<nsIAsyncShutdownBarrier>(barrier);
   }
 }
 
 already_AddRefed<nsIAsyncShutdownClient>
 ClientsShutdownBlocker::GetClient()
 {
   nsCOMPtr<nsIAsyncShutdownClient> client;
   if (mBarrier) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mBarrier->GetClient(getter_AddRefs(client))));
+    MOZ_ALWAYS_SUCCEEDS(mBarrier->GetClient(getter_AddRefs(client)));
   }
   return client.forget();
 }
 
 // nsIAsyncShutdownBlocker
 NS_IMETHODIMP
 ClientsShutdownBlocker::BlockShutdown(nsIAsyncShutdownClient* aParentClient)
 {
@@ -115,17 +115,17 @@ ClientsShutdownBlocker::BlockShutdown(ns
   mParentClient = new nsMainThreadPtrHolder<nsIAsyncShutdownClient>(aParentClient);
   mState = RECEIVED_BLOCK_SHUTDOWN;
 
   if (NS_WARN_IF(!mBarrier)) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   // Wait until all the clients have removed their blockers.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mBarrier->Wait(this)));
+  MOZ_ALWAYS_SUCCEEDS(mBarrier->Wait(this));
 
   mState = CALLED_WAIT_CLIENTS;
   return NS_OK;
 }
 
 // nsIAsyncShutdownCompletionCallback
 NS_IMETHODIMP
 ClientsShutdownBlocker::Done()
@@ -199,19 +199,19 @@ ConnectionShutdownBlocker::Complete(nsre
   // The connection is closed, the Database has no more use, so we can break
   // possible cycles.
   mDatabase = nullptr;
 
   // Notify the connection has gone.
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   MOZ_ASSERT(os);
   if (os) {
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(os->NotifyObservers(nullptr,
-                                                     TOPIC_PLACES_CONNECTION_CLOSED,
-                                                     nullptr)));
+    MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr,
+					    TOPIC_PLACES_CONNECTION_CLOSED,
+					    nullptr));
   }
   mState = NOTIFIED_OBSERVERS_PLACES_CONNECTION_CLOSED;
 
   // mParentClient is nullptr in tests
   if (mParentClient) {
     nsresult rv = mParentClient->RemoveBlocker(this);
     if (NS_WARN_IF(NS_FAILED(rv))) return rv;
     mParentClient = nullptr;
--- a/toolkit/components/places/nsNavBookmarks.cpp
+++ b/toolkit/components/places/nsNavBookmarks.cpp
@@ -2572,17 +2572,17 @@ nsNavBookmarks::GetObservers(uint32_t* _
 
   return NS_OK;
 }
 
 void
 nsNavBookmarks::NotifyItemVisited(const ItemVisitData& aData)
 {
   nsCOMPtr<nsIURI> uri;
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), aData.bookmark.url)));
+  MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), aData.bookmark.url));
   // Notify the visit only if we have a valid uri, otherwise the observer
   // couldn't gather enough data from the notification.
   // This should be false only if there's a bug in the code preceding us.
   if (uri) {
     NOTIFY_OBSERVERS(mCanNotify, mCacheObservers, mObservers,
                      nsINavBookmarkObserver,
                      OnItemVisited(aData.bookmark.id,
                                    aData.visitId,
--- a/toolkit/components/places/nsNavHistoryResult.cpp
+++ b/toolkit/components/places/nsNavHistoryResult.cpp
@@ -1075,27 +1075,27 @@ int32_t nsNavHistoryContainerResultNode:
 
   // Not used for item annos
   nsCOMPtr<nsIURI> a_uri, b_uri;
   if (a->mItemId != -1) {
     a_itemAnno = true;
   } else {
     nsAutoCString spec;
     if (NS_SUCCEEDED(a->GetUri(spec))){
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(a_uri), spec)));
+      MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(a_uri), spec));
     }
     NS_ENSURE_TRUE(a_uri, 0);
   }
 
   if (b->mItemId != -1) {
     b_itemAnno = true;
   } else {
     nsAutoCString spec;
     if (NS_SUCCEEDED(b->GetUri(spec))) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(b_uri), spec)));
+      MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(b_uri), spec));
     }
     NS_ENSURE_TRUE(b_uri, 0);
   }
 
   nsAnnotationService* annosvc = nsAnnotationService::GetAnnotationService();
   NS_ENSURE_TRUE(annosvc, 0);
 
   bool a_hasAnno, b_hasAnno;
--- a/toolkit/components/places/tests/cpp/places_test_harness.h
+++ b/toolkit/components/places/tests/cpp/places_test_harness.h
@@ -383,30 +383,30 @@ public:
   NS_DECL_ISUPPORTS
 
   WaitForConnectionClosed()
   {
     nsCOMPtr<nsIObserverService> os =
       do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
     MOZ_ASSERT(os);
     if (os) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(os->AddObserver(this, TOPIC_PROFILE_CHANGE, false)));
+      MOZ_ALWAYS_SUCCEEDS(os->AddObserver(this, TOPIC_PROFILE_CHANGE, false));
     }
     mSpinner = new WaitForTopicSpinner(TOPIC_PLACES_CONNECTION_CLOSED);
   }
 
   NS_IMETHOD Observe(nsISupports* aSubject,
                      const char* aTopic,
                      const char16_t* aData) override
   {
     nsCOMPtr<nsIObserverService> os =
       do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
     MOZ_ASSERT(os);
     if (os) {
-      MOZ_ALWAYS_TRUE(NS_SUCCEEDED(os->RemoveObserver(this, aTopic)));
+      MOZ_ALWAYS_SUCCEEDS(os->RemoveObserver(this, aTopic));
     }
 
     mSpinner->Spin();
 
     return NS_OK;
   }
 };
 
--- a/widget/android/PrefsHelper.h
+++ b/widget/android/PrefsHelper.h
@@ -258,33 +258,33 @@ public:
 
         nsTArray<jni::Object::LocalRef> nameRefArray(
                 aPrefsToObserve->GetElements());
         nsAppShell* const appShell = nsAppShell::Get();
         MOZ_ASSERT(appShell);
 
         for (jni::Object::LocalRef& nameRef : nameRefArray) {
             jni::String::LocalRef nameStr(mozilla::Move(nameRef));
-            MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Preferences::AddStrongObserver(
-                    appShell, nameStr->ToCString().get())));
+            MOZ_ALWAYS_SUCCEEDS(Preferences::AddStrongObserver(
+                    appShell, nameStr->ToCString().get()));
         }
     }
 
     static void RemoveObserver(const jni::Class::LocalRef& aCls,
                                jni::ObjectArray::Param aPrefsToUnobserve)
     {
         nsTArray<jni::Object::LocalRef> nameRefArray(
                 aPrefsToUnobserve->GetElements());
         nsAppShell* const appShell = nsAppShell::Get();
         MOZ_ASSERT(appShell);
 
         for (jni::Object::LocalRef& nameRef : nameRefArray) {
             jni::String::LocalRef nameStr(mozilla::Move(nameRef));
-            MOZ_ALWAYS_TRUE(NS_SUCCEEDED(Preferences::RemoveObserver(
-                    appShell, nameStr->ToCString().get())));
+            MOZ_ALWAYS_SUCCEEDS(Preferences::RemoveObserver(
+                    appShell, nameStr->ToCString().get()));
         }
     }
 
     static void OnPrefChange(const char16_t* aData)
     {
         const nsCString& name = NS_LossyConvertUTF16toASCII(aData);
 
         int32_t type = -1;
--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -2721,18 +2721,18 @@ nsWindow::GeckoViewSupport::FlushIMEChan
     // Only send change notifications if we are *not* masking events,
     // i.e. if we have a focused editor,
     NS_ENSURE_TRUE_VOID(!mIMEMaskEventsCount);
 
     nsCOMPtr<nsISelection> imeSelection;
     nsCOMPtr<nsIContent> imeRoot;
 
     // If we are receiving notifications, we must have selection/root content.
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(IMEStateManager::GetFocusSelectionAndRoot(
-            getter_AddRefs(imeSelection), getter_AddRefs(imeRoot))));
+    MOZ_ALWAYS_SUCCEEDS(IMEStateManager::GetFocusSelectionAndRoot(
+            getter_AddRefs(imeSelection), getter_AddRefs(imeRoot)));
 
     // Make sure we still have a valid selection/root. We can potentially get
     // a stale selection/root if the editor becomes hidden, for example.
     NS_ENSURE_TRUE_VOID(imeRoot->IsInComposedDoc());
 
     RefPtr<nsWindow> kungFuDeathGrip(&window);
     window.UserActivity();
 
--- a/xpcom/base/nsConsoleService.cpp
+++ b/xpcom/base/nsConsoleService.cpp
@@ -458,16 +458,16 @@ nsConsoleService::Observe(nsISupports* a
     Reset();
     // We could remove ourselves from the observer service, but it is about to
     // drop all observers anyways, so why bother.
   } else if (!strcmp(aTopic, "inner-window-destroyed")) {
     nsCOMPtr<nsISupportsPRUint64> supportsInt = do_QueryInterface(aSubject);
     MOZ_ASSERT(supportsInt);
 
     uint64_t windowId;
-    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(supportsInt->GetData(&windowId)));
+    MOZ_ALWAYS_SUCCEEDS(supportsInt->GetData(&windowId));
 
     ClearMessagesForWindowID(windowId);
   } else {
     MOZ_CRASH();
   }
   return NS_OK;
 }
--- a/xpcom/tests/TestHarness.h
+++ b/xpcom/tests/TestHarness.h
@@ -111,20 +111,20 @@ class ScopedXPCOM : public nsIDirectoryS
     ~ScopedXPCOM()
     {
       // If we created a profile directory, we need to remove it.
       if (mProfD) {
         nsCOMPtr<nsIObserverService> os =
           do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
         MOZ_ASSERT(os);
         if (os) {
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(os->NotifyObservers(nullptr, "profile-change-net-teardown", nullptr)));
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(os->NotifyObservers(nullptr, "profile-change-teardown", nullptr)));
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(os->NotifyObservers(nullptr, "profile-before-change", nullptr)));
-          MOZ_ALWAYS_TRUE(NS_SUCCEEDED(os->NotifyObservers(nullptr, "profile-before-change2", nullptr)));
+          MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-change-net-teardown", nullptr));
+          MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-change-teardown", nullptr));
+          MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-before-change", nullptr));
+          MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-before-change2", nullptr));
         }
 
         if (NS_FAILED(mProfD->Remove(true))) {
           NS_WARNING("Problem removing profile directory");
         }
 
         mProfD = nullptr;
       }
--- a/xpcom/tests/gtest/TestPipes.cpp
+++ b/xpcom/tests/gtest/TestPipes.cpp
@@ -884,17 +884,17 @@ CloseDuringReadFunc(nsIInputStream *aRea
   MOZ_ASSERT(aWriteCountOut);
   MOZ_ASSERT(aToOffset == 0);
 
   // This is insanity and you probably should not do this under normal
   // conditions.  We want to simulate the case where the pipe is closed
   // (possibly from other end on another thread) simultaneously with the
   // read.  This is the easiest way to do trigger this case in a synchronous
   // gtest.
-  MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aReader->Close()));
+  MOZ_ALWAYS_SUCCEEDS(aReader->Close());
 
   nsTArray<char>* buffer = static_cast<nsTArray<char>*>(aClosure);
   buffer->AppendElements(aFromSegment, aCount);
 
   *aWriteCountOut = aCount;
 
   return NS_OK;
 }