Backed out changeset a296439a25ff (bug 1519636) for frequent Windows cppunit failures CLOSED TREE
authorarthur.iakab <aiakab@mozilla.com>
Fri, 24 May 2019 14:26:01 +0300
changeset 475355 28f5cf540df5060eb7d399af223fdb56aa4ea352
parent 475354 e52d041dc3dec4d932186ed0316428f6fb1400c9
child 475356 ecbe277800aa0e2c4ae427bdda4b7f870cd3acee
push id36060
push usercbrindusan@mozilla.com
push dateFri, 24 May 2019 21:47:21 +0000
treeherdermozilla-central@ac95bdf3c0b3 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1519636
milestone69.0a1
backs outa296439a25ffcafae35dda80b1ecc99e4e88cad3
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
Backed out changeset a296439a25ff (bug 1519636) for frequent Windows cppunit failures CLOSED TREE
accessible/html/HTMLFormControlAccessible.cpp
accessible/html/HTMLFormControlAccessible.h
browser/app/winlauncher/LauncherProcessWin.cpp
caps/ContentPrincipal.cpp
docshell/base/BrowsingContext.cpp
docshell/base/nsDocShell.h
dom/base/Document.cpp
dom/base/ResizeObserver.cpp
dom/base/ResizeObserverController.cpp
dom/base/SerializedStackHolder.cpp
dom/base/SerializedStackHolder.h
dom/base/TabGroup.cpp
dom/base/nsContentUtils.cpp
dom/base/nsDOMDataChannel.cpp
dom/base/nsDocumentEncoder.cpp
dom/base/nsFrameLoaderOwner.cpp
dom/base/nsGlobalWindowOuter.h
dom/canvas/WebGLShader.cpp
dom/canvas/WebGLShaderValidator.h
dom/events/PointerEventHandler.cpp
dom/ipc/BrowserHost.h
dom/ipc/BrowserParent.cpp
dom/ipc/RemoteWebProgressRequest.cpp
dom/media/GraphDriver.cpp
dom/media/platforms/PDMFactory.cpp
dom/media/platforms/agnostic/AgnosticDecoderModule.cpp
dom/network/TCPSocketParent.cpp
dom/plugins/base/nsJSNPRuntime.cpp
dom/quota/QuotaManager.h
dom/storage/StorageNotifierService.cpp
dom/svg/SVGPathData.h
dom/websocket/WebSocket.cpp
dom/workers/RuntimeService.cpp
dom/workers/ScriptLoader.cpp
dom/workers/WorkerPrivate.cpp
dom/workers/WorkerPrivate.h
editor/libeditor/HTMLEditorController.cpp
editor/libeditor/HTMLEditorDocumentCommands.cpp
gfx/layers/LayerTreeInvalidation.cpp
gfx/layers/apz/src/APZCTreeManager.h
gfx/layers/apz/util/APZCCallbackHelper.cpp
gfx/layers/apz/util/APZEventState.cpp
gfx/layers/basic/BasicCompositor.cpp
gfx/layers/d3d11/CompositorD3D11.cpp
gfx/layers/wr/WebRenderLayerManager.cpp
gfx/thebes/SharedFontList-impl.h
gfx/thebes/SharedFontList.cpp
gfx/thebes/SharedFontList.h
gfx/thebes/gfxDWriteFontList.cpp
gfx/thebes/gfxFontEntry.cpp
gfx/thebes/gfxFontUtils.h
gfx/thebes/gfxMacPlatformFontList.mm
gfx/thebes/gfxPlatform.cpp
gfx/thebes/gfxPlatformFontList.cpp
gfx/webrender_bindings/RendererOGL.cpp
gfx/webrender_bindings/WebRenderAPI.cpp
hal/android/AndroidHal.cpp
intl/hyphenation/glue/nsHyphenator.h
ipc/mscom/ProcessRuntime.cpp
js/public/AllocPolicy.h
js/public/RootingAPI.h
js/public/experimental/SourceHook.h
js/rust/src/jsglue.cpp
js/src/builtin/AtomicsObject.cpp
js/src/builtin/ModuleObject.cpp
js/src/builtin/ReflectParse.cpp
js/src/builtin/Stream.cpp
js/src/frontend/BinASTParser.cpp
js/src/frontend/BinASTParserPerTokenizer.cpp
js/src/frontend/BytecodeSection.h
js/src/frontend/FunctionEmitter.cpp
js/src/frontend/ParseContext.cpp
js/src/frontend/ParseContext.h
js/src/frontend/SharedContext.cpp
js/src/frontend/SharedContext.h
js/src/gc/Barrier.h
js/src/gc/FreeOp-inl.h
js/src/gc/GC-inl.h
js/src/gc/Marking.cpp
js/src/gc/NurseryAwareHashMap.h
js/src/gc/PrivateIterators-inl.h
js/src/gc/Scheduling.h
js/src/gc/Tracer.h
js/src/gc/Verifier.h
js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
js/src/jsapi-tests/testGCGrayMarking.cpp
js/src/jsapi-tests/testScriptObject.cpp
js/src/vm/ArrayBufferObject.cpp
js/src/vm/AtomsTable.h
js/src/vm/CompilationAndEvaluation.cpp
js/src/vm/Debugger-inl.h
js/src/vm/EnvironmentObject.cpp
js/src/vm/EnvironmentObject.h
js/src/vm/GeneratorObject.h
js/src/vm/JSScript.h
js/src/vm/Runtime.h
js/src/vm/SavedFrame.h
js/src/vm/SavedStacks.cpp
js/src/vm/Shape.h
js/src/vm/StringType-inl.h
js/src/vm/StringType.cpp
js/src/wasm/AsmJS.cpp
js/src/wasm/WasmJS.h
js/src/wasm/WasmTable.h
js/xpconnect/src/XPCJSRuntime.cpp
layout/base/nsQuoteList.cpp
layout/generic/nsFrame.cpp
layout/painting/RetainedDisplayListBuilder.cpp
layout/painting/nsCSSRenderingBorders.cpp
layout/style/CounterStyleManager.cpp
layout/style/FontFace.cpp
layout/style/FontFaceSet.cpp
layout/style/ServoComputedDataInlines.h
layout/style/ServoStyleConstsForwards.h
layout/style/nsCSSValue.h
layout/style/nsStyleConsts.h
layout/style/nsStyleUtil.h
layout/svg/SVGImageContext.cpp
layout/svg/SVGObserverUtils.cpp
layout/tables/nsTableRowGroupFrame.cpp
media/libdav1d/config.h
mfbt/HashTable.h
mfbt/RecordReplay.cpp
mozglue/build/Authenticode.cpp
mozglue/tests/interceptor/TestDllInterceptor.cpp
netwerk/protocol/data/DataChannelParent.cpp
netwerk/protocol/file/FileChannelParent.cpp
netwerk/protocol/http/nsHttpHandler.h
netwerk/protocol/http/nsHttpTransaction.cpp
parser/html/nsHtml5PlainTextUtils.cpp
security/manager/ssl/CSTrustDomain.cpp
security/sandbox/win/SandboxInitialization.cpp
toolkit/components/places/nsNavBookmarks.cpp
toolkit/components/satchel/nsFormFillController.cpp
toolkit/components/sessionstore/SessionStoreListener.cpp
toolkit/components/startup/nsAppStartup.cpp
toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
toolkit/recordreplay/MemorySnapshot.cpp
toolkit/recordreplay/ProcessRewind.cpp
toolkit/recordreplay/ThreadSnapshot.h
toolkit/recordreplay/ipc/Channel.cpp
toolkit/recordreplay/ipc/Channel.h
toolkit/recordreplay/ipc/ChildIPC.cpp
toolkit/recordreplay/ipc/JSControl.cpp
toolkit/recordreplay/ipc/JSControl.h
toolkit/xre/LauncherRegistryInfo.cpp
toolkit/xre/LauncherRegistryInfo.h
uriloader/exthandler/nsExternalProtocolHandler.cpp
widget/cocoa/GfxInfo.mm
widget/gtk/nsWindow.cpp
xpcom/base/CycleCollectedJSRuntime.cpp
xpcom/base/nsMacUtilsImpl.h
xpcom/base/nsSystemInfo.cpp
xpcom/io/nsLocalFileWin.cpp
xpcom/threads/PrioritizedEventQueue.cpp
xpcom/threads/ThrottledEventQueue.cpp
xpcom/threads/ThrottledEventQueue.h
--- a/accessible/html/HTMLFormControlAccessible.cpp
+++ b/accessible/html/HTMLFormControlAccessible.cpp
@@ -333,18 +333,17 @@ uint64_t HTMLTextFieldAccessible::Native
     return state;
   }
 
   // Expose autocomplete state if it has associated autocomplete list.
   if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::list_))
     return state | states::SUPPORTS_AUTOCOMPLETION | states::HASPOPUP;
 
   // Ordinal XUL textboxes don't support autocomplete.
-  if (!BindingOrWidgetParent() &&
-      Preferences::GetBool("browser.formfill.enable")) {
+  if (!BindingOrWidgetParent() && Preferences::GetBool("browser.formfill.enable")) {
     // Check to see if autocompletion is allowed on this input. We don't expose
     // it for password fields even though the entire password can be remembered
     // for a page if the user asks it to be. However, the kind of autocomplete
     // we're talking here is based on what the user types, where a popup of
     // possible choices comes up.
     nsAutoString autocomplete;
     mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::autocomplete,
                                    autocomplete);
--- a/accessible/html/HTMLFormControlAccessible.h
+++ b/accessible/html/HTMLFormControlAccessible.h
@@ -97,17 +97,17 @@ class HTMLTextFieldAccessible final : pu
   // Accessible
   virtual ENameValueFlag NativeName(nsString& aName) const override;
 
   /**
    * Return a widget element this input is part of, for example, XUL:textbox or
    * HTML:input@type="number".
    */
   nsIContent* BindingOrWidgetParent() const {
-    nsIContent* el = mContent->GetBindingParent();
+    nsIContent * el = mContent->GetBindingParent();
     if (el) {
       return el;
     }
     // XUL textboxes custom elements implementation.
     ErrorResult rv;
     return Elm()->Closest(NS_LITERAL_STRING("textbox"), rv);
   }
 };
--- a/browser/app/winlauncher/LauncherProcessWin.cpp
+++ b/browser/app/winlauncher/LauncherProcessWin.cpp
@@ -171,21 +171,21 @@ static mozilla::Maybe<bool> RunAsLaunche
                         static_cast<const wchar_t**>(nullptr),
                         mozilla::CheckArgFlag::None) == mozilla::ARG_FOUND) {
     return mozilla::Some(false);
   }
 
   bool runAsLauncher = DoLauncherProcessChecks(argc, argv);
 
 #if defined(MOZ_LAUNCHER_PROCESS)
-  bool forceLauncher =
-      runAsLauncher &&
-      mozilla::CheckArg(argc, argv, L"force-launcher",
-                        static_cast<const wchar_t**>(nullptr),
-                        mozilla::CheckArgFlag::RemoveArg) == mozilla::ARG_FOUND;
+  bool forceLauncher = runAsLauncher &&
+                       mozilla::CheckArg(argc, argv, L"force-launcher",
+                                         static_cast<const wchar_t**>(nullptr),
+                                         mozilla::CheckArgFlag::RemoveArg) ==
+                       mozilla::ARG_FOUND;
 
   mozilla::LauncherRegistryInfo::ProcessType desiredType =
       runAsLauncher ? mozilla::LauncherRegistryInfo::ProcessType::Launcher
                     : mozilla::LauncherRegistryInfo::ProcessType::Browser;
 
   mozilla::LauncherRegistryInfo::CheckOption checkOption =
       forceLauncher ? mozilla::LauncherRegistryInfo::CheckOption::Force
                     : mozilla::LauncherRegistryInfo::CheckOption::Default;
--- a/caps/ContentPrincipal.cpp
+++ b/caps/ContentPrincipal.cpp
@@ -44,17 +44,18 @@ static inline ExtensionPolicyService& EP
 
 NS_IMPL_CLASSINFO(ContentPrincipal, nullptr, nsIClassInfo::MAIN_THREAD_ONLY,
                   NS_PRINCIPAL_CID)
 NS_IMPL_QUERY_INTERFACE_CI(ContentPrincipal, nsIPrincipal, nsISerializable)
 NS_IMPL_CI_INTERFACE_GETTER(ContentPrincipal, nsIPrincipal, nsISerializable)
 
 ContentPrincipal::ContentPrincipal() : BasePrincipal(eCodebasePrincipal) {}
 
-ContentPrincipal::~ContentPrincipal() {}
+ContentPrincipal::~ContentPrincipal() {
+}
 
 nsresult ContentPrincipal::Init(nsIURI* aCodebase,
                                 const OriginAttributes& aOriginAttributes,
                                 const nsACString& aOriginNoSuffix) {
   NS_ENSURE_ARG(aCodebase);
 
   // Assert that the URI we get here isn't any of the schemes that we know we
   // should not get here.  These schemes always either inherit their principal
--- a/docshell/base/BrowsingContext.cpp
+++ b/docshell/base/BrowsingContext.cpp
@@ -809,19 +809,19 @@ void BrowsingContext::Transaction::Apply
     aBrowsingContext->m##name = std::move(*m##name);    \
     aBrowsingContext->DidSet##name(aSource);            \
     m##name.reset();                                    \
   }
 #include "mozilla/dom/BrowsingContextFieldList.h"
 }
 
 BrowsingContext::IPCInitializer BrowsingContext::GetIPCInitializer() {
-  MOZ_ASSERT(!mozilla::Preferences::GetBool(
-                 "fission.preserve_browsing_contexts", false) ||
-             IsContent());
+  MOZ_ASSERT(
+      !mozilla::Preferences::GetBool("fission.preserve_browsing_contexts", false) ||
+      IsContent());
 
   IPCInitializer init;
   init.mId = Id();
   init.mParentId = mParent ? mParent->Id() : 0;
   init.mCached = IsCached();
 
 #define MOZ_BC_FIELD(name, type) init.m##name = m##name;
 #include "mozilla/dom/BrowsingContextFieldList.h"
--- a/docshell/base/nsDocShell.h
+++ b/docshell/base/nsDocShell.h
@@ -761,34 +761,34 @@ class nsDocShell final : public nsDocLoa
   // (see BFCacheStatus in dom/base/Document.h), and we'd like to record
   // the common combinations for reasons which make requests fail to use
   // BFCache. These combinations are generated based on some local browsings,
   // we need to adjust them when necessary.
   enum BFCacheStatusCombo : uint16_t {
     BFCACHE_SUCCESS,
     UNLOAD = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER,
     UNLOAD_REQUEST = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
-                     mozilla::dom::BFCacheStatus::REQUEST,
+                              mozilla::dom::BFCacheStatus::REQUEST,
     REQUEST = mozilla::dom::BFCacheStatus::REQUEST,
     UNLOAD_REQUEST_PEER = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
                           mozilla::dom::BFCacheStatus::REQUEST |
                           mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION,
     UNLOAD_REQUEST_PEER_MSE =
-        mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
-        mozilla::dom::BFCacheStatus::REQUEST |
-        mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION |
-        mozilla::dom::BFCacheStatus::CONTAINS_MSE_CONTENT,
+      mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
+      mozilla::dom::BFCacheStatus::REQUEST |
+      mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION |
+      mozilla::dom::BFCacheStatus::CONTAINS_MSE_CONTENT,
     UNLOAD_REQUEST_MSE = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
                          mozilla::dom::BFCacheStatus::REQUEST |
                          mozilla::dom::BFCacheStatus::CONTAINS_MSE_CONTENT,
     SUSPENDED_UNLOAD_REQUEST_PEER =
-        mozilla::dom::BFCacheStatus::SUSPENDED |
-        mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
-        mozilla::dom::BFCacheStatus::REQUEST |
-        mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION,
+      mozilla::dom::BFCacheStatus::SUSPENDED |
+      mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
+      mozilla::dom::BFCacheStatus::REQUEST |
+      mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION,
   };
 
   void ReportBFCacheComboTelemetry(uint16_t aCombo);
 
   // Captures the state of the supporting elements of the presentation
   // (the "window" object, docshell tree, meta-refresh loads, and security
   // state) and stores them on |mOSHE|.
   nsresult CaptureState();
--- a/dom/base/Document.cpp
+++ b/dom/base/Document.cpp
@@ -6866,17 +6866,17 @@ static Maybe<LayoutDeviceToScreenScale> 
   if (scale < 0) {
     return Nothing();
   }
   return Some(clamped(LayoutDeviceToScreenScale(scale), kViewportMinScale,
                       kViewportMaxScale));
 }
 
 Maybe<LayoutDeviceToScreenScale> Document::ParseScaleInHeader(
-    nsAtom* aHeaderField) {
+  nsAtom* aHeaderField) {
   MOZ_ASSERT(aHeaderField == nsGkAtoms::viewport_initial_scale ||
              aHeaderField == nsGkAtoms::viewport_maximum_scale ||
              aHeaderField == nsGkAtoms::viewport_minimum_scale);
 
   nsAutoString scaleStr;
   GetHeaderData(aHeaderField, scaleStr);
 
   return ParseScaleString(scaleStr);
--- a/dom/base/ResizeObserver.cpp
+++ b/dom/base/ResizeObserver.cpp
@@ -275,17 +275,17 @@ void ResizeObserverEntry::SetBorderBoxSi
   const WritingMode wm = frame ? frame->GetWritingMode() : WritingMode();
   mBorderBoxSize = new ResizeObserverSize(this, aSize, wm);
 }
 
 void ResizeObserverEntry::SetContentRectAndSize(const nsSize& aSize) {
   nsIFrame* frame = mTarget->GetPrimaryFrame();
 
   // 1. Update mContentRect.
-  nsMargin padding = frame ? frame->GetUsedPadding() : nsMargin();
+  nsMargin padding = frame ? frame->GetUsedPadding(): nsMargin();
   // Per the spec, we need to use the top-left padding offset as the origin of
   // our contentRect.
   nsRect rect(nsPoint(padding.left, padding.top), aSize);
   RefPtr<DOMRect> contentRect = new DOMRect(this);
   contentRect->SetLayoutRect(rect);
   mContentRect = contentRect.forget();
 
   // 2. Update mContentBoxSize.
--- a/dom/base/ResizeObserverController.cpp
+++ b/dom/base/ResizeObserverController.cpp
@@ -54,19 +54,18 @@ void ResizeObserverNotificationHelper::R
 }
 
 void ResizeObserverNotificationHelper::Unregister() {
   if (!mRegistered) {
     return;
   }
 
   nsRefreshDriver* refreshDriver = GetRefreshDriver();
-  MOZ_RELEASE_ASSERT(
-      refreshDriver,
-      "We should not leave a dangling reference to the observer around");
+  MOZ_RELEASE_ASSERT(refreshDriver,
+                     "We should not leave a dangling reference to the observer around");
 
   bool rv = refreshDriver->RemoveRefreshObserver(this, FlushType::Display);
   MOZ_DIAGNOSTIC_ASSERT(rv, "Should remove the observer successfully");
   Unused << rv;
 
   mRegistered = false;
 }
 
--- a/dom/base/SerializedStackHolder.cpp
+++ b/dom/base/SerializedStackHolder.cpp
@@ -8,20 +8,19 @@
 
 #include "js/SavedFrameAPI.h"
 #include "mozilla/dom/WorkerPrivate.h"
 
 namespace mozilla {
 namespace dom {
 
 SerializedStackHolder::SerializedStackHolder()
-    : mHolder(StructuredCloneHolder::CloningSupported,
-              StructuredCloneHolder::TransferringNotSupported,
-              StructuredCloneHolder::StructuredCloneScope::
-                  SameProcessDifferentThread) {}
+  : mHolder(StructuredCloneHolder::CloningSupported,
+            StructuredCloneHolder::TransferringNotSupported,
+            StructuredCloneHolder::StructuredCloneScope::SameProcessDifferentThread) {}
 
 void SerializedStackHolder::WriteStack(JSContext* aCx,
                                        JS::HandleObject aStack) {
   JS::RootedValue stackValue(aCx, JS::ObjectValue(*aStack));
   mHolder.Write(aCx, stackValue, IgnoreErrors());
 
   // StructuredCloneHolder::Write can leave a pending exception on the context.
   JS_ClearPendingException(aCx);
@@ -33,18 +32,18 @@ void SerializedStackHolder::SerializeMai
   WriteStack(aCx, aStack);
 }
 
 void SerializedStackHolder::SerializeWorkerStack(JSContext* aCx,
                                                  WorkerPrivate* aWorkerPrivate,
                                                  JS::HandleObject aStack) {
   MOZ_ASSERT(aWorkerPrivate->IsOnCurrentThread());
 
-  RefPtr<StrongWorkerRef> workerRef =
-      StrongWorkerRef::Create(aWorkerPrivate, "WorkerErrorReport");
+  RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create(
+      aWorkerPrivate, "WorkerErrorReport");
   if (workerRef) {
     mWorkerRef = new ThreadSafeWorkerRef(workerRef);
   } else {
     // Don't write the stack if we can't create a ref to the worker.
     return;
   }
 
   WriteStack(aCx, aStack);
@@ -74,31 +73,32 @@ JSObject* SerializedStackHolder::ReadSta
   }
 
   Maybe<nsJSPrincipals::AutoSetActiveWorkerPrincipal> set;
   if (mWorkerRef) {
     set.emplace(mWorkerRef->Private()->GetPrincipal());
   }
 
   JS::RootedValue stackValue(aCx);
-  mHolder.Read(xpc::CurrentNativeGlobal(aCx), aCx, &stackValue, IgnoreErrors());
+  mHolder.Read(xpc::CurrentNativeGlobal(aCx), aCx, &stackValue,
+               IgnoreErrors());
   return stackValue.isObject() ? &stackValue.toObject() : nullptr;
 }
 
 UniquePtr<SerializedStackHolder> GetCurrentStackForNetMonitor(JSContext* aCx) {
   MOZ_ASSERT_IF(!NS_IsMainThread(),
                 GetCurrentThreadWorkerPrivate()->IsWatchedByDevtools());
 
   UniquePtr<SerializedStackHolder> stack = MakeUnique<SerializedStackHolder>();
   stack->SerializeCurrentStack(aCx);
   return stack;
 }
 
-void NotifyNetworkMonitorAlternateStack(
-    nsISupports* aChannel, UniquePtr<SerializedStackHolder> aStackHolder) {
+void NotifyNetworkMonitorAlternateStack(nsISupports* aChannel,
+                                        UniquePtr<SerializedStackHolder> aStackHolder) {
   if (!aStackHolder) {
     return;
   }
 
   nsString stackString;
   ConvertSerializedStackToJSON(std::move(aStackHolder), stackString);
 
   if (!stackString.IsEmpty()) {
@@ -116,18 +116,18 @@ void ConvertSerializedStackToJSON(Unique
   JSContext* cx = jsapi.cx();
 
   JS::RootedObject savedFrame(cx, aStackHolder->ReadStack(cx));
   if (!savedFrame) {
     return;
   }
 
   JS::RootedObject converted(cx);
-  converted = JS::ConvertSavedFrameToPlainObject(
-      cx, savedFrame, JS::SavedFrameSelfHosted::Exclude);
+  converted = JS::ConvertSavedFrameToPlainObject(cx, savedFrame,
+                                                 JS::SavedFrameSelfHosted::Exclude);
   if (!converted) {
     JS_ClearPendingException(cx);
     return;
   }
 
   JS::RootedValue convertedValue(cx, JS::ObjectValue(*converted));
   if (!nsContentUtils::StringifyJSON(cx, &convertedValue, aStackString)) {
     JS_ClearPendingException(cx);
--- a/dom/base/SerializedStackHolder.h
+++ b/dom/base/SerializedStackHolder.h
@@ -54,18 +54,18 @@ class SerializedStackHolder {
 // before creating the stack.
 UniquePtr<SerializedStackHolder> GetCurrentStackForNetMonitor(JSContext* aCx);
 
 // If aStackHolder is non-null, this notifies the net monitor that aStackHolder
 // is the stack from which aChannel originates. This must be called on the main
 // thread. This call is synchronous, and aChannel and aStackHolder will not be
 // used afterward. aChannel is an nsISupports object because this can be used
 // with either nsIChannel or nsIWebSocketChannel.
-void NotifyNetworkMonitorAlternateStack(
-    nsISupports* aChannel, UniquePtr<SerializedStackHolder> aStackHolder);
+void NotifyNetworkMonitorAlternateStack(nsISupports* aChannel,
+                                        UniquePtr<SerializedStackHolder> aStackHolder);
 
 // Read back the saved frame stack and store it in a string as JSON.
 // This must be called on the main thread.
 void ConvertSerializedStackToJSON(UniquePtr<SerializedStackHolder> aStackHolder,
                                   nsAString& aStackString);
 
 // As above, notify the net monitor for a stack that has already been converted
 // to JSON. This can be used with ConvertSerializedStackToJSON when multiple
--- a/dom/base/TabGroup.cpp
+++ b/dom/base/TabGroup.cpp
@@ -76,21 +76,23 @@ void TabGroup::EnsureThrottledEventQueue
     return;
   }
 
   mThrottledQueuesInitialized = true;
 
   for (size_t i = 0; i < size_t(TaskCategory::Count); i++) {
     TaskCategory category = static_cast<TaskCategory>(i);
     if (category == TaskCategory::Worker) {
-      mEventTargets[i] = ThrottledEventQueue::Create(mEventTargets[i],
-                                                     "TabGroup worker queue");
+      mEventTargets[i] =
+          ThrottledEventQueue::Create(mEventTargets[i],
+                                      "TabGroup worker queue");
     } else if (category == TaskCategory::Timer) {
       mEventTargets[i] =
-          ThrottledEventQueue::Create(mEventTargets[i], "TabGroup timer queue");
+          ThrottledEventQueue::Create(mEventTargets[i],
+                                      "TabGroup timer queue");
     }
   }
 }
 
 /* static */
 TabGroup* TabGroup::GetChromeTabGroup() {
   if (!sChromeTabGroup) {
     sChromeTabGroup = new TabGroup(true /* chrome tab group */);
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -4175,19 +4175,20 @@ nsresult nsContentUtils::DispatchFocusCh
   return DispatchChromeEvent(doc, aWindow, NS_LITERAL_STRING("DOMWindowFocus"),
                              CanBubble::eYes, Cancelable::eYes);
 }
 
 void nsContentUtils::RequestFrameFocus(Element& aFrameElement, bool aCanRaise) {
   RefPtr<Element> target = &aFrameElement;
   bool defaultAction = true;
   if (aCanRaise) {
-    DispatchEventOnlyToChrome(
-        target->OwnerDoc(), target, NS_LITERAL_STRING("framefocusrequested"),
-        CanBubble::eYes, Cancelable::eYes, &defaultAction);
+    DispatchEventOnlyToChrome(target->OwnerDoc(), target,
+                              NS_LITERAL_STRING("framefocusrequested"),
+                              CanBubble::eYes, Cancelable::eYes,
+                              &defaultAction);
   }
   if (!defaultAction) {
     return;
   }
 
   nsCOMPtr<nsIFocusManager> fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     return;
--- a/dom/base/nsDOMDataChannel.cpp
+++ b/dom/base/nsDOMDataChannel.cpp
@@ -137,19 +137,17 @@ mozilla::dom::Nullable<uint16_t> nsDOMDa
     const {
   return mDataChannel->GetMaxPacketLifeTime();
 }
 
 mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetMaxRetransmits() const {
   return mDataChannel->GetMaxRetransmits();
 }
 
-bool nsDOMDataChannel::Negotiated() const {
-  return mDataChannel->GetNegotiated();
-}
+bool nsDOMDataChannel::Negotiated() const { return mDataChannel->GetNegotiated(); }
 
 bool nsDOMDataChannel::Ordered() const { return mDataChannel->GetOrdered(); }
 
 RTCDataChannelState nsDOMDataChannel::ReadyState() const {
   return static_cast<RTCDataChannelState>(mDataChannel->GetReadyState());
 }
 
 uint32_t nsDOMDataChannel::BufferedAmount() const {
--- a/dom/base/nsDocumentEncoder.cpp
+++ b/dom/base/nsDocumentEncoder.cpp
@@ -612,41 +612,40 @@ nsresult nsDocumentEncoder::SerializeNod
 
   if (node->IsElement()) {
     if ((mFlags & (nsIDocumentEncoder::OutputPreformatted |
                    nsIDocumentEncoder::OutputDropInvisibleBreak)) &&
         nsLayoutUtils::IsInvisibleBreak(node)) {
       return rv;
     }
     Element* originalElement = aOriginalNode.AsElement();
-    rv = mSerializer->AppendElementStart(node->AsElement(), originalElement,
-                                         aStr);
+    rv = mSerializer->AppendElementStart(node->AsElement(), originalElement, aStr);
     return rv;
   }
 
   switch (node->NodeType()) {
     case nsINode::TEXT_NODE: {
       rv = mSerializer->AppendText(static_cast<nsIContent*>(node), aStartOffset,
-                                   aEndOffset, aStr);
+                              aEndOffset, aStr);
       break;
     }
     case nsINode::CDATA_SECTION_NODE: {
       rv = mSerializer->AppendCDATASection(static_cast<nsIContent*>(node),
-                                           aStartOffset, aEndOffset, aStr);
+                                      aStartOffset, aEndOffset, aStr);
       break;
     }
     case nsINode::PROCESSING_INSTRUCTION_NODE: {
       rv = mSerializer->AppendProcessingInstruction(
           static_cast<ProcessingInstruction*>(node), aStartOffset, aEndOffset,
           aStr);
       break;
     }
     case nsINode::COMMENT_NODE: {
       rv = mSerializer->AppendComment(static_cast<Comment*>(node), aStartOffset,
-                                      aEndOffset, aStr);
+                                 aEndOffset, aStr);
       break;
     }
     case nsINode::DOCUMENT_TYPE_NODE: {
       rv = mSerializer->AppendDoctype(static_cast<DocumentType*>(node), aStr);
       break;
     }
   }
 
--- a/dom/base/nsFrameLoaderOwner.cpp
+++ b/dom/base/nsFrameLoaderOwner.cpp
@@ -42,18 +42,17 @@ void nsFrameLoaderOwner::ChangeRemotenes
     bool isChromeRemoteToLocal =
         XRE_IsParentProcess() && (!aOptions.mRemoteType.WasPassed() ||
                                   aOptions.mRemoteType.Value().IsVoid());
 
     // If this is a process switch due to a difference in Cross Origin Opener
     // Policy, do not preserve the browsing context. Otherwise, save off the
     // browsing context and use it when creating our new FrameLoader.
     if (!aOptions.mReplaceBrowsingContext && !isChromeRemoteToLocal &&
-        mozilla::Preferences::GetBool("fission.preserve_browsing_contexts",
-                                      false)) {
+        mozilla::Preferences::GetBool("fission.preserve_browsing_contexts", false)) {
       bc = mFrameLoader->GetBrowsingContext();
       mFrameLoader->SkipBrowsingContextDetach();
     }
 
     mFrameLoader->Destroy();
     mFrameLoader = nullptr;
   }
 
--- a/dom/base/nsGlobalWindowOuter.h
+++ b/dom/base/nsGlobalWindowOuter.h
@@ -226,17 +226,19 @@ class nsGlobalWindowOuter final : public
 
   // nsWrapperCache
   virtual JSObject* WrapObject(JSContext* cx,
                                JS::Handle<JSObject*> aGivenProto) override {
     return EnsureInnerWindow() ? GetWrapper() : nullptr;
   }
 
   // nsIGlobalJSObjectHolder
-  JSObject* GetGlobalJSObject() final { return GetWrapper(); }
+  JSObject* GetGlobalJSObject() final {
+    return GetWrapper();
+  }
   JSObject* GetGlobalJSObjectPreserveColor() const final {
     return GetWrapperPreserveColor();
   }
 
   virtual nsresult EnsureScriptEnvironment() override;
 
   virtual nsIScriptContext* GetScriptContext() override;
 
--- a/dom/canvas/WebGLShader.cpp
+++ b/dom/canvas/WebGLShader.cpp
@@ -129,18 +129,18 @@ void WebGLShader::CompileShader() {
   MOZ_ASSERT(mValidator);
 
   static const bool kDumpShaders = PR_GetEnv("MOZ_WEBGL_DUMP_SHADERS");
   if (MOZ_UNLIKELY(kDumpShaders)) {
     printf_stderr("==== begin MOZ_WEBGL_DUMP_SHADERS ====\n");
     PrintLongString(mCleanSource.BeginReading(), mCleanSource.Length());
   }
 
-  const bool success = Translate(mCleanSource, mValidator.get(),
-                                 &mValidationLog, &mTranslatedSource);
+  const bool success = Translate(mCleanSource, mValidator.get(), &mValidationLog,
+                        &mTranslatedSource);
 
   if (MOZ_UNLIKELY(kDumpShaders)) {
     printf_stderr("\n==== \\/ \\/ \\/ ====\n");
     if (success) {
       PrintLongString(mTranslatedSource.BeginReading(),
                       mTranslatedSource.Length());
     } else {
       printf_stderr("Validation failed:\n%s", mValidationLog.BeginReading());
--- a/dom/canvas/WebGLShaderValidator.h
+++ b/dom/canvas/WebGLShaderValidator.h
@@ -11,20 +11,19 @@
 #include "GLDefs.h"
 #include "GLSLANG/ShaderLang.h"
 #include "nsString.h"
 
 namespace mozilla {
 namespace webgl {
 
 class ShaderValidator final {
- public:
+public:
   const ShHandle mHandle;
-
- private:
+private:
   const ShCompileOptions mCompileOptions;
   const int mMaxVaryingVectors;
   bool mHasRun;
 
  public:
   static ShaderValidator* Create(GLenum shaderType, ShShaderSpec spec,
                                  ShShaderOutput outputLanguage,
                                  const ShBuiltInResources& resources,
--- a/dom/events/PointerEventHandler.cpp
+++ b/dom/events/PointerEventHandler.cpp
@@ -513,18 +513,18 @@ void PointerEventHandler::DispatchPointe
       case eMouseMove:
         pointerMessage = ePointerMove;
         break;
       case eMouseUp:
         pointerMessage = mouseEvent->mButtons ? ePointerMove : ePointerUp;
         break;
       case eMouseDown:
         pointerMessage =
-            mouseEvent->mButtons & ~nsContentUtils::GetButtonsFlagForButton(
-                                       mouseEvent->mButton)
+            mouseEvent->mButtons &
+                    ~nsContentUtils::GetButtonsFlagForButton(mouseEvent->mButton)
                 ? ePointerMove
                 : ePointerDown;
         break;
       default:
         return;
     }
 
     WidgetPointerEvent event(*mouseEvent);
--- a/dom/ipc/BrowserHost.h
+++ b/dom/ipc/BrowserHost.h
@@ -50,17 +50,19 @@ class BrowserHost : public RemoteBrowser
   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(BrowserHost, RemoteBrowser)
 
   // Get the IPDL actor for the root BrowserParent. This method should be
   // avoided and consumers migrated to use this class.
   BrowserParent* GetActor() { return mRoot; }
   ContentParent* GetContentParent() const {
     return mRoot ? mRoot->Manager() : nullptr;
   }
-  TabId GetTabId() const { return mId; }
+  TabId GetTabId() const {
+    return mId;
+  }
 
   BrowserHost* AsBrowserHost() override { return this; }
   BrowserBridgeHost* AsBrowserBridgeHost() override { return nullptr; }
 
   LayersId GetLayersId() const override;
   BrowsingContext* GetBrowsingContext() const override;
   nsILoadContext* GetLoadContext() const override;
 
--- a/dom/ipc/BrowserParent.cpp
+++ b/dom/ipc/BrowserParent.cpp
@@ -132,19 +132,19 @@ using namespace mozilla::dom;
 using namespace mozilla::ipc;
 using namespace mozilla::layers;
 using namespace mozilla::layout;
 using namespace mozilla::services;
 using namespace mozilla::widget;
 using namespace mozilla::jsipc;
 using namespace mozilla::gfx;
 
+using mozilla::Unused;
 using mozilla::LazyLogModule;
 using mozilla::StaticAutoPtr;
-using mozilla::Unused;
 
 LazyLogModule gBrowserFocusLog("BrowserFocus");
 
 #define LOGBROWSERFOCUS(args) \
   MOZ_LOG(gBrowserFocusLog, mozilla::LogLevel::Debug, args)
 
 /* static */
 StaticAutoPtr<nsTArray<BrowserParent*>> BrowserParent::sFocusStack;
--- a/dom/ipc/RemoteWebProgressRequest.cpp
+++ b/dom/ipc/RemoteWebProgressRequest.cpp
@@ -156,27 +156,27 @@ NS_IMETHODIMP RemoteWebProgressRequest::
 }
 
 NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedFullHash(
     nsACString& aMatchedFullHash) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP RemoteWebProgressRequest::SetMatchedTrackingInfo(
-    const nsTArray<nsCString>& aLists, const nsTArray<nsCString>& aFullHashes) {
+    const nsTArray<nsCString> &aLists, const nsTArray<nsCString> &aFullHashes) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedTrackingLists(
-    nsTArray<nsCString>& aLists) {
+    nsTArray<nsCString> &aLists) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedTrackingFullHashes(
-    nsTArray<nsCString>& aFullHashes) {
+    nsTArray<nsCString> &aFullHashes) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 // nsIRequest methods
 
 NS_IMETHODIMP RemoteWebProgressRequest::GetName(nsACString& aName) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
--- a/dom/media/GraphDriver.cpp
+++ b/dom/media/GraphDriver.cpp
@@ -969,33 +969,28 @@ long AudioCallbackDriver::DataCallback(c
     return aFrames - 1;
   }
 
   return aFrames;
 }
 
 static const char* StateToString(cubeb_state aState) {
   switch (aState) {
-    case CUBEB_STATE_STARTED:
-      return "STARTED";
-    case CUBEB_STATE_STOPPED:
-      return "STOPPED";
-    case CUBEB_STATE_DRAINED:
-      return "DRAINED";
-    case CUBEB_STATE_ERROR:
-      return "ERROR";
+    case CUBEB_STATE_STARTED: return "STARTED";
+    case CUBEB_STATE_STOPPED: return "STOPPED";
+    case CUBEB_STATE_DRAINED: return "DRAINED";
+    case CUBEB_STATE_ERROR: return "ERROR";
     default:
       MOZ_CRASH("Unexpected state!");
   }
 }
 
 void AudioCallbackDriver::StateCallback(cubeb_state aState) {
   MOZ_ASSERT(!OnGraphThread());
-  LOG(LogLevel::Debug,
-      ("AudioCallbackDriver State: %s", StateToString(aState)));
+  LOG(LogLevel::Debug, ("AudioCallbackDriver State: %s", StateToString(aState)));
 
   // Clear the flag for the not running
   // states: stopped, drained, error.
   mAudioThreadRunning = (aState == CUBEB_STATE_STARTED);
 
   if (aState == CUBEB_STATE_ERROR && mShouldFallbackIfError) {
     MOZ_ASSERT(!ThreadRunning());
     mShouldFallbackIfError = false;
--- a/dom/media/platforms/PDMFactory.cpp
+++ b/dom/media/platforms/PDMFactory.cpp
@@ -11,17 +11,17 @@
 #include "EMEDecoderModule.h"
 #include "GMPDecoderModule.h"
 #include "H264.h"
 #include "MP4Decoder.h"
 #include "MediaChangeMonitor.h"
 #include "MediaInfo.h"
 #include "VPXDecoder.h"
 #include "gfxPrefs.h"
-#include "nsIXULRuntime.h"  // for BrowserTabsRemoteAutostart
+#include "nsIXULRuntime.h" // for BrowserTabsRemoteAutostart
 #include "mozilla/CDMProxy.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/GpuDecoderModule.h"
 #include "mozilla/RemoteDecoderModule.h"
 #include "mozilla/SharedThreadPool.h"
 #include "mozilla/StaticPrefs.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/SyncRunnable.h"
@@ -340,17 +340,18 @@ void PDMFactory::CreatePDMs() {
     m = CreateBlankDecoderModule();
     StartupPDM(m);
     // The Blank PDM SupportsMimeType reports true for all codecs; the creation
     // of its decoder is infallible. As such it will be used for all media, we
     // can stop creating more PDM from this point.
     return;
   }
 
-  if (StaticPrefs::MediaRddProcessEnabled() && BrowserTabsRemoteAutostart()) {
+  if (StaticPrefs::MediaRddProcessEnabled()
+      && BrowserTabsRemoteAutostart()) {
     m = new RemoteDecoderModule;
     StartupPDM(m);
   }
 
 #ifdef XP_WIN
   if (StaticPrefs::MediaWmfEnabled() && !IsWin7AndPre2000Compatible()) {
     m = new WMFDecoderModule();
     RefPtr<PlatformDecoderModule> remote = new GpuDecoderModule(m);
--- a/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp
+++ b/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp
@@ -21,17 +21,18 @@
 namespace mozilla {
 
 bool AgnosticDecoderModule::SupportsMimeType(
     const nsACString& aMimeType, DecoderDoctorDiagnostics* aDiagnostics) const {
   bool supports =
       VPXDecoder::IsVPX(aMimeType) || OpusDataDecoder::IsOpus(aMimeType) ||
       WaveDataDecoder::IsWave(aMimeType) || TheoraDecoder::IsTheora(aMimeType);
   if (!StaticPrefs::MediaRddVorbisEnabled() ||
-      !StaticPrefs::MediaRddProcessEnabled() || !BrowserTabsRemoteAutostart()) {
+      !StaticPrefs::MediaRddProcessEnabled() ||
+      !BrowserTabsRemoteAutostart()) {
     supports |= VorbisDataDecoder::IsVorbis(aMimeType);
   }
 #ifdef MOZ_AV1
   // We remove support for decoding AV1 here if RDD is enabled so that
   // decoding on the content process doesn't accidentally happen in case
   // something goes wrong with launching the RDD process.
   if (StaticPrefs::MediaAv1Enabled() &&
       !StaticPrefs::MediaRddProcessEnabled()) {
--- a/dom/network/TCPSocketParent.cpp
+++ b/dom/network/TCPSocketParent.cpp
@@ -38,17 +38,18 @@ extern LazyLogModule gTCPSocketLog;
 #define TCPSOCKET_LOG(args) MOZ_LOG(gTCPSocketLog, LogLevel::Debug, args)
 #define TCPSOCKET_LOG_ENABLED() MOZ_LOG_TEST(gTCPSocketLog, LogLevel::Debug)
 }  // namespace net
 
 using namespace net;
 
 namespace dom {
 
-static void FireInteralError(TCPSocketParent* aActor, uint32_t aLineNo) {
+static void FireInteralError(TCPSocketParent* aActor,
+                             uint32_t aLineNo) {
   MOZ_ASSERT(aActor->IPCOpen());
 
   mozilla::Unused << aActor->SendCallback(
       NS_LITERAL_STRING("onerror"),
       TCPError(NS_LITERAL_STRING("InvalidStateError"),
                NS_LITERAL_STRING("Internal error")),
       static_cast<uint32_t>(TCPReadyState::Connecting));
 }
--- a/dom/plugins/base/nsJSNPRuntime.cpp
+++ b/dom/plugins/base/nsJSNPRuntime.cpp
@@ -61,17 +61,19 @@ namespace JS {
 template <>
 struct GCPolicy<nsJSObjWrapper*> {
   static void trace(JSTracer* trc, nsJSObjWrapper** wrapper, const char* name) {
     MOZ_ASSERT(wrapper);
     MOZ_ASSERT(*wrapper);
     (*wrapper)->trace(trc);
   }
 
-  static bool isValid(const nsJSObjWrapper*& wrapper) { return true; }
+  static bool isValid(const nsJSObjWrapper *&wrapper) {
+    return true;
+  }
 };
 }  // namespace JS
 
 class NPObjWrapperHashEntry : public PLDHashEntryHdr {
  public:
   NPObject* mNPObj;  // Must be the first member for the PLDHash stubs to work
   JS::TenuredHeap<JSObject*> mJSObj;
   NPP mNpp;
--- a/dom/quota/QuotaManager.h
+++ b/dom/quota/QuotaManager.h
@@ -168,18 +168,17 @@ class QuotaManager final : public Backgr
    */
   void EnsureQuotaForOrigin(PersistenceType aPersistenceType,
                             const nsACString& aGroup,
                             const nsACString& aOrigin);
 
   /**
    * For use when creating an origin directory. It's possible that origin usage
    * is already being tracked due to a call to EnsureQuotaForOrigin, and in that
-   * case we need to update the existing OriginInfo rather than create a new
-   * one.
+   * case we need to update the existing OriginInfo rather than create a new one.
    */
   void NoteOriginDirectoryCreated(PersistenceType aPersistenceType,
                                   const nsACString& aGroup,
                                   const nsACString& aOrigin, bool aPersisted,
                                   int64_t& aTimestamp);
 
   void DecreaseUsageForOrigin(PersistenceType aPersistenceType,
                               const nsACString& aGroup,
--- a/dom/storage/StorageNotifierService.cpp
+++ b/dom/storage/StorageNotifierService.cpp
@@ -70,18 +70,18 @@ void StorageNotifierService::Broadcast(S
     // having their OriginAttributes set (because they have the system
     // principal).
     if (aPrivateBrowsing != observer->IsPrivateBrowsing()) {
       continue;
     }
 
     // No reasons to continue if the principal of the event doesn't match with
     // the window's one.
-    if (!StorageUtils::PrincipalsEqual(
-            aEvent->GetPrincipal(), observer->GetEffectiveStoragePrincipal())) {
+    if (!StorageUtils::PrincipalsEqual(aEvent->GetPrincipal(),
+                                       observer->GetEffectiveStoragePrincipal())) {
       continue;
     }
 
     RefPtr<Runnable> r = NS_NewRunnableFunction(
         "StorageNotifierService::Broadcast",
         [observer, event, aStorageType, aPrivateBrowsing]() {
           observer->ObserveStorageNotification(event, aStorageType,
                                                aPrivateBrowsing);
--- a/dom/svg/SVGPathData.h
+++ b/dom/svg/SVGPathData.h
@@ -160,21 +160,19 @@ class SVGPathData {
   already_AddRefed<Path> BuildPath(PathBuilder* aBuilder,
                                    uint8_t aStrokeLineCap,
                                    Float aStrokeWidth) const;
   /**
    * This function tries to build the path from an array of StylePathCommand,
    * which is generated by cbindgen from Rust (see ServoStyleConsts.h).
    * Basically, this is a variant of the above BuildPath() functions.
    */
-  static already_AddRefed<Path> BuildPath(Span<const StylePathCommand> aPath,
-                                          PathBuilder* aBuilder,
-                                          uint8_t aStrokeLineCap,
-                                          Float aStrokeWidth,
-                                          float aZoomFactor = 1.0);
+  static already_AddRefed<Path> BuildPath(
+      Span<const StylePathCommand> aPath, PathBuilder* aBuilder,
+      uint8_t aStrokeLineCap, Float aStrokeWidth, float aZoomFactor = 1.0);
 
   const_iterator begin() const { return mData.Elements(); }
   const_iterator end() const { return mData.Elements() + mData.Length(); }
 
   // memory reporting methods
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
--- a/dom/websocket/WebSocket.cpp
+++ b/dom/websocket/WebSocket.cpp
@@ -1644,21 +1644,21 @@ nsresult WebSocketImpl::Init(JSContext* 
     }
 
     AppendUTF16toUTF8(aProtocolArray[index], mRequestedProtocolList);
   }
 
   return NS_OK;
 }
 
-nsresult WebSocketImpl::AsyncOpen(
-    nsIPrincipal* aPrincipal, uint64_t aInnerWindowID,
-    nsITransportProvider* aTransportProvider,
-    const nsACString& aNegotiatedExtensions,
-    UniquePtr<SerializedStackHolder> aOriginStack) {
+nsresult WebSocketImpl::AsyncOpen(nsIPrincipal* aPrincipal,
+                                  uint64_t aInnerWindowID,
+                                  nsITransportProvider* aTransportProvider,
+                                  const nsACString& aNegotiatedExtensions,
+                                  UniquePtr<SerializedStackHolder> aOriginStack) {
   MOZ_ASSERT(NS_IsMainThread(), "Not running on main thread");
   MOZ_ASSERT_IF(!aTransportProvider, aNegotiatedExtensions.IsEmpty());
 
   nsCString asciiOrigin;
   nsresult rv = nsContentUtils::GetASCIIOrigin(aPrincipal, asciiOrigin);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (aTransportProvider) {
--- a/dom/workers/RuntimeService.cpp
+++ b/dom/workers/RuntimeService.cpp
@@ -67,17 +67,17 @@
 #include "nsServiceManagerUtils.h"
 #include "nsThreadUtils.h"
 #include "nsXPCOM.h"
 #include "nsXPCOMPrivate.h"
 #include "OSFileConstants.h"
 #include "xpcpublic.h"
 
 #if defined(XP_MACOSX)
-#  include "nsMacUtilsImpl.h"
+# include "nsMacUtilsImpl.h"
 #endif
 
 #include "Principal.h"
 #include "WorkerDebuggerManager.h"
 #include "WorkerError.h"
 #include "WorkerLoadInfo.h"
 #include "WorkerPrivate.h"
 #include "WorkerRunnable.h"
--- a/dom/workers/ScriptLoader.cpp
+++ b/dom/workers/ScriptLoader.cpp
@@ -839,17 +839,18 @@ class ScriptLoaderRunnable final : publi
     if (IsMainWorkerScript()) {
       mWorkerPrivate->SetLoadingWorkerScript(true);
     }
 
     // Convert the origin stack to JSON (which must be done on the main
     // thread) explicitly, so that we can use the stack to notify the net
     // monitor about every script we load.
     if (mOriginStack) {
-      ConvertSerializedStackToJSON(std::move(mOriginStack), mOriginStackJSON);
+      ConvertSerializedStackToJSON(std::move(mOriginStack),
+                                   mOriginStackJSON);
     }
 
     if (!mWorkerPrivate->IsServiceWorker() || IsDebuggerScript()) {
       for (uint32_t index = 0, len = mLoadInfos.Length(); index < len;
            ++index) {
         nsresult rv = LoadScript(index);
         if (NS_WARN_IF(NS_FAILED(rv))) {
           LoadingFinished(index, rv);
@@ -2119,18 +2120,18 @@ void LoadAllScripts(WorkerPrivate* aWork
   Maybe<ClientInfo> clientInfo;
   Maybe<ServiceWorkerDescriptor> controller;
   if (!aIsMainScript) {
     clientInfo = aWorkerPrivate->GetClientInfo();
     controller = aWorkerPrivate->GetController();
   }
 
   RefPtr<ScriptLoaderRunnable> loader = new ScriptLoaderRunnable(
-      aWorkerPrivate, std::move(aOriginStack), syncLoopTarget, aLoadInfos,
-      clientInfo, controller, aIsMainScript, aWorkerScriptType, aRv);
+      aWorkerPrivate, std::move(aOriginStack), syncLoopTarget, aLoadInfos, clientInfo,
+      controller, aIsMainScript, aWorkerScriptType, aRv);
 
   NS_ASSERTION(aLoadInfos.IsEmpty(), "Should have swapped!");
 
   RefPtr<StrongWorkerRef> workerRef =
       StrongWorkerRef::Create(aWorkerPrivate, "ScriptLoader", [loader]() {
         NS_DispatchToMainThread(NewRunnableMethod(
             "ScriptLoader::CancelMainThreadWithBindingAborted", loader,
             &ScriptLoaderRunnable::CancelMainThreadWithBindingAborted));
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -305,18 +305,17 @@ class CompileScriptRunnable final : publ
   nsString mScriptURL;
   UniquePtr<SerializedStackHolder> mOriginStack;
 
  public:
   explicit CompileScriptRunnable(WorkerPrivate* aWorkerPrivate,
                                  UniquePtr<SerializedStackHolder> aOriginStack,
                                  const nsAString& aScriptURL)
       : WorkerDebuggeeRunnable(aWorkerPrivate, WorkerThreadModifyBusyCount),
-        mScriptURL(aScriptURL),
-        mOriginStack(aOriginStack.release()) {}
+        mScriptURL(aScriptURL), mOriginStack(aOriginStack.release()) {}
 
  private:
   // We can't implement PreRun effectively, because at the point when that would
   // run we have not yet done our load so don't know things like our final
   // principal and whatnot.
 
   virtual bool WorkerRun(JSContext* aCx,
                          WorkerPrivate* aWorkerPrivate) override {
@@ -2174,19 +2173,20 @@ WorkerPrivate::WorkerPrivate(WorkerPriva
     MOZ_DIAGNOSTIC_ASSERT(target);
   }
 
   // Throttle events to the main thread using a ThrottledEventQueue specific to
   // this tree of worker threads.
   mMainThreadEventTargetForMessaging =
       ThrottledEventQueue::Create(target, "Worker queue for messaging");
   if (StaticPrefs::dom_worker_use_medium_high_event_queue()) {
-    mMainThreadEventTarget = ThrottledEventQueue::Create(
-        GetMainThreadSerialEventTarget(), "Worker queue",
-        nsIRunnablePriority::PRIORITY_MEDIUMHIGH);
+    mMainThreadEventTarget =
+        ThrottledEventQueue::Create(GetMainThreadSerialEventTarget(),
+                                    "Worker queue",
+                                    nsIRunnablePriority::PRIORITY_MEDIUMHIGH);
   } else {
     mMainThreadEventTarget = mMainThreadEventTargetForMessaging;
   }
   mMainThreadDebuggeeEventTarget =
       ThrottledEventQueue::Create(target, "Worker debuggee queue");
   if (IsParentWindowPaused() || IsFrozen()) {
     MOZ_ALWAYS_SUCCEEDS(mMainThreadDebuggeeEventTarget->SetIsPaused(true));
   }
--- a/dom/workers/WorkerPrivate.h
+++ b/dom/workers/WorkerPrivate.h
@@ -761,17 +761,19 @@ class WorkerPrivate : public RelativeTim
     return mLoadInfo.mOriginAttributes;
   }
 
   // Determine if the SW testing per-window flag is set by devtools
   bool ServiceWorkersTestingInWindow() const {
     return mLoadInfo.mServiceWorkersTestingInWindow;
   }
 
-  bool IsWatchedByDevtools() const { return mLoadInfo.mWatchedByDevtools; }
+  bool IsWatchedByDevtools() const {
+    return mLoadInfo.mWatchedByDevtools;
+  }
 
   // Determine if the worker is currently loading its top level script.
   bool IsLoadingWorkerScript() const { return mLoadingWorkerScript; }
 
   // Called by ScriptLoader to track when this worker is loading its
   // top level script.
   void SetLoadingWorkerScript(bool aLoadingWorkerScript) {
     // any thread
--- a/editor/libeditor/HTMLEditorController.cpp
+++ b/editor/libeditor/HTMLEditorController.cpp
@@ -1,19 +1,19 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/HTMLEditorController.h"
 
-#include "mozilla/EditorCommands.h"    // for StyleUpdatingCommand, etc
-#include "mozilla/mozalloc.h"          // for operator new
-#include "nsControllerCommandTable.h"  // for nsControllerCommandTable
-#include "nsError.h"                   // for NS_OK
+#include "mozilla/EditorCommands.h"      // for StyleUpdatingCommand, etc
+#include "mozilla/mozalloc.h"            // for operator new
+#include "nsControllerCommandTable.h"    // for nsControllerCommandTable
+#include "nsError.h"                     // for NS_OK
 
 namespace mozilla {
 
 #define NS_REGISTER_COMMAND(_cmdClass, _cmdName)                       \
   {                                                                    \
     aCommandTable->RegisterCommand(                                    \
         _cmdName,                                                      \
         static_cast<nsIControllerCommand*>(_cmdClass::GetInstance())); \
--- a/editor/libeditor/HTMLEditorDocumentCommands.cpp
+++ b/editor/libeditor/HTMLEditorDocumentCommands.cpp
@@ -1,26 +1,26 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/EditorCommands.h"
 
-#include "mozilla/HTMLEditor.h"      // for HTMLEditor
-#include "mozilla/TextEditor.h"      // for TextEditor
-#include "mozilla/dom/Document.h"    // for Document
-#include "nsCommandParams.h"         // for nsCommandParams
-#include "nsIDocShell.h"             // for nsIDocShell
-#include "nsIEditingSession.h"       // for nsIEditingSession, etc
-#include "nsISelectionController.h"  // for nsISelectionController
-#include "nsISupportsImpl.h"         // for nsPresContext::Release
-#include "nsISupportsUtils.h"        // for NS_IF_ADDREF
-#include "nsIURI.h"                  // for nsIURI
-#include "nsPresContext.h"           // for nsPresContext
+#include "mozilla/HTMLEditor.h"          // for HTMLEditor
+#include "mozilla/TextEditor.h"          // for TextEditor
+#include "mozilla/dom/Document.h"        // for Document
+#include "nsCommandParams.h"             // for nsCommandParams
+#include "nsIDocShell.h"                 // for nsIDocShell
+#include "nsIEditingSession.h"           // for nsIEditingSession, etc
+#include "nsISelectionController.h"      // for nsISelectionController
+#include "nsISupportsImpl.h"             // for nsPresContext::Release
+#include "nsISupportsUtils.h"            // for NS_IF_ADDREF
+#include "nsIURI.h"                      // for nsIURI
+#include "nsPresContext.h"               // for nsPresContext
 
 // defines
 #define STATE_ENABLED "state_enabled"
 #define STATE_ALL "state_all"
 #define STATE_ATTRIBUTE "state_attribute"
 #define STATE_DATA "state_data"
 
 namespace mozilla {
--- a/gfx/layers/LayerTreeInvalidation.cpp
+++ b/gfx/layers/LayerTreeInvalidation.cpp
@@ -136,23 +136,25 @@ static void NotifySubdocumentInvalidatio
           nsIntRegion region =
               container->GetLocalVisibleRegion().ToUnknownRegion();
           aCallback(container, &region);
         }
       });
 }
 
 static void SetChildrenChangedRecursive(Layer* aLayer) {
-  ForEachNode<ForwardIterator>(aLayer, [](Layer* layer) {
-    ContainerLayer* container = layer->AsContainerLayer();
-    if (container) {
-      container->SetChildrenChanged(true);
-      container->SetInvalidCompositeRect(nullptr);
-    }
-  });
+  ForEachNode<ForwardIterator>(
+      aLayer,
+      [](Layer* layer) {
+        ContainerLayer* container = layer->AsContainerLayer();
+        if (container) {
+          container->SetChildrenChanged(true);
+          container->SetInvalidCompositeRect(nullptr);
+        }
+      });
 }
 
 struct LayerPropertiesBase : public LayerProperties {
   explicit LayerPropertiesBase(Layer* aLayer)
       : mLayer(aLayer),
         mMaskLayer(nullptr),
         mVisibleRegion(mLayer->GetLocalVisibleRegion().ToUnknownRegion()),
         mPostXScale(aLayer->GetPostXScale()),
--- a/gfx/layers/apz/src/APZCTreeManager.h
+++ b/gfx/layers/apz/src/APZCTreeManager.h
@@ -585,17 +585,16 @@ class APZCTreeManager : public IAPZCTree
       wr::RenderRoot aRenderRoot);
 
  public:
   // Public hook for gtests subclass
   virtual TimeStamp GetFrameTime();
 
   // Also used for controlling time during tests
   void SetTestSampleTime(const Maybe<TimeStamp>& aTime);
-
  private:
   Maybe<TimeStamp> mTestSampleTime;
 
  public:
   /* Some helper functions to find an APZC given some identifying input. These
      functions lock the tree of APZCs while they find the right one, and then
      return an addref'd pointer to it. This allows caller code to just use the
      target APZC without worrying about it going away. These are public for
--- a/gfx/layers/apz/util/APZCCallbackHelper.cpp
+++ b/gfx/layers/apz/util/APZCCallbackHelper.cpp
@@ -661,17 +661,18 @@ using FrameForPointOption = nsLayoutUtil
 
 // Determine the scrollable target frame for the given point and add it to
 // the target list. If the frame doesn't have a displayport, set one.
 // Return whether or not a displayport was set.
 static bool PrepareForSetTargetAPZCNotification(
     nsIWidget* aWidget, const LayersId& aLayersId, nsIFrame* aRootFrame,
     const LayoutDeviceIntPoint& aRefPoint,
     nsTArray<SLGuidAndRenderRoot>* aTargets) {
-  SLGuidAndRenderRoot guid(aLayersId, 0, ScrollableLayerGuid::NULL_SCROLL_ID,
+  SLGuidAndRenderRoot guid(aLayersId, 0,
+                           ScrollableLayerGuid::NULL_SCROLL_ID,
                            wr::RenderRoot::Default);
   nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
       aWidget, aRefPoint, aRootFrame);
   EnumSet<FrameForPointOption> options;
   if (nsLayoutUtils::AllowZoomingForDocument(
           aRootFrame->PresShell()->GetDocument())) {
     // If zooming is enabled, we need IgnoreRootScrollFrame for correct
     // hit testing. Otherwise, don't use it because it interferes with
@@ -812,21 +813,19 @@ void DisplayportSetListener::DidRefresh(
     mPresShell = nullptr;
     return;
   }
 
   delete this;
 }
 
 UniquePtr<DisplayportSetListener>
-APZCCallbackHelper::SendSetTargetAPZCNotification(nsIWidget* aWidget,
-                                                  dom::Document* aDocument,
-                                                  const WidgetGUIEvent& aEvent,
-                                                  const LayersId& aLayersId,
-                                                  uint64_t aInputBlockId) {
+APZCCallbackHelper::SendSetTargetAPZCNotification(
+    nsIWidget* aWidget, dom::Document* aDocument, const WidgetGUIEvent& aEvent,
+    const LayersId& aLayersId, uint64_t aInputBlockId) {
   if (!aWidget || !aDocument) {
     return nullptr;
   }
   if (aInputBlockId == sLastTargetAPZCNotificationInputBlock) {
     // We have already confirmed the target APZC for a previous event of this
     // input block. If we activated a scroll frame for this input block,
     // sending another target APZC confirmation would be harmful, as it might
     // race the original confirmation (which needs to go through a layers
--- a/gfx/layers/apz/util/APZEventState.cpp
+++ b/gfx/layers/apz/util/APZEventState.cpp
@@ -171,18 +171,18 @@ class DelayedFireSingleTapEvent final : 
 };
 
 NS_IMPL_ISUPPORTS(DelayedFireSingleTapEvent, nsITimerCallback, nsINamed)
 
 void APZEventState::ProcessSingleTap(const CSSPoint& aPoint,
                                      const CSSToLayoutDeviceScale& aScale,
                                      Modifiers aModifiers,
                                      int32_t aClickCount) {
-  APZES_LOG("Handling single tap at %s with %d\n", Stringify(aPoint).c_str(),
-            mTouchEndCancelled);
+  APZES_LOG("Handling single tap at %s with %d\n",
+            Stringify(aPoint).c_str(), mTouchEndCancelled);
 
   RefPtr<nsIContent> touchRollup = GetTouchRollup();
   mTouchRollup = nullptr;
 
   nsCOMPtr<nsIWidget> widget = GetWidget();
   if (!widget) {
     return;
   }
--- a/gfx/layers/basic/BasicCompositor.cpp
+++ b/gfx/layers/basic/BasicCompositor.cpp
@@ -220,16 +220,17 @@ BasicCompositor::BasicCompositor(Composi
 
   // The widget backends may create intermediate Cairo surfaces to deal with
   // various window buffers, regardless of actual content backend type, when
   // using the basic compositor. Ensure that the buffers will be able to fit
   // in or blit with a Cairo surface.
   mMaxTextureSize =
       std::min(Factory::GetMaxSurfaceSize(gfxVars::ContentBackend()),
                Factory::GetMaxSurfaceSize(BackendType::CAIRO));
+
 }
 
 BasicCompositor::~BasicCompositor() { MOZ_COUNT_DTOR(BasicCompositor); }
 
 bool BasicCompositor::Initialize(nsCString* const out_failureReason) {
   return mWidget ? mWidget->InitCompositor(this) : false;
 };
 
--- a/gfx/layers/d3d11/CompositorD3D11.cpp
+++ b/gfx/layers/d3d11/CompositorD3D11.cpp
@@ -446,18 +446,17 @@ CompositorD3D11::CreateRenderTargetFromS
       new CompositingRenderTargetD3D11(texture, aRect.TopLeft());
   rt->SetSize(aRect.Size());
 
   return rt.forget();
 }
 
 bool CompositorD3D11::ShouldAllowFrameRecording() const {
 #ifdef MOZ_GECKO_PROFILER
-  return mAllowFrameRecording ||
-         profiler_feature_active(ProfilerFeature::Screenshots);
+  return mAllowFrameRecording || profiler_feature_active(ProfilerFeature::Screenshots);
 #else
   return mAllowFrameRecording;
 #endif
 }
 
 already_AddRefed<CompositingRenderTarget>
 CompositorD3D11::GetWindowRenderTarget() const {
   if (!ShouldAllowFrameRecording()) {
--- a/gfx/layers/wr/WebRenderLayerManager.cpp
+++ b/gfx/layers/wr/WebRenderLayerManager.cpp
@@ -475,23 +475,23 @@ void WebRenderLayerManager::MakeSnapshot
   // XXX Add other TextureData supports.
   // Only BufferTexture is supported now.
 
   // TODO: fixup for proper surface format.
   // The GLES spec only guarantees that RGBA can be used with glReadPixels,
   // so on Android we use RGBA.
   SurfaceFormat format =
 #ifdef MOZ_WIDGET_ANDROID
-      SurfaceFormat::R8G8B8A8;
+    SurfaceFormat::R8G8B8A8;
 #else
-      SurfaceFormat::B8G8R8A8;
+    SurfaceFormat::B8G8R8A8;
 #endif
   RefPtr<TextureClient> texture = TextureClient::CreateForRawBufferAccess(
-      WrBridge(), format, aSize.ToUnknownSize(), BackendType::SKIA,
-      TextureFlags::SNAPSHOT);
+      WrBridge(), format, aSize.ToUnknownSize(),
+      BackendType::SKIA, TextureFlags::SNAPSHOT);
   if (!texture) {
     return;
   }
 
   texture->InitIPDLActor(WrBridge());
   if (!texture->GetIPDLActor()) {
     return;
   }
--- a/gfx/thebes/SharedFontList-impl.h
+++ b/gfx/thebes/SharedFontList-impl.h
@@ -71,17 +71,17 @@ class FontList {
    * the FontList and create a new one.
    *
    * In some cases, a font family may be known by multiple names (e.g.
    * localizations in multiple languages, or there may be legacy family names
    * that correspond to specific styled faces like "Arial Black"). Such names
    * do not appear in this master list, but are referred to as aliases (see
    * SetAliases below); the alias list need not be populated before the font
    * list is shared to content processes and used.
-   *
+   * 
    * Only used in the parent process.
    */
   void SetFamilyNames(const nsTArray<Family::InitData>& aFamilies);
 
   /**
    * Aliases are Family records whose Face entries are already part of another
    * family (either because the family has multiple localized names, or because
    * the alias family is a legacy name like "Arial Narrow" that is a subset of
@@ -177,22 +177,22 @@ class FontList {
    * (Subsequent blocks have only the mAllocated field, accessed via the
    * Block::Allocated() method.)
    * The mGeneration and mFamilyCount fields are set by the parent process
    * during font-list construction, before the list has been shared with any
    * other process, and subsequently never change; therefore, we don't need
    * to use std::atomic<> for these.
    */
   struct Header {
-    std::atomic<uint32_t> mAllocated;   // Space allocated from this block;
-                                        // must be first field in Header
-    uint32_t mGeneration;               // Font-list generation ID
-    uint32_t mFamilyCount;              // Number of font families in the list
-    std::atomic<uint32_t> mBlockCount;  // Total number of blocks that exist
-    std::atomic<uint32_t> mAliasCount;  // Number of family aliases
+    std::atomic<uint32_t> mAllocated;    // Space allocated from this block;
+                                         // must be first field in Header
+    uint32_t mGeneration;                // Font-list generation ID
+    uint32_t mFamilyCount;               // Number of font families in the list
+    std::atomic<uint32_t> mBlockCount;   // Total number of blocks that exist
+    std::atomic<uint32_t> mAliasCount;   // Number of family aliases
     std::atomic<uint32_t> mLocalFaceCount;  // Number of local face names
     Pointer mFamilies;    // Pointer to array of |mFamilyCount| families
     Pointer mAliases;     // Pointer to array of |mAliasCount| aliases
     Pointer mLocalFaces;  // Pointer to array of |mLocalFaceCount| face records
   };
 
   /**
    * Used by the parent process to pass a handle to a shared block to a
@@ -249,19 +249,19 @@ class FontList {
     // The first 32-bit word of each block holds the current amount allocated
     // in that block; this is updated whenever a new record is stored in the
     // block.
     std::atomic<uint32_t>& Allocated() const {
       return *static_cast<std::atomic<uint32_t>*>(mAddr);
     }
 
     RefPtr<mozilla::ipc::SharedMemoryBasic> mShmem;
-    void* mAddr;  // Address where the shared memory block is mapped in this
-                  // process; avoids virtual call to mShmem->memory() each time
-                  // we need to convert between Pointer and a real C++ pointer.
+    void* mAddr; // Address where the shared memory block is mapped in this
+                 // process; avoids virtual call to mShmem->memory() each time
+                 // we need to convert between Pointer and a real C++ pointer.
   };
 
   Header& GetHeader() {
     // It's invalid to try and access this before the first block exists.
     MOZ_ASSERT(mBlocks.Length() > 0);
     return *static_cast<Header*>(Pointer(0, 0).ToPtr(this));
   }
 
--- a/gfx/thebes/SharedFontList.cpp
+++ b/gfx/thebes/SharedFontList.cpp
@@ -107,17 +107,17 @@ void Family::AddFaces(FontList* aList, c
   }
 
   uint32_t count = aFaces.Length();
   bool isSimple = false;
   // A family is "simple" (i.e. simplified style selection may be used instead
   // of the full CSS font-matching algorithm) if there is at maximum one normal,
   // bold, italic, and bold-italic face; in this case, they are stored at known
   // positions in the mFaces array.
-  const Face::InitData* slots[4] = {nullptr, nullptr, nullptr, nullptr};
+  const Face::InitData* slots[4] = { nullptr, nullptr, nullptr, nullptr };
   if (count >= 2 && count <= 4) {
     // Check if this can be treated as a "simple" family
     isSimple = true;
     for (const auto& f : aFaces) {
       if (!f.mWeight.IsSingle() || !f.mStretch.IsSingle() ||
           !f.mStyle.IsSingle()) {
         isSimple = false;
         break;
@@ -303,17 +303,17 @@ void Family::SearchAllFontsForChar(FontL
     return;
   }
   if (!IsInitialized()) {
     if (!gfxPlatformFontList::PlatformFontList()->InitializeFamily(this)) {
       return;
     }
   }
   uint32_t numFaces = NumFaces();
-  uint32_t charMapsLoaded = 0;  // number of faces whose charmap is loaded
+  uint32_t charMapsLoaded = 0; // number of faces whose charmap is loaded
   Pointer* facePtrs = Faces(aList);
   for (uint32_t i = 0; i < numFaces; i++) {
     Face* face = static_cast<Face*>(facePtrs[i].ToPtr(aList));
     if (!face) {
       continue;
     }
     MOZ_ASSERT(face->HasValidDescriptor());
     // Get the face's character map, if available (may be null!)
@@ -327,19 +327,18 @@ void Family::SearchAllFontsForChar(FontL
     // match than what we've already found).
     if (!charmap || charmap->test(aMatchData->mCh)) {
       double distance = WSSDistance(face, aMatchData->mStyle);
       if (distance < aMatchData->mMatchDistance) {
         // It's a better style match: get a fontEntry, and if we haven't
         // already checked character coverage, do it now (note that
         // HasCharacter() will trigger loading the fontEntry's cmap, if
         // needed).
-        RefPtr<gfxFontEntry> fe =
-            gfxPlatformFontList::PlatformFontList()->GetOrCreateFontEntry(face,
-                                                                          this);
+        RefPtr<gfxFontEntry> fe = gfxPlatformFontList::PlatformFontList()
+            ->GetOrCreateFontEntry(face, this);
         if (!fe) {
           continue;
         }
         if (!charmap && !fe->HasCharacter(aMatchData->mCh)) {
           continue;
         }
         aMatchData->mBestMatch = fe;
         aMatchData->mMatchDistance = distance;
@@ -354,18 +353,19 @@ void Family::SearchAllFontsForChar(FontL
 
 void Family::SetFacePtrs(FontList* aList, nsTArray<Pointer>& aFaces) {
   if (aFaces.Length() >= 2 && aFaces.Length() <= 4) {
     // Check whether the faces meet the criteria for a "simple" family: no more
     // than one each of Regular, Bold, Italic, BoldItalic styles. If so, store
     // them at the appropriate slots in mFaces and set the mIsSimple flag to
     // accelerate font-matching.
     bool isSimple = true;
-    Pointer slots[4] = {Pointer::Null(), Pointer::Null(), Pointer::Null(),
-                        Pointer::Null()};
+    Pointer slots[4] = {
+      Pointer::Null(), Pointer::Null(), Pointer::Null(), Pointer::Null()
+    };
     for (const Pointer& fp : aFaces) {
       const Face* f = static_cast<const Face*>(fp.ToPtr(aList));
       if (!f->mWeight.IsSingle() || !f->mStyle.IsSingle() ||
           !f->mStretch.IsSingle()) {
         isSimple = false;
         break;
       }
       if (!f->mStretch.Min().IsNormal()) {
@@ -433,17 +433,17 @@ void Family::SetupFamilyCharMap(FontList
         familyMap.Union(*firstMap);
         merged = true;
       }
       familyMap.Union(*faceMap);
     }
   }
   if (merged) {
     mCharacterMap =
-        gfxPlatformFontList::PlatformFontList()->GetShmemCharMap(&familyMap);
+      gfxPlatformFontList::PlatformFontList()->GetShmemCharMap(&familyMap);
   } else {
     mCharacterMap = firstMapShmPointer;
   }
 }
 
 FontList::FontList(uint32_t aGeneration) {
   if (XRE_IsParentProcess()) {
     // Create the initial shared block, and initialize Header
--- a/gfx/thebes/SharedFontList.h
+++ b/gfx/thebes/SharedFontList.h
@@ -119,23 +119,23 @@ struct String {
  * instantiate a (platform-specific) font reference that can be used with
  * platform font APIs; their content depends on the requirements of the
  * platform APIs (e.g. font PostScript name, file pathname, serialized
  * fontconfig pattern, etc).
  */
 struct Face {
   // Data required to initialize a Face
   struct InitData {
-    nsCString mDescriptor;  // descriptor that can be used to instantiate a
-                            // platform font reference
-    uint16_t mIndex;        // an index used with descriptor (on some platforms)
-    bool mFixedPitch;       // is the face fixed-pitch (monospaced)?
-    mozilla::WeightRange mWeight;     // CSS font-weight value
-    mozilla::StretchRange mStretch;   // CSS font-stretch value
-    mozilla::SlantStyleRange mStyle;  // CSS font-style value
+    nsCString mDescriptor; // descriptor that can be used to instantiate a
+                           // platform font reference
+    uint16_t mIndex;       // an index used with descriptor (on some platforms)
+    bool mFixedPitch;      // is the face fixed-pitch (monospaced)?
+    mozilla::WeightRange mWeight;    // CSS font-weight value
+    mozilla::StretchRange mStretch;  // CSS font-stretch value
+    mozilla::SlantStyleRange mStyle; // CSS font-style value
   };
 
   Face(FontList* aList, const InitData& aData)
       : mDescriptor(aList, aData.mDescriptor),
         mIndex(aData.mIndex),
         mFixedPitch(aData.mFixedPitch),
         mWeight(aData.mWeight),
         mStretch(aData.mStretch),
@@ -162,25 +162,25 @@ struct Face {
  * a name (for display purposes) and a key (lowercased, for case-insensitive
  * lookups), as well as a pointer to an array of Faces. Depending on the
  * platform, the array of faces may be lazily initialized the first time we
  * want to use the family.
  */
 struct Family {
   // Data required to initialize a Family
   struct InitData {
-    InitData(const nsACString& aKey,   // lookup key (lowercased)
-             const nsACString& aName,  // display name
-             uint32_t aIndex = 0,   // [win] index in the system font collection
-             bool aHidden = false,  // [mac] hidden font (e.g. .SFNSText)?
-             bool aBundled = false,       // [win] font was bundled with the app
-                                          // rather than system-installed
-             bool aBadUnderline = false,  // underline-position in font is bad
-             bool aForceClassic = false   // [win] use "GDI classic" rendering
-             )
+    InitData(const nsACString& aKey, // lookup key (lowercased)
+             const nsACString& aName, // display name
+             uint32_t aIndex = 0, // [win] index in the system font collection
+             bool aHidden = false, // [mac] hidden font (e.g. .SFNSText)?
+             bool aBundled = false, // [win] font was bundled with the app
+                                    // rather than system-installed
+             bool aBadUnderline = false, // underline-position in font is bad
+             bool aForceClassic = false // [win] use "GDI classic" rendering
+            )
         : mKey(aKey),
           mName(aName),
           mIndex(aIndex),
           mHidden(aHidden),
           mBundled(aBundled),
           mBadUnderline(aBadUnderline),
           mForceClassic(aForceClassic) {}
     bool operator<(const InitData& aRHS) const { return mKey < aRHS.mKey; }
@@ -256,25 +256,25 @@ struct Family {
   void SearchAllFontsForChar(FontList* aList, GlobalFontMatch* aMatchData);
 
   void SetupFamilyCharMap(FontList* aList);
 
  private:
   std::atomic<uint32_t> mFaceCount;
   String mKey;
   String mName;
-  Pointer mCharacterMap;  // If non-null, union of character coverage of all
-                          // faces in the family
-  Pointer mFaces;         // Pointer to array of |mFaceCount| face pointers
-  uint32_t mIndex;        // [win] Top bit set indicates app-bundled font family
+  Pointer mCharacterMap; // If non-null, union of character coverage of all
+                         // faces in the family
+  Pointer mFaces; // Pointer to array of |mFaceCount| face pointers
+  uint32_t mIndex; // [win] Top bit set indicates app-bundled font family
   bool mIsHidden;
   bool mIsBadUnderlineFamily;
   bool mIsForceClassic;
-  bool mIsSimple;  // family allows simplified style matching: mFaces contains
-                   // exactly 4 entries [Regular, Bold, Italic, BoldItalic].
+  bool mIsSimple; // family allows simplified style matching: mFaces contains
+                  // exactly 4 entries [Regular, Bold, Italic, BoldItalic].
 };
 
 /**
  * For platforms where we build an index of local font face names (PS-name
  * and fullname of the font) to support @font-face{src:local(...)}, we map
  * each face name to an index into the family list, and an index into the
  * family's list of faces.
  */
@@ -320,12 +320,12 @@ struct ParamTraits<mozilla::fontlist::Po
       return true;
     }
     return false;
   }
 };
 
 }  // namespace IPC
 
-#undef ERROR  // This is defined via Windows.h, but conflicts with some bindings
-              // code when this gets included in the same compilation unit.
+#undef ERROR // This is defined via Windows.h, but conflicts with some bindings
+             // code when this gets included in the same compilation unit.
 
 #endif /* SharedFontList_h */
--- a/gfx/thebes/gfxDWriteFontList.cpp
+++ b/gfx/thebes/gfxDWriteFontList.cpp
@@ -520,17 +520,17 @@ nsresult gfxDWriteFontEntry::ReadCMAP(Fo
     // Fallback to Segoe UI Symbol is preferred.
     if (FamilyName().EqualsLiteral("Segoe UI")) {
       charmap->clear(0x25b6);
       charmap->clear(0x25c0);
     }
     gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
     fontlist::FontList* sharedFontList = pfl->SharedFontList();
     if (!IsUserFont() && mShmemFace) {
-      mShmemFace->SetCharacterMap(sharedFontList, charmap);  // async
+      mShmemFace->SetCharacterMap(sharedFontList, charmap); // async
       if (!TrySetShmemCharacterMap()) {
         // Temporarily retain charmap, until the shared version is
         // ready for use.
         mCharacterMap = charmap;
       }
     } else {
       mCharacterMap = pfl->FindCharMap(charmap);
     }
--- a/gfx/thebes/gfxFontEntry.cpp
+++ b/gfx/thebes/gfxFontEntry.cpp
@@ -135,17 +135,18 @@ gfxFontEntry::~gfxFontEntry() {
 
   // By the time the entry is destroyed, all font instances that were
   // using it should already have been deleted, and so the HB and/or Gr
   // face objects should have been released.
   MOZ_ASSERT(!mHBFace);
   MOZ_ASSERT(!mGrFaceInitialized);
 }
 
-bool gfxFontEntry::TrySetShmemCharacterMap() {
+bool gfxFontEntry::TrySetShmemCharacterMap()
+{
   MOZ_ASSERT(mShmemFace);
   auto list = gfxPlatformFontList::PlatformFontList()->SharedFontList();
   mShmemCharacterMap =
       static_cast<const SharedBitSet*>(mShmemFace->mCharacterMap.ToPtr(list));
   return mShmemCharacterMap != nullptr;
 }
 
 bool gfxFontEntry::TestCharacterMap(uint32_t aCh) {
--- a/gfx/thebes/gfxFontUtils.h
+++ b/gfx/thebes/gfxFontUtils.h
@@ -482,34 +482,34 @@ class SharedBitSet {
 
 // Union the contents of a SharedBitSet with the target gfxSparseBitSet
 inline void gfxSparseBitSet::Union(const SharedBitSet& aBitset) {
   // ensure mBlockIndex is large enough
   while (mBlockIndex.Length() < aBitset.mBlockIndexCount) {
     mBlockIndex.AppendElement(NO_BLOCK);
   }
   auto blockIndex = reinterpret_cast<const uint16_t*>(&aBitset + 1);
-  auto blocks =
-      reinterpret_cast<const Block*>(blockIndex + aBitset.mBlockIndexCount);
+  auto blocks = reinterpret_cast<const Block*>(blockIndex + aBitset.mBlockIndexCount);
   for (uint32_t i = 0; i < aBitset.mBlockIndexCount; ++i) {
     // if it is missing (implicitly empty) in source, just skip
     if (blockIndex[i] == NO_BLOCK) {
       continue;
     }
     // if the block is missing, just copy from source bitset
     if (mBlockIndex[i] == NO_BLOCK) {
       mBlocks.AppendElement(blocks[blockIndex[i]]);
       MOZ_ASSERT(mBlocks.Length() < 0xffff, "block index overflow");
       mBlockIndex[i] = uint16_t(mBlocks.Length() - 1);
       continue;
     }
     // else set existing target block to the union of both
-    uint32_t* dst = reinterpret_cast<uint32_t*>(&mBlocks[mBlockIndex[i]].mBits);
-    const uint32_t* src =
-        reinterpret_cast<const uint32_t*>(&blocks[blockIndex[i]].mBits);
+    uint32_t* dst = reinterpret_cast<uint32_t*>(
+        &mBlocks[mBlockIndex[i]].mBits);
+    const uint32_t* src = reinterpret_cast<const uint32_t*>(
+        &blocks[blockIndex[i]].mBits);
     for (uint32_t j = 0; j < BLOCK_SIZE / 4; ++j) {
       dst[j] |= src[j];
     }
   }
 }
 
 #define TRUETYPE_TAG(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d))
 
--- a/gfx/thebes/gfxMacPlatformFontList.mm
+++ b/gfx/thebes/gfxMacPlatformFontList.mm
@@ -234,17 +234,17 @@ nsresult MacOSFontEntry::ReadCMAP(FontIn
     }
   }
 
   mHasCmapTable = NS_SUCCEEDED(rv);
   if (mHasCmapTable) {
     gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
     fontlist::FontList* sharedFontList = pfl->SharedFontList();
     if (!IsUserFont() && mShmemFace) {
-      mShmemFace->SetCharacterMap(sharedFontList, charmap);  // async
+      mShmemFace->SetCharacterMap(sharedFontList, charmap); // async
       if (!TrySetShmemCharacterMap()) {
         // Temporarily retain charmap, until the shared version is
         // ready for use.
         mCharacterMap = charmap;
       }
     } else {
       mCharacterMap = pfl->FindCharMap(charmap);
     }
@@ -1758,17 +1758,18 @@ void gfxMacPlatformFontList::ActivateFon
     }
   }
 
   ::CTFontManagerRegisterFontsForURLs(urls, kCTFontManagerScopeProcess, nullptr);
   ::CFRelease(urls);
 }
 
 void gfxMacPlatformFontList::GetFacesInitDataForFamily(
-    const fontlist::Family* aFamily, nsTArray<fontlist::Face::InitData>& aFaces) const {
+    const fontlist::Family* aFamily,
+    nsTArray<fontlist::Face::InitData>& aFaces) const {
   nsAutoreleasePool localPool;
 
   NS_ConvertUTF8toUTF16 name(aFamily->Key().AsString(SharedFontList()));
   NSString* family = GetNSStringForString(name);
 
   // returns an array of [psname, style name, weight, traits] elements, goofy api
   NSArray* fontfaces = [sFontManager availableMembersOfFontFamily:family];
   int faceCount = [fontfaces count];
@@ -1854,29 +1855,30 @@ void gfxMacPlatformFontList::ReadFaceNam
     nsAutoCString name(face->mDescriptor.AsString(list));
     // We create a temporary MacOSFontEntry just to read family names from the
     // 'name' table in the font resource. The style attributes here are ignored
     // as this entry is not used for font style matching.
     // The size hint might be used to select which face is accessed in the case
     // of the macOS UI font; see MacOSFontEntry::GetFontRef(). We pass 16.0 in
     // order to get a standard text-size face in this case, although it's
     // unlikely to matter for the purpose of just reading family names.
-    auto fe = MakeUnique<MacOSFontEntry>(name, WeightRange(FontWeight::Normal()), false, 16.0);
+    auto fe = MakeUnique<MacOSFontEntry>(name, WeightRange(FontWeight::Normal()),
+                                         false, 16.0);
     if (!fe) {
       continue;
     }
     gfxFontEntry::AutoTable nameTable(fe.get(), kNAME);
     if (!nameTable) {
       continue;
     }
     uint32_t dataLength;
     const char* nameData = hb_blob_get_data(nameTable, &dataLength);
     AutoTArray<nsCString, 4> otherFamilyNames;
-    gfxFontUtils::ReadOtherFamilyNamesForFace(canonicalName, nameData, dataLength, otherFamilyNames,
-                                              false);
+    gfxFontUtils::ReadOtherFamilyNamesForFace(canonicalName, nameData, dataLength,
+                                              otherFamilyNames, false);
     for (const auto& alias : otherFamilyNames) {
       auto af = mAliasTable.LookupOrAdd(alias);
       af->AppendElement(facePtrs[i]);
     }
   }
 }
 
 #ifdef MOZ_BUNDLED_FONTS
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -405,17 +405,17 @@ NS_IMPL_ISUPPORTS(SRGBOverrideObserver, 
 
 #define GFX_PREF_OPENTYPE_SVG "gfx.font_rendering.opentype_svg.enabled"
 
 #define GFX_PREF_WORD_CACHE_CHARLIMIT "gfx.font_rendering.wordcache.charlimit"
 #define GFX_PREF_WORD_CACHE_MAXENTRIES "gfx.font_rendering.wordcache.maxentries"
 
 #define GFX_PREF_GRAPHITE_SHAPING "gfx.font_rendering.graphite.enabled"
 #if defined(XP_MACOSX)
-#  define GFX_PREF_CORETEXT_SHAPING "gfx.font_rendering.coretext.enabled"
+#define GFX_PREF_CORETEXT_SHAPING "gfx.font_rendering.coretext.enabled"
 #endif
 
 #define BIDI_NUMERAL_PREF "bidi.numeral"
 
 #define GFX_PREF_CMS_FORCE_SRGB "gfx.color_management.force_srgb"
 
 #define FONT_VARIATIONS_PREF "layout.css.font-variations.enabled"
 
--- a/gfx/thebes/gfxPlatformFontList.cpp
+++ b/gfx/thebes/gfxPlatformFontList.cpp
@@ -1751,18 +1751,18 @@ void gfxPlatformFontList::InitLoader() {
 #define FONT_LOADER_MAX_TIMESLICE \
   100  // max time for one pass through RunLoader = 100ms
 
 bool gfxPlatformFontList::LoadFontInfo() {
   TimeStamp start = TimeStamp::Now();
   uint32_t i, endIndex = mNumFamilies;
   fontlist::FontList* list = SharedFontList();
   bool loadCmaps =
-      !list && (!UsesSystemFallback() ||
-                gfxPlatform::GetPlatform()->UseCmapsDuringSystemFallback());
+    !list && (!UsesSystemFallback() ||
+              gfxPlatform::GetPlatform()->UseCmapsDuringSystemFallback());
 
   // for each font family, load in various font info
   for (i = mStartIndex; i < endIndex; i++) {
     nsAutoCString key;
     GenerateFontListKey(mFontInfo->mFontFamiliesToLoad[i], key);
 
     if (list) {
       fontlist::Family* family = list->FindFamily(key);
--- a/gfx/webrender_bindings/RendererOGL.cpp
+++ b/gfx/webrender_bindings/RendererOGL.cpp
@@ -124,17 +124,18 @@ bool RendererOGL::UpdateAndRender(const 
                           aOutStats)) {
     NotifyWebRenderError(WebRenderError::RENDER);
   }
 
   if (aReadbackBuffer.isSome()) {
     MOZ_ASSERT(aReadbackSize.isSome());
     MOZ_ASSERT(aReadbackFormat.isSome());
     wr_renderer_readback(mRenderer, aReadbackSize.ref().width,
-                         aReadbackSize.ref().height, aReadbackFormat.ref(),
+                         aReadbackSize.ref().height,
+                         aReadbackFormat.ref(),
                          &aReadbackBuffer.ref()[0],
                          aReadbackBuffer.ref().length());
   }
 
   mScreenshotGrabber.MaybeGrabScreenshot(mRenderer, size.ToUnknownSize());
 
   mCompositor->EndFrame();
 
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -425,20 +425,17 @@ bool WebRenderAPI::HitTest(const wr::Wor
 void WebRenderAPI::Readback(const TimeStamp& aStartTime, gfx::IntSize size,
                             const gfx::SurfaceFormat& aFormat,
                             const Range<uint8_t>& buffer) {
   class Readback : public RendererEvent {
    public:
     explicit Readback(layers::SynchronousTask* aTask, TimeStamp aStartTime,
                       gfx::IntSize aSize, const gfx::SurfaceFormat& aFormat,
                       const Range<uint8_t>& aBuffer)
-        : mTask(aTask),
-          mStartTime(aStartTime),
-          mSize(aSize),
-          mFormat(aFormat),
+        : mTask(aTask), mStartTime(aStartTime), mSize(aSize), mFormat(aFormat),
           mBuffer(aBuffer) {
       MOZ_COUNT_CTOR(Readback);
     }
 
     virtual ~Readback() { MOZ_COUNT_DTOR(Readback); }
 
     void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
       aRenderThread.UpdateAndRender(aWindowId, VsyncId(), mStartTime,
@@ -1159,17 +1156,18 @@ void DisplayListBuilder::PushShadow(cons
   // Local clip_rects are translated inside of shadows, as they are assumed to
   // be part of the element drawing itself, and not a parent frame clipping it.
   // As such, it is not sound to apply the MergeClipLeaf optimization inside of
   // shadows. So we disable the optimization when we encounter a shadow.
   // Shadows don't span frames, so we don't have to worry about MergeClipLeaf
   // being re-enabled mid-shadow. The optimization is restored in PopAllShadows.
   SuspendClipLeafMerging();
   wr_dp_push_shadow(mWrState, aRect, aClip, aIsBackfaceVisible,
-                    &mCurrentSpaceAndClipChain, aShadow, aShouldInflate);
+                    &mCurrentSpaceAndClipChain, aShadow,
+                    aShouldInflate);
 }
 
 void DisplayListBuilder::PopAllShadows() {
   wr_dp_pop_all_shadows(mWrState);
   ResumeClipLeafMerging();
 }
 
 void DisplayListBuilder::SuspendClipLeafMerging() {
--- a/hal/android/AndroidHal.cpp
+++ b/hal/android/AndroidHal.cpp
@@ -109,17 +109,17 @@ void GetCurrentScreenConfiguration(Scree
   int32_t rectX, rectY, rectWidth, rectHeight;
 
   screenMgr->GetPrimaryScreen(getter_AddRefs(screen));
 
   screen->GetRect(&rectX, &rectY, &rectWidth, &rectHeight);
   screen->GetColorDepth(&colorDepth);
   screen->GetPixelDepth(&pixelDepth);
   orientation =
-      static_cast<hal::ScreenOrientation>(bridge->GetScreenOrientation());
+    static_cast<hal::ScreenOrientation>(bridge->GetScreenOrientation());
   angle = bridge->GetScreenAngle();
 
   *aScreenConfiguration =
       hal::ScreenConfiguration(nsIntRect(rectX, rectY, rectWidth, rectHeight),
                                orientation, angle, colorDepth, pixelDepth);
 }
 
 bool LockScreenOrientation(const hal::ScreenOrientation& aOrientation) {
--- a/intl/hyphenation/glue/nsHyphenator.h
+++ b/intl/hyphenation/glue/nsHyphenator.h
@@ -20,16 +20,16 @@ class nsHyphenator {
 
   bool IsValid();
 
   nsresult Hyphenate(const nsAString& aText, nsTArray<bool>& aHyphens);
 
  private:
   ~nsHyphenator();
 
-  void HyphenateWord(const nsAString& aString, uint32_t aStart, uint32_t aLimit,
-                     nsTArray<bool>& aHyphens);
+  void HyphenateWord(const nsAString& aString, uint32_t aStart,
+                     uint32_t aLimit, nsTArray<bool>& aHyphens);
 
   void* mDict;
   bool mHyphenateCapitalized;
 };
 
 #endif  // nsHyphenator_h__
--- a/ipc/mscom/ProcessRuntime.cpp
+++ b/ipc/mscom/ProcessRuntime.cpp
@@ -64,56 +64,52 @@ ProcessRuntime::ProcessRuntime(GeckoProc
     HANDLE rawCurThreadImpToken;
     if (!::OpenThreadToken(::GetCurrentThread(), TOKEN_DUPLICATE | TOKEN_QUERY,
                            FALSE, &rawCurThreadImpToken)) {
       mInitResult = HRESULT_FROM_WIN32(::GetLastError());
       return;
     }
     nsAutoHandle curThreadImpToken(rawCurThreadImpToken);
 
-#  if defined(DEBUG)
+#if defined(DEBUG)
     // Ensure that our current token is still an impersonation token (ie, we
     // have not yet called RevertToSelf() on this thread).
     DWORD len;
     TOKEN_TYPE tokenType;
     MOZ_ASSERT(::GetTokenInformation(rawCurThreadImpToken, TokenType,
                                      &tokenType, sizeof(tokenType), &len) &&
                len == sizeof(tokenType) && tokenType == TokenImpersonation);
-#  endif  // defined(DEBUG)
+#endif  // defined(DEBUG)
 
     // Create an impersonation token based on the current thread's token
     HANDLE rawMtaThreadImpToken = nullptr;
     if (!::DuplicateToken(rawCurThreadImpToken, SecurityImpersonation,
                           &rawMtaThreadImpToken)) {
       mInitResult = HRESULT_FROM_WIN32(::GetLastError());
       return;
     }
     nsAutoHandle mtaThreadImpToken(rawMtaThreadImpToken);
 
     SandboxTarget::Instance()->RegisterSandboxStartCallback([]() -> void {
-      EnsureMTA(
-          []() -> void {
-            // This is a security risk if it fails, so we release assert
-            MOZ_RELEASE_ASSERT(::RevertToSelf(),
-                               "mscom::ProcessRuntime RevertToSelf failed");
-          },
-          EnsureMTA::Option::ForceDispatch);
+      EnsureMTA([]() -> void {
+        // This is a security risk if it fails, so we release assert
+        MOZ_RELEASE_ASSERT(::RevertToSelf(),
+                           "mscom::ProcessRuntime RevertToSelf failed");
+      }, EnsureMTA::Option::ForceDispatch);
     });
 
     // Impersonate and initialize.
-    EnsureMTA(
-        [this, rawMtaThreadImpToken]() -> void {
-          if (!::SetThreadToken(nullptr, rawMtaThreadImpToken)) {
-            mInitResult = HRESULT_FROM_WIN32(::GetLastError());
-            return;
-          }
+    EnsureMTA([this, rawMtaThreadImpToken]() -> void {
+      if (!::SetThreadToken(nullptr, rawMtaThreadImpToken)) {
+        mInitResult = HRESULT_FROM_WIN32(::GetLastError());
+        return;
+      }
 
-          InitInsideApartment();
-        },
-        EnsureMTA::Option::ForceDispatch);
+      InitInsideApartment();
+    }, EnsureMTA::Option::ForceDispatch);
 
     return;
   }
 
 #endif  // defined(MOZILLA_INTERNAL_API)
 
   // Otherwise we initialize a single-threaded apartment on the current thread.
   mAptRegion.Init(COINIT_APARTMENTTHREADED);
--- a/js/public/AllocPolicy.h
+++ b/js/public/AllocPolicy.h
@@ -30,31 +30,29 @@ class AllocPolicyBase {
   T* maybe_pod_arena_malloc(arena_id_t arenaId, size_t numElems) {
     return js_pod_arena_malloc<T>(arenaId, numElems);
   }
   template <typename T>
   T* maybe_pod_arena_calloc(arena_id_t arenaId, size_t numElems) {
     return js_pod_arena_calloc<T>(arenaId, numElems);
   }
   template <typename T>
-  T* maybe_pod_arena_realloc(arena_id_t arenaId, T* p, size_t oldSize,
-                             size_t newSize) {
+  T* maybe_pod_arena_realloc(arena_id_t arenaId, T* p, size_t oldSize, size_t newSize) {
     return js_pod_arena_realloc<T>(arenaId, p, oldSize, newSize);
   }
   template <typename T>
   T* pod_arena_malloc(arena_id_t arenaId, size_t numElems) {
     return maybe_pod_arena_malloc<T>(arenaId, numElems);
   }
   template <typename T>
   T* pod_arena_calloc(arena_id_t arenaId, size_t numElems) {
     return maybe_pod_arena_calloc<T>(arenaId, numElems);
   }
   template <typename T>
-  T* pod_arena_realloc(arena_id_t arenaId, T* p, size_t oldSize,
-                       size_t newSize) {
+  T* pod_arena_realloc(arena_id_t arenaId, T* p, size_t oldSize, size_t newSize) {
     return maybe_pod_arena_realloc<T>(arenaId, p, oldSize, newSize);
   }
 
   template <typename T>
   T* maybe_pod_malloc(size_t numElems) {
     return maybe_pod_arena_malloc<T>(js::MallocArena, numElems);
   }
   template <typename T>
@@ -140,18 +138,17 @@ class TempAllocPolicy : public AllocPoli
     T* p = this->maybe_pod_arena_calloc<T>(arenaId, numElems);
     if (MOZ_UNLIKELY(!p)) {
       p = onOutOfMemoryTyped<T>(arenaId, AllocFunction::Calloc, numElems);
     }
     return p;
   }
 
   template <typename T>
-  T* pod_arena_realloc(arena_id_t arenaId, T* prior, size_t oldSize,
-                       size_t newSize) {
+  T* pod_arena_realloc(arena_id_t arenaId, T* prior, size_t oldSize, size_t newSize) {
     T* p2 = this->maybe_pod_arena_realloc<T>(arenaId, prior, oldSize, newSize);
     if (MOZ_UNLIKELY(!p2)) {
       p2 = onOutOfMemoryTyped<T>(arenaId, AllocFunction::Realloc, newSize,
                                  prior);
     }
     return p2;
   }
 
--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -1025,23 +1025,22 @@ class MOZ_RAII Rooted : public js::Roote
 
   // Dummy type to distinguish these constructors from Rooted(cx, initial)
   struct CtorDispatcher {};
 
   // Normal case: construct an empty Rooted holding a safely initialized but
   // empty T.
   template <typename RootingContext>
   Rooted(const RootingContext& cx, CtorDispatcher, detail::FallbackOverload)
-      : Rooted(cx, SafelyInitialized<T>()) {}
+    : Rooted(cx, SafelyInitialized<T>()) {}
 
   // If T can be constructed with a cx, then define another constructor for it
   // that will be preferred.
   template <typename RootingContext,
-            typename = typename std::enable_if<
-                std::is_constructible<T, RootingContext>::value>::type>
+            typename = typename std::enable_if<std::is_constructible<T, RootingContext>::value>::type>
   Rooted(const RootingContext& cx, CtorDispatcher, detail::PreferredOverload)
       : Rooted(cx, T(cx)) {}
 
  public:
   using ElementType = T;
 
   // Construct an empty Rooted. Delegates to an internal constructor that
   // chooses a specific meaning of "empty" depending on whether T can be
--- a/js/public/experimental/SourceHook.h
+++ b/js/public/experimental/SourceHook.h
@@ -89,11 +89,11 @@ class SourceHook {
  */
 extern JS_FRIEND_API void SetSourceHook(JSContext* cx,
                                         mozilla::UniquePtr<SourceHook> hook);
 
 /** Remove |cx|'s source hook, and return it. The caller now owns the hook. */
 extern JS_FRIEND_API mozilla::UniquePtr<SourceHook> ForgetSourceHook(
     JSContext* cx);
 
-}  // namespace js
+} // namespace js
 
-#endif  // js_experimental_SourceHook_h
+#endif // js_experimental_SourceHook_h
--- a/js/rust/src/jsglue.cpp
+++ b/js/rust/src/jsglue.cpp
@@ -549,33 +549,35 @@ bool AppendToRootedIdVector(JS::Persiste
 const jsid* SliceRootedIdVector(const JS::PersistentRootedIdVector* v,
                                 size_t* length) {
   *length = v->length();
   return v->begin();
 }
 
 void DestroyRootedIdVector(JS::PersistentRootedIdVector* v) { delete v; }
 
-JS::MutableHandleIdVector GetMutableHandleIdVector(
-    JS::PersistentRootedIdVector* v) {
+JS::MutableHandleIdVector GetMutableHandleIdVector(JS::PersistentRootedIdVector* v) {
   return JS::MutableHandleIdVector(v);
 }
 
-JS::PersistentRootedObjectVector* CreateRootedObjectVector(JSContext* aCx) {
+JS::PersistentRootedObjectVector* CreateRootedObjectVector(
+    JSContext* aCx) {
   JS::PersistentRootedObjectVector* vec =
       new JS::PersistentRootedObjectVector(aCx);
   return vec;
 }
 
 bool AppendToRootedObjectVector(JS::PersistentRootedObjectVector* v,
-                                JSObject* obj) {
+                                          JSObject* obj) {
   return v->append(obj);
 }
 
-void DeleteRootedObjectVector(JS::PersistentRootedObjectVector* v) { delete v; }
+void DeleteRootedObjectVector(JS::PersistentRootedObjectVector* v) {
+  delete v;
+}
 
 #if defined(__linux__)
 #  include <malloc.h>
 #elif defined(__APPLE__)
 #  include <malloc/malloc.h>
 #elif defined(__MINGW32__) || defined(__MINGW64__)
 // nothing needed here
 #elif defined(_MSC_VER)
--- a/js/src/builtin/AtomicsObject.cpp
+++ b/js/src/builtin/AtomicsObject.cpp
@@ -157,17 +157,17 @@ struct ArrayOps<int64_t> {
     BigInt* bi = ToBigInt(cx, v);
     if (!bi) {
       return cx->alreadyReportedError();
     }
     return BigInt::toInt64(bi);
   }
 
   static JS::Result<int64_t> convertValue(JSContext* cx, HandleValue v,
-                                          MutableHandleValue result) {
+                                           MutableHandleValue result) {
     BigInt* bi = ToBigInt(cx, v);
     if (!bi) {
       return cx->alreadyReportedError();
     }
     result.setBigInt(bi);
     return BigInt::toInt64(bi);
   }
 
@@ -188,17 +188,17 @@ struct ArrayOps<uint64_t> {
     BigInt* bi = ToBigInt(cx, v);
     if (!bi) {
       return cx->alreadyReportedError();
     }
     return BigInt::toUint64(bi);
   }
 
   static JS::Result<uint64_t> convertValue(JSContext* cx, HandleValue v,
-                                           MutableHandleValue result) {
+                                            MutableHandleValue result) {
     BigInt* bi = ToBigInt(cx, v);
     if (!bi) {
       return cx->alreadyReportedError();
     }
     result.setBigInt(bi);
     return BigInt::toUint64(bi);
   }
 
--- a/js/src/builtin/ModuleObject.cpp
+++ b/js/src/builtin/ModuleObject.cpp
@@ -1052,18 +1052,19 @@ bool ModuleObject::execute(JSContext* cx
   }
 #endif
 
   RootedScript script(cx, self->script());
 
   // The top-level script if a module is only ever executed once. Clear the
   // reference at exit to prevent us keeping this alive unnecessarily. This is
   // kept while executing so it is available to the debugger.
-  auto guardA = mozilla::MakeScopeExit(
-      [&] { self->setReservedSlot(ScriptSlot, UndefinedValue()); });
+  auto guardA = mozilla::MakeScopeExit([&] {
+      self->setReservedSlot(ScriptSlot, UndefinedValue());
+    });
 
   RootedModuleEnvironmentObject scope(cx, self->environment());
   if (!scope) {
     JS_ReportErrorASCII(cx,
                         "Module declarations have not yet been instantiated");
     return false;
   }
 
--- a/js/src/builtin/ReflectParse.cpp
+++ b/js/src/builtin/ReflectParse.cpp
@@ -2645,18 +2645,18 @@ bool ASTSerializer::rightAssociate(ListN
 bool ASTSerializer::expression(ParseNode* pn, MutableHandleValue dst) {
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
 
   switch (pn->getKind()) {
     case ParseNodeKind::Function: {
       FunctionNode* funNode = &pn->as<FunctionNode>();
-      ASTType type =
-          funNode->funbox()->isArrow() ? AST_ARROW_EXPR : AST_FUNC_EXPR;
+      ASTType type = funNode->funbox()->isArrow() ? AST_ARROW_EXPR
+                                                              : AST_FUNC_EXPR;
       return function(funNode, type, dst);
     }
 
     case ParseNodeKind::CommaExpr: {
       NodeVector exprs(cx);
       return expressions(&pn->as<ListNode>(), exprs) &&
              builder.sequenceExpression(exprs, &pn->pn_pos, dst);
     }
@@ -3139,19 +3139,19 @@ bool ASTSerializer::property(ParseNode* 
     kind = PROP_INIT;
   }
 
   BinaryNode* node = &pn->as<BinaryNode>();
   ParseNode* keyNode = node->left();
   ParseNode* valNode = node->right();
 
   bool isShorthand = node->isKind(ParseNodeKind::Shorthand);
-  bool isMethod =
-      valNode->is<FunctionNode>() &&
-      valNode->as<FunctionNode>().funbox()->kind() == JSFunction::Method;
+  bool isMethod = valNode->is<FunctionNode>() &&
+                  valNode->as<FunctionNode>().funbox()->kind() ==
+                      JSFunction::Method;
   RootedValue key(cx), val(cx);
   return propertyName(keyNode, &key) && expression(valNode, &val) &&
          builder.propertyInitializer(key, val, kind, isShorthand, isMethod,
                                      &node->pn_pos, dst);
 }
 
 bool ASTSerializer::literal(ParseNode* pn, MutableHandleValue dst) {
   RootedValue val(cx);
--- a/js/src/builtin/Stream.cpp
+++ b/js/src/builtin/Stream.cpp
@@ -3479,17 +3479,19 @@ class MOZ_RAII AutoClearUnderlyingSource
 
   ~AutoClearUnderlyingSource() {
     if (controller_) {
       ReadableStreamController::clearUnderlyingSource(
           controller_, /* finalizeSource */ false);
     }
   }
 
-  void reset() { controller_ = nullptr; }
+  void reset() {
+    controller_ = nullptr;
+  }
 };
 
 /**
  * Version of SetUpReadableByteStreamController that's specialized for handling
  * external, embedding-provided, underlying sources.
  */
 static MOZ_MUST_USE bool SetUpExternalReadableByteStreamController(
     JSContext* cx, Handle<ReadableStream*> stream,
--- a/js/src/frontend/BinASTParser.cpp
+++ b/js/src/frontend/BinASTParser.cpp
@@ -3222,17 +3222,18 @@ JS::Result<Ok> BinASTParser<Tok>::parseI
   MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
 #endif  // defined(DEBUG)
 
   BINJS_MOZ_TRY_DECL(isFunctionNameCaptured,
                      tokenizer_->readBool(fieldContext++));
   // Per spec, isFunctionNameCaptured can be true for anonymous
   // function.  Check isFunctionNameCaptured only for named
   // function.
-  if (pc_->functionBox()->isNamedLambda() && isFunctionNameCaptured) {
+  if (pc_->functionBox()->isNamedLambda() &&
+      isFunctionNameCaptured) {
     captureFunctionName();
   }
   BINJS_MOZ_TRY_DECL(isThisCaptured, tokenizer_->readBool(fieldContext++));
   // TODO: Use this in BinASTParser::buildFunction.
   (void)isThisCaptured;
   Rooted<GCVector<JSAtom*>> positionalParams(cx_, GCVector<JSAtom*>(cx_));
   MOZ_TRY(parseAssertedParameterScope(&positionalParams, fieldContext++));
 
--- a/js/src/frontend/BinASTParserPerTokenizer.cpp
+++ b/js/src/frontend/BinASTParserPerTokenizer.cpp
@@ -270,17 +270,17 @@ JS::Result<FunctionBox*> BinASTParserPer
       cx_, traceListHead_, fun, /* toStringStart = */ 0, *directives,
       /* extraWarning = */ false, generatorKind, functionAsyncKind);
   if (!funbox) {
     return raiseOOM();
   }
 
   traceListHead_ = funbox;
   if (pc_) {
-    funbox->initWithEnclosingParseContext(pc_, fun, syntax);
+    funbox->initWithEnclosingParseContext(pc_, fun,syntax);
   } else {
     funbox->initFromLazyFunction(fun);
   }
   return funbox;
 }
 
 FunctionSyntaxKind BinASTKindToFunctionSyntaxKind(const BinASTKind kind) {
   // FIXME: this doesn't cover FunctionSyntaxKind::ClassConstructor and
--- a/js/src/frontend/BytecodeSection.h
+++ b/js/src/frontend/BytecodeSection.h
@@ -99,16 +99,17 @@ struct CGResumeOffsetList {
   Vector<uint32_t> list;
   explicit CGResumeOffsetList(JSContext* cx) : list(cx) {}
 
   MOZ_MUST_USE bool append(uint32_t offset) { return list.append(offset); }
   size_t length() const { return list.length(); }
   void finish(mozilla::Span<uint32_t> array);
 };
 
+
 static constexpr size_t MaxBytecodeLength = INT32_MAX;
 static constexpr size_t MaxSrcNotesLength = INT32_MAX;
 
 // Have a few inline elements, so as to avoid heap allocation for tiny
 // sequences.  See bug 1390526.
 typedef Vector<jsbytecode, 64> BytecodeVector;
 typedef Vector<jssrcnote, 64> SrcNotesVector;
 
--- a/js/src/frontend/FunctionEmitter.cpp
+++ b/js/src/frontend/FunctionEmitter.cpp
@@ -470,17 +470,18 @@ bool FunctionScriptEmitter::prepareForBo
   }
 
   if (funbox_->needsPromiseResult()) {
     if (!emitAsyncFunctionRejectPrologue()) {
       return false;
     }
   }
 
-  if (funbox_->kind() == JSFunction::FunctionKind::ClassConstructor) {
+  if (funbox_->kind() ==
+      JSFunction::FunctionKind::ClassConstructor) {
     if (!funbox_->isDerivedClassConstructor()) {
       if (!bce_->emitInitializeInstanceFields()) {
         //          [stack]
         return false;
       }
     }
   }
 
--- a/js/src/frontend/ParseContext.cpp
+++ b/js/src/frontend/ParseContext.cpp
@@ -291,17 +291,18 @@ bool ParseContext::init() {
 
   return true;
 }
 
 bool ParseContext::annexBAppliesToLexicalFunctionInInnermostScope(
     FunctionBox* funbox) {
   MOZ_ASSERT(!sc()->strict());
 
-  RootedPropertyName name(sc()->cx_, funbox->explicitName()->asPropertyName());
+  RootedPropertyName name(sc()->cx_,
+                          funbox->explicitName()->asPropertyName());
   Maybe<DeclarationKind> redeclaredKind = isVarRedeclaredInInnermostScope(
       name, DeclarationKind::VarForAnnexBLexicalFunction);
 
   if (!redeclaredKind && isFunctionBox()) {
     Scope& funScope = functionScope();
     if (&funScope != &varScope()) {
       // Annex B.3.3.1 disallows redeclaring parameter names. In the
       // presence of parameter expressions, parameter names are on the
--- a/js/src/frontend/ParseContext.h
+++ b/js/src/frontend/ParseContext.h
@@ -618,18 +618,19 @@ class ParseContext : public Nestable<Par
     return sc_->isFunctionBox() && sc_->asFunctionBox()->isArrow();
   }
 
   bool isMethod() const {
     return sc_->isFunctionBox() && sc_->asFunctionBox()->isMethod();
   }
 
   bool isGetterOrSetter() const {
-    return sc_->isFunctionBox() && (sc_->asFunctionBox()->isGetter() ||
-                                    sc_->asFunctionBox()->isSetter());
+    return sc_->isFunctionBox() &&
+           (sc_->asFunctionBox()->isGetter() ||
+            sc_->asFunctionBox()->isSetter());
   }
 
   uint32_t scriptId() const { return scriptId_; }
 
   bool annexBAppliesToLexicalFunctionInInnermostScope(FunctionBox* funbox);
 
   bool tryDeclareVar(HandlePropertyName name, DeclarationKind kind,
                      uint32_t beginPos,
--- a/js/src/frontend/SharedContext.cpp
+++ b/js/src/frontend/SharedContext.cpp
@@ -158,17 +158,18 @@ FunctionBox::FunctionBox(JSContext* cx, 
       hasThisBinding_(false),
       hasInnerFunctions_(false),
       isArrow_(fun->isArrow()),
       isNamedLambda_(fun->isNamedLambda()),
       isGetter_(fun->isGetter()),
       isSetter_(fun->isSetter()),
       isMethod_(fun->isMethod()),
       kind_(fun->kind()),
-      explicitName_(fun->explicitName()) {
+      explicitName_(fun->explicitName())
+{
   // Functions created at parse time may be set singleton after parsing and
   // baked into JIT code, so they must be allocated tenured. They are held by
   // the JSScript so cannot be collected during a minor GC anyway.
   MOZ_ASSERT(fun->isTenured());
 }
 
 void FunctionBox::initFromLazyFunction(JSFunction* fun) {
   if (fun->lazyScript()->isDerivedClassConstructor()) {
@@ -189,18 +190,17 @@ void FunctionBox::initStandaloneFunction
   // Standalone functions are Function or Generator constructors and are
   // always scoped to the global.
   MOZ_ASSERT(enclosingScope->is<GlobalScope>());
   enclosingScope_ = enclosingScope;
   allowNewTarget_ = true;
   thisBinding_ = ThisBinding::Function;
 }
 
-void FunctionBox::initWithEnclosingParseContext(ParseContext* enclosing,
-                                                JSFunction* fun,
+void FunctionBox::initWithEnclosingParseContext(ParseContext* enclosing, JSFunction* fun,
                                                 FunctionSyntaxKind kind) {
   SharedContext* sc = enclosing->sc();
   useAsm = sc->isFunctionBox() && sc->asFunctionBox()->useAsmOrInsideUseAsm();
 
   // Arrow functions don't have their own `this` binding.
   if (fun->isArrow()) {
     allowNewTarget_ = sc->allowNewTarget();
     allowSuperProperty_ = sc->allowSuperProperty();
--- a/js/src/frontend/SharedContext.h
+++ b/js/src/frontend/SharedContext.h
@@ -430,18 +430,17 @@ class FunctionBox : public ObjectBox, pu
     return MutableHandle<VarScope::Data*>::fromMarkedLocation(
         &extraVarScopeBindings_);
   }
 
   void initFromLazyFunction(JSFunction* fun);
   void initStandaloneFunction(Scope* enclosingScope);
   void initWithEnclosingParseContext(ParseContext* enclosing, JSFunction* fun,
                                      FunctionSyntaxKind kind);
-  void initFieldInitializer(ParseContext* enclosing, JSFunction* fun,
-                            HasHeritage hasHeritage);
+  void initFieldInitializer(ParseContext* enclosing, JSFunction* fun, HasHeritage hasHeritage);
 
   inline bool isLazyFunctionWithoutEnclosingScope() const {
     return function()->isInterpretedLazy() &&
            !function()->lazyScript()->hasEnclosingScope();
   }
   void setEnclosingScopeForInnerLazyFunction(Scope* enclosingScope);
   void finish();
 
--- a/js/src/gc/Barrier.h
+++ b/js/src/gc/Barrier.h
@@ -420,18 +420,19 @@ class MOZ_NON_MEMMOVABLE BarrieredBase {
   // instantiation. Friending to the generic template leads to a number of
   // unintended consequences, including template resolution ambiguity and a
   // circular dependency with Tracing.h.
   T* unsafeUnbarrieredForTracing() { return &value; }
 };
 
 // Base class for barriered pointer types that intercept only writes.
 template <class T>
-class WriteBarriered : public BarrieredBase<T>,
-                       public WrappedPtrOperations<T, WriteBarriered<T>> {
+class WriteBarriered
+    : public BarrieredBase<T>,
+      public WrappedPtrOperations<T, WriteBarriered<T>> {
  protected:
   using BarrieredBase<T>::value;
 
   // WriteBarriered is not directly instantiable.
   explicit WriteBarriered(const T& v) : BarrieredBase<T>(v) {}
 
  public:
   using ElementType = T;
--- a/js/src/gc/FreeOp-inl.h
+++ b/js/src/gc/FreeOp-inl.h
@@ -37,11 +37,11 @@ inline void FreeOp::freeLater(void* p) {
   // It's not safe to free this allocation immediately, so we must crash if we
   // can't append to the list.
   AutoEnterOOMUnsafeRegion oomUnsafe;
   if (!freeLaterList.append(p)) {
     oomUnsafe.crash("FreeOp::freeLater");
   }
 }
 
-}  // namespace js
+} // namespace js
 
-#endif  // gc_FreeOp_inl_h
+#endif // gc_FreeOp_inl_h
--- a/js/src/gc/GC-inl.h
+++ b/js/src/gc/GC-inl.h
@@ -105,17 +105,20 @@ class ArenaCellIter {
   ArenaCellIter()
       : firstThingOffset(0),
         thingSize(0),
         arenaAddr(nullptr),
         thing(0),
         traceKind(JS::TraceKind::Null),
         initialized(false) {}
 
-  explicit ArenaCellIter(Arena* arena) : initialized(false) { init(arena); }
+  explicit ArenaCellIter(Arena* arena)
+      : initialized(false) {
+    init(arena);
+  }
 
   void init(Arena* arena) {
     MOZ_ASSERT(!initialized);
     MOZ_ASSERT(arena);
     initialized = true;
     AllocKind kind = arena->getAllocKind();
     firstThingOffset = Arena::firstThingOffset(kind);
     thingSize = Arena::thingSize(kind);
@@ -387,17 +390,19 @@ class ZoneCellIter : protected ZoneAllCe
     if (!JS::RuntimeHeapIsCollecting(rt->heapState())) {
       JS::TraceKind traceKind = JS::MapTypeToTraceKind<T>::kind;
       ExposeGCThingToActiveJS(JS::GCCellPtr(cell, traceKind));
     }
 
     return cell;
   }
 
-  T* get() const { return reinterpret_cast<T*>(getCell()); }
+  T* get() const {
+    return reinterpret_cast<T*>(getCell());
+  }
 
   TenuredCell* unbarrieredGetCell() const { return Base::getCell(); }
   T* unbarrieredGet() const { return Base::get(); }
   operator T*() const { return get(); }
   T* operator->() const { return get(); }
 
  private:
   void skipDying() {
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -436,19 +436,19 @@ JS_PUBLIC_API void JS::UnsafeTraceRoot(J
       JSTracer*, type*, const char*);
 FOR_EACH_PUBLIC_GC_POINTER_TYPE(INSTANTIATE_PUBLIC_TRACE_FUNCTIONS)
 FOR_EACH_PUBLIC_TAGGED_GC_POINTER_TYPE(INSTANTIATE_PUBLIC_TRACE_FUNCTIONS)
 #undef INSTANTIATE_PUBLIC_TRACE_FUNCTIONS
 
 namespace js {
 namespace gc {
 
-#define INSTANTIATE_INTERNAL_TRACE_FUNCTIONS(type)                      \
-  template void TraceEdgeInternal<type>(JSTracer*, type*, const char*); \
-  template void TraceRangeInternal<type>(JSTracer*, size_t len, type*,  \
+#define INSTANTIATE_INTERNAL_TRACE_FUNCTIONS(type)                          \
+  template void TraceEdgeInternal<type>(JSTracer*, type*, const char*);     \
+  template void TraceRangeInternal<type>(JSTracer*, size_t len, type*,      \
                                          const char*);
 
 #define INSTANTIATE_INTERNAL_TRACE_FUNCTIONS_FROM_TRACEKIND(_1, type, _2, _3) \
   INSTANTIATE_INTERNAL_TRACE_FUNCTIONS(type*)
 
 JS_FOR_EACH_TRACEKIND(INSTANTIATE_INTERNAL_TRACE_FUNCTIONS_FROM_TRACEKIND)
 FOR_EACH_PUBLIC_TAGGED_GC_POINTER_TYPE(INSTANTIATE_INTERNAL_TRACE_FUNCTIONS)
 
@@ -733,20 +733,20 @@ JS_PUBLIC_API void js::gc::PerformIncrem
   Zone* zone = cell->zone();
   MOZ_ASSERT(zone->needsIncrementalBarrier());
 
   // Skip disptaching on known tracer type.
   GCMarker* gcmarker = GCMarker::fromTracer(zone->barrierTracer());
 
   // Mark the argument, as DoMarking above.
   ApplyGCThingTyped(thing, [gcmarker](auto thing) {
-    MOZ_ASSERT(ShouldMark(gcmarker, thing));
-    CheckTracedThing(gcmarker, thing);
-    gcmarker->traverse(thing);
-  });
+                             MOZ_ASSERT(ShouldMark(gcmarker, thing));
+                             CheckTracedThing(gcmarker, thing);
+                             gcmarker->traverse(thing);
+                           });
 }
 
 // The simplest traversal calls out to the fully generic traceChildren function
 // to visit the child edges. In the absence of other traversal mechanisms, this
 // function will rapidly grow the stack past its bounds and crash the process.
 // Thus, this generic tracing should only be used in cases where subsequent
 // tracing will not recurse.
 template <typename T>
@@ -3099,17 +3099,18 @@ size_t js::TenuringTracer::moveStringToT
   if (!src->isInline() && src->isLinear()) {
     if (src->isUndepended() || !src->hasBase()) {
       void* chars = src->asLinear().nonInlineCharsRaw();
       nursery().removeMallocedBuffer(chars);
     }
   }
 
   if (dst->isFlat() && !dst->isInline()) {
-    AddCellMemory(dst, dst->asFlat().allocSize(), MemoryUse::StringContents);
+    AddCellMemory(dst, dst->asFlat().allocSize(),
+                  MemoryUse::StringContents);
   }
 
   return size;
 }
 
 /*** IsMarked / IsAboutToBeFinalized ****************************************/
 
 template <typename T>
--- a/js/src/gc/NurseryAwareHashMap.h
+++ b/js/src/gc/NurseryAwareHashMap.h
@@ -17,17 +17,18 @@ namespace js {
 
 namespace detail {
 // This class only handles the incremental case and does not deal with nursery
 // pointers. The only users should be for NurseryAwareHashMap; it is defined
 // externally because we need a GCPolicy for its use in the contained map.
 template <typename T>
 class UnsafeBareWeakHeapPtr : public ReadBarriered<T> {
  public:
-  UnsafeBareWeakHeapPtr() : ReadBarriered<T>(JS::SafelyInitialized<T>()) {}
+  UnsafeBareWeakHeapPtr()
+      : ReadBarriered<T>(JS::SafelyInitialized<T>()) {}
   MOZ_IMPLICIT UnsafeBareWeakHeapPtr(const T& v) : ReadBarriered<T>(v) {}
   explicit UnsafeBareWeakHeapPtr(const UnsafeBareWeakHeapPtr& v)
       : ReadBarriered<T>(v) {}
   UnsafeBareWeakHeapPtr(UnsafeBareWeakHeapPtr&& v)
       : ReadBarriered<T>(std::move(v)) {}
 
   UnsafeBareWeakHeapPtr& operator=(const UnsafeBareWeakHeapPtr& v) {
     this->value = v.value;
@@ -175,17 +176,18 @@ class NurseryAwareHashMap {
   bool hasNurseryEntries() const { return !nurseryEntries.empty(); }
 };
 
 }  // namespace js
 
 namespace JS {
 template <typename T>
 struct GCPolicy<js::detail::UnsafeBareWeakHeapPtr<T>> {
-  static void trace(JSTracer* trc, js::detail::UnsafeBareWeakHeapPtr<T>* thingp,
+  static void trace(JSTracer* trc,
+                    js::detail::UnsafeBareWeakHeapPtr<T>* thingp,
                     const char* name) {
     js::TraceEdge(trc, thingp, name);
   }
   static bool needsSweep(js::detail::UnsafeBareWeakHeapPtr<T>* thingp) {
     return js::gc::IsAboutToBeFinalized(thingp);
   }
 };
 }  // namespace JS
--- a/js/src/gc/PrivateIterators-inl.h
+++ b/js/src/gc/PrivateIterators-inl.h
@@ -15,24 +15,26 @@
 
 #include "gc/GC-inl.h"
 
 namespace js {
 namespace gc {
 
 class ArenaCellIterUnderGC : public ArenaCellIter {
  public:
-  explicit ArenaCellIterUnderGC(Arena* arena) : ArenaCellIter(arena) {
+  explicit ArenaCellIterUnderGC(Arena* arena)
+      : ArenaCellIter(arena) {
     MOZ_ASSERT(CurrentThreadIsPerformingGC());
   }
 };
 
 class ArenaCellIterUnderFinalize : public ArenaCellIter {
  public:
-  explicit ArenaCellIterUnderFinalize(Arena* arena) : ArenaCellIter(arena) {
+  explicit ArenaCellIterUnderFinalize(Arena* arena)
+      : ArenaCellIter(arena) {
     MOZ_ASSERT(CurrentThreadIsGCSweeping());
   }
 };
 
 class GrayObjectIter : public ZoneAllCellIter<js::gc::TenuredCell> {
  public:
   explicit GrayObjectIter(JS::Zone* zone, AllocKind kind)
       : ZoneAllCellIter<js::gc::TenuredCell>() {
--- a/js/src/gc/Scheduling.h
+++ b/js/src/gc/Scheduling.h
@@ -309,22 +309,22 @@
 
 #include "mozilla/Atomics.h"
 #include "mozilla/DebugOnly.h"
 
 #include "js/HashTable.h"
 
 namespace js {
 
-#define JS_FOR_EACH_INTERNAL_MEMORY_USE(_) \
-  _(ArrayBufferContents)                   \
+#define JS_FOR_EACH_INTERNAL_MEMORY_USE(_)      \
+  _(ArrayBufferContents)                        \
   _(StringContents)
 
-#define JS_FOR_EACH_MEMORY_USE(_)  \
-  JS_FOR_EACH_PUBLIC_MEMORY_USE(_) \
+#define JS_FOR_EACH_MEMORY_USE(_)               \
+  JS_FOR_EACH_PUBLIC_MEMORY_USE(_)              \
   JS_FOR_EACH_INTERNAL_MEMORY_USE(_)
 
 enum class MemoryUse : uint8_t {
 #define DEFINE_MEMORY_USE(Name) Name,
   JS_FOR_EACH_MEMORY_USE(DEFINE_MEMORY_USE)
 #undef DEFINE_MEMORY_USE
 };
 
--- a/js/src/gc/Tracer.h
+++ b/js/src/gc/Tracer.h
@@ -121,17 +121,18 @@ inline void AssertRootMarkingPhase(JSTra
 template <typename T>
 inline void TraceEdge(JSTracer* trc, WriteBarriered<T>* thingp,
                       const char* name) {
   gc::TraceEdgeInternal(
       trc, gc::ConvertToBase(thingp->unsafeUnbarrieredForTracing()), name);
 }
 
 template <typename T>
-inline void TraceEdge(JSTracer* trc, WeakHeapPtr<T>* thingp, const char* name) {
+inline void TraceEdge(JSTracer* trc, WeakHeapPtr<T>* thingp,
+                      const char* name) {
   gc::TraceEdgeInternal(trc, gc::ConvertToBase(thingp->unsafeGet()), name);
 }
 
 // Trace through a possibly-null edge in the live object graph on behalf of
 // tracing.
 
 template <typename T>
 inline void TraceNullableEdge(JSTracer* trc, WriteBarriered<T>* thingp,
@@ -155,17 +156,18 @@ inline void TraceNullableEdge(JSTracer* 
 
 template <typename T>
 inline void TraceRoot(JSTracer* trc, T* thingp, const char* name) {
   gc::AssertRootMarkingPhase(trc);
   gc::TraceEdgeInternal(trc, gc::ConvertToBase(thingp), name);
 }
 
 template <typename T>
-inline void TraceRoot(JSTracer* trc, WeakHeapPtr<T>* thingp, const char* name) {
+inline void TraceRoot(JSTracer* trc, WeakHeapPtr<T>* thingp,
+                      const char* name) {
   TraceRoot(trc, thingp->unsafeGet(), name);
 }
 
 // Idential to TraceRoot, except that this variant will not crash if |*thingp|
 // is null.
 
 template <typename T>
 inline void TraceNullableRoot(JSTracer* trc, T* thingp, const char* name) {
@@ -206,17 +208,18 @@ template <typename T>
 void TraceRootRange(JSTracer* trc, size_t len, T* vec, const char* name) {
   gc::AssertRootMarkingPhase(trc);
   gc::TraceRangeInternal(trc, len, gc::ConvertToBase(vec), name);
 }
 
 // Trace an edge that crosses compartment boundaries. If the compartment of the
 // destination thing is not being GC'd, then the edge will not be traced.
 void TraceCrossCompartmentEdge(JSTracer* trc, JSObject* src,
-                               WriteBarriered<Value>* dst, const char* name);
+                               WriteBarriered<Value>* dst,
+                               const char* name);
 
 // As above but with manual barriers.
 template <typename T>
 void TraceManuallyBarrieredCrossCompartmentEdge(JSTracer* trc, JSObject* src,
                                                 T* dst, const char* name);
 
 // Permanent atoms and well-known symbols are shared between runtimes and must
 // use a separate marking path so that we can filter them out of normal heap
--- a/js/src/gc/Verifier.h
+++ b/js/src/gc/Verifier.h
@@ -19,21 +19,23 @@ namespace gc {
 // Like gc::MarkColor but allows the possibility of the cell being
 // unmarked.
 enum class CellColor : uint8_t {
   White = 0,
   Gray = uint8_t(MarkColor::Gray),
   Black = uint8_t(MarkColor::Black)
 };
 
-static constexpr CellColor AllCellColors[] = {CellColor::White, CellColor::Gray,
-                                              CellColor::Black};
+static constexpr CellColor AllCellColors[] = {
+  CellColor::White, CellColor::Gray, CellColor::Black
+};
 
-static constexpr CellColor MarkedCellColors[] = {CellColor::Gray,
-                                                 CellColor::Black};
+static constexpr CellColor MarkedCellColors[] = {
+  CellColor::Gray, CellColor::Black
+};
 
 inline CellColor GetCellColor(Cell* cell) {
   if (cell->isMarkedBlack()) {
     return CellColor::Black;
   }
 
   if (cell->isMarkedGray()) {
     return CellColor::Gray;
@@ -52,12 +54,12 @@ inline CellColor ExpectedWeakMapKeyColor
   return Min(mapColor, delegateColor);
 }
 
 inline CellColor ExpectedKeyAndDelegateColor(CellColor keyColor,
                                              CellColor delegateColor) {
   return Max(keyColor, delegateColor);
 }
 
-}  // namespace gc
-}  // namespace js
+} // namespace gc
+} // namespace js
 
 #endif /* gc_Verifier_h */
--- a/js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
+++ b/js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
@@ -25,17 +25,19 @@ void MacroAssembler::moveGPRToFloat32(Re
 void MacroAssembler::move8SignExtend(Register src, Register dest) {
   ma_seb(dest, src);
 }
 
 void MacroAssembler::move16SignExtend(Register src, Register dest) {
   ma_seh(dest, src);
 }
 
-void MacroAssembler::loadAbiReturnAddress(Register dest) { movePtr(ra, dest); }
+void MacroAssembler::loadAbiReturnAddress(Register dest) {
+  movePtr(ra, dest);
+}
 
 // ===============================================================
 // Logical instructions
 
 void MacroAssembler::not32(Register reg) { ma_not(reg, reg); }
 
 void MacroAssembler::and32(Register src, Register dest) {
   as_and(dest, dest, src);
--- a/js/src/jsapi-tests/testGCGrayMarking.cpp
+++ b/js/src/jsapi-tests/testGCGrayMarking.cpp
@@ -157,24 +157,25 @@ bool TestMarking() {
 
 static const CellColor DontMark = CellColor::White;
 
 enum MarkKeyOrDelegate : bool { MarkKey = true, MarkDelegate = false };
 
 bool TestJSWeakMaps() {
   for (auto keyOrDelegateColor : MarkedCellColors) {
     for (auto mapColor : MarkedCellColors) {
-      for (auto markKeyOrDelegate : {MarkKey, MarkDelegate}) {
-        CellColor expected =
-            ExpectedWeakMapValueColor(keyOrDelegateColor, mapColor);
+      for (auto markKeyOrDelegate : { MarkKey, MarkDelegate }) {
+        CellColor expected = ExpectedWeakMapValueColor(keyOrDelegateColor,
+                                                       mapColor);
         CHECK(TestJSWeakMap(markKeyOrDelegate, keyOrDelegateColor, mapColor,
                             expected));
 #ifdef JS_GC_ZEAL
-        CHECK(TestJSWeakMapWithGrayUnmarking(
-            markKeyOrDelegate, keyOrDelegateColor, mapColor, expected));
+        CHECK(TestJSWeakMapWithGrayUnmarking(markKeyOrDelegate,
+                                             keyOrDelegateColor, mapColor,
+                                             expected));
 #endif
       }
     }
   }
 
   return true;
 }
 
@@ -183,23 +184,24 @@ bool TestInternalWeakMaps() {
     for (auto delegateMarkColor : AllCellColors) {
       if (keyMarkColor == CellColor::White &&
           delegateMarkColor == CellColor::White) {
         continue;
       }
 
       CellColor keyOrDelegateColor =
           ExpectedKeyAndDelegateColor(keyMarkColor, delegateMarkColor);
-      CellColor expected =
-          ExpectedWeakMapValueColor(keyOrDelegateColor, CellColor::Black);
+      CellColor expected = ExpectedWeakMapValueColor(keyOrDelegateColor,
+                                                     CellColor::Black);
       CHECK(TestInternalWeakMap(keyMarkColor, delegateMarkColor, expected));
 
 #ifdef JS_GC_ZEAL
       CHECK(TestInternalWeakMapWithGrayUnmarking(keyMarkColor,
-                                                 delegateMarkColor, expected));
+                                                 delegateMarkColor,
+                                                 expected));
 #endif
     }
   }
 
   return true;
 }
 
 bool TestJSWeakMap(MarkKeyOrDelegate markKey, CellColor weakMapMarkColor,
@@ -303,21 +305,21 @@ bool TestJSWeakMapWithGrayUnmarking(Mark
 
   JS_UnsetGCZeal(cx, uint8_t(ZealMode::YieldWhileGrayMarking));
 
   return true;
 }
 
 static void MaybeExposeObject(JSObject* object, CellColor color) {
   if (color == CellColor::Black) {
-    JS::ExposeObjectToActiveJS(object);
+      JS::ExposeObjectToActiveJS(object);
   }
 }
 
-#endif  // JS_GC_ZEAL
+#endif // JS_GC_ZEAL
 
 bool CreateJSWeakMapObjects(JSObject** weakMapOut, JSObject** keyOut,
                             JSObject** valueOut) {
   RootedObject key(cx, AllocWeakmapKeyObject());
   CHECK(key);
 
   RootedObject value(cx, AllocPlainObject());
   CHECK(value);
@@ -426,17 +428,17 @@ bool TestInternalWeakMapWithGrayUnmarkin
     CHECK(GetCellColor(value) == expectedColor);
   }
 
   JS_UnsetGCZeal(cx, uint8_t(ZealMode::YieldWhileGrayMarking));
 
   return true;
 }
 
-#endif  // JS_GC_ZEAL
+#endif // JS_GC_ZEAL
 
 bool CreateInternalWeakMapObjects(UniquePtr<GCManagedObjectWeakMap>* weakMapOut,
                                   JSObject** keyOut, JSObject** valueOut) {
   RootedObject key(cx, AllocWeakmapKeyObject());
   CHECK(key);
 
   RootedObject value(cx, AllocPlainObject());
   CHECK(value);
--- a/js/src/jsapi-tests/testScriptObject.cpp
+++ b/js/src/jsapi-tests/testScriptObject.cpp
@@ -3,17 +3,17 @@
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/Utf8.h"  // mozilla::Utf8Unit
 
 #include "js/CompilationAndEvaluation.h"  // JS::Compile{,{,Utf8{File,Path}}DontInflate}
-#include "js/SourceText.h"                // JS::Source{Ownership,Text}
+#include "js/SourceText.h"  // JS::Source{Ownership,Text}
 #include "jsapi-tests/tests.h"
 
 struct ScriptObjectFixture : public JSAPITest {
   static const int code_size;
   static const char code[];
   static char16_t uc_code[];
 
   ScriptObjectFixture() {
--- a/js/src/vm/ArrayBufferObject.cpp
+++ b/js/src/vm/ArrayBufferObject.cpp
@@ -951,17 +951,18 @@ void ArrayBufferObject::releaseData(Free
       // There's nothing to release if there's no data.
       MOZ_ASSERT(dataPointer() == nullptr);
       break;
     case USER_OWNED:
       // User-owned data is released by, well, the user.
       break;
     case MAPPED:
       gc::DeallocateMappedContent(dataPointer(), byteLength());
-      RemoveCellMemory(this, associatedBytes(), MemoryUse::ArrayBufferContents);
+      RemoveCellMemory(this, associatedBytes(),
+                       MemoryUse::ArrayBufferContents);
       break;
     case WASM:
       WasmArrayRawBuffer::Release(dataPointer());
       RemoveCellMemory(this, byteLength(), MemoryUse::ArrayBufferContents);
       break;
     case EXTERNAL:
       if (freeInfo()->freeFunc) {
         // The analyzer can't know for sure whether the embedder-supplied
--- a/js/src/vm/AtomsTable.h
+++ b/js/src/vm/AtomsTable.h
@@ -41,18 +41,18 @@ class MOZ_RAII AutoLockAllAtoms {
 
 struct AtomHasher {
   struct Lookup;
   static inline HashNumber hash(const Lookup& l);
   static MOZ_ALWAYS_INLINE bool match(const WeakHeapPtr<JSAtom*>& entry,
                                       const Lookup& lookup);
 };
 
-using AtomSet =
-    JS::GCHashSet<WeakHeapPtr<JSAtom*>, AtomHasher, SystemAllocPolicy>;
+using AtomSet = JS::GCHashSet<WeakHeapPtr<JSAtom*>, AtomHasher,
+                              SystemAllocPolicy>;
 
 // This class is a wrapper for AtomSet that is used to ensure the AtomSet is
 // not modified. It should only expose read-only methods from AtomSet.
 // Note however that the atoms within the table can be marked during GC.
 class FrozenAtomSet {
   AtomSet* mSet;
 
  public:
--- a/js/src/vm/CompilationAndEvaluation.cpp
+++ b/js/src/vm/CompilationAndEvaluation.cpp
@@ -558,19 +558,18 @@ static bool EvaluateSourceBuffer(JSConte
 JS_PUBLIC_API bool JS::Evaluate(JSContext* cx,
                                 const ReadOnlyCompileOptions& options,
                                 SourceText<Utf8Unit>& srcBuf,
                                 MutableHandle<Value> rval) {
   RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment());
 
   size_t length = srcBuf.length();
   auto chars = UniqueTwoByteChars(
-      UTF8CharsToNewTwoByteCharsZ(cx, UTF8Chars(srcBuf.get(), length), &length,
-                                  js::MallocArena)
-          .get());
+      UTF8CharsToNewTwoByteCharsZ(cx, UTF8Chars(srcBuf.get(), length),
+                                  &length, js::MallocArena).get());
   if (!chars) {
     return false;
   }
 
   SourceText<char16_t> inflatedSrc;
   if (!inflatedSrc.init(cx, std::move(chars), length)) {
     return false;
   }
--- a/js/src/vm/Debugger-inl.h
+++ b/js/src/vm/Debugger-inl.h
@@ -51,18 +51,18 @@
 /* static */ inline bool js::Debugger::checkNoExecute(JSContext* cx,
                                                       HandleScript script) {
   if (!cx->realm()->isDebuggee() || !cx->noExecuteDebuggerTop) {
     return true;
   }
   return slowPathCheckNoExecute(cx, script);
 }
 
-/* static */ inline js::ResumeMode js::Debugger::onEnterFrame(
-    JSContext* cx, AbstractFramePtr frame) {
+/* static */ inline js::ResumeMode js::Debugger::onEnterFrame(JSContext* cx,
+                                                       AbstractFramePtr frame) {
   MOZ_ASSERT_IF(frame.hasScript() && frame.script()->isDebuggee(),
                 frame.isDebuggee());
   if (!frame.isDebuggee()) {
     return ResumeMode::Continue;
   }
   return slowPathOnEnterFrame(cx, frame);
 }
 
@@ -94,18 +94,18 @@
 
 /* static */ inline void js::Debugger::onNewWasmInstance(
     JSContext* cx, Handle<WasmInstanceObject*> wasmInstance) {
   if (cx->realm()->isDebuggee()) {
     slowPathOnNewWasmInstance(cx, wasmInstance);
   }
 }
 
-/* static */ inline void js::Debugger::onNewPromise(
-    JSContext* cx, Handle<PromiseObject*> promise) {
+/* static */ inline void js::Debugger::onNewPromise(JSContext* cx,
+                                             Handle<PromiseObject*> promise) {
   if (MOZ_UNLIKELY(cx->realm()->isDebuggee())) {
     slowPathPromiseHook(cx, Debugger::OnNewPromise, promise);
   }
 }
 
 /* static */ inline void js::Debugger::onPromiseSettled(
     JSContext* cx, Handle<PromiseObject*> promise) {
   if (MOZ_UNLIKELY(promise->realm()->isDebuggee())) {
--- a/js/src/vm/EnvironmentObject.cpp
+++ b/js/src/vm/EnvironmentObject.cpp
@@ -1782,18 +1782,17 @@ class DebugEnvironmentProxyHandler : pub
            !env.as<LexicalEnvironmentObject>().isExtensible();
   }
 
   static Scope* getEnvironmentScope(const JSObject& env) {
     if (isFunctionEnvironment(env)) {
       return env.as<CallObject>().callee().nonLazyScript()->bodyScope();
     }
     if (env.is<ModuleEnvironmentObject>()) {
-      JSScript* script =
-          env.as<ModuleEnvironmentObject>().module().maybeScript();
+      JSScript* script = env.as<ModuleEnvironmentObject>().module().maybeScript();
       return script ? script->bodyScope() : nullptr;
     }
     if (isNonExtensibleLexicalEnvironment(env)) {
       return &env.as<LexicalEnvironmentObject>().scope();
     }
     if (env.is<VarEnvironmentObject>()) {
       return &env.as<VarEnvironmentObject>().scope();
     }
--- a/js/src/vm/EnvironmentObject.h
+++ b/js/src/vm/EnvironmentObject.h
@@ -959,17 +959,18 @@ class DebugEnvironments {
    * The map from environment objects of live frames to the live frame. This
    * map updated lazily whenever the debugger needs the information. In
    * between two lazy updates, liveEnvs becomes incomplete (but not invalid,
    * onPop* removes environments as they are popped). Thus, two consecutive
    * debugger lazy updates of liveEnvs need only fill in the new
    * environments.
    */
   typedef GCHashMap<WeakHeapPtr<JSObject*>, LiveEnvironmentVal,
-                    MovableCellHasher<WeakHeapPtr<JSObject*>>, ZoneAllocPolicy>
+                    MovableCellHasher<WeakHeapPtr<JSObject*>>,
+                    ZoneAllocPolicy>
       LiveEnvironmentMap;
   LiveEnvironmentMap liveEnvs;
 
  public:
   DebugEnvironments(JSContext* cx, Zone* zone);
   ~DebugEnvironments();
 
   Zone* zone() const { return zone_; }
--- a/js/src/vm/GeneratorObject.h
+++ b/js/src/vm/GeneratorObject.h
@@ -127,18 +127,17 @@ class AbstractGeneratorObject : public N
   }
   bool isRunning() const {
     return getFixedSlot(RESUME_INDEX_SLOT) == Int32Value(RESUME_INDEX_RUNNING);
   }
   bool isSuspended() const {
     // Note: also update Baseline's IsSuspendedGenerator code if this
     // changes.
     Value resumeIndex = getFixedSlot(RESUME_INDEX_SLOT);
-    return resumeIndex.isInt32() &&
-           resumeIndex.toInt32() < RESUME_INDEX_RUNNING;
+    return resumeIndex.isInt32() && resumeIndex.toInt32() < RESUME_INDEX_RUNNING;
   }
   void setRunning() {
     MOZ_ASSERT(isSuspended());
     setFixedSlot(RESUME_INDEX_SLOT, Int32Value(RESUME_INDEX_RUNNING));
   }
   void setResumeIndex(jsbytecode* pc) {
     MOZ_ASSERT(*pc == JSOP_INITIALYIELD || *pc == JSOP_YIELD ||
                *pc == JSOP_AWAIT);
--- a/js/src/vm/JSScript.h
+++ b/js/src/vm/JSScript.h
@@ -79,17 +79,17 @@ class JitScript;
 namespace frontend {
 struct BytecodeEmitter;
 class FunctionBox;
 class ModuleSharedContext;
 }  // namespace frontend
 
 namespace gc {
 void SweepLazyScripts(GCParallelTask* task);
-}  // namespace gc
+} // namespace gc
 
 namespace detail {
 
 // Do not call this directly! It is exposed for the friend declarations in
 // this file.
 JSScript* CopyScript(JSContext* cx, HandleScript src,
                      HandleScriptSourceObject sourceObject,
                      MutableHandle<GCVector<Scope*>> scopes);
--- a/js/src/vm/Runtime.h
+++ b/js/src/vm/Runtime.h
@@ -530,17 +530,19 @@ struct JSRuntime : public js::MallocProv
 
   // Number of debuggee realms in the runtime observing code coverage.
   js::MainThreadData<size_t> numDebuggeeRealmsObservingCoverage_;
 
  public:
   void incrementNumDebuggeeRealms();
   void decrementNumDebuggeeRealms();
 
-  size_t numDebuggeeRealms() const { return numDebuggeeRealms_; }
+  size_t numDebuggeeRealms() const {
+    return numDebuggeeRealms_;
+  }
 
   void incrementNumDebuggeeRealmsObservingCoverage();
   void decrementNumDebuggeeRealmsObservingCoverage();
 
   /* Locale-specific callbacks for string conversion. */
   js::MainThreadData<const JSLocaleCallbacks*> localeCallbacks;
 
   /* Default locale for Internationalization API */
--- a/js/src/vm/SavedFrame.h
+++ b/js/src/vm/SavedFrame.h
@@ -101,17 +101,18 @@ class SavedFrame : public NativeObject {
     RootedRange(JSContext* cx, HandleSavedFrame frame) : frame_(cx, frame) {}
     RootedIterator begin() { return RootedIterator(*this); }
     RootedIterator end() { return RootedIterator(); }
   };
 
   struct Lookup;
   struct HashPolicy;
 
-  typedef JS::GCHashSet<WeakHeapPtr<SavedFrame*>, HashPolicy, SystemAllocPolicy>
+  typedef JS::GCHashSet<WeakHeapPtr<SavedFrame*>, HashPolicy,
+                        SystemAllocPolicy>
       Set;
 
  private:
   static SavedFrame* create(JSContext* cx);
   static MOZ_MUST_USE bool finishSavedFrameInit(JSContext* cx,
                                                 HandleObject ctor,
                                                 HandleObject proto);
   void initFromLookup(JSContext* cx, Handle<Lookup> lookup);
--- a/js/src/vm/SavedStacks.cpp
+++ b/js/src/vm/SavedStacks.cpp
@@ -1090,19 +1090,18 @@ JS_PUBLIC_API bool IsUnwrappedSavedFrame
 
 static bool AssignProperty(JSContext* cx, HandleObject dst, HandleObject src,
                            const char* property) {
   RootedValue v(cx);
   return JS_GetProperty(cx, src, property, &v) &&
          JS_DefineProperty(cx, dst, property, v, JSPROP_ENUMERATE);
 }
 
-JS_PUBLIC_API JSObject* ConvertSavedFrameToPlainObject(
-    JSContext* cx, HandleObject savedFrameArg,
-    SavedFrameSelfHosted selfHosted) {
+JS_PUBLIC_API JSObject* ConvertSavedFrameToPlainObject
+    (JSContext* cx, HandleObject savedFrameArg, SavedFrameSelfHosted selfHosted) {
   MOZ_ASSERT(savedFrameArg);
 
   RootedObject savedFrame(cx, savedFrameArg);
   RootedObject baseConverted(cx), lastConverted(cx);
   RootedValue v(cx);
 
   baseConverted = lastConverted = JS_NewObject(cx, nullptr);
   if (!baseConverted) {
@@ -1115,17 +1114,17 @@ JS_PUBLIC_API JSObject* ConvertSavedFram
         !AssignProperty(cx, lastConverted, savedFrame, "sourceId") ||
         !AssignProperty(cx, lastConverted, savedFrame, "line") ||
         !AssignProperty(cx, lastConverted, savedFrame, "column") ||
         !AssignProperty(cx, lastConverted, savedFrame, "functionDisplayName") ||
         !AssignProperty(cx, lastConverted, savedFrame, "asyncCause")) {
       return nullptr;
     }
 
-    const char* parentProperties[] = {"parent", "asyncParent"};
+    const char* parentProperties[] = { "parent", "asyncParent" };
     foundParent = false;
     for (const char* prop : parentProperties) {
       if (!JS_GetProperty(cx, savedFrame, prop, &v)) {
         return nullptr;
       }
       if (v.isObject()) {
         RootedObject nextConverted(cx, JS_NewObject(cx, nullptr));
         if (!nextConverted ||
--- a/js/src/vm/Shape.h
+++ b/js/src/vm/Shape.h
@@ -891,18 +891,18 @@ struct DefaultHasher<jsid> {
   static bool match(jsid id1, jsid id2) { return id1 == id2; }
 };
 
 }  // namespace mozilla
 
 namespace js {
 
 using BaseShapeSet =
-    JS::WeakCache<JS::GCHashSet<WeakHeapPtr<UnownedBaseShape*>, StackBaseShape,
-                                SystemAllocPolicy>>;
+    JS::WeakCache<JS::GCHashSet<WeakHeapPtr<UnownedBaseShape*>,
+                                StackBaseShape, SystemAllocPolicy>>;
 
 class Shape : public gc::TenuredCell {
   friend class ::JSObject;
   friend class ::JSFunction;
   friend class NativeObject;
   friend class PropertyTree;
   friend class TenuringTracer;
   friend struct StackBaseShape;
--- a/js/src/vm/StringType-inl.h
+++ b/js/src/vm/StringType-inl.h
@@ -432,18 +432,18 @@ inline void JSFlatString::finalize(js::F
     fop->free_(this, nonInlineCharsRaw(), allocSize(),
                js::MemoryUse::StringContents);
   }
 }
 
 inline size_t JSFlatString::allocSize() const {
   MOZ_ASSERT(!isInline());
 
-  size_t charSize =
-      hasLatin1Chars() ? sizeof(JS::Latin1Char) : sizeof(char16_t);
+  size_t charSize = hasLatin1Chars() ? sizeof(JS::Latin1Char)
+                                     : sizeof(char16_t);
   size_t count = isExtensible() ? asExtensible().capacity() : length();
   return (count + 1) * charSize;
 }
 
 inline void JSFatInlineString::finalize(js::FreeOp* fop) {
   MOZ_ASSERT(getAllocKind() == js::gc::AllocKind::FAT_INLINE_STRING);
   MOZ_ASSERT(isInline());
 
--- a/js/src/vm/StringType.cpp
+++ b/js/src/vm/StringType.cpp
@@ -572,17 +572,18 @@ JSFlatString* JSRope::flattenInternal(JS
       }
       str->setNonInlineChars(wholeChars);
       uint32_t left_len = left.length();
       pos = wholeChars + left_len;
 
       // Remove memory association for left node we're about to make into a
       // dependent string.
       if (left.isTenured()) {
-        RemoveCellMemory(&left, left.allocSize(), MemoryUse::StringContents);
+        RemoveCellMemory(&left, left.allocSize(),
+                         MemoryUse::StringContents);
       }
 
       if (IsSame<CharT, char16_t>::value) {
         left.setLengthAndFlags(left_len, DEPENDENT_FLAGS);
       } else {
         left.setLengthAndFlags(left_len, DEPENDENT_FLAGS | LATIN1_CHARS_BIT);
       }
       left.d.s.u3.base = (JSLinearString*)this; /* will be true on exit */
@@ -659,17 +660,18 @@ finish_node : {
       str->setLengthAndFlags(wholeLength, EXTENSIBLE_FLAGS);
     } else {
       str->setLengthAndFlags(wholeLength, EXTENSIBLE_FLAGS | LATIN1_CHARS_BIT);
     }
     str->setNonInlineChars(wholeChars);
     str->d.s.u3.capacity = wholeCapacity;
 
     if (str->isTenured()) {
-      AddCellMemory(str, str->asFlat().allocSize(), MemoryUse::StringContents);
+      AddCellMemory(str, str->asFlat().allocSize(),
+                    MemoryUse::StringContents);
     }
 
     return &this->asFlat();
   }
   uintptr_t flattenData;
   uint32_t len = pos - str->nonInlineCharsRaw<CharT>();
   if (IsSame<CharT, char16_t>::value) {
     flattenData = str->unsetFlattenData(len, DEPENDENT_FLAGS);
@@ -1469,17 +1471,18 @@ JSFlatString* JSExternalString::ensureFl
     AutoCheckCannotGC nogc;
     FillAndTerminate(s.get(), nonInlineChars<char16_t>(nogc), n);
   }
 
   // Release the external chars.
   finalize(cx->runtime()->defaultFreeOp());
 
   MOZ_ASSERT(isTenured());
-  AddCellMemory(this, (n + 1) * sizeof(char16_t), MemoryUse::StringContents);
+  AddCellMemory(this, (n + 1) * sizeof(char16_t),
+                MemoryUse::StringContents);
 
   // Transform the string into a non-external, flat string. Note that the
   // resulting string will still be in an AllocKind::EXTERNAL_STRING arena,
   // but will no longer be an external string.
   setLengthAndFlags(n, INIT_FLAT_FLAGS);
   setNonInlineChars<char16_t>(s.release());
 
   return &this->asFlat();
--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -567,16 +567,17 @@ static PropertyName* DotMember(ParseNode
 static ParseNode* ElemBase(ParseNode* pn) {
   return &pn->as<PropertyByValue>().expression();
 }
 
 static ParseNode* ElemIndex(ParseNode* pn) {
   return &pn->as<PropertyByValue>().key();
 }
 
+
 static inline PropertyName* FunctionName(FunctionNode* funNode) {
   if (JSAtom* name = funNode->funbox()->explicitName()) {
     return name->asPropertyName();
   }
   return nullptr;
 }
 
 static inline ParseNode* FunctionStatementList(FunctionNode* funNode) {
@@ -6028,18 +6029,17 @@ static bool ParseFunction(ModuleValidato
   ParseContext* outerpc = m.parser().pc_;
   Directives directives(outerpc);
   FunctionBox* funbox = m.parser().newFunctionBox(
       funNode, fun, toStringStart, directives, GeneratorKind::NotGenerator,
       FunctionAsyncKind::SyncFunction);
   if (!funbox) {
     return false;
   }
-  funbox->initWithEnclosingParseContext(outerpc, fun,
-                                        FunctionSyntaxKind::Statement);
+  funbox->initWithEnclosingParseContext(outerpc, fun, FunctionSyntaxKind::Statement);
 
   Directives newDirectives = directives;
   SourceParseContext funpc(&m.parser(), funbox, &newDirectives);
   if (!funpc.init()) {
     return false;
   }
 
   if (!m.parser().functionFormalParametersAndBody(
--- a/js/src/wasm/WasmJS.h
+++ b/js/src/wasm/WasmJS.h
@@ -287,20 +287,19 @@ class WasmMemoryObject : public NativeOb
   static const ClassOps classOps_;
   static void finalize(FreeOp* fop, JSObject* obj);
   static bool bufferGetterImpl(JSContext* cx, const CallArgs& args);
   static bool bufferGetter(JSContext* cx, unsigned argc, Value* vp);
   static bool growImpl(JSContext* cx, const CallArgs& args);
   static bool grow(JSContext* cx, unsigned argc, Value* vp);
   static uint32_t growShared(HandleWasmMemoryObject memory, uint32_t delta);
 
-  using InstanceSet =
-      JS::WeakCache<GCHashSet<WeakHeapPtrWasmInstanceObject,
-                              MovableCellHasher<WeakHeapPtrWasmInstanceObject>,
-                              SystemAllocPolicy>>;
+  using InstanceSet = JS::WeakCache<GCHashSet<
+      WeakHeapPtrWasmInstanceObject,
+      MovableCellHasher<WeakHeapPtrWasmInstanceObject>, SystemAllocPolicy>>;
   bool hasObservers() const;
   InstanceSet& observers() const;
   InstanceSet* getOrCreateObservers(JSContext* cx);
 
  public:
   static const unsigned RESERVED_SLOTS = 2;
   static const Class class_;
   static const JSPropertySpec properties[];
--- a/js/src/wasm/WasmTable.h
+++ b/js/src/wasm/WasmTable.h
@@ -36,20 +36,19 @@ namespace wasm {
 
 // TODO/AnyRef-boxing: With boxed immediates and strings, JSObject* is no longer
 // the most appropriate representation for Cell::anyref.
 STATIC_ASSERT_ANYREF_IS_JSOBJECT;
 
 typedef GCVector<HeapPtr<JSObject*>, 0, SystemAllocPolicy> TableAnyRefVector;
 
 class Table : public ShareableBase<Table> {
-  using InstanceSet =
-      JS::WeakCache<GCHashSet<WeakHeapPtrWasmInstanceObject,
-                              MovableCellHasher<WeakHeapPtrWasmInstanceObject>,
-                              SystemAllocPolicy>>;
+  using InstanceSet = JS::WeakCache<GCHashSet<
+      WeakHeapPtrWasmInstanceObject,
+      MovableCellHasher<WeakHeapPtrWasmInstanceObject>, SystemAllocPolicy>>;
   using UniqueFuncRefArray = UniquePtr<FunctionTableElem[], JS::FreePolicy>;
 
   WeakHeapPtrWasmTableObject maybeObject_;
   InstanceSet observers_;
   UniqueFuncRefArray functions_;  // either functions_ has data
   TableAnyRefVector objects_;     //   or objects_, but not both
   const TableKind kind_;
   uint32_t length_;
--- a/js/xpconnect/src/XPCJSRuntime.cpp
+++ b/js/xpconnect/src/XPCJSRuntime.cpp
@@ -1822,19 +1822,20 @@ static void ReportRealmStats(const JS::R
       realmJSPathPrefix + NS_LITERAL_CSTRING("baseline/fallback-stubs"),
       realmStats.baselineStubsFallback,
       "The Baseline JIT's fallback IC stubs (excluding code).");
 
   ZRREPORT_BYTES(realmJSPathPrefix + NS_LITERAL_CSTRING("ion-data"),
                  realmStats.ionData,
                  "The IonMonkey JIT's compilation data (IonScripts).");
 
-  ZRREPORT_BYTES(realmJSPathPrefix + NS_LITERAL_CSTRING("jit-scripts"),
-                 realmStats.jitScripts,
-                 "JIT and Type Inference data associated with scripts.");
+  ZRREPORT_BYTES(
+      realmJSPathPrefix + NS_LITERAL_CSTRING("jit-scripts"),
+      realmStats.jitScripts,
+      "JIT and Type Inference data associated with scripts.");
 
   ZRREPORT_BYTES(
       realmJSPathPrefix +
           NS_LITERAL_CSTRING("type-inference/allocation-site-tables"),
       realmStats.typeInferenceAllocationSiteTables,
       "Tables of type objects associated with allocation sites.");
 
   ZRREPORT_BYTES(realmJSPathPrefix +
--- a/layout/base/nsQuoteList.cpp
+++ b/layout/base/nsQuoteList.cpp
@@ -37,33 +37,33 @@ nsString nsQuoteNode::Text() {
   NS_ASSERTION(mType == StyleContentType::OpenQuote ||
                    mType == StyleContentType::CloseQuote,
                "should only be called when mText should be non-null");
   nsString result;
   int32_t depth = Depth();
   MOZ_ASSERT(depth >= -1);
 
   Span<const StyleQuotePair> quotes =
-      mPseudoFrame->StyleList()->mQuotes._0.AsSpan();
+    mPseudoFrame->StyleList()->mQuotes._0.AsSpan();
 
   // Reuse the last pair when the depth is greater than the number of
   // pairs of quotes.  (Also make 'quotes: none' and close-quote from
   // a depth of 0 equivalent for the next test.)
   if (depth >= static_cast<int32_t>(quotes.Length())) {
-    depth = static_cast<int32_t>(quotes.Length()) - 1;
+      depth = static_cast<int32_t>(quotes.Length()) - 1;
   }
 
   if (depth == -1) {
     // close-quote from a depth of 0 or 'quotes: none'
     return result;
   }
 
   const StyleQuotePair& pair = quotes[depth];
   const StyleOwnedStr& quote =
-      mType == StyleContentType::OpenQuote ? pair.opening : pair.closing;
+    mType == StyleContentType::OpenQuote ? pair.opening : pair.closing;
   result.Assign(NS_ConvertUTF8toUTF16(quote.AsString()));
   return result;
 }
 
 void nsQuoteList::Calc(nsQuoteNode* aNode) {
   if (aNode == FirstNode()) {
     aNode->mDepthBefore = 0;
   } else {
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -3637,18 +3637,18 @@ static bool DescendIntoChild(nsDisplayLi
     nsRect normalPositionOverflowRelativeToTable = overflow;
 
     while (f->IsFrameOfType(nsIFrame::eTablePart)) {
       normalPositionOverflowRelativeToTable += f->GetNormalPosition();
       f = f->GetParent();
     }
 
     nsDisplayTableBackgroundSet* tableBGs = aBuilder->GetTableBackgroundSet();
-    if (tableBGs && tableBGs->GetDirtyRect().Intersects(
-                        normalPositionOverflowRelativeToTable)) {
+    if (tableBGs &&
+        tableBGs->GetDirtyRect().Intersects(normalPositionOverflowRelativeToTable)) {
       return true;
     }
   }
 
   return false;
 }
 
 void nsIFrame::BuildDisplayListForSimpleChild(nsDisplayListBuilder* aBuilder,
--- a/layout/painting/RetainedDisplayListBuilder.cpp
+++ b/layout/painting/RetainedDisplayListBuilder.cpp
@@ -125,19 +125,18 @@ bool RetainedDisplayListBuilder::PreProc
     PartialUpdateResult& aUpdated, uint32_t aCallerKey, uint32_t aNestingDepth,
     bool aKeepLinked) {
   // The DAG merging algorithm does not have strong mechanisms in place to keep
   // the complexity of the resulting DAG under control. In some cases we can
   // build up edges very quickly. Detect those cases and force a full display
   // list build if we hit them.
   static const uint32_t kMaxEdgeRatio = 5;
   const bool initializeDAG = !aList->mDAG.Length();
-  if (!aKeepLinked && !initializeDAG &&
-      aList->mDAG.mDirectPredecessorList.Length() >
-          (aList->mDAG.mNodesInfo.Length() * kMaxEdgeRatio)) {
+  if (!aKeepLinked && !initializeDAG && aList->mDAG.mDirectPredecessorList.Length() >
+                            (aList->mDAG.mNodesInfo.Length() * kMaxEdgeRatio)) {
     return false;
   }
 
   // If we had aKeepLinked=true for this list on the previous paint, then
   // mOldItems will already be initialized as it won't have been consumed during
   // a merge.
   const bool initializeOldItems = aList->mOldItems.IsEmpty();
   if (initializeOldItems) {
@@ -223,19 +222,17 @@ bool RetainedDisplayListBuilder::PreProc
           !(invalid->GetStateBits() &
             NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO)) {
         keepLinked = true;
       }
 
       if (!PreProcessDisplayList(
               item->GetChildren(), SelectAGRForFrame(f, aAGR), aUpdated,
               item->GetPerFrameKey(), aNestingDepth + 1, keepLinked)) {
-        MOZ_RELEASE_ASSERT(
-            !aKeepLinked,
-            "Can't early return since we need to move the out list back");
+        MOZ_RELEASE_ASSERT(!aKeepLinked, "Can't early return since we need to move the out list back");
         return false;
       }
     }
 
     // TODO: We should be able to check the clipped bounds relative
     // to the common AGR (of both the existing item and the invalidated
     // frame) and determine if they can ever intersect.
     // TODO: We only really need to build the ancestor container item that is a
@@ -1199,17 +1196,18 @@ static void AddFramesForContainingBlock(
 // their OOF frames list, and manually invalidate any frames that are
 // descendants of a modified frame (us, or another frame we'll get to soon).
 // This is combined with the work required for MarkFrameForDisplayIfVisible,
 // so that we can avoid an extra ancestor walk, and we can reuse the flag
 // to detect when we've already visited an ancestor (and thus all further
 // ancestors must also be visited).
 static void FindContainingBlocks(nsIFrame* aFrame,
                                  nsTArray<nsIFrame*>& aExtraFrames) {
-  for (nsIFrame* f = aFrame; f; f = nsLayoutUtils::GetDisplayListParent(f)) {
+  for (nsIFrame* f = aFrame; f;
+       f = nsLayoutUtils::GetDisplayListParent(f)) {
     if (f->ForceDescendIntoIfVisible()) return;
     f->SetForceDescendIntoIfVisible(true);
     CRR_LOG("Considering OOFs for %p\n", f);
 
     AddFramesForContainingBlock(f, f->GetChildList(nsIFrame::kFloatList),
                                 aExtraFrames);
     AddFramesForContainingBlock(f, f->GetChildList(f->GetAbsoluteListID()),
                                 aExtraFrames);
--- a/layout/painting/nsCSSRenderingBorders.cpp
+++ b/layout/painting/nsCSSRenderingBorders.cpp
@@ -3748,18 +3748,17 @@ nsCSSBorderImageRenderer::nsCSSBorderIma
     }
     if (value < 0) value = 0;
     if (value > imgDimension) value = imgDimension;
     mSlice.Side(s) = value;
 
     const auto& width = aStyleBorder.mBorderImageWidth.Get(s);
     switch (width.tag) {
       case StyleBorderImageSideWidth::Tag::LengthPercentage:
-        value =
-            std::max(0, width.AsLengthPercentage().Resolve(borderDimension));
+        value = std::max(0, width.AsLengthPercentage().Resolve(borderDimension));
         break;
       case StyleBorderImageSideWidth::Tag::Number:
         value = width.AsNumber() * borderWidths.Side(s);
         break;
       case StyleBorderImageSideWidth::Tag::Auto:
         value = mSlice.Side(s);
         break;
       default:
--- a/layout/style/CounterStyleManager.cpp
+++ b/layout/style/CounterStyleManager.cpp
@@ -1148,17 +1148,18 @@ bool CustomCounterStyle::IsBullet() {
       return false;
   }
 }
 
 /* virtual */
 void CustomCounterStyle::GetNegative(NegativeType& aResult) {
   if (!(mFlags & FLAG_NEGATIVE_INITED)) {
     mFlags |= FLAG_NEGATIVE_INITED;
-    if (!Servo_CounterStyleRule_GetNegative(mRule, &mNegative.before,
+    if (!Servo_CounterStyleRule_GetNegative(mRule,
+                                            &mNegative.before,
                                             &mNegative.after)) {
       if (IsExtendsSystem()) {
         GetExtends()->GetNegative(mNegative);
       } else {
         mNegative.before.AssignLiteral(u"-");
         mNegative.after.Truncate();
       }
     }
--- a/layout/style/FontFace.cpp
+++ b/layout/style/FontFace.cpp
@@ -310,27 +310,28 @@ void FontFace::GetDisplay(nsString& aRes
 
 void FontFace::SetDisplay(const nsAString& aValue, ErrorResult& aRv) {
   mFontFaceSet->FlushUserFontSet();
   if (SetDescriptor(eCSSFontDesc_Display, aValue, aRv)) {
     DescriptorUpdated();
   }
 }
 
-void FontFace::DescriptorUpdated() {
+void FontFace::DescriptorUpdated()
+{
   // If we haven't yet initialized mUserFontEntry, no need to do anything here;
   // we'll respect the updated descriptor when the time comes to create it.
   if (!mUserFontEntry) {
     return;
   }
 
   // Behind the scenes, this will actually update the existing entry and return
   // it, rather than create a new one.
   RefPtr<gfxUserFontEntry> newEntry =
-      mFontFaceSet->FindOrCreateUserFontEntryFromFontFace(this);
+    mFontFaceSet->FindOrCreateUserFontEntryFromFontFace(this);
   SetUserFontEntry(newEntry);
 
   if (mInFontFaceSet) {
     mFontFaceSet->MarkUserFontSetDirty();
   }
   for (auto& set : mOtherFontFaceSets) {
     set->MarkUserFontSetDirty();
   }
--- a/layout/style/FontFaceSet.cpp
+++ b/layout/style/FontFaceSet.cpp
@@ -1027,26 +1027,27 @@ FontFaceSet::FindOrCreateUserFontEntryFr
 
   // set up unicode-range
   gfxCharacterMap* unicodeRanges = aFontFace->GetUnicodeRangeAsCharacterMap();
 
   RefPtr<gfxUserFontEntry> existingEntry = aFontFace->GetUserFontEntry();
   if (existingEntry) {
     // aFontFace already has a user font entry, so we update its attributes
     // rather than creating a new one.
-    existingEntry->UpdateAttributes(
-        weight, stretch, italicStyle, featureSettings, variationSettings,
-        languageOverride, unicodeRanges, fontDisplay, rangeFlags);
+    existingEntry->UpdateAttributes(weight, stretch, italicStyle,
+                                    featureSettings, variationSettings,
+                                    languageOverride, unicodeRanges,
+                                    fontDisplay, rangeFlags);
     // If the family name has changed, remove the entry from its current family
     // and clear the mFamilyName field so it can be reset when added to a new
     // family.
     if (!existingEntry->mFamilyName.IsEmpty() &&
         existingEntry->mFamilyName != aFamilyName) {
       gfxUserFontFamily* family =
-          set->GetUserFontSet()->LookupFamily(existingEntry->mFamilyName);
+        set->GetUserFontSet()->LookupFamily(existingEntry->mFamilyName);
       if (family) {
         family->RemoveFontEntry(existingEntry);
       }
       existingEntry->mFamilyName.Truncate(0);
     }
     return existingEntry.forget();
   }
 
--- a/layout/style/ServoComputedDataInlines.h
+++ b/layout/style/ServoComputedDataInlines.h
@@ -6,19 +6,19 @@
 
 #ifndef mozilla_ServoComputedDataInlines_h
 #define mozilla_ServoComputedDataInlines_h
 
 #include "mozilla/ServoComputedData.h"
 #include "nsStyleStruct.h"
 
 namespace mozilla {
-#define STYLE_STRUCT(name_)                  \
-  struct Gecko##name_ {                      \
-    ServoManuallyDrop<nsStyle##name_> gecko; \
+#define STYLE_STRUCT(name_) \
+  struct Gecko##name_ {     \
+    ServoManuallyDrop<nsStyle##name_> gecko;   \
   };
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 }  // namespace mozilla
 
 #define STYLE_STRUCT(name_)                                          \
   const nsStyle##name_* ServoComputedData::GetStyle##name_() const { \
     return &name_.mPtr->gecko.mInner;                                \
--- a/layout/style/ServoStyleConstsForwards.h
+++ b/layout/style/ServoStyleConstsForwards.h
@@ -75,17 +75,17 @@ using ComputedKeyframeValues = nsTArray<
 class ComputedStyle;
 class SeenPtrs;
 class SharedFontList;
 class StyleSheet;
 class WritingMode;
 class ServoElementSnapshotTable;
 enum class StyleContentType : uint8_t;
 
-template <typename T>
+template<typename T>
 struct StyleForgottenArcSlicePtr;
 
 struct AnimationPropertySegment;
 struct ComputedTiming;
 struct URLExtraData;
 
 enum HalfCorner : uint8_t;
 enum LogicalSide : uint8_t;
--- a/layout/style/nsCSSValue.h
+++ b/layout/style/nsCSSValue.h
@@ -235,17 +235,17 @@ struct GridTemplateAreasValue final {
   GridTemplateAreasValue& operator=(const GridTemplateAreasValue& aOther) =
       delete;
 };
 
 }  // namespace css
 }  // namespace mozilla
 
 enum nsCSSUnit : uint32_t {
-  eCSSUnit_Null = 0,  // (n/a) null unit, value is not specified
+  eCSSUnit_Null = 0,     // (n/a) null unit, value is not specified
 
   eCSSUnit_Integer = 70,     // (int) simple value
   eCSSUnit_Enumerated = 71,  // (int) value has enumerated meaning
 
   eCSSUnit_Percent = 100,  // (float) (1.0 == 100%) value is percentage of
                            // something
   eCSSUnit_Number = 101,   // (float) value is numeric (usually multiplier,
                            // different behavior than percent)
--- a/layout/style/nsStyleConsts.h
+++ b/layout/style/nsStyleConsts.h
@@ -166,18 +166,17 @@ enum class StyleScrollbarWidth : uint8_t
   Auto,
   Thin,
   None,
 };
 
 // Shape source type
 enum class StyleShapeSourceType : uint8_t {
   None,
-  Image,  // shape-outside / clip-path only, and clip-path only uses it for
-          // <url>s
+  Image,  // shape-outside / clip-path only, and clip-path only uses it for <url>s
   Shape,
   Box,
   Path,  // SVG path function
 };
 
 // -moz-stack-sizing
 enum class StyleStackSizing : uint8_t {
   Ignore,
--- a/layout/style/nsStyleUtil.h
+++ b/layout/style/nsStyleUtil.h
@@ -24,17 +24,17 @@ struct gfxAlternateValue;
 struct nsCSSKTableEntry;
 struct nsCSSValueList;
 
 namespace mozilla {
 class FontSlantStyle;
 namespace dom {
 class Document;
 class Element;
-}  // namespace dom
+}
 }  // namespace mozilla
 
 // Style utility functions
 class nsStyleUtil {
  public:
   static bool DashMatchCompare(const nsAString& aAttributeValue,
                                const nsAString& aSelectorValue,
                                const nsStringComparator& aComparator);
--- a/layout/svg/SVGImageContext.cpp
+++ b/layout/svg/SVGImageContext.cpp
@@ -50,23 +50,21 @@ void SVGImageContext::MaybeStoreContextP
     haveContextPaint = true;
     contextPaint->SetFill(style->mFill.GetColor(aFromComputedStyle));
   }
   if ((style->mMozContextProperties.bits & StyleContextPropertyBits_STROKE) &&
       style->mStroke.Type() == eStyleSVGPaintType_Color) {
     haveContextPaint = true;
     contextPaint->SetStroke(style->mStroke.GetColor(aFromComputedStyle));
   }
-  if (style->mMozContextProperties.bits &
-      StyleContextPropertyBits_FILL_OPACITY) {
+  if (style->mMozContextProperties.bits & StyleContextPropertyBits_FILL_OPACITY) {
     haveContextPaint = true;
     contextPaint->SetFillOpacity(style->mFillOpacity);
   }
-  if (style->mMozContextProperties.bits &
-      StyleContextPropertyBits_STROKE_OPACITY) {
+  if (style->mMozContextProperties.bits & StyleContextPropertyBits_STROKE_OPACITY) {
     haveContextPaint = true;
     contextPaint->SetStrokeOpacity(style->mStrokeOpacity);
   }
 
   if (haveContextPaint) {
     if (!aContext) {
       aContext.emplace();
     }
--- a/layout/svg/SVGObserverUtils.cpp
+++ b/layout/svg/SVGObserverUtils.cpp
@@ -1169,18 +1169,17 @@ static nsSVGPaintingProperty* GetOrCreat
     nsIFrame* aClippedFrame) {
   MOZ_ASSERT(!aClippedFrame->GetPrevContinuation(),
              "Require first continuation");
 
   const nsStyleSVGReset* svgStyleReset = aClippedFrame->StyleSVGReset();
   if (svgStyleReset->mClipPath.GetType() != StyleShapeSourceType::Image) {
     return nullptr;
   }
-  const css::URLValue* url =
-      svgStyleReset->mClipPath.ShapeImage().GetURLValue();
+  const css::URLValue* url = svgStyleReset->mClipPath.ShapeImage().GetURLValue();
   MOZ_ASSERT(url);
   RefPtr<URLAndReferrerInfo> pathURI =
       ResolveURLUsingLocalRef(aClippedFrame, url);
   return GetPaintingProperty(pathURI, aClippedFrame, ClipPathProperty());
 }
 
 SVGObserverUtils::ReferenceState SVGObserverUtils::GetAndObserveClipPath(
     nsIFrame* aClippedFrame, nsSVGClipPathFrame** aClipPathFrame) {
--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -235,18 +235,18 @@ static void DisplayRows(nsDisplayListBui
   }
 }
 
 void nsTableRowGroupFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
                                             const nsDisplayListSet& aLists) {
   DisplayOutsetBoxShadow(aBuilder, aLists.BorderBackground());
 
   for (nsTableRowFrame* row = GetFirstRow(); row; row = row->GetNextRow()) {
-    if (!aBuilder->GetDirtyRect().Intersects(row->GetVisualOverflowRect() +
-                                             row->GetNormalPosition())) {
+    if (!aBuilder->GetDirtyRect().Intersects(
+            row->GetVisualOverflowRect() + row->GetNormalPosition())) {
       continue;
     }
     row->PaintCellBackgroundsForFrame(this, aBuilder, aLists,
                                       row->GetNormalPosition());
   }
 
   DisplayInsetBoxShadow(aBuilder, aLists.BorderBackground());
 
--- a/media/libdav1d/config.h
+++ b/media/libdav1d/config.h
@@ -40,19 +40,19 @@
 #  define HAVE_ASM 1
 #else
 #  define HAVE_ASM 0
 #endif
 
 #if ARCH_AARCH64 == 1
 // Those values are copied from the auto generated
 // config file produced by stand alone dav1d build.
-#  define HAVE_AS_FUNC 0
-#  define HAVE_GETAUXVAL 1
-#  define PIC 3
+#define HAVE_AS_FUNC 0
+#define HAVE_GETAUXVAL 1
+#define PIC 3
 #endif
 
 // The following macros are defined from autoconf
 // according to the system configuration.
 // (HAVE_MEMALIGN | HAVE_ALIGNED_MALLOC | HAVE_POSIX_MEMALIGN)
 // HAVE_UNISTD_H
 
 // Important when asm is enabled
--- a/mfbt/HashTable.h
+++ b/mfbt/HashTable.h
@@ -1613,16 +1613,17 @@ class HashTable : private AllocPolicy {
   // Fake a struct that we're going to alloc. See the comments in
   // HashTableEntry about how the table is laid out, and why it's safe.
   struct FakeSlot {
     unsigned char c[sizeof(HashNumber) + sizeof(typename Entry::NonConstT)];
   };
 
   static char* createTable(AllocPolicy& aAllocPolicy, uint32_t aCapacity,
                            FailureBehavior aReportFailure = ReportFailure) {
+
     FakeSlot* fake =
         aReportFailure
             ? aAllocPolicy.template pod_malloc<FakeSlot>(aCapacity)
             : aAllocPolicy.template maybe_pod_malloc<FakeSlot>(aCapacity);
     char* table = reinterpret_cast<char*>(fake);
     if (table) {
       forEachSlot(table, aCapacity, [&](Slot& slot) {
         *slot.mKeyHash = sFreeKey;
--- a/mfbt/RecordReplay.cpp
+++ b/mfbt/RecordReplay.cpp
@@ -40,51 +40,52 @@ namespace recordreplay {
               Macro(ExecutionProgressCounter, ProgressCounter*, (), ())        \
                   Macro(NewTimeWarpTarget, ProgressCounter, (), ()) Macro(     \
                       ShouldUpdateProgressCounter, bool, (const char* aURL),   \
                       (aURL))                                                  \
                       Macro(DefineRecordReplayControlObject, bool,             \
                             (JSContext * aCx, JSObject * aObj), (aCx, aObj))
 
 #define FOR_EACH_INTERFACE_VOID(Macro)                                         \
-  Macro(InternalBeginOrderedAtomicAccess, (const void* aValue),                \
-        (aValue)) Macro(InternalEndOrderedAtomicAccess, (), ())                \
-      Macro(InternalBeginPassThroughThreadEvents, (), ()) Macro(               \
-          InternalEndPassThroughThreadEvents, (),                              \
-          ()) Macro(InternalBeginDisallowThreadEvents, (),                     \
-                    ()) Macro(InternalEndDisallowThreadEvents, (),             \
-                              ()) Macro(InternalRecordReplayBytes,             \
-                                        (void* aData, size_t aSize),           \
-                                        (aData, aSize))                        \
-          Macro(                                                               \
-              InternalInvalidateRecording, (const char* aWhy),                 \
-              (aWhy)) Macro(InternalDestroyPLDHashTableCallbacks,              \
-                            (const PLDHashTableOps* aOps),                     \
-                            (aOps)) Macro(InternalMovePLDHashTableContents,    \
-                                          (const PLDHashTableOps* aFirstOps,   \
-                                           const PLDHashTableOps* aSecondOps), \
-                                          (aFirstOps, aSecondOps))             \
-              Macro(SetWeakPointerJSRoot,                                      \
-                    (const void* aPtr, JSObject* aJSObj), (aPtr, aJSObj))      \
-                  Macro(RegisterTrigger,                                       \
-                        (void* aObj, const std::function<void()>& aCallback),  \
-                        (aObj,                                                 \
-                         aCallback)) Macro(UnregisterTrigger, (void* aObj),    \
-                                           (aObj)) Macro(ActivateTrigger,      \
-                                                         (void* aObj), (aObj)) \
-                      Macro(ExecuteTriggers, (), ()) Macro(                    \
-                          InternalRecordReplayAssert,                          \
-                          (const char* aFormat, va_list aArgs),                \
-                          (aFormat,                                            \
-                           aArgs)) Macro(InternalRecordReplayAssertBytes,      \
-                                         (const void* aData, size_t aSize),    \
-                                         (aData, aSize))                       \
-                          Macro(InternalRegisterThing, (void* aThing),         \
-                                (aThing)) Macro(InternalUnregisterThing,       \
-                                                (void* aThing), (aThing))      \
+  Macro(                                                                       \
+      InternalBeginOrderedAtomicAccess, (const void* aValue),                  \
+      (aValue)) Macro(InternalEndOrderedAtomicAccess, (),                      \
+                      ()) Macro(InternalBeginPassThroughThreadEvents, (),      \
+                                ()) Macro(InternalEndPassThroughThreadEvents,  \
+                                          (), ())                              \
+      Macro(InternalBeginDisallowThreadEvents, (), ()) Macro(                  \
+          InternalEndDisallowThreadEvents, (),                                 \
+          ()) Macro(InternalRecordReplayBytes, (void* aData, size_t aSize),    \
+                    (aData, aSize)) Macro(InternalInvalidateRecording,         \
+                                          (const char* aWhy), (aWhy))          \
+          Macro(InternalDestroyPLDHashTableCallbacks,                          \
+                (const PLDHashTableOps* aOps),                                 \
+                (aOps)) Macro(InternalMovePLDHashTableContents,                \
+                              (const PLDHashTableOps* aFirstOps,               \
+                               const PLDHashTableOps* aSecondOps),             \
+                              (aFirstOps,                                      \
+                               aSecondOps)) Macro(SetWeakPointerJSRoot,        \
+                                                  (const void* aPtr,           \
+                                                   JSObject* aJSObj),          \
+                                                  (aPtr, aJSObj))              \
+              Macro(RegisterTrigger,                                           \
+                    (void* aObj, const std::function<void()>& aCallback),      \
+                    (aObj, aCallback)) Macro(UnregisterTrigger, (void* aObj),  \
+                                             (aObj))                           \
+                  Macro(ActivateTrigger, (void* aObj), (aObj)) Macro(          \
+                      ExecuteTriggers, (),                                     \
+                      ()) Macro(InternalRecordReplayAssert,                    \
+                                (const char* aFormat, va_list aArgs),          \
+                                (aFormat, aArgs))                              \
+                      Macro(InternalRecordReplayAssertBytes,                   \
+                            (const void* aData, size_t aSize),                 \
+                            (aData, aSize)) Macro(InternalRegisterThing,       \
+                                                  (void* aThing), (aThing))    \
+                          Macro(InternalUnregisterThing, (void* aThing),       \
+                                (aThing))                                      \
                               Macro(BeginContentParse,                         \
                                     (const void* aToken, const char* aURL,     \
                                      const char* aContentType),                \
                                     (aToken, aURL, aContentType))              \
                                   Macro(AddContentParseData8,                  \
                                         (const void* aToken,                   \
                                          const mozilla::Utf8Unit* aUtf8Buffer, \
                                          size_t aLength),                      \
--- a/mozglue/build/Authenticode.cpp
+++ b/mozglue/build/Authenticode.cpp
@@ -307,34 +307,34 @@ bool SignedBinary::VerifySignature(const
       pCryptCATAdminEnumCatalogFromHash(L"wintrust.dll",
                                         "CryptCATAdminEnumCatalogFromHash");
   if (!pCryptCATAdminEnumCatalogFromHash) {
     return false;
   }
 
   static const mozilla::DynamicallyLinkedFunctionPtr<decltype(
       &::CryptCATAdminReleaseCatalogContext)>
-      pCryptCATAdminReleaseCatalogContext(L"wintrust.dll",
-                                          "CryptCATAdminReleaseCatalogContext");
+    pCryptCATAdminReleaseCatalogContext(L"wintrust.dll",
+                                        "CryptCATAdminReleaseCatalogContext");
   if (!pCryptCATAdminReleaseCatalogContext) {
     return false;
   }
 
   HCATINFO catInfoHdl = pCryptCATAdminEnumCatalogFromHash(
       rawCatAdmin, hashBuf.get(), hashLen, 0, nullptr);
   if (!catInfoHdl) {
     return false;
   }
 
   // We can't use UniquePtr for this because the deleter function requires two
   // parameters.
-  auto cleanCatInfoHdl =
-      mozilla::MakeScopeExit([rawCatAdmin, catInfoHdl]() -> void {
-        pCryptCATAdminReleaseCatalogContext(rawCatAdmin, catInfoHdl, 0);
-      });
+  auto cleanCatInfoHdl = mozilla::MakeScopeExit(
+    [rawCatAdmin, catInfoHdl]() -> void {
+    pCryptCATAdminReleaseCatalogContext(rawCatAdmin, catInfoHdl, 0);
+  });
 
   // We found a catalog! Now query for the path to the catalog file.
 
   static const mozilla::DynamicallyLinkedFunctionPtr<decltype(
       &::CryptCATCatalogInfoFromContext)>
       pCryptCATCatalogInfoFromContext(L"wintrust.dll",
                                       "CryptCATCatalogInfoFromContext");
   if (!pCryptCATCatalogInfoFromContext) {
--- a/mozglue/tests/interceptor/TestDllInterceptor.cpp
+++ b/mozglue/tests/interceptor/TestDllInterceptor.cpp
@@ -528,17 +528,17 @@ bool MaybeTestHook(const bool cond, cons
           NULL))
 
 bool ShouldTestTipTsf() {
   if (!IsWin8OrLater()) {
     return false;
   }
 
   mozilla::DynamicallyLinkedFunctionPtr<decltype(&SHGetKnownFolderPath)>
-      pSHGetKnownFolderPath(L"shell32.dll", "SHGetKnownFolderPath");
+    pSHGetKnownFolderPath(L"shell32.dll", "SHGetKnownFolderPath");
   if (!pSHGetKnownFolderPath) {
     return false;
   }
 
   PWSTR commonFilesPath = nullptr;
   if (FAILED(pSHGetKnownFolderPath(FOLDERID_ProgramFilesCommon, 0, nullptr,
                                    &commonFilesPath))) {
     return false;
@@ -558,17 +558,17 @@ bool ShouldTestTipTsf() {
 }
 
 static const wchar_t gEmptyUnicodeStringLiteral[] = L"";
 static UNICODE_STRING gEmptyUnicodeString;
 static BOOLEAN gIsPresent;
 
 bool HasApiSetQueryApiSetPresence() {
   mozilla::DynamicallyLinkedFunctionPtr<decltype(&ApiSetQueryApiSetPresence)>
-      func(L"Api-ms-win-core-apiquery-l1-1-0.dll", "ApiSetQueryApiSetPresence");
+    func(L"Api-ms-win-core-apiquery-l1-1-0.dll", "ApiSetQueryApiSetPresence");
   if (!func) {
     return false;
   }
 
   // Prepare gEmptyUnicodeString for the test
   ::RtlInitUnicodeString(&gEmptyUnicodeString, gEmptyUnicodeStringLiteral);
 
   return true;
@@ -827,20 +827,17 @@ extern "C" int wmain(int argc, wchar_t* 
       TEST_HOOK_PARAMS(sspicli.dll, QueryCredentialsAttributesA, Equals,
                        SEC_E_INVALID_HANDLE, &credHandle, 0, nullptr) &&
 #if !defined(_M_ARM64)
       TEST_HOOK_PARAMS(sspicli.dll, FreeCredentialsHandle, Equals,
                        SEC_E_INVALID_HANDLE, &credHandle) &&
 #endif
       TEST_DETOUR_SKIP_EXEC(kernel32.dll, BaseThreadInitThunk) &&
       TEST_DETOUR_SKIP_EXEC(ntdll.dll, LdrLoadDll) &&
-      MAYBE_TEST_HOOK_PARAMS(HasApiSetQueryApiSetPresence(),
-                             Api - ms - win - core - apiquery - l1 - 1 - 0.dll,
-                             ApiSetQueryApiSetPresence, Equals, FALSE,
-                             &gEmptyUnicodeString, &gIsPresent) &&
+      MAYBE_TEST_HOOK_PARAMS(HasApiSetQueryApiSetPresence(), Api-ms-win-core-apiquery-l1-1-0.dll, ApiSetQueryApiSetPresence, Equals, FALSE, &gEmptyUnicodeString, &gIsPresent) &&
       TestTenByteDetour()) {
     printf("TEST-PASS | WindowsDllInterceptor | all checks passed\n");
 
     LARGE_INTEGER end, freq;
     QueryPerformanceCounter(&end);
 
     QueryPerformanceFrequency(&freq);
 
--- a/netwerk/protocol/data/DataChannelParent.cpp
+++ b/netwerk/protocol/data/DataChannelParent.cpp
@@ -66,17 +66,17 @@ DataChannelParent::SetClassifierMatchedI
                                             const nsACString& aProvider,
                                             const nsACString& aFullHash) {
   // nothing to do
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DataChannelParent::SetClassifierMatchedTrackingInfo(
-    const nsACString& aLists, const nsACString& aFullHashes) {
+    const nsACString &aLists, const nsACString &aFullHashes) {
   // nothing to do
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DataChannelParent::Delete() {
   // Nothing to do.
   return NS_OK;
--- a/netwerk/protocol/file/FileChannelParent.cpp
+++ b/netwerk/protocol/file/FileChannelParent.cpp
@@ -66,17 +66,17 @@ FileChannelParent::SetClassifierMatchedI
                                             const nsACString& aProvider,
                                             const nsACString& aFullHash) {
   // nothing to do
   return NS_OK;
 }
 
 NS_IMETHODIMP
 FileChannelParent::SetClassifierMatchedTrackingInfo(
-    const nsACString& aLists, const nsACString& aFullHashes) {
+    const nsACString &aLists, const nsACString &aFullHashes) {
   // nothing to do
   return NS_OK;
 }
 
 NS_IMETHODIMP
 FileChannelParent::Delete() {
   // Nothing to do.
   return NS_OK;
--- a/netwerk/protocol/http/nsHttpHandler.h
+++ b/netwerk/protocol/http/nsHttpHandler.h
@@ -70,22 +70,18 @@ class AltSvcMapping;
  *                     and consider a mismatch to mean a
  *                     NS_ERROR_NET_PARTIAL_TRANSFER error.
  * FRAMECHECK_STRICT_CHUNKED - This is the same as FRAMECHECK_BARELY only we
  *                             enforce that the last 0-size chunk is received
  *                             in case 1).
  * FRAMECHECK_STRICT - we also do not allow case 2) and 3) from
  *                     FRAMECHECK_BARELY.
  */
-enum FrameCheckLevel {
-  FRAMECHECK_LAX,
-  FRAMECHECK_BARELY,
-  FRAMECHECK_STRICT_CHUNKED,
-  FRAMECHECK_STRICT
-};
+enum FrameCheckLevel { FRAMECHECK_LAX, FRAMECHECK_BARELY,
+                       FRAMECHECK_STRICT_CHUNKED, FRAMECHECK_STRICT };
 
 //-----------------------------------------------------------------------------
 // nsHttpHandler - protocol handler for HTTP and HTTPS
 //-----------------------------------------------------------------------------
 
 class nsHttpHandler final : public nsIHttpProtocolHandler,
                             public nsIObserver,
                             public nsSupportsWeakReference,
--- a/netwerk/protocol/http/nsHttpTransaction.cpp
+++ b/netwerk/protocol/http/nsHttpTransaction.cpp
@@ -1138,18 +1138,19 @@ void nsHttpTransaction::Close(nsresult r
         // chunk boundary. (check mChunkedDecoder->GetChunkRemaining() != 0)
         // 2) mark a transfer that is partial and it is not chunk-encoded or
         // gzip-encoded or other content-encoding as partial. (check
         // !mChunkedDecoder && !mContentDecoding && mContentDecodingCheck))
         // if clevel == FRAMECHECK_STRICT_CHUNKED mark a chunked-encoded
         // response that ends on exactly a chunk boundary also as partial.
         // Here a response must have the last 0-size chunk.
         if ((clevel == FRAMECHECK_STRICT) ||
-            (mChunkedDecoder && (mChunkedDecoder->GetChunkRemaining() ||
-                                 (clevel == FRAMECHECK_STRICT_CHUNKED))) ||
+            (mChunkedDecoder &&
+             (mChunkedDecoder->GetChunkRemaining() ||
+              (clevel == FRAMECHECK_STRICT_CHUNKED))) ||
             (!mChunkedDecoder && !mContentDecoding && mContentDecodingCheck)) {
           reason = NS_ERROR_NET_PARTIAL_TRANSFER;
           LOG(("Partial transfer, incomplete HTTP response received: %s",
                mChunkedDecoder ? "broken chunk" : "c-l underrun"));
         }
       }
     }
 
--- a/parser/html/nsHtml5PlainTextUtils.cpp
+++ b/parser/html/nsHtml5PlainTextUtils.cpp
@@ -8,15 +8,16 @@
 #include "nsHtml5Portability.h"
 #include "nsHtml5String.h"
 #include "nsIServiceManager.h"
 #include "nsIStringBundle.h"
 
 // static
 nsHtml5HtmlAttributes* nsHtml5PlainTextUtils::NewLinkAttributes() {
   nsHtml5HtmlAttributes* linkAttrs = new nsHtml5HtmlAttributes(0);
-  nsHtml5String rel = nsHtml5Portability::newStringFromLiteral("stylesheet");
+  nsHtml5String rel =
+      nsHtml5Portability::newStringFromLiteral("stylesheet");
   linkAttrs->addAttribute(nsHtml5AttributeName::ATTR_REL, rel, -1);
   nsHtml5String href = nsHtml5Portability::newStringFromLiteral(
       "resource://content-accessible/plaintext.css");
   linkAttrs->addAttribute(nsHtml5AttributeName::ATTR_HREF, href, -1);
   return linkAttrs;
 }
--- a/security/manager/ssl/CSTrustDomain.cpp
+++ b/security/manager/ssl/CSTrustDomain.cpp
@@ -26,21 +26,19 @@ namespace mozilla {
 namespace psm {
 
 static LazyLogModule gTrustDomainPRLog("CSTrustDomain");
 #define CSTrust_LOG(args) MOZ_LOG(gTrustDomainPRLog, LogLevel::Debug, args)
 
 CSTrustDomain::CSTrustDomain(UniqueCERTCertList& certChain)
     : mCertChain(certChain),
 #ifdef MOZ_NEW_CERT_STORAGE
-      mCertBlocklist(do_GetService(NS_CERT_STORAGE_CID)) {
-}
+      mCertBlocklist(do_GetService(NS_CERT_STORAGE_CID)) {}
 #else
-      mCertBlocklist(do_GetService(NS_CERTBLOCKLIST_CONTRACTID)) {
-}
+      mCertBlocklist(do_GetService(NS_CERTBLOCKLIST_CONTRACTID)) {}
 #endif
 
 Result CSTrustDomain::GetCertTrust(EndEntityOrCA endEntityOrCA,
                                    const CertPolicyId& policy,
                                    Input candidateCertDER,
                                    /*out*/ TrustLevel& trustLevel) {
   MOZ_ASSERT(policy.IsAnyPolicy());
   if (!policy.IsAnyPolicy()) {
--- a/security/sandbox/win/SandboxInitialization.cpp
+++ b/security/sandbox/win/SandboxInitialization.cpp
@@ -43,29 +43,27 @@ static BOOL WINAPI patched_DuplicateHand
     base::win::OnHandleBeingClosed(hSourceHandle);
   }
 
   return stub_DuplicateHandle(hSourceProcessHandle, hSourceHandle,
                               hTargetProcessHandle, lpTargetHandle,
                               dwDesiredAccess, bInheritHandle, dwOptions);
 }
 
-typedef BOOL(WINAPI* ApiSetQueryApiSetPresence_func)(PCUNICODE_STRING,
-                                                     PBOOLEAN);
-static WindowsDllInterceptor::FuncHookType<ApiSetQueryApiSetPresence_func>
-    stub_ApiSetQueryApiSetPresence;
+typedef BOOL (WINAPI* ApiSetQueryApiSetPresence_func)(PCUNICODE_STRING, PBOOLEAN);
+static WindowsDllInterceptor::FuncHookType<ApiSetQueryApiSetPresence_func> stub_ApiSetQueryApiSetPresence;
 
 static const WCHAR gApiSetNtUserWindowStation[] =
-    L"ext-ms-win-ntuser-windowstation-l1-1-0";
+  L"ext-ms-win-ntuser-windowstation-l1-1-0";
 
 static BOOL WINAPI patched_ApiSetQueryApiSetPresence(
     PCUNICODE_STRING aNamespace, PBOOLEAN aPresent) {
-  if (aNamespace && aPresent &&
-      !wcsncmp(aNamespace->Buffer, gApiSetNtUserWindowStation,
-               aNamespace->Length / sizeof(WCHAR))) {
+  if (aNamespace && aPresent && !wcsncmp(aNamespace->Buffer,
+                                         gApiSetNtUserWindowStation,
+                                         aNamespace->Length / sizeof(WCHAR))) {
     *aPresent = FALSE;
     return TRUE;
   }
 
   return stub_ApiSetQueryApiSetPresence(aNamespace, aPresent);
 }
 
 static WindowsDllInterceptor Kernel32Intercept;
@@ -96,19 +94,20 @@ static bool EnableHandleCloseMonitoring(
  * interest is not present.
  */
 static void EnableApiQueryInterception() {
   if (!IsWin32kLockedDown()) {
     return;
   }
 
   gApiQueryIntercept.Init(L"Api-ms-win-core-apiquery-l1-1-0.dll");
-  DebugOnly<bool> hookSetOk = stub_ApiSetQueryApiSetPresence.Set(
-      gApiQueryIntercept, "ApiSetQueryApiSetPresence",
-      &patched_ApiSetQueryApiSetPresence);
+  DebugOnly<bool> hookSetOk =
+    stub_ApiSetQueryApiSetPresence.Set(gApiQueryIntercept,
+                                       "ApiSetQueryApiSetPresence",
+                                       &patched_ApiSetQueryApiSetPresence);
   MOZ_ASSERT(hookSetOk);
 }
 
 static bool ShouldDisableHandleVerifier() {
 #if defined(_X86_) && (defined(EARLY_BETA_OR_EARLIER) || defined(DEBUG))
   // Chromium only has the verifier enabled for 32-bit and our close monitoring
   // hooks cause debug assertions for 64-bit anyway.
   // For x86 keep the verifier enabled by default only for Nightly or debug.
--- a/toolkit/components/places/nsNavBookmarks.cpp
+++ b/toolkit/components/places/nsNavBookmarks.cpp
@@ -1758,18 +1758,17 @@ nsNavBookmarks::AddObserver(nsINavBookma
 }
 
 NS_IMETHODIMP
 nsNavBookmarks::RemoveObserver(nsINavBookmarkObserver* aObserver) {
   return mObservers.RemoveWeakElement(aObserver);
 }
 
 NS_IMETHODIMP
-nsNavBookmarks::GetObservers(
-    nsTArray<RefPtr<nsINavBookmarkObserver>>& aObservers) {
+nsNavBookmarks::GetObservers(nsTArray<RefPtr<nsINavBookmarkObserver>>& aObservers) {
   aObservers.Clear();
 
   if (!mCanNotify) return NS_OK;
 
   for (uint32_t i = 0; i < mObservers.Length(); ++i) {
     nsCOMPtr<nsINavBookmarkObserver> observer =
         mObservers.ElementAt(i).GetValue();
     // Skip nullified weak observers.
--- a/toolkit/components/satchel/nsFormFillController.cpp
+++ b/toolkit/components/satchel/nsFormFillController.cpp
@@ -294,18 +294,17 @@ nsFormFillController::MarkAsLoginManager
     if (focusedContent == aInput) {
       if (!mFocusedInput) {
         MaybeStartControllingInput(aInput);
       }
     }
   }
 
   if (!mLoginManagerAC) {
-    mLoginManagerAC =
-        do_GetService("@mozilla.org/login-manager/autocompletesearch;1");
+    mLoginManagerAC = do_GetService("@mozilla.org/login-manager/autocompletesearch;1");
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsFormFillController::MarkAsAutofillField(HTMLInputElement* aInput) {
   /*
@@ -704,29 +703,27 @@ nsFormFillController::StartSearch(const 
       (mPwmgrInputs.Get(mFocusedInput) ||
        mFocusedInput->ControlType() == NS_FORM_INPUT_PASSWORD)) {
     MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch: login field"));
 
     // Handle the case where a password field is focused but
     // MarkAsLoginManagerField wasn't called because password manager is
     // disabled.
     if (!mLoginManagerAC) {
-      mLoginManagerAC =
-          do_GetService("@mozilla.org/login-manager/autocompletesearch;1");
+      mLoginManagerAC = do_GetService("@mozilla.org/login-manager/autocompletesearch;1");
     }
 
     if (NS_WARN_IF(!mLoginManagerAC)) {
       return NS_ERROR_FAILURE;
     }
 
     // XXX aPreviousResult shouldn't ever be a historyResult type, since we're
     // not letting satchel manage the field?
     mLastListener = aListener;
-    rv = mLoginManagerAC->StartSearch(aSearchString, aPreviousResult,
-                                      mFocusedInput, this);
+    rv = mLoginManagerAC->StartSearch(aSearchString, aPreviousResult, mFocusedInput, this);
     NS_ENSURE_SUCCESS(rv, rv);
   } else {
     MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch: non-login field"));
     mLastListener = aListener;
 
     nsCOMPtr<nsIAutoCompleteResult> datalistResult;
     if (mFocusedInput) {
       rv = PerformInputListAutoComplete(aSearchString,
--- a/toolkit/components/sessionstore/SessionStoreListener.cpp
+++ b/toolkit/components/sessionstore/SessionStoreListener.cpp
@@ -512,9 +512,9 @@ void TabListener::RemoveListeners() {
     if (obs) {
       obs->RemoveObserver(this, kTimeOutDisable);
       obs->RemoveObserver(this, kPrefInterval);
       mPrefObserverRegistered = false;
     }
   }
 }
 
-TabListener::~TabListener() { RemoveListeners(); }
+TabListener::~TabListener() { RemoveListeners();}
--- a/toolkit/components/startup/nsAppStartup.cpp
+++ b/toolkit/components/startup/nsAppStartup.cpp
@@ -543,17 +543,17 @@ nsAppStartup::GetWasRestarted(bool* aRes
    * be unset or set to the empty string depending on the underlying platform
    * thus we have to check if the variable is present and not empty. */
   *aResult = mozAppRestart && (strcmp(mozAppRestart, "") != 0);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsAppStartup::GetSecondsSinceLastOSRestart(int64_t* aResult) {
+nsAppStartup::GetSecondsSinceLastOSRestart(int64_t *aResult) {
 #if defined(XP_WIN)
   *aResult = int64_t(GetTickCount64() / 1000ull);
   return NS_OK;
 #elif defined(XP_DARWIN)
   uint64_t absTime = mach_absolute_time();
   mach_timebase_info_data_t timebaseInfo;
   mach_timebase_info(&timebaseInfo);
   double toNanoseconds =
--- a/toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
+++ b/toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
@@ -228,18 +228,17 @@ void GetEncodedOriginStrings(
     JS::RootedObject arrayItemObj(aCx, &arrayItem.toObject());
 
     JS::RootedValue encodingVal(aCx);
     ASSERT_TRUE(JS_GetProperty(aCx, arrayItemObj, "encoding", &encodingVal));
     ASSERT_TRUE(encodingVal.isString());
     nsAutoJSString jsStr;
     ASSERT_TRUE(jsStr.init(aCx, encodingVal));
 
-    nsPrintfCString encoding(aEncoding.get(),
-                             i % TelemetryOrigin::SizeOfPrioDatasPerMetric());
+    nsPrintfCString encoding(aEncoding.get(), i % TelemetryOrigin::SizeOfPrioDatasPerMetric());
     ASSERT_TRUE(NS_ConvertUTF16toUTF8(jsStr) == encoding)
     << "Actual 'encoding' (" << NS_ConvertUTF16toUTF8(jsStr).get()
     << ") must match expected (" << encoding << ")";
 
     JS::RootedValue prioVal(aCx);
     ASSERT_TRUE(JS_GetProperty(aCx, arrayItemObj, "prio", &prioVal));
     ASSERT_TRUE(prioVal.isObject());
     ASSERT_FALSE(prioVal.isNullOrUndefined());
--- a/toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
@@ -30,18 +30,20 @@ static LazyLogModule gUrlClassifierPrefi
 #define LOG(args) \
   MOZ_LOG(gUrlClassifierPrefixSetLog, mozilla::LogLevel::Debug, args)
 #define LOG_ENABLED() \
   MOZ_LOG_TEST(gUrlClassifierPrefixSetLog, mozilla::LogLevel::Debug)
 
 NS_IMPL_ISUPPORTS(nsUrlClassifierPrefixSet, nsIUrlClassifierPrefixSet,
                   nsIMemoryReporter)
 
+
 nsUrlClassifierPrefixSet::nsUrlClassifierPrefixSet()
-    : mLock("nsUrlClassifierPrefixSet.mLock"), mTotalPrefixes(0) {}
+    : mLock("nsUrlClassifierPrefixSet.mLock"),
+      mTotalPrefixes(0) {}
 
 NS_IMETHODIMP
 nsUrlClassifierPrefixSet::Init(const nsACString& aName) {
   mName = aName;
   mMemoryReportPath = nsPrintfCString(
       "explicit/storage/prefix-set/%s",
       (!aName.IsEmpty() ? PromiseFlatCString(aName).get() : "?!"));
 
--- a/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
@@ -486,12 +486,10 @@ TEST_P(UrlClassifierPrefixSetTest, LoadS
     DoExpectedLookup(load, array);
     DoRandomLookup(load, 1000, array);
     CheckContent(load, array);
   }
 
   file->Remove(false);
 }
 
-// To run the same test for different configurations of
-// "browser_safebrowsing_prefixset_max_array_size"
-INSTANTIATE_TEST_CASE_P(UrlClassifierPrefixSetTest, UrlClassifierPrefixSetTest,
-                        ::testing::Values(0, UINT32_MAX));
+// To run the same test for different configurations of "browser_safebrowsing_prefixset_max_array_size"
+INSTANTIATE_TEST_CASE_P(UrlClassifierPrefixSetTest, UrlClassifierPrefixSetTest, ::testing::Values(0, UINT32_MAX));
--- a/toolkit/recordreplay/MemorySnapshot.cpp
+++ b/toolkit/recordreplay/MemorySnapshot.cpp
@@ -165,17 +165,18 @@ struct DirtyPageSet {
 
   // All dirty pages in the set. Pages may be added or destroyed by the main
   // thread when all other threads are idle, by the dirty memory handler when
   // it is active and this is the active page set, and by the snapshot thread
   // which owns this set.
   InfallibleVector<DirtyPage, 256, AllocPolicy<MemoryKind::DirtyPageSet>>
       mPages;
 
-  explicit DirtyPageSet(size_t aCheckpoint) : mCheckpoint(aCheckpoint) {}
+  explicit DirtyPageSet(size_t aCheckpoint)
+      : mCheckpoint(aCheckpoint) {}
 };
 
 // Worklist used by each snapshot thread.
 struct SnapshotThreadWorklist {
   // Index into gMemoryInfo->mSnapshotWorklists of the thread.
   size_t mThreadIndex;
 
   // Record/replay ID of the thread.
--- a/toolkit/recordreplay/ProcessRewind.cpp
+++ b/toolkit/recordreplay/ProcessRewind.cpp
@@ -60,48 +60,51 @@ void InitializeRewindState() {
 
   gMainThreadCallbackMonitor = new Monitor();
 }
 
 void RestoreCheckpointAndResume(size_t aCheckpoint) {
   MOZ_RELEASE_ASSERT(IsReplaying());
   MOZ_RELEASE_ASSERT(Thread::CurrentIsMainThread());
   MOZ_RELEASE_ASSERT(!AreThreadEventsPassedThrough());
-  MOZ_RELEASE_ASSERT(aCheckpoint == gRewindInfo->mLastCheckpoint ||
-                     aCheckpoint < gRewindInfo->mLastCheckpoint);
+  MOZ_RELEASE_ASSERT(
+      aCheckpoint == gRewindInfo->mLastCheckpoint ||
+      aCheckpoint < gRewindInfo->mLastCheckpoint);
 
   // Make sure we don't lose pending main thread callbacks due to rewinding.
   {
     MonitorAutoLock lock(*gMainThreadCallbackMonitor);
     MOZ_RELEASE_ASSERT(gMainThreadCallbacks.empty());
   }
 
   Thread::WaitForIdleThreads();
 
   double start = CurrentTime();
 
   {
     // Rewind heap memory to the target checkpoint, which must have been saved.
     AutoDisallowMemoryChanges disallow;
-    size_t newCheckpoint = gRewindInfo->mSavedCheckpoints.back().mCheckpoint;
+    size_t newCheckpoint =
+        gRewindInfo->mSavedCheckpoints.back().mCheckpoint;
     RestoreMemoryToLastSavedCheckpoint();
     while (aCheckpoint < newCheckpoint) {
       gRewindInfo->mSavedCheckpoints.back().ReleaseContents();
       gRewindInfo->mSavedCheckpoints.popBack();
       RestoreMemoryToLastSavedDiffCheckpoint();
       newCheckpoint = gRewindInfo->mSavedCheckpoints.back().mCheckpoint;
     }
     MOZ_RELEASE_ASSERT(newCheckpoint == aCheckpoint);
   }
 
   FixupFreeRegionsAfterRewind();
 
   double end = CurrentTime();
-  PrintSpew("Restore #%d -> #%d %.2fs\n", (int)gRewindInfo->mLastCheckpoint,
-            (int)aCheckpoint, (end - start) / 1000000.0);
+  PrintSpew("Restore #%d -> #%d %.2fs\n",
+            (int)gRewindInfo->mLastCheckpoint, (int)aCheckpoint,
+            (end - start) / 1000000.0);
 
   // Finally, let threads restore themselves to their stacks at the checkpoint
   // we are rewinding to.
   RestoreAllThreads(gRewindInfo->mSavedCheckpoints.back());
   Unreachable();
 }
 
 void SetSaveCheckpoint(size_t aCheckpoint, bool aSave) {
--- a/toolkit/recordreplay/ThreadSnapshot.h
+++ b/toolkit/recordreplay/ThreadSnapshot.h
@@ -71,17 +71,18 @@ struct SavedThreadStack {
     }
   }
 };
 
 struct SavedCheckpoint {
   size_t mCheckpoint;
   SavedThreadStack mStacks[MaxRecordedThreadId];
 
-  explicit SavedCheckpoint(size_t aCheckpoint) : mCheckpoint(aCheckpoint) {}
+  explicit SavedCheckpoint(size_t aCheckpoint)
+      : mCheckpoint(aCheckpoint) {}
 
   void ReleaseContents() {
     for (SavedThreadStack& stack : mStacks) {
       stack.ReleaseContents();
     }
   }
 };
 
--- a/toolkit/recordreplay/ipc/Channel.cpp
+++ b/toolkit/recordreplay/ipc/Channel.cpp
@@ -219,34 +219,36 @@ void Channel::SendMessage(Message&& aMsg
     MonitorAutoLock lock(mMonitor);
     while (!mInitialized) {
       mMonitor.Wait();
     }
   }
 
   PrintMessage("SendMsg", aMsg);
 
-  if (gSimulatedLatency && gSimulatedBandwidth && mSimulateDelays &&
+  if (gSimulatedLatency &&
+      gSimulatedBandwidth &&
+      mSimulateDelays &&
       MessageSubjectToSimulatedDelay(aMsg.mType)) {
     AutoEnsurePassThroughThreadEvents pt;
 
     // Find the time this message will start sending.
     TimeStamp sendTime = TimeStamp::Now();
     if (sendTime < mAvailableTime) {
       sendTime = mAvailableTime;
     }
 
     // Find the time spent sending the message over the channel.
     size_t sendDurationMs = aMsg.mSize / gSimulatedBandwidth;
     mAvailableTime = sendTime + TimeDuration::FromMilliseconds(sendDurationMs);
 
     // The receive time of the message is the time the message finishes sending
     // plus the connection latency.
     TimeStamp receiveTime =
-        mAvailableTime + TimeDuration::FromMilliseconds(gSimulatedLatency);
+      mAvailableTime + TimeDuration::FromMilliseconds(gSimulatedLatency);
 
     aMsg.mReceiveTime = (receiveTime - mStartTime).ToMilliseconds();
   }
 
   const char* ptr = (const char*)&aMsg;
   size_t nbytes = aMsg.mSize;
   while (nbytes) {
     int rv = HANDLE_EINTR(send(mFd, ptr, nbytes, 0));
@@ -311,17 +313,17 @@ Message::UniquePtr Channel::WaitForMessa
     memmove(mMessageBuffer->begin(), &mMessageBuffer->begin()[messageSize],
             remaining);
   }
   mMessageBytes = remaining;
 
   // If there is a simulated delay on the message, wait until it completes.
   if (res->mReceiveTime) {
     TimeStamp receiveTime =
-        mStartTime + TimeDuration::FromMilliseconds(res->mReceiveTime);
+      mStartTime + TimeDuration::FromMilliseconds(res->mReceiveTime);
     while (receiveTime > TimeStamp::Now()) {
       MonitorAutoLock lock(mMonitor);
       mMonitor.WaitUntil(receiveTime);
     }
   }
 
   PrintMessage("RecvMsg", *res);
   return res;
--- a/toolkit/recordreplay/ipc/Channel.h
+++ b/toolkit/recordreplay/ipc/Channel.h
@@ -104,17 +104,17 @@ struct Message {
   // relative to when the channel was opened.
   uint32_t mReceiveTime;
 
   // Total message size, including the header.
   uint32_t mSize;
 
  protected:
   Message(MessageType aType, uint32_t aSize)
-      : mType(aType), mReceiveTime(0), mSize(aSize) {
+    : mType(aType), mReceiveTime(0), mSize(aSize) {
     MOZ_RELEASE_ASSERT(mSize >= sizeof(*this));
   }
 
  public:
   struct FreePolicy {
     void operator()(Message* msg) { /*free(msg);*/
     }
   };
--- a/toolkit/recordreplay/ipc/ChildIPC.cpp
+++ b/toolkit/recordreplay/ipc/ChildIPC.cpp
@@ -115,19 +115,19 @@ static void ChannelMessageHandler(Messag
       }
       break;
     }
     case MessageType::ManifestStart: {
       const ManifestStartMessage& nmsg = (const ManifestStartMessage&)*aMsg;
       js::CharBuffer* buf = new js::CharBuffer();
       buf->append(nmsg.Buffer(), nmsg.BufferSize());
       PauseMainThreadAndInvokeCallback([=]() {
-        js::ManifestStart(*buf);
-        delete buf;
-      });
+          js::ManifestStart(*buf);
+          delete buf;
+        });
       break;
     }
     case MessageType::MiddlemanCallResponse: {
       MonitorAutoLock lock(*gMonitor);
       MOZ_RELEASE_ASSERT(gWaitingForCallResponse);
       MOZ_RELEASE_ASSERT(!gCallResponseMessage);
       gCallResponseMessage.reset(
           static_cast<MiddlemanCallResponseMessage*>(aMsg.release()));
@@ -145,18 +145,18 @@ static void ChannelMessageHandler(Messag
 // recorded. By communicating between the two threads with a pipe, this
 // thread's behavior will be replicated exactly when replaying and new
 // checkpoints will be created at the same point as during recording.
 static void ListenForCheckpointThreadMain(void*) {
   while (true) {
     uint8_t data = 0;
     ssize_t rv = HANDLE_EINTR(read(gCheckpointReadFd, &data, 1));
     if (rv > 0) {
-      NS_DispatchToMainThread(
-          NewRunnableFunction("NewCheckpoint", NewCheckpoint));
+      NS_DispatchToMainThread(NewRunnableFunction("NewCheckpoint",
+                                                  NewCheckpoint));
     } else {
       MOZ_RELEASE_ASSERT(errno == EIO);
       MOZ_RELEASE_ASSERT(HasDivergedFromRecording());
       Thread::WaitForever();
     }
   }
 }
 
@@ -483,18 +483,18 @@ static void PaintFromMainThread() {
   }
 
   // If all paints have completed, the compositor cannot be simultaneously
   // operating on the draw target buffer.
   MOZ_RELEASE_ASSERT(!gNumPendingPaints);
 
   if (IsMainChild() && gDrawTargetBuffer) {
     memcpy(gGraphicsShmem, gDrawTargetBuffer, gDrawTargetBufferSize);
-    gChannel->SendMessage(
-        PaintMessage(GetLastCheckpoint(), gPaintWidth, gPaintHeight));
+    gChannel->SendMessage(PaintMessage(GetLastCheckpoint(),
+                                       gPaintWidth, gPaintHeight));
   }
 }
 
 void NotifyPaintComplete() {
   MOZ_RELEASE_ASSERT(!gCompositorThreadId ||
                      Thread::Current()->Id() == gCompositorThreadId);
 
   // Notify the main thread in case it is waiting for this paint to complete.
@@ -574,17 +574,17 @@ bool CurrentRepaintCannotFail() {
 
 ///////////////////////////////////////////////////////////////////////////////
 // Message Helpers
 ///////////////////////////////////////////////////////////////////////////////
 
 void ManifestFinished(const js::CharBuffer& aBuffer) {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   ManifestFinishedMessage* msg =
-      ManifestFinishedMessage::New(aBuffer.begin(), aBuffer.length());
+    ManifestFinishedMessage::New(aBuffer.begin(), aBuffer.length());
   PauseMainThreadAndInvokeCallback([=]() {
     gChannel->SendMessage(std::move(*msg));
     free(msg);
   });
 }
 
 void SendMiddlemanCallRequest(const char* aInputData, size_t aInputSize,
                               InfallibleVector<char>* aOutputData) {
--- a/toolkit/recordreplay/ipc/JSControl.cpp
+++ b/toolkit/recordreplay/ipc/JSControl.cpp
@@ -308,17 +308,19 @@ void SetupDevtoolsSandbox() {
   MOZ_RELEASE_ASSERT(gReplay);
 
   gIncludeSystemScripts =
       Preferences::GetBool("devtools.recordreplay.includeSystemScripts");
 
   InitializeScriptHits();
 }
 
-bool IsInitialized() { return !!gReplay; }
+bool IsInitialized() {
+  return !!gReplay;
+}
 
 extern "C" {
 
 MOZ_EXPORT bool RecordReplayInterface_ShouldUpdateProgressCounter(
     const char* aURL) {
   // Progress counters are only updated for scripts which are exposed to the
   // debugger. The devtools timeline is based on progress values and we don't
   // want gaps on the timeline which users can't seek to.
@@ -567,28 +569,28 @@ static bool FetchContent(JSContext* aCx,
 
 static bool RecordReplay_AreThreadEventsDisallowed(JSContext* aCx,
                                                    unsigned aArgc, Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
   args.rval().setBoolean(AreThreadEventsDisallowed());
   return true;
 }
 
-static bool RecordReplay_DivergeFromRecording(JSContext* aCx, unsigned aArgc,
-                                              Value* aVp) {
+static bool RecordReplay_DivergeFromRecording(JSContext* aCx,
+                                              unsigned aArgc, Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
   DivergeFromRecording();
   args.rval().setUndefined();
   return true;
 }
 
 static bool RecordReplay_ProgressCounter(JSContext* aCx, unsigned aArgc,
                                          Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
-  args.rval().setNumber((double)gProgressCounter);
+  args.rval().setNumber((double) gProgressCounter);
   return true;
 }
 
 static bool RecordReplay_AdvanceProgressCounter(JSContext* aCx, unsigned aArgc,
                                                 Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
   AdvanceExecutionProgressCounter();
   args.rval().setUndefined();
@@ -654,17 +656,17 @@ static bool RecordReplay_ResumeExecution
 
   ResumeExecution();
 
   args.rval().setUndefined();
   return true;
 }
 
 static bool RecordReplay_RestoreCheckpoint(JSContext* aCx, unsigned aArgc,
-                                           Value* aVp) {
+                                         Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   if (!args.get(0).isNumber()) {
     JS_ReportErrorASCII(aCx, "Bad checkpoint ID");
     return false;
   }
 
   size_t checkpoint = args.get(0).toNumber();
@@ -758,31 +760,30 @@ static const size_t MaxHitsPerCheckpoint
 
 struct ScriptHitInfo {
   // Information about a location where a script offset has been hit, or an
   // aggregate set of hits.
   struct ScriptHit {
     // The most recent checkpoint prior to the hit.
     uint32_t mCheckpoint;
 
-    // Index of the frame where the hit occurred, or UINT32_MAX if this
-    // represents an aggregate set of hits after the checkpoint.
+    // Index of the frame where the hit occurred, or UINT32_MAX if this represents
+    // an aggregate set of hits after the checkpoint.
     uint32_t mFrameIndex;
 
     // Progress counter when the hit occurred, invalid if this represents an
     // aggregate set of hits.
     ProgressCounter mProgress;
 
     explicit ScriptHit(uint32_t aCheckpoint)
         : mCheckpoint(aCheckpoint), mFrameIndex(UINT32_MAX), mProgress(0) {}
 
     ScriptHit(uint32_t aCheckpoint, uint32_t aFrameIndex,
               ProgressCounter aProgress)
-        : mCheckpoint(aCheckpoint),
-          mFrameIndex(aFrameIndex),
+        : mCheckpoint(aCheckpoint), mFrameIndex(aFrameIndex),
           mProgress(aProgress) {}
   };
 
   struct ScriptHitChunk {
     ScriptHit mHits[7];
     ScriptHitChunk* mPrevious;
   };
 
@@ -795,24 +796,23 @@ struct ScriptHitInfo {
 
     typedef ScriptHitKey Lookup;
 
     static HashNumber hash(const ScriptHitKey& aKey) {
       return HashGeneric(aKey.mScript, aKey.mOffset);
     }
 
     static bool match(const ScriptHitKey& aFirst, const ScriptHitKey& aSecond) {
-      return aFirst.mScript == aSecond.mScript &&
-             aFirst.mOffset == aSecond.mOffset;
+      return aFirst.mScript == aSecond.mScript
+          && aFirst.mOffset == aSecond.mOffset;
     }
   };
 
   typedef HashMap<ScriptHitKey, ScriptHitChunk*, ScriptHitKey,
-                  AllocPolicy<MemoryKind::ScriptHits>>
-      ScriptHitMap;
+                  AllocPolicy<MemoryKind::ScriptHits>> ScriptHitMap;
   ScriptHitMap mTable;
   ScriptHitChunk* mFreeChunk;
 
   ScriptHitInfo() : mFreeChunk(nullptr) {}
 
   ScriptHitChunk* FindHits(uint32_t aScript, uint32_t aOffset) {
     ScriptHitKey key(aScript, aOffset);
     ScriptHitMap::Ptr p = mTable.lookup(key);
@@ -866,17 +866,18 @@ static void InitializeScriptHits() {
   void* mem = AllocateMemory(sizeof(ScriptHitInfo), MemoryKind::ScriptHits);
   gScriptHits = new (mem) ScriptHitInfo();
 }
 
 static bool RecordReplay_AddScriptHit(JSContext* aCx, unsigned aArgc,
                                       Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
-  if (!args.get(0).isNumber() || !args.get(1).isNumber() ||
+  if (!args.get(0).isNumber() ||
+      !args.get(1).isNumber() ||
       !args.get(2).isNumber()) {
     JS_ReportErrorASCII(aCx, "Bad parameters");
     return false;
   }
 
   uint32_t script = args.get(0).toNumber();
   uint32_t offset = args.get(1).toNumber();
   uint32_t frameIndex = args.get(2).toNumber();
@@ -903,22 +904,22 @@ static bool RecordReplay_FindScriptHits(
 
   ScriptHitInfo::ScriptHitChunk* chunk =
       gScriptHits ? gScriptHits->FindHits(script, offset) : nullptr;
   while (chunk) {
     for (const auto& hit : chunk->mHits) {
       if (hit.mCheckpoint) {
         RootedObject hitObject(aCx, JS_NewObject(aCx, nullptr));
         if (!hitObject ||
-            !JS_DefineProperty(aCx, hitObject, "checkpoint", hit.mCheckpoint,
-                               JSPROP_ENUMERATE) ||
+            !JS_DefineProperty(aCx, hitObject, "checkpoint",
+                               hit.mCheckpoint, JSPROP_ENUMERATE) ||
             !JS_DefineProperty(aCx, hitObject, "progress",
-                               (double)hit.mProgress, JSPROP_ENUMERATE) ||
-            !JS_DefineProperty(aCx, hitObject, "frameIndex", hit.mFrameIndex,
-                               JSPROP_ENUMERATE) ||
+                               (double) hit.mProgress, JSPROP_ENUMERATE) ||
+            !JS_DefineProperty(aCx, hitObject, "frameIndex",
+                               hit.mFrameIndex, JSPROP_ENUMERATE) ||
             !values.append(ObjectValue(*hitObject))) {
           return false;
         }
       }
     }
     chunk = chunk->mPrevious;
   }
 
--- a/toolkit/recordreplay/ipc/JSControl.h
+++ b/toolkit/recordreplay/ipc/JSControl.h
@@ -16,17 +16,17 @@
 #include "nsString.h"
 
 namespace mozilla {
 namespace recordreplay {
 
 struct Message;
 
 namespace parent {
-class ChildProcessInfo;
+  class ChildProcessInfo;
 }
 
 namespace js {
 
 // This file manages interactions between the record/replay infrastructure and
 // JS code. This interaction can occur in two ways:
 //
 // - In the middleman process, devtools server code can use the
--- a/toolkit/xre/LauncherRegistryInfo.cpp
+++ b/toolkit/xre/LauncherRegistryInfo.cpp
@@ -100,19 +100,19 @@ LauncherVoidResult LauncherRegistryInfo:
   if (disposition.isErr()) {
     return LAUNCHER_ERROR_FROM_RESULT(disposition);
   }
 
   std::wstring valueName(ResolveTelemetryValueName());
 
   DWORD value = aEnable ? 1UL : 0UL;
   DWORD len = sizeof(value);
-  LSTATUS result =
-      ::RegSetValueExW(mRegKey.get(), valueName.c_str(), 0, REG_DWORD,
-                       reinterpret_cast<PBYTE>(&value), len);
+  LSTATUS result = ::RegSetValueExW(mRegKey.get(), valueName.c_str(), 0,
+                                    REG_DWORD, reinterpret_cast<PBYTE>(&value),
+                                    len);
   if (result != ERROR_SUCCESS) {
     return LAUNCHER_ERROR_FROM_WIN32(result);
   }
 
   return Ok();
 }
 
 LauncherResult<LauncherRegistryInfo::ProcessType> LauncherRegistryInfo::Check(
@@ -438,19 +438,19 @@ LauncherResult<DWORD> LauncherRegistryIn
 }
 
 LauncherResult<bool> LauncherRegistryInfo::GetTelemetrySetting() {
   std::wstring telemetryValueName = ResolveTelemetryValueName();
 
   DWORD value;
   DWORD valueLen = sizeof(value);
   DWORD type;
-  LSTATUS result =
-      ::RegQueryValueExW(mRegKey.get(), telemetryValueName.c_str(), nullptr,
-                         &type, reinterpret_cast<PBYTE>(&value), &valueLen);
+  LSTATUS result = ::RegQueryValueExW(
+      mRegKey.get(), telemetryValueName.c_str(), nullptr, &type,
+      reinterpret_cast<PBYTE>(&value), &valueLen);
   if (result == ERROR_FILE_NOT_FOUND) {
     // Value does not exist, treat as false
     return false;
   }
 
   if (result != ERROR_SUCCESS) {
     return LAUNCHER_ERROR_FROM_WIN32(result);
   }
--- a/toolkit/xre/LauncherRegistryInfo.h
+++ b/toolkit/xre/LauncherRegistryInfo.h
@@ -38,19 +38,19 @@ class LauncherRegistryInfo final {
   };
 
   LauncherRegistryInfo() : mBinPath(GetFullBinaryPath().get()) {}
 
   LauncherVoidResult ReflectPrefToRegistry(const bool aEnable);
   LauncherResult<EnabledState> IsEnabled();
   LauncherResult<bool> IsTelemetryEnabled();
   LauncherVoidResult ReflectTelemetryPrefToRegistry(const bool aEnable);
-  LauncherResult<ProcessType> Check(
-      const ProcessType aDesiredType,
-      const CheckOption aOption = CheckOption::Default);
+  LauncherResult<ProcessType> Check(const ProcessType aDesiredType,
+                                    const CheckOption aOption =
+                                      CheckOption::Default);
   LauncherVoidResult DisableDueToFailure();
 
  private:
   enum class Disposition { CreatedNew, OpenedExisting };
 
  private:
   LauncherResult<Disposition> Open();
   LauncherVoidResult WriteStartTimestamp(
--- a/uriloader/exthandler/nsExternalProtocolHandler.cpp
+++ b/uriloader/exthandler/nsExternalProtocolHandler.cpp
@@ -402,17 +402,17 @@ NS_IMETHODIMP nsExtProtocolChannel::Noti
 NS_IMETHODIMP nsExtProtocolChannel::SetClassifierMatchedInfo(
     const nsACString& aList, const nsACString& aProvider,
     const nsACString& aFullHash) {
   // nothing to do
   return NS_OK;
 }
 
 NS_IMETHODIMP nsExtProtocolChannel::SetClassifierMatchedTrackingInfo(
-    const nsACString& aLists, const nsACString& aFullHashes) {
+    const nsACString &aLists, const nsACString &aFullHashes) {
   // nothing to do
   return NS_OK;
 }
 
 NS_IMETHODIMP nsExtProtocolChannel::NotifyClassificationFlags(
     uint32_t aClassificationFlags, bool aIsThirdParty) {
   // nothing to do
   return NS_OK;
--- a/widget/cocoa/GfxInfo.mm
+++ b/widget/cocoa/GfxInfo.mm
@@ -231,28 +231,27 @@ void GfxInfo::AddCrashReportAnnotations(
 
   CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterVendorID, narrowVendorID);
   CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterDeviceID, narrowDeviceID);
   CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterDriverVersion,
                                      narrowDriverVersion);
 }
 
 // We don't support checking driver versions on Mac.
-#define IMPLEMENT_MAC_DRIVER_BLOCKLIST(os, vendor, driverVendor, device, features, blockOn, \
-                                       ruleId)                                              \
-  APPEND_TO_DRIVER_BLOCKLIST(os, vendor, driverVendor, device, features, blockOn,           \
-                             DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0), ruleId, "")
+#define IMPLEMENT_MAC_DRIVER_BLOCKLIST(os, vendor, driverVendor, device, features, blockOn, ruleId)          \
+  APPEND_TO_DRIVER_BLOCKLIST(os, vendor, driverVendor, device, features, blockOn, DRIVER_COMPARISON_IGNORED, \
+                             V(0, 0, 0, 0), ruleId, "")
 
 const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
   if (!sDriverInfo->Length()) {
     IMPLEMENT_MAC_DRIVER_BLOCKLIST(
         OperatingSystem::OSX, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
-        (nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll), GfxDriverInfo::allDevices,
-        nsIGfxInfo::FEATURE_WEBGL_MSAA, nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION,
-        "FEATURE_FAILURE_MAC_ATI_NO_MSAA");
+        (nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
+        GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBGL_MSAA,
+        nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION, "FEATURE_FAILURE_MAC_ATI_NO_MSAA");
     IMPLEMENT_MAC_DRIVER_BLOCKLIST(
         OperatingSystem::OSX, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
         (nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
         (GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(RadeonX1000),
         nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
         "FEATURE_FAILURE_MAC_RADEONX1000_NO_TEXTURE2D");
     IMPLEMENT_MAC_DRIVER_BLOCKLIST(
         OperatingSystem::OSX, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
--- a/widget/gtk/nsWindow.cpp
+++ b/widget/gtk/nsWindow.cpp
@@ -4237,18 +4237,17 @@ LayoutDeviceIntSize nsWindow::GetSafeWin
   // reads it as CARD16.  Sizes of pixmaps, used for drawing, are (unsigned)
   // CARD16 in the protocol, but the server's ProcCreatePixmap returns
   // BadAlloc if dimensions cannot be represented by signed shorts.
   // Because we are creating Cairo surfaces to represent window buffers,
   // we also must ensure that the window can fit in a Cairo surface.
   LayoutDeviceIntSize result = aSize;
   int32_t maxSize = 32767;
   if (mLayerManager && mLayerManager->AsKnowsCompositor()) {
-    maxSize = std::min(maxSize,
-                       mLayerManager->AsKnowsCompositor()->GetMaxTextureSize());
+    maxSize = std::min(maxSize, mLayerManager->AsKnowsCompositor()->GetMaxTextureSize());
   }
   if (result.width > maxSize) {
     result.width = maxSize;
   }
   if (result.height > maxSize) {
     result.height = maxSize;
   }
   return result;
--- a/xpcom/base/CycleCollectedJSRuntime.cpp
+++ b/xpcom/base/CycleCollectedJSRuntime.cpp
@@ -88,17 +88,17 @@
 #include "nsStringBuffer.h"
 #include "GeckoProfiler.h"
 
 #ifdef MOZ_GECKO_PROFILER
 #  include "ProfilerMarkerPayload.h"
 #endif
 
 #if defined(XP_MACOSX)
-#  include "nsMacUtilsImpl.h"
+# include "nsMacUtilsImpl.h"
 #endif
 
 #include "nsIException.h"
 #include "nsThread.h"
 #include "nsThreadUtils.h"
 #include "xpcpublic.h"
 
 #ifdef NIGHTLY_BUILD
--- a/xpcom/base/nsMacUtilsImpl.h
+++ b/xpcom/base/nsMacUtilsImpl.h
@@ -50,17 +50,21 @@ class nsMacUtilsImpl final : public nsIM
 
 #if defined(MOZ_SANDBOX)
   // Cache the appDir returned from GetAppPath to avoid doing I/O
   static StaticAutoPtr<nsCString> sCachedAppPath;
   // For thread safe setting/checking of sCachedAppPath
   static StaticMutex sCachedAppPathMutex;
 #endif
 
-  enum TCSMStatus { TCSM_Unknown = 0, TCSM_Available, TCSM_Unavailable };
+  enum TCSMStatus {
+    TCSM_Unknown = 0,
+    TCSM_Available,
+    TCSM_Unavailable
+  };
   static mozilla::Atomic<nsMacUtilsImpl::TCSMStatus> sTCSMStatus;
 
   static nsresult EnableTCSM();
 #if defined(DEBUG)
   static bool IsTCSMEnabled();
 #endif
 };
 
--- a/xpcom/base/nsSystemInfo.cpp
+++ b/xpcom/base/nsSystemInfo.cpp
@@ -163,23 +163,22 @@ nsresult GetHDDInfo(const char* aSpecial
     }
   }
 
   if (isSSD) {
     // Get Seek Penalty
     queryParameters.PropertyId = StorageDeviceSeekPenaltyProperty;
     bytesRead = 0;
     DEVICE_SEEK_PENALTY_DESCRIPTOR seekPenaltyDescriptor = {
-        sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR)};
-    if (::DeviceIoControl(handle, IOCTL_STORAGE_QUERY_PROPERTY,
-                          &queryParameters, sizeof(queryParameters),
-                          &seekPenaltyDescriptor, sizeof(seekPenaltyDescriptor),
-                          &bytesRead, nullptr)) {
-      // It is possible that the disk has TrimEnabled, but also
-      // IncursSeekPenalty; In this case, this is an HDD
+      sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR)};
+    if (::DeviceIoControl(handle, IOCTL_STORAGE_QUERY_PROPERTY, &queryParameters,
+          sizeof(queryParameters), &seekPenaltyDescriptor,
+          sizeof(seekPenaltyDescriptor), &bytesRead, nullptr)) {
+      // It is possible that the disk has TrimEnabled, but also IncursSeekPenalty;
+      // In this case, this is an HDD
       if (seekPenaltyDescriptor.IncursSeekPenalty) {
         isSSD = false;
       }
     }
   }
 
   // Some HDDs are including product ID info in the vendor field. Since PNP
   // IDs include vendor info and product ID concatenated together, we'll do
--- a/xpcom/io/nsLocalFileWin.cpp
+++ b/xpcom/io/nsLocalFileWin.cpp
@@ -1690,22 +1690,22 @@ nsresult nsLocalFile::CopySingleFile(nsI
   if (!copyOK && (!move || GetLastError() == ERROR_NOT_SAME_DEVICE)) {
     // Failed renames here should just return access denied.
     if (move && (aOptions & Rename)) {
       return NS_ERROR_FILE_ACCESS_DENIED;
     }
 
     // Pass the flag COPY_FILE_NO_BUFFERING to CopyFileEx as we may be copying
     // to a SMBV2 remote drive. Without this parameter subsequent append mode
-    // file writes can cause the resultant file to become corrupt. We only need
-    // to do this if the major version of Windows is > 5(Only Windows Vista and
-    // above can support SMBV2).  With a 7200RPM hard drive: Copying a 1KB file
-    // with COPY_FILE_NO_BUFFERING takes about 30-60ms. Copying a 1KB file
-    // without COPY_FILE_NO_BUFFERING takes < 1ms. So we only use
-    // COPY_FILE_NO_BUFFERING when we have a remote drive.
+    // file writes can cause the resultant file to become corrupt. We only need to
+    // do this if the major version of Windows is > 5(Only Windows Vista and above
+    // can support SMBV2).  With a 7200RPM hard drive:
+    // Copying a 1KB file with COPY_FILE_NO_BUFFERING takes about 30-60ms.
+    // Copying a 1KB file without COPY_FILE_NO_BUFFERING takes < 1ms.
+    // So we only use COPY_FILE_NO_BUFFERING when we have a remote drive.
     DWORD dwCopyFlags = COPY_FILE_ALLOW_DECRYPTED_DESTINATION;
     bool path1Remote, path2Remote;
     if (!IsRemoteFilePath(filePath.get(), path1Remote) ||
         !IsRemoteFilePath(destPath.get(), path2Remote) || path1Remote ||
         path2Remote) {
       dwCopyFlags |= COPY_FILE_NO_BUFFERING;
     }
 
--- a/xpcom/threads/PrioritizedEventQueue.cpp
+++ b/xpcom/threads/PrioritizedEventQueue.cpp
@@ -9,19 +9,20 @@
 #include "mozilla/ScopeExit.h"
 #include "mozilla/StaticPrefs.h"
 #include "nsThreadManager.h"
 #include "nsXPCOMPrivate.h"  // for gXPCOMThreadsShutDown
 #include "InputEventStatistics.h"
 
 using namespace mozilla;
 
-void PrioritizedEventQueue::PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
-                                     EventQueuePriority aPriority,
-                                     const MutexAutoLock& aProofOfLock) {
+void PrioritizedEventQueue::PutEvent(
+    already_AddRefed<nsIRunnable>&& aEvent, EventQueuePriority aPriority,
+    const MutexAutoLock& aProofOfLock) {
+
   // Double check the priority with a QI.
   RefPtr<nsIRunnable> event(aEvent);
   EventQueuePriority priority = aPriority;
 
   if (priority == EventQueuePriority::Input &&
       mInputQueueState == STATE_DISABLED) {
     priority = EventQueuePriority::Normal;
   } else if (priority == EventQueuePriority::MediumHigh &&
@@ -250,28 +251,30 @@ already_AddRefed<nsIRunnable> Prioritize
     // in ProcessNextEvent.
     *mNextIdleDeadline = idleDeadline;
 #endif
   }
 
   return event.forget();
 }
 
-bool PrioritizedEventQueue::IsEmpty(const MutexAutoLock& aProofOfLock) {
+bool PrioritizedEventQueue::IsEmpty(
+    const MutexAutoLock& aProofOfLock) {
   // Just check IsEmpty() on the sub-queues. Don't bother checking the idle
   // deadline since that only determines whether an idle event is ready or not.
   return mHighQueue->IsEmpty(aProofOfLock) &&
          mInputQueue->IsEmpty(aProofOfLock) &&
          mMediumHighQueue->IsEmpty(aProofOfLock) &&
          mNormalQueue->IsEmpty(aProofOfLock) &&
          mDeferredTimersQueue->IsEmpty(aProofOfLock) &&
          mIdleQueue->IsEmpty(aProofOfLock);
 }
 
-bool PrioritizedEventQueue::HasReadyEvent(const MutexAutoLock& aProofOfLock) {
+bool PrioritizedEventQueue::HasReadyEvent(
+    const MutexAutoLock& aProofOfLock) {
   mHasPendingEventsPromisedIdleEvent = false;
 
   EventQueuePriority queue = SelectQueue(false, aProofOfLock);
 
   if (queue == EventQueuePriority::High) {
     return mHighQueue->HasReadyEvent(aProofOfLock);
   } else if (queue == EventQueuePriority::Input) {
     return mInputQueue->HasReadyEvent(aProofOfLock);
@@ -301,17 +304,18 @@ bool PrioritizedEventQueue::HasReadyEven
   return false;
 }
 
 bool PrioritizedEventQueue::HasPendingHighPriorityEvents(
     const MutexAutoLock& aProofOfLock) {
   return !mHighQueue->IsEmpty(aProofOfLock);
 }
 
-size_t PrioritizedEventQueue::Count(const MutexAutoLock& aProofOfLock) const {
+size_t PrioritizedEventQueue::Count(
+    const MutexAutoLock& aProofOfLock) const {
   MOZ_CRASH("unimplemented");
 }
 
 void PrioritizedEventQueue::EnableInputEventPrioritization(
     const MutexAutoLock& aProofOfLock) {
   MOZ_ASSERT(mInputQueueState == STATE_DISABLED);
   mInputQueueState = STATE_ENABLED;
   mInputHandlingStartTime = TimeStamp();
--- a/xpcom/threads/ThrottledEventQueue.cpp
+++ b/xpcom/threads/ThrottledEventQueue.cpp
@@ -124,18 +124,18 @@ class ThrottledEventQueue::Inner final :
   explicit Inner(nsISerialEventTarget* aBaseTarget, const char* aName,
                  uint32_t aPriority)
       : mMutex("ThrottledEventQueue"),
         mIdleCondVar(mMutex, "ThrottledEventQueue:Idle"),
         mBaseTarget(aBaseTarget),
         mName(aName),
         mPriority(aPriority),
         mIsPaused(false) {
-    MOZ_ASSERT(mName, "Must pass a valid name!");
-  }
+          MOZ_ASSERT(mName, "Must pass a valid name!");
+        }
 
   ~Inner() {
 #ifdef DEBUG
     MutexAutoLock lock(mMutex);
 
     // As long as an executor exists, it had better keep us alive, since it's
     // going to call ExecuteRunnable on us.
     MOZ_ASSERT(!mExecutor);
@@ -249,17 +249,18 @@ class ThrottledEventQueue::Inner final :
     }
 
     // Execute the event now that we have unlocked.
     Unused << event->Run();
   }
 
  public:
   static already_AddRefed<Inner> Create(nsISerialEventTarget* aBaseTarget,
-                                        const char* aName, uint32_t aPriority) {
+                                        const char* aName,
+                                        uint32_t aPriority) {
     MOZ_ASSERT(NS_IsMainThread());
     MOZ_ASSERT(ClearOnShutdown_Internal::sCurrentShutdownPhase ==
                ShutdownPhase::NotInShutdown);
 
     RefPtr<Inner> ref = new Inner(aBaseTarget, aName, aPriority);
     return ref.forget();
   }
 
--- a/xpcom/threads/ThrottledEventQueue.h
+++ b/xpcom/threads/ThrottledEventQueue.h
@@ -63,17 +63,18 @@ class ThrottledEventQueue final : public
   RefPtr<Inner> mInner;
 
   explicit ThrottledEventQueue(already_AddRefed<Inner> aInner);
   ~ThrottledEventQueue() = default;
 
  public:
   // Create a ThrottledEventQueue for the given target.
   static already_AddRefed<ThrottledEventQueue> Create(
-      nsISerialEventTarget* aBaseTarget, const char* aName,
+      nsISerialEventTarget* aBaseTarget,
+      const char* aName,
       uint32_t aPriority = nsIRunnablePriority::PRIORITY_NORMAL);
 
   // Determine if there are any events pending in the queue.
   bool IsEmpty() const;
 
   // Determine how many events are pending in the queue.
   uint32_t Length() const;