Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Mon, 04 Feb 2019 19:10:18 +0000
changeset 457194 3924aed041cf7cb12c445e8c76618726f552f706
parent 457193 1c5bac504475e77c3c23b4df82a268fcd9e0a5aa
child 457195 baee8b94d34e3139d1cc22eae0c6da42053d0769
push id111711
push usercsabou@mozilla.com
push dateTue, 05 Feb 2019 23:12:20 +0000
treeherdermozilla-inbound@48b467365ea8 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1519636
milestone67.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D18488
accessible/atk/nsMaiInterfaceText.cpp
browser/components/shell/nsToolkitShellService.h
browser/components/shell/nsWindowsShellService.cpp
docshell/base/BrowsingContext.cpp
docshell/base/BrowsingContextGroup.cpp
docshell/base/CanonicalBrowsingContext.cpp
docshell/base/CanonicalBrowsingContext.h
dom/base/ChromeUtils.cpp
dom/base/StructuredCloneBlob.cpp
dom/base/StructuredCloneBlob.h
dom/base/TimeoutManager.cpp
dom/base/nsJSUtils.h
dom/events/EventStateManager.cpp
dom/ipc/ContentParent.cpp
dom/ipc/FilePickerParent.cpp
dom/ipc/TabParent.h
dom/script/ScriptLoadRequest.h
dom/script/ScriptLoader.cpp
dom/smil/SMILMilestone.h
gfx/2d/DrawTargetD2D1.h
gfx/2d/DrawTargetOffset.h
gfx/2d/FilterNodeSoftware.h
gfx/layers/ipc/fuzztest/compositor_manager_parent_ipc_libfuzz.cpp
gfx/layers/wr/WebRenderCommandBuilder.cpp
gfx/vr/gfxVRExternal.cpp
gfx/vr/gfxVRMutex.h
gfx/vr/service/VRService.cpp
ipc/chromium/src/base/rand_util.cc
ipc/glue/InputStreamUtils.cpp
js/public/ContextOptions.h
js/src/builtin/TestingFunctions.cpp
js/src/frontend/LexicalScopeEmitter.h
js/src/gc/GC.cpp
js/src/gc/GCRuntime.h
js/src/gc/RootMarking.cpp
js/src/gc/StoreBuffer.cpp
js/src/gc/StoreBuffer.h
js/src/gc/Verifier.cpp
js/src/gc/Zone.h
js/src/jit/CodeGenerator.cpp
js/src/jit/JitSpewer.h
js/src/jit/MacroAssembler.cpp
js/src/jit/arm/Assembler-arm.cpp
js/src/jit/arm64/CodeGenerator-arm64.cpp
js/src/jit/arm64/LIR-arm64.h
js/src/jit/arm64/MacroAssembler-arm64.cpp
js/src/jit/x86-shared/MacroAssembler-x86-shared.cpp
js/src/jsapi-tests/testScriptSourceCompression.cpp
js/src/jsapi.h
js/src/vm/BigIntType.cpp
js/src/vm/HelperThreads.cpp
js/src/vm/TypedArrayObject.cpp
js/src/wasm/AsmJS.h
js/src/wasm/WasmAST.h
js/src/wasm/WasmBaselineCompile.h
js/src/wasm/WasmCompile.cpp
js/src/wasm/WasmCompile.h
js/src/wasm/WasmCraneliftCompile.cpp
js/src/wasm/WasmIonCompile.cpp
js/src/wasm/WasmIonCompile.h
js/src/wasm/WasmJS.cpp
js/src/wasm/WasmOpIter.h
js/src/wasm/WasmStubs.cpp
js/src/wasm/WasmTextToBinary.cpp
js/src/wasm/WasmValidate.cpp
layout/forms/nsHTMLButtonControlFrame.cpp
layout/generic/nsTextFrame.h
layout/painting/nsDisplayList.cpp
layout/style/nsFontFaceLoader.cpp
media/mtransport/dtlsidentity.cpp
media/mtransport/dtlsidentity.h
media/mtransport/transportlayerdtls.cpp
media/webrtc/signaling/gtest/mediapipeline_unittest.cpp
media/webrtc/signaling/src/peerconnection/MediaTransportHandler.cpp
media/webrtc/signaling/src/peerconnection/MediaTransportHandler.h
media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
mfbt/ThreadLocal.h
netwerk/build/nsNetModule.cpp
netwerk/build/nsNetModule.h
netwerk/cache/nsCacheService.cpp
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/protocol/http/nsAHttpTransaction.h
netwerk/protocol/http/nsHttpResponseHead.h
netwerk/url-classifier/UrlClassifierFeatureFlash.cpp
netwerk/url-classifier/UrlClassifierFeaturePhishingProtection.h
security/certverifier/NSSCertDBTrustDomain.h
toolkit/components/build/nsToolkitCompsModule.h
toolkit/components/sessionstore/SessionStoreUtils.cpp
toolkit/recordreplay/MiddlemanCall.cpp
toolkit/recordreplay/MiddlemanCall.h
toolkit/recordreplay/ipc/ChildProcess.cpp
toolkit/xre/nsAppRunner.cpp
toolkit/xre/nsCommandLineServiceMac.mm
toolkit/xre/nsUpdateDriver.cpp
widget/cocoa/nsChildView.h
widget/gtk/gtk3drawing.cpp
widget/gtk/nsWindow.cpp
widget/nsBaseWidget.cpp
xpcom/base/MemoryTelemetry.cpp
xpcom/base/nsTraceRefcnt.cpp
xpcom/build/XPCOMInit.cpp
xpcom/components/nsComponentManager.cpp
xpcom/components/nsComponentManager.h
xpcom/threads/BlockingResourceBase.cpp
--- a/accessible/atk/nsMaiInterfaceText.cpp
+++ b/accessible/atk/nsMaiInterfaceText.cpp
@@ -586,19 +586,18 @@ static gboolean setCaretOffsetCB(AtkText
   if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aText))) {
     proxy->SetCaretOffset(aOffset);
     return TRUE;
   }
 
   return FALSE;
 }
 
-static gboolean scrollSubstringToCB(AtkText* aText,
-                                    gint aStartOffset, gint aEndOffset,
-                                    AtkScrollType aType) {
+static gboolean scrollSubstringToCB(AtkText* aText, gint aStartOffset,
+                                    gint aEndOffset, AtkScrollType aType) {
   AtkObject* atkObject = ATK_OBJECT(aText);
   AccessibleWrap* accWrap = GetAccessibleWrap(atkObject);
   if (accWrap) {
     HyperTextAccessible* text = accWrap->AsHyperText();
     if (!text || !text->IsTextRole() ||
         !text->IsValidRange(aStartOffset, aEndOffset)) {
       return FALSE;
     }
@@ -610,19 +609,18 @@ static gboolean scrollSubstringToCB(AtkT
   if (proxy) {
     proxy->ScrollSubstringTo(aStartOffset, aEndOffset, aType);
     return TRUE;
   }
 
   return FALSE;
 }
 
-static gboolean scrollSubstringToPointCB(AtkText* aText,
-                                         gint aStartOffset, gint aEndOffset,
-                                         AtkCoordType aCoords,
+static gboolean scrollSubstringToPointCB(AtkText* aText, gint aStartOffset,
+                                         gint aEndOffset, AtkCoordType aCoords,
                                          gint aX, gint aY) {
   AtkObject* atkObject = ATK_OBJECT(aText);
   AccessibleWrap* accWrap = GetAccessibleWrap(atkObject);
   if (accWrap) {
     HyperTextAccessible* text = accWrap->AsHyperText();
     if (!text || !text->IsTextRole() ||
         !text->IsValidRange(aStartOffset, aEndOffset)) {
       return FALSE;
--- a/browser/components/shell/nsToolkitShellService.h
+++ b/browser/components/shell/nsToolkitShellService.h
@@ -5,18 +5,17 @@
 
 #ifndef nstoolkitshellservice_h____
 #define nstoolkitshellservice_h____
 
 #include "nsIToolkitShellService.h"
 
 class nsToolkitShellService : public nsIToolkitShellService {
  public:
-  NS_IMETHOD IsDefaultBrowser(bool aForAllTypes,
-                              bool* aIsDefaultBrowser) = 0;
+  NS_IMETHOD IsDefaultBrowser(bool aForAllTypes, bool* aIsDefaultBrowser) = 0;
 
   NS_IMETHODIMP IsDefaultApplication(bool* aIsDefaultBrowser) {
     // Only care about the http(s) protocol. This only matters on Windows.
     return IsDefaultBrowser(false, aIsDefaultBrowser);
   }
 };
 
 #endif  // nstoolkitshellservice_h____
--- a/browser/components/shell/nsWindowsShellService.cpp
+++ b/browser/components/shell/nsWindowsShellService.cpp
@@ -61,17 +61,18 @@
 #define REG_FAILED(val) (val != ERROR_SUCCESS)
 
 #define APP_REG_NAME_BASE L"Firefox-"
 
 using mozilla::IsWin8OrLater;
 using namespace mozilla;
 using namespace mozilla::widget;
 
-NS_IMPL_ISUPPORTS(nsWindowsShellService, nsIToolkitShellService, nsIShellService)
+NS_IMPL_ISUPPORTS(nsWindowsShellService, nsIToolkitShellService,
+                  nsIShellService)
 
 static nsresult OpenKeyForReading(HKEY aKeyRoot, const nsAString& aKeyName,
                                   HKEY* aKey) {
   const nsString& flatName = PromiseFlatString(aKeyName);
 
   DWORD res = ::RegOpenKeyExW(aKeyRoot, flatName.get(), 0, KEY_READ, aKey);
   switch (res) {
     case ERROR_SUCCESS:
--- a/docshell/base/BrowsingContext.cpp
+++ b/docshell/base/BrowsingContext.cpp
@@ -112,17 +112,17 @@ BrowsingContext* BrowsingContext::TopLev
 
   MOZ_LOG(GetLog(), LogLevel::Debug,
           ("Creating 0x%08" PRIx64 " in %s", id,
            XRE_IsParentProcess() ? "Parent" : "Child"));
 
   RefPtr<BrowsingContext> context;
   if (XRE_IsParentProcess()) {
     context = new CanonicalBrowsingContext(aParent, aOpener, aName, id,
-                                          /* aProcessId */ 0, aType);
+                                           /* aProcessId */ 0, aType);
   } else {
     context = new BrowsingContext(aParent, aOpener, aName, id, aType);
   }
 
   Register(context);
 
   // Attach the browsing context to the tree.
   context->Attach();
--- a/docshell/base/BrowsingContextGroup.cpp
+++ b/docshell/base/BrowsingContextGroup.cpp
@@ -6,17 +6,18 @@
 
 #include "mozilla/dom/BrowsingContextGroup.h"
 #include "mozilla/dom/BrowsingContextBinding.h"
 #include "mozilla/dom/BindingUtils.h"
 
 namespace mozilla {
 namespace dom {
 
-StaticAutoPtr<nsTArray<RefPtr<BrowsingContextGroup>>> BrowsingContextGroup::sAllGroups;
+StaticAutoPtr<nsTArray<RefPtr<BrowsingContextGroup>>>
+    BrowsingContextGroup::sAllGroups;
 
 /* static */ void BrowsingContextGroup::Init() {
   if (!sAllGroups) {
     sAllGroups = new nsTArray<RefPtr<BrowsingContextGroup>>();
     ClearOnShutdown(&sAllGroups);
   }
 }
 
--- a/docshell/base/CanonicalBrowsingContext.cpp
+++ b/docshell/base/CanonicalBrowsingContext.cpp
@@ -13,21 +13,21 @@ namespace mozilla {
 namespace dom {
 
 extern mozilla::LazyLogModule gUserInteractionPRLog;
 
 #define USER_ACTIVATION_LOG(msg, ...) \
   MOZ_LOG(gUserInteractionPRLog, LogLevel::Debug, (msg, ##__VA_ARGS__))
 
 CanonicalBrowsingContext::CanonicalBrowsingContext(BrowsingContext* aParent,
-                                                 BrowsingContext* aOpener,
-                                                 const nsAString& aName,
-                                                 uint64_t aBrowsingContextId,
-                                                 uint64_t aProcessId,
-                                                 BrowsingContext::Type aType)
+                                                   BrowsingContext* aOpener,
+                                                   const nsAString& aName,
+                                                   uint64_t aBrowsingContextId,
+                                                   uint64_t aProcessId,
+                                                   BrowsingContext::Type aType)
     : BrowsingContext(aParent, aOpener, aName, aBrowsingContextId, aType),
       mProcessId(aProcessId) {
   // You are only ever allowed to create CanonicalBrowsingContexts in the
   // parent process.
   MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
 }
 
 // TODO(farre): CanonicalBrowsingContext::CleanupContexts starts from the
@@ -124,17 +124,18 @@ void CanonicalBrowsingContext::NotifySet
                       " would notify other browsing contexts for updating "
                       "user gesture activation flag.",
                       Id());
   // XXX(alwu) : we need to sync the flag to other browsing contexts which are
   // not in the same child process where the flag was set. Will implement that
   // in bug1519229.
 }
 
-void CanonicalBrowsingContext::Traverse(nsCycleCollectionTraversalCallback& cb) {
+void CanonicalBrowsingContext::Traverse(
+    nsCycleCollectionTraversalCallback& cb) {
   CanonicalBrowsingContext* tmp = this;
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindowGlobals);
 }
 
 void CanonicalBrowsingContext::Unlink() {
   CanonicalBrowsingContext* tmp = this;
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindowGlobals);
 }
--- a/docshell/base/CanonicalBrowsingContext.h
+++ b/docshell/base/CanonicalBrowsingContext.h
@@ -59,18 +59,18 @@ class CanonicalBrowsingContext final : p
   void NotifySetUserGestureActivationFromIPC(bool aIsUserGestureActivation);
 
  protected:
   void Traverse(nsCycleCollectionTraversalCallback& cb);
   void Unlink();
 
   using Type = BrowsingContext::Type;
   CanonicalBrowsingContext(BrowsingContext* aParent, BrowsingContext* aOpener,
-                          const nsAString& aName, uint64_t aBrowsingContextId,
-                          uint64_t aProcessId, Type aType = Type::Chrome);
+                           const nsAString& aName, uint64_t aBrowsingContextId,
+                           uint64_t aProcessId, Type aType = Type::Chrome);
 
  private:
   friend class BrowsingContext;
 
   // XXX(farre): Store a ContentParent pointer here rather than mProcessId?
   // Indicates which process owns the docshell.
   uint64_t mProcessId;
 
--- a/dom/base/ChromeUtils.cpp
+++ b/dom/base/ChromeUtils.cpp
@@ -400,17 +400,18 @@ NS_IMPL_ISUPPORTS_INHERITED(IdleDispatch
                                         registryLocation);
 
   JSContext* cx = aGlobal.Context();
 
   bool ignoreExports = aTargetObj.WasPassed() && !aTargetObj.Value();
 
   JS::RootedObject global(cx);
   JS::RootedObject exports(cx);
-  nsresult rv = moduleloader->Import(cx, registryLocation, &global, &exports, ignoreExports);
+  nsresult rv = moduleloader->Import(cx, registryLocation, &global, &exports,
+                                     ignoreExports);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
     return;
   }
 
   // Import() on the component loader can return NS_OK while leaving an
   // exception on the JSContext.  Check for that case.
   if (JS_IsExceptionPending(cx)) {
--- a/dom/base/StructuredCloneBlob.cpp
+++ b/dom/base/StructuredCloneBlob.cpp
@@ -14,18 +14,17 @@
 #include "mozilla/Maybe.h"
 #include "mozilla/UniquePtr.h"
 #include "xpcpublic.h"
 
 namespace mozilla {
 namespace dom {
 
 StructuredCloneBlob::StructuredCloneBlob() {
-  mHolder.emplace(Holder::CloningSupported,
-                  Holder::TransferringNotSupported,
+  mHolder.emplace(Holder::CloningSupported, Holder::TransferringNotSupported,
                   Holder::StructuredCloneScope::DifferentProcess);
 }
 
 StructuredCloneBlob::~StructuredCloneBlob() {
   UnregisterWeakMemoryReporter(this);
 }
 
 /* static */ already_AddRefed<StructuredCloneBlob>
@@ -172,19 +171,19 @@ bool StructuredCloneBlob::WriteStructure
                                                JSStructuredCloneWriter* aWriter,
                                                StructuredCloneHolder* aHolder) {
   if (mHolder.isNothing()) {
     return false;
   }
   return mHolder->WriteStructuredClone(aCx, aWriter, aHolder);
 }
 
-bool StructuredCloneBlob::Holder::WriteStructuredClone(JSContext* aCx,
-                                                       JSStructuredCloneWriter* aWriter,
-                                                       StructuredCloneHolder* aHolder) {
+bool StructuredCloneBlob::Holder::WriteStructuredClone(
+    JSContext* aCx, JSStructuredCloneWriter* aWriter,
+    StructuredCloneHolder* aHolder) {
   auto& data = mBuffer->data();
   if (!JS_WriteUint32Pair(aWriter, SCTAG_DOM_STRUCTURED_CLONE_HOLDER, 0) ||
       !JS_WriteUint32Pair(aWriter, data.Size(), JS_STRUCTURED_CLONE_VERSION) ||
       !JS_WriteUint32Pair(aWriter, aHolder->BlobImpls().Length(),
                           BlobImpls().Length())) {
     return false;
   }
 
@@ -205,18 +204,17 @@ NS_IMETHODIMP
 StructuredCloneBlob::CollectReports(nsIHandleReportCallback* aHandleReport,
                                     nsISupports* aData, bool aAnonymize) {
   size_t size = MallocSizeOf(this);
   if (mHolder.isSome()) {
     size += mHolder->SizeOfExcludingThis(MallocSizeOf);
   }
 
   MOZ_COLLECT_REPORT("explicit/dom/structured-clone-holder", KIND_HEAP,
-                     UNITS_BYTES,
-                     size,
+                     UNITS_BYTES, size,
                      "Memory used by StructuredCloneHolder DOM objects.");
 
   return NS_OK;
 }
 
 NS_IMPL_ISUPPORTS(StructuredCloneBlob, nsIMemoryReporter)
 
 }  // namespace dom
--- a/dom/base/StructuredCloneBlob.h
+++ b/dom/base/StructuredCloneBlob.h
@@ -49,17 +49,17 @@ class StructuredCloneBlob final : public
 
  protected:
   virtual ~StructuredCloneBlob();
 
  private:
   explicit StructuredCloneBlob();
 
   class Holder : public StructuredCloneHolder {
-  public:
+   public:
     using StructuredCloneHolder::StructuredCloneHolder;
 
     bool ReadStructuredCloneInternal(JSContext* aCx,
                                      JSStructuredCloneReader* aReader,
                                      StructuredCloneHolder* aHolder);
 
     bool WriteStructuredClone(JSContext* aCx, JSStructuredCloneWriter* aWriter,
                               StructuredCloneHolder* aHolder);
--- a/dom/base/TimeoutManager.cpp
+++ b/dom/base/TimeoutManager.cpp
@@ -922,17 +922,17 @@ void TimeoutManager::RunTimeout(const Ti
           TimeDuration delta = now - timeout->When();
           TimeDuration runtime = TimeStamp::Now() - now;
           nsPrintfCString marker(
               "%sset%s() for %dms (original target time was %dms (%dms "
               "delta)); runtime = %dms",
               aProcessIdle ? "Deferred " : "",
               timeout->mIsInterval ? "Interval" : "Timeout",
               int(elapsed.ToMilliseconds()), int(target.ToMilliseconds()),
-              int(delta.ToMilliseconds()),  int(runtime.ToMilliseconds()));
+              int(delta.ToMilliseconds()), int(runtime.ToMilliseconds()));
           // don't have end before start...
           profiler_add_marker(
               "setTimeout", js::ProfilingStackFrame::Category::DOM,
               MakeUnique<TextMarkerPayload>(
                   marker, delta.ToMilliseconds() >= 0 ? timeout->When() : now,
                   now));
         }
 #endif
--- a/dom/base/nsJSUtils.h
+++ b/dom/base/nsJSUtils.h
@@ -191,18 +191,17 @@ class nsJSUtils {
     //
     // The value returned in the mutable handle argument is part of the
     // compartment given as argument to the ExecutionContext constructor. If the
     // caller is in a different compartment, then the out-param value should be
     // wrapped by calling |JS_WrapValue|.
     MOZ_MUST_USE nsresult ExecScript(JS::MutableHandle<JS::Value> aRetValue);
   };
 
-  static bool BinASTEncodingEnabled()
-  {
+  static bool BinASTEncodingEnabled() {
 #ifdef JS_BUILD_BINAST
     return mozilla::StaticPrefs::dom_script_loader_binast_encoding_enabled();
 #else
     return false;
 #endif
   }
 
   static nsresult CompileModule(JSContext* aCx,
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -3824,17 +3824,16 @@ nsresult EventStateManager::SetCursor(St
       c = eCursor_none;
       break;
   }
 
   // First, try the imgIContainer, if non-null
   uint32_t hotspotX = 0;
   uint32_t hotspotY = 0;
   if (aContainer) {
-
     // css3-ui says to use the CSS-specified hotspot if present,
     // otherwise use the intrinsic hotspot, otherwise use the top left
     // corner.
     if (aHaveHotspot) {
       int32_t imgWidth, imgHeight;
       aContainer->GetWidth(&imgWidth);
       aContainer->GetHeight(&imgHeight);
 
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -5759,17 +5759,18 @@ void ContentParent::UnregisterRemoveWork
     MessageLoop::current()->PostTask(NewRunnableMethod<ShutDownMethod>(
         "dom::ContentParent::ShutDownProcess", this,
         &ContentParent::ShutDownProcess, SEND_SHUTDOWN_MESSAGE));
   }
 }
 
 mozilla::ipc::IPCResult ContentParent::RecvWindowClose(
     const BrowsingContextId& aContextId, const bool& aTrustedCaller) {
-  RefPtr<CanonicalBrowsingContext> bc = CanonicalBrowsingContext::Get(aContextId);
+  RefPtr<CanonicalBrowsingContext> bc =
+      CanonicalBrowsingContext::Get(aContextId);
   if (!bc) {
     MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
             ("ParentIPC: Trying to send a message to dead or detached context "
              "0x%08" PRIx64,
              (uint64_t)aContextId));
     return IPC_OK();
   }
 
@@ -5781,17 +5782,18 @@ mozilla::ipc::IPCResult ContentParent::R
   ContentParent* cp =
       cpm->GetContentProcessById(ContentParentId(bc->OwnerProcessId()));
   Unused << cp->SendWindowClose(aContextId, aTrustedCaller);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult ContentParent::RecvWindowFocus(
     const BrowsingContextId& aContextId) {
-  RefPtr<CanonicalBrowsingContext> bc = CanonicalBrowsingContext::Get(aContextId);
+  RefPtr<CanonicalBrowsingContext> bc =
+      CanonicalBrowsingContext::Get(aContextId);
   if (!bc) {
     MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
             ("ParentIPC: Trying to send a message to dead or detached context "
              "0x%08" PRIx64,
              (uint64_t)aContextId));
     return IPC_OK();
   }
 
@@ -5799,17 +5801,18 @@ mozilla::ipc::IPCResult ContentParent::R
   ContentParent* cp =
       cpm->GetContentProcessById(ContentParentId(bc->OwnerProcessId()));
   Unused << cp->SendWindowFocus(aContextId);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult ContentParent::RecvWindowBlur(
     const BrowsingContextId& aContextId) {
-  RefPtr<CanonicalBrowsingContext> bc = CanonicalBrowsingContext::Get(aContextId);
+  RefPtr<CanonicalBrowsingContext> bc =
+      CanonicalBrowsingContext::Get(aContextId);
   if (!bc) {
     MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
             ("ParentIPC: Trying to send a message to dead or detached context "
              "0x%08" PRIx64,
              (uint64_t)aContextId));
     return IPC_OK();
   }
 
@@ -5818,17 +5821,18 @@ mozilla::ipc::IPCResult ContentParent::R
       cpm->GetContentProcessById(ContentParentId(bc->OwnerProcessId()));
   Unused << cp->SendWindowBlur(aContextId);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult ContentParent::RecvWindowPostMessage(
     const BrowsingContextId& aContextId, const ClonedMessageData& aMessage,
     const PostMessageData& aData) {
-  RefPtr<CanonicalBrowsingContext> bc = CanonicalBrowsingContext::Get(aContextId);
+  RefPtr<CanonicalBrowsingContext> bc =
+      CanonicalBrowsingContext::Get(aContextId);
   if (!bc) {
     MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
             ("ParentIPC: Trying to send a message to dead or detached context "
              "0x%08" PRIx64,
              (uint64_t)aContextId));
     return IPC_OK();
   }
 
--- a/dom/ipc/FilePickerParent.cpp
+++ b/dom/ipc/FilePickerParent.cpp
@@ -236,19 +236,18 @@ bool FilePickerParent::CreateFilePicker(
   return NS_SUCCEEDED(mFilePicker->Init(window, mTitle, mMode));
 }
 
 mozilla::ipc::IPCResult FilePickerParent::RecvOpen(
     const int16_t& aSelectedType, const bool& aAddToRecentDocs,
     const nsString& aDefaultFile, const nsString& aDefaultExtension,
     InfallibleTArray<nsString>&& aFilters,
     InfallibleTArray<nsString>&& aFilterNames,
-    InfallibleTArray<nsString>&& aRawFilters,
-    const nsString& aDisplayDirectory, const nsString& aDisplaySpecialDirectory,
-    const nsString& aOkButtonLabel) {
+    InfallibleTArray<nsString>&& aRawFilters, const nsString& aDisplayDirectory,
+    const nsString& aDisplaySpecialDirectory, const nsString& aOkButtonLabel) {
   if (!CreateFilePicker()) {
     Unused << Send__delete__(this, void_t(), nsIFilePicker::returnCancel);
     return IPC_OK();
   }
 
   mFilePicker->SetAddToRecentDocs(aAddToRecentDocs);
 
   for (uint32_t i = 0; i < aFilters.Length(); ++i) {
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -254,25 +254,22 @@ class TabParent final : public PBrowserP
   virtual mozilla::ipc::IPCResult RecvLookUpDictionary(
       const nsString& aText, nsTArray<mozilla::FontRange>&& aFontRangeArray,
       const bool& aIsVertical, const LayoutDeviceIntPoint& aPoint) override;
 
   virtual mozilla::ipc::IPCResult RecvEnableDisableCommands(
       const nsString& aAction, nsTArray<nsCString>&& aEnabledCommands,
       nsTArray<nsCString>&& aDisabledCommands) override;
 
-  virtual mozilla::ipc::IPCResult RecvSetCursor(const nsCursor& aValue,
-                                                const bool& aHasCustomCursor,
-                                                const nsCString& aUri,
-                                                const uint32_t& aWidth, const uint32_t& aHeight,
-                                                const uint32_t& aStride,
-                                                const gfx::SurfaceFormat& aFormat,
-                                                const uint32_t& aHotspotX,
-                                                const uint32_t& aHotspotY,
-                                                const bool& aForce) override;
+  virtual mozilla::ipc::IPCResult RecvSetCursor(
+      const nsCursor& aValue, const bool& aHasCustomCursor,
+      const nsCString& aUri, const uint32_t& aWidth, const uint32_t& aHeight,
+      const uint32_t& aStride, const gfx::SurfaceFormat& aFormat,
+      const uint32_t& aHotspotX, const uint32_t& aHotspotY,
+      const bool& aForce) override;
 
   virtual mozilla::ipc::IPCResult RecvSetStatus(
       const uint32_t& aType, const nsString& aStatus) override;
 
   virtual mozilla::ipc::IPCResult RecvShowTooltip(
       const uint32_t& aX, const uint32_t& aY, const nsString& aTooltip,
       const nsString& aDirection) override;
 
--- a/dom/script/ScriptLoadRequest.h
+++ b/dom/script/ScriptLoadRequest.h
@@ -250,20 +250,20 @@ class ScriptLoadRequest
   bool mHasSourceMapURL;   // Does the HTTP header have a source map url?
   bool mInDeferList;       // True if we live in mDeferRequests.
   bool mInAsyncList;       // True if we live in mLoadingAsyncRequests or
                            // mLoadedAsyncRequests.
   bool mIsNonAsyncScriptInserted;  // True if we live in
                                    // mNonAsyncExternalScriptInsertedRequests
   bool mIsXSLT;                    // True if we live in mXSLTRequests.
   bool mIsCanceled;                // True if we have been explicitly canceled.
-  bool mWasCompiledOMT;    // True if the script has been compiled off main
-                           // thread.
-  bool mIsTracking;        // True if the script comes from a source on our
-                           // tracking protection list.
+  bool mWasCompiledOMT;  // True if the script has been compiled off main
+                         // thread.
+  bool mIsTracking;      // True if the script comes from a source on our
+                         // tracking protection list.
 
   RefPtr<ScriptFetchOptions> mFetchOptions;
 
   JS::OffThreadToken* mOffThreadToken;  // Off-thread parsing token.
   nsString mSourceMapURL;  // Holds source map url for loaded scripts
 
   // Holds the top-level JSScript that corresponds to the current source, once
   // it is parsed, and planned to be saved in the bytecode cache.
--- a/dom/script/ScriptLoader.cpp
+++ b/dom/script/ScriptLoader.cpp
@@ -1302,17 +1302,18 @@ nsresult ScriptLoader::StartLoad(ScriptL
       }
     }
   }
 
   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
   if (httpChannel) {
     // HTTP content negotation has little value in this context.
     nsAutoCString acceptTypes("*/*");
-    if (nsJSUtils::BinASTEncodingEnabled() && aRequest->ShouldAcceptBinASTEncoding()) {
+    if (nsJSUtils::BinASTEncodingEnabled() &&
+        aRequest->ShouldAcceptBinASTEncoding()) {
       acceptTypes = APPLICATION_JAVASCRIPT_BINAST ", */*";
     }
     rv = httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept"),
                                        acceptTypes, false);
     MOZ_ASSERT(NS_SUCCEEDED(rv));
 
     rv = httpChannel->SetReferrerWithPolicy(aRequest->mReferrer,
                                             aRequest->ReferrerPolicy());
--- a/dom/smil/SMILMilestone.h
+++ b/dom/smil/SMILMilestone.h
@@ -59,17 +59,17 @@ class SMILMilestone {
   bool operator<=(const SMILMilestone& aOther) const {
     return *this == aOther || *this < aOther;
   }
 
   bool operator>=(const SMILMilestone& aOther) const {
     return !(*this < aOther);
   }
 
-  SMILTime mTime;    // The milestone time. This may be in container time or
-                     // parent container time depending on where it is used.
-  bool mIsEnd;       // true if this milestone corresponds to an interval
-                     // end, false otherwise.
+  SMILTime mTime;  // The milestone time. This may be in container time or
+                   // parent container time depending on where it is used.
+  bool mIsEnd;     // true if this milestone corresponds to an interval
+                   // end, false otherwise.
 };
 
 }  // namespace mozilla
 
 #endif  // mozilla_SMILMilestone_h
--- a/gfx/2d/DrawTargetD2D1.h
+++ b/gfx/2d/DrawTargetD2D1.h
@@ -313,21 +313,17 @@ class DrawTargetD2D1 : public DrawTarget
   // This value is uesed to verify if the DrawTarget is created by a stale
   // device.
   uint32_t mDeviceSeq;
 
   // List of effects we use
   bool EnsureLuminanceEffect();
   RefPtr<ID2D1Effect> mLuminanceEffect;
 
-  enum class InitState {
-    Uninitialized,
-    Success,
-    Failure
-  };
+  enum class InitState { Uninitialized, Success, Failure };
   InitState mInitState;
   RefPtr<IDXGISurface> mSurface;
 };
 
 }  // namespace gfx
 }  // namespace mozilla
 
 #endif /* MOZILLA_GFX_DRAWTARGETD2D_H_ */
--- a/gfx/2d/DrawTargetOffset.h
+++ b/gfx/2d/DrawTargetOffset.h
@@ -14,27 +14,33 @@
 #include "Filters.h"
 #include "Logging.h"
 
 #include <vector>
 
 namespace mozilla {
 namespace gfx {
 
-class SourceSurfaceOffset: public SourceSurface {
-  public:
-  SourceSurfaceOffset(RefPtr<SourceSurface> aSurface, IntPoint aOffset) :
-    mSurface(aSurface),
-    mOffset(aOffset) {}
+class SourceSurfaceOffset : public SourceSurface {
+ public:
+  SourceSurfaceOffset(RefPtr<SourceSurface> aSurface, IntPoint aOffset)
+      : mSurface(aSurface), mOffset(aOffset) {}
   virtual SurfaceType GetType() const override { return SurfaceType::OFFSET; }
   virtual IntSize GetSize() const override { return mSurface->GetSize(); }
-  virtual IntRect GetRect() const override { return IntRect(mOffset, mSurface->GetSize()); }
-  virtual SurfaceFormat GetFormat() const override { return mSurface->GetFormat(); }
-  virtual already_AddRefed<DataSourceSurface> GetDataSurface() override { return mSurface->GetDataSurface(); }
-  private:
+  virtual IntRect GetRect() const override {
+    return IntRect(mOffset, mSurface->GetSize());
+  }
+  virtual SurfaceFormat GetFormat() const override {
+    return mSurface->GetFormat();
+  }
+  virtual already_AddRefed<DataSourceSurface> GetDataSurface() override {
+    return mSurface->GetDataSurface();
+  }
+
+ private:
   RefPtr<SourceSurface> mSurface;
   IntPoint mOffset;
 };
 
 class DrawTargetOffset : public DrawTarget {
  public:
   DrawTargetOffset();
 
--- a/gfx/2d/FilterNodeSoftware.h
+++ b/gfx/2d/FilterNodeSoftware.h
@@ -22,17 +22,17 @@ class FilterNodeSoftware;
 /**
  * Can be attached to FilterNodeSoftware instances using
  * AddInvalidationListener. FilterInvalidated is called whenever the output of
  * the observed filter may have changed; that is, whenever cached GetOutput()
  * results (and results derived from them) need to discarded.
  */
 class FilterInvalidationListener {
  public:
-  virtual void FilterInvalidated(FilterNodeSoftware* aFilter) = 0;
+  virtual void FilterInvalidated(FilterNodeSoftware *aFilter) = 0;
 };
 
 /**
  * This is the base class for the software (i.e. pure CPU, non-accelerated)
  * FilterNode implementation. The software implementation is backend-agnostic,
  * so it can be used as a fallback for all DrawTarget implementations.
  */
 class FilterNodeSoftware : public FilterNode,
@@ -41,33 +41,33 @@ class FilterNodeSoftware : public Filter
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeSoftware, override)
   FilterNodeSoftware();
   virtual ~FilterNodeSoftware();
 
   // Factory method, intended to be called from DrawTarget*::CreateFilter.
   static already_AddRefed<FilterNode> Create(FilterType aType);
 
   // Draw the filter, intended to be called by DrawTarget*::DrawFilter.
-  void Draw(DrawTarget* aDrawTarget, const Rect& aSourceRect,
-            const Point& aDestPoint, const DrawOptions& aOptions);
+  void Draw(DrawTarget *aDrawTarget, const Rect &aSourceRect,
+            const Point &aDestPoint, const DrawOptions &aOptions);
 
   virtual FilterBackend GetBackendType() override {
     return FILTER_BACKEND_SOFTWARE;
   }
-  virtual void SetInput(uint32_t aIndex, SourceSurface* aSurface) override;
-  virtual void SetInput(uint32_t aIndex, FilterNode* aFilter) override;
+  virtual void SetInput(uint32_t aIndex, SourceSurface *aSurface) override;
+  virtual void SetInput(uint32_t aIndex, FilterNode *aFilter) override;
 
-  virtual const char* GetName() { return "Unknown"; }
+  virtual const char *GetName() { return "Unknown"; }
 
-  virtual void AddInvalidationListener(FilterInvalidationListener* aListener);
+  virtual void AddInvalidationListener(FilterInvalidationListener *aListener);
   virtual void RemoveInvalidationListener(
-      FilterInvalidationListener* aListener);
+      FilterInvalidationListener *aListener);
 
   // FilterInvalidationListener implementation
-  virtual void FilterInvalidated(FilterNodeSoftware* aFilter) override;
+  virtual void FilterInvalidated(FilterNodeSoftware *aFilter) override;
 
  protected:
   // The following methods are intended to be overriden by subclasses.
 
   /**
    * Translates a *FilterInputs enum value into an index for the
    * mInputFilters / mInputSurfaces arrays. Returns -1 for invalid inputs.
    * If somebody calls SetInput(enumValue, input) with an enumValue for which
@@ -77,42 +77,42 @@ class FilterNodeSoftware : public Filter
 
   /**
    * Every filter node has an output rect, which can also be infinite. The
    * output rect can depend on the values of any set attributes and on the
    * output rects of any input filters or surfaces.
    * This method returns the intersection of the filter's output rect with
    * aInRect. Filters with unconstrained output always return aInRect.
    */
-  virtual IntRect GetOutputRectInRect(const IntRect& aInRect) = 0;
+  virtual IntRect GetOutputRectInRect(const IntRect &aInRect) = 0;
 
   /**
    * Return a surface with the rendered output which is of size aRect.Size().
    * aRect is required to be a subrect of this filter's output rect; in other
    * words, aRect == GetOutputRectInRect(aRect) must always be true.
    * May return nullptr in error conditions or for an empty aRect.
    * Implementations are not required to allocate a new surface and may even
    * pass through input surfaces unchanged.
    * Callers need to treat the returned surface as immutable.
    */
-  virtual already_AddRefed<DataSourceSurface> Render(const IntRect& aRect) = 0;
+  virtual already_AddRefed<DataSourceSurface> Render(const IntRect &aRect) = 0;
 
   /**
    * Call RequestRect (see below) on any input filters with the desired input
    * rect, so that the input filter knows what to cache the next time it
    * renders.
    */
-  virtual void RequestFromInputsForRect(const IntRect& aRect) {}
+  virtual void RequestFromInputsForRect(const IntRect &aRect) {}
 
   /**
    * This method provides a caching default implementation but can be overriden
    * by subclasses that don't want to cache their output. Those classes should
    * call Render(aRect) directly from here.
    */
-  virtual already_AddRefed<DataSourceSurface> GetOutput(const IntRect& aRect);
+  virtual already_AddRefed<DataSourceSurface> GetOutput(const IntRect &aRect);
 
   // The following methods are non-virtual helper methods.
 
   /**
    * Format hints for GetInputDataSourceSurface. Some callers of
    * GetInputDataSourceSurface can handle both B8G8R8A8 and A8 surfaces, these
    * should pass CAN_HANDLE_A8 in order to avoid unnecessary conversions.
    * Callers that can only handle B8G8R8A8 surfaces pass NEED_COLOR_CHANNELS.
@@ -135,20 +135,20 @@ class FilterNodeSoftware : public Filter
    * according to aEdgeMode: The default, EDGE_MODE_NONE, simply pads with
    * transparent black.
    * If non-null, the returned surface is guaranteed to be of SurfaceFormat::A8
    * or SurfaceFormat::B8G8R8A8. If aFormatHint is NEED_COLOR_CHANNELS, the
    * returned surface is guaranteed to be of SurfaceFormat::B8G8R8A8 always.
    * Each pixel row of the returned surface is guaranteed to be 16-byte aligned.
    */
   already_AddRefed<DataSourceSurface> GetInputDataSourceSurface(
-      uint32_t aInputEnumIndex, const IntRect& aRect,
+      uint32_t aInputEnumIndex, const IntRect &aRect,
       FormatHint aFormatHint = CAN_HANDLE_A8,
       ConvolveMatrixEdgeMode aEdgeMode = EDGE_MODE_NONE,
-      const IntRect* aTransparencyPaddedSourceRect = nullptr);
+      const IntRect *aTransparencyPaddedSourceRect = nullptr);
 
   /**
    * Returns the intersection of the input filter's or surface's output rect
    * with aInRect.
    */
   IntRect GetInputRectInRect(uint32_t aInputEnumIndex, const IntRect &aInRect);
 
   /**
@@ -175,41 +175,41 @@ class FilterNodeSoftware : public Filter
    */
   void Invalidate();
 
   /**
    * Called in order to let this filter know what to cache during the next
    * GetOutput call. Expected to call RequestRect on this filter's input
    * filters.
    */
-  void RequestRect(const IntRect& aRect);
+  void RequestRect(const IntRect &aRect);
 
   /**
    * Set input filter and clear input surface for this input index, or set
    * input surface and clear input filter. One of aSurface and aFilter should
    * be null.
    */
-  void SetInput(uint32_t aIndex, SourceSurface* aSurface,
-                FilterNodeSoftware* aFilter);
+  void SetInput(uint32_t aIndex, SourceSurface *aSurface,
+                FilterNodeSoftware *aFilter);
 
  protected:
   /**
    * mInputSurfaces / mInputFilters: For each input index, either a surface or
    * a filter is set, and the other is null.
    */
   std::vector<RefPtr<SourceSurface> > mInputSurfaces;
   std::vector<RefPtr<FilterNodeSoftware> > mInputFilters;
 
   /**
    * Weak pointers to our invalidation listeners, i.e. to those filters who
    * have this filter as an input. Invalidation listeners are required to
    * unsubscribe themselves from us when they let go of their reference to us.
    * This ensures that the pointers in this array are never stale.
    */
-  std::vector<FilterInvalidationListener*> mInvalidationListeners;
+  std::vector<FilterInvalidationListener *> mInvalidationListeners;
 
   /**
    * Lock guarding mRequestedRect, mCachedRect, and mCachedOutput. All uses
    * of those members must aquire this lock.
    */
   Mutex mCacheMutex;
 
   /**
@@ -386,66 +386,66 @@ class FilterNodeComponentTransferSoftwar
   bool mDisableA;
 };
 
 class FilterNodeTableTransferSoftware
     : public FilterNodeComponentTransferSoftware {
  public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTableTransferSoftware,
                                           override)
-  virtual const char* GetName() override { return "TableTransfer"; }
+  virtual const char *GetName() override { return "TableTransfer"; }
   using FilterNodeComponentTransferSoftware::SetAttribute;
-  virtual void SetAttribute(uint32_t aIndex, const Float* aFloat,
+  virtual void SetAttribute(uint32_t aIndex, const Float *aFloat,
                             uint32_t aSize) override;
 
  protected:
   virtual void FillLookupTable(ptrdiff_t aComponent,
                                uint8_t aTable[256]) override;
 
  private:
-  void FillLookupTableImpl(std::vector<Float>& aTableValues,
+  void FillLookupTableImpl(std::vector<Float> &aTableValues,
                            uint8_t aTable[256]);
 
   std::vector<Float> mTableR;
   std::vector<Float> mTableG;
   std::vector<Float> mTableB;
   std::vector<Float> mTableA;
 };
 
 class FilterNodeDiscreteTransferSoftware
     : public FilterNodeComponentTransferSoftware {
  public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeDiscreteTransferSoftware,
                                           override)
-  virtual const char* GetName() override { return "DiscreteTransfer"; }
+  virtual const char *GetName() override { return "DiscreteTransfer"; }
   using FilterNodeComponentTransferSoftware::SetAttribute;
-  virtual void SetAttribute(uint32_t aIndex, const Float* aFloat,
+  virtual void SetAttribute(uint32_t aIndex, const Float *aFloat,
                             uint32_t aSize) override;
 
  protected:
   virtual void FillLookupTable(ptrdiff_t aComponent,
                                uint8_t aTable[256]) override;
 
  private:
-  void FillLookupTableImpl(std::vector<Float>& aTableValues,
+  void FillLookupTableImpl(std::vector<Float> &aTableValues,
                            uint8_t aTable[256]);
 
   std::vector<Float> mTableR;
   std::vector<Float> mTableG;
   std::vector<Float> mTableB;
   std::vector<Float> mTableA;
 };
 
 class FilterNodeLinearTransferSoftware
     : public FilterNodeComponentTransferSoftware {
  public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeLinearTransformSoftware,
                                           override)
   FilterNodeLinearTransferSoftware();
-  virtual const char* GetName() override { return "LinearTransfer"; }
+  virtual const char *GetName() override { return "LinearTransfer"; }
   using FilterNodeComponentTransferSoftware::SetAttribute;
   virtual void SetAttribute(uint32_t aIndex, Float aValue) override;
 
  protected:
   virtual void FillLookupTable(ptrdiff_t aComponent,
                                uint8_t aTable[256]) override;
 
  private:
@@ -462,17 +462,17 @@ class FilterNodeLinearTransferSoftware
 };
 
 class FilterNodeGammaTransferSoftware
     : public FilterNodeComponentTransferSoftware {
  public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeGammaTransferSoftware,
                                           override)
   FilterNodeGammaTransferSoftware();
-  virtual const char* GetName() override { return "GammaTransfer"; }
+  virtual const char *GetName() override { return "GammaTransfer"; }
   using FilterNodeComponentTransferSoftware::SetAttribute;
   virtual void SetAttribute(uint32_t aIndex, Float aValue) override;
 
  protected:
   virtual void FillLookupTable(ptrdiff_t aComponent,
                                uint8_t aTable[256]) override;
 
  private:
--- a/gfx/layers/ipc/fuzztest/compositor_manager_parent_ipc_libfuzz.cpp
+++ b/gfx/layers/ipc/fuzztest/compositor_manager_parent_ipc_libfuzz.cpp
@@ -8,32 +8,29 @@
 
 #include "FuzzingInterface.h"
 #include "ProtocolFuzzer.h"
 
 #include "mozilla/layers/CompositorBridgeParent.h"
 #include "mozilla/layers/CompositorManagerParent.h"
 #include "mozilla/layers/LayerTreeOwnerTracker.h"
 
-int
-FuzzingInitCompositorManagerParentIPC(int* argc, char*** argv)
-{
+int FuzzingInitCompositorManagerParentIPC(int* argc, char*** argv) {
   mozilla::ipc::ProtocolFuzzerHelper::CompositorBridgeParentSetup();
   mozilla::layers::LayerTreeOwnerTracker::Initialize();
   return 0;
 }
 
-static int
-RunCompositorManagerParentIPCFuzzing(const uint8_t* data, size_t size)
-{
+static int RunCompositorManagerParentIPCFuzzing(const uint8_t* data,
+                                                size_t size) {
   static mozilla::layers::CompositorManagerParent* p =
-    mozilla::layers::CompositorManagerParent::CreateSameProcess().take();
+      mozilla::layers::CompositorManagerParent::CreateSameProcess().take();
 
   static nsTArray<nsCString> ignored = mozilla::ipc::LoadIPCMessageBlacklist(
-    getenv("MOZ_IPC_MESSAGE_FUZZ_BLACKLIST"));
+      getenv("MOZ_IPC_MESSAGE_FUZZ_BLACKLIST"));
 
   mozilla::ipc::FuzzProtocol(p, data, size, ignored);
 
   return 0;
 }
 
 MOZ_FUZZING_INTERFACE_RAW(FuzzingInitCompositorManagerParentIPC,
                           RunCompositorManagerParentIPCFuzzing,
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -515,17 +515,17 @@ struct DIGroup {
           GP("TransformChange: %s %d %d %d %d\n", aItem->Name(), aData->mRect.x,
              aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
         } else if (IsContainerLayerItem(aItem)) {
           UniquePtr<nsDisplayItemGeometry> geometry(
               aItem->AllocateGeometry(aBuilder));
           // we need to catch bounds changes of containers so that we continue
           // to have the correct bounds rects in the recording
           if (DetectContainerLayerPropertiesBoundsChange(aItem, aData,
-                                                            *geometry)) {
+                                                         *geometry)) {
             nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
                 geometry->ComputeInvalidationRegion());
             aData->mGeometry = std::move(geometry);
             IntRect transformedRect =
                 ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel,
                               mLayerBounds.TopLeft());
             InvalidateRect(aData->mRect.Intersect(mImageBounds));
             aData->mRect = transformedRect.Intersect(mClippedImageBounds);
--- a/gfx/vr/gfxVRExternal.cpp
+++ b/gfx/vr/gfxVRExternal.cpp
@@ -422,20 +422,22 @@ bool VRDisplayExternal::PullState() {
                             mDisplayInfo.mControllerState);
 }
 #endif
 
 VRSystemManagerExternal::VRSystemManagerExternal(
     VRExternalShmem* aAPIShmem /* = nullptr*/)
     : mExternalShmem(aAPIShmem)
 #if !defined(MOZ_WIDGET_ANDROID)
-#if defined(XP_WIN)
-    , mMutex(NULL)
-#endif  // defined(XP_WIN)
-    , mSameProcess(aAPIShmem != nullptr)
+#  if defined(XP_WIN)
+      ,
+      mMutex(NULL)
+#  endif  // defined(XP_WIN)
+      ,
+      mSameProcess(aAPIShmem != nullptr)
 #endif  // !defined(MOZ_WIDGET_ANDROID)
 {
 #if defined(XP_MACOSX)
   mShmemFD = 0;
 #elif defined(XP_WIN)
   mShmemFile = NULL;
 #elif defined(MOZ_WIDGET_ANDROID)
   mExternalStructFailed = false;
@@ -827,20 +829,20 @@ bool VRSystemManagerExternal::PullState(
 bool VRSystemManagerExternal::PullState(
     VRDisplayState* aDisplayState,
     VRHMDSensorState* aSensorState /* = nullptr */,
     VRControllerState* aControllerState /* = nullptr */) {
   bool success = false;
   bool status = true;
   MOZ_ASSERT(mExternalShmem);
 
-#if defined(XP_WIN)
+#  if defined(XP_WIN)
   WaitForMutex lock(mMutex);
   status = lock.GetStatus();
-#endif  // defined(XP_WIN)
+#  endif  // defined(XP_WIN)
 
   if (mExternalShmem && status) {
     VRExternalShmem tmp;
     memcpy(&tmp, (void*)mExternalShmem, sizeof(VRExternalShmem));
     if (tmp.generationA == tmp.generationB && tmp.generationA != 0 &&
         tmp.generationA != -1 && tmp.state.enumerationCompleted) {
       memcpy(aDisplayState, &tmp.state.displayState, sizeof(VRDisplayState));
       if (aSensorState) {
@@ -861,17 +863,17 @@ bool VRSystemManagerExternal::PullState(
         }
       }
       success = true;
     }
   }
 
   return success;
 }
-#endif  // defined(MOZ_WIDGET_ANDROID)
+#endif    // defined(MOZ_WIDGET_ANDROID)
 
 void VRSystemManagerExternal::PushState(VRBrowserState* aBrowserState,
                                         bool aNotifyCond) {
   MOZ_ASSERT(aBrowserState);
   MOZ_ASSERT(mExternalShmem);
   if (mExternalShmem) {
 #if defined(MOZ_WIDGET_ANDROID)
     if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->geckoMutex)) ==
@@ -880,24 +882,25 @@ void VRSystemManagerExternal::PushState(
              sizeof(VRBrowserState));
       if (aNotifyCond) {
         pthread_cond_signal((pthread_cond_t*)&(mExternalShmem->geckoCond));
       }
       pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->geckoMutex));
     }
 #else
     bool status = true;
-#if defined(XP_WIN)
+#  if defined(XP_WIN)
     WaitForMutex lock(mMutex);
     status = lock.GetStatus();
-#endif  // defined(XP_WIN)
+#  endif  // defined(XP_WIN)
     if (status) {
       mExternalShmem->geckoGenerationA++;
       memcpy((void*)&(mExternalShmem->geckoState), (void*)aBrowserState,
-            sizeof(VRBrowserState));
-      mExternalShmem->geckoGenerationB++; mExternalShmem->geckoGenerationA++;
+             sizeof(VRBrowserState));
+      mExternalShmem->geckoGenerationB++;
+      mExternalShmem->geckoGenerationA++;
       memcpy((void*)&(mExternalShmem->geckoState), (void*)aBrowserState,
-            sizeof(VRBrowserState));
+             sizeof(VRBrowserState));
       mExternalShmem->geckoGenerationB++;
     }
-#endif  // defined(MOZ_WIDGET_ANDROID)
+#endif    // defined(MOZ_WIDGET_ANDROID)
   }
 }
--- a/gfx/vr/gfxVRMutex.h
+++ b/gfx/vr/gfxVRMutex.h
@@ -47,21 +47,19 @@ public:
       nsAutoCString msg;
       msg.AppendPrintf("WaitForMutex %d ReleaseMutex error \"%lu\".",
                         mHandle, GetLastError());
       NS_WARNING(msg.get());
       MOZ_ASSERT(false, "Failed to release mutex.");
     }
   }
 
-  bool GetStatus() {
-    return mStatus;
-  }
+  bool GetStatus() { return mStatus; }
 
-private:
+ private:
   HANDLE mHandle;
   bool mStatus;
 };
 #endif
 
 }  // namespace gfx
 }  // namespace mozilla
 
--- a/gfx/vr/service/VRService.cpp
+++ b/gfx/vr/service/VRService.cpp
@@ -467,17 +467,17 @@ void VRService::PushState(const mozilla:
     state = lock.GetStatus();
   }
 #endif  // defined(XP_WIN)
   if (state) {
     mAPIShmem->generationA++;
     memcpy((void*)&mAPIShmem->state, &aState, sizeof(VRSystemState));
     mAPIShmem->generationB++;
   }
-#endif // defined(MOZ_WIDGET_ANDROID)
+#endif    // defined(MOZ_WIDGET_ANDROID)
 }
 
 void VRService::PullState(mozilla::gfx::VRBrowserState& aState) {
   if (!mAPIShmem) {
     return;
   }
   // Copying the browser state from the shmem is non-blocking
   // on x86/x64 architectures.  Arm requires a mutex that is
@@ -508,12 +508,12 @@ void VRService::PullState(mozilla::gfx::
       memcpy(&tmp, mAPIShmem, sizeof(VRExternalShmem));
       if (tmp.geckoGenerationA == tmp.geckoGenerationB &&
           tmp.geckoGenerationA != 0 && tmp.geckoGenerationA != -1) {
         memcpy(&aState, &tmp.geckoState, sizeof(VRBrowserState));
         mBrowserGeneration = tmp.geckoGenerationA;
       }
     }
   }
-#endif  // defined(MOZ_WIDGET_ANDROID)
+#endif    // defined(MOZ_WIDGET_ANDROID)
 }
 
 VRExternalShmem* VRService::GetAPIShmem() { return mAPIShmem; }
--- a/ipc/chromium/src/base/rand_util.cc
+++ b/ipc/chromium/src/base/rand_util.cc
@@ -9,17 +9,16 @@
 #include <math.h>
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "mozilla/RandomNum.h"
 
-
 namespace base {
 
 int RandInt(int min, int max) {
   DCHECK(min <= max);
 
   uint64_t range = static_cast<int64_t>(max) - min + 1;
   mozilla::Maybe<uint64_t> number = mozilla::RandomUint64();
   MOZ_RELEASE_ASSERT(number.isSome());
--- a/ipc/glue/InputStreamUtils.cpp
+++ b/ipc/glue/InputStreamUtils.cpp
@@ -142,34 +142,36 @@ void InputStreamHelper::SerializeInputSt
 void InputStreamHelper::SerializeInputStream(
     nsIInputStream* aInputStream, InputStreamParams& aParams,
     nsTArray<FileDescriptor>& aFileDescriptors, bool aDelayedStart,
     PBackgroundParent* aManager) {
   SerializeInputStreamInternal(aInputStream, aParams, aFileDescriptors,
                                aDelayedStart, aManager);
 }
 
-void InputStreamHelper::SerializeInputStreamAsPipe(
-    nsIInputStream* aInputStream, InputStreamParams& aParams,
-    bool aDelayedStart, nsIContentChild* aManager) {
+void InputStreamHelper::SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
+                                                   InputStreamParams& aParams,
+                                                   bool aDelayedStart,
+                                                   nsIContentChild* aManager) {
   SerializeInputStreamAsPipeInternal(aInputStream, aParams, aDelayedStart,
                                      aManager);
 }
 
 void InputStreamHelper::SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
                                                    InputStreamParams& aParams,
                                                    bool aDelayedStart,
                                                    PBackgroundChild* aManager) {
   SerializeInputStreamAsPipeInternal(aInputStream, aParams, aDelayedStart,
                                      aManager);
 }
 
-void InputStreamHelper::SerializeInputStreamAsPipe(
-    nsIInputStream* aInputStream, InputStreamParams& aParams,
-    bool aDelayedStart, nsIContentParent* aManager) {
+void InputStreamHelper::SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
+                                                   InputStreamParams& aParams,
+                                                   bool aDelayedStart,
+                                                   nsIContentParent* aManager) {
   SerializeInputStreamAsPipeInternal(aInputStream, aParams, aDelayedStart,
                                      aManager);
 }
 
 void InputStreamHelper::SerializeInputStreamAsPipe(
     nsIInputStream* aInputStream, InputStreamParams& aParams,
     bool aDelayedStart, PBackgroundParent* aManager) {
   SerializeInputStreamAsPipeInternal(aInputStream, aParams, aDelayedStart,
--- a/js/public/ContextOptions.h
+++ b/js/public/ContextOptions.h
@@ -241,11 +241,11 @@ class JS_PUBLIC_API ContextOptions {
   bool extraWarnings_ : 1;
 #ifdef FUZZING
   bool fuzzing_ : 1;
 #endif
 };
 
 JS_PUBLIC_API ContextOptions& ContextOptionsRef(JSContext* cx);
 
-} // namespace JS
+}  // namespace JS
 
-#endif // js_ContextOptions_h
+#endif  // js_ContextOptions_h
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -693,17 +693,18 @@ static bool WasmGcEnabled(JSContext* cx,
 #else
   args.rval().setBoolean(false);
 #endif
   return true;
 }
 
 static bool WasmDebugSupport(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
-  args.rval().setBoolean(cx->options().wasmBaseline() && wasm::BaselineCanCompile());
+  args.rval().setBoolean(cx->options().wasmBaseline() &&
+                         wasm::BaselineCanCompile());
   return true;
 }
 
 static bool WasmGeneralizedTables(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 #ifdef ENABLE_WASM_GENERALIZED_TABLES
   // Generalized tables depend on anyref, though not currently on (ref T)
   // types nor on structures or other GC-proposal features.
--- a/js/src/frontend/LexicalScopeEmitter.h
+++ b/js/src/frontend/LexicalScopeEmitter.h
@@ -76,19 +76,17 @@ class MOZ_STACK_CLASS LexicalScopeEmitte
   };
   State state_ = State::Start;
 #endif
 
  public:
   explicit LexicalScopeEmitter(BytecodeEmitter* bce);
 
   // Returns the scope object for non-empty scope.
-  const EmitterScope& emitterScope() const {
-    return *emitterScope_;
-  }
+  const EmitterScope& emitterScope() const { return *emitterScope_; }
 
   MOZ_MUST_USE bool emitScope(ScopeKind kind,
                               JS::Handle<LexicalScope::Data*> bindings);
   MOZ_MUST_USE bool emitEmptyScope();
 
   MOZ_MUST_USE bool emitEnd();
 };
 
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -7378,17 +7378,17 @@ MOZ_NEVER_INLINE GCRuntime::IncrementalR
   auto result = budgetIncrementalGC(nonincrementalByAPI, reason, budget);
   if (result == IncrementalResult::ResetIncremental) {
     reason = JS::GCReason::RESET;
   }
 
   if (shouldCollectNurseryForSlice(nonincrementalByAPI, budget)) {
     minorGC(reason, gcstats::PhaseKind::EVICT_NURSERY_FOR_MAJOR_GC);
   } else {
-    ++number; // This otherwise happens in minorGC().
+    ++number;  // This otherwise happens in minorGC().
   }
 
   AutoGCSession session(rt, JS::HeapState::MajorCollecting);
 
   majorGCTriggerReason = JS::GCReason::NO_REASON;
 
   {
     gcstats::AutoPhase ap(stats(), gcstats::PhaseKind::WAIT_BACKGROUND_THREAD);
--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -400,19 +400,17 @@ class GCRuntime {
 
   uint64_t minorGCCount() const { return minorGCNumber; }
   void incMinorGcNumber() {
     ++minorGCNumber;
     ++number;
   }
 
   uint64_t majorGCCount() const { return majorGCNumber; }
-  void incMajorGcNumber() {
-    ++majorGCNumber;
-  }
+  void incMajorGcNumber() { ++majorGCNumber; }
 
   int64_t defaultSliceBudget() const { return defaultTimeBudget_; }
 
   bool isIncrementalGc() const { return isIncremental; }
   bool isFullGc() const { return isFull; }
   bool isCompactingGc() const { return isCompacting; }
 
   bool areGrayBitsValid() const { return grayBitsValid; }
--- a/js/src/gc/RootMarking.cpp
+++ b/js/src/gc/RootMarking.cpp
@@ -560,18 +560,18 @@ void GCRuntime::markBufferedGrayRoots(JS
   for (auto iter = roots.Iter(); !iter.Done(); iter.Next()) {
     Cell* cell = iter.Get();
 
     // Bug 1203273: Check for bad pointers on OSX and output diagnostics.
 #if defined(XP_DARWIN) && defined(MOZ_DIAGNOSTIC_ASSERT_ENABLED)
     auto addr = uintptr_t(cell);
     if (addr < ChunkSize || addr % CellAlignBytes != 0) {
       MOZ_CRASH_UNSAFE_PRINTF(
-          "Bad GC thing pointer in gray root buffer: %p at address %p",
-          cell, &iter.Get());
+          "Bad GC thing pointer in gray root buffer: %p at address %p", cell,
+          &iter.Get());
     }
 #else
     MOZ_ASSERT(IsCellPointerValid(cell));
 #endif
 
     TraceManuallyBarrieredGenericPointerEdge(&marker, &cell,
                                              "buffered gray root");
   }
--- a/js/src/gc/StoreBuffer.cpp
+++ b/js/src/gc/StoreBuffer.cpp
@@ -50,34 +50,33 @@ void StoreBuffer::GenericBuffer::trace(J
   for (LifoAlloc::Enum e(*storage_); !e.empty();) {
     unsigned size = *e.read<unsigned>();
     BufferableRef* edge = e.read<BufferableRef>(size);
     edge->trace(trc);
   }
 }
 
 StoreBuffer::StoreBuffer(JSRuntime* rt, const Nursery& nursery)
- : bufferVal(this),
-   bufferCell(this),
-   bufferSlot(this),
-   bufferWholeCell(this),
-   bufferGeneric(this),
-   cancelIonCompilations_(false),
-   runtime_(rt),
-   nursery_(nursery),
-   aboutToOverflow_(false),
-   enabled_(false)
+    : bufferVal(this),
+      bufferCell(this),
+      bufferSlot(this),
+      bufferWholeCell(this),
+      bufferGeneric(this),
+      cancelIonCompilations_(false),
+      runtime_(rt),
+      nursery_(nursery),
+      aboutToOverflow_(false),
+      enabled_(false)
 #ifdef DEBUG
- ,
-   mEntered(false)
+      ,
+      mEntered(false)
 #endif
 {
 }
 
-
 void StoreBuffer::checkEmpty() const {
   MOZ_ASSERT(bufferVal.isEmpty());
   MOZ_ASSERT(bufferCell.isEmpty());
   MOZ_ASSERT(bufferSlot.isEmpty());
   MOZ_ASSERT(bufferWholeCell.isEmpty());
   MOZ_ASSERT(bufferGeneric.isEmpty());
 }
 
--- a/js/src/gc/StoreBuffer.h
+++ b/js/src/gc/StoreBuffer.h
@@ -78,19 +78,17 @@ class StoreBuffer {
      */
     T last_;
 
     StoreBuffer* owner_;
 
     /* Maximum number of entries before we request a minor GC. */
     const static size_t MaxEntries = 48 * 1024 / sizeof(T);
 
-    explicit MonoTypeBuffer(StoreBuffer* owner)
-     : last_(T()), owner_(owner)
-    {}
+    explicit MonoTypeBuffer(StoreBuffer* owner) : last_(T()), owner_(owner) {}
 
     void clear() {
       last_ = T();
       stores_.clear();
     }
 
     /* Add one item to the buffer. */
     void put(const T& t) {
@@ -138,18 +136,17 @@ class StoreBuffer {
   };
 
   struct WholeCellBuffer {
     UniquePtr<LifoAlloc> storage_;
     ArenaCellSet* head_;
     StoreBuffer* owner_;
 
     explicit WholeCellBuffer(StoreBuffer* owner)
-     : storage_(nullptr), head_(nullptr), owner_(owner)
-    {}
+        : storage_(nullptr), head_(nullptr), owner_(owner) {}
 
     MOZ_MUST_USE bool init();
 
     void clear();
 
     bool isAboutToOverflow() const {
       return !storage_->isEmpty() &&
              storage_->used() > WholeCellBufferOverflowThresholdBytes;
@@ -174,17 +171,18 @@ class StoreBuffer {
     WholeCellBuffer(const WholeCellBuffer& other) = delete;
     WholeCellBuffer& operator=(const WholeCellBuffer& other) = delete;
   };
 
   struct GenericBuffer {
     UniquePtr<LifoAlloc> storage_;
     StoreBuffer* owner_;
 
-    explicit GenericBuffer(StoreBuffer* owner) : storage_(nullptr), owner_(owner) {}
+    explicit GenericBuffer(StoreBuffer* owner)
+        : storage_(nullptr), owner_(owner) {}
 
     MOZ_MUST_USE bool init();
 
     void clear() {
       if (storage_) {
         storage_->used() ? storage_->releaseAll() : storage_->freeAll();
       }
     }
--- a/js/src/gc/Verifier.cpp
+++ b/js/src/gc/Verifier.cpp
@@ -777,19 +777,19 @@ bool js::gc::CheckWeakMapEntryMarking(co
 
   Zone* valueZone = GetCellZoneFromAnyThread(value);
   MOZ_ASSERT(valueZone == zone || valueZone->isAtomsZone());
 
   CellColor mapColor =
       map->markColor == MarkColor::Black ? CellColor::Black : CellColor::Gray;
   if (object && GetCellColor(object) != mapColor) {
     fprintf(stderr, "WeakMap object is marked differently to the map\n");
-    fprintf(stderr, "(map %p is %s, object %p is %s)\n",
-            map, CellColorName(mapColor),
-            object, CellColorName(GetCellColor(object)));
+    fprintf(stderr, "(map %p is %s, object %p is %s)\n", map,
+            CellColorName(mapColor), object,
+            CellColorName(GetCellColor(object)));
     ok = false;
   }
 
   CellColor keyColor = GetCellColor(key);
   CellColor valueColor =
       valueZone->isGCMarking() ? GetCellColor(value) : CellColor::Black;
 
   if (valueColor < Min(mapColor, keyColor)) {
--- a/js/src/gc/Zone.h
+++ b/js/src/gc/Zone.h
@@ -371,19 +371,19 @@ class Zone : public JS::shadow::Zone,
  private:
   // The set of compartments in this zone.
   js::MainThreadOrGCTaskData<CompartmentVector> compartments_;
 
  public:
   CompartmentVector& compartments() { return compartments_.ref(); }
 
   // This zone's gray roots.
-  using GrayRootVector = mozilla::SegmentedVector<js::gc::Cell*,
-                                                  1024 * sizeof(js::gc::Cell*),
-                                                  js::SystemAllocPolicy>;
+  using GrayRootVector =
+      mozilla::SegmentedVector<js::gc::Cell*, 1024 * sizeof(js::gc::Cell*),
+                               js::SystemAllocPolicy>;
 
  private:
   js::ZoneOrGCTaskData<GrayRootVector> gcGrayRoots_;
 
  public:
   GrayRootVector& gcGrayRoots() { return gcGrayRoots_.ref(); }
 
   // This zone's weak edges found via graph traversal during marking,
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -11671,19 +11671,19 @@ class OutOfLineSwitch : public OutOfLine
 };
 
 template <SwitchTableType tableType>
 void CodeGenerator::visitOutOfLineSwitch(
     OutOfLineSwitch<tableType>* jumpTable) {
   jumpTable->setOutOfLine();
   auto& labels = jumpTable->labels();
 #if defined(JS_CODEGEN_ARM64)
-  AutoForbidPools afp(&masm, (labels.length() + 1) * (sizeof(void*) / vixl::kInstructionSize));
-#endif
-
+  AutoForbidPools afp(
+      &masm, (labels.length() + 1) * (sizeof(void*) / vixl::kInstructionSize));
+#endif
 
   if (tableType == SwitchTableType::OutOfLine) {
 #if defined(JS_CODEGEN_ARM)
     MOZ_CRASH("NYI: SwitchTableType::OutOfLine");
 #elif defined(JS_CODEGEN_NONE)
     MOZ_CRASH();
 #else
     masm.haltingAlign(sizeof(void*));
--- a/js/src/jit/JitSpewer.h
+++ b/js/src/jit/JitSpewer.h
@@ -200,17 +200,18 @@ class GraphSpewer {
   void spewPass(const char* pass) {}
   void spewPass(const char* pass, BacktrackingAllocator* ra) {}
   void endFunction() {}
 
   void dump(Fprinter& c1, Fprinter& json) {}
 };
 
 static inline void SpewBeginFunction(MIRGenerator* mir, JSScript* function) {}
-static inline void SpewBeginWasmFunction(MIRGenerator* mir, unsigned funcIndex) {}
+static inline void SpewBeginWasmFunction(MIRGenerator* mir,
+                                         unsigned funcIndex) {}
 
 class AutoSpewEndFunction {
  public:
   explicit AutoSpewEndFunction(MIRGenerator* mir) {}
   ~AutoSpewEndFunction() {}
 };
 
 static inline void CheckLogging() {}
--- a/js/src/jit/MacroAssembler.cpp
+++ b/js/src/jit/MacroAssembler.cpp
@@ -96,26 +96,23 @@ void MacroAssembler::guardTypeSet(const 
   //
   // spectreRegToZero is a register that will be zeroed by guardObjectType on
   // speculatively executed paths.
 
   MOZ_ASSERT(kind == BarrierKind::TypeTagOnly || kind == BarrierKind::TypeSet);
   MOZ_ASSERT(!types->unknown());
 
   Label matched;
-  TypeSet::Type tests[] = {TypeSet::Int32Type(),
-                           TypeSet::UndefinedType(),
-                           TypeSet::BooleanType(),
-                           TypeSet::StringType(),
+  TypeSet::Type tests[] = {TypeSet::Int32Type(),    TypeSet::UndefinedType(),
+                           TypeSet::BooleanType(),  TypeSet::StringType(),
                            TypeSet::SymbolType(),
 #ifdef ENABLE_BIGINT
                            TypeSet::BigIntType(),
 #endif
-                           TypeSet::NullType(),
-                           TypeSet::MagicArgType(),
+                           TypeSet::NullType(),     TypeSet::MagicArgType(),
                            TypeSet::AnyObjectType()};
 
   // The double type also implies Int32.
   // So replace the int32 test with the double one.
   if (types->hasType(TypeSet::DoubleType())) {
     MOZ_ASSERT(types->hasType(TypeSet::Int32Type()));
     tests[0] = TypeSet::DoubleType();
   }
--- a/js/src/jit/arm/Assembler-arm.cpp
+++ b/js/src/jit/arm/Assembler-arm.cpp
@@ -1110,18 +1110,19 @@ VFPRegister VFPRegister::singleOverlay(u
     MOZ_ASSERT(code_ < 16);
     MOZ_ASSERT(which < 2);
     return VFPRegister((code_ << 1) + which, Single);
   }
   MOZ_ASSERT(which == 0);
   return VFPRegister(code_, Single);
 }
 
-static_assert(FloatRegisters::TotalDouble <= 16,
-              "We assume that every Double register also has an Integer personality");
+static_assert(
+    FloatRegisters::TotalDouble <= 16,
+    "We assume that every Double register also has an Integer personality");
 
 VFPRegister VFPRegister::sintOverlay(unsigned int which) const {
   MOZ_ASSERT(!_isInvalid);
   if (kind == Double) {
     // There are no corresponding float registers for d16-d31.
     MOZ_ASSERT(code_ < 16);
     MOZ_ASSERT(which < 2);
     return VFPRegister((code_ << 1) + which, Int);
--- a/js/src/jit/arm64/CodeGenerator-arm64.cpp
+++ b/js/src/jit/arm64/CodeGenerator-arm64.cpp
@@ -807,17 +807,18 @@ class js::jit::OutOfLineTableSwitch
   MTableSwitch* mir() const { return mir_; }
 
   CodeLabel* jumpLabel() { return &jumpLabel_; }
 };
 
 void CodeGeneratorARM64::visitOutOfLineTableSwitch(OutOfLineTableSwitch* ool) {
   MTableSwitch* mir = ool->mir();
 
-  AutoForbidPools afp(&masm, (mir->numCases() + 1) * (sizeof(void*) / vixl::kInstructionSize));
+  AutoForbidPools afp(
+      &masm, (mir->numCases() + 1) * (sizeof(void*) / vixl::kInstructionSize));
   masm.haltingAlign(sizeof(void*));
   masm.bind(ool->jumpLabel());
   masm.addCodeLabel(*ool->jumpLabel());
 
   for (size_t i = 0; i < mir->numCases(); i++) {
     LBlock* caseblock = skipTrivialBlocks(mir->getCase(i))->lir();
     Label* caseheader = caseblock->label();
     uint32_t caseoffset = caseheader->offset();
--- a/js/src/jit/arm64/LIR-arm64.h
+++ b/js/src/jit/arm64/LIR-arm64.h
@@ -204,18 +204,19 @@ class LMulI : public LBinaryMath<0> {
 
   MMul* mir() { return mir_->toMul(); }
 };
 
 class LUDiv : public LBinaryMath<1> {
  public:
   LIR_HEADER(UDiv);
 
-  LUDiv(const LAllocation& lhs, const LAllocation& rhs, const LDefinition& remainder)
-    : LBinaryMath(classOpcode) {
+  LUDiv(const LAllocation& lhs, const LAllocation& rhs,
+        const LDefinition& remainder)
+      : LBinaryMath(classOpcode) {
     setOperand(0, lhs);
     setOperand(1, rhs);
     setTemp(0, remainder);
   }
 
   const LDefinition* remainder() { return getTemp(0); }
 
   MDiv* mir() { return mir_->toDiv(); }
--- a/js/src/jit/arm64/MacroAssembler-arm64.cpp
+++ b/js/src/jit/arm64/MacroAssembler-arm64.cpp
@@ -1242,18 +1242,17 @@ void MacroAssembler::oolWasmTruncateChec
                 &isOverflow);
     loadConstantFloat32(-1.0f, fpscratch);
     branchFloat(Assembler::DoubleGreaterThan, input, fpscratch, rejoin);
   } else {
     loadConstantFloat32(two_31, fpscratch);
     branchFloat(Assembler::DoubleGreaterThanOrEqual, input, fpscratch,
                 &isOverflow);
     loadConstantFloat32(-two_31, fpscratch);
-    branchFloat(Assembler::DoubleGreaterThanOrEqual, input, fpscratch,
-                rejoin);
+    branchFloat(Assembler::DoubleGreaterThanOrEqual, input, fpscratch, rejoin);
   }
   bind(&isOverflow);
   wasmTrap(wasm::Trap::IntegerOverflow, off);
 }
 
 void MacroAssembler::oolWasmTruncateCheckF64ToI32(FloatRegister input,
                                                   Register output,
                                                   TruncFlags flags,
@@ -1303,18 +1302,17 @@ void MacroAssembler::oolWasmTruncateChec
                 &isOverflow);
     loadConstantFloat32(-1.0f, fpscratch);
     branchFloat(Assembler::DoubleGreaterThan, input, fpscratch, rejoin);
   } else {
     loadConstantFloat32(two_63, fpscratch);
     branchFloat(Assembler::DoubleGreaterThanOrEqual, input, fpscratch,
                 &isOverflow);
     loadConstantFloat32(-two_63, fpscratch);
-    branchFloat(Assembler::DoubleGreaterThanOrEqual, input, fpscratch,
-                rejoin);
+    branchFloat(Assembler::DoubleGreaterThanOrEqual, input, fpscratch, rejoin);
   }
   bind(&isOverflow);
   wasmTrap(wasm::Trap::IntegerOverflow, off);
 }
 
 void MacroAssembler::oolWasmTruncateCheckF64ToI64(FloatRegister input,
                                                   Register64 output,
                                                   TruncFlags flags,
@@ -1334,18 +1332,17 @@ void MacroAssembler::oolWasmTruncateChec
                  &isOverflow);
     loadConstantDouble(-1.0, fpscratch);
     branchDouble(Assembler::DoubleGreaterThan, input, fpscratch, rejoin);
   } else {
     loadConstantDouble(two_63, fpscratch);
     branchDouble(Assembler::DoubleGreaterThanOrEqual, input, fpscratch,
                  &isOverflow);
     loadConstantDouble(-two_63, fpscratch);
-    branchDouble(Assembler::DoubleGreaterThanOrEqual, input, fpscratch,
-                 rejoin);
+    branchDouble(Assembler::DoubleGreaterThanOrEqual, input, fpscratch, rejoin);
   }
   bind(&isOverflow);
   wasmTrap(wasm::Trap::IntegerOverflow, off);
 }
 
 void MacroAssembler::wasmLoad(const wasm::MemoryAccessDesc& access,
                               Register memoryBase, Register ptr,
                               Register ptrScratch, AnyRegister output) {
--- a/js/src/jit/x86-shared/MacroAssembler-x86-shared.cpp
+++ b/js/src/jit/x86-shared/MacroAssembler-x86-shared.cpp
@@ -866,18 +866,17 @@ void MacroAssembler::oolWasmTruncateChec
   if (isSaturating) {
     if (isUnsigned) {
       // Negative overflow and NaN both are converted to 0, and the only
       // other case is positive overflow which is converted to
       // UINT64_MAX.
       Label positive;
       ScratchDoubleScope fpscratch(*this);
       loadConstantDouble(0.0, fpscratch);
-      branchDouble(Assembler::DoubleGreaterThan, input, fpscratch,
-                   &positive);
+      branchDouble(Assembler::DoubleGreaterThan, input, fpscratch, &positive);
       move64(Imm64(0), output);
       jump(rejoin);
 
       bind(&positive);
       move64(Imm64(UINT64_MAX), output);
     } else {
       // Negative overflow is already saturated to INT64_MIN, so we only
       // have to handle NaN and positive overflow here.
@@ -914,18 +913,17 @@ void MacroAssembler::oolWasmTruncateChec
     return;
   }
 
   // We've used vcvtsd2sq. The only legit value whose i64
   // truncation is INT64_MIN is double(INT64_MIN): exponent is so
   // high that the highest resolution around is much more than 1.
   ScratchDoubleScope fpscratch(*this);
   loadConstantDouble(double(int64_t(INT64_MIN)), fpscratch);
-  branchDouble(Assembler::DoubleNotEqual, input, fpscratch,
-               &traps.intOverflow);
+  branchDouble(Assembler::DoubleNotEqual, input, fpscratch, &traps.intOverflow);
   jump(rejoin);
 }
 
 void MacroAssembler::oolWasmTruncateCheckF32ToI64(FloatRegister input,
                                                   Register64 output,
                                                   TruncFlags flags,
                                                   wasm::BytecodeOffset off,
                                                   Label* rejoin) {
--- a/js/src/jsapi-tests/testScriptSourceCompression.cpp
+++ b/js/src/jsapi-tests/testScriptSourceCompression.cpp
@@ -20,19 +20,19 @@
 #include "js/Conversions.h"               // JS::ToString
 #include "js/MemoryFunctions.h"           // JS_malloc
 #include "js/RootingAPI.h"                // JS::MutableHandle, JS::Rooted
 #include "js/SourceText.h"                // JS::SourceOwnership, JS::SourceText
 #include "js/UniquePtr.h"                 // js::UniquePtr
 #include "js/Utility.h"                   // JS::FreePolicy
 #include "js/Value.h"  // JS::NullValue, JS::ObjectValue, JS::Value
 #include "jsapi-tests/tests.h"
-#include "vm/Compression.h"  // js::Compressor::CHUNK_SIZE
+#include "vm/Compression.h"    // js::Compressor::CHUNK_SIZE
 #include "vm/HelperThreads.h"  // js::RunPendingSourceCompressions
-#include "vm/JSFunction.h"   // JSFunction::getOrCreateScript
+#include "vm/JSFunction.h"     // JSFunction::getOrCreateScript
 #include "vm/JSScript.h"  // JSScript, js::ScriptSource::MinimumCompressibleLength
 
 using mozilla::ArrayLength;
 
 struct JSContext;
 class JSString;
 
 template <typename CharT>
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -1756,17 +1756,18 @@ extern JS_PUBLIC_API bool JS_DeleteEleme
 extern JS_PUBLIC_API bool JS_Enumerate(JSContext* cx, JS::HandleObject obj,
                                        JS::MutableHandle<JS::IdVector> props);
 
 /**
  * Equivalent to `Object.assign(target, src)`: Copies the properties from the
  * `src` object (which must not be null) to `target` (which also must not be
  * null).
  */
-extern JS_PUBLIC_API bool JS_AssignObject(JSContext* cx, JS::HandleObject target,
+extern JS_PUBLIC_API bool JS_AssignObject(JSContext* cx,
+                                          JS::HandleObject target,
                                           JS::HandleObject src);
 
 /*
  * API for determining callability and constructability. [[Call]] and
  * [[Construct]] are internal methods that aren't present on all objects, so it
  * is useful to ask if they are there or not. The standard itself asks these
  * questions routinely.
  */
--- a/js/src/vm/BigIntType.cpp
+++ b/js/src/vm/BigIntType.cpp
@@ -207,20 +207,20 @@ BigInt* BigInt::neg(JSContext* cx, Handl
   if (!result) {
     return nullptr;
   }
   result->lengthSignAndReservedBits_ ^= SignBit;
   return result;
 }
 
 #if !defined(JS_64BIT)
-#define HAVE_TWO_DIGIT 1
+#  define HAVE_TWO_DIGIT 1
 using TwoDigit = uint64_t;
 #elif defined(HAVE_INT128_SUPPORT)
-#define HAVE_TWO_DIGIT 1
+#  define HAVE_TWO_DIGIT 1
 using TwoDigit = __uint128_t;
 #endif
 
 inline BigInt::Digit BigInt::digitMul(Digit a, Digit b, Digit* high) {
 #if defined(HAVE_TWO_DIGIT)
   TwoDigit result = static_cast<TwoDigit>(a) * static_cast<TwoDigit>(b);
   *high = result >> DigitBits;
 
@@ -558,21 +558,20 @@ BigInt* BigInt::absoluteSub(JSContext* c
 //
 // If `quotient` is an empty handle, an appropriately sized BigInt will be
 // allocated for it; otherwise the caller must ensure that it is big enough.
 // `quotient` can be the same as `x` for an in-place division. `quotient` can
 // also be `Nothing()` if the caller is only interested in the remainder.
 //
 // This function returns false if `quotient` is an empty handle, but allocating
 // the quotient failed.  Otherwise it returns true, indicating success.
-bool BigInt::absoluteDivWithDigitDivisor(JSContext* cx, HandleBigInt x,
-                                         Digit divisor,
-                                         const Maybe<MutableHandleBigInt>& quotient,
-                                         Digit* remainder,
-                                         bool quotientNegative) {
+bool BigInt::absoluteDivWithDigitDivisor(
+    JSContext* cx, HandleBigInt x, Digit divisor,
+    const Maybe<MutableHandleBigInt>& quotient, Digit* remainder,
+    bool quotientNegative) {
   MOZ_ASSERT(divisor);
 
   MOZ_ASSERT(!x->isZero());
   *remainder = 0;
   if (divisor == 1) {
     if (quotient) {
       BigInt* q;
       if (x->isNegative() == quotientNegative) {
@@ -729,21 +728,20 @@ BigInt* BigInt::absoluteLeftShiftAlwaysC
 // `remainder`. Mathematically, the contract is:
 //
 //   quotient = (dividend - remainder) / divisor, with 0 <= remainder < divisor.
 //
 // Both `quotient` and `remainder` are optional, for callers that are only
 // interested in one of them.  See Knuth, Volume 2, section 4.3.1, Algorithm D.
 // Also see the overview of the algorithm by Jan Marthedal Rasmussen over at
 // https://janmr.com/blog/2014/04/basic-multiple-precision-long-division/.
-bool BigInt::absoluteDivWithBigIntDivisor(JSContext* cx, HandleBigInt dividend,
-                                          HandleBigInt divisor,
-                                          const Maybe<MutableHandleBigInt>& quotient,
-                                          const Maybe<MutableHandleBigInt>& remainder,
-                                          bool isNegative) {
+bool BigInt::absoluteDivWithBigIntDivisor(
+    JSContext* cx, HandleBigInt dividend, HandleBigInt divisor,
+    const Maybe<MutableHandleBigInt>& quotient,
+    const Maybe<MutableHandleBigInt>& remainder, bool isNegative) {
   MOZ_ASSERT(divisor->digitLength() >= 2);
   MOZ_ASSERT(dividend->digitLength() >= divisor->digitLength());
 
   // Any early error return is detectable by checking the quotient and/or
   // remainder output values.
   MOZ_ASSERT(!quotient || !quotient.value());
   MOZ_ASSERT(!remainder || !remainder.value());
 
@@ -1150,18 +1148,19 @@ JSLinearString* BigInt::toStringBasePowe
     MOZ_ASSERT(pos);
     resultChars[--pos] = '-';
   }
 
   MOZ_ASSERT(pos == 0);
   return NewStringCopyN<allowGC>(cx, resultChars.get(), charsRequired);
 }
 
-template<AllowGC allowGC>
-JSLinearString* BigInt::toStringSingleDigitBaseTen(JSContext* cx, Digit digit, bool isNegative) {
+template <AllowGC allowGC>
+JSLinearString* BigInt::toStringSingleDigitBaseTen(JSContext* cx, Digit digit,
+                                                   bool isNegative) {
   if (digit <= Digit(INT32_MAX)) {
     int32_t val = AssertedCast<int32_t>(digit);
     return Int32ToString<allowGC>(cx, isNegative ? -val : val);
   }
 
   MOZ_ASSERT(digit != 0, "zero case should have been handled in toString");
 
   constexpr size_t maxLength = 1 + (std::numeric_limits<Digit>::digits10 + 1);
@@ -3061,29 +3060,34 @@ JSLinearString* BigInt::toString(JSConte
     return cx->staticStrings().getInt(0);
   }
 
   if (mozilla::IsPowerOfTwo(radix)) {
     return toStringBasePowerOfTwo<allowGC>(cx, x, radix);
   }
 
   if (radix == 10 && x->digitLength() == 1) {
-    return toStringSingleDigitBaseTen<allowGC>(cx, x->digit(0), x->isNegative());
+    return toStringSingleDigitBaseTen<allowGC>(cx, x->digit(0),
+                                               x->isNegative());
   }
 
   // Punt on doing generic toString without GC.
   if (!allowGC) {
     return nullptr;
   }
 
   return toStringGeneric(cx, x, radix);
 }
 
-template JSLinearString* BigInt::toString<js::CanGC>(JSContext* cx, HandleBigInt x, uint8_t radix);
-template JSLinearString* BigInt::toString<js::NoGC>(JSContext* cx, HandleBigInt x, uint8_t radix);
+template JSLinearString* BigInt::toString<js::CanGC>(JSContext* cx,
+                                                     HandleBigInt x,
+                                                     uint8_t radix);
+template JSLinearString* BigInt::toString<js::NoGC>(JSContext* cx,
+                                                    HandleBigInt x,
+                                                    uint8_t radix);
 
 template <typename CharT>
 static inline BigInt* ParseStringBigIntLiteral(JSContext* cx,
                                                Range<const CharT> range,
                                                bool* haveParseError) {
   auto start = range.begin();
   auto end = range.end();
 
--- a/js/src/vm/HelperThreads.cpp
+++ b/js/src/vm/HelperThreads.cpp
@@ -2259,17 +2259,18 @@ void js::CancelOffThreadCompressions(JSR
     HelperThreadState().wait(lock, GlobalHelperThreadState::CONSUMER);
   }
 
   // Clean up finished tasks.
   ClearCompressionTaskList(HelperThreadState().compressionFinishedList(lock),
                            runtime);
 }
 
-void js::AttachFinishedCompressions(JSRuntime* runtime, AutoLockHelperThreadState& lock) {
+void js::AttachFinishedCompressions(JSRuntime* runtime,
+                                    AutoLockHelperThreadState& lock) {
   auto& finished = HelperThreadState().compressionFinishedList(lock);
   for (size_t i = 0; i < finished.length(); i++) {
     if (finished[i]->runtimeMatches(runtime)) {
       UniquePtr<SourceCompressionTask> compressionTask(std::move(finished[i]));
       HelperThreadState().remove(finished, &i);
       compressionTask->complete();
     }
   }
--- a/js/src/vm/TypedArrayObject.cpp
+++ b/js/src/vm/TypedArrayObject.cpp
@@ -1406,17 +1406,17 @@ bool BufferGetterImpl(JSContext* cx, con
                                             Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<TypedArrayObject::is, BufferGetterImpl>(cx, args);
 }
 
 // ES2019 draft rev fc9ecdcd74294d0ca3146d4b274e2a8e79565dc3
 // 22.2.3.32 get %TypedArray%.prototype [ @@toStringTag ]
 static bool TypedArray_toStringTagGetter(JSContext* cx, unsigned argc,
-    Value* vp) {
+                                         Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   // Steps 1-2.
   if (!args.thisv().isObject()) {
     args.rval().setUndefined();
     return true;
   }
 
--- a/js/src/wasm/AsmJS.h
+++ b/js/src/wasm/AsmJS.h
@@ -15,17 +15,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #ifndef wasm_AsmJS_h
 #define wasm_AsmJS_h
 
 #include "mozilla/Attributes.h"  // MOZ_MUST_USE
-#include "mozilla/Utf8.h"  // mozilla::Utf8Unit
+#include "mozilla/Utf8.h"        // mozilla::Utf8Unit
 
 #include <stdint.h>  // uint32_t
 
 #include "js/CallArgs.h"  // JSNative
 
 struct JSContext;
 class JSFunction;
 
--- a/js/src/wasm/WasmAST.h
+++ b/js/src/wasm/WasmAST.h
@@ -829,19 +829,25 @@ class AstMemOrTableCopy : public AstExpr
         isMem_(isMem),
         destTable_(destTable),
         dest_(dest),
         srcTable_(srcTable),
         src_(src),
         len_(len) {}
 
   bool isMem() const { return isMem_; }
-  AstRef& destTable() { MOZ_ASSERT(!isMem()); return destTable_; }
+  AstRef& destTable() {
+    MOZ_ASSERT(!isMem());
+    return destTable_;
+  }
   AstExpr& dest() const { return *dest_; }
-  AstRef& srcTable() { MOZ_ASSERT(!isMem()); return srcTable_; }
+  AstRef& srcTable() {
+    MOZ_ASSERT(!isMem());
+    return srcTable_;
+  }
   AstExpr& src() const { return *src_; }
   AstExpr& len() const { return *len_; }
 };
 
 class AstDataOrElemDrop : public AstExpr {
   bool isData_;
   uint32_t segIndex_;
 
@@ -887,18 +893,24 @@ class AstMemOrTableInit : public AstExpr
         target_(target),
         dst_(dst),
         src_(src),
         len_(len) {}
 
   bool isMem() const { return isMem_; }
   uint32_t segIndex() const { return segIndex_; }
   AstRef& target() { return target_; }
-  AstRef& targetTable() { MOZ_ASSERT(!isMem()); return target_; }
-  AstRef& targetMemory() { MOZ_ASSERT(isMem()); return target_; }
+  AstRef& targetTable() {
+    MOZ_ASSERT(!isMem());
+    return target_;
+  }
+  AstRef& targetMemory() {
+    MOZ_ASSERT(isMem());
+    return target_;
+  }
   AstExpr& dst() const { return *dst_; }
   AstExpr& src() const { return *src_; }
   AstExpr& len() const { return *len_; }
 };
 #endif
 
 #ifdef ENABLE_WASM_GENERALIZED_TABLES
 class AstTableGet : public AstExpr {
--- a/js/src/wasm/WasmBaselineCompile.h
+++ b/js/src/wasm/WasmBaselineCompile.h
@@ -24,20 +24,21 @@
 namespace js {
 namespace wasm {
 
 // Return whether BaselineCompileFunction can generate code on the current
 // device.
 bool BaselineCanCompile();
 
 // Generate adequate code quickly.
-MOZ_MUST_USE bool BaselineCompileFunctions(
-    const ModuleEnvironment& env, LifoAlloc& lifo,
-    const FuncCompileInputVector& inputs, CompiledCode* code,
-    UniqueChars* error);
+MOZ_MUST_USE bool BaselineCompileFunctions(const ModuleEnvironment& env,
+                                           LifoAlloc& lifo,
+                                           const FuncCompileInputVector& inputs,
+                                           CompiledCode* code,
+                                           UniqueChars* error);
 
 class BaseLocalIter {
  private:
   using ConstValTypeRange = mozilla::Range<const ValType>;
 
   const ValTypeVector& locals_;
   size_t argsLength_;
   ConstValTypeRange argsRange_;  // range struct cache for ABIArgIter
--- a/js/src/wasm/WasmCompile.cpp
+++ b/js/src/wasm/WasmCompile.cpp
@@ -68,19 +68,18 @@ uint32_t wasm::ObservedCPUFeatures() {
   return MIPS64 | (jit::GetMIPSFlags() << ARCH_BITS);
 #elif defined(JS_CODEGEN_NONE)
   return 0;
 #else
 #  error "unknown architecture"
 #endif
 }
 
-SharedCompileArgs
-CompileArgs::build(JSContext* cx, ScriptedCaller&& scriptedCaller)
-{
+SharedCompileArgs CompileArgs::build(JSContext* cx,
+                                     ScriptedCaller&& scriptedCaller) {
   bool baseline = BaselineCanCompile() && cx->options().wasmBaseline();
   bool ion = IonCanCompile() && cx->options().wasmIon();
 #ifdef ENABLE_WASM_CRANELIFT
   bool cranelift = CraneliftCanCompile() && cx->options().wasmCranelift();
 #else
   bool cranelift = false;
 #endif
 
@@ -91,18 +90,20 @@ CompileArgs::build(JSContext* cx, Script
 #endif
 
   // Debug information such as source view or debug traps will require
   // additional memory and permanently stay in baseline code, so we try to
   // only enable it when a developer actually cares: when the debugger tab
   // is open.
   bool debug = cx->realm()->debuggerObservesAsmJS();
 
-  bool sharedMemory = cx->realm()->creationOptions().getSharedMemoryAndAtomicsEnabled();
-  bool forceTiering = cx->options().testWasmAwaitTier2() || JitOptions.wasmDelayTier2;
+  bool sharedMemory =
+      cx->realm()->creationOptions().getSharedMemoryAndAtomicsEnabled();
+  bool forceTiering =
+      cx->options().testWasmAwaitTier2() || JitOptions.wasmDelayTier2;
 
   if (debug || gc) {
     if (!baseline) {
       JS_ReportErrorASCII(cx, "can't use wasm debug/gc without baseline");
       return nullptr;
     }
     ion = false;
     cranelift = false;
@@ -474,17 +475,18 @@ void CompilerEnvironment::computeParamet
       (TieringBeneficial(codeSectionSize) || forceTiering)) {
     mode_ = CompileMode::Tier1;
     tier_ = Tier::Baseline;
   } else {
     mode_ = CompileMode::Once;
     tier_ = hasSecondTier ? Tier::Optimized : Tier::Baseline;
   }
 
-  optimizedBackend_ = craneliftEnabled ? OptimizedBackend::Cranelift : OptimizedBackend::Ion;
+  optimizedBackend_ =
+      craneliftEnabled ? OptimizedBackend::Cranelift : OptimizedBackend::Ion;
 
   debug_ = debugEnabled ? DebugEnabled::True : DebugEnabled::False;
   gcTypes_ = gcEnabled;
   state_ = Computed;
 }
 
 template <class DecoderT>
 static bool DecodeFunctionBody(DecoderT& d, ModuleGenerator& mg,
@@ -577,18 +579,19 @@ SharedModule wasm::CompileBuffer(const C
 }
 
 void wasm::CompileTier2(const CompileArgs& args, const Bytes& bytecode,
                         const Module& module, Atomic<bool>* cancelled) {
   UniqueChars error;
   Decoder d(bytecode, 0, &error);
 
   bool gcTypesConfigured = false;  // No optimized backend support yet
-  OptimizedBackend optimizedBackend =
-      args.craneliftEnabled ? OptimizedBackend::Cranelift : OptimizedBackend::Ion;
+  OptimizedBackend optimizedBackend = args.craneliftEnabled
+                                          ? OptimizedBackend::Cranelift
+                                          : OptimizedBackend::Ion;
 
   CompilerEnvironment compilerEnv(CompileMode::Tier2, Tier::Optimized,
                                   optimizedBackend, DebugEnabled::False,
                                   gcTypesConfigured);
 
   ModuleEnvironment env(
       gcTypesConfigured, &compilerEnv,
       args.sharedMemoryEnabled ? Shareable::True : Shareable::False);
--- a/js/src/wasm/WasmCompile.h
+++ b/js/src/wasm/WasmCompile.h
@@ -62,17 +62,18 @@ struct CompileArgs : ShareableBase<Compi
   //
   // - one through a factory function `build`, which checks that flags are
   // consistent with each other.
   // - one that gives complete access to underlying fields.
   //
   // You should use the first one in general, unless you have a very good
   // reason (i.e. no JSContext around and you know which flags have been used).
 
-  static SharedCompileArgs build(JSContext* cx, ScriptedCaller&& scriptedCaller);
+  static SharedCompileArgs build(JSContext* cx,
+                                 ScriptedCaller&& scriptedCaller);
 
   explicit CompileArgs(ScriptedCaller&& scriptedCaller)
       : scriptedCaller(std::move(scriptedCaller)),
         baselineEnabled(false),
         ionEnabled(false),
         craneliftEnabled(false),
         debugEnabled(false),
         sharedMemoryEnabled(false),
--- a/js/src/wasm/WasmCraneliftCompile.cpp
+++ b/js/src/wasm/WasmCraneliftCompile.cpp
@@ -274,19 +274,17 @@ const TableDesc* env_table(const Craneli
 const GlobalDesc* env_global(const CraneliftModuleEnvironment* env,
                              size_t globalIndex) {
   return &env->env.globals[globalIndex];
 }
 
 bool wasm::CraneliftCompileFunctions(const ModuleEnvironment& env,
                                      LifoAlloc& lifo,
                                      const FuncCompileInputVector& inputs,
-                                     CompiledCode* code,
-                                     UniqueChars* error) {
-
+                                     CompiledCode* code, UniqueChars* error) {
   MOZ_RELEASE_ASSERT(CraneliftCanCompile());
 
   MOZ_ASSERT(env.tier() == Tier::Optimized);
   MOZ_ASSERT(env.optimizedBackend() == OptimizedBackend::Cranelift);
   MOZ_ASSERT(!env.isAsmJS());
 
   AutoCranelift compiler(env);
   if (!compiler.init()) {
--- a/js/src/wasm/WasmIonCompile.cpp
+++ b/js/src/wasm/WasmIonCompile.cpp
@@ -4006,18 +4006,17 @@ static bool EmitBodyExprs(FunctionCompil
 
   MOZ_CRASH("unreachable");
 
 #undef CHECK
 }
 
 bool wasm::IonCompileFunctions(const ModuleEnvironment& env, LifoAlloc& lifo,
                                const FuncCompileInputVector& inputs,
-                               CompiledCode* code,
-                               UniqueChars* error) {
+                               CompiledCode* code, UniqueChars* error) {
   MOZ_ASSERT(env.tier() == Tier::Optimized);
   MOZ_ASSERT(env.optimizedBackend() == OptimizedBackend::Ion);
 
   TempAllocator alloc(&lifo);
   JitContext jitContext(&alloc);
   MOZ_ASSERT(IsCompilingWasm());
   WasmMacroAssembler masm(alloc);
 
--- a/js/src/wasm/WasmIonCompile.h
+++ b/js/src/wasm/WasmIonCompile.h
@@ -28,15 +28,14 @@ namespace wasm {
 
 // Return whether IonCompileFunction() can generate code on the current device.
 bool IonCanCompile();
 
 // Generates very fast code at the expense of compilation time.
 MOZ_MUST_USE bool IonCompileFunctions(const ModuleEnvironment& env,
                                       LifoAlloc& lifo,
                                       const FuncCompileInputVector& inputs,
-                                      CompiledCode* code,
-                                      UniqueChars* error);
+                                      CompiledCode* code, UniqueChars* error);
 
 }  // namespace wasm
 }  // namespace js
 
 #endif  // wasm_ion_compile_h
--- a/js/src/wasm/WasmJS.cpp
+++ b/js/src/wasm/WasmJS.cpp
@@ -106,17 +106,17 @@ bool wasm::HasCompilerSupport(JSContext*
   return BaselineCanCompile() || IonCanCompile() || CraneliftCanCompile();
 }
 
 bool wasm::HasOptimizedCompilerTier(JSContext* cx) {
   return (cx->options().wasmIon() && IonCanCompile())
 #ifdef ENABLE_WASM_CRANELIFT
          || (cx->options().wasmCranelift() && CraneliftCanCompile())
 #endif
-  ;
+      ;
 }
 
 // Return whether wasm compilation is allowed by prefs.  This check
 // only makes sense if HasCompilerSupport() is true.
 static bool HasAvailableCompilerTier(JSContext* cx) {
   return (cx->options().wasmBaseline() && BaselineCanCompile()) ||
          HasOptimizedCompilerTier(cx);
 }
@@ -412,17 +412,18 @@ bool wasm::Eval(JSContext* cx, Handle<Ty
     return false;
   }
 
   ScriptedCaller scriptedCaller;
   if (!DescribeScriptedCaller(cx, &scriptedCaller, "wasm_eval")) {
     return false;
   }
 
-  SharedCompileArgs compileArgs = CompileArgs::build(cx, std::move(scriptedCaller));
+  SharedCompileArgs compileArgs =
+      CompileArgs::build(cx, std::move(scriptedCaller));
   if (!compileArgs) {
     return false;
   }
 
   UniqueChars error;
   UniqueCharsVector warnings;
   SharedModule module =
       CompileBuffer(*compileArgs, *bytecode, &error, &warnings);
--- a/js/src/wasm/WasmOpIter.h
+++ b/js/src/wasm/WasmOpIter.h
@@ -1908,17 +1908,18 @@ inline bool OpIter<Policy>::readMemOrTab
   if (!popWithType(ValType::I32, dst)) {
     return false;
   }
 
   return true;
 }
 
 template <typename Policy>
-inline bool OpIter<Policy>::readDataOrElemDrop(bool isData, uint32_t* segIndex) {
+inline bool OpIter<Policy>::readDataOrElemDrop(bool isData,
+                                               uint32_t* segIndex) {
   MOZ_ASSERT(Classify(op_) == OpKind::DataOrElemDrop);
 
   if (isData) {
     if (!env_.usesMemory()) {
       return fail("can't touch memory without memory");
     }
   } else {
     if (env_.tables.length() == 0) {
--- a/js/src/wasm/WasmStubs.cpp
+++ b/js/src/wasm/WasmStubs.cpp
@@ -132,27 +132,25 @@ static void SetupABIArguments(MacroAssem
           case MIRType::Pointer:
             masm.loadPtr(src, scratch);
             masm.storePtr(scratch, Address(masm.getStackPointer(),
                                            iter->offsetFromArgBase()));
             break;
           case MIRType::Double: {
             ScratchDoubleScope fpscratch(masm);
             masm.loadDouble(src, fpscratch);
-            masm.storeDouble(
-                fpscratch,
-                Address(masm.getStackPointer(), iter->offsetFromArgBase()));
+            masm.storeDouble(fpscratch, Address(masm.getStackPointer(),
+                                                iter->offsetFromArgBase()));
             break;
           }
           case MIRType::Float32: {
             ScratchFloat32Scope fpscratch(masm);
             masm.loadFloat32(src, fpscratch);
-            masm.storeFloat32(
-                fpscratch,
-                Address(masm.getStackPointer(), iter->offsetFromArgBase()));
+            masm.storeFloat32(fpscratch, Address(masm.getStackPointer(),
+                                                 iter->offsetFromArgBase()));
             break;
           }
           default:
             MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE(
                 "unexpected stack arg type");
         }
         break;
       case ABIArg::Uninitialized:
--- a/js/src/wasm/WasmTextToBinary.cpp
+++ b/js/src/wasm/WasmTextToBinary.cpp
@@ -3672,17 +3672,18 @@ static AstMemOrTableCopy* ParseMemOrTabl
   if (!len) {
     return nullptr;
   }
 
   return new (c.lifo) AstMemOrTableCopy(isMem, targetMemOrTable, dest,
                                         memOrTableSource, src, len);
 }
 
-static AstDataOrElemDrop* ParseDataOrElemDrop(WasmParseContext& c, bool isData) {
+static AstDataOrElemDrop* ParseDataOrElemDrop(WasmParseContext& c,
+                                              bool isData) {
   WasmToken segIndexTok;
   if (!c.ts.getIf(WasmToken::Index, &segIndexTok)) {
     return nullptr;
   }
 
   if (isData) {
     c.requiresDataCount = true;
   }
@@ -5595,18 +5596,17 @@ static bool ResolveWait(Resolver& r, Ast
 }
 
 static bool ResolveWake(Resolver& r, AstWake& s) {
   return ResolveLoadStoreAddress(r, s.address()) && ResolveExpr(r, s.count());
 }
 
 #ifdef ENABLE_WASM_BULKMEM_OPS
 static bool ResolveMemOrTableCopy(Resolver& r, AstMemOrTableCopy& s) {
-  return ResolveExpr(r, s.dest()) &&
-         ResolveExpr(r, s.src()) &&
+  return ResolveExpr(r, s.dest()) && ResolveExpr(r, s.src()) &&
          ResolveExpr(r, s.len()) &&
          (s.isMem() || r.resolveTable(s.destTable())) &&
          (s.isMem() || r.resolveTable(s.srcTable()));
 }
 
 static bool ResolveMemFill(Resolver& r, AstMemFill& s) {
   return ResolveExpr(r, s.start()) && ResolveExpr(r, s.val()) &&
          ResolveExpr(r, s.len());
@@ -6365,43 +6365,39 @@ static bool EncodeWait(Encoder& e, AstWa
 
 static bool EncodeWake(Encoder& e, AstWake& s) {
   return EncodeLoadStoreAddress(e, s.address()) && EncodeExpr(e, s.count()) &&
          e.writeOp(ThreadOp::Wake) && EncodeLoadStoreFlags(e, s.address());
 }
 
 #ifdef ENABLE_WASM_BULKMEM_OPS
 static bool EncodeMemOrTableCopy(Encoder& e, AstMemOrTableCopy& s) {
-  return EncodeExpr(e, s.dest()) &&
-         EncodeExpr(e, s.src()) &&
+  return EncodeExpr(e, s.dest()) && EncodeExpr(e, s.src()) &&
          EncodeExpr(e, s.len()) &&
          e.writeOp(s.isMem() ? MiscOp::MemCopy : MiscOp::TableCopy) &&
          e.writeVarU32(s.isMem() ? 0 : s.srcTable().index()) &&
          e.writeVarU32(s.isMem() ? 0 : s.destTable().index());
 }
 
 static bool EncodeDataOrElemDrop(Encoder& e, AstDataOrElemDrop& s) {
   return e.writeOp(s.isData() ? MiscOp::DataDrop : MiscOp::ElemDrop) &&
          e.writeVarU32(s.segIndex());
 }
 
 static bool EncodeMemFill(Encoder& e, AstMemFill& s) {
-  return EncodeExpr(e, s.start()) &&
-         EncodeExpr(e, s.val()) &&
-         EncodeExpr(e, s.len()) &&
-         e.writeOp(MiscOp::MemFill) &&
-         e.writeVarU32(/* memory index */0);
+  return EncodeExpr(e, s.start()) && EncodeExpr(e, s.val()) &&
+         EncodeExpr(e, s.len()) && e.writeOp(MiscOp::MemFill) &&
+         e.writeVarU32(/* memory index */ 0);
 }
 
 static bool EncodeMemOrTableInit(Encoder& e, AstMemOrTableInit& s) {
   return EncodeExpr(e, s.dst()) && EncodeExpr(e, s.src()) &&
          EncodeExpr(e, s.len()) &&
          e.writeOp(s.isMem() ? MiscOp::MemInit : MiscOp::TableInit) &&
-         e.writeVarU32(s.segIndex()) &&
-         e.writeVarU32(s.target().index());
+         e.writeVarU32(s.segIndex()) && e.writeVarU32(s.target().index());
 }
 #endif
 
 #ifdef ENABLE_WASM_GENERALIZED_TABLES
 static bool EncodeTableGet(Encoder& e, AstTableGet& s) {
   return EncodeExpr(e, s.index()) && e.writeOp(MiscOp::TableGet) &&
          EncodeOneTableIndex(e, s.targetTable().index());
 }
--- a/js/src/wasm/WasmValidate.cpp
+++ b/js/src/wasm/WasmValidate.cpp
@@ -1411,17 +1411,18 @@ static bool DecodeStructType(Decoder& d,
   env->numStructTypes++;
 
   return true;
 }
 
 #ifdef ENABLE_WASM_REFTYPES
 static bool DecodeGCFeatureOptInSection(Decoder& d, ModuleEnvironment* env) {
   MaybeSectionRange range;
-  if (!d.startSection(SectionId::GcFeatureOptIn, env, &range, "gcfeatureoptin")) {
+  if (!d.startSection(SectionId::GcFeatureOptIn, env, &range,
+                      "gcfeatureoptin")) {
     return false;
   }
   if (!range) {
     return true;
   }
 
   uint32_t version;
   if (!d.readVarU32(&version)) {
--- a/layout/forms/nsHTMLButtonControlFrame.cpp
+++ b/layout/forms/nsHTMLButtonControlFrame.cpp
@@ -100,17 +100,18 @@ void nsHTMLButtonControlFrame::BuildDisp
     DisplayListClipState::AutoSaveRestore clipState(aBuilder);
 
     if (ShouldClipPaintingToBorderBox()) {
       nsMargin border = StyleBorder()->GetComputedBorder();
       nsRect rect(aBuilder->ToReferenceFrame(this), GetSize());
       rect.Deflate(border);
       nscoord radii[8];
       bool hasRadii = GetPaddingBoxBorderRadii(radii);
-      clipState.ClipContainingBlockDescendants(rect, hasRadii ? radii : nullptr);
+      clipState.ClipContainingBlockDescendants(rect,
+                                               hasRadii ? radii : nullptr);
     }
 
     BuildDisplayListForChild(aBuilder, mFrames.FirstChild(), set,
                              DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT);
   }
 
   // Put the foreground outline and focus rects on top of the children
   set.Content()->AppendToTop(&onTop);
--- a/layout/generic/nsTextFrame.h
+++ b/layout/generic/nsTextFrame.h
@@ -400,21 +400,21 @@ class nsTextFrame : public nsFrame {
 
   struct PaintTextParams {
     gfxContext* context;
     mozilla::gfx::Point framePt;
     LayoutDeviceRect dirtyRect;
     mozilla::SVGContextPaint* contextPaint = nullptr;
     DrawPathCallbacks* callbacks = nullptr;
     enum {
-      PaintText,         // Normal text painting.
-      GenerateTextMask   // To generate a mask from a text frame. Should
-                         // only paint text itself with opaque color.
-                         // Text shadow, text selection color and text
-                         // decoration are all discarded in this state.
+      PaintText,        // Normal text painting.
+      GenerateTextMask  // To generate a mask from a text frame. Should
+                        // only paint text itself with opaque color.
+                        // Text shadow, text selection color and text
+                        // decoration are all discarded in this state.
     };
     uint8_t state = PaintText;
     explicit PaintTextParams(gfxContext* aContext) : context(aContext) {}
 
     bool IsPaintText() const { return state == PaintText; }
     bool IsGenerateTextMask() const { return state == GenerateTextMask; }
   };
 
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -8550,17 +8550,17 @@ bool nsDisplayPerspective::CreateWebRend
   params.mTransformPtr = &perspectiveMatrix;
   params.reference_frame_kind = wr::WrReferenceFrameKind::Perspective;
   params.is_backface_visible = !BackfaceIsHidden();
   params.SetPreserve3D(preserve3D);
 
   Maybe<uint64_t> scrollingRelativeTo;
   for (auto* asr = GetActiveScrolledRoot(); asr; asr = asr->mParent) {
     if (nsLayoutUtils::IsAncestorFrameCrossDoc(
-          asr->mScrollableFrame->GetScrolledFrame(), perspectiveFrame)) {
+            asr->mScrollableFrame->GetScrolledFrame(), perspectiveFrame)) {
       scrollingRelativeTo.emplace(asr->GetViewId());
       break;
     }
   }
 
   // We put the perspective reference frame wrapping the transformed frame,
   // even though there may be arbitrarily nested scroll frames in between.
   //
--- a/layout/style/nsFontFaceLoader.cpp
+++ b/layout/style/nsFontFaceLoader.cpp
@@ -96,17 +96,17 @@ void nsFontFaceLoader::StartedLoading(ns
 }
 
 /* static */ void nsFontFaceLoader::LoadTimerCallback(nsITimer* aTimer,
                                                       void* aClosure) {
   nsFontFaceLoader* loader = static_cast<nsFontFaceLoader*>(aClosure);
 
   MOZ_DIAGNOSTIC_ASSERT(!loader->mInLoadTimerCallback);
   MOZ_DIAGNOSTIC_ASSERT(!loader->mInStreamComplete);
-  AutoRestore<bool> scope { loader->mInLoadTimerCallback };
+  AutoRestore<bool> scope{loader->mInLoadTimerCallback};
   loader->mInLoadTimerCallback = true;
 
   if (!loader->mFontFaceSet) {
     // We've been canceled
     return;
   }
 
   gfxUserFontEntry* ufe = loader->mUserFontEntry.get();
@@ -196,17 +196,17 @@ NS_IMETHODIMP
 nsFontFaceLoader::OnStreamComplete(nsIStreamLoader* aLoader,
                                    nsISupports* aContext, nsresult aStatus,
                                    uint32_t aStringLen,
                                    const uint8_t* aString) {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_DIAGNOSTIC_ASSERT(!mInLoadTimerCallback);
   MOZ_DIAGNOSTIC_ASSERT(!mInStreamComplete);
 
-  AutoRestore<bool> scope { mInStreamComplete };
+  AutoRestore<bool> scope{mInStreamComplete};
   mInStreamComplete = true;
 
   DropChannel();
 
   if (!mFontFaceSet) {
     // We've been canceled
     return aStatus;
   }
--- a/media/mtransport/dtlsidentity.cpp
+++ b/media/mtransport/dtlsidentity.cpp
@@ -18,26 +18,26 @@
 
 #include "mozilla/Sprintf.h"
 #include "mozilla/dom/CryptoBuffer.h"
 #include "mozilla/dom/CryptoKey.h"
 
 namespace mozilla {
 
 // TODO(bug 1522632): This function should be moved to NSS
-static SECItem* ExportDEREncryptedPrivateKeyInfo(
+static SECItem *ExportDEREncryptedPrivateKeyInfo(
     PK11SlotInfo *slot,    /* optional, encrypt key in this slot */
     SECOidTag algTag,      /* encrypt key with this algorithm */
     const SECItem *pwitem, /* password for PBE encryption */
     SECKEYPrivateKey *pk,  /* encrypt this private key */
     int iteration,         /* interations for PBE alg */
     void *wincx)           /* context for password callback ? */
 {
   SECKEYEncryptedPrivateKeyInfo *pki = PK11_ExportEncryptedPrivKeyInfo(
-      slot, algTag, const_cast<SECItem*>(pwitem), pk, iteration, wincx);
+      slot, algTag, const_cast<SECItem *>(pwitem), pk, iteration, wincx);
   SECItem *derPKI;
 
   if (!pki) {
     return NULL;
   }
   derPKI = SEC_ASN1EncodeItem(
       NULL, NULL, pki,
       NSS_Get_SECKEY_EncryptedPrivateKeyInfoTemplate(NULL, PR_FALSE));
@@ -332,18 +332,18 @@ nsresult DtlsIdentity::ComputeFingerprin
   MOZ_ASSERT(ho);
   if (!ho) {
     return NS_ERROR_INVALID_ARG;
   }
 
   MOZ_ASSERT(ho->length >= 20);  // Double check
   digest->value_.resize(ho->length);
 
-  SECStatus rv =
-      HASH_HashBuf(ho->type, digest->value_.data(), cert->derCert.data, cert->derCert.len);
+  SECStatus rv = HASH_HashBuf(ho->type, digest->value_.data(),
+                              cert->derCert.data, cert->derCert.len);
   if (rv != SECSuccess) {
     return NS_ERROR_FAILURE;
   }
 
   return NS_OK;
 }
 
 }  // namespace mozilla
--- a/media/mtransport/dtlsidentity.h
+++ b/media/mtransport/dtlsidentity.h
@@ -20,28 +20,24 @@
 // All code in this module requires NSS to be live.
 // Callers must initialize NSS and implement the nsNSSShutdownObject
 // protocol.
 namespace mozilla {
 
 class DtlsDigest {
  public:
   const static size_t kMaxDtlsDigestLength = HASH_LENGTH_MAX;
-  explicit DtlsDigest(const std::string& algorithm)
-      : algorithm_(algorithm) {}
-  DtlsDigest(const std::string& algorithm,
-             const std::vector<uint8_t>& value)
+  explicit DtlsDigest(const std::string& algorithm) : algorithm_(algorithm) {}
+  DtlsDigest(const std::string& algorithm, const std::vector<uint8_t>& value)
       : algorithm_(algorithm), value_(value) {
     MOZ_ASSERT(value.size() <= kMaxDtlsDigestLength);
   }
   ~DtlsDigest() = default;
 
-  bool operator!=(const DtlsDigest& rhs) const {
-    return !operator==(rhs);
-  }
+  bool operator!=(const DtlsDigest& rhs) const { return !operator==(rhs); }
 
   bool operator==(const DtlsDigest& rhs) const {
     if (algorithm_ != rhs.algorithm_) {
       return false;
     }
 
     return value_ == rhs.value_;
   }
--- a/media/mtransport/transportlayerdtls.cpp
+++ b/media/mtransport/transportlayerdtls.cpp
@@ -421,18 +421,17 @@ nsresult TransportLayerDtls::SetVerifica
   // Defensive programming
   if (verification_mode_ != VERIFY_UNSET) return NS_ERROR_ALREADY_INITIALIZED;
 
   verification_mode_ = VERIFY_ALLOW_ALL;
 
   return NS_OK;
 }
 
-nsresult TransportLayerDtls::SetVerificationDigest(
-    const DtlsDigest &digest) {
+nsresult TransportLayerDtls::SetVerificationDigest(const DtlsDigest &digest) {
   // Defensive programming
   if (verification_mode_ != VERIFY_UNSET &&
       verification_mode_ != VERIFY_DIGEST) {
     return NS_ERROR_ALREADY_INITIALIZED;
   }
 
   digests_.push_back(digest);
   verification_mode_ = VERIFY_DIGEST;
--- a/media/webrtc/signaling/gtest/mediapipeline_unittest.cpp
+++ b/media/webrtc/signaling/gtest/mediapipeline_unittest.cpp
@@ -178,26 +178,23 @@ class LoopbackTransport : public MediaTr
   // capture permissions have been granted on the window, which could easily
   // change between Init (ie; when the PC is created) and StartIceGathering
   // (ie; when we set the local description).
   void StartIceGathering(bool aDefaultRouteOnly,
                          // TODO: It probably makes sense to look
                          // this up internally
                          const nsTArray<NrIceStunAddr>& aStunAddrs) override {}
 
-  void ActivateTransport(const std::string& aTransportId,
-                         const std::string& aLocalUfrag,
-                         const std::string& aLocalPwd, size_t aComponentCount,
-                         const std::string& aUfrag,
-                         const std::string& aPassword,
-                         const nsTArray<uint8_t>& aKeyDer,
-                         const nsTArray<uint8_t>& aCertDer,
-                         SSLKEAType aAuthType, bool aDtlsClient,
-                         const DtlsDigestList& aDigests,
-                         bool aPrivacyRequested) override {}
+  void ActivateTransport(
+      const std::string& aTransportId, const std::string& aLocalUfrag,
+      const std::string& aLocalPwd, size_t aComponentCount,
+      const std::string& aUfrag, const std::string& aPassword,
+      const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer,
+      SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests,
+      bool aPrivacyRequested) override {}
 
   void RemoveTransportsExcept(
       const std::set<std::string>& aTransportIds) override {}
 
   void StartIceChecks(bool aIsControlling, bool aIsOfferer,
                       const std::vector<std::string>& aIceOptions) override {}
 
   void AddIceCandidate(const std::string& aTransportId,
--- a/media/webrtc/signaling/src/peerconnection/MediaTransportHandler.cpp
+++ b/media/webrtc/signaling/src/peerconnection/MediaTransportHandler.cpp
@@ -79,18 +79,18 @@ class MediaTransportHandlerSTS : public 
                          // via IPC anymore
                          const nsTArray<NrIceStunAddr>& aStunAddrs) override;
 
   void ActivateTransport(
       const std::string& aTransportId, const std::string& aLocalUfrag,
       const std::string& aLocalPwd, size_t aComponentCount,
       const std::string& aUfrag, const std::string& aPassword,
       const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer,
-      SSLKEAType aAuthType, bool aDtlsClient,
-      const DtlsDigestList& aDigests, bool aPrivacyRequested) override;
+      SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests,
+      bool aPrivacyRequested) override;
 
   void RemoveTransportsExcept(
       const std::set<std::string>& aTransportIds) override;
 
   void StartIceChecks(bool aIsControlling, bool aIsOfferer,
                       const std::vector<std::string>& aIceOptions) override;
 
   void AddIceCandidate(const std::string& aTransportId,
@@ -104,20 +104,22 @@ class MediaTransportHandlerSTS : public 
   TransportLayer::State GetState(const std::string& aTransportId,
                                  bool aRtcp) const override;
 
   RefPtr<StatsPromise> GetIceStats(
       const std::string& aTransportId, DOMHighResTimeStamp aNow,
       std::unique_ptr<dom::RTCStatsReportInternal>&& aReport) override;
 
  private:
-  RefPtr<TransportFlow> CreateTransportFlow(
-      const std::string& aTransportId, bool aIsRtcp,
-      RefPtr<DtlsIdentity> aDtlsIdentity, bool aDtlsClient,
-      const DtlsDigestList& aDigests, bool aPrivacyRequested);
+  RefPtr<TransportFlow> CreateTransportFlow(const std::string& aTransportId,
+                                            bool aIsRtcp,
+                                            RefPtr<DtlsIdentity> aDtlsIdentity,
+                                            bool aDtlsClient,
+                                            const DtlsDigestList& aDigests,
+                                            bool aPrivacyRequested);
 
   struct Transport {
     RefPtr<TransportFlow> mFlow;
     RefPtr<TransportFlow> mRtcpFlow;
   };
 
   void OnGatheringStateChange(NrIceCtx* aIceCtx,
                               NrIceCtx::GatheringState aState);
@@ -411,18 +413,18 @@ void MediaTransportHandlerSTS::EnsurePro
   mTransports[aTransportId];
 }
 
 void MediaTransportHandlerSTS::ActivateTransport(
     const std::string& aTransportId, const std::string& aLocalUfrag,
     const std::string& aLocalPwd, size_t aComponentCount,
     const std::string& aUfrag, const std::string& aPassword,
     const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer,
-    SSLKEAType aAuthType, bool aDtlsClient,
-    const DtlsDigestList& aDigests, bool aPrivacyRequested) {
+    SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests,
+    bool aPrivacyRequested) {
   MOZ_ASSERT(aComponentCount);
   RefPtr<DtlsIdentity> dtlsIdentity(
       DtlsIdentity::Deserialize(aKeyDer, aCertDer, aAuthType));
   if (!dtlsIdentity) {
     MOZ_ASSERT(false);
     return;
   }
 
--- a/media/webrtc/signaling/src/peerconnection/MediaTransportHandler.h
+++ b/media/webrtc/signaling/src/peerconnection/MediaTransportHandler.h
@@ -3,18 +3,18 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef _MTRANSPORTHANDLER_H__
 #define _MTRANSPORTHANDLER_H__
 
 #include "mozilla/RefPtr.h"
 #include "nsISupportsImpl.h"
 #include "sigslot.h"
-#include "transportlayer.h"      // Need the State enum
-#include "dtlsidentity.h"  // For DtlsDigest
+#include "transportlayer.h"  // Need the State enum
+#include "dtlsidentity.h"    // For DtlsDigest
 #include "mozilla/dom/PeerConnectionImplEnumsBinding.h"
 #include "mozilla/dom/RTCConfigurationBinding.h"
 #include "nricectx.h"               // Need some enums
 #include "nsDOMNavigationTiming.h"  // DOMHighResTimeStamp
 #include "signaling/src/common/CandidateInfo.h"
 
 #include "nsString.h"
 
@@ -73,18 +73,18 @@ class MediaTransportHandler {
                                  // this up internally
                                  const nsTArray<NrIceStunAddr>& aStunAddrs) = 0;
 
   virtual void ActivateTransport(
       const std::string& aTransportId, const std::string& aLocalUfrag,
       const std::string& aLocalPwd, size_t aComponentCount,
       const std::string& aUfrag, const std::string& aPassword,
       const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer,
-      SSLKEAType aAuthType, bool aDtlsClient,
-      const DtlsDigestList& aDigests, bool aPrivacyRequested) = 0;
+      SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests,
+      bool aPrivacyRequested) = 0;
 
   virtual void RemoveTransportsExcept(
       const std::set<std::string>& aTransportIds) = 0;
 
   virtual void StartIceChecks(bool aIsControlling, bool aIsOfferer,
                               const std::vector<std::string>& aIceOptions) = 0;
 
   virtual void SendPacket(const std::string& aTransportId,
--- a/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
+++ b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
@@ -439,19 +439,20 @@ static nsresult RunLogQuery(const nsCStr
     return rv;
   }
   if (!stsThread) {
     return NS_ERROR_FAILURE;
   }
 
   RefPtr<MediaTransportHandler> transportHandler = ctx->GetTransportHandler();
 
-  InvokeAsync(
-      stsThread, __func__,
-      [transportHandler, aPattern]() { return transportHandler->GetIceLog(aPattern); })
+  InvokeAsync(stsThread, __func__,
+              [transportHandler, aPattern]() {
+                return transportHandler->GetIceLog(aPattern);
+              })
       ->Then(GetMainThreadSerialEventTarget(), __func__,
              [aRequestId, aThisChild](Sequence<nsString>&& aLogLines) {
                OnGetLogging_m(aThisChild, aRequestId, std::move(aLogLines));
              },
              [aRequestId, aThisChild](nsresult aError) {
                OnGetLogging_m(aThisChild, aRequestId, Sequence<nsString>());
              });
 
@@ -473,18 +474,20 @@ static nsresult RunLogClear() {
     return rv;
   }
   if (!stsThread) {
     return NS_ERROR_FAILURE;
   }
 
   RefPtr<MediaTransportHandler> transportHandler = ctx->GetTransportHandler();
 
-  return RUN_ON_THREAD(stsThread, WrapRunnable(transportHandler, &MediaTransportHandler::ClearIceLog),
-                       NS_DISPATCH_NORMAL);
+  return RUN_ON_THREAD(
+      stsThread,
+      WrapRunnable(transportHandler, &MediaTransportHandler::ClearIceLog),
+      NS_DISPATCH_NORMAL);
 }
 
 void WebrtcGlobalInformation::ClearLogging(const GlobalObject& aGlobal) {
   if (!NS_IsMainThread()) {
     return;
   }
 
   // Chrome-only API
--- a/mfbt/ThreadLocal.h
+++ b/mfbt/ThreadLocal.h
@@ -207,24 +207,25 @@ inline void ThreadLocal<T, Storage>::set
   bool succeeded = Storage<T>::set(aValue);
   if (!succeeded) {
     MOZ_CRASH();
   }
 }
 
 #if (defined(XP_WIN) || defined(MACOSX_HAS_THREAD_LOCAL)) && \
     !defined(__MINGW32__)
-#  define MOZ_THREAD_LOCAL(TYPE)               \
+#  define MOZ_THREAD_LOCAL(TYPE)                 \
     thread_local ::mozilla::detail::ThreadLocal< \
         TYPE, ::mozilla::detail::ThreadLocalNativeStorage>
 #elif defined(HAVE_THREAD_TLS_KEYWORD)
-#  define MOZ_THREAD_LOCAL(TYPE)           \
+#  define MOZ_THREAD_LOCAL(TYPE)             \
     __thread ::mozilla::detail::ThreadLocal< \
         TYPE, ::mozilla::detail::ThreadLocalNativeStorage>
 #else
-#  define MOZ_THREAD_LOCAL(TYPE) \
-    ::mozilla::detail::ThreadLocal<TYPE, ::mozilla::detail::ThreadLocalKeyStorage>
+#  define MOZ_THREAD_LOCAL(TYPE)         \
+    ::mozilla::detail::ThreadLocal<TYPE, \
+                                   ::mozilla::detail::ThreadLocalKeyStorage>
 #endif
 
 }  // namespace detail
 }  // namespace mozilla
 
 #endif /* mozilla_ThreadLocal_h */
--- a/netwerk/build/nsNetModule.cpp
+++ b/netwerk/build/nsNetModule.cpp
@@ -71,17 +71,16 @@ NS_IMPL_COMPONENT_FACTORY(net::nsHttpsHa
   auto handler = MakeRefPtr<net::nsHttpsHandler>();
 
   if (NS_FAILED(handler->Init())) {
     return nullptr;
   }
   return handler.forget().downcast<nsIHttpProtocolHandler>();
 }
 
-
 #include "nsCacheService.h"
 
 nsresult nsCacheServiceConstructor(nsISupports* aOuter, const nsIID& aIID,
                                    void** aResult) {
   return nsCacheService::Create(aOuter, aIID, aResult);
 }
 
 #include "WebSocketChannel.h"
@@ -373,18 +372,19 @@ void nsNetShutdown() {
   nsAuthGSSAPI::Shutdown();
 
   delete gNetSniffers;
   gNetSniffers = nullptr;
   delete gDataSniffers;
   gDataSniffers = nullptr;
 }
 
-static const mozilla::Module kNeckoModule = {mozilla::Module::kVersion,
-                                             nullptr,
-                                             nullptr,
-                                             kNeckoCategories,
-                                             nullptr,
-                                             nullptr,
-                                             nullptr,
-                                             mozilla::Module::ALLOW_IN_SOCKET_PROCESS};
+static const mozilla::Module kNeckoModule = {
+    mozilla::Module::kVersion,
+    nullptr,
+    nullptr,
+    kNeckoCategories,
+    nullptr,
+    nullptr,
+    nullptr,
+    mozilla::Module::ALLOW_IN_SOCKET_PROCESS};
 
 NSMODULE_DEFN(necko) = &kNeckoModule;
--- a/netwerk/build/nsNetModule.h
+++ b/netwerk/build/nsNetModule.h
@@ -36,12 +36,12 @@ nsresult nsCacheServiceConstructor(nsISu
 extern nsresult net_NewIncrementalDownload(nsISupports*, const nsIID&, void**);
 
 namespace mozilla {
 namespace net {
 nsresult WebSocketChannelConstructor(nsISupports* aOuter, const nsIID& aIID,
                                      void** aResult);
 nsresult WebSocketSSLChannelConstructor(nsISupports* aOuter, const nsIID& aIID,
                                         void** aResult);
-}
-}
+}  // namespace net
+}  // namespace mozilla
 
 #endif
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -59,18 +59,20 @@ using namespace mozilla::net;
 #define CACHE_COMPRESSION_LEVEL 1
 
 static const char *observerList[] = {
     "profile-before-change",        "profile-do-change",
     NS_XPCOM_SHUTDOWN_OBSERVER_ID,  "last-pb-context-exited",
     "suspend_process_notification", "resume_process_notification"};
 
 static const char *prefList[] = {
-    OFFLINE_CACHE_ENABLE_PREF,      OFFLINE_CACHE_CAPACITY_PREF,
-    OFFLINE_CACHE_DIR_PREF,         nullptr,
+    OFFLINE_CACHE_ENABLE_PREF,
+    OFFLINE_CACHE_CAPACITY_PREF,
+    OFFLINE_CACHE_DIR_PREF,
+    nullptr,
 };
 
 class nsCacheProfilePrefObserver : public nsIObserver {
   virtual ~nsCacheProfilePrefObserver() = default;
 
  public:
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIOBSERVER
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -2222,17 +2222,17 @@ HttpBaseChannel::RedirectTo(nsIURI* targ
   // the WebRequst API, we are dropping the flag here.
   if (mLoadInfo) {
     mLoadInfo->SetAllowInsecureRedirectToDataURI(false);
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
-HttpBaseChannel::SwitchProcessTo(mozilla::dom::Promise *aTabParent,
+HttpBaseChannel::SwitchProcessTo(mozilla::dom::Promise* aTabParent,
                                  uint64_t aIdentifier) {
   return NS_ERROR_NOT_AVAILABLE;
 }
 
 NS_IMETHODIMP
 HttpBaseChannel::UpgradeToSecure() {
   // Upgrades are handled internally between http-on-modify-request and
   // http-on-before-connect, which means upgrades are only possible during
--- a/netwerk/protocol/http/nsAHttpTransaction.h
+++ b/netwerk/protocol/http/nsAHttpTransaction.h
@@ -8,17 +8,17 @@
 #include "nsISupports.h"
 #include "nsTArray.h"
 #include "nsWeakReference.h"
 
 #ifdef Status
 /* Xlib headers insist on this for some reason... Nuke it because
    it'll override our member name */
 typedef Status __StatusTmp;
-#undef Status
+#  undef Status
 typedef __StatusTmp Status;
 #endif
 
 class nsIInterfaceRequestor;
 class nsITransport;
 class nsIRequestContext;
 
 namespace mozilla {
--- a/netwerk/protocol/http/nsHttpResponseHead.h
+++ b/netwerk/protocol/http/nsHttpResponseHead.h
@@ -10,17 +10,17 @@
 #include "nsHttp.h"
 #include "nsString.h"
 #include "mozilla/RecursiveMutex.h"
 
 #ifdef Status
 /* Xlib headers insist on this for some reason... Nuke it because
    it'll override our member name */
 typedef Status __StatusTmp;
-#undef Status
+#  undef Status
 typedef __StatusTmp Status;
 #endif
 
 class nsIHttpHeaderVisitor;
 
 // This needs to be forward declared here so we can include only this header
 // without also including PHttpChannelParams.h
 namespace IPC {
--- a/netwerk/url-classifier/UrlClassifierFeatureFlash.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureFlash.cpp
@@ -33,17 +33,18 @@ static UrlClassifierFeatureFlash::FlashF
      "urlclassifier.flashSubDocExceptTable", true,
      nsIHttpChannel::FlashPluginDeniedInSubdocuments},
 };
 
 bool IsInitialized() { return !!sFlashFeaturesMap[0].mFeature; }
 
 }  // namespace
 
-UrlClassifierFeatureFlash::UrlClassifierFeatureFlash(const UrlClassifierFeatureFlash::FlashFeature& aFlashFeature)
+UrlClassifierFeatureFlash::UrlClassifierFeatureFlash(
+    const UrlClassifierFeatureFlash::FlashFeature& aFlashFeature)
     : UrlClassifierFeatureBase(
           nsDependentCString(aFlashFeature.mName),
           nsDependentCString(aFlashFeature.mBlacklistPrefTables),
           nsDependentCString(aFlashFeature.mWhitelistPrefTables),
           EmptyCString(),  // aPrefBlacklistHosts
           EmptyCString(),  // aPrefWhitelistHosts
           EmptyCString(),  // aPrefBlacklistTableName
           EmptyCString(),  // aPrefWhitelistTableName
@@ -114,17 +115,18 @@ UrlClassifierFeatureFlash::UrlClassifier
       return;
     }
   }
 
   MaybeInitialize();
 
   for (const FlashFeature& flashFeature : sFlashFeaturesMap) {
     MOZ_ASSERT(flashFeature.mFeature);
-    if (!flashFeature.mSubdocumentOnly || contentPolicyType == nsIContentPolicy::TYPE_SUBDOCUMENT) {
+    if (!flashFeature.mSubdocumentOnly ||
+        contentPolicyType == nsIContentPolicy::TYPE_SUBDOCUMENT) {
       aFeatures.AppendElement(flashFeature.mFeature);
     }
   }
 }
 
 /* static */ already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureFlash::GetIfNameMatches(const nsACString& aName) {
   MaybeInitialize();
--- a/netwerk/url-classifier/UrlClassifierFeaturePhishingProtection.h
+++ b/netwerk/url-classifier/UrlClassifierFeaturePhishingProtection.h
@@ -16,18 +16,17 @@ class UrlClassifierFeaturePhishingProtec
     : public UrlClassifierFeatureBase {
  public:
   struct PhishingProtectionFeature;
 
   static void GetFeatureNames(nsTArray<nsCString>& aNames);
 
   static void MaybeShutdown();
 
-  static void MaybeCreate(
-      nsTArray<RefPtr<nsIUrlClassifierFeature>>& aFeatures);
+  static void MaybeCreate(nsTArray<RefPtr<nsIUrlClassifierFeature>>& aFeatures);
 
   static already_AddRefed<nsIUrlClassifierFeature> GetIfNameMatches(
       const nsACString& aName);
 
   NS_IMETHOD
   ProcessChannel(nsIChannel* aChannel, const nsACString& aList,
                  bool* aShouldContinue) override;
 
--- a/security/certverifier/NSSCertDBTrustDomain.h
+++ b/security/certverifier/NSSCertDBTrustDomain.h
@@ -212,17 +212,17 @@ class NSSCertDBTrustDomain : public mozi
   const unsigned int mMinRSABits;
   ValidityCheckingMode mValidityCheckingMode;
   CertVerifier::SHA1Mode mSHA1Mode;
   NetscapeStepUpPolicy mNetscapeStepUpPolicy;
   DistrustedCAPolicy mDistrustedCAPolicy;
   bool mSawDistrustedCAByPolicyError;
   const OriginAttributes& mOriginAttributes;
   const Vector<mozilla::pkix::Input>& mThirdPartyRootInputs;  // non-owning
-  UniqueCERTCertList& mBuiltChain;  // non-owning
+  UniqueCERTCertList& mBuiltChain;                            // non-owning
   PinningTelemetryInfo* mPinningTelemetryInfo;
   const char* mHostname;  // non-owning - only used for pinning checks
   nsCOMPtr<nsICertBlocklist> mCertBlocklist;
   CertVerifier::OCSPStaplingStatus mOCSPStaplingStatus;
   // Certificate Transparency data extracted during certificate verification
   UniqueSECItem mSCTListFromCertificate;
   UniqueSECItem mSCTListFromOCSPStapling;
 };
--- a/toolkit/components/build/nsToolkitCompsModule.h
+++ b/toolkit/components/build/nsToolkitCompsModule.h
@@ -3,10 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nscore.h"
 #include "nsID.h"
 
 class nsISupports;
 
 nsresult nsUrlClassifierDBServiceConstructor(nsISupports *aOuter,
-                                             const nsIID& aIID,
-                                             void **aResult);
+                                             const nsIID &aIID, void **aResult);
--- a/toolkit/components/sessionstore/SessionStoreUtils.cpp
+++ b/toolkit/components/sessionstore/SessionStoreUtils.cpp
@@ -688,17 +688,18 @@ static void SetElementAsString(Element* 
   HTMLInputElement* input = HTMLInputElement::FromNode(aElement);
   if (input) {
     input->SetValue(aValue, CallerType::NonSystem, rv);
     if (!rv.Failed()) {
       nsContentUtils::DispatchInputEvent(aElement);
       return;
     }
   }
-  input = HTMLInputElement::FromNodeOrNull(nsFocusManager::GetRedirectedFocus(aElement));
+  input = HTMLInputElement::FromNodeOrNull(
+      nsFocusManager::GetRedirectedFocus(aElement));
   if (input) {
     input->SetValue(aValue, CallerType::NonSystem, rv);
     if (!rv.Failed()) {
       nsContentUtils::DispatchInputEvent(aElement);
     }
   }
 }
 
@@ -957,17 +958,18 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY
         JS::Rooted<JS::Value> object(
             cx, JS::ObjectValue(*entry.mValue.GetAsObject()));
         SetElementAsObject(cx, node, object);
       }
     }
   }
   if (aData.mXpath.WasPassed()) {
     for (auto& entry : aData.mXpath.Value().Entries()) {
-      RefPtr<Element> node = FindNodeByXPath(aGlobal.Context(), aDocument, entry.mKey);
+      RefPtr<Element> node =
+          FindNodeByXPath(aGlobal.Context(), aDocument, entry.mKey);
       if (node == nullptr) {
         continue;
       }
       if (entry.mValue.IsString()) {
         SetElementAsString(node, entry.mValue.GetAsString());
       } else if (entry.mValue.IsBoolean()) {
         SetElementAsBool(node, entry.mValue.GetAsBoolean());
       } else {
@@ -1022,17 +1024,18 @@ static void ReadAllEntriesFromStorage(
   if (result.Failed() || len == 0) {
     return;
   }
   int64_t storageUsage = storage->GetOriginQuotaUsage();
   if (storageUsage > StaticPrefs::browser_sessionstore_dom_storage_limit()) {
     return;
   }
 
-  Record<nsString, Record<nsString, nsString>>::EntryType* recordEntry = nullptr;
+  Record<nsString, Record<nsString, nsString>>::EntryType* recordEntry =
+      nullptr;
   for (uint32_t i = 0; i < len; i++) {
     Record<nsString, nsString>::EntryType entry;
     mozilla::IgnoredErrorResult res;
     storage->Key(i, entry.mKey, *principal, res);
     if (res.Failed()) {
       continue;
     }
 
@@ -1121,28 +1124,30 @@ static void CollectedSessionStorageInter
     // If changing this logic, make sure to also change the principal
     // computation logic in SessionStore::_sendRestoreHistory.
 
     // OriginAttributes are always after a '^' character
     int32_t pos = entry.mKey.RFindChar('^');
     nsCOMPtr<nsIPrincipal> principal = BasePrincipal::CreateCodebasePrincipal(
         NS_ConvertUTF16toUTF8(Substring(entry.mKey, 0, pos)));
     nsresult rv;
-    nsCOMPtr<nsIDOMStorageManager> storageManager = do_QueryInterface(aDocShell, &rv);
+    nsCOMPtr<nsIDOMStorageManager> storageManager =
+        do_QueryInterface(aDocShell, &rv);
     if (NS_FAILED(rv)) {
       return;
     }
     RefPtr<Storage> storage;
     // There is no need to pass documentURI, it's only used to fill documentURI
     // property of domstorage event, which in this case has no consumer.
     // Prevention of events in case of missing documentURI will be solved in a
     // followup bug to bug 600307.
     // Null window because the current window doesn't match the principal yet
     // and loads about:blank.
-    storageManager->CreateStorage(nullptr, principal, EmptyString(), false, getter_AddRefs(storage));
+    storageManager->CreateStorage(nullptr, principal, EmptyString(), false,
+                                  getter_AddRefs(storage));
     if (!storage) {
       continue;
     }
     for (auto& InnerEntry : entry.mValue.Entries()) {
       IgnoredErrorResult result;
       storage->SetItem(InnerEntry.mKey, InnerEntry.mValue, *principal, result);
       if (result.Failed()) {
         NS_WARNING("storage set item failed!");
--- a/toolkit/recordreplay/MiddlemanCall.cpp
+++ b/toolkit/recordreplay/MiddlemanCall.cpp
@@ -165,17 +165,18 @@ bool SendCallToMiddleman(size_t aCallId,
   // Perform the ReplayOutput phase to fill in outputs for the current call.
   newCall->mArguments.CopyTo(aArguments);
   MiddlemanCallContext cx(newCall, aArguments,
                           MiddlemanCallPhase::ReplayOutput);
   redirection.mMiddlemanCall(cx);
   return true;
 }
 
-void ProcessMiddlemanCall(size_t aChildId, const char* aInputData, size_t aInputSize,
+void ProcessMiddlemanCall(size_t aChildId, const char* aInputData,
+                          size_t aInputSize,
                           InfallibleVector<char>* aOutputData) {
   MOZ_RELEASE_ASSERT(IsMiddleman());
 
   while (aChildId >= gStatePerChild.length()) {
     gStatePerChild.append(nullptr);
   }
   if (!gStatePerChild[aChildId]) {
     gStatePerChild[aChildId] = new MiddlemanCallState();
--- a/toolkit/recordreplay/MiddlemanCall.h
+++ b/toolkit/recordreplay/MiddlemanCall.h
@@ -340,18 +340,18 @@ struct MiddlemanCallContext {
 // been filled in using data from the recording. Returns false if the call was
 // unable to be processed.
 bool SendCallToMiddleman(size_t aCallId, CallArguments* aArguments,
                          bool aDiverged);
 
 // In the middleman process, perform one or more calls encoded in aInputData
 // and encode their outputs to aOutputData. The calls are associated with the
 // specified child process ID.
-void ProcessMiddlemanCall(size_t aChildId,
-                          const char* aInputData, size_t aInputSize,
+void ProcessMiddlemanCall(size_t aChildId, const char* aInputData,
+                          size_t aInputSize,
                           InfallibleVector<char>* aOutputData);
 
 // In the middleman process, reset all call state for a child process ID.
 void ResetMiddlemanCalls(size_t aChildId);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Middleman Call Helpers
 ///////////////////////////////////////////////////////////////////////////////
--- a/toolkit/recordreplay/ipc/ChildProcess.cpp
+++ b/toolkit/recordreplay/ipc/ChildProcess.cpp
@@ -92,19 +92,18 @@ void ChildProcessInfo::OnIncomingMessage
       mPaused = true;
       break;
     case MessageType::MiddlemanCallRequest: {
       const MiddlemanCallRequestMessage& nmsg =
           static_cast<const MiddlemanCallRequestMessage&>(aMsg);
       InfallibleVector<char> outputData;
       ProcessMiddlemanCall(GetId(), nmsg.BinaryData(), nmsg.BinaryDataSize(),
                            &outputData);
-      Message::UniquePtr response(
-        MiddlemanCallResponseMessage::New(outputData.begin(),
-                                          outputData.length()));
+      Message::UniquePtr response(MiddlemanCallResponseMessage::New(
+          outputData.begin(), outputData.length()));
       SendMessage(*response);
       break;
     }
     case MessageType::ResetMiddlemanCalls:
       ResetMiddlemanCalls(GetId());
       break;
     default:
       break;
--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -2542,34 +2542,36 @@ static ReturnAbortOnError CheckDowngrade
 // Build ID dates are 8 digits, build ID times are 6 digits.
 #define BUILDID_DATE_LENGTH 8
 #define BUILDID_TIME_LENGTH 6
 #define BUILDID_LENGTH BUILDID_DATE_LENGTH + BUILDID_TIME_LENGTH
 
 static void GetBuildIDVersions(const nsACString& aFullVersion, int32_t aPos,
                                nsACString& aBuildVersions) {
   // Extract the date part then the time part.
-  aBuildVersions.Assign(Substring(aFullVersion, aPos, BUILDID_DATE_LENGTH) +
+  aBuildVersions.Assign(
+      Substring(aFullVersion, aPos, BUILDID_DATE_LENGTH) +
       NS_LITERAL_CSTRING(".") +
       Substring(aFullVersion, aPos + BUILDID_DATE_LENGTH, BUILDID_TIME_LENGTH));
 }
 
 static Version GetComparableVersion(const nsCString& aVersionStr) {
   // We'll find the position of the '_' and '/' characters. The length from the
   // '_' character to the '/' character will be the length of a build ID plus
   // one for the '_' character. Similarly the length from the '/' character to
   // the end of the string will be the same.
   const uint32_t kExpectedLength = BUILDID_LENGTH + 1;
 
   int32_t underscorePos = aVersionStr.FindChar('_');
   int32_t slashPos = aVersionStr.FindChar('/');
   if (underscorePos == kNotFound || slashPos == kNotFound ||
       (slashPos - underscorePos) != kExpectedLength ||
       (aVersionStr.Length() - slashPos) != kExpectedLength) {
-    NS_WARNING("compatibility.ini Version string does not match the expected format.");
+    NS_WARNING(
+        "compatibility.ini Version string does not match the expected format.");
     return Version(aVersionStr.get());
   }
 
   nsCString appBuild, platBuild;
   NS_NAMED_LITERAL_CSTRING(dot, ".");
 
   const nsACString& version = Substring(aVersionStr, 0, underscorePos);
 
@@ -4688,17 +4690,18 @@ nsresult XREMain::XRE_mainRun() {
   CrashReporter::AnnotateCrashReport(
       CrashReporter::Annotation::ContentSandboxCapabilities, flagsString);
 #endif /* MOZ_SANDBOX && XP_LINUX */
 
 #if defined(MOZ_CONTENT_SANDBOX)
   AddSandboxAnnotations();
 #endif /* MOZ_CONTENT_SANDBOX */
 
-  static_cast<nsToolkitProfileService*>(mProfileSvc.get())->RecordStartupTelemetry();
+  static_cast<nsToolkitProfileService*>(mProfileSvc.get())
+      ->RecordStartupTelemetry();
 
   {
     rv = appStartup->Run();
     if (NS_FAILED(rv)) {
       NS_ERROR("failed to run appstartup");
       gLogConsoleErrors = true;
     }
   }
--- a/toolkit/xre/nsCommandLineServiceMac.mm
+++ b/toolkit/xre/nsCommandLineServiceMac.mm
@@ -14,18 +14,18 @@ static char** sArgs = nullptr;
 static int sArgsAllocated = 0;
 static int sArgsUsed = 0;
 
 static bool sBuildingCommandLine = false;
 
 void AddToCommandLine(const char* inArgText) {
   if (sArgsUsed >= sArgsAllocated - 1) {
     // realloc does not free the given pointer if allocation fails
-    char** temp = static_cast<char**>(
-        realloc(sArgs, (sArgsAllocated + kArgsGrowSize) * sizeof(char*)));
+    char** temp =
+        static_cast<char**>(realloc(sArgs, (sArgsAllocated + kArgsGrowSize) * sizeof(char*)));
     if (!temp) return;
     sArgs = temp;
     sArgsAllocated += kArgsGrowSize;
   }
 
   char* temp2 = strdup(inArgText);
   if (!temp2) return;
 
--- a/toolkit/xre/nsUpdateDriver.cpp
+++ b/toolkit/xre/nsUpdateDriver.cpp
@@ -656,43 +656,43 @@ static void ApplyUpdate(nsIFile *greDir,
     // Launch the updater to either stage or apply an update.
     if (!WinLaunchChild(updaterPathW.get(), argc, argv, nullptr, outpid)) {
       delete[] argv;
       return;
     }
   }
   delete[] argv;
 #elif defined(XP_MACOSX)
-  UpdateDriverSetupMacCommandLine(argc, argv, restart);
-  // We need to detect whether elevation is required for this update. This can
-  // occur when an admin user installs the application, but another admin
-  // user attempts to update (see bug 394984).
-  if (restart && !IsRecursivelyWritable(installDirPath.get())) {
-    if (!LaunchElevatedUpdate(argc, argv, outpid)) {
-      LOG(("Failed to launch elevated update!"));
-      exit(1);
-    }
-    exit(0);
+UpdateDriverSetupMacCommandLine(argc, argv, restart);
+// We need to detect whether elevation is required for this update. This can
+// occur when an admin user installs the application, but another admin
+// user attempts to update (see bug 394984).
+if (restart && !IsRecursivelyWritable(installDirPath.get())) {
+  if (!LaunchElevatedUpdate(argc, argv, outpid)) {
+    LOG(("Failed to launch elevated update!"));
+    exit(1);
   }
+  exit(0);
+}
 
-  if (isStaged) {
-    // Launch the updater to replace the installation with the staged updated.
-    LaunchChildMac(argc, argv);
-  } else {
-    // Launch the updater to either stage or apply an update.
-    LaunchChildMac(argc, argv, outpid);
-  }
+if (isStaged) {
+  // Launch the updater to replace the installation with the staged updated.
+  LaunchChildMac(argc, argv);
+} else {
+  // Launch the updater to either stage or apply an update.
+  LaunchChildMac(argc, argv, outpid);
+}
 #else
-  if (isStaged) {
-    // Launch the updater to replace the installation with the staged updated.
-    PR_CreateProcessDetached(updaterPath.get(), argv, nullptr, nullptr);
-  } else {
-    // Launch the updater to either stage or apply an update.
-    *outpid = PR_CreateProcess(updaterPath.get(), argv, nullptr, nullptr);
-  }
+if (isStaged) {
+  // Launch the updater to replace the installation with the staged updated.
+  PR_CreateProcessDetached(updaterPath.get(), argv, nullptr, nullptr);
+} else {
+  // Launch the updater to either stage or apply an update.
+  *outpid = PR_CreateProcess(updaterPath.get(), argv, nullptr, nullptr);
+}
 #endif
   if (restart) {
     exit(0);
   }
 }
 
 /**
  * Wait briefly to see if a process terminates, then return true if it has.
--- a/widget/cocoa/nsChildView.h
+++ b/widget/cocoa/nsChildView.h
@@ -359,18 +359,18 @@ class nsChildView final : public nsBaseW
   static bool ConvertStatus(nsEventStatus aStatus) {
     return aStatus == nsEventStatus_eConsumeNoDefault;
   }
   virtual nsresult DispatchEvent(mozilla::WidgetGUIEvent* aEvent, nsEventStatus& aStatus) override;
 
   virtual bool WidgetTypeSupportsAcceleration() override;
   virtual bool ShouldUseOffMainThreadCompositing() override;
 
-  virtual void SetCursor(nsCursor aDefaultCursor, imgIContainer* aCursor,
-                         uint32_t aHotspotX, uint32_t aHotspotY) override;
+  virtual void SetCursor(nsCursor aDefaultCursor, imgIContainer* aCursor, uint32_t aHotspotX,
+                         uint32_t aHotspotY) override;
 
   virtual nsresult SetTitle(const nsAString& title) override;
 
   virtual MOZ_MUST_USE nsresult GetAttention(int32_t aCycleCount) override;
 
   virtual bool HasPendingInputEvent() override;
 
   bool SendEventToNativeMenuSystem(NSEvent* aEvent);
--- a/widget/gtk/gtk3drawing.cpp
+++ b/widget/gtk/gtk3drawing.cpp
@@ -405,18 +405,18 @@ int GetGtkHeaderBarButtonLayout(WidgetNo
   // Use a default layout
   if (!decorationLayout) {
     decorationLayout = "menu:minimize,maximize,close";
   }
 
   // "minimize,maximize,close:" layout means buttons are on the opposite
   // titlebar side. close button is always there.
   bool reversedButtonsPlacement = false;
-  const char *closeButton = strstr(decorationLayout, "close");
-  const char *separator = strchr(decorationLayout, ':');
+  const char* closeButton = strstr(decorationLayout, "close");
+  const char* separator = strchr(decorationLayout, ':');
   if (closeButton != nullptr && separator != nullptr) {
     reversedButtonsPlacement = closeButton < separator;
   }
 
   // We support only default button order now:
   // minimize/maximize/close for right placement
   // close/minimize/maximize for left placement
   int activeButtonNums = 0;
--- a/widget/gtk/nsWindow.cpp
+++ b/widget/gtk/nsWindow.cpp
@@ -3303,17 +3303,18 @@ nsresult nsWindow::Create(nsIWidget *aPa
       // Use GL/WebRender compatible visual only when it is necessary, since
       // the visual consumes more memory.
       if (mIsX11Display && shouldAccelerate) {
         auto display = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(mShell));
         auto screen = gtk_widget_get_screen(mShell);
         int screenNumber = GDK_SCREEN_XNUMBER(screen);
         int visualId = 0;
         if (useWebRender) {
-          // WebRender rquests AlphaVisual for making readback to work correctly.
+          // WebRender rquests AlphaVisual for making readback to work
+          // correctly.
           needsAlphaVisual = true;
         }
         if (GLContextGLX::FindVisual(display, screenNumber, useWebRender,
                                      needsAlphaVisual, &visualId)) {
           // If we're using CSD, rendering will go through mContainer, but
           // it will inherit this visual as it is a child of mShell.
           gtk_widget_set_visual(mShell,
                                 gdk_x11_screen_lookup_visual(screen, visualId));
--- a/widget/nsBaseWidget.cpp
+++ b/widget/nsBaseWidget.cpp
@@ -635,18 +635,18 @@ void nsBaseWidget::SetSizeMode(nsSizeMod
 }
 
 //-------------------------------------------------------------------------
 //
 // Get this component cursor
 //
 //-------------------------------------------------------------------------
 
-void nsBaseWidget::SetCursor(nsCursor aCursor,
-                             imgIContainer*, uint32_t, uint32_t) {
+void nsBaseWidget::SetCursor(nsCursor aCursor, imgIContainer*, uint32_t,
+                             uint32_t) {
   // We don't support the cursor image.
   mCursor = aCursor;
 }
 
 //-------------------------------------------------------------------------
 //
 // Window transparency methods
 //
--- a/xpcom/base/MemoryTelemetry.cpp
+++ b/xpcom/base/MemoryTelemetry.cpp
@@ -235,17 +235,17 @@ nsresult MemoryTelemetry::GatherReports(
 
 #define RECORD(id, metric, units)                                       \
   do {                                                                  \
     int64_t amt;                                                        \
     nsresult rv = mgr->Get##metric(&amt);                               \
     if (NS_SUCCEEDED(rv)) {                                             \
       HandleMemoryReport(Telemetry::id, nsIMemoryReporter::units, amt); \
     } else if (rv != NS_ERROR_NOT_AVAILABLE) {                          \
-      NS_WARNING("Failed to retrieve memory telemetry for " # metric);  \
+      NS_WARNING("Failed to retrieve memory telemetry for " #metric);   \
     }                                                                   \
   } while (0)
 
   // GHOST_WINDOWS is opt-out as of Firefox 55
   RECORD(GHOST_WINDOWS, GhostWindows, UNITS_COUNT);
 
   if (!Telemetry::CanRecordReleaseData()) {
     return NS_OK;
--- a/xpcom/base/nsTraceRefcnt.cpp
+++ b/xpcom/base/nsTraceRefcnt.cpp
@@ -49,17 +49,17 @@
 
 #ifdef MOZ_DMD
 #  include "base/process_util.h"
 #  include "nsMemoryInfoDumper.h"
 #endif
 
 // dynamic_cast<void*> is not supported on Windows without RTTI.
 #ifndef _WIN32
-#define HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR
+#  define HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "prthread.h"
 
 // We use a spin lock instead of a regular mutex because this lock is usually
 // only held for a very short time, and gets grabbed at a very high frequency
--- a/xpcom/build/XPCOMInit.cpp
+++ b/xpcom/build/XPCOMInit.cpp
@@ -154,22 +154,20 @@ static NS_DEFINE_CID(kINIParserFactoryCI
 
 static already_AddRefed<nsIFactory> CreateINIParserFactory(
     const mozilla::Module& aModule, const mozilla::Module::CIDEntry& aEntry) {
   nsCOMPtr<nsIFactory> f = new nsINIParserFactory();
   return f.forget();
 }
 
 const mozilla::Module::CIDEntry kXPCOMCIDEntries[] = {
-    {&kINIParserFactoryCID, false, CreateINIParserFactory},
-    {nullptr}};
+    {&kINIParserFactoryCID, false, CreateINIParserFactory}, {nullptr}};
 
 const mozilla::Module::ContractIDEntry kXPCOMContracts[] = {
-    {NS_INIPARSERFACTORY_CONTRACTID, &kINIParserFactoryCID},
-    {nullptr}};
+    {NS_INIPARSERFACTORY_CONTRACTID, &kINIParserFactoryCID}, {nullptr}};
 
 const mozilla::Module kXPCOMModule = {
     mozilla::Module::kVersion,
     kXPCOMCIDEntries,
     kXPCOMContracts,
     nullptr,
     nullptr,
     nullptr,
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -122,21 +122,22 @@ nsresult nsGetServiceFromCategory::opera
 }
 
 namespace {
 
 class AutoIDString : public nsAutoCStringN<NSID_LENGTH> {
  public:
   explicit AutoIDString(const nsID& aID) {
     SetLength(NSID_LENGTH - 1);
-    aID.ToProvidedString(*reinterpret_cast<char(*)[NSID_LENGTH]>(BeginWriting()));
+    aID.ToProvidedString(
+        *reinterpret_cast<char(*)[NSID_LENGTH]>(BeginWriting()));
   }
 };
 
-}
+}  // namespace
 
 namespace mozilla {
 namespace xpcom {
 
 using ProcessSelector = Module::ProcessSelector;
 
 // Note: These must be kept in sync with the ProcessSelector definition in
 // Module.h.
@@ -457,20 +458,24 @@ nsresult nsComponentManagerImpl::Init() 
     gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_GPU_PROCESS)] =
         ProcessSelectorMatches(ProcessSelector::ALLOW_IN_GPU_PROCESS);
     gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_VR_PROCESS)] =
         ProcessSelectorMatches(ProcessSelector::ALLOW_IN_VR_PROCESS);
     gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_SOCKET_PROCESS)] =
         ProcessSelectorMatches(ProcessSelector::ALLOW_IN_SOCKET_PROCESS);
     gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_GPU_AND_VR_PROCESS)] =
         ProcessSelectorMatches(ProcessSelector::ALLOW_IN_GPU_AND_VR_PROCESS);
-    gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_GPU_AND_SOCKET_PROCESS)] =
-        ProcessSelectorMatches(ProcessSelector::ALLOW_IN_GPU_AND_SOCKET_PROCESS);
-    gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS)] =
-        ProcessSelectorMatches(ProcessSelector::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS);
+    gProcessMatchTable[size_t(
+        ProcessSelector::ALLOW_IN_GPU_AND_SOCKET_PROCESS)] =
+        ProcessSelectorMatches(
+            ProcessSelector::ALLOW_IN_GPU_AND_SOCKET_PROCESS);
+    gProcessMatchTable[size_t(
+        ProcessSelector::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS)] =
+        ProcessSelectorMatches(
+            ProcessSelector::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS);
   }
 
   MOZ_ASSERT(NOT_INITIALIZED == mStatus);
 
   nsCOMPtr<nsIFile> greDir = GetLocationFromDirectoryService(NS_GRE_DIR);
   nsCOMPtr<nsIFile> appDir =
       GetLocationFromDirectoryService(NS_XPCOM_CURRENT_PROCESS_DIR);
 
@@ -809,18 +814,17 @@ void nsComponentManagerImpl::ManifestCom
   if (Maybe<EntryWrapper> f = LookupByCID(lock, cid)) {
     nsCString existing(f->ModuleDescription());
 
     lock.Unlock();
 
     LogMessageWithContext(
         aCx.mFile, aLineNo,
         "Trying to re-register CID '%s' already registered by %s.",
-        AutoIDString(cid).get(),
-        existing.get());
+        AutoIDString(cid).get(), existing.get());
     return;
   }
 
   KnownModule* km;
 
   km = mKnownModules.Get(hash);
   if (!km) {
     km = new KnownModule(fl);
@@ -1123,18 +1127,17 @@ nsComponentManagerImpl::CreateInstance(c
   // shutdown -- whether it's available or not would depend on the order it
   // occurs in the list
   if (gXPCOMShuttingDown) {
     // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
     fprintf(stderr,
             "Creating new instance on shutdown. Denied.\n"
             "         CID: %s\n         IID: %s\n",
-            AutoIDString(aClass).get(),
-            AutoIDString(aIID).get());
+            AutoIDString(aClass).get(), AutoIDString(aIID).get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
     return NS_ERROR_UNEXPECTED;
   }
 
   if (!aResult) {
     return NS_ERROR_NULL_POINTER;
   }
   *aResult = nullptr;
@@ -1425,48 +1428,45 @@ nsComponentManagerImpl::GetService(const
   // shutdown -- whether it's available or not would depend on the order it
   // occurs in the list
   if (gXPCOMShuttingDown) {
     // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
     fprintf(stderr,
             "Getting service on shutdown. Denied.\n"
             "         CID: %s\n         IID: %s\n",
-            AutoIDString(aClass).get(),
-            AutoIDString(aIID).get());
+            AutoIDString(aClass).get(), AutoIDString(aIID).get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
     return NS_ERROR_UNEXPECTED;
   }
 
   MutexLock lock(mLock);
 
   Maybe<EntryWrapper> entry = LookupByCID(lock, aClass);
   if (!entry) {
     return NS_ERROR_FACTORY_NOT_REGISTERED;
   }
 
   return GetServiceLocked(lock, *entry, aIID, aResult);
 }
 
-nsresult
-nsComponentManagerImpl::GetService(ModuleID aId, const nsIID& aIID,
-                                   void** aResult) {
+nsresult nsComponentManagerImpl::GetService(ModuleID aId, const nsIID& aIID,
+                                            void** aResult) {
   const auto& entry = gStaticModules[size_t(aId)];
 
   // test this first, since there's no point in returning a service during
   // shutdown -- whether it's available or not would depend on the order it
   // occurs in the list
   if (gXPCOMShuttingDown) {
     // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
     fprintf(stderr,
             "Getting service on shutdown. Denied.\n"
             "         CID: %s\n         IID: %s\n",
-            AutoIDString(entry.CID()).get(),
-            AutoIDString(aIID).get());
+            AutoIDString(entry.CID()).get(), AutoIDString(aIID).get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
     return NS_ERROR_UNEXPECTED;
   }
 
   MutexLock lock(mLock);
 
   if (!entry.Active()) {
     return NS_ERROR_FACTORY_NOT_REGISTERED;
@@ -1497,27 +1497,25 @@ nsComponentManagerImpl::IsServiceInstant
   // shutdown -- whether it's available or not would depend on the order it
   // occurs in the list
   if (gXPCOMShuttingDown) {
     // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
     fprintf(stderr,
             "Checking for service on shutdown. Denied.\n"
             "         CID: %s\n         IID: %s\n",
-            AutoIDString(aClass).get(),
-            AutoIDString(aIID).get());
+            AutoIDString(aClass).get(), AutoIDString(aIID).get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
     return NS_ERROR_UNEXPECTED;
   }
 
   if (Maybe<EntryWrapper> entry = LookupByCID(aClass)) {
     if (auto* service = entry->ServiceInstance()) {
       nsCOMPtr<nsISupports> instance;
-      nsresult rv = service->QueryInterface(
-          aIID, getter_AddRefs(instance));
+      nsresult rv = service->QueryInterface(aIID, getter_AddRefs(instance));
       *aResult = (instance != nullptr);
       return rv;
     }
   }
 
   *aResult = false;
   return NS_OK;
 }
@@ -1541,18 +1539,17 @@ nsComponentManagerImpl::IsServiceInstant
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
     return NS_ERROR_UNEXPECTED;
   }
 
   if (Maybe<EntryWrapper> entry =
           LookupByContractID(nsDependentCString(aContractID))) {
     if (auto* service = entry->ServiceInstance()) {
       nsCOMPtr<nsISupports> instance;
-      nsresult rv = service->QueryInterface(
-          aIID, getter_AddRefs(instance));
+      nsresult rv = service->QueryInterface(aIID, getter_AddRefs(instance));
       *aResult = (instance != nullptr);
       return rv;
     }
   }
 
   *aResult = false;
   return NS_OK;
 }
--- a/xpcom/components/nsComponentManager.h
+++ b/xpcom/components/nsComponentManager.h
@@ -158,17 +158,18 @@ class nsComponentManagerImpl final : pub
   mozilla::Maybe<EntryWrapper> LookupByCID(const nsID& aCID);
   mozilla::Maybe<EntryWrapper> LookupByCID(const MutexLock&, const nsID& aCID);
 
   mozilla::Maybe<EntryWrapper> LookupByContractID(
       const nsACString& aContractID);
   mozilla::Maybe<EntryWrapper> LookupByContractID(
       const MutexLock&, const nsACString& aContractID);
 
-  nsresult GetService(mozilla::xpcom::ModuleID, const nsIID& aIID, void** aResult);
+  nsresult GetService(mozilla::xpcom::ModuleID, const nsIID& aIID,
+                      void** aResult);
 
   static void InitializeStaticModules();
   static void InitializeModuleLocations();
 
   struct ComponentLocation {
     NSLocationType type;
     mozilla::FileLocation location;
   };
--- a/xpcom/threads/BlockingResourceBase.cpp
+++ b/xpcom/threads/BlockingResourceBase.cpp
@@ -39,17 +39,18 @@ namespace mozilla {
 // static members
 const char* const BlockingResourceBase::kResourceTypeName[] = {
     // needs to be kept in sync with BlockingResourceType
     "Mutex", "ReentrantMonitor", "CondVar", "RecursiveMutex"};
 
 #ifdef DEBUG
 
 PRCallOnceType BlockingResourceBase::sCallOnce;
-MOZ_THREAD_LOCAL(BlockingResourceBase*) BlockingResourceBase::sResourceAcqnChainFront;
+MOZ_THREAD_LOCAL(BlockingResourceBase*)
+BlockingResourceBase::sResourceAcqnChainFront;
 BlockingResourceBase::DDT* BlockingResourceBase::sDeadlockDetector;
 
 void BlockingResourceBase::StackWalkCallback(uint32_t aFrameNumber, void* aPc,
                                              void* aSp, void* aClosure) {
 #  ifndef MOZ_CALLSTACK_DISABLED
   AcquisitionState* state = (AcquisitionState*)aClosure;
   state->AppendElement(aPc);
 #  endif