Bug 1519636 - Automatically reformat recent changes using clang-format r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Tue, 21 Jan 2020 09:51:27 +0000
changeset 510897 b990267ff717548430ce2debf26f1812e36a38da
parent 510896 d7e6814835fe00e57019186b0e2f01eb9a63455a
child 510898 5f9acc76d590208bfd6c7626c0eab0a73ddc867d
push id37041
push usershindli@mozilla.com
push dateTue, 21 Jan 2020 16:14:08 +0000
treeherdermozilla-central@875ae8e3ce6f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1519636
milestone74.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1519636 - Automatically reformat recent changes using clang-format r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D60354
docshell/base/ChildProcessChannelListener.h
dom/base/CustomElementRegistry.cpp
dom/base/nsDOMNavigationTiming.h
dom/base/nsFrameLoader.cpp
dom/base/nsIStyleSheetLinkingElement.h
dom/base/nsJSUtils.h
dom/broadcastchannel/BroadcastChannelService.cpp
dom/canvas/WebGLTypes.h
dom/html/HTMLInputElement.cpp
dom/ipc/WindowGlobalParent.cpp
dom/localstorage/ActorsParent.cpp
dom/workers/RuntimeService.cpp
dom/workers/WorkerPrivate.cpp
editor/libeditor/ChangeStyleTransaction.cpp
extensions/spellcheck/src/mozInlineSpellWordUtil.cpp
gfx/layers/apz/src/AsyncPanZoomController.cpp
gfx/layers/apz/src/AsyncPanZoomController.h
gfx/layers/ipc/ContentCompositorBridgeParent.cpp
gfx/thebes/gfxWindowsNativeDrawing.h
gfx/vr/external_api/moz_external_vr.h
gfx/webrender_bindings/DCLayerTree.cpp
js/src/builtin/streams/MiscellaneousOperations-inl.h
js/src/builtin/streams/PipeToState.h
js/src/builtin/streams/ReadableStreamDefaultControllerOperations.cpp
js/src/builtin/streams/ReadableStreamInternals.cpp
js/src/builtin/streams/ReadableStreamOperations.cpp
js/src/builtin/streams/ReadableStreamReader.cpp
js/src/builtin/streams/TeeState.cpp
js/src/builtin/streams/TeeState.h
js/src/builtin/streams/WritableStreamDefaultControllerOperations.cpp
js/src/builtin/streams/WritableStreamDefaultWriter.cpp
js/src/builtin/streams/WritableStreamOperations.cpp
js/src/builtin/streams/WritableStreamWriterOperations.cpp
js/src/debugger/Object.cpp
js/src/gc/Heap.h
js/src/jsapi.cpp
js/src/vm/Interpreter.cpp
js/src/vm/JSContext.cpp
js/src/vm/ToSource.cpp
layout/base/nsCounterManager.cpp
layout/base/nsCounterManager.h
layout/build/nsContentDLF.cpp
layout/forms/nsTextControlFrame.h
layout/generic/nsFrame.cpp
layout/style/CSSFontFaceRule.h
layout/style/nsComputedDOMStyle.cpp
layout/style/nsComputedDOMStyle.h
layout/style/nsDOMCSSDeclaration.cpp
layout/style/nsICSSDeclaration.h
layout/style/nsStyleConsts.h
mfbt/Utf8.h
modules/libpref/Preferences.cpp
mozglue/tests/interceptor/TestIATPatcher.cpp
netwerk/cache2/CacheFile.cpp
netwerk/cache2/CacheFileIOManager.cpp
netwerk/cache2/CacheIndex.cpp
netwerk/cache2/CacheIndex.h
netwerk/protocol/http/Http3Session.cpp
netwerk/protocol/http/nsHttpAuthCache.h
netwerk/protocol/http/nsHttpHandler.h
parser/htmlparser/nsExpatDriver.cpp
toolkit/recordreplay/Assembler.cpp
toolkit/recordreplay/Assembler.h
toolkit/recordreplay/ExternalCall.cpp
toolkit/recordreplay/ExternalCall.h
toolkit/recordreplay/ProcessRecordReplay.cpp
toolkit/recordreplay/ProcessRedirect.cpp
toolkit/recordreplay/ProcessRedirect.h
toolkit/recordreplay/ProcessRedirectDarwin.cpp
toolkit/recordreplay/ProcessRewind.cpp
toolkit/recordreplay/Recording.cpp
toolkit/recordreplay/Recording.h
toolkit/recordreplay/Thread.cpp
toolkit/recordreplay/Thread.h
toolkit/recordreplay/ThreadSnapshot.cpp
toolkit/recordreplay/ipc/Channel.cpp
toolkit/recordreplay/ipc/Channel.h
toolkit/recordreplay/ipc/ChildIPC.cpp
toolkit/recordreplay/ipc/ChildInternal.h
toolkit/recordreplay/ipc/ChildProcess.cpp
toolkit/recordreplay/ipc/JSControl.cpp
toolkit/recordreplay/ipc/ParentIPC.cpp
toolkit/xre/glxtest.cpp
widget/gtk/nsLookAndFeel.cpp
widget/windows/nsWindowBase.cpp
xpcom/base/CycleCollectedJSContext.cpp
xpcom/base/CycleCollectedJSContext.h
xpcom/base/Logging.cpp
--- a/docshell/base/ChildProcessChannelListener.h
+++ b/docshell/base/ChildProcessChannelListener.h
@@ -15,19 +15,19 @@
 #include "nsIChannel.h"
 
 namespace mozilla {
 namespace dom {
 
 class ChildProcessChannelListener final {
   NS_INLINE_DECL_REFCOUNTING(ChildProcessChannelListener)
 
-  using Callback = std::function<void(nsIChannel*,
-                                      nsTArray<net::DocumentChannelRedirect>&&,
-                                      uint32_t, nsDOMNavigationTiming*)>;
+  using Callback =
+      std::function<void(nsIChannel*, nsTArray<net::DocumentChannelRedirect>&&,
+                         uint32_t, nsDOMNavigationTiming*)>;
 
   void RegisterCallback(uint64_t aIdentifier, Callback&& aCallback);
 
   void OnChannelReady(nsIChannel* aChannel, uint64_t aIdentifier,
                       nsTArray<net::DocumentChannelRedirect>&& aRedirects,
                       uint32_t aLoadStateLoadFlags,
                       nsDOMNavigationTiming* aTiming);
 
--- a/dom/base/CustomElementRegistry.cpp
+++ b/dom/base/CustomElementRegistry.cpp
@@ -596,17 +596,18 @@ nsTArray<nsCOMPtr<Element>> CandidateFin
 void CustomElementRegistry::UpgradeCandidates(
     nsAtom* aKey, CustomElementDefinition* aDefinition, ErrorResult& aRv) {
   DocGroup* docGroup = mWindow->GetDocGroup();
   if (!docGroup) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
     return;
   }
 
-  mozilla::UniquePtr<nsTHashtable<nsRefPtrHashKey<nsIWeakReference>>> candidates;
+  mozilla::UniquePtr<nsTHashtable<nsRefPtrHashKey<nsIWeakReference>>>
+      candidates;
   if (mCandidatesMap.Remove(aKey, &candidates)) {
     MOZ_ASSERT(candidates);
     CustomElementReactionsStack* reactionsStack =
         docGroup->CustomElementReactionsStack();
 
     CandidateFinder finder(*candidates, mWindow->GetExtantDoc());
     for (auto& elem : finder.OrderedCandidates()) {
       reactionsStack->EnqueueUpgradeReaction(elem, aDefinition);
--- a/dom/base/nsDOMNavigationTiming.h
+++ b/dom/base/nsDOMNavigationTiming.h
@@ -186,18 +186,18 @@ class nsDOMNavigationTiming final : publ
 
   void Clear();
 
   mozilla::TimeStamp GetUnloadEventStartTimeStamp() const;
   mozilla::TimeStamp GetUnloadEventEndTimeStamp() const;
 
   bool IsTopLevelContentDocumentInContentProcess() const;
 
-// Should those be amended, the IPC serializer should be updated
-// accordingly.
+  // Should those be amended, the IPC serializer should be updated
+  // accordingly.
   mozilla::WeakPtr<nsDocShell> mDocShell;
 
   nsCOMPtr<nsIURI> mUnloadedURI;
   nsCOMPtr<nsIURI> mLoadedURI;
   nsCOMPtr<nsITimer> mTTITimer;
 
   Type mNavigationType;
   DOMHighResTimeStamp mNavigationStartHighRes;
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -880,17 +880,17 @@ bool nsFrameLoader::Show(nsSubDocumentFr
   nsDocShell* ds = GetDocShell();
   MOZ_ASSERT(ds, "MaybeCreateDocShell succeeded, but null docShell");
   if (!ds) {
     return false;
   }
 
   ds->SetScrollbarPreference(GetScrollbarPreference(mOwnerContent));
   const bool marginsChanged =
-    ds->UpdateFrameMargins(GetMarginAttributes(mOwnerContent));
+      ds->UpdateFrameMargins(GetMarginAttributes(mOwnerContent));
   if (PresShell* presShell = ds->GetPresShell()) {
     // Ensure root scroll frame is reflowed in case margins have changed
     if (marginsChanged) {
       if (nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame()) {
         presShell->FrameNeedsReflow(rootScrollFrame, IntrinsicDirty::Resize,
                                     NS_FRAME_IS_DIRTY);
       }
     }
--- a/dom/base/nsIStyleSheetLinkingElement.h
+++ b/dom/base/nsIStyleSheetLinkingElement.h
@@ -104,20 +104,18 @@ class nsIStyleSheetLinkingElement : publ
     bool mIsInline;
     IsExplicitlyEnabled mIsExplicitlyEnabled;
 
     SheetInfo(const mozilla::dom::Document&, nsIContent*,
               already_AddRefed<nsIURI> aURI,
               already_AddRefed<nsIPrincipal> aTriggeringPrincipal,
               already_AddRefed<nsIReferrerInfo> aReferrerInfo,
               mozilla::CORSMode, const nsAString& aTitle,
-              const nsAString& aMedia,
-              const nsAString& aIntegrity,
-              const nsAString& aNonce,
-              HasAlternateRel, IsInline,
+              const nsAString& aMedia, const nsAString& aIntegrity,
+              const nsAString& aNonce, HasAlternateRel, IsInline,
               IsExplicitlyEnabled);
 
     ~SheetInfo();
   };
 
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ISTYLESHEETLINKINGELEMENT_IID)
 
   /**
--- a/dom/base/nsJSUtils.h
+++ b/dom/base/nsJSUtils.h
@@ -246,17 +246,18 @@ class nsJSUtils {
   static bool DumpEnabled();
 };
 
 inline void AssignFromStringBuffer(nsStringBuffer* buffer, size_t len,
                                    nsAString& dest) {
   buffer->ToString(len, dest);
 }
 
-template <typename T, typename std::enable_if_t<std::is_same<typename T::char_type, char16_t>::value>* = nullptr>
+template <typename T, typename std::enable_if_t<std::is_same<
+                          typename T::char_type, char16_t>::value>* = nullptr>
 inline bool AssignJSString(JSContext* cx, T& dest, JSString* s) {
   size_t len = JS::GetStringLength(s);
   static_assert(js::MaxStringLength < (1 << 30),
                 "Shouldn't overflow here or in SetCapacity");
 
   const char16_t* chars;
   if (XPCStringConvert::MaybeGetDOMStringChars(s, &chars)) {
     // The characters represent an existing string buffer that we shared with
@@ -280,17 +281,18 @@ inline bool AssignJSString(JSContext* cx
   if (MOZ_UNLIKELY(!dest.SetLength(len, mozilla::fallible))) {
     JS_ReportOutOfMemory(cx);
     return false;
   }
   return js::CopyStringChars(cx, dest.BeginWriting(), s, len);
 }
 
 // Specialization for UTF8String.
-template <typename T, typename std::enable_if_t<std::is_same<typename T::char_type, char>::value>* = nullptr>
+template <typename T, typename std::enable_if_t<std::is_same<
+                          typename T::char_type, char>::value>* = nullptr>
 inline bool AssignJSString(JSContext* cx, T& dest, JSString* s) {
   using namespace mozilla;
   CheckedInt<size_t> bufLen(JS::GetStringLength(s));
   // From the contract for JS_EncodeStringToUTF8BufferPartial, to guarantee that
   // the whole string is converted.
   if (js::StringHasLatin1Chars(s)) {
     bufLen *= 2;
   } else {
--- a/dom/broadcastchannel/BroadcastChannelService.cpp
+++ b/dom/broadcastchannel/BroadcastChannelService.cpp
@@ -54,20 +54,19 @@ BroadcastChannelService::GetOrCreate() {
   return instance.forget();
 }
 
 void BroadcastChannelService::RegisterActor(
     BroadcastChannelParent* aParent, const nsAString& aOriginChannelKey) {
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(aParent);
 
-  const auto& parents =
-      mAgents.LookupForAdd(aOriginChannelKey).OrInsert([]() {
-        return new nsTArray<BroadcastChannelParent*>();
-      });
+  const auto& parents = mAgents.LookupForAdd(aOriginChannelKey).OrInsert([]() {
+    return new nsTArray<BroadcastChannelParent*>();
+  });
 
   MOZ_ASSERT(!parents->Contains(aParent));
   parents->AppendElement(aParent);
 }
 
 void BroadcastChannelService::UnregisterActor(
     BroadcastChannelParent* aParent, const nsAString& aOriginChannelKey) {
   AssertIsOnBackgroundThread();
--- a/dom/canvas/WebGLTypes.h
+++ b/dom/canvas/WebGLTypes.h
@@ -676,18 +676,17 @@ class RawBuffer {
 
  public:
   using ElementType = T;
 
   /**
    * If aTakeData is true, RawBuffer will delete[] the memory when destroyed.
    */
   RawBuffer(size_t len, T* data, bool aTakeData = false)
-      : mData(data), mLength(len), mOwnsData(aTakeData) {
-  }
+      : mData(data), mLength(len), mOwnsData(aTakeData) {}
 
   RawBuffer(size_t len, RefPtr<mozilla::ipc::SharedMemoryBasic>& aSmem)
       : mSmem(aSmem), mData(aSmem->memory()), mLength(len), mOwnsData(false) {
     MOZ_ASSERT(mData && mLength);
   }
 
   ~RawBuffer() {
     // If we have a SharedMemoryBasic then it must own mData.
--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -2927,17 +2927,17 @@ void HTMLInputElement::Blur(ErrorResult&
       return;
     }
   }
 
   nsGenericHTMLElement::Blur(aError);
 }
 
 void HTMLInputElement::Focus(const FocusOptions& aOptions,
-                            CallerType aCallerType, ErrorResult& aError) {
+                             CallerType aCallerType, ErrorResult& aError) {
   if ((mType == NS_FORM_INPUT_TIME || mType == NS_FORM_INPUT_DATE) &&
       !IsExperimentalMobileType(mType)) {
     if (Element* dateTimeBoxElement = GetDateTimeBoxElement()) {
       AsyncEventDispatcher* dispatcher = new AsyncEventDispatcher(
           dateTimeBoxElement, NS_LITERAL_STRING("MozFocusInnerTextBox"),
           CanBubble::eNo, ChromeOnlyDispatch::eNo);
       dispatcher->RunDOMEventWhenSafe();
       return;
--- a/dom/ipc/WindowGlobalParent.cpp
+++ b/dom/ipc/WindowGlobalParent.cpp
@@ -183,17 +183,16 @@ uint32_t WindowGlobalParent::ContentBloc
   return GetContentBlockingLog()->GetContentBlockingEventsInLog();
 }
 
 void WindowGlobalParent::GetContentBlockingLog(nsAString& aLog) {
   NS_ConvertUTF8toUTF16 log(GetContentBlockingLog()->Stringify());
   aLog.Assign(std::move(log));
 }
 
-
 mozilla::ipc::IPCResult WindowGlobalParent::RecvLoadURI(
     dom::BrowsingContext* aTargetBC, nsDocShellLoadState* aLoadState,
     bool aSetNavigating) {
   if (!aTargetBC || aTargetBC->IsDiscarded()) {
     MOZ_LOG(
         BrowsingContext::GetLog(), LogLevel::Debug,
         ("ParentIPC: Trying to send a message with dead or detached context"));
     return IPC_OK();
@@ -306,17 +305,17 @@ void WindowGlobalParent::NotifyContentBl
   DebugOnly<bool> isCookiesBlockedTracker =
       aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
       aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER;
   MOZ_ASSERT_IF(aBlocked, aReason.isNothing());
   MOZ_ASSERT_IF(!isCookiesBlockedTracker, aReason.isNothing());
   MOZ_ASSERT_IF(isCookiesBlockedTracker && !aBlocked, aReason.isSome());
   MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
   // TODO: temporarily remove this until we find the root case of Bug 1609144
-  //MOZ_DIAGNOSTIC_ASSERT_IF(XRE_IsE10sParentProcess(), !IsInProcess());
+  // MOZ_DIAGNOSTIC_ASSERT_IF(XRE_IsE10sParentProcess(), !IsInProcess());
 
   // Return early if this WindowGlobalParent is in process.
   if (IsInProcess()) {
     return;
   }
 
   nsAutoCString origin;
   nsContentUtils::GetASCIIOrigin(aURIHint, origin);
--- a/dom/localstorage/ActorsParent.cpp
+++ b/dom/localstorage/ActorsParent.cpp
@@ -3661,19 +3661,19 @@ void DatastoreWriteOptimizer::ApplyAndRe
 
         case WriteInfo::UpdateItem: {
           auto updateItemInfo = static_cast<UpdateItemInfo*>(writeInfo);
           if (updateItemInfo->UpdateWithMove()) {
             // See the comment in LSWriteOptimizer::InsertItem for more details
             // about the UpdateWithMove flag.
 
             aOrderedItems.RemoveElementAt(index);
-            entry.Data() = MakeUnique<InsertItemInfo>(updateItemInfo->SerialNumber(),
-                                              updateItemInfo->GetKey(),
-                                              updateItemInfo->GetValue());
+            entry.Data() = MakeUnique<InsertItemInfo>(
+                updateItemInfo->SerialNumber(), updateItemInfo->GetKey(),
+                updateItemInfo->GetValue());
           } else {
             item.value() = updateItemInfo->GetValue();
             entry.Remove();
           }
           break;
         }
 
         case WriteInfo::InsertItem:
--- a/dom/workers/RuntimeService.cpp
+++ b/dom/workers/RuntimeService.cpp
@@ -1205,23 +1205,25 @@ bool RuntimeService::RegisterWorker(Work
   }
 
   const nsCString& domain = aWorkerPrivate->Domain();
 
   bool queued = false;
   {
     MutexAutoLock lock(mMutex);
 
-    const auto& domainInfo = mDomainMap.LookupForAdd(domain).OrInsert([&domain, parent]() {
-      NS_ASSERTION(!parent, "Shouldn't have a parent here!");
-      Unused << parent;  // silence clang -Wunused-lambda-capture in opt builds
-      WorkerDomainInfo* wdi = new WorkerDomainInfo();
-      wdi->mDomain = domain;
-      return wdi;
-    });
+    const auto& domainInfo =
+        mDomainMap.LookupForAdd(domain).OrInsert([&domain, parent]() {
+          NS_ASSERTION(!parent, "Shouldn't have a parent here!");
+          Unused
+              << parent;  // silence clang -Wunused-lambda-capture in opt builds
+          WorkerDomainInfo* wdi = new WorkerDomainInfo();
+          wdi->mDomain = domain;
+          return wdi;
+        });
 
     queued = gMaxWorkersPerDomain &&
              domainInfo->ActiveWorkerCount() >= gMaxWorkersPerDomain &&
              !domain.IsEmpty() && !exemptFromPerDomainMax;
 
     if (queued) {
       domainInfo->mQueuedWorkers.AppendElement(aWorkerPrivate);
 
@@ -1272,19 +1274,18 @@ bool RuntimeService::RegisterWorker(Work
       mNavigatorPropertiesLoaded = true;
     }
 
     nsPIDOMWindowInner* window = aWorkerPrivate->GetWindow();
 
     if (!isServiceWorker) {
       // Service workers are excluded since their lifetime is separate from
       // that of dom windows.
-      const auto& windowArray =
-          mWindowMap.LookupForAdd(window).OrInsert(
-              []() { return new nsTArray<WorkerPrivate*>(1); });
+      const auto& windowArray = mWindowMap.LookupForAdd(window).OrInsert(
+          []() { return new nsTArray<WorkerPrivate*>(1); });
       if (!windowArray->Contains(aWorkerPrivate)) {
         windowArray->AppendElement(aWorkerPrivate);
       } else {
         MOZ_ASSERT(aWorkerPrivate->IsSharedWorker());
       }
     }
   }
 
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -2189,17 +2189,16 @@ WorkerPrivate::WorkerPrivate(
     mJSSettings.content.realmOptions.behaviors().setClampAndJitterTime(
         !UsesSystemPrincipal());
 
     mJSSettings.chrome.realmOptions.creationOptions().setToSourceEnabled(
         UsesSystemPrincipal());
     mJSSettings.content.realmOptions.creationOptions().setToSourceEnabled(
         UsesSystemPrincipal());
 
-
     if (mIsSecureContext) {
       mJSSettings.chrome.realmOptions.creationOptions().setSecureContext(true);
       mJSSettings.content.realmOptions.creationOptions().setSecureContext(true);
     }
 
     mIsInAutomation = xpc::IsInAutomation();
 
     // Our parent can get suspended after it initiates the async creation
--- a/editor/libeditor/ChangeStyleTransaction.cpp
+++ b/editor/libeditor/ChangeStyleTransaction.cpp
@@ -188,18 +188,18 @@ ChangeStyleTransaction::DoTransaction() 
     nsAutoString priority;
     cssDecl->GetPropertyPriority(propertyNameString, priority);
     if (multiple) {
       // Let's add the value we have to add to the others
       AddValueToMultivalueProperty(values, mValue);
     } else {
       values.Assign(mValue);
     }
-    rv = cssDecl->SetProperty(propertyNameString,
-                              NS_ConvertUTF16toUTF8(values), priority);
+    rv = cssDecl->SetProperty(propertyNameString, NS_ConvertUTF16toUTF8(values),
+                              priority);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // Let's be sure we don't keep an empty style attribute
   uint32_t length = cssDecl->Length();
   if (!length) {
     rv = mElement->UnsetAttr(kNameSpaceID_None, nsGkAtoms::style, true);
     NS_ENSURE_SUCCESS(rv, rv);
--- a/extensions/spellcheck/src/mozInlineSpellWordUtil.cpp
+++ b/extensions/spellcheck/src/mozInlineSpellWordUtil.cpp
@@ -38,17 +38,17 @@ inline bool IsIgnorableCharacter(char16_
 }
 
 // IsConditionalPunctuation
 //
 //    Some characters (like apostrophes) require characters on each side to be
 //    part of a word, and are otherwise punctuation.
 
 inline bool IsConditionalPunctuation(char ch) {
-  return (ch == '\'' ||       // RIGHT SINGLE QUOTATION MARK
+  return (ch == '\'' ||                    // RIGHT SINGLE QUOTATION MARK
           ch == static_cast<char>(0xB7));  // MIDDLE DOT
 }
 
 inline bool IsConditionalPunctuation(char16_t ch) {
   return (ch == '\'' || ch == 0x2019 ||  // RIGHT SINGLE QUOTATION MARK
           ch == 0x00B7);                 // MIDDLE DOT
 }
 
@@ -605,17 +605,18 @@ bool WordSplitState<T>::IsSpecialWord() 
 
 // WordSplitState::ShouldSkipWord
 template <class T>
 bool WordSplitState<T>::ShouldSkipWord(int32_t aStart, int32_t aLength) const {
   int32_t last = aStart + aLength;
 
   // check to see if the word contains a digit
   for (int32_t i = aStart; i < last; i++) {
-    if (mozilla::unicode::GetGenCategory(GetUnicharAt(i)) == nsUGenCategory::kNumber) {
+    if (mozilla::unicode::GetGenCategory(GetUnicharAt(i)) ==
+        nsUGenCategory::kNumber) {
       return true;
     }
   }
 
   // not special
   return false;
 }
 
--- a/gfx/layers/apz/src/AsyncPanZoomController.cpp
+++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp
@@ -3533,17 +3533,18 @@ void AsyncPanZoomController::CallDispatc
 void AsyncPanZoomController::RecordScrollPayload(const TimeStamp& aTimeStamp) {
   RecursiveMutexAutoLock lock(mRecursiveMutex);
   if (!mScrollPayload) {
     mScrollPayload = Some(
         CompositionPayload{CompositionPayloadType::eAPZScroll, aTimeStamp});
   }
 }
 
-void AsyncPanZoomController::StartTouch(const ParentLayerPoint& aPoint, uint32_t aTime) {
+void AsyncPanZoomController::StartTouch(const ParentLayerPoint& aPoint,
+                                        uint32_t aTime) {
   RecursiveMutexAutoLock lock(mRecursiveMutex);
   mX.StartTouch(aPoint.x, aTime);
   mY.StartTouch(aPoint.y, aTime);
 }
 
 void AsyncPanZoomController::TrackTouch(const MultiTouchInput& aEvent) {
   ExternalPoint extPoint = GetFirstExternalTouchPoint(aEvent);
   ScreenPoint panVector = PanVector(extPoint);
--- a/gfx/layers/apz/src/AsyncPanZoomController.h
+++ b/gfx/layers/apz/src/AsyncPanZoomController.h
@@ -838,17 +838,18 @@ class AsyncPanZoomController {
   void UpdateWithTouchAtDevicePoint(const MultiTouchInput& aEvent);
 
   /**
    * Does any panning required due to a new touch event.
    */
   void TrackTouch(const MultiTouchInput& aEvent);
 
   /**
-   * Register the start of a touch or pan gesture at the given position and time.
+   * Register the start of a touch or pan gesture at the given position and
+   * time.
    */
   void StartTouch(const ParentLayerPoint& aPoint, uint32_t aTime);
 
   /**
    * Utility function to send updated FrameMetrics to Gecko so that it can paint
    * the displayport area. Calls into GeckoContentController to do the actual
    * work. This call will use the current metrics. If this function is called
    * from a non-main thread, it will redispatch itself to the main thread, and
--- a/gfx/layers/ipc/ContentCompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/ContentCompositorBridgeParent.cpp
@@ -734,17 +734,18 @@ ContentCompositorBridgeParent::RecvSuppo
 mozilla::ipc::IPCResult ContentCompositorBridgeParent::RecvPreferredDXGIAdapter(
     DxgiAdapterDesc* aOutDesc) {
   PodZero(aOutDesc);
 #ifdef XP_WIN
   if (!AllowDirectDXGISurfaceDrawing()) {
     return IPC_FAIL_NO_REASON(this);
   }
 
-  RefPtr<ID3D11Device> device = gfx::DeviceManagerDx::Get()->GetCompositorDevice();
+  RefPtr<ID3D11Device> device =
+      gfx::DeviceManagerDx::Get()->GetCompositorDevice();
   if (!device) {
     return IPC_FAIL_NO_REASON(this);
   }
 
   RefPtr<IDXGIDevice> dxgi;
   if (FAILED(device->QueryInterface(__uuidof(IDXGIDevice),
                                     getter_AddRefs(dxgi))) ||
       !dxgi) {
--- a/gfx/thebes/gfxWindowsNativeDrawing.h
+++ b/gfx/thebes/gfxWindowsNativeDrawing.h
@@ -48,21 +48,21 @@ class gfxWindowsNativeDrawing {
    *     nativeDraw.TransformToNativeRect(rect, winRect);
    *
    *       ... call win32 operations on HDC to draw to winRect ...
    *
    *     nativeDraw.EndNativeDrawing();
    *   } while (nativeDraw.ShouldRenderAgain());
    *   nativeDraw.PaintToContext();
    */
-  gfxWindowsNativeDrawing(gfxContext* ctx, const gfxRect& nativeRect,
-                          uint32_t nativeDrawFlags =
-                              CANNOT_DRAW_TO_COLOR_ALPHA |
-                              CANNOT_AXIS_ALIGNED_SCALE |
-                              CANNOT_COMPLEX_TRANSFORM);
+  gfxWindowsNativeDrawing(
+      gfxContext* ctx, const gfxRect& nativeRect,
+      uint32_t nativeDrawFlags = CANNOT_DRAW_TO_COLOR_ALPHA |
+                                 CANNOT_AXIS_ALIGNED_SCALE |
+                                 CANNOT_COMPLEX_TRANSFORM);
 
   /* Returns a HDC which may be used for native drawing.  This HDC is valid
    * until EndNativeDrawing is called; if it is used for drawing after that
    * time, the result is undefined. */
   HDC BeginNativeDrawing();
 
   /* Transform the native rect into something valid for rendering
    * to the HDC.  This may or may not change RECT, depending on
--- a/gfx/vr/external_api/moz_external_vr.h
+++ b/gfx/vr/external_api/moz_external_vr.h
@@ -546,25 +546,25 @@ struct VRWindowState {
 enum class VRTelemetryId : uint8_t {
   NONE = 0,
   INSTALLED_FROM = 1,
   ENTRY_METHOD = 2,
   FIRST_RUN = 3,
   TOTAL = 4,
 };
 
-enum class VRTelemetryInstallFrom: uint8_t {
+enum class VRTelemetryInstallFrom : uint8_t {
   User = 0,
   FxR = 1,
   HTC = 2,
   Valve = 3,
   TOTAL = 4,
 };
 
-enum class VRTelemetryEntryMethod: uint8_t {
+enum class VRTelemetryEntryMethod : uint8_t {
   SystemBtn = 0,
   Library = 1,
   Gaze = 2,
   TOTAL = 3,
 };
 
 struct VRTelemetryState {
   uint32_t uid;
--- a/gfx/webrender_bindings/DCLayerTree.cpp
+++ b/gfx/webrender_bindings/DCLayerTree.cpp
@@ -428,18 +428,18 @@ void DCSurface::UpdateAllocatedRect() {
     // The virtual surface may have holes in it (for example, an empty tile
     // that has no primitives). Instead of trimming to a single bounding
     // rect, supply the rect of each valid tile to handle this case.
     std::vector<RECT> validRects;
 
     for (auto it = mDCLayers.begin(); it != mDCLayers.end(); ++it) {
       RECT rect;
 
-      rect.left = (LONG) (VIRTUAL_OFFSET + it->first.mX * mTileSize.width);
-      rect.top = (LONG) (VIRTUAL_OFFSET + it->first.mY * mTileSize.height);
+      rect.left = (LONG)(VIRTUAL_OFFSET + it->first.mX * mTileSize.width);
+      rect.top = (LONG)(VIRTUAL_OFFSET + it->first.mY * mTileSize.height);
       rect.right = rect.left + mTileSize.width;
       rect.bottom = rect.top + mTileSize.height;
 
       validRects.push_back(rect);
     }
 
     mVirtualSurface->Trim(validRects.data(), validRects.size());
     mAllocatedRectDirty = false;
--- a/js/src/builtin/streams/MiscellaneousOperations-inl.h
+++ b/js/src/builtin/streams/MiscellaneousOperations-inl.h
@@ -9,23 +9,23 @@
 #ifndef builtin_streams_MiscellaneousOperations_inl_h
 #define builtin_streams_MiscellaneousOperations_inl_h
 
 #include "builtin/streams/MiscellaneousOperations.h"
 
 #include "mozilla/Assertions.h"  // MOZ_ASSERT
 #include "mozilla/Attributes.h"  // MOZ_MUST_USE
 
-#include "js/Promise.h"       // JS::{Resolve,Reject}Promise, JS::PromiseState
-#include "js/RootingAPI.h"    // JS::Rooted, JS::{,Mutable}Handle
-#include "js/Value.h"         // JS::UndefinedHandleValue, JS::Value
-#include "vm/Compartment.h"   // JS::Compartment
-#include "vm/Interpreter.h"   // js::Call
-#include "vm/JSContext.h"     // JSContext
-#include "vm/JSObject.h"      // JSObject
+#include "js/Promise.h"        // JS::{Resolve,Reject}Promise, JS::PromiseState
+#include "js/RootingAPI.h"     // JS::Rooted, JS::{,Mutable}Handle
+#include "js/Value.h"          // JS::UndefinedHandleValue, JS::Value
+#include "vm/Compartment.h"    // JS::Compartment
+#include "vm/Interpreter.h"    // js::Call
+#include "vm/JSContext.h"      // JSContext
+#include "vm/JSObject.h"       // JSObject
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap
 #include "vm/JSContext-inl.h"    // JSContext::check
 #include "vm/JSObject-inl.h"     // js::IsCallable
 
 namespace js {
 
--- a/js/src/builtin/streams/PipeToState.h
+++ b/js/src/builtin/streams/PipeToState.h
@@ -23,20 +23,17 @@ namespace js {
  * PipeToState objects implement the local variables in Streams spec 3.4.11
  * ReadableStreamPipeTo across all sub-operations that occur in that algorithm.
  */
 class PipeToState : public NativeObject {
  public:
   /**
    * Memory layout for PipeToState instances.
    */
-  enum Slots {
-    Slot_Flags,
-    SlotCount
-  };
+  enum Slots { Slot_Flags, SlotCount };
 
  private:
   enum Flags {
     Flag_ShuttingDown = 1 << 0,
   };
 
   uint32_t flags() const { return getFixedSlot(Slot_Flags).toInt32(); }
   void setFlags(uint32_t flags) {
--- a/js/src/builtin/streams/ReadableStreamDefaultControllerOperations.cpp
+++ b/js/src/builtin/streams/ReadableStreamDefaultControllerOperations.cpp
@@ -20,24 +20,24 @@
 #include "builtin/streams/ReadableStreamInternals.h"  // js::ReadableStream{CloseInternal,ErrorInternal,FulfillReadOrReadIntoRequest,GetNumReadRequests}
 #include "builtin/streams/ReadableStreamOperations.h"  // js::ReadableStreamTee_Pull, js::SetUpReadableStreamDefaultController
 #include "builtin/streams/TeeState.h"  // js::TeeState
 #include "js/CallArgs.h"               // JS::CallArgs{,FromVp}
 #include "js/Promise.h"                // JS::AddPromiseReactions
 #include "js/RootingAPI.h"             // JS::Handle, JS::Rooted
 #include "js/Stream.h"                 // JS::ReadableStreamUnderlyingSource
 #include "js/Value.h"  // JS::{,Int32,Object}Value, JS::UndefinedHandleValue
-#include "vm/Compartment.h"  // JS::Compartment
-#include "vm/Interpreter.h"  // js::Call, js::GetAndClearExceptionAndStack
-#include "vm/JSContext.h"    // JSContext
-#include "vm/JSObject.h"     // JSObject
-#include "vm/List.h"         // js::ListObject
+#include "vm/Compartment.h"    // JS::Compartment
+#include "vm/Interpreter.h"    // js::Call, js::GetAndClearExceptionAndStack
+#include "vm/JSContext.h"      // JSContext
+#include "vm/JSObject.h"       // JSObject
+#include "vm/List.h"           // js::ListObject
 #include "vm/PromiseObject.h"  // js::PromiseObject
-#include "vm/Runtime.h"      // JSAtomState
-#include "vm/SavedFrame.h"   // js::SavedFrame
+#include "vm/Runtime.h"        // JSAtomState
+#include "vm/SavedFrame.h"     // js::SavedFrame
 
 #include "builtin/streams/HandlerFunction-inl.h"          // js::NewHandler
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::PromiseCall
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapCalleeSlot
 #include "vm/JSContext-inl.h"    // JSContext::check
 #include "vm/JSObject-inl.h"     // js::IsCallable, js::NewBuiltinClassInstance
 #include "vm/Realm-inl.h"        // js::AutoRealm
 
--- a/js/src/builtin/streams/ReadableStreamInternals.cpp
+++ b/js/src/builtin/streams/ReadableStreamInternals.cpp
@@ -20,23 +20,23 @@
 #include "gc/AllocKind.h"   // js::gc::AllocKind
 #include "js/CallArgs.h"    // JS::CallArgs{,FromVp}
 #include "js/GCAPI.h"       // JS::AutoSuppressGCAnalysis
 #include "js/Promise.h"     // JS::CallOriginalPromiseThen, JS::ResolvePromise
 #include "js/Result.h"      // JS_TRY_VAR_OR_RETURN_NULL
 #include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
 #include "js/Stream.h"  // JS::ReadableStreamUnderlyingSource, JS::ReadableStreamMode
 #include "js/Value.h"  // JS::Value, JS::{Boolean,Object}Value, JS::UndefinedHandleValue
-#include "vm/JSContext.h"     // JSContext
-#include "vm/JSFunction.h"    // JSFunction, js::NewNativeFunction
-#include "vm/NativeObject.h"  // js::NativeObject
-#include "vm/ObjectGroup.h"   // js::GenericObject
+#include "vm/JSContext.h"      // JSContext
+#include "vm/JSFunction.h"     // JSFunction, js::NewNativeFunction
+#include "vm/NativeObject.h"   // js::NativeObject
+#include "vm/ObjectGroup.h"    // js::GenericObject
 #include "vm/PromiseObject.h"  // js::PromiseObject
-#include "vm/Realm.h"         // JS::Realm
-#include "vm/StringType.h"    // js::PropertyName
+#include "vm/Realm.h"          // JS::Realm
+#include "vm/StringType.h"     // js::PropertyName
 
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::{Reject,Resolve}UnwrappedPromiseWithUndefined, js::SetSettledPromiseIsHandled
 #include "builtin/streams/ReadableStreamReader-inl.h"  // js::js::UnwrapReaderFromStream{,NoThrow}
 #include "vm/Compartment-inl.h"                        // JS::Compartment::wrap
 #include "vm/JSContext-inl.h"                          // JSContext::check
 #include "vm/List-inl.h"  // js::ListObject, js::AppendToListInFixedSlot, js::StoreNewListInFixedSlot
 #include "vm/Realm-inl.h"  // JS::Realm
 
--- a/js/src/builtin/streams/ReadableStreamOperations.cpp
+++ b/js/src/builtin/streams/ReadableStreamOperations.cpp
@@ -8,17 +8,17 @@
 
 #include "builtin/streams/ReadableStreamOperations.h"
 
 #include "mozilla/Assertions.h"  // MOZ_ASSERT{,_IF}
 #include "mozilla/Attributes.h"  // MOZ_MUST_USE
 
 #include "jsapi.h"  // JS_SetPrivate
 
-#include "builtin/Array.h"  // js::NewDenseFullyAllocatedArray
+#include "builtin/Array.h"    // js::NewDenseFullyAllocatedArray
 #include "builtin/Promise.h"  // js::RejectPromiseWithPendingError
 #include "builtin/streams/ReadableStream.h"  // js::ReadableStream
 #include "builtin/streams/ReadableStreamController.h"  // js::ReadableStream{,Default}Controller
 #include "builtin/streams/ReadableStreamDefaultControllerOperations.h"  // js::ReadableStreamDefaultController{Close,Enqueue}, js::ReadableStreamControllerError, js::SourceAlgorithms
 #include "builtin/streams/ReadableStreamInternals.h"  // js::ReadableStreamCancel
 #include "builtin/streams/ReadableStreamReader.h"  // js::CreateReadableStreamDefaultReader, js::ReadableStream{,Default}Reader, js::ReadableStreamDefaultReaderRead
 #include "builtin/streams/TeeState.h"              // js::TeeState
 #include "js/CallArgs.h"                           // JS::CallArgs{,FromVp}
--- a/js/src/builtin/streams/ReadableStreamReader.cpp
+++ b/js/src/builtin/streams/ReadableStreamReader.cpp
@@ -13,21 +13,21 @@
 
 #include "jsfriendapi.h"  // JS_ReportErrorNumberASCII, js::GetErrorMessage
 
 #include "builtin/Stream.h"  // js::ReadableStreamController, js::ReadableStreamControllerPullSteps
 #include "builtin/streams/ReadableStream.h"            // js::ReadableStream
 #include "builtin/streams/ReadableStreamController.h"  // js::ReadableStreamController
 #include "builtin/streams/ReadableStreamInternals.h"  // js::ReadableStream{Cancel,CreateReadResult}
 #include "js/RootingAPI.h"                            // JS::Handle, JS::Rooted
-#include "js/Value.h"        // JS::Value, JS::UndefinedHandleValue
-#include "vm/Interpreter.h"  // js::GetAndClearException
-#include "vm/JSContext.h"    // JSContext
+#include "js/Value.h"          // JS::Value, JS::UndefinedHandleValue
+#include "vm/Interpreter.h"    // js::GetAndClearException
+#include "vm/JSContext.h"      // JSContext
 #include "vm/PromiseObject.h"  // js::PromiseObject
-#include "vm/Runtime.h"      // JSRuntime
+#include "vm/Runtime.h"        // JSRuntime
 
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::SetSettledPromiseIsHandled
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapInternalSlot
 #include "vm/List-inl.h"         // js::StoreNewListInFixedSlot
 #include "vm/Realm-inl.h"        // js::AutoRealm
 
 using js::ReadableStreamController;
 using js::UnwrapStreamFromReader;
--- a/js/src/builtin/streams/TeeState.cpp
+++ b/js/src/builtin/streams/TeeState.cpp
@@ -4,19 +4,19 @@
  * 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/. */
 
 /* Stream teeing state. */
 
 #include "builtin/streams/TeeState.h"
 
 #include "builtin/streams/ReadableStream.h"  // js::ReadableStream
-#include "js/Class.h"       // JSClass, JSCLASS_HAS_RESERVED_SLOTS
-#include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
-#include "vm/JSContext.h"   // JSContext
+#include "js/Class.h"          // JSClass, JSCLASS_HAS_RESERVED_SLOTS
+#include "js/RootingAPI.h"     // JS::Handle, JS::Rooted
+#include "vm/JSContext.h"      // JSContext
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 #include "vm/JSObject-inl.h"  // js::NewBuiltinClassInstance
 
 using js::ReadableStream;
 using js::TeeState;
 
 using JS::Handle;
--- a/js/src/builtin/streams/TeeState.h
+++ b/js/src/builtin/streams/TeeState.h
@@ -10,18 +10,18 @@
 #define builtin_streams_TeeState_h
 
 #include "mozilla/Assertions.h"  // MOZ_ASSERT
 
 #include <stdint.h>  // uint32_t
 
 #include "builtin/streams/ReadableStreamController.h"  // js::ReadableStreamDefaultController
 #include "js/Class.h"                                  // JSClass
-#include "js/Value.h"         // JS::{Int32,Object}Value
-#include "vm/NativeObject.h"  // js::NativeObject
+#include "js/Value.h"          // JS::{Int32,Object}Value
+#include "vm/NativeObject.h"   // js::NativeObject
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 namespace js {
 
 /**
  * TeeState objects implement the local variables in Streams spec 3.3.9
  * ReadableStreamTee, which are accessed by several algorithms.
  */
--- a/js/src/builtin/streams/WritableStreamDefaultControllerOperations.cpp
+++ b/js/src/builtin/streams/WritableStreamDefaultControllerOperations.cpp
@@ -17,22 +17,22 @@
 #include "builtin/streams/QueueWithSizes.h"  // js::{EnqueueValueWithSize,QueueIsEmpty,ResetQueue}
 #include "builtin/streams/WritableStream.h"  // js::WritableStream
 #include "builtin/streams/WritableStreamDefaultController.h"  // js::WritableStreamDefaultController
 #include "builtin/streams/WritableStreamOperations.h"  // js::WritableStream{CloseQueuedOrInFlight,DealWithRejection,{Start,Finish}Erroring,UpdateBackpressure,Mark{Close,FirstWrite}RequestInFlight}
 #include "js/CallArgs.h"                               // JS::CallArgs{,FromVp}
 #include "js/Promise.h"     // JS::AddPromiseReactions
 #include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
 #include "js/Value.h"  // JS::{,Int32,Magic,Object}Value, JS::UndefinedHandleValue, JS_WRITABLESTREAM_CLOSE_RECORD
-#include "vm/Compartment.h"  // JS::Compartment
-#include "vm/JSContext.h"    // JSContext
-#include "vm/JSObject.h"     // JSObject
-#include "vm/List.h"         // js::ListObject
+#include "vm/Compartment.h"    // JS::Compartment
+#include "vm/JSContext.h"      // JSContext
+#include "vm/JSObject.h"       // JSObject
+#include "vm/List.h"           // js::ListObject
 #include "vm/PromiseObject.h"  // js::PromiseObject
-#include "vm/Runtime.h"      // JSAtomState
+#include "vm/Runtime.h"        // JSAtomState
 
 #include "builtin/streams/HandlerFunction-inl.h"  // js::TargetFromHandler
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::PromiseCall
 #include "builtin/streams/QueueWithSizes-inl.h"           // js::PeekQueueValue
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap
 #include "vm/JSContext-inl.h"    // JSContext::check
 #include "vm/JSObject-inl.h"  // js::IsCallable, js::NewBuiltinClassInstance, js::NewObjectWithClassProto
 #include "vm/Realm-inl.h"  // js::AutoRealm
--- a/js/src/builtin/streams/WritableStreamDefaultWriter.cpp
+++ b/js/src/builtin/streams/WritableStreamDefaultWriter.cpp
@@ -17,20 +17,20 @@
 #include "builtin/streams/ClassSpecMacro.h"  // JS_STREAMS_CLASS_SPEC
 #include "builtin/streams/MiscellaneousOperations.h"  // js::ReturnPromiseRejectedWithPendingError
 #include "builtin/streams/WritableStream.h"  // js::WritableStream
 #include "builtin/streams/WritableStreamOperations.h"  // js::WritableStreamCloseQueuedOrInFlight
 #include "builtin/streams/WritableStreamWriterOperations.h"  // js::WritableStreamDefaultWriter{Abort,GetDesiredSize,Release,Write}
 #include "js/CallArgs.h"  // JS::CallArgs{,FromVp}
 #include "js/Class.h"     // js::ClassSpec, JS_NULL_CLASS_OPS
 #include "js/PropertySpec.h"  // JS{Function,Property}Spec, JS_{FS,PS}_END, JS_{FN,PSG}
-#include "js/RootingAPI.h"   // JS::Handle
-#include "js/Value.h"        // JS::Value
-#include "vm/Compartment.h"  // JS::Compartment
-#include "vm/JSContext.h"    // JSContext
+#include "js/RootingAPI.h"     // JS::Handle
+#include "js/Value.h"          // JS::Value
+#include "vm/Compartment.h"    // JS::Compartment
+#include "vm/JSContext.h"      // JSContext
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::SetSettledPromiseIsHandled
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapAndTypeCheck{Argument,This}
 #include "vm/JSObject-inl.h"      // js::NewObjectWithClassProto
 #include "vm/NativeObject-inl.h"  // js::ThrowIfNotConstructing
 #include "vm/Realm-inl.h"         // js::AutoRealm
 
--- a/js/src/builtin/streams/WritableStreamOperations.cpp
+++ b/js/src/builtin/streams/WritableStreamOperations.cpp
@@ -20,19 +20,19 @@
 #include "builtin/streams/WritableStream.h"  // js::WritableStream
 #include "builtin/streams/WritableStreamDefaultController.h"  // js::WritableStreamDefaultController{,Close}, js::WritableStream::controller
 #include "builtin/streams/WritableStreamDefaultControllerOperations.h"  // js::WritableStreamControllerErrorSteps
 #include "builtin/streams/WritableStreamWriterOperations.h"  // js::WritableStreamDefaultWriterEnsureReadyPromiseRejected
 #include "js/CallArgs.h"    // JS::CallArgs{,FromVp}
 #include "js/Promise.h"     // JS::{Reject,Resolve}Promise
 #include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
 #include "js/Value.h"  // JS::Value, JS::ObjecValue, JS::UndefinedHandleValue
-#include "vm/Compartment.h"  // JS::Compartment
-#include "vm/JSContext.h"    // JSContext
-#include "vm/List.h"         // js::ListObject
+#include "vm/Compartment.h"    // JS::Compartment
+#include "vm/JSContext.h"      // JSContext
+#include "vm/List.h"           // js::ListObject
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 #include "builtin/streams/HandlerFunction-inl.h"  // js::NewHandler, js::TargetFromHandler
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::ResolveUnwrappedPromiseWithUndefined, js::RejectUnwrappedPromiseWithError, js::SetSettledPromiseIsHandled
 #include "builtin/streams/WritableStream-inl.h"  // js::UnwrapWriterFromStream
 #include "builtin/streams/WritableStreamDefaultWriter-inl.h"  // js::WritableStreamDefaultWriter::closedPromise
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapAndDowncastObject
 #include "vm/JSContext-inl.h"  // JSContext::check
--- a/js/src/builtin/streams/WritableStreamWriterOperations.cpp
+++ b/js/src/builtin/streams/WritableStreamWriterOperations.cpp
@@ -16,20 +16,20 @@
 
 #include "builtin/streams/MiscellaneousOperations.h"  // js::PromiseRejectedWithPendingError
 #include "builtin/streams/WritableStream.h"  // js::WritableStream
 #include "builtin/streams/WritableStreamDefaultController.h"  // js::WritableStream::controller
 #include "builtin/streams/WritableStreamDefaultControllerOperations.h"  // js::WritableStreamDefaultController{Close,GetDesiredSize}
 #include "builtin/streams/WritableStreamDefaultWriter.h"  // js::WritableStreamDefaultWriter
 #include "builtin/streams/WritableStreamOperations.h"  // js::WritableStream{Abort,CloseQueuedOrInFlight}
 #include "js/Promise.h"                                // JS::PromiseState
-#include "js/Value.h"        // JS::Value, JS::{Int32,Null}Value
-#include "vm/Compartment.h"  // JS::Compartment
-#include "vm/Interpreter.h"  // js::GetAndClearException
-#include "vm/JSContext.h"    // JSContext
+#include "js/Value.h"          // JS::Value, JS::{Int32,Null}Value
+#include "vm/Compartment.h"    // JS::Compartment
+#include "vm/Interpreter.h"    // js::GetAndClearException
+#include "vm/JSContext.h"      // JSContext
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::ResolveUnwrappedPromiseWithUndefined, js::SetSettledPromiseIsHandled
 #include "builtin/streams/WritableStream-inl.h"  // js::WritableStream::setCloseRequest
 #include "builtin/streams/WritableStreamDefaultWriter-inl.h"  // js::UnwrapStreamFromWriter
 #include "vm/Compartment-inl.h"  // js::UnwrapAnd{DowncastObject,TypeCheckThis}
 #include "vm/JSContext-inl.h"    // JSContext::check
 #include "vm/Realm-inl.h"        // js::AutoRealm
--- a/js/src/debugger/Object.cpp
+++ b/js/src/debugger/Object.cpp
@@ -28,48 +28,48 @@
 #include "debugger/Source.h"     // for DebuggerSource
 #include "gc/Barrier.h"          // for ImmutablePropertyNamePtr
 #include "gc/Rooting.h"          // for RootedDebuggerObject
 #include "gc/Tracer.h"  // for TraceManuallyBarrieredCrossCompartmentEdge
 #include "js/CompilationAndEvaluation.h"  //  for Compile
 #include "js/Conversions.h"               // for ToObject
 #include "js/HeapAPI.h"                   // for IsInsideNursery
 #include "js/Promise.h"                   // for PromiseState
-#include "js/Proxy.h"    // for PropertyDescriptor
-#include "js/StableStringChars.h"        // for AutoStableStringChars
-#include "proxy/ScriptedProxyHandler.h"  // for ScriptedProxyHandler
-#include "vm/ArgumentsObject.h"          // for ARGS_LENGTH_MAX
-#include "vm/ArrayObject.h"              // for ArrayObject
-#include "vm/AsyncFunction.h"            // for AsyncGeneratorObject
-#include "vm/AsyncIteration.h"           // for AsyncFunctionGeneratorObject
-#include "vm/BytecodeUtil.h"             // for JSDVG_SEARCH_STACK
-#include "vm/Compartment.h"              // for Compartment
-#include "vm/EnvironmentObject.h"        // for GetDebugEnvironmentForFunction
-#include "vm/ErrorObject.h"              // for JSObject::is, ErrorObject
-#include "vm/GeneratorObject.h"          // for AbstractGeneratorObject
-#include "vm/GlobalObject.h"             // for JSObject::is, GlobalObject
-#include "vm/Instrumentation.h"          // for RealmInstrumentation
-#include "vm/Interpreter.h"              // for Call
-#include "vm/JSAtom.h"                   // for Atomize, js_apply_str
-#include "vm/JSContext.h"                // for JSContext, ReportValueError
-#include "vm/JSFunction.h"               // for JSFunction
-#include "vm/JSScript.h"                 // for JSScript
-#include "vm/NativeObject.h"             // for NativeObject, JSObject::is
-#include "vm/ObjectGroup.h"              // for GenericObject, NewObjectKind
-#include "vm/ObjectOperations.h"         // for DefineProperty
-#include "vm/PromiseObject.h"            // for js::PromiseObject
-#include "vm/Realm.h"                    // for AutoRealm, ErrorCopier, Realm
-#include "vm/Runtime.h"                  // for JSAtomState
-#include "vm/SavedFrame.h"               // for SavedFrame
-#include "vm/Scope.h"                    // for PositionalFormalParameterIter
-#include "vm/SelfHosting.h"              // for GetClonedSelfHostedFunctionName
-#include "vm/Shape.h"                    // for Shape
-#include "vm/Stack.h"                    // for InvokeArgs
-#include "vm/StringType.h"               // for JSAtom, PropertyName
-#include "vm/WrapperObject.h"            // for JSObject::is, WrapperObject
+#include "js/Proxy.h"                     // for PropertyDescriptor
+#include "js/StableStringChars.h"         // for AutoStableStringChars
+#include "proxy/ScriptedProxyHandler.h"   // for ScriptedProxyHandler
+#include "vm/ArgumentsObject.h"           // for ARGS_LENGTH_MAX
+#include "vm/ArrayObject.h"               // for ArrayObject
+#include "vm/AsyncFunction.h"             // for AsyncGeneratorObject
+#include "vm/AsyncIteration.h"            // for AsyncFunctionGeneratorObject
+#include "vm/BytecodeUtil.h"              // for JSDVG_SEARCH_STACK
+#include "vm/Compartment.h"               // for Compartment
+#include "vm/EnvironmentObject.h"         // for GetDebugEnvironmentForFunction
+#include "vm/ErrorObject.h"               // for JSObject::is, ErrorObject
+#include "vm/GeneratorObject.h"           // for AbstractGeneratorObject
+#include "vm/GlobalObject.h"              // for JSObject::is, GlobalObject
+#include "vm/Instrumentation.h"           // for RealmInstrumentation
+#include "vm/Interpreter.h"               // for Call
+#include "vm/JSAtom.h"                    // for Atomize, js_apply_str
+#include "vm/JSContext.h"                 // for JSContext, ReportValueError
+#include "vm/JSFunction.h"                // for JSFunction
+#include "vm/JSScript.h"                  // for JSScript
+#include "vm/NativeObject.h"              // for NativeObject, JSObject::is
+#include "vm/ObjectGroup.h"               // for GenericObject, NewObjectKind
+#include "vm/ObjectOperations.h"          // for DefineProperty
+#include "vm/PromiseObject.h"             // for js::PromiseObject
+#include "vm/Realm.h"                     // for AutoRealm, ErrorCopier, Realm
+#include "vm/Runtime.h"                   // for JSAtomState
+#include "vm/SavedFrame.h"                // for SavedFrame
+#include "vm/Scope.h"                     // for PositionalFormalParameterIter
+#include "vm/SelfHosting.h"               // for GetClonedSelfHostedFunctionName
+#include "vm/Shape.h"                     // for Shape
+#include "vm/Stack.h"                     // for InvokeArgs
+#include "vm/StringType.h"                // for JSAtom, PropertyName
+#include "vm/WrapperObject.h"             // for JSObject::is, WrapperObject
 
 #include "vm/Compartment-inl.h"       // for Compartment::wrap
 #include "vm/JSAtom-inl.h"            // for ValueToId
 #include "vm/JSObject-inl.h"          // for GetObjectClassName, InitClass
 #include "vm/NativeObject-inl.h"      // for NativeObject::global
 #include "vm/ObjectOperations-inl.h"  // for DeleteProperty, GetProperty
 #include "vm/Realm-inl.h"             // for AutoRealm::AutoRealm
 
--- a/js/src/gc/Heap.h
+++ b/js/src/gc/Heap.h
@@ -157,17 +157,16 @@ class FreeSpan {
  * <---------------------------------------> = first thing offset
  *
  * The mark bits store the GC marking state for GC things in the arena, with one
  * byte per thing. These are stored in reverse order with the first byte
  * corresponding to the last GC thing in the arena. This is done for to make the
  * index calculation easier; see TenuredCell::indexInArena() for details.
  */
 class Arena {
-
   /*
    * The first span of free things in the arena. Most of these spans are
    * stored as offsets in free regions of the data array, and most operations
    * on FreeSpans take an Arena pointer for safety. However, the FreeSpans
    * used for allocation are stored here, at the start of an Arena, and use
    * their own address to grab the next span within the same Arena.
    */
   FreeSpan firstFreeSpan;
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -896,17 +896,17 @@ static const JSStdName builtin_property_
     {NAME_OFFSET(decodeURIComponent), JSProto_String},
     {NAME_OFFSET(encodeURIComponent), JSProto_String},
     {NAME_OFFSET(uneval), JSProto_String},
 
     {0, JSProto_LIMIT}};
 
 static bool SkipUneval(JSContext* cx, jsid id) {
   return !cx->realm()->creationOptions().getToSourceEnabled() &&
-          id == NameToId(cx->names().uneval);
+         id == NameToId(cx->names().uneval);
 }
 
 JS_PUBLIC_API bool JS_ResolveStandardClass(JSContext* cx, HandleObject obj,
                                            HandleId id, bool* resolved) {
   const JSStdName* stdnm;
 
   AssertHeapIsIdle();
   CHECK_THREAD(cx);
@@ -1151,17 +1151,18 @@ JS_PUBLIC_API JSProtoKey JS_IdToProtoKey
   if (GlobalObject::skipDeselectedConstructor(cx, stdnm->key)) {
     return JSProto_Null;
   }
 
   if (SkipUneval(cx, id)) {
     return JSProto_Null;
   }
 
-  static_assert(mozilla::ArrayLength(standard_class_names) == JSProto_LIMIT + 1);
+  static_assert(mozilla::ArrayLength(standard_class_names) ==
+                JSProto_LIMIT + 1);
   return static_cast<JSProtoKey>(stdnm - standard_class_names);
 }
 
 extern JS_PUBLIC_API bool JS_IsGlobalObject(JSObject* obj) {
   return obj->is<GlobalObject>();
 }
 
 extern JS_PUBLIC_API JSObject* JS_GlobalLexicalEnvironment(JSObject* obj) {
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -1651,35 +1651,35 @@ void js::ReportInNotObjectError(JSContex
 
 static MOZ_NEVER_INLINE JS_HAZ_JSNATIVE_CALLER bool Interpret(JSContext* cx,
                                                               RunState& state) {
 /*
  * Define macros for an interpreter loop. Opcode dispatch is done by
  * indirect goto (aka a threaded interpreter), which is technically
  * non-standard but is supported by all of our supported compilers.
  */
-#  define INTERPRETER_LOOP()
-#  define CASE(OP) label_##OP:
-#  define DEFAULT() \
+#define INTERPRETER_LOOP()
+#define CASE(OP) label_##OP:
+#define DEFAULT() \
   label_default:
-#  define DISPATCH_TO(OP) goto* addresses[(OP)]
-
-#  define LABEL(X) (&&label_##X)
+#define DISPATCH_TO(OP) goto* addresses[(OP)]
+
+#define LABEL(X) (&&label_##X)
 
   // Use addresses instead of offsets to optimize for runtime speed over
   // load-time relocation overhead.
   static const void* const addresses[EnableInterruptsPseudoOpcode + 1] = {
-#  define OPCODE_LABEL(op, ...) LABEL(op),
+#define OPCODE_LABEL(op, ...) LABEL(op),
       FOR_EACH_OPCODE(OPCODE_LABEL)
-#  undef OPCODE_LABEL
-#  define TRAILING_LABEL(v)                                                    \
-    ((v) == EnableInterruptsPseudoOpcode ? LABEL(EnableInterruptsPseudoOpcode) \
-                                         : LABEL(default)),
+#undef OPCODE_LABEL
+#define TRAILING_LABEL(v)                                                    \
+  ((v) == EnableInterruptsPseudoOpcode ? LABEL(EnableInterruptsPseudoOpcode) \
+                                       : LABEL(default)),
           FOR_EACH_TRAILING_UNUSED_OPCODE(TRAILING_LABEL)
-#  undef TRAILING_LABEL
+#undef TRAILING_LABEL
   };
 
   /*
    * Increment REGS.pc by N, load the opcode at that position,
    * and jump to the code to execute it.
    *
    * When Debugger puts a script in single-step mode, all js::Interpret
    * invocations that might be presently running that script must have
--- a/js/src/vm/JSContext.cpp
+++ b/js/src/vm/JSContext.cpp
@@ -888,18 +888,18 @@ const char* NullOrUndefinedToCharZ(Handl
 }
 
 void js::ReportIsNullOrUndefinedForPropertyAccess(JSContext* cx, HandleValue v,
                                                   bool reportScanStack) {
   MOZ_ASSERT(v.isNullOrUndefined());
 
   if (!reportScanStack) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
-                              JSMSG_CANT_CONVERT_TO,
-                              NullOrUndefinedToCharZ(v), "object");
+                              JSMSG_CANT_CONVERT_TO, NullOrUndefinedToCharZ(v),
+                              "object");
     return;
   }
 
   UniqueChars bytes =
       DecompileValueGenerator(cx, JSDVG_SEARCH_STACK, v, nullptr);
   if (!bytes) {
     return;
   }
@@ -933,18 +933,17 @@ void js::ReportIsNullOrUndefinedForPrope
 
   UniqueChars keyStr = StringToNewUTF8CharsZ(cx, *idStr);
   if (!keyStr) {
     return;
   }
 
   if (!reportScanStack) {
     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_PROPERTY_FAIL,
-                             keyStr.get(),
-                             NullOrUndefinedToCharZ(v));
+                             keyStr.get(), NullOrUndefinedToCharZ(v));
     return;
   }
 
   UniqueChars bytes =
       DecompileValueGenerator(cx, JSDVG_SEARCH_STACK, v, nullptr);
   if (!bytes) {
     return;
   }
@@ -952,18 +951,18 @@ void js::ReportIsNullOrUndefinedForPrope
   if (strcmp(bytes.get(), js_undefined_str) == 0 ||
       strcmp(bytes.get(), js_null_str) == 0) {
     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_PROPERTY_FAIL,
                              keyStr.get(), bytes.get());
     return;
   }
 
   JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
-                           JSMSG_PROPERTY_FAIL_EXPR, keyStr.get(),
-                           bytes.get(), NullOrUndefinedToCharZ(v));
+                           JSMSG_PROPERTY_FAIL_EXPR, keyStr.get(), bytes.get(),
+                           NullOrUndefinedToCharZ(v));
 }
 
 bool js::ReportValueErrorFlags(JSContext* cx, unsigned flags,
                                const unsigned errorNumber, int spindex,
                                HandleValue v, HandleString fallback,
                                const char* arg1, const char* arg2) {
   MOZ_ASSERT(js_ErrorFormatString[errorNumber].argCount >= 1);
   MOZ_ASSERT(js_ErrorFormatString[errorNumber].argCount <= 3);
--- a/js/src/vm/ToSource.cpp
+++ b/js/src/vm/ToSource.cpp
@@ -9,21 +9,21 @@
 #include "mozilla/ArrayUtils.h"     // mozilla::ArrayLength
 #include "mozilla/Assertions.h"     // MOZ_ASSERT
 #include "mozilla/FloatingPoint.h"  // mozilla::IsNegativeZero
 
 #include <stdint.h>  // uint32_t
 
 #include "jsfriendapi.h"  // CheckRecursionLimit
 
-#include "builtin/Array.h"   // ArrayToSource
+#include "builtin/Array.h"    // ArrayToSource
 #include "builtin/Boolean.h"  // BooleanToString
-#include "builtin/Object.h"  // ObjectToSource
-#include "gc/Allocator.h"    // CanGC
-#include "js/Symbol.h"       // SymbolCode, JS::WellKnownSymbolLimit
+#include "builtin/Object.h"   // ObjectToSource
+#include "gc/Allocator.h"     // CanGC
+#include "js/Symbol.h"        // SymbolCode, JS::WellKnownSymbolLimit
 #include "js/TypeDecls.h"  // Rooted{Function, Object, String, Value}, HandleValue, Latin1Char
 #include "js/Utility.h"         // UniqueChars
 #include "js/Value.h"           // JS::Value
 #include "util/StringBuffer.h"  // JSStringBuilder
 #include "vm/ArrayObject.h"     // ArrayObject
 #include "vm/ErrorObject.h"     // ErrorObject, ErrorToSource
 #include "vm/Interpreter.h"     // Call
 #include "vm/JSContext.h"       // JSContext
--- a/layout/base/nsCounterManager.cpp
+++ b/layout/base/nsCounterManager.cpp
@@ -274,19 +274,19 @@ bool nsCounterManager::AddCounterChanges
                                     nsCounterChangeNode::SET);
     }
   }
   return dirty;
 }
 
 nsCounterList* nsCounterManager::CounterListFor(nsAtom* aCounterName) {
   MOZ_ASSERT(aCounterName);
-  return mNames.LookupForAdd(aCounterName).OrInsert([]() {
-    return new nsCounterList();
-  }).get();
+  return mNames.LookupForAdd(aCounterName)
+      .OrInsert([]() { return new nsCounterList(); })
+      .get();
 }
 
 void nsCounterManager::RecalcAll() {
   for (auto iter = mNames.Iter(); !iter.Done(); iter.Next()) {
     nsCounterList* list = iter.UserData();
     if (list->IsDirty()) {
       list->RecalcAll();
     }
--- a/layout/base/nsCounterManager.h
+++ b/layout/base/nsCounterManager.h
@@ -84,19 +84,18 @@ struct nsCounterUseNode : public nsCount
 
   enum ForLegacyBullet { ForLegacyBullet };
   explicit nsCounterUseNode(enum ForLegacyBullet)
       : nsCounterNode(0, USE), mForLegacyBullet(true) {
     mCounterStyle = nsGkAtoms::list_item;
   }
 
   // args go directly to member variables here and of nsGenConNode
-  nsCounterUseNode(mozilla::CounterStylePtr aCounterStyle,
-                   nsString aSeparator, uint32_t aContentIndex,
-                   bool aAllCounters)
+  nsCounterUseNode(mozilla::CounterStylePtr aCounterStyle, nsString aSeparator,
+                   uint32_t aContentIndex, bool aAllCounters)
       : nsCounterNode(aContentIndex, USE),
         mCounterStyle(std::move(aCounterStyle)),
         mSeparator(std::move(aSeparator)),
         mAllCounters(aAllCounters) {
     NS_ASSERTION(aContentIndex <= INT32_MAX, "out of range");
   }
 
   virtual bool InitTextFrame(nsGenConList* aList, nsIFrame* aPseudoFrame,
--- a/layout/build/nsContentDLF.cpp
+++ b/layout/build/nsContentDLF.cpp
@@ -32,21 +32,19 @@
 // Factory code for creating variations on html documents
 
 #undef NOISY_REGISTRY
 
 using mozilla::dom::Document;
 
 already_AddRefed<nsIContentViewer> NS_NewContentViewer();
 
-static const char* const gHTMLTypes[] = {TEXT_HTML,
-                                         VIEWSOURCE_CONTENT_TYPE,
+static const char* const gHTMLTypes[] = {TEXT_HTML, VIEWSOURCE_CONTENT_TYPE,
                                          APPLICATION_XHTML_XML,
-                                         APPLICATION_WAPXHTML_XML,
-                                         0};
+                                         APPLICATION_WAPXHTML_XML, 0};
 
 static const char* const gXMLTypes[] = {TEXT_XML,
                                         APPLICATION_XML,
                                         APPLICATION_MATHML_XML,
                                         APPLICATION_RDF_XML,
                                         TEXT_RDF,
                                         0};
 
--- a/layout/forms/nsTextControlFrame.h
+++ b/layout/forms/nsTextControlFrame.h
@@ -140,17 +140,17 @@ class nsTextControlFrame : public nsCont
   MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult
   SetFormProperty(nsAtom* aName, const nsAString& aValue) override;
 
   //==== END NSIFORMCONTROLFRAME
 
   //==== NSITEXTCONTROLFRAME
 
   MOZ_CAN_RUN_SCRIPT_BOUNDARY already_AddRefed<mozilla::TextEditor>
-      GetTextEditor() override;
+  GetTextEditor() override;
   MOZ_CAN_RUN_SCRIPT NS_IMETHOD
   SetSelectionRange(uint32_t aSelectionStart, uint32_t aSelectionEnd,
                     SelectionDirection aDirection = eNone) override;
   NS_IMETHOD GetOwnedSelectionController(
       nsISelectionController** aSelCon) override;
   nsFrameSelection* GetOwnedFrameSelection() override;
 
   /**
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -9293,18 +9293,19 @@ static nsRect UnionBorderBoxes(
 
   const nsStyleEffects* effects = aFrame->StyleEffects();
   Maybe<nsRect> clipPropClipRect =
       aFrame->GetClipPropClipRect(disp, effects, bounds.Size());
 
   // Iterate over all children except pop-up, absolutely-positioned,
   // float, and overflow ones.
   const nsIFrame::ChildListIDs skip = {
-      nsIFrame::kPopupList, nsIFrame::kSelectPopupList, nsIFrame::kAbsoluteList,
-      nsIFrame::kFixedList, nsIFrame::kFloatList, nsIFrame::kOverflowList};
+      nsIFrame::kPopupList,    nsIFrame::kSelectPopupList,
+      nsIFrame::kAbsoluteList, nsIFrame::kFixedList,
+      nsIFrame::kFloatList,    nsIFrame::kOverflowList};
   for (nsIFrame::ChildListIterator childLists(aFrame); !childLists.IsDone();
        childLists.Next()) {
     if (skip.contains(childLists.CurrentID())) {
       continue;
     }
 
     nsFrameList children = childLists.CurrentList();
     for (nsFrameList::Enumerator e(children); !e.AtEnd(); e.Next()) {
--- a/layout/style/CSSFontFaceRule.h
+++ b/layout/style/CSSFontFaceRule.h
@@ -17,17 +17,18 @@ namespace dom {
 // A CSSFontFaceRuleDecl is always embeded in a CSSFontFaceRule.
 class CSSFontFaceRule;
 class CSSFontFaceRuleDecl final : public nsICSSDeclaration {
  public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIDOMCSSSTYLEDECLARATION_HELPER
 
   nsINode* GetParentObject() final;
-  void IndexedGetter(uint32_t aIndex, bool& aFound, nsACString& aPropName) final;
+  void IndexedGetter(uint32_t aIndex, bool& aFound,
+                     nsACString& aPropName) final;
 
   void GetPropertyValue(nsCSSFontDesc aFontDescID, nsAString& aResult) const;
 
   JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
 
  protected:
   // For accessing the constructor.
   friend class CSSFontFaceRule;
--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -621,17 +621,18 @@ static void AddImageURL(const StyleCompu
   }
 }
 
 static void AddImageURL(const nsStyleImageRequest& aRequest,
                         nsTArray<nsCString>& aURLs) {
   AddImageURL(aRequest.GetImageValue(), aURLs);
 }
 
-static void AddImageURL(const nsStyleImage& aImage, nsTArray<nsCString>& aURLs) {
+static void AddImageURL(const nsStyleImage& aImage,
+                        nsTArray<nsCString>& aURLs) {
   if (auto* urlValue = aImage.GetURLValue()) {
     AddImageURL(*urlValue, aURLs);
   }
 }
 
 static void AddImageURL(const StyleShapeSource& aShapeSource,
                         nsTArray<nsCString>& aURLs) {
   switch (aShapeSource.GetType()) {
@@ -1557,26 +1558,27 @@ already_AddRefed<CSSValue> nsComputedDOM
     const Span<const StyleCustomIdent> empty;
     for (; line < lastLine; ++line) {
       AppendGridLineNames(valueList, empty, /*aSuppressEmptyList*/ false);
     }
     return valueList.forget();
   }
 
   const bool serializeImplicit =
-    StaticPrefs::layout_css_serialize_grid_implicit_tracks();
+      StaticPrefs::layout_css_serialize_grid_implicit_tracks();
 
   const nsTArray<nscoord>& trackSizes = aTrackInfo.mSizes;
   const uint32_t numExplicitTracks = aTrackInfo.mNumExplicitTracks;
   const uint32_t numLeadingImplicitTracks =
       aTrackInfo.mNumLeadingImplicitTracks;
   uint32_t numSizes = trackSizes.Length();
   MOZ_ASSERT(numSizes >= numLeadingImplicitTracks + numExplicitTracks);
 
-  const bool hasTracksToSerialize = serializeImplicit ? !!numSizes : !!numExplicitTracks;
+  const bool hasTracksToSerialize =
+      serializeImplicit ? !!numSizes : !!numExplicitTracks;
   const bool hasRepeatAuto = aTrackList.HasRepeatAuto();
   if (!hasTracksToSerialize && !hasRepeatAuto) {
     RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
     val->SetIdent(eCSSKeyword_none);
     return val.forget();
   }
 
   // We've done layout on the grid and have resolved the sizes of its tracks,
@@ -1688,18 +1690,18 @@ already_AddRefed<CSSValue> nsComputedDOM
       RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
       val->SetAppUnits(trackSizes[i + numLeadingImplicitTracks]);
       valueList->AppendCSSValue(val.forget());
     }
   }
 
   // Add any trailing implicit tracks.
   if (serializeImplicit) {
-    for (uint32_t i = numLeadingImplicitTracks + numExplicitTracks; i < numSizes;
-         ++i) {
+    for (uint32_t i = numLeadingImplicitTracks + numExplicitTracks;
+         i < numSizes; ++i) {
       RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
       val->SetAppUnits(trackSizes[i]);
       valueList->AppendCSSValue(val.forget());
     }
   }
 
   return valueList.forget();
 }
--- a/layout/style/nsComputedDOMStyle.h
+++ b/layout/style/nsComputedDOMStyle.h
@@ -69,17 +69,18 @@ class nsComputedDOMStyle final : public 
 
   NS_DECL_NSIDOMCSSSTYLEDECLARATION_HELPER
   nsresult GetPropertyValue(const nsCSSPropertyID aPropID,
                             nsAString& aValue) override;
   nsresult SetPropertyValue(const nsCSSPropertyID aPropID,
                             const nsACString& aValue,
                             nsIPrincipal* aSubjectPrincipal) override;
 
-  void IndexedGetter(uint32_t aIndex, bool& aFound, nsACString& aPropName) final;
+  void IndexedGetter(uint32_t aIndex, bool& aFound,
+                     nsACString& aPropName) final;
 
   enum StyleType {
     eDefaultOnly,  // Only includes UA and user sheets
     eAll           // Includes all stylesheets
   };
 
   nsComputedDOMStyle(Element* aElement, const nsAString& aPseudoElt,
                      Document* aDocument, StyleType aStyleType);
--- a/layout/style/nsDOMCSSDeclaration.cpp
+++ b/layout/style/nsDOMCSSDeclaration.cpp
@@ -323,18 +323,19 @@ nsresult nsDOMCSSDeclaration::ParseCusto
   DeclarationBlockMutationClosure closure = {};
   MutationClosureData closureData;
   GetPropertyChangeClosure(&closure, &closureData);
 
   return ModifyDeclaration(
       aSubjectPrincipal, &closureData,
       [&](DeclarationBlock* decl, ParsingEnvironment& env) {
         return Servo_DeclarationBlock_SetProperty(
-            decl->Raw(), &aPropertyName, &aPropValue, aIsImportant, env.mUrlExtraData,
-            ParsingMode::Default, env.mCompatMode, env.mLoader, closure);
+            decl->Raw(), &aPropertyName, &aPropValue, aIsImportant,
+            env.mUrlExtraData, ParsingMode::Default, env.mCompatMode,
+            env.mLoader, closure);
       });
 }
 
 nsresult nsDOMCSSDeclaration::RemovePropertyInternal(nsCSSPropertyID aPropID) {
   DeclarationBlock* olddecl =
       GetOrCreateCSSDeclaration(eOperation_RemoveProperty, nullptr);
   if (IsReadOnly()) {
     return NS_OK;
--- a/layout/style/nsICSSDeclaration.h
+++ b/layout/style/nsICSSDeclaration.h
@@ -113,14 +113,14 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsICSSDecl
                   mozilla::ErrorResult& aRv) override;                        \
   NS_IMETHOD GetPropertyValue(const nsACString& propertyName,                 \
                               nsAString& _retval) override;                   \
   NS_IMETHOD RemoveProperty(const nsACString& propertyName,                   \
                             nsAString& _retval) override;                     \
   void GetPropertyPriority(const nsACString& propertyName,                    \
                            nsAString& aPriority) override;                    \
   NS_IMETHOD SetProperty(const nsACString& propertyName,                      \
-                         const nsACString& value, const nsAString& priority, \
+                         const nsACString& value, const nsAString& priority,  \
                          nsIPrincipal* aSubjectPrincipal = nullptr) override; \
   uint32_t Length() override;                                                 \
   mozilla::css::Rule* GetParentRule() override;
 
 #endif  // nsICSSDeclaration_h__
--- a/layout/style/nsStyleConsts.h
+++ b/layout/style/nsStyleConsts.h
@@ -84,18 +84,18 @@ enum class StyleDisplay : uint16_t {
   RubyText = StyleDisplayFrom(StyleDisplayOutside::InternalRuby,
                               StyleDisplayInside::RubyText),
   RubyTextContainer = StyleDisplayFrom(StyleDisplayOutside::InternalRuby,
                                        StyleDisplayInside::RubyTextContainer),
 
   /// XUL boxes.
   MozBox =
       StyleDisplayFrom(StyleDisplayOutside::Block, StyleDisplayInside::MozBox),
-  MozInlineBox = StyleDisplayFrom(StyleDisplayOutside::Inline,
-                                  StyleDisplayInside::MozBox),
+  MozInlineBox =
+      StyleDisplayFrom(StyleDisplayOutside::Inline, StyleDisplayInside::MozBox),
   MozGrid =
       StyleDisplayFrom(StyleDisplayOutside::XUL, StyleDisplayInside::MozGrid),
   MozGridGroup = StyleDisplayFrom(StyleDisplayOutside::XUL,
                                   StyleDisplayInside::MozGridGroup),
   MozGridLine = StyleDisplayFrom(StyleDisplayOutside::XUL,
                                  StyleDisplayInside::MozGridLine),
   MozDeck =
       StyleDisplayFrom(StyleDisplayOutside::XUL, StyleDisplayInside::MozDeck),
--- a/mfbt/Utf8.h
+++ b/mfbt/Utf8.h
@@ -7,20 +7,20 @@
 /*
  * UTF-8-related functionality, including a type-safe structure representing a
  * UTF-8 code unit.
  */
 
 #ifndef mozilla_Utf8_h
 #define mozilla_Utf8_h
 
-#include "mozilla/Casting.h"            // for mozilla::AssertedCast
-#include "mozilla/Likely.h"             // for MOZ_UNLIKELY
-#include "mozilla/Maybe.h"              // for mozilla::Maybe
-#include "mozilla/Span.h"               // for mozilla::Span
+#include "mozilla/Casting.h"    // for mozilla::AssertedCast
+#include "mozilla/Likely.h"     // for MOZ_UNLIKELY
+#include "mozilla/Maybe.h"      // for mozilla::Maybe
+#include "mozilla/Span.h"       // for mozilla::Span
 #include "mozilla/TextUtils.h"  // for mozilla::IsAscii and via Latin1.h for
                                 // encoding_rs_mem.h and MOZ_HAS_JSRUST.
 #include "mozilla/Tuple.h"      // for mozilla::Tuple
 #include "mozilla/Types.h"      // for MFBT_API
 
 #include <limits>    // for CHAR_BIT / std::numeric_limits
 #include <stddef.h>  // for size_t
 #include <stdint.h>  // for uint8_t
--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -2728,18 +2728,18 @@ nsPrefBranch::RemoveObserverImpl(const n
   // to it. Unregister the callback first, and then let the owning pointer go
   // out of scope and destroy the callback.
   nsCString prefName;
   GetPrefName(aDomain).get(prefName);
   PrefCallback key(prefName, aObserver, this);
   mozilla::UniquePtr<PrefCallback> pCallback;
   mObservers.Remove(&key, &pCallback);
   if (pCallback) {
-    rv = Preferences::UnregisterCallback(NotifyObserver, prefName, pCallback.get(),
-                                         Preferences::PrefixMatch);
+    rv = Preferences::UnregisterCallback(
+        NotifyObserver, prefName, pCallback.get(), Preferences::PrefixMatch);
   }
 
   return rv;
 }
 
 NS_IMETHODIMP
 nsPrefBranch::Observe(nsISupports* aSubject, const char* aTopic,
                       const char16_t* aData) {
--- a/mozglue/tests/interceptor/TestIATPatcher.cpp
+++ b/mozglue/tests/interceptor/TestIATPatcher.cpp
@@ -6,19 +6,17 @@
 
 #include "mozilla/Assertions.h"
 #include "mozilla/DynamicallyLinkedFunctionPtr.h"
 #include "nsWindowsDllInterceptor.h"
 #include "nsWindowsHelpers.h"
 
 #include <shlwapi.h>
 
-static int NormalImport() {
-  return ::GetSystemMetrics(SM_CYCAPTION);
-}
+static int NormalImport() { return ::GetSystemMetrics(SM_CYCAPTION); }
 
 static bool DelayLoadImport() {
   return !!::UrlIsW(L"http://example.com/", URLIS_FILEURL);
 }
 
 static mozilla::WindowsIATPatcher::FuncHookType<decltype(&::GetSystemMetrics)>
     gGetSystemMetricsHook;
 
--- a/netwerk/cache2/CacheFile.cpp
+++ b/netwerk/cache2/CacheFile.cpp
@@ -1211,18 +1211,18 @@ nsresult CacheFile::SetNetworkTimes(uint
 
   uint16_t onStartTime16 = aOnStartTime <= kIndexTimeOutOfBound
                                ? aOnStartTime
                                : kIndexTimeOutOfBound;
   uint16_t onStopTime16 =
       aOnStopTime <= kIndexTimeOutOfBound ? aOnStopTime : kIndexTimeOutOfBound;
 
   if (mHandle && !mHandle->IsDoomed()) {
-    CacheFileIOManager::UpdateIndexEntry(mHandle, nullptr, nullptr,
-                                         &onStartTime16, &onStopTime16, nullptr);
+    CacheFileIOManager::UpdateIndexEntry(
+        mHandle, nullptr, nullptr, &onStartTime16, &onStopTime16, nullptr);
   }
   return NS_OK;
 }
 
 nsresult CacheFile::GetOnStartTime(uint64_t* _retval) {
   CacheFileAutoLock lock(this);
 
   MOZ_ASSERT(mMetadata);
@@ -2534,19 +2534,18 @@ nsresult CacheFile::InitIndexEntry() {
     int64_t n64 = nsDependentCString(contentTypeStr).ToInteger64(&rv);
     if (NS_FAILED(rv) || n64 < nsICacheEntry::CONTENT_TYPE_UNKNOWN ||
         n64 >= nsICacheEntry::CONTENT_TYPE_LAST) {
       n64 = nsICacheEntry::CONTENT_TYPE_UNKNOWN;
     }
     contentType = n64;
   }
 
-  rv = CacheFileIOManager::UpdateIndexEntry(mHandle, &frecency, &hasAltData,
-                                            &onStartTime, &onStopTime,
-                                            &contentType);
+  rv = CacheFileIOManager::UpdateIndexEntry(
+      mHandle, &frecency, &hasAltData, &onStartTime, &onStopTime, &contentType);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 size_t CacheFile::SizeOfExcludingThis(
     mozilla::MallocSizeOf mallocSizeOf) const {
   CacheFileAutoLock lock(const_cast<CacheFile*>(this));
--- a/netwerk/cache2/CacheFileIOManager.cpp
+++ b/netwerk/cache2/CacheFileIOManager.cpp
@@ -1028,23 +1028,22 @@ class UpdateIndexEntryEvent : public Run
   ~UpdateIndexEntryEvent() = default;
 
  public:
   NS_IMETHOD Run() override {
     if (mHandle->IsClosed() || mHandle->IsDoomed()) {
       return NS_OK;
     }
 
-    CacheIndex::UpdateEntry(
-        mHandle->Hash(), mHasFrecency ? &mFrecency : nullptr,
-        mHasHasAltData ? &mHasAltData : nullptr,
-        mHasOnStartTime ? &mOnStartTime : nullptr,
-        mHasOnStopTime ? &mOnStopTime : nullptr,
-        mHasContentType ? &mContentType : nullptr,
-        nullptr);
+    CacheIndex::UpdateEntry(mHandle->Hash(),
+                            mHasFrecency ? &mFrecency : nullptr,
+                            mHasHasAltData ? &mHasAltData : nullptr,
+                            mHasOnStartTime ? &mOnStartTime : nullptr,
+                            mHasOnStopTime ? &mOnStopTime : nullptr,
+                            mHasContentType ? &mContentType : nullptr, nullptr);
     return NS_OK;
   }
 
  protected:
   RefPtr<CacheFileHandle> mHandle;
 
   bool mHasFrecency;
   bool mHasHasAltData;
@@ -3512,20 +3511,22 @@ nsresult CacheFileIOManager::InitIndexEn
                                           ? CacheIOThread::WRITE_PRIORITY
                                           : CacheIOThread::WRITE);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 // static
-nsresult CacheFileIOManager::UpdateIndexEntry(
-    CacheFileHandle* aHandle, const uint32_t* aFrecency,
-    const bool* aHasAltData, const uint16_t* aOnStartTime,
-    const uint16_t* aOnStopTime, const uint8_t* aContentType) {
+nsresult CacheFileIOManager::UpdateIndexEntry(CacheFileHandle* aHandle,
+                                              const uint32_t* aFrecency,
+                                              const bool* aHasAltData,
+                                              const uint16_t* aOnStartTime,
+                                              const uint16_t* aOnStopTime,
+                                              const uint8_t* aContentType) {
   LOG(
       ("CacheFileIOManager::UpdateIndexEntry() [handle=%p, frecency=%s, "
        "hasAltData=%s, onStartTime=%s, onStopTime=%s, contentType=%s]",
        aHandle, aFrecency ? nsPrintfCString("%u", *aFrecency).get() : "",
        aHasAltData ? (*aHasAltData ? "true" : "false") : "",
        aOnStartTime ? nsPrintfCString("%u", *aOnStartTime).get() : "",
        aOnStopTime ? nsPrintfCString("%u", *aOnStopTime).get() : "",
        aContentType ? nsPrintfCString("%u", *aContentType).get() : ""));
--- a/netwerk/cache2/CacheIndex.cpp
+++ b/netwerk/cache2/CacheIndex.cpp
@@ -920,21 +920,23 @@ nsresult CacheIndex::RemoveEntry(const S
 
   index->StartUpdatingIndexIfNeeded();
   index->WriteIndexToDiskIfNeeded();
 
   return NS_OK;
 }
 
 // static
-nsresult CacheIndex::UpdateEntry(
-    const SHA1Sum::Hash* aHash, const uint32_t* aFrecency,
-    const bool* aHasAltData, const uint16_t* aOnStartTime,
-    const uint16_t* aOnStopTime, const uint8_t* aContentType,
-    const uint32_t* aSize) {
+nsresult CacheIndex::UpdateEntry(const SHA1Sum::Hash* aHash,
+                                 const uint32_t* aFrecency,
+                                 const bool* aHasAltData,
+                                 const uint16_t* aOnStartTime,
+                                 const uint16_t* aOnStopTime,
+                                 const uint8_t* aContentType,
+                                 const uint32_t* aSize) {
   LOG(
       ("CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, "
        "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, "
        "contentType=%s, size=%s]",
        LOGSHA1(aHash), aFrecency ? nsPrintfCString("%u", *aFrecency).get() : "",
        aHasAltData ? (*aHasAltData ? "true" : "false") : "",
        aOnStartTime ? nsPrintfCString("%u", *aOnStartTime).get() : "",
        aOnStopTime ? nsPrintfCString("%u", *aOnStopTime).get() : "",
@@ -971,19 +973,18 @@ nsresult CacheIndex::UpdateEntry(
 
       if (!entry) {
         LOG(("CacheIndex::UpdateEntry() - Entry was not found in mIndex!"));
         NS_WARNING(
             ("CacheIndex::UpdateEntry() - Entry was not found in mIndex!"));
         return NS_ERROR_UNEXPECTED;
       }
 
-      if (!HasEntryChanged(
-              entry, aFrecency, aHasAltData, aOnStartTime, aOnStopTime,
-              aContentType, aSize)) {
+      if (!HasEntryChanged(entry, aFrecency, aHasAltData, aOnStartTime,
+                           aOnStopTime, aContentType, aSize)) {
         return NS_OK;
       }
 
       MOZ_ASSERT(entry->IsFresh());
       MOZ_ASSERT(entry->IsInitialized());
       entry->MarkDirty();
 
       if (aFrecency) {
--- a/netwerk/cache2/CacheIndex.h
+++ b/netwerk/cache2/CacheIndex.h
@@ -677,21 +677,23 @@ class CacheIndex final : public CacheFil
 
   // Remove entry from index. The entry should be present in index.
   static nsresult RemoveEntry(const SHA1Sum::Hash* aHash);
 
   // Update some information in entry. The entry MUST be present in index and
   // MUST be initialized. Call to AddEntry() or EnsureEntryExists() and to
   // InitEntry() must precede the call to this method.
   // Pass nullptr if the value didn't change.
-  static nsresult UpdateEntry(
-      const SHA1Sum::Hash* aHash, const uint32_t* aFrecency,
-      const bool* aHasAltData, const uint16_t* aOnStartTime,
-      const uint16_t* aOnStopTime, const uint8_t* aContentType,
-      const uint32_t* aSize);
+  static nsresult UpdateEntry(const SHA1Sum::Hash* aHash,
+                              const uint32_t* aFrecency,
+                              const bool* aHasAltData,
+                              const uint16_t* aOnStartTime,
+                              const uint16_t* aOnStopTime,
+                              const uint8_t* aContentType,
+                              const uint32_t* aSize);
 
   // Remove all entries from the index. Called when clearing the whole cache.
   static nsresult RemoveAll();
 
   enum EntryStatus { EXISTS = 0, DOES_NOT_EXIST = 1, DO_NOT_KNOW = 2 };
 
   // Returns status of the entry in index for the given key. It can be called
   // on any thread.
@@ -784,21 +786,23 @@ class CacheIndex final : public CacheFil
   // This method checks whether the entry has the same values of
   // originAttributes and isAnonymous. We don't expect to find a collision
   // since these values are part of the key that we hash and we use a strong
   // hash function.
   static bool IsCollision(CacheIndexEntry* aEntry,
                           OriginAttrsHash aOriginAttrsHash, bool aAnonymous);
 
   // Checks whether any of the information about the entry has changed.
-  static bool HasEntryChanged(
-      CacheIndexEntry* aEntry, const uint32_t* aFrecency,
-      const bool* aHasAltData, const uint16_t* aOnStartTime,
-      const uint16_t* aOnStopTime, const uint8_t* aContentType,
-      const uint32_t* aSize);
+  static bool HasEntryChanged(CacheIndexEntry* aEntry,
+                              const uint32_t* aFrecency,
+                              const bool* aHasAltData,
+                              const uint16_t* aOnStartTime,
+                              const uint16_t* aOnStopTime,
+                              const uint8_t* aContentType,
+                              const uint32_t* aSize);
 
   // Merge all pending operations from mPendingUpdates into mIndex.
   void ProcessPendingOperations();
 
   // Following methods perform writing of the index file.
   //
   // The index is written periodically, but not earlier than once in
   // kMinDumpInterval and there must be at least kMinUnwrittenChanges
--- a/netwerk/protocol/http/Http3Session.cpp
+++ b/netwerk/protocol/http/Http3Session.cpp
@@ -448,18 +448,17 @@ nsresult Http3Session::ProcessOutputAndE
     mSegmentReaderWriter = nullptr;
   }
   return NS_OK;
 }
 
 void Http3Session::SetupTimer(uint64_t aTimeout) {
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
 
-  LOG(("Http3Session::SetupTimer to %" PRIu64 "ms [this=%p].", aTimeout,
-       this));
+  LOG(("Http3Session::SetupTimer to %" PRIu64 "ms [this=%p].", aTimeout, this));
   if (!mTimer) {
     mTimer = NS_NewTimer();
   }
 
   if (!mTimer || NS_FAILED(mTimer->InitWithCallback(this, aTimeout,
                                                     nsITimer::TYPE_ONE_SHOT))) {
     NS_DispatchToCurrentThread(
         NewRunnableMethod("net::Http3Session::ProcessOutputAndEvents", this,
--- a/netwerk/protocol/http/nsHttpAuthCache.h
+++ b/netwerk/protocol/http/nsHttpAuthCache.h
@@ -143,17 +143,18 @@ class nsHttpAuthNode {
   void ClearAuthEntry(const char* realm);
 
   uint32_t EntryCount() { return mList.Length(); }
 
  private:
   nsTArray<nsAutoPtr<nsHttpAuthEntry> > mList;
 
   friend class nsHttpAuthCache;
-  friend class mozilla::DefaultDelete<nsHttpAuthNode>; // needs to call the destructor
+  friend class mozilla::DefaultDelete<nsHttpAuthNode>;  // needs to call the
+                                                        // destructor
 };
 
 //-----------------------------------------------------------------------------
 // nsHttpAuthCache
 //  (holds a hash table from host:port to nsHttpAuthNode)
 //-----------------------------------------------------------------------------
 
 class nsHttpAuthCache {
--- a/netwerk/protocol/http/nsHttpHandler.h
+++ b/netwerk/protocol/http/nsHttpHandler.h
@@ -767,16 +767,17 @@ class nsHttpHandler final : public nsIHt
   // to the parent process.  On the content process then we just update this
   // value from ipc onstoprequest arguments.  This is a sufficent way of passing
   // it down to the content process, since the value will be used only after
   // onstoprequest notification coming from an http channel.
   Mutex mLastActiveTabLoadOptimizationLock;
   TimeStamp mLastActiveTabLoadOptimizationHit;
 
   Mutex mSpdyBlacklistLock;
+
  public:
   MOZ_MUST_USE nsresult NewChannelId(uint64_t& channelId);
 
   void BlacklistSpdy(const nsHttpConnectionInfo* ci);
   MOZ_MUST_USE bool IsSpdyBlacklisted(const nsHttpConnectionInfo* ci);
 
  private:
   nsTHashtable<nsCStringHashKey> mBlacklistedSpdyOrigins;
--- a/parser/htmlparser/nsExpatDriver.cpp
+++ b/parser/htmlparser/nsExpatDriver.cpp
@@ -276,18 +276,19 @@ void nsExpatDriver::HandleStartElement(v
   for (attrArrayLength = XML_GetSpecifiedAttributeCount(self->mExpatParser);
        aAtts[attrArrayLength]; attrArrayLength += 2) {
     // Just looping till we find out what the length is
   }
 
   if (self->mSink) {
     // We store the tagdepth in a PRUint16, so make sure the limit fits in a
     // PRUint16.
-    static_assert(sMaxXMLTreeDepth <=
-                  std::numeric_limits<decltype(nsExpatDriver::mTagDepth)>::max());
+    static_assert(
+        sMaxXMLTreeDepth <=
+        std::numeric_limits<decltype(nsExpatDriver::mTagDepth)>::max());
 
     if (++self->mTagDepth > sMaxXMLTreeDepth) {
       self->MaybeStopParser(NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP);
       return;
     }
 
     nsresult rv = self->mSink->HandleStartElement(
         aName, aAtts, attrArrayLength,
--- a/toolkit/recordreplay/Assembler.cpp
+++ b/toolkit/recordreplay/Assembler.cpp
@@ -9,30 +9,27 @@
 #include "ProcessRecordReplay.h"
 
 #include <sys/mman.h>
 
 namespace mozilla {
 namespace recordreplay {
 
 Assembler::Assembler(uint8_t* aStorage, size_t aSize)
-    : mCursor(aStorage),
-      mCursorEnd(aStorage + aSize) {}
+    : mCursor(aStorage), mCursorEnd(aStorage + aSize) {}
 
 // The maximum byte length of an x86/x64 instruction.
 static const size_t MaximumInstructionLength = 15;
 
 void Assembler::Advance(size_t aSize) {
   mCursor += aSize;
   MOZ_RELEASE_ASSERT(mCursor + MaximumInstructionLength <= mCursorEnd);
 }
 
-uint8_t* Assembler::Current() {
-  return mCursor;
-}
+uint8_t* Assembler::Current() { return mCursor; }
 
 void Assembler::Jump(void* aTarget) {
   PushImmediate(aTarget);
   Return();
 }
 
 void Assembler::PushImmediate(void* aValue) {
   // Push the target literal onto the stack, 2 bytes at a time. This is
@@ -48,23 +45,19 @@ void Assembler::PushImmediate(void* aVal
 void Assembler::Push16(uint16_t aValue) {
   uint8_t* ip = Current();
   ip[0] = 0x66;
   ip[1] = 0x68;
   *reinterpret_cast<uint16_t*>(ip + 2) = aValue;
   Advance(4);
 }
 
-void Assembler::Return() {
-  NewInstruction(0xC3);
-}
+void Assembler::Return() { NewInstruction(0xC3); }
 
-void Assembler::Breakpoint() {
-  NewInstruction(0xCC);
-}
+void Assembler::Breakpoint() { NewInstruction(0xCC); }
 
 void Assembler::PushRax() { NewInstruction(0x50); }
 
 void Assembler::PopRax() { NewInstruction(0x58); }
 
 void Assembler::PopRegister(Register aRegister) {
   if (aRegister <= Register::RDI) {
     NewInstruction(0x58 + (int)aRegister - (int)Register::RAX);
@@ -86,17 +79,18 @@ void Assembler::MoveRaxToRegister(Regist
     NewInstruction(0x48, 0x89, 0xC0 + (int)aRegister - (int)Register::RAX);
   } else {
     NewInstruction(0x49, 0x89, 0xC0 + (int)aRegister - (int)Register::R8);
   }
 }
 
 void Assembler::MoveRegisterToRax(Register aRegister) {
   if (aRegister <= Register::RDI) {
-    NewInstruction(0x48, 0x89, 0xC0 + ((int)aRegister - (int)Register::RAX) * 8);
+    NewInstruction(0x48, 0x89,
+                   0xC0 + ((int)aRegister - (int)Register::RAX) * 8);
   } else {
     NewInstruction(0x4C, 0x89, 0xC0 + ((int)aRegister - (int)Register::R8) * 8);
   }
 }
 
 static uint8_t* PageStart(uint8_t* aPtr) {
   static_assert(sizeof(size_t) == sizeof(uintptr_t), "Unsupported Platform");
   return reinterpret_cast<uint8_t*>(reinterpret_cast<size_t>(aPtr) &
--- a/toolkit/recordreplay/Assembler.h
+++ b/toolkit/recordreplay/Assembler.h
@@ -11,17 +11,32 @@
 
 #include <utility>
 
 namespace mozilla {
 namespace recordreplay {
 
 // x86-64 general purpose registers.
 enum class Register {
-  RAX, RCX, RDX, RBX, RSP, RBP, RSI, RDI, R8, R9, R10, R11, R12, R13, R14, R15,
+  RAX,
+  RCX,
+  RDX,
+  RBX,
+  RSP,
+  RBP,
+  RSI,
+  RDI,
+  R8,
+  R9,
+  R10,
+  R11,
+  R12,
+  R13,
+  R14,
+  R15,
 };
 
 // Assembler for x64 instructions. This is a simple assembler that is primarily
 // designed for use in copying instructions from a function that is being
 // redirected.
 class Assembler {
  public:
   Assembler(uint8_t* aStorage, size_t aSize);
--- a/toolkit/recordreplay/ExternalCall.cpp
+++ b/toolkit/recordreplay/ExternalCall.cpp
@@ -90,29 +90,29 @@ bool OnExternalCall(size_t aCallId, Call
   MOZ_RELEASE_ASSERT(redirection.mExternalCall);
 
   const char* messageName = "";
   if (!strcmp(redirection.mName, "objc_msgSend")) {
     messageName = aArguments->Arg<1, const char*>();
   }
 
   if (aDiverged) {
-    PrintSpew("OnExternalCall Diverged %s %s\n", redirection.mName, messageName);
+    PrintSpew("OnExternalCall Diverged %s %s\n", redirection.mName,
+              messageName);
   }
 
   MonitorAutoLock lock(*gMonitor);
 
   // Allocate the new ExternalCall.
   ExternalCall* call = new ExternalCall();
   call->mCallId = aCallId;
 
   // Save all the call's inputs.
   {
-    ExternalCallContext cx(call, aArguments,
-                           ExternalCallPhase::SaveInput);
+    ExternalCallContext cx(call, aArguments, ExternalCallPhase::SaveInput);
     redirection.mExternalCall(cx);
     if (cx.mFailed) {
       delete call;
       if (child::CurrentRepaintCannotFail() && aDiverged) {
         child::ReportFatalError("External call input failed: %s\n",
                                 redirection.mName);
       }
       return false;
@@ -140,18 +140,17 @@ bool OnExternalCall(size_t aCallId, Call
       return true;
     }
   }
 
   // If we have not diverged from the recording, we already have the outputs
   // we need. Run the SaveOutput phase to capture these so that we can reuse
   // them later and associate any system outputs with the call.
   if (!aDiverged) {
-    ExternalCallContext cx(call, aArguments,
-                           ExternalCallPhase::SaveOutput);
+    ExternalCallContext cx(call, aArguments, ExternalCallPhase::SaveOutput);
     redirection.mExternalCall(cx);
     if (isNewCall) {
       gUnflushedCalls.append(call);
     }
     return true;
   }
 
   PrintSpew("OnExternalCall Send %s %s\n", redirection.mName, messageName);
@@ -164,19 +163,18 @@ bool OnExternalCall(size_t aCallId, Call
   InfallibleVector<char> inputData;
   BufferStream inputStream(&inputData);
   for (int i = outgoingCalls.length() - 1; i >= 0; i--) {
     outgoingCalls[i]->EncodeInput(inputStream);
   }
 
   // Synchronously wait for the call result.
   InfallibleVector<char> outputData;
-  child::SendExternalCallRequest(call->mId,
-                                 inputData.begin(), inputData.length(),
-                                 &outputData);
+  child::SendExternalCallRequest(call->mId, inputData.begin(),
+                                 inputData.length(), &outputData);
 
   // Decode the external call's output.
   BufferStream outputStream(outputData.begin(), outputData.length());
   call->DecodeOutput(outputStream);
 
   ExternalCallContext cx(call, aArguments, ExternalCallPhase::RestoreOutput);
   redirection.mExternalCall(cx);
   return true;
@@ -411,19 +409,19 @@ void EX_SystemOutput(ExternalCallContext
       }
       if (aliasedCall.isSome()) {
         auto iter = gState->mCallsById.find(aliasedCall.ref());
         if (iter != gState->mCallsById.end()) {
           *aOutput = iter->second;
           break;
         }
         // If we haven't encountered the aliased call, fall through and generate
-        // a new value for it. Aliases might be spurious if they were derived from
-        // the recording and reflect a value that was released and had its memory
-        // reused.
+        // a new value for it. Aliases might be spurious if they were derived
+        // from the recording and reflect a value that was released and had its
+        // memory reused.
       }
       *aOutput = MangledSystemValue(aCx.mCall->mId);
     } while (false);
 
     SetExternalCallValue(aCx.mCall, *aOutput);
   }
 }
 
--- a/toolkit/recordreplay/ExternalCall.h
+++ b/toolkit/recordreplay/ExternalCall.h
@@ -165,19 +165,17 @@ struct ExternalCallContext {
 
   // If we are running the SaveOutput phase in an external process, a list of
   // callbacks which will release all system resources created by by the call.
   typedef InfallibleVector<std::function<void()>> ReleaseCallbackVector;
   ReleaseCallbackVector* mReleaseCallbacks = nullptr;
 
   ExternalCallContext(ExternalCall* aCall, CallArguments* aArguments,
                       ExternalCallPhase aPhase)
-      : mCall(aCall),
-        mArguments(aArguments),
-        mPhase(aPhase) {
+      : mCall(aCall), mArguments(aArguments), mPhase(aPhase) {
     switch (mPhase) {
       case ExternalCallPhase::SaveInput:
         mInputStream.emplace(&mCall->mInput);
         break;
       case ExternalCallPhase::RestoreInput:
         mInputStream.emplace(mCall->mInput.begin(), mCall->mInput.length());
         break;
       case ExternalCallPhase::SaveOutput:
@@ -213,17 +211,18 @@ struct ExternalCallContext {
 
   size_t ReadInputScalar() {
     MOZ_RELEASE_ASSERT(mPhase == ExternalCallPhase::RestoreInput);
     return mInputStream.ref().ReadScalar();
   }
 
   bool AccessInput() { return mInputStream.isSome(); }
 
-  void ReadOrWriteInputBytes(void* aBuffer, size_t aSize, bool aExcludeInput = false) {
+  void ReadOrWriteInputBytes(void* aBuffer, size_t aSize,
+                             bool aExcludeInput = false) {
     switch (mPhase) {
       case ExternalCallPhase::SaveInput:
         // Only one buffer can be excluded, and it has to be the last input to
         // the external call.
         MOZ_RELEASE_ASSERT(!mCall->mExcludeInput);
         if (aExcludeInput) {
           mCall->mExcludeInput = mCall->mInput.length();
         }
@@ -293,18 +292,17 @@ struct ExternalCallContext {
   void* AllocateBytes(size_t aSize);
 };
 
 // Notify the system about a call to a redirection with an external call hook.
 // aDiverged is set if the current thread has diverged from the recording and
 // any outputs for the call must be filled in; otherwise, they already have
 // been filled in using data from the recording. Returns false if the call was
 // unable to be processed.
-bool OnExternalCall(size_t aCallId, CallArguments* aArguments,
-                    bool aDiverged);
+bool OnExternalCall(size_t aCallId, CallArguments* aArguments, bool aDiverged);
 
 // In the external process, perform one or more calls encoded in aInputData
 // and encode the output of the final call in aOutputData.
 void ProcessExternalCall(const char* aInputData, size_t aInputSize,
                          InfallibleVector<char>* aOutputData);
 
 // In a replaying process, flush all new external call found in the recording
 // since the last flush to the root replaying process.
@@ -370,19 +368,18 @@ static inline void EX_InParam(ExternalCa
   }
 }
 
 // Capture a C string argument.
 template <size_t StringArg>
 static inline void EX_CString(ExternalCallContext& aCx) {
   if (aCx.AccessInput()) {
     auto& buffer = aCx.mArguments->Arg<StringArg, char*>();
-    size_t len = (aCx.mPhase == ExternalCallPhase::SaveInput)
-                     ? strlen(buffer) + 1
-                     : 0;
+    size_t len =
+        (aCx.mPhase == ExternalCallPhase::SaveInput) ? strlen(buffer) + 1 : 0;
     aCx.ReadOrWriteInputBytes(&len, sizeof(len));
     aCx.ReadOrWriteInputBuffer((void**)&buffer, len);
   }
 }
 
 // Capture the data written to an output buffer at BufferArg with element count
 // at CountArg.
 template <size_t BufferArg, size_t CountArg, typename ElemType>
@@ -420,19 +417,19 @@ static inline void EX_StackArgumentData(
 static inline void EX_SkipExecuting(ExternalCallContext& aCx) {
   if (aCx.mPhase == ExternalCallPhase::RestoreInput) {
     aCx.mSkipExecuting = true;
   }
 }
 
 static inline void EX_NoOp(ExternalCallContext& aCx) {}
 
-template <ExternalCallFn Fn0, ExternalCallFn Fn1,
-          ExternalCallFn Fn2 = EX_NoOp, ExternalCallFn Fn3 = EX_NoOp,
-          ExternalCallFn Fn4 = EX_NoOp, ExternalCallFn Fn5 = EX_NoOp>
+template <ExternalCallFn Fn0, ExternalCallFn Fn1, ExternalCallFn Fn2 = EX_NoOp,
+          ExternalCallFn Fn3 = EX_NoOp, ExternalCallFn Fn4 = EX_NoOp,
+          ExternalCallFn Fn5 = EX_NoOp>
 static inline void EX_Compose(ExternalCallContext& aCx) {
   Fn0(aCx);
   Fn1(aCx);
   Fn2(aCx);
   Fn3(aCx);
   Fn4(aCx);
   Fn5(aCx);
 }
--- a/toolkit/recordreplay/ProcessRecordReplay.cpp
+++ b/toolkit/recordreplay/ProcessRecordReplay.cpp
@@ -226,28 +226,31 @@ MOZ_EXPORT void RecordReplayInterface_In
   if (IsRecording()) {
     child::ReportFatalError("Recording invalidated: %s", aWhy);
   } else {
     child::ReportFatalError("Recording invalidated while replaying: %s", aWhy);
   }
   Unreachable();
 }
 
-MOZ_EXPORT void RecordReplayInterface_InternalBeginPassThroughThreadEventsWithLocalReplay() {
+MOZ_EXPORT void
+RecordReplayInterface_InternalBeginPassThroughThreadEventsWithLocalReplay() {
   if (IsReplaying() && !gReplayingInCloud) {
     BeginPassThroughThreadEvents();
   }
 }
 
-MOZ_EXPORT void RecordReplayInterface_InternalEndPassThroughThreadEventsWithLocalReplay() {
+MOZ_EXPORT void
+RecordReplayInterface_InternalEndPassThroughThreadEventsWithLocalReplay() {
   // If we are replaying locally we will be skipping over a section of the
   // recording while events are passed through. Include the current stream
   // position in the recording so that we will know how much to skip over.
   MOZ_RELEASE_ASSERT(Thread::CurrentIsMainThread());
-  Stream* localReplayStream = gRecording->OpenStream(StreamName::LocalReplaySkip, 0);
+  Stream* localReplayStream =
+      gRecording->OpenStream(StreamName::LocalReplaySkip, 0);
   Stream& events = Thread::Current()->Events();
 
   size_t position = IsRecording() ? events.StreamPosition() : 0;
   localReplayStream->RecordOrReplayScalar(&position);
 
   if (IsReplaying() && !ReplayingInCloud()) {
     EndPassThroughThreadEvents();
     MOZ_RELEASE_ASSERT(events.StreamPosition() <= position);
@@ -274,19 +277,20 @@ void FlushRecording() {
   Stream* endpointStream = gRecording->OpenStream(StreamName::Endpoint, 0);
   endpointStream->WriteScalar(endpoint);
 
   gRecording->PreventStreamWrites();
   gRecording->Flush();
   gRecording->AllowStreamWrites();
 
   if (gRecording->Size() > gRecordingDataSentToMiddleman) {
-    child::SendRecordingData(gRecordingDataSentToMiddleman,
-                             gRecording->Data() + gRecordingDataSentToMiddleman,
-                             gRecording->Size() - gRecordingDataSentToMiddleman);
+    child::SendRecordingData(
+        gRecordingDataSentToMiddleman,
+        gRecording->Data() + gRecordingDataSentToMiddleman,
+        gRecording->Size() - gRecordingDataSentToMiddleman);
     gRecordingDataSentToMiddleman = gRecording->Size();
   }
 }
 
 void HitEndOfRecording() {
   MOZ_RELEASE_ASSERT(IsReplaying());
   MOZ_RELEASE_ASSERT(!AreThreadEventsPassedThrough());
 
@@ -479,23 +483,23 @@ static void CrashDetectorThread(void*) {
                     MACH_PORT_NULL);
     Print("Crashing: %s\n", gMozCrashReason);
 
     kern_return_t replyCode = KERN_FAILURE;
     if (kret == KERN_SUCCESS && request.body.Head.msgh_id == sExceptionId &&
         request.body.exception == EXC_BAD_ACCESS && request.body.codeCnt == 2) {
       uint8_t* faultingAddress = (uint8_t*)request.body.code[1];
       child::MinidumpInfo info(request.body.exception, request.body.code[0],
-                               request.body.code[1],
-                               request.body.thread.name,
+                               request.body.code[1], request.body.thread.name,
                                request.body.task.name);
       child::ReportCrash(info, faultingAddress);
     } else {
-      child::ReportFatalError("CrashDetectorThread mach_msg "
-                              "returned unexpected data");
+      child::ReportFatalError(
+          "CrashDetectorThread mach_msg "
+          "returned unexpected data");
     }
 
     __Reply__exception_raise_t reply;
     reply.Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(request.body.Head.msgh_bits), 0);
     reply.Head.msgh_size = sizeof(reply);
     reply.Head.msgh_remote_port = request.body.Head.msgh_remote_port;
     reply.Head.msgh_local_port = MACH_PORT_NULL;
--- a/toolkit/recordreplay/ProcessRedirect.cpp
+++ b/toolkit/recordreplay/ProcessRedirect.cpp
@@ -300,26 +300,29 @@ MOZ_NEVER_INLINE void RecordReplayInvoke
 ///////////////////////////////////////////////////////////////////////////////
 
 uint8_t* GenerateRedirectStub(Assembler& aAssembler, size_t aCallId,
                               bool aPreserveCallerSaveRegisters) {
   // Generate code to set %rax and enter RecordReplayRedirectCall.
   uint8_t* newFunction = aAssembler.Current();
   if (aPreserveCallerSaveRegisters) {
     static Register registers[] = {
-      Register::RDI, Register::RDI /* for alignment */,
-      Register::RSI, Register::RDX, Register::RCX,
-      Register::R8, Register::R9, Register::R10, Register::R11,
+        Register::RDI, Register::RDI /* for alignment */,
+        Register::RSI, Register::RDX,
+        Register::RCX, Register::R8,
+        Register::R9,  Register::R10,
+        Register::R11,
     };
     for (size_t i = 0; i < ArrayLength(registers); i++) {
       aAssembler.MoveRegisterToRax(registers[i]);
       aAssembler.PushRax();
     }
     aAssembler.MoveImmediateToRax((void*)aCallId);
-    uint8_t* after = aAssembler.Current() + Assembler::PushImmediateBytes + Assembler::JumpBytes;
+    uint8_t* after = aAssembler.Current() + Assembler::PushImmediateBytes +
+                     Assembler::JumpBytes;
     aAssembler.PushImmediate(after);
     aAssembler.Jump(BitwiseCast<void*>(RecordReplayRedirectCall));
     for (int i = ArrayLength(registers) - 1; i >= 0; i--) {
       aAssembler.PopRegister(registers[i]);
     }
     aAssembler.Return();
   } else {
     aAssembler.MoveImmediateToRax((void*)aCallId);
--- a/toolkit/recordreplay/ProcessRedirect.h
+++ b/toolkit/recordreplay/ProcessRedirect.h
@@ -84,29 +84,29 @@ namespace recordreplay {
 // to the function originally. For functions with complex or floating point
 // arguments and return values, the right index to use might be different than
 // expected, per the requirements of the System V x64 ABI.
 struct CallArguments {
   // The maximum number of stack arguments that can be captured.
   static const size_t NumStackArguments = 64;
 
  protected:
-  size_t arg0;        // 0
-  size_t arg1;        // 8
-  size_t arg2;        // 16
-  size_t arg3;        // 24
-  size_t arg4;        // 32
-  size_t arg5;        // 40
-  double floatarg0;   // 48
-  double floatarg1;   // 56
-  double floatarg2;   // 64
-  size_t rval0;       // 72
-  size_t rval1;       // 80
-  double floatrval0;  // 88
-  double floatrval1;  // 96
+  size_t arg0;                      // 0
+  size_t arg1;                      // 8
+  size_t arg2;                      // 16
+  size_t arg3;                      // 24
+  size_t arg4;                      // 32
+  size_t arg5;                      // 40
+  double floatarg0;                 // 48
+  double floatarg1;                 // 56
+  double floatarg2;                 // 64
+  size_t rval0;                     // 72
+  size_t rval1;                     // 80
+  double floatrval0;                // 88
+  double floatrval1;                // 96
   size_t stack[NumStackArguments];  // 104
                                     // Size: 616
 
  public:
   template <typename T>
   T& Arg(size_t aIndex) {
     static_assert(sizeof(T) == sizeof(size_t), "Size must match");
     static_assert(IsFloatingPoint<T>::value == false, "Use FloatArg");
--- a/toolkit/recordreplay/ProcessRedirectDarwin.cpp
+++ b/toolkit/recordreplay/ProcessRedirectDarwin.cpp
@@ -243,17 +243,17 @@ static void EX_ObjCInput(ExternalCallCon
       // on the fly and don't have correct contents. Parse the contents we are
       // given so we can do a dynamic lookup and generate the right string.
       static const char cloudPrefix[] = "RECORD_REPLAY_STRING:";
       if (len >= sizeof(cloudPrefix) &&
           !memcmp(cstring.get(), cloudPrefix, sizeof(cloudPrefix))) {
         MOZ_RELEASE_ASSERT(cstring.get()[len - 1] == 0);
         void* ptr = dlsym(RTLD_DEFAULT, cstring.get() + strlen(cloudPrefix));
         MOZ_RELEASE_ASSERT(ptr);
-        *aThingPtr = (id)*(CFStringRef*)ptr;
+        *aThingPtr = (id) * (CFStringRef*)ptr;
         break;
       }
 
       NS_ConvertUTF8toUTF16 converted(cstring.get(), len);
       UniquePtr<UniChar[]> contents(new UniChar[len]);
       memcpy(contents.get(), converted.get(), len * sizeof(UniChar));
       *aThingPtr = (id)CFStringCreateWithCharacters(kCFAllocatorDefault,
                                                     contents.get(), len);
@@ -298,17 +298,17 @@ static void EX_CreateCFTypeRval(External
   EX_CFTypeOutput(aCx, &rval, /* aOwnsReference = */ true);
 }
 
 template <size_t Argument>
 static void EX_CFTypeOutputArg(ExternalCallContext& aCx) {
   auto& arg = aCx.mArguments->Arg<Argument, const void**>();
 
   if (aCx.mPhase == ExternalCallPhase::RestoreInput) {
-    arg = (const void**) aCx.AllocateBytes(sizeof(const void*));
+    arg = (const void**)aCx.AllocateBytes(sizeof(const void*));
   }
 
   EX_CFTypeOutput(aCx, arg, /* aOwnsReference = */ false);
 }
 
 static void SendMessageToObject(const void* aObject, const char* aMessage) {
   CallArguments arguments;
   arguments.Arg<0, const void*>() = aObject;
@@ -319,19 +319,18 @@ static void SendMessageToObject(const vo
 // For APIs whose result will be released by the middleman's autorelease pool.
 static void EX_AutoreleaseCFTypeRval(ExternalCallContext& aCx) {
   auto& rvalReference = aCx.mArguments->Rval<const void*>();
   EX_SystemOutput(aCx, &rvalReference);
   const void* rval = rvalReference;
 
   if (rval && aCx.mPhase == ExternalCallPhase::SaveOutput && !IsReplaying()) {
     SendMessageToObject(rval, "retain");
-    aCx.mReleaseCallbacks->append([=]() {
-        SendMessageToObject(rval, "autorelease");
-      });
+    aCx.mReleaseCallbacks->append(
+        [=]() { SendMessageToObject(rval, "autorelease"); });
   }
 }
 
 // For functions which have an input CFType value and also have side effects on
 // that value, this associates the call with its own input value so that this
 // will be treated as a dependent for any future calls using the value.
 template <size_t Argument>
 static void EX_UpdateCFTypeArg(ExternalCallContext& aCx) {
@@ -343,55 +342,56 @@ static void EX_UpdateCFTypeArg(ExternalC
 
 template <int Error = EAGAIN>
 static PreambleResult Preamble_SetError(CallArguments* aArguments) {
   aArguments->Rval<ssize_t>() = -1;
   errno = Error;
   return PreambleResult::Veto;
 }
 
-#define ForEachFixedInputAddress(Macro)                 \
-  Macro(kCFTypeArrayCallBacks)                          \
-  Macro(kCFTypeDictionaryKeyCallBacks)                  \
-  Macro(kCFTypeDictionaryValueCallBacks)
-
-#define ForEachFixedInput(Macro)                \
-  Macro(kCFAllocatorDefault)                    \
-  Macro(kCFAllocatorNull)
+#define ForEachFixedInputAddress(Macro)                             \
+  Macro(kCFTypeArrayCallBacks) Macro(kCFTypeDictionaryKeyCallBacks) \
+      Macro(kCFTypeDictionaryValueCallBacks)
+
+#define ForEachFixedInput(Macro) \
+  Macro(kCFAllocatorDefault) Macro(kCFAllocatorNull)
 
 enum class FixedInput {
 #define DefineEnum(Name) Name,
-  ForEachFixedInputAddress(DefineEnum)
-  ForEachFixedInput(DefineEnum)
+  ForEachFixedInputAddress(DefineEnum) ForEachFixedInput(DefineEnum)
 #undef DefineEnum
 };
 
 static const void* GetFixedInput(FixedInput aWhich) {
   switch (aWhich) {
-#define FetchEnumAddress(Name) case FixedInput::Name: return &Name;
+#define FetchEnumAddress(Name) \
+  case FixedInput::Name:       \
+    return &Name;
     ForEachFixedInputAddress(FetchEnumAddress)
 #undef FetchEnumAddress
-#define FetchEnum(Name) case FixedInput::Name: return Name;
-    ForEachFixedInput(FetchEnum)
+#define FetchEnum(Name)  \
+  case FixedInput::Name: \
+    return Name;
+        ForEachFixedInput(FetchEnum)
 #undef FetchEnum
   }
   MOZ_CRASH("Unknown fixed input");
   return nullptr;
 }
 
 template <size_t Arg, FixedInput Which>
 static void EX_RequireFixed(ExternalCallContext& aCx) {
   auto& arg = aCx.mArguments->Arg<Arg, const void*>();
 
   if (aCx.AccessInput()) {
     const void* value = GetFixedInput(Which);
     if (aCx.mPhase == ExternalCallPhase::SaveInput) {
-      MOZ_RELEASE_ASSERT(arg == value ||
-                         (Which == FixedInput::kCFAllocatorDefault &&
-                          arg == nullptr));
+      MOZ_RELEASE_ASSERT(
+          arg == value ||
+          (Which == FixedInput::kCFAllocatorDefault && arg == nullptr));
     } else {
       arg = value;
     }
   }
 }
 
 template <size_t Arg>
 static void EX_RequireDefaultAllocator(ExternalCallContext& aCx) {
@@ -468,17 +468,17 @@ static void RR_open(Stream& aEvents, Cal
         AutoSpinLock lock(gInstallDirectoryFdsLock);
         gInstallDirectoryFds.emplaceBack(fd, std::move(suffix));
       }
     }
   }
 }
 
 static void RR_close(Stream& aEvents, CallArguments* aArguments,
-                    ErrorType* aError) {
+                     ErrorType* aError) {
   RR_SaveRvalHadErrorNegative(aEvents, aArguments, aError);
 
   if (IsRecording()) {
     auto fd = aArguments->Arg<0, size_t>();
     AutoSpinLock lock(gInstallDirectoryFdsLock);
     for (auto& info : gInstallDirectoryFds) {
       if (info.mFd == fd) {
         gInstallDirectoryFds.erase(&info);
@@ -547,19 +547,18 @@ static PreambleResult Preamble_mmap(Call
         size_t installLength = strlen(installDirectory);
 
         UniquePtr<char[]> path(new char[installLength + len]);
         strcpy(path.get(), installDirectory);
         RecordReplayBytes(path.get() + installLength, len);
         size_t hash = RecordReplayValue(0);
 
         int fd = DirectOpenFile(path.get(), /* aWriting */ false);
-        void* fileContents = CallFunction<void*>(gOriginal_mmap, nullptr, size,
-                                                 PROT_READ, MAP_PRIVATE,
-                                                 fd, offset);
+        void* fileContents = CallFunction<void*>(
+            gOriginal_mmap, nullptr, size, PROT_READ, MAP_PRIVATE, fd, offset);
         MOZ_RELEASE_ASSERT(fileContents != MAP_FAILED);
 
         memcpy(memory, fileContents, size);
         MOZ_RELEASE_ASSERT(hash == HashBytes(memory, size));
 
         munmap(fileContents, size);
         DirectCloseFile(fd);
       } else {
@@ -725,18 +724,17 @@ void DirectUnlockMutex(pthread_mutex_t* 
 // and reacquires the mutex before returning.
 static ssize_t WaitForCvar(pthread_mutex_t* aMutex, pthread_cond_t* aCond,
                            bool aRecordReturnValue,
                            const std::function<ssize_t()>& aCallback) {
   Lock* lock = Lock::Find(aMutex);
   if (!lock) {
     if (IsReplaying() && !AreThreadEventsPassedThrough()) {
       Thread* thread = Thread::Current();
-      if (thread->MaybeWaitForFork(
-              [=]() { pthread_mutex_unlock(aMutex); })) {
+      if (thread->MaybeWaitForFork([=]() { pthread_mutex_unlock(aMutex); })) {
         // We unlocked the mutex while the thread idled, so don't wait on the
         // condvar: the state the thread is waiting on may have changed and it
         // might not want to continue waiting. Returning immediately means this
         // this is a spurious wakeup, which is allowed by the pthreads API and
         // should be handled correctly by callers.
         pthread_mutex_lock(aMutex);
         return 0;
       }
@@ -973,41 +971,40 @@ static PreambleResult Preamble_pthread_s
     if (!thread->IsMainThread()) {
       aArguments->Rval<pthread_t>() = thread->NativeId();
       return PreambleResult::Veto;
     }
   }
   return PreambleResult::PassThrough;
 }
 
-static void*
-GetTLVTemplate(void* aPtr, size_t* aSize) {
+static void* GetTLVTemplate(void* aPtr, size_t* aSize) {
   uint8_t* tlvTemplate = nullptr;
   *aSize = 0;
 
   Dl_info info;
   dladdr(aPtr, &info);
-  mach_header_64* header = (mach_header_64*) info.dli_fbase;
+  mach_header_64* header = (mach_header_64*)info.dli_fbase;
   MOZ_RELEASE_ASSERT(header->magic == MH_MAGIC_64);
 
   uint32_t offset = sizeof(mach_header_64);
   for (size_t i = 0; i < header->ncmds; i++) {
-    load_command* cmd = (load_command*) ((uint8_t*)header + offset);
+    load_command* cmd = (load_command*)((uint8_t*)header + offset);
     if (LC_SEGMENT_64 == (cmd->cmd & ~LC_REQ_DYLD)) {
-      segment_command_64* ncmd = (segment_command_64*) cmd;
-      section_64* sect = (section_64*) (ncmd + 1);
+      segment_command_64* ncmd = (segment_command_64*)cmd;
+      section_64* sect = (section_64*)(ncmd + 1);
       for (size_t i = 0; i < ncmd->nsects; i++, sect++) {
         switch (sect->flags & SECTION_TYPE) {
-        case S_THREAD_LOCAL_REGULAR:
-        case S_THREAD_LOCAL_ZEROFILL:
-          if (!tlvTemplate) {
-            tlvTemplate = (uint8_t*)header + sect->addr;
-          }
-          *aSize = (uint8_t*)header + sect->addr + sect->size - tlvTemplate;
-          break;
+          case S_THREAD_LOCAL_REGULAR:
+          case S_THREAD_LOCAL_ZEROFILL:
+            if (!tlvTemplate) {
+              tlvTemplate = (uint8_t*)header + sect->addr;
+            }
+            *aSize = (uint8_t*)header + sect->addr + sect->size - tlvTemplate;
+            break;
         }
       }
     }
     offset += cmd->cmdsize;
   }
 
   return tlvTemplate;
 }
@@ -1309,17 +1306,17 @@ static void EX_PerformSelector(ExternalC
   if (aCx.mPhase == ExternalCallPhase::SaveInput) {
     if (strcmp(selector, "appearanceNamed:")) {
       aCx.MarkAsFailed();
       return;
     }
   }
 
   if (aCx.mPhase == ExternalCallPhase::RestoreInput) {
-    selector = (const char*) sel_registerName(selector);
+    selector = (const char*)sel_registerName(selector);
   }
 
   EX_AutoreleaseCFTypeRval(aCx);
 }
 
 static void EX_DictionaryWithObjectsAndKeys(ExternalCallContext& aCx) {
   if (aCx.AccessInput()) {
     size_t numArgs = 0;
@@ -1415,18 +1412,18 @@ static ObjCMessageInfo gObjCExternalCall
 
     // NSArray
     {"count"},
     {"objectAtIndex:", EX_Compose<EX_ScalarArg<2>, EX_AutoreleaseCFTypeRval>},
 
     // NSBezierPath
     {"addClip", EX_NoOp, true},
     {"bezierPathWithRoundedRect:xRadius:yRadius:",
-     EX_Compose<EX_StackArgumentData<sizeof(CGRect)>,
-                EX_FloatArg<0>, EX_FloatArg<1>, EX_AutoreleaseCFTypeRval>},
+     EX_Compose<EX_StackArgumentData<sizeof(CGRect)>, EX_FloatArg<0>,
+                EX_FloatArg<1>, EX_AutoreleaseCFTypeRval>},
 
     // NSCell
     {"drawFocusRingMaskWithFrame:inView:",
      EX_Compose<EX_CFTypeArg<2>, EX_StackArgumentData<sizeof(CGRect)>>},
     {"drawWithFrame:inView:",
      EX_Compose<EX_CFTypeArg<2>, EX_StackArgumentData<sizeof(CGRect)>>},
     {"initTextCell:", EX_Compose<EX_CFTypeArg<2>, EX_AutoreleaseCFTypeRval>},
     {"initTextCell:pullsDown:",
@@ -1478,22 +1475,20 @@ static ObjCMessageInfo gObjCExternalCall
     {"controlContentFontOfSize:",
      EX_Compose<EX_FloatArg<0>, EX_AutoreleaseCFTypeRval>},
     {"familyName", EX_AutoreleaseCFTypeRval},
     {"fontDescriptor", EX_AutoreleaseCFTypeRval},
     {"menuBarFontOfSize:",
      EX_Compose<EX_FloatArg<0>, EX_AutoreleaseCFTypeRval>},
     {"pointSize"},
     {"smallSystemFontSize"},
-    {"systemFontOfSize:",
-     EX_Compose<EX_FloatArg<0>, EX_AutoreleaseCFTypeRval>},
+    {"systemFontOfSize:", EX_Compose<EX_FloatArg<0>, EX_AutoreleaseCFTypeRval>},
     {"toolTipsFontOfSize:",
      EX_Compose<EX_FloatArg<0>, EX_AutoreleaseCFTypeRval>},
-    {"userFontOfSize:",
-     EX_Compose<EX_FloatArg<0>, EX_AutoreleaseCFTypeRval>},
+    {"userFontOfSize:", EX_Compose<EX_FloatArg<0>, EX_AutoreleaseCFTypeRval>},
 
     // NSFontManager
     {"availableMembersOfFontFamily:",
      EX_Compose<EX_CFTypeArg<2>, EX_AutoreleaseCFTypeRval>},
     {"sharedFontManager", EX_AutoreleaseCFTypeRval},
 
     // NSGraphicsContext
     {"currentContext", EX_AutoreleaseCFTypeRval},
@@ -1524,17 +1519,17 @@ static ObjCMessageInfo gObjCExternalCall
     {"symbolicTraits"},
 };
 
 static void EX_objc_msgSend(ExternalCallContext& aCx) {
   EX_CString<1>(aCx);
   auto& message = aCx.mArguments->Arg<1, const char*>();
 
   if (aCx.mPhase == ExternalCallPhase::RestoreInput) {
-    message = (const char*) sel_registerName(message);
+    message = (const char*)sel_registerName(message);
   }
 
   for (const ObjCMessageInfo& info : gObjCExternalCallMessages) {
     if (!strcmp(info.mMessage, message)) {
       if (info.mUpdatesObject) {
         EX_UpdateCFTypeArg<0>(aCx);
       } else {
         EX_CFTypeArg<0>(aCx);
@@ -2172,28 +2167,27 @@ static SystemRedirection gSystemRedirect
     {"close", RR_close, nullptr, nullptr, Preamble_Veto<0>},
     {"__close_nocancel", RR_SaveRvalHadErrorNegative},
     {"mkdir", RR_SaveRvalHadErrorNegative},
     {"dup", RR_SaveRvalHadErrorNegative},
     {"access", RR_SaveRvalHadErrorNegative, nullptr, nullptr,
      Preamble_SetError<EACCES>},
     {"lseek", RR_SaveRvalHadErrorNegative},
     {"select$DARWIN_EXTSN",
-     RR_SaveRvalHadErrorNegative<RR_Compose<RR_OutParam<1, fd_set>,
-                                            RR_OutParam<2, fd_set>,
-                                            RR_OutParam<3, fd_set>>>,
+     RR_SaveRvalHadErrorNegative<
+         RR_Compose<RR_OutParam<1, fd_set>, RR_OutParam<2, fd_set>,
+                    RR_OutParam<3, fd_set>>>,
      nullptr, nullptr, Preamble_WaitForever},
     {"socketpair",
      RR_SaveRvalHadErrorNegative<RR_WriteBufferFixedSize<3, 2 * sizeof(int)>>},
     {"fileport_makeport", RR_SaveRvalHadErrorNegative<RR_OutParam<1, size_t>>},
     {"getsockopt", RR_SaveRvalHadErrorNegative<RR_getsockopt>},
     {"gettimeofday",
-     RR_SaveRvalHadErrorNegative<RR_Compose<
-         RR_OutParam<0, struct timeval>,
-         RR_OutParam<1, struct timezone>>>,
+     RR_SaveRvalHadErrorNegative<RR_Compose<RR_OutParam<0, struct timeval>,
+                                            RR_OutParam<1, struct timezone>>>,
      nullptr, nullptr, Preamble_PassThrough},
     {"getuid", RR_ScalarRval},
     {"geteuid", RR_ScalarRval},
     {"getgid", RR_ScalarRval},
     {"getegid", RR_ScalarRval},
     {"issetugid", RR_ScalarRval},
     {"__gettid", RR_ScalarRval},
     {"getpid", nullptr, Preamble_getpid},
@@ -2202,32 +2196,30 @@ static SystemRedirection gSystemRedirect
     {"getattrlist", RR_SaveRvalHadErrorNegative<RR_WriteBuffer<2, 3>>},
     {"fstat$INODE64", RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct stat>>,
      nullptr, nullptr, Preamble_SetError},
     {"lstat$INODE64", RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct stat>>,
      nullptr, nullptr, Preamble_SetError},
     {"stat$INODE64", RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct stat>>,
      nullptr, nullptr, Preamble_SetError},
     {"statfs$INODE64",
-     RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct statfs>>,
-     nullptr, nullptr, Preamble_SetError},
+     RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct statfs>>, nullptr,
+     nullptr, Preamble_SetError},
     {"fstatfs$INODE64",
-     RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct statfs>>,
-     nullptr, nullptr, Preamble_SetError},
+     RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct statfs>>, nullptr,
+     nullptr, Preamble_SetError},
     {"readlink", RR_SaveRvalHadErrorNegative<RR_WriteBuffer<1, 2>>},
     {"__getdirentries64",
-     RR_SaveRvalHadErrorNegative<RR_Compose<
-         RR_WriteBuffer<1, 2>, RR_OutParam<3, size_t>>>},
+     RR_SaveRvalHadErrorNegative<
+         RR_Compose<RR_WriteBuffer<1, 2>, RR_OutParam<3, size_t>>>},
     {"getdirentriesattr",
-     RR_SaveRvalHadErrorNegative<RR_Compose<
-         RR_WriteBufferFixedSize<1, sizeof(struct attrlist)>,
-         RR_WriteBuffer<2, 3>,
-         RR_OutParam<4, size_t>,
-         RR_OutParam<5, size_t>,
-         RR_OutParam<6, size_t>>>},
+     RR_SaveRvalHadErrorNegative<
+         RR_Compose<RR_WriteBufferFixedSize<1, sizeof(struct attrlist)>,
+                    RR_WriteBuffer<2, 3>, RR_OutParam<4, size_t>,
+                    RR_OutParam<5, size_t>, RR_OutParam<6, size_t>>>},
     {"getrusage", RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct rusage>>,
      nullptr, nullptr, Preamble_SetError},
     {"getrlimit", RR_SaveRvalHadErrorNegative<RR_OutParam<1, struct rlimit>>},
     {"setrlimit", RR_SaveRvalHadErrorNegative},
     {"sigprocmask", RR_SaveRvalHadErrorNegative<RR_OutParam<2, sigset_t>>,
      nullptr, nullptr, Preamble_PassThrough},
     {"sigaltstack", RR_SaveRvalHadErrorNegative<RR_OutParam<2, stack_t>>},
     {"sigaction",
@@ -2243,25 +2235,22 @@ static SystemRedirection gSystemRedirect
      Preamble_sysctlbyname, nullptr, Preamble_SetError},
     {"__mac_syscall", RR_SaveRvalHadErrorNegative},
     {"syscall", RR_SaveRvalHadErrorNegative},
     {"getaudit_addr",
      RR_SaveRvalHadErrorNegative<RR_OutParam<0, auditinfo_addr_t>>},
     {"umask", RR_ScalarRval},
     {"__select",
      RR_SaveRvalHadErrorNegative<
-         RR_Compose<RR_OutParam<1, fd_set>,
-                    RR_OutParam<2, fd_set>,
-                    RR_OutParam<3, fd_set>,
-                    RR_OutParam<4, timeval>>>,
+         RR_Compose<RR_OutParam<1, fd_set>, RR_OutParam<2, fd_set>,
+                    RR_OutParam<3, fd_set>, RR_OutParam<4, timeval>>>,
      nullptr, nullptr, Preamble_WaitForever},
     {"__process_policy", RR_SaveRvalHadErrorNegative},
     {"__kdebug_trace", RR_SaveRvalHadErrorNegative},
-    {"guarded_kqueue_np",
-     RR_SaveRvalHadErrorNegative<RR_OutParam<0, size_t>>},
+    {"guarded_kqueue_np", RR_SaveRvalHadErrorNegative<RR_OutParam<0, size_t>>},
     {"csops", RR_SaveRvalHadErrorNegative<RR_WriteBuffer<2, 3>>},
     {"__getlogin", RR_SaveRvalHadErrorNegative<RR_WriteBuffer<0, 1>>},
     {"__workq_kernreturn", nullptr, Preamble___workq_kernreturn},
     {"start_wqthread", nullptr, Preamble_start_wqthread},
     {"isatty", RR_SaveRvalHadErrorZero},
 
     /////////////////////////////////////////////////////////////////////////////
     // PThreads interfaces
@@ -2298,27 +2287,26 @@ static SystemRedirection gSystemRedirect
     {"fprintf", RR_SaveRvalHadErrorNegative},
     {"fopen", RR_SaveRvalHadErrorZero},
     {"fread", RR_Compose<RR_ScalarRval, RR_fread>},
     {"fseek", RR_SaveRvalHadErrorNegative},
     {"ftell", RR_SaveRvalHadErrorNegative},
     {"fwrite", RR_ScalarRval},
     {"getenv", RR_CStringRval, Preamble_getenv, nullptr, Preamble_Veto<0>},
     {"localtime_r",
-     RR_SaveRvalHadErrorZero<RR_Compose<RR_OutParam<1, struct tm>,
-                                        RR_RvalIsArgument<1>>>,
+     RR_SaveRvalHadErrorZero<
+         RR_Compose<RR_OutParam<1, struct tm>, RR_RvalIsArgument<1>>>,
      nullptr, nullptr, Preamble_PassThrough},
     {"gmtime_r",
-     RR_SaveRvalHadErrorZero<RR_Compose<RR_OutParam<1, struct tm>,
-                                        RR_RvalIsArgument<1>>>,
+     RR_SaveRvalHadErrorZero<
+         RR_Compose<RR_OutParam<1, struct tm>, RR_RvalIsArgument<1>>>,
      nullptr, nullptr, Preamble_PassThrough},
     {"localtime", nullptr, Preamble_localtime, nullptr, Preamble_PassThrough},
     {"gmtime", nullptr, Preamble_gmtime, nullptr, Preamble_PassThrough},
-    {"mktime",
-     RR_Compose<RR_ScalarRval, RR_OutParam<0, struct tm>>},
+    {"mktime", RR_Compose<RR_ScalarRval, RR_OutParam<0, struct tm>>},
     {"setlocale", RR_CStringRval},
     {"strftime", RR_Compose<RR_ScalarRval, RR_WriteBufferViaRval<0, 1, 1>>},
     {"arc4random", RR_ScalarRval, nullptr, nullptr, Preamble_PassThrough},
     {"arc4random_buf", RR_WriteBuffer<0, 1>},
     {"bootstrap_look_up", RR_OutParam<2, mach_port_t>},
     {"clock_gettime", RR_Compose<RR_ScalarRval, RR_OutParam<1, timespec>>},
     {"clock_get_time",
      RR_Compose<RR_ScalarRval, RR_OutParam<1, mach_timespec_t>>},
@@ -2351,21 +2339,21 @@ static SystemRedirection gSystemRedirect
          RR_CStringRval, RR_WriteOptionalBufferFixedSize<1, PATH_MAX>>>},
     {"sandbox_init", RR_ScalarRval},
     {"sandbox_init_with_parameters", RR_ScalarRval},
     {"srand", nullptr, nullptr, nullptr, Preamble_PassThrough},
     {"task_threads", RR_task_threads},
     {"task_get_special_port",
      RR_Compose<RR_ScalarRval, RR_OutParam<2, mach_port_t>>},
     {"task_set_special_port", RR_ScalarRval},
-    {"task_swap_exception_ports", RR_ScalarRval}, // Ignore out parameters
-    {"time", RR_Compose<RR_ScalarRval, RR_OutParam<0, time_t>>,
-     nullptr, nullptr, Preamble_PassThrough},
-    {"uname", RR_SaveRvalHadErrorNegative<RR_OutParam<0, utsname>>,
-     nullptr, nullptr, Preamble_SetError},
+    {"task_swap_exception_ports", RR_ScalarRval},  // Ignore out parameters
+    {"time", RR_Compose<RR_ScalarRval, RR_OutParam<0, time_t>>, nullptr,
+     nullptr, Preamble_PassThrough},
+    {"uname", RR_SaveRvalHadErrorNegative<RR_OutParam<0, utsname>>, nullptr,
+     nullptr, Preamble_SetError},
     {"vm_allocate", nullptr, Preamble_VetoIfNotPassedThrough<KERN_FAILURE>},
     {"vm_copy", nullptr, Preamble_PassThrough},
     {"tzset"},
     {"_dyld_register_func_for_add_image"},
     {"_dyld_register_func_for_remove_image"},
     {"setjmp", nullptr, Preamble_VetoIfNotPassedThrough<0>},
     {"longjmp", nullptr, Preamble_NYI},
 
@@ -2403,18 +2391,18 @@ static SystemRedirection gSystemRedirect
     {"CFArrayAppendValue"},
     {"CFArrayCreate", RR_ScalarRval, nullptr, EX_CFArrayCreate},
     {"CFArrayCreateMutable", RR_ScalarRval},
     {"CFArrayGetCount", RR_ScalarRval, nullptr, EX_CFTypeArg<0>},
     {"CFArrayGetValueAtIndex", RR_ScalarRval, nullptr,
      EX_CFArrayGetValueAtIndex},
     {"CFArrayRemoveValueAtIndex"},
     {"CFAttributedStringCreate", RR_ScalarRval, nullptr,
-     EX_Compose<EX_RequireDefaultAllocator<0>,
-                EX_CFTypeArg<1>, EX_CFTypeArg<2>, EX_CreateCFTypeRval>},
+     EX_Compose<EX_RequireDefaultAllocator<0>, EX_CFTypeArg<1>, EX_CFTypeArg<2>,
+                EX_CreateCFTypeRval>},
     {"CFBundleCopyExecutableURL", RR_ScalarRval},
     {"CFBundleCopyInfoDictionaryForURL", RR_ScalarRval},
     {"CFBundleCreate", RR_ScalarRval},
     {"CFBundleGetBundleWithIdentifier", RR_ScalarRval},
     {"CFBundleGetDataPointerForName", nullptr,
      Preamble_VetoIfNotPassedThrough<0>},
     {"CFBundleGetFunctionPointerForName", nullptr,
      Preamble_VetoIfNotPassedThrough<0>},
@@ -2427,26 +2415,23 @@ static SystemRedirection gSystemRedirect
     {"CFDataGetBytePtr", RR_CFDataGetBytePtr, nullptr, EX_CFDataGetBytePtr},
     {"CFDataGetLength", RR_ScalarRval, nullptr, EX_CFTypeArg<0>},
     {"CFDateFormatterCreate", RR_ScalarRval},
     {"CFDateFormatterGetFormat", RR_ScalarRval},
     {"CFDictionaryAddValue", nullptr, nullptr,
      EX_Compose<EX_UpdateCFTypeArg<0>, EX_CFTypeArg<1>, EX_CFTypeArg<2>>},
     {"CFDictionaryCreate", RR_ScalarRval, nullptr, EX_CFDictionaryCreate},
     {"CFDictionaryCreateMutable", RR_ScalarRval, nullptr,
-     EX_Compose<EX_RequireDefaultAllocator<0>,
-                EX_ScalarArg<1>,
-                EX_RequireFixed<2,
-                    FixedInput::kCFTypeDictionaryKeyCallBacks>,
-                EX_RequireFixed<3,
-                    FixedInput::kCFTypeDictionaryValueCallBacks>,
+     EX_Compose<EX_RequireDefaultAllocator<0>, EX_ScalarArg<1>,
+                EX_RequireFixed<2, FixedInput::kCFTypeDictionaryKeyCallBacks>,
+                EX_RequireFixed<3, FixedInput::kCFTypeDictionaryValueCallBacks>,
                 EX_CreateCFTypeRval>},
     {"CFDictionaryCreateMutableCopy", RR_ScalarRval, nullptr,
-     EX_Compose<EX_RequireDefaultAllocator<0>,
-                EX_ScalarArg<1>, EX_CFTypeArg<2>, EX_CreateCFTypeRval>},
+     EX_Compose<EX_RequireDefaultAllocator<0>, EX_ScalarArg<1>, EX_CFTypeArg<2>,
+                EX_CreateCFTypeRval>},
     {"CFDictionaryGetTypeID", RR_ScalarRval, nullptr, EX_NoOp},
     {"CFDictionaryGetValue", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_CFTypeRval>},
     {"CFDictionaryGetValueIfPresent",
      RR_Compose<RR_ScalarRval, RR_OutParam<2, const void*>>, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_CFTypeOutputArg<2>>},
     {"CFDictionaryReplaceValue", nullptr, nullptr,
      EX_Compose<EX_UpdateCFTypeArg<0>, EX_CFTypeArg<1>, EX_CFTypeArg<2>>},
@@ -2495,40 +2480,37 @@ static SystemRedirection gSystemRedirect
     {"CFRunLoopSourceSignal"},
     {"CFRunLoopWakeUp"},
     {"CFStringAppendCharacters"},
     {"CFStringCompare", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>>},
     {"CFStringCreateArrayBySeparatingStrings", RR_ScalarRval},
     {"CFStringCreateMutable", RR_ScalarRval},
     {"CFStringCreateWithBytes", RR_ScalarRval, nullptr,
-     EX_Compose<EX_RequireDefaultAllocator<0>,
-                EX_Buffer<1, 2>, EX_ScalarArg<3>, EX_ScalarArg<4>,
-                EX_CreateCFTypeRval>},
+     EX_Compose<EX_RequireDefaultAllocator<0>, EX_Buffer<1, 2>, EX_ScalarArg<3>,
+                EX_ScalarArg<4>, EX_CreateCFTypeRval>},
     {"CFStringCreateWithBytesNoCopy", RR_ScalarRval},
     {"CFStringCreateWithCharactersNoCopy", RR_ScalarRval, nullptr,
-     EX_Compose<EX_RequireDefaultAllocator<0>,
-                EX_Buffer<1, 2, UniChar>,
+     EX_Compose<EX_RequireDefaultAllocator<0>, EX_Buffer<1, 2, UniChar>,
                 EX_RequireFixed<3, FixedInput::kCFAllocatorNull>,
                 EX_CreateCFTypeRval>},
     {"CFStringCreateWithCString", RR_ScalarRval},
     {"CFStringCreateWithFormat", RR_ScalarRval},
     {"CFStringGetBytes",
      // Argument indexes are off by one here as the CFRange argument uses two
      // slots.
      RR_Compose<RR_ScalarRval, RR_WriteOptionalBuffer<6, 7>,
                 RR_OutParam<8, CFIndex>>},
     {"CFStringGetCharacters",
      // Argument indexes are off by one here as the CFRange argument uses two
      // slots.
      // We also need to specify the argument register with the range's length
      // here.
      RR_WriteBuffer<3, 2, UniChar>, nullptr,
-     EX_Compose<EX_CFTypeArg<0>,
-                EX_ScalarArg<1>,
+     EX_Compose<EX_CFTypeArg<0>, EX_ScalarArg<1>,
                 EX_WriteBuffer<3, 2, UniChar>>},
     {"CFStringGetCString", RR_Compose<RR_ScalarRval, RR_WriteBuffer<1, 2>>},
     {"CFStringGetCStringPtr", nullptr, Preamble_VetoIfNotPassedThrough<0>},
     {"CFStringGetIntValue", RR_ScalarRval},
     {"CFStringGetLength", RR_ScalarRval, nullptr, EX_CFTypeArg<0>},
     {"CFStringGetMaximumSizeForEncoding", RR_ScalarRval},
     {"CFStringHasPrefix", RR_ScalarRval},
     {"CFStringGetTypeID", RR_ScalarRval, nullptr, EX_NoOp},
@@ -2541,28 +2523,27 @@ static SystemRedirection gSystemRedirect
     {"CFURLCreateWithString", RR_ScalarRval},
     {"CFURLGetFileSystemRepresentation",
      RR_Compose<RR_ScalarRval, RR_WriteBuffer<2, 3>>},
     {"CFURLGetFSRef", RR_Compose<RR_ScalarRval, RR_OutParam<1, FSRef>>},
     {"CFUUIDCreate", RR_ScalarRval, nullptr,
      EX_Compose<EX_RequireDefaultAllocator<0>, EX_CreateCFTypeRval>},
     {"CFUUIDCreateString", RR_ScalarRval},
     {"CFUUIDGetUUIDBytes", RR_ComplexScalarRval, nullptr, EX_CFTypeArg<0>},
-    {"CGAffineTransformConcat",
-     RR_OversizeRval<sizeof(CGAffineTransform)>, nullptr,
+    {"CGAffineTransformConcat", RR_OversizeRval<sizeof(CGAffineTransform)>,
+     nullptr,
      EX_Compose<EX_StackArgumentData<2 * sizeof(CGAffineTransform)>,
                 EX_OversizeRval<CGAffineTransform>>},
-    {"CGAffineTransformInvert",
-     RR_OversizeRval<sizeof(CGAffineTransform)>, nullptr,
+    {"CGAffineTransformInvert", RR_OversizeRval<sizeof(CGAffineTransform)>,
+     nullptr,
      EX_Compose<EX_StackArgumentData<sizeof(CGAffineTransform)>,
                 EX_OversizeRval<CGAffineTransform>>},
-    {"CGAffineTransformMakeScale",
-     RR_OversizeRval<sizeof(CGAffineTransform)>, nullptr,
-     EX_Compose<EX_FloatArg<0>,
-                EX_FloatArg<1>,
+    {"CGAffineTransformMakeScale", RR_OversizeRval<sizeof(CGAffineTransform)>,
+     nullptr,
+     EX_Compose<EX_FloatArg<0>, EX_FloatArg<1>,
                 EX_OversizeRval<CGAffineTransform>>},
     {"CGBitmapContextCreateImage", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CreateCFTypeRval>},
     {"CGBitmapContextCreate",
      RR_Compose<RR_ScalarRval, RR_CGBitmapContextCreateWithData>, nullptr,
      EX_CGBitmapContextCreateWithData},
     {"CGBitmapContextCreateWithData",
      RR_Compose<RR_ScalarRval, RR_CGBitmapContextCreateWithData>, nullptr,
@@ -2590,18 +2571,17 @@ static SystemRedirection gSystemRedirect
     {"CGContextConcatCTM", nullptr, nullptr,
      EX_Compose<EX_CFTypeArg<0>,
                 EX_StackArgumentData<sizeof(CGAffineTransform)>>},
     {"CGContextDrawImage", RR_FlushCGContext<0>, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_StackArgumentData<sizeof(CGRect)>,
                 EX_CFTypeArg<1>, EX_FlushCGContext<0>>},
     {"CGContextDrawLinearGradient", RR_FlushCGContext<0>, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>,
-                EX_StackArgumentData<2 * sizeof(CGPoint)>,
-                EX_ScalarArg<2>,
+                EX_StackArgumentData<2 * sizeof(CGPoint)>, EX_ScalarArg<2>,
                 EX_FlushCGContext<0>>},
     {"CGContextEndTransparencyLayer", nullptr, nullptr, EX_UpdateCFTypeArg<0>},
     {"CGContextFillPath", RR_FlushCGContext<0>, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_FlushCGContext<0>>},
     {"CGContextFillRect", RR_FlushCGContext<0>, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_StackArgumentData<sizeof(CGRect)>,
                 EX_FlushCGContext<0>>},
     {"CGContextGetClipBoundingBox", RR_OversizeRval<sizeof(CGRect)>},
@@ -2625,23 +2605,21 @@ static SystemRedirection gSystemRedirect
      EX_Compose<EX_UpdateCFTypeArg<0>,
                 EX_StackArgumentData<sizeof(CGAffineTransform)>>},
     {"CGContextSetCTM", nullptr, nullptr,
      EX_Compose<EX_UpdateCFTypeArg<0>,
                 EX_StackArgumentData<sizeof(CGAffineTransform)>>},
     {"CGContextSetGrayFillColor", nullptr, nullptr,
      EX_Compose<EX_FloatArg<0>, EX_FloatArg<1>, EX_UpdateCFTypeArg<0>>},
     {"CGContextSetRGBFillColor", nullptr, nullptr,
-     EX_Compose<EX_UpdateCFTypeArg<0>,
-                EX_FloatArg<0>, EX_FloatArg<1>, EX_FloatArg<2>,
-                EX_StackArgumentData<sizeof(CGFloat)>>},
+     EX_Compose<EX_UpdateCFTypeArg<0>, EX_FloatArg<0>, EX_FloatArg<1>,
+                EX_FloatArg<2>, EX_StackArgumentData<sizeof(CGFloat)>>},
     {"CGContextSetRGBStrokeColor", nullptr, nullptr,
-     EX_Compose<EX_UpdateCFTypeArg<0>,
-                EX_FloatArg<0>, EX_FloatArg<1>, EX_FloatArg<2>,
-                EX_StackArgumentData<sizeof(CGFloat)>>},
+     EX_Compose<EX_UpdateCFTypeArg<0>, EX_FloatArg<0>, EX_FloatArg<1>,
+                EX_FloatArg<2>, EX_StackArgumentData<sizeof(CGFloat)>>},
     {"CGContextSetShouldAntialias", nullptr, nullptr,
      EX_Compose<EX_UpdateCFTypeArg<0>, EX_ScalarArg<1>>},
     {"CGContextSetShouldSmoothFonts", nullptr, nullptr,
      EX_Compose<EX_UpdateCFTypeArg<0>, EX_ScalarArg<1>>},
     {"CGContextSetShouldSubpixelPositionFonts", nullptr, nullptr,
      EX_Compose<EX_UpdateCFTypeArg<0>, EX_ScalarArg<1>>},
     {"CGContextSetShouldSubpixelQuantizeFonts", nullptr, nullptr,
      EX_Compose<EX_UpdateCFTypeArg<0>, EX_ScalarArg<1>>},
@@ -2701,92 +2679,81 @@ static SystemRedirection gSystemRedirect
     {"CGImageGetWidth", RR_ScalarRval},
     {"CGImageRelease", RR_ScalarRval, nullptr, nullptr, Preamble_Veto<0>},
     {"CGMainDisplayID", RR_ScalarRval},
     {"CGPathAddPath"},
     {"CGPathApply", nullptr, Preamble_CGPathApply, EX_CGPathApply},
     {"CGPathContainsPoint", RR_ScalarRval},
     {"CGPathCreateMutable", RR_ScalarRval},
     {"CGPathCreateWithRoundedRect", RR_ScalarRval, nullptr,
-     EX_Compose<EX_StackArgumentData<sizeof(CGRect)>,
-                EX_FloatArg<0>, EX_FloatArg<1>,
-                EX_InParam<0, CGAffineTransform>,
+     EX_Compose<EX_StackArgumentData<sizeof(CGRect)>, EX_FloatArg<0>,
+                EX_FloatArg<1>, EX_InParam<0, CGAffineTransform>,
                 EX_CreateCFTypeRval>},
     {"CGPathGetBoundingBox", RR_OversizeRval<sizeof(CGRect)>},
     {"CGPathGetCurrentPoint", RR_ComplexFloatRval},
     {"CGPathIsEmpty", RR_ScalarRval},
     {"CGRectApplyAffineTransform", RR_OversizeRval<sizeof(CGRect)>, nullptr,
-     EX_Compose<EX_StackArgumentData<sizeof(CGRect) +
-                                     sizeof(CGAffineTransform)>,
-                EX_OversizeRval<CGRect>>},
+     EX_Compose<
+         EX_StackArgumentData<sizeof(CGRect) + sizeof(CGAffineTransform)>,
+         EX_OversizeRval<CGRect>>},
     {"CGSSetDebugOptions", RR_ScalarRval},
     {"CGSShutdownServerConnections"},
     {"CTFontCopyFamilyName", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CreateCFTypeRval>},
     {"CTFontCopyFeatures", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CreateCFTypeRval>},
     {"CTFontCopyFontDescriptor", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CreateCFTypeRval>},
     {"CTFontCopyGraphicsFont", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_CreateCFTypeRval>},
     {"CTFontCopyTable", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_ScalarArg<1>, EX_ScalarArg<2>,
                 EX_CreateCFTypeRval>},
     {"CTFontCopyVariationAxes", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CreateCFTypeRval>},
     {"CTFontCreateForString", RR_ScalarRval, nullptr,
-     EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>,
-                EX_ScalarArg<2>, EX_ScalarArg<3>, EX_CreateCFTypeRval>},
+     EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_ScalarArg<2>,
+                EX_ScalarArg<3>, EX_CreateCFTypeRval>},
     {"CTFontCreatePathForGlyph", RR_ScalarRval, nullptr,
-     EX_Compose<EX_CFTypeArg<0>,
-                EX_ScalarArg<1>,
-                EX_InParam<2, CGAffineTransform>,
-                EX_CreateCFTypeRval>},
+     EX_Compose<EX_CFTypeArg<0>, EX_ScalarArg<1>,
+                EX_InParam<2, CGAffineTransform>, EX_CreateCFTypeRval>},
     {"CTFontCreateWithFontDescriptor", RR_ScalarRval, nullptr,
-     EX_Compose<EX_CFTypeArg<0>,
-                EX_FloatArg<0>,
-                EX_InParam<1, CGAffineTransform>,
-                EX_CreateCFTypeRval>},
+     EX_Compose<EX_CFTypeArg<0>, EX_FloatArg<0>,
+                EX_InParam<1, CGAffineTransform>, EX_CreateCFTypeRval>},
     {"CTFontCreateWithGraphicsFont", RR_ScalarRval, nullptr,
-     EX_Compose<EX_CFTypeArg<0>,
-                EX_FloatArg<0>,
-                EX_InParam<1, CGAffineTransform>,
-                EX_CFTypeArg<2>,
+     EX_Compose<EX_CFTypeArg<0>, EX_FloatArg<0>,
+                EX_InParam<1, CGAffineTransform>, EX_CFTypeArg<2>,
                 EX_CreateCFTypeRval>},
     {"CTFontCreateWithName", RR_ScalarRval, nullptr,
-     EX_Compose<EX_CFTypeArg<0>,
-                EX_FloatArg<0>,
-                EX_InParam<1, CGAffineTransform>,
-                EX_CreateCFTypeRval>},
+     EX_Compose<EX_CFTypeArg<0>, EX_FloatArg<0>,
+                EX_InParam<1, CGAffineTransform>, EX_CreateCFTypeRval>},
     {"CTFontDescriptorCopyAttribute", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_CreateCFTypeRval>},
     {"CTFontDescriptorCreateCopyWithAttributes", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_CreateCFTypeRval>},
     {"CTFontDescriptorCreateMatchingFontDescriptors", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_CreateCFTypeRval>},
     {"CTFontDescriptorCreateWithAttributes", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CreateCFTypeRval>},
     {"CTFontDrawGlyphs", RR_FlushCGContext<4>, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<4>, EX_Buffer<1, 3, CGGlyph>,
                 EX_Buffer<2, 3, CGPoint>, EX_FlushCGContext<4>>},
     {"CTFontGetAdvancesForGlyphs",
      RR_Compose<RR_FloatRval, RR_WriteOptionalBuffer<3, 4, CGSize>>, nullptr,
-     EX_Compose<EX_CFTypeArg<0>, EX_ScalarArg<1>,
-                EX_Buffer<2, 4, CGGlyph>,
+     EX_Compose<EX_CFTypeArg<0>, EX_ScalarArg<1>, EX_Buffer<2, 4, CGGlyph>,
                 EX_WriteBuffer<3, 4, CGSize>>},
     {"CTFontGetAscent", RR_FloatRval, nullptr, EX_CFTypeArg<0>},
     {"CTFontGetBoundingBox", RR_OversizeRval<sizeof(CGRect)>, nullptr,
      EX_Compose<EX_CFTypeArg<1>, EX_OversizeRval<CGRect>>},
     {"CTFontGetBoundingRectsForGlyphs",
      // Argument indexes here are off by one due to the oversize rval.
      RR_Compose<RR_OversizeRval<sizeof(CGRect)>,
                 RR_WriteOptionalBuffer<4, 5, CGRect>>,
      nullptr,
-     EX_Compose<EX_CFTypeArg<1>, EX_ScalarArg<2>,
-                EX_Buffer<3, 5, CGGlyph>,
+     EX_Compose<EX_CFTypeArg<1>, EX_ScalarArg<2>, EX_Buffer<3, 5, CGGlyph>,
                 EX_OversizeRval<CGRect>, EX_WriteBuffer<4, 5, CGRect>>},
     {"CTFontGetCapHeight", RR_FloatRval, nullptr, EX_CFTypeArg<0>},
     {"CTFontGetDescent", RR_FloatRval, nullptr, EX_CFTypeArg<0>},
     {"CTFontGetGlyphCount", RR_ScalarRval, nullptr, EX_CFTypeArg<0>},
     {"CTFontGetGlyphsForCharacters",
      RR_Compose<RR_ScalarRval, RR_WriteBuffer<2, 3, CGGlyph>>, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_Buffer<1, 3, UniChar>,
                 EX_WriteBuffer<2, 3, CGGlyph>>},
@@ -2813,123 +2780,92 @@ static SystemRedirection gSystemRedirect
      nullptr, EX_CTRunGetElements<CGPoint, CTRunGetPositions>},
     {"CTRunGetStringIndicesPtr",
      RR_CTRunGetElements<CFIndex, CTRunGetStringIndices>, nullptr,
      EX_CTRunGetElements<CFIndex, CTRunGetStringIndices>},
     {"CTRunGetStringRange", RR_ComplexScalarRval, nullptr, EX_CFTypeArg<0>},
     {"CTRunGetTypographicBounds",
      // Argument indexes are off by one here as the CFRange argument uses two
      // slots.
-     RR_Compose<RR_FloatRval,
-                RR_OutParam<3, CGFloat>,
-                RR_OutParam<4, CGFloat>,
+     RR_Compose<RR_FloatRval, RR_OutParam<3, CGFloat>, RR_OutParam<4, CGFloat>,
                 RR_OutParam<5, CGFloat>>,
      nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_ScalarArg<1>, EX_ScalarArg<2>,
                 EX_OutParam<3, CGFloat>, EX_OutParam<4, CGFloat>,
                 EX_OutParam<5, CGFloat>>},
     {"CUIDraw", nullptr, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeArg<1>, EX_CFTypeArg<2>,
                 EX_StackArgumentData<sizeof(CGRect)>>},
     {"FSCompareFSRefs", RR_ScalarRval},
-    {"FSGetVolumeInfo",
-     RR_Compose<RR_ScalarRval,
-                RR_OutParam<5, HFSUniStr255>,
-                RR_OutParam<6, FSRef>>},
+    {"FSGetVolumeInfo", RR_Compose<RR_ScalarRval, RR_OutParam<5, HFSUniStr255>,
+                                   RR_OutParam<6, FSRef>>},
     {"FSFindFolder", RR_Compose<RR_ScalarRval, RR_OutParam<3, FSRef>>},
     {"Gestalt", RR_Compose<RR_ScalarRval, RR_OutParam<1, SInt32>>},
     {"GetEventClass", RR_ScalarRval},
     {"GetCurrentEventQueue", RR_ScalarRval},
     {"GetCurrentProcess",
      RR_Compose<RR_ScalarRval, RR_OutParam<0, ProcessSerialNumber>>},
     {"GetEventAttributes", RR_ScalarRval},
     {"GetEventDispatcherTarget", RR_ScalarRval},
     {"GetEventKind", RR_ScalarRval},
     {"GetThemeMetric", RR_Compose<RR_ScalarRval, RR_OutParam<1, SInt32>>,
      nullptr, EX_Compose<EX_ScalarArg<0>, EX_OutParam<1, SInt32>>},
     {"HIThemeDrawButton", RR_Compose<RR_OutParam<4, HIRect>, RR_ScalarRval>,
      nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIThemeButtonDrawInfo>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>,
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIThemeButtonDrawInfo>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>,
                 EX_OutParam<4, HIRect>>},
     {"HIThemeDrawFrame", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIThemeFrameDrawInfo>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>>},
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIThemeFrameDrawInfo>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"HIThemeDrawGroupBox", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIThemeGroupBoxDrawInfo>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>>},
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIThemeGroupBoxDrawInfo>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"HIThemeDrawGrowBox", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIPoint>,
-                EX_InParam<1, HIThemeGrowBoxDrawInfo>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>>},
+     EX_Compose<EX_InParam<0, HIPoint>, EX_InParam<1, HIThemeGrowBoxDrawInfo>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"HIThemeDrawMenuBackground", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIThemeMenuDrawInfo>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>>},
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIThemeMenuDrawInfo>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"HIThemeDrawMenuItem", RR_Compose<RR_OutParam<5, HIRect>, RR_ScalarRval>,
      nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIRect>,
-                EX_InParam<2, HIThemeMenuItemDrawInfo>,
-                EX_UpdateCFTypeArg<3>,
-                EX_ScalarArg<4>,
-                EX_OutParam<5, HIRect>>},
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIRect>,
+                EX_InParam<2, HIThemeMenuItemDrawInfo>, EX_UpdateCFTypeArg<3>,
+                EX_ScalarArg<4>, EX_OutParam<5, HIRect>>},
     {"HIThemeDrawMenuSeparator", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIRect>,
-                EX_InParam<2, HIThemeMenuItemDrawInfo>,
-                EX_UpdateCFTypeArg<3>,
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIRect>,
+                EX_InParam<2, HIThemeMenuItemDrawInfo>, EX_UpdateCFTypeArg<3>,
                 EX_ScalarArg<4>>},
     {"HIThemeDrawSeparator", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIThemeSeparatorDrawInfo>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>>},
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIThemeSeparatorDrawInfo>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"HIThemeDrawTabPane", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIRect>,
-                EX_InParam<1, HIThemeTabPaneDrawInfo>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>>},
+     EX_Compose<EX_InParam<0, HIRect>, EX_InParam<1, HIThemeTabPaneDrawInfo>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"HIThemeDrawTrack", RR_ScalarRval, nullptr,
-     EX_Compose<EX_InParam<0, HIThemeTrackDrawInfo>,
-                EX_InParam<1, HIRect>,
-                EX_UpdateCFTypeArg<2>,
-                EX_ScalarArg<3>>},
+     EX_Compose<EX_InParam<0, HIThemeTrackDrawInfo>, EX_InParam<1, HIRect>,
+                EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"HIThemeGetGrowBoxBounds",
-     RR_Compose<RR_ScalarRval, RR_OutParam<2, HIRect>>,
-     nullptr,
-     EX_Compose<EX_InParam<0, HIPoint>,
-                EX_InParam<1, HIThemeGrowBoxDrawInfo>,
+     RR_Compose<RR_ScalarRval, RR_OutParam<2, HIRect>>, nullptr,
+     EX_Compose<EX_InParam<0, HIPoint>, EX_InParam<1, HIThemeGrowBoxDrawInfo>,
                 EX_OutParam<2, HIRect>>},
     {"HIThemeSetFill", RR_ScalarRval, nullptr,
      EX_Compose<EX_ScalarArg<0>, EX_UpdateCFTypeArg<2>, EX_ScalarArg<3>>},
     {"IORegistryEntrySearchCFProperty", RR_ScalarRval},
     {"LSCopyAllHandlersForURLScheme", RR_ScalarRval},
     {"LSCopyApplicationForMIMEType",
      RR_Compose<RR_ScalarRval, RR_OutParam<2, CFURLRef>>},
     {"LSCopyItemAttribute",
      RR_Compose<RR_ScalarRval, RR_OutParam<3, CFTypeRef>>},
     {"LSCopyKindStringForMIMEType",
      RR_Compose<RR_ScalarRval, RR_OutParam<1, CFStringRef>>},
-    {"LSGetApplicationForInfo",
-     RR_Compose<RR_ScalarRval,
-                RR_OutParam<4, FSRef>,
-                RR_OutParam<5, CFURLRef>>},
-    {"LSGetApplicationForURL",
-     RR_Compose<RR_ScalarRval,
-                RR_OutParam<2, FSRef>,
-                RR_OutParam<3, CFURLRef>>},
+    {"LSGetApplicationForInfo", RR_Compose<RR_ScalarRval, RR_OutParam<4, FSRef>,
+                                           RR_OutParam<5, CFURLRef>>},
+    {"LSGetApplicationForURL", RR_Compose<RR_ScalarRval, RR_OutParam<2, FSRef>,
+                                          RR_OutParam<3, CFURLRef>>},
     {"LSCopyDefaultApplicationURLForURL",
      RR_Compose<RR_ScalarRval, RR_OutParam<2, CFErrorRef>>},
     {"NSClassFromString", RR_ScalarRval, nullptr,
      EX_Compose<EX_CFTypeArg<0>, EX_CFTypeRval>},
     {"NSRectFill", nullptr, nullptr, EX_NoOp},
     {"NSSearchPathForDirectoriesInDomains", RR_ScalarRval},
     {"NSSetFocusRingStyle", nullptr, nullptr, EX_NoOp},
     {"NSTemporaryDirectory", RR_ScalarRval},
@@ -2966,19 +2902,17 @@ static SystemRedirection gSystemRedirect
     {"SLSSetDenyWindowServerConnections", RR_ScalarRval},
     {"SLSShutdownServerConnections"},
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Redirection Generation
 ///////////////////////////////////////////////////////////////////////////////
 
-size_t NumRedirections() {
-  return ArrayLength(gSystemRedirections);
-}
+size_t NumRedirections() { return ArrayLength(gSystemRedirections); }
 
 static Redirection* gRedirections;
 
 Redirection& GetRedirection(size_t aCallId) {
   MOZ_RELEASE_ASSERT(aCallId < ArrayLength(gSystemRedirections));
   return gRedirections[aCallId];
 }
 
@@ -3031,19 +2965,18 @@ void InitializeRedirections() {
     redirection.mSaveOutput = systemRedirection.mSaveOutput;
     redirection.mPreamble = systemRedirection.mPreamble;
     redirection.mExternalCall = systemRedirection.mExternalCall;
     redirection.mExternalPreamble = systemRedirection.mExternalPreamble;
 
     redirection.mOriginalFunction = FunctionStartAddress(redirection);
 
     if (IsRecordingOrReplaying()) {
-      redirection.mRedirectedFunction =
-          GenerateRedirectStub(assembler.ref(), i,
-                               PreserveCallerSaveRegisters(redirection.mName));
+      redirection.mRedirectedFunction = GenerateRedirectStub(
+          assembler.ref(), i, PreserveCallerSaveRegisters(redirection.mName));
       gRedirectionAddresses->insert(RedirectionAddressMap::value_type(
           std::string(redirection.mName), redirection.mRedirectedFunction));
     }
   }
 
   // Bind the gOriginal functions to their redirections' addresses.
 #define INIT_ORIGINAL_FUNCTION(aName) \
   gOriginal_##aName = OriginalFunction(#aName);
@@ -3080,18 +3013,17 @@ static void ApplyBinding(const char* aNa
   if (aName[0] != '_') {
     return;
   }
   aName++;
 
   void* binding = FindRedirectionBinding(aName);
   if (binding) {
     if (!strcmp(aName, "_tlv_bootstrap")) {
-      MOZ_RELEASE_ASSERT(gTLVGetAddress == nullptr ||
-                         gTLVGetAddress == *aPtr);
+      MOZ_RELEASE_ASSERT(gTLVGetAddress == nullptr || gTLVGetAddress == *aPtr);
       gTLVGetAddress = *aPtr;
     }
     *aPtr = binding;
   }
 }
 
 // Based on Apple's read_uleb128 implementation.
 static uint64_t ReadLEB128(uint8_t*& aPtr, uint8_t* aEnd) {
@@ -3126,75 +3058,75 @@ struct MachOLibrary {
   MachOLibrary(const char* aPath, uint8_t* aAddress) : mAddress(aAddress) {
     mFile = DirectOpenFile(aPath, /* aWriting */ false);
 
     struct stat info;
     int rv = fstat(mFile, &info);
     MOZ_RELEASE_ASSERT(rv >= 0);
 
     mFileSize = info.st_size;
-    mFileAddress = (uint8_t*)mmap(nullptr, mFileSize, PROT_READ,
-                                  MAP_PRIVATE, mFile, 0);
+    mFileAddress =
+        (uint8_t*)mmap(nullptr, mFileSize, PROT_READ, MAP_PRIVATE, mFile, 0);
     MOZ_RELEASE_ASSERT(mFileAddress != MAP_FAILED);
 
     mach_header_64* header = (mach_header_64*)mFileAddress;
     MOZ_RELEASE_ASSERT(header->magic == MH_MAGIC_64);
   }
 
   ~MachOLibrary() {
     munmap(mFileAddress, mFileSize);
     DirectCloseFile(mFile);
   }
 
   void ApplyRedirections() {
     ForEachCommand([=](load_command* aCmd) {
-        switch (aCmd->cmd & ~LC_REQ_DYLD) {
-          case LC_SYMTAB:
-            AddSymbolTable((symtab_command*)aCmd);
-            break;
-          case LC_DYSYMTAB:
-            AddDynamicSymbolTable((dysymtab_command*)aCmd);
-            break;
-        }
-      });
+      switch (aCmd->cmd & ~LC_REQ_DYLD) {
+        case LC_SYMTAB:
+          AddSymbolTable((symtab_command*)aCmd);
+          break;
+        case LC_DYSYMTAB:
+          AddDynamicSymbolTable((dysymtab_command*)aCmd);
+          break;
+      }
+    });
 
     ForEachCommand([=](load_command* aCmd) {
-        switch (aCmd->cmd & ~LC_REQ_DYLD) {
-          case LC_DYLD_INFO:
-            BindLoadInfo((dyld_info_command*)aCmd);
-            break;
-          case LC_SEGMENT_64:  {
-            auto ncmd = (segment_command_64*)aCmd;
-            mSegments.append(ncmd);
-            BindSegment(ncmd);
-            break;
-          }
+      switch (aCmd->cmd & ~LC_REQ_DYLD) {
+        case LC_DYLD_INFO:
+          BindLoadInfo((dyld_info_command*)aCmd);
+          break;
+        case LC_SEGMENT_64: {
+          auto ncmd = (segment_command_64*)aCmd;
+          mSegments.append(ncmd);
+          BindSegment(ncmd);
+          break;
         }
-      });
+      }
+    });
   }
 
   void ForEachCommand(const std::function<void(load_command*)>& aCallback) {
     mach_header_64* header = (mach_header_64*)mFileAddress;
     uint32_t offset = sizeof(mach_header_64);
     for (size_t i = 0; i < header->ncmds; i++) {
-      load_command* cmd = (load_command*) (mFileAddress + offset);
+      load_command* cmd = (load_command*)(mFileAddress + offset);
       aCallback(cmd);
       offset += cmd->cmdsize;
     }
   }
 
   void AddSymbolTable(symtab_command* aCmd) {
-    mSymbolTable = (nlist_64*) (mFileAddress + aCmd->symoff);
+    mSymbolTable = (nlist_64*)(mFileAddress + aCmd->symoff);
     mSymbolCount = aCmd->nsyms;
 
-    mStringTable = (char*) (mFileAddress + aCmd->stroff);
+    mStringTable = (char*)(mFileAddress + aCmd->stroff);
   }
 
   void AddDynamicSymbolTable(dysymtab_command* aCmd) {
-    mIndirectSymbols = (uint32_t*) (mFileAddress + aCmd->indirectsymoff);
+    mIndirectSymbols = (uint32_t*)(mFileAddress + aCmd->indirectsymoff);
     mIndirectSymbolCount = aCmd->nindirectsyms;
   }
 
   void BindLoadInfo(dyld_info_command* aCmd) {
     DoBindings(aCmd->bind_off, aCmd->bind_size);
     DoBindings(aCmd->weak_bind_off, aCmd->weak_bind_size);
     DoBindings(aCmd->lazy_bind_off, aCmd->lazy_bind_size);
   }
@@ -3232,39 +3164,39 @@ struct MachOLibrary {
           cursor += strlen(symbolName) + 1;
           break;
         case BIND_OPCODE_SET_TYPE_IMM:
           symbolType = immediate;
           break;
         case BIND_OPCODE_SET_ADDEND_SLEB:
           break;
         case BIND_OPCODE_DO_BIND:
-          DoBinding(segmentIndex, segmentOffset,
-                    symbolName, symbolFlags, symbolType);
+          DoBinding(segmentIndex, segmentOffset, symbolName, symbolFlags,
+                    symbolType);
           segmentOffset += sizeof(uintptr_t);
           break;
         case BIND_OPCODE_ADD_ADDR_ULEB:
           segmentOffset += ReadLEB128(cursor, end);
           break;
         case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
-          DoBinding(segmentIndex, segmentOffset,
-                    symbolName, symbolFlags, symbolType);
+          DoBinding(segmentIndex, segmentOffset, symbolName, symbolFlags,
+                    symbolType);
           segmentOffset += ReadLEB128(cursor, end) + sizeof(uintptr_t);
           break;
         case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
-          DoBinding(segmentIndex, segmentOffset,
-                    symbolName, symbolFlags, symbolType);
+          DoBinding(segmentIndex, segmentOffset, symbolName, symbolFlags,
+                    symbolType);
           segmentOffset += immediate * sizeof(uintptr_t) + sizeof(uintptr_t);
           break;
         case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: {
           size_t count = ReadLEB128(cursor, end);
           size_t skip = ReadLEB128(cursor, end);
           for (size_t i = 0; i < count; i++) {
-            DoBinding(segmentIndex, segmentOffset,
-                      symbolName, symbolFlags, symbolType);
+            DoBinding(segmentIndex, segmentOffset, symbolName, symbolFlags,
+                      symbolType);
             segmentOffset += skip + sizeof(uintptr_t);
           }
           break;
         }
         default:
           MOZ_CRASH("Unknown binding opcode");
       }
     }
@@ -3274,22 +3206,22 @@ struct MachOLibrary {
                  const char* aSymbolName, uint8_t aSymbolFlags,
                  uint8_t aSymbolType) {
     MOZ_RELEASE_ASSERT(aSegmentIndex < mSegments.length());
     segment_command_64* seg = mSegments[aSegmentIndex];
 
     uint8_t* address = mAddress + seg->vmaddr + aSegmentOffset;
 
     MOZ_RELEASE_ASSERT(aSymbolType == BIND_TYPE_POINTER);
-    void** ptr = (void**) address;
+    void** ptr = (void**)address;
     ApplyBinding(aSymbolName, ptr);
   }
 
   void BindSegment(segment_command_64* aCmd) {
-    section_64* sect = (section_64*) (aCmd + 1);
+    section_64* sect = (section_64*)(aCmd + 1);
     for (size_t i = 0; i < aCmd->nsects; i++, sect++) {
       switch (sect->flags & SECTION_TYPE) {
         case S_NON_LAZY_SYMBOL_POINTERS:
         case S_LAZY_SYMBOL_POINTERS: {
           size_t entryCount = sect->size / 8;
           size_t symbolStart = sect->reserved1;
           for (size_t i = 0; i < entryCount; i++) {
             void* ptr = mAddress + sect->addr + i * 8;
@@ -3311,21 +3243,21 @@ struct MachOLibrary {
   }
 };
 
 // One symbol from each library that is loaded at startup and has external
 // references we want to fix up. These libraries might not be loaded at startup
 // so we check again after each new library is loaded, and clear out these
 // entries once we have fixed their external references.
 static const char* gInitialLibrarySymbols[] = {
-  "RecordReplayInterface_Initialize", // XUL
-  "_ZN7mozilla12recordreplay10InitializeEiPPc", // libmozglue
-  "PR_Initialize", // libnss3
-  "FREEBL_GetVector", // libfreebl
-  "NSC_GetFunctionList", // libsoftokn3
+    "RecordReplayInterface_Initialize",            // XUL
+    "_ZN7mozilla12recordreplay10InitializeEiPPc",  // libmozglue
+    "PR_Initialize",                               // libnss3
+    "FREEBL_GetVector",                            // libfreebl
+    "NSC_GetFunctionList",                         // libsoftokn3
 };
 
 void ApplyLibraryRedirections(void* aLibrary) {
   for (const char*& symbol : gInitialLibrarySymbols) {
     if (!symbol) {
       continue;
     }
 
@@ -3366,45 +3298,46 @@ void ApplyLibraryRedirections(void* aLib
 // so that those constants can be converted to appropriate values on the host
 // platform.
 
 struct PlatformSymbol {
   const char* mName;
   uint32_t mValue;
 };
 
-#define NewPlatformSymbol(Name) { #Name, Name }
+#define NewPlatformSymbol(Name) \
+  { #Name, Name }
 
 extern "C" {
 
 MOZ_EXPORT PlatformSymbol RecordReplayInterface_PlatformSymbols[] = {
-  NewPlatformSymbol(PROT_READ),
-  NewPlatformSymbol(PROT_WRITE),
-  NewPlatformSymbol(PROT_EXEC),
-  NewPlatformSymbol(MAP_FIXED),
-  NewPlatformSymbol(MAP_PRIVATE),
-  NewPlatformSymbol(MAP_ANON),
-  NewPlatformSymbol(MAP_NORESERVE),
-  NewPlatformSymbol(PTHREAD_MUTEX_NORMAL),
-  NewPlatformSymbol(PTHREAD_MUTEX_RECURSIVE),
-  NewPlatformSymbol(PTHREAD_CREATE_JOINABLE),
-  NewPlatformSymbol(PTHREAD_CREATE_DETACHED),
-  NewPlatformSymbol(SYS_thread_selfid),
-  NewPlatformSymbol(_SC_PAGESIZE),
-  NewPlatformSymbol(_SC_NPROCESSORS_CONF),
-  NewPlatformSymbol(RLIMIT_AS),
-  NewPlatformSymbol(ETIMEDOUT),
-  NewPlatformSymbol(EINTR),
-  NewPlatformSymbol(EPIPE),
-  NewPlatformSymbol(EAGAIN),
-  NewPlatformSymbol(ECONNRESET),
-  { nullptr, 0 },
+    NewPlatformSymbol(PROT_READ),
+    NewPlatformSymbol(PROT_WRITE),
+    NewPlatformSymbol(PROT_EXEC),
+    NewPlatformSymbol(MAP_FIXED),
+    NewPlatformSymbol(MAP_PRIVATE),
+    NewPlatformSymbol(MAP_ANON),
+    NewPlatformSymbol(MAP_NORESERVE),
+    NewPlatformSymbol(PTHREAD_MUTEX_NORMAL),
+    NewPlatformSymbol(PTHREAD_MUTEX_RECURSIVE),
+    NewPlatformSymbol(PTHREAD_CREATE_JOINABLE),
+    NewPlatformSymbol(PTHREAD_CREATE_DETACHED),
+    NewPlatformSymbol(SYS_thread_selfid),
+    NewPlatformSymbol(_SC_PAGESIZE),
+    NewPlatformSymbol(_SC_NPROCESSORS_CONF),
+    NewPlatformSymbol(RLIMIT_AS),
+    NewPlatformSymbol(ETIMEDOUT),
+    NewPlatformSymbol(EINTR),
+    NewPlatformSymbol(EPIPE),
+    NewPlatformSymbol(EAGAIN),
+    NewPlatformSymbol(ECONNRESET),
+    {nullptr, 0},
 };
 
-} // extern "C"
+}  // extern "C"
 
 ///////////////////////////////////////////////////////////////////////////////
 // Direct system call API
 ///////////////////////////////////////////////////////////////////////////////
 
 const char* SymbolNameRaw(void* aPtr) {
   Dl_info info;
   return (dladdr(aPtr, &info) && info.dli_sname) ? info.dli_sname : "???";
@@ -3483,18 +3416,18 @@ static double gNsPerTick;
 
 void InitializeCurrentTime() {
   mach_timebase_info_data_t info;
   mach_timebase_info(&info);
   gNsPerTick = (double)info.numer / info.denom;
 }
 
 double CurrentTime() {
-  return CallFunction<int64_t>(gOriginal_mach_absolute_time) *
-         gNsPerTick / 1000.0;
+  return CallFunction<int64_t>(gOriginal_mach_absolute_time) * gNsPerTick /
+         1000.0;
 }
 
 NativeThreadId DirectSpawnThread(void (*aFunction)(void*), void* aArgument,
                                  void* aStackBase, size_t aStackSize) {
   MOZ_RELEASE_ASSERT(!IsRecordingOrReplaying() ||
                      AreThreadEventsPassedThrough());
 
   pthread_attr_t attr;
--- a/toolkit/recordreplay/ProcessRewind.cpp
+++ b/toolkit/recordreplay/ProcessRewind.cpp
@@ -22,19 +22,17 @@ static size_t gLastCheckpoint = InvalidC
 
 // Lock for managing pending main thread callbacks.
 static Monitor* gMainThreadCallbackMonitor;
 
 // Callbacks to execute on the main thread, in FIFO order. Protected by
 // gMainThreadCallbackMonitor.
 static StaticInfallibleVector<std::function<void()>> gMainThreadCallbacks;
 
-void InitializeRewindState() {
-  gMainThreadCallbackMonitor = new Monitor();
-}
+void InitializeRewindState() { gMainThreadCallbackMonitor = new Monitor(); }
 
 void NewCheckpoint() {
   MOZ_RELEASE_ASSERT(Thread::CurrentIsMainThread());
   MOZ_RELEASE_ASSERT(!AreThreadEventsPassedThrough());
   MOZ_RELEASE_ASSERT(!HasDivergedFromRecording());
 
   gLastCheckpoint++;
 
--- a/toolkit/recordreplay/Recording.cpp
+++ b/toolkit/recordreplay/Recording.cpp
@@ -175,20 +175,19 @@ void Stream::RecordOrReplayThreadEvent(T
       if (oldEvent == ThreadEvent::Assert) {
         // Include the asserted string in the error. This must match up with
         // the writes in RecordReplayAssert.
         if (mNameIndex == MainThreadId) {
           (void)ReadScalar();  // For the ExecutionProgressCounter write below.
         }
         extra = ReadInputString();
       }
-      child::ReportFatalError(
-          "Event Mismatch: Recorded %s %s Replayed %s %s",
-          ThreadEventName(oldEvent), extra,
-          ThreadEventName(aEvent), aExtra ? aExtra : "");
+      child::ReportFatalError("Event Mismatch: Recorded %s %s Replayed %s %s",
+                              ThreadEventName(oldEvent), extra,
+                              ThreadEventName(aEvent), aExtra ? aExtra : "");
     }
     mLastEvent = aEvent;
     PushEvent(ThreadEventName(aEvent));
   }
 
   // Check the execution progress counter for events executing on the main
   // thread.
   if (mNameIndex == MainThreadId) {
@@ -292,19 +291,18 @@ void Stream::Flush(bool aTakeLock) {
                DontCopyExistingData);
 
   size_t compressedSize =
       Compression::LZ4::compress(mBuffer.get(), mBufferPos, mBallast.get());
   MOZ_RELEASE_ASSERT(compressedSize != 0);
   MOZ_RELEASE_ASSERT((size_t)compressedSize <= bound);
 
   StreamChunkLocation chunk =
-      mRecording->WriteChunk(mName, mNameIndex,
-                             mBallast.get(), compressedSize, mBufferPos,
-                             mStreamPos - mBufferPos, aTakeLock);
+      mRecording->WriteChunk(mName, mNameIndex, mBallast.get(), compressedSize,
+                             mBufferPos, mStreamPos - mBufferPos, aTakeLock);
   mChunks.append(chunk);
   MOZ_ALWAYS_TRUE(++mChunkIndex == mChunks.length());
 
   mBufferPos = 0;
 }
 
 /* static */
 size_t Stream::BallastMaxSize() {
@@ -391,17 +389,17 @@ void Recording::NewContents(const uint8_
   MOZ_RELEASE_ASSERT(IsReading());
 
   // Make sure the header matches when reading the first data in the recording.
   size_t offset = 0;
   if (mContents.empty()) {
     MOZ_RELEASE_ASSERT(aSize >= sizeof(Header));
     offset += sizeof(Header);
 
-    Header* header = (Header*) aContents;
+    Header* header = (Header*)aContents;
     MOZ_RELEASE_ASSERT(header->mMagic == MagicValue);
 
     BuildId currentBuildId;
     GetCurrentBuildId(&currentBuildId);
     MOZ_RELEASE_ASSERT(currentBuildId.Matches(header->mBuildId));
   }
 
   mContents.append(aContents, aSize);
@@ -447,29 +445,30 @@ StreamChunkLocation Recording::WriteChun
   StreamChunkLocation chunk;
   chunk.mOffset = mContents.length() + sizeof(ChunkDescriptor);
   chunk.mCompressedSize = aCompressedSize;
   chunk.mDecompressedSize = aDecompressedSize;
   chunk.mHash = HashBytes(aStart, aCompressedSize);
   chunk.mStreamPos = aStreamPos;
 
   ChunkDescriptor desc;
-  desc.mName = (uint32_t) aName;
+  desc.mName = (uint32_t)aName;
   desc.mNameIndex = aNameIndex;
   desc.mChunk = chunk;
 
   mContents.append((const uint8_t*)&desc, sizeof(ChunkDescriptor));
   mContents.append(aStart, aCompressedSize);
 
   return chunk;
 }
 
 void Recording::ReadChunk(char* aDest, const StreamChunkLocation& aChunk) {
   AutoSpinLock lock(mLock);
-  MOZ_RELEASE_ASSERT(aChunk.mOffset + aChunk.mCompressedSize <= mContents.length());
+  MOZ_RELEASE_ASSERT(aChunk.mOffset + aChunk.mCompressedSize <=
+                     mContents.length());
   memcpy(aDest, mContents.begin() + aChunk.mOffset, aChunk.mCompressedSize);
   MOZ_RELEASE_ASSERT(HashBytes(aDest, aChunk.mCompressedSize) == aChunk.mHash);
 }
 
 Stream* Recording::OpenStream(StreamName aName, size_t aNameIndex) {
   AutoSpinLock lock(mLock);
 
   auto& vector = mStreams[(size_t)aName];
--- a/toolkit/recordreplay/Recording.h
+++ b/toolkit/recordreplay/Recording.h
@@ -172,17 +172,18 @@ class Stream {
 
   template <typename T>
   inline void RecordOrReplayValue(T* aPtr) {
     RecordOrReplayBytes(aPtr, sizeof(T));
   }
 
   // Note a new thread event for this stream, and make sure it is the same
   // while replaying as it was while recording.
-  void RecordOrReplayThreadEvent(ThreadEvent aEvent, const char* aExtra = nullptr);
+  void RecordOrReplayThreadEvent(ThreadEvent aEvent,
+                                 const char* aExtra = nullptr);
 
   // Replay a thread event without requiring it to be a specific event.
   ThreadEvent ReplayThreadEvent();
 
   // Make sure that a value or buffer is the same while replaying as it was
   // while recording.
   void CheckInput(size_t aValue);
   void CheckInput(const char* aValue);
--- a/toolkit/recordreplay/Thread.cpp
+++ b/toolkit/recordreplay/Thread.cpp
@@ -108,31 +108,32 @@ static int gWaitForeverFd;
 void Thread::InitializeThreads() {
   FileHandle writeFd, readFd;
   DirectCreatePipe(&writeFd, &readFd);
   gWaitForeverFd = readFd;
 
   gThreads = new Thread[MaxThreadId + 1];
 
   size_t nbytes = (MaxThreadId - MainThreadId) * ThreadStackSize;
-  gThreadStackMemory = (uint8_t*) DirectAllocateMemory(nbytes);
+  gThreadStackMemory = (uint8_t*)DirectAllocateMemory(nbytes);
 
   for (size_t i = MainThreadId; i <= MaxThreadId; i++) {
     Thread* thread = &gThreads[i];
     PodZero(thread);
     new (thread) Thread();
 
     thread->mId = i;
     thread->mEvents = gRecording->OpenStream(StreamName::Event, i);
 
     if (i == MainThreadId) {
       thread->BindToCurrent();
       thread->mNativeId = DirectCurrentThread();
     } else {
-      thread->mStackBase = gThreadStackMemory + (i - MainThreadId - 1) * ThreadStackSize;
+      thread->mStackBase =
+          gThreadStackMemory + (i - MainThreadId - 1) * ThreadStackSize;
       thread->mStackSize = ThreadStackSize - PageSize * 2;
 
       // Make some memory between thread stacks inaccessible so that breakpad
       // can tell the different thread stacks apart.
       DirectMakeInaccessible(thread->mStackBase + ThreadStackSize - PageSize,
                              PageSize);
 
       thread->SetPassThrough(true);
@@ -316,39 +317,40 @@ void Thread::ReleaseOrAcquireOwnedLocks(
       DirectUnlockMutex(lock, /* aPassThroughEvents */ false);
     } else {
       DirectLockMutex(lock, /* aPassThroughEvents */ false);
     }
   }
 }
 
 void** Thread::GetOrCreateStorage(uintptr_t aKey) {
-  for (StorageEntry** pentry = &mStorageEntries; *pentry; pentry = &(*pentry)->mNext) {
+  for (StorageEntry** pentry = &mStorageEntries; *pentry;
+       pentry = &(*pentry)->mNext) {
     StorageEntry* entry = *pentry;
     if (entry->mKey == aKey) {
       // Put this at the front of the list.
       *pentry = entry->mNext;
       entry->mNext = mStorageEntries;
       mStorageEntries = entry;
       return &entry->mData;
     }
   }
-  StorageEntry* entry = (StorageEntry*) AllocateStorage(sizeof(StorageEntry));
+  StorageEntry* entry = (StorageEntry*)AllocateStorage(sizeof(StorageEntry));
   entry->mKey = aKey;
   entry->mData = 0;
   entry->mNext = mStorageEntries;
   mStorageEntries = entry;
   return &entry->mData;
 }
 
 uint8_t* Thread::AllocateStorage(size_t aSize) {
   // malloc uses TLS, so go directly to the system to allocate TLS storage.
   if (mStorageCursor + aSize >= mStorageLimit) {
     size_t nbytes = std::max(aSize, PageSize);
-    mStorageCursor = (uint8_t*) DirectAllocateMemory(nbytes);
+    mStorageCursor = (uint8_t*)DirectAllocateMemory(nbytes);
     mStorageLimit = mStorageCursor + nbytes;
   }
   uint8_t* res = mStorageCursor;
   mStorageCursor += aSize;
   return res;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -505,18 +507,17 @@ void Thread::NotifyUnrecordedWait(
 
   // The main thread might be able to make progress now by calling the routine
   // if it is waiting for idle replay threads.
   if (mShouldIdle) {
     Notify(MainThreadId);
   }
 }
 
-bool Thread::MaybeWaitForFork(
-    const std::function<void()>& aReleaseCallback) {
+bool Thread::MaybeWaitForFork(const std::function<void()>& aReleaseCallback) {
   MOZ_RELEASE_ASSERT(!PassThroughEvents());
   if (IsMainThread()) {
     return false;
   }
   MonitorAutoLock lock(*gMonitor);
   if (!mShouldIdle) {
     return false;
   }
--- a/toolkit/recordreplay/Thread.h
+++ b/toolkit/recordreplay/Thread.h
@@ -168,17 +168,16 @@ class Thread {
   };
   StorageEntry* mStorageEntries;
   uint8_t* mStorageCursor;
   uint8_t* mStorageLimit;
 
   uint8_t* AllocateStorage(size_t aSize);
 
  public:
-
   // These are used by certain redirections to convey information from the
   // SaveOutput hook to the MiddlemanCall hook.
   uintptr_t mRedirectionValue;
   InfallibleVector<char> mRedirectionData;
 
   ///////////////////////////////////////////////////////////////////////////////
   // Public Routines
   ///////////////////////////////////////////////////////////////////////////////
@@ -231,19 +230,17 @@ class Thread {
 
   // Return whether this thread may read or write to its recorded event stream.
   bool CanAccessRecording() const {
     return !PassThroughEvents() && !AreEventsDisallowed() &&
            !HasDivergedFromRecording();
   }
 
   // Get the macOS mach identifier for this thread.
-  uintptr_t GetMachId() const {
-    return mMachId;
-  }
+  uintptr_t GetMachId() const { return mMachId; }
 
   // The actual start routine at the root of all recorded threads, and of all
   // threads when replaying.
   static void ThreadMain(void* aArgument);
 
   // Bind this Thread to the current system thread, setting Thread::Current()
   // and some other basic state.
   void BindToCurrent();
--- a/toolkit/recordreplay/ThreadSnapshot.cpp
+++ b/toolkit/recordreplay/ThreadSnapshot.cpp
@@ -170,18 +170,17 @@ bool SaveThreadState(size_t aId, int* aS
               THREAD_STACK_TOP_BYTES_OFFSET &&
           offsetof(ThreadState, mStackContents) ==
               THREAD_STACK_CONTENTS_OFFSET &&
           offsetof(ThreadState, mStackBytes) == THREAD_STACK_BYTES_OFFSET,
       "Incorrect ThreadState offsets");
 
   MOZ_RELEASE_ASSERT(aId <= MaxThreadId);
   ThreadState* info = &gThreadState[aId];
-  bool res =
-      SaveThreadStateOrReturnFromRestore(info, aStackSeparator) == 0;
+  bool res = SaveThreadStateOrReturnFromRestore(info, aStackSeparator) == 0;
   if (!res) {
     ClearThreadState(info);
   }
   return res;
 }
 
 void SaveThreadStack(size_t aId) {
   Thread* thread = Thread::GetById(aId);
@@ -194,23 +193,22 @@ void SaveThreadStack(size_t aId) {
   MOZ_RELEASE_ASSERT(stackTop >= stackPointer);
   size_t stackBytes = stackTop - stackPointer;
 
   MOZ_RELEASE_ASSERT(stackBytes >= info.mStackTopBytes);
 
   // Release any existing stack contents from a previous fork.
   free(info.mStackContents);
 
-  info.mStackContents = (uint8_t*) malloc(stackBytes);
+  info.mStackContents = (uint8_t*)malloc(stackBytes);
   info.mStackBytes = stackBytes;
 
   memcpy(info.mStackContents, info.mStackTop, info.mStackTopBytes);
   memcpy(info.mStackContents + info.mStackTopBytes,
-         stackPointer + info.mStackTopBytes,
-         stackBytes - info.mStackTopBytes);
+         stackPointer + info.mStackTopBytes, stackBytes - info.mStackTopBytes);
 }
 
 void RestoreThreadStack(size_t aId) {
   MOZ_RELEASE_ASSERT(aId <= MaxThreadId);
 
   ThreadState* info = &gThreadState[aId];
   MOZ_RELEASE_ASSERT(info->mStackContents);
 
--- a/toolkit/recordreplay/ipc/Channel.cpp
+++ b/toolkit/recordreplay/ipc/Channel.cpp
@@ -63,17 +63,18 @@ Channel::Channel(size_t aId, Kind aKind,
                  base::ProcessId aParentPid)
     : mId(aId),
       mKind(aKind),
       mHandler(aHandler),
       mInitialized(false),
       mConnectionFd(0),
       mFd(0),
       mMessageBytes(0) {
-  MOZ_RELEASE_ASSERT(!IsRecordingOrReplaying() || AreThreadEventsPassedThrough());
+  MOZ_RELEASE_ASSERT(!IsRecordingOrReplaying() ||
+                     AreThreadEventsPassedThrough());
 
   if (IsParent()) {
     ipc::FileDescriptor connection;
     if (aKind == Kind::MiddlemanReplay) {
       // The middleman is sandboxed at this point and the parent must open
       // the channel on our behalf.
       dom::ContentChild::GetSingleton()->SendOpenRecordReplayChannel(
           aId, &connection);
@@ -218,18 +219,17 @@ Message::UniquePtr Channel::WaitForMessa
     mMessageBytes += nbytes;
   }
 
   Message::UniquePtr res = ((Message*)mMessageBuffer.begin())->Clone();
 
   // Remove the message we just received from the incoming buffer.
   size_t remaining = mMessageBytes - messageSize;
   if (remaining) {
-    memmove(mMessageBuffer.begin(), &mMessageBuffer[messageSize],
-            remaining);
+    memmove(mMessageBuffer.begin(), &mMessageBuffer[messageSize], remaining);
   }
   mMessageBytes = remaining;
 
   PrintMessage("RecvMsg", *res);
   return res;
 }
 
 void Channel::ExitIfNotInitializedBefore(const TimeStamp& aDeadline) {
--- a/toolkit/recordreplay/ipc/Channel.h
+++ b/toolkit/recordreplay/ipc/Channel.h
@@ -36,21 +36,21 @@ namespace recordreplay {
 //
 // Messages can be sent from the child process to the middleman only when the
 // child process is unpaused, and messages can only be sent from the middleman
 // to the child process when the child process is paused. This prevents
 // messages from being lost when they are sent from the middleman as the
 // replaying process rewinds itself. A few exceptions to this rule are noted
 // below.
 
-#define ForEachMessageType(_Macro)                             \
+#define ForEachMessageType(_Macro)                                            \
   /* Messages which can be interpreted or constructed by the cloud server. */ \
-  /* Avoid changing the message IDs for these. */              \
-                                                               \
-  /* Sent by the middleman at startup. */                      \
+  /* Avoid changing the message IDs for these. */                             \
+                                                                              \
+  /* Sent by the middleman at startup. */                                     \
   _Macro(Introduction)                                         \
                                                                \
   /* An error occurred in the cloud server. */                 \
   _Macro(CloudError)                                           \
                                                                \
   /* Messages sent from the middleman to the child process. */ \
                                                                \
   /* Sent to recording processes to indicate that the middleman will be running */ \
@@ -157,20 +157,18 @@ struct Message {
   }
 
   // Return whether this is a middleman->child message that can be sent while
   // the child is unpaused.
   bool CanBeSentWhileUnpaused() const {
     return mType == MessageType::CreateCheckpoint ||
            mType == MessageType::SetDebuggerRunsInMiddleman ||
            mType == MessageType::ExternalCallResponse ||
-           mType == MessageType::Ping ||
-           mType == MessageType::Terminate ||
-           mType == MessageType::Crash ||
-           mType == MessageType::Introduction ||
+           mType == MessageType::Ping || mType == MessageType::Terminate ||
+           mType == MessageType::Crash || mType == MessageType::Introduction ||
            mType == MessageType::RecordingData;
   }
 
  protected:
   template <typename T, typename Elem>
   Elem* Data() {
     return (Elem*)(sizeof(T) + (char*)this);
   }
@@ -281,17 +279,18 @@ struct ErrorMessage : public Message {
       : Message(Type, aSize, aForkId) {}
 
   const char* Error() const { return Data<ErrorMessage<Type>, const char>(); }
 };
 
 typedef ErrorMessage<MessageType::FatalError> FatalErrorMessage;
 typedef ErrorMessage<MessageType::CloudError> CloudErrorMessage;
 
-typedef EmptyMessage<MessageType::UnhandledDivergence> UnhandledDivergenceMessage;
+typedef EmptyMessage<MessageType::UnhandledDivergence>
+    UnhandledDivergenceMessage;
 
 // The format for graphics data which will be sent to the middleman process.
 // This needs to match the format expected for canvas image data, to avoid
 // transforming the data before rendering it in the middleman process.
 static const gfx::SurfaceFormat gSurfaceFormat = gfx::SurfaceFormat::R8G8B8X8;
 
 struct PaintMessage : public Message {
   uint32_t mWidth;
@@ -421,17 +420,17 @@ class Channel {
 
   // Main routine for the channel's thread.
   static void ThreadMain(void* aChannel);
 
   void SendRaw(const char* aData, size_t aSize);
 
   // Return whether this is the parent side of a connection. This side is opened
   // first and the child will connect to it afterwards.
-  bool IsParent()  {
+  bool IsParent() {
     switch (mKind) {
       case Kind::MiddlemanRecord:
       case Kind::MiddlemanReplay:
       case Kind::ReplayForked:
         return true;
       case Kind::RecordReplay:
       case Kind::ParentCloud:
       case Kind::ReplayRoot:
--- a/toolkit/recordreplay/ipc/ChildIPC.cpp
+++ b/toolkit/recordreplay/ipc/ChildIPC.cpp
@@ -156,18 +156,18 @@ static void ChannelMessageHandler(Messag
       gCallResponseMessage.reset(
           static_cast<ExternalCallResponseMessage*>(aMsg.release()));
       gMonitor->NotifyAll();
       break;
     }
     case MessageType::RecordingData: {
       MonitorAutoLock lock(*gMonitor);
       const RecordingDataMessage& nmsg = (const RecordingDataMessage&)*aMsg;
-      MOZ_RELEASE_ASSERT(
-          nmsg.mTag == gRecording->Size() + gPendingRecordingData.length());
+      MOZ_RELEASE_ASSERT(nmsg.mTag ==
+                         gRecording->Size() + gPendingRecordingData.length());
       gPendingRecordingData.append(nmsg.BinaryData(), nmsg.BinaryDataSize());
       gMonitor->NotifyAll();
       break;
     }
     default:
       MOZ_CRASH();
   }
 }
@@ -346,19 +346,19 @@ static char* gFatalErrorMemory;
 static const size_t FatalErrorMemorySize = PageSize;
 
 static void ForkListenerThread(void*) {
   while (true) {
     ForkedProcess process;
     int nbytes = read(gForkReadFd, &process, sizeof(process));
     MOZ_RELEASE_ASSERT(nbytes == sizeof(process));
 
-    process.mChannel = new Channel(0, Channel::Kind::ReplayRoot,
-                                   HandleMessageFromForkedProcess,
-                                   process.mPid);
+    process.mChannel =
+        new Channel(0, Channel::Kind::ReplayRoot,
+                    HandleMessageFromForkedProcess, process.mPid);
 
     // Send any messages destined for this fork.
     size_t i = 0;
     while (i < gPendingForkMessages.length()) {
       auto& pending = gPendingForkMessages[i];
       if (pending->mForkId == process.mForkId) {
         process.mChannel->SendMessage(std::move(*pending));
         gPendingForkMessages.erase(&pending);
@@ -372,28 +372,28 @@ static void ForkListenerThread(void*) {
 }
 
 static void InitializeForkListener() {
   DirectCreatePipe(&gForkWriteFd, &gForkReadFd);
 
   Thread::SpawnNonRecordedThread(ForkListenerThread, nullptr);
 
   if (!ReplayingInCloud()) {
-    gFatalErrorMemory = (char*) mmap(nullptr, FatalErrorMemorySize,
-                                     PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
+    gFatalErrorMemory =
+        (char*)mmap(nullptr, FatalErrorMemorySize, PROT_READ | PROT_WRITE,
+                    MAP_ANON | MAP_SHARED, -1, 0);
     MOZ_RELEASE_ASSERT(gFatalErrorMemory != MAP_FAILED);
   }
 }
 
 static void SendMessageToForkedProcess(Message::UniquePtr aMsg) {
   for (ForkedProcess& process : gForkedProcesses) {
     if (process.mForkId == aMsg->mForkId) {
-      bool remove =
-          aMsg->mType == MessageType::Terminate ||
-          aMsg->mType == MessageType::Crash;
+      bool remove = aMsg->mType == MessageType::Terminate ||
+                    aMsg->mType == MessageType::Crash;
       process.mChannel->SendMessage(std::move(*aMsg));
       if (remove) {
         gForkedProcesses.erase(&process);
       }
       return;
     }
   }
 
@@ -462,25 +462,26 @@ void RegisterFork(size_t aForkId) {
   gChannel->ExitIfNotInitializedBefore(deadline);
 }
 
 static void SendFatalErrorMessage(size_t aForkId, const char* aMessage) {
   // Construct a FatalErrorMessage on the stack, to avoid touching the heap.
   char msgBuf[4096];
   size_t header = sizeof(FatalErrorMessage);
   size_t len = std::min(strlen(aMessage) + 1, sizeof(msgBuf) - header);
-  FatalErrorMessage* msg = new (msgBuf) FatalErrorMessage(header + len, aForkId);
+  FatalErrorMessage* msg =
+      new (msgBuf) FatalErrorMessage(header + len, aForkId);
   memcpy(&msgBuf[header], aMessage, len);
   msgBuf[sizeof(msgBuf) - 1] = 0;
 
   // Don't take the message lock when sending this, to avoid touching the heap.
   gChannel->SendMessage(std::move(*msg));
 
-  Print("***** Fatal Record/Replay Error #%lu:%lu *****\n%s\n", GetId(), aForkId,
-        aMessage);
+  Print("***** Fatal Record/Replay Error #%lu:%lu *****\n%s\n", GetId(),
+        aForkId, aMessage);
 }
 
 void ReportCrash(const MinidumpInfo& aInfo, void* aFaultingAddress) {
   int pid;
   pid_for_task(aInfo.mTask, &pid);
 
   uint32_t forkId = UINT32_MAX;
   if (aInfo.mTask != mach_task_self()) {
@@ -532,17 +533,17 @@ extern "C" {
 
 // When running in the cloud the translation layer detects crashes that have
 // occurred in the current process, and uses this interface to report those
 // crashes to the middleman.
 MOZ_EXPORT void RecordReplayInterface_ReportCrash(const char* aMessage) {
   SendFatalErrorMessage(gForkId, aMessage);
 }
 
-} // extern "C"
+}  // extern "C"
 
 void ReportUnhandledDivergence() {
   gChannel->SendMessage(UnhandledDivergenceMessage(gForkId));
 
   // Block until we get a terminate message and die.
   Thread::WaitForeverNoIdle();
 }
 
@@ -835,48 +836,48 @@ void ManifestFinished(const js::CharBuff
   ManifestFinishedMessage* msg =
       ManifestFinishedMessage::New(gForkId, aBuffer.begin(), aBuffer.length());
   PauseMainThreadAndInvokeCallback([=]() {
     gChannel->SendMessage(std::move(*msg));
     free(msg);
   });
 }
 
-void SendExternalCallRequest(ExternalCallId aId,
-                             const char* aInputData, size_t aInputSize,
+void SendExternalCallRequest(ExternalCallId aId, const char* aInputData,
+                             size_t aInputSize,
                              InfallibleVector<char>* aOutputData) {
   AutoPassThroughThreadEvents pt;
   MonitorAutoLock lock(*gMonitor);
 
   while (gWaitingForCallResponse) {
     gMonitor->Wait();
   }
   gWaitingForCallResponse = true;
 
-  UniquePtr<ExternalCallRequestMessage> msg(ExternalCallRequestMessage::New(
-      gForkId, aId, aInputData, aInputSize));
+  UniquePtr<ExternalCallRequestMessage> msg(
+      ExternalCallRequestMessage::New(gForkId, aId, aInputData, aInputSize));
   gChannel->SendMessage(std::move(*msg));
 
   while (!gCallResponseMessage) {
     gMonitor->Wait();
   }
 
   aOutputData->append(gCallResponseMessage->BinaryData(),
                       gCallResponseMessage->BinaryDataSize());
 
   gCallResponseMessage = nullptr;
   gWaitingForCallResponse = false;
 
   gMonitor->Notify();
 }
 
-void SendExternalCallOutput(ExternalCallId aId,
-                            const char* aOutputData, size_t aOutputSize) {
-  Message::UniquePtr msg(ExternalCallResponseMessage::New(
-      gForkId, aId, aOutputData, aOutputSize));
+void SendExternalCallOutput(ExternalCallId aId, const char* aOutputData,
+                            size_t aOutputSize) {
+  Message::UniquePtr msg(
+      ExternalCallResponseMessage::New(gForkId, aId, aOutputData, aOutputSize));
   gChannel->SendMessage(std::move(*msg));
 }
 
 void SendRecordingData(size_t aStart, const uint8_t* aData, size_t aSize) {
   MOZ_RELEASE_ASSERT(Thread::CurrentIsMainThread());
   RecordingDataMessage* msg =
       RecordingDataMessage::New(gForkId, aStart, (const char*)aData, aSize);
   gChannel->SendMessage(std::move(*msg));
--- a/toolkit/recordreplay/ipc/ChildInternal.h
+++ b/toolkit/recordreplay/ipc/ChildInternal.h
@@ -57,24 +57,24 @@ extern Monitor* gMonitor;
 
 // Whether the middleman runs developer tools server code.
 bool DebuggerRunsInMiddleman();
 
 // Notify the middleman that the last manifest was finished.
 void ManifestFinished(const js::CharBuffer& aResponse);
 
 // Send messages operating on external calls.
-void SendExternalCallRequest(ExternalCallId aId,
-                             const char* aInputData, size_t aInputSize,
+void SendExternalCallRequest(ExternalCallId aId, const char* aInputData,
+                             size_t aInputSize,
                              InfallibleVector<char>* aOutputData);
 
 // Send the output from an external call to the root replaying process,
 // to fill in its external call cache.
-void SendExternalCallOutput(ExternalCallId aId,
-                            const char* aOutputData, size_t aOutputSize);
+void SendExternalCallOutput(ExternalCallId aId, const char* aOutputData,
+                            size_t aOutputSize);
 
 // Return whether a repaint is in progress and is not allowed to trigger an
 // unhandled recording divergence per preferences.
 bool CurrentRepaintCannotFail();
 
 // Paint according to the current process state, then convert it to an image
 // and serialize it in aData.
 bool Repaint(nsACString& aData);
--- a/toolkit/recordreplay/ipc/ChildProcess.cpp
+++ b/toolkit/recordreplay/ipc/ChildProcess.cpp
@@ -22,21 +22,21 @@ void ChildProcessInfo::SetIntroductionMe
   gIntroductionMessage = aMessage;
 }
 
 ChildProcessInfo::ChildProcessInfo(
     size_t aId, const Maybe<RecordingProcessData>& aRecordingProcessData)
     : mRecording(aRecordingProcessData.isSome()) {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 
-  Channel::Kind kind =
-    IsRecording() ? Channel::Kind::MiddlemanRecord : Channel::Kind::MiddlemanReplay;
+  Channel::Kind kind = IsRecording() ? Channel::Kind::MiddlemanRecord
+                                     : Channel::Kind::MiddlemanReplay;
   mChannel = new Channel(aId, kind, [=](Message::UniquePtr aMsg) {
-        ReceiveChildMessageOnMainThread(aId, std::move(aMsg));
-      });
+    ReceiveChildMessageOnMainThread(aId, std::move(aMsg));
+  });
 
   LaunchSubprocess(aId, aRecordingProcessData);
 }
 
 ChildProcessInfo::~ChildProcessInfo() {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   SendMessage(TerminateMessage(0));
 }
@@ -292,17 +292,17 @@ void ChildProcessInfo::MaybeProcessPendi
       break;
     }
   }
 }
 
 // Execute a task that processes a message received from the child. This is
 // called on a channel thread, and the function executes asynchronously on
 // the main thread.
-  /* static */ void ChildProcessInfo::ReceiveChildMessageOnMainThread(
+/* static */ void ChildProcessInfo::ReceiveChildMessageOnMainThread(
     size_t aChildId, Message::UniquePtr aMsg) {
   MOZ_RELEASE_ASSERT(!NS_IsMainThread());
 
   MonitorAutoLock lock(*gMonitor);
 
   PendingMessage pending;
   pending.mChildId = aChildId;
   pending.mMsg = std::move(aMsg);
--- a/toolkit/recordreplay/ipc/JSControl.cpp
+++ b/toolkit/recordreplay/ipc/JSControl.cpp
@@ -260,18 +260,18 @@ static bool Middleman_SendManifest(JSCon
 
   CharBuffer manifestBuffer;
   if (!ToJSONMaybeSafely(aCx, manifestObject, FillCharBufferCallback,
                          &manifestBuffer)) {
     return false;
   }
 
   size_t forkId;
-  parent::ChildProcessInfo* child = ToChildProcess(aCx, args.get(0),
-                                                   args.get(1), &forkId);
+  parent::ChildProcessInfo* child =
+      ToChildProcess(aCx, args.get(0), args.get(1), &forkId);
   if (!child) {
     return false;
   }
 
   ManifestStartMessage* msg = ManifestStartMessage::New(
       forkId, manifestBuffer.begin(), manifestBuffer.length());
   child->SendMessage(std::move(*msg));
   free(msg);
@@ -279,18 +279,18 @@ static bool Middleman_SendManifest(JSCon
   args.rval().setUndefined();
   return true;
 }
 
 static bool Middleman_Ping(JSContext* aCx, unsigned aArgc, Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   size_t forkId;
-  parent::ChildProcessInfo* child = ToChildProcess(aCx, args.get(0),
-                                                   args.get(1), &forkId);
+  parent::ChildProcessInfo* child =
+      ToChildProcess(aCx, args.get(0), args.get(1), &forkId);
   if (!child) {
     return false;
   }
 
   size_t pingId;
   if (!RequireNumber(aCx, args.get(2), &pingId)) {
     return false;
   }
@@ -423,35 +423,35 @@ static bool Middleman_Atomize(JSContext*
   args.rval().setString(atom);
   return true;
 }
 
 static bool Middleman_Terminate(JSContext* aCx, unsigned aArgc, Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   size_t forkId;
-  parent::ChildProcessInfo* child = ToChildProcess(aCx, args.get(0),
-                                                   args.get(1), &forkId);
+  parent::ChildProcessInfo* child =
+      ToChildProcess(aCx, args.get(0), args.get(1), &forkId);
   if (!child) {
     return false;
   }
 
   child->SendMessage(TerminateMessage(forkId));
 
   args.rval().setUndefined();
   return true;
 }
 
 static bool Middleman_CrashHangedChild(JSContext* aCx, unsigned aArgc,
                                        Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   size_t forkId;
-  parent::ChildProcessInfo* child = ToChildProcess(aCx, args.get(0),
-                                                   args.get(1), &forkId);
+  parent::ChildProcessInfo* child =
+      ToChildProcess(aCx, args.get(0), args.get(1), &forkId);
   if (!child) {
     return false;
   }
 
   // Try to get the child to crash, so that we can get a minidump.
   CrashReporter::AnnotateCrashReport(
       CrashReporter::Annotation::RecordReplayHang, true);
   child->SendMessage(CrashMessage(forkId));
@@ -467,18 +467,18 @@ static bool Middleman_RecordingLength(JS
   return true;
 }
 
 static bool Middleman_UpdateRecording(JSContext* aCx, unsigned aArgc,
                                       Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   size_t forkId;
-  parent::ChildProcessInfo* child = ToChildProcess(aCx, args.get(0),
-                                                   args.get(1), &forkId);
+  parent::ChildProcessInfo* child =
+      ToChildProcess(aCx, args.get(0), args.get(1), &forkId);
   if (!child) {
     return false;
   }
 
   if (!args.get(2).isNumber() || !args.get(3).isNumber()) {
     JS_ReportErrorASCII(aCx, "Expected numeric argument");
     return false;
   }
@@ -1082,18 +1082,17 @@ struct ScriptHitInfo {
     }
 
     static bool match(const ScriptHitKey& aFirst, const ScriptHitKey& aSecond) {
       return aFirst.mScript == aSecond.mScript &&
              aFirst.mOffset == aSecond.mOffset;
     }
   };
 
-  typedef HashMap<ScriptHitKey, ScriptHitVector*, ScriptHitKey>
-      ScriptHitMap;
+  typedef HashMap<ScriptHitKey, ScriptHitVector*, ScriptHitKey> ScriptHitMap;
 
   struct AnyScriptHit {
     uint32_t mScript;
     uint32_t mFrameIndex;
     ProgressCounter mProgress;
 
     AnyScriptHit(uint32_t aScript, uint32_t aFrameIndex,
                  ProgressCounter aProgress)
@@ -1115,17 +1114,17 @@ struct ScriptHitInfo {
     }
     if (!mInfo[aCheckpoint]) {
       mInfo[aCheckpoint] = new CheckpointInfo();
     }
     return mInfo[aCheckpoint];
   }
 
   ScriptHitVector* FindHits(uint32_t aCheckpoint, uint32_t aScript,
-                           uint32_t aOffset) {
+                            uint32_t aOffset) {
     CheckpointInfo* info = GetInfo(aCheckpoint);
 
     ScriptHitKey key(aScript, aOffset);
     ScriptHitMap::Ptr p = info->mTable.lookup(key);
     return p ? p->value() : nullptr;
   }
 
   void AddHit(uint32_t aCheckpoint, uint32_t aScript, uint32_t aOffset,
@@ -1344,18 +1343,18 @@ static bool RecordReplay_FindScriptHits(
   RootedValueVector values(aCx);
 
   ScriptHitInfo::ScriptHitVector* hits =
       gScriptHits ? gScriptHits->FindHits(checkpoint, script, offset) : nullptr;
   if (hits) {
     for (const auto& hit : *hits) {
       RootedObject hitObject(aCx, JS_NewObject(aCx, nullptr));
       if (!hitObject ||
-          !JS_DefineProperty(aCx, hitObject, "progress",
-                             (double)hit.mProgress, JSPROP_ENUMERATE) ||
+          !JS_DefineProperty(aCx, hitObject, "progress", (double)hit.mProgress,
+                             JSPROP_ENUMERATE) ||
           !JS_DefineProperty(aCx, hitObject, "frameIndex", hit.mFrameIndex,
                              JSPROP_ENUMERATE) ||
           !values.append(ObjectValue(*hitObject))) {
         return false;
       }
     }
   }
 
--- a/toolkit/recordreplay/ipc/ParentIPC.cpp
+++ b/toolkit/recordreplay/ipc/ParentIPC.cpp
@@ -193,17 +193,18 @@ static StaticInfallibleVector<Channel*> 
 
 class SendMessageToCloudRunnable : public Runnable {
  public:
   int32_t mConnectionId;
   Message::UniquePtr mMsg;
 
   SendMessageToCloudRunnable(int32_t aConnectionId, Message::UniquePtr aMsg)
       : Runnable("SendMessageToCloudRunnable"),
-        mConnectionId(aConnectionId), mMsg(std::move(aMsg)) {}
+        mConnectionId(aConnectionId),
+        mMsg(std::move(aMsg)) {}
 
   NS_IMETHODIMP Run() {
     AutoSafeJSContext cx;
     JSAutoRealm ar(cx, xpc::PrivilegedJunkScope());
 
     JS::RootedObject data(cx, JS::NewArrayBuffer(cx, mMsg->mSize));
     MOZ_RELEASE_ASSERT(data);
 
@@ -251,17 +252,17 @@ static bool ConnectionCallback(JSContext
     uint32_t length;
     uint8_t* ptr;
     bool isSharedMemory;
     JS::GetArrayBufferLengthAndData(&args.get(1).toObject(), &length,
                                     &isSharedMemory, &ptr);
 
     if (ptr) {
       Channel* channel = gConnectionChannels[id];
-      channel->SendMessageData((const char*) ptr, length);
+      channel->SendMessageData((const char*)ptr, length);
       sentData = true;
     }
   }
   if (!sentData) {
     JS_ReportErrorASCII(aCx, "Expected array buffer");
     return false;
   }
 
@@ -269,26 +270,26 @@ static bool ConnectionCallback(JSContext
   return true;
 }
 
 void CreateReplayingCloudProcess(base::ProcessId aProcessId,
                                  uint32_t aChannelId) {
   MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
 
   if (!gConnection) {
-    nsCOMPtr<rrIConnection> connection =
-        do_ImportModule("resource://devtools/server/actors/replay/connection.js");
+    nsCOMPtr<rrIConnection> connection = do_ImportModule(
+        "resource://devtools/server/actors/replay/connection.js");
     gConnection = connection.forget();
     ClearOnShutdown(&gConnection);
 
     AutoSafeJSContext cx;
     JSAutoRealm ar(cx, xpc::PrivilegedJunkScope());
 
-    JSFunction* fun = JS_NewFunction(cx, ConnectionCallback, 2, 0,
-                                     "ConnectionCallback");
+    JSFunction* fun =
+        JS_NewFunction(cx, ConnectionCallback, 2, 0, "ConnectionCallback");
     MOZ_RELEASE_ASSERT(fun);
     JS::RootedValue callback(cx, JS::ObjectValue(*(JSObject*)fun));
     if (NS_FAILED(gConnection->Initialize(callback))) {
       MOZ_CRASH("CreateReplayingCloudProcess");
     }
   }
 
   AutoSafeJSContext cx;
@@ -302,19 +303,20 @@ void CreateReplayingCloudProcess(base::P
   if (NS_FAILED(gConnection->Connect(aChannelId, cloudServer, &connectionId))) {
     MOZ_CRASH("CreateReplayingCloudProcess");
   }
 
   Channel* channel = new Channel(
       aChannelId, Channel::Kind::ParentCloud,
       [=](Message::UniquePtr aMsg) {
         RefPtr<SendMessageToCloudRunnable> runnable =
-          new SendMessageToCloudRunnable(connectionId, std::move(aMsg));
+            new SendMessageToCloudRunnable(connectionId, std::move(aMsg));
         NS_DispatchToMainThread(runnable);
-      }, aProcessId);
+      },
+      aProcessId);
   while ((size_t)connectionId >= gConnectionChannels.length()) {
     gConnectionChannels.append(nullptr);
   }
   gConnectionChannels[connectionId] = channel;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Initialization
--- a/toolkit/xre/glxtest.cpp
+++ b/toolkit/xre/glxtest.cpp
@@ -32,18 +32,18 @@
 #endif
 
 #include "X11/Xlib.h"
 #include "X11/Xutil.h"
 
 #include "mozilla/Unused.h"
 
 #ifdef MOZ_WAYLAND
-#include "nsAppRunner.h"  // for IsWaylandDisabled
-#include "mozilla/widget/mozwayland.h"
+#  include "nsAppRunner.h"  // for IsWaylandDisabled
+#  include "mozilla/widget/mozwayland.h"
 #endif
 
 // stuff from glx.h
 typedef struct __GLXcontextRec* GLXContext;
 typedef XID GLXPixmap;
 typedef XID GLXDrawable;
 /* GLX 1.3 and later */
 typedef struct __GLXFBConfigRec* GLXFBConfig;
@@ -547,17 +547,18 @@ bool fire_glxtest_process() {
   }
   // The child exits early to avoid running the full shutdown sequence and avoid
   // conflicting with threads we have already spawned (like the profiler).
   if (pid == 0) {
     close(pfd[0]);
     write_end_of_the_pipe = pfd[1];
     close_logging();
     // TODO: --display command line argument is not properly handled
-    // NOTE: prefers X for now because eglQueryRendererIntegerMESA does not exist yet
+    // NOTE: prefers X for now because eglQueryRendererIntegerMESA does not
+    // exist yet
 #ifdef MOZ_WAYLAND
     if (IsWaylandDisabled() || getenv("DISPLAY") || !wayland_egltest())
 #endif
       glxtest();
     close(pfd[1]);
     _exit(0);
   }
 
--- a/widget/gtk/nsLookAndFeel.cpp
+++ b/widget/gtk/nsLookAndFeel.cpp
@@ -943,18 +943,17 @@ static nsCString GetGtkTheme() {
 
 void nsLookAndFeel::ConfigureContentGtkTheme() {
   GtkSettings* settings = gtk_settings_get_for_screen(gdk_screen_get_default());
 
   nsAutoCString themeOverride;
   mozilla::Preferences::GetCString("widget.content.gtk-theme-override",
                                    themeOverride);
   if (!themeOverride.IsEmpty()) {
-      g_object_set(settings, "gtk-theme-name", themeOverride.get(),
-                   nullptr);
+    g_object_set(settings, "gtk-theme-name", themeOverride.get(), nullptr);
     LOG(("ConfigureContentGtkTheme(%s)\n", themeOverride.get()));
   } else {
     LOG(("ConfigureContentGtkTheme(%s)\n", GetGtkTheme().get()));
   }
 
   // Dark theme is active but user explicitly enables it, or we're on
   // high-contrast (in which case we prevent content to mess up with the colors
   // of the page), so we're done now.
--- a/widget/windows/nsWindowBase.cpp
+++ b/widget/windows/nsWindowBase.cpp
@@ -216,18 +216,17 @@ nsresult nsWindowBase::ClearNativeTouchS
   AutoObserverNotifier notifier(aObserver, "cleartouch");
   if (!sTouchInjectInitialized) {
     return NS_OK;
   }
 
   // cancel all input points
   for (auto iter = mActivePointers.Iter(); !iter.Done(); iter.Next()) {
     auto info = iter.UserData();
-    InjectTouchPoint(info->mPointerId, info->mPosition,
-                     POINTER_FLAG_CANCELED);
+    InjectTouchPoint(info->mPointerId, info->mPosition, POINTER_FLAG_CANCELED);
     iter.Remove();
   }
 
   nsBaseWidget::ClearNativeTouchSequence(nullptr);
 
   return NS_OK;
 }
 
--- a/xpcom/base/CycleCollectedJSContext.cpp
+++ b/xpcom/base/CycleCollectedJSContext.cpp
@@ -74,18 +74,17 @@ CycleCollectedJSContext::CycleCollectedJ
 
 CycleCollectedJSContext::~CycleCollectedJSContext() {
   MOZ_COUNT_DTOR(CycleCollectedJSContext);
   // If the allocation failed, here we are.
   if (!mJSContext) {
     return;
   }
 
-  JS::SetHostCleanupFinalizationGroupCallback(
-      mJSContext, nullptr, nullptr);
+  JS::SetHostCleanupFinalizationGroupCallback(mJSContext, nullptr, nullptr);
   mFinalizationGroupsToCleanUp.reset();
 
   JS_SetContextPrivate(mJSContext, nullptr);
 
   mRuntime->SetContext(nullptr);
   mRuntime->Shutdown(mJSContext);
 
   // Last chance to process any events.
@@ -740,17 +739,18 @@ nsresult CycleCollectedJSContext::Notify
     mCx->mPendingUnhandledRejections.Remove(JS::GetPromiseID(promiseObj));
   }
   return NS_OK;
 }
 
 class CleanupFinalizationGroupsRunnable : public CancelableRunnable {
  public:
   explicit CleanupFinalizationGroupsRunnable(CycleCollectedJSContext* aContext)
-      : CancelableRunnable("CleanupFinalizationGroupsRunnable"), mContext(aContext) {}
+      : CancelableRunnable("CleanupFinalizationGroupsRunnable"),
+        mContext(aContext) {}
   NS_DECL_NSIRUNNABLE
  private:
   CycleCollectedJSContext* mContext;
 };
 
 NS_IMETHODIMP
 CleanupFinalizationGroupsRunnable::Run() {
   if (mContext->mFinalizationGroupsToCleanUp.empty()) {
--- a/xpcom/base/CycleCollectedJSContext.h
+++ b/xpcom/base/CycleCollectedJSContext.h
@@ -80,19 +80,17 @@ class MicroTaskRunnable {
   NS_INLINE_DECL_REFCOUNTING(MicroTaskRunnable)
   MOZ_CAN_RUN_SCRIPT virtual void Run(AutoSlowOperation& aAso) = 0;
   virtual bool Suppressed() { return false; }
 
  protected:
   virtual ~MicroTaskRunnable() = default;
 };
 
-class CycleCollectedJSContext
-    : dom::PerThreadAtomCache,
-      private JS::JobQueue {
+class CycleCollectedJSContext : dom::PerThreadAtomCache, private JS::JobQueue {
   friend class CycleCollectedJSRuntime;
 
  protected:
   CycleCollectedJSContext();
   virtual ~CycleCollectedJSContext();
 
   MOZ_IS_CLASS_INIT
   nsresult Initialize(JSRuntime* aParentRuntime, uint32_t aMaxBytes);
--- a/xpcom/base/Logging.cpp
+++ b/xpcom/base/Logging.cpp
@@ -635,17 +635,17 @@ void LogModule::Init(int argc, char* arg
 
 void LogModule::Printv(LogLevel aLevel, const char* aFmt, va_list aArgs) const {
   MOZ_ASSERT(sLogModuleManager != nullptr);
 
   // Forward to LogModule manager w/ level and name
   sLogModuleManager->Print(Name(), aLevel, aFmt, aArgs);
 }
 
-void LogModule::Printv(LogLevel aLevel, const TimeStamp* aStart, const char* aFmt,
-                       va_list aArgs) const {
+void LogModule::Printv(LogLevel aLevel, const TimeStamp* aStart,
+                       const char* aFmt, va_list aArgs) const {
   MOZ_ASSERT(sLogModuleManager != nullptr);
 
   // Forward to LogModule manager w/ level and name
   sLogModuleManager->Print(Name(), aLevel, aStart, aFmt, aArgs);
 }
 
 }  // namespace mozilla