Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Fri, 15 Feb 2019 08:15:57 +0000
changeset 459503 a031c9dd9dd5d0d90ca56bfbe6c6ded1a2fadf44
parent 459502 bf504227f36241116e5d277e11f6bc2c3db1d53c
child 459504 539cfa77c2d24fe84b719e18fb7f78d4714deade
push id111964
push usercsabou@mozilla.com
push dateFri, 15 Feb 2019 18:54:44 +0000
treeherdermozilla-inbound@db3c4f905082 [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/D19663
docshell/base/nsDocShell.cpp
dom/base/Timeout.cpp
dom/base/nsFrameLoader.cpp
dom/canvas/CanvasRenderingContext2D.cpp
dom/canvas/WebGLExtensionDrawBuffers.cpp
dom/canvas/WebGLExtensionFragDepth.cpp
dom/events/EventStateManager.cpp
dom/html/HTMLLabelElement.cpp
dom/jsurl/nsJSProtocolHandler.cpp
dom/localstorage/ActorsParent.cpp
dom/media/ipc/RDDProcessHost.cpp
dom/media/mp4/MP4Demuxer.cpp
dom/media/systemservices/VideoFrameUtils.cpp
dom/media/webaudio/AudioContext.cpp
dom/media/webaudio/AudioParam.cpp
dom/security/ReferrerInfo.cpp
dom/security/ReferrerInfo.h
dom/webbrowserpersist/nsWebBrowserPersist.cpp
gfx/2d/DrawTargetDual.h
gfx/gl/GLContextProviderEGL.cpp
gfx/ipc/GPUProcessHost.cpp
gfx/layers/PersistentBufferProvider.cpp
gfx/layers/ipc/CompositorBridgeParent.cpp
gfx/layers/ipc/ImageBridgeChild.cpp
gfx/layers/wr/StackingContextHelper.cpp
gfx/layers/wr/WebRenderBridgeChild.cpp
gfx/thebes/gfxFontEntry.cpp
gfx/vr/gfxVRExternal.cpp
gfx/vr/gfxVRMutex.h
gfx/vr/service/VRService.cpp
gfx/webrender_bindings/RenderCompositor.cpp
gfx/webrender_bindings/RenderCompositorEGL.cpp
gfx/webrender_bindings/RenderCompositorEGL.h
gfx/webrender_bindings/WebRenderAPI.h
image/decoders/icon/mac/nsIconChannelCocoa.mm
image/decoders/icon/win/nsIconChannel.cpp
image/imgLoader.cpp
intl/l10n/DocumentL10n.cpp
ipc/chromium/src/chrome/common/ipc_channel_win.cc
js/public/Id.h
js/public/Value.h
js/src/builtin/ModuleObject.cpp
js/src/ctypes/CTypes.cpp
js/src/frontend/EitherParser.h
js/src/gc/AllocKind.h
js/src/gc/FindSCCs.h
js/src/gc/GC.cpp
js/src/gc/Marking-inl.h
js/src/gc/Marking.cpp
js/src/gc/Tracer.cpp
js/src/gc/Zone.h
js/src/jit/AtomicOperations.h
js/src/jit/MCallOptimize.cpp
js/src/jit/MacroAssembler.h
js/src/jit/arm/Assembler-arm.h
js/src/jit/arm/Lowering-arm.cpp
js/src/jit/arm64/CodeGenerator-arm64.cpp
js/src/jit/arm64/Lowering-arm64.cpp
js/src/jsapi-tests/testFindSCCs.cpp
js/src/vm/CodeCoverage.cpp
js/src/vm/Compartment.cpp
js/src/vm/Compartment.h
js/src/vm/TaggedProto.h
js/src/vm/Xdr.h
js/src/wasm/AsmJS.cpp
js/src/wasm/WasmBaselineCompile.cpp
js/src/wasm/WasmBuiltins.cpp
js/src/wasm/WasmCode.cpp
js/src/wasm/WasmInstance.cpp
js/src/wasm/WasmIonCompile.cpp
js/src/wasm/WasmJS.cpp
js/src/wasm/WasmTypes.cpp
js/src/wasm/WasmValidate.cpp
layout/base/PresShell.cpp
layout/base/nsRefreshDriver.h
layout/generic/ScrollAnchorContainer.cpp
layout/generic/nsTextFrame.cpp
layout/painting/nsDisplayList.cpp
layout/style/ComputedStyle.cpp
layout/style/ComputedStyle.h
media/mtransport/test/ice_unittest.cpp
media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
modules/libjar/nsJARChannel.cpp
netwerk/base/Predictor.cpp
netwerk/base/nsNetUtil.cpp
netwerk/dns/TRRService.cpp
netwerk/dns/TRRService.h
netwerk/protocol/http/HttpChannelChild.cpp
netwerk/protocol/http/TunnelUtils.cpp
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/res/ExtensionProtocolHandler.cpp
security/certverifier/NSSCertDBTrustDomain.h
toolkit/recordreplay/ProcessRewind.cpp
toolkit/recordreplay/ipc/ChildIPC.cpp
toolkit/recordreplay/ipc/ChildNavigation.cpp
toolkit/xre/nsGDKErrorHandler.cpp
tools/profiler/core/ProfilerMarkerPayload.cpp
widget/gtk/CompositorWidgetParent.cpp
widget/gtk/mozcontainer.cpp
widget/gtk/nsWindow.cpp
widget/windows/CompositorWidgetChild.h
widget/windows/CompositorWidgetParent.cpp
widget/windows/CompositorWidgetParent.h
widget/windows/WinCompositorWidget.cpp
widget/windows/WinCompositorWidget.h
widget/windows/WinCompositorWindowThread.cpp
widget/windows/WinCompositorWindowThread.h
xpcom/threads/SchedulerGroup.cpp
xpcom/threads/SchedulerGroup.h
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -8651,19 +8651,19 @@ nsresult nsDocShell::PerformRetargeting(
 
       return NS_ERROR_CONTENT_BLOCKED;
     }
   }
 
   if ((!targetDocShell || targetDocShell == static_cast<nsIDocShell*>(this))) {
     bool handled;
     rv = MaybeHandleLoadDelegate(aLoadState,
-                                 targetDocShell ?
-                                 nsIBrowserDOMWindow::OPEN_CURRENTWINDOW :
-                                 nsIBrowserDOMWindow::OPEN_NEWWINDOW,
+                                 targetDocShell
+                                     ? nsIBrowserDOMWindow::OPEN_CURRENTWINDOW
+                                     : nsIBrowserDOMWindow::OPEN_NEWWINDOW,
                                  &handled);
     if (NS_FAILED(rv)) {
       return rv;
     }
     if (handled) {
       return NS_OK;
     }
   }
@@ -8682,17 +8682,17 @@ nsresult nsDocShell::PerformRetargeting(
   if (!targetDocShell) {
     // If the docshell's document is sandboxed, only open a new window
     // if the document's SANDBOXED_AUXILLARY_NAVIGATION flag is not set.
     // (i.e. if allow-popups is specified)
     NS_ENSURE_TRUE(mContentViewer, NS_ERROR_FAILURE);
     Document* doc = mContentViewer->GetDocument();
 
     const bool isDocumentAuxSandboxed =
-      doc && (doc->GetSandboxFlags() & SANDBOXED_AUXILIARY_NAVIGATION);
+        doc && (doc->GetSandboxFlags() & SANDBOXED_AUXILIARY_NAVIGATION);
 
     if (isDocumentAuxSandboxed) {
       return NS_ERROR_DOM_INVALID_ACCESS_ERR;
     }
 
     nsCOMPtr<nsPIDOMWindowOuter> win = GetWindow();
     NS_ENSURE_TRUE(win, NS_ERROR_NOT_AVAILABLE);
 
--- a/dom/base/Timeout.cpp
+++ b/dom/base/Timeout.cpp
@@ -18,17 +18,18 @@ Timeout::Timeout()
 #ifdef DEBUG
       mFiringIndex(-1),
 #endif
       mPopupState(PopupBlocker::openAllowed),
       mReason(Reason::eTimeoutOrInterval),
       mNestingLevel(0),
       mCleared(false),
       mRunning(false),
-      mIsInterval(false) {}
+      mIsInterval(false) {
+}
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(Timeout)
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Timeout)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mScriptHandler)
   if (tmp->isInList()) {
     tmp->remove();
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -444,17 +444,16 @@ nsresult nsFrameLoader::ReallyStartLoadi
         if (iframeReferrerPolicy != net::RP_Unset) {
           referrerPolicy = iframeReferrerPolicy;
         }
       }
       loadState->SetReferrerInfo(new ReferrerInfo(referrer, referrerPolicy));
     }
   }
 
-
   // Default flags:
   int32_t flags = nsIWebNavigation::LOAD_FLAGS_NONE;
 
   // Flags for browser frame:
   if (OwnerIsMozBrowserFrame()) {
     flags = nsIWebNavigation::LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP |
             nsIWebNavigation::LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL;
   }
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -2586,17 +2586,17 @@ bool CanvasRenderingContext2D::ParseFilt
   }
 
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   if (!presShell) {
     aError.Throw(NS_ERROR_FAILURE);
     return false;
   }
 
-  nsAutoString usedFont; // unused
+  nsAutoString usedFont;  // unused
 
   RefPtr<ComputedStyle> parentStyle = GetFontStyleForServo(
       mCanvasElement, GetFont(), presShell, usedFont, aError);
   if (!parentStyle) {
     return false;
   }
 
   RefPtr<ComputedStyle> style =
--- a/dom/canvas/WebGLExtensionDrawBuffers.cpp
+++ b/dom/canvas/WebGLExtensionDrawBuffers.cpp
@@ -34,17 +34,18 @@ void WebGLExtensionDrawBuffers::DrawBuff
   mContext->DrawBuffers(buffers);
 }
 
 bool WebGLExtensionDrawBuffers::IsSupported(const WebGLContext* webgl) {
   if (webgl->IsWebGL2()) return false;
 
   gl::GLContext* gl = webgl->GL();
   if (gl->IsGLES() && gl->Version() >= 300) {
-    // ANGLE's shader translator can't translate ESSL1 exts to ESSL3. (bug 1524804)
+    // ANGLE's shader translator can't translate ESSL1 exts to ESSL3. (bug
+    // 1524804)
     return false;
   }
   return gl->IsSupported(gl::GLFeature::draw_buffers);
 }
 
 IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDrawBuffers, WEBGL_draw_buffers)
 
 }  // namespace mozilla
--- a/dom/canvas/WebGLExtensionFragDepth.cpp
+++ b/dom/canvas/WebGLExtensionFragDepth.cpp
@@ -18,17 +18,18 @@ WebGLExtensionFragDepth::WebGLExtensionF
 
 WebGLExtensionFragDepth::~WebGLExtensionFragDepth() {}
 
 bool WebGLExtensionFragDepth::IsSupported(const WebGLContext* webgl) {
   if (webgl->IsWebGL2()) return false;
 
   gl::GLContext* gl = webgl->GL();
   if (gl->IsGLES() && gl->Version() >= 300) {
-    // ANGLE's shader translator can't translate ESSL1 exts to ESSL3. (bug 1524804)
+    // ANGLE's shader translator can't translate ESSL1 exts to ESSL3. (bug
+    // 1524804)
     return false;
   }
   return gl->IsSupported(gl::GLFeature::frag_depth);
 }
 
 IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionFragDepth, EXT_frag_depth)
 
 }  // namespace mozilla
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -3684,17 +3684,17 @@ static bool ShouldBlockCustomCursor(nsPr
   }
 
   // We don't want to deal with iframes, just let them do their thing unless
   // they intersect UI.
   //
   // TODO(emilio, bug 1525561): In a fission world, we should have a better way
   // to find the event coordinates relative to the content area.
   nsPresContext* topLevel =
-    aPresContext->GetToplevelContentDocumentPresContext();
+      aPresContext->GetToplevelContentDocumentPresContext();
   if (!topLevel) {
     return false;
   }
 
   nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
       aEvent, topLevel->PresShell()->GetRootFrame());
 
   nsSize size(CSSPixel::ToAppUnits(width), CSSPixel::ToAppUnits(height));
--- a/dom/html/HTMLLabelElement.cpp
+++ b/dom/html/HTMLLabelElement.cpp
@@ -68,18 +68,18 @@ nsresult HTMLLabelElement::PostHandleEve
        aVisitor.mEvent->mMessage != eMouseDown) ||
       aVisitor.mEventStatus == nsEventStatus_eConsumeNoDefault ||
       !aVisitor.mPresContext ||
       // Don't handle the event if it's already been handled by another label
       aVisitor.mEvent->mFlags.mMultipleActionsPrevented) {
     return NS_OK;
   }
 
-  nsCOMPtr<Element> target = do_QueryInterface(
-      aVisitor.mEvent->GetOriginalDOMEventTarget());
+  nsCOMPtr<Element> target =
+      do_QueryInterface(aVisitor.mEvent->GetOriginalDOMEventTarget());
   if (nsContentUtils::IsInInteractiveHTMLContent(target, this)) {
     return NS_OK;
   }
 
   // Strong ref because event dispatch is going to happen.
   RefPtr<Element> content = GetLabeledElement();
 
   if (content) {
--- a/dom/jsurl/nsJSProtocolHandler.cpp
+++ b/dom/jsurl/nsJSProtocolHandler.cpp
@@ -486,24 +486,23 @@ nsJSChannel::GetURI(nsIURI** aURI) { ret
 
 NS_IMETHODIMP
 nsJSChannel::Open(nsIInputStream** aStream) {
   nsCOMPtr<nsIStreamListener> listener;
   nsresult rv =
       nsContentSecurityManager::doContentSecurityCheck(this, listener);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = mIOThunk->EvaluateScript(
-      mStreamChannel, mPopupState, mExecutionPolicy, mOriginalInnerWindow);
+  rv = mIOThunk->EvaluateScript(mStreamChannel, mPopupState, mExecutionPolicy,
+                                mOriginalInnerWindow);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return mStreamChannel->Open(aStream);
 }
 
-
 NS_IMETHODIMP
 nsJSChannel::AsyncOpen(nsIStreamListener* aListener) {
   NS_ENSURE_ARG(aListener);
 
   nsCOMPtr<nsIStreamListener> listener = aListener;
   nsresult rv =
       nsContentSecurityManager::doContentSecurityCheck(this, listener);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -610,18 +609,17 @@ nsJSChannel::AsyncOpen(nsIStreamListener
     // it asynchronously.
     method = &nsJSChannel::NotifyListener;
     name = "nsJSChannel::NotifyListener";
   }
 
   nsCOMPtr<nsIRunnable> runnable =
       mozilla::NewRunnableMethod(name, this, method);
   nsGlobalWindowInner* window = nsGlobalWindowInner::Cast(mOriginalInnerWindow);
-  rv =
-      window->Dispatch(mozilla::TaskCategory::Other, runnable.forget());
+  rv = window->Dispatch(mozilla::TaskCategory::Other, runnable.forget());
 
   if (NS_FAILED(rv)) {
     loadGroup->RemoveRequest(this, nullptr, rv);
     mIsActive = false;
     CleanupStrongRefs();
   }
   return rv;
 }
--- a/dom/localstorage/ActorsParent.cpp
+++ b/dom/localstorage/ActorsParent.cpp
@@ -3132,18 +3132,18 @@ PBackgroundLSRequestParent* AllocPBackgr
     case LSRequestParams::TLSRequestPrepareDatastoreParams: {
       Maybe<ContentParentId> contentParentId;
 
       uint64_t childID = BackgroundParent::GetChildID(aBackgroundActor);
       if (childID) {
         contentParentId = Some(ContentParentId(childID));
       }
 
-      RefPtr<PrepareDatastoreOp> prepareDatastoreOp = new PrepareDatastoreOp(
-          mainEventTarget, aParams, contentParentId);
+      RefPtr<PrepareDatastoreOp> prepareDatastoreOp =
+          new PrepareDatastoreOp(mainEventTarget, aParams, contentParentId);
 
       if (!gPrepareDatastoreOps) {
         gPrepareDatastoreOps = new PrepareDatastoreOpArray();
       }
       gPrepareDatastoreOps->AppendElement(prepareDatastoreOp);
 
       actor = std::move(prepareDatastoreOp);
 
@@ -5577,18 +5577,17 @@ mozilla::ipc::IPCResult LSRequestBase::R
   return IPC_OK();
 }
 
 /*******************************************************************************
  * PrepareDatastoreOp
  ******************************************************************************/
 
 PrepareDatastoreOp::PrepareDatastoreOp(
-    nsIEventTarget* aMainEventTarget,
-    const LSRequestParams& aParams,
+    nsIEventTarget* aMainEventTarget, const LSRequestParams& aParams,
     const Maybe<ContentParentId>& aContentParentId)
     : LSRequestBase(aMainEventTarget),
       mMainEventTarget(aMainEventTarget),
       mLoadDataOp(nullptr),
       mParams(aParams.get_LSRequestPrepareDatastoreParams()),
       mContentParentId(aContentParentId),
       mPrivateBrowsingId(0),
       mUsage(0),
--- a/dom/media/ipc/RDDProcessHost.cpp
+++ b/dom/media/ipc/RDDProcessHost.cpp
@@ -200,13 +200,13 @@ void RDDProcessHost::KillProcess() { Kil
 void RDDProcessHost::DestroyProcess() {
   // Cancel all tasks. We don't want anything triggering after our caller
   // expects this to go away.
   {
     MonitorAutoLock lock(mMonitor);
     mTaskFactory.RevokeAll();
   }
 
-  MessageLoop::current()->PostTask(NS_NewRunnableFunction(
-      "DestroyProcessRunnable", [this] { Destroy(); }));
+  MessageLoop::current()->PostTask(
+      NS_NewRunnableFunction("DestroyProcessRunnable", [this] { Destroy(); }));
 }
 
 }  // namespace mozilla
--- a/dom/media/mp4/MP4Demuxer.cpp
+++ b/dom/media/mp4/MP4Demuxer.cpp
@@ -69,21 +69,17 @@ class MP4TrackDemuxer : public MediaTrac
   UniquePtr<TrackInfo> mInfo;
   RefPtr<Index> mIndex;
   UniquePtr<SampleIterator> mIterator;
   Maybe<media::TimeUnit> mNextKeyframeTime;
   // Queued samples extracted by the demuxer, but not yet returned.
   RefPtr<MediaRawData> mQueuedSample;
   bool mNeedReIndex;
   bool mNeedSPSForTelemetry;
-  enum CodecType {
-    kH264,
-    kVP9,
-    kOther
-  } mType = kOther;
+  enum CodecType { kH264, kVP9, kOther } mType = kOther;
 };
 
 // Returns true if no SPS was found and search for it should continue.
 bool AccumulateSPSTelemetry(const MediaByteBuffer* aExtradata) {
   SPSData spsdata;
   if (H264::DecodeSPSFromExtraData(aExtradata, spsdata)) {
     uint8_t constraints = (spsdata.constraint_set0_flag ? (1 << 0) : 0) |
                           (spsdata.constraint_set1_flag ? (1 << 1) : 0) |
--- a/dom/media/systemservices/VideoFrameUtils.cpp
+++ b/dom/media/systemservices/VideoFrameUtils.cpp
@@ -9,18 +9,19 @@
 #include "mozilla/ShmemPool.h"
 
 namespace mozilla {
 
 uint32_t VideoFrameUtils::TotalRequiredBufferSize(
     const webrtc::VideoFrame& aVideoFrame) {
   auto i420 = aVideoFrame.video_frame_buffer()->ToI420();
   auto height = i420->height();
-  size_t size = height * i420->StrideY() + ((height + 1) / 2) * i420->StrideU() +
-         ((height + 1) / 2) * i420->StrideV();
+  size_t size = height * i420->StrideY() +
+                ((height + 1) / 2) * i420->StrideU() +
+                ((height + 1) / 2) * i420->StrideV();
   MOZ_RELEASE_ASSERT(size < std::numeric_limits<uint32_t>::max());
   return static_cast<uint32_t>(size);
 }
 
 void VideoFrameUtils::InitFrameBufferProperties(
     const webrtc::VideoFrame& aVideoFrame,
     camera::VideoFrameProperties& aDestProps) {
   // The VideoFrameBuffer image data stored in the accompanying buffer
--- a/dom/media/webaudio/AudioContext.cpp
+++ b/dom/media/webaudio/AudioContext.cpp
@@ -533,18 +533,18 @@ Worklet* AudioContext::GetAudioWorklet(E
 }
 
 bool AudioContext::IsRunning() const {
   return mAudioContextState == AudioContextState::Running;
 }
 
 already_AddRefed<Promise> AudioContext::DecodeAudioData(
     const ArrayBuffer& aBuffer,
-    const Optional<OwningNonNull<DecodeSuccessCallback> >& aSuccessCallback,
-    const Optional<OwningNonNull<DecodeErrorCallback> >& aFailureCallback,
+    const Optional<OwningNonNull<DecodeSuccessCallback>>& aSuccessCallback,
+    const Optional<OwningNonNull<DecodeErrorCallback>>& aFailureCallback,
     ErrorResult& aRv) {
   nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());
   RefPtr<Promise> promise;
   AutoJSAPI jsapi;
   jsapi.Init();
   JSContext* cx = jsapi.cx();
 
   // CheckedUnwrapStatic is OK, since we know we have an ArrayBuffer.
--- a/dom/media/webaudio/AudioParam.cpp
+++ b/dom/media/webaudio/AudioParam.cpp
@@ -67,19 +67,17 @@ void AudioParam::DisconnectFromGraphAndD
   }
 
   if (mStream) {
     mStream->Destroy();
     mStream = nullptr;
   }
 }
 
-MediaStream* AudioParam::GetStream() const {
-  return mStream;
-}
+MediaStream* AudioParam::GetStream() const { return mStream; }
 
 MediaStream* AudioParam::Stream() {
   if (mStream) {
     return mStream;
   }
 
   AudioNodeEngine* engine = new AudioNodeEngine(nullptr);
   mStream = AudioNodeStream::Create(mNode->Context(), engine,
--- a/dom/security/ReferrerInfo.cpp
+++ b/dom/security/ReferrerInfo.cpp
@@ -13,18 +13,17 @@ namespace mozilla {
 namespace dom {
 
 // Implementation of ClassInfo is required to serialize/deserialize
 NS_IMPL_CLASSINFO(ReferrerInfo, nullptr, nsIClassInfo::MAIN_THREAD_ONLY,
                   REFERRERINFO_CID)
 
 NS_IMPL_ISUPPORTS_CI(ReferrerInfo, nsIReferrerInfo, nsISerializable)
 
-ReferrerInfo::ReferrerInfo(nsIURI* aOriginalReferrer,
-                           uint32_t aPolicy,
+ReferrerInfo::ReferrerInfo(nsIURI* aOriginalReferrer, uint32_t aPolicy,
                            bool aSendReferrer)
     : mOriginalReferrer(aOriginalReferrer),
       mPolicy(aPolicy),
       mSendReferrer(aSendReferrer) {}
 
 NS_IMETHODIMP
 ReferrerInfo::GetOriginalReferrer(nsIURI** aOriginalReferrer) {
   *aOriginalReferrer = mOriginalReferrer;
@@ -52,18 +51,17 @@ ReferrerInfo::GetSendReferrer(bool* aSen
 
 NS_IMETHODIMP
 ReferrerInfo::SetSendReferrer(bool aSendReferrer) {
   mSendReferrer = aSendReferrer;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-ReferrerInfo::Init(uint32_t aReferrerPolicy,
-                   bool aSendReferrer,
+ReferrerInfo::Init(uint32_t aReferrerPolicy, bool aSendReferrer,
                    nsIURI* aOriginalReferrer) {
   mPolicy = aReferrerPolicy;
   mSendReferrer = aSendReferrer;
   mOriginalReferrer = aOriginalReferrer;
   return NS_OK;
 }
 
 /* ===== nsISerializable implementation ====== */
--- a/dom/security/ReferrerInfo.h
+++ b/dom/security/ReferrerInfo.h
@@ -29,22 +29,21 @@ namespace dom {
 
 /**
  * ReferrerInfo class holds a original referrer URL, as well as the referrer
  * policy to be applied to this referrer.
  *
  **/
 class ReferrerInfo : public nsIReferrerInfo {
  public:
-  ReferrerInfo () = default;
+  ReferrerInfo() = default;
   explicit ReferrerInfo(nsIURI* aOriginalReferrer,
                         uint32_t aPolicy = mozilla::net::RP_Unset,
                         bool aSendReferrer = true);
 
-
   NS_DECL_ISUPPORTS
   NS_DECL_NSIREFERRERINFO
   NS_DECL_NSISERIALIZABLE
 
  private:
   virtual ~ReferrerInfo() {}
 
   nsCOMPtr<nsIURI> mOriginalReferrer;
--- a/dom/webbrowserpersist/nsWebBrowserPersist.cpp
+++ b/dom/webbrowserpersist/nsWebBrowserPersist.cpp
@@ -1334,18 +1334,18 @@ nsresult nsWebBrowserPersist::SaveChanne
   // special-cases a file target and creates a file output stream directly.
   // We want to special-case a file source and create a file input stream,
   // but we don't need to do this in the case of a file target.
   nsCOMPtr<nsIFileChannel> fc(do_QueryInterface(aChannel));
   nsCOMPtr<nsIFileURL> fu(do_QueryInterface(aFile));
 
   if (fc && !fu) {
     nsCOMPtr<nsIInputStream> fileInputStream, bufferedInputStream;
-    nsresult rv = NS_MaybeOpenChannelUsingOpen(
-        aChannel, getter_AddRefs(fileInputStream));
+    nsresult rv =
+        NS_MaybeOpenChannelUsingOpen(aChannel, getter_AddRefs(fileInputStream));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = NS_NewBufferedInputStream(getter_AddRefs(bufferedInputStream),
                                    fileInputStream.forget(),
                                    BUFFERED_OUTPUT_SIZE);
     NS_ENSURE_SUCCESS(rv, rv);
     nsAutoCString contentType;
     aChannel->GetContentType(contentType);
     return StartUpload(bufferedInputStream, aFile, contentType);
--- a/gfx/2d/DrawTargetDual.h
+++ b/gfx/2d/DrawTargetDual.h
@@ -36,17 +36,19 @@ namespace gfx {
  * to the first destination DrawTarget (mA) and the snapshot of the second
  * source DrawTarget is used at the source for the second destination
  * DrawTarget (mB). This class facilitates black-background/white-background
  * drawing for per-component alpha extraction for backends which do not support
  * native component alpha.
  */
 class DrawTargetDual : public DrawTarget {
  public:
-  virtual bool IsValid() const override { return mA->IsValid() && mB->IsValid(); };
+  virtual bool IsValid() const override {
+    return mA->IsValid() && mB->IsValid();
+  };
 
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetDual, override)
   DrawTargetDual(DrawTarget *aA, DrawTarget *aB) : mA(aA), mB(aB) {
     mFormat = aA->GetFormat();
   }
 
   virtual DrawTargetType GetType() const override { return mA->GetType(); }
   virtual BackendType GetBackendType() const override {
--- a/gfx/gl/GLContextProviderEGL.cpp
+++ b/gfx/gl/GLContextProviderEGL.cpp
@@ -301,22 +301,24 @@ already_AddRefed<GLContext> GLContextEGL
     widget::CompositorWidget* aCompositorWidget, bool aForceAccelerated) {
   nsCString discardFailureId;
   if (!GLLibraryEGL::EnsureInitialized(false, &discardFailureId)) {
     gfxCriticalNote << "Failed to load EGL library 6!";
     return EGL_NO_SURFACE;
   }
 
   MOZ_ASSERT(aCompositorWidget);
-  EGLNativeWindowType window = GET_NATIVE_WINDOW_FROM_COMPOSITOR_WIDGET(aCompositorWidget);
+  EGLNativeWindowType window =
+      GET_NATIVE_WINDOW_FROM_COMPOSITOR_WIDGET(aCompositorWidget);
   if (!window) {
     gfxCriticalNote << "window is null";
     return EGL_NO_SURFACE;
   }
-  const bool useWebRender = aCompositorWidget->GetCompositorOptions().UseWebRender();
+  const bool useWebRender =
+      aCompositorWidget->GetCompositorOptions().UseWebRender();
 
   EGLConfig config;
   if (!CreateConfig(&config, useWebRender)) {
     gfxCriticalNote << "Failed to create EGLConfig!";
     return EGL_NO_SURFACE;
   }
 
   return mozilla::gl::CreateSurfaceFromNativeWindow(window, config);
--- a/gfx/ipc/GPUProcessHost.cpp
+++ b/gfx/ipc/GPUProcessHost.cpp
@@ -207,14 +207,14 @@ void GPUProcessHost::KillProcess() { Kil
 void GPUProcessHost::DestroyProcess() {
   // Cancel all tasks. We don't want anything triggering after our caller
   // expects this to go away.
   {
     MonitorAutoLock lock(mMonitor);
     mTaskFactory.RevokeAll();
   }
 
-  MessageLoop::current()->PostTask(NS_NewRunnableFunction(
-      "DestroyProcessRunnable", [this] { Destroy(); }));
+  MessageLoop::current()->PostTask(
+      NS_NewRunnableFunction("DestroyProcessRunnable", [this] { Destroy(); }));
 }
 
 }  // namespace gfx
 }  // namespace mozilla
--- a/gfx/layers/PersistentBufferProvider.cpp
+++ b/gfx/layers/PersistentBufferProvider.cpp
@@ -73,18 +73,18 @@ already_AddRefed<PersistentBufferProvide
 PersistentBufferProviderBasic::Create(gfx::IntSize aSize,
                                       gfx::SurfaceFormat aFormat,
                                       gfx::BackendType aBackend) {
   RefPtr<DrawTarget> dt =
       gfxPlatform::GetPlatform()->CreateDrawTargetForBackend(aBackend, aSize,
                                                              aFormat);
 
   if (dt) {
-    // This is simply to ensure the DrawTarget gets initialized, and will detect a
-    // device reset, even if we're on the main thread.
+    // This is simply to ensure the DrawTarget gets initialized, and will detect
+    // a device reset, even if we're on the main thread.
     dt->ClearRect(Rect(0, 0, 0, 0));
   }
 
   if (!dt || !dt->IsValid()) {
     return nullptr;
   }
 
   RefPtr<PersistentBufferProviderBasic> provider =
@@ -341,18 +341,18 @@ PersistentBufferProviderShared::BorrowDr
 
       previous->Unlock();
     }
   }
 
   mDrawTarget = tex->BorrowDrawTarget();
 
   if (mDrawTarget) {
-    // This is simply to ensure the DrawTarget gets initialized, and will detect a
-    // device reset, even if we're on the main thread.
+    // This is simply to ensure the DrawTarget gets initialized, and will detect
+    // a device reset, even if we're on the main thread.
     mDrawTarget->ClearRect(Rect(0, 0, 0, 0));
 
     if (!mDrawTarget->IsValid()) {
       mDrawTarget = nullptr;
     }
   }
 
   RefPtr<gfx::DrawTarget> dt(mDrawTarget);
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -1727,21 +1727,21 @@ PWebRenderBridgeParent* CompositorBridge
   MOZ_RELEASE_ASSERT(false);
 #endif
   MOZ_ASSERT(wr::AsLayersId(aPipelineId) == mRootLayerTreeID);
   MOZ_ASSERT(!mWrBridge);
   MOZ_ASSERT(!mCompositor);
   MOZ_ASSERT(!mCompositorScheduler);
   MOZ_ASSERT(mWidget);
 
-#  ifdef XP_WIN
+#ifdef XP_WIN
   if (mWidget && DeviceManagerDx::Get()->CanUseDComp()) {
     mWidget->AsWindows()->EnsureCompositorWindow();
   }
-#  endif
+#endif
 
   RefPtr<widget::CompositorWidget> widget = mWidget;
   wr::WrWindowId windowId = wr::NewWindowId();
   if (mApzUpdater) {
     // If APZ is enabled, we need to register the APZ updater with the window id
     // before the updater thread is created in WebRenderAPI::Create, so
     // that the callback from the updater thread can find the right APZUpdater.
     mApzUpdater->SetWebRenderWindowId(windowId);
--- a/gfx/layers/ipc/ImageBridgeChild.cpp
+++ b/gfx/layers/ipc/ImageBridgeChild.cpp
@@ -618,22 +618,24 @@ void ImageBridgeChild::UpdateTextureFact
   // ImageHost is incompatible between WebRender enabled and WebRender disabled.
   // Then drop all ImageContainers' ImageClients during disabling WebRender.
   bool disablingWebRender =
       GetCompositorBackendType() == LayersBackend::LAYERS_WR &&
       aIdentifier.mParentBackend != LayersBackend::LAYERS_WR;
   // D3DTexture might become obsolte. To prevent to use obsoleted D3DTexture,
   // drop all ImageContainers' ImageClients.
 
-  // During re-creating GPU process, there was a period that ImageBridgeChild was
-  // re-created, but ImageBridgeChild::UpdateTextureFactoryIdentifier() was not
-  // called yet. In the period, if ImageBridgeChild::CreateImageClient() is called,
-  // ImageBridgeParent creates incompatible ImageHost than WebRenderImageHost.
-  bool initializingWebRender = GetCompositorBackendType() != LayersBackend::LAYERS_WR &&
-                               aIdentifier.mParentBackend == LayersBackend::LAYERS_WR;
+  // During re-creating GPU process, there was a period that ImageBridgeChild
+  // was re-created, but ImageBridgeChild::UpdateTextureFactoryIdentifier() was
+  // not called yet. In the period, if ImageBridgeChild::CreateImageClient() is
+  // called, ImageBridgeParent creates incompatible ImageHost than
+  // WebRenderImageHost.
+  bool initializingWebRender =
+      GetCompositorBackendType() != LayersBackend::LAYERS_WR &&
+      aIdentifier.mParentBackend == LayersBackend::LAYERS_WR;
 
   bool needsDrop = disablingWebRender || initializingWebRender;
 
 #if defined(XP_WIN)
   RefPtr<ID3D11Device> device = gfx::DeviceManagerDx::Get()->GetImageDevice();
   needsDrop |= !!mImageDevice && mImageDevice != device &&
                GetCompositorBackendType() == LayersBackend::LAYERS_D3D11;
   mImageDevice = device;
--- a/gfx/layers/wr/StackingContextHelper.cpp
+++ b/gfx/layers/wr/StackingContextHelper.cpp
@@ -25,17 +25,18 @@ StackingContextHelper::StackingContextHe
     const StackingContextHelper& aParentSC, const ActiveScrolledRoot* aAsr,
     nsIFrame* aContainerFrame, nsDisplayItem* aContainerItem,
     wr::DisplayListBuilder& aBuilder, const wr::StackingContextParams& aParams,
     const LayoutDeviceRect& aBounds)
     : mBuilder(&aBuilder),
       mScale(1.0f, 1.0f),
       mDeferredTransformItem(aParams.mDeferredTransformItem),
       mIsPreserve3D(aParams.transform_style == wr::TransformStyle::Preserve3D),
-      mRasterizeLocally(aParams.mRasterizeLocally || aParentSC.mRasterizeLocally) {
+      mRasterizeLocally(aParams.mRasterizeLocally ||
+                        aParentSC.mRasterizeLocally) {
   // Compute scale for fallback rendering. We don't try to guess a scale for 3d
   // transformed items
   gfx::Matrix transform2d;
   if (aParams.mBoundTransform &&
       aParams.mBoundTransform->CanDraw2D(&transform2d) &&
       aParams.reference_frame_kind != wr::WrReferenceFrameKind::Perspective &&
       !aParentSC.mIsPreserve3D) {
     mInheritedTransform = transform2d * aParentSC.mInheritedTransform;
--- a/gfx/layers/wr/WebRenderBridgeChild.cpp
+++ b/gfx/layers/wr/WebRenderBridgeChild.cpp
@@ -273,18 +273,18 @@ Maybe<wr::FontInstanceKey> WebRenderBrid
 
   Maybe<wr::FontInstanceOptions> options;
   Maybe<wr::FontInstancePlatformOptions> platformOptions;
   std::vector<FontVariation> variations;
   aScaledFont->GetWRFontInstanceOptions(&options, &platformOptions,
                                         &variations);
 
   aResources->AddFontInstance(
-      instanceKey, fontKey.value(), aScaledFont->GetSize(), options.ptrOr(nullptr),
-      platformOptions.ptrOr(nullptr),
+      instanceKey, fontKey.value(), aScaledFont->GetSize(),
+      options.ptrOr(nullptr), platformOptions.ptrOr(nullptr),
       Range<const FontVariation>(variations.data(), variations.size()));
   if (resources.isSome()) {
     UpdateResources(resources.ref());
   }
 
   mFontInstanceKeys.Put(aScaledFont, instanceKey);
 
   return Some(instanceKey);
--- a/gfx/thebes/gfxFontEntry.cpp
+++ b/gfx/thebes/gfxFontEntry.cpp
@@ -1704,17 +1704,17 @@ void gfxFontFamily::FindFontForChar(Glob
   if (profiler_is_active()) {
     charAndName = nsPrintfCString("\\u%x %s", aMatchData->mCh, mName.get());
   }
 
   AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING("gfxFontFamily::FindFontForChar",
                                         LAYOUT, charAndName);
 #endif
 
-  AutoTArray<gfxFontEntry*,4> entries;
+  AutoTArray<gfxFontEntry*, 4> entries;
   FindAllFontsForStyle(aMatchData->mStyle, entries,
                        /*aIgnoreSizeTolerance*/ true);
   if (entries.IsEmpty()) {
     return;
   }
 
   gfxFontEntry* fe = nullptr;
   float distance = INFINITY;
@@ -1731,18 +1731,17 @@ void gfxFontFamily::FindFontForChar(Glob
       LogModule* log = gfxPlatform::GetLog(eGfxLog_textrun);
 
       if (MOZ_UNLIKELY(MOZ_LOG_TEST(log, LogLevel::Debug))) {
         uint32_t unicodeRange = FindCharUnicodeRange(aMatchData->mCh);
         Script script = GetScriptCode(aMatchData->mCh);
         MOZ_LOG(log, LogLevel::Debug,
                 ("(textrun-systemfallback-fonts) char: u+%6.6x "
                  "unicode-range: %d script: %d match: [%s]\n",
-                 aMatchData->mCh, unicodeRange, int(script),
-                 e->Name().get()));
+                 aMatchData->mCh, unicodeRange, int(script), e->Name().get()));
       }
 
       fe = e;
       distance = WeightStyleStretchDistance(fe, aMatchData->mStyle);
       break;
     }
   }
 
--- a/gfx/vr/gfxVRExternal.cpp
+++ b/gfx/vr/gfxVRExternal.cpp
@@ -441,32 +441,32 @@ VRSystemManagerExternal::VRSystemManager
   mShmemFile = NULL;
 #elif defined(MOZ_WIDGET_ANDROID)
   mExternalStructFailed = false;
   mEnumerationCompleted = false;
 #endif
   mDoShutdown = false;
 
 #if defined(XP_WIN)
-  mMutex = CreateMutex(
-    NULL,                   // default security descriptor
-    false,                  // mutex not owned
-    TEXT("mozilla::vr::ShmemMutex"));  // object name
+  mMutex = CreateMutex(NULL,   // default security descriptor
+                       false,  // mutex not owned
+                       TEXT("mozilla::vr::ShmemMutex"));  // object name
 
   if (mMutex == NULL) {
     nsAutoCString msg;
     msg.AppendPrintf("VRSystemManagerExternal CreateMutex error \"%lu\".",
-                      GetLastError());
+                     GetLastError());
     NS_WARNING(msg.get());
     MOZ_ASSERT(false);
     return;
   }
-  // At xpcshell extension tests, it creates multiple VRSystemManagerExternal instances
-  // in plug-contrainer.exe. It causes GetLastError() return `ERROR_ALREADY_EXISTS`.
-  // However, even though `ERROR_ALREADY_EXISTS`, it still returns the same mutex handle.
+  // At xpcshell extension tests, it creates multiple VRSystemManagerExternal
+  // instances in plug-contrainer.exe. It causes GetLastError() return
+  // `ERROR_ALREADY_EXISTS`. However, even though `ERROR_ALREADY_EXISTS`, it
+  // still returns the same mutex handle.
   //
   // https://docs.microsoft.com/en-us/windows/desktop/api/synchapi/nf-synchapi-createmutexa
   MOZ_ASSERT(GetLastError() == 0 || GetLastError() == ERROR_ALREADY_EXISTS);
 #endif  // defined(XP_WIN)
 }
 
 VRSystemManagerExternal::~VRSystemManagerExternal() {
   CloseShmem();
--- a/gfx/vr/gfxVRMutex.h
+++ b/gfx/vr/gfxVRMutex.h
@@ -6,29 +6,24 @@
 
 #ifndef GFX_VR_MUTEX_H
 #define GFX_VR_MUTEX_H
 
 namespace mozilla {
 namespace gfx {
 
 #if defined(XP_WIN)
-class WaitForMutex
-{
-public:
-  explicit WaitForMutex(HANDLE handle)
-    : mHandle(handle)
-    , mStatus(false) {
-
+class WaitForMutex {
+ public:
+  explicit WaitForMutex(HANDLE handle) : mHandle(handle), mStatus(false) {
     MOZ_ASSERT(mHandle);
 
     DWORD dwWaitResult;
-    dwWaitResult = WaitForSingleObject(
-        mHandle,    // handle to mutex
-        INFINITE);  // no time-out interval
+    dwWaitResult = WaitForSingleObject(mHandle,    // handle to mutex
+                                       INFINITE);  // no time-out interval
 
     switch (dwWaitResult) {
       // The thread got ownership of the mutex
       case WAIT_OBJECT_0:
         mStatus = true;
         break;
 
       // The thread got ownership of an abandoned mutex
@@ -40,18 +35,18 @@ public:
         mStatus = false;
         break;
     }
   }
 
   ~WaitForMutex() {
     if (mHandle && !ReleaseMutex(mHandle)) {
       nsAutoCString msg;
-      msg.AppendPrintf("WaitForMutex %d ReleaseMutex error \"%lu\".",
-                        mHandle, GetLastError());
+      msg.AppendPrintf("WaitForMutex %d ReleaseMutex error \"%lu\".", mHandle,
+                       GetLastError());
       NS_WARNING(msg.get());
       MOZ_ASSERT(false, "Failed to release mutex.");
     }
   }
 
   bool GetStatus() { return mStatus; }
 
  private:
--- a/gfx/vr/service/VRService.cpp
+++ b/gfx/vr/service/VRService.cpp
@@ -103,25 +103,23 @@ void VRService::Refresh() {
 }
 
 void VRService::Start() {
 #if defined(XP_WIN)
   // Adding `!XRE_IsParentProcess()` to avoid Win 7 32-bit WebVR tests
   // to OpenMutex when there is no GPU process to create
   // VRSystemManagerExternal and its mutex.
   if (!mMutex && !XRE_IsParentProcess()) {
-     mMutex = OpenMutex(
-        MUTEX_ALL_ACCESS,       // request full access
-        false,                  // handle not inheritable
-        TEXT("mozilla::vr::ShmemMutex"));  // object name
+    mMutex = OpenMutex(MUTEX_ALL_ACCESS,  // request full access
+                       false,             // handle not inheritable
+                       TEXT("mozilla::vr::ShmemMutex"));  // object name
 
     if (mMutex == NULL) {
       nsAutoCString msg;
-      msg.AppendPrintf("VRService OpenMutex error \"%lu\".",
-                       GetLastError());
+      msg.AppendPrintf("VRService OpenMutex error \"%lu\".", GetLastError());
       NS_WARNING(msg.get());
       MOZ_ASSERT(false);
     }
     MOZ_ASSERT(GetLastError() == 0);
   }
 #endif
 
   if (!mServiceThread) {
@@ -456,22 +454,22 @@ void VRService::PushState(const mozilla:
 #if defined(MOZ_WIDGET_ANDROID)
   if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->systemMutex)) ==
       0) {
     memcpy((void*)&mAPIShmem->state, &aState, sizeof(VRSystemState));
     pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->systemMutex));
   }
 #else
   bool state = true;
-#if defined(XP_WIN)
+#  if defined(XP_WIN)
   if (!XRE_IsParentProcess()) {
     WaitForMutex lock(mMutex);
     state = lock.GetStatus();
   }
-#endif  // defined(XP_WIN)
+#  endif  // defined(XP_WIN)
   if (state) {
     mAPIShmem->generationA++;
     memcpy((void*)&mAPIShmem->state, &aState, sizeof(VRSystemState));
     mAPIShmem->generationB++;
   }
 #endif    // defined(MOZ_WIDGET_ANDROID)
 }
 
@@ -491,22 +489,22 @@ void VRService::PullState(mozilla::gfx::
 #if defined(MOZ_WIDGET_ANDROID)
   if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->geckoMutex)) ==
       0) {
     memcpy(&aState, &tmp.geckoState, sizeof(VRBrowserState));
     pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->geckoMutex));
   }
 #else
   bool status = true;
-#if defined(XP_WIN)
+#  if defined(XP_WIN)
   if (!XRE_IsParentProcess()) {
     WaitForMutex lock(mMutex);
     status = lock.GetStatus();
   }
-#endif  // defined(XP_WIN)
+#  endif  // defined(XP_WIN)
   if (status) {
     VRExternalShmem tmp;
     if (mAPIShmem->geckoGenerationA != mBrowserGeneration) {
       memcpy(&tmp, mAPIShmem, sizeof(VRExternalShmem));
       if (tmp.geckoGenerationA == tmp.geckoGenerationB &&
           tmp.geckoGenerationA != 0 && tmp.geckoGenerationA != -1) {
         memcpy(&aState, &tmp.geckoState, sizeof(VRBrowserState));
         mBrowserGeneration = tmp.geckoGenerationA;
--- a/gfx/webrender_bindings/RenderCompositor.cpp
+++ b/gfx/webrender_bindings/RenderCompositor.cpp
@@ -12,32 +12,33 @@
 #include "mozilla/webrender/RenderCompositorOGL.h"
 #include "mozilla/widget/CompositorWidget.h"
 
 #ifdef XP_WIN
 #  include "mozilla/webrender/RenderCompositorANGLE.h"
 #endif
 
 #ifdef MOZ_WAYLAND
-#include "mozilla/webrender/RenderCompositorEGL.h"
+#  include "mozilla/webrender/RenderCompositorEGL.h"
 #endif
 
 namespace mozilla {
 namespace wr {
 
 /* static */ UniquePtr<RenderCompositor> RenderCompositor::Create(
     RefPtr<widget::CompositorWidget>&& aWidget) {
 #ifdef XP_WIN
   if (gfx::gfxVars::UseWebRenderANGLE()) {
     return RenderCompositorANGLE::Create(std::move(aWidget));
   }
 #endif
 
 #ifdef MOZ_WAYLAND
-  UniquePtr<RenderCompositor> eglCompositor = RenderCompositorEGL::Create(aWidget);
+  UniquePtr<RenderCompositor> eglCompositor =
+      RenderCompositorEGL::Create(aWidget);
   if (eglCompositor) {
     return eglCompositor;
   }
 #endif
 
   return RenderCompositorOGL::Create(std::move(aWidget));
 }
 
--- a/gfx/webrender_bindings/RenderCompositorEGL.cpp
+++ b/gfx/webrender_bindings/RenderCompositorEGL.cpp
@@ -16,17 +16,16 @@
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 
 namespace mozilla {
 namespace wr {
 
 /* static */ UniquePtr<RenderCompositor> RenderCompositorEGL::Create(
     RefPtr<widget::CompositorWidget> aWidget) {
-
   if (GDK_IS_X11_DISPLAY(gdk_display_get_default())) {
     return nullptr;
   }
 
   RefPtr<gl::GLContext> gl;
   gl = CreateGLContext(aWidget);
   if (!gl) {
     return nullptr;
@@ -35,17 +34,17 @@ namespace wr {
 }
 
 /* static */ already_AddRefed<gl::GLContext>
 RenderCompositorEGL::CreateGLContext(RefPtr<widget::CompositorWidget> aWidget) {
   nsCString discardFailureId;
 
   // Create GLContext with dummy EGLSurface.
   RefPtr<gl::GLContext> gl =
-      //XXX headless context did not work.
+      // XXX headless context did not work.
       gl::GLContextProviderEGL::CreateForCompositorWidget(aWidget, true);
   if (!gl) {
     gfxCriticalNote << "Failed GL context creation for WebRender: "
                     << gfx::hexa(gl.get());
     return nullptr;
   }
 
   if (!gl->MakeCurrent()) {
@@ -65,53 +64,50 @@ RenderCompositorEGL::CreateGLContext(Ref
   if (surface == EGL_NO_SURFACE) {
     gfxCriticalNote << "Failed to create EGLSurface";
   }
   return surface;
 }
 
 RenderCompositorEGL::RenderCompositorEGL(
     RefPtr<gl::GLContext> aGL, RefPtr<widget::CompositorWidget> aWidget)
-    : RenderCompositor(std::move(aWidget)), mGL(aGL), mEGLSurface(EGL_NO_SURFACE) {
+    : RenderCompositor(std::move(aWidget)),
+      mGL(aGL),
+      mEGLSurface(EGL_NO_SURFACE) {
   MOZ_ASSERT(mGL);
 }
 
-RenderCompositorEGL::~RenderCompositorEGL() {
-  DestroyEGLSurface();
-}
+RenderCompositorEGL::~RenderCompositorEGL() { DestroyEGLSurface(); }
 
 bool RenderCompositorEGL::BeginFrame() {
-
-  if (mWidget->AsX11() && mWidget->AsX11()->WaylandRequestsUpdatingEGLSurface()) {
+  if (mWidget->AsX11() &&
+      mWidget->AsX11()->WaylandRequestsUpdatingEGLSurface()) {
     mEGLSurface = CreateEGLSurface(mWidget);
     gl::GLContextEGL::Cast(gl())->SetEGLSurfaceOverride(mEGLSurface);
   }
 
   if (!mGL->MakeCurrent()) {
     gfxCriticalNote << "Failed to make render context current, can't draw.";
     return false;
   }
 
   return true;
 }
 
-void RenderCompositorEGL::EndFrame()
-{
+void RenderCompositorEGL::EndFrame() {
   if (mEGLSurface != EGL_NO_SURFACE) {
     mGL->SwapBuffers();
   }
 }
 
 void RenderCompositorEGL::WaitForGPU() {}
 
 void RenderCompositorEGL::Pause() {}
 
-bool RenderCompositorEGL::Resume() {
-  return true;
-}
+bool RenderCompositorEGL::Resume() { return true; }
 
 bool RenderCompositorEGL::MakeCurrent() {
   gl::GLContextEGL::Cast(gl())->SetEGLSurfaceOverride(mEGLSurface);
   return gl()->MakeCurrent();
 }
 
 void RenderCompositorEGL::DestroyEGLSurface() {
   auto* egl = gl::GLLibraryEGL::Get();
--- a/gfx/webrender_bindings/RenderCompositorEGL.h
+++ b/gfx/webrender_bindings/RenderCompositorEGL.h
@@ -33,19 +33,19 @@ class RenderCompositorEGL : public Rende
 
   bool MakeCurrent() override;
 
   bool UseANGLE() const override { return false; }
 
   LayoutDeviceIntSize GetBufferSize() override;
 
  protected:
-   static already_AddRefed<gl::GLContext> CreateGLContext(
+  static already_AddRefed<gl::GLContext> CreateGLContext(
       RefPtr<widget::CompositorWidget> aWidget);
-   static EGLSurface CreateEGLSurface(widget::CompositorWidget* aWidget);
+  static EGLSurface CreateEGLSurface(widget::CompositorWidget* aWidget);
 
   void DestroyEGLSurface();
 
   const RefPtr<gl::GLContext> mGL;
   EGLSurface mEGLSurface;
 };
 
 }  // namespace wr
--- a/gfx/webrender_bindings/WebRenderAPI.h
+++ b/gfx/webrender_bindings/WebRenderAPI.h
@@ -328,22 +328,23 @@ struct MOZ_STACK_CLASS StackingContextPa
         aPreserve ? wr::TransformStyle::Preserve3D : wr::TransformStyle::Flat;
   }
 
   nsTArray<wr::FilterOp> mFilters;
   wr::LayoutRect mBounds = wr::ToLayoutRect(LayoutDeviceRect());
   const gfx::Matrix4x4* mBoundTransform = nullptr;
   const gfx::Matrix4x4* mTransformPtr = nullptr;
   Maybe<nsDisplayTransform*> mDeferredTransformItem;
-  // Whether the stacking context is possibly animated. This alters how coordinates
-  // are transformed/snapped to invalidate less when transforms change frequently.
+  // Whether the stacking context is possibly animated. This alters how
+  // coordinates are transformed/snapped to invalidate less when transforms
+  // change frequently.
   bool mAnimated = false;
-  // Whether items should be rasterized in a local space that is (mostly) invariant
-  // to transforms, i.e. disabling subpixel AA and screen space pixel snapping on
-  // text runs that would only make sense in screen space.
+  // Whether items should be rasterized in a local space that is (mostly)
+  // invariant to transforms, i.e. disabling subpixel AA and screen space pixel
+  // snapping on text runs that would only make sense in screen space.
   bool mRasterizeLocally = false;
 };
 
 /// This is a simple C++ wrapper around WrState defined in the rust bindings.
 /// We may want to turn this into a direct wrapper on top of
 /// WebRenderFrameBuilder instead, so the interface may change a bit.
 class DisplayListBuilder {
  public:
--- a/image/decoders/icon/mac/nsIconChannelCocoa.mm
+++ b/image/decoders/icon/mac/nsIconChannelCocoa.mm
@@ -126,18 +126,17 @@ nsIconChannel::SetOriginalURI(nsIURI* aU
 NS_IMETHODIMP
 nsIconChannel::GetURI(nsIURI** aURI) {
   *aURI = mUrl;
   NS_IF_ADDREF(*aURI);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsIconChannel::Open(nsIInputStream** _retval)
-{
+nsIconChannel::Open(nsIInputStream** _retval) {
   nsCOMPtr<nsIStreamListener> listener;
   nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return MakeInputStream(_retval, false);
 }
 
 nsresult nsIconChannel::ExtractIconInfoFromUrl(nsIFile** aLocalFile, uint32_t* aDesiredImageSize,
@@ -167,32 +166,30 @@ nsresult nsIconChannel::ExtractIconInfoF
 
   *aLocalFile = file;
   NS_IF_ADDREF(*aLocalFile);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsIconChannel::AsyncOpen(nsIStreamListener* aListener)
-{
+nsIconChannel::AsyncOpen(nsIStreamListener* aListener) {
   nsCOMPtr<nsIStreamListener> listener = aListener;
   nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
   if (NS_FAILED(rv)) {
     mCallbacks = nullptr;
     return rv;
   }
 
   MOZ_ASSERT(
       !mLoadInfo || mLoadInfo->GetSecurityMode() == 0 || mLoadInfo->GetInitialSecurityCheckDone() ||
           (mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
            nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
       "security flags in loadInfo but doContentSecurityCheck() not called");
 
-
   nsCOMPtr<nsIInputStream> inStream;
   MakeInputStream(getter_AddRefs(inStream), true);
   if (NS_FAILED(rv)) {
     mCallbacks = nullptr;
     return rv;
   }
 
   // Init our stream pump
--- a/image/decoders/icon/win/nsIconChannel.cpp
+++ b/image/decoders/icon/win/nsIconChannel.cpp
@@ -186,17 +186,16 @@ nsresult nsIconChannel::ExtractIconInfoF
 
   nsCOMPtr<nsIFile> file;
   rv = fileURL->GetFile(getter_AddRefs(file));
   if (NS_FAILED(rv) || !file) return NS_OK;
 
   return file->Clone(aLocalFile);
 }
 
-
 NS_IMETHODIMP
 nsIconChannel::AsyncOpen(nsIStreamListener* aListener) {
   nsCOMPtr<nsIStreamListener> listener = aListener;
   nsresult rv =
       nsContentSecurityManager::doContentSecurityCheck(this, listener);
   if (NS_FAILED(rv)) {
     mCallbacks = nullptr;
     return rv;
--- a/image/imgLoader.cpp
+++ b/image/imgLoader.cpp
@@ -2255,20 +2255,19 @@ nsresult imgLoader::LoadImage(
     nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(newChannel);
     if (timedChannel) {
       timedChannel->SetInitiatorType(initiatorType);
     }
 
     // create the proxy listener
     nsCOMPtr<nsIStreamListener> listener = new ProxyListener(request.get());
 
-    MOZ_LOG(
-        gImgLog, LogLevel::Debug,
-        ("[this=%p] imgLoader::LoadImage -- Calling channel->AsyncOpen()\n",
-         this));
+    MOZ_LOG(gImgLog, LogLevel::Debug,
+            ("[this=%p] imgLoader::LoadImage -- Calling channel->AsyncOpen()\n",
+             this));
 
     mozilla::net::PredictorLearn(aURI, aInitialDocumentURI,
                                  nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE,
                                  aLoadGroup);
 
     nsresult openRes = newChannel->AsyncOpen(listener);
 
     if (NS_FAILED(openRes)) {
--- a/intl/l10n/DocumentL10n.cpp
+++ b/intl/l10n/DocumentL10n.cpp
@@ -70,17 +70,17 @@ DocumentL10n::DocumentL10n(Document* aDo
     : mDocument(aDocument), mState(DocumentL10nState::Initialized) {
   mContentSink = do_QueryInterface(aDocument->GetCurrentContentSink());
 }
 
 DocumentL10n::~DocumentL10n() {}
 
 bool DocumentL10n::Init(nsTArray<nsString>& aResourceIds) {
   nsCOMPtr<mozIDOMLocalizationJSM> jsm =
-        do_ImportModule("resource://gre/modules/DOMLocalization.jsm");
+      do_ImportModule("resource://gre/modules/DOMLocalization.jsm");
   MOZ_RELEASE_ASSERT(jsm);
 
   Unused << jsm->GetDOMLocalization(getter_AddRefs(mDOMLocalization));
   MOZ_RELEASE_ASSERT(mDOMLocalization);
 
   nsIGlobalObject* global = mDocument->GetScopeObject();
   if (!global) {
     return false;
--- a/ipc/chromium/src/chrome/common/ipc_channel_win.cc
+++ b/ipc/chromium/src/chrome/common/ipc_channel_win.cc
@@ -14,17 +14,17 @@
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "chrome/common/ipc_message_utils.h"
 #include "mozilla/ipc/ProtocolUtils.h"
 
 #ifdef FUZZING
-#include "mozilla/ipc/Faulty.h"
+#  include "mozilla/ipc/Faulty.h"
 #endif
 
 // ChannelImpl is used on the IPC thread, but constructed on a different thread,
 // so it has to hold the nsAutoOwningThread as a pointer, and we need a slightly
 // different macro.
 #ifdef DEBUG
 #  define ASSERT_OWNINGTHREAD(_class)                              \
     if (nsAutoOwningThread* owningThread = _mOwningThread.get()) { \
--- a/js/public/Id.h
+++ b/js/public/Id.h
@@ -223,16 +223,21 @@ auto MapGCThingTyped(const jsid& id, F&&
   using ReturnType = decltype(f(static_cast<JSString*>(nullptr)));
   return mozilla::Maybe<ReturnType>();
 }
 
 // If the jsid is a GC pointer type, convert to that type and call |f| with the
 // pointer. Return whether this happened.
 template <typename F>
 bool ApplyGCThingTyped(const jsid& id, F&& f) {
-  return MapGCThingTyped(id, [&f](auto t) { f(t); return true; }).isSome();
+  return MapGCThingTyped(id,
+                         [&f](auto t) {
+                           f(t);
+                           return true;
+                         })
+      .isSome();
 }
 
 #undef id
 
 }  // namespace js
 
 #endif /* js_Id_h */
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -1274,17 +1274,16 @@ class HeapBase<JS::Value, Wrapper>
     if (arg) {
       setObject(*arg);
     } else {
       setNull();
     }
   }
 };
 
-
 // If the Value is a GC pointer type, call |f| with the pointer cast to that
 // type and return the result wrapped in a Maybe, otherwise return None().
 template <typename F>
 auto MapGCThingTyped(const JS::Value& val, F&& f) {
   if (val.isString()) {
     JSString* str = val.toString();
     MOZ_ASSERT(gc::IsCellPointerValid(str));
     return mozilla::Some(f(str));
@@ -1312,17 +1311,22 @@ auto MapGCThingTyped(const JS::Value& va
   using ReturnType = decltype(f(static_cast<JSObject*>(nullptr)));
   return mozilla::Maybe<ReturnType>();
 }
 
 // If the Value is a GC pointer type, call |f| with the pointer cast to that
 // type. Return whether this happened.
 template <typename F>
 bool ApplyGCThingTyped(const JS::Value& val, F&& f) {
-  return MapGCThingTyped(val, [&f](auto t) { f(t); return true; }).isSome();
+  return MapGCThingTyped(val,
+                         [&f](auto t) {
+                           f(t);
+                           return true;
+                         })
+      .isSome();
 }
 
 static inline JS::Value PoisonedObjectValue(uintptr_t poison) {
   JS::Value v;
   v.setObjectNoCheck(reinterpret_cast<JSObject*>(poison));
   return v;
 }
 
--- a/js/src/builtin/ModuleObject.cpp
+++ b/js/src/builtin/ModuleObject.cpp
@@ -1728,19 +1728,18 @@ JSObject* js::StartDynamicModuleImport(J
 }
 
 bool js::FinishDynamicModuleImport(JSContext* cx,
                                    HandleValue referencingPrivate,
                                    HandleString specifier,
                                    HandleObject promiseArg) {
   Handle<PromiseObject*> promise = promiseArg.as<PromiseObject>();
 
-  auto releasePrivate = mozilla::MakeScopeExit([&] {
-    cx->runtime()->releaseScriptPrivate(referencingPrivate);
-  });
+  auto releasePrivate = mozilla::MakeScopeExit(
+      [&] { cx->runtime()->releaseScriptPrivate(referencingPrivate); });
 
   if (cx->isExceptionPending()) {
     return RejectPromiseWithPendingError(cx, promise);
   }
 
   RootedObject result(cx,
                       CallModuleResolveHook(cx, referencingPrivate, specifier));
   if (!result) {
--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -3236,17 +3236,17 @@ static bool ImplicitConvert(JSContext* c
       }
       *static_cast<bool*>(buffer) = result;
       break;
     }
 #define CHAR16_CASE(name, type, ffiType)                                     \
   case TYPE_##name: {                                                        \
     /* Convert from a 1-character string, regardless of encoding, */         \
     /* or from an integer, provided the result fits in 'type'. */            \
-    type result = 0;                                                             \
+    type result = 0;                                                         \
     if (val.isString()) {                                                    \
       JSString* str = val.toString();                                        \
       if (str->length() != 1)                                                \
         return ConvError(cx, #name, val, convType, funObj, argIndex, arrObj, \
                          arrIndex);                                          \
       JSLinearString* linear = str->ensureLinear(cx);                        \
       if (!linear) return false;                                             \
       result = linear->latin1OrTwoByteChar(0);                               \
--- a/js/src/frontend/EitherParser.h
+++ b/js/src/frontend/EitherParser.h
@@ -59,42 +59,34 @@ struct InvokeMemberFunction {
 
 template <class Parser>
 struct GetParser {
   static Parser* get(Parser* parser) { return parser; }
 };
 
 template <class Parser>
 struct GetTokenStream {
-  static auto get(Parser* parser) {
-    return &parser->tokenStream;
-  }
+  static auto get(Parser* parser) { return &parser->tokenStream; }
 };
 
 // Member function-computing templates.
 
 template <class Parser>
 struct ParserOptions {
-  static constexpr auto get() {
-    return &Parser::options;
-  }
+  static constexpr auto get() { return &Parser::options; }
 };
 
 template <class Parser>
 struct ParserNewObjectBox {
-  static constexpr auto get() {
-    return &Parser::newObjectBox;
-  }
+  static constexpr auto get() { return &Parser::newObjectBox; }
 };
 
 template <class TokenStream>
 struct TokenStreamComputeLineAndColumn {
-  static constexpr auto get() {
-    return &TokenStream::computeLineAndColumn;
-  }
+  static constexpr auto get() { return &TokenStream::computeLineAndColumn; }
 };
 
 // Generic matchers.
 
 struct ParseHandlerMatcher {
   template <class Parser>
   frontend::FullParseHandler& match(Parser* parser) {
     return parser->handler;
--- a/js/src/gc/AllocKind.h
+++ b/js/src/gc/AllocKind.h
@@ -136,19 +136,18 @@ inline auto AllAllocKinds() {
 // to iterate over all object alloc kinds.
 inline auto ObjectAllocKinds() {
   return mozilla::MakeEnumeratedRange(AllocKind::OBJECT_FIRST,
                                       AllocKind::OBJECT_LIMIT);
 }
 
 // Returns a sequence for use in a range-based for loop,
 // to iterate over alloc kinds from |first| to |limit|, exclusive.
-inline auto
-SomeAllocKinds(AllocKind first = AllocKind::FIRST,
-               AllocKind limit = AllocKind::LIMIT) {
+inline auto SomeAllocKinds(AllocKind first = AllocKind::FIRST,
+                           AllocKind limit = AllocKind::LIMIT) {
   MOZ_ASSERT(IsAllocKind(first), "|first| is not a valid AllocKind!");
   MOZ_ASSERT(IsAllocKind(limit), "|limit| is not a valid AllocKind!");
   return mozilla::MakeEnumeratedRange(first, limit);
 }
 
 // AllAllocKindArray<ValueType> gives an enumerated array of ValueTypes,
 // with each index corresponding to a particular alloc kind.
 template <typename ValueType>
--- a/js/src/gc/FindSCCs.h
+++ b/js/src/gc/FindSCCs.h
@@ -61,18 +61,17 @@ struct GraphNodeBase {
  * finder.addNode(node2);
  * finder.addNode(node3);
  * MyGraphNode* result = finder.getResultsList();
  */
 
 template <typename Node>
 class ComponentFinder {
  public:
-  explicit ComponentFinder(uintptr_t sl)
-      : stackLimit(sl) {}
+  explicit ComponentFinder(uintptr_t sl) : stackLimit(sl) {}
 
   ~ComponentFinder() {
     MOZ_ASSERT(!stack);
     MOZ_ASSERT(!firstComponent);
   }
 
   /* Forces all nodes to be added to a single component. */
   void useOneComponent() { stackFull = true; }
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -4025,19 +4025,18 @@ static bool InCrossCompartmentMap(JSObje
       return true;
     }
   }
 
   return false;
 }
 
 void CompartmentCheckTracer::onChild(const JS::GCCellPtr& thing) {
-  Compartment* comp = MapGCThingTyped(thing, [](auto t) {
-    return t->maybeCompartment();
-  });
+  Compartment* comp =
+      MapGCThingTyped(thing, [](auto t) { return t->maybeCompartment(); });
   if (comp && compartment) {
     MOZ_ASSERT(comp == compartment ||
                (srcKind == JS::TraceKind::Object &&
                 InCrossCompartmentMap(static_cast<JSObject*>(src), thing)));
   } else {
     TenuredCell* tenured = TenuredCell::fromPointer(thing.asCell());
     Zone* thingZone = tenured->zoneFromAnyThread();
     MOZ_ASSERT(thingZone == zone || thingZone->isAtomsZone());
@@ -4054,19 +4053,18 @@ void GCRuntime::checkForCompartmentMisma
   AutoAssertEmptyNursery empty(cx);
   for (ZonesIter zone(rt, SkipAtoms); !zone.done(); zone.next()) {
     trc.zone = zone;
     for (auto thingKind : AllAllocKinds()) {
       for (auto i = zone->cellIter<TenuredCell>(thingKind, empty); !i.done();
            i.next()) {
         trc.src = i.getCell();
         trc.srcKind = MapAllocToTraceKind(thingKind);
-        trc.compartment = MapGCThingTyped(trc.src, trc.srcKind, [](auto t) {
-          return t->maybeCompartment();
-        });
+        trc.compartment = MapGCThingTyped(
+            trc.src, trc.srcKind, [](auto t) { return t->maybeCompartment(); });
         js::TraceChildren(&trc, trc.src, trc.srcKind);
       }
     }
   }
 }
 #endif
 
 static void RelazifyFunctions(Zone* zone, AllocKind kind) {
@@ -4843,19 +4841,18 @@ bool Compartment::findSweepGroupEdges() 
 
     if (key.is<JSObject*>() &&
         key.as<JSObject*>()->asTenured().isMarkedBlack()) {
       // CCW target is already marked, so we don't need to watch out for
       // later marking of the CCW.
       continue;
     }
 
-    Zone* target = key.applyToWrapped([](auto tp) {
-      return (*tp)->asTenured().zone();
-    });
+    Zone* target =
+        key.applyToWrapped([](auto tp) { return (*tp)->asTenured().zone(); });
     if (!target->isGCMarking()) {
       continue;
     }
 
     if (!source->addSweepGroupEdgeTo(target)) {
       return false;
     }
   }
@@ -7400,18 +7397,17 @@ bool GCRuntime::shouldCollectNurseryForS
     case State::NotActive:
     case State::Sweep:
     case State::Finalize:
     case State::Compact:
     case State::Decommit:
       return true;
     case State::Mark:
       return (nonincrementalByAPI || budget.isUnlimited() || lastMarkSlice ||
-              nursery().shouldCollect() ||
-              hasIncrementalTwoSliceZealMode());
+              nursery().shouldCollect() || hasIncrementalTwoSliceZealMode());
     case State::Finish:
       return false;
     case State::MarkRoots:
       MOZ_CRASH("Unexpected GC state");
   }
 
   return false;
 }
--- a/js/src/gc/Marking-inl.h
+++ b/js/src/gc/Marking-inl.h
@@ -14,18 +14,18 @@
 #include "gc/RelocationOverlay.h"
 
 #include "vm/BigIntType.h"
 #include "vm/RegExpShared.h"
 
 namespace js {
 namespace gc {
 
-// An abstraction to re-wrap any kind of typed pointer back to the tagged pointer
-// it came from with |TaggedPtr<TargetType>::wrap(sourcePtr)|.
+// An abstraction to re-wrap any kind of typed pointer back to the tagged
+// pointer it came from with |TaggedPtr<TargetType>::wrap(sourcePtr)|.
 template <typename T>
 struct TaggedPtr {};
 
 template <>
 struct TaggedPtr<JS::Value> {
   static JS::Value wrap(JSObject* obj) { return JS::ObjectOrNullValue(obj); }
   static JS::Value wrap(JSString* str) { return JS::StringValue(str); }
   static JS::Value wrap(JS::Symbol* sym) { return JS::SymbolValue(sym); }
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -516,37 +516,37 @@ void js::TraceGenericPointerRoot(JSTrace
   MOZ_ASSERT(thingp);
   Cell* thing = *thingp;
   if (!thing) {
     return;
   }
 
   auto traced = MapGCThingTyped(thing, thing->getTraceKind(),
                                 [trc, name](auto t) -> Cell* {
-    TraceRoot(trc, &t, name);
-    return t;
-  });
+                                  TraceRoot(trc, &t, name);
+                                  return t;
+                                });
   if (traced != thing) {
     *thingp = traced;
   }
 }
 
 void js::TraceManuallyBarrieredGenericPointerEdge(JSTracer* trc, Cell** thingp,
                                                   const char* name) {
   MOZ_ASSERT(thingp);
   Cell* thing = *thingp;
   if (!*thingp) {
     return;
   }
 
   auto traced = MapGCThingTyped(thing, thing->getTraceKind(),
                                 [trc, name](auto t) -> Cell* {
-    TraceManuallyBarrieredEdge(trc, &t, name);
-    return t;
-  });
+                                  TraceManuallyBarrieredEdge(trc, &t, name);
+                                  return t;
+                                });
   if (traced != thing) {
     *thingp = traced;
   }
 }
 
 // This method is responsible for dynamic dispatch to the real tracer
 // implementation. Consider replacing this choke point with virtual dispatch:
 // a sufficiently smart C++ compiler may be able to devirtualize some paths.
@@ -914,19 +914,18 @@ static void CheckTraversedEdge(S source,
 template <typename S, typename T>
 void js::GCMarker::traverseEdge(S source, T* target) {
   CheckTraversedEdge(source, target);
   traverse(target);
 }
 
 template <typename S, typename T>
 void js::GCMarker::traverseEdge(S source, const T& thing) {
-  ApplyGCThingTyped(thing, [this, source](auto t) {
-                             this->traverseEdge(source, t);
-                           });
+  ApplyGCThingTyped(thing,
+                    [this, source](auto t) { this->traverseEdge(source, t); });
 }
 
 namespace {
 
 template <typename T>
 struct TypeParticipatesInCC {};
 #define EXPAND_PARTICIPATES_IN_CC(_, type, addToCCKind) \
   template <>                                           \
@@ -1498,17 +1497,18 @@ template <typename Functor>
 static void VisitTraceList(const Functor& f, const int32_t* traceList,
                            uint8_t* memory);
 
 // Call the trace hook set on the object, if present. If further tracing of
 // NativeObject fields is required, this will return the native object.
 enum class CheckGeneration { DoChecks, NoChecks };
 template <typename Functor>
 static inline NativeObject* CallTraceHook(Functor&& f, JSTracer* trc,
-                                          JSObject* obj, CheckGeneration check) {
+                                          JSObject* obj,
+                                          CheckGeneration check) {
   const Class* clasp = obj->getClass();
   MOZ_ASSERT(clasp);
   MOZ_ASSERT(obj->isNative() == clasp->isNative());
 
   if (!clasp->hasTrace()) {
     return &obj->as<NativeObject>();
   }
 
@@ -1788,19 +1788,19 @@ scan_obj : {
     repush(obj);
     return;
   }
 
   markImplicitEdges(obj);
   ObjectGroup* group = obj->groupFromGC();
   traverseEdge(obj, group);
 
-  NativeObject* nobj = CallTraceHook([this, obj](auto thingp) {
-                                       this->traverseEdge(obj, *thingp);
-                                     }, this, obj, CheckGeneration::DoChecks);
+  NativeObject* nobj = CallTraceHook(
+      [this, obj](auto thingp) { this->traverseEdge(obj, *thingp); }, this, obj,
+      CheckGeneration::DoChecks);
   if (!nobj) {
     return;
   }
 
   Shape* shape = nobj->lastProperty();
   traverseEdge(obj, shape);
 
   unsigned nslots = nobj->slotSpan();
@@ -2898,19 +2898,19 @@ void js::gc::StoreBuffer::CellPtrEdge::t
 void js::gc::StoreBuffer::ValueEdge::trace(TenuringTracer& mover) const {
   if (deref()) {
     mover.traverse(edge);
   }
 }
 
 // Visit all object children of the object and trace them.
 void js::TenuringTracer::traceObject(JSObject* obj) {
-  NativeObject* nobj = CallTraceHook([this](auto thingp) {
-                                       this->traverse(thingp);
-                                     }, this, obj, CheckGeneration::NoChecks);
+  NativeObject* nobj =
+      CallTraceHook([this](auto thingp) { this->traverse(thingp); }, this, obj,
+                    CheckGeneration::NoChecks);
   if (!nobj) {
     return;
   }
 
   // Note: the contents of copy on write elements pointers are filled in
   // during parsing and cannot contain nursery pointers.
   if (!nobj->hasEmptyElements() && !nobj->denseElementsAreCopyOnWrite() &&
       ObjectDenseElementsMayBeMarkable(nobj)) {
@@ -3586,19 +3586,18 @@ static bool UnmarkGrayGCThing(JSRuntime*
   MOZ_ASSERT(thing);
   MOZ_ASSERT(thing.asCell()->isMarkedGray());
 
   // Gray cell unmarking can occur at different points between recording and
   // replay, so disallow recorded events from occurring in the tracer.
   mozilla::recordreplay::AutoDisallowThreadEvents d;
 
   AutoGeckoProfilerEntry profilingStackFrame(
-    rt->mainContextFromOwnThread(),
-    "UnmarkGrayGCThing",
-    ProfilingStackFrame::Category::GCCC);
+      rt->mainContextFromOwnThread(), "UnmarkGrayGCThing",
+      ProfilingStackFrame::Category::GCCC);
 
   UnmarkGrayTracer unmarker(rt);
   gcstats::AutoPhase innerPhase(rt->gc.stats(),
                                 gcstats::PhaseKind::UNMARK_GRAY);
   unmarker.unmark(thing);
   return unmarker.unmarkedAny;
 }
 
--- a/js/src/gc/Tracer.cpp
+++ b/js/src/gc/Tracer.cpp
@@ -58,19 +58,23 @@ T DoCallback(JS::CallbackTracer* trc, T*
   // Only update *thingp if the value changed, to avoid TSan false positives for
   // template objects when using DumpHeapTracer or UbiNode tracers while Ion
   // compiling off-thread.
   if (thing.isSome() && thing.value() != *thingp) {
     *thingp = thing.value();
   }
   return *thingp;
 }
-template JS::Value DoCallback<JS::Value>(JS::CallbackTracer*, JS::Value*, const char*);
-template JS::PropertyKey DoCallback<JS::PropertyKey>(JS::CallbackTracer*, JS::PropertyKey*, const char*);
-template TaggedProto DoCallback<TaggedProto>(JS::CallbackTracer*, TaggedProto*, const char*);
+template JS::Value DoCallback<JS::Value>(JS::CallbackTracer*, JS::Value*,
+                                         const char*);
+template JS::PropertyKey DoCallback<JS::PropertyKey>(JS::CallbackTracer*,
+                                                     JS::PropertyKey*,
+                                                     const char*);
+template TaggedProto DoCallback<TaggedProto>(JS::CallbackTracer*, TaggedProto*,
+                                             const char*);
 
 void JS::CallbackTracer::getTracingEdgeName(char* buffer, size_t bufferSize) {
   MOZ_ASSERT(bufferSize > 0);
   if (contextFunctor_) {
     (*contextFunctor_)(this, buffer, bufferSize);
     return;
   }
   if (contextIndex_ != InvalidIndex) {
@@ -86,17 +90,17 @@ JS_PUBLIC_API void JS::TraceChildren(JST
   js::TraceChildren(trc, thing.asCell(), thing.kind());
 }
 
 void js::TraceChildren(JSTracer* trc, void* thing, JS::TraceKind kind) {
   MOZ_ASSERT(thing);
   ApplyGCThingTyped(thing, kind, [trc](auto t) {
     MOZ_ASSERT_IF(t->runtimeFromAnyThread() != trc->runtime(),
                   ThingIsPermanentAtomOrWellKnownSymbol(t) ||
-                  t->zoneFromAnyThread()->isSelfHostingZone());
+                      t->zoneFromAnyThread()->isSelfHostingZone());
     t->traceChildren(trc);
   });
 }
 
 JS_PUBLIC_API void JS::TraceIncomingCCWs(
     JSTracer* trc, const JS::CompartmentSet& compartments) {
   for (js::CompartmentsIter comp(trc->runtime()); !comp.done(); comp.next()) {
     if (compartments.has(comp)) {
--- a/js/src/gc/Zone.h
+++ b/js/src/gc/Zone.h
@@ -410,25 +410,23 @@ class Zone : public JS::shadow::Zone,
   js::ZoneOrGCTaskData<js::gc::WeakKeyTable> gcWeakKeys_;
 
  public:
   js::gc::WeakKeyTable& gcWeakKeys() { return gcWeakKeys_.ref(); }
 
   // A set of edges from this zone to other zones used during GC to calculate
   // sweep groups.
   NodeSet& gcSweepGroupEdges() {
-    return gcGraphEdges; // Defined in GraphNodeBase base class.
+    return gcGraphEdges;  // Defined in GraphNodeBase base class.
   }
   MOZ_MUST_USE bool addSweepGroupEdgeTo(Zone* otherZone) {
     MOZ_ASSERT(otherZone->isGCMarking());
     return gcSweepGroupEdges().put(otherZone);
   }
-  void clearSweepGroupEdges() {
-    gcSweepGroupEdges().clear();
-  }
+  void clearSweepGroupEdges() { gcSweepGroupEdges().clear(); }
 
   // Keep track of all TypeDescr and related objects in this compartment.
   // This is used by the GC to trace them all first when compacting, since the
   // TypedObject trace hook may access these objects.
   //
   // There are no barriers here - the set contains only tenured objects so no
   // post-barrier is required, and these are weak references so no pre-barrier
   // is required.
--- a/js/src/jit/AtomicOperations.h
+++ b/js/src/jit/AtomicOperations.h
@@ -281,18 +281,17 @@ class AtomicOperations {
       while (iterations--) {
         memcpySafeWhenRacy(dest + offs, SharedMem<uint8_t*>::unshared(buf),
                            sizeof(buf));
         offs += sizeof(buf);
       }
     } else {
       memset(buf, value, tail);
     }
-    memcpySafeWhenRacy(dest + offs, SharedMem<uint8_t*>::unshared(buf),
-                       tail);
+    memcpySafeWhenRacy(dest + offs, SharedMem<uint8_t*>::unshared(buf), tail);
   }
 
   template <typename T>
   static void podCopySafeWhenRacy(SharedMem<T*> dest, SharedMem<T*> src,
                                   size_t nelem) {
     memcpySafeWhenRacy(dest, src, nelem * sizeof(T));
   }
 
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -4138,22 +4138,21 @@ IonBuilder::InliningResult IonBuilder::i
   auto bestTier = inst.code().bestTier();
   const wasm::FuncExport& funcExport =
       inst.metadata(bestTier).lookupFuncExport(funcIndex);
   const wasm::FuncType& sig = funcExport.funcType();
 
   // Check that the function doesn't take or return non-compatible JS
   // argument types before adding nodes to the MIR graph, otherwise they'd be
   // dead code.
-  if (sig.hasI64ArgOrRet() ||
-      sig.temporarilyUnsupportedAnyRef()
+  if (sig.hasI64ArgOrRet() || sig.temporarilyUnsupportedAnyRef()
 #ifdef WASM_CODEGEN_DEBUG
       || !JitOptions.enableWasmIonFastCalls
 #endif
-     ) {
+  ) {
     return InliningStatus_NotInlined;
   }
 
   // If there are too many arguments, don't inline (we won't be able to store
   // the arguments in the LIR node).
   static constexpr size_t MaxNumInlinedArgs = 8;
   static_assert(MaxNumInlinedArgs <= MaxNumLInstructionOperands,
                 "inlined arguments can all be LIR operands");
--- a/js/src/jit/MacroAssembler.h
+++ b/js/src/jit/MacroAssembler.h
@@ -588,17 +588,18 @@ class MacroAssembler : public MacroAssem
       void* fun, MoveOp::Type result = MoveOp::GENERAL,
       CheckUnsafeCallWithABI check = CheckUnsafeCallWithABI::Check);
   inline void callWithABI(Register fun, MoveOp::Type result = MoveOp::GENERAL);
   inline void callWithABI(const Address& fun,
                           MoveOp::Type result = MoveOp::GENERAL);
 
   CodeOffset callWithABI(wasm::BytecodeOffset offset, wasm::SymbolicAddress fun,
                          MoveOp::Type result = MoveOp::GENERAL);
-  void callDebugWithABI(wasm::SymbolicAddress fun, MoveOp::Type result = MoveOp::GENERAL);
+  void callDebugWithABI(wasm::SymbolicAddress fun,
+                        MoveOp::Type result = MoveOp::GENERAL);
 
  private:
   // Reinitialize the variables which have to be cleared before making a call
   // with callWithABI.
   void setupABICall();
 
   // Reserve the stack and resolve the arguments move.
   void callWithABIPre(uint32_t* stackAdjust,
--- a/js/src/jit/arm/Assembler-arm.h
+++ b/js/src/jit/arm/Assembler-arm.h
@@ -86,21 +86,21 @@ static const uint32_t NumCallTempNonArgR
 // register allocator.
 
 // CompareExchange: Any two odd/even pairs would do for `new` and `out`, and any
 // pair would do for `old`, so long as none of them overlap.
 
 static constexpr Register CmpXchgOldLo = r4;
 static constexpr Register CmpXchgOldHi = r5;
 static constexpr Register64 CmpXchgOld64 =
-  Register64(CmpXchgOldHi, CmpXchgOldLo);
+    Register64(CmpXchgOldHi, CmpXchgOldLo);
 static constexpr Register CmpXchgNewLo = IntArgReg2;
 static constexpr Register CmpXchgNewHi = IntArgReg3;
 static constexpr Register64 CmpXchgNew64 =
-  Register64(CmpXchgNewHi, CmpXchgNewLo);
+    Register64(CmpXchgNewHi, CmpXchgNewLo);
 static constexpr Register CmpXchgOutLo = IntArgReg0;
 static constexpr Register CmpXchgOutHi = IntArgReg1;
 
 // Exchange: Any two non-equal odd/even pairs would do for `new` and `out`.
 
 static constexpr Register XchgNewLo = IntArgReg2;
 static constexpr Register XchgNewHi = IntArgReg3;
 static constexpr Register64 XchgNew64 = Register64(XchgNewHi, XchgNewLo);
@@ -108,17 +108,17 @@ static constexpr Register XchgOutLo = In
 static constexpr Register XchgOutHi = IntArgReg1;
 
 // Atomic rmw operations: Any two odd/even pairs would do for `tmp` and `out`,
 // and any pair would do for `val`, so long as none of them overlap.
 
 static constexpr Register FetchOpValLo = r4;
 static constexpr Register FetchOpValHi = r5;
 static constexpr Register64 FetchOpVal64 =
-  Register64(FetchOpValHi, FetchOpValLo);
+    Register64(FetchOpValHi, FetchOpValLo);
 static constexpr Register FetchOpTmpLo = IntArgReg2;
 static constexpr Register FetchOpTmpHi = IntArgReg3;
 static constexpr Register FetchOpOutLo = IntArgReg0;
 static constexpr Register FetchOpOutHi = IntArgReg1;
 
 class ABIArgGenerator {
   unsigned intRegIndex_;
   unsigned floatRegIndex_;
--- a/js/src/jit/arm/Lowering-arm.cpp
+++ b/js/src/jit/arm/Lowering-arm.cpp
@@ -859,20 +859,18 @@ void LIRGenerator::visitCompareExchangeT
 }
 
 void LIRGenerator::visitWasmCompareExchangeHeap(MWasmCompareExchangeHeap* ins) {
   MDefinition* base = ins->base();
   MOZ_ASSERT(base->type() == MIRType::Int32);
 
   if (ins->access().type() == Scalar::Int64) {
     // The three register pairs must be distinct.
-    auto* lir =
-      new (alloc()) LWasmCompareExchangeI64(
-        useRegister(base),
-        useInt64Fixed(ins->oldValue(), CmpXchgOld64),
+    auto* lir = new (alloc()) LWasmCompareExchangeI64(
+        useRegister(base), useInt64Fixed(ins->oldValue(), CmpXchgOld64),
         useInt64Fixed(ins->newValue(), CmpXchgNew64));
     defineInt64Fixed(lir, ins,
                      LInt64Allocation(LAllocation(AnyRegister(CmpXchgOutHi)),
                                       LAllocation(AnyRegister(CmpXchgOutLo))));
     return;
   }
 
   MOZ_ASSERT(ins->access().type() < Scalar::Float32);
@@ -885,18 +883,17 @@ void LIRGenerator::visitWasmCompareExcha
   define(lir, ins);
 }
 
 void LIRGenerator::visitWasmAtomicExchangeHeap(MWasmAtomicExchangeHeap* ins) {
   MOZ_ASSERT(ins->base()->type() == MIRType::Int32);
 
   if (ins->access().type() == Scalar::Int64) {
     auto* lir = new (alloc()) LWasmAtomicExchangeI64(
-        useRegister(ins->base()),
-        useInt64Fixed(ins->value(), XchgNew64),
+        useRegister(ins->base()), useInt64Fixed(ins->value(), XchgNew64),
         ins->access());
     defineInt64Fixed(lir, ins,
                      LInt64Allocation(LAllocation(AnyRegister(XchgOutHi)),
                                       LAllocation(AnyRegister(XchgOutLo))));
     return;
   }
 
   MOZ_ASSERT(ins->access().type() < Scalar::Float32);
@@ -904,24 +901,20 @@ void LIRGenerator::visitWasmAtomicExchan
 
   const LAllocation base = useRegister(ins->base());
   const LAllocation value = useRegister(ins->value());
   define(new (alloc()) LWasmAtomicExchangeHeap(base, value), ins);
 }
 
 void LIRGenerator::visitWasmAtomicBinopHeap(MWasmAtomicBinopHeap* ins) {
   if (ins->access().type() == Scalar::Int64) {
-    auto* lir =
-      new (alloc()) LWasmAtomicBinopI64(useRegister(ins->base()),
-                                        useInt64Fixed(ins->value(),
-                                                      FetchOpVal64),
-                                        tempFixed(FetchOpTmpLo),
-                                        tempFixed(FetchOpTmpHi),
-                                        ins->access(),
-                                        ins->operation());
+    auto* lir = new (alloc()) LWasmAtomicBinopI64(
+        useRegister(ins->base()), useInt64Fixed(ins->value(), FetchOpVal64),
+        tempFixed(FetchOpTmpLo), tempFixed(FetchOpTmpHi), ins->access(),
+        ins->operation());
     defineInt64Fixed(lir, ins,
                      LInt64Allocation(LAllocation(AnyRegister(FetchOpOutHi)),
                                       LAllocation(AnyRegister(FetchOpOutLo))));
     return;
   }
 
   MOZ_ASSERT(ins->access().type() < Scalar::Float32);
   MOZ_ASSERT(HasLDSTREXBHD(), "by HasCompilerSupport() constraints");
--- a/js/src/jit/arm64/CodeGenerator-arm64.cpp
+++ b/js/src/jit/arm64/CodeGenerator-arm64.cpp
@@ -1838,17 +1838,17 @@ void CodeGenerator::visitWasmReinterpret
 void CodeGenerator::visitAtomicTypedArrayElementBinop(
     LAtomicTypedArrayElementBinop* lir) {
   MOZ_ASSERT(lir->mir()->hasUses());
 
   AnyRegister output = ToAnyRegister(lir->output());
   Register elements = ToRegister(lir->elements());
   Register flagTemp = ToRegister(lir->temp1());
   Register outTemp =
-    lir->temp2()->isBogusTemp() ? InvalidReg : ToRegister(lir->temp2());
+      lir->temp2()->isBogusTemp() ? InvalidReg : ToRegister(lir->temp2());
   Register value = ToRegister(lir->value());
 
   Scalar::Type arrayType = lir->mir()->arrayType();
   size_t width = Scalar::byteSize(arrayType);
 
   if (lir->index()->isConstant()) {
     Address mem(elements, ToInt32(lir->index()) * width);
     masm.atomicFetchOpJS(arrayType, Synchronization::Full(),
--- a/js/src/jit/arm64/Lowering-arm64.cpp
+++ b/js/src/jit/arm64/Lowering-arm64.cpp
@@ -427,18 +427,19 @@ void LIRGenerator::visitCompareExchangeT
   const LAllocation newval = useRegister(ins->newval());
   const LAllocation oldval = useRegister(ins->oldval());
 
   LDefinition outTemp = LDefinition::BogusTemp();
   if (ins->arrayType() == Scalar::Uint32) {
     outTemp = temp();
   }
 
-  LCompareExchangeTypedArrayElement* lir = new (alloc())
-      LCompareExchangeTypedArrayElement(elements, index, oldval, newval, outTemp);
+  LCompareExchangeTypedArrayElement* lir =
+      new (alloc()) LCompareExchangeTypedArrayElement(elements, index, oldval,
+                                                      newval, outTemp);
 
   define(lir, ins);
 }
 
 void LIRGenerator::visitAtomicExchangeTypedArrayElement(
     MAtomicExchangeTypedArrayElement* ins) {
   MOZ_ASSERT(ins->arrayType() <= Scalar::Uint32);
 
--- a/js/src/jsapi-tests/testFindSCCs.cpp
+++ b/js/src/jsapi-tests/testFindSCCs.cpp
@@ -13,17 +13,16 @@
 
 static const unsigned MaxVertices = 10;
 
 using js::gc::ComponentFinder;
 using js::gc::GraphNodeBase;
 
 struct TestNode : public GraphNodeBase<TestNode> {
   unsigned index;
-
 };
 
 using TestComponentFinder = ComponentFinder<TestNode>;
 
 static TestNode Vertex[MaxVertices];
 
 BEGIN_TEST(testFindSCCs) {
   // no vertices
--- a/js/src/vm/CodeCoverage.cpp
+++ b/js/src/vm/CodeCoverage.cpp
@@ -615,33 +615,34 @@ bool LCovRuntime::fillWithFilename(char*
 
   int64_t timestamp = static_cast<double>(PRMJ_Now()) / PRMJ_USEC_PER_SEC;
   static mozilla::Atomic<size_t> globalRuntimeId(0);
   size_t rid = globalRuntimeId++;
 
   int len = snprintf(name, length, "%s/%" PRId64 "-%" PRIu32 "-%zu.info",
                      outDir, timestamp, pid_, rid);
   if (len < 0 || size_t(len) >= length) {
-    fprintf(stderr, "Warning: LCovRuntime::init: Cannot serialize file name.\n");
+    fprintf(stderr,
+            "Warning: LCovRuntime::init: Cannot serialize file name.\n");
     return false;
   }
 
   return true;
 }
 
 void LCovRuntime::init() {
   char name[1024];
   if (!fillWithFilename(name, sizeof(name))) {
     return;
   }
 
   // If we cannot open the file, report a warning.
   if (!out_.init(name)) {
-    fprintf(stderr, "Warning: LCovRuntime::init: Cannot open file named '%s'.\n",
-            name);
+    fprintf(stderr,
+            "Warning: LCovRuntime::init: Cannot open file named '%s'.\n", name);
   }
   isEmpty_ = true;
 }
 
 void LCovRuntime::finishFile() {
   MOZ_ASSERT(out_.isInitialized());
   out_.finish();
 
--- a/js/src/vm/Compartment.cpp
+++ b/js/src/vm/Compartment.cpp
@@ -430,22 +430,20 @@ void Compartment::sweepAfterMinorGC(JSTr
  * string entries in the crossCompartmentWrappers table are not marked during
  * markCrossCompartmentWrappers.
  */
 void Compartment::sweepCrossCompartmentWrappers() {
   crossCompartmentWrappers.sweep();
 }
 
 void CrossCompartmentKey::trace(JSTracer* trc) {
-  applyToWrapped([trc](auto tp) {
-    TraceRoot(trc, tp, "CrossCompartmentKey::wrapped");
-  });
-  applyToDebugger([trc](auto tp) {
-    TraceRoot(trc, tp, "CrossCompartmentKey::debugger");
-  });
+  applyToWrapped(
+      [trc](auto tp) { TraceRoot(trc, tp, "CrossCompartmentKey::wrapped"); });
+  applyToDebugger(
+      [trc](auto tp) { TraceRoot(trc, tp, "CrossCompartmentKey::debugger"); });
 }
 
 bool CrossCompartmentKey::needsSweep() {
   auto needsSweep = [](auto tp) { return IsAboutToBeFinalizedUnbarriered(tp); };
   return applyToWrapped(needsSweep) || applyToDebugger(needsSweep);
 }
 
 /* static */ void Compartment::fixupCrossCompartmentWrappersAfterMovingGC(
--- a/js/src/vm/Compartment.h
+++ b/js/src/vm/Compartment.h
@@ -84,25 +84,21 @@ class CrossCompartmentKey {
 
   template <typename F>
   auto applyToWrapped(F f) {
     struct WrappedMatcher {
       F f_;
       explicit WrappedMatcher(F f) : f_(f) {}
       auto match(JSObject*& obj) { return f_(&obj); }
       auto match(JSString*& str) { return f_(&str); }
-      auto match(DebuggerAndScript& tpl) {
-        return f_(&mozilla::Get<1>(tpl));
-      }
+      auto match(DebuggerAndScript& tpl) { return f_(&mozilla::Get<1>(tpl)); }
       auto match(DebuggerAndLazyScript& tpl) {
         return f_(&mozilla::Get<1>(tpl));
       }
-      auto match(DebuggerAndObject& tpl) {
-        return f_(&mozilla::Get<1>(tpl));
-      }
+      auto match(DebuggerAndObject& tpl) { return f_(&mozilla::Get<1>(tpl)); }
     } matcher(f);
     return wrapped.match(matcher);
   }
 
   template <typename F>
   auto applyToDebugger(F f) {
     using ReturnType = decltype(f(static_cast<NativeObject**>(nullptr)));
     struct DebuggerMatcher {
--- a/js/src/vm/TaggedProto.h
+++ b/js/src/vm/TaggedProto.h
@@ -138,17 +138,22 @@ auto MapGCThingTyped(const TaggedProto& 
     return mozilla::Some(f(proto.toObject()));
   }
   using ReturnType = decltype(f(static_cast<JSObject*>(nullptr)));
   return mozilla::Maybe<ReturnType>();
 }
 
 template <typename F>
 bool ApplyGCThingTyped(const TaggedProto& proto, F&& f) {
-  return MapGCThingTyped(proto, [&f](auto t) { f(t); return true; }).isSome();
+  return MapGCThingTyped(proto,
+                         [&f](auto t) {
+                           f(t);
+                           return true;
+                         })
+      .isSome();
 }
 
 // Since JSObject pointers are either nullptr or a valid object and since the
 // object layout of TaggedProto is identical to a bare object pointer, we can
 // safely treat a pointer to an already-rooted object (e.g. HandleObject) as a
 // pointer to a TaggedProto.
 inline Handle<TaggedProto> AsTaggedProto(HandleObject obj) {
   static_assert(sizeof(JSObject*) == sizeof(TaggedProto),
--- a/js/src/vm/Xdr.h
+++ b/js/src/vm/Xdr.h
@@ -459,20 +459,20 @@ class XDRState : public XDRCoderBase {
     size_t len = (size_t)len64;
 
     if (mode == XDR_ENCODE) {
       uint8_t* ptr = buf.write(len);
       if (!ptr) {
         return fail(JS::TranscodeResult_Throw);
       }
       memcpy(ptr, *sp, len);
-      MOZ_ASSERT(ptr[len-1] == '\0');
+      MOZ_ASSERT(ptr[len - 1] == '\0');
     } else {
       const uint8_t* ptr = buf.read(len);
-      if (!ptr || ptr[len-1] != '\0') {
+      if (!ptr || ptr[len - 1] != '\0') {
         return fail(JS::TranscodeResult_Failure_BadDecode);
       }
       *sp = reinterpret_cast<const char*>(ptr);
     }
     return Ok();
   }
 
   XDRResult codeChars(JS::Latin1Char* chars, size_t nchars);
--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -1967,19 +1967,17 @@ class MOZ_STACK_CLASS JS_HAZ_ROOTED Modu
       return false;
     }
 
     return true;
   }
 
   AsmJSParser<Unit>& parser() const { return parser_; }
 
-  auto& tokenStream() const {
-    return parser_.tokenStream;
-  }
+  auto& tokenStream() const { return parser_.tokenStream; }
 
  public:
   bool addFuncDef(PropertyName* name, uint32_t firstUse, FuncType&& sig,
                   Func** func) {
     uint32_t sigIndex;
     if (!declareSig(std::move(sig), &sigIndex)) {
       return false;
     }
--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -1222,18 +1222,18 @@ class BaseStackFrameAllocator {
 #ifdef RABALDR_CHUNKY_STACK
   // The allocated frame size is frequently larger than the logical stack
   // height; we round up to a chunk boundary, and special case the initial
   // chunk.
   uint32_t framePushedForHeight(uint32_t logicalHeight) {
     if (logicalHeight <= fixedAllocSize()) {
       return fixedAllocSize();
     }
-    return fixedAllocSize() + AlignBytes(logicalHeight - fixedAllocSize(),
-                                         ChunkSize);
+    return fixedAllocSize() +
+           AlignBytes(logicalHeight - fixedAllocSize(), ChunkSize);
   }
 #endif
 
  protected:
   //////////////////////////////////////////////////////////////////////
   //
   // The Dynamic area - the dynamic part of the frame, for spilling and saving
   // intermediate values.
--- a/js/src/wasm/WasmBuiltins.cpp
+++ b/js/src/wasm/WasmBuiltins.cpp
@@ -463,40 +463,25 @@ static inline void* FuncCast(F* funcPtr,
   void* pf = JS_FUNC_TO_DATA_PTR(void*, funcPtr);
 #ifdef JS_SIMULATOR
   pf = Simulator::RedirectNativeFunction(pf, abiType);
 #endif
   return pf;
 }
 
 #ifdef WASM_CODEGEN_DEBUG
-void wasm::PrintI32(int32_t val)
-{
-  fprintf(stderr, "i32(%d) ", val);
-}
+void wasm::PrintI32(int32_t val) { fprintf(stderr, "i32(%d) ", val); }
 
-void wasm::PrintPtr(uint8_t* val)
-{
-  fprintf(stderr, "ptr(%p) ", val);
-}
+void wasm::PrintPtr(uint8_t* val) { fprintf(stderr, "ptr(%p) ", val); }
 
-void wasm::PrintF32(float val)
-{
-  fprintf(stderr, "f32(%f) ", val);
-}
+void wasm::PrintF32(float val) { fprintf(stderr, "f32(%f) ", val); }
 
-void wasm::PrintF64(double val)
-{
-  fprintf(stderr, "f64(%lf) ", val);
-}
+void wasm::PrintF64(double val) { fprintf(stderr, "f64(%lf) ", val); }
 
-void wasm::PrintText(const char* out)
-{
-  fprintf(stderr, "%s", out);
-}
+void wasm::PrintText(const char* out) { fprintf(stderr, "%s", out); }
 #endif
 
 void* wasm::AddressOf(SymbolicAddress imm, ABIFunctionType* abiType) {
   switch (imm) {
     case SymbolicAddress::HandleDebugTrap:
       *abiType = Args_General0;
       return FuncCast(WasmHandleDebugTrap, *abiType);
     case SymbolicAddress::HandleThrow:
@@ -738,17 +723,17 @@ bool wasm::NeedsBuiltinThunk(SymbolicAdd
 #if defined(JS_CODEGEN_MIPS32)
     case SymbolicAddress::js_jit_gAtomic64Lock:
 #endif
 #ifdef WASM_CODEGEN_DEBUG
     case SymbolicAddress::PrintI32:
     case SymbolicAddress::PrintPtr:
     case SymbolicAddress::PrintF32:
     case SymbolicAddress::PrintF64:
-    case SymbolicAddress::PrintText: // Used only in stubs
+    case SymbolicAddress::PrintText:  // Used only in stubs
 #endif
       return false;
     case SymbolicAddress::ToInt32:
     case SymbolicAddress::DivI64:
     case SymbolicAddress::UDivI64:
     case SymbolicAddress::ModI64:
     case SymbolicAddress::UModI64:
     case SymbolicAddress::TruncateDoubleToUint64:
--- a/js/src/wasm/WasmCode.cpp
+++ b/js/src/wasm/WasmCode.cpp
@@ -1444,29 +1444,28 @@ uint8_t* Code::serialize(uint8_t* cursor
   if (!code || !code->initialize(linkData)) {
     return nullptr;
   }
 
   *out = code;
   return cursor;
 }
 
-void wasm::PatchDebugSymbolicAccesses(uint8_t* codeBase, MacroAssembler& masm)
-{
+void wasm::PatchDebugSymbolicAccesses(uint8_t* codeBase, MacroAssembler& masm) {
 #ifdef WASM_CODEGEN_DEBUG
   for (auto& access : masm.symbolicAccesses()) {
     switch (access.target) {
-     case SymbolicAddress::PrintI32:
-     case SymbolicAddress::PrintPtr:
-     case SymbolicAddress::PrintF32:
-     case SymbolicAddress::PrintF64:
-     case SymbolicAddress::PrintText:
-      break;
-     default:
-      MOZ_CRASH("unexpected symbol in PatchDebugSymbolicAccesses");
+      case SymbolicAddress::PrintI32:
+      case SymbolicAddress::PrintPtr:
+      case SymbolicAddress::PrintF32:
+      case SymbolicAddress::PrintF64:
+      case SymbolicAddress::PrintText:
+        break;
+      default:
+        MOZ_CRASH("unexpected symbol in PatchDebugSymbolicAccesses");
     }
     ABIFunctionType abiType;
     void* target = AddressOf(access.target, &abiType);
     uint8_t* patchAt = codeBase + access.patchAt.offset();
     Assembler::PatchDataWithValueCheck(CodeLocationLabel(patchAt),
                                        PatchedImmPtr(target),
                                        PatchedImmPtr((void*)-1));
   }
--- a/js/src/wasm/WasmInstance.cpp
+++ b/js/src/wasm/WasmInstance.cpp
@@ -436,17 +436,17 @@ Instance::memCopy(Instance* instance, ui
     bool mustTrap = false;
 
     // As we're supposed to write data until we trap we have to deal with
     // arithmetic overflow in the limit calculation.
     uint64_t highestDstOffset = uint64_t(dstByteOffset) + uint64_t(len - 1);
     uint64_t highestSrcOffset = uint64_t(srcByteOffset) + uint64_t(len - 1);
 
     bool copyDown =
-      srcByteOffset < dstByteOffset && dstByteOffset < highestSrcOffset;
+        srcByteOffset < dstByteOffset && dstByteOffset < highestSrcOffset;
 
     if (highestDstOffset >= memLen || highestSrcOffset >= memLen) {
       // We would read past the end of the source or write past the end of the
       // target.
       if (copyDown) {
         // We would trap on the first read or write, so don't read or write
         // anything.
         len = 0;
@@ -463,19 +463,18 @@ Instance::memCopy(Instance* instance, ui
 
     if (len > 0) {
       // The required write direction is indicated by `copyDown`, but apart from
       // the trap that may happen without writing anything, the direction is not
       // currently observable as there are no fences nor any read/write protect
       // operation.  So memmove is good enough to handle overlaps.
       SharedMem<uint8_t*> dataPtr = mem->buffer().dataPointerEither();
       if (mem->isShared()) {
-        AtomicOperations::memmoveSafeWhenRacy(dataPtr + dstByteOffset,
-                                              dataPtr + srcByteOffset,
-                                              size_t(len));
+        AtomicOperations::memmoveSafeWhenRacy(
+            dataPtr + dstByteOffset, dataPtr + srcByteOffset, size_t(len));
       } else {
         uint8_t* rawBuf = dataPtr.unwrap(/*Unshared*/);
         memmove(rawBuf + dstByteOffset, rawBuf + srcByteOffset, size_t(len));
       }
     }
 
     if (!mustTrap) {
       return 0;
@@ -612,19 +611,17 @@ Instance::memInit(Instance* instance, ui
     }
 
     if (len > 0) {
       // The required read/write direction is upward, but that is not currently
       // observable as there are no fences nor any read/write protect operation.
       SharedMem<uint8_t*> dataPtr = mem->buffer().dataPointerEither();
       if (mem->isShared()) {
         AtomicOperations::memcpySafeWhenRacy(
-          dataPtr + dstOffset,
-          (uint8_t*)seg.bytes.begin() + srcOffset,
-          len);
+            dataPtr + dstOffset, (uint8_t*)seg.bytes.begin() + srcOffset, len);
       } else {
         uint8_t* rawBuf = dataPtr.unwrap(/*Unshared*/);
         memcpy(rawBuf + dstOffset, (const char*)seg.bytes.begin() + srcOffset,
                len);
       }
     }
 
     if (!mustTrap) {
@@ -657,31 +654,32 @@ Instance::tableCopy(Instance* instance, 
     // Here, we know that |len - 1| cannot underflow.
     bool mustTrap = false;
 
     // As we're supposed to write data until we trap we have to deal with
     // arithmetic overflow in the limit calculation.
     uint64_t highestDstOffset = uint64_t(dstOffset) + (len - 1);
     uint64_t highestSrcOffset = uint64_t(srcOffset) + (len - 1);
 
-    bool copyDown =
-      srcOffset < dstOffset && dstOffset < highestSrcOffset;
+    bool copyDown = srcOffset < dstOffset && dstOffset < highestSrcOffset;
 
     if (highestDstOffset >= dstTableLen || highestSrcOffset >= srcTableLen) {
       // We would read past the end of the source or write past the end of the
       // target.
       if (copyDown) {
         // We would trap on the first read or write, so don't read or write
         // anything.
         len = 0;
       } else {
         // Compute what we have space for in target and what's available in the
         // source and pick the lowest value as the new len.
-        uint64_t srcAvail = srcTableLen < srcOffset ? 0 : srcTableLen - srcOffset;
-        uint64_t dstAvail = dstTableLen < dstOffset ? 0 : dstTableLen - dstOffset;
+        uint64_t srcAvail =
+            srcTableLen < srcOffset ? 0 : srcTableLen - srcOffset;
+        uint64_t dstAvail =
+            dstTableLen < dstOffset ? 0 : dstTableLen - dstOffset;
         MOZ_ASSERT(len > Min(srcAvail, dstAvail));
         len = uint32_t(Min(srcAvail, dstAvail));
       }
       mustTrap = true;
     }
 
     if (len > 0) {
       // The required write direction is indicated by `copyDown`, but apart from
@@ -1476,54 +1474,60 @@ bool Instance::callExport(JSContext* cx,
   // memory and then calls into the internal entry point. The return value is
   // stored in the first element of the array (which, therefore, must have
   // length >= 1).
   Vector<ExportArg, 8> exportArgs(cx);
   if (!exportArgs.resize(Max<size_t>(1, func.funcType().args().length()))) {
     return false;
   }
 
-  DebugCodegen(DebugChannel::Function, "wasm-function[%d]; arguments ", funcIndex);
+  DebugCodegen(DebugChannel::Function, "wasm-function[%d]; arguments ",
+               funcIndex);
   RootedValue v(cx);
   for (unsigned i = 0; i < func.funcType().args().length(); ++i) {
     v = i < args.length() ? args[i] : UndefinedValue();
     switch (func.funcType().arg(i).code()) {
       case ValType::I32:
         if (!ToInt32(cx, v, (int32_t*)&exportArgs[i])) {
           DebugCodegen(DebugChannel::Function, "call to ToInt32 failed!\n");
           return false;
         }
-        DebugCodegen(DebugChannel::Function, "i32(%d) ", *(int32_t*)&exportArgs[i]);
+        DebugCodegen(DebugChannel::Function, "i32(%d) ",
+                     *(int32_t*)&exportArgs[i]);
         break;
       case ValType::I64:
         MOZ_CRASH("unexpected i64 flowing into callExport");
       case ValType::F32:
         if (!RoundFloat32(cx, v, (float*)&exportArgs[i])) {
-          DebugCodegen(DebugChannel::Function, "call to RoundFloat32 failed!\n");
+          DebugCodegen(DebugChannel::Function,
+                       "call to RoundFloat32 failed!\n");
           return false;
         }
-        DebugCodegen(DebugChannel::Function, "f32(%f) ", *(float*)&exportArgs[i]);
+        DebugCodegen(DebugChannel::Function, "f32(%f) ",
+                     *(float*)&exportArgs[i]);
         break;
       case ValType::F64:
         if (!ToNumber(cx, v, (double*)&exportArgs[i])) {
           DebugCodegen(DebugChannel::Function, "call to ToNumber failed!\n");
           return false;
         }
-        DebugCodegen(DebugChannel::Function, "f64(%lf) ", *(double*)&exportArgs[i]);
+        DebugCodegen(DebugChannel::Function, "f64(%lf) ",
+                     *(double*)&exportArgs[i]);
         break;
       case ValType::Ref:
         MOZ_CRASH("temporarily unsupported Ref type in callExport");
       case ValType::AnyRef: {
         RootedAnyRef ar(cx, AnyRef::null());
         if (!BoxAnyRef(cx, v, &ar)) {
           DebugCodegen(DebugChannel::Function, "call to BoxAnyRef failed!\n");
           return false;
         }
         *(void**)&exportArgs[i] = ar.get().forCompiledCode();
-        DebugCodegen(DebugChannel::Function, "ptr(%p) ", *(void**)&exportArgs[i]);
+        DebugCodegen(DebugChannel::Function, "ptr(%p) ",
+                     *(void**)&exportArgs[i]);
         break;
       }
       case ValType::NullRef: {
         MOZ_CRASH("NullRef not expressible");
       }
     }
   }
 
@@ -1556,17 +1560,18 @@ bool Instance::callExport(JSContext* cx,
       return false;
     }
     args.rval().set(ObjectValue(*obj));
     return true;
   }
 
   void* retAddr = &exportArgs[0];
 
-  DebugCodegen(DebugChannel::Function, "wasm-function[%d]; returns ", funcIndex);
+  DebugCodegen(DebugChannel::Function, "wasm-function[%d]; returns ",
+               funcIndex);
   switch (func.funcType().ret().code()) {
     case ExprType::Void:
       args.rval().set(UndefinedValue());
       DebugCodegen(DebugChannel::Function, "void");
       break;
     case ExprType::I32:
       args.rval().set(Int32Value(*(int32_t*)retAddr));
       DebugCodegen(DebugChannel::Function, "i32(%d)", *(int32_t*)retAddr);
--- a/js/src/wasm/WasmIonCompile.cpp
+++ b/js/src/wasm/WasmIonCompile.cpp
@@ -4030,17 +4030,17 @@ bool wasm::IonCompileFunctions(const Mod
     Decoder d(func.begin, func.end, func.lineOrBytecode, error);
 
     // Build the local types vector.
 
     ValTypeVector locals;
     if (!locals.appendAll(env.funcTypes[func.index]->args())) {
       return false;
     }
-    if (!DecodeLocalEntries(d,  env.types, env.gcTypesEnabled(), &locals)) {
+    if (!DecodeLocalEntries(d, env.types, env.gcTypesEnabled(), &locals)) {
       return false;
     }
 
     // Set up for Ion compilation.
 
     const JitCompileOptions options;
     MIRGraph graph(&alloc);
     CompileInfo compileInfo(locals.length());
--- a/js/src/wasm/WasmJS.cpp
+++ b/js/src/wasm/WasmJS.cpp
@@ -1487,26 +1487,25 @@ static bool EnsureLazyEntryStub(const In
   } else {
     RootedAtom name(cx, NumberToAtom(cx, funcIndex));
     if (!name) {
       return false;
     }
 
     bool disableJitEntry = funcType.temporarilyUnsupportedAnyRef()
 #ifdef WASM_CODEGEN_DEBUG
-      || !JitOptions.enableWasmJitEntry;
+                           || !JitOptions.enableWasmJitEntry;
 #endif
     ;
 
     // Functions with anyref don't have jit entries yet, so they should
     // mostly behave like asm.js functions. Pretend it's the case, until
     // jit entries are implemented.
-    JSFunction::Flags flags = disableJitEntry
-                                  ? JSFunction::ASMJS_NATIVE
-                                  : JSFunction::WASM_FUN;
+    JSFunction::Flags flags =
+        disableJitEntry ? JSFunction::ASMJS_NATIVE : JSFunction::WASM_FUN;
 
     fun.set(NewNativeFunction(cx, WasmCall, numArgs, name,
                               gc::AllocKind::FUNCTION_EXTENDED, SingletonObject,
                               flags));
     if (!fun) {
       return false;
     }
 
--- a/js/src/wasm/WasmTypes.cpp
+++ b/js/src/wasm/WasmTypes.cpp
@@ -957,18 +957,17 @@ void wasm::Log(JSContext* cx, const char
       cx->clearPendingException();
     }
   }
 
   va_end(args);
 }
 
 #ifdef WASM_CODEGEN_DEBUG
-bool wasm::IsCodegenDebugEnabled(DebugChannel channel)
-{
+bool wasm::IsCodegenDebugEnabled(DebugChannel channel) {
   switch (channel) {
     case DebugChannel::Function:
       return JitOptions.enableWasmFuncCallSpew;
     case DebugChannel::Import:
       return JitOptions.enableWasmImportCallSpew;
   }
   return false;
 }
--- a/js/src/wasm/WasmValidate.cpp
+++ b/js/src/wasm/WasmValidate.cpp
@@ -2271,17 +2271,18 @@ static bool DecodeElemSection(Decoder& d
         break;
       }
       case InitializerKind::Passive: {
         uint8_t form;
         if (!d.readFixedU8(&form)) {
           return d.fail("expected type form");
         }
         if (form != uint8_t(TypeCode::AnyFunc)) {
-          return d.fail("passive segments can only contain function references");
+          return d.fail(
+              "passive segments can only contain function references");
         }
         break;
       }
     }
 
     uint32_t numElems;
     if (!d.readVarU32(&numElems)) {
       return d.fail("expected segment size");
--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -7253,17 +7253,16 @@ bool PresShell::EventHandler::MaybeDisca
       EmptyString());
 
   suppressedListener->HandleEvent(*event);
   return true;
 }
 
 nsIFrame* PresShell::EventHandler::MaybeFlushThrottledStyles(
     nsIFrame* aFrameForPresShell) {
-
   if (!GetDocument()) {
     // XXX Only when mPresShell has document, we'll try to look for a frame
     //     containing mPresShell even if given frame is nullptr.  Does this
     //     make sense?
     return aFrameForPresShell;
   }
 
   AutoWeakFrame weakFrameForPresShell(aFrameForPresShell);
--- a/layout/base/nsRefreshDriver.h
+++ b/layout/base/nsRefreshDriver.h
@@ -419,18 +419,17 @@ class nsRefreshDriver final : public moz
                                             uint32_t aDelay);
   static void CancelIdleRunnable(nsIRunnable* aRunnable);
 
   void NotifyDOMContentLoaded();
 
   // Schedule a refresh so that any delayed events will run soon.
   void RunDelayedEventsSoon();
 
-  void InitializeTimer()
-  {
+  void InitializeTimer() {
     MOZ_ASSERT(!mActiveTimer);
     EnsureTimerStarted();
   }
 
  private:
   typedef nsTObserverArray<nsARefreshObserver*> ObserverArray;
   typedef nsTArray<RefPtr<VVPResizeEvent>> VisualViewportResizeEventArray;
   typedef nsTArray<RefPtr<mozilla::Runnable>> ScrollEventArray;
--- a/layout/generic/ScrollAnchorContainer.cpp
+++ b/layout/generic/ScrollAnchorContainer.cpp
@@ -344,19 +344,18 @@ void ScrollAnchorContainer::ApplyAdjustm
       physicalAdjustment.x = -logicalAdjustment;
       break;
     }
   }
 
   MOZ_ASSERT(!mApplyingAnchorAdjustment);
   // We should use AutoRestore here, but that doesn't work with bitfields
   mApplyingAnchorAdjustment = true;
-  mScrollFrame->ScrollTo(
-      mScrollFrame->GetScrollPosition() + physicalAdjustment,
-      nsIScrollableFrame::INSTANT, nsGkAtoms::relative);
+  mScrollFrame->ScrollTo(mScrollFrame->GetScrollPosition() + physicalAdjustment,
+                         nsIScrollableFrame::INSTANT, nsGkAtoms::relative);
   mApplyingAnchorAdjustment = false;
 
   nsPresContext* pc = Frame()->PresContext();
   Document* doc = pc->Document();
   doc->UpdateForScrollAnchorAdjustment(logicalAdjustment);
 
   // The anchor position may not be in the same relative position after
   // adjustment. Update ourselves so we have consistent state.
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -1848,60 +1848,59 @@ bool BuildTextRunsScanner::ContinueTextR
       HasTerminalNewline(aFrame1)) {
     return false;
   }
 
   if (aFrame1->GetParent()->GetContent() !=
       aFrame2->GetParent()->GetContent()) {
     // Does aFrame, or any ancestor between it and aAncestor, have a property
     // that should inhibit cross-element-boundary shaping on aSide?
-    auto PreventCrossBoundaryShaping = [](const nsIFrame* aFrame,
-                                          const nsIFrame* aAncestor,
-                                          Side aSide) {
-      while (aFrame != aAncestor) {
-        ComputedStyle* ctx = aFrame->Style();
-        // According to https://drafts.csswg.org/css-text/#boundary-shaping:
-        //
-        // Text shaping must be broken at inline box boundaries when any of the
-        // following are true for any box whose boundary separates the two
-        // typographic character units:
-        //
-        // 1. Any of margin/border/padding separating the two typographic
-        //    character units in the inline axis is non-zero.
-        const auto& margin = ctx->StyleMargin()->mMargin.Get(aSide);
-        if (!margin.ConvertsToLength() ||
-            margin.AsLengthPercentage().ToLength() != 0) {
-          return true;
-        }
-        const auto& padding = ctx->StylePadding()->mPadding.Get(aSide);
-        if (!padding.ConvertsToLength() || padding.ToLength() != 0) {
-          return true;
-        }
-        if (ctx->StyleBorder()->GetComputedBorderWidth(aSide) != 0) {
-          return true;
-        }
-
-        // 2. vertical-align is not baseline.
-        const nsStyleCoord& coord = ctx->StyleDisplay()->mVerticalAlign;
-        if (coord.GetUnit() != eStyleUnit_Enumerated ||
-            coord.GetIntValue() != NS_STYLE_VERTICAL_ALIGN_BASELINE) {
-          return true;
-        }
-
-        // 3. The boundary is a bidi isolation boundary.
-        const uint8_t unicodeBidi = ctx->StyleTextReset()->mUnicodeBidi;
-        if (unicodeBidi == NS_STYLE_UNICODE_BIDI_ISOLATE ||
-            unicodeBidi == NS_STYLE_UNICODE_BIDI_ISOLATE_OVERRIDE) {
-          return true;
-        }
-
-        aFrame = aFrame->GetParent();
-      }
-      return false;
-    };
+    auto PreventCrossBoundaryShaping =
+        [](const nsIFrame* aFrame, const nsIFrame* aAncestor, Side aSide) {
+          while (aFrame != aAncestor) {
+            ComputedStyle* ctx = aFrame->Style();
+            // According to https://drafts.csswg.org/css-text/#boundary-shaping:
+            //
+            // Text shaping must be broken at inline box boundaries when any of
+            // the following are true for any box whose boundary separates the
+            // two typographic character units:
+            //
+            // 1. Any of margin/border/padding separating the two typographic
+            //    character units in the inline axis is non-zero.
+            const auto& margin = ctx->StyleMargin()->mMargin.Get(aSide);
+            if (!margin.ConvertsToLength() ||
+                margin.AsLengthPercentage().ToLength() != 0) {
+              return true;
+            }
+            const auto& padding = ctx->StylePadding()->mPadding.Get(aSide);
+            if (!padding.ConvertsToLength() || padding.ToLength() != 0) {
+              return true;
+            }
+            if (ctx->StyleBorder()->GetComputedBorderWidth(aSide) != 0) {
+              return true;
+            }
+
+            // 2. vertical-align is not baseline.
+            const nsStyleCoord& coord = ctx->StyleDisplay()->mVerticalAlign;
+            if (coord.GetUnit() != eStyleUnit_Enumerated ||
+                coord.GetIntValue() != NS_STYLE_VERTICAL_ALIGN_BASELINE) {
+              return true;
+            }
+
+            // 3. The boundary is a bidi isolation boundary.
+            const uint8_t unicodeBidi = ctx->StyleTextReset()->mUnicodeBidi;
+            if (unicodeBidi == NS_STYLE_UNICODE_BIDI_ISOLATE ||
+                unicodeBidi == NS_STYLE_UNICODE_BIDI_ISOLATE_OVERRIDE) {
+              return true;
+            }
+
+            aFrame = aFrame->GetParent();
+          }
+          return false;
+        };
 
     const nsIFrame* ancestor =
         nsLayoutUtils::FindNearestCommonAncestorFrame(aFrame1, aFrame2);
     MOZ_ASSERT(ancestor);
 
     // Map inline-end and inline-start to physical sides for checking presence
     // of non-zero margin/border/padding.
     Side side1 = wm.PhysicalSide(eLogicalSideIEnd);
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -7944,31 +7944,31 @@ bool nsDisplayTransform::CreateWebRender
     // we can just stash the transform on the StackingContextHelper and
     // apply it to any scroll data that are created inside this
     // nsDisplayTransform.
     deferredTransformItem = Some(this);
   }
 
   // Determine if we're possibly animated (= would need an active layer in FLB).
   bool animated =
-    ActiveLayerTracker::IsStyleMaybeAnimated(Frame(), eCSSProperty_transform);
+      ActiveLayerTracker::IsStyleMaybeAnimated(Frame(), eCSSProperty_transform);
 
   wr::StackingContextParams params;
   params.mBoundTransform = &newTransformMatrix;
   params.animation = animationsId ? &prop : nullptr;
   params.mTransformPtr = transformForSC;
   params.is_backface_visible = !BackfaceIsHidden();
   params.mDeferredTransformItem = deferredTransformItem;
   params.mAnimated = animated;
   // Determine if we would have to rasterize any items in local raster space
   // (i.e. disable subpixel AA). We don't always need to rasterize locally even
   // if the stacking context is possibly animated (at the cost of potentially
   // some false negatives with respect to will-change handling), so we pass in
-  // this determination separately to accurately match with when FLB would normally
-  // disable subpixel AA.
+  // this determination separately to accurately match with when FLB would
+  // normally disable subpixel AA.
   params.mRasterizeLocally = animated && Frame()->HasAnimationOfTransform();
   params.SetPreserve3D(mFrame->Extend3DContext() && !mIsTransformSeparator);
   params.clip =
       wr::WrStackingContextClip::ClipChain(aBuilder.CurrentClipChainId());
 
   StackingContextHelper sc(aSc, GetActiveScrolledRoot(), mFrame, this, aBuilder,
                            params,
                            LayoutDeviceRect(position, LayoutDeviceSize()));
--- a/layout/style/ComputedStyle.cpp
+++ b/layout/style/ComputedStyle.cpp
@@ -172,24 +172,25 @@ nsChangeHint ComputedStyle::CalcStyleDif
     bool change = false;
 
     // NB: Calling Peek on |this|, not |thisVis|, since callers may look
     // at a struct on |this| without looking at the same struct on
     // |thisVis| (including this function if we skip one of these checks
     // due to change being true already or due to the old style not having a
     // style-if-visited), but not the other way around.
 #define STYLE_FIELD(name_) thisVisStruct->name_ != otherVisStruct->name_
-#define STYLE_STRUCT(name_, fields_) {                                       \
-  const nsStyle##name_* thisVisStruct = thisVis->Style##name_();             \
-  const nsStyle##name_* otherVisStruct = otherVis->Style##name_();           \
-  if (MOZ_FOR_EACH_SEPARATED(STYLE_FIELD, (||), (), fields_)) {              \
-    *aEqualStructs &= ~STYLE_STRUCT_BIT(name_);                              \
-    change = true;                                                           \
-  }                                                                          \
-}
+#define STYLE_STRUCT(name_, fields_)                                 \
+  {                                                                  \
+    const nsStyle##name_* thisVisStruct = thisVis->Style##name_();   \
+    const nsStyle##name_* otherVisStruct = otherVis->Style##name_(); \
+    if (MOZ_FOR_EACH_SEPARATED(STYLE_FIELD, (||), (), fields_)) {    \
+      *aEqualStructs &= ~STYLE_STRUCT_BIT(name_);                    \
+      change = true;                                                 \
+    }                                                                \
+  }
 #include "nsCSSVisitedDependentPropList.h"
 #undef STYLE_STRUCT
 #undef STYLE_FIELD
 #undef STYLE_STRUCT_BIT
 
     if (change) {
       hint |= nsChangeHint_RepaintFrame;
     }
--- a/layout/style/ComputedStyle.h
+++ b/layout/style/ComputedStyle.h
@@ -272,17 +272,16 @@ class ComputedStyle {
 #endif
 
   // The |aCVsSize| outparam on this function is where the actual CVs size
   // value is added. It's done that way because the callers know which value
   // the size should be added to.
   void AddSizeOfIncludingThis(nsWindowSizes& aSizes, size_t* aCVsSize) const;
 
  protected:
-
   // Needs to be friend so that it can call the destructor without making it
   // public.
   friend void ::Gecko_ComputedStyle_Destroy(ComputedStyle*);
 
   ~ComputedStyle() = default;
 
   ServoComputedData mSource;
 
--- a/media/mtransport/test/ice_unittest.cpp
+++ b/media/mtransport/test/ice_unittest.cpp
@@ -717,17 +717,18 @@ class IceTestPeer : public sigslot::has_
 
     remote_ = remote;
 
     trickle_mode_ = trickle_mode;
     ice_connected_ = false;
     ice_failed_ = false;
     ice_reached_checking_ = false;
     res = ice_ctx_->ParseGlobalAttributes(remote->GetGlobalAttributes());
-    ASSERT_FALSE(remote->simulate_ice_lite_ && (ice_ctx_->GetControlling() == NrIceCtx::ICE_CONTROLLED));
+    ASSERT_FALSE(remote->simulate_ice_lite_ &&
+                 (ice_ctx_->GetControlling() == NrIceCtx::ICE_CONTROLLED));
     ASSERT_TRUE(NS_SUCCEEDED(res));
 
     for (size_t i = 0; i < stream_counter_; ++i) {
       auto aStream = GetStream_s(i);
       if (aStream) {
         std::vector<std::string> attributes = remote->GetAttributes(i);
 
         for (auto it = attributes.begin(); it != attributes.end();) {
--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
@@ -2837,17 +2837,17 @@ RefPtr<RTCStatsQueryPromise> PeerConnect
             s.mMediaType.Construct(
                 kind);  // mediaType is the old name for kind.
             s.mKind.Construct(kind);
             s.mJitter.Construct(double(jitterMs) / 1000);
             s.mLocalId.Construct(localId);
             s.mPacketsReceived.Construct(packetsReceived);
             s.mBytesReceived.Construct(bytesReceived);
             s.mPacketsLost.Construct(packetsLost);
-            if (rtt > 0) { // RTT is not reported when it is zero
+            if (rtt > 0) {  // RTT is not reported when it is zero
               s.mRoundTripTime.Construct(static_cast<double>(rtt) / 1000);
             }
             query->report->mInboundRTPStreamStats.Value().AppendElement(
                 s, fallible);
           }
         }
         // Then, fill in local side (with cross-link to remote only if present)
         {
@@ -2990,18 +2990,17 @@ RefPtr<RTCStatsQueryPromise> PeerConnect
 
   std::string transportId;
   if (!query->grabAllLevels) {
     transportId = query->transportId;
   }
   auto report = std::move(query->report);
   auto now = query->now;
 
-  return aTransportHandler
-      ->GetIceStats(transportId, now, std::move(report))
+  return aTransportHandler->GetIceStats(transportId, now, std::move(report))
       ->Then(
           GetMainThreadSerialEventTarget(), __func__,
           [query = std::move(query)](
               std::unique_ptr<dom::RTCStatsReportInternal>&& aReport) mutable {
             query->report = std::move(aReport);
             return RTCStatsQueryPromise::CreateAndResolve(std::move(query),
                                                           __func__);
           },
--- a/modules/libjar/nsJARChannel.cpp
+++ b/modules/libjar/nsJARChannel.cpp
@@ -836,17 +836,16 @@ nsJARChannel::Open(nsIInputStream **aStr
   rv = CreateJarInput(gJarHandler->JarCache(), getter_AddRefs(input));
   if (NS_FAILED(rv)) return rv;
 
   input.forget(aStream);
   mOpened = true;
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
 nsJARChannel::AsyncOpen(nsIStreamListener *aListener) {
   LOG(("nsJARChannel::AsyncOpen [this=%p]\n", this));
   nsCOMPtr<nsIStreamListener> listener = aListener;
   nsresult rv =
       nsContentSecurityManager::doContentSecurityCheck(this, listener);
   if (NS_FAILED(rv)) {
     mIsPending = false;
--- a/netwerk/base/Predictor.cpp
+++ b/netwerk/base/Predictor.cpp
@@ -1275,18 +1275,18 @@ nsresult Predictor::Prefetch(nsIURI *uri
   }
 
   rv = httpChannel->SetReferrer(referrer);
   NS_ENSURE_SUCCESS(rv, rv);
   // XXX - set a header here to indicate this is a prefetch?
 
   nsCOMPtr<nsIStreamListener> listener =
       new PrefetchListener(verifier, uri, this);
-  PREDICTOR_LOG(("    calling AsyncOpen listener=%p channel=%p",
-                 listener.get(), channel.get()));
+  PREDICTOR_LOG(("    calling AsyncOpen listener=%p channel=%p", listener.get(),
+                 channel.get()));
   rv = channel->AsyncOpen(listener);
   if (NS_FAILED(rv)) {
     PREDICTOR_LOG(
         ("    AsyncOpen failed rv=0x%" PRIX32, static_cast<uint32_t>(rv)));
   }
 
   return rv;
 }
--- a/netwerk/base/nsNetUtil.cpp
+++ b/netwerk/base/nsNetUtil.cpp
@@ -2353,23 +2353,23 @@ nsresult NS_LinkRedirectChannels(uint32_
   nsCOMPtr<nsIRedirectChannelRegistrar> registrar =
       RedirectChannelRegistrar::GetOrCreate();
   MOZ_ASSERT(registrar);
 
   return registrar->LinkChannels(channelId, parentChannel, _result);
 }
 
 nsresult NS_MaybeOpenChannelUsingOpen(nsIChannel *aChannel,
-                                       nsIInputStream **aStream) {
+                                      nsIInputStream **aStream) {
   nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
   return aChannel->Open(aStream);
 }
 
 nsresult NS_MaybeOpenChannelUsingAsyncOpen(nsIChannel *aChannel,
-                                            nsIStreamListener *aListener) {
+                                           nsIStreamListener *aListener) {
   nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
   return aChannel->AsyncOpen(aListener);
 }
 
 /** Given the first (disposition) token from a Content-Disposition header,
  * tell whether it indicates the content is inline or attachment
  * @param aDispToken the disposition token from the content-disposition header
  */
--- a/netwerk/dns/TRRService.cpp
+++ b/netwerk/dns/TRRService.cpp
@@ -313,19 +313,19 @@ TRRService::Observe(nsISupports *aSubjec
   } else if (!strcmp(aTopic, kOpenCaptivePortalLoginEvent)) {
     // We are in a captive portal
     LOG(("TRRservice in captive portal\n"));
     mCaptiveIsPassed = false;
   } else if (!strcmp(aTopic, NS_CAPTIVE_PORTAL_CONNECTIVITY)) {
     nsAutoCString data = NS_ConvertUTF16toUTF8(aData);
     LOG(("TRRservice captive portal was %s\n", data.get()));
     if (!mTRRBLStorage) {
-     // We need a lock if we modify mTRRBLStorage variable because it is
-     // access off the main thread as well.
-     MutexAutoLock lock(mLock);
+      // We need a lock if we modify mTRRBLStorage variable because it is
+      // access off the main thread as well.
+      MutexAutoLock lock(mLock);
       mTRRBLStorage = DataStorage::Get(DataStorageClass::TRRBlacklist);
       if (mTRRBLStorage) {
         bool storageWillPersist = true;
         if (NS_FAILED(mTRRBLStorage->Init(storageWillPersist))) {
           mTRRBLStorage = nullptr;
         }
         if (mClearTRRBLStorage) {
           if (mTRRBLStorage) {
@@ -374,17 +374,18 @@ void TRRService::MaybeConfirm_locked() {
 
   if (mConfirmationNS.Equals("skip")) {
     LOG(("TRRService starting confirmation test %s SKIPPED\n",
          mPrivateURI.get()));
     mConfirmationState = CONFIRM_OK;
   } else {
     LOG(("TRRService starting confirmation test %s %s\n", mPrivateURI.get(),
          mConfirmationNS.get()));
-    mConfirmer = new TRR(this, mConfirmationNS, TRRTYPE_NS, EmptyCString(), false);
+    mConfirmer =
+        new TRR(this, mConfirmationNS, TRRTYPE_NS, EmptyCString(), false);
     NS_DispatchToMainThread(mConfirmer);
   }
 }
 
 bool TRRService::MaybeBootstrap(const nsACString &aPossible,
                                 nsACString &aResult) {
   MutexAutoLock lock(mLock);
   if (TRR_DISABLED(mMode) || mBootstrapAddr.IsEmpty()) {
@@ -620,18 +621,18 @@ AHostResolver::LookupStatus TRRService::
     MOZ_ASSERT(!mConfirmer || (mConfirmationState == CONFIRM_TRYING));
   }
 #endif
   if (mConfirmationState == CONFIRM_TRYING) {
     {
       MutexAutoLock lock(mLock);
       MOZ_ASSERT(mConfirmer);
       mConfirmationState = NS_SUCCEEDED(status) ? CONFIRM_OK : CONFIRM_FAILED;
-      LOG(("TRRService finishing confirmation test %s %d %X\n", mPrivateURI.get(),
-           (int)mConfirmationState, (unsigned int)status));
+      LOG(("TRRService finishing confirmation test %s %d %X\n",
+           mPrivateURI.get(), (int)mConfirmationState, (unsigned int)status));
       mConfirmer = nullptr;
     }
     if (mConfirmationState == CONFIRM_FAILED) {
       // retry failed NS confirmation
       NS_NewTimerWithCallback(getter_AddRefs(mRetryConfirmTimer), this,
                               mRetryConfirmInterval, nsITimer::TYPE_ONE_SHOT);
       if (mRetryConfirmInterval < 64000) {
         // double the interval up to this point
--- a/netwerk/dns/TRRService.h
+++ b/netwerk/dns/TRRService.h
@@ -85,19 +85,19 @@ class TRRService : public nsIObserver,
   Atomic<bool, Relaxed> mUseGET;  // do DOH using GET requests (instead of POST)
   Atomic<bool, Relaxed> mEarlyAAAA;  // allow use of AAAA results before A is in
   Atomic<bool, Relaxed> mDisableIPv6;  // don't even try
   Atomic<bool, Relaxed> mDisableECS;   // disable EDNS Client Subnet in requests
   Atomic<uint32_t, Relaxed>
       mDisableAfterFails;  // this many fails in a row means failed TRR service
 
   // TRR Blacklist storage
-  // mTRRBLStorage is only modified on the main thread, but we query whether it is initialized or not
-  // off the main thread as well. Therefore we need to lock while creating it and while accessing it
-  // off the main thread.
+  // mTRRBLStorage is only modified on the main thread, but we query whether it
+  // is initialized or not off the main thread as well. Therefore we need to
+  // lock while creating it and while accessing it off the main thread.
   RefPtr<DataStorage> mTRRBLStorage;
   Atomic<bool, Relaxed> mClearTRRBLStorage;
 
   enum ConfirmationState {
     CONFIRM_INIT = 0,
     CONFIRM_TRYING = 1,
     CONFIRM_OK = 2,
     CONFIRM_FAILED = 3
--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -2375,17 +2375,16 @@ HttpChannelChild::Resume() {
 
 NS_IMETHODIMP
 HttpChannelChild::GetSecurityInfo(nsISupports** aSecurityInfo) {
   NS_ENSURE_ARG_POINTER(aSecurityInfo);
   NS_IF_ADDREF(*aSecurityInfo = mSecurityInfo);
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
 HttpChannelChild::AsyncOpen(nsIStreamListener* aListener) {
   nsCOMPtr<nsIStreamListener> listener = aListener;
   nsresult rv =
       nsContentSecurityManager::doContentSecurityCheck(this, listener);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     ReleaseListeners();
     return rv;
--- a/netwerk/protocol/http/TunnelUtils.cpp
+++ b/netwerk/protocol/http/TunnelUtils.cpp
@@ -341,17 +341,18 @@ nsresult TLSFilterTransaction::ReadSegme
     return NS_ERROR_UNEXPECTED;
   }
 
   mReadSegmentReturnValue = NS_OK;
   mSegmentReader = aReader;
   nsresult rv = mTransaction->ReadSegments(this, aCount, outCountRead);
   LOG(("TLSFilterTransaction %p called trans->ReadSegments rv=%" PRIx32 " %d\n",
        this, static_cast<uint32_t>(rv), *outCountRead));
-  if (NS_SUCCEEDED(rv) && (mReadSegmentReturnValue == NS_BASE_STREAM_WOULD_BLOCK)) {
+  if (NS_SUCCEEDED(rv) &&
+      (mReadSegmentReturnValue == NS_BASE_STREAM_WOULD_BLOCK)) {
     LOG(("TLSFilterTransaction %p read segment blocked found rv=%" PRIx32 "\n",
          this, static_cast<uint32_t>(rv)));
     Unused << Connection()->ForceSend();
   }
 
   return NS_SUCCEEDED(rv) ? mReadSegmentReturnValue : rv;
 }
 
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -3148,17 +3148,16 @@ nsresult nsHttpChannel::ContinueDoReplac
   if (NS_FAILED(rv)) return rv;
 
   MOZ_ASSERT(mRedirectChannel, "No redirect channel?");
 
   // Make sure to do this after we received redirect veto answer,
   // i.e. after all sinks had been notified
   mRedirectChannel->SetOriginalURI(mOriginalURI);
 
-
   // open new channel
   rv = mRedirectChannel->AsyncOpen(mListener);
   NS_ENSURE_SUCCESS(rv, rv);
 
   mStatus = NS_BINDING_REDIRECTED;
 
   notifier.RedirectSucceeded();
 
--- a/netwerk/protocol/res/ExtensionProtocolHandler.cpp
+++ b/netwerk/protocol/res/ExtensionProtocolHandler.cpp
@@ -440,17 +440,17 @@ nsresult ExtensionProtocolHandler::Subst
     return NS_OK;
   }
 
   // Filter CSS files to replace locale message tokens with localized strings.
 
   nsCOMPtr<nsIChannel> channel = NS_NewSimpleChannel(
       aURI, aLoadInfo, *result,
       [](nsIStreamListener* listener, nsIChannel* channel,
-                     nsIChannel* origChannel) -> RequestOrReason {
+         nsIChannel* origChannel) -> RequestOrReason {
         nsresult rv;
         nsCOMPtr<nsIStreamConverterService> convService =
             do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv);
         MOZ_TRY(rv);
 
         nsCOMPtr<nsIURI> uri;
         MOZ_TRY(channel->GetURI(getter_AddRefs(uri)));
 
--- a/security/certverifier/NSSCertDBTrustDomain.h
+++ b/security/certverifier/NSSCertDBTrustDomain.h
@@ -214,18 +214,18 @@ class NSSCertDBTrustDomain : public mozi
   ValidityCheckingMode mValidityCheckingMode;
   CertVerifier::SHA1Mode mSHA1Mode;
   NetscapeStepUpPolicy mNetscapeStepUpPolicy;
   DistrustedCAPolicy mDistrustedCAPolicy;
   bool mSawDistrustedCAByPolicyError;
   const OriginAttributes& mOriginAttributes;
   const Vector<mozilla::pkix::Input>& mThirdPartyRootInputs;  // non-owning
   const Vector<mozilla::pkix::Input>&
-      mThirdPartyIntermediateInputs;                          // non-owning
-  UniqueCERTCertList& mBuiltChain;                            // non-owning
+      mThirdPartyIntermediateInputs;  // non-owning
+  UniqueCERTCertList& mBuiltChain;    // non-owning
   PinningTelemetryInfo* mPinningTelemetryInfo;
   const char* mHostname;  // non-owning - only used for pinning checks
   nsCOMPtr<nsICertBlocklist> mCertBlocklist;
   CertVerifier::OCSPStaplingStatus mOCSPStaplingStatus;
   // Certificate Transparency data extracted during certificate verification
   UniqueSECItem mSCTListFromCertificate;
   UniqueSECItem mSCTListFromOCSPStapling;
 };
--- a/toolkit/recordreplay/ProcessRewind.cpp
+++ b/toolkit/recordreplay/ProcessRewind.cpp
@@ -241,19 +241,17 @@ bool HasSavedCheckpoint() {
   return gRewindInfo && !gRewindInfo->mSavedCheckpoints.empty();
 }
 
 CheckpointId GetLastSavedCheckpoint() {
   MOZ_RELEASE_ASSERT(HasSavedCheckpoint());
   return gRewindInfo->mSavedCheckpoints.back().mCheckpoint;
 }
 
-CheckpointId
-GetLastSavedCheckpointPriorTo(const CheckpointId& aCheckpoint)
-{
+CheckpointId GetLastSavedCheckpointPriorTo(const CheckpointId& aCheckpoint) {
   MOZ_RELEASE_ASSERT(HasSavedCheckpoint());
   for (size_t i = gRewindInfo->mSavedCheckpoints.length() - 1; i >= 1; i--) {
     if (gRewindInfo->mSavedCheckpoints[i].mCheckpoint == aCheckpoint) {
       return gRewindInfo->mSavedCheckpoints[i - 1].mCheckpoint;
     }
   }
   MOZ_CRASH("GetLastSavedCheckpointPriorTo");
 }
--- a/toolkit/recordreplay/ipc/ChildIPC.cpp
+++ b/toolkit/recordreplay/ipc/ChildIPC.cpp
@@ -538,17 +538,18 @@ static void PaintFromMainThread() {
     // so don't send a Paint message.
     return;
   }
 
   // If all paints have completed, the compositor cannot be simultaneously
   // operating on the draw target buffer.
   MOZ_RELEASE_ASSERT(!gNumPendingPaints);
 
-  if (IsActiveChild() && navigation::ShouldSendPaintMessage() && gDrawTargetBuffer) {
+  if (IsActiveChild() && navigation::ShouldSendPaintMessage() &&
+      gDrawTargetBuffer) {
     memcpy(gGraphicsShmem, gDrawTargetBuffer, gDrawTargetBufferSize);
     gChannel->SendMessage(PaintMessage(navigation::LastNormalCheckpoint(),
                                        gPaintWidth, gPaintHeight));
   }
 }
 
 void NotifyPaintComplete() {
   MOZ_RELEASE_ASSERT(!gCompositorThreadId ||
--- a/toolkit/recordreplay/ipc/ChildNavigation.cpp
+++ b/toolkit/recordreplay/ipc/ChildNavigation.cpp
@@ -269,17 +269,18 @@ class FindLastHitPhase final : public Na
   void OnRegionEnd();
 
  public:
   // Note: this always rewinds.
   void Enter(const CheckpointId& aStart, const ExecutionPoint& aEnd,
              bool aIncludeEnd);
 
   void ToString(nsAutoCString& aStr) override {
-    aStr.AppendPrintf("FindLastHit #%zu:%zu", mStart.mNormal, mStart.mTemporary);
+    aStr.AppendPrintf("FindLastHit #%zu:%zu", mStart.mNormal,
+                      mStart.mTemporary);
     mEnd.ToString(aStr);
   }
 
   void AfterCheckpoint(const CheckpointId& aCheckpoint) override;
   void PositionHit(const ExecutionPoint& aPoint) override;
   void HitRecordingEndpoint(const ExecutionPoint& aPoint) override;
   bool ShouldSendPaintMessage() override;
 };
@@ -404,19 +405,17 @@ class NavigationState {
   bool MaybeDivergeFromRecording() {
     return mPhase->MaybeDivergeFromRecording();
   }
 
   ExecutionPoint CurrentExecutionPoint() {
     return mPhase->CurrentExecutionPoint();
   }
 
-  bool ShouldSendPaintMessage() {
-    return mPhase->ShouldSendPaintMessage();
-  }
+  bool ShouldSendPaintMessage() { return mPhase->ShouldSendPaintMessage(); }
 
   void SetRecordingEndpoint(size_t aIndex, const ExecutionPoint& aEndpoint) {
     // Ignore endpoints older than the last one we know about.
     if (aIndex <= mRecordingEndpointIndex) {
       return;
     }
     MOZ_RELEASE_ASSERT(mRecordingEndpoint.mCheckpoint <= aEndpoint.mCheckpoint);
     mRecordingEndpointIndex = aIndex;
@@ -463,19 +462,18 @@ class NavigationState {
 };
 
 static NavigationState* gNavigation;
 
 // When searching backwards in the execution space, we need to ignore any
 // temporary checkpoints associated with old normal checkpoints. We don't
 // remember what execution points these old temporary checkpoints are
 // associated with.
-static CheckpointId
-SkipUnknownTemporaryCheckpoints(const CheckpointId& aCheckpoint)
-{
+static CheckpointId SkipUnknownTemporaryCheckpoints(
+    const CheckpointId& aCheckpoint) {
   CheckpointId rval = aCheckpoint;
   while (rval.mTemporary &&
          rval.mNormal != gNavigation->LastCheckpoint().mNormal) {
     rval = GetLastSavedCheckpointPriorTo(rval);
   }
   return rval;
 }
 
@@ -556,17 +554,18 @@ void PausedPhase::Resume(bool aForward) 
   }
 
   // Skip to the previous saved checkpoint if we are paused at a checkpoint.
   if (!mPoint.HasPosition() && start == CheckpointId(mPoint.mCheckpoint)) {
     start = GetLastSavedCheckpointPriorTo(start);
   }
 
   start = SkipUnknownTemporaryCheckpoints(start);
-  gNavigation->mFindLastHitPhase.Enter(start, mPoint, /* aIncludeEnd = */ false);
+  gNavigation->mFindLastHitPhase.Enter(start, mPoint,
+                                       /* aIncludeEnd = */ false);
   Unreachable();
 }
 
 void PausedPhase::RestoreCheckpoint(size_t aCheckpoint) {
   ExecutionPoint target = gNavigation->CheckpointExecutionPoint(aCheckpoint);
   bool rewind = target != mPoint;
   Enter(target, rewind, /* aRecordingEndpoint = */ false);
 }
@@ -784,21 +783,17 @@ void ForwardPhase::PositionHit(const Exe
   }
 }
 
 void ForwardPhase::HitRecordingEndpoint(const ExecutionPoint& aPoint) {
   gNavigation->mPausedPhase.Enter(aPoint, /* aRewind = */ false,
                                   /* aRecordingEndpoint = */ true);
 }
 
-bool
-ForwardPhase::ShouldSendPaintMessage()
-{
-  return true;
-}
+bool ForwardPhase::ShouldSendPaintMessage() { return true; }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ReachBreakpointPhase
 ///////////////////////////////////////////////////////////////////////////////
 
 void ReachBreakpointPhase::Enter(
     const CheckpointId& aStart, bool aRewind, const ExecutionPoint& aPoint,
     const Maybe<ExecutionPoint>& aTemporaryCheckpoint) {
@@ -864,19 +859,17 @@ void ReachBreakpointPhase::PositionHit(c
     }
   }
 
   if (mPoint == aPoint) {
     gNavigation->mPausedPhase.Enter(aPoint);
   }
 }
 
-bool
-ReachBreakpointPhase::ShouldSendPaintMessage()
-{
+bool ReachBreakpointPhase::ShouldSendPaintMessage() {
   // We don't need to send paint messages when reaching the breakpoint, as we
   // will be pausing at the breakpoint and doing a repaint of the state there.
   return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // FindLastHitPhase
 ///////////////////////////////////////////////////////////////////////////////
@@ -956,19 +949,17 @@ void FindLastHitPhase::CheckForRegionEnd
   }
 }
 
 void FindLastHitPhase::HitRecordingEndpoint(const ExecutionPoint& aPoint) {
   OnRegionEnd();
   Unreachable();
 }
 
-bool
-FindLastHitPhase::ShouldSendPaintMessage()
-{
+bool FindLastHitPhase::ShouldSendPaintMessage() {
   // If the region we're searching contains multiple normal checkpoints, we
   // only want to send paint messages for the first one. We won't pause at the
   // later checkpoints, and sending paint messages for them will clobber the
   // one for the checkpoint we will end up pausing at.
   return gNavigation->LastCheckpoint().mNormal == mStart.mNormal;
 }
 
 const FindLastHitPhase::TrackedPosition& FindLastHitPhase::FindTrackedPosition(
@@ -1192,15 +1183,13 @@ ExecutionPoint TimeWarpTargetExecutionPo
   return ExecutionPoint(checkpoint, aTarget,
                         BreakpointPosition(BreakpointPosition::WarpTarget));
 }
 
 bool MaybeDivergeFromRecording() {
   return gNavigation->MaybeDivergeFromRecording();
 }
 
-bool ShouldSendPaintMessage() {
-  return gNavigation->ShouldSendPaintMessage();
-}
+bool ShouldSendPaintMessage() { return gNavigation->ShouldSendPaintMessage(); }
 
 }  // namespace navigation
 }  // namespace recordreplay
 }  // namespace mozilla
--- a/toolkit/xre/nsGDKErrorHandler.cpp
+++ b/toolkit/xre/nsGDKErrorHandler.cpp
@@ -32,53 +32,65 @@ static void GdkErrorHandler(const gchar 
     char *endptr;
 
     /* Parse Gdk X Window error message which has this format:
      * (Details: serial XXXX error_code XXXX request_code XXXX (XXXX) minor_code
      * XXXX)
      */
     NS_NAMED_LITERAL_CSTRING(serialString, "(Details: serial ");
     int32_t start = buffer.Find(serialString);
-    if (start == kNotFound) { MOZ_CRASH_UNSAFE(message); }
+    if (start == kNotFound) {
+      MOZ_CRASH_UNSAFE(message);
+    }
 
     start += serialString.Length();
     errno = 0;
     event.serial = strtol(buffer.BeginReading() + start, &endptr, 10);
-    if (errno) { MOZ_CRASH_UNSAFE(message); }
+    if (errno) {
+      MOZ_CRASH_UNSAFE(message);
+    }
 
     NS_NAMED_LITERAL_CSTRING(errorCodeString, " error_code ");
     if (!StringBeginsWith(Substring(endptr, buffer.EndReading()),
                           errorCodeString)) {
       MOZ_CRASH_UNSAFE(message);
     }
 
     errno = 0;
     event.error_code = strtol(endptr + errorCodeString.Length(), &endptr, 10);
-    if (errno) { MOZ_CRASH_UNSAFE(message); }
+    if (errno) {
+      MOZ_CRASH_UNSAFE(message);
+    }
 
     NS_NAMED_LITERAL_CSTRING(requestCodeString, " request_code ");
     if (!StringBeginsWith(Substring(endptr, buffer.EndReading()),
                           requestCodeString)) {
       MOZ_CRASH_UNSAFE(message);
     }
 
     errno = 0;
     event.request_code =
         strtol(endptr + requestCodeString.Length(), &endptr, 10);
-    if (errno) { MOZ_CRASH_UNSAFE(message); }
+    if (errno) {
+      MOZ_CRASH_UNSAFE(message);
+    }
 
     NS_NAMED_LITERAL_CSTRING(minorCodeString, " minor_code ");
     start = buffer.Find(minorCodeString, /* aIgnoreCase = */ false,
                         endptr - buffer.BeginReading());
-    if (!start) { MOZ_CRASH_UNSAFE(message); }
+    if (!start) {
+      MOZ_CRASH_UNSAFE(message);
+    }
 
     errno = 0;
     event.minor_code = strtol(
         buffer.BeginReading() + start + minorCodeString.Length(), nullptr, 10);
-    if (errno) { MOZ_CRASH_UNSAFE(message); }
+    if (errno) {
+      MOZ_CRASH_UNSAFE(message);
+    }
 
     event.display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
     // Gdk does not provide resource ID
     event.resourceid = 0;
 
     X11Error(event.display, &event);
   } else {
     g_log_default_handler(log_domain, log_level, message, user_data);
--- a/tools/profiler/core/ProfilerMarkerPayload.cpp
+++ b/tools/profiler/core/ProfilerMarkerPayload.cpp
@@ -66,18 +66,18 @@ void TracingMarkerPayload::StreamPayload
   if (mKind == TRACING_INTERVAL_START) {
     aWriter.StringProperty("interval", "start");
   } else if (mKind == TRACING_INTERVAL_END) {
     aWriter.StringProperty("interval", "end");
   }
 }
 
 void DiskIOMarkerPayload::StreamPayload(SpliceableJSONWriter& aWriter,
-                                    const TimeStamp& aProcessStartTime,
-                                    UniqueStacks& aUniqueStacks) {
+                                        const TimeStamp& aProcessStartTime,
+                                        UniqueStacks& aUniqueStacks) {
   StreamCommonProps("DiskIO", aWriter, aProcessStartTime, aUniqueStacks);
   aWriter.StringProperty("operation", mOperation.get());
   aWriter.StringProperty("source", mSource);
   if (mFilename) {
     aWriter.StringProperty("filename", mFilename.get());
   }
 }
 
--- a/widget/gtk/CompositorWidgetParent.cpp
+++ b/widget/gtk/CompositorWidgetParent.cpp
@@ -35,18 +35,18 @@ RefPtr<VsyncObserver> CompositorWidgetPa
 }
 
 mozilla::ipc::IPCResult CompositorWidgetParent::RecvNotifyClientSizeChanged(
     const LayoutDeviceIntSize& aClientSize) {
   NotifyClientSizeChanged(aClientSize);
   return IPC_OK();
 }
 
-mozilla::ipc::IPCResult CompositorWidgetParent::RecvRequestsUpdatingEGLSurface()
-{
+mozilla::ipc::IPCResult
+CompositorWidgetParent::RecvRequestsUpdatingEGLSurface() {
 #ifdef MOZ_WAYLAND
   RequestsUpdatingEGLSurface();
 #endif
   return IPC_OK();
 }
 
 }  // namespace widget
 }  // namespace mozilla
--- a/widget/gtk/mozcontainer.cpp
+++ b/widget/gtk/mozcontainer.cpp
@@ -556,17 +556,17 @@ gboolean moz_container_has_wl_egl_window
 }
 
 gboolean moz_container_surface_needs_clear(MozContainer *container) {
   gboolean state = container->surface_needs_clear;
   container->surface_needs_clear = false;
   return state;
 }
 
-gboolean moz_container_egl_surface_needs_update(MozContainer *container){
+gboolean moz_container_egl_surface_needs_update(MozContainer *container) {
   gboolean state = container->egl_surface_needs_update;
   container->egl_surface_needs_update = false;
   return state;
 }
 #endif
 
 void moz_container_force_default_visual(MozContainer *container) {
   container->force_default_visual = true;
--- a/widget/gtk/nsWindow.cpp
+++ b/widget/gtk/nsWindow.cpp
@@ -1884,17 +1884,17 @@ gboolean nsWindow::OnExposeEvent(cairo_t
   }
 
   gint scale = GdkScaleFactor();
   LayoutDeviceIntRegion region = exposeRegion;
   region.ScaleRoundOut(scale, scale);
 
   if (GetLayerManager()->AsKnowsCompositor() && mCompositorSession) {
 #ifdef MOZ_WAYLAND
-    if(mCompositorWidgetDelegate && WaylandRequestsUpdatingEGLSurface()) {
+    if (mCompositorWidgetDelegate && WaylandRequestsUpdatingEGLSurface()) {
       mCompositorWidgetDelegate->RequestsUpdatingEGLSurface();
     }
 #endif
     // We need to paint to the screen even if nothing changed, since if we
     // don't have a compositing window manager, our pixels could be stale.
     GetLayerManager()->SetNeedsComposite(true);
     GetLayerManager()->SendInvalidRegion(region.ToUnknownRegion());
   }
--- a/widget/windows/CompositorWidgetChild.h
+++ b/widget/windows/CompositorWidgetChild.h
@@ -28,17 +28,18 @@ class CompositorWidgetChild final : publ
   void UpdateTransparency(nsTransparencyMode aMode) override;
   void ClearTransparentWindow() override;
   HDC GetTransparentDC() const override;
   void SetParentWnd(const HWND aParentWnd) override;
 
   mozilla::ipc::IPCResult RecvObserveVsync() override;
   mozilla::ipc::IPCResult RecvUnobserveVsync() override;
   mozilla::ipc::IPCResult RecvUpdateCompositorWnd(
-      const WindowsHandle& aCompositorWnd, const WindowsHandle& aParentWnd) override;
+      const WindowsHandle& aCompositorWnd,
+      const WindowsHandle& aParentWnd) override;
 
  private:
   RefPtr<CompositorVsyncDispatcher> mVsyncDispatcher;
   RefPtr<CompositorWidgetVsyncObserver> mVsyncObserver;
   HWND mCompositorWnd;
   HWND mParentWnd;
 };
 
--- a/widget/windows/CompositorWidgetParent.cpp
+++ b/widget/windows/CompositorWidgetParent.cpp
@@ -53,18 +53,18 @@ void CompositorWidgetParent::ObserveVsyn
   mVsyncObserver = aObserver;
 }
 
 RefPtr<VsyncObserver> CompositorWidgetParent::GetVsyncObserver() const {
   MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_GPU);
   return mVsyncObserver;
 }
 
-void CompositorWidgetParent::UpdateCompositorWnd(
-    const HWND aCompositorWnd, const HWND aParentWnd) {
+void CompositorWidgetParent::UpdateCompositorWnd(const HWND aCompositorWnd,
+                                                 const HWND aParentWnd) {
   Unused << SendUpdateCompositorWnd(
       reinterpret_cast<WindowsHandle>(aCompositorWnd),
       reinterpret_cast<WindowsHandle>(aParentWnd));
 }
 
 void CompositorWidgetParent::ActorDestroy(ActorDestroyReason aWhy) {}
 
 }  // namespace widget
--- a/widget/windows/CompositorWidgetParent.h
+++ b/widget/windows/CompositorWidgetParent.h
@@ -26,17 +26,18 @@ class CompositorWidgetParent final : pub
   mozilla::ipc::IPCResult RecvClearTransparentWindow() override;
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   nsIWidget* RealWidget() override;
   void ObserveVsync(VsyncObserver* aObserver) override;
   RefPtr<VsyncObserver> GetVsyncObserver() const override;
 
   // PlatformCompositorWidgetDelegate Overrides
-  void UpdateCompositorWnd(const HWND aCompositorWnd, const HWND aParentWnd) override;
+  void UpdateCompositorWnd(const HWND aCompositorWnd,
+                           const HWND aParentWnd) override;
 
  private:
   RefPtr<VsyncObserver> mVsyncObserver;
 };
 
 }  // namespace widget
 }  // namespace mozilla
 
--- a/widget/windows/WinCompositorWidget.cpp
+++ b/widget/windows/WinCompositorWidget.cpp
@@ -322,17 +322,18 @@ void WinCompositorWidget::UpdateComposit
   }
 
   LayoutDeviceIntSize size = GetClientSize();
   if (mLastCompositorWndSize == size) {
     return;
   }
 
   // Force a resize and redraw (but not a move, activate, etc.).
-  if (!::SetWindowPos(mCompositorWnds.mCompositorWnd, nullptr, 0, 0, size.width, size.height,
+  if (!::SetWindowPos(mCompositorWnds.mCompositorWnd, nullptr, 0, 0, size.width,
+                      size.height,
                       SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOCOPYBITS |
                           SWP_NOOWNERZORDER | SWP_NOZORDER)) {
     return;
   }
   mLastCompositorWndSize = size;
 }
 
 }  // namespace widget
--- a/widget/windows/WinCompositorWidget.h
+++ b/widget/windows/WinCompositorWidget.h
@@ -28,18 +28,19 @@ class PlatformCompositorWidgetDelegate :
 
   // Transparency handling.
   virtual void UpdateTransparency(nsTransparencyMode aMode) = 0;
   virtual void ClearTransparentWindow() = 0;
 
   // If in-process and using software rendering, return the backing transparent
   // DC.
   virtual HDC GetTransparentDC() const = 0;
-  virtual void SetParentWnd( const HWND aParentWnd) {}
-  virtual void UpdateCompositorWnd(const HWND aCompositorWnd, const HWND aParentWnd) {}
+  virtual void SetParentWnd(const HWND aParentWnd) {}
+  virtual void UpdateCompositorWnd(const HWND aCompositorWnd,
+                                   const HWND aParentWnd) {}
 
   // CompositorWidgetDelegate Overrides
 
   PlatformCompositorWidgetDelegate* AsPlatformSpecificDelegate() override {
     return this;
   }
 };
 
@@ -83,17 +84,20 @@ class WinCompositorWidget : public Compo
   void ClearTransparentWindow() override;
 
   bool RedrawTransparentWindow();
 
   // Ensure that a transparent surface exists, then return it.
   RefPtr<gfxASurface> EnsureTransparentSurface();
 
   HDC GetTransparentDC() const override { return mMemoryDC; }
-  HWND GetHwnd() const { return mCompositorWnds.mCompositorWnd ? mCompositorWnds.mCompositorWnd : mWnd; }
+  HWND GetHwnd() const {
+    return mCompositorWnds.mCompositorWnd ? mCompositorWnds.mCompositorWnd
+                                          : mWnd;
+  }
 
   HWND GetCompositorHwnd() const { return mCompositorWnds.mCompositorWnd; }
 
   void EnsureCompositorWindow();
   void DestroyCompositorWindow();
   void UpdateCompositorWndSizeIfNecessary();
 
   mozilla::Mutex& GetTransparentSurfaceLock() {
--- a/widget/windows/WinCompositorWindowThread.cpp
+++ b/widget/windows/WinCompositorWindowThread.cpp
@@ -6,17 +6,17 @@
 
 #include "base/platform_thread.h"
 #include "WinCompositorWindowThread.h"
 #include "mozilla/layers/SynchronousTask.h"
 #include "mozilla/StaticPtr.h"
 #include "mtransport/runnable_utils.h"
 
 #if WINVER < 0x0602
-#define WS_EX_NOREDIRECTIONBITMAP 0x00200000L
+#  define WS_EX_NOREDIRECTIONBITMAP 0x00200000L
 #endif
 
 namespace mozilla {
 namespace widget {
 
 static StaticRefPtr<WinCompositorWindowThread> sWinCompositorWindowThread;
 
 WinCompositorWindowThread::WinCompositorWindowThread(base::Thread* aThread)
@@ -72,17 +72,18 @@ void WinCompositorWindowThread::ShutDown
 }
 
 /* static */ bool WinCompositorWindowThread::IsInCompositorWindowThread() {
   return sWinCompositorWindowThread &&
          sWinCompositorWindowThread->mThread->thread_id() ==
              PlatformThread::CurrentId();
 }
 
-const wchar_t kClassNameCompositorInitalParent[] = L"MozillaCompositorInitialParentClass";
+const wchar_t kClassNameCompositorInitalParent[] =
+    L"MozillaCompositorInitialParentClass";
 const wchar_t kClassNameCompositor[] = L"MozillaCompositorWindowClass";
 
 ATOM g_compositor_inital_parent_window_class;
 ATOM g_compositor_window_class;
 
 // This runs on the window owner thread.
 void InitializeInitialParentWindowClass() {
   if (g_compositor_inital_parent_window_class) {
@@ -118,17 +119,18 @@ void InitializeWindowClass() {
   wc.hIcon = nullptr;
   wc.hCursor = nullptr;
   wc.hbrBackground = nullptr;
   wc.lpszMenuName = nullptr;
   wc.lpszClassName = kClassNameCompositor;
   g_compositor_window_class = ::RegisterClassW(&wc);
 }
 
-/* static */ WinCompositorWnds WinCompositorWindowThread::CreateCompositorWindow() {
+/* static */ WinCompositorWnds
+WinCompositorWindowThread::CreateCompositorWindow() {
   MOZ_ASSERT(Loop());
 
   if (!Loop()) {
     return WinCompositorWnds(nullptr, nullptr);
   }
 
   layers::SynchronousTask task("Create compositor window");
 
@@ -138,29 +140,30 @@ void InitializeWindowClass() {
   RefPtr<Runnable> runnable = NS_NewRunnableFunction(
       "WinCompositorWindowThread::CreateCompositorWindow::Runnable", [&]() {
         layers::AutoCompleteTask complete(&task);
 
         InitializeInitialParentWindowClass();
         InitializeWindowClass();
 
         // Create initial parent window.
-        // We could not directly create a compositor window with a main window as
-        // parent window, so instead create it with a temporary placeholder parent.
-        // Its parent is set as main window in UI process.
-        initialParentWnd = ::CreateWindowEx(
-            WS_EX_TOOLWINDOW, kClassNameCompositorInitalParent, nullptr,
-            WS_POPUP | WS_DISABLED, 0, 0, 1, 1, nullptr,
-            0, GetModuleHandle(nullptr), 0);
+        // We could not directly create a compositor window with a main window
+        // as parent window, so instead create it with a temporary placeholder
+        // parent. Its parent is set as main window in UI process.
+        initialParentWnd =
+            ::CreateWindowEx(WS_EX_TOOLWINDOW, kClassNameCompositorInitalParent,
+                             nullptr, WS_POPUP | WS_DISABLED, 0, 0, 1, 1,
+                             nullptr, 0, GetModuleHandle(nullptr), 0);
 
         compositorWnd = ::CreateWindowEx(
-            WS_EX_NOPARENTNOTIFY | WS_EX_LAYERED | WS_EX_TRANSPARENT | WS_EX_NOREDIRECTIONBITMAP,
+            WS_EX_NOPARENTNOTIFY | WS_EX_LAYERED | WS_EX_TRANSPARENT |
+                WS_EX_NOREDIRECTIONBITMAP,
             kClassNameCompositor, nullptr,
-            WS_CHILDWINDOW | WS_DISABLED | WS_VISIBLE, 0, 0, 1, 1, initialParentWnd,
-            0, GetModuleHandle(nullptr), 0);
+            WS_CHILDWINDOW | WS_DISABLED | WS_VISIBLE, 0, 0, 1, 1,
+            initialParentWnd, 0, GetModuleHandle(nullptr), 0);
       });
 
   Loop()->PostTask(runnable.forget());
 
   task.Wait();
 
   return WinCompositorWnds(compositorWnd, initialParentWnd);
 }
@@ -171,18 +174,17 @@ void InitializeWindowClass() {
   MOZ_ASSERT(aWnds.mInitialParentWnd);
   MOZ_ASSERT(Loop());
 
   if (!Loop()) {
     return;
   }
 
   RefPtr<Runnable> runnable = NS_NewRunnableFunction(
-      "WinCompositorWidget::CreateNativeWindow::Runnable",
-      [aWnds]() {
+      "WinCompositorWidget::CreateNativeWindow::Runnable", [aWnds]() {
         ::DestroyWindow(aWnds.mCompositorWnd);
         ::DestroyWindow(aWnds.mInitialParentWnd);
       });
 
   Loop()->PostTask(runnable.forget());
 }
 
 }  // namespace widget
--- a/widget/windows/WinCompositorWindowThread.h
+++ b/widget/windows/WinCompositorWindowThread.h
@@ -18,18 +18,17 @@ class SynchronousTask;
 }
 
 namespace widget {
 
 struct WinCompositorWnds {
   HWND mCompositorWnd;
   HWND mInitialParentWnd;
   WinCompositorWnds(HWND aCompositorWnd, HWND aInitialParentWnd)
-      : mCompositorWnd(aCompositorWnd),
-        mInitialParentWnd(aInitialParentWnd) {}
+      : mCompositorWnd(aCompositorWnd), mInitialParentWnd(aInitialParentWnd) {}
 };
 
 class WinCompositorWindowThread final {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_MAIN_THREAD_DESTRUCTION(
       WinCompositorWindowThread)
 
  public:
   /// Can be called from any thread.
--- a/xpcom/threads/SchedulerGroup.cpp
+++ b/xpcom/threads/SchedulerGroup.cpp
@@ -302,10 +302,9 @@ SchedulerGroup::Runnable::Run() {
 NS_IMETHODIMP
 SchedulerGroup::Runnable::GetPriority(uint32_t* aPriority) {
   *aPriority = nsIRunnablePriority::PRIORITY_NORMAL;
   nsCOMPtr<nsIRunnablePriority> runnablePrio = do_QueryInterface(mRunnable);
   return runnablePrio ? runnablePrio->GetPriority(aPriority) : NS_OK;
 }
 
 NS_IMPL_ISUPPORTS_INHERITED(SchedulerGroup::Runnable, mozilla::Runnable,
-                            nsIRunnablePriority,
-                            SchedulerGroup::Runnable)
+                            nsIRunnablePriority, SchedulerGroup::Runnable)
--- a/xpcom/threads/SchedulerGroup.h
+++ b/xpcom/threads/SchedulerGroup.h
@@ -91,18 +91,17 @@ class SchedulerGroup : public LinkedList
   // Records that this SchedulerGroup had an event dequeued from some
   // queue. Returns whether the SchedulerGroup is still in a queue after
   // DequeueEvent() returns.
   DequeueStatus DequeueEvent() {
     mEventCount--;
     return mEventCount == 0 ? NoLongerQueued : StillQueued;
   }
 
-  class Runnable final : public mozilla::Runnable,
-                         public nsIRunnablePriority {
+  class Runnable final : public mozilla::Runnable, public nsIRunnablePriority {
    public:
     Runnable(already_AddRefed<nsIRunnable>&& aRunnable, SchedulerGroup* aGroup,
              dom::DocGroup* aDocGroup);
 
     SchedulerGroup* Group() const { return mGroup; }
     dom::DocGroup* DocGroup() const;
 
 #ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY