Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Wed, 13 Mar 2019 10:19:06 +0100
changeset 521903 d55401632cea92b6b2775ba278274b5490275876
parent 521902 8647c1f78210adcb01511ea27eecfb53bc5c1a5d
child 521904 858a58a6aa93e044e04de5ccdad4aae4b9840657
child 521966 abe66ccddd970628f025780e1e5d0adc0b06e018
push id10870
push usernbeleuzu@mozilla.com
push dateFri, 15 Mar 2019 20:00:07 +0000
treeherdermozilla-beta@c594aee5b7a4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1519636
milestone67.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D22514
browser/app/winlauncher/ErrorHandler.cpp
caps/ContentPrincipal.cpp
docshell/base/nsPingListener.cpp
dom/base/DOMParser.cpp
dom/base/Document.cpp
dom/base/EventSource.cpp
dom/base/ScreenOrientation.cpp
dom/base/nsContentUtils.cpp
dom/base/nsContentUtils.h
dom/base/nsGlobalWindowCommands.cpp
dom/base/nsINode.h
dom/base/nsObjectLoadingContent.cpp
dom/base/nsSyncLoadService.cpp
dom/bindings/Exceptions.cpp
dom/bindings/nsScriptError.cpp
dom/cache/DBSchema.cpp
dom/canvas/CanvasImageCache.cpp
dom/canvas/CanvasImageCache.h
dom/canvas/CanvasRenderingContext2D.h
dom/canvas/WebGLExtensions.cpp
dom/events/EventStateManager.cpp
dom/fetch/FetchDriver.cpp
dom/html/HTMLMediaElement.cpp
dom/html/ImageDocument.cpp
dom/html/MediaDocument.cpp
dom/html/nsGenericHTMLElement.h
dom/jsurl/nsJSProtocolHandler.cpp
dom/localstorage/ActorsParent.cpp
dom/localstorage/LSObject.cpp
dom/media/ChannelMediaResource.cpp
dom/media/CubebUtils.cpp
dom/media/MediaManager.cpp
dom/media/VideoFrameContainer.cpp
dom/media/WebVTTListener.cpp
dom/media/webrtc/MediaEngineDefault.cpp
dom/media/webrtc/MediaEngineDefault.h
dom/media/webrtc/MediaEngineWebRTCAudio.h
dom/network/TCPSocket.cpp
dom/plugins/base/nsPluginStreamListenerPeer.cpp
dom/presentation/PresentationTCPSessionTransport.cpp
dom/quota/ActorsParent.cpp
dom/quota/nsIndexedDBProtocolHandler.cpp
dom/security/ContentVerifier.cpp
dom/serviceworkers/ServiceWorkerPrivate.cpp
dom/serviceworkers/ServiceWorkerScriptCache.cpp
dom/serviceworkers/ServiceWorkerUpdateJob.cpp
dom/u2f/U2F.cpp
dom/workers/RuntimeService.cpp
dom/workers/ScriptLoader.cpp
dom/workers/WorkerDebugger.cpp
dom/xbl/nsXBLService.cpp
dom/xhr/XMLHttpRequestMainThread.cpp
dom/xslt/xslt/txMozillaStylesheetCompiler.cpp
extensions/cookie/nsCookieModule.h
extensions/pref/autoconfig/src/nsAutoConfig.cpp
gfx/2d/DrawTargetSkia.cpp
gfx/gl/GLContext.cpp
gfx/gl/GLContext.h
gfx/gl/GLContextProviderCGL.mm
gfx/gl/GLLibraryLoader.cpp
gfx/gl/GLLibraryLoader.h
gfx/gl/GLXLibrary.h
gfx/layers/CanvasRenderer.h
gfx/layers/apz/src/FocusTarget.cpp
gfx/layers/ipc/APZCTreeManagerChild.cpp
gfx/layers/ipc/CompositorBridgeParent.cpp
gfx/layers/ipc/ImageBridgeParent.cpp
gfx/layers/wr/AsyncImagePipelineManager.cpp
gfx/layers/wr/AsyncImagePipelineManager.h
gfx/layers/wr/StackingContextHelper.h
gfx/layers/wr/WebRenderBridgeParent.cpp
gfx/layers/wr/WebRenderBridgeParent.h
gfx/layers/wr/WebRenderImageHost.cpp
gfx/layers/wr/WebRenderTextureHostWrapper.cpp
gfx/tests/gtest/TestRegion.cpp
gfx/thebes/gfxFontEntry.h
gfx/thebes/gfxFontUtils.cpp
gfx/thebes/gfxSVGGlyphs.cpp
gfx/vr/VRDisplayHost.cpp
gfx/webrender_bindings/RenderCompositorANGLE.cpp
gfx/webrender_bindings/WebRenderAPI.cpp
gfx/webrender_bindings/WebRenderTypes.h
gfx/webrender_bindings/webrender_ffi.h
image/SVGDocumentWrapper.cpp
image/VectorImage.cpp
image/decoders/icon/mac/nsIconChannelCocoa.mm
image/decoders/icon/win/nsIconChannel.cpp
image/imgLoader.cpp
image/imgRequest.cpp
intl/unicharutil/util/ICUUtils.cpp
ipc/glue/InputStreamUtils.h
ipc/glue/nsIIPCSerializableInputStream.h
js/public/ErrorReport.h
js/src/builtin/DataViewObject.cpp
js/src/builtin/TestingFunctions.h
js/src/frontend/BytecodeEmitter.h
js/src/frontend/FunctionEmitter.cpp
js/src/frontend/TokenStream.cpp
js/src/gc/Allocator.cpp
js/src/gc/Allocator.h
js/src/gc/Nursery.h
js/src/gc/WeakMap.h
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineCompiler.h
js/src/jit/BaselineFrame.h
js/src/jit/CodeGenerator.cpp
js/src/jit/CompileWrappers.cpp
js/src/jit/Linker.h
js/src/jit/Lowering.cpp
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jit/MacroAssembler.cpp
js/src/jit/MacroAssembler.h
js/src/jit/ProcessExecutableMemory.cpp
js/src/jit/VMFunctionList-inl.h
js/src/jit/shared/LIR-shared.h
js/src/jsapi-tests/testArrayBuffer.cpp
js/src/jsapi.cpp
js/src/jsexn.cpp
js/src/shell/js.cpp
js/src/vm/ArrayBufferObject.h
js/src/vm/Caches-inl.h
js/src/vm/Debugger.cpp
js/src/vm/JSObject.cpp
js/src/vm/ProxyObject.cpp
js/src/vm/Realm.h
js/src/vm/SavedStacks.cpp
js/src/vm/SavedStacks.h
js/src/vm/Scope.cpp
js/src/vm/Shape-inl.h
js/src/vm/Shape.h
js/src/vm/StringType-inl.h
js/src/vm/StringType.cpp
js/src/vm/TypeSet.h
js/src/wasm/WasmAST.h
js/src/wasm/WasmBaselineCompile.cpp
js/src/wasm/WasmBuiltins.cpp
js/src/wasm/WasmConstants.h
js/src/wasm/WasmCraneliftCompile.cpp
js/src/wasm/WasmGC.cpp
js/src/wasm/WasmGC.h
js/src/wasm/WasmInstance.cpp
js/src/wasm/WasmIonCompile.cpp
js/src/wasm/WasmJS.cpp
js/src/wasm/WasmModule.cpp
js/src/wasm/WasmTextToBinary.cpp
js/src/wasm/WasmTypes.h
js/src/wasm/WasmValidate.cpp
js/src/wasm/cranelift/baldrapi.h
js/xpconnect/src/XPCJSContext.cpp
js/xpconnect/src/XPCShellImpl.cpp
js/xpconnect/src/nsXPConnect.cpp
layout/base/nsCSSFrameConstructor.cpp
layout/base/nsPresContext.cpp
layout/forms/nsHTMLButtonControlFrame.cpp
layout/generic/BRFrame.cpp
layout/generic/WritingModes.h
layout/generic/nsFrame.h
layout/generic/nsFrameSelection.cpp
layout/generic/nsIFrame.h
layout/generic/nsLineLayout.cpp
layout/generic/nsTextFrame.cpp
layout/generic/nsTextFrame.h
layout/painting/FrameLayerBuilder.h
layout/svg/nsFilterInstance.cpp
layout/svg/nsSVGIntegrationUtils.h
layout/svg/nsSVGMaskFrame.h
layout/xul/nsMenuPopupFrame.cpp
layout/xul/tree/nsTreeColumns.cpp
media/libdav1d/config.h
media/mtransport/ipc/WebrtcProxyChannel.cpp
media/webrtc/signaling/src/media-conduit/AudioConduit.cpp
media/webrtc/signaling/src/media-conduit/AudioConduit.h
media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h
media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
media/webrtc/signaling/src/media-conduit/VideoConduit.h
media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
modules/libjar/nsJARChannel.cpp
modules/libjar/nsZipArchive.cpp
modules/libjar/zipwriter/nsDeflateConverter.cpp
modules/libjar/zipwriter/nsZipWriter.cpp
modules/libpref/Preferences.cpp
mozglue/build/WindowsDllServices.h
mozglue/misc/Debug.h
mozglue/misc/interceptor/PatcherBase.h
mozglue/tests/interceptor/TestDllInterceptor.cpp
netwerk/base/MemoryDownloader.cpp
netwerk/base/SimpleChannelParent.cpp
netwerk/base/mozurl/MozURL.cpp
netwerk/base/nsBaseChannel.cpp
netwerk/base/nsBufferedStreams.cpp
netwerk/base/nsDownloader.cpp
netwerk/base/nsIncrementalDownload.cpp
netwerk/base/nsInputStreamPump.cpp
netwerk/base/nsProtocolProxyService.cpp
netwerk/base/nsRequestObserverProxy.cpp
netwerk/base/nsSimpleStreamListener.cpp
netwerk/base/nsStreamListenerTee.cpp
netwerk/base/nsStreamLoader.cpp
netwerk/base/nsSyncStreamListener.cpp
netwerk/dns/TRR.cpp
netwerk/protocol/data/DataChannelParent.cpp
netwerk/protocol/file/FileChannelParent.cpp
netwerk/protocol/ftp/FTPChannelParent.cpp
netwerk/protocol/ftp/nsFtpConnectionThread.cpp
netwerk/protocol/http/AlternateServices.cpp
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/protocol/http/HttpChannelChild.cpp
netwerk/protocol/http/HttpChannelParent.cpp
netwerk/protocol/http/HttpChannelParentListener.cpp
netwerk/protocol/http/InterceptedHttpChannel.cpp
netwerk/protocol/http/nsCORSListenerProxy.cpp
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/viewsource/nsViewSourceChannel.cpp
netwerk/protocol/websocket/WebSocketChannel.cpp
netwerk/streamconv/converters/mozTXTToHTMLConv.cpp
netwerk/streamconv/converters/nsDirIndexParser.cpp
netwerk/streamconv/converters/nsFTPDirListingConv.cpp
netwerk/streamconv/converters/nsHTTPCompressConv.cpp
netwerk/streamconv/converters/nsIndexedToHTML.cpp
netwerk/streamconv/converters/nsMultiMixedConv.cpp
netwerk/streamconv/converters/nsUnknownDecoder.cpp
netwerk/test/gtest/TestMozURL.cpp
netwerk/wifi/win_wifiScanner.cpp
parser/html/nsHtml5StreamListener.cpp
parser/html/nsHtml5StreamParser.h
parser/htmlparser/nsParser.cpp
parser/prototype/PrototypeDocumentParser.cpp
security/manager/ssl/DataStorage.cpp
security/manager/ssl/EnterpriseRoots.cpp
security/manager/ssl/PSMContentListener.cpp
security/manager/ssl/PSMContentListener.h
security/sandbox/common/SandboxSettings.cpp
toolkit/components/extensions/WebExtensionPolicy.cpp
toolkit/components/extensions/webrequest/ChannelWrapper.cpp
toolkit/components/extensions/webrequest/StreamFilterParent.cpp
toolkit/components/remote/nsDBusRemoteClient.cpp
toolkit/components/remote/nsRemoteService.cpp
toolkit/components/remote/nsWinRemoteClient.cpp
toolkit/components/remote/nsWinRemoteClient.h
toolkit/components/remote/nsWinRemoteServer.cpp
toolkit/components/remote/nsWinRemoteUtils.h
toolkit/components/reputationservice/ApplicationReputation.cpp
toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp
toolkit/components/sessionstore/SessionStoreUtils.cpp
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
toolkit/components/url-classifier/tests/gtest/Common.h
toolkit/profile/nsToolkitProfileService.cpp
toolkit/xre/LauncherRegistryInfo.cpp
toolkit/xre/nsUpdateDriver.cpp
tools/fuzzing/interface/FuzzingInterface.h
tools/profiler/core/EHABIStackWalk.cpp
uriloader/base/nsDocLoader.cpp
uriloader/base/nsURILoader.cpp
uriloader/exthandler/ExternalHelperAppChild.cpp
uriloader/exthandler/ExternalHelperAppParent.cpp
uriloader/exthandler/ExternalHelperAppParent.h
uriloader/exthandler/nsExternalProtocolHandler.cpp
uriloader/prefetch/nsOfflineCacheUpdate.cpp
uriloader/prefetch/nsPrefetchService.cpp
widget/android/WebExecutorSupport.cpp
widget/android/nsWindow.cpp
widget/cocoa/nsChildView.mm
widget/cocoa/nsClipboard.mm
widget/cocoa/nsCocoaUtils.mm
widget/cocoa/nsDragService.mm
widget/gtk/mozcontainer.cpp
widget/gtk/mozcontainer.h
widget/windows/GfxInfo.cpp
widget/windows/nsWidgetFactory.cpp
xpcom/build/NSPRInterposer.cpp
xpcom/io/nsLocalFileWin.cpp
xpcom/io/nsMultiplexInputStream.cpp
xpcom/tests/gtest/TestNonBlockingAsyncInputStream.cpp
--- a/browser/app/winlauncher/ErrorHandler.cpp
+++ b/browser/app/winlauncher/ErrorHandler.cpp
@@ -171,27 +171,27 @@ using SigMap = mozilla::Vector<std::wstr
 static const size_t kMaxStrLen = 80;
 
 static mozilla::UniquePtr<char[]> WideToUTF8(const wchar_t* aStr,
                                              const size_t aStrLenExclNul) {
   // Yes, this might not handle surrogate pairs correctly. Let's just let
   // WideCharToMultiByte fail in that unlikely case.
   size_t cvtLen = std::min(aStrLenExclNul, kMaxStrLen);
 
-  int numConv = ::WideCharToMultiByte(CP_UTF8, 0, aStr, cvtLen, nullptr,
-                                      0, nullptr, nullptr);
+  int numConv = ::WideCharToMultiByte(CP_UTF8, 0, aStr, cvtLen, nullptr, 0,
+                                      nullptr, nullptr);
   if (!numConv) {
     return nullptr;
   }
 
   // Include room for the null terminator by adding one
   auto buf = mozilla::MakeUnique<char[]>(numConv + 1);
 
-  numConv = ::WideCharToMultiByte(CP_UTF8, 0, aStr, cvtLen, buf.get(),
-                                  numConv, nullptr, nullptr);
+  numConv = ::WideCharToMultiByte(CP_UTF8, 0, aStr, cvtLen, buf.get(), numConv,
+                                  nullptr, nullptr);
   if (!numConv) {
     return nullptr;
   }
 
   // Add null termination. numConv does not include the terminator, so we don't
   // subtract 1 when indexing into buf.
   buf[numConv] = 0;
 
@@ -202,17 +202,17 @@ static mozilla::UniquePtr<char[]> WideTo
   return WideToUTF8(aStr, wcslen(aStr));
 }
 
 static mozilla::UniquePtr<char[]> WideToUTF8(const std::wstring& aStr) {
   return WideToUTF8(aStr.c_str(), aStr.length());
 }
 
 // MinGW does not support the Windows Security Center APIs.
-#if !defined(__MINGW32__)
+#  if !defined(__MINGW32__)
 
 static mozilla::UniquePtr<char[]> WideToUTF8(const _bstr_t& aStr) {
   return WideToUTF8(static_cast<const wchar_t*>(aStr), aStr.length());
 }
 
 namespace {
 
 struct ProviderKey {
@@ -322,17 +322,17 @@ static bool AddWscInfo(mozilla::JSONWrit
 
     aJson.EndArray();
   }
 
   aJson.EndObject();
 
   return true;
 }
-#endif  // !defined(__MINGW32__)
+#  endif  // !defined(__MINGW32__)
 
 // Max array length for telemetry intake.
 static const size_t kMaxArrayLen = 1000;
 
 static bool AddModuleInfo(const nsAutoHandle& aSnapshot,
                           mozilla::JSONWriter& aJson) {
   if (aSnapshot.get() == INVALID_HANDLE_VALUE) {
     // We haven't written anything yet, so we can return true here and continue
@@ -447,26 +447,25 @@ struct PingThreadContext {
       : mLauncherError(aError),
         mModulesSnapshot(::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, 0)) {}
   mozilla::LauncherError mLauncherError;
   nsAutoHandle mModulesSnapshot;
 };
 
 }  // anonymous namespace
 
-static bool PrepPing(const PingThreadContext& aContext,
-                     const std::wstring& aId,
+static bool PrepPing(const PingThreadContext& aContext, const std::wstring& aId,
                      mozilla::JSONWriter& aJson) {
-#if defined(DEBUG)
+#  if defined(DEBUG)
   const mozilla::JSONWriter::CollectionStyle style =
       mozilla::JSONWriter::MultiLineStyle;
-#else
+#  else
   const mozilla::JSONWriter::CollectionStyle style =
       mozilla::JSONWriter::SingleLineStyle;
-#endif  // defined(DEBUG)
+#  endif  // defined(DEBUG)
 
   aJson.Start(style);
 
   aJson.StringProperty("type", "launcher-process-failure");
   aJson.IntProperty("version", 1);
 
   auto idUtf8 = WideToUTF8(aId);
   if (idUtf8) {
@@ -558,21 +557,21 @@ static bool PrepPing(const PingThreadCon
   }
 
   aJson.StringProperty("source_file", srcFileLeaf.c_str());
 
   aJson.IntProperty("source_line", aContext.mLauncherError.mLine);
   aJson.IntProperty("hresult", aContext.mLauncherError.mError.AsHResult());
   aJson.EndObject();
 
-#if !defined(__MINGW32__)
+#  if !defined(__MINGW32__)
   if (!AddWscInfo(aJson)) {
     return false;
   }
-#endif  // !defined(__MINGW32__)
+#  endif  // !defined(__MINGW32__)
 
   if (!AddModuleInfo(aContext.mModulesSnapshot, aJson)) {
     return false;
   }
 
   aJson.End();
 
   return true;
@@ -677,28 +676,28 @@ static unsigned __stdcall SendPingThread
 
   return 0;
 }
 
 #endif  // defined(MOZ_TELEMETRY_REPORTING)
 
 static bool SendPing(const mozilla::LauncherError& aError) {
 #if defined(MOZ_TELEMETRY_REPORTING)
-#if defined(MOZ_LAUNCHER_PROCESS)
+#  if defined(MOZ_LAUNCHER_PROCESS)
   mozilla::LauncherRegistryInfo regInfo;
   mozilla::LauncherResult<mozilla::LauncherRegistryInfo::EnabledState>
       launcherEnabled = regInfo.IsEnabled();
   if (launcherEnabled.isErr() ||
       launcherEnabled.unwrap() ==
           mozilla::LauncherRegistryInfo::EnabledState::ForceDisabled) {
     // If the launcher is force disabled, we do not send any pings
     // (since studies and thus telemetry have been opted out)
     return false;
   }
-#endif  // defined(MOZ_LAUNCHER_PROCESS)
+#  endif  // defined(MOZ_LAUNCHER_PROCESS)
 
   // We send this ping when the launcher process fails. After we start the
   // SendPingThread, this thread falls back from running as the launcher process
   // to running as the browser main thread. Once this happens, it will be unsafe
   // to set up PoisonIOInterposer (since we have already spun up a background
   // thread).
   mozilla::SaveToEnv("MOZ_DISABLE_POISON_IO_INTERPOSER=1");
 
@@ -740,13 +739,11 @@ void HandleLauncherError(const LauncherE
 
   PostErrorToLog(aError);
 }
 
 void SetLauncherErrorAppData(const StaticXREAppData& aAppData) {
   gAppData = &aAppData;
 }
 
-void SetLauncherErrorForceEventLog() {
-  gForceEventLog = true;
-}
+void SetLauncherErrorForceEventLog() { gForceEventLog = true; }
 
 }  // namespace mozilla
--- a/caps/ContentPrincipal.cpp
+++ b/caps/ContentPrincipal.cpp
@@ -406,18 +406,17 @@ static nsresult GetSpecialBaseDomain(con
   }
 
   if (hasNoRelativeFlag) {
     *aHandled = true;
     return aCodebase->GetSpec(aBaseDomain);
   }
 
   bool isBehaved;
-  if (NS_SUCCEEDED(aCodebase->SchemeIs("indexeddb", &isBehaved)) &&
-      isBehaved) {
+  if (NS_SUCCEEDED(aCodebase->SchemeIs("indexeddb", &isBehaved)) && isBehaved) {
     *aHandled = true;
     return aCodebase->GetSpec(aBaseDomain);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
--- a/docshell/base/nsPingListener.cpp
+++ b/docshell/base/nsPingListener.cpp
@@ -322,31 +322,27 @@ nsresult nsPingListener::StartTimeout(Do
 
   return NS_NewTimerWithFuncCallback(
       getter_AddRefs(mTimer), OnPingTimeout, mLoadGroup, PING_TIMEOUT,
       nsITimer::TYPE_ONE_SHOT, "nsPingListener::StartTimeout",
       aDocGroup->EventTargetFor(TaskCategory::Network));
 }
 
 NS_IMETHODIMP
-nsPingListener::OnStartRequest(nsIRequest* aRequest) {
-  return NS_OK;
-}
+nsPingListener::OnStartRequest(nsIRequest* aRequest) { return NS_OK; }
 
 NS_IMETHODIMP
-nsPingListener::OnDataAvailable(nsIRequest* aRequest,
-                                nsIInputStream* aStream, uint64_t aOffset,
-                                uint32_t aCount) {
+nsPingListener::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aStream,
+                                uint64_t aOffset, uint32_t aCount) {
   uint32_t result;
   return aStream->ReadSegments(NS_DiscardSegment, nullptr, aCount, &result);
 }
 
 NS_IMETHODIMP
-nsPingListener::OnStopRequest(nsIRequest* aRequest,
-                              nsresult aStatus) {
+nsPingListener::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   mLoadGroup = nullptr;
 
   if (mTimer) {
     mTimer->Cancel();
     mTimer = nullptr;
   }
 
   return NS_OK;
--- a/dom/base/DOMParser.cpp
+++ b/dom/base/DOMParser.cpp
@@ -198,18 +198,17 @@ already_AddRefed<Document> DOMParser::Pa
   // Now start pumping data to the listener
   nsresult status;
 
   rv = listener->OnStartRequest(parserChannel);
   if (NS_FAILED(rv)) parserChannel->Cancel(rv);
   parserChannel->GetStatus(&status);
 
   if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(status)) {
-    rv = listener->OnDataAvailable(parserChannel, stream, 0,
-                                   aContentLength);
+    rv = listener->OnDataAvailable(parserChannel, stream, 0, aContentLength);
     if (NS_FAILED(rv)) parserChannel->Cancel(rv);
     parserChannel->GetStatus(&status);
   }
 
   rv = listener->OnStopRequest(parserChannel, status);
   // Failure returned from OnStopRequest does not affect the final status of
   // the channel, so we do not need to call Cancel(rv) as we do above.
 
--- a/dom/base/Document.cpp
+++ b/dom/base/Document.cpp
@@ -987,18 +987,17 @@ ExternalResourceMap::PendingLoad::OnData
                                                   nsIInputStream* aStream,
                                                   uint64_t aOffset,
                                                   uint32_t aCount) {
   // mTargetListener might be null if SetupViewer or AddExternalResource failed.
   NS_ENSURE_TRUE(mTargetListener, NS_ERROR_FAILURE);
   if (mDisplayDocument->ExternalResourceMap().HaveShutDown()) {
     return NS_BINDING_ABORTED;
   }
-  return mTargetListener->OnDataAvailable(aRequest, aStream, aOffset,
-                                          aCount);
+  return mTargetListener->OnDataAvailable(aRequest, aStream, aOffset, aCount);
 }
 
 NS_IMETHODIMP
 ExternalResourceMap::PendingLoad::OnStopRequest(nsIRequest* aRequest,
                                                 nsresult aStatus) {
   // mTargetListener might be null if SetupViewer or AddExternalResource failed
   if (mTargetListener) {
     nsCOMPtr<nsIStreamListener> listener;
--- a/dom/base/EventSource.cpp
+++ b/dom/base/EventSource.cpp
@@ -725,18 +725,17 @@ EventSourceImpl::OnDataAvailable(nsIRequ
   NS_ENSURE_SUCCESS(rv, rv);
 
   uint32_t totalRead;
   return aInputStream->ReadSegments(EventSourceImpl::StreamReaderFunc, this,
                                     aCount, &totalRead);
 }
 
 NS_IMETHODIMP
-EventSourceImpl::OnStopRequest(nsIRequest* aRequest,
-                               nsresult aStatusCode) {
+EventSourceImpl::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
   AssertIsOnMainThread();
 
   if (IsClosed()) {
     return NS_ERROR_ABORT;
   }
   MOZ_ASSERT(mSrc);
   // "Network errors that prevents the connection from being established in the
   //  first place (e.g. DNS errors), must cause the user agent to asynchronously
--- a/dom/base/ScreenOrientation.cpp
+++ b/dom/base/ScreenOrientation.cpp
@@ -533,30 +533,33 @@ void ScreenOrientation::UpdateActiveOrie
   if (aOrientation == hal::eScreenOrientation_None) {
     hal::UnlockScreenOrientation();
   } else {
     DebugOnly<bool> ok = hal::LockScreenOrientation(aOrientation);
     NS_WARNING_ASSERTION(ok, "hal::LockScreenOrientation failed");
   }
 }
 
-nsCOMPtr<nsIRunnable> ScreenOrientation::DispatchChangeEventAndResolvePromise() {
+nsCOMPtr<nsIRunnable>
+ScreenOrientation::DispatchChangeEventAndResolvePromise() {
   RefPtr<Document> doc = GetResponsibleDocument();
   RefPtr<ScreenOrientation> self = this;
-  return NS_NewRunnableFunction("dom::ScreenOrientation::DispatchChangeEvent", [self, doc]() {
-    DebugOnly<nsresult> rv = self->DispatchTrustedEvent(NS_LITERAL_STRING("change"));
-    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "DispatchTrustedEvent failed");
-    if (doc) {
-      Promise* pendingPromise = doc->GetOrientationPendingPromise();
-      if (pendingPromise) {
-        pendingPromise->MaybeResolveWithUndefined();
-        doc->SetOrientationPendingPromise(nullptr);
-      }
-    }
-  });
+  return NS_NewRunnableFunction(
+      "dom::ScreenOrientation::DispatchChangeEvent", [self, doc]() {
+        DebugOnly<nsresult> rv =
+            self->DispatchTrustedEvent(NS_LITERAL_STRING("change"));
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "DispatchTrustedEvent failed");
+        if (doc) {
+          Promise* pendingPromise = doc->GetOrientationPendingPromise();
+          if (pendingPromise) {
+            pendingPromise->MaybeResolveWithUndefined();
+            doc->SetOrientationPendingPromise(nullptr);
+          }
+        }
+      });
 }
 
 JSObject* ScreenOrientation::WrapObject(JSContext* aCx,
                                         JS::Handle<JSObject*> aGivenProto) {
   return ScreenOrientation_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 bool ScreenOrientation::ShouldResistFingerprinting() const {
@@ -599,17 +602,18 @@ ScreenOrientation::VisibleEventListener:
   target->RemoveSystemEventListener(NS_LITERAL_STRING("visibilitychange"), this,
                                     true);
 
   if (doc->CurrentOrientationType() !=
       orientation->DeviceType(CallerType::System)) {
     doc->SetCurrentOrientation(orientation->DeviceType(CallerType::System),
                                orientation->DeviceAngle(CallerType::System));
 
-    nsCOMPtr<nsIRunnable> runnable = orientation->DispatchChangeEventAndResolvePromise();
+    nsCOMPtr<nsIRunnable> runnable =
+        orientation->DispatchChangeEventAndResolvePromise();
     rv = NS_DispatchToMainThread(runnable);
     if (NS_WARN_IF(rv.Failed())) {
       return rv.StealNSResult();
     }
   }
 
   return NS_OK;
 }
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -7233,18 +7233,17 @@ void nsContentUtils::SetKeyboardIndicato
   CallOnAllRemoteChildren(aWindow, SetKeyboardIndicatorsChild,
                           (void*)&stateInfo);
 }
 
 nsresult nsContentUtils::IPCTransferableToTransferable(
     const IPCDataTransfer& aDataTransfer, const bool& aIsPrivateData,
     nsIPrincipal* aRequestingPrincipal,
     const nsContentPolicyType& aContentPolicyType,
-    nsITransferable* aTransferable,
-    mozilla::dom::ContentParent* aContentParent,
+    nsITransferable* aTransferable, mozilla::dom::ContentParent* aContentParent,
     mozilla::dom::TabChild* aTabChild) {
   nsresult rv;
 
   const nsTArray<IPCDataTransferItem>& items = aDataTransfer.items();
   for (const auto& item : items) {
     aTransferable->AddDataFlavor(item.flavor().get());
 
     if (item.data().type() == IPCDataTransferData::TnsString) {
--- a/dom/base/nsContentUtils.h
+++ b/dom/base/nsContentUtils.h
@@ -2840,18 +2840,17 @@ class nsContentUtils {
   static void TransferablesToIPCTransferables(
       nsIArray* aTransferables, nsTArray<mozilla::dom::IPCDataTransfer>& aIPC,
       bool aInSyncMessage, mozilla::dom::ContentChild* aChild,
       mozilla::dom::ContentParent* aParent);
 
   static void TransferableToIPCTransferable(
       nsITransferable* aTransferable,
       mozilla::dom::IPCDataTransfer* aIPCDataTransfer, bool aInSyncMessage,
-      mozilla::dom::ContentChild* aChild,
-      mozilla::dom::ContentParent* aParent);
+      mozilla::dom::ContentChild* aChild, mozilla::dom::ContentParent* aParent);
 
   /*
    * Get the pixel data from the given source surface and return it as a buffer.
    * The length and stride will be assigned from the surface.
    */
   static mozilla::UniquePtr<char[]> GetSurfaceData(
       mozilla::NotNull<mozilla::gfx::DataSourceSurface*> aSurface,
       size_t* aLength, int32_t* aStride);
--- a/dom/base/nsGlobalWindowCommands.cpp
+++ b/dom/base/nsGlobalWindowCommands.cpp
@@ -471,18 +471,18 @@ class nsClipboardCommand final : public 
 NS_IMPL_ISUPPORTS(nsClipboardCommand, nsIControllerCommand)
 
 nsresult nsClipboardCommand::IsCommandEnabled(const char *aCommandName,
                                               nsISupports *aContext,
                                               bool *outCmdEnabled) {
   NS_ENSURE_ARG_POINTER(outCmdEnabled);
   *outCmdEnabled = false;
 
-  if (strcmp(aCommandName, "cmd_copy") &&
-      strcmp(aCommandName, "cmd_cut") && strcmp(aCommandName, "cmd_paste")) {
+  if (strcmp(aCommandName, "cmd_copy") && strcmp(aCommandName, "cmd_cut") &&
+      strcmp(aCommandName, "cmd_paste")) {
     return NS_OK;
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aContext);
   NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
   RefPtr<Document> doc = window->GetExtantDoc();
   NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
 
--- a/dom/base/nsINode.h
+++ b/dom/base/nsINode.h
@@ -1073,20 +1073,20 @@ class nsINode : public mozilla::dom::Eve
            NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE | NODE_DESCENDANTS_NEED_FRAMES |
            NODE_NEEDS_FRAME | NODE_HAS_BEEN_IN_UA_WIDGET)) ||
             IsContent(),
         "Flag only permitted on nsIContent nodes");
     nsWrapperCache::SetFlags(aFlagsToSet);
   }
 
   void UnsetFlags(FlagsType aFlagsToUnset) {
-    NS_ASSERTION(!(aFlagsToUnset & (NODE_IS_ANONYMOUS_ROOT |
-                                    NODE_HAS_BEEN_IN_UA_WIDGET |
-                                    NODE_IS_NATIVE_ANONYMOUS_ROOT)),
-                 "Trying to unset write-only flags");
+    NS_ASSERTION(
+        !(aFlagsToUnset & (NODE_IS_ANONYMOUS_ROOT | NODE_HAS_BEEN_IN_UA_WIDGET |
+                           NODE_IS_NATIVE_ANONYMOUS_ROOT)),
+        "Trying to unset write-only flags");
     nsWrapperCache::UnsetFlags(aFlagsToUnset);
   }
 
   void SetEditableFlag(bool aEditable) {
     if (aEditable) {
       SetFlags(NODE_IS_EDITABLE);
     } else {
       UnsetFlags(NODE_IS_EDITABLE);
--- a/dom/base/nsObjectLoadingContent.cpp
+++ b/dom/base/nsObjectLoadingContent.cpp
@@ -519,18 +519,19 @@ bool nsObjectLoadingContent::MakePluginL
 }
 
 // Helper to spawn the frameloader.
 void nsObjectLoadingContent::SetupFrameLoader(int32_t aJSPluginId) {
   nsCOMPtr<nsIContent> thisContent =
       do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
   NS_ASSERTION(thisContent, "must be a content");
 
-  mFrameLoader = nsFrameLoader::Create(thisContent->AsElement(),
-                                       /* aOpener = */ nullptr, mNetworkCreated);
+  mFrameLoader =
+      nsFrameLoader::Create(thisContent->AsElement(),
+                            /* aOpener = */ nullptr, mNetworkCreated);
   MOZ_ASSERT(mFrameLoader, "nsFrameLoader::Create failed");
 }
 
 // Helper to spawn the frameloader and return a pointer to its docshell.
 already_AddRefed<nsIDocShell> nsObjectLoadingContent::SetupDocShell(
     nsIURI* aRecursionCheckURI) {
   SetupFrameLoader(nsFakePluginTag::NOT_JSPLUGIN);
   if (!mFrameLoader) {
@@ -1051,18 +1052,18 @@ nsObjectLoadingContent::OnDataAvailable(
                                         uint64_t aOffset, uint32_t aCount) {
   if (aRequest != mChannel) {
     return NS_BINDING_ABORTED;
   }
 
   if (mFinalListener) {
     // This may re-enter in the case of plugin listeners
     nsCOMPtr<nsIStreamListener> listenerGrip(mFinalListener);
-    return listenerGrip->OnDataAvailable(aRequest, aInputStream,
-                                         aOffset, aCount);
+    return listenerGrip->OnDataAvailable(aRequest, aInputStream, aOffset,
+                                         aCount);
   }
 
   // We shouldn't have a connected channel with no final listener
   MOZ_ASSERT_UNREACHABLE(
       "Got data for channel with no connected final "
       "listener");
   mChannel = nullptr;
 
@@ -2151,17 +2152,19 @@ nsresult nsObjectLoadingContent::LoadObj
              static_cast<uint32_t>(rv)));
       }
       break;
     case eType_Null:
       // Handled below, silence compiler warnings
       break;
     case eType_FakePlugin:
       // We're now in the process of removing FakePlugin. See bug 1529133.
-      MOZ_CRASH("Shouldn't reach here! This means there's a fakeplugin trying to be loaded.");
+      MOZ_CRASH(
+          "Shouldn't reach here! This means there's a fakeplugin trying to be "
+          "loaded.");
   }
 
   //
   // Loaded, handle notifications and fallback
   //
   if (NS_FAILED(rv)) {
     // If we failed in the loading hunk above, switch to fallback
     LOG(("OBJLC [%p]: Loading failed, switching to fallback", this));
--- a/dom/base/nsSyncLoadService.cpp
+++ b/dom/base/nsSyncLoadService.cpp
@@ -96,18 +96,17 @@ nsForceXMLListener::OnStartRequest(nsIRe
   if (channel && NS_SUCCEEDED(status)) {
     channel->SetContentType(NS_LITERAL_CSTRING("text/xml"));
   }
 
   return mListener->OnStartRequest(aRequest);
 }
 
 NS_IMETHODIMP
-nsForceXMLListener::OnStopRequest(nsIRequest *aRequest,
-                                  nsresult aStatusCode) {
+nsForceXMLListener::OnStopRequest(nsIRequest *aRequest, nsresult aStatusCode) {
   return mListener->OnStopRequest(aRequest, aStatusCode);
 }
 
 nsSyncLoader::~nsSyncLoader() {
   if (mLoading && mChannel) {
     mChannel->Cancel(NS_BINDING_ABORTED);
   }
 }
@@ -239,18 +238,17 @@ nsresult nsSyncLoader::PushSyncStream(ns
 }
 
 NS_IMETHODIMP
 nsSyncLoader::OnStartRequest(nsIRequest *aRequest) {
   return mListener->OnStartRequest(aRequest);
 }
 
 NS_IMETHODIMP
-nsSyncLoader::OnStopRequest(nsIRequest *aRequest,
-                            nsresult aStatusCode) {
+nsSyncLoader::OnStopRequest(nsIRequest *aRequest, nsresult aStatusCode) {
   if (NS_SUCCEEDED(mAsyncLoadStatus) && NS_FAILED(aStatusCode)) {
     mAsyncLoadStatus = aStatusCode;
   }
   nsresult rv = mListener->OnStopRequest(aRequest, aStatusCode);
   if (NS_SUCCEEDED(mAsyncLoadStatus) && NS_FAILED(rv)) {
     mAsyncLoadStatus = rv;
   }
   mLoading = false;
@@ -341,18 +339,17 @@ nsresult nsSyncLoadService::PushSyncStre
           rv = NS_OK;
         }
         break;
       }
 
       if (readCount > UINT32_MAX) readCount = UINT32_MAX;
 
       rv = aListener->OnDataAvailable(
-          aChannel, in,
-          (uint32_t)std::min(sourceOffset, (uint64_t)UINT32_MAX),
+          aChannel, in, (uint32_t)std::min(sourceOffset, (uint64_t)UINT32_MAX),
           (uint32_t)readCount);
       if (NS_FAILED(rv)) {
         break;
       }
       sourceOffset += readCount;
     }
   }
   if (NS_FAILED(rv)) {
--- a/dom/bindings/Exceptions.cpp
+++ b/dom/bindings/Exceptions.cpp
@@ -457,18 +457,18 @@ void JSStackFrame::GetName(JSContext* aC
 
 int32_t JSStackFrame::GetSourceId(JSContext* aCx) {
   if (!mStack) {
     return 0;
   }
 
   uint32_t id;
   bool canCache = false, useCachedValue = false;
-  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameSourceId, mSourceIdInitialized,
-                      &canCache, &useCachedValue, &id);
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameSourceId,
+                      mSourceIdInitialized, &canCache, &useCachedValue, &id);
 
   if (useCachedValue) {
     return mSourceId;
   }
 
   if (canCache) {
     mSourceId = id;
     mSourceIdInitialized = true;
--- a/dom/bindings/nsScriptError.cpp
+++ b/dom/bindings/nsScriptError.cpp
@@ -401,25 +401,27 @@ bool nsScriptErrorBase::ComputeIsFromPri
   nsIPrincipal* winPrincipal = aWindow->GetPrincipal();
   return aWindow->IsPrivateBrowsing() &&
          !nsContentUtils::IsSystemPrincipal(winPrincipal);
 }
 
 NS_IMPL_ISUPPORTS(nsScriptError, nsIConsoleMessage, nsIScriptError)
 
 nsScriptErrorNote::nsScriptErrorNote()
-: mMessage(), mSourceName(), mSourceId(0), mLineNumber(0), mColumnNumber(0) {}
+    : mMessage(),
+      mSourceName(),
+      mSourceId(0),
+      mLineNumber(0),
+      mColumnNumber(0) {}
 
 nsScriptErrorNote::~nsScriptErrorNote() {}
 
 void nsScriptErrorNote::Init(const nsAString& message,
-                             const nsAString& sourceName,
-                             uint32_t sourceId,
-                             uint32_t lineNumber,
-                             uint32_t columnNumber) {
+                             const nsAString& sourceName, uint32_t sourceId,
+                             uint32_t lineNumber, uint32_t columnNumber) {
   mMessage.Assign(message);
   AssignSourceNameHelper(mSourceName, sourceName);
   mSourceId = sourceId;
   mLineNumber = lineNumber;
   mColumnNumber = columnNumber;
 }
 
 // nsIScriptErrorNote methods
--- a/dom/cache/DBSchema.cpp
+++ b/dom/cache/DBSchema.cpp
@@ -2497,19 +2497,19 @@ nsresult ReadResponse(mozIStorageConnect
 
     nsCString baseDomain;
     rv = url->BaseDomain(baseDomain);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     aSavedResponseOut->mValue.principalInfo() =
-        Some(mozilla::ipc::ContentPrincipalInfo(
-            attrs, origin, specNoSuffix, Nothing(), std::move(policies),
-            baseDomain));
+        Some(mozilla::ipc::ContentPrincipalInfo(attrs, origin, specNoSuffix,
+                                                Nothing(), std::move(policies),
+                                                baseDomain));
   }
 
   bool nullPadding = false;
   rv = state->GetIsNull(6, &nullPadding);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
--- a/dom/canvas/CanvasImageCache.cpp
+++ b/dom/canvas/CanvasImageCache.cpp
@@ -39,18 +39,17 @@ struct ImageCacheKey {
  */
 struct ImageCacheEntryData {
   ImageCacheEntryData(const ImageCacheEntryData& aOther)
       : mImage(aOther.mImage),
         mCanvas(aOther.mCanvas),
         mSourceSurface(aOther.mSourceSurface),
         mSize(aOther.mSize) {}
   explicit ImageCacheEntryData(const ImageCacheKey& aKey)
-      : mImage(aKey.mImage),
-        mCanvas(aKey.mCanvas) {}
+      : mImage(aKey.mImage), mCanvas(aKey.mCanvas) {}
 
   nsExpirationState* GetExpirationState() { return &mState; }
   size_t SizeInBytes() { return mSize.width * mSize.height * 4; }
 
   // Key
   nsCOMPtr<imgIContainer> mImage;
   HTMLCanvasElement* mCanvas;
   // Value
@@ -82,39 +81,35 @@ class ImageCacheEntry : public PLDHashEn
 
   nsAutoPtr<ImageCacheEntryData> mData;
 };
 
 /**
  * Used for all images across all canvases.
  */
 struct AllCanvasImageCacheKey {
-  explicit AllCanvasImageCacheKey(imgIContainer* aImage)
-      : mImage(aImage) {}
+  explicit AllCanvasImageCacheKey(imgIContainer* aImage) : mImage(aImage) {}
 
   nsCOMPtr<imgIContainer> mImage;
 };
 
 class AllCanvasImageCacheEntry : public PLDHashEntryHdr {
  public:
   typedef AllCanvasImageCacheKey KeyType;
   typedef const AllCanvasImageCacheKey* KeyTypePointer;
 
   explicit AllCanvasImageCacheEntry(const KeyType* aKey)
       : mImage(aKey->mImage) {}
 
   AllCanvasImageCacheEntry(const AllCanvasImageCacheEntry& toCopy)
-      : mImage(toCopy.mImage),
-        mSourceSurface(toCopy.mSourceSurface) {}
+      : mImage(toCopy.mImage), mSourceSurface(toCopy.mSourceSurface) {}
 
   ~AllCanvasImageCacheEntry() {}
 
-  bool KeyEquals(KeyTypePointer key) const {
-    return mImage == key->mImage;
-  }
+  bool KeyEquals(KeyTypePointer key) const { return mImage == key->mImage; }
 
   static KeyTypePointer KeyToPointer(KeyType& key) { return &key; }
   static PLDHashNumber HashKey(KeyTypePointer key) {
     return HashGeneric(key->mImage.get());
   }
   enum { ALLOW_MEMMOVE = true };
 
   nsCOMPtr<imgIContainer> mImage;
@@ -134,18 +129,17 @@ class ImageCache final : public nsExpira
   ~ImageCache();
 
   virtual void NotifyExpired(ImageCacheEntryData* aObject) override {
     mTotal -= aObject->SizeInBytes();
     RemoveObject(aObject);
 
     // Remove from the all canvas cache entry first since nsExpirationTracker
     // will delete aObject.
-    mAllCanvasCache.RemoveEntry(
-        AllCanvasImageCacheKey(aObject->mImage));
+    mAllCanvasCache.RemoveEntry(AllCanvasImageCacheKey(aObject->mImage));
 
     // Deleting the entry will delete aObject since the entry owns aObject.
     mCache.RemoveEntry(ImageCacheKey(aObject->mImage, aObject->mCanvas));
   }
 
   nsTHashtable<ImageCacheEntry> mCache;
   nsTHashtable<AllCanvasImageCacheEntry> mAllCanvasCache;
   size_t mTotal;
@@ -332,18 +326,18 @@ SourceSurface* CanvasImageCache::LookupC
     return nullptr;
   }
 
   nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage);
   if (!imgContainer) {
     return nullptr;
   }
 
-  ImageCacheEntry* entry = gImageCache->mCache.GetEntry(
-      ImageCacheKey(imgContainer, aCanvas));
+  ImageCacheEntry* entry =
+      gImageCache->mCache.GetEntry(ImageCacheKey(imgContainer, aCanvas));
   if (!entry) {
     return nullptr;
   }
 
   MOZ_ASSERT(aSizeOut);
 
   gImageCache->MarkUsed(entry->mData);
   *aSizeOut = entry->mData->mSize;
--- a/dom/canvas/CanvasImageCache.h
+++ b/dom/canvas/CanvasImageCache.h
@@ -28,17 +28,18 @@ class CanvasImageCache {
  public:
   /**
    * Notify that image element aImage was drawn to aCanvas element
    * using the first frame of aRequest's image. The data for the surface is
    * in aSurface, and the image size is in aSize.
    */
   static void NotifyDrawImage(dom::Element* aImage,
                               dom::HTMLCanvasElement* aCanvas,
-                              SourceSurface* aSource, const gfx::IntSize& aSize);
+                              SourceSurface* aSource,
+                              const gfx::IntSize& aSize);
 
   /**
    * Check whether aImage has recently been drawn any canvas. If we return
    * a non-null surface, then the same image was recently drawn into a canvas.
    */
   static SourceSurface* LookupAllCanvas(dom::Element* aImage);
 
   /**
--- a/dom/canvas/CanvasRenderingContext2D.h
+++ b/dom/canvas/CanvasRenderingContext2D.h
@@ -602,19 +602,18 @@ class CanvasRenderingContext2D final : p
   /**
    * Create the backing surfacing, if it doesn't exist. If there is an error
    * in creating the target then it will put sErrorTarget in place. If there
    * is in turn an error in creating the sErrorTarget then they would both
    * be null so IsTargetValid() would still return null.
    *
    * Returns true on success.
    */
-  bool EnsureTarget(
-      const gfx::Rect* aCoveredRect = nullptr,
-      bool aWillClear = false);
+  bool EnsureTarget(const gfx::Rect* aCoveredRect = nullptr,
+                    bool aWillClear = false);
 
   void RestoreClipsAndTransformToTarget();
 
   bool TrySharedTarget(RefPtr<gfx::DrawTarget>& aOutDT,
                        RefPtr<layers::PersistentBufferProvider>& aOutProvider);
 
   bool TryBasicTarget(RefPtr<gfx::DrawTarget>& aOutDT,
                       RefPtr<layers::PersistentBufferProvider>& aOutProvider);
--- a/dom/canvas/WebGLExtensions.cpp
+++ b/dom/canvas/WebGLExtensions.cpp
@@ -47,24 +47,26 @@ bool WebGLExtensionFloatBlend::IsSupport
   return !gl->IsGLES() || gl->IsANGLE() ||
          gl->IsExtensionSupported(gl::GLContext::EXT_float_blend);
 }
 
 IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionFloatBlend, EXT_float_blend)
 
 // -
 
-WebGLExtensionFBORenderMipmap::WebGLExtensionFBORenderMipmap(WebGLContext* const webgl)
+WebGLExtensionFBORenderMipmap::WebGLExtensionFBORenderMipmap(
+    WebGLContext* const webgl)
     : WebGLExtensionBase(webgl) {
   MOZ_ASSERT(IsSupported(webgl), "Don't construct extension if unsupported.");
 }
 
 WebGLExtensionFBORenderMipmap::~WebGLExtensionFBORenderMipmap() = default;
 
-bool WebGLExtensionFBORenderMipmap::IsSupported(const WebGLContext* const webgl) {
+bool WebGLExtensionFBORenderMipmap::IsSupported(
+    const WebGLContext* const webgl) {
   if (webgl->IsWebGL2()) return false;
   if (!gfxPrefs::WebGLDraftExtensionsEnabled()) return false;
 
   const auto& gl = webgl->gl;
   if (!gl->IsGLES()) return true;
   if (gl->Version() >= 300) return true;
   return gl->IsExtensionSupported(gl::GLContext::OES_fbo_render_mipmap);
 }
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -5584,17 +5584,18 @@ nsresult EventStateManager::DoContentCom
         case eContentCommandPasteTransferable: {
           nsFocusManager* fm = nsFocusManager::GetFocusManager();
           nsIContent* focusedContent = fm ? fm->GetFocusedElement() : nullptr;
           RefPtr<TabParent> remote = TabParent::GetFrom(focusedContent);
           if (remote) {
             nsCOMPtr<nsITransferable> transferable = aEvent->mTransferable;
             IPCDataTransfer ipcDataTransfer;
             nsContentUtils::TransferableToIPCTransferable(
-                transferable, &ipcDataTransfer, false, nullptr, remote->Manager());
+                transferable, &ipcDataTransfer, false, nullptr,
+                remote->Manager());
             bool isPrivateData = transferable->GetIsPrivateData();
             nsCOMPtr<nsIPrincipal> requestingPrincipal =
                 transferable->GetRequestingPrincipal();
             nsContentPolicyType contentPolicyType =
                 transferable->GetContentPolicyType();
             remote->SendPasteTransferable(ipcDataTransfer, isPrivateData,
                                           IPC::Principal(requestingPrincipal),
                                           contentPolicyType);
--- a/dom/fetch/FetchDriver.cpp
+++ b/dom/fetch/FetchDriver.cpp
@@ -259,18 +259,18 @@ AlternativeDataStreamListener::OnDataAva
   if (mStatus == AlternativeDataStreamListener::LOADING) {
     MOZ_ASSERT(mPipeAlternativeOutputStream);
     uint32_t read;
     return aInputStream->ReadSegments(
         NS_CopySegmentToStream, mPipeAlternativeOutputStream, aCount, &read);
   }
   if (mStatus == AlternativeDataStreamListener::FALLBACK) {
     MOZ_ASSERT(mFetchDriver);
-    return mFetchDriver->OnDataAvailable(aRequest, aInputStream,
-                                         aOffset, aCount);
+    return mFetchDriver->OnDataAvailable(aRequest, aInputStream, aOffset,
+                                         aCount);
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 AlternativeDataStreamListener::OnStopRequest(nsIRequest* aRequest,
                                              nsresult aStatusCode) {
   AssertIsOnMainThread();
@@ -1146,19 +1146,18 @@ nsresult CopySegmentToStreamAndSRI(nsIIn
     *aCountWritten += n;
   }
   return NS_OK;
 }
 
 }  // anonymous namespace
 
 NS_IMETHODIMP
-FetchDriver::OnDataAvailable(nsIRequest* aRequest,
-                             nsIInputStream* aInputStream, uint64_t aOffset,
-                             uint32_t aCount) {
+FetchDriver::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInputStream,
+                             uint64_t aOffset, uint32_t aCount) {
   // NB: This can be called on any thread!  But we're guaranteed that it is
   // called between OnStartRequest and OnStopRequest, so we don't need to worry
   // about races.
 
   if (mNeedToObserveOnDataAvailable) {
     mNeedToObserveOnDataAvailable = false;
     if (mObserver) {
       if (NS_IsMainThread()) {
@@ -1203,18 +1202,17 @@ FetchDriver::OnDataAvailable(nsIRequest*
   // So we must just assume the pipe is broken.
   if (aRead == 0 && aCount != 0) {
     return NS_BASE_STREAM_CLOSED;
   }
   return rv;
 }
 
 NS_IMETHODIMP
-FetchDriver::OnStopRequest(nsIRequest* aRequest,
-                           nsresult aStatusCode) {
+FetchDriver::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
   AssertIsOnMainThread();
 
   MOZ_DIAGNOSTIC_ASSERT(!mOnStopRequestCalled);
   mOnStopRequestCalled = true;
 
   // main data loading is going to finish, breaking the reference cycle.
   RefPtr<AlternativeDataStreamListener> altDataListener =
       mAltDataListener.forget();
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -712,18 +712,17 @@ HTMLMediaElement::MediaLoadListener::OnD
                                                      uint64_t aOffset,
                                                      uint32_t aCount) {
   if (!mNextListener) {
     NS_ERROR(
         "Must have a chained listener; OnStartRequest should have "
         "canceled this request");
     return NS_BINDING_ABORTED;
   }
-  return mNextListener->OnDataAvailable(aRequest, aStream, aOffset,
-                                        aCount);
+  return mNextListener->OnDataAvailable(aRequest, aStream, aOffset, aCount);
 }
 
 NS_IMETHODIMP
 HTMLMediaElement::MediaLoadListener::AsyncOnChannelRedirect(
     nsIChannel* aOldChannel, nsIChannel* aNewChannel, uint32_t aFlags,
     nsIAsyncVerifyRedirectCallback* cb) {
   // TODO is this really correct?? See bug #579329.
   if (mElement) {
--- a/dom/html/ImageDocument.cpp
+++ b/dom/html/ImageDocument.cpp
@@ -123,18 +123,17 @@ ImageListener::OnStartRequest(nsIRequest
     imgDoc->mObservingImageLoader = true;
     imageLoader->LoadImageWithChannel(channel, getter_AddRefs(mNextStream));
   }
 
   return MediaDocumentStreamListener::OnStartRequest(request);
 }
 
 NS_IMETHODIMP
-ImageListener::OnStopRequest(nsIRequest* aRequest,
-                             nsresult aStatus) {
+ImageListener::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   ImageDocument* imgDoc = static_cast<ImageDocument*>(mDocument.get());
   nsContentUtils::DispatchChromeEvent(imgDoc, ToSupports(imgDoc),
                                       NS_LITERAL_STRING("ImageContentLoaded"),
                                       CanBubble::eYes, Cancelable::eYes);
   return MediaDocumentStreamListener::OnStopRequest(aRequest, aStatus);
 }
 
 ImageDocument::ImageDocument()
--- a/dom/html/MediaDocument.cpp
+++ b/dom/html/MediaDocument.cpp
@@ -84,18 +84,17 @@ MediaDocumentStreamListener::OnStopReque
 }
 
 NS_IMETHODIMP
 MediaDocumentStreamListener::OnDataAvailable(nsIRequest* request,
                                              nsIInputStream* inStr,
                                              uint64_t sourceOffset,
                                              uint32_t count) {
   if (mNextStream) {
-    return mNextStream->OnDataAvailable(request, inStr, sourceOffset,
-                                        count);
+    return mNextStream->OnDataAvailable(request, inStr, sourceOffset, count);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 MediaDocumentStreamListener::CheckListenerChain() {
   nsCOMPtr<nsIThreadRetargetableStreamListener> retargetable =
--- a/dom/html/nsGenericHTMLElement.h
+++ b/dom/html/nsGenericHTMLElement.h
@@ -614,18 +614,17 @@ class nsGenericHTMLElement : public nsGe
 
   static bool MatchLabelsElement(Element* aElement, int32_t aNamespaceID,
                                  nsAtom* aAtom, void* aData);
 
   already_AddRefed<nsINodeList> Labels();
 
   virtual bool IsInteractiveHTMLContent(bool aIgnoreTabindex) const override;
 
-  static bool LegacyTouchAPIEnabled(JSContext* aCx,
-                                    JSObject* aObj);
+  static bool LegacyTouchAPIEnabled(JSContext* aCx, JSObject* aObj);
 
   static inline bool CanHaveName(nsAtom* aTag) {
     return aTag == nsGkAtoms::img || aTag == nsGkAtoms::form ||
            aTag == nsGkAtoms::embed || aTag == nsGkAtoms::object;
   }
   static inline bool ShouldExposeNameAsHTMLDocumentProperty(Element* aElement) {
     return aElement->IsHTMLElement() &&
            CanHaveName(aElement->NodeInfo()->NameAtom());
--- a/dom/jsurl/nsJSProtocolHandler.cpp
+++ b/dom/jsurl/nsJSProtocolHandler.cpp
@@ -940,28 +940,25 @@ nsJSChannel::SetContentLength(int64_t aC
 NS_IMETHODIMP
 nsJSChannel::OnStartRequest(nsIRequest* aRequest) {
   NS_ENSURE_TRUE(aRequest == mStreamChannel, NS_ERROR_UNEXPECTED);
 
   return mListener->OnStartRequest(this);
 }
 
 NS_IMETHODIMP
-nsJSChannel::OnDataAvailable(nsIRequest* aRequest,
-                             nsIInputStream* aInputStream, uint64_t aOffset,
-                             uint32_t aCount) {
+nsJSChannel::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInputStream,
+                             uint64_t aOffset, uint32_t aCount) {
   NS_ENSURE_TRUE(aRequest == mStreamChannel, NS_ERROR_UNEXPECTED);
 
-  return mListener->OnDataAvailable(this, aInputStream, aOffset,
-                                    aCount);
+  return mListener->OnDataAvailable(this, aInputStream, aOffset, aCount);
 }
 
 NS_IMETHODIMP
-nsJSChannel::OnStopRequest(nsIRequest* aRequest,
-                           nsresult aStatus) {
+nsJSChannel::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   NS_ENSURE_TRUE(aRequest == mStreamChannel, NS_ERROR_UNEXPECTED);
 
   nsCOMPtr<nsIStreamListener> listener = mListener;
 
   CleanupStrongRefs();
 
   // Make sure aStatus matches what GetStatus() returns
   if (NS_FAILED(mStatus)) {
--- a/dom/localstorage/ActorsParent.cpp
+++ b/dom/localstorage/ActorsParent.cpp
@@ -3200,19 +3200,18 @@ bool VerifyRequestParams(const Maybe<Con
       }
       break;
     }
 
     case LSRequestParams::TLSRequestPrepareObserverParams: {
       const LSRequestPrepareObserverParams& params =
           aParams.get_LSRequestPrepareObserverParams();
 
-      if (NS_WARN_IF(!VerifyPrincipalInfo(aContentParentId,
-                                          params.principalInfo(),
-                                          params.clientId()))) {
+      if (NS_WARN_IF(!VerifyPrincipalInfo(
+              aContentParentId, params.principalInfo(), params.clientId()))) {
         ASSERT_UNLESS_FUZZING();
         return false;
       }
       break;
     }
 
     default:
       MOZ_CRASH("Should never get here!");
@@ -3324,18 +3323,17 @@ bool VerifyRequestParams(const Maybe<Con
   MOZ_ASSERT(aParams.type() != LSSimpleRequestParams::T__None);
 
   switch (aParams.type()) {
     case LSSimpleRequestParams::TLSSimpleRequestPreloadedParams: {
       const LSSimpleRequestPreloadedParams& params =
           aParams.get_LSSimpleRequestPreloadedParams();
 
       if (NS_WARN_IF(!VerifyPrincipalInfo(aContentParentId,
-                                          params.principalInfo(),
-                                          Nothing()))) {
+                                          params.principalInfo(), Nothing()))) {
         ASSERT_UNLESS_FUZZING();
         return false;
       }
       break;
     }
 
     default:
       MOZ_CRASH("Should never get here!");
--- a/dom/localstorage/LSObject.cpp
+++ b/dom/localstorage/LSObject.cpp
@@ -212,18 +212,18 @@ void LSObject::Initialize() {
         PBackgroundChild* backgroundActor =
             BackgroundChild::GetOrCreateForCurrentThread();
 
         if (NS_WARN_IF(!backgroundActor)) {
           return;
         }
       });
 
-  if (NS_WARN_IF(NS_FAILED(domFileThread->Dispatch(runnable,
-                                                   NS_DISPATCH_NORMAL)))) {
+  if (NS_WARN_IF(
+          NS_FAILED(domFileThread->Dispatch(runnable, NS_DISPATCH_NORMAL)))) {
     return;
   }
 }
 
 // static
 nsresult LSObject::CreateForWindow(nsPIDOMWindowInner* aWindow,
                                    Storage** aStorage) {
   MOZ_ASSERT(NS_IsMainThread());
@@ -414,19 +414,20 @@ void LSObject::OnSyncMessageHandled() {
   gPendingSyncMessage = false;
 }
 
 LSRequestChild* LSObject::StartRequest(nsIEventTarget* aMainEventTarget,
                                        const LSRequestParams& aParams,
                                        LSRequestChildCallback* aCallback) {
   AssertIsOnDOMFileThread();
 
-  PBackgroundChild* backgroundActor = XRE_IsParentProcess() ?
-      BackgroundChild::GetOrCreateForCurrentThread(aMainEventTarget) :
-      BackgroundChild::GetForCurrentThread();
+  PBackgroundChild* backgroundActor =
+      XRE_IsParentProcess()
+          ? BackgroundChild::GetOrCreateForCurrentThread(aMainEventTarget)
+          : BackgroundChild::GetForCurrentThread();
   if (NS_WARN_IF(!backgroundActor)) {
     return nullptr;
   }
 
   LSRequestChild* actor = new LSRequestChild(aCallback);
 
   backgroundActor->SendPBackgroundLSRequestConstructor(actor, aParams);
 
@@ -1042,19 +1043,19 @@ nsresult RequestHelper::StartAndReturnRe
 
     const nsLocalExecutionGuard localExecution(thread->EnterLocalExecution());
     mNestedEventTarget = localExecution.GetEventTarget();
     MOZ_ASSERT(mNestedEventTarget);
 
     mNestedEventTargetWrapper =
         new NestedEventTargetWrapper(mNestedEventTarget);
 
-    nsCOMPtr<nsIEventTarget> domFileThread = XRE_IsParentProcess() ?
-        IPCBlobInputStreamThread::GetOrCreate() :
-        IPCBlobInputStreamThread::Get();
+    nsCOMPtr<nsIEventTarget> domFileThread =
+        XRE_IsParentProcess() ? IPCBlobInputStreamThread::GetOrCreate()
+                              : IPCBlobInputStreamThread::Get();
     if (NS_WARN_IF(!domFileThread)) {
       return NS_ERROR_FAILURE;
     }
 
     nsresult rv;
 
     {
       {
--- a/dom/media/ChannelMediaResource.cpp
+++ b/dom/media/ChannelMediaResource.cpp
@@ -62,18 +62,18 @@ nsresult ChannelMediaResource::Listener:
 nsresult ChannelMediaResource::Listener::OnStopRequest(nsIRequest* aRequest,
                                                        nsresult aStatus) {
   MOZ_ASSERT(NS_IsMainThread());
   if (!mResource) return NS_OK;
   return mResource->OnStopRequest(aRequest, aStatus);
 }
 
 nsresult ChannelMediaResource::Listener::OnDataAvailable(
-    nsIRequest* aRequest, nsIInputStream* aStream,
-    uint64_t aOffset, uint32_t aCount) {
+    nsIRequest* aRequest, nsIInputStream* aStream, uint64_t aOffset,
+    uint32_t aCount) {
   // This might happen off the main thread.
   RefPtr<ChannelMediaResource> res;
   {
     MutexAutoLock lock(mMutex);
     res = mResource;
   }
   // Note Rekove() might happen at the same time to reset mResource. We check
   // the load ID to determine if the data is from an old channel.
--- a/dom/media/CubebUtils.cpp
+++ b/dom/media/CubebUtils.cpp
@@ -49,17 +49,18 @@
 #define PREF_CUBEB_FORCE_NULL_CONTEXT "media.cubeb.force_null_context"
 // Hidden pref to disable BMO 1427011 experiment; can be removed once proven.
 #define PREF_CUBEB_DISABLE_DEVICE_SWITCHING \
   "media.cubeb.disable_device_switching"
 #define PREF_CUBEB_SANDBOX "media.cubeb.sandbox"
 #define PREF_AUDIOIPC_POOL_SIZE "media.audioipc.pool_size"
 #define PREF_AUDIOIPC_STACK_SIZE "media.audioipc.stack_size"
 
-#if (defined(XP_LINUX) && !defined(MOZ_WIDGET_ANDROID)) || defined(XP_MACOSX) || (defined(XP_WIN) && !defined(_ARM64_))
+#if (defined(XP_LINUX) && !defined(MOZ_WIDGET_ANDROID)) || \
+    defined(XP_MACOSX) || (defined(XP_WIN) && !defined(_ARM64_))
 #  define MOZ_CUBEB_REMOTING
 #endif
 
 extern "C" {
 
 // This must match AudioIpcInitParams in media/audioipc/client/src/lib.rs.
 // TODO: Generate this from the Rust definition rather than duplicating it.
 struct AudioIpcInitParams {
--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -3079,17 +3079,16 @@ RefPtr<MediaManager::StreamPromise> Medi
 
   return MediaManager::GetUserMedia(aWindow, c, aCallerType);
 }
 
 /* static */
 void MediaManager::AnonymizeDevices(MediaDeviceSet& aDevices,
                                     const nsACString& aOriginKey,
                                     const uint64_t aWindowId) {
-
   if (!aOriginKey.IsEmpty()) {
     for (RefPtr<MediaDevice>& device : aDevices) {
       nsString id;
       device->GetId(id);
       nsString rawId(id);
       AnonymizeId(id, aOriginKey);
 
       nsString groupId;
--- a/dom/media/VideoFrameContainer.cpp
+++ b/dom/media/VideoFrameContainer.cpp
@@ -137,17 +137,18 @@ void VideoFrameContainer::SetCurrentFram
     Image* image = frame->GetImage();
     CONTAINER_LOG(
         LogLevel::Verbose,
         ("VideoFrameContainer %p writing video frame %p (%d x %d)", this, image,
          frame->GetIntrinsicSize().width, frame->GetIntrinsicSize().height));
 
     if (frame->GetForceBlack()) {
       if (!mBlackImage) {
-        RefPtr<Image> blackImage = GetImageContainer()->CreatePlanarYCbCrImage();
+        RefPtr<Image> blackImage =
+            GetImageContainer()->CreatePlanarYCbCrImage();
         if (blackImage) {
           // Sets the image to a single black pixel, which will be scaled to
           // fill the rendered size.
           if (SetImageToBlackPixel(blackImage->AsPlanarYCbCrImage())) {
             mBlackImage = blackImage;
           }
         }
       }
--- a/dom/media/WebVTTListener.cpp
+++ b/dom/media/WebVTTListener.cpp
@@ -79,18 +79,17 @@ WebVTTListener::AsyncOnChannelRedirect(n
 
 NS_IMETHODIMP
 WebVTTListener::OnStartRequest(nsIRequest* aRequest) {
   VTT_LOG("WebVTTListener::OnStartRequest\n");
   return NS_OK;
 }
 
 NS_IMETHODIMP
-WebVTTListener::OnStopRequest(nsIRequest* aRequest,
-                              nsresult aStatus) {
+WebVTTListener::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   VTT_LOG("WebVTTListener::OnStopRequest\n");
   if (NS_FAILED(aStatus)) {
     mElement->SetReadyState(TextTrackReadyState::FailedToLoad);
   }
   // Attempt to parse any final data the parser might still have.
   mParserWrapper->Flush();
   if (mElement->ReadyState() != TextTrackReadyState::FailedToLoad) {
     mElement->SetReadyState(TextTrackReadyState::Loaded);
@@ -114,19 +113,18 @@ nsresult WebVTTListener::ParseChunk(nsII
     return NS_ERROR_FAILURE;
   }
 
   *aWriteCount = aCount;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-WebVTTListener::OnDataAvailable(nsIRequest* aRequest,
-                                nsIInputStream* aStream, uint64_t aOffset,
-                                uint32_t aCount) {
+WebVTTListener::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aStream,
+                                uint64_t aOffset, uint32_t aCount) {
   VTT_LOG("WebVTTListener::OnDataAvailable\n");
   uint32_t count = aCount;
   while (count > 0) {
     uint32_t read;
     nsresult rv = aStream->ReadSegments(ParseChunk, this, count, &read);
     NS_ENSURE_SUCCESS(rv, rv);
     if (!read) {
       return NS_ERROR_FAILURE;
--- a/dom/media/webrtc/MediaEngineDefault.cpp
+++ b/dom/media/webrtc/MediaEngineDefault.cpp
@@ -58,19 +58,17 @@ static nsString DefaultVideoName() {
 
 MediaEngineDefaultVideoSource::MediaEngineDefaultVideoSource()
     : mTimer(nullptr),
       mMutex("MediaEngineDefaultVideoSource::mMutex"),
       mName(DefaultVideoName()) {}
 
 MediaEngineDefaultVideoSource::~MediaEngineDefaultVideoSource() {}
 
-nsString MediaEngineDefaultVideoSource::GetName() const {
-  return mName;
-}
+nsString MediaEngineDefaultVideoSource::GetName() const { return mName; }
 
 nsCString MediaEngineDefaultVideoSource::GetUUID() const {
   return NS_LITERAL_CSTRING("1041FCBD-3F12-4F7B-9E9B-1EC556DD5676");
 }
 
 nsString MediaEngineDefaultVideoSource::GetGroupId() const {
   return NS_LITERAL_STRING(u"Default Video Group");
 }
@@ -577,30 +575,30 @@ void MediaEngineDefault::EnumerateDevice
       // in Allocate().
 
       nsTArray<RefPtr<MediaEngineSource>>* devicesForThisWindow =
           mVSources.LookupOrAdd(aWindowId);
       auto newSource = MakeRefPtr<MediaEngineDefaultVideoSource>();
       devicesForThisWindow->AppendElement(newSource);
       aDevices->AppendElement(MakeRefPtr<MediaDevice>(
           newSource, newSource->GetName(),
-          NS_ConvertUTF8toUTF16(newSource->GetUUID()),
-          newSource->GetGroupId(), NS_LITERAL_STRING("")));
+          NS_ConvertUTF8toUTF16(newSource->GetUUID()), newSource->GetGroupId(),
+          NS_LITERAL_STRING("")));
       return;
     }
     case dom::MediaSourceEnum::Microphone: {
       nsTArray<RefPtr<MediaEngineDefaultAudioSource>>* devicesForThisWindow =
           mASources.LookupOrAdd(aWindowId);
       for (const RefPtr<MediaEngineDefaultAudioSource>& source :
            *devicesForThisWindow) {
         if (source->IsAvailable()) {
           aDevices->AppendElement(MakeRefPtr<MediaDevice>(
               source, source->GetName(),
-              NS_ConvertUTF8toUTF16(source->GetUUID()),
-              source->GetGroupId(), NS_LITERAL_STRING("")));
+              NS_ConvertUTF8toUTF16(source->GetUUID()), source->GetGroupId(),
+              NS_LITERAL_STRING("")));
         }
       }
 
       if (aDevices->IsEmpty()) {
         // All streams are currently busy, just make a new one.
         auto newSource = MakeRefPtr<MediaEngineDefaultAudioSource>();
         devicesForThisWindow->AppendElement(newSource);
         aDevices->AppendElement(MakeRefPtr<MediaDevice>(
--- a/dom/media/webrtc/MediaEngineDefault.h
+++ b/dom/media/webrtc/MediaEngineDefault.h
@@ -95,17 +95,17 @@ class MediaEngineDefaultVideoSource : pu
   RefPtr<layers::Image> mImage;
   RefPtr<SourceMediaStream> mStream;
   TrackID mTrackID = TRACK_NONE;
 
   MediaEnginePrefs mOpts;
   int mCb = 16;
   int mCr = 16;
 
-private:
+ private:
   const nsString mName;
 };
 
 class SineWaveGenerator;
 
 class MediaEngineDefaultAudioSource : public MediaEngineSource {
  public:
   MediaEngineDefaultAudioSource();
--- a/dom/media/webrtc/MediaEngineWebRTCAudio.h
+++ b/dom/media/webrtc/MediaEngineWebRTCAudio.h
@@ -23,18 +23,20 @@ class AudioInputProcessing;
 //   the main thread and then the MSG thread so that it can be used as part of
 //   the graph processing. On destruction, similarly, a message is sent to the
 //   graph so that it stops using it, and then it is deleted.
 // - mSettings is created on the MediaManager thread is always ever accessed on
 //   the Main Thread. It is const.
 class MediaEngineWebRTCMicrophoneSource : public MediaEngineSource {
  public:
   MediaEngineWebRTCMicrophoneSource(RefPtr<AudioDeviceInfo> aInfo,
-                                    const nsString& aName, const nsCString& aUuid,
-                                    const nsString& aGroupId, uint32_t aMaxChannelCount,
+                                    const nsString& aName,
+                                    const nsCString& aUuid,
+                                    const nsString& aGroupId,
+                                    uint32_t aMaxChannelCount,
                                     bool aDelayAgnostic, bool aExtendedFilter);
 
   bool RequiresSharing() const override { return false; }
 
   nsString GetName() const override;
   nsCString GetUUID() const override;
   nsString GetGroupId() const override;
 
--- a/dom/network/TCPSocket.cpp
+++ b/dom/network/TCPSocket.cpp
@@ -314,23 +314,20 @@ class CopierCallbacks final : public nsI
   NS_DECL_NSIREQUESTOBSERVER
  private:
   ~CopierCallbacks() {}
 };
 
 NS_IMPL_ISUPPORTS(CopierCallbacks, nsIRequestObserver)
 
 NS_IMETHODIMP
-CopierCallbacks::OnStartRequest(nsIRequest* aRequest) {
-  return NS_OK;
-}
+CopierCallbacks::OnStartRequest(nsIRequest* aRequest) { return NS_OK; }
 
 NS_IMETHODIMP
-CopierCallbacks::OnStopRequest(nsIRequest* aRequest,
-                               nsresult aStatus) {
+CopierCallbacks::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   mOwner->NotifyCopyComplete(aStatus);
   mOwner = nullptr;
   return NS_OK;
 }
 }  // unnamed namespace
 
 nsresult TCPSocket::EnsureCopying() {
   if (mAsyncCopierActive) {
@@ -927,24 +924,21 @@ TCPSocket::OnInputStreamReady(nsIAsyncIn
   nsresult rv = aStream->Available(&dummy);
   if (NS_FAILED(rv)) {
     MaybeReportErrorAndCloseIfOpen(NS_ERROR_CONNECTION_REFUSED);
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
-TCPSocket::OnStartRequest(nsIRequest* aRequest) {
-  return NS_OK;
-}
+TCPSocket::OnStartRequest(nsIRequest* aRequest) { return NS_OK; }
 
 NS_IMETHODIMP
-TCPSocket::OnDataAvailable(nsIRequest* aRequest,
-                           nsIInputStream* aStream, uint64_t aOffset,
-                           uint32_t aCount) {
+TCPSocket::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aStream,
+                           uint64_t aOffset, uint32_t aCount) {
   if (mUseArrayBuffers) {
     nsTArray<uint8_t> buffer;
     buffer.SetCapacity(aCount);
     uint32_t actual;
     nsresult rv = aStream->Read(reinterpret_cast<char*>(buffer.Elements()),
                                 aCount, &actual);
     NS_ENSURE_SUCCESS(rv, rv);
     MOZ_ASSERT(actual == aCount);
@@ -989,18 +983,17 @@ TCPSocket::OnDataAvailable(nsIRequest* a
     return NS_ERROR_FAILURE;
   }
   FireDataEvent(cx, NS_LITERAL_STRING("data"), value);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-TCPSocket::OnStopRequest(nsIRequest* aRequest,
-                         nsresult aStatus) {
+TCPSocket::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   mInputStreamPump = nullptr;
 
   if (mAsyncCopierActive && NS_SUCCEEDED(aStatus)) {
     // If we have some buffered output still, and status is not an
     // error, the other side has done a half-close, but we don't
     // want to be in the close state until we are done sending
     // everything that was buffered. We also don't want to call onclose
     // yet.
--- a/dom/plugins/base/nsPluginStreamListenerPeer.cpp
+++ b/dom/plugins/base/nsPluginStreamListenerPeer.cpp
@@ -271,18 +271,18 @@ nsresult nsPluginStreamListenerPeer::Get
 }
 
 nsresult nsPluginStreamListenerPeer::SetStreamOffset(int32_t value) {
   mStreamOffset = value;
   return NS_OK;
 }
 
 NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(
-    nsIRequest* request, nsIInputStream* aIStream,
-    uint64_t sourceOffset, uint32_t aLength) {
+    nsIRequest* request, nsIInputStream* aIStream, uint64_t sourceOffset,
+    uint32_t aLength) {
   if (mRequests.IndexOfObject(request) == -1) {
     MOZ_ASSERT(false, "Received OnDataAvailable for untracked request.");
     return NS_ERROR_UNEXPECTED;
   }
 
   if (mRequestFailed) return NS_ERROR_FAILURE;
 
   nsresult rv = NS_OK;
--- a/dom/presentation/PresentationTCPSessionTransport.cpp
+++ b/dom/presentation/PresentationTCPSessionTransport.cpp
@@ -39,23 +39,20 @@ class CopierCallbacks final : public nsI
   ~CopierCallbacks() {}
 
   RefPtr<PresentationTCPSessionTransport> mOwner;
 };
 
 NS_IMPL_ISUPPORTS(CopierCallbacks, nsIRequestObserver)
 
 NS_IMETHODIMP
-CopierCallbacks::OnStartRequest(nsIRequest* aRequest) {
-  return NS_OK;
-}
+CopierCallbacks::OnStartRequest(nsIRequest* aRequest) { return NS_OK; }
 
 NS_IMETHODIMP
-CopierCallbacks::OnStopRequest(nsIRequest* aRequest,
-                               nsresult aStatus) {
+CopierCallbacks::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   mOwner->NotifyCopyComplete(aStatus);
   return NS_OK;
 }
 
 NS_IMPL_CYCLE_COLLECTION(PresentationTCPSessionTransport, mTransport,
                          mSocketInputStream, mSocketOutputStream,
                          mInputStreamPump, mInputStreamScriptable, mCallback)
 
--- a/dom/quota/ActorsParent.cpp
+++ b/dom/quota/ActorsParent.cpp
@@ -2121,25 +2121,25 @@ void InitializeQuotaManager() {
       NS_WARNING("Failed to get storage service!");
     }
   }
 
   if (NS_FAILED(QuotaManager::Initialize())) {
     NS_WARNING("Failed to initialize quota manager!");
   }
 
-   if (NS_FAILED(Preferences::AddAtomicIntVarCache(
-           &gFixedLimitKB, PREF_FIXED_LIMIT, kDefaultFixedLimitKB)) ||
-       NS_FAILED(Preferences::AddAtomicUintVarCache(
-           &gChunkSizeKB, PREF_CHUNK_SIZE, kDefaultChunkSizeKB))) {
+  if (NS_FAILED(Preferences::AddAtomicIntVarCache(
+          &gFixedLimitKB, PREF_FIXED_LIMIT, kDefaultFixedLimitKB)) ||
+      NS_FAILED(Preferences::AddAtomicUintVarCache(
+          &gChunkSizeKB, PREF_CHUNK_SIZE, kDefaultChunkSizeKB))) {
     NS_WARNING("Unable to respond to temp storage pref changes!");
   }
 
-   if (NS_FAILED(Preferences::AddAtomicBoolVarCache(
-           &gTestingEnabled, PREF_TESTING_FEATURES, false))) {
+  if (NS_FAILED(Preferences::AddAtomicBoolVarCache(
+          &gTestingEnabled, PREF_TESTING_FEATURES, false))) {
     NS_WARNING("Unable to respond to testing pref changes!");
   }
 
 #ifdef DEBUG
   gQuotaManagerInitialized = true;
 #endif
 }
 
--- a/dom/quota/nsIndexedDBProtocolHandler.cpp
+++ b/dom/quota/nsIndexedDBProtocolHandler.cpp
@@ -32,25 +32,25 @@ NS_IMETHODIMP nsIndexedDBProtocolHandler
 
 NS_IMETHODIMP nsIndexedDBProtocolHandler::GetProtocolFlags(
     uint32_t* aProtocolFlags) {
   *aProtocolFlags = URI_STD | URI_DANGEROUS_TO_LOAD | URI_DOES_NOT_RETURN_DATA |
                     URI_NON_PERSISTABLE;
   return NS_OK;
 }
 
-NS_IMETHODIMP nsIndexedDBProtocolHandler::NewURI(
-    const nsACString& aSpec, const char* aOriginCharset, nsIURI* aBaseURI,
-    nsIURI** _retval) {
+NS_IMETHODIMP nsIndexedDBProtocolHandler::NewURI(const nsACString& aSpec,
+                                                 const char* aOriginCharset,
+                                                 nsIURI* aBaseURI,
+                                                 nsIURI** _retval) {
   nsCOMPtr<nsIURI> baseURI(aBaseURI);
   return NS_MutateURI(new nsStandardURL::Mutator())
-      .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init,
-                              nsIStandardURL::URLTYPE_AUTHORITY, 0,
-                              nsCString(aSpec), aOriginCharset, baseURI,
-                              nullptr))
+      .Apply(NS_MutatorMethod(
+          &nsIStandardURLMutator::Init, nsIStandardURL::URLTYPE_AUTHORITY, 0,
+          nsCString(aSpec), aOriginCharset, baseURI, nullptr))
       .Finalize(_retval);
 }
 
 NS_IMETHODIMP
 nsIndexedDBProtocolHandler::NewChannel(nsIURI* aURI, nsILoadInfo* aLoadInfo,
                                        nsIChannel** _retval) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
--- a/dom/security/ContentVerifier.cpp
+++ b/dom/security/ContentVerifier.cpp
@@ -97,18 +97,18 @@ void ContentVerifier::FinishSignature() 
   uint64_t offset = 0;
   for (uint32_t i = 0; i < mContent.Length(); ++i) {
     nsCOMPtr<nsIInputStream> oInStr;
     rv = NS_NewCStringInputStream(getter_AddRefs(oInStr), mContent[i]);
     if (NS_FAILED(rv)) {
       break;
     }
     // let the next listener know that there is data in oInStr
-    rv = nextListener->OnDataAvailable(mContentRequest, oInStr,
-                                       offset, mContent[i].Length());
+    rv = nextListener->OnDataAvailable(mContentRequest, oInStr, offset,
+                                       mContent[i].Length());
     offset += mContent[i].Length();
     if (NS_FAILED(rv)) {
       break;
     }
   }
 
   // propagate OnStopRequest and return
   nextListener->OnStopRequest(mContentRequest, rv);
@@ -116,18 +116,17 @@ void ContentVerifier::FinishSignature() 
 
 NS_IMETHODIMP
 ContentVerifier::OnStartRequest(nsIRequest* aRequest) {
   MOZ_CRASH("This OnStartRequest should've never been called!");
   return NS_OK;
 }
 
 NS_IMETHODIMP
-ContentVerifier::OnStopRequest(nsIRequest* aRequest,
-                               nsresult aStatus) {
+ContentVerifier::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   // If we don't have a next listener, we handed off this request already.
   // Return, there's nothing to do here.
   if (!mNextListener) {
     return NS_OK;
   }
 
   if (NS_FAILED(aStatus)) {
     CSV_LOG(("Stream failed\n"));
@@ -183,18 +182,18 @@ ContentVerifier::ContextCreated(bool suc
 
     // Make sure that OnStartRequest was called and we have a request.
     MOZ_ASSERT(mContentRequest);
 
     // In this case something went wrong with the cert. Let's stop this load.
     CSV_LOG(("failed to get a valid cert chain\n"));
     if (mContentRequest && nextListener) {
       mContentRequest->Cancel(NS_ERROR_INVALID_SIGNATURE);
-      nsresult rv = nextListener->OnStopRequest(
-          mContentRequest, NS_ERROR_INVALID_SIGNATURE);
+      nsresult rv = nextListener->OnStopRequest(mContentRequest,
+                                                NS_ERROR_INVALID_SIGNATURE);
       mContentRequest = nullptr;
       mContentContext = nullptr;
       return rv;
     }
 
     // We should never get here!
     MOZ_ASSERT_UNREACHABLE(
         "ContentVerifier was used without getting OnStartRequest!");
--- a/dom/serviceworkers/ServiceWorkerPrivate.cpp
+++ b/dom/serviceworkers/ServiceWorkerPrivate.cpp
@@ -655,17 +655,18 @@ class LifeCycleEventWatcher final : publ
 
     if (!mWorkerRef) {
       return;
     }
 
     mCallback->SetResult(aResult);
     // Using DispatchToMainThreadForMessaging so that state update on
     // the main thread doesn't happen too soon.
-    nsresult rv = mWorkerRef->Private()->DispatchToMainThreadForMessaging(mCallback);
+    nsresult rv =
+        mWorkerRef->Private()->DispatchToMainThreadForMessaging(mCallback);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       MOZ_CRASH("Failed to dispatch life cycle event handler.");
     }
 
     mWorkerRef = nullptr;
   }
 
   void FinishedWithResult(ExtendableEventResult aResult) override {
--- a/dom/serviceworkers/ServiceWorkerScriptCache.cpp
+++ b/dom/serviceworkers/ServiceWorkerScriptCache.cpp
@@ -844,18 +844,17 @@ nsresult CompareNetwork::SetPrincipalInf
     return rv;
   }
 
   mPrincipalInfo = std::move(principalInfo);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-CompareNetwork::OnStopRequest(nsIRequest* aRequest,
-                              nsresult aStatusCode) {
+CompareNetwork::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
   // Nothing to do here!
   return NS_OK;
 }
 
 NS_IMETHODIMP
 CompareNetwork::OnStreamComplete(nsIStreamLoader* aLoader,
                                  nsISupports* aContext, nsresult aStatus,
                                  uint32_t aLen, const uint8_t* aString) {
--- a/dom/serviceworkers/ServiceWorkerUpdateJob.cpp
+++ b/dom/serviceworkers/ServiceWorkerUpdateJob.cpp
@@ -358,17 +358,18 @@ void ServiceWorkerUpdateJob::ComparisonR
     rv = GetRequiredScopeStringPrefix(maxScopeURI, maxPrefix, eUsePath);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       FailUpdateJob(NS_ERROR_DOM_SECURITY_ERR);
       return;
     }
   }
 
   nsCOMPtr<nsIURI> scopeURI;
-  rv = NS_NewURI(getter_AddRefs(scopeURI), mRegistration->Scope(), nullptr, scriptURI);
+  rv = NS_NewURI(getter_AddRefs(scopeURI), mRegistration->Scope(), nullptr,
+                 scriptURI);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     FailUpdateJob(NS_ERROR_FAILURE);
     return;
   }
 
   nsAutoCString scopeString;
   rv = scopeURI->GetPathQueryRef(scopeString);
   if (NS_WARN_IF(NS_FAILED(rv))) {
--- a/dom/u2f/U2F.cpp
+++ b/dom/u2f/U2F.cpp
@@ -11,17 +11,17 @@
 #include "mozilla/dom/WebAuthnTransactionChild.h"
 #include "mozilla/dom/WebAuthnUtil.h"
 #include "nsContentUtils.h"
 #include "nsIEffectiveTLDService.h"
 #include "nsNetUtil.h"
 #include "nsURLParsers.h"
 
 #ifdef OS_WIN
-#include "WinWebAuthnManager.h"
+#  include "WinWebAuthnManager.h"
 #endif
 
 using namespace mozilla::ipc;
 
 // Forward decl because of nsHTMLDocument.h's complex dependency on
 // /layout/style
 class nsHTMLDocument {
  public:
--- a/dom/workers/RuntimeService.cpp
+++ b/dom/workers/RuntimeService.cpp
@@ -817,17 +817,18 @@ static bool PreserveWrapper(JSContext* c
 
   return mozilla::dom::TryPreserveWrapper(obj);
 }
 
 JSObject* Wrap(JSContext* cx, JS::HandleObject existing, JS::HandleObject obj) {
   JSObject* targetGlobal = JS::CurrentGlobalOrNull(cx);
   if (!IsWorkerDebuggerGlobal(targetGlobal) &&
       !IsWorkerDebuggerSandbox(targetGlobal)) {
-    JS_ReportErrorASCII(cx, "There should be no edges from the debuggee to the debugger.");
+    JS_ReportErrorASCII(
+        cx, "There should be no edges from the debuggee to the debugger.");
     return nullptr;
   }
 
   // Note: the JS engine unwraps CCWs before calling this callback.
   JSObject* originGlobal = JS::GetNonCCWObjectGlobal(obj);
 
   const js::Wrapper* wrapper = nullptr;
   if (IsWorkerDebuggerGlobal(originGlobal) ||
--- a/dom/workers/ScriptLoader.cpp
+++ b/dom/workers/ScriptLoader.cpp
@@ -524,18 +524,17 @@ class LoaderListener final : public nsIS
   OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext,
                    nsresult aStatus, uint32_t aStringLen,
                    const uint8_t* aString) override;
 
   NS_IMETHOD
   OnStartRequest(nsIRequest* aRequest) override;
 
   NS_IMETHOD
-  OnStopRequest(nsIRequest* aRequest,
-                nsresult aStatusCode) override {
+  OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) override {
     // Nothing to do here!
     return NS_OK;
   }
 
  private:
   ~LoaderListener() {}
 
   RefPtr<ScriptLoaderRunnable> mRunnable;
--- a/dom/workers/WorkerDebugger.cpp
+++ b/dom/workers/WorkerDebugger.cpp
@@ -375,18 +375,17 @@ WorkerDebugger::RemoveListener(nsIWorker
     return NS_ERROR_INVALID_ARG;
   }
 
   mListeners.RemoveElement(aListener);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-WorkerDebugger::SetDebuggerReady(bool aReady)
-{
+WorkerDebugger::SetDebuggerReady(bool aReady) {
   return mWorkerPrivate->SetIsDebuggerReady(aReady);
 }
 
 void WorkerDebugger::Close() {
   MOZ_ASSERT(mWorkerPrivate);
   mWorkerPrivate = nullptr;
 
   nsTArray<nsCOMPtr<nsIWorkerDebuggerListener>> listeners(mListeners);
--- a/dom/xbl/nsXBLService.cpp
+++ b/dom/xbl/nsXBLService.cpp
@@ -175,18 +175,17 @@ nsXBLStreamListener::~nsXBLStreamListene
   }
 }
 
 NS_IMETHODIMP
 nsXBLStreamListener::OnDataAvailable(nsIRequest* request,
                                      nsIInputStream* aInStr,
                                      uint64_t aSourceOffset, uint32_t aCount) {
   if (mInner)
-    return mInner->OnDataAvailable(request, aInStr, aSourceOffset,
-                                   aCount);
+    return mInner->OnDataAvailable(request, aInStr, aSourceOffset, aCount);
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsXBLStreamListener::OnStartRequest(nsIRequest* request) {
   // Make sure we don't hold on to the sink and binding document past this point
   nsCOMPtr<nsIXMLContentSink> sink;
   mSink.swap(sink);
@@ -207,18 +206,17 @@ nsXBLStreamListener::OnStartRequest(nsIR
   // Make sure to add ourselves as a listener after StartDocumentLoad,
   // since that resets the event listners on the document.
   doc->AddEventListener(NS_LITERAL_STRING("load"), this, false);
 
   return mInner->OnStartRequest(request);
 }
 
 NS_IMETHODIMP
-nsXBLStreamListener::OnStopRequest(nsIRequest* request,
-                                   nsresult aStatus) {
+nsXBLStreamListener::OnStopRequest(nsIRequest* request, nsresult aStatus) {
   nsresult rv = NS_OK;
   if (mInner) {
     rv = mInner->OnStopRequest(request, aStatus);
   }
 
   // Don't hold onto the inner listener; holding onto it can create a cycle
   // with the document
   mInner = nullptr;
--- a/dom/xhr/XMLHttpRequestMainThread.cpp
+++ b/dom/xhr/XMLHttpRequestMainThread.cpp
@@ -1547,18 +1547,17 @@ nsresult XMLHttpRequestMainThread::Strea
     nsCOMPtr<nsIInputStream> copyStream;
     rv = NS_NewByteInputStream(getter_AddRefs(copyStream),
                                MakeSpan(fromRawSegment, count));
 
     if (NS_SUCCEEDED(rv) && xmlHttpRequest->mXMLParserStreamListener) {
       NS_ASSERTION(copyStream, "NS_NewByteInputStream lied");
       nsresult parsingResult =
           xmlHttpRequest->mXMLParserStreamListener->OnDataAvailable(
-              xmlHttpRequest->mChannel, copyStream,
-              toOffset, count);
+              xmlHttpRequest->mChannel, copyStream, toOffset, count);
 
       // No use to continue parsing if we failed here, but we
       // should still finish reading the stream
       if (NS_FAILED(parsingResult)) {
         xmlHttpRequest->mFlagParseBody = false;
       }
     }
   }
@@ -2015,18 +2014,17 @@ XMLHttpRequestMainThread::OnStartRequest
   if (NS_SUCCEEDED(rv) && HasListenersFor(nsGkAtoms::onprogress)) {
     StartProgressEventTimer();
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-XMLHttpRequestMainThread::OnStopRequest(nsIRequest* request,
-                                        nsresult status) {
+XMLHttpRequestMainThread::OnStopRequest(nsIRequest* request, nsresult status) {
   AUTO_PROFILER_LABEL("XMLHttpRequestMainThread::OnStopRequest", NETWORK);
 
   if (request != mChannel) {
     // Can this still happen?
     return NS_OK;
   }
 
   // Send the decoder the signal that we've hit the end of the stream,
--- a/dom/xslt/xslt/txMozillaStylesheetCompiler.cpp
+++ b/dom/xslt/xslt/txMozillaStylesheetCompiler.cpp
@@ -211,18 +211,17 @@ txStylesheetSink::OnDataAvailable(nsIReq
         getSpec(channel, spec);
         mCompiler->cancel(NS_ERROR_XSLT_WRONG_MIME_TYPE, nullptr, spec.get());
 
         return NS_ERROR_XSLT_WRONG_MIME_TYPE;
       }
     }
   }
 
-  return mListener->OnDataAvailable(aRequest, aInputStream, aOffset,
-                                    aCount);
+  return mListener->OnDataAvailable(aRequest, aInputStream, aOffset, aCount);
 }
 
 NS_IMETHODIMP
 txStylesheetSink::OnStartRequest(nsIRequest* aRequest) {
   int32_t charsetSource = kCharsetFromDocTypeDefault;
 
   nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
 
@@ -264,18 +263,17 @@ txStylesheetSink::OnStartRequest(nsIRequ
       }
     }
   }
 
   return mListener->OnStartRequest(aRequest);
 }
 
 NS_IMETHODIMP
-txStylesheetSink::OnStopRequest(nsIRequest* aRequest,
-                                nsresult aStatusCode) {
+txStylesheetSink::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
   bool success = true;
 
   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest);
   if (httpChannel) {
     Unused << httpChannel->GetRequestSucceeded(&success);
   }
 
   nsresult result = aStatusCode;
--- a/extensions/cookie/nsCookieModule.h
+++ b/extensions/cookie/nsCookieModule.h
@@ -11,9 +11,8 @@
 
 namespace mozilla {
 
 void CookieModuleDtor();
 
 }  // namespace mozilla
 
 #endif
-
--- a/extensions/pref/autoconfig/src/nsAutoConfig.cpp
+++ b/extensions/pref/autoconfig/src/nsAutoConfig.cpp
@@ -57,41 +57,37 @@ nsresult nsAutoConfig::Init() {
 
 nsAutoConfig::~nsAutoConfig() {}
 
 void nsAutoConfig::SetConfigURL(const char *aConfigURL) {
   mConfigURL.Assign(aConfigURL);
 }
 
 NS_IMETHODIMP
-nsAutoConfig::OnStartRequest(nsIRequest *request) {
-  return NS_OK;
-}
+nsAutoConfig::OnStartRequest(nsIRequest *request) { return NS_OK; }
 
 NS_IMETHODIMP
-nsAutoConfig::OnDataAvailable(nsIRequest *request,
-                              nsIInputStream *aIStream, uint64_t aSourceOffset,
-                              uint32_t aLength) {
+nsAutoConfig::OnDataAvailable(nsIRequest *request, nsIInputStream *aIStream,
+                              uint64_t aSourceOffset, uint32_t aLength) {
   uint32_t amt, size;
   nsresult rv;
   char buf[1024];
 
   while (aLength) {
     size = std::min<size_t>(aLength, sizeof(buf));
     rv = aIStream->Read(buf, size, &amt);
     if (NS_FAILED(rv)) return rv;
     mBuf.Append(buf, amt);
     aLength -= amt;
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsAutoConfig::OnStopRequest(nsIRequest *request,
-                            nsresult aStatus) {
+nsAutoConfig::OnStopRequest(nsIRequest *request, nsresult aStatus) {
   nsresult rv;
 
   // If the request is failed, go read the failover.jsc file
   if (NS_FAILED(aStatus)) {
     MOZ_LOG(MCD, LogLevel::Debug,
             ("mcd request failed with status %" PRIx32 "\n",
              static_cast<uint32_t>(aStatus)));
     return readOfflineFile();
--- a/gfx/2d/DrawTargetSkia.cpp
+++ b/gfx/2d/DrawTargetSkia.cpp
@@ -1446,17 +1446,18 @@ void DrawTargetSkia::MaskSurface(const P
   AutoPaintSetup paint(mCanvas, aOptions, aSource, nullptr, &invOffset);
 
   sk_sp<SkImage> alphaMask = ExtractAlphaForSurface(aMask);
   if (!alphaMask) {
     gfxDebug() << *this << ": MaskSurface() failed to extract alpha for mask";
     return;
   }
 
-  mCanvas->drawImage(alphaMask, aOffset.x + aMask->GetRect().x, aOffset.y + aMask->GetRect().y, &paint.mPaint);
+  mCanvas->drawImage(alphaMask, aOffset.x + aMask->GetRect().x,
+                     aOffset.y + aMask->GetRect().y, &paint.mPaint);
 }
 
 bool DrawTarget::Draw3DTransformedSurface(SourceSurface* aSurface,
                                           const Matrix4x4& aMatrix) {
   // Composite the 3D transform with the DT's transform.
   Matrix4x4 fullMat = aMatrix * Matrix4x4::From2D(mTransform);
   if (fullMat.IsSingular()) {
     return false;
--- a/gfx/gl/GLContext.cpp
+++ b/gfx/gl/GLContext.cpp
@@ -836,17 +836,18 @@ bool GLContext::InitImpl() {
 
   if (mWorkAroundDriverBugs) {
 #ifdef XP_MACOSX
     if (!nsCocoaFeatures::IsAtLeastVersion(10, 12)) {
       if (mVendor == GLVendor::Intel) {
         // see bug 737182 for 2D textures, bug 684882 for cube map textures.
         mMaxTextureSize = std::min(mMaxTextureSize, 4096);
         mMaxCubeMapTextureSize = std::min(mMaxCubeMapTextureSize, 512);
-        // for good measure, we align renderbuffers on what we do for 2D textures
+        // for good measure, we align renderbuffers on what we do for 2D
+        // textures
         mMaxRenderbufferSize = std::min(mMaxRenderbufferSize, 4096);
         mNeedsTextureSizeChecks = true;
       } else if (mVendor == GLVendor::NVIDIA) {
         // See bug 879656.  8192 fails, 8191 works.
         mMaxTextureSize = std::min(mMaxTextureSize, 8191);
         mMaxRenderbufferSize = std::min(mMaxRenderbufferSize, 8191);
 
         // Part of the bug 879656, but it also doesn't hurt the 877949
@@ -885,18 +886,17 @@ bool GLContext::InitImpl() {
          Renderer() == GLRenderer::AdrenoTM330) &&
         jni::GetAPIVersion() < 21) {
       // Bug 1164027. Driver crashes when functions such as
       // glTexImage2D fail due to virtual memory exhaustion.
       mTextureAllocCrashesOnMapFailure = true;
     }
 #endif
 #if MOZ_WIDGET_ANDROID
-    if (Renderer() == GLRenderer::SGX540 &&
-        jni::GetAPIVersion() <= 15) {
+    if (Renderer() == GLRenderer::SGX540 && jni::GetAPIVersion() <= 15) {
       // Bug 1288446. Driver sometimes crashes when uploading data to a
       // texture if the render target has changed since the texture was
       // rendered from. Calling glCheckFramebufferStatus after
       // glFramebufferTexture2D prevents the crash.
       mNeedsCheckAfterAttachTextureToFb = true;
     }
 #endif
   }
--- a/gfx/gl/GLContext.h
+++ b/gfx/gl/GLContext.h
@@ -3306,18 +3306,18 @@ class GLContext : public GenericAtomicRe
 #undef AFTER_GL_CALL
 #undef ASSERT_SYMBOL_PRESENT
 // #undef TRACKING_CONTEXT // Needed in GLContext.cpp
 #undef ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL
 
   // -----------------------------------------------------------------------------
   // Constructor
  protected:
-  explicit GLContext(CreateContextFlags flags,
-                     const SurfaceCaps& caps, GLContext* sharedContext = nullptr,
+  explicit GLContext(CreateContextFlags flags, const SurfaceCaps& caps,
+                     GLContext* sharedContext = nullptr,
                      bool isOffscreen = false, bool canUseTLSIsCurrent = false);
 
   // -----------------------------------------------------------------------------
   // Destructor
  public:
   virtual ~GLContext();
 
   // Mark this context as destroyed.  This will nullptr out all
@@ -3564,17 +3564,18 @@ class GLContext : public GenericAtomicRe
 
   virtual bool Init();
 
  private:
   bool InitImpl();
   void LoadMoreSymbols(const SymbolLoader& loader);
   bool LoadExtSymbols(const SymbolLoader& loader, const SymLoadStruct* list,
                       GLExtensions ext);
-  bool LoadFeatureSymbols(const SymbolLoader& loader, const SymLoadStruct* list, GLFeature feature);
+  bool LoadFeatureSymbols(const SymbolLoader& loader, const SymLoadStruct* list,
+                          GLFeature feature);
 
  protected:
   void InitExtensions();
 
   GLint mViewportRect[4] = {};
   GLint mScissorRect[4] = {};
 
   uint32_t mMaxTexOrRbSize = 0;
--- a/gfx/gl/GLContextProviderCGL.mm
+++ b/gfx/gl/GLContextProviderCGL.mm
@@ -114,20 +114,19 @@ bool GLContextCGL::SwapBuffers() {
   AUTO_PROFILER_LABEL("GLContextCGL::SwapBuffers", GRAPHICS);
 
   [mContext flushBuffer];
   return true;
 }
 
 void GLContextCGL::GetWSIInfo(nsCString* const out) const { out->AppendLiteral("CGL"); }
 
-Maybe<SymbolLoader> GLContextCGL::GetSymbolLoader() const
-{
-    const auto& lib = sCGLLibrary.Library();
-    return Some(SymbolLoader(*lib));
+Maybe<SymbolLoader> GLContextCGL::GetSymbolLoader() const {
+  const auto& lib = sCGLLibrary.Library();
+  return Some(SymbolLoader(*lib));
 }
 
 already_AddRefed<GLContext> GLContextProviderCGL::CreateWrappingExisting(void*, void*) {
   return nullptr;
 }
 
 static const NSOpenGLPixelFormatAttribute kAttribs_singleBuffered[] = {
     NSOpenGLPFAAllowOfflineRenderers, 0};
--- a/gfx/gl/GLLibraryLoader.cpp
+++ b/gfx/gl/GLLibraryLoader.cpp
@@ -64,10 +64,10 @@ PRFuncPtr SymbolLoader::GetProcAddress(c
     ret = PR_FindFunctionSymbol(mLib, name);
   }
   if (!ret && mPfn) {
     ret = mPfn(name);
   }
   return ret;
 }
 
-} // namespace gl
-} // namespace mozilla
+}  // namespace gl
+}  // namespace mozilla
--- a/gfx/gl/GLLibraryLoader.h
+++ b/gfx/gl/GLLibraryLoader.h
@@ -18,40 +18,34 @@ namespace gl {
 struct SymLoadStruct final {
   PRFuncPtr* symPointer;
   std::array<const char*, 6> symNames;
 };
 
 void ClearSymbols(const SymLoadStruct* firstStruct);
 
 class SymbolLoader final {
-public:
-  typedef PRFuncPtr (GLAPIENTRY * GetProcAddressT)(const char*);
+ public:
+  typedef PRFuncPtr(GLAPIENTRY* GetProcAddressT)(const char*);
 
-  GetProcAddressT mPfn = nullptr; // Try this first, if not null.
+  GetProcAddressT mPfn = nullptr;  // Try this first, if not null.
   PRLibrary* mLib = nullptr;
 
-  explicit SymbolLoader(void* (GLAPIENTRY * pfn)(const char*))
-    : mPfn(GetProcAddressT(pfn))
-  {
+  explicit SymbolLoader(void*(GLAPIENTRY* pfn)(const char*))
+      : mPfn(GetProcAddressT(pfn)) {
     MOZ_ASSERT(mPfn);
   }
 
-  explicit SymbolLoader(const GetProcAddressT pfn)
-    : mPfn(pfn)
-  {
+  explicit SymbolLoader(const GetProcAddressT pfn) : mPfn(pfn) {
     MOZ_ASSERT(mPfn);
   }
 
-  explicit SymbolLoader(PRLibrary& lib)
-    : mLib(&lib)
-  {
-    MOZ_ASSERT(mLib);
-  }
+  explicit SymbolLoader(PRLibrary& lib) : mLib(&lib) { MOZ_ASSERT(mLib); }
 
   PRFuncPtr GetProcAddress(const char*) const;
-  bool LoadSymbols(const SymLoadStruct* firstStruct, bool warnOnFailures = true) const;
+  bool LoadSymbols(const SymLoadStruct* firstStruct,
+                   bool warnOnFailures = true) const;
 };
 
-} // namespace gl
-} // namespace mozilla
+}  // namespace gl
+}  // namespace mozilla
 
-#endif // GLLIBRARYLOADER_H_
+#endif  // GLLIBRARYLOADER_H_
--- a/gfx/gl/GLXLibrary.h
+++ b/gfx/gl/GLXLibrary.h
@@ -174,19 +174,17 @@ class GLXLibrary final {
   bool HasVideoMemoryPurge() { return mHasVideoMemoryPurge; }
   bool HasCreateContextAttribs() { return mHasCreateContextAttribs; }
   bool SupportsTextureFromPixmap(gfxASurface* aSurface);
   bool SupportsVideoSync();
   bool SupportsSwapControl() const { return bool(mSymbols.fSwapIntervalEXT); }
   bool IsATI() { return mIsATI; }
   bool IsMesa() { return mClientIsMesa; }
 
-  auto GetGetProcAddress() const {
-    return mSymbols.fGetProcAddress;
-  }
+  auto GetGetProcAddress() const { return mSymbols.fGetProcAddress; }
 
  private:
   struct {
     void(GLAPIENTRY* fDestroyContext)(Display*, GLXContext);
     Bool(GLAPIENTRY* fMakeCurrent)(Display*, GLXDrawable, GLXContext);
     XVisualInfo*(GLAPIENTRY* fGetConfig)(Display*, XVisualInfo*, int, int*);
     GLXContext(GLAPIENTRY* fGetCurrentContext)();
     void*(GLAPIENTRY* fGetProcAddress)(const char*);
--- a/gfx/layers/CanvasRenderer.h
+++ b/gfx/layers/CanvasRenderer.h
@@ -40,17 +40,17 @@ struct CanvasInitializeData final {
 
   typedef void (*TransactionCallback)(void* closureData);
   TransactionCallback mPreTransCallback = nullptr;
   void* mPreTransCallbackData = nullptr;
   TransactionCallback mDidTransCallback = nullptr;
   void* mDidTransCallbackData = nullptr;
 
   // The size of the canvas content
-  gfx::IntSize mSize = {0,0};
+  gfx::IntSize mSize = {0, 0};
 
   // Whether the canvas drawingbuffer has an alpha channel.
   bool mHasAlpha = false;
 
   // Whether mGLContext contains data that is alpha-premultiplied.
   bool mIsGLAlphaPremult = true;
 };
 
--- a/gfx/layers/apz/src/FocusTarget.cpp
+++ b/gfx/layers/apz/src/FocusTarget.cpp
@@ -2,23 +2,23 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/layers/FocusTarget.h"
 
 #include "mozilla/dom/BrowserBridgeChild.h"  // for BrowserBridgeChild
-#include "mozilla/dom/EventTarget.h"     // for EventTarget
-#include "mozilla/dom/TabParent.h"       // for TabParent
-#include "mozilla/EventDispatcher.h"     // for EventDispatcher
-#include "mozilla/layout/RenderFrame.h"  // For RenderFrame
-#include "nsIContentInlines.h"           // for nsINode::IsEditable()
-#include "nsIPresShell.h"                // for nsIPresShell
-#include "nsLayoutUtils.h"               // for nsLayoutUtils
+#include "mozilla/dom/EventTarget.h"         // for EventTarget
+#include "mozilla/dom/TabParent.h"           // for TabParent
+#include "mozilla/EventDispatcher.h"         // for EventDispatcher
+#include "mozilla/layout/RenderFrame.h"      // For RenderFrame
+#include "nsIContentInlines.h"               // for nsINode::IsEditable()
+#include "nsIPresShell.h"                    // for nsIPresShell
+#include "nsLayoutUtils.h"                   // for nsLayoutUtils
 
 #define ENABLE_FT_LOGGING 0
 // #define ENABLE_FT_LOGGING 1
 
 #if ENABLE_FT_LOGGING
 #  define FT_LOG(FMT, ...)         \
     printf_stderr("FT (%s): " FMT, \
                   XRE_IsParentProcess() ? "chrome" : "content", __VA_ARGS__)
--- a/gfx/layers/ipc/APZCTreeManagerChild.cpp
+++ b/gfx/layers/ipc/APZCTreeManagerChild.cpp
@@ -123,19 +123,18 @@ mozilla::ipc::IPCResult APZCTreeManagerC
     const TapType& aType, const LayoutDevicePoint& aPoint,
     const Modifiers& aModifiers, const ScrollableLayerGuid& aGuid,
     const uint64_t& aInputBlockId) {
   MOZ_ASSERT(XRE_IsParentProcess());
   if (mCompositorSession &&
       mCompositorSession->RootLayerTreeId() == aGuid.mLayersId &&
       mCompositorSession->GetContentController()) {
     RefPtr<GeckoContentController> controller =
-      mCompositorSession->GetContentController();
-    controller->HandleTap(
-        aType, aPoint, aModifiers, aGuid, aInputBlockId);
+        mCompositorSession->GetContentController();
+    controller->HandleTap(aType, aPoint, aModifiers, aGuid, aInputBlockId);
     return IPC_OK();
   }
   dom::TabParent* tab =
       dom::TabParent::GetTabParentFromLayersId(aGuid.mLayersId);
   if (tab) {
     tab->SendHandleTap(aType, aPoint, aModifiers, aGuid, aInputBlockId);
   }
   return IPC_OK();
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -2128,23 +2128,23 @@ void CompositorBridgeParent::NotifyDidCo
 }
 
 void CompositorBridgeParent::InvalidateRemoteLayers() {
   MOZ_ASSERT(CompositorLoop() == MessageLoop::current());
 
   Unused << PCompositorBridgeParent::SendInvalidateLayers(LayersId{0});
 
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
-  ForEachIndirectLayerTree(
-      [](LayerTreeState* lts, const LayersId& aLayersId) -> void {
-        if (lts->mContentCompositorBridgeParent) {
-          ContentCompositorBridgeParent* cpcp = lts->mContentCompositorBridgeParent;
-          Unused << cpcp->SendInvalidateLayers(aLayersId);
-        }
-      });
+  ForEachIndirectLayerTree([](LayerTreeState* lts,
+                              const LayersId& aLayersId) -> void {
+    if (lts->mContentCompositorBridgeParent) {
+      ContentCompositorBridgeParent* cpcp = lts->mContentCompositorBridgeParent;
+      Unused << cpcp->SendInvalidateLayers(aLayersId);
+    }
+  });
 }
 
 static void UpdateIndirectTree(LayersId aId, Layer* aRoot,
                                const TargetConfig& aTargetConfig) {
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
   sIndirectLayerTrees[aId].mRoot = aRoot;
   sIndirectLayerTrees[aId].mTargetConfig = aTargetConfig;
 }
--- a/gfx/layers/ipc/ImageBridgeParent.cpp
+++ b/gfx/layers/ipc/ImageBridgeParent.cpp
@@ -170,17 +170,16 @@ class MOZ_STACK_CLASS AutoImageBridgePar
  private:
   ImageBridgeParent* mImageBridge;
   InfallibleTArray<OpDestroy>* mToDestroy;
 };
 
 mozilla::ipc::IPCResult ImageBridgeParent::RecvUpdate(
     EditArray&& aEdits, OpDestroyArray&& aToDestroy,
     const uint64_t& aFwdTransactionId) {
-
   AUTO_PROFILER_TRACING("Paint", "ImageBridgeTransaction", GRAPHICS);
   AUTO_PROFILER_LABEL("ImageBridgeParent::RecvUpdate", GRAPHICS);
 
   // This ensures that destroy operations are always processed. It is not safe
   // to early-return from RecvUpdate without doing so.
   AutoImageBridgeParentAsyncMessageSender autoAsyncMessageSender(this,
                                                                  &aToDestroy);
   UpdateFwdTransactionId(aFwdTransactionId);
--- a/gfx/layers/wr/AsyncImagePipelineManager.cpp
+++ b/gfx/layers/wr/AsyncImagePipelineManager.cpp
@@ -233,18 +233,18 @@ Maybe<TextureHost::ResourceUpdateOp> Asy
   }
 
   bool useExternalImage = !gfxEnv::EnableWebRenderRecording() && wrTexture;
   aPipeline->mUseExternalImage = useExternalImage;
 
   // Use WebRenderTextureHostWrapper only for video.
   // And WebRenderTextureHostWrapper could be used only with
   // WebRenderTextureHost that supports NativeTexture
-  bool useWrTextureWrapper = useExternalImage && wrTexture &&
-                             wrTexture->SupportsWrNativeTexture();
+  bool useWrTextureWrapper =
+      useExternalImage && wrTexture && wrTexture->SupportsWrNativeTexture();
 
   // The non-external image code path falls back to converting the texture into
   // an rgb image.
   auto numKeys = useExternalImage ? texture->NumSubTextures() : 1;
 
   // If we already had a texture and the format hasn't changed, better to reuse
   // the image keys than create new ones.
   bool canUpdate = !!previousTexture &&
@@ -278,23 +278,25 @@ Maybe<TextureHost::ResourceUpdateOp> Asy
   if (!useExternalImage) {
     return UpdateWithoutExternalImage(texture, aKeys[0], op, aMaybeFastTxn);
   }
 
   if (useWrTextureWrapper && aPipeline->mWrTextureWrapper) {
     MOZ_ASSERT(canUpdate);
     // Reuse WebRenderTextureHostWrapper. With it, rendered frame could be
     // updated without batch re-creation.
-    aPipeline->mWrTextureWrapper->UpdateWebRenderTextureHost(aMaybeFastTxn, wrTexture);
+    aPipeline->mWrTextureWrapper->UpdateWebRenderTextureHost(aMaybeFastTxn,
+                                                             wrTexture);
     // Ensure frame generation.
     SetWillGenerateFrame();
   } else {
     if (useWrTextureWrapper) {
       aPipeline->mWrTextureWrapper = new WebRenderTextureHostWrapper(this);
-      aPipeline->mWrTextureWrapper->UpdateWebRenderTextureHost(aMaybeFastTxn, wrTexture);
+      aPipeline->mWrTextureWrapper->UpdateWebRenderTextureHost(aMaybeFastTxn,
+                                                               wrTexture);
     }
     Range<wr::ImageKey> keys(&aKeys[0], aKeys.Length());
     auto externalImageKey =
         aPipeline->mWrTextureWrapper
             ? aPipeline->mWrTextureWrapper->GetExternalImageKey()
             : wrTexture->GetExternalImageKey();
     wrTexture->PushResourceUpdates(aMaybeFastTxn, op, keys, externalImageKey);
   }
@@ -384,18 +386,17 @@ void AsyncImagePipelineManager::ApplyAsy
     // We don't need to update the display list, either because we can't or
     // because the previous one is still up to date. We may, however, have
     // updated some resources.
 
     // Use transaction of scene builder thread to notify epoch.
     // It is for making epoch update consistent.
     aSceneBuilderTxn.UpdateEpoch(aPipelineId, aEpoch);
     if (aPipeline->mCurrentTexture) {
-      HoldExternalImage(aPipelineId, aEpoch,
-                        aPipeline->mCurrentTexture);
+      HoldExternalImage(aPipelineId, aEpoch, aPipeline->mCurrentTexture);
     }
     return;
   }
 
   aPipeline->mIsChanged = false;
 
   wr::LayoutSize contentSize{aPipeline->mScBounds.Width(),
                              aPipeline->mScBounds.Height()};
@@ -427,18 +428,17 @@ void AsyncImagePipelineManager::ApplyAsy
     }
 
     if (aPipeline->mUseExternalImage) {
       MOZ_ASSERT(aPipeline->mCurrentTexture->AsWebRenderTextureHost());
       Range<wr::ImageKey> range_keys(&keys[0], keys.Length());
       aPipeline->mCurrentTexture->PushDisplayItems(
           builder, wr::ToRoundedLayoutRect(rect), wr::ToRoundedLayoutRect(rect),
           aPipeline->mFilter, range_keys);
-      HoldExternalImage(aPipelineId, aEpoch,
-                        aPipeline->mCurrentTexture);
+      HoldExternalImage(aPipelineId, aEpoch, aPipeline->mCurrentTexture);
     } else {
       MOZ_ASSERT(keys.Length() == 1);
       builder.PushImage(wr::ToRoundedLayoutRect(rect),
                         wr::ToRoundedLayoutRect(rect), true, aPipeline->mFilter,
                         keys[0]);
     }
   }
 
--- a/gfx/layers/wr/AsyncImagePipelineManager.h
+++ b/gfx/layers/wr/AsyncImagePipelineManager.h
@@ -48,18 +48,17 @@ class AsyncImagePipelineManager final {
 
   void AddPipeline(const wr::PipelineId& aPipelineId,
                    WebRenderBridgeParent* aWrBridge);
   void RemovePipeline(const wr::PipelineId& aPipelineId,
                       const wr::Epoch& aEpoch);
   WebRenderBridgeParent* GetWrBridge(const wr::PipelineId& aPipelineId);
 
   void HoldExternalImage(const wr::PipelineId& aPipelineId,
-                         const wr::Epoch& aEpoch,
-                         TextureHost* aTexture);
+                         const wr::Epoch& aEpoch, TextureHost* aTexture);
   void HoldExternalImage(const wr::PipelineId& aPipelineId,
                          const wr::Epoch& aEpoch,
                          WebRenderTextureHostWrapper* aWrTextureWrapper);
   void HoldExternalImage(const wr::PipelineId& aPipelineId,
                          const wr::Epoch& aEpoch,
                          const wr::ExternalImageId& aImageId);
 
   // This is called from the Renderer thread to notify this class about the
--- a/gfx/layers/wr/StackingContextHelper.h
+++ b/gfx/layers/wr/StackingContextHelper.h
@@ -7,17 +7,17 @@
 #ifndef GFX_STACKINGCONTEXTHELPER_H
 #define GFX_STACKINGCONTEXTHELPER_H
 
 #include "mozilla/Attributes.h"
 #include "mozilla/gfx/MatrixFwd.h"
 #include "mozilla/webrender/WebRenderAPI.h"
 #include "mozilla/webrender/WebRenderTypes.h"
 #include "Units.h"
-#include "nsSVGIntegrationUtils.h" // for WrFiltersHolder
+#include "nsSVGIntegrationUtils.h"  // for WrFiltersHolder
 
 class nsDisplayTransform;
 
 namespace mozilla {
 
 struct ActiveScrolledRoot;
 
 namespace layers {
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -60,23 +60,24 @@ void gecko_profiler_start_marker(const c
 
 void gecko_profiler_end_marker(const char* name) {
 #ifdef MOZ_GECKO_PROFILER
   profiler_tracing("WebRender", name, JS::ProfilingCategoryPair::GRAPHICS,
                    TRACING_INTERVAL_END);
 #endif
 }
 
-void gecko_profiler_add_text_marker(const char* name, const char* text_bytes, size_t text_len, uint64_t microseconds) {
+void gecko_profiler_add_text_marker(const char* name, const char* text_bytes,
+                                    size_t text_len, uint64_t microseconds) {
 #ifdef MOZ_GECKO_PROFILER
   if (profiler_thread_is_being_profiled()) {
     auto now = mozilla::TimeStamp::Now();
     auto start = now - mozilla::TimeDuration::FromMicroseconds(microseconds);
-    profiler_add_text_marker(
-        name, nsDependentCString(text_bytes, text_len), JS::ProfilingCategoryPair::GRAPHICS, start, now);
+    profiler_add_text_marker(name, nsDependentCString(text_bytes, text_len),
+                             JS::ProfilingCategoryPair::GRAPHICS, start, now);
   }
 #endif
 }
 
 bool gecko_profiler_thread_is_being_profiled() {
 #ifdef MOZ_GECKO_PROFILER
   return profiler_thread_is_being_profiled();
 #else
--- a/gfx/layers/wr/WebRenderBridgeParent.h
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -42,21 +42,22 @@ namespace layers {
 
 class Compositor;
 class CompositorAnimationStorage;
 class CompositorBridgeParentBase;
 class CompositorVsyncScheduler;
 class AsyncImagePipelineManager;
 class WebRenderImageHost;
 
-class WebRenderBridgeParent final : public PWebRenderBridgeParent,
-                                    public CompositorVsyncSchedulerOwner,
-                                    public CompositableParentManager,
-                                    public layers::FrameRecorder,
-                                    public SupportsWeakPtr<WebRenderBridgeParent> {
+class WebRenderBridgeParent final
+    : public PWebRenderBridgeParent,
+      public CompositorVsyncSchedulerOwner,
+      public CompositableParentManager,
+      public layers::FrameRecorder,
+      public SupportsWeakPtr<WebRenderBridgeParent> {
  public:
   MOZ_DECLARE_WEAKREFERENCE_TYPENAME(WebRenderBridgeParent)
   WebRenderBridgeParent(CompositorBridgeParentBase* aCompositorBridge,
                         const wr::PipelineId& aPipelineId,
                         widget::CompositorWidget* aWidget,
                         CompositorVsyncScheduler* aScheduler,
                         RefPtr<wr::WebRenderAPI>&& aApi,
                         RefPtr<AsyncImagePipelineManager>&& aImageMgr,
--- a/gfx/layers/wr/WebRenderImageHost.cpp
+++ b/gfx/layers/wr/WebRenderImageHost.cpp
@@ -23,19 +23,17 @@ namespace mozilla {
 
 using namespace gfx;
 
 namespace layers {
 
 class ISurfaceAllocator;
 
 WebRenderImageHost::WebRenderImageHost(const TextureInfo& aTextureInfo)
-    : CompositableHost(aTextureInfo),
-      ImageComposite(),
-      mWrBridgeBindings(0) {}
+    : CompositableHost(aTextureInfo), ImageComposite(), mWrBridgeBindings(0) {}
 
 WebRenderImageHost::~WebRenderImageHost() { MOZ_ASSERT(!mWrBridge); }
 
 void WebRenderImageHost::UseTextureHost(
     const nsTArray<TimedTexture>& aTextures) {
   CompositableHost::UseTextureHost(aTextures);
   MOZ_ASSERT(aTextures.Length() >= 1);
 
--- a/gfx/layers/wr/WebRenderTextureHostWrapper.cpp
+++ b/gfx/layers/wr/WebRenderTextureHostWrapper.cpp
@@ -21,19 +21,18 @@ class ScheduleUpdateRenderTextureHost : 
   ScheduleUpdateRenderTextureHost(uint64_t aSrcExternalImageId,
                                   uint64_t aWrappedExternalImageId)
       : mSrcExternalImageId(aSrcExternalImageId),
         mWrappedExternalImageId(aWrappedExternalImageId) {}
 
   virtual void Notify(wr::Checkpoint aCheckpoint) override {
     if (aCheckpoint == wr::Checkpoint::FrameTexturesUpdated) {
       MOZ_ASSERT(wr::RenderThread::IsInRenderThread());
-      wr::RenderThread::Get()->UpdateRenderTextureHost(
-          mSrcExternalImageId,
-          mWrappedExternalImageId);
+      wr::RenderThread::Get()->UpdateRenderTextureHost(mSrcExternalImageId,
+                                                       mWrappedExternalImageId);
     } else {
       MOZ_ASSERT(aCheckpoint == wr::Checkpoint::TransactionDropped);
     }
   }
 
  protected:
   uint64_t mSrcExternalImageId;
   uint64_t mWrappedExternalImageId;
@@ -52,26 +51,25 @@ WebRenderTextureHostWrapper::WebRenderTe
 
 WebRenderTextureHostWrapper::~WebRenderTextureHostWrapper() {
   MOZ_COUNT_DTOR(WebRenderTextureHostWrapper);
   wr::RenderThread::Get()->UnregisterExternalImage(
       wr::AsUint64(mExternalImageId));
 }
 
 void WebRenderTextureHostWrapper::UpdateWebRenderTextureHost(
-    wr::TransactionBuilder& aTxn,
-    WebRenderTextureHost* aTextureHost) {
+    wr::TransactionBuilder& aTxn, WebRenderTextureHost* aTextureHost) {
   MOZ_ASSERT(aTextureHost);
 
   // AsyncImagePipelineManager is responsible of holding compositable ref of
   // wrapped WebRenderTextureHost by using ForwardingTextureHost.
   // ScheduleUpdateRenderTextureHost does not need to handle it.
 
   aTxn.Notify(wr::Checkpoint::FrameTexturesUpdated,
-      MakeUnique<ScheduleUpdateRenderTextureHost>(
-        wr::AsUint64(mExternalImageId),
-        wr::AsUint64(aTextureHost->GetExternalImageKey())));
+              MakeUnique<ScheduleUpdateRenderTextureHost>(
+                  wr::AsUint64(mExternalImageId),
+                  wr::AsUint64(aTextureHost->GetExternalImageKey())));
 
   mWrTextureHost = aTextureHost;
 }
 
 }  // namespace layers
 }  // namespace mozilla
--- a/gfx/tests/gtest/TestRegion.cpp
+++ b/gfx/tests/gtest/TestRegion.cpp
@@ -1186,18 +1186,18 @@ struct RegionBitmap {
     }
   }
 
   unsigned char *bitmap;
   int width;
   int height;
 };
 
-static void VisitEdge(void *closure, VisitSide side, int x1, int y1,
-                      int x2, int y2) {
+static void VisitEdge(void *closure, VisitSide side, int x1, int y1, int x2,
+                      int y2) {
   EXPECT_GE(x2, x1);
   RegionBitmap *visitor = static_cast<RegionBitmap *>(closure);
   unsigned char *bitmap = visitor->bitmap;
   const int width = visitor->width;
 
   if (side == VisitSide::TOP) {
     while (x1 != x2) {
       bitmap[x1 + (y1 - 1) * width] = DILATE_VALUE;
--- a/gfx/thebes/gfxFontEntry.h
+++ b/gfx/thebes/gfxFontEntry.h
@@ -261,19 +261,17 @@ class gfxFontEntry {
 
   // Stack-based utility to return a specified table, automatically releasing
   // the blob when the AutoTable goes out of scope.
   class AutoTable {
    public:
     AutoTable(gfxFontEntry* aFontEntry, uint32_t aTag) {
       mBlob = aFontEntry->GetFontTable(aTag);
     }
-    ~AutoTable() {
-      hb_blob_destroy(mBlob);
-    }
+    ~AutoTable() { hb_blob_destroy(mBlob); }
     operator hb_blob_t*() const { return mBlob; }
 
    private:
     hb_blob_t* mBlob;
     // not implemented:
     AutoTable(const AutoTable&) = delete;
     AutoTable& operator=(const AutoTable&) = delete;
   };
--- a/gfx/thebes/gfxFontUtils.cpp
+++ b/gfx/thebes/gfxFontUtils.cpp
@@ -1764,19 +1764,17 @@ void gfxFontUtils::GetVariationInstances
     //  AutoSwap_PRUint16 postScriptNameID;
   };
 
   // Helper to ensure we free a font table when we return.
   class AutoHBBlob {
    public:
     explicit AutoHBBlob(hb_blob_t* aBlob) : mBlob(aBlob) {}
 
-    ~AutoHBBlob() {
-      hb_blob_destroy(mBlob);
-    }
+    ~AutoHBBlob() { hb_blob_destroy(mBlob); }
 
     operator hb_blob_t*() { return mBlob; }
 
    private:
     hb_blob_t* const mBlob;
   };
 
   // Load the two font tables we need as harfbuzz blobs; if either is absent,
--- a/gfx/thebes/gfxSVGGlyphs.cpp
+++ b/gfx/thebes/gfxSVGGlyphs.cpp
@@ -367,18 +367,17 @@ nsresult gfxSVGGlyphsDocument::ParseDocu
   rv = listener->OnStartRequest(channel);
   if (NS_FAILED(rv)) {
     channel->Cancel(rv);
   }
 
   nsresult status;
   channel->GetStatus(&status);
   if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(status)) {
-    rv = listener->OnDataAvailable(channel, stream, 0,
-                                   aBufLen);
+    rv = listener->OnDataAvailable(channel, stream, 0, aBufLen);
     if (NS_FAILED(rv)) {
       channel->Cancel(rv);
     }
     channel->GetStatus(&status);
   }
 
   rv = listener->OnStopRequest(channel, status);
   NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
--- a/gfx/vr/VRDisplayHost.cpp
+++ b/gfx/vr/VRDisplayHost.cpp
@@ -286,17 +286,17 @@ void VRDisplayHost::Run100msTasks() {
 void VRDisplayHost::SubmitFrameInternal(
     const layers::SurfaceDescriptor& aTexture, uint64_t aFrameId,
     const gfx::Rect& aLeftEyeRect, const gfx::Rect& aRightEyeRect) {
 #if !defined(MOZ_WIDGET_ANDROID)
   MOZ_ASSERT(mSubmitThread->GetThread() == NS_GetCurrentThread());
 #endif  // !defined(MOZ_WIDGET_ANDROID)
   AUTO_PROFILER_TRACING("VR", "SubmitFrameAtVRDisplayHost", OTHER);
 
-  { // scope lock
+  {  // scope lock
     MonitorAutoLock lock(mCurrentSubmitTaskMonitor);
 
     if (!SubmitFrame(aTexture, aFrameId, aLeftEyeRect, aRightEyeRect)) {
       mCurrentSubmitTask = nullptr;
       return;
     }
     mCurrentSubmitTask = nullptr;
   }
@@ -350,37 +350,35 @@ void VRDisplayHost::SubmitFrame(VRLayerP
     return;
   }
 
   mLastSubmittedFrameId = aFrameId;
 #endif  // !defined(MOZ_WIDGET_ANDROID)
 
   mFrameStarted = false;
 
-  RefPtr<CancelableRunnable> task =
-    NewCancelableRunnableMethod<StoreCopyPassByConstLRef<layers::SurfaceDescriptor>,
-                                uint64_t, StoreCopyPassByConstLRef<gfx::Rect>,
-                                StoreCopyPassByConstLRef<gfx::Rect>>(
+  RefPtr<CancelableRunnable> task = NewCancelableRunnableMethod<
+      StoreCopyPassByConstLRef<layers::SurfaceDescriptor>, uint64_t,
+      StoreCopyPassByConstLRef<gfx::Rect>, StoreCopyPassByConstLRef<gfx::Rect>>(
       "gfx::VRDisplayHost::SubmitFrameInternal", this,
       &VRDisplayHost::SubmitFrameInternal, aTexture, aFrameId, aLeftEyeRect,
       aRightEyeRect);
 
   if (!mCurrentSubmitTask) {
     mCurrentSubmitTask = task;
 #if !defined(MOZ_WIDGET_ANDROID)
     if (!mSubmitThread) {
       mSubmitThread = new VRThread(NS_LITERAL_CSTRING("VR_SubmitFrame"));
     }
     mSubmitThread->Start();
     mSubmitThread->PostTask(task.forget());
 #else
     CompositorThreadHolder::Loop()->PostTask(task.forget());
 #endif  // defined(MOZ_WIDGET_ANDROID)
   }
-
 }
 
 void VRDisplayHost::CancelCurrentSubmitTask() {
   MonitorAutoLock lock(mCurrentSubmitTaskMonitor);
   if (mCurrentSubmitTask) {
     mCurrentSubmitTask->Cancel();
     mCurrentSubmitTask = nullptr;
   }
--- a/gfx/webrender_bindings/RenderCompositorANGLE.cpp
+++ b/gfx/webrender_bindings/RenderCompositorANGLE.cpp
@@ -156,17 +156,18 @@ bool RenderCompositorANGLE::Initialize()
     DXGI_SWAP_CHAIN_DESC1 desc{};
     desc.Width = 0;
     desc.Height = 0;
     desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
     desc.SampleDesc.Count = 1;
     desc.SampleDesc.Quality = 0;
     // DXGI_USAGE_SHADER_INPUT is set for improving performanc of copying from
     // framebuffer to texture on intel gpu.
-    desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
+    desc.BufferUsage =
+        DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
     // Do not use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, since it makes HWND
     // unreusable.
     // desc.BufferCount = 2;
     // desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
     desc.BufferCount = 1;
     desc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
     desc.Scaling = DXGI_SCALING_NONE;
     desc.Flags = 0;
@@ -186,17 +187,18 @@ bool RenderCompositorANGLE::Initialize()
     swapDesc.BufferDesc.Height = 0;
     swapDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
     swapDesc.BufferDesc.RefreshRate.Numerator = 60;
     swapDesc.BufferDesc.RefreshRate.Denominator = 1;
     swapDesc.SampleDesc.Count = 1;
     swapDesc.SampleDesc.Quality = 0;
     // DXGI_USAGE_SHADER_INPUT is set for improving performanc of copying from
     // framebuffer to texture on intel gpu.
-    swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
+    swapDesc.BufferUsage =
+        DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
     swapDesc.BufferCount = 1;
     swapDesc.OutputWindow = hwnd;
     swapDesc.Windowed = TRUE;
     swapDesc.Flags = 0;
     swapDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
 
     HRESULT hr = dxgiFactory->CreateSwapChain(dxgiDevice, &swapDesc,
                                               getter_AddRefs(mSwapChain));
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -686,17 +686,18 @@ Maybe<wr::WrSpatialId> DisplayListBuilde
   const wr::LayoutTransform* maybeTransform = transform ? &matrix : nullptr;
   WRDL_LOG("PushStackingContext b=%s t=%s\n", mWrState,
            Stringify(aBounds).c_str(),
            transform ? Stringify(*transform).c_str() : "none");
 
   auto spatialId = wr_dp_push_stacking_context(
       mWrState, aBounds, mCurrentSpaceAndClipChain.space, &aParams,
       maybeTransform, aParams.mFilters.Elements(), aParams.mFilters.Length(),
-      aParams.mFilterDatas.Elements(), aParams.mFilterDatas.Length(), aRasterSpace);
+      aParams.mFilterDatas.Elements(), aParams.mFilterDatas.Length(),
+      aRasterSpace);
 
   return spatialId.id != 0 ? Some(spatialId) : Nothing();
 }
 
 void DisplayListBuilder::PopStackingContext(bool aIsReferenceFrame) {
   WRDL_LOG("PopStackingContext\n", mWrState);
   wr_dp_pop_stacking_context(mWrState, aIsReferenceFrame);
 }
--- a/gfx/webrender_bindings/WebRenderTypes.h
+++ b/gfx/webrender_bindings/WebRenderTypes.h
@@ -52,19 +52,17 @@ typedef Maybe<FontInstancePlatformOption
 struct ExternalImageKeyPair {
   ImageKey key;
   ExternalImageId id;
 };
 
 /* Generate a brand new window id and return it. */
 WindowId NewWindowId();
 
-inline DebugFlags NewDebugFlags(uint32_t aFlags) {
-  return {aFlags};
-}
+inline DebugFlags NewDebugFlags(uint32_t aFlags) { return {aFlags}; }
 
 inline Maybe<wr::ImageFormat> SurfaceFormatToImageFormat(
     gfx::SurfaceFormat aFormat) {
   switch (aFormat) {
     case gfx::SurfaceFormat::R8G8B8X8:
       // WebRender not support RGBX8. Assert here.
       MOZ_ASSERT(false);
       return Nothing();
--- a/gfx/webrender_bindings/webrender_ffi.h
+++ b/gfx/webrender_bindings/webrender_ffi.h
@@ -28,18 +28,18 @@ void gfx_critical_error(const char* msg)
 void gecko_printf_stderr_output(const char* msg);
 void* get_proc_address_from_glcontext(void* glcontext_ptr,
                                       const char* procname);
 void gecko_profiler_register_thread(const char* threadname);
 void gecko_profiler_unregister_thread();
 
 void gecko_profiler_start_marker(const char* name);
 void gecko_profiler_end_marker(const char* name);
-void gecko_profiler_add_text_marker(
-    const char* name, const char* text_ptr, size_t text_len, uint64_t microseconds);
+void gecko_profiler_add_text_marker(const char* name, const char* text_ptr,
+                                    size_t text_len, uint64_t microseconds);
 bool gecko_profiler_thread_is_being_profiled();
 
 // IMPORTANT: Keep this synchronized with enumerate_interners in
 // gfx/wr/webrender_api
 #define WEBRENDER_FOR_EACH_INTERNER(macro) \
   macro(clip);                             \
   macro(prim);                             \
   macro(normal_border);                    \
@@ -48,17 +48,16 @@ bool gecko_profiler_thread_is_being_prof
   macro(yuv_image);                        \
   macro(line_decoration);                  \
   macro(linear_grad);                      \
   macro(radial_grad);                      \
   macro(picture);                          \
   macro(text_run);                         \
   macro(filterdata);
 
-
 // Prelude of types necessary before including webrender_ffi_generated.h
 namespace mozilla {
 namespace wr {
 
 // Because this struct is macro-generated on the Rust side, cbindgen can't see
 // it. Work around that by re-declaring it here.
 #define DECLARE_MEMBER(id) uintptr_t id;
 struct InternerSubReport {
--- a/image/SVGDocumentWrapper.cpp
+++ b/image/SVGDocumentWrapper.cpp
@@ -181,45 +181,42 @@ void SVGDocumentWrapper::TickRefreshDriv
       presContext->RefreshDriver()->DoTick();
     }
   }
 }
 
 /** nsIStreamListener methods **/
 
 NS_IMETHODIMP
-SVGDocumentWrapper::OnDataAvailable(nsIRequest* aRequest,
-                                    nsIInputStream* inStr,
+SVGDocumentWrapper::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* inStr,
                                     uint64_t sourceOffset, uint32_t count) {
   return mListener->OnDataAvailable(aRequest, inStr, sourceOffset, count);
 }
 
 /** nsIRequestObserver methods **/
 
 NS_IMETHODIMP
 SVGDocumentWrapper::OnStartRequest(nsIRequest* aRequest) {
   nsresult rv = SetupViewer(aRequest, getter_AddRefs(mViewer),
                             getter_AddRefs(mLoadGroup));
 
-  if (NS_SUCCEEDED(rv) &&
-      NS_SUCCEEDED(mListener->OnStartRequest(aRequest))) {
+  if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(mListener->OnStartRequest(aRequest))) {
     mViewer->GetDocument()->SetIsBeingUsedAsImage();
     StopAnimation();  // otherwise animations start automatically in helper doc
 
     rv = mViewer->Init(nullptr, nsIntRect(0, 0, 0, 0));
     if (NS_SUCCEEDED(rv)) {
       rv = mViewer->Open(nullptr, nullptr);
     }
   }
   return rv;
 }
 
 NS_IMETHODIMP
-SVGDocumentWrapper::OnStopRequest(nsIRequest* aRequest,
-                                  nsresult status) {
+SVGDocumentWrapper::OnStopRequest(nsIRequest* aRequest, nsresult status) {
   if (mListener) {
     mListener->OnStopRequest(aRequest, status);
     mListener = nullptr;
   }
 
   return NS_OK;
 }
 
--- a/image/VectorImage.cpp
+++ b/image/VectorImage.cpp
@@ -1362,18 +1362,17 @@ VectorImage::OnStartRequest(nsIRequest* 
   mLoadEventListener = new SVGLoadEventListener(document, this);
   mParseCompleteListener = new SVGParseCompleteListener(document, this);
 
   return NS_OK;
 }
 
 //******************************************************************************
 NS_IMETHODIMP
-VectorImage::OnStopRequest(nsIRequest* aRequest,
-                           nsresult aStatus) {
+VectorImage::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   if (mError) {
     return NS_ERROR_FAILURE;
   }
 
   return mSVGDocumentWrapper->OnStopRequest(aRequest, aStatus);
 }
 
 void VectorImage::OnSVGDocumentParsed() {
@@ -1463,25 +1462,24 @@ void VectorImage::OnSVGDocumentError() {
   }
 }
 
 //------------------------------------------------------------------------------
 // nsIStreamListener method
 
 //******************************************************************************
 NS_IMETHODIMP
-VectorImage::OnDataAvailable(nsIRequest* aRequest,
-                             nsIInputStream* aInStr, uint64_t aSourceOffset,
-                             uint32_t aCount) {
+VectorImage::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInStr,
+                             uint64_t aSourceOffset, uint32_t aCount) {
   if (mError) {
     return NS_ERROR_FAILURE;
   }
 
-  return mSVGDocumentWrapper->OnDataAvailable(aRequest, aInStr,
-                                              aSourceOffset, aCount);
+  return mSVGDocumentWrapper->OnDataAvailable(aRequest, aInStr, aSourceOffset,
+                                              aCount);
 }
 
 // --------------------------
 // Invalidation helper method
 
 void VectorImage::InvalidateObserversOnNextRefreshDriverTick() {
   if (mHasPendingInvalidation) {
     return;
--- a/image/decoders/icon/mac/nsIconChannelCocoa.mm
+++ b/image/decoders/icon/mac/nsIconChannelCocoa.mm
@@ -93,18 +93,18 @@ nsIconChannel::OnStopRequest(nsIRequest*
     mLoadGroup->RemoveRequest(this, nullptr, aStatus);
   }
 
   return NS_OK;
 }
 
 // nsIStreamListener methods
 NS_IMETHODIMP
-nsIconChannel::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aStream,
-                               uint64_t aOffset, uint32_t aCount) {
+nsIconChannel::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aStream, uint64_t aOffset,
+                               uint32_t aCount) {
   if (mListener) {
     return mListener->OnDataAvailable(this, aStream, aOffset, aCount);
   }
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIChannel methods:
--- a/image/decoders/icon/win/nsIconChannel.cpp
+++ b/image/decoders/icon/win/nsIconChannel.cpp
@@ -709,18 +709,17 @@ nsIconChannel::GetSecurityInfo(nsISuppor
 NS_IMETHODIMP nsIconChannel::OnStartRequest(nsIRequest* aRequest) {
   if (mListener) {
     return mListener->OnStartRequest(this);
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsIconChannel::OnStopRequest(nsIRequest* aRequest,
-                             nsresult aStatus) {
+nsIconChannel::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   if (mListener) {
     mListener->OnStopRequest(this, aStatus);
     mListener = nullptr;
   }
 
   // Remove from load group
   if (mLoadGroup) {
     mLoadGroup->RemoveRequest(this, nullptr, aStatus);
@@ -729,16 +728,15 @@ nsIconChannel::OnStopRequest(nsIRequest*
   // Drop notification callbacks to prevent cycles.
   mCallbacks = nullptr;
 
   return NS_OK;
 }
 
 // nsIStreamListener methods
 NS_IMETHODIMP
-nsIconChannel::OnDataAvailable(nsIRequest* aRequest,
-                               nsIInputStream* aStream, uint64_t aOffset,
-                               uint32_t aCount) {
+nsIconChannel::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aStream,
+                               uint64_t aOffset, uint32_t aCount) {
   if (mListener) {
     return mListener->OnDataAvailable(this, aStream, aOffset, aCount);
   }
   return NS_OK;
 }
--- a/image/imgLoader.cpp
+++ b/image/imgLoader.cpp
@@ -2688,37 +2688,34 @@ ProxyListener::OnStartRequest(nsIRequest
       }
     }
   }
 
   return mDestListener->OnStartRequest(aRequest);
 }
 
 NS_IMETHODIMP
-ProxyListener::OnStopRequest(nsIRequest* aRequest,
-                             nsresult status) {
+ProxyListener::OnStopRequest(nsIRequest* aRequest, nsresult status) {
   if (!mDestListener) {
     return NS_ERROR_FAILURE;
   }
 
   return mDestListener->OnStopRequest(aRequest, status);
 }
 
 /** nsIStreamListener methods **/
 
 NS_IMETHODIMP
-ProxyListener::OnDataAvailable(nsIRequest* aRequest,
-                               nsIInputStream* inStr, uint64_t sourceOffset,
-                               uint32_t count) {
+ProxyListener::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* inStr,
+                               uint64_t sourceOffset, uint32_t count) {
   if (!mDestListener) {
     return NS_ERROR_FAILURE;
   }
 
-  return mDestListener->OnDataAvailable(aRequest, inStr, sourceOffset,
-                                        count);
+  return mDestListener->OnDataAvailable(aRequest, inStr, sourceOffset, count);
 }
 
 /** nsThreadRetargetableStreamListener methods **/
 NS_IMETHODIMP
 ProxyListener::CheckListenerChain() {
   NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!");
   nsresult rv = NS_OK;
   nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener =
@@ -2914,43 +2911,40 @@ imgCacheValidator::OnStartRequest(nsIReq
   // the cache before the proxies' ownership changes, because adding a proxy
   // changes the caching behaviour for imgRequests.
   mImgLoader->PutIntoCache(mNewRequest->CacheKey(), mNewEntry);
   UpdateProxies(/* aCancelRequest */ false, /* aSyncNotify */ true);
   return mDestListener->OnStartRequest(aRequest);
 }
 
 NS_IMETHODIMP
-imgCacheValidator::OnStopRequest(nsIRequest* aRequest,
-                                 nsresult status) {
+imgCacheValidator::OnStopRequest(nsIRequest* aRequest, nsresult status) {
   // Be sure we've released the document that we may have been holding on to.
   mContext = nullptr;
 
   if (!mDestListener) {
     return NS_OK;
   }
 
   return mDestListener->OnStopRequest(aRequest, status);
 }
 
 /** nsIStreamListener methods **/
 
 NS_IMETHODIMP
-imgCacheValidator::OnDataAvailable(nsIRequest* aRequest,
-                                   nsIInputStream* inStr, uint64_t sourceOffset,
-                                   uint32_t count) {
+imgCacheValidator::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* inStr,
+                                   uint64_t sourceOffset, uint32_t count) {
   if (!mDestListener) {
     // XXX see bug 113959
     uint32_t _retval;
     inStr->ReadSegments(NS_DiscardSegment, nullptr, count, &_retval);
     return NS_OK;
   }
 
-  return mDestListener->OnDataAvailable(aRequest, inStr, sourceOffset,
-                                        count);
+  return mDestListener->OnDataAvailable(aRequest, inStr, sourceOffset, count);
 }
 
 /** nsIThreadRetargetableStreamListener methods **/
 
 NS_IMETHODIMP
 imgCacheValidator::CheckListenerChain() {
   NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!");
   nsresult rv = NS_OK;
--- a/image/imgRequest.cpp
+++ b/image/imgRequest.cpp
@@ -730,18 +730,17 @@ imgRequest::OnStartRequest(nsIRequest* a
              this, static_cast<uint32_t>(rv),
              NS_SUCCEEDED(rv) ? "succeeded" : "failed"));
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-imgRequest::OnStopRequest(nsIRequest* aRequest,
-                          nsresult status) {
+imgRequest::OnStopRequest(nsIRequest* aRequest, nsresult status) {
   LOG_FUNC(gImgLog, "imgRequest::OnStopRequest");
   MOZ_ASSERT(NS_IsMainThread(), "Can't send notifications off-main-thread");
 
   RefPtr<Image> image = GetImage();
 
   RefPtr<imgRequest> strongThis = this;
 
   if (mIsMultiPartChannel && mNewPartPending) {
@@ -774,17 +773,18 @@ imgRequest::OnStopRequest(nsIRequest* aR
     isPartial = true;
     status = NS_OK;  // fake happy face
   }
 
   // Tell the image that it has all of the source data. Note that this can
   // trigger a failure, since the image might be waiting for more non-optional
   // data and this is the point where we break the news that it's not coming.
   if (image) {
-    nsresult rv = image->OnImageDataComplete(aRequest, nullptr, status, lastPart);
+    nsresult rv =
+        image->OnImageDataComplete(aRequest, nullptr, status, lastPart);
 
     // If we got an error in the OnImageDataComplete() call, we don't want to
     // proceed as if nothing bad happened. However, we also want to give
     // precedence to failure status codes from necko, since presumably they're
     // more meaningful.
     if (NS_FAILED(rv) && NS_SUCCEEDED(status)) {
       status = rv;
     }
@@ -984,19 +984,18 @@ void imgRequest::FinishPreparingForNewPa
   }
 
   if (IsDecodeRequested()) {
     aResult.mImage->StartDecoding(imgIContainer::FLAG_NONE);
   }
 }
 
 NS_IMETHODIMP
-imgRequest::OnDataAvailable(nsIRequest* aRequest,
-                            nsIInputStream* aInStr, uint64_t aOffset,
-                            uint32_t aCount) {
+imgRequest::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInStr,
+                            uint64_t aOffset, uint32_t aCount) {
   LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequest::OnDataAvailable", "count", aCount);
 
   NS_ASSERTION(aRequest, "imgRequest::OnDataAvailable -- no request!");
 
   RefPtr<Image> image;
   RefPtr<ProgressTracker> progressTracker;
   bool isMultipart = false;
   bool newPartPending = false;
@@ -1057,18 +1056,18 @@ imgRequest::OnDataAvailable(nsIRequest* 
       // Something went wrong; probably a content type issue.
       Cancel(NS_IMAGELIB_ERROR_FAILURE);
       return NS_BINDING_ABORTED;
     }
   }
 
   // Notify the image that it has new data.
   if (aInStr) {
-    nsresult rv = image->OnImageDataAvailable(aRequest, nullptr, aInStr,
-                                              aOffset, aCount);
+    nsresult rv =
+        image->OnImageDataAvailable(aRequest, nullptr, aInStr, aOffset, aCount);
 
     if (NS_FAILED(rv)) {
       MOZ_LOG(gImgLog, LogLevel::Warning,
               ("[this=%p] imgRequest::OnDataAvailable -- "
                "copy to RasterImage failed\n",
                this));
       Cancel(NS_IMAGELIB_ERROR_FAILURE);
       return NS_BINDING_ABORTED;
--- a/intl/unicharutil/util/ICUUtils.cpp
+++ b/intl/unicharutil/util/ICUUtils.cpp
@@ -1,16 +1,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifdef MOZILLA_INTERNAL_API
 
-#include "mozilla/Assertions.h"
-#include "mozilla/UniquePtr.h"
+#  include "mozilla/Assertions.h"
+#  include "mozilla/UniquePtr.h"
 
 #  include "ICUUtils.h"
 #  include "mozilla/Preferences.h"
 #  include "mozilla/intl/LocaleService.h"
 #  include "nsIContent.h"
 #  include "mozilla/dom/Document.h"
 #  include "nsString.h"
 #  include "unicode/uloc.h"
@@ -152,20 +152,19 @@ double ICUUtils::ParseNumber(nsAString& 
     UniqueUNumberFormat format(
         unum_open(UNUM_DECIMAL, nullptr, 0, langTag.get(), nullptr, &status));
     if (!LocaleNumberGroupingIsEnabled()) {
       unum_setAttribute(format.get(), UNUM_GROUPING_USED, UBool(0));
     }
     int32_t parsePos = 0;
     static_assert(sizeof(UChar) == 2 && sizeof(nsAString::char_type) == 2,
                   "Unexpected character size - the following cast is unsafe");
-    double val =
-        unum_parseDouble(format.get(),
-                         (const UChar*)PromiseFlatString(aValue).get(),
-                         length, &parsePos, &status);
+    double val = unum_parseDouble(format.get(),
+                                  (const UChar*)PromiseFlatString(aValue).get(),
+                                  length, &parsePos, &status);
     if (U_SUCCESS(status) && parsePos == (int32_t)length) {
       return val;
     }
     aLangTags.GetNext(langTag);
   }
   return std::numeric_limits<float>::quiet_NaN();
 }
 
--- a/ipc/glue/InputStreamUtils.h
+++ b/ipc/glue/InputStreamUtils.h
@@ -54,28 +54,30 @@ class InputStreamHelper {
                                    InputStreamParams& aParams,
                                    nsTArray<FileDescriptor>& aFileDescriptors,
                                    bool aDelayedStart, uint32_t aMaxSize,
                                    uint32_t* aSizeUsed,
                                    PBackgroundParent* aManager);
 
   // When a stream wants to serialize itself as IPCRemoteStream, it uses one of
   // these methods.
-  static void SerializeInputStreamAsPipe(
-      nsIInputStream* aInputStream, InputStreamParams& aParams,
-      bool aDelayedStart, mozilla::dom::ContentChild* aManager);
+  static void SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
+                                         InputStreamParams& aParams,
+                                         bool aDelayedStart,
+                                         mozilla::dom::ContentChild* aManager);
 
   static void SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
                                          InputStreamParams& aParams,
                                          bool aDelayedStart,
                                          PBackgroundChild* aManager);
 
-  static void SerializeInputStreamAsPipe(
-      nsIInputStream* aInputStream, InputStreamParams& aParams,
-      bool aDelayedStart, mozilla::dom::ContentParent* aManager);
+  static void SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
+                                         InputStreamParams& aParams,
+                                         bool aDelayedStart,
+                                         mozilla::dom::ContentParent* aManager);
 
   static void SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
                                          InputStreamParams& aParams,
                                          bool aDelayedStart,
                                          PBackgroundParent* aManager);
 
   // After the sending of the inputStream into the IPC pipe, some of the
   // InputStreamParams data struct needs to be activated (IPCRemoteStream).
--- a/ipc/glue/nsIIPCSerializableInputStream.h
+++ b/ipc/glue/nsIIPCSerializableInputStream.h
@@ -74,39 +74,39 @@ class NS_NO_VTABLE nsIIPCSerializableInp
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
                               NS_IIPCSERIALIZABLEINPUTSTREAM_IID)
 
 #define NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM                             \
   virtual void Serialize(mozilla::ipc::InputStreamParams&,                \
                          FileDescriptorArray&, bool, uint32_t, uint32_t*, \
-                         mozilla::dom::ContentChild*) override;        \
+                         mozilla::dom::ContentChild*) override;           \
                                                                           \
   virtual void Serialize(mozilla::ipc::InputStreamParams&,                \
                          FileDescriptorArray&, bool, uint32_t, uint32_t*, \
                          mozilla::ipc::PBackgroundChild*) override;       \
                                                                           \
   virtual void Serialize(mozilla::ipc::InputStreamParams&,                \
                          FileDescriptorArray&, bool, uint32_t, uint32_t*, \
-                         mozilla::dom::ContentParent*) override;       \
+                         mozilla::dom::ContentParent*) override;          \
                                                                           \
   virtual void Serialize(mozilla::ipc::InputStreamParams&,                \
                          FileDescriptorArray&, bool, uint32_t, uint32_t*, \
                          mozilla::ipc::PBackgroundParent*) override;      \
                                                                           \
   virtual bool Deserialize(const mozilla::ipc::InputStreamParams&,        \
                            const FileDescriptorArray&) override;
 
 #define NS_FORWARD_NSIIPCSERIALIZABLEINPUTSTREAM(_to)                          \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
                          bool aDelayedStart, uint32_t aMaxSize,                \
                          uint32_t* aSizeUsed,                                  \
-                         mozilla::dom::ContentChild* aManager) override {   \
+                         mozilla::dom::ContentChild* aManager) override {      \
     _to Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,          \
                   aSizeUsed, aManager);                                        \
   }                                                                            \
                                                                                \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
                          bool aDelayedStart, uint32_t aMaxSize,                \
                          uint32_t* aSizeUsed,                                  \
@@ -114,17 +114,17 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSeri
     _to Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,          \
                   aSizeUsed, aManager);                                        \
   }                                                                            \
                                                                                \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
                          bool aDelayedStart, uint32_t aMaxSize,                \
                          uint32_t* aSizeUsed,                                  \
-                         mozilla::dom::ContentParent* aManager) override {  \
+                         mozilla::dom::ContentParent* aManager) override {     \
     _to Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,          \
                   aSizeUsed, aManager);                                        \
   }                                                                            \
                                                                                \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
                          bool aDelayedStart, uint32_t aMaxSize,                \
                          uint32_t* aSizeUsed,                                  \
@@ -139,17 +139,17 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSeri
     return _to Deserialize(aParams, aFileDescriptors);                         \
   }
 
 #define NS_FORWARD_SAFE_NSIIPCSERIALIZABLEINPUTSTREAM(_to)                     \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
                          bool aDelayedStart, uint32_t aMaxSize,                \
                          uint32_t* aSizeUsed,                                  \
-                         mozilla::dom::ContentChild* aManager) override {   \
+                         mozilla::dom::ContentChild* aManager) override {      \
     if (_to) {                                                                 \
       _to->Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,       \
                      aSizeUsed, aManager);                                     \
     }                                                                          \
   }                                                                            \
                                                                                \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
@@ -161,17 +161,17 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSeri
                      aSizeUsed, aManager);                                     \
     }                                                                          \
   }                                                                            \
                                                                                \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
                          bool aDelayedStart, uint32_t aMaxSize,                \
                          uint32_t* aSizeUsed,                                  \
-                         mozilla::dom::ContentParent* aManager) override {  \
+                         mozilla::dom::ContentParent* aManager) override {     \
     if (_to) {                                                                 \
       _to->Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,       \
                      aSizeUsed, aManager);                                     \
     }                                                                          \
   }                                                                            \
                                                                                \
   virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,             \
                          FileDescriptorArray& aFileDescriptors,                \
--- a/js/public/ErrorReport.h
+++ b/js/public/ErrorReport.h
@@ -148,28 +148,28 @@ class JSErrorNotes {
   // Stores pointers to each note.
   js::Vector<js::UniquePtr<Note>, 1, js::SystemAllocPolicy> notes_;
 
  public:
   JSErrorNotes();
   ~JSErrorNotes();
 
   // Add an note to the given position.
-  bool addNoteASCII(JSContext* cx, const char* filename,
-                    unsigned sourceId, unsigned lineno,
-                    unsigned column, JSErrorCallback errorCallback,
-                    void* userRef, const unsigned errorNumber, ...);
-  bool addNoteLatin1(JSContext* cx, const char* filename,
-                     unsigned sourceId, unsigned lineno,
-                     unsigned column, JSErrorCallback errorCallback,
-                     void* userRef, const unsigned errorNumber, ...);
-  bool addNoteUTF8(JSContext* cx, const char* filename,
-                   unsigned sourceId, unsigned lineno,
-                   unsigned column, JSErrorCallback errorCallback,
-                   void* userRef, const unsigned errorNumber, ...);
+  bool addNoteASCII(JSContext* cx, const char* filename, unsigned sourceId,
+                    unsigned lineno, unsigned column,
+                    JSErrorCallback errorCallback, void* userRef,
+                    const unsigned errorNumber, ...);
+  bool addNoteLatin1(JSContext* cx, const char* filename, unsigned sourceId,
+                     unsigned lineno, unsigned column,
+                     JSErrorCallback errorCallback, void* userRef,
+                     const unsigned errorNumber, ...);
+  bool addNoteUTF8(JSContext* cx, const char* filename, unsigned sourceId,
+                   unsigned lineno, unsigned column,
+                   JSErrorCallback errorCallback, void* userRef,
+                   const unsigned errorNumber, ...);
 
   JS_PUBLIC_API size_t length();
 
   // Create a deep copy of notes.
   js::UniquePtr<JSErrorNotes> copy(JSContext* cx);
 
   class iterator final
       : public std::iterator<std::input_iterator_tag, js::UniquePtr<Note>> {
--- a/js/src/builtin/DataViewObject.cpp
+++ b/js/src/builtin/DataViewObject.cpp
@@ -1005,18 +1005,17 @@ static const ClassOps DataViewObjectClas
 const ClassSpec DataViewObject::classSpec_ = {
     GenericCreateConstructor<DataViewObject::construct, 1,
                              gc::AllocKind::FUNCTION>,
     GenericCreatePrototype<DataViewObject>,
     nullptr,
     nullptr,
     DataViewObject::methods,
     DataViewObject::properties,
-    DataViewObject::finishInit
-};
+    DataViewObject::finishInit};
 
 const Class DataViewObject::class_ = {
     "DataView",
     JSCLASS_HAS_PRIVATE |
         JSCLASS_HAS_RESERVED_SLOTS(DataViewObject::RESERVED_SLOTS) |
         JSCLASS_HAS_CACHED_PROTO(JSProto_DataView),
     &DataViewObjectClassOps, &DataViewObject::classSpec_};
 
@@ -1042,18 +1041,17 @@ const JSFunctionSpec DataViewObject::met
     JS_FN("setFloat32", DataViewObject::fun_setFloat32, 2, 0),
     JS_FN("setFloat64", DataViewObject::fun_setFloat64, 2, 0),
     JS_FS_END};
 
 const JSFunctionSpec DataViewObject::bigIntMethods[] = {
     JS_FN("getBigInt64", DataViewObject::fun_getBigInt64, 1, 0),
     JS_FN("getBigUint64", DataViewObject::fun_getBigUint64, 1, 0),
     JS_FN("setBigInt64", DataViewObject::fun_setBigInt64, 2, 0),
-    JS_FN("setBigUint64", DataViewObject::fun_setBigUint64, 2, 0),
-    JS_FS_END};
+    JS_FN("setBigUint64", DataViewObject::fun_setBigUint64, 2, 0), JS_FS_END};
 
 const JSPropertySpec DataViewObject::properties[] = {
     JS_PSG("buffer", DataViewObject::bufferGetter, 0),
     JS_PSG("byteLength", DataViewObject::byteLengthGetter, 0),
     JS_PSG("byteOffset", DataViewObject::byteOffsetGetter, 0),
     JS_STRING_SYM_PS(toStringTag, "DataView", JSPROP_READONLY), JS_PS_END};
 
 JS_FRIEND_API JSObject* JS_NewDataView(JSContext* cx, HandleObject buffer,
--- a/js/src/builtin/TestingFunctions.h
+++ b/js/src/builtin/TestingFunctions.h
@@ -17,18 +17,17 @@ MOZ_MUST_USE bool DefineTestingFunctions
 
 MOZ_MUST_USE bool testingFunc_assertFloat32(JSContext* cx, unsigned argc,
                                             Value* vp);
 
 MOZ_MUST_USE bool testingFunc_assertRecoveredOnBailout(JSContext* cx,
                                                        unsigned argc,
                                                        Value* vp);
 
-MOZ_MUST_USE bool testingFunc_serialize(JSContext* cx,
-                                        unsigned argc,
+MOZ_MUST_USE bool testingFunc_serialize(JSContext* cx, unsigned argc,
                                         Value* vp);
 
 extern JSScript* TestingFunctionArgumentToScript(JSContext* cx, HandleValue v,
                                                  JSFunction** funp = nullptr);
 
 } /* namespace js */
 
 #endif /* builtin_TestingFunctions_h */
--- a/js/src/frontend/BytecodeEmitter.h
+++ b/js/src/frontend/BytecodeEmitter.h
@@ -158,21 +158,23 @@ struct MOZ_STACK_CLASS BytecodeEmitter {
   // initialized. Use |parser| instead.
   mozilla::Maybe<EitherParser> ep_ = {};
   BCEParserHandle* parser = nullptr;
 
   PooledMapPtr<AtomIndexMap> atomIndices; /* literals indexed for mapping */
   unsigned firstLine = 0; /* first line, for JSScript::initFromEmitter */
 
   uint32_t maxFixedSlots = 0; /* maximum number of fixed frame slots so far */
-  uint32_t maxStackDepth = 0; /* maximum number of expression stack slots so far */
+  uint32_t maxStackDepth =
+      0; /* maximum number of expression stack slots so far */
 
   int32_t stackDepth = 0; /* current stack depth in script frame */
 
-  uint32_t bodyScopeIndex = UINT32_MAX; /* index into scopeList of the body scope */
+  uint32_t bodyScopeIndex =
+      UINT32_MAX; /* index into scopeList of the body scope */
 
   EmitterScope* varEmitterScope = nullptr;
   NestableControl* innermostNestableControl = nullptr;
   EmitterScope* innermostEmitterScope_ = nullptr;
   TDZCheckCache* innermostTDZCheckCache = nullptr;
 
   /* field info for enclosing class */
   FieldInitializers fieldInitializers_;
@@ -347,18 +349,18 @@ struct MOZ_STACK_CLASS BytecodeEmitter {
     MOZ_ASSERT(emitterScope);
     MOZ_ASSERT(!varEmitterScope);
     varEmitterScope = emitterScope;
   }
 
   Scope* outermostScope() const { return scopeList.vector[0]; }
   Scope* innermostScope() const;
   Scope* bodyScope() const {
-      MOZ_ASSERT(bodyScopeIndex < scopeList.length());
-      return scopeList.vector[bodyScopeIndex];
+    MOZ_ASSERT(bodyScopeIndex < scopeList.length());
+    return scopeList.vector[bodyScopeIndex];
   }
 
   MOZ_ALWAYS_INLINE
   MOZ_MUST_USE bool makeAtomIndex(JSAtom* atom, uint32_t* indexp) {
     MOZ_ASSERT(atomIndices);
     AtomIndexMap::AddPtr p = atomIndices->lookupForAdd(atom);
     if (p) {
       *indexp = p->value();
--- a/js/src/frontend/FunctionEmitter.cpp
+++ b/js/src/frontend/FunctionEmitter.cpp
@@ -486,34 +486,35 @@ bool FunctionScriptEmitter::prepareForBo
 #ifdef DEBUG
   state_ = State::Body;
 #endif
   return true;
 }
 
 bool FunctionScriptEmitter::emitAsyncFunctionRejectPrologue() {
   rejectTryCatch_.emplace(bce_, TryEmitter::Kind::TryCatch,
-                   TryEmitter::ControlKind::NonSyntactic);
+                          TryEmitter::ControlKind::NonSyntactic);
   return rejectTryCatch_->emitTry();
 }
 
 bool FunctionScriptEmitter::emitAsyncFunctionRejectEpilogue() {
   if (!rejectTryCatch_->emitCatch()) {
     return false;
   }
 
   if (!bce_->emit1(JSOP_EXCEPTION)) {
     //              [stack] EXC
     return false;
   }
   if (!bce_->emitGetDotGeneratorInInnermostScope()) {
     //              [stack] EXC GEN
     return false;
   }
-  if (!bce_->emit2(JSOP_ASYNCRESOLVE, uint8_t(AsyncFunctionResolveKind::Reject))) {
+  if (!bce_->emit2(JSOP_ASYNCRESOLVE,
+                   uint8_t(AsyncFunctionResolveKind::Reject))) {
     //              [stack] PROMISE
     return false;
   }
   if (!bce_->emit1(JSOP_SETRVAL)) {
     //              [stack]
     return false;
   }
   if (!bce_->emitGetDotGeneratorInInnermostScope()) {
--- a/js/src/frontend/TokenStream.cpp
+++ b/js/src/frontend/TokenStream.cpp
@@ -754,20 +754,19 @@ MOZ_COLD void TokenStreamChars<Utf8Unit,
       relevantUnits--;
     }
 
     ptr[-1] = '\0';
 
     uint32_t line, column;
     computeLineAndColumn(offset, &line, &column);
 
-    if (!notes->addNoteASCII(anyChars.cx, anyChars.getFilename(),
-                             0, line, column,
-                             GetErrorMessage, nullptr, JSMSG_BAD_CODE_UNITS,
-                             badUnitsStr)) {
+    if (!notes->addNoteASCII(anyChars.cx, anyChars.getFilename(), 0, line,
+                             column, GetErrorMessage, nullptr,
+                             JSMSG_BAD_CODE_UNITS, badUnitsStr)) {
       break;
     }
 
     ReportCompileError(anyChars.cx, std::move(err), std::move(notes),
                        JSREPORT_ERROR, errorNumber, &args);
   } while (false);
 
   va_end(args);
--- a/js/src/gc/Allocator.cpp
+++ b/js/src/gc/Allocator.cpp
@@ -21,18 +21,19 @@
 #include "gc/Heap-inl.h"
 #include "gc/PrivateIterators-inl.h"
 #include "vm/JSObject-inl.h"
 
 using namespace js;
 using namespace gc;
 
 template <AllowGC allowGC /* = CanGC */>
-JSObject* js::AllocateObject(JSContext* cx, AllocKind kind, size_t nDynamicSlots,
-                             InitialHeap heap, const Class* clasp) {
+JSObject* js::AllocateObject(JSContext* cx, AllocKind kind,
+                             size_t nDynamicSlots, InitialHeap heap,
+                             const Class* clasp) {
   MOZ_ASSERT(IsObjectAllocKind(kind));
   size_t thingSize = Arena::thingSize(kind);
 
   MOZ_ASSERT(thingSize == Arena::thingSize(kind));
   MOZ_ASSERT(thingSize >= sizeof(JSObject_Slots0));
   static_assert(
       sizeof(JSObject_Slots0) >= MinCellSize,
       "All allocations must be at least the allocator-imposed minimum size.");
@@ -70,26 +71,24 @@ JSObject* js::AllocateObject(JSContext* 
     if (!allowGC) {
       return nullptr;
     }
   }
 
   return GCRuntime::tryNewTenuredObject<allowGC>(cx, kind, thingSize,
                                                  nDynamicSlots);
 }
-template JSObject* js::AllocateObject<NoGC>(JSContext* cx,
-                                            gc::AllocKind kind,
+template JSObject* js::AllocateObject<NoGC>(JSContext* cx, gc::AllocKind kind,
                                             size_t nDynamicSlots,
                                             gc::InitialHeap heap,
                                             const Class* clasp);
-template JSObject* js::AllocateObject<CanGC>(JSContext* cx,
-                                               gc::AllocKind kind,
-                                               size_t nDynamicSlots,
-                                               gc::InitialHeap heap,
-                                               const Class* clasp);
+template JSObject* js::AllocateObject<CanGC>(JSContext* cx, gc::AllocKind kind,
+                                             size_t nDynamicSlots,
+                                             gc::InitialHeap heap,
+                                             const Class* clasp);
 
 // Attempt to allocate a new JSObject out of the nursery. If there is not
 // enough room in the nursery or there is an OOM, this method will return
 // nullptr.
 template <AllowGC allowGC>
 JSObject* GCRuntime::tryNewNurseryObject(JSContext* cx, size_t thingSize,
                                          size_t nDynamicSlots,
                                          const Class* clasp) {
--- a/js/src/gc/Allocator.h
+++ b/js/src/gc/Allocator.h
@@ -27,18 +27,19 @@ template <typename T, AllowGC allowGC = 
 T* Allocate(JSContext* cx);
 
 // Allocate a JSObject.
 //
 // A longer signature that includes additional information in support of various
 // optimizations. If dynamic slots are requested they will be allocated and the
 // pointer stored directly in |NativeObject::slots_|.
 template <AllowGC allowGC = CanGC>
-JSObject* AllocateObject(JSContext* cx, gc::AllocKind kind, size_t nDynamicSlots,
-                         gc::InitialHeap heap, const Class* clasp);
+JSObject* AllocateObject(JSContext* cx, gc::AllocKind kind,
+                         size_t nDynamicSlots, gc::InitialHeap heap,
+                         const Class* clasp);
 
 // Internal function used for nursery-allocatable strings.
 template <typename StringAllocT, AllowGC allowGC = CanGC>
 StringAllocT* AllocateStringImpl(JSContext* cx, gc::InitialHeap heap);
 
 // Allocate a string.
 //
 // Use for nursery-allocatable strings. Returns a value cast to the correct
--- a/js/src/gc/Nursery.h
+++ b/js/src/gc/Nursery.h
@@ -146,17 +146,18 @@ class Nursery {
    */
   static const size_t SubChunkStep = gc::ArenaSize;
 
   /*
    * 192K is conservative, not too low that root marking dominates.  The Limit
    * should be a multiple of the Step.
    */
   static const size_t SubChunkLimit = 192 * 1024;
-  static_assert(SubChunkLimit % SubChunkStep == 0, "The limit should be a multiple of the step");
+  static_assert(SubChunkLimit % SubChunkStep == 0,
+                "The limit should be a multiple of the step");
 
   struct alignas(gc::CellAlignBytes) CellAlignedByte {
     char byte;
   };
 
   struct StringLayout {
     JS::Zone* zone;
     CellAlignedByte cell;
--- a/js/src/gc/WeakMap.h
+++ b/js/src/gc/WeakMap.h
@@ -152,18 +152,18 @@ class WeakMap
   using Ptr = typename Base::Ptr;
   using AddPtr = typename Base::AddPtr;
 
   struct Enum : public Base::Enum {
     explicit Enum(WeakMap& map) : Base::Enum(static_cast<Base&>(map)) {}
   };
 
   using Base::all;
+  using Base::clear;
   using Base::has;
-  using Base::clear;
   using Base::shallowSizeOfExcludingThis;
 
   // Resolve ambiguity with LinkedListElement<>::remove.
   using Base::remove;
 
   explicit WeakMap(JSContext* cx, JSObject* memOf = nullptr);
 
   // Add a read barrier to prevent an incorrectly gray value from escaping the
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -1657,18 +1657,17 @@ MOZ_MUST_USE bool BaselineCompilerCodeGe
     return emit();
   }
   return true;
 }
 
 template <>
 template <typename F>
 MOZ_MUST_USE bool BaselineCompilerCodeGen::emitTestScriptFlag(
-    JSScript::MutableFlags flag, bool value, const F& emit,
-    Register scratch) {
+    JSScript::MutableFlags flag, bool value, const F& emit, Register scratch) {
   if (handler.script()->hasFlag(flag) == value) {
     return emit();
   }
   return true;
 }
 
 template <>
 template <typename F>
@@ -1688,18 +1687,17 @@ MOZ_MUST_USE bool BaselineInterpreterCod
 
   masm.bind(&done);
   return true;
 }
 
 template <>
 template <typename F>
 MOZ_MUST_USE bool BaselineInterpreterCodeGen::emitTestScriptFlag(
-    JSScript::MutableFlags flag, bool value, const F& emit,
-    Register scratch) {
+    JSScript::MutableFlags flag, bool value, const F& emit, Register scratch) {
   Label done;
   loadScript(scratch);
   masm.branchTest32(value ? Assembler::Zero : Assembler::NonZero,
                     Address(scratch, JSScript::offsetOfMutableFlags()),
                     Imm32(uint32_t(flag)), &done);
   {
     if (!emit()) {
       return false;
--- a/js/src/jit/BaselineCompiler.h
+++ b/js/src/jit/BaselineCompiler.h
@@ -381,19 +381,18 @@ class BaselineCodeGen {
                                        Register scratch);
 
   // If |script->hasFlag(flag) == value|, execute the code emitted by |emit|.
   template <typename F>
   MOZ_MUST_USE bool emitTestScriptFlag(JSScript::ImmutableFlags flag,
                                        bool value, const F& emit,
                                        Register scratch);
   template <typename F>
-  MOZ_MUST_USE bool emitTestScriptFlag(JSScript::MutableFlags flag,
-                                       bool value, const F& emit,
-                                       Register scratch);
+  MOZ_MUST_USE bool emitTestScriptFlag(JSScript::MutableFlags flag, bool value,
+                                       const F& emit, Register scratch);
 
   MOZ_MUST_USE bool emitCheckThis(ValueOperand val, bool reinit = false);
   void emitLoadReturnValue(ValueOperand val);
 
   MOZ_MUST_USE bool emitNextIC();
   MOZ_MUST_USE bool emitInterruptCheck();
   MOZ_MUST_USE bool emitWarmUpCounterIncrement();
   MOZ_MUST_USE bool emitTraceLoggerResume(Register script,
--- a/js/src/jit/BaselineFrame.h
+++ b/js/src/jit/BaselineFrame.h
@@ -98,17 +98,17 @@ class BaselineFrame {
     };
     BaselineDebugModeOSRInfo* debugModeOSRInfo_;
   };
 
   uint32_t flags_;
   uint32_t frameSize_;
   uint32_t loReturnValue_;  // If HAS_RVAL, the frame's return value.
   uint32_t hiReturnValue_;
-  uint32_t overrideOffset_;   // If HAS_OVERRIDE_PC, the bytecode offset.
+  uint32_t overrideOffset_;  // If HAS_OVERRIDE_PC, the bytecode offset.
 #if JS_BITS_PER_WORD == 32
   // Ensure frame is 8-byte aligned, see static_assert below.
   uint32_t padding_;
 #endif
 
  public:
   // Distance between the frame pointer and the frame header (return address).
   // This is the old frame pointer saved in the prologue.
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -5996,18 +5996,18 @@ void CodeGenerator::emitAssertGCThingRes
 
     masm.assumeUnreachable(
         "MIR instruction returned object with unexpected type");
 
     masm.bind(&ok);
   }
 
   // Check that we have a valid GC pointer.
-  // Disable for wasm because we don't have a context on wasm compilation threads
-  // and this needs a context.
+  // Disable for wasm because we don't have a context on wasm compilation
+  // threads and this needs a context.
   if (JitOptions.fullDebugChecks && !IsCompilingWasm()) {
     saveVolatile();
     masm.setupUnalignedABICall(temp);
     masm.loadJSContext(temp);
     masm.passABIArg(temp);
     masm.passABIArg(input);
 
     void* callee;
@@ -7495,19 +7495,17 @@ void CodeGenerator::emitWasmCallBase(LWa
     if (switchRealm) {
       masm.switchToWasmTlsRealm(ABINonArgReturnReg0, ABINonArgReturnReg1);
     }
   } else {
     MOZ_ASSERT(!switchRealm);
   }
 }
 
-void CodeGenerator::visitWasmCall(LWasmCall* ins) {
-  emitWasmCallBase(ins);
-}
+void CodeGenerator::visitWasmCall(LWasmCall* ins) { emitWasmCallBase(ins); }
 
 void CodeGenerator::visitWasmCallVoid(LWasmCallVoid* ins) {
   emitWasmCallBase(ins);
 }
 
 void CodeGenerator::visitWasmCallI64(LWasmCallI64* ins) {
   emitWasmCallBase(ins);
 }
@@ -10313,17 +10311,17 @@ void CodeGenerator::visitRest(LRest* lir
 }
 
 // A stackmap creation helper.  Create a stackmap from a vector of booleans.
 // The caller owns the resulting stackmap.
 
 typedef Vector<bool, 128, SystemAllocPolicy> StackMapBoolVector;
 
 static wasm::StackMap* ConvertStackMapBoolVectorToStackMap(
-                          const StackMapBoolVector& vec, bool hasRefs) {
+    const StackMapBoolVector& vec, bool hasRefs) {
   wasm::StackMap* stackMap = wasm::StackMap::create(vec.length());
   if (!stackMap) {
     return nullptr;
   }
 
   bool hasRefsObserved = false;
   size_t i = 0;
   for (bool b : vec) {
@@ -10367,17 +10365,18 @@ static bool CreateStackMapFromLSafepoint
   const size_t nBodyBytes = safepoint.framePushedAtStackMapBase();
 
   // This is the number of bytes in the general spill area, the Frame, and the
   // incoming args, but not including any trap (register dump) area.
   const size_t nNonTrapBytes = nBodyBytes + nFrameBytes + nInboundStackArgBytes;
   MOZ_ASSERT(nNonTrapBytes % sizeof(void*) == 0);
 
   // This is the total number of bytes covered by the map.
-  const DebugOnly<size_t> nTotalBytes = nNonTrapBytes +
+  const DebugOnly<size_t> nTotalBytes =
+      nNonTrapBytes +
       (safepoint.isWasmTrap() ? (trapExitLayoutNumWords * sizeof(void*)) : 0);
 
   // Create the stackmap initially in this vector.  Since most frames will
   // contain 128 or fewer words, heap allocation is avoided in the majority of
   // cases.  vec[0] is for the lowest address in the map, vec[N-1] is for the
   // highest address in the map.
   StackMapBoolVector vec;
 
@@ -10393,17 +10392,17 @@ static bool CreateStackMapFromLSafepoint
     // don't expect to have any live values in registers, hence no roots in
     // registers.
     if (!vec.appendN(false, trapExitLayoutNumWords)) {
       return false;
     }
     for (; gcRegsIter.more(); ++gcRegsIter) {
       Register reg = *gcRegsIter;
       size_t offsetFromTop =
-        reinterpret_cast<size_t>(trapExitLayout.address(reg));
+          reinterpret_cast<size_t>(trapExitLayout.address(reg));
 
       // If this doesn't hold, the associated register wasn't saved by
       // the trap exit stub.  Better to crash now than much later, in
       // some obscure place, and possibly with security consequences.
       MOZ_RELEASE_ASSERT(offsetFromTop < trapExitLayoutNumWords);
 
       // offsetFromTop is an offset in words down from the highest
       // address in the exit stub save area.  Switch it around to be an
@@ -10462,18 +10461,18 @@ static bool CreateStackMapFromLSafepoint
   }
   if (safepoint.isWasmTrap()) {
     stackMap->setExitStubWords(trapExitLayoutNumWords);
   }
 
   // Record in the map, how far down from the highest address the Frame* is.
   // Take the opportunity to check that we haven't marked any part of the
   // Frame itself as a pointer.
-  stackMap->setFrameOffsetFromTop((nInboundStackArgBytes + nFrameBytes)
-                                  / sizeof(void*));
+  stackMap->setFrameOffsetFromTop((nInboundStackArgBytes + nFrameBytes) /
+                                  sizeof(void*));
 #ifdef DEBUG
   for (uint32_t i = 0; i < nFrameBytes / sizeof(void*); i++) {
     MOZ_ASSERT(stackMap->getBit(stackMap->numMappedWords -
                                 stackMap->frameOffsetFromTop + i) == 0);
   }
 #endif
 
   *result = stackMap;
@@ -10495,50 +10494,46 @@ static bool CreateStackMapFromLSafepoint
 // For non-debug builds, if the stackmap would contain no pointers, no
 // stackmap is created, and nullptr is returned.  For a debug build, a
 // stackmap is always created and returned.
 //
 // The "space reserved before trap" is the space reserved by
 // MacroAssembler::wasmReserveStackChecked, in the case where the frame is
 // "small", as determined by that function.
 static bool CreateStackMapForFunctionEntryTrap(
-                const wasm::ValTypeVector& argTypes,
-                const MachineState& trapExitLayout,
-                size_t trapExitLayoutWords,
-                size_t nBytesReservedBeforeTrap,
-                size_t nInboundStackArgBytes,
-                wasm::StackMap** result) {
+    const wasm::ValTypeVector& argTypes, const MachineState& trapExitLayout,
+    size_t trapExitLayoutWords, size_t nBytesReservedBeforeTrap,
+    size_t nInboundStackArgBytes, wasm::StackMap** result) {
   // Ensure this is defined on all return paths.
   *result = nullptr;
 
   // The size of the wasm::Frame itself.
   const size_t nFrameBytes = sizeof(wasm::Frame);
 
   // The size of the register dump (trap) area.
   const size_t trapExitLayoutBytes = trapExitLayoutWords * sizeof(void*);
 
   // This is the total number of bytes covered by the map.
-  const DebugOnly<size_t> nTotalBytes =
-      trapExitLayoutBytes + nBytesReservedBeforeTrap + nFrameBytes +
-      nInboundStackArgBytes;
+  const DebugOnly<size_t> nTotalBytes = trapExitLayoutBytes +
+                                        nBytesReservedBeforeTrap + nFrameBytes +
+                                        nInboundStackArgBytes;
 
   // Create the stackmap initially in this vector.  Since most frames will
   // contain 128 or fewer words, heap allocation is avoided in the majority of
   // cases.  vec[0] is for the lowest address in the map, vec[N-1] is for the
   // highest address in the map.
   StackMapBoolVector vec;
 
   // Keep track of whether we've actually seen any refs.
   bool hasRefs = false;
 
   // REG DUMP AREA
   wasm::ExitStubMapVector trapExitExtras;
-  if (!GenerateStackmapEntriesForTrapExit(argTypes, trapExitLayout,
-                                          trapExitLayoutWords,
-                                          &trapExitExtras)) {
+  if (!GenerateStackmapEntriesForTrapExit(
+          argTypes, trapExitLayout, trapExitLayoutWords, &trapExitExtras)) {
     return false;
   }
   MOZ_ASSERT(trapExitExtras.length() == trapExitLayoutWords);
 
   if (!vec.appendN(false, trapExitLayoutWords)) {
     return false;
   }
   for (size_t i = 0; i < trapExitLayoutWords; i++) {
@@ -10591,18 +10586,18 @@ static bool CreateStackMapForFunctionEnt
   // Convert vec into a wasm::StackMap.
   MOZ_ASSERT(vec.length() * sizeof(void*) == nTotalBytes);
   wasm::StackMap* stackMap = ConvertStackMapBoolVectorToStackMap(vec, hasRefs);
   if (!stackMap) {
     return false;
   }
   stackMap->setExitStubWords(trapExitLayoutWords);
 
-  stackMap->setFrameOffsetFromTop(nFrameBytes / sizeof(void*)
-                                  + numStackArgWords);
+  stackMap->setFrameOffsetFromTop(nFrameBytes / sizeof(void*) +
+                                  numStackArgWords);
 #ifdef DEBUG
   for (uint32_t i = 0; i < nFrameBytes / sizeof(void*); i++) {
     MOZ_ASSERT(stackMap->getBit(stackMap->numMappedWords -
                                 stackMap->frameOffsetFromTop + i) == 0);
   }
 #endif
 
   *result = stackMap;
@@ -10628,19 +10623,20 @@ bool CodeGenerator::generateWasm(wasm::F
     masm.reserveStack(frameSize());
   } else {
     std::pair<CodeOffset, uint32_t> pair =
         masm.wasmReserveStackChecked(frameSize(), trapOffset);
     CodeOffset trapInsnOffset = pair.first;
     size_t nBytesReservedBeforeTrap = pair.second;
 
     wasm::StackMap* functionEntryStackMap = nullptr;
-    if (!CreateStackMapForFunctionEntryTrap(argTypes, trapExitLayout,
-            trapExitLayoutNumWords, nBytesReservedBeforeTrap,
-            nInboundStackArgBytes, &functionEntryStackMap)) {
+    if (!CreateStackMapForFunctionEntryTrap(
+            argTypes, trapExitLayout, trapExitLayoutNumWords,
+            nBytesReservedBeforeTrap, nInboundStackArgBytes,
+            &functionEntryStackMap)) {
       return false;
     }
     // In debug builds, we'll always have a stack map, even if there are no
     // refs to track.
     MOZ_ALWAYS_TRUE(functionEntryStackMap);
     if (functionEntryStackMap &&
         !stackMaps->add((uint8_t*)(uintptr_t)trapInsnOffset.offset(),
                         functionEntryStackMap)) {
@@ -10685,17 +10681,18 @@ bool CodeGenerator::generateWasm(wasm::F
   MOZ_ASSERT(safepoints_.size() == 0);
   MOZ_ASSERT(!scriptCounts_);
 
   // Convert the safepoints to stackmaps and add them to our running
   // collection thereof.
   for (SafepointIndex& index : safepointIndices_) {
     wasm::StackMap* stackMap = nullptr;
     if (!CreateStackMapFromLSafepoint(*index.safepoint(), trapExitLayout,
-            trapExitLayoutNumWords, nInboundStackArgBytes, &stackMap)) {
+                                      trapExitLayoutNumWords,
+                                      nInboundStackArgBytes, &stackMap)) {
       return false;
     }
     // In debug builds, we'll always have a stack map.
     MOZ_ALWAYS_TRUE(stackMap);
     if (!stackMap) {
       continue;
     }
     if (!stackMaps->add((uint8_t*)(uintptr_t)index.displacement(), stackMap)) {
--- a/js/src/jit/CompileWrappers.cpp
+++ b/js/src/jit/CompileWrappers.cpp
@@ -212,19 +212,17 @@ bool CompileRealm::hasAllocationMetadata
 // semantics of the JavaScript code which is executed.
 void CompileRealm::setSingletonsAsValues() {
   realm()->behaviors().setSingletonsAsValues();
 }
 
 JitCompileOptions::JitCompileOptions()
     : cloneSingletons_(false),
       profilerSlowAssertionsEnabled_(false),
-      offThreadCompilationAvailable_(false)
-{
-}
+      offThreadCompilationAvailable_(false) {}
 
 JitCompileOptions::JitCompileOptions(JSContext* cx) {
   cloneSingletons_ = cx->realm()->creationOptions().cloneSingletons();
   profilerSlowAssertionsEnabled_ =
       cx->runtime()->geckoProfiler().enabled() &&
       cx->runtime()->geckoProfiler().slowAssertionsEnabled();
   offThreadCompilationAvailable_ = OffThreadCompilationAvailable(cx);
 }
--- a/js/src/jit/Linker.h
+++ b/js/src/jit/Linker.h
@@ -25,18 +25,17 @@ class Linker {
   JitCode* fail(JSContext* cx) {
     ReportOutOfMemory(cx);
     return nullptr;
   }
 
  public:
   // Construct a linker with a rooted macro assembler.
   explicit Linker(MacroAssembler& masm, const char* name)
-      : masm(masm), afc(name)
-  {
+      : masm(masm), afc(name) {
     masm.finish();
   }
 
   // Create a new JitCode object and populate it with the contents of the
   // macro assember buffer.
   //
   // This method cannot GC. Errors are reported to the context.
   JitCode* newCode(JSContext* cx, CodeKind kind);
--- a/js/src/jit/Lowering.cpp
+++ b/js/src/jit/Lowering.cpp
@@ -4341,17 +4341,18 @@ void LIRGenerator::visitWasmStoreGlobalV
     LAllocation tlsPtr = useRegister(ins->tlsPtr());
     LInt64Allocation valueAlloc = useInt64Register(value);
 #endif
     add(new (alloc()) LWasmStoreSlotI64(valueAlloc, tlsPtr, offs), ins);
   } else {
     MOZ_ASSERT(value->type() != MIRType::RefOrNull);
     LAllocation tlsPtr = useRegisterAtStart(ins->tlsPtr());
     LAllocation valueAlloc = useRegisterAtStart(value);
-    add(new (alloc()) LWasmStoreSlot(valueAlloc, tlsPtr, offs, value->type()), ins);
+    add(new (alloc()) LWasmStoreSlot(valueAlloc, tlsPtr, offs, value->type()),
+        ins);
   }
 }
 
 void LIRGenerator::visitWasmStoreGlobalCell(MWasmStoreGlobalCell* ins) {
   MDefinition* value = ins->value();
   size_t offs = 0;
   if (value->type() == MIRType::Int64) {
 #ifdef JS_PUNBOX64
@@ -4743,18 +4744,18 @@ void LIRGenerator::visitConstant(MConsta
   }
 }
 
 void LIRGenerator::visitWasmNullConstant(MWasmNullConstant* ins) {
   define(new (alloc()) LWasmNullConstant(), ins);
 }
 
 void LIRGenerator::visitIsNullPointer(MIsNullPointer* ins) {
-  define(new (alloc()) LIsNullPointer(
-           useRegisterAtStart(ins->getOperand(0))), ins);
+  define(new (alloc()) LIsNullPointer(useRegisterAtStart(ins->getOperand(0))),
+         ins);
 }
 
 void LIRGenerator::visitWasmFloatConstant(MWasmFloatConstant* ins) {
   switch (ins->type()) {
     case MIRType::Double:
       define(new (alloc()) LDouble(ins->toDouble()), ins);
       break;
     case MIRType::Float32:
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -5492,18 +5492,18 @@ MDefinition* MWasmUnsignedToFloat32::fol
   return this;
 }
 
 MWasmCall* MWasmCall::New(TempAllocator& alloc, const wasm::CallSiteDesc& desc,
                           const wasm::CalleeDesc& callee, const Args& args,
                           MIRType resultType,
                           uint32_t stackArgAreaSizeUnaligned,
                           MDefinition* tableIndex) {
-  MWasmCall* call = new (alloc) MWasmCall(desc, callee,
-                                          stackArgAreaSizeUnaligned);
+  MWasmCall* call =
+      new (alloc) MWasmCall(desc, callee, stackArgAreaSizeUnaligned);
   call->setResultType(resultType);
 
   if (!call->argRegs_.init(alloc, args.length())) {
     return nullptr;
   }
   for (size_t i = 0; i < call->argRegs_.length(); i++) {
     call->argRegs_[i] = args[i].reg;
   }
@@ -5523,19 +5523,18 @@ MWasmCall* MWasmCall::New(TempAllocator&
   return call;
 }
 
 MWasmCall* MWasmCall::NewBuiltinInstanceMethodCall(
     TempAllocator& alloc, const wasm::CallSiteDesc& desc,
     const wasm::SymbolicAddress builtin, const ABIArg& instanceArg,
     const Args& args, MIRType resultType, uint32_t stackArgAreaSizeUnaligned) {
   auto callee = wasm::CalleeDesc::builtinInstanceMethod(builtin);
-  MWasmCall* call =
-      MWasmCall::New(alloc, desc, callee, args, resultType,
-                     stackArgAreaSizeUnaligned, nullptr);
+  MWasmCall* call = MWasmCall::New(alloc, desc, callee, args, resultType,
+                                   stackArgAreaSizeUnaligned, nullptr);
   if (!call) {
     return nullptr;
   }
 
   MOZ_ASSERT(instanceArg != ABIArg());
   call->instanceArg_ = instanceArg;
   return call;
 }
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -110,21 +110,21 @@ static inline MIRType MIRTypeFromValue(c
    * GuardRangeBailouts.                                                       \
    *                                                                           \
    * This flag prevents further optimization of instructions, which            \
    * might remove the run-time checks (bailout conditions) used as a           \
    * predicate of the previous transformation.                                 \
    */                                                                          \
   _(GuardRangeBailouts)                                                        \
                                                                                \
-  /* Some instructions have uses that aren't directly represented in the graph,\
-   * and need to be handled specially. As an example, this is used to keep the \
-   * flagged instruction in resume points, not substituting with an            \
-   * UndefinedValue. This can be used by call inlining when a function argument\
-   * is not used by the inlined instructions.                                  \
+  /* Some instructions have uses that aren't directly represented in the       \
+   * graph, and need to be handled specially. As an example, this is used to   \
+   * keep the flagged instruction in resume points, not substituting with an   \
+   * UndefinedValue. This can be used by call inlining when a function         \
+   * argument is not used by the inlined instructions.                         \
    */                                                                          \
   _(ImplicitlyUsed)                                                            \
                                                                                \
   /* The instruction has been marked dead for lazy removal from resume         \
    * points.                                                                   \
    */                                                                          \
   _(Unused)                                                                    \
                                                                                \
@@ -1567,22 +1567,23 @@ class MWasmNullConstant : public MNullar
     return ins->isWasmNullConstant();
   }
   AliasSet getAliasSet() const override { return AliasSet::None(); }
 
   ALLOW_CLONE(MWasmNullConstant)
 };
 
 class MIsNullPointer : public MUnaryInstruction, public NoTypePolicy::Data {
-  explicit MIsNullPointer(MDefinition* value) : MUnaryInstruction(classOpcode,
-                                                                  value) {
+  explicit MIsNullPointer(MDefinition* value)
+      : MUnaryInstruction(classOpcode, value) {
     MOZ_ASSERT(value->type() == MIRType::Pointer);
     setResultType(MIRType::Boolean);
     setMovable();
   }
+
  public:
   INSTRUCTION_HEADER(IsNullPointer);
 
   static MIsNullPointer* New(TempAllocator& alloc, MDefinition* value) {
     return new (alloc) MIsNullPointer(value);
   }
 
   bool congruentTo(const MDefinition* ins) const override {
@@ -3213,17 +3214,18 @@ class MCompare : public MBinaryInstructi
     setMovable();
   }
 
   MCompare(MDefinition* left, MDefinition* right, JSOp jsop,
            CompareType compareType)
       : MCompare(left, right, jsop) {
     MOZ_ASSERT(compareType == Compare_Int32 || compareType == Compare_UInt32 ||
                compareType == Compare_Int64 || compareType == Compare_UInt64 ||
-               compareType == Compare_Double || compareType == Compare_Float32 ||
+               compareType == Compare_Double ||
+               compareType == Compare_Float32 ||
                compareType == Compare_RefOrNull);
     compareType_ = compareType;
     operandMightEmulateUndefined_ = false;
     setResultType(MIRType::Int32);
   }
 
  public:
   INSTRUCTION_HEADER(Compare)
@@ -11898,17 +11900,17 @@ class MWasmStoreGlobalCell : public MBin
 // Represents a known-good derived pointer into an object or memory region (in
 // the most general sense) that will not move while the derived pointer is live.
 // The `offset` *must* be a valid offset into the object represented by `base`;
 // hence overflow in the address calculation will never be an issue.
 
 class MWasmDerivedPointer : public MUnaryInstruction,
                             public NoTypePolicy::Data {
   MWasmDerivedPointer(MDefinition* base, size_t offset)
-    : MUnaryInstruction(classOpcode, base), offset_(offset) {
+      : MUnaryInstruction(classOpcode, base), offset_(offset) {
     MOZ_ASSERT(offset <= INT32_MAX);
     setResultType(MIRType::Pointer);
     setMovable();
   }
 
   size_t offset_;
 
  public:
@@ -11922,18 +11924,17 @@ class MWasmDerivedPointer : public MUnar
 
   bool congruentTo(const MDefinition* ins) const override {
     return congruentIfOperandsEqual(ins);
   }
 
   ALLOW_CLONE(MWasmDerivedPointer)
 };
 
-class MWasmLoadRef : public MUnaryInstruction,
-                     public NoTypePolicy::Data {
+class MWasmLoadRef : public MUnaryInstruction, public NoTypePolicy::Data {
   AliasSet::Flag aliasSet_;
 
   explicit MWasmLoadRef(MDefinition* valueAddr, AliasSet::Flag aliasSet)
       : MUnaryInstruction(classOpcode, valueAddr), aliasSet_(aliasSet) {
     MOZ_ASSERT(valueAddr->type() == MIRType::Pointer);
     setResultType(MIRType::RefOrNull);
     setMovable();
   }
@@ -11945,38 +11946,35 @@ class MWasmLoadRef : public MUnaryInstru
   bool congruentTo(const MDefinition* ins) const override {
     return congruentIfOperandsEqual(ins);
   }
   AliasSet getAliasSet() const override { return AliasSet::Load(aliasSet_); }
 
   ALLOW_CLONE(MWasmLoadRef)
 };
 
-class MWasmStoreRef : public MAryInstruction<3>,
-                      public NoTypePolicy::Data {
+class MWasmStoreRef : public MAryInstruction<3>, public NoTypePolicy::Data {
   AliasSet::Flag aliasSet_;
 
   MWasmStoreRef(MDefinition* tls, MDefinition* valueAddr, MDefinition* value,
                 AliasSet::Flag aliasSet)
-    : MAryInstruction<3>(classOpcode), aliasSet_(aliasSet) {
+      : MAryInstruction<3>(classOpcode), aliasSet_(aliasSet) {
     MOZ_ASSERT(valueAddr->type() == MIRType::Pointer);
     MOZ_ASSERT(value->type() == MIRType::RefOrNull);
     initOperand(0, tls);
     initOperand(1, valueAddr);
     initOperand(2, value);
   }
 
  public:
   INSTRUCTION_HEADER(WasmStoreRef)
   TRIVIAL_NEW_WRAPPERS
   NAMED_OPERANDS((0, tls), (1, valueAddr), (2, value))
 
-  AliasSet getAliasSet() const override {
-    return AliasSet::Store(aliasSet_);
-  }
+  AliasSet getAliasSet() const override { return AliasSet::Store(aliasSet_); }
 };
 
 class MWasmParameter : public MNullaryInstruction {
   ABIArg abi_;
 
   MWasmParameter(ABIArg abi, MIRType mirType)
       : MNullaryInstruction(classOpcode), abi_(abi) {
     setResultType(mirType);
@@ -12028,17 +12026,19 @@ class MWasmCall final : public MVariadic
   wasm::CallSiteDesc desc_;
   wasm::CalleeDesc callee_;
   FixedList<AnyRegister> argRegs_;
   uint32_t stackArgAreaSizeUnaligned_;
   ABIArg instanceArg_;
 
   MWasmCall(const wasm::CallSiteDesc& desc, const wasm::CalleeDesc& callee,
             uint32_t stackArgAreaSizeUnaligned)
-      : MVariadicInstruction(classOpcode), desc_(desc), callee_(callee),
+      : MVariadicInstruction(classOpcode),
+        desc_(desc),
+        callee_(callee),
         stackArgAreaSizeUnaligned_(stackArgAreaSizeUnaligned) {}
 
  public:
   INSTRUCTION_HEADER(WasmCall)
 
   struct Arg {
     AnyRegister reg;
     MDefinition* def;
--- a/js/src/jit/MacroAssembler.cpp
+++ b/js/src/jit/MacroAssembler.cpp
@@ -3422,19 +3422,18 @@ void MacroAssembler::wasmInterruptCheck(
                                         wasm::BytecodeOffset bytecodeOffset) {
   Label ok;
   branch32(Assembler::Equal, Address(tls, offsetof(wasm::TlsData, interrupt)),
            Imm32(0), &ok);
   wasmTrap(wasm::Trap::CheckInterrupt, bytecodeOffset);
   bind(&ok);
 }
 
-std::pair<CodeOffset, uint32_t>
-MacroAssembler::wasmReserveStackChecked(uint32_t amount,
-                                        wasm::BytecodeOffset trapOffset) {
+std::pair<CodeOffset, uint32_t> MacroAssembler::wasmReserveStackChecked(
+    uint32_t amount, wasm::BytecodeOffset trapOffset) {
   if (amount > MAX_UNCHECKED_LEAF_FRAME_SIZE) {
     // The frame is large.  Don't bump sp until after the stack limit check so
     // that the trap handler isn't called with a wild sp.
     Label ok;
     Register scratch = ABINonArgReg0;
     moveStackPtrTo(scratch);
     subPtr(Address(WasmTlsReg, offsetof(wasm::TlsData, stackLimit)), scratch);
     branchPtr(Assembler::GreaterThan, scratch, Imm32(amount), &ok);
@@ -3448,17 +3447,17 @@ MacroAssembler::wasmReserveStackChecked(
   reserveStack(amount);
   Label ok;
   branchStackPtrRhs(Assembler::Below,
                     Address(WasmTlsReg, offsetof(wasm::TlsData, stackLimit)),
                     &ok);
   wasmTrap(wasm::Trap::StackOverflow, trapOffset);
   CodeOffset trapInsnOffset = CodeOffset(currentOffset());
   bind(&ok);
-  return std::pair<CodeOffset,uint32_t>(trapInsnOffset, amount);
+  return std::pair<CodeOffset, uint32_t>(trapInsnOffset, amount);
 }
 
 CodeOffset MacroAssembler::wasmCallImport(const wasm::CallSiteDesc& desc,
                                           const wasm::CalleeDesc& callee) {
   // Load the callee, before the caller's registers are clobbered.
   uint32_t globalDataOffset = callee.importGlobalDataOffset();
   loadWasmGlobalPtr(globalDataOffset + offsetof(wasm::FuncImportTls, code),
                     ABINonArgReg0);
--- a/js/src/jit/MacroAssembler.h
+++ b/js/src/jit/MacroAssembler.h
@@ -1758,18 +1758,18 @@ class MacroAssembler : public MacroAssem
   CodeOffset wasmTrapInstruction() PER_SHARED_ARCH;
 
   void wasmTrap(wasm::Trap trap, wasm::BytecodeOffset bytecodeOffset);
   void wasmInterruptCheck(Register tls, wasm::BytecodeOffset bytecodeOffset);
 
   // Returns a pair: the offset of the undefined (trapping) instruction, and
   // the number of extra bytes of stack allocated prior to the trap
   // instruction proper.
-  std::pair<CodeOffset, uint32_t>
-  wasmReserveStackChecked(uint32_t amount, wasm::BytecodeOffset trapOffset);
+  std::pair<CodeOffset, uint32_t> wasmReserveStackChecked(
+      uint32_t amount, wasm::BytecodeOffset trapOffset);
 
   // Emit a bounds check against the wasm heap limit, jumping to 'label' if
   // 'cond' holds. If JitOptions.spectreMaskIndex is true, in speculative
   // executions 'index' is saturated in-place to 'boundsCheckLimit'.
   void wasmBoundsCheck(Condition cond, Register index,
                        Register boundsCheckLimit, Label* label)
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
 
--- a/js/src/jit/ProcessExecutableMemory.cpp
+++ b/js/src/jit/ProcessExecutableMemory.cpp
@@ -167,19 +167,20 @@ static bool RegisterExecutableMemory(voi
 
   memset(&r->unwindInfo, 0, sizeof(r->unwindInfo));
   r->unwindInfo.hasExceptionHandler = true;
   r->unwindInfo.exceptionHandler = offsetof(ExceptionHandlerRecord, thunk);
 
   // Use a fake unwind code to make the Windows unwinder do _something_. If the
   // PC and SP both stay unchanged, we'll fail the unwinder's sanity checks and
   // it won't call our exception handler.
-  r->unwindInfo.codeWords = 1; // one 32-bit word gives us up to 4 codes
-  r->unwindInfo.unwindCodes[0] = 0b00000001; // alloc_s small stack of size 1*16
-  r->unwindInfo.unwindCodes[1] = 0b11100100; // end
+  r->unwindInfo.codeWords = 1;  // one 32-bit word gives us up to 4 codes
+  r->unwindInfo.unwindCodes[0] =
+      0b00000001;  // alloc_s small stack of size 1*16
+  r->unwindInfo.unwindCodes[1] = 0b11100100;  // end
 
   uint32_t* thunk = (uint32_t*)r->thunk;
   uint16_t* addr = (uint16_t*)&handler;
 
   // xip0/r16 should be safe to clobber: Windows just used it to call our thunk.
   const uint8_t reg = 16;
 
   // Say `handler` is 0x4444333322221111, then:
--- a/js/src/jit/VMFunctionList-inl.h
+++ b/js/src/jit/VMFunctionList-inl.h
@@ -273,20 +273,17 @@ namespace jit {
   _(DoSetPropFallback, js::jit::DoSetPropFallback, 1)           \
   _(DoToBoolFallback, js::jit::DoToBoolFallback, 0)             \
   _(DoTypeMonitorFallback, js::jit::DoTypeMonitorFallback, 0)   \
   _(DoTypeOfFallback, js::jit::DoTypeOfFallback, 0)             \
   _(DoUnaryArithFallback, js::jit::DoUnaryArithFallback, 1)     \
   _(GeneratorThrowOrReturn, js::jit::GeneratorThrowOrReturn, 0)
 
 #define DEF_ID(name, ...) name,
-enum class VMFunctionId {
-  VMFUNCTION_LIST(DEF_ID)
-      Count
-};
+enum class VMFunctionId { VMFUNCTION_LIST(DEF_ID) Count };
 enum class TailCallVMFunctionId { TAIL_CALL_VMFUNCTION_LIST(DEF_ID) Count };
 #undef DEF_ID
 
 // Define the VMFunctionToId template to map from signature + function to
 // the VMFunctionId. This lets us verify the consumer/codegen code matches
 // the C++ signature.
 template <typename Function, Function fun>
 struct VMFunctionToId;  // Error here? Update VMFUNCTION_LIST?
@@ -321,9 +318,9 @@ TAIL_CALL_VMFUNCTION_LIST(DEF_TEMPLATE)
 
 #if MOZ_IS_GCC
 #  pragma GCC diagnostic pop
 #endif
 
 }  // namespace jit
 }  // namespace js
 
-#endif // jit_VMFunctionList_inl_h
+#endif  // jit_VMFunctionList_inl_h
--- a/js/src/jit/shared/LIR-shared.h
+++ b/js/src/jit/shared/LIR-shared.h
@@ -6630,101 +6630,104 @@ class LWasmAtomicBinopHeapForEffect : pu
   const LDefinition* maskTemp() { return getTemp(4); }
 
   MWasmAtomicBinopHeap* mir() const { return mir_->toWasmAtomicBinopHeap(); }
 };
 
 class LWasmLoadSlot : public LInstructionHelper<1, 1, 0> {
   size_t offset_;
   MIRType type_;
+
  public:
   LIR_HEADER(WasmLoadSlot);
-  explicit LWasmLoadSlot(const LAllocation& containerRef, size_t offset, MIRType type)
-    : LInstructionHelper(classOpcode), offset_(offset), type_(type) {
+  explicit LWasmLoadSlot(const LAllocation& containerRef, size_t offset,
+                         MIRType type)
+      : LInstructionHelper(classOpcode), offset_(offset), type_(type) {
     setOperand(0, containerRef);
   }
   const LAllocation* containerRef() { return getOperand(0); }
   size_t offset() const { return offset_; }
   MIRType type() const { return type_; }
 };
 
 class LWasmLoadSlotI64 : public LInstructionHelper<INT64_PIECES, 1, 0> {
   size_t offset_;
+
  public:
   LIR_HEADER(WasmLoadSlotI64);
   explicit LWasmLoadSlotI64(const LAllocation& containerRef, size_t offset)
-    : LInstructionHelper(classOpcode), offset_(offset) {
+      : LInstructionHelper(classOpcode), offset_(offset) {
     setOperand(0, containerRef);
   }
   const LAllocation* containerRef() { return getOperand(0); }
   size_t offset() const { return offset_; }
 };
 
 class LWasmStoreSlot : public LInstructionHelper<0, 2, 0> {
   size_t offset_;
   MIRType type_;
+
  public:
   LIR_HEADER(WasmStoreSlot);
   LWasmStoreSlot(const LAllocation& value, const LAllocation& containerRef,
                  size_t offset, MIRType type)
-    : LInstructionHelper(classOpcode), offset_(offset), type_(type) {
+      : LInstructionHelper(classOpcode), offset_(offset), type_(type) {
     setOperand(0, value);
     setOperand(1, containerRef);
   }
   const LAllocation* value() { return getOperand(0); }
   const LAllocation* containerRef() { return getOperand(1); }
   size_t offset() const { return offset_; }
   MIRType type() const { return type_; }
 };
 
-class LWasmStoreSlotI64
-    : public LInstructionHelper<0, INT64_PIECES + 1, 0> {
+class LWasmStoreSlotI64 : public LInstructionHelper<0, INT64_PIECES + 1, 0> {
   size_t offset_;
+
  public:
   LIR_HEADER(WasmStoreSlotI64);
   LWasmStoreSlotI64(const LInt64Allocation& value,
-                    const LAllocation& containerRef,
-                    size_t offset)
-    : LInstructionHelper(classOpcode), offset_(offset) {
+                    const LAllocation& containerRef, size_t offset)
+      : LInstructionHelper(classOpcode), offset_(offset) {
     setInt64Operand(0, value);
     setOperand(INT64_PIECES, containerRef);
   }
   const LInt64Allocation value() { return getInt64Operand(0); }
   const LAllocation* containerRef() { return getOperand(INT64_PIECES); }
   size_t offset() const { return offset_; }
 };
 
 class LWasmDerivedPointer : public LInstructionHelper<1, 1, 0> {
  public:
   LIR_HEADER(WasmDerivedPointer);
   explicit LWasmDerivedPointer(const LAllocation& base)
-    : LInstructionHelper(classOpcode) {
+      : LInstructionHelper(classOpcode) {
     setOperand(0, base);
   }
   const LAllocation* base() { return getOperand(0); }
   size_t offset() { return mirRaw()->toWasmDerivedPointer()->offset(); }
 };
 
 class LWasmLoadRef : public LInstructionHelper<1, 1, 0> {
  public:
   LIR_HEADER(WasmLoadRef);
   explicit LWasmLoadRef(const LAllocation& ptr)
-    : LInstructionHelper(classOpcode) {
+      : LInstructionHelper(classOpcode) {
     setOperand(0, ptr);
   }
   MWasmLoadRef* mir() const { return mirRaw()->toWasmLoadRef(); }
   const LAllocation* ptr() { return getOperand(0); }
 };
 
 class LWasmStoreRef : public LInstructionHelper<0, 3, 1> {
  public:
   LIR_HEADER(WasmStoreRef);
   LWasmStoreRef(const LAllocation& tls, const LAllocation& valueAddr,
                 const LAllocation& value, const LDefinition& temp)
-    : LInstructionHelper(classOpcode) {
+      : LInstructionHelper(classOpcode) {
     setOperand(0, tls);
     setOperand(1, valueAddr);
     setOperand(2, value);
     setTemp(0, temp);
   }
   MWasmStoreRef* mir() const { return mirRaw()->toWasmStoreRef(); }
   const LAllocation* tls() { return getOperand(0); }
   const LAllocation* valueAddr() { return getOperand(1); }
@@ -6795,26 +6798,24 @@ class LWasmStackArgI64 : public LInstruc
 inline bool IsWasmCall(LNode::Opcode op) {
   return (op == LNode::Opcode::WasmCall || op == LNode::Opcode::WasmCallVoid ||
           op == LNode::Opcode::WasmCallI64);
 }
 
 class LWasmNullConstant : public LInstructionHelper<1, 0, 0> {
  public:
   LIR_HEADER(WasmNullConstant);
-  explicit LWasmNullConstant()
-      : LInstructionHelper(classOpcode) {
-  }
+  explicit LWasmNullConstant() : LInstructionHelper(classOpcode) {}
 };
 
 class LIsNullPointer : public LInstructionHelper<1, 1, 0> {
  public:
   LIR_HEADER(IsNullPointer);
   explicit LIsNullPointer(const LAllocation& value)
-    : LInstructionHelper(classOpcode) {
+      : LInstructionHelper(classOpcode) {
     setOperand(0, value);
   }
   MIsNullPointer* mir() const { return mirRaw()->toIsNullPointer(); }
   const LAllocation* value() { return getOperand(0); }
 };
 
 template <size_t Defs>
 class LWasmCallBase : public LVariadicInstruction<Defs, 0> {
--- a/js/src/jsapi-tests/testArrayBuffer.cpp
+++ b/js/src/jsapi-tests/testArrayBuffer.cpp
@@ -239,31 +239,33 @@ BEGIN_TEST(testArrayBuffer_stealDetachEx
 }
 END_TEST(testArrayBuffer_stealDetachExternal)
 
 BEGIN_TEST(testArrayBuffer_serializeExternal) {
   JS::RootedValue serializeValue(cx);
 
   {
     JS::RootedFunction serialize(cx);
-    serialize = JS_NewFunction(cx, js::testingFunc_serialize, 1, 0, "serialize");
+    serialize =
+        JS_NewFunction(cx, js::testingFunc_serialize, 1, 0, "serialize");
     CHECK(serialize);
 
     serializeValue.setObject(*JS_GetFunctionObject(serialize));
   }
 
   ExternalData data("One two three four");
   JS::RootedObject externalBuffer(
       cx, JS::NewExternalArrayBuffer(cx, data.len(), data.contents(),
                                      &ExternalData::freeCallback, &data));
   CHECK(externalBuffer);
   CHECK(!data.wasFreed());
 
   JS::RootedValue v(cx, JS::ObjectValue(*externalBuffer));
-  JS::RootedObject transferMap(cx, JS_NewArrayObject(cx, JS::HandleValueArray(v)));
+  JS::RootedObject transferMap(cx,
+                               JS_NewArrayObject(cx, JS::HandleValueArray(v)));
   CHECK(transferMap);
 
   JS::AutoValueArray<2> args(cx);
   args[0].setObject(*externalBuffer);
   args[1].setObject(*transferMap);
 
   // serialize(externalBuffer, [externalBuffer]) should throw for an unhandled
   // BufferContents kind.
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -5299,20 +5299,19 @@ void JSErrorBase::freeMessage() {
   message_ = JS::ConstUTF8CharsZ();
 }
 
 JSErrorNotes::JSErrorNotes() : notes_() {}
 
 JSErrorNotes::~JSErrorNotes() {}
 
 static UniquePtr<JSErrorNotes::Note> CreateErrorNoteVA(
-    JSContext* cx, const char* filename, unsigned sourceId,
-    unsigned lineno, unsigned column,
-    JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber,
-    ErrorArgumentsType argumentsType, va_list ap) {
+    JSContext* cx, const char* filename, unsigned sourceId, unsigned lineno,
+    unsigned column, JSErrorCallback errorCallback, void* userRef,
+    const unsigned errorNumber, ErrorArgumentsType argumentsType, va_list ap) {
   auto note = MakeUnique<JSErrorNotes::Note>();
   if (!note) {
     ReportOutOfMemory(cx);
     return nullptr;
   }
 
   note->errorNumber = errorNumber;
   note->filename = filename;
@@ -5324,69 +5323,68 @@ static UniquePtr<JSErrorNotes::Note> Cre
                               argumentsType, note.get(), ap)) {
     return nullptr;
   }
 
   return note;
 }
 
 bool JSErrorNotes::addNoteASCII(JSContext* cx, const char* filename,
-                                unsigned sourceId,
-                                unsigned lineno, unsigned column,
-                                JSErrorCallback errorCallback, void* userRef,
-                                const unsigned errorNumber, ...) {
+                                unsigned sourceId, unsigned lineno,
+                                unsigned column, JSErrorCallback errorCallback,
+                                void* userRef, const unsigned errorNumber,
+                                ...) {
   va_list ap;
   va_start(ap, errorNumber);
-  auto note = CreateErrorNoteVA(cx, filename, sourceId, lineno, column,
-                                errorCallback,
-                                userRef, errorNumber, ArgumentsAreASCII, ap);
+  auto note =
+      CreateErrorNoteVA(cx, filename, sourceId, lineno, column, errorCallback,
+                        userRef, errorNumber, ArgumentsAreASCII, ap);
   va_end(ap);
 
   if (!note) {
     return false;
   }
   if (!notes_.append(std::move(note))) {
     ReportOutOfMemory(cx);
     return false;
   }
   return true;
 }
 
 bool JSErrorNotes::addNoteLatin1(JSContext* cx, const char* filename,
-                                 unsigned sourceId,
-                                 unsigned lineno, unsigned column,
-                                 JSErrorCallback errorCallback, void* userRef,
-                                 const unsigned errorNumber, ...) {
+                                 unsigned sourceId, unsigned lineno,
+                                 unsigned column, JSErrorCallback errorCallback,
+                                 void* userRef, const unsigned errorNumber,
+                                 ...) {
   va_list ap;
   va_start(ap, errorNumber);
-  auto note = CreateErrorNoteVA(cx, filename, sourceId, lineno, column,
-                                errorCallback,
-                                userRef, errorNumber, ArgumentsAreLatin1, ap);
+  auto note =
+      CreateErrorNoteVA(cx, filename, sourceId, lineno, column, errorCallback,
+                        userRef, errorNumber, ArgumentsAreLatin1, ap);
   va_end(ap);
 
   if (!note) {
     return false;
   }
   if (!notes_.append(std::move(note))) {
     ReportOutOfMemory(cx);
     return false;
   }
   return true;
 }
 
 bool JSErrorNotes::addNoteUTF8(JSContext* cx, const char* filename,
-                               unsigned sourceId,
-                               unsigned lineno, unsigned column,
-                               JSErrorCallback errorCallback, void* userRef,
-                               const unsigned errorNumber, ...) {
+                               unsigned sourceId, unsigned lineno,
+                               unsigned column, JSErrorCallback errorCallback,
+                               void* userRef, const unsigned errorNumber, ...) {
   va_list ap;
   va_start(ap, errorNumber);
-  auto note = CreateErrorNoteVA(cx, filename, sourceId, lineno, column,
-                                errorCallback,
-                                userRef, errorNumber, ArgumentsAreUTF8, ap);
+  auto note =
+      CreateErrorNoteVA(cx, filename, sourceId, lineno, column, errorCallback,
+                        userRef, errorNumber, ArgumentsAreUTF8, ap);
   va_end(ap);
 
   if (!note) {
     return false;
   }
   if (!notes_.append(std::move(note))) {
     ReportOutOfMemory(cx);
     return false;
--- a/js/src/jsexn.cpp
+++ b/js/src/jsexn.cpp
@@ -446,20 +446,19 @@ bool Error(JSContext* cx, unsigned argc,
     columnNumber = FixupColumnForDisplay(columnNumber);
   }
 
   RootedObject stack(cx);
   if (!CaptureStack(cx, &stack)) {
     return false;
   }
 
-  RootedObject obj(cx,
-                   ErrorObject::create(cx, exnType, stack, fileName, sourceId,
-                                       lineNumber, columnNumber, nullptr,
-                                       message, proto));
+  RootedObject obj(cx, ErrorObject::create(cx, exnType, stack, fileName,
+                                           sourceId, lineNumber, columnNumber,
+                                           nullptr, message, proto));
   if (!obj) {
     return false;
   }
 
   args.rval().setObject(*obj);
   return true;
 }
 
@@ -666,17 +665,17 @@ void js::ErrorToException(JSContext* cx,
   }
 
   UniquePtr<JSErrorReport> report = CopyErrorReport(cx, reportp);
   if (!report) {
     return;
   }
 
   ErrorObject* errObject =
-    ErrorObject::create(cx, exnType, stack, fileName, sourceId, lineNumber,
+      ErrorObject::create(cx, exnType, stack, fileName, sourceId, lineNumber,
                           columnNumber, std::move(report), messageStr);
   if (!errObject) {
     return;
   }
 
   // Throw it.
   RootedValue errValue(cx, ObjectValue(*errObject));
   cx->setPendingException(errValue);
@@ -955,17 +954,17 @@ bool ErrorReport::populateUncaughtExcept
   // XXXbz this assumes the stack we have right now is still
   // related to our exception object.  It would be better if we
   // could accept a passed-in stack of some sort instead.
   NonBuiltinFrameIter iter(cx, cx->realm()->principals());
   if (!iter.done()) {
     ownedReport.filename = iter.filename();
     uint32_t column;
     ownedReport.sourceId =
-      iter.hasScript() ? iter.script()->scriptSource()->id() : 0;
+        iter.hasScript() ? iter.script()->scriptSource()->id() : 0;
     ownedReport.lineno = iter.computeLine(&column);
     ownedReport.column = FixupColumnForDisplay(column);
     ownedReport.isMuted = iter.mutedErrors();
   }
 
   if (!ExpandErrorArgumentsVA(cx, GetErrorMessage, nullptr,
                               JSMSG_UNCAUGHT_EXCEPTION, nullptr,
                               ArgumentsAreUTF8, &ownedReport, ap)) {
@@ -1000,18 +999,18 @@ JSObject* js::CopyErrorObject(JSContext*
   }
   uint32_t sourceId = err->sourceId();
   uint32_t lineNumber = err->lineNumber();
   uint32_t columnNumber = err->columnNumber();
   JSExnType errorType = err->type();
 
   // Create the Error object.
   return ErrorObject::create(cx, errorType, stack, fileName, sourceId,
-                             lineNumber, columnNumber,
-                             std::move(copyReport), message);
+                             lineNumber, columnNumber, std::move(copyReport),
+                             message);
 }
 
 JS_PUBLIC_API bool JS::CreateError(JSContext* cx, JSExnType type,
                                    HandleObject stack, HandleString fileName,
                                    uint32_t lineNumber, uint32_t columnNumber,
                                    JSErrorReport* report, HandleString message,
                                    MutableHandleValue rval) {
   cx->check(stack, fileName, message);
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -10897,17 +10897,18 @@ int main(int argc, char** argv, char** e
       || !op.addBoolOption('\0', "no-native-regexp",
                            "Disable native regexp compilation") ||
       !op.addBoolOption('\0', "no-unboxed-objects",
                         "Disable creating unboxed plain objects") ||
       !op.addBoolOption('\0', "enable-streams",
                         "Enable WHATWG Streams (default)") ||
       !op.addBoolOption('\0', "no-streams", "Disable WHATWG Streams") ||
       !op.addBoolOption('\0', "no-bigint", "Disable BigInt support") ||
-      !op.addBoolOption('\0', "enable-experimental-fields", "Enable fields in classes") ||
+      !op.addBoolOption('\0', "enable-experimental-fields",
+                        "Enable fields in classes") ||
       !op.addStringOption('\0', "shared-memory", "on/off",
                           "SharedArrayBuffer and Atomics "
 #if SHARED_MEMORY_DEFAULT
                           "(default: on, off to disable)"
 #else
                           "(default: off, on to enable)"
 #endif
                           ) ||
--- a/js/src/vm/ArrayBufferObject.h
+++ b/js/src/vm/ArrayBufferObject.h
@@ -165,17 +165,17 @@ class ArrayBufferObject : public ArrayBu
                 "right flags slot");
 
   // The length of an ArrayBuffer or SharedArrayBuffer can be at most
   // INT32_MAX, and much code must change if this changes.
   static constexpr size_t MaxBufferByteLength = INT32_MAX;
 
   /** The largest number of bytes that can be stored inline. */
   static constexpr size_t MaxInlineBytes =
-    (NativeObject::MAX_FIXED_SLOTS - RESERVED_SLOTS) * sizeof(JS::Value);
+      (NativeObject::MAX_FIXED_SLOTS - RESERVED_SLOTS) * sizeof(JS::Value);
 
  public:
   enum OwnsState {
     DoesntOwnData = 0,
     OwnsData = 1,
   };
 
   enum BufferKind {
--- a/js/src/vm/Caches-inl.h
+++ b/js/src/vm/Caches-inl.h
@@ -67,19 +67,18 @@ inline NativeObject* NewObjectCache::new
       heap = gc::TenuredHeap;
     }
   }
 
   if (cx->runtime()->gc.upcomingZealousGC()) {
     return nullptr;
   }
 
-  NativeObject* obj = static_cast<NativeObject*>(
-      AllocateObject<NoGC>(cx, entry->kind, /* nDynamicSlots = */ 0,
-                           heap, group->clasp()));
+  NativeObject* obj = static_cast<NativeObject*>(AllocateObject<NoGC>(
+      cx, entry->kind, /* nDynamicSlots = */ 0, heap, group->clasp()));
   if (!obj) {
     return nullptr;
   }
 
   copyCachedToObject(obj, templateObj, entry->kind);
 
   if (group->clasp()->shouldDelayMetadataBuilder()) {
     cx->realm()->setObjectPendingMetadata(cx, obj);
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -8405,19 +8405,17 @@ static bool DebuggerSource_getURL(JSCont
 class DebuggerSourceGetIdMatcher {
  public:
   using ReturnType = uint32_t;
 
   ReturnType match(HandleScriptSourceObject sourceObject) {
     ScriptSource* ss = sourceObject->source();
     return ss->id();
   }
-  ReturnType match(Handle<WasmInstanceObject*> instanceObj) {
-    return 0;
-  }
+  ReturnType match(Handle<WasmInstanceObject*> instanceObj) { return 0; }
 };
 
 static bool DebuggerSource_getId(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get id)", args, obj, referent);
 
   DebuggerSourceGetIdMatcher matcher;
   uint32_t id = referent.match(matcher);
   args.rval().setNumber(id);
--- a/js/src/vm/JSObject.cpp
+++ b/js/src/vm/JSObject.cpp
@@ -3518,17 +3518,18 @@ static void dumpValue(const Value& v, js
           out.printf(" (%s:%u)", script->filename() ? script->filename() : "",
                      script->lineno());
         }
         out.printf(" at %p>", (void*)fun);
       } else {
         JSObject* obj = &v.toObject();
         const Class* clasp = obj->getClass();
         out.printf("<%s%s at %p>", clasp->name,
-                   (clasp == &PlainObject::class_) ? "" : " object", (void*)obj);
+                   (clasp == &PlainObject::class_) ? "" : " object",
+                   (void*)obj);
       }
       break;
     case ValueType::Boolean:
       if (v.toBoolean()) {
         out.put("true");
       } else {
         out.put("false");
       }
--- a/js/src/vm/ProxyObject.cpp
+++ b/js/src/vm/ProxyObject.cpp
@@ -182,18 +182,18 @@ void ProxyObject::nuke() {
 
     MOZ_ASSERT(group->realm() == realm);
     realm->newProxyCache.add(group, shape);
   }
 
   gc::InitialHeap heap = GetInitialHeap(newKind, clasp);
   debugCheckNewObject(group, shape, allocKind, heap);
 
-  JSObject* obj = js::AllocateObject(cx, allocKind, /* nDynamicSlots = */ 0,
-                                     heap, clasp);
+  JSObject* obj =
+      js::AllocateObject(cx, allocKind, /* nDynamicSlots = */ 0, heap, clasp);
   if (!obj) {
     return cx->alreadyReportedOOM();
   }
 
   ProxyObject* pobj = static_cast<ProxyObject*>(obj);
   pobj->initGroup(group);
   pobj->initShape(shape);
 
--- a/js/src/vm/Realm.h
+++ b/js/src/vm/Realm.h
@@ -285,21 +285,23 @@ class ObjectRealm {
       js::HandleObject thisv);
   js::LexicalEnvironmentObject* getNonSyntacticLexicalEnvironment(
       JSObject* key) const;
 };
 
 }  // namespace js
 
 namespace JS {
-template <> struct GCPolicy<js::ImmediateMetadata>:
-  public IgnoreGCPolicy<js::ImmediateMetadata> {};
-template <> struct GCPolicy<js::DelayMetadata>:
-  public IgnoreGCPolicy<js::DelayMetadata> {};
-} // namespace JS
+template <>
+struct GCPolicy<js::ImmediateMetadata>
+    : public IgnoreGCPolicy<js::ImmediateMetadata> {};
+template <>
+struct GCPolicy<js::DelayMetadata> : public IgnoreGCPolicy<js::DelayMetadata> {
+};
+}  // namespace JS
 
 class JS::Realm : public JS::shadow::Realm {
   JS::Zone* zone_;
   JSRuntime* runtime_;
 
   const JS::RealmCreationOptions creationOptions_;
   JS::RealmBehaviors behaviors_;
 
--- a/js/src/vm/SavedStacks.cpp
+++ b/js/src/vm/SavedStacks.cpp
@@ -237,17 +237,18 @@ struct SavedFrame::Lookup {
                                  "SavedFrame::Lookup::asyncCause");
     }
     if (parent) {
       TraceManuallyBarrieredEdge(trc, &parent, "SavedFrame::Lookup::parent");
     }
   }
 };
 
-using GCLookupVector = GCVector<SavedFrame::Lookup, ASYNC_STACK_MAX_FRAME_COUNT>;
+using GCLookupVector =
+    GCVector<SavedFrame::Lookup, ASYNC_STACK_MAX_FRAME_COUNT>;
 
 template <class Wrapper>
 class WrappedPtrOperations<SavedFrame::Lookup, Wrapper> {
   const SavedFrame::Lookup& value() const {
     return static_cast<const Wrapper*>(this)->get();
   }
 
  public:
@@ -262,28 +263,22 @@ class WrappedPtrOperations<SavedFrame::L
   Maybe<LiveSavedFrameCache::FramePtr> framePtr() { return value().framePtr; }
   jsbytecode* pc() { return value().pc; }
   Activation* activation() { return value().activation; }
 };
 
 template <typename Wrapper>
 class MutableWrappedPtrOperations<SavedFrame::Lookup, Wrapper>
     : public WrappedPtrOperations<SavedFrame::Lookup, Wrapper> {
-  SavedFrame::Lookup& value() {
-    return static_cast<Wrapper*>(this)->get();
-  }
+  SavedFrame::Lookup& value() { return static_cast<Wrapper*>(this)->get(); }
 
  public:
-  void setParent(SavedFrame* parent) {
-    value().parent = parent;
-  }
+  void setParent(SavedFrame* parent) { value().parent = parent; }
 
-  void setAsyncCause(HandleAtom asyncCause) {
-    value().asyncCause = asyncCause;
-  }
+  void setAsyncCause(HandleAtom asyncCause) { value().asyncCause = asyncCause; }
 };
 
 /* static */
 bool SavedFrame::HashPolicy::hasHash(const Lookup& l) {
   return SavedFramePtrHasher::hasHash(l.parent);
 }
 
 /* static */
@@ -507,18 +502,17 @@ void SavedFrame::initAsyncCause(JSAtom* 
   initReservedSlot(JSSLOT_ASYNCCAUSE,
                    maybeCause ? StringValue(maybeCause) : NullValue());
 }
 
 void SavedFrame::initParent(SavedFrame* maybeParent) {
   initReservedSlot(JSSLOT_PARENT, ObjectOrNullValue(maybeParent));
 }
 
-void SavedFrame::initFromLookup(JSContext* cx,
-                                Handle<Lookup> lookup) {
+void SavedFrame::initFromLookup(JSContext* cx, Handle<Lookup> lookup) {
   // Make sure any atoms used in the lookup are marked in the current zone.
   // Normally we would try to keep these mark bits up to date around the
   // points where the context moves between compartments, but Lookups live on
   // the stack (where the atoms are kept alive regardless) and this is a
   // more convenient pinchpoint.
   if (lookup.source()) {
     cx->markAtom(lookup.source());
   }
@@ -1411,22 +1405,21 @@ bool SavedStacks::insertFrames(JSContext
       }
     }
 
     RootedAtom displayAtom(cx, iter.maybeFunctionDisplayAtom());
 
     auto principals = iter.realm()->principals();
     MOZ_ASSERT_IF(framePtr && !iter.isWasm(), iter.pc());
 
-    if (!stackChain.emplaceBack(
-            location.source(), location.sourceId(),
-            location.line(), location.column(), displayAtom,
-            nullptr,  // asyncCause
-            nullptr,  // parent (not known yet)
-            principals, framePtr, iter.pc(), &activation)) {
+    if (!stackChain.emplaceBack(location.source(), location.sourceId(),
+                                location.line(), location.column(), displayAtom,
+                                nullptr,  // asyncCause
+                                nullptr,  // parent (not known yet)
+                                principals, framePtr, iter.pc(), &activation)) {
       ReportOutOfMemory(cx);
       return false;
     }
 
     if (captureIsSatisfied(cx, principals, location.source(), capture)) {
       // The stack should end after the frame we just saved.
       parent.set(nullptr);
       break;
@@ -1507,17 +1500,18 @@ bool SavedStacks::insertFrames(JSContext
 
     frame.set(getOrCreateSavedFrame(cx, lookup));
     if (!frame) {
       return false;
     }
 
     if (capture.is<JS::AllFrames>() && lookup.framePtr()) {
       auto* cache = lookup.activation()->getLiveSavedFrameCache(cx);
-      if (!cache || !cache->insert(cx, *lookup.framePtr(), lookup.pc(), frame)) {
+      if (!cache ||
+          !cache->insert(cx, *lookup.framePtr(), lookup.pc(), frame)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
@@ -1592,18 +1586,18 @@ bool SavedStacks::adoptAsyncStack(JSCont
 // Debugger eval frames run code in the scope of some random older frame on the
 // stack (the 'target' frame). It is our custom to report the target as the
 // immediate parent of the eval frame. The LiveSavedFrameCache requires us not
 // to skip frames, so instead we walk the entire stack, and just give Debugger
 // eval frames the right parents as we encounter them.
 //
 // Call this function only if we are using the LiveSavedFrameCache; otherwise,
 // FrameIter has already taken care of getting us the right parent.
-bool SavedStacks::checkForEvalInFramePrev(JSContext* cx,
-                                          MutableHandle<SavedFrame::Lookup> lookup) {
+bool SavedStacks::checkForEvalInFramePrev(
+    JSContext* cx, MutableHandle<SavedFrame::Lookup> lookup) {
   MOZ_ASSERT(lookup.framePtr());
   if (!lookup.framePtr()->isInterpreterFrame()) {
     return true;
   }
 
   InterpreterFrame& interpreterFrame = lookup.framePtr()->asInterpreterFrame();
   if (!interpreterFrame.isDebuggerEvalFrame()) {
     return true;
@@ -1912,20 +1906,20 @@ JS_PUBLIC_API bool ConstructSavedFrameSt
         return false;
       }
     }
 
     auto principals =
         js::ReconstructedSavedFramePrincipals::getSingleton(ubiFrame.get());
 
     if (!stackChain.emplaceBack(source, ubiFrame.get().sourceId(),
-                                 ubiFrame.get().line(),
-                                 ubiFrame.get().column(), functionDisplayName,
-                                 /* asyncCause */ nullptr,
-                                 /* parent */ nullptr, principals)) {
+                                ubiFrame.get().line(), ubiFrame.get().column(),
+                                functionDisplayName,
+                                /* asyncCause */ nullptr,
+                                /* parent */ nullptr, principals)) {
       ReportOutOfMemory(cx);
       return false;
     }
 
     ubiFrame = ubiFrame.get().parent();
   }
 
   js::RootedSavedFrame parentFrame(cx);
--- a/js/src/vm/SavedStacks.h
+++ b/js/src/vm/SavedStacks.h
@@ -216,18 +216,18 @@ class SavedStacks {
     ~AutoReentrancyGuard() { stacks.creatingSavedFrame = false; }
   };
 
   MOZ_MUST_USE bool insertFrames(JSContext* cx, MutableHandleSavedFrame frame,
                                  JS::StackCapture&& capture);
   MOZ_MUST_USE bool adoptAsyncStack(
       JSContext* cx, MutableHandleSavedFrame asyncStack, HandleAtom asyncCause,
       const mozilla::Maybe<size_t>& maxFrameCount);
-  MOZ_MUST_USE bool checkForEvalInFramePrev(JSContext* cx,
-                                            MutableHandle<SavedFrame::Lookup> lookup);
+  MOZ_MUST_USE bool checkForEvalInFramePrev(
+      JSContext* cx, MutableHandle<SavedFrame::Lookup> lookup);
   SavedFrame* getOrCreateSavedFrame(JSContext* cx,
                                     Handle<SavedFrame::Lookup> lookup);
   SavedFrame* createFrameFromLookup(JSContext* cx,
                                     Handle<SavedFrame::Lookup> lookup);
 
   // Cache for memoizing PCToLineNumber lookups.
 
   struct PCKey {
@@ -239,17 +239,18 @@ class SavedStacks {
     void trace(JSTracer* trc) { /* PCKey is weak. */
     }
     bool needsSweep() { return IsAboutToBeFinalized(&script); }
   };
 
  public:
   struct LocationValue {
     LocationValue() : source(nullptr), sourceId(0), line(0), column(0) {}
-    LocationValue(JSAtom* source, uint32_t sourceId, size_t line, uint32_t column)
+    LocationValue(JSAtom* source, uint32_t sourceId, size_t line,
+                  uint32_t column)
         : source(source), sourceId(sourceId), line(line), column(column) {}
 
     void trace(JSTracer* trc) {
       TraceNullableEdge(trc, &source, "SavedStacks::LocationValue::source");
     }
 
     bool needsSweep() {
       // LocationValue is always held strongly, but in a weak map.
--- a/js/src/vm/Scope.cpp
+++ b/js/src/vm/Scope.cpp
@@ -1582,17 +1582,17 @@ PositionalFormalParameterIter::Positiona
   // Reinit with flags = 0, i.e., iterate over all positional parameters.
   if (scope->is<FunctionScope>()) {
     init(scope->as<FunctionScope>().data(), /* flags = */ 0);
   }
   settle();
 }
 
 PositionalFormalParameterIter::PositionalFormalParameterIter(JSScript* script)
-    : PositionalFormalParameterIter(script->bodyScope()) { }
+    : PositionalFormalParameterIter(script->bodyScope()) {}
 
 void js::DumpBindings(JSContext* cx, Scope* scopeArg) {
   RootedScope scope(cx, scopeArg);
   for (Rooted<BindingIter> bi(cx, BindingIter(scope)); bi; bi++) {
     UniqueChars bytes = AtomToPrintableString(cx, bi.name());
     if (!bytes) {
       return;
     }
--- a/js/src/vm/Shape-inl.h
+++ b/js/src/vm/Shape-inl.h
@@ -221,22 +221,19 @@ template <class ObjectSubclass>
 
   // Cache the initial shape for non-prototype objects, however, so that
   // future instances will begin life with that shape.
   RootedObject proto(cx, obj->staticPrototype());
   EmptyShape::insertInitialShape(cx, shape, proto);
   return true;
 }
 
-inline AutoRooterGetterSetter::Inner::Inner(uint8_t attrs,
-                                            GetterOp* pgetter_,
+inline AutoRooterGetterSetter::Inner::Inner(uint8_t attrs, GetterOp* pgetter_,
                                             SetterOp* psetter_)
-    : attrs(attrs),
-      pgetter(pgetter_),
-      psetter(psetter_) {}
+    : attrs(attrs), pgetter(pgetter_), psetter(psetter_) {}
 
 inline AutoRooterGetterSetter::AutoRooterGetterSetter(
     JSContext* cx, uint8_t attrs, GetterOp* pgetter,
     SetterOp* psetter MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL) {
   if (attrs & (JSPROP_GETTER | JSPROP_SETTER)) {
     inner.emplace(cx, Inner(attrs, pgetter, psetter));
   }
   MOZ_GUARD_OBJECT_NOTIFIER_INIT;
--- a/js/src/vm/Shape.h
+++ b/js/src/vm/Shape.h
@@ -1450,17 +1450,17 @@ class MOZ_RAII AutoRooterGetterSetter {
     uint8_t attrs;
     GetterOp* pgetter;
     SetterOp* psetter;
   };
 
  public:
   inline AutoRooterGetterSetter(JSContext* cx, uint8_t attrs, GetterOp* pgetter,
                                 SetterOp* psetter
-                                MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
+                                    MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
 
  private:
   mozilla::Maybe<Rooted<Inner>> inner;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 struct EmptyShape : public js::Shape {
   EmptyShape(UnownedBaseShape* base, uint32_t nfixed)
--- a/js/src/vm/StringType-inl.h
+++ b/js/src/vm/StringType-inl.h
@@ -311,26 +311,28 @@ inline js::PropertyName* JSFlatString::t
 }
 
 template <js::AllowGC allowGC>
 MOZ_ALWAYS_INLINE JSThinInlineString* JSThinInlineString::new_(JSContext* cx) {
   if (cx->zone()->isAtomsZone()) {
     return (JSThinInlineString*)(js::Allocate<js::NormalAtom, allowGC>(cx));
   }
 
-  return js::AllocateString<JSThinInlineString, allowGC>(cx, js::gc::DefaultHeap);
+  return js::AllocateString<JSThinInlineString, allowGC>(cx,
+                                                         js::gc::DefaultHeap);
 }
 
 template <js::AllowGC allowGC>
 MOZ_ALWAYS_INLINE JSFatInlineString* JSFatInlineString::new_(JSContext* cx) {
   if (cx->zone()->isAtomsZone()) {
     return (JSFatInlineString*)(js::Allocate<js::FatInlineAtom, allowGC>(cx));
   }
 
-  return js::AllocateString<JSFatInlineString, allowGC>(cx, js::gc::DefaultHeap);
+  return js::AllocateString<JSFatInlineString, allowGC>(cx,
+                                                        js::gc::DefaultHeap);
 }
 
 template <>
 MOZ_ALWAYS_INLINE JS::Latin1Char* JSThinInlineString::init<JS::Latin1Char>(
     size_t length) {
   MOZ_ASSERT(lengthFits<JS::Latin1Char>(length));
   setLengthAndFlags(length, INIT_THIN_INLINE_FLAGS | LATIN1_CHARS_BIT);
   return d.inlineStorageLatin1;
--- a/js/src/vm/StringType.cpp
+++ b/js/src/vm/StringType.cpp
@@ -13,17 +13,17 @@
 #include "mozilla/MathAlgorithms.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/PodOperations.h"
 #include "mozilla/RangedPtr.h"
 #include "mozilla/TextUtils.h"
 #include "mozilla/TypeTraits.h"
 #include "mozilla/Unused.h"
 
-#include <algorithm>  // std::{all_of,copy_n,enable_if,is_const,move}
+#include <algorithm>    // std::{all_of,copy_n,enable_if,is_const,move}
 #include <type_traits>  // std::is_unsigned
 
 #include "jsfriendapi.h"
 
 #include "frontend/BytecodeCompiler.h"
 #include "gc/GCInternals.h"
 #include "gc/Marking.h"
 #include "gc/Nursery.h"
@@ -806,17 +806,17 @@ template JSString* js::ConcatStrings<NoG
 template <typename Dest, typename Source>
 static void FillAndTerminate(Dest* dest, Source src, size_t length) {
   static_assert(sizeof(src[length]) <= sizeof(dest[length]),
                 "source → destination conversion must not narrow");
 
   for (size_t i = 0; i < length; i++) {
     auto srcChar = src[i];
     static_assert(std::is_unsigned<decltype(srcChar)>::value &&
-                  std::is_unsigned<Dest>::value,
+                      std::is_unsigned<Dest>::value,
                   "source/destination characters are unsigned for simplicity");
     *dest++ = srcChar;
   }
 
   *dest = '\0';
 }
 
 template <typename Dest, typename Src,
@@ -834,17 +834,17 @@ template <typename Dest, typename Source
 static void FillFromCompatibleAndTerminate(Dest* dest, Source src,
                                            size_t length) {
   static_assert(sizeof(src[length]) > sizeof(dest[length]),
                 "source → destination conversion must be narrowing");
 
   for (size_t i = 0; i < length; i++) {
     auto srcChar = src[i];
     static_assert(std::is_unsigned<decltype(srcChar)>::value &&
-                  std::is_unsigned<Dest>::value,
+                      std::is_unsigned<Dest>::value,
                   "source/destination characters are unsigned for simplicity");
     *dest++ = AssertedCast<Dest>(src[i]);
   }
 
   *dest = '\0';
 }
 
 template <typename Dest, typename Src,
--- a/js/src/vm/TypeSet.h
+++ b/js/src/vm/TypeSet.h
@@ -84,17 +84,18 @@ enum : uint32_t {
   TYPE_FLAG_STRING = 0x20,
   TYPE_FLAG_SYMBOL = 0x40,
   TYPE_FLAG_BIGINT = 0x80,
   TYPE_FLAG_LAZYARGS = 0x100,
   TYPE_FLAG_ANYOBJECT = 0x200,
 
   /* Mask containing all "immediate" primitives (not heap-allocated) */
   TYPE_FLAG_PRIMITIVE_IMMEDIATE = TYPE_FLAG_UNDEFINED | TYPE_FLAG_NULL |
-      TYPE_FLAG_BOOLEAN | TYPE_FLAG_INT32 | TYPE_FLAG_DOUBLE,
+                                  TYPE_FLAG_BOOLEAN | TYPE_FLAG_INT32 |
+                                  TYPE_FLAG_DOUBLE,
   /* Mask containing all GCThing primitives (heap-allocated) */
   TYPE_FLAG_PRIMITIVE_GCTHING =
       TYPE_FLAG_STRING | TYPE_FLAG_SYMBOL | TYPE_FLAG_BIGINT,
 
   /* Mask containing all primitives */
   TYPE_FLAG_PRIMITIVE =
       TYPE_FLAG_PRIMITIVE_IMMEDIATE | TYPE_FLAG_PRIMITIVE_GCTHING,
 
--- a/js/src/wasm/WasmAST.h
+++ b/js/src/wasm/WasmAST.h
@@ -1237,17 +1237,17 @@ class AstDataSegment : public AstNode {
       : offsetIfActive_(offsetIfActive), fragments_(std::move(fragments)) {}
 
   AstExpr* offsetIfActive() const { return offsetIfActive_; }
   const AstNameVector& fragments() const { return fragments_; }
 };
 
 typedef AstVector<AstDataSegment*> AstDataSegmentVector;
 
-struct AstNullValue { };
+struct AstNullValue {};
 typedef Variant<AstRef, AstNullValue> AstElem;
 typedef AstVector<AstElem> AstElemVector;
 
 class AstElemSegment : public AstNode {
   AstRef targetTable_;
   AstExpr* offsetIfActive_;
   AstElemVector elems_;
 
--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -10479,17 +10479,18 @@ bool BaseCompiler::emitStructNew() {
         RegPtr rowner = rp;
         if (!structType.isInline_) {
           rowner = needRef();
           masm.loadPtr(Address(rp, OutlineTypedObject::offsetOfOwner()),
                        rowner);
         }
 
         RegPtr otherScratch = needRef();
-        EmitWasmPostBarrierGuard(masm, Some(rowner), otherScratch, value, &skipBarrier);
+        EmitWasmPostBarrierGuard(masm, Some(rowner), otherScratch, value,
+                                 &skipBarrier);
         freeRef(otherScratch);
 
         if (!structType.isInline_) {
           freeRef(rowner);
         }
 
         freeRef(value);
 
--- a/js/src/wasm/WasmBuiltins.cpp
+++ b/js/src/wasm/WasmBuiltins.cpp
@@ -43,147 +43,113 @@ using mozilla::MakeEnumeratedRange;
 
 static const unsigned BUILTIN_THUNK_LIFO_SIZE = 64 * 1024;
 
 // ============================================================================
 // WebAssembly builtin C++ functions called from wasm code to implement internal
 // wasm operations: type descriptions.
 
 // Some abbreviations, for the sake of conciseness.
-#define _F64  MIRType::Double
-#define _F32  MIRType::Float32
-#define _I32  MIRType::Int32
-#define _I64  MIRType::Int64
-#define _PTR  MIRType::Pointer
-#define _RoN  MIRType::RefOrNull
+#define _F64 MIRType::Double
+#define _F32 MIRType::Float32
+#define _I32 MIRType::Int32
+#define _I64 MIRType::Int64
+#define _PTR MIRType::Pointer
+#define _RoN MIRType::RefOrNull
 #define _VOID MIRType::None
-#define _END  MIRType::None
+#define _END MIRType::None
 
 namespace js {
 namespace wasm {
 
 const SymbolicAddressSignature SASigSinD = {
-  SymbolicAddress::SinD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::SinD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigCosD = {
-  SymbolicAddress::CosD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::CosD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigTanD = {
-  SymbolicAddress::TanD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::TanD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigASinD = {
-  SymbolicAddress::ASinD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::ASinD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigACosD = {
-  SymbolicAddress::ACosD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::ACosD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigATanD = {
-  SymbolicAddress::ATanD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::ATanD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigCeilD = {
-  SymbolicAddress::CeilD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::CeilD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigCeilF = {
-  SymbolicAddress::CeilF, _F32, 1, { _F32, _END }
-};
+    SymbolicAddress::CeilF, _F32, 1, {_F32, _END}};
 const SymbolicAddressSignature SASigFloorD = {
-  SymbolicAddress::FloorD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::FloorD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigFloorF = {
-  SymbolicAddress::FloorF, _F32, 1, { _F32, _END }
-};
+    SymbolicAddress::FloorF, _F32, 1, {_F32, _END}};
 const SymbolicAddressSignature SASigTruncD = {
-  SymbolicAddress::TruncD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::TruncD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigTruncF = {
-  SymbolicAddress::TruncF, _F32, 1, { _F32, _END }
-};
+    SymbolicAddress::TruncF, _F32, 1, {_F32, _END}};
 const SymbolicAddressSignature SASigNearbyIntD = {
-  SymbolicAddress::NearbyIntD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::NearbyIntD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigNearbyIntF = {
-  SymbolicAddress::NearbyIntF, _F32, 1, { _F32, _END }
-};
+    SymbolicAddress::NearbyIntF, _F32, 1, {_F32, _END}};
 const SymbolicAddressSignature SASigExpD = {
-  SymbolicAddress::ExpD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::ExpD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigLogD = {
-  SymbolicAddress::LogD, _F64, 1, { _F64, _END }
-};
+    SymbolicAddress::LogD, _F64, 1, {_F64, _END}};
 const SymbolicAddressSignature SASigPowD = {
-  SymbolicAddress::PowD, _F64, 2, { _F64, _F64, _END }
-};
+    SymbolicAddress::PowD, _F64, 2, {_F64, _F64, _END}};
 const SymbolicAddressSignature SASigATan2D = {
-  SymbolicAddress::ATan2D, _F64, 2, { _F64, _F64, _END }
-};
+    SymbolicAddress::ATan2D, _F64, 2, {_F64, _F64, _END}};
 const SymbolicAddressSignature SASigMemoryGrow = {
-  SymbolicAddress::MemoryGrow, _I32, 2, { _PTR, _I32, _END }
-};
+    SymbolicAddress::MemoryGrow, _I32, 2, {_PTR, _I32, _END}};
 const SymbolicAddressSignature SASigMemorySize = {
-  SymbolicAddress::MemorySize, _I32, 1, { _PTR, _END }
-};
+    SymbolicAddress::MemorySize, _I32, 1, {_PTR, _END}};
 const SymbolicAddressSignature SASigWaitI32 = {
-  SymbolicAddress::WaitI32, _I32, 4, { _PTR, _I32, _I32, _I64, _END }
-};
+    SymbolicAddress::WaitI32, _I32, 4, {_PTR, _I32, _I32, _I64, _END}};
 const SymbolicAddressSignature SASigWaitI64 = {
-  SymbolicAddress::WaitI64, _I32, 4, { _PTR, _I32, _I64, _I64, _END }
-};
+    SymbolicAddress::WaitI64, _I32, 4, {_PTR, _I32, _I64, _I64, _END}};
 const SymbolicAddressSignature SASigWake = {
-  SymbolicAddress::Wake, _I32, 3, { _PTR, _I32, _I32, _END }
-};
+    SymbolicAddress::Wake, _I32, 3, {_PTR, _I32, _I32, _END}};
 const SymbolicAddressSignature SASigMemCopy = {
-  SymbolicAddress::MemCopy, _I32, 4, { _PTR, _I32, _I32, _I32, _END }
-};
+    SymbolicAddress::MemCopy, _I32, 4, {_PTR, _I32, _I32, _I32, _END}};
 const SymbolicAddressSignature SASigDataDrop = {
-  SymbolicAddress::DataDrop, _I32, 2, { _PTR, _I32, _END }
-};
+    SymbolicAddress::DataDrop, _I32, 2, {_PTR, _I32, _END}};
 const SymbolicAddressSignature SASigMemFill = {
-  SymbolicAddress::MemFill, _I32, 4, { _PTR, _I32, _I32, _I32, _END }
-};
+    SymbolicAddress::MemFill, _I32, 4, {_PTR, _I32, _I32, _I32, _END}};
 const SymbolicAddressSignature SASigMemInit = {
-  SymbolicAddress::MemInit, _I32, 5, { _PTR, _I32, _I32, _I32, _I32, _END }
-};
+    SymbolicAddress::MemInit, _I32, 5, {_PTR, _I32, _I32, _I32, _I32, _END}};
 const SymbolicAddressSignature SASigTableCopy = {
-  SymbolicAddress::TableCopy,
-  _I32, 6, { _PTR, _I32, _I32, _I32, _I32, _I32, _END }
-};
+    SymbolicAddress::TableCopy,
+    _I32,
+    6,
+    {_PTR, _I32, _I32, _I32, _I32, _I32, _END}};
 const SymbolicAddressSignature SASigElemDrop = {
-  SymbolicAddress::ElemDrop, _I32, 2, { _PTR, _I32, _END }
-};
+    SymbolicAddress::ElemDrop, _I32, 2, {_PTR, _I32, _END}};
 const SymbolicAddressSignature SASigTableGet = {
-  SymbolicAddress::TableGet, _PTR, 3, { _PTR, _I32, _I32, _END }
-};
+    SymbolicAddress::TableGet, _PTR, 3, {_PTR, _I32, _I32, _END}};
 const SymbolicAddressSignature SASigTableGrow = {
-  SymbolicAddress::TableGrow, _I32, 4, { _PTR, _I32, _RoN, _I32, _END }
-};
+    SymbolicAddress::TableGrow, _I32, 4, {_PTR, _I32, _RoN, _I32, _END}};
 const SymbolicAddressSignature SASigTableInit = {
-  SymbolicAddress::TableInit,
-  _I32, 6, { _PTR, _I32, _I32, _I32, _I32, _I32, _END }
-};
+    SymbolicAddress::TableInit,
+    _I32,
+    6,
+    {_PTR, _I32, _I32, _I32, _I32, _I32, _END}};
 const SymbolicAddressSignature SASigTableSet = {
-  SymbolicAddress::TableSet, _I32, 4, { _PTR, _I32, _RoN, _I32, _END }
-};
+    SymbolicAddress::TableSet, _I32, 4, {_PTR, _I32, _RoN, _I32, _END}};
 const SymbolicAddressSignature SASigTableSize = {
-  SymbolicAddress::TableSize, _I32, 2, { _PTR, _I32, _END }
-};
+    SymbolicAddress::TableSize, _I32, 2, {_PTR, _I32, _END}};
 const SymbolicAddressSignature SASigPostBarrier = {
-  SymbolicAddress::PostBarrier, _VOID, 2, { _PTR, _PTR, _END }
-};
+    SymbolicAddress::PostBarrier, _VOID, 2, {_PTR, _PTR, _END}};
 const SymbolicAddressSignature SASigPostBarrierFiltering = {
-  SymbolicAddress::PostBarrierFiltering, _VOID, 2, { _PTR, _PTR, _END }
-};
+    SymbolicAddress::PostBarrierFiltering, _VOID, 2, {_PTR, _PTR, _END}};
 const SymbolicAddressSignature SASigStructNew = {
-  SymbolicAddress::StructNew, _RoN, 2, { _PTR, _I32, _END }
-};
+    SymbolicAddress::StructNew, _RoN, 2, {_PTR, _I32, _END}};
 const SymbolicAddressSignature SASigStructNarrow = {
-  SymbolicAddress::StructNarrow, _RoN, 4, { _PTR, _I32, _I32, _RoN, _END }
-};
+    SymbolicAddress::StructNarrow, _RoN, 4, {_PTR, _I32, _I32, _RoN, _END}};
 
-} // namespace wasm
-} // namespace js
+}  // namespace wasm
+}  // namespace js
 
 #undef _F64
 #undef _F32
 #undef _I32
 #undef _I64
 #undef _PTR
 #undef _RoN
 #undef _VOID
--- a/js/src/wasm/WasmConstants.h
+++ b/js/src/wasm/WasmConstants.h
@@ -165,18 +165,18 @@ enum class Op {
   Select = 0x1b,
 
   // Variable access
   GetLocal = 0x20,
   SetLocal = 0x21,
   TeeLocal = 0x22,
   GetGlobal = 0x23,
   SetGlobal = 0x24,
-  TableGet = 0x25,              // Reftypes,
-  TableSet = 0x26,              //   per proposal as of February 2019
+  TableGet = 0x25,  // Reftypes,
+  TableSet = 0x26,  //   per proposal as of February 2019
 
   // Memory-related operators
   I32Load = 0x28,
   I64Load = 0x29,
   F32Load = 0x2a,
   F64Load = 0x2b,
   I32Load8S = 0x2c,
   I32Load8U = 0x2d,
--- a/js/src/wasm/WasmCraneliftCompile.cpp
+++ b/js/src/wasm/WasmCraneliftCompile.cpp
@@ -121,17 +121,18 @@ static bool GenerateCraneliftCode(WasmMa
     // Check bytecode offsets.
     if (metadata.srcLoc > 0 && lineOrBytecode > 0) {
       MOZ_ASSERT(metadata.srcLoc >= lineOrBytecode);
       MOZ_ASSERT(metadata.srcLoc < lineOrBytecode + funcBytecodeSize);
     }
 #endif
     // TODO(bug 1532716): Cranelift gives null bytecode offsets for symbolic
     // accesses.
-    uint32_t bytecodeOffset = metadata.srcLoc ? metadata.srcLoc : lineOrBytecode;
+    uint32_t bytecodeOffset =
+        metadata.srcLoc ? metadata.srcLoc : lineOrBytecode;
 
     switch (metadata.which) {
       case CraneliftMetadataEntry::Which::DirectCall: {
         CallSiteDesc desc(bytecodeOffset, CallSiteDesc::Func);
         masm.append(desc, CodeOffset(offset.value()), metadata.extra);
         break;
       }
       case CraneliftMetadataEntry::Which::IndirectCall: {
@@ -188,18 +189,17 @@ class AutoCranelift {
   operator CraneliftCompiler*() { return compiler_; }
 };
 
 CraneliftFuncCompileInput::CraneliftFuncCompileInput(
     const FuncCompileInput& func)
     : bytecode(func.begin),
       bytecodeSize(func.end - func.begin),
       index(func.index),
-      offset_in_module(func.lineOrBytecode)
-    {}
+      offset_in_module(func.lineOrBytecode) {}
 
 #ifndef WASM_HUGE_MEMORY
 static_assert(offsetof(TlsData, boundsCheckLimit) == sizeof(size_t),
               "fix make_heap() in wasm2clif.rs");
 #endif
 
 CraneliftStaticEnvironment::CraneliftStaticEnvironment()
     :
@@ -253,32 +253,31 @@ CraneliftStaticEnvironment::CraneliftSta
 // This function translates between the two.
 
 static size_t globalToTlsOffset(size_t globalOffset) {
   return offsetof(wasm::TlsData, globalArea) + globalOffset;
 }
 
 CraneliftModuleEnvironment::CraneliftModuleEnvironment(
     const ModuleEnvironment& env)
-    : env(&env),
-      min_memory_length(env.minMemoryLength)
-{}
+    : env(&env), min_memory_length(env.minMemoryLength) {}
 
 TypeCode env_unpack(BD_ValType valType) {
   return TypeCode(UnpackTypeCodeType(PackedTypeCode(valType.packed)));
 }
 
 const FuncTypeWithId* env_function_signature(
     const CraneliftModuleEnvironment* wrapper, size_t funcIndex) {
   return wrapper->env->funcTypes[funcIndex];
 }
 
 size_t env_func_import_tls_offset(const CraneliftModuleEnvironment* wrapper,
                                   size_t funcIndex) {
-  return globalToTlsOffset(wrapper->env->funcImportGlobalDataOffsets[funcIndex]);
+  return globalToTlsOffset(
+      wrapper->env->funcImportGlobalDataOffsets[funcIndex]);
 }
 
 bool env_func_is_import(const CraneliftModuleEnvironment* wrapper,
                         size_t funcIndex) {
   return wrapper->env->funcIsImport(funcIndex);
 }
 
 const FuncTypeWithId* env_signature(const CraneliftModuleEnvironment* wrapper,
--- a/js/src/wasm/WasmGC.cpp
+++ b/js/src/wasm/WasmGC.cpp
@@ -18,19 +18,20 @@
 
 #include "wasm/WasmGC.h"
 #include "wasm/WasmInstance.h"
 #include "jit/MacroAssembler-inl.h"
 
 namespace js {
 namespace wasm {
 
-bool GenerateStackmapEntriesForTrapExit(
-    const ValTypeVector& args, const MachineState& trapExitLayout,
-    const size_t trapExitLayoutNumWords,  ExitStubMapVector* extras) {
+bool GenerateStackmapEntriesForTrapExit(const ValTypeVector& args,
+                                        const MachineState& trapExitLayout,
+                                        const size_t trapExitLayoutNumWords,
+                                        ExitStubMapVector* extras) {
   MOZ_ASSERT(extras->empty());
 
   // If this doesn't hold, we can't distinguish saved and not-saved
   // registers in the MachineState.  See MachineState::MachineState().
   MOZ_ASSERT(trapExitLayoutNumWords < 0x100);
 
   if (!extras->appendN(false, trapExitLayoutNumWords)) {
     return false;
@@ -38,17 +39,17 @@ bool GenerateStackmapEntriesForTrapExit(
 
   for (ABIArgIter<const ValTypeVector> i(args); !i.done(); i++) {
     MOZ_ASSERT(i.mirType() != MIRType::Pointer);
     if (!i->argInRegister() || i.mirType() != MIRType::RefOrNull) {
       continue;
     }
 
     size_t offsetFromTop =
-       reinterpret_cast<size_t>(trapExitLayout.address(i->gpr()));
+        reinterpret_cast<size_t>(trapExitLayout.address(i->gpr()));
 
     // If this doesn't hold, the associated register wasn't saved by
     // the trap exit stub.  Better to crash now than much later, in
     // some obscure place, and possibly with security consequences.
     MOZ_RELEASE_ASSERT(offsetFromTop < trapExitLayoutNumWords);
 
     // offsetFromTop is an offset in words down from the highest
     // address in the exit stub save area.  Switch it around to be an
@@ -61,18 +62,18 @@ bool GenerateStackmapEntriesForTrapExit(
   return true;
 }
 
 void EmitWasmPreBarrierGuard(MacroAssembler& masm, Register tls,
                              Register scratch, Register valueAddr,
                              Label* skipBarrier) {
   // If no incremental GC has started, we don't need the barrier.
   masm.loadPtr(
-    Address(tls, offsetof(TlsData, addressOfNeedsIncrementalBarrier)),
-    scratch);
+      Address(tls, offsetof(TlsData, addressOfNeedsIncrementalBarrier)),
+      scratch);
   masm.branchTest32(Assembler::Zero, Address(scratch, 0), Imm32(0x1),
                     skipBarrier);
 
   // If the previous value is null, we don't need the barrier.
   masm.loadPtr(Address(valueAddr, 0), scratch);
   masm.branchTestPtr(Assembler::Zero, scratch, scratch, skipBarrier);
 }
 
@@ -88,17 +89,18 @@ void EmitWasmPreBarrierCall(MacroAssembl
   masm.Cmp(sp, vixl::Operand(x28));
   masm.B(&ok, Assembler::Equal);
   masm.breakpoint();
   masm.bind(&ok);
 #endif
   masm.call(scratch);
 }
 
-void EmitWasmPostBarrierGuard(MacroAssembler& masm, const Maybe<Register>& object,
+void EmitWasmPostBarrierGuard(MacroAssembler& masm,
+                              const Maybe<Register>& object,
                               Register otherScratch, Register setValue,
                               Label* skipBarrier) {
   // If the pointer being stored is null, no barrier.
   masm.branchTestPtr(Assembler::Zero, setValue, setValue, skipBarrier);
 
   // If there is a containing object and it is in the nursery, no barrier.
   if (object) {
     masm.branchPtrInNurseryChunk(Assembler::Equal, *object, otherScratch,
--- a/js/src/wasm/WasmGC.h
+++ b/js/src/wasm/WasmGC.h
@@ -253,42 +253,43 @@ static inline size_t StackArgAreaSizeUna
   ABIArgIter<const T> i(argTypes);
   while (!i.done()) {
     i++;
   }
   return i.stackBytesConsumedSoFar();
 }
 
 static inline size_t StackArgAreaSizeUnaligned(
-                         const SymbolicAddressSignature& saSig) {
+    const SymbolicAddressSignature& saSig) {
   // ABIArgIter::ABIArgIter wants the items to be iterated over to be
   // presented in some type that has methods length() and operator[].  So we
   // have to wrap up |saSig|'s array of types in this API-matching class.
   class MOZ_STACK_CLASS ItemsAndLength {
     const MIRType* items_;
     size_t length_;
+
    public:
     ItemsAndLength(const MIRType* items, size_t length)
-      : items_(items), length_(length)
-    {}
+        : items_(items), length_(length) {}
     size_t length() const { return length_; }
     MIRType operator[](size_t i) const { return items_[i]; }
   };
 
   // Assert, at least crudely, that we're not accidentally going to run off
   // the end of the array of types, nor into undefined parts of it, while
   // iterating.
-  MOZ_ASSERT(saSig.numArgs < sizeof(saSig.argTypes) / sizeof(saSig.argTypes[0]));
-  MOZ_ASSERT(saSig.argTypes[saSig.numArgs] == MIRType::None/*the end marker*/);
+  MOZ_ASSERT(saSig.numArgs <
+             sizeof(saSig.argTypes) / sizeof(saSig.argTypes[0]));
+  MOZ_ASSERT(saSig.argTypes[saSig.numArgs] == MIRType::None /*the end marker*/);
 
   ItemsAndLength itemsAndLength(saSig.argTypes, saSig.numArgs);
 
   ABIArgIter<ItemsAndLength> i(itemsAndLength);
   while (!i.done()) {
-     i++;
+    i++;
   }
   return i.stackBytesConsumedSoFar();
 }
 
 static inline size_t AlignStackArgAreaSize(size_t unalignedSize) {
   return AlignBytes(unalignedSize, 16u);
 }
 
@@ -299,17 +300,17 @@ static inline size_t StackArgAreaSizeAli
 
 // At a resumable wasm trap, the machine's registers are saved on the stack by
 // (code generated by) GenerateTrapExit().  This function writes into |args| a
 // vector of booleans describing the ref-ness of the saved integer registers.
 // |args[0]| corresponds to the low addressed end of the described section of
 // the save area.
 MOZ_MUST_USE bool GenerateStackmapEntriesForTrapExit(
     const ValTypeVector& args, const MachineState& trapExitLayout,
-    const size_t trapExitLayoutNumWords,  ExitStubMapVector* extras);
+    const size_t trapExitLayoutNumWords, ExitStubMapVector* extras);
 
 // Shared write barrier code.
 //
 // A barriered store looks like this:
 //
 //   Label skipPreBarrier;
 //   EmitWasmPreBarrierGuard(..., &skipPreBarrier);
 //   <COMPILER-SPECIFIC ACTIONS HERE>
@@ -351,16 +352,17 @@ void EmitWasmPreBarrierCall(MacroAssembl
 // After storing a GC pointer value in memory, skip to `skipBarrier` if a
 // postbarrier is not needed.  If the location being set is in an heap-allocated
 // object then `object` must reference that object; otherwise it should be None.
 // The value that was stored is `setValue`.  Will clobber `otherScratch` and
 // will use other available scratch registers.
 //
 // `otherScratch` cannot be a designated scratch register.
 
-void EmitWasmPostBarrierGuard(MacroAssembler& masm, const Maybe<Register>& object,
+void EmitWasmPostBarrierGuard(MacroAssembler& masm,
+                              const Maybe<Register>& object,
                               Register otherScratch, Register setValue,
                               Label* skipBarrier);
 
 }  // namespace wasm
 }  // namespace js
 
 #endif  // wasm_gc_h
--- a/js/src/wasm/WasmInstance.cpp
+++ b/js/src/wasm/WasmInstance.cpp
@@ -761,29 +761,29 @@ void Instance::initElems(uint32_t tableI
         if (IsExportedWasmFunction(fun)) {
           // This element is a wasm function imported from another
           // instance. To preserve the === function identity required by
           // the JS embedding spec, we must set the element to the
           // imported function's underlying CodeRange.funcTableEntry and
           // Instance so that future Table.get()s produce the same
           // function object as was imported.
           WasmInstanceObject* calleeInstanceObj =
-            ExportedFunctionToInstanceObject(fun);
+              ExportedFunctionToInstanceObject(fun);
           Instance& calleeInstance = calleeInstanceObj->instance();
           Tier calleeTier = calleeInstance.code().bestTier();
           const CodeRange& calleeCodeRange =
-            calleeInstanceObj->getExportedFunctionCodeRange(fun, calleeTier);
+              calleeInstanceObj->getExportedFunctionCodeRange(fun, calleeTier);
           void* code = calleeInstance.codeBase(calleeTier) +
-            calleeCodeRange.funcTableEntry();
+                       calleeCodeRange.funcTableEntry();
           table.setAnyFunc(dstOffset + i, code, &calleeInstance);
           continue;
         }
       }
-      void* code =
-        codeBaseTier + codeRanges[funcToCodeRange[funcIndex]].funcTableEntry();
+      void* code = codeBaseTier +
+                   codeRanges[funcToCodeRange[funcIndex]].funcTableEntry();
       table.setAnyFunc(dstOffset + i, code, this);
     }
   }
 }
 
 /* static */ int32_t /* -1 to signal trap; 0 for ok */
 Instance::tableInit(Instance* instance, uint32_t dstOffset, uint32_t srcOffset,
                     uint32_t len, uint32_t segIndex, uint32_t tableIndex) {
--- a/js/src/wasm/WasmIonCompile.cpp
+++ b/js/src/wasm/WasmIonCompile.cpp
@@ -725,17 +725,17 @@ class FunctionCompiler {
     failBlock->end(
         MWasmTrap::New(alloc(), wasm::Trap::ThrowReported, bytecodeOffset()));
     curBlock_ = okBlock;
     return true;
   }
 
   MDefinition* derefTableElementPointer(MDefinition* base) {
     MWasmLoadRef* load =
-      MWasmLoadRef::New(alloc(), base, AliasSet::WasmTableElement);
+        MWasmLoadRef::New(alloc(), base, AliasSet::WasmTableElement);
     curBlock_->add(load);
     return load;
   }
 
   MDefinition* load(MDefinition* base, MemoryAccessDesc* access,
                     ValType result) {
     if (inDeadCode()) {
       return nullptr;
@@ -934,20 +934,19 @@ class FunctionCompiler {
         store = MWasmStoreRef::New(alloc(), tlsPointer_, valueAddr, v,
                                    AliasSet::WasmGlobalCell);
       } else {
         store = MWasmStoreGlobalCell::New(alloc(), v, cellPtr);
       }
     } else {
       // Store the value directly in TlsData::globalArea.
       if (v->type() == MIRType::RefOrNull) {
-        valueAddr =
-          MWasmDerivedPointer::New(alloc(), tlsPointer_,
-                                   offsetof(wasm::TlsData, globalArea) +
-                                   globalDataOffset);
+        valueAddr = MWasmDerivedPointer::New(
+            alloc(), tlsPointer_,
+            offsetof(wasm::TlsData, globalArea) + globalDataOffset);
         curBlock_->add(valueAddr);
         store = MWasmStoreRef::New(alloc(), tlsPointer_, valueAddr, v,
                                    AliasSet::WasmGlobalVar);
       } else {
         store =
             MWasmStoreGlobalVar::New(alloc(), globalDataOffset, v, tlsPointer_);
       }
     }
@@ -985,17 +984,18 @@ class FunctionCompiler {
 
     // Should only pass an instance once.
     MOZ_ASSERT(args->instanceArg_ == ABIArg());
     args->instanceArg_ = args->abi_.next(MIRType::Pointer);
     return true;
   }
 
   // Do not call this directly.  Call one of the passArg() variants instead.
-  bool passArgWorker(MDefinition* argDef, MIRType type, CallCompileState* call) {
+  bool passArgWorker(MDefinition* argDef, MIRType type,
+                     CallCompileState* call) {
     ABIArg arg = call->abi_.next(type);
     switch (arg.kind()) {
 #ifdef JS_CODEGEN_REGISTER_PAIR
       case ABIArg::GPR_PAIR: {
         auto mirLow =
             MWrapInt64ToInt32::New(alloc(), argDef, /* bottomHalf = */ true);
         curBlock_->add(mirLow);
         auto mirHigh =
@@ -1104,20 +1104,19 @@ class FunctionCompiler {
       callee = CalleeDesc::asmJSTable(table);
     } else {
       MOZ_ASSERT(funcType.id.kind() != FuncTypeIdDescKind::None);
       const TableDesc& table = env_.tables[tableIndex];
       callee = CalleeDesc::wasmTable(table, funcType.id);
     }
 
     CallSiteDesc desc(lineOrBytecode, CallSiteDesc::Dynamic);
-    auto* ins = MWasmCall::New(alloc(), desc, callee, call.regArgs_,
-                               ToMIRType(funcType.ret()),
-                               StackArgAreaSizeUnaligned(funcType.args()),
-                               index);
+    auto* ins = MWasmCall::New(
+        alloc(), desc, callee, call.regArgs_, ToMIRType(funcType.ret()),
+        StackArgAreaSizeUnaligned(funcType.args()), index);
     if (!ins) {
       return false;
     }
 
     curBlock_->add(ins);
     *def = ins;
     return true;
   }
@@ -2197,29 +2196,29 @@ static bool EmitSetGlobal(FunctionCompil
   MDefinition* value;
   if (!f.iter().readSetGlobal(&id, &value)) {
     return false;
   }
 
   const GlobalDesc& global = f.env().globals[id];
   MOZ_ASSERT(global.isMutable());
   MInstruction* barrierAddr =
-    f.storeGlobalVar(global.offset(), global.isIndirect(), value);
+      f.storeGlobalVar(global.offset(), global.isIndirect(), value);
 
   // We always call the C++ postbarrier because the location will never be in
   // the nursery, and the value stored will very frequently be in the nursery.
   // The C++ postbarrier performs any necessary filtering.
 
   if (barrierAddr) {
     CallCompileState args;
     if (!f.passInstance(&args)) {
       return false;
     }
     if (!f.passArg(barrierAddr, ValType::AnyRef, &args)) {
-        return false;
+      return false;
     }
     f.finishCall(&args);
     MDefinition* ret;
     if (!f.builtinInstanceMethodCall(SASigPostBarrierFiltering, lineOrBytecode,
                                      args, &ret)) {
       return false;
     }
   }
@@ -2957,17 +2956,18 @@ static bool EmitMemOrTableCopy(FunctionC
     if (!f.passArg(sti, ValType::I32, &args)) {
       return false;
     }
   }
   if (!f.finishCall(&args)) {
     return false;
   }
 
-  const SymbolicAddressSignature& callee = isMem ? SASigMemCopy : SASigTableCopy;
+  const SymbolicAddressSignature& callee =
+      isMem ? SASigMemCopy : SASigTableCopy;
   MDefinition* ret;
   if (!f.builtinInstanceMethodCall(callee, lineOrBytecode, args, &ret)) {
     return false;
   }
 
   if (!f.checkI32NegativeMeansFailedResult(ret)) {
     return false;
   }
@@ -3101,17 +3101,18 @@ static bool EmitMemOrTableInit(FunctionC
     if (!f.passArg(dti, ValType::I32, &args)) {
       return false;
     }
   }
   if (!f.finishCall(&args)) {
     return false;
   }
 
-  const SymbolicAddressSignature& callee = isMem ? SASigMemInit : SASigTableInit;
+  const SymbolicAddressSignature& callee =
+      isMem ? SASigMemInit : SASigTableInit;
   MDefinition* ret;
   if (!f.builtinInstanceMethodCall(callee, lineOrBytecode, args, &ret)) {
     return false;
   }
 
   if (!f.checkI32NegativeMeansFailedResult(ret)) {
     return false;
   }
@@ -3141,18 +3142,18 @@ static bool EmitTableGet(FunctionCompile
   if (!f.passInstance(&args)) {
     return false;
   }
 
   if (!f.passArg(index, ValType::I32, &args)) {
     return false;
   }
 
-  MDefinition* tableIndexArg = f.constant(Int32Value(tableIndex),
-                                          MIRType::Int32);
+  MDefinition* tableIndexArg =
+      f.constant(Int32Value(tableIndex), MIRType::Int32);
   if (!tableIndexArg) {
     return false;
   }
   if (!f.passArg(tableIndexArg, ValType::I32, &args)) {
     return false;
   }
 
   if (!f.finishCall(&args)) {
@@ -3201,18 +3202,18 @@ static bool EmitTableGrow(FunctionCompil
   if (!f.passArg(delta, ValType::I32, &args)) {
     return false;
   }
 
   if (!f.passArg(initValue, ValType::AnyRef, &args)) {
     return false;
   }
 
-  MDefinition* tableIndexArg = f.constant(Int32Value(tableIndex),
-                                          MIRType::Int32);
+  MDefinition* tableIndexArg =
+      f.constant(Int32Value(tableIndex), MIRType::Int32);
   if (!tableIndexArg) {
     return false;
   }
   if (!f.passArg(tableIndexArg, ValType::I32, &args)) {
     return false;
   }
 
   if (!f.finishCall(&args)) {
@@ -3251,18 +3252,18 @@ static bool EmitTableSet(FunctionCompile
   if (!f.passArg(index, ValType::I32, &args)) {
     return false;
   }
 
   if (!f.passArg(value, ValType::AnyRef, &args)) {
     return false;
   }
 
-  MDefinition* tableIndexArg = f.constant(Int32Value(tableIndex),
-                                          MIRType::Int32);
+  MDefinition* tableIndexArg =
+      f.constant(Int32Value(tableIndex), MIRType::Int32);
   if (!tableIndexArg) {
     return false;
   }
   if (!f.passArg(tableIndexArg, ValType::I32, &args)) {
     return false;
   }
 
   if (!f.finishCall(&args)) {
@@ -3347,18 +3348,18 @@ static bool EmitRefIsNull(FunctionCompil
   if (f.inDeadCode()) {
     return false;
   }
 
   MDefinition* nullVal = f.nullRefConstant();
   if (!nullVal) {
     return false;
   }
-  f.iter().setResult(f.compare(input, nullVal, JSOP_EQ,
-                               MCompare::Compare_RefOrNull));
+  f.iter().setResult(
+      f.compare(input, nullVal, JSOP_EQ, MCompare::Compare_RefOrNull));
   return true;
 }
 #endif
 
 static bool EmitBodyExprs(FunctionCompiler& f) {
   if (!f.iter().readFunctionStart(f.funcType().ret())) {
     return false;
   }
--- a/js/src/wasm/WasmJS.cpp
+++ b/js/src/wasm/WasmJS.cpp
@@ -2108,18 +2108,17 @@ bool WasmTableObject::construct(JSContex
 
   RootedLinearString elementLinearStr(cx, elementStr->ensureLinear(cx));
   if (!elementLinearStr) {
     return false;
   }
 
   TableKind tableKind;
   if (StringEqualsAscii(elementLinearStr, "anyfunc") ||
-      StringEqualsAscii(elementLinearStr, "funcref"))
-  {
+      StringEqualsAscii(elementLinearStr, "funcref")) {
     tableKind = TableKind::AnyFunction;
 #ifdef ENABLE_WASM_REFTYPES
   } else if (StringEqualsAscii(elementLinearStr, "anyref")) {
     if (!HasReftypesSupport(cx)) {
       JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
                                JSMSG_WASM_BAD_ELEMENT);
       return false;
     }
@@ -2235,34 +2234,32 @@ bool WasmTableObject::getImpl(JSContext*
 
 /* static */
 bool WasmTableObject::get(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<IsTable, getImpl>(cx, args);
 }
 
 static void TableFunctionFill(JSContext* cx, Table* table, HandleFunction value,
-                              uint32_t index, uint32_t limit)
-{
-  RootedWasmInstanceObject instanceObj(
-    cx, ExportedFunctionToInstanceObject(value));
+                              uint32_t index, uint32_t limit) {
+  RootedWasmInstanceObject instanceObj(cx,
+                                       ExportedFunctionToInstanceObject(value));
   uint32_t funcIndex = ExportedFunctionToFuncIndex(value);
 
 #ifdef DEBUG
   RootedFunction f(cx);
-  MOZ_ASSERT(
-    instanceObj->getExportedFunction(cx, instanceObj, funcIndex, &f));
+  MOZ_ASSERT(instanceObj->getExportedFunction(cx, instanceObj, funcIndex, &f));
   MOZ_ASSERT(value == f);
 #endif
 
   Instance& instance = instanceObj->instance();
   Tier tier = instance.code().bestTier();
   const MetadataTier& metadata = instance.metadata(tier);
   const CodeRange& codeRange =
-    metadata.codeRange(metadata.lookupFuncExport(funcIndex));
+      metadata.codeRange(metadata.lookupFuncExport(funcIndex));
   void* code = instance.codeBase(tier) + codeRange.funcTableEntry();
   while (index < limit) {
     table->setAnyFunc(index++, code, &instance);
   }
 }
 
 /* static */
 bool WasmTableObject::setImpl(JSContext* cx, const CallArgs& args) {
@@ -2301,21 +2298,18 @@ bool WasmTableObject::setImpl(JSContext*
     case TableKind::AnyRef: {
       RootedAnyRef tmp(cx, AnyRef::null());
       if (!BoxAnyRef(cx, fillValue, &tmp)) {
         return false;
       }
       table.setAnyRef(index, tmp);
       break;
     }
-    default: {
-      MOZ_CRASH("Unexpected table kind");
-    }
-  }
-
+    default: { MOZ_CRASH("Unexpected table kind"); }
+  }
 
   args.rval().setUndefined();
   return true;
 }
 
 /* static */
 bool WasmTableObject::set(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
@@ -2345,18 +2339,18 @@ bool WasmTableObject::growImpl(JSContext
   }
 
   RootedValue fillValue(cx);
   fillValue.setNull();
   if (args.length() > 1) {
     fillValue = args[1];
   }
 
-  MOZ_ASSERT(delta <= MaxTableLength); // grow() should ensure this
-  MOZ_ASSERT(oldLength <= MaxTableLength - delta); // ditto
+  MOZ_ASSERT(delta <= MaxTableLength);              // grow() should ensure this
+  MOZ_ASSERT(oldLength <= MaxTableLength - delta);  // ditto
 
   static_assert(MaxTableLength < UINT32_MAX, "Invariant");
 
   switch (table->table().kind()) {
     case TableKind::AnyFunction: {
       RootedFunction value(cx);
       if (fillValue.isNull()) {
 #ifdef DEBUG
@@ -2387,19 +2381,17 @@ bool WasmTableObject::growImpl(JSContext
 #ifdef DEBUG
         for (uint32_t index = oldLength; index < oldLength + delta; index++) {
           MOZ_ASSERT(table->table().getAnyRef(index).isNull());
         }
 #endif
       }
       break;
     }
-    default: {
-      MOZ_CRASH("Unexpected table kind");
-    }
+    default: { MOZ_CRASH("Unexpected table kind"); }
   }
 
   args.rval().setInt32(oldLength);
   return true;
 }
 
 /* static */
 bool WasmTableObject::grow(JSContext* cx, unsigned argc, Value* vp) {
--- a/js/src/wasm/WasmModule.cpp
+++ b/js/src/wasm/WasmModule.cpp
@@ -639,18 +639,18 @@ bool Module::initSegments(JSContext* cx,
         count = tableLength - offset;
       }
 #endif
       if (count) {
         instance.initElems(seg->tableIndex, *seg, offset, 0, count);
       }
 #ifdef ENABLE_WASM_BULKMEM_OPS
       if (fail) {
-        JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_WASM_BAD_FIT,
-                                 "elem", "table");
+        JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
+                                 JSMSG_WASM_BAD_FIT, "elem", "table");
         return false;
       }
 #endif
     }
   }
 
   if (memoryObj) {
 #ifdef ENABLE_WASM_BULKMEM_OPS
--- a/js/src/wasm/WasmTextToBinary.cpp
+++ b/js/src/wasm/WasmTextToBinary.cpp
@@ -6427,29 +6427,26 @@ static bool EncodeMemOrTableInit(Encoder
 #ifdef ENABLE_WASM_REFTYPES
 static bool EncodeTableGet(Encoder& e, AstTableGet& s) {
   return EncodeExpr(e, s.index()) && e.writeOp(Op::TableGet) &&
          e.writeVarU32(s.targetTable().index());
 }
 
 static bool EncodeTableGrow(Encoder& e, AstTableGrow& s) {
   return EncodeExpr(e, s.delta()) && EncodeExpr(e, s.initValue()) &&
-         e.writeOp(MiscOp::TableGrow) &&
-         e.writeVarU32(s.targetTable().index());
+         e.writeOp(MiscOp::TableGrow) && e.writeVarU32(s.targetTable().index());
 }
 
 static bool EncodeTableSet(Encoder& e, AstTableSet& s) {
   return EncodeExpr(e, s.index()) && EncodeExpr(e, s.value()) &&
-         e.writeOp(Op::TableSet) &&
-         e.writeVarU32(s.targetTable().index());
+         e.writeOp(Op::TableSet) && e.writeVarU32(s.targetTable().index());
 }
 
 static bool EncodeTableSize(Encoder& e, AstTableSize& s) {
-  return e.writeOp(MiscOp::TableSize) &&
-         e.writeVarU32(s.targetTable().index());
+  return e.writeOp(MiscOp::TableSize) && e.writeVarU32(s.targetTable().index());
 }
 #endif
 
 #ifdef ENABLE_WASM_GC
 static bool EncodeStructNew(Encoder& e, AstStructNew& s) {
   if (!EncodeArgs(e, s.fieldValues())) {
     return false;
   }
@@ -7208,18 +7205,18 @@ static bool EncodeElemSegment(Encoder& e
 
   if (!e.writeVarU32(segment.elems().length())) {
     return false;
   }
 
   for (const AstElem& elem : segment.elems()) {
     if (elem.is<AstRef>()) {
       const AstRef& ref = elem.as<AstRef>();
-      // Passive segments have an initializer expression, for now restricted to a
-      // function index.
+      // Passive segments have an initializer expression, for now restricted to
+      // a function index.
       if (segment.isPassive() && !e.writeFixedU8(uint8_t(Op::RefFunc))) {
         return false;
       }
       if (!e.writeVarU32(ref.index())) {
         return false;
       }
       if (segment.isPassive() && !e.writeFixedU8(uint8_t(Op::End))) {
         return false;
--- a/js/src/wasm/WasmTypes.h
+++ b/js/src/wasm/WasmTypes.h
@@ -393,21 +393,30 @@ class ValType {
   explicit ValType(const ExprType& t) : tc_(t.packed()) {
     MOZ_ASSERT(isValidCode());
   }
 
   explicit ValType(PackedTypeCode ptc) : tc_(ptc) { MOZ_ASSERT(isValidCode()); }
 
   explicit ValType(jit::MIRType mty) {
     switch (mty) {
-      case jit::MIRType::Int32: tc_ = PackTypeCode(TypeCode::I32); break;
-      case jit::MIRType::Int64: tc_ = PackTypeCode(TypeCode::I64); break;
-      case jit::MIRType::Float32: tc_ = PackTypeCode(TypeCode::F32); break;
-      case jit::MIRType::Double: tc_ = PackTypeCode(TypeCode::F64); break;
-      default: MOZ_CRASH("ValType(MIRType): unexpected type");
+      case jit::MIRType::Int32:
+        tc_ = PackTypeCode(TypeCode::I32);
+        break;
+      case jit::MIRType::Int64:
+        tc_ = PackTypeCode(TypeCode::I64);
+        break;
+      case jit::MIRType::Float32:
+        tc_ = PackTypeCode(TypeCode::F32);
+        break;
+      case jit::MIRType::Double:
+        tc_ = PackTypeCode(TypeCode::F64);
+        break;
+      default:
+        MOZ_CRASH("ValType(MIRType): unexpected type");
     }
   }
 
   static ValType fromBitsUnsafe(uint32_t bits) {
     return ValType(PackedTypeCodeFromBits(bits));
   }
 
   PackedTypeCode packed() const { return tc_; }
@@ -1153,17 +1162,17 @@ typedef Vector<GlobalDesc, 0, SystemAllo
 // When a ElemSegment is "passive" it is shared between a wasm::Module and its
 // wasm::Instances. To allow each segment to be released as soon as the last
 // Instance elem.drops it and the Module is destroyed, each ElemSegment is
 // individually atomically ref-counted.
 
 struct ElemSegment : AtomicRefCounted<ElemSegment> {
   uint32_t tableIndex;
   Maybe<InitExpr> offsetIfActive;
-  Uint32Vector elemFuncIndices; // Element may be NullFuncIndex
+  Uint32Vector elemFuncIndices;  // Element may be NullFuncIndex
 
   bool active() const { return !!offsetIfActive; }
 
   InitExpr offset() const { return *offsetIfActive; }
 
   size_t length() const { return elemFuncIndices.length(); }
 
   WASM_DECLARE_SERIALIZABLE(ElemSegment)
--- a/js/src/wasm/WasmValidate.cpp
+++ b/js/src/wasm/WasmValidate.cpp
@@ -1371,21 +1371,24 @@ static bool DecodeGCFeatureOptInSection(
   // Version 1 is complete and obsolete.
   // Version 2 is incomplete but obsolete.
   // Version 3 is in progress.
 
   switch (version) {
     case 1:
     case 2:
       return d.fail(
-          "Wasm GC feature versions 1 and 2 are no longer supported by this engine.\n"
-          "The current version is 3, which is not backward-compatible with earlier\n"
+          "Wasm GC feature versions 1 and 2 are no longer supported by this "
+          "engine.\n"
+          "The current version is 3, which is not backward-compatible with "
+          "earlier\n"
           "versions:\n"
           " - The v1 encoding of ref.null is no longer accepted.\n"
-          " - The v2 encodings of ref.eq, table.get, table.set, and table.size\n"
+          " - The v2 encodings of ref.eq, table.get, table.set, and "
+          "table.size\n"
           "   are no longer accepted.\n");
     case 3:
       break;
     default:
       return d.fail(
           "The specified Wasm GC feature version is unknown.\n"
           "The current version is 3.");
   }
@@ -1572,18 +1575,17 @@ static bool DecodeTableTypeAndLimits(Dec
   if (!DecodeLimits(d, &limits)) {
     return false;
   }
 
   // If there's a maximum, check it is in range.  The check to exclude
   // initial > maximum is carried out by the DecodeLimits call above, so
   // we don't repeat it here.
   if (limits.initial > MaxTableInitialLength ||
-      ((limits.maximum.isSome() &&
-        limits.maximum.value() > MaxTableLength))) {
+      ((limits.maximum.isSome() && limits.maximum.value() > MaxTableLength))) {
     return d.fail("too many table elements");
   }
 
   if (tables->length() >= MaxTables) {
     return d.fail("too many tables");
   }
 
   return tables->emplaceBack(tableKind, limits);
@@ -1951,18 +1953,18 @@ static bool DecodeInitializerExpression(
         return d.fail("global index out of range in initializer expression");
       }
       if (!globals[i].isImport() || globals[i].isMutable()) {
         return d.fail(
             "initializer expression must reference a global immutable import");
       }
       if (expected.isReference()) {
         bool fail = false;
-        if ((expected.isRef() || globals[i].type().isRef())
-            && !env->gcTypesEnabled()) {
+        if ((expected.isRef() || globals[i].type().isRef()) &&
+            !env->gcTypesEnabled()) {
           fail = true;
         } else if (!(globals[i].type().isReference() &&
                      env->isRefSubtypeOf(globals[i].type(), expected))) {
           fail = true;
         }
         if (fail) {
           return d.fail(
               "type mismatch: initializer type and expected type don't match");
--- a/js/src/wasm/cranelift/baldrapi.h
+++ b/js/src/wasm/cranelift/baldrapi.h
@@ -116,18 +116,18 @@ struct CraneliftFuncCompileInput {
 struct CraneliftMetadataEntry {
   enum Which {
     DirectCall,
     IndirectCall,
     Trap,
     MemoryAccess,
     SymbolicAccess
   } which;
-  uint32_t offset; // relative to the beginning of the function generated code
-  uint32_t srcLoc; // relative to the beginning of the module bytecode
+  uint32_t offset;  // relative to the beginning of the function generated code
+  uint32_t srcLoc;  // relative to the beginning of the module bytecode
   size_t extra;
 };
 
 // The result of a single function compilation, containing the machine code
 // generated by Cranelift, as well as some useful metadata to generate the
 // prologue/epilogue etc.
 
 struct CraneliftCompiledFunc {
--- a/js/xpconnect/src/XPCJSContext.cpp
+++ b/js/xpconnect/src/XPCJSContext.cpp
@@ -844,17 +844,18 @@ static void ReloadPrefsCallback(const ch
       Preferences::GetBool(JS_OPTIONS_DOT_STR "spectre.jit_to_C++_calls");
 
   bool unboxedObjects =
       Preferences::GetBool(JS_OPTIONS_DOT_STR "unboxed_objects");
 
   sSharedMemoryEnabled =
       Preferences::GetBool(JS_OPTIONS_DOT_STR "shared_memory");
   sStreamsEnabled = Preferences::GetBool(JS_OPTIONS_DOT_STR "streams");
-  sFieldsEnabled = Preferences::GetBool(JS_OPTIONS_DOT_STR "experimental.fields");
+  sFieldsEnabled =
+      Preferences::GetBool(JS_OPTIONS_DOT_STR "experimental.fields");
 
 #ifdef DEBUG
   sExtraWarningsForSystemJS =
       Preferences::GetBool(JS_OPTIONS_DOT_STR "strict.debug");
 #endif
 
 #ifdef JS_GC_ZEAL
   int32_t zeal = Preferences::GetInt(JS_OPTIONS_DOT_STR "gczeal", -1);
--- a/js/xpconnect/src/XPCShellImpl.cpp
+++ b/js/xpconnect/src/XPCShellImpl.cpp
@@ -1321,17 +1321,18 @@ int XRE_XPCShellMain(int argc, char** ar
     BrowserTabsRemoteAutostart();
 #ifdef XP_WIN
     // Plugin may require audio session if installed plugin can initialize
     // asynchronized.
     AutoAudioSession audioSession;
 
     // Ensure that DLL Services are running
     RefPtr<DllServices> dllSvc(DllServices::Get());
-    auto dllServicesDisable = MakeScopeExit([&dllSvc]() { dllSvc->DisableFull(); });
+    auto dllServicesDisable =
+        MakeScopeExit([&dllSvc]() { dllSvc->DisableFull(); });
 
 #  if defined(MOZ_SANDBOX)
     // Required for sandboxed child processes.
     if (aShellData->sandboxBrokerServices) {
       SandboxBroker::Initialize(aShellData->sandboxBrokerServices);
       SandboxBroker::GeckoDependentInitialize();
     } else {
       NS_WARNING(
--- a/js/xpconnect/src/nsXPConnect.cpp
+++ b/js/xpconnect/src/nsXPConnect.cpp
@@ -352,18 +352,18 @@ void xpc::ErrorReport::LogToConsoleWithS
 
   rv = errorObject->InitSourceId(mSourceId);
   NS_ENSURE_SUCCESS_VOID(rv);
 
   for (size_t i = 0, len = mNotes.Length(); i < len; i++) {
     ErrorNote& note = mNotes[i];
 
     nsScriptErrorNote* noteObject = new nsScriptErrorNote();
-    noteObject->Init(note.mErrorMsg, note.mFileName,
-                     note.mSourceId, note.mLineNumber, note.mColumn);
+    noteObject->Init(note.mErrorMsg, note.mFileName, note.mSourceId,
+                     note.mLineNumber, note.mColumn);
     errorObject->AddNote(noteObject);
   }
 
   consoleService->LogMessage(errorObject);
 }
 
 /* static */
 void xpc::ErrorNote::ErrorNoteToMessageString(JSErrorNotes::Note* aNote,
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -3392,18 +3392,17 @@ nsCSSFrameConstructor::FindHTMLData(cons
       SIMPLE_TAG_CHAIN(canvas, nsCSSFrameConstructor::FindCanvasData),
       SIMPLE_TAG_CREATE(video, NS_NewHTMLVideoFrame),
       SIMPLE_TAG_CREATE(audio, NS_NewHTMLVideoFrame),
       SIMPLE_TAG_CREATE(progress, NS_NewProgressFrame),
       SIMPLE_TAG_CREATE(meter, NS_NewMeterFrame),
       COMPLEX_TAG_CREATE(details,
                          &nsCSSFrameConstructor::ConstructDetailsFrame)};
 
-  return FindDataByTag(aElement, aStyle, sHTMLData,
-                       ArrayLength(sHTMLData));
+  return FindDataByTag(aElement, aStyle, sHTMLData, ArrayLength(sHTMLData));
 }
 
 /* static */
 const nsCSSFrameConstructor::FrameConstructionData*
 nsCSSFrameConstructor::FindGeneratedImageData(const Element& aElement,
                                               ComputedStyle&) {
   if (!aElement.IsInNativeAnonymousSubtree()) {
     return nullptr;
@@ -4021,18 +4020,18 @@ const nsCSSFrameConstructor::FrameConstr
         SIMPLE_XUL_FCDATA(NS_NewTextBoxFrame);
 
 /* static */
 const nsCSSFrameConstructor::FrameConstructionData*
 nsCSSFrameConstructor::FindXULButtonData(const Element& aElement,
                                          ComputedStyle&) {
   static const FrameConstructionData sXULMenuData =
       SIMPLE_XUL_FCDATA(NS_NewMenuFrame);
-  if (aElement.AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
-                           nsGkAtoms::menu, eCaseMatters)) {
+  if (aElement.AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, nsGkAtoms::menu,
+                           eCaseMatters)) {
     return &sXULMenuData;
   }
 
 #  ifdef MOZ_THUNDERBIRD
   if (aElement.AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                            NS_LITERAL_STRING("menu-button"), eCaseMatters)) {
     return &sXULMenuData;
   }
@@ -5292,25 +5291,23 @@ nsCSSFrameConstructor::FindElementTagDat
     default:
       return nullptr;
   }
 }
 
 nsCSSFrameConstructor::XBLBindingLoadInfo::XBLBindingLoadInfo(
     already_AddRefed<ComputedStyle>&& aStyle,
     UniquePtr<PendingBinding> aPendingBinding)
-    : mStyle(std::move(aStyle)),
-      mPendingBinding(std::move(aPendingBinding)) {
+    : mStyle(std::move(aStyle)), mPendingBinding(std::move(aPendingBinding)) {
   MOZ_ASSERT(mStyle);
 }
 
 nsCSSFrameConstructor::XBLBindingLoadInfo::XBLBindingLoadInfo(
     nsIContent& aContent, ComputedStyle& aStyle)
-    : mStyle(&aStyle),
-      mPendingBinding(nullptr) {}
+    : mStyle(&aStyle), mPendingBinding(nullptr) {}
 
 nsCSSFrameConstructor::XBLBindingLoadInfo::XBLBindingLoadInfo() = default;
 
 nsCSSFrameConstructor::XBLBindingLoadInfo
 nsCSSFrameConstructor::LoadXBLBindingIfNeeded(nsIContent& aContent,
                                               ComputedStyle& aStyle,
                                               uint32_t aFlags) {
   if (!(aFlags & ITEM_ALLOW_XBL_BASE)) {
--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -1635,17 +1635,18 @@ bool nsPresContext::HasAuthorSpecifiedRu
 
   // Anonymous boxes are more complicated, and we just assume that they
   // cannot have any author-specified rules here.
   if (aFrame->Style()->IsAnonBox()) {
     return false;
   }
 
   auto* set = PresShell()->StyleSet()->RawSet();
-  return Servo_HasAuthorSpecifiedRules(set, aFrame->Style(), elem, aRuleTypeMask);
+  return Servo_HasAuthorSpecifiedRules(set, aFrame->Style(), elem,
+                                       aRuleTypeMask);
 }
 
 gfxUserFontSet* nsPresContext::GetUserFontSet() {
   return mDocument->GetUserFontSet();
 }
 
 void nsPresContext::UserFontSetUpdated(gfxUserFontEntry* aUpdatedFont) {
   if (!mShell) return;
--- a/layout/forms/nsHTMLButtonControlFrame.cpp
+++ b/layout/forms/nsHTMLButtonControlFrame.cpp
@@ -83,18 +83,18 @@ void nsHTMLButtonControlFrame::BuildDisp
   if (IsVisibleForPainting()) {
     // Clip the button itself to its border area for event hit testing.
     Maybe<DisplayListClipState::AutoSaveRestore> eventClipState;
     if (aBuilder->IsForEventDelivery()) {
       eventClipState.emplace(aBuilder);
       nsRect rect(aBuilder->ToReferenceFrame(this), GetSize());
       nscoord radii[8];
       bool hasRadii = GetBorderRadii(radii);
-      eventClipState->ClipContainingBlockDescendants(rect,
-          hasRadii ? radii : nullptr);
+      eventClipState->ClipContainingBlockDescendants(
+          rect, hasRadii ? radii : nullptr);
     }
 
     mRenderer.DisplayButton(aBuilder, aLists.BorderBackground(), &onTop);
   }
 
   nsDisplayListCollection set(aBuilder);
 
   {
--- a/layout/generic/BRFrame.cpp
+++ b/layout/generic/BRFrame.cpp
@@ -36,22 +36,19 @@ class BRFrame final : public nsFrame {
       const nsPoint& aPoint) override;
 
   virtual FrameSearchResult PeekOffsetNoAmount(bool aForward,
                                                int32_t* aOffset) override;
   virtual FrameSearchResult PeekOffsetCharacter(
       bool aForward, int32_t* aOffset,
       PeekOffsetCharacterOptions aOptions =
           PeekOffsetCharacterOptions()) override;
-  virtual FrameSearchResult PeekOffsetWord(bool aForward,
-                                           bool aWordSelectEatSpace,
-                                           bool aIsKeyboardSelect,
-                                           int32_t* aOffset,
-                                           PeekWordState* aState,
-                                           bool aTrimSpaces) override;
+  virtual FrameSearchResult PeekOffsetWord(
+      bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect,
+      int32_t* aOffset, PeekWordState* aState, bool aTrimSpaces) override;
 
   virtual void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
                       const ReflowInput& aReflowInput,
                       nsReflowStatus& aStatus) override;
   virtual void AddInlineMinISize(gfxContext* aRenderingContext,
                                  InlineMinISizeData* aData) override;
   virtual void AddInlinePrefISize(gfxContext* aRenderingContext,
                                   InlinePrefISizeData* aData) override;
@@ -234,22 +231,19 @@ nsIFrame::FrameSearchResult BRFrame::Pee
 
 nsIFrame::FrameSearchResult BRFrame::PeekOffsetCharacter(
     bool aForward, int32_t* aOffset, PeekOffsetCharacterOptions aOptions) {
   NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range");
   // Keep going. The actual line jumping will stop us.
   return CONTINUE;
 }
 
-nsIFrame::FrameSearchResult BRFrame::PeekOffsetWord(bool aForward,
-                                                    bool aWordSelectEatSpace,
-                                                    bool aIsKeyboardSelect,
-                                                    int32_t* aOffset,
-                                                    PeekWordState* aState,
-                                                    bool aTrimSpaces) {
+nsIFrame::FrameSearchResult BRFrame::PeekOffsetWord(
+    bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect,
+    int32_t* aOffset, PeekWordState* aState, bool aTrimSpaces) {
   NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range");
   // Keep going. The actual line jumping will stop us.
   return CONTINUE;
 }
 
 #ifdef ACCESSIBILITY
 a11y::AccType BRFrame::AccessibleType() {
   nsIContent* parent = mContent->GetParent();
--- a/layout/generic/WritingModes.h
+++ b/layout/generic/WritingModes.h
@@ -1561,18 +1561,17 @@ class LogicalRect {
   /**
    * Physical coordinates of the rect.
    */
   nscoord X(WritingMode aWritingMode, nscoord aContainerWidth) const {
     CHECK_WRITING_MODE(aWritingMode);
     if (aWritingMode.IsVertical()) {
       return aWritingMode.IsVerticalLR() ? mBStart : aContainerWidth - BEnd();
     }
-    return aWritingMode.IsInlineReversed() ? aContainerWidth - IEnd()
-                                           : mIStart;
+    return aWritingMode.IsInlineReversed() ? aContainerWidth - IEnd() : mIStart;
   }
 
   nscoord Y(WritingMode aWritingMode, nscoord aContainerHeight) const {
     CHECK_WRITING_MODE(aWritingMode);
     if (aWritingMode.IsVertical()) {
       return aWritingMode.IsInlineReversed() ? aContainerHeight - IEnd()
                                              : mIStart;
     }
@@ -1589,18 +1588,17 @@ class LogicalRect {
     return aWritingMode.IsVertical() ? mISize : mBSize;
   }
 
   nscoord XMost(WritingMode aWritingMode, nscoord aContainerWidth) const {
     CHECK_WRITING_MODE(aWritingMode);
     if (aWritingMode.IsVertical()) {
       return aWritingMode.IsVerticalLR() ? BEnd() : aContainerWidth - mBStart;
     }
-    return aWritingMode.IsInlineReversed() ? aContainerWidth - mIStart
-                                           : IEnd();
+    return aWritingMode.IsInlineReversed() ? aContainerWidth - mIStart : IEnd();
   }
 
   nscoord YMost(WritingMode aWritingMode, nscoord aContainerHeight) const {
     CHECK_WRITING_MODE(aWritingMode);
     if (aWritingMode.IsVertical()) {
       return aWritingMode.IsInlineReversed() ? aContainerHeight - mIStart
                                              : IEnd();
     }
--- a/layout/generic/nsFrame.h
+++ b/layout/generic/nsFrame.h
@@ -210,18 +210,18 @@ class nsFrame : public nsBox {
   FrameSearchResult PeekOffsetNoAmount(bool aForward,
                                        int32_t* aOffset) override;
   FrameSearchResult PeekOffsetCharacter(
       bool aForward, int32_t* aOffset,
       PeekOffsetCharacterOptions aOptions =
           PeekOffsetCharacterOptions()) override;
   FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace,
                                    bool aIsKeyboardSelect, int32_t* aOffset,
-                                   PeekWordState* aState, bool aTrimSpaces)
-                                   override;
+                                   PeekWordState* aState,
+                                   bool aTrimSpaces) override;
   /**
    * Check whether we should break at a boundary between punctuation and
    * non-punctuation. Only call it at a punctuation boundary
    * (i.e. exactly one of the previous and next characters are punctuation).
    * @param aForward true if we're moving forward in content order
    * @param aPunctAfter true if the next character is punctuation
    * @param aWhitespaceAfter true if the next character is whitespace
    */
--- a/layout/generic/nsFrameSelection.cpp
+++ b/layout/generic/nsFrameSelection.cpp
@@ -106,18 +106,17 @@ static void printRange(nsRange* aDomRang
 
 //#define DEBUG_TABLE_SELECTION 1
 
 nsPeekOffsetStruct::nsPeekOffsetStruct(
     nsSelectionAmount aAmount, nsDirection aDirection, int32_t aStartOffset,
     nsPoint aDesiredPos, bool aJumpLines, bool aScrollViewStop,
     bool aIsKeyboardSelect, bool aVisual, bool aExtend,
     ForceEditableRegion aForceEditableRegion,
-    EWordMovementType aWordMovementType,
-    bool aTrimSpaces)
+    EWordMovementType aWordMovementType, bool aTrimSpaces)
     : mAmount(aAmount),
       mDirection(aDirection),
       mStartOffset(aStartOffset),
       mDesiredPos(aDesiredPos),
       mWordMovementType(aWordMovementType),
       mJumpLines(aJumpLines),
       mTrimSpaces(aTrimSpaces),
       mScrollViewStop(aScrollViewStop),
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -4493,22 +4493,19 @@ class nsIFrame : public nsQueryFrame {
       if (aAfterWhitespace) {
         mSeenNonPunctuationSinceWhitespace = false;
       } else if (!aAfterPunctuation) {
         mSeenNonPunctuationSinceWhitespace = true;
       }
       mAtStart = false;
     }
   };
-  virtual FrameSearchResult PeekOffsetWord(bool aForward,
-                                           bool aWordSelectEatSpace,
-                                           bool aIsKeyboardSelect,
-                                           int32_t* aOffset,
-                                           PeekWordState* aState,
-                                           bool aTrimSpaces) = 0;
+  virtual FrameSearchResult PeekOffsetWord(
+      bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect,
+      int32_t* aOffset, PeekWordState* aState, bool aTrimSpaces) = 0;
 
   /**
    * Search for the first paragraph boundary before or after the given position
    * @param  aPos See description in nsFrameSelection.h. The following fields
    *              are used by this method:
    *              Input: mDirection
    *              Output: mResultContent, mContentOffset
    */
--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -2184,19 +2184,18 @@ void nsLineLayout::VerticalAlignFrames(P
       //           For example in quirks mode, avoiding empty text frames
       //           prevents "tall" lines around elements like <hr> since the
       //           rules of <hr> in quirks.css have pseudo text contents with LF
       //           in them.
       bool canUpdate;
       if (pfd->mIsTextFrame) {
         // Only consider text frames if they're not empty and
         // line-height=normal.
-        canUpdate =
-            pfd->mIsNonWhitespaceTextFrame &&
-            frame->StyleText()->mLineHeight.IsNormal();
+        canUpdate = pfd->mIsNonWhitespaceTextFrame &&
+                    frame->StyleText()->mLineHeight.IsNormal();
       } else {
         canUpdate = !pfd->mIsPlaceholder;
       }
 
       if (canUpdate) {
         nscoord blockStart, blockEnd;
         if (frameSpan) {
           // For spans that were are now placing, use their position
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -1765,19 +1765,18 @@ static nscoord WordSpacing(nsIFrame* aFr
                            const nsStyleText* aStyleText = nullptr) {
   if (nsSVGUtils::IsInSVGTextSubtree(aFrame)) {
     return 0;
   }
   if (!aStyleText) {
     aStyleText = aFrame->StyleText();
   }
 
-  return aStyleText->mWordSpacing.Resolve([&] {
-    return GetSpaceWidthAppUnits(aTextRun);
-  });
+  return aStyleText->mWordSpacing.Resolve(
+      [&] { return GetSpaceWidthAppUnits(aTextRun); });
 }
 
 // Returns gfxTextRunFactory::TEXT_ENABLE_SPACING if non-standard
 // letter-spacing or word-spacing is present.
 static gfx::ShapedTextFlags GetSpacingFlags(
     nsIFrame* aFrame, const nsStyleText* aStyleText = nullptr) {
   if (nsSVGUtils::IsInSVGTextSubtree(aFrame)) {
     return gfx::ShapedTextFlags();
@@ -3698,49 +3697,46 @@ void PropertyProvider::GetHyphenationBre
           aBreakBefore[i] == HyphenType::None) {
         aBreakBefore[i] = HyphenType::AutoWithoutManualInSameWord;
       }
     }
   }
 }
 
 void PropertyProvider::InitializeForDisplay(bool aTrimAfter) {
-  nsTextFrame::TrimmedOffsets trimmed =
-      mFrame->GetTrimmedOffsets(mFrag,
-          (aTrimAfter ? nsTextFrame::TrimmedOffsetFlags::kDefaultTrimFlags :
-                        nsTextFrame::TrimmedOffsetFlags::kNoTrimAfter));
+  nsTextFrame::TrimmedOffsets trimmed = mFrame->GetTrimmedOffsets(
+      mFrag, (aTrimAfter ? nsTextFrame::TrimmedOffsetFlags::kDefaultTrimFlags
+                         : nsTextFrame::TrimmedOffsetFlags::kNoTrimAfter));
   mStart.SetOriginalOffset(trimmed.mStart);
   mLength = trimmed.mLength;
   SetupJustificationSpacing(true);
 }
 
 void PropertyProvider::InitializeForMeasure() {
-  nsTextFrame::TrimmedOffsets trimmed =
-      mFrame->GetTrimmedOffsets(mFrag,
-          nsTextFrame::TrimmedOffsetFlags::kNotPostReflow);
+  nsTextFrame::TrimmedOffsets trimmed = mFrame->GetTrimmedOffsets(
+      mFrag, nsTextFrame::TrimmedOffsetFlags::kNotPostReflow);
   mStart.SetOriginalOffset(trimmed.mStart);
   mLength = trimmed.mLength;
   SetupJustificationSpacing(false);
 }
 
 void PropertyProvider::SetupJustificationSpacing(bool aPostReflow) {
   MOZ_ASSERT(mLength != INT32_MAX, "Can't call this with undefined length");
 
   if (!(mFrame->GetStateBits() & TEXT_JUSTIFICATION_ENABLED)) {
     return;
   }
 
   gfxSkipCharsIterator start(mStart), end(mStart);
   // We can't just use our mLength here; when InitializeForDisplay is
   // called with false for aTrimAfter, we still shouldn't be assigning
   // justification space to any trailing whitespace.
-  nsTextFrame::TrimmedOffsets trimmed =
-      mFrame->GetTrimmedOffsets(mFrag,
-          (aPostReflow ? nsTextFrame::TrimmedOffsetFlags::kDefaultTrimFlags :
-                         nsTextFrame::TrimmedOffsetFlags::kNotPostReflow));
+  nsTextFrame::TrimmedOffsets trimmed = mFrame->GetTrimmedOffsets(
+      mFrag, (aPostReflow ? nsTextFrame::TrimmedOffsetFlags::kDefaultTrimFlags
+                          : nsTextFrame::TrimmedOffsetFlags::kNotPostReflow));
   end.AdvanceOriginal(trimmed.mLength);
   gfxSkipCharsIterator realEnd(end);
 
   Range range(uint32_t(start.GetOriginalOffset()),
               uint32_t(end.GetOriginalOffset()));
   nsTArray<JustificationAssignment> assignments;
   JustificationInfo info = ComputeJustification(range, &assignments);
 
@@ -7823,18 +7819,18 @@ nsIFrame::FrameSearchResult nsTextFrame:
     if (selectStyle == StyleUserSelect::All) {
       return CONTINUE_UNSELECTABLE;
     }
   }
 
   gfxSkipCharsIterator iter = EnsureTextRun(nsTextFrame::eInflated);
   if (!mTextRun) return CONTINUE_EMPTY;
 
-  TrimmedOffsets trimmed = GetTrimmedOffsets(mContent->GetText(),
-                                             TrimmedOffsetFlags::kNoTrimAfter);
+  TrimmedOffsets trimmed =
+      GetTrimmedOffsets(mContent->GetText(), TrimmedOffsetFlags::kNoTrimAfter);
 
   // A negative offset means "end of frame".
   int32_t startOffset =
       GetContentOffset() + (*aOffset < 0 ? contentLength : *aOffset);
 
   if (!aForward) {
     // If at the beginning of the line, look at the previous continuation
     for (int32_t i = std::min(trimmed.GetEnd(), startOffset) - 1;
@@ -7958,20 +7954,20 @@ ClusterIterator::ClusterIterator(nsTextF
   mIterator = aTextFrame->EnsureTextRun(nsTextFrame::eInflated);
   if (!aTextFrame->GetTextRun(nsTextFrame::eInflated)) {
     mDirection = 0;  // signal failure
     return;
   }
   mIterator.SetOriginalOffset(aPosition);
 
   mFrag = aTextFrame->GetContent()->GetText();
-  mTrimmed = aTextFrame->GetTrimmedOffsets(mFrag,
-      aTrimSpaces ? nsTextFrame::TrimmedOffsetFlags::kDefaultTrimFlags :
-                    nsTextFrame::TrimmedOffsetFlags::kNoTrimAfter |
-                        nsTextFrame::TrimmedOffsetFlags::kNoTrimBefore);
+  mTrimmed = aTextFrame->GetTrimmedOffsets(
+      mFrag, aTrimSpaces ? nsTextFrame::TrimmedOffsetFlags::kDefaultTrimFlags
+                         : nsTextFrame::TrimmedOffsetFlags::kNoTrimAfter |
+                               nsTextFrame::TrimmedOffsetFlags::kNoTrimBefore);
 
   int32_t textOffset = aTextFrame->GetContentOffset();
   int32_t textLen = aTextFrame->GetContentLength();
   if (!mWordBreaks.AppendElements(textLen + 1)) {
     mDirection = 0;  // signal failure
     return;
   }
   memset(mWordBreaks.Elements(), false, (textLen + 1) * sizeof(bool));
@@ -9773,20 +9769,19 @@ nsIFrame::RenderedText nsTextFrame::GetR
       trimAfter = LineEndsInHardLineBreak(textFrame, lineContainer);
     } else {
       // Weird situation where we have a line layout without a block.
       // No soft breaks occur in this situation.
       trimAfter = true;
     }
 
     // Skip to the start of the text run, past ignored chars at start of line
-    TrimmedOffsets trimmedOffsets =
-        textFrame->GetTrimmedOffsets(textFrag,
-            (trimAfter ? TrimmedOffsetFlags::kDefaultTrimFlags :
-                         TrimmedOffsetFlags::kNoTrimAfter));
+    TrimmedOffsets trimmedOffsets = textFrame->GetTrimmedOffsets(
+        textFrag, (trimAfter ? TrimmedOffsetFlags::kDefaultTrimFlags
+                             : TrimmedOffsetFlags::kNoTrimAfter));
     bool trimmedSignificantNewline =
         trimmedOffsets.GetEnd() < GetContentEnd() &&
         HasSignificantTerminalNewline();
     uint32_t skippedToRenderedStringOffset =
         offsetInRenderedString -
         tmpIter.ConvertOriginalToSkipped(trimmedOffsets.mStart);
     uint32_t nextOffsetInRenderedString =
         tmpIter.ConvertOriginalToSkipped(trimmedOffsets.GetEnd()) +
@@ -10116,12 +10111,12 @@ bool nsTextFrame::HasNonSuppressedText()
                       NS_FRAME_FIRST_REFLOW | NS_FRAME_IN_REFLOW)) {
     return true;
   }
 
   if (!GetTextRun(nsTextFrame::eInflated)) {
     return false;
   }
 
-  TrimmedOffsets offsets = GetTrimmedOffsets(mContent->GetText(),
-                                             TrimmedOffsetFlags::kNoTrimAfter);
+  TrimmedOffsets offsets =
+      GetTrimmedOffsets(mContent->GetText(), TrimmedOffsetFlags::kNoTrimAfter);
   return offsets.mLength != 0;
 }
--- a/layout/generic/nsTextFrame.h
+++ b/layout/generic/nsTextFrame.h
@@ -178,18 +178,18 @@ class nsTextFrame : public nsFrame {
                         SelectionType aSelectionType);
 
   FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) final;
   FrameSearchResult PeekOffsetCharacter(
       bool aForward, int32_t* aOffset,
       PeekOffsetCharacterOptions aOptions = PeekOffsetCharacterOptions()) final;
   FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace,
                                    bool aIsKeyboardSelect, int32_t* aOffset,
-                                   PeekWordState* aState, bool aTrimSpaces)
-                                   final;
+                                   PeekWordState* aState,
+                                   bool aTrimSpaces) final;
 
   nsresult CheckVisibility(nsPresContext* aContext, int32_t aStartIndex,
                            int32_t aEndIndex, bool aRecurse, bool* aFinished,
                            bool* _retval) final;
 
   // Flags for aSetLengthFlags
   enum { ALLOW_FRAME_CREATION_AND_DESTRUCTION = 0x01 };
 
@@ -575,17 +575,18 @@ class nsTextFrame : public nsFrame {
     int32_t GetEnd() const { return mStart + mLength; }
   };
   enum class TrimmedOffsetFlags : uint8_t {
     kDefaultTrimFlags = 0,
     kNotPostReflow = 1 << 0,
     kNoTrimAfter = 1 << 1,
     kNoTrimBefore = 1 << 2
   };
-  TrimmedOffsets GetTrimmedOffsets(const nsTextFragment* aFrag,
+  TrimmedOffsets GetTrimmedOffsets(
+      const nsTextFragment* aFrag,
       TrimmedOffsetFlags aFlags = TrimmedOffsetFlags::kDefaultTrimFlags) const;
 
   // Similar to Reflow(), but for use from nsLineLayout
   void ReflowText(nsLineLayout& aLineLayout, nscoord aAvailableWidth,
                   DrawTarget* aDrawTarget, ReflowOutput& aMetrics,
                   nsReflowStatus& aStatus);
 
   bool IsFloatingFirstLetterChild() const;
--- a/layout/painting/FrameLayerBuilder.h
+++ b/layout/painting/FrameLayerBuilder.h
@@ -485,18 +485,17 @@ class FrameLayerBuilder : public layers:
    * properties we can animate on layers and calls |aCallback|
    * with the animation generation for the layer.  If there is no corresponding
    * layer for the display item or the layer has no animation, the animation
    * generation is Nothing().
    *
    * The enumeration stops if |aCallback| returns false.
    */
   static void EnumerateGenerationForDedicatedLayers(
-      const nsIFrame* aFrame,
-      const AnimationGenerationCallback& aCallback);
+      const nsIFrame* aFrame, const AnimationGenerationCallback& aCallback);
 
   /**
    * This callback must be provided to EndTransaction. The callback data
    * must be the nsDisplayListBuilder containing this FrameLayerBuilder.
    * This function can be called multiple times in a row to draw
    * different regions. This will occur when, for example, progressive paint is
    * enabled. In these cases aDirtyRegion can be used to specify a larger region
    * than aRegionToDraw that will be drawn during the transaction, possibly
--- a/layout/svg/nsFilterInstance.cpp
+++ b/layout/svg/nsFilterInstance.cpp
@@ -90,18 +90,17 @@ void nsFilterInstance::PaintFilteredFram
                             *metrics, filterChain, /* InputIsTainted */ true,
                             aPaintCallback, scaleMatrixInDevUnits, aDirtyArea,
                             nullptr, nullptr, nullptr);
   if (instance.IsInitialized()) {
     instance.Render(aCtx, aImgParams, aOpacity);
   }
 }
 
-static mozilla::wr::ComponentTransferFuncType
-FuncTypeToWr(uint8_t aFuncType) {
+static mozilla::wr::ComponentTransferFuncType FuncTypeToWr(uint8_t aFuncType) {
   switch (aFuncType) {
     case SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY:
       return mozilla::wr::ComponentTransferFuncType::Identity;
     case SVG_FECOMPONENTTRANSFER_TYPE_TABLE:
       return mozilla::wr::ComponentTransferFuncType::Table;
     case SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE:
       return mozilla::wr::ComponentTransferFuncType::Discrete;
     case SVG_FECOMPONENTTRANSFER_TYPE_LINEAR:
@@ -277,29 +276,30 @@ bool nsFilterInstance::BuildWebRenderFil
       wr::FilterOp filterOp = wr::FilterOp::DropShadow(
           offset, radius, wr::ToColorF(ToDeviceColor(color)));
 
       aWrFilters.filters.AppendElement(filterOp);
     } else if (attr.is<ComponentTransferAttributes>()) {
       const ComponentTransferAttributes& attributes =
           attr.as<ComponentTransferAttributes>();
 
-      size_t numValues = attributes.mValues[0].Length() +
-          attributes.mValues[1].Length() + attributes.mValues[2].Length() +
-          attributes.mValues[3].Length();
+      size_t numValues =
+          attributes.mValues[0].Length() + attributes.mValues[1].Length() +
+          attributes.mValues[2].Length() + attributes.mValues[3].Length();
       if (numValues > 1024) {
         // Depending on how the wr shaders are implemented we may need to
         // limit the total number of values.
         return false;
       }
 
       wr::FilterOp filterOp = {wr::FilterOp::Tag::ComponentTransfer};
       wr::WrFilterData filterData;
       aWrFilters.values.AppendElement(nsTArray<float>());
-      nsTArray<float>* values = &aWrFilters.values[aWrFilters.values.Length()-1];
+      nsTArray<float>* values =
+          &aWrFilters.values[aWrFilters.values.Length() - 1];
       values->SetCapacity(numValues);
 
       filterData.funcR_type = FuncTypeToWr(attributes.mTypes[0]);
       size_t R_startindex = values->Length();
       values->AppendElements(attributes.mValues[0]);
       filterData.R_values_count = attributes.mValues[0].Length();
 
       filterData.funcG_type = FuncTypeToWr(attributes.mTypes[1]);
@@ -312,30 +312,36 @@ bool nsFilterInstance::BuildWebRenderFil
       values->AppendElements(attributes.mValues[2]);
       filterData.B_values_count = attributes.mValues[2].Length();
 
       filterData.funcA_type = FuncTypeToWr(attributes.mTypes[3]);
       size_t A_startindex = values->Length();
       values->AppendElements(attributes.mValues[3]);
       filterData.A_values_count = attributes.mValues[3].Length();
 
-      filterData.R_values = filterData.R_values_count > 0 ? &((*values)[R_startindex]) : nullptr;
-      filterData.G_values = filterData.G_values_count > 0 ? &((*values)[G_startindex]) : nullptr;
-      filterData.B_values = filterData.B_values_count > 0 ? &((*values)[B_startindex]) : nullptr;
-      filterData.A_values = filterData.A_values_count > 0 ? &((*values)[A_startindex]) : nullptr;
+      filterData.R_values =
+          filterData.R_values_count > 0 ? &((*values)[R_startindex]) : nullptr;
+      filterData.G_values =
+          filterData.G_values_count > 0 ? &((*values)[G_startindex]) : nullptr;
+      filterData.B_values =
+          filterData.B_values_count > 0 ? &((*values)[B_startindex]) : nullptr;
+      filterData.A_values =
+          filterData.A_values_count > 0 ? &((*values)[A_startindex]) : nullptr;
 
       aWrFilters.filters.AppendElement(filterOp);
       aWrFilters.filter_datas.AppendElement(filterData);
     } else {
       return false;
     }
 
     if (filterIsNoop && aWrFilters.filters.Length() > 0 &&
-        (aWrFilters.filters.LastElement().tag == wr::FilterOp::Tag::SrgbToLinear ||
-         aWrFilters.filters.LastElement().tag == wr::FilterOp::Tag::LinearToSrgb)) {
+        (aWrFilters.filters.LastElement().tag ==
+             wr::FilterOp::Tag::SrgbToLinear ||
+         aWrFilters.filters.LastElement().tag ==
+             wr::FilterOp::Tag::LinearToSrgb)) {
       // We pushed a color space conversion filter in prevision of applying
       // another filter which turned out to be a no-op, so the conversion is
       // unnecessary. Remove it from the filter list.
       // This is both an optimization and a way to pass the wptest
       // css/filter-effects/filter-scale-001.html for which the needless
       // sRGB->linear->no-op->sRGB roundtrip introduces a slight error and we
       // cannot add fuzziness to the test.
       Unused << aWrFilters.filters.PopLastElement();
--- a/layout/svg/nsSVGIntegrationUtils.h
+++ b/layout/svg/nsSVGIntegrationUtils.h
@@ -32,17 +32,18 @@ class LayerManager;
 }  // namespace mozilla
 
 struct nsPoint;
 struct nsSize;
 
 struct WrFiltersHolder {
   nsTArray<mozilla::wr::FilterOp> filters;
   nsTArray<mozilla::wr::WrFilterData> filter_datas;
-  // This exists just to own the values long enough for them to be copied into rust.
+  // This exists just to own the values long enough for them to be copied into
+  // rust.
   nsTArray<nsTArray<float>> values;
 };
 
 /**
  * Integration of SVG effects (clipPath clipping, masking and filters) into
  * regular display list based painting and hit-testing.
  */
 class nsSVGIntegrationUtils final {
--- a/layout/svg/nsSVGMaskFrame.h
+++ b/layout/svg/nsSVGMaskFrame.h
@@ -40,17 +40,18 @@ class nsSVGMaskFrame final : public nsSV
     const gfxMatrix& toUserSpace;
     float opacity;
     Matrix* maskTransform;
     mozilla::StyleMaskMode maskMode;
     imgDrawingParams& imgParams;
 
     explicit MaskParams(gfxContext* aCtx, nsIFrame* aMaskedFrame,
                         const gfxMatrix& aToUserSpace, float aOpacity,
-                        Matrix* aMaskTransform, mozilla::StyleMaskMode aMaskMode,
+                        Matrix* aMaskTransform,
+                        mozilla::StyleMaskMode aMaskMode,
                         imgDrawingParams& aImgParams)
         : ctx(aCtx),
           maskedFrame(aMaskedFrame),
           toUserSpace(aToUserSpace),
           opacity(aOpacity),
           maskTransform(aMaskTransform),
           maskMode(aMaskMode),
           imgParams(aImgParams) {}
--- a/layout/xul/nsMenuPopupFrame.cpp
+++ b/layout/xul/nsMenuPopupFrame.cpp
@@ -1607,18 +1607,17 @@ nsresult nsMenuPopupFrame::SetPopupPosit
     if (aNotify) {
       nsXULPopupPositionedEvent::DispatchIfNeeded(mContent, false, false);
     }
   }
 
   return NS_OK;
 }
 
-void nsMenuPopupFrame::GenerateFrames()
-{
+void nsMenuPopupFrame::GenerateFrames() {
   const bool generateFrames = IsLeaf();
   MOZ_ASSERT_IF(generateFrames, !mGeneratedChildren);
   mGeneratedChildren = true;
   if (generateFrames) {
     MOZ_ASSERT(PrincipalChildList().IsEmpty());
     nsCOMPtr<nsIPresShell> presShell = PresContext()->PresShell();
     presShell->FrameConstructor()->GenerateChildFrames(this);
   }
--- a/layout/xul/tree/nsTreeColumns.cpp
+++ b/layout/xul/tree/nsTreeColumns.cpp
@@ -237,17 +237,17 @@ int32_t nsTreeColumn::GetWidth(mozilla::
 }
 
 already_AddRefed<nsTreeColumn> nsTreeColumn::GetPreviousColumn() {
   nsIFrame* frame = GetFrame();
   while (frame) {
     frame = frame->GetPrevSibling();
     if (frame && frame->GetContent()->IsElement()) {
       RefPtr<nsTreeColumn> column =
-        mColumns->GetColumnFor(frame->GetContent()->AsElement());
+          mColumns->GetColumnFor(frame->GetContent()->AsElement());
       if (column) {
         return column.forget();
       }
     }
   }
 
   return nullptr;
 }
--- a/media/libdav1d/config.h
+++ b/media/libdav1d/config.h
@@ -43,26 +43,25 @@
 #endif
 
 // The following macros are defined from autoconf
 // according to the system configuration.
 // (HAVE_MEMALIGN | HAVE_ALIGNED_MALLOC | HAVE_POSIX_MEMALIGN)
 // HAVE_UNISTD_H
 
 // Important when asm is enabled
-#if defined(__APPLE__) || \
-    (ARCH_x86_32 == 1 && defined(_WIN32))
+#if defined(__APPLE__) || (ARCH_x86_32 == 1 && defined(_WIN32))
 #  define PREFIX 1
 #endif
 
 #if (ARCH_x86_32 == 1 || ARCH_X86_64 == 1) && defined(__linux__) && \
     !defined(__ANDROID__)
 #  define STACK_ALIGNMENT 16
 #else
 #  define STACK_ALIGNMENT 32
 #endif
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 // _WIN32_WINNT 0x0601 is set in global macros
-#define UNICODE 1
-#define _UNICODE 1
-#define __USE_MINGW_ANSI_STDIO 1
+#  define UNICODE 1
+#  define _UNICODE 1
+#  define __USE_MINGW_ANSI_STDIO 1
 #endif
--- a/media/mtransport/ipc/WebrtcProxyChannel.cpp
+++ b/media/mtransport/ipc/WebrtcProxyChannel.cpp
@@ -333,18 +333,17 @@ WebrtcProxyChannel::OnTransportAvailable
 NS_IMETHODIMP
 WebrtcProxyChannel::OnStartRequest(nsIRequest* aRequest) {
   LOG(("WebrtcProxyChannel::OnStartRequest %p\n", this));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-WebrtcProxyChannel::OnStopRequest(nsIRequest* aRequest,
-                                  nsresult aStatusCode) {
+WebrtcProxyChannel::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
   LOG(("WebrtcProxyChannel::OnStopRequest %p status=%u\n", this,
        static_cast<uint32_t>(aStatusCode)));
 
   // see nsHttpChannel::ProcessFailedProxyConnect for most error codes
   if (NS_FAILED(aStatusCode)) {
     CloseWithReason(aStatusCode);
     return aStatusCode;
   }
--- a/media/webrtc/signaling/src/media-conduit/AudioConduit.cpp
+++ b/media/webrtc/signaling/src/media-conduit/AudioConduit.cpp
@@ -170,17 +170,17 @@ bool WebrtcAudioConduit::GetRecvPacketTy
   ASSERT_ON_THREAD(mStsThread);
   if (!mEngineReceiving) {
     return false;
   }
   return mRecvChannelProxy->GetRTCPPacketTypeCounters(*aPacketCounts);
 }
 
 bool WebrtcAudioConduit::GetRTPReceiverStats(unsigned int* jitterMs,
-                                     unsigned int* cumulativeLost) {
+                                             unsigned int* cumulativeLost) {
   ASSERT_ON_THREAD(mStsThread);
   *jitterMs = 0;
   *cumulativeLost = 0;
   if (!mRecvStream) {
     return false;
   }
   auto stats = mRecvStream->GetStats();
   *jitterMs = stats.jitter_ms;
--- a/media/webrtc/signaling/src/media-conduit/AudioConduit.h
+++ b/media/webrtc/signaling/src/media-conduit/AudioConduit.h
@@ -220,17 +220,17 @@ class WebrtcAudioConduit : public AudioS
 
   bool GetSendPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) override;
 
   bool GetRecvPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) override;
 
   bool GetRTPReceiverStats(unsigned int* jitterMs,
-                   unsigned int* cumulativeLost) override;
+                           unsigned int* cumulativeLost) override;
   bool GetRTCPReceiverReport(uint32_t* jitterMs, uint32_t* packetsReceived,
                              uint64_t* bytesReceived, uint32_t* cumulativeLost,
                              int32_t* rttMs) override;
   bool GetRTCPSenderReport(unsigned int* packetsSent,
                            uint64_t* bytesSent) override;
 
   bool SetDtmfPayloadType(unsigned char type, int freq) override;
 
--- a/media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h
+++ b/media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h
@@ -226,17 +226,17 @@ class MediaSessionConduit {
 
   virtual bool GetSendPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) = 0;
 
   virtual bool GetRecvPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) = 0;
 
   virtual bool GetRTPReceiverStats(unsigned int* jitterMs,
-                           unsigned int* cumulativeLost) = 0;
+                                   unsigned int* cumulativeLost) = 0;
   virtual bool GetRTCPReceiverReport(uint32_t* jitterMs,
                                      uint32_t* packetsReceived,
                                      uint64_t* bytesReceived,
                                      uint32_t* cumulativeLost,
                                      int32_t* rttMs) = 0;
   virtual bool GetRTCPSenderReport(unsigned int* packetsSent,
                                    uint64_t* bytesSent) = 0;
 
@@ -458,16 +458,17 @@ class VideoSessionConduit : public Media
                                     uint32_t* droppedFrames,
                                     uint32_t* framesEncoded,
                                     Maybe<uint64_t>* qpSum) = 0;
   virtual bool GetVideoDecoderStats(double* framerateMean,
                                     double* framerateStdDev,
                                     double* bitrateMean, double* bitrateStdDev,
                                     uint32_t* discardedPackets,
                                     uint32_t* framesDecoded) = 0;
+
  protected:
   /* RTCP feedback settings, for unit testing purposes */
   FrameRequestType mFrameRequestMethod;
   bool mUsingNackBasic;
   bool mUsingTmmbr;
   bool mUsingFEC;
 };
 
--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
@@ -1167,17 +1167,17 @@ bool WebrtcVideoConduit::GetVideoDecoder
   mRecvStreamStats.GetVideoStreamStats(*framerateMean, *framerateStdDev,
                                        *bitrateMean, *bitrateStdDev);
   *discardedPackets = mRecvStreamStats.DiscardedPackets();
   *framesDecoded = mRecvStreamStats.FramesDecoded();
   return true;
 }
 
 bool WebrtcVideoConduit::GetRTPReceiverStats(uint32_t* jitterMs,
-                                     uint32_t* packetsLost) {
+                                             uint32_t* packetsLost) {
   ASSERT_ON_THREAD(mStsThread);
 
   CSFLogVerbose(LOGTAG, "%s for VideoConduit:%p", __FUNCTION__, this);
   MutexAutoLock lock(mMutex);
   if (!mRecvStream) {
     return false;
   }
 
--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.h
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.h
@@ -258,17 +258,17 @@ class WebrtcVideoConduit
                             double* bitrateMean, double* bitrateStdDev,
                             uint32_t* droppedFrames, uint32_t* framesEncoded,
                             Maybe<uint64_t>* qpSum) override;
   bool GetVideoDecoderStats(double* framerateMean, double* framerateStdDev,
                             double* bitrateMean, double* bitrateStdDev,
                             uint32_t* discardedPackets,
                             uint32_t* framesDecoded) override;
   bool GetRTPReceiverStats(unsigned int* jitterMs,
-                   unsigned int* cumulativeLost) override;
+                           unsigned int* cumulativeLost) override;
   bool GetRTCPReceiverReport(uint32_t* jitterMs, uint32_t* packetsReceived,
                              uint64_t* bytesReceived, uint32_t* cumulativeLost,
                              int32_t* rttMs) override;
   bool GetRTCPSenderReport(unsigned int* packetsSent,
                            uint64_t* bytesSent) override;
   uint64_t MozVideoLatencyAvg();
 
   void DisableSsrcChanges() override {
--- a/media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
+++ b/media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
@@ -254,17 +254,17 @@ class VideoFrameConverter {
                 ("Creating a buffer for a black video frame failed"));
         return;
       }
 
       MOZ_LOG(gMediaPipelineLog, LogLevel::Debug,
               ("Sending a black video frame"));
       webrtc::I420Buffer::SetBlack(buffer);
 
-      webrtc::VideoFrame frame(buffer, 0, // not setting rtp timestamp
+      webrtc::VideoFrame frame(buffer, 0,  // not setting rtp timestamp
                                now, webrtc::kVideoRotation_0);
       VideoFrameConverted(frame);
       return;
     }
 
     MOZ_RELEASE_ASSERT(aImage, "Must have image if not forcing black");
     MOZ_ASSERT(aImage->GetSize() == aSize);
 
@@ -275,17 +275,17 @@ class VideoFrameConverter {
         rtc::scoped_refptr<webrtc::WrappedI420Buffer> video_frame_buffer(
             new rtc::RefCountedObject<webrtc::WrappedI420Buffer>(
                 aImage->GetSize().width, aImage->GetSize().height,
                 data->mYChannel, data->mYStride, data->mCbChannel,
                 data->mCbCrStride, data->mCrChannel, data->mCbCrStride,
                 rtc::KeepRefUntilDone(image)));
 
         webrtc::VideoFrame i420_frame(video_frame_buffer,
-                                      0, // not setting rtp timestamp
+                                      0,  // not setting rtp timestamp
                                       now, webrtc::kVideoRotation_0);
         MOZ_LOG(gMediaPipelineLog, LogLevel::Debug,
                 ("Sending an I420 video frame"));
         VideoFrameConverted(i420_frame);
         return;
       }
     }
 
@@ -306,17 +306,17 @@ class VideoFrameConverter {
                       buffer->MutableDataV(), buffer->StrideV());
 
     if (NS_FAILED(rv)) {
       MOZ_LOG(gMediaPipelineLog, LogLevel::Warning,
               ("Image conversion failed"));
       return;
     }
 
-    webrtc::VideoFrame frame(buffer, 0, //not setting rtp timestamp
+    webrtc::VideoFrame frame(buffer, 0,  // not setting rtp timestamp
                              now, webrtc::kVideoRotation_0);
     VideoFrameConverted(frame);
   }
 
   Atomic<int32_t, Relaxed> mLength;
   const RefPtr<TaskQueue> mTaskQueue;
   webrtc::I420BufferPool mBufferPool;
 
--- a/modules/libjar/nsJARChannel.cpp
+++ b/modules/libjar/nsJARChannel.cpp
@@ -1010,18 +1010,17 @@ nsJARChannel::OnStartRequest(nsIRequest 
           NS_ConvertUTF8toUTF16(contentType))) {
     return NS_ERROR_CORRUPTED_CONTENT;
   }
 
   return rv;
 }
 
 NS_IMETHODIMP
-nsJARChannel::OnStopRequest(nsIRequest *req,
-                            nsresult status) {
+nsJARChannel::OnStopRequest(nsIRequest *req, nsresult status) {
   LOG(("nsJARChannel::OnStopRequest [this=%p %s status=%" PRIx32 "]\n", this,
        mSpec.get(), static_cast<uint32_t>(status)));
 
   if (NS_SUCCEEDED(mStatus)) mStatus = status;
 
   if (mListener) {
     mListener->OnStopRequest(this, status);
     mListener = nullptr;
@@ -1041,19 +1040,18 @@ nsJARChannel::OnStopRequest(nsIRequest *
   // To deallocate file descriptor by RemoteOpenFileChild destructor.
   mJarFile = nullptr;
 #endif
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsJARChannel::OnDataAvailable(nsIRequest *req,
-                              nsIInputStream *stream, uint64_t offset,
-                              uint32_t count) {
+nsJARChannel::OnDataAvailable(nsIRequest *req, nsIInputStream *stream,
+                              uint64_t offset, uint32_t count) {
   LOG(("nsJARChannel::OnDataAvailable [this=%p %s]\n", this, mSpec.get()));
 
   nsresult rv;
 
   rv = mListener->OnDataAvailable(this, stream, offset, count);
 
   // simply report progress here instead of hooking ourselves up as a
   // nsITransportEventSink implementation.
--- a/modules/libjar/nsZipArchive.cpp
+++ b/modules/libjar/nsZipArchive.cpp
@@ -653,17 +653,17 @@ nsresult nsZipArchive::BuildFileList(PRF
     if (readaheadLength) {
 #if defined(XP_SOLARIS)
       posix_madvise(const_cast<uint8_t *>(startp), readaheadLength,
                     POSIX_MADV_WILLNEED);
 #elif defined(XP_UNIX)
       madvise(const_cast<uint8_t *>(startp), readaheadLength, MADV_WILLNEED);
 #elif defined(XP_WIN)
       static auto prefetchVirtualMemory =
-          reinterpret_cast<BOOL (WINAPI *)(HANDLE, ULONG_PTR, PVOID, ULONG)>(
+          reinterpret_cast<BOOL(WINAPI *)(HANDLE, ULONG_PTR, PVOID, ULONG)>(
               GetProcAddress(GetModuleHandle(L"kernel32.dll"),
                              "PrefetchVirtualMemory"));
       if (prefetchVirtualMemory) {
         // Normally, we'd use WIN32_MEMORY_RANGE_ENTRY, but that requires
         // a different _WIN32_WINNT value before including windows.h, but
         // that causes complications with unified sources. It's a simple
         // enough struct anyways.
         struct {
--- a/modules/libjar/zipwriter/nsDeflateConverter.cpp
+++ b/modules/libjar/zipwriter/nsDeflateConverter.cpp
@@ -155,18 +155,17 @@ nsresult nsDeflateConverter::PushAvailab
   if (bytesToWrite == 0) return NS_OK;
 
   MOZ_ASSERT(bytesToWrite <= INT32_MAX);
   nsCOMPtr<nsIInputStream> stream;
   nsresult rv = NS_NewByteInputStream(
       getter_AddRefs(stream), MakeSpan((char *)mWriteBuffer, bytesToWrite));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = mListener->OnDataAvailable(aRequest, stream, mOffset,
-                                  bytesToWrite);
+  rv = mListener->OnDataAvailable(aRequest, stream, mOffset, bytesToWrite);
 
   // now set the state for 'deflate'
   mZstream.next_out = mWriteBuffer;
   mZstream.avail_out = sizeof(mWriteBuffer);
 
   mOffset += bytesToWrite;
   return rv;
 }
--- a/modules/libjar/zipwriter/nsZipWriter.cpp
+++ b/modules/libjar/zipwriter/nsZipWriter.cpp
@@ -534,18 +534,17 @@ NS_IMETHODIMP nsZipWriter::ProcessQueue(
                                         nsISupports *aContext) {
   if (!mStream) return NS_ERROR_NOT_INITIALIZED;
   if (mInQueue) return NS_ERROR_IN_PROGRESS;
 
   mProcessObserver = aObserver;
   mProcessContext = aContext;
   mInQueue = true;
 
-  if (mProcessObserver)
-    mProcessObserver->OnStartRequest(nullptr);
+  if (mProcessObserver) mProcessObserver->OnStartRequest(nullptr);
 
   BeginProcessingNextItem();
 
   return NS_OK;
 }
 
 NS_IMETHODIMP nsZipWriter::Close() {
   if (!mStream) return NS_ERROR_NOT_INITIALIZED;
--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -2060,19 +2060,17 @@ nsPrefBranch::nsPrefBranch(const char* a
     ++mRefCnt;  // must be > 0 when we call this, or we'll get deleted!
 
     // Add weakly so we don't have to clean up at shutdown.
     observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
     --mRefCnt;
   }
 }
 
-nsPrefBranch::~nsPrefBranch() {
-  FreeObserverList();
-}
+nsPrefBranch::~nsPrefBranch() { FreeObserverList(); }
 
 NS_IMPL_ISUPPORTS(nsPrefBranch, nsIPrefBranch, nsIObserver,
                   nsISupportsWeakReference)
 
 NS_IMETHODIMP
 nsPrefBranch::GetRoot(nsACString& aRoot) {
   aRoot = mPrefRoot;
   return NS_OK;
@@ -5455,9 +5453,9 @@ NS_IMPL_COMPONENT_FACTORY(nsPrefLocalize
   }
   return nullptr;
 }
 
 namespace mozilla {
 
 void UnloadPrefsModule() { Preferences::Shutdown(); }
 
-}
+}  // namespace mozilla
--- a/mozglue/build/WindowsDllServices.h
+++ b/mozglue/build/WindowsDllServices.h
@@ -164,25 +164,23 @@ class DllServices : public detail::DllSe
   virtual void NotifyDllLoad(const bool aIsMainThread,
                              const nsString& aDllName) = 0;
 };
 
 #else
 
 class BasicDllServices final : public detail::DllServicesBase {
  public:
-  BasicDllServices() {
-    EnableBasic();
-  }
+  BasicDllServices() { EnableBasic(); }
 
   ~BasicDllServices() = default;
 
   // Not useful in this class, so provide a default implementation
-  virtual void DispatchDllLoadNotification(PCUNICODE_STRING aDllName) override
-      {}
+  virtual void DispatchDllLoadNotification(PCUNICODE_STRING aDllName) override {
+  }
 
   virtual void NotifyUntrustedModuleLoads(
       const Vector<glue::ModuleLoadEvent, 0, InfallibleAllocPolicy>& aEvents)
       override {}
 };
 
 #endif  // defined(MOZILLA_INTERNAL_API)
 
--- a/mozglue/misc/Debug.h
+++ b/mozglue/misc/Debug.h
@@ -12,23 +12,23 @@
  * e.g. mozglue, browser/app
  *
  * NB: printf_stderr() is in the global namespace, so include this file with
  * care; avoid including from header files.
  */
 
 #include <io.h>
 #if defined(XP_WIN)
-#include <windows.h>
+#  include <windows.h>
 #endif  // defined(XP_WIN)
 #include "mozilla/Attributes.h"
 #include "mozilla/Sprintf.h"
 
 #if defined(MOZILLA_INTERNAL_API)
-#error Do not include this file from XUL sources.
+#  error Do not include this file from XUL sources.
 #endif
 
 // Though this is a separate implementation than nsDebug's, we want to make the
 // declarations compatible to avoid confusing the linker if both headers are
 // included.
 #ifdef __cplusplus
 extern "C" {
 #endif  // __cplusplus
--- a/mozglue/misc/interceptor/PatcherBase.h
+++ b/mozglue/misc/interceptor/PatcherBase.h
@@ -26,27 +26,27 @@ class WindowsDllPatcherBase {
     ReadOnlyTargetFunction<MMPolicyT> origFn(mVMPolicy, aOriginalFunction);
 #if defined(_M_IX86) || defined(_M_X64)
     // If function entry is jmp rel8 stub to the internal implementation, we
     // resolve redirected address from the jump target.
     if (origFn[0] == 0xeb) {
       int8_t offset = (int8_t)(origFn[1]);
       uintptr_t abstarget = origFn.GetAddress() + 2 + offset;
 
-#if defined(_M_X64)
+#  if defined(_M_X64)
       // We redirect to the target of a short jump backwards if the target
       // is another jump (only 32-bit displacement is currently supported).
       // This case is used by GetFileAttributesW in Win7.
       if ((offset < 0) && (origFn.IsValidAtOffset(2 + offset))) {
         ReadOnlyTargetFunction<MMPolicyT> redirectFn(mVMPolicy, abstarget);
         if ((redirectFn[0] == 0xff) && (redirectFn[1] == 0x25)) {
           return redirectFn;
         }
       }
-#endif
+#  endif
 
       if (offset <= 0) {
         // Bail out for negative offset: probably already patched by some
         // third-party code.
         return origFn;
       }
 
       for (int8_t i = 0; i < offset; i++) {
@@ -54,37 +54,37 @@ class WindowsDllPatcherBase {
           // Bail out on insufficient nop space.
           return origFn;
         }
       }
 
       return EnsureTargetIsAccessible(std::move(origFn), abstarget);
     }
 
-#if defined(_M_IX86)
+#  if defined(_M_IX86)
     // If function entry is jmp [disp32] such as used by kernel32,
     // we resolve redirected address from import table.
     if (origFn[0] == 0xff && origFn[1] == 0x25) {
       uintptr_t abstarget = (origFn + 2).template ChasePointer<uintptr_t*>();
       return EnsureTargetIsAccessible(std::move(origFn), abstarget);
     }
-#elif defined(_M_X64)
+#  elif defined(_M_X64)
     // If function entry is jmp [disp32] such as used by kernel32,
     // we resolve redirected address from import table.
     if (origFn[0] == 0x48 && origFn[1] == 0xff && origFn[2] == 0x25) {
       uintptr_t abstarget = (origFn + 3).ChasePointerFromDisp();
       return EnsureTargetIsAccessible(std::move(origFn), abstarget);
     }
 
     if (origFn[0] == 0xe9) {
       // require for TestDllInterceptor with --disable-optimize
       uintptr_t abstarget = (origFn + 1).ReadDisp32AsAbsolute();
       return EnsureTargetIsAccessible(std::move(origFn), abstarget);
     }
-#endif
+#  endif
 #endif  // defined(_M_IX86) || defined(_M_X64)
 
     return origFn;
   }
 
  private:
   ReadOnlyTargetFunction<MMPolicyT> EnsureTargetIsAccessible(
       ReadOnlyTargetFunction<MMPolicyT> aOrigFn, uintptr_t aRedirAddress) {
--- a/mozglue/tests/interceptor/TestDllInterceptor.cpp
+++ b/mozglue/tests/interceptor/TestDllInterceptor.cpp
@@ -605,22 +605,22 @@ extern "C" int wmain(int argc, wchar_t* 
 #endif
 #if !defined(_M_ARM64)
       TEST_HOOK(ntdll.dll, NtCreateFile, NotEquals, 0) &&
       TEST_HOOK(ntdll.dll, NtReadFile, NotEquals, 0) &&
       TEST_HOOK(ntdll.dll, NtReadFileScatter, NotEquals, 0) &&
       TEST_HOOK(ntdll.dll, NtWriteFile, NotEquals, 0) &&
       TEST_HOOK(ntdll.dll, NtWriteFileGather, NotEquals, 0) &&
       TEST_HOOK(ntdll.dll, NtQueryFullAttributesFile, NotEquals, 0) &&
-#ifndef MOZ_ASAN
+#  ifndef MOZ_ASAN
       // Bug 733892: toolkit/crashreporter/nsExceptionHandler.cpp
       // This fails on ASan because the ASan runtime already hooked this
       // function
       TEST_HOOK(kernel32.dll, SetUnhandledExceptionFilter, Ignore, nullptr) &&
-#endif
+#  endif
 #endif
 #ifdef _M_IX86
       TEST_HOOK_FOR_INVALID_HANDLE_VALUE(kernel32.dll, CreateFileW) &&
 #endif
 #if !defined(_M_ARM64)
       TEST_HOOK_FOR_INVALID_HANDLE_VALUE(kernel32.dll, CreateFileA) &&
 #endif
       TEST_HOOK(kernelbase.dll, QueryDosDeviceW, Equals, 0) &&
@@ -677,18 +677,17 @@ extern "C" int wmain(int argc, wchar_t* 
 
       TEST_HOOK(sspicli.dll, AcquireCredentialsHandleA, NotEquals, SEC_E_OK) &&
       TEST_HOOK(sspicli.dll, QueryCredentialsAttributesA, NotEquals,
                 SEC_E_OK) &&
 #if !defined(_M_ARM64)
       TEST_HOOK(sspicli.dll, FreeCredentialsHandle, NotEquals, SEC_E_OK) &&
 #endif
       TEST_DETOUR_SKIP_EXEC(kernel32.dll, BaseThreadInitThunk) &&
-      TEST_DETOUR_SKIP_EXEC(ntdll.dll, LdrLoadDll) && TestTenByteDetour()
-      ) {
+      TEST_DETOUR_SKIP_EXEC(ntdll.dll, LdrLoadDll) && TestTenByteDetour()) {
     printf("TEST-PASS | WindowsDllInterceptor | all checks passed\n");
 
     LARGE_INTEGER end, freq;
     QueryPerformanceCounter(&end);
 
     QueryPerformanceFrequency(&freq);
 
     LARGE_INTEGER result;
--- a/netwerk/base/MemoryDownloader.cpp
+++ b/netwerk/base/MemoryDownloader.cpp
@@ -20,25 +20,25 @@ NS_IMETHODIMP
 MemoryDownloader::OnStartRequest(nsIRequest* aRequest) {
   MOZ_ASSERT(!mData);
   mData.reset(new FallibleTArray<uint8_t>());
   mStatus = NS_OK;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-MemoryDownloader::OnStopRequest(nsIRequest* aRequest,
-                                nsresult aStatus) {
+MemoryDownloader::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
   MOZ_ASSERT_IF(NS_FAILED(mStatus), NS_FAILED(aStatus));
   MOZ_ASSERT(!mData == NS_FAILED(mStatus));
   Data data;
   data.swap(mData);
   RefPtr<IObserver> observer;
   observer.swap(mObserver);
-  observer->OnDownloadComplete(this, aRequest, nullptr, aStatus, std::move(data));
+  observer->OnDownloadComplete(this, aRequest, nullptr, aStatus,
+                               std::move(data));
   return NS_OK;
 }
 
 nsresult MemoryDownloader::ConsumeData(nsIInputStream* aIn, void* aClosure,
                                        const char* aFromRawSegment,
                                        uint32_t aToOffset, uint32_t aCount,
                                        uint32_t* aWriteCount) {
   MemoryDownloader* self = static_cast<MemoryDownloader*>(aClosure);
@@ -48,18 +48,17 @@ nsresult MemoryDownloader::ConsumeData(n
     self->mStatus = NS_ERROR_OUT_OF_MEMORY;
     return NS_ERROR_OUT_OF_MEMORY;
   }
   *aWriteCount = aCount;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-MemoryDownloader::OnDataAvailable(nsIRequest* aRequest,
-                                  nsIInputStream* aInStr,
+MemoryDownloader::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInStr,
                                   uint64_t aSourceOffset, uint32_t aCount) {
   uint32_t n;
   MOZ_ASSERT(mData);
   nsresult rv = aInStr->ReadSegments(ConsumeData, this, aCount, &n);
   if (NS_SUCCEEDED(mStatus) && NS_FAILED(rv)) {
     mStatus = rv;
   }
   if (NS_WARN_IF(NS_FAILED(mStatus))) {
--- a/netwerk/base/SimpleChannelParent.cpp
+++ b/netwerk/base/SimpleChannelParent.cpp
@@ -80,18 +80,17 @@ NS_IMETHODIMP
 SimpleChannelParent::OnStartRequest(nsIRequest* aRequest) {
   // We don't have a way to prevent nsBaseChannel from calling AsyncOpen on
   // the created nsSimpleChannel. We don't have anywhere to send the data in the
   // parent, so abort the binding.
   return NS_BINDING_ABORTED;
 }
 
 NS_IMETHODIMP
-SimpleChannelParent::OnStopRequest(nsIRequest* aRequest,
-                                   nsresult aStatusCode) {
+SimpleChannelParent::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
   // See above.
   MOZ_ASSERT(NS_FAILED(aStatusCode));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 SimpleChannelParent::OnDataAvailable(nsIRequest* aRequest,
                                      nsIInputStream* aInputStream,
--- a/netwerk/base/mozurl/MozURL.cpp
+++ b/netwerk/base/mozurl/MozURL.cpp
@@ -4,10 +4,9 @@
 
 #include "mozilla/StaticPrefs.h"
 
 extern "C" {
 
 bool Gecko_StrictFileOriginPolicy() {
   return mozilla::StaticPrefs::security_fileuri_strict_origin_policy();
 }
-
 }
--- a/netwerk/base/nsBaseChannel.cpp
+++ b/netwerk/base/nsBaseChannel.cpp
@@ -760,18 +760,17 @@ nsBaseChannel::OnStartRequest(nsIRequest
   SUSPEND_PUMP_FOR_SCOPE();
 
   if (mListener)  // null in case of redirect
     return mListener->OnStartRequest(this);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsBaseChannel::OnStopRequest(nsIRequest *request,
-                             nsresult status) {
+nsBaseChannel::OnStopRequest(nsIRequest *request, nsresult status) {
   // If both mStatus and status are failure codes, we keep mStatus as-is since
   // that is consistent with our GetStatus and Cancel methods.
   if (NS_SUCCEEDED(mStatus)) mStatus = status;
 
   // Cause Pending to return false.
   mPump = nullptr;
   mRequest = nullptr;
   mPumpingData = false;
@@ -791,23 +790,21 @@ nsBaseChannel::OnStopRequest(nsIRequest 
 
   return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // nsBaseChannel::nsIStreamListener
 
 NS_IMETHODIMP
-nsBaseChannel::OnDataAvailable(nsIRequest *request,
-                               nsIInputStream *stream, uint64_t offset,
-                               uint32_t count) {
+nsBaseChannel::OnDataAvailable(nsIRequest *request, nsIInputStream *stream,
+                               uint64_t offset, uint32_t count) {
   SUSPEND_PUMP_FOR_SCOPE();
 
-  nsresult rv =
-      mListener->OnDataAvailable(this, stream, offset, count);
+  nsresult rv = mListener->OnDataAvailable(this, stream, offset, count);
   if (mSynthProgressEvents && NS_SUCCEEDED(rv)) {
     int64_t prog = offset + count;
     if (NS_IsMainThread()) {
       OnTransportStatus(nullptr, NS_NET_STATUS_READING, prog, mContentLength);
     } else {
       class OnTransportStatusAsyncEvent : public mozilla::Runnable {
         RefPtr<nsBaseChannel> mChannel;
         int64_t mProgress;
--- a/netwerk/base/nsBufferedStreams.cpp
+++ b/netwerk/base/nsBufferedStreams.cpp
@@ -595,20 +595,21 @@ void nsBufferedInputStream::Serialize(In
                                       FileDescriptorArray& aFileDescriptors,
                                       bool aDelayedStart, uint32_t aMaxSize,
                                       uint32_t* aSizeUsed,
                                       PBackgroundChild* aManager) {
   SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
                     aSizeUsed, aManager);
 }
 
-void nsBufferedInputStream::Serialize(
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::dom::ContentParent* aManager) {
+void nsBufferedInputStream::Serialize(InputStreamParams& aParams,
+                                      FileDescriptorArray& aFileDescriptors,
+                                      bool aDelayedStart, uint32_t aMaxSize,
+                                      uint32_t* aSizeUsed,
+                                      mozilla::dom::ContentParent* aManager) {
   SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
                     aSizeUsed, aManager);
 }
 
 void nsBufferedInputStream::Serialize(InputStreamParams& aParams,
                                       FileDescriptorArray& aFileDescriptors,
                                       bool aDelayedStart, uint32_t aMaxSize,
                                       uint32_t* aSizeUsed,
--- a/netwerk/base/nsDownloader.cpp
+++ b/netwerk/base/nsDownloader.cpp
@@ -62,18 +62,17 @@ nsDownloader::OnStartRequest(nsIRequest 
   // we could wrap this output stream with a buffered output stream,
   // but it shouldn't be necessary since we will be writing large
   // chunks given to us via OnDataAvailable.
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsDownloader::OnStopRequest(nsIRequest *request,
-                            nsresult status) {
+nsDownloader::OnStopRequest(nsIRequest *request, nsresult status) {
   if (mSink) {
     mSink->Close();
     mSink = nullptr;
   }
 
   mObserver->OnDownloadComplete(this, request, nullptr, status, mLocation);
   mObserver = nullptr;
 
@@ -87,14 +86,13 @@ nsresult nsDownloader::ConsumeData(nsIIn
   nsDownloader *self = (nsDownloader *)closure;
   if (self->mSink) return self->mSink->Write(fromRawSegment, count, writeCount);
 
   *writeCount = count;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsDownloader::OnDataAvailable(nsIRequest *request,
-                              nsIInputStream *inStr, uint64_t sourceOffset,
-                              uint32_t count) {
+nsDownloader::OnDataAvailable(nsIRequest *request, nsIInputStream *inStr,
+                              uint64_t sourceOffset, uint32_t count) {
   uint32_t n;
   return inStr->ReadSegments(ConsumeData, this, count, &n);
 }
--- a/netwerk/base/nsIncrementalDownload.cpp
+++ b/netwerk/base/nsIncrementalDownload.cpp
@@ -635,18 +635,17 @@ nsIncrementalDownload::OnStartRequest(ns
 
   mChunk = mozilla::MakeUniqueFallible<char[]>(mChunkSize);
   if (!mChunk) rv = NS_ERROR_OUT_OF_MEMORY;
 
   return rv;
 }
 
 NS_IMETHODIMP
-nsIncrementalDownload::OnStopRequest(nsIRequest *request,
-                                     nsresult status) {
+nsIncrementalDownload::OnStopRequest(nsIRequest *request, nsresult status) {
   // Not a real error; just a trick to kill off the channel without our
   // listener having to care.
   if (status == NS_ERROR_DOWNLOAD_NOT_PARTIAL) return NS_OK;
 
   // Not a real error; just a trick used to suppress OnDataAvailable calls.
   if (status == NS_ERROR_DOWNLOAD_COMPLETE) status = NS_OK;
 
   if (NS_SUCCEEDED(mStatus)) mStatus = status;
--- a/netwerk/base/nsInputStreamPump.cpp
+++ b/netwerk/base/nsInputStreamPump.cpp
@@ -546,18 +546,18 @@ uint32_t nsInputStreamPump::OnStateTrans
          "(%u)]\n",
          mStreamOffset, avail, odaAvail));
 
     {
       // Note: Must exit mutex for call to OnStartRequest to avoid
       // deadlocks when calls to RetargetDeliveryTo for multiple
       // nsInputStreamPumps are needed (e.g. nsHttpChannel).
       RecursiveMutexAutoUnlock unlock(mMutex);
-      rv = mListener->OnDataAvailable(this, mAsyncStream,
-                                      mStreamOffset, odaAvail);
+      rv = mListener->OnDataAvailable(this, mAsyncStream, mStreamOffset,
+                                      odaAvail);
     }
 
     // don't enter this code if ODA failed or called Cancel
     if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(mStatus)) {
       // test to see if this ODA failed to consume data
       if (tellable) {
         // NOTE: if Tell fails, which can happen if the stream is
         // now closed, then we assume that everything was read.
--- a/netwerk/base/nsProtocolProxyService.cpp
+++ b/netwerk/base/nsProtocolProxyService.cpp
@@ -1084,19 +1084,18 @@ bool nsProtocolProxyService::CanUseProxy
       NS_WARNING("unknown address family");
       return true;  // allow proxying
     }
   }
 
   // Don't use proxy for local hosts (plain hostname, no dots)
   if ((!is_ipaddr && mFilterLocalHosts && !host.Contains('.')) ||
       (!mAllowHijackingLocalhost &&
-           (host.EqualsLiteral("127.0.0.1") ||
-            host.EqualsLiteral("::1") ||
-            host.EqualsLiteral("localhost")))) {
+       (host.EqualsLiteral("127.0.0.1") || host.EqualsLiteral("::1") ||
+        host.EqualsLiteral("localhost")))) {
     LOG(("Not using proxy for this local host [%s]!\n", host.get()));
     return false;  // don't allow proxying
   }
 
   int32_t index = -1;
   while (++index < int32_t(mHostFiltersArray.Length())) {
     HostInfo *hinfo = mHostFiltersArray[index];
 
--- a/netwerk/base/nsRequestObserverProxy.cpp
+++ b/netwerk/base/nsRequestObserverProxy.cpp
@@ -127,18 +127,17 @@ nsRequestObserverProxy::OnStartRequest(n
 
   LOG(("post startevent=%p\n", ev));
   nsresult rv = FireEvent(ev);
   if (NS_FAILED(rv)) delete ev;
   return rv;
 }
 
 NS_IMETHODIMP
-nsRequestObserverProxy::OnStopRequest(nsIRequest *request,
-                                      nsresult status) {
+nsRequestObserverProxy::OnStopRequest(nsIRe