Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan default tip
authorSylvestre Ledru <sledru@mozilla.com>
Sat, 25 May 2019 17:46:15 +0000
changeset 475580 edbf8267dd4f5a786ae660ff9e2fe890cf74c48e
parent 475579 60dca41daf70de78be31d4a45fc6b61404c53ddc
push id36063
push userdvarga@mozilla.com
push dateSat, 25 May 2019 21:38:40 +0000
treeherdermozilla-central@edbf8267dd4f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1519636
milestone69.0a1
first release with
nightly linux32
edbf8267dd4f / 69.0a1 / 20190525213840 / files
nightly linux64
edbf8267dd4f / 69.0a1 / 20190525213840 / files
nightly mac
edbf8267dd4f / 69.0a1 / 20190525213840 / files
nightly win32
edbf8267dd4f / 69.0a1 / 20190525213840 / files
nightly win64
edbf8267dd4f / 69.0a1 / 20190525213840 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D30883
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/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/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
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
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,17 +333,18 @@ 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,18 +44,17 @@ 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
@@ -805,19 +805,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
@@ -7022,17 +7022,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,18 +54,19 @@ 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,19 +8,20 @@
 
 #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);
@@ -32,18 +33,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);
@@ -73,32 +74,31 @@ 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,23 +76,21 @@ 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,20 +4175,19 @@ 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,17 +137,19 @@ 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,40 +612,41 @@ 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,17 +42,18 @@ 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,19 +226,17 @@ 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,19 +11,20 @@
 #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,19 +50,17 @@ 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/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,28 +969,33 @@ 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,18 +340,17 @@ 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,18 +21,17 @@
 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,18 +38,17 @@ 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,19 +61,17 @@ 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,17 +168,18 @@ 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,19 +160,21 @@ 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,18 +839,17 @@ 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);
@@ -2120,18 +2119,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,17 +305,18 @@ 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 {
@@ -2173,20 +2174,19 @@ 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,19 +761,17 @@ 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,25 +136,23 @@ 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,16 +585,17 @@ 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,18 +661,17 @@ 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
@@ -813,19 +812,21 @@ 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,17 +220,16 @@ 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,17 +446,18 @@ 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,18 +327,19 @@ 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;
@@ -353,19 +354,18 @@ 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,18 +135,17 @@ 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,18 +1758,17 @@ 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];
@@ -1855,30 +1854,29 @@ 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/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,18 +124,17 @@ 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,17 +425,20 @@ 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,
@@ -1156,18 +1159,17 @@ 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,52 +64,56 @@ 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/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,18 +125,19 @@ 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) {
@@ -222,17 +223,19 @@ 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
@@ -1196,18 +1199,17 @@ 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,17 +3748,18 @@ 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,18 +1148,17 @@ 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,28 +310,27 @@ 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,27 +1027,26 @@ 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,17 +166,18 @@ 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,21 +50,23 @@ 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
@@ -1229,17 +1229,18 @@ 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,17 +1613,16 @@ 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,52 +40,51 @@ 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,17 +827,22 @@ 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(),
+                             // clang-format off
+                             Api-ms-win-core-apiquery-l1-1-0.dll,
+                             // clang-format on
+                             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,18 +70,22 @@ 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,19 +1138,18 @@ 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,16 +8,15 @@
 #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,19 +26,21 @@ 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,27 +43,29 @@ 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;
@@ -94,20 +96,19 @@ 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,17 +1758,18 @@ 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,17 +294,18 @@ 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) {
   /*
@@ -703,27 +704,29 @@ 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,17 +228,18 @@ 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,20 +30,18 @@ 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,10 +486,12 @@ 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,18 +165,17 @@ 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,51 +60,48 @@ 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,18 +71,17 @@ 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,36 +219,34 @@ 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));
@@ -313,17 +311,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,19 +308,17 @@ 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.
@@ -569,28 +567,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();
@@ -656,17 +654,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();
@@ -760,30 +758,31 @@ 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;
   };
 
@@ -796,23 +795,24 @@ 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,18 +866,17 @@ 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();
@@ -904,22 +903,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,27 +231,28 @@ 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/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,21 +50,17 @@ 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,22 +163,23 @@ 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,20 +9,19 @@
 #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 &&
@@ -251,30 +250,28 @@ 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);
@@ -304,18 +301,17 @@ 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,18 +249,17 @@ 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,18 +63,17 @@ 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;