Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Sat, 16 Feb 2019 20:20:37 +0100
changeset 459675 9adeff2c423fc4ac047b4ddbdbb9b8e64ce7fdac
parent 459674 d6a48567ce7f03dcec284d66fc6612c25d575b42
child 459676 f65fff3dc23cb51c9245bb3a29603ef95de4bb7c
push id111985
push usersledru@mozilla.com
push dateSat, 16 Feb 2019 20:07:50 +0000
treeherdermozilla-inbound@9adeff2c423f [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 Summary: # ignore-this-changeset Reviewers: Ehsan Reviewed By: Ehsan Subscribers: emilio, jandem, bbouvier, jya Bug #: 1519636 Differential Revision: https://phabricator.services.mozilla.com/D20062
dom/base/TimeoutManager.cpp
dom/base/nsFrameLoaderOwner.cpp
dom/base/nsFrameLoaderOwner.h
dom/base/nsOpenURIInFrameParams.cpp
dom/base/nsOpenURIInFrameParams.h
dom/html/nsGenericHTMLFrameElement.h
dom/ipc/ContentChild.cpp
dom/ipc/ContentParent.cpp
dom/ipc/TabParent.cpp
dom/media/MediaInfo.cpp
dom/media/ipc/RemoteAudioDecoder.cpp
dom/media/ipc/RemoteAudioDecoder.h
dom/media/ipc/RemoteDecoderChild.cpp
dom/media/ipc/RemoteDecoderManagerChild.cpp
dom/media/ipc/RemoteDecoderManagerChild.h
dom/media/ipc/RemoteDecoderManagerParent.cpp
dom/media/ipc/RemoteDecoderManagerParent.h
dom/media/ipc/RemoteDecoderModule.cpp
dom/media/ipc/RemoteDecoderParent.cpp
dom/media/ipc/RemoteVideoDecoder.cpp
dom/media/ipc/RemoteVideoDecoder.h
dom/media/platforms/agnostic/AgnosticDecoderModule.cpp
dom/xul/nsXULElement.cpp
gfx/layers/ImageTypes.h
gfx/layers/wr/WebRenderCommandBuilder.cpp
gfx/layers/wr/WebRenderUserData.cpp
gfx/layers/wr/WebRenderUserData.h
ipc/mscom/ProcessRuntime.cpp
ipc/mscom/mozglue/ProcessRuntimeShared.cpp
ipc/mscom/mozglue/ProcessRuntimeShared.h
js/public/MemoryMetrics.h
js/public/ProtoKey.h
js/public/Value.h
js/src/NamespaceImports.h
js/src/devtools/rootAnalysis/t/hazards/source.cpp
js/src/frontend/ParseNode.h
js/src/frontend/TokenStream.h
js/src/gc/AtomMarking.cpp
js/src/gc/GC.cpp
js/src/gc/Nursery.cpp
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jit/VMFunctions.cpp
js/src/jsapi-tests/testGCExactRooting.cpp
js/src/jsapi.h
js/src/jspubtd.h
js/src/vm/EqualityOperations.cpp
js/src/vm/TypeSet.h
js/src/wasm/WasmBaselineCompile.cpp
js/src/wasm/WasmGC.cpp
js/src/wasm/WasmGC.h
js/src/wasm/WasmIonCompile.cpp
js/src/wasm/WasmStubs.cpp
layout/base/nsCSSFrameConstructor.cpp
layout/forms/nsRangeFrame.cpp
layout/generic/WritingModes.h
layout/generic/nsGfxScrollFrame.cpp
layout/style/Loader.cpp
layout/style/nsMediaFeatures.cpp
netwerk/base/nsSocketTransport2.cpp
toolkit/components/places/tests/gtest/places_test_harness_tail.h
toolkit/components/telemetry/core/Telemetry.cpp
toolkit/system/gnome/nsGConfService.h
toolkit/xre/nsAppRunner.cpp
tools/profiler/core/platform.cpp
tools/profiler/public/GeckoProfiler.h
tools/profiler/public/ProfilerMarkerPayload.h
xpcom/components/nsComponentManager.cpp
xpcom/ds/nsObserverService.cpp
--- a/dom/base/TimeoutManager.cpp
+++ b/dom/base/TimeoutManager.cpp
@@ -793,21 +793,22 @@ void TimeoutManager::RunTimeout(const Ti
         if (elapsed >= initialTimeLimit) {
           nextDeadline = timeout->When();
           break;
         }
       }
     }
   }
   if (aProcessIdle) {
-    MOZ_LOG(gTimeoutLog, LogLevel::Debug,
-            ("Running %u deferred timeouts on idle (TimeoutManager=%p), "
-             "nextDeadline = %gms from now",
-             numTimersToRun, this,
-             nextDeadline.IsNull() ? 0.0 : (nextDeadline - now).ToMilliseconds()));
+    MOZ_LOG(
+        gTimeoutLog, LogLevel::Debug,
+        ("Running %u deferred timeouts on idle (TimeoutManager=%p), "
+         "nextDeadline = %gms from now",
+         numTimersToRun, this,
+         nextDeadline.IsNull() ? 0.0 : (nextDeadline - now).ToMilliseconds()));
   }
 
   now = TimeStamp::Now();
 
   // Wherever we stopped in the timer list, schedule the executor to
   // run for the next unexpired deadline.  Note, this *must* be done
   // before we start executing any content script handlers.  If one
   // of them spins the event loop the executor must already be scheduled
--- a/dom/base/nsFrameLoaderOwner.cpp
+++ b/dom/base/nsFrameLoaderOwner.cpp
@@ -2,17 +2,15 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsFrameLoaderOwner.h"
 #include "nsFrameLoader.h"
 
-already_AddRefed<nsFrameLoader> nsFrameLoaderOwner::GetFrameLoader()
-{
+already_AddRefed<nsFrameLoader> nsFrameLoaderOwner::GetFrameLoader() {
   return do_AddRef(mFrameLoader);
 }
 
-void nsFrameLoaderOwner::SetFrameLoader(nsFrameLoader* aNewFrameLoader)
-{
+void nsFrameLoaderOwner::SetFrameLoader(nsFrameLoader* aNewFrameLoader) {
   mFrameLoader = aNewFrameLoader;
 }
--- a/dom/base/nsFrameLoaderOwner.h
+++ b/dom/base/nsFrameLoaderOwner.h
@@ -19,25 +19,24 @@ class nsFrameLoader;
 
 // Mixin that handles ownership of nsFrameLoader for Frame elements
 // (XULFrameElement, HTMLI/FrameElement, etc...). Manages information when doing
 // FrameLoader swaps.
 //
 // This class is considered an XPCOM mixin. This means that while we inherit
 // from ISupports in order to be QI'able, we expect the classes that inherit
 // nsFrameLoaderOwner to actually implement ISupports for us.
-class nsFrameLoaderOwner : public nsISupports
-{
-public:
-
+class nsFrameLoaderOwner : public nsISupports {
+ public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_FRAMELOADEROWNER_IID)
 
   nsFrameLoaderOwner() = default;
   already_AddRefed<nsFrameLoader> GetFrameLoader();
   void SetFrameLoader(nsFrameLoader* aNewFrameLoader);
-protected:
+
+ protected:
   virtual ~nsFrameLoaderOwner() = default;
   RefPtr<nsFrameLoader> mFrameLoader;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsFrameLoaderOwner, NS_FRAMELOADEROWNER_IID)
 
-#endif //nsFrameLoaderOwner_h_
+#endif  // nsFrameLoaderOwner_h_
--- a/dom/base/nsOpenURIInFrameParams.cpp
+++ b/dom/base/nsOpenURIInFrameParams.cpp
@@ -15,18 +15,17 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTION(nsOpenURIInFrameParams, mOpenerBrowser)
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsOpenURIInFrameParams)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsOpenURIInFrameParams)
 
 nsOpenURIInFrameParams::nsOpenURIInFrameParams(
-    const mozilla::OriginAttributes& aOriginAttributes,
-    Element* aOpener)
+    const mozilla::OriginAttributes& aOriginAttributes, Element* aOpener)
     : mOpenerOriginAttributes(aOriginAttributes),
       mOpenerBrowser(aOpener),
       mReferrerPolicy(mozilla::net::RP_Unset) {}
 
 nsOpenURIInFrameParams::~nsOpenURIInFrameParams() {}
 
 NS_IMETHODIMP
 nsOpenURIInFrameParams::GetReferrer(nsAString& aReferrer) {
@@ -69,18 +68,17 @@ nsOpenURIInFrameParams::GetTriggeringPri
 NS_IMETHODIMP
 nsOpenURIInFrameParams::SetTriggeringPrincipal(
     nsIPrincipal* aTriggeringPrincipal) {
   NS_ENSURE_TRUE(aTriggeringPrincipal, NS_ERROR_INVALID_ARG);
   mTriggeringPrincipal = aTriggeringPrincipal;
   return NS_OK;
 }
 
-nsresult
-nsOpenURIInFrameParams::GetOpenerBrowser(Element** aOpenerBrowser) {
+nsresult nsOpenURIInFrameParams::GetOpenerBrowser(Element** aOpenerBrowser) {
   RefPtr<Element> owner = mOpenerBrowser;
   owner.forget(aOpenerBrowser);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsOpenURIInFrameParams::GetOpenerOriginAttributes(
     JSContext* aCx, JS::MutableHandle<JS::Value> aValue) {
--- a/dom/base/nsOpenURIInFrameParams.h
+++ b/dom/base/nsOpenURIInFrameParams.h
@@ -16,18 +16,17 @@ class OriginAttributes;
 
 class nsOpenURIInFrameParams final : public nsIOpenURIInFrameParams {
  public:
   NS_DECL_CYCLE_COLLECTION_CLASS(nsOpenURIInFrameParams)
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_NSIOPENURIINFRAMEPARAMS
 
   explicit nsOpenURIInFrameParams(
-      const mozilla::OriginAttributes& aOriginAttributes,
-      Element* aOpener);
+      const mozilla::OriginAttributes& aOriginAttributes, Element* aOpener);
 
  private:
   ~nsOpenURIInFrameParams();
 
   mozilla::OriginAttributes mOpenerOriginAttributes;
   RefPtr<Element> mOpenerBrowser;
   nsString mReferrer;
   uint32_t mReferrerPolicy;
--- a/dom/html/nsGenericHTMLFrameElement.h
+++ b/dom/html/nsGenericHTMLFrameElement.h
@@ -106,16 +106,17 @@ class nsGenericHTMLFrameElement : public
   nsIPrincipal* GetSrcTriggeringPrincipal() const {
     return mSrcTriggeringPrincipal;
   }
 
   // Needed for nsBrowserElement
   already_AddRefed<nsFrameLoader> GetFrameLoader() override {
     return nsFrameLoaderOwner::GetFrameLoader();
   }
+
  protected:
   virtual ~nsGenericHTMLFrameElement();
 
   // This doesn't really ensure a frame loader in all cases, only when
   // it makes sense.
   void EnsureFrameLoader();
   void LoadSrc();
   Document* GetContentDocument(nsIPrincipal& aSubjectPrincipal);
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -3588,30 +3588,31 @@ PContentChild::Result ContentChild::OnMe
     MOZ_ASSERT(!aMsg.is_reply());
 
     LSObject::OnSyncMessageHandled();
   }
 
   return result;
 }
 
-mozilla::ipc::IPCResult ContentChild::RecvWindowClose(
-    BrowsingContext* aContext, bool aTrustedCaller) {
+mozilla::ipc::IPCResult ContentChild::RecvWindowClose(BrowsingContext* aContext,
+                                                      bool aTrustedCaller) {
   if (!aContext) {
     MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
             ("ChildIPC: Trying to send a message to dead or detached context"));
     return IPC_OK();
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> window = aContext->GetDOMWindow();
   nsGlobalWindowOuter::Cast(window)->CloseOuter(aTrustedCaller);
   return IPC_OK();
 }
 
-mozilla::ipc::IPCResult ContentChild::RecvWindowFocus(BrowsingContext* aContext) {
+mozilla::ipc::IPCResult ContentChild::RecvWindowFocus(
+    BrowsingContext* aContext) {
   if (!aContext) {
     MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
             ("ChildIPC: Trying to send a message to dead or detached context"));
     return IPC_OK();
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> window = aContext->GetDOMWindow();
   nsGlobalWindowOuter::Cast(window)->FocusOuter();
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -4750,18 +4750,17 @@ mozilla::ipc::IPCResult ContentParent::C
   // dimensions. See bug 1358712 for details.
   //
   // This involves doing a bit of gymnastics in order to get at the FrameLoader,
   // so we scope this to avoid polluting the main function scope.
   {
     nsCOMPtr<Element> frameElement =
         TabParent::GetFrom(aNewTabParent)->GetOwnerElement();
     MOZ_ASSERT(frameElement);
-    RefPtr<nsFrameLoaderOwner> frameLoaderOwner =
-        do_QueryObject(frameElement);
+    RefPtr<nsFrameLoaderOwner> frameLoaderOwner = do_QueryObject(frameElement);
     MOZ_ASSERT(frameLoaderOwner);
     RefPtr<nsFrameLoader> frameLoader = frameLoaderOwner->GetFrameLoader();
     MOZ_ASSERT(frameLoader);
     frameLoader->ForceLayoutIfNecessary();
   }
 
   // If we were passed a name for the window which would override the default,
   // we should send it down to the new tab.
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -1742,17 +1742,17 @@ mozilla::ipc::IPCResult TabParent::RecvS
   if (!xulBrowserWindow) {
     return IPC_OK();
   }
 
   // ShowTooltip will end up accessing XULElement properties in JS (specifically
   // BoxObject). However, to get it to JS, we need to make sure we're a
   // nsFrameLoaderOwner, which implies we're a XULFrameElement. We can then
   // safely pass Element into JS.
-  RefPtr<nsFrameLoaderOwner> flo  = do_QueryObject(mFrameElement);
+  RefPtr<nsFrameLoaderOwner> flo = do_QueryObject(mFrameElement);
   if (!flo) return IPC_OK();
 
   nsCOMPtr<Element> el = do_QueryInterface(flo);
   if (!el) return IPC_OK();
 
   xulBrowserWindow->ShowTooltip(aX, aY, aTooltip, aDirection, el);
   return IPC_OK();
 }
@@ -2463,18 +2463,17 @@ already_AddRefed<nsFrameLoader> TabParen
   if (mIsDestroyed && !aUseCachedFrameLoaderAfterDestroy) {
     return nullptr;
   }
 
   if (mFrameLoader) {
     RefPtr<nsFrameLoader> fl = mFrameLoader;
     return fl.forget();
   }
-  RefPtr<nsFrameLoaderOwner> frameLoaderOwner =
-      do_QueryObject(mFrameElement);
+  RefPtr<nsFrameLoaderOwner> frameLoaderOwner = do_QueryObject(mFrameElement);
   return frameLoaderOwner ? frameLoaderOwner->GetFrameLoader() : nullptr;
 }
 
 void TabParent::TryCacheDPIAndScale() {
   if (mDPI > 0) {
     return;
   }
 
@@ -3448,17 +3447,17 @@ mozilla::ipc::IPCResult TabParent::RecvG
   nsCOMPtr<nsIWidget> widget = GetWidget();
   if (widget) {
     widget->GetSystemFont(*aFontName);
   }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TabParent::RecvRootBrowsingContext(
-  BrowsingContext* aBrowsingContext) {
+    BrowsingContext* aBrowsingContext) {
   MOZ_ASSERT(!mBrowsingContext, "May only set browsing context once!");
   mBrowsingContext = CanonicalBrowsingContext::Cast(aBrowsingContext);
   MOZ_ASSERT(mBrowsingContext, "Invalid ID!");
   return IPC_OK();
 }
 
 NS_IMETHODIMP
 FakeChannel::OnAuthAvailable(nsISupports* aContext,
--- a/dom/media/MediaInfo.cpp
+++ b/dom/media/MediaInfo.cpp
@@ -19,54 +19,41 @@ const char* TrackTypeToStr(TrackInfo::Tr
     case TrackInfo::kTextTrack:
       return "Text";
     default:
       return "Unknown";
   }
 }
 
 bool TrackInfo::IsEqualTo(const TrackInfo& rhs) const {
-  return (mId == rhs.mId &&
-          mKind == rhs.mKind &&
-          mLabel == rhs.mLabel &&
-          mLanguage == rhs.mLanguage &&
-          mEnabled == rhs.mEnabled &&
-          mTrackId == rhs.mTrackId &&
-          mMimeType == rhs.mMimeType &&
-          mDuration == rhs.mDuration &&
-          mMediaTime == rhs.mMediaTime &&
-          mCrypto.mCryptoScheme == rhs.mCrypto.mCryptoScheme &&
-          mCrypto.mIVSize == rhs.mCrypto.mIVSize &&
-          mCrypto.mKeyId == rhs.mCrypto.mKeyId &&
-          mCrypto.mCryptByteBlock == rhs.mCrypto.mCryptByteBlock &&
-          mCrypto.mSkipByteBlock == rhs.mCrypto.mSkipByteBlock &&
-          mCrypto.mConstantIV == rhs.mCrypto.mConstantIV &&
-          mTags == rhs.mTags &&
-          mIsRenderedExternally == rhs.mIsRenderedExternally &&
-          mType == rhs.mType);
+  return (
+      mId == rhs.mId && mKind == rhs.mKind && mLabel == rhs.mLabel &&
+      mLanguage == rhs.mLanguage && mEnabled == rhs.mEnabled &&
+      mTrackId == rhs.mTrackId && mMimeType == rhs.mMimeType &&
+      mDuration == rhs.mDuration && mMediaTime == rhs.mMediaTime &&
+      mCrypto.mCryptoScheme == rhs.mCrypto.mCryptoScheme &&
+      mCrypto.mIVSize == rhs.mCrypto.mIVSize &&
+      mCrypto.mKeyId == rhs.mCrypto.mKeyId &&
+      mCrypto.mCryptByteBlock == rhs.mCrypto.mCryptByteBlock &&
+      mCrypto.mSkipByteBlock == rhs.mCrypto.mSkipByteBlock &&
+      mCrypto.mConstantIV == rhs.mCrypto.mConstantIV && mTags == rhs.mTags &&
+      mIsRenderedExternally == rhs.mIsRenderedExternally && mType == rhs.mType);
 }
 
 bool VideoInfo::operator==(const VideoInfo& rhs) const {
-  return (TrackInfo::IsEqualTo(rhs) &&
-          mDisplay == rhs.mDisplay &&
-          mStereoMode == rhs.mStereoMode &&
-          mImage == rhs.mImage &&
+  return (TrackInfo::IsEqualTo(rhs) && mDisplay == rhs.mDisplay &&
+          mStereoMode == rhs.mStereoMode && mImage == rhs.mImage &&
           *mCodecSpecificConfig == *rhs.mCodecSpecificConfig &&
-          *mExtraData == *rhs.mExtraData &&
-          mRotation == rhs.mRotation &&
-          mColorDepth == rhs.mColorDepth &&
-          mImageRect == rhs.mImageRect &&
+          *mExtraData == *rhs.mExtraData && mRotation == rhs.mRotation &&
+          mColorDepth == rhs.mColorDepth && mImageRect == rhs.mImageRect &&
           mAlphaPresent == rhs.mAlphaPresent);
 }
 
 bool AudioInfo::operator==(const AudioInfo& rhs) const {
-  return (TrackInfo::IsEqualTo(rhs) &&
-          mRate == rhs.mRate &&
-          mChannels == rhs.mChannels &&
-          mChannelMap == rhs.mChannelMap &&
-          mBitDepth == rhs.mBitDepth &&
-          mProfile == rhs.mProfile &&
+  return (TrackInfo::IsEqualTo(rhs) && mRate == rhs.mRate &&
+          mChannels == rhs.mChannels && mChannelMap == rhs.mChannelMap &&
+          mBitDepth == rhs.mBitDepth && mProfile == rhs.mProfile &&
           mExtendedProfile == rhs.mExtendedProfile &&
           *mCodecSpecificConfig == *rhs.mCodecSpecificConfig &&
           *mExtraData == *rhs.mExtraData);
 }
 
 }  // namespace mozilla
--- a/dom/media/ipc/RemoteAudioDecoder.cpp
+++ b/dom/media/ipc/RemoteAudioDecoder.cpp
@@ -25,21 +25,18 @@ mozilla::ipc::IPCResult RemoteAudioDecod
          aData.buffer().Size<uint8_t>());
 
   DeallocShmem(aData.buffer());
 
   RefPtr<AudioData> audio =
       new AudioData(aData.base().offset(),
                     media::TimeUnit::FromMicroseconds(aData.base().time()),
                     media::TimeUnit::FromMicroseconds(aData.base().duration()),
-                    aData.base().frames(),
-                    std::move(alignedAudioBuffer),
-                    aData.channels(),
-                    aData.rate(),
-                    aData.channelMap());
+                    aData.base().frames(), std::move(alignedAudioBuffer),
+                    aData.channels(), aData.rate(), aData.channelMap());
 
   mDecodedData.AppendElement(std::move(audio));
   return IPC_OK();
 }
 
 MediaResult RemoteAudioDecoderChild::InitIPDL(
     const AudioInfo& aAudioInfo,
     const CreateDecoderParams::OptionSet& aOptions) {
@@ -57,35 +54,29 @@ MediaResult RemoteAudioDecoderChild::Ini
   if (!manager->CanSend()) {
     return MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
                        RESULT_DETAIL("RemoteDecoderManager unable to send."));
   }
 
   mIPDLSelfRef = this;
   bool success = false;
   nsCString errorDescription;
-  if (manager->SendPRemoteDecoderConstructor(this,
-                                             aAudioInfo,
-                                             aOptions,
-                                             &success,
-                                             &errorDescription)) {
+  if (manager->SendPRemoteDecoderConstructor(this, aAudioInfo, aOptions,
+                                             &success, &errorDescription)) {
     mCanSend = true;
   }
 
   return success ? MediaResult(NS_OK)
                  : MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR, errorDescription);
 }
 
 RemoteAudioDecoderParent::RemoteAudioDecoderParent(
-    RemoteDecoderManagerParent* aParent,
-    const AudioInfo& aAudioInfo,
+    RemoteDecoderManagerParent* aParent, const AudioInfo& aAudioInfo,
     const CreateDecoderParams::OptionSet& aOptions,
-    TaskQueue* aManagerTaskQueue,
-    TaskQueue* aDecodeTaskQueue,
-    bool* aSuccess,
+    TaskQueue* aManagerTaskQueue, TaskQueue* aDecodeTaskQueue, bool* aSuccess,
     nsCString* aErrorDescription)
     : RemoteDecoderParent(aParent, aManagerTaskQueue, aDecodeTaskQueue),
       mAudioInfo(aAudioInfo) {
   CreateDecoderParams params(mAudioInfo);
   params.mTaskQueue = mDecodeTaskQueue;
   params.mOptions = aOptions;
   MediaResult error(NS_OK);
   params.mError = &error;
@@ -119,24 +110,19 @@ void RemoteAudioDecoderParent::ProcessDe
     if (AllocShmem(audio->mAudioData.Size(), Shmem::SharedMemory::TYPE_BASIC,
                    &buffer) &&
         audio->mAudioData.Size() == buffer.Size<uint8_t>()) {
       memcpy(buffer.get<uint8_t>(), audio->mAudioData.Data(),
              audio->mAudioData.Size());
     }
 
     RemoteAudioDataIPDL output(
-        MediaDataIPDL(data->mOffset,
-                      data->mTime.ToMicroseconds(),
+        MediaDataIPDL(data->mOffset, data->mTime.ToMicroseconds(),
                       data->mTimecode.ToMicroseconds(),
-                      data->mDuration.ToMicroseconds(),
-                      data->mFrames,
+                      data->mDuration.ToMicroseconds(), data->mFrames,
                       data->mKeyframe),
-        audio->mChannels,
-        audio->mRate,
-        audio->mChannelMap,
-        buffer);
+        audio->mChannels, audio->mRate, audio->mChannelMap, buffer);
 
     Unused << SendOutput(output);
   }
 }
 
 }  // namespace mozilla
--- a/dom/media/ipc/RemoteAudioDecoder.h
+++ b/dom/media/ipc/RemoteAudioDecoder.h
@@ -24,18 +24,17 @@ class RemoteAudioDecoderChild final : pu
 };
 
 class RemoteAudioDecoderParent final : public RemoteDecoderParent {
  public:
   RemoteAudioDecoderParent(RemoteDecoderManagerParent* aParent,
                            const AudioInfo& aAudioInfo,
                            const CreateDecoderParams::OptionSet& aOptions,
                            TaskQueue* aManagerTaskQueue,
-                           TaskQueue* aDecodeTaskQueue,
-                           bool* aSuccess,
+                           TaskQueue* aDecodeTaskQueue, bool* aSuccess,
                            nsCString* aErrorDescription);
 
  protected:
   void ProcessDecodedData(const MediaDataDecoder::DecodedData& aData) override;
 
  private:
   // Can only be accessed from the manager thread
   // Note: we can't keep a reference to the original AudioInfo here
--- a/dom/media/ipc/RemoteDecoderChild.cpp
+++ b/dom/media/ipc/RemoteDecoderChild.cpp
@@ -36,18 +36,17 @@ mozilla::ipc::IPCResult RemoteDecoderChi
   mDecodedData = MediaDataDecoder::DecodedData();
   mDecodePromise.RejectIfExists(aError, __func__);
   mDrainPromise.RejectIfExists(aError, __func__);
   mFlushPromise.RejectIfExists(aError, __func__);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult RemoteDecoderChild::RecvInitComplete(
-    const TrackInfo::TrackType& trackType,
-    const nsCString& aDecoderDescription,
+    const TrackInfo::TrackType& trackType, const nsCString& aDecoderDescription,
     const ConversionRequired& aConversion) {
   AssertOnManagerThread();
   mInitPromise.ResolveIfExists(trackType, __func__);
   mInitialized = true;
   mDescription = aDecoderDescription;
   mConversion = aConversion;
   return IPC_OK();
 }
@@ -108,21 +107,19 @@ RefPtr<MediaDataDecoder::DecodePromise> 
   if (!AllocShmem(aSample->Size(), Shmem::SharedMemory::TYPE_BASIC, &buffer)) {
     return MediaDataDecoder::DecodePromise::CreateAndReject(
         NS_ERROR_DOM_MEDIA_DECODE_ERR, __func__);
   }
 
   memcpy(buffer.get<uint8_t>(), aSample->Data(), aSample->Size());
 
   MediaRawDataIPDL sample(
-      MediaDataIPDL(aSample->mOffset,
-                    aSample->mTime.ToMicroseconds(),
+      MediaDataIPDL(aSample->mOffset, aSample->mTime.ToMicroseconds(),
                     aSample->mTimecode.ToMicroseconds(),
-                    aSample->mDuration.ToMicroseconds(),
-                    aSample->mFrames,
+                    aSample->mDuration.ToMicroseconds(), aSample->mFrames,
                     aSample->mKeyframe),
       buffer);
   SendInput(sample);
 
   return mDecodePromise.Ensure(__func__);
 }
 
 RefPtr<MediaDataDecoder::FlushPromise> RemoteDecoderChild::Flush() {
--- a/dom/media/ipc/RemoteDecoderManagerChild.cpp
+++ b/dom/media/ipc/RemoteDecoderManagerChild.cpp
@@ -72,25 +72,25 @@ RemoteDecoderManagerChild::GetSingleton(
   return sRemoteDecoderManagerChildThread;
 }
 
 /* static */ AbstractThread*
 RemoteDecoderManagerChild::GetManagerAbstractThread() {
   return sRemoteDecoderManagerChildAbstractThread;
 }
 
-PRemoteDecoderChild*
-RemoteDecoderManagerChild::AllocPRemoteDecoderChild(
+PRemoteDecoderChild* RemoteDecoderManagerChild::AllocPRemoteDecoderChild(
     const RemoteDecoderInfoIPDL& /* not used */,
     const CreateDecoderParams::OptionSet& /* not used */, bool* /* not used */,
     nsCString* /* not used */) {
   // RemoteDecoderModule is responsible for creating RemoteDecoderChild
   // classes.
-  MOZ_ASSERT(false, "RemoteDecoderManagerChild cannot create "
-                    "RemoteDecoderChild classes");
+  MOZ_ASSERT(false,
+             "RemoteDecoderManagerChild cannot create "
+             "RemoteDecoderChild classes");
   return nullptr;
 }
 
 bool RemoteDecoderManagerChild::DeallocPRemoteDecoderChild(
     PRemoteDecoderChild* actor) {
   RemoteDecoderChild* child = static_cast<RemoteDecoderChild*>(actor);
   child->IPDLActorDestroyed();
   return true;
--- a/dom/media/ipc/RemoteDecoderManagerChild.h
+++ b/dom/media/ipc/RemoteDecoderManagerChild.h
@@ -32,18 +32,17 @@ class RemoteDecoderManagerChild final : 
  protected:
   void InitIPDL();
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
   void DeallocPRemoteDecoderManagerChild() override;
 
   PRemoteDecoderChild* AllocPRemoteDecoderChild(
       const RemoteDecoderInfoIPDL& aRemoteDecoderInfo,
-      const CreateDecoderParams::OptionSet& aOptions,
-      bool* aSuccess,
+      const CreateDecoderParams::OptionSet& aOptions, bool* aSuccess,
       nsCString* aErrorDescription);
   bool DeallocPRemoteDecoderChild(PRemoteDecoderChild* actor);
 
  private:
   // Main thread only
   static void InitializeThread();
 
   RemoteDecoderManagerChild() = default;
--- a/dom/media/ipc/RemoteDecoderManagerParent.cpp
+++ b/dom/media/ipc/RemoteDecoderManagerParent.cpp
@@ -142,56 +142,46 @@ RemoteDecoderManagerParent::~RemoteDecod
   MOZ_COUNT_DTOR(RemoteDecoderManagerParent);
 }
 
 void RemoteDecoderManagerParent::ActorDestroy(
     mozilla::ipc::IProtocol::ActorDestroyReason) {
   mThreadHolder = nullptr;
 }
 
-PRemoteDecoderParent*
-RemoteDecoderManagerParent::AllocPRemoteDecoderParent(
+PRemoteDecoderParent* RemoteDecoderManagerParent::AllocPRemoteDecoderParent(
     const RemoteDecoderInfoIPDL& aRemoteDecoderInfo,
-    const CreateDecoderParams::OptionSet& aOptions,
-    bool* aSuccess,
+    const CreateDecoderParams::OptionSet& aOptions, bool* aSuccess,
     nsCString* aErrorDescription) {
   RefPtr<TaskQueue> decodeTaskQueue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLATFORM_DECODER),
                     "RemoteVideoDecoderParent::mDecodeTaskQueue");
 
   if (aRemoteDecoderInfo.type() ==
       RemoteDecoderInfoIPDL::TVideoDecoderInfoIPDL) {
     const VideoDecoderInfoIPDL& decoderInfo =
         aRemoteDecoderInfo.get_VideoDecoderInfoIPDL();
-    return new RemoteVideoDecoderParent(this,
-                                        decoderInfo.videoInfo(),
-                                        decoderInfo.framerate(),
-                                        aOptions,
-                                        sRemoteDecoderManagerTaskQueue,
-                                        decodeTaskQueue,
-                                        aSuccess,
-                                        aErrorDescription);
+    return new RemoteVideoDecoderParent(
+        this, decoderInfo.videoInfo(), decoderInfo.framerate(), aOptions,
+        sRemoteDecoderManagerTaskQueue, decodeTaskQueue, aSuccess,
+        aErrorDescription);
   } else if (aRemoteDecoderInfo.type() == RemoteDecoderInfoIPDL::TAudioInfo) {
-    return new RemoteAudioDecoderParent(this,
-                                        aRemoteDecoderInfo.get_AudioInfo(),
-                                        aOptions,
-                                        sRemoteDecoderManagerTaskQueue,
-                                        decodeTaskQueue,
-                                        aSuccess,
-                                        aErrorDescription);
+    return new RemoteAudioDecoderParent(
+        this, aRemoteDecoderInfo.get_AudioInfo(), aOptions,
+        sRemoteDecoderManagerTaskQueue, decodeTaskQueue, aSuccess,
+        aErrorDescription);
   }
 
   MOZ_CRASH("unrecognized type of RemoteDecoderInfoIPDL union");
   return nullptr;
 }
 
 bool RemoteDecoderManagerParent::DeallocPRemoteDecoderParent(
     PRemoteDecoderParent* actor) {
-  RemoteDecoderParent* parent =
-      static_cast<RemoteDecoderParent*>(actor);
+  RemoteDecoderParent* parent = static_cast<RemoteDecoderParent*>(actor);
   parent->Destroy();
   return true;
 }
 
 void RemoteDecoderManagerParent::Open(
     Endpoint<PRemoteDecoderManagerParent>&& aEndpoint) {
   if (!aEndpoint.Bind(this)) {
     // We can't recover from this.
--- a/dom/media/ipc/RemoteDecoderManagerParent.h
+++ b/dom/media/ipc/RemoteDecoderManagerParent.h
@@ -23,18 +23,17 @@ class RemoteDecoderManagerParent final :
   static bool StartupThreads();
   static void ShutdownThreads();
 
   bool OnManagerThread();
 
  protected:
   PRemoteDecoderParent* AllocPRemoteDecoderParent(
       const RemoteDecoderInfoIPDL& aRemoteDecoderInfo,
-      const CreateDecoderParams::OptionSet& aOptions,
-      bool* aSuccess,
+      const CreateDecoderParams::OptionSet& aOptions, bool* aSuccess,
       nsCString* aErrorDescription);
   bool DeallocPRemoteDecoderParent(PRemoteDecoderParent* actor);
 
   void ActorDestroy(mozilla::ipc::IProtocol::ActorDestroyReason) override;
 
   void DeallocPRemoteDecoderManagerParent() override;
 
  private:
--- a/dom/media/ipc/RemoteDecoderModule.cpp
+++ b/dom/media/ipc/RemoteDecoderModule.cpp
@@ -40,18 +40,18 @@ bool RemoteDecoderModule::SupportsMimeTy
   }
 
   MOZ_LOG(
       sPDMLog, LogLevel::Debug,
       ("Sandbox decoder %s requested type", supports ? "supports" : "rejects"));
   return supports;
 }
 
-already_AddRefed<MediaDataDecoder>
-RemoteDecoderModule::CreateAudioDecoder(const CreateDecoderParams& aParams) {
+already_AddRefed<MediaDataDecoder> RemoteDecoderModule::CreateAudioDecoder(
+    const CreateDecoderParams& aParams) {
   if (XRE_IsContentProcess()) {
     ContentChild* contentChild = ContentChild::GetSingleton();
     contentChild->LaunchRDDProcess();
   }
 
   if (!RemoteDecoderManagerChild::GetManagerThread()) {
     return nullptr;
   }
--- a/dom/media/ipc/RemoteDecoderParent.cpp
+++ b/dom/media/ipc/RemoteDecoderParent.cpp
@@ -42,18 +42,17 @@ mozilla::ipc::IPCResult RemoteDecoderPar
   MOZ_ASSERT(OnManagerThread());
   RefPtr<RemoteDecoderParent> self = this;
   mDecoder->Init()->Then(mManagerTaskQueue, __func__,
                          [self](TrackInfo::TrackType aTrack) {
                            MOZ_ASSERT(aTrack == TrackInfo::kAudioTrack ||
                                       aTrack == TrackInfo::kVideoTrack);
                            if (self->mDecoder) {
                              Unused << self->SendInitComplete(
-                                 aTrack,
-                                 self->mDecoder->GetDescriptionName(),
+                                 aTrack, self->mDecoder->GetDescriptionName(),
                                  self->mDecoder->NeedsConversion());
                            }
                          },
                          [self](MediaResult aReason) {
                            if (!self->mDestroyed) {
                              Unused << self->SendInitFailed(aReason);
                            }
                          });
--- a/dom/media/ipc/RemoteVideoDecoder.cpp
+++ b/dom/media/ipc/RemoteVideoDecoder.cpp
@@ -13,18 +13,17 @@
 #include "ImageContainer.h"  // for PlanarYCbCrData and BufferRecycleBin
 #include "RemoteDecoderManagerChild.h"
 
 namespace mozilla {
 
 using namespace layers;  // for PlanarYCbCrData and BufferRecycleBin
 
 RemoteVideoDecoderChild::RemoteVideoDecoderChild()
-    : RemoteDecoderChild(),
-      mBufferRecycleBin(new BufferRecycleBin) {}
+    : RemoteDecoderChild(), mBufferRecycleBin(new BufferRecycleBin) {}
 
 RefPtr<mozilla::layers::Image> RemoteVideoDecoderChild::DeserializeImage(
     const SurfaceDescriptorBuffer& aSdBuffer, const IntSize& aPicSize) {
   MOZ_ASSERT(aSdBuffer.desc().type() == BufferDescriptor::TYCbCrDescriptor);
   if (aSdBuffer.desc().type() != BufferDescriptor::TYCbCrDescriptor) {
     return nullptr;
   }
   const YCbCrDescriptor& descriptor = aSdBuffer.desc().get_YCbCrDescriptor();
@@ -96,18 +95,17 @@ mozilla::ipc::IPCResult RemoteVideoDecod
       aData.base().keyframe(),
       media::TimeUnit::FromMicroseconds(aData.base().timecode()));
 
   mDecodedData.AppendElement(std::move(video));
   return IPC_OK();
 }
 
 MediaResult RemoteVideoDecoderChild::InitIPDL(
-    const VideoInfo& aVideoInfo,
-    float aFramerate,
+    const VideoInfo& aVideoInfo, float aFramerate,
     const CreateDecoderParams::OptionSet& aOptions) {
   RefPtr<RemoteDecoderManagerChild> manager =
       RemoteDecoderManagerChild::GetSingleton();
 
   // The manager isn't available because RemoteDecoderManagerChild has been
   // initialized with null end points and we don't want to decode video on RDD
   // process anymore. Return false here so that we can fallback to other PDMs.
   if (!manager) {
@@ -119,40 +117,31 @@ MediaResult RemoteVideoDecoderChild::Ini
     return MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
                        RESULT_DETAIL("RemoteDecoderManager unable to send."));
   }
 
   mIPDLSelfRef = this;
   bool success = false;
   nsCString errorDescription;
   VideoDecoderInfoIPDL decoderInfo(aVideoInfo, aFramerate);
-  if (manager->SendPRemoteDecoderConstructor(this,
-                                             decoderInfo,
-                                             aOptions,
-                                             &success,
-                                             &errorDescription)) {
+  if (manager->SendPRemoteDecoderConstructor(this, decoderInfo, aOptions,
+                                             &success, &errorDescription)) {
     mCanSend = true;
   }
 
   return success ? MediaResult(NS_OK)
                  : MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR, errorDescription);
 }
 
 RemoteVideoDecoderParent::RemoteVideoDecoderParent(
-    RemoteDecoderManagerParent* aParent,
-    const VideoInfo& aVideoInfo,
-    float aFramerate,
-    const CreateDecoderParams::OptionSet& aOptions,
-    TaskQueue* aManagerTaskQueue,
-    TaskQueue* aDecodeTaskQueue,
-    bool* aSuccess,
+    RemoteDecoderManagerParent* aParent, const VideoInfo& aVideoInfo,
+    float aFramerate, const CreateDecoderParams::OptionSet& aOptions,
+    TaskQueue* aManagerTaskQueue, TaskQueue* aDecodeTaskQueue, bool* aSuccess,
     nsCString* aErrorDescription)
-    : RemoteDecoderParent(aParent,
-                          aManagerTaskQueue,
-                          aDecodeTaskQueue),
+    : RemoteDecoderParent(aParent, aManagerTaskQueue, aDecodeTaskQueue),
       mVideoInfo(aVideoInfo) {
   CreateDecoderParams params(mVideoInfo);
   params.mTaskQueue = mDecodeTaskQueue;
   params.mImageContainer = new layers::ImageContainer();
   params.mRate = CreateDecoderParams::VideoFrameRate(aFramerate);
   params.mOptions = aOptions;
   MediaResult error(NS_OK);
   params.mError = &error;
--- a/dom/media/ipc/RemoteVideoDecoder.h
+++ b/dom/media/ipc/RemoteVideoDecoder.h
@@ -18,38 +18,35 @@ namespace mozilla {
 
 using mozilla::ipc::IPCResult;
 
 class RemoteVideoDecoderChild final : public RemoteDecoderChild {
  public:
   explicit RemoteVideoDecoderChild();
 
   MOZ_IS_CLASS_INIT
-  MediaResult InitIPDL(const VideoInfo& aVideoInfo,
-                       float aFramerate,
+  MediaResult InitIPDL(const VideoInfo& aVideoInfo, float aFramerate,
                        const CreateDecoderParams::OptionSet& aOptions);
 
   IPCResult RecvOutput(const DecodedOutputIPDL& aDecodedData) override;
 
  private:
   RefPtr<mozilla::layers::Image> DeserializeImage(
       const SurfaceDescriptorBuffer& sdBuffer, const IntSize& aPicSize);
 
   RefPtr<mozilla::layers::BufferRecycleBin> mBufferRecycleBin;
 };
 
 class RemoteVideoDecoderParent final : public RemoteDecoderParent {
  public:
   RemoteVideoDecoderParent(RemoteDecoderManagerParent* aParent,
-                           const VideoInfo& aVideoInfo,
-                           float aFramerate,
+                           const VideoInfo& aVideoInfo, float aFramerate,
                            const CreateDecoderParams::OptionSet& aOptions,
                            TaskQueue* aManagerTaskQueue,
-                           TaskQueue* aDecodeTaskQueue,
-                           bool* aSuccess,
+                           TaskQueue* aDecodeTaskQueue, bool* aSuccess,
                            nsCString* aErrorDescription);
 
  protected:
   void ProcessDecodedData(const MediaDataDecoder::DecodedData& aData) override;
 
  private:
   // Can only be accessed from the manager thread
   // Note: we can't keep a reference to the original VideoInfo here
--- a/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp
+++ b/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp
@@ -20,17 +20,18 @@
 
 namespace mozilla {
 
 bool AgnosticDecoderModule::SupportsMimeType(
     const nsACString& aMimeType, DecoderDoctorDiagnostics* aDiagnostics) const {
   bool supports =
       VPXDecoder::IsVPX(aMimeType) || OpusDataDecoder::IsOpus(aMimeType) ||
       WaveDataDecoder::IsWave(aMimeType) || TheoraDecoder::IsTheora(aMimeType);
-  if (!StaticPrefs::MediaRddVorbisEnabled() || !StaticPrefs::MediaRddProcessEnabled()) {
+  if (!StaticPrefs::MediaRddVorbisEnabled() ||
+      !StaticPrefs::MediaRddProcessEnabled()) {
     supports |= VorbisDataDecoder::IsVorbis(aMimeType);
   }
 #ifdef MOZ_AV1
   if (StaticPrefs::MediaAv1Enabled()) {
     supports |= AOMDecoder::IsAV1(aMimeType);
   }
 #endif
   MOZ_LOG(sPDMLog, LogLevel::Debug,
--- a/dom/xul/nsXULElement.cpp
+++ b/dom/xul/nsXULElement.cpp
@@ -469,17 +469,17 @@ bool nsXULElement::IsFocusableInternal(i
     }
   }
 
   return shouldFocus;
 }
 
 int32_t nsXULElement::ScreenX() {
   nsIFrame* frame = GetPrimaryFrame(FlushType::Layout);
-  return frame ? frame->GetScreenRect().x: 0;
+  return frame ? frame->GetScreenRect().x : 0;
 }
 
 int32_t nsXULElement::ScreenY() {
   nsIFrame* frame = GetPrimaryFrame(FlushType::Layout);
   return frame ? frame->GetScreenRect().y : 0;
 }
 
 bool nsXULElement::HasMenu() {
--- a/gfx/layers/ImageTypes.h
+++ b/gfx/layers/ImageTypes.h
@@ -2,17 +2,17 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_IMAGETYPES_H
 #define GFX_IMAGETYPES_H
 
-#include <stdint.h>     // for uint32_t
+#include <stdint.h>  // for uint32_t
 
 namespace mozilla {
 
 enum class ImageFormat {
   /**
    * The PLANAR_YCBCR format creates a PlanarYCbCrImage. All backends should
    * support this format, because the Ogg video decoder depends on it.
    * The maximum image width and height is 16384.
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -2340,18 +2340,18 @@ Maybe<wr::WrImageMask> WebRenderCommandB
         MakeAndAddRef<WebRenderDrawEventRecorder>(
             [&](MemStream& aStream,
                 std::vector<RefPtr<ScaledFont>>& aScaledFonts) {
               size_t count = aScaledFonts.size();
               aStream.write((const char*)&count, sizeof(count));
 
               for (auto& scaled : aScaledFonts) {
                 Maybe<wr::FontInstanceKey> key =
-                    mManager->WrBridge()->GetFontKeyForScaledFont(
-                        scaled, &aResources);
+                    mManager->WrBridge()->GetFontKeyForScaledFont(scaled,
+                                                                  &aResources);
                 if (key.isNothing()) {
                   validFonts = false;
                   break;
                 }
                 BlobFont font = {key.value(), scaled};
                 aStream.write((const char*)&font, sizeof(font));
               }
 
--- a/gfx/layers/wr/WebRenderUserData.cpp
+++ b/gfx/layers/wr/WebRenderUserData.cpp
@@ -61,18 +61,17 @@ void WebRenderBackgroundData::AddWebRend
     return true;
   }
 
   aFrame->SchedulePaint();
   return false;
 }
 
 WebRenderUserData::WebRenderUserData(RenderRootStateManager* aManager,
-                                     uint32_t aDisplayItemKey,
-                                     nsIFrame* aFrame)
+                                     uint32_t aDisplayItemKey, nsIFrame* aFrame)
     : mManager(aManager),
       mFrame(aFrame),
       mDisplayItemKey(aDisplayItemKey),
       mTable(aManager->GetWebRenderUserDataTable()),
       mUsed(false) {}
 
 WebRenderUserData::WebRenderUserData(RenderRootStateManager* aManager,
                                      nsDisplayItem* aItem)
@@ -319,22 +318,22 @@ WebRenderImageData* WebRenderFallbackDat
     mManager->AddBlobImageKeyForDiscard(mBlobKey.value());
     mBlobKey.reset();
   }
 
   if (mImageData) {
     return mImageData.get();
   }
 
-  mImageData = MakeAndAddRef<WebRenderImageData>(mManager.get(), mDisplayItemKey, mFrame);
+  mImageData = MakeAndAddRef<WebRenderImageData>(mManager.get(),
+                                                 mDisplayItemKey, mFrame);
 
   return mImageData.get();
 }
 
-
 WebRenderAnimationData::WebRenderAnimationData(RenderRootStateManager* aManager,
                                                nsDisplayItem* aItem)
     : WebRenderUserData(aManager, aItem) {}
 
 WebRenderAnimationData::~WebRenderAnimationData() {
   // It may be the case that nsDisplayItem that created this WebRenderUserData
   // gets destroyed without getting a chance to discard the compositor animation
   // id, so we should do it as part of cleanup here.
--- a/gfx/layers/wr/WebRenderUserData.h
+++ b/gfx/layers/wr/WebRenderUserData.h
@@ -59,17 +59,18 @@ class WebRenderUserData {
   static bool SupportsAsyncUpdate(nsIFrame* aFrame);
 
   static bool ProcessInvalidateForImage(nsIFrame* aFrame, DisplayItemType aType,
                                         ContainerProducerID aProducerId);
 
   NS_INLINE_DECL_REFCOUNTING(WebRenderUserData)
 
   WebRenderUserData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
-  WebRenderUserData(RenderRootStateManager* aManager, uint32_t mDisplayItemKey, nsIFrame* aFrame);
+  WebRenderUserData(RenderRootStateManager* aManager, uint32_t mDisplayItemKey,
+                    nsIFrame* aFrame);
 
   virtual WebRenderImageData* AsImageData() { return nullptr; }
   virtual WebRenderFallbackData* AsFallbackData() { return nullptr; }
   virtual WebRenderCanvasData* AsCanvasData() { return nullptr; }
   virtual WebRenderGroupData* AsGroupData() { return nullptr; }
 
   enum class UserDataType {
     eImage,
@@ -122,17 +123,18 @@ typedef nsRefPtrHashtable<
     nsGenericHashKey<mozilla::layers::WebRenderUserDataKey>, WebRenderUserData>
     WebRenderUserDataTable;
 
 /// Holds some data used to share TextureClient/ImageClient with the parent
 /// process.
 class WebRenderImageData : public WebRenderUserData {
  public:
   WebRenderImageData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
-  WebRenderImageData(RenderRootStateManager* aManager, uint32_t aDisplayItemKey, nsIFrame* aFrame);
+  WebRenderImageData(RenderRootStateManager* aManager, uint32_t aDisplayItemKey,
+                     nsIFrame* aFrame);
   virtual ~WebRenderImageData();
 
   virtual WebRenderImageData* AsImageData() override { return this; }
   virtual UserDataType GetType() override { return UserDataType::eImage; }
   static UserDataType Type() { return UserDataType::eImage; }
   Maybe<wr::ImageKey> GetImageKey() { return mKey; }
   void SetImageKey(const wr::ImageKey& aKey);
   already_AddRefed<ImageClient> GetImageClient();
@@ -186,32 +188,33 @@ class WebRenderFallbackData : public Web
   bool IsInvalid() { return mInvalid; }
   void SetFonts(const std::vector<RefPtr<gfx::ScaledFont>>& aFonts) {
     mFonts = aFonts;
   }
   Maybe<wr::BlobImageKey> GetBlobImageKey() { return mBlobKey; }
   void SetBlobImageKey(const wr::BlobImageKey& aKey);
   Maybe<wr::ImageKey> GetImageKey();
 
-  /// Create a WebRenderImageData to manage the image we are about to render into.
+  /// Create a WebRenderImageData to manage the image we are about to render
+  /// into.
   WebRenderImageData* PaintIntoImage();
 
   std::vector<RefPtr<gfx::SourceSurface>> mExternalSurfaces;
   RefPtr<BasicLayerManager> mBasicLayerManager;
   nsAutoPtr<nsDisplayItemGeometry> mGeometry;
   nsRect mBounds;
   gfx::Size mScale;
 
  protected:
   void ClearImageKey();
 
   std::vector<RefPtr<gfx::ScaledFont>> mFonts;
   Maybe<wr::BlobImageKey> mBlobKey;
-  // When rendering into a blob image, mImageData is null. It is non-null only when
-  // we render directly into a texture on the content side.
+  // When rendering into a blob image, mImageData is null. It is non-null only
+  // when we render directly into a texture on the content side.
   RefPtr<WebRenderImageData> mImageData;
   bool mInvalid;
 };
 
 class WebRenderAnimationData : public WebRenderUserData {
  public:
   WebRenderAnimationData(RenderRootStateManager* aManager,
                          nsDisplayItem* aItem);
--- a/ipc/mscom/ProcessRuntime.cpp
+++ b/ipc/mscom/ProcessRuntime.cpp
@@ -262,27 +262,29 @@ ProcessRuntime::InitializeSecurity() {
 
   return ::CoInitializeSecurity(
       &sd, -1, nullptr, nullptr, RPC_C_AUTHN_LEVEL_DEFAULT,
       RPC_C_IMP_LEVEL_IDENTIFY, nullptr, EOAC_NONE, nullptr);
 }
 
 #if defined(MOZILLA_INTERNAL_API)
 
-/* static */ bool
-ProcessRuntime::IsWin32kLockedDown() {
-  static const DynamicallyLinkedFunctionPtr<decltype(&::GetProcessMitigationPolicy)>
-    pGetProcessMitigationPolicy(L"kernel32.dll", "GetProcessMitigationPolicy");
+/* static */ bool ProcessRuntime::IsWin32kLockedDown() {
+  static const DynamicallyLinkedFunctionPtr<decltype(
+      &::GetProcessMitigationPolicy)>
+      pGetProcessMitigationPolicy(L"kernel32.dll",
+                                  "GetProcessMitigationPolicy");
   if (!pGetProcessMitigationPolicy) {
     return false;
   }
 
   PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY polInfo;
   if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
-      ProcessSystemCallDisablePolicy, &polInfo, sizeof(polInfo))) {
+                                   ProcessSystemCallDisablePolicy, &polInfo,
+                                   sizeof(polInfo))) {
     return false;
   }
 
   return polInfo.DisallowWin32kSystemCalls;
 }
 
 #endif  // defined(MOZILLA_INTERNAL_API)
 
--- a/ipc/mscom/mozglue/ProcessRuntimeShared.cpp
+++ b/ipc/mscom/mozglue/ProcessRuntimeShared.cpp
@@ -12,22 +12,18 @@
 // initialization. These variables provide that mutual exclusion.
 static mozilla::glue::Win32SRWLock gLock;
 static bool gIsProcessInitialized = false;
 
 namespace mozilla {
 namespace mscom {
 namespace detail {
 
-MFBT_API bool&
-BeginProcessRuntimeInit() {
+MFBT_API bool& BeginProcessRuntimeInit() {
   gLock.LockExclusive();
   return gIsProcessInitialized;
 }
 
-MFBT_API void
-EndProcessRuntimeInit() {
-  gLock.UnlockExclusive();
-}
+MFBT_API void EndProcessRuntimeInit() { gLock.UnlockExclusive(); }
 
 }  //  namespace detail
 }  // namespace mscom
 }  // namespace mozilla
--- a/ipc/mscom/mozglue/ProcessRuntimeShared.h
+++ b/ipc/mscom/mozglue/ProcessRuntimeShared.h
@@ -18,26 +18,21 @@ namespace detail {
 MFBT_API bool& BeginProcessRuntimeInit();
 MFBT_API void EndProcessRuntimeInit();
 
 }  // namespace detail
 
 class MOZ_RAII ProcessInitLock final {
  public:
   ProcessInitLock()
-    : mIsProcessInitialized(detail::BeginProcessRuntimeInit()) {
-  }
+      : mIsProcessInitialized(detail::BeginProcessRuntimeInit()) {}
 
-  ~ProcessInitLock() {
-    detail::EndProcessRuntimeInit();
-  }
+  ~ProcessInitLock() { detail::EndProcessRuntimeInit(); }
 
-  bool IsInitialized() const {
-    return mIsProcessInitialized;
-  }
+  bool IsInitialized() const { return mIsProcessInitialized; }
 
   void SetInitialized() {
     MOZ_ASSERT(!mIsProcessInitialized);
     mIsProcessInitialized = true;
   }
 
   ProcessInitLock(const ProcessInitLock&) = delete;
   ProcessInitLock(ProcessInitLock&&) = delete;
--- a/js/public/MemoryMetrics.h
+++ b/js/public/MemoryMetrics.h
@@ -555,28 +555,28 @@ struct RuntimeSizes {
   ScriptSourcesHashMap* allScriptSources;
   js::Vector<NotableScriptSourceInfo, 0, js::SystemAllocPolicy>
       notableScriptSources;
 
 #undef FOR_EACH_SIZE
 };
 
 struct UnusedGCThingSizes {
-#define FOR_EACH_SIZE(MACRO)                      \
-  MACRO(Other, GCHeapUnused, object)              \
-  MACRO(Other, GCHeapUnused, script)              \
-  MACRO(Other, GCHeapUnused, lazyScript)          \
-  MACRO(Other, GCHeapUnused, shape)               \
-  MACRO(Other, GCHeapUnused, baseShape)           \
-  MACRO(Other, GCHeapUnused, objectGroup)         \
-  MACRO(Other, GCHeapUnused, string)              \
-  MACRO(Other, GCHeapUnused, symbol)              \
-  MACRO(Other, GCHeapUnused, bigInt)              \
-  MACRO(Other, GCHeapUnused, jitcode)             \
-  MACRO(Other, GCHeapUnused, scope)               \
+#define FOR_EACH_SIZE(MACRO)              \
+  MACRO(Other, GCHeapUnused, object)      \
+  MACRO(Other, GCHeapUnused, script)      \
+  MACRO(Other, GCHeapUnused, lazyScript)  \
+  MACRO(Other, GCHeapUnused, shape)       \
+  MACRO(Other, GCHeapUnused, baseShape)   \
+  MACRO(Other, GCHeapUnused, objectGroup) \
+  MACRO(Other, GCHeapUnused, string)      \
+  MACRO(Other, GCHeapUnused, symbol)      \
+  MACRO(Other, GCHeapUnused, bigInt)      \
+  MACRO(Other, GCHeapUnused, jitcode)     \
+  MACRO(Other, GCHeapUnused, scope)       \
   MACRO(Other, GCHeapUnused, regExpShared)
 
   UnusedGCThingSizes() : FOR_EACH_SIZE(ZERO_SIZE) dummy() {}
 
   UnusedGCThingSizes(UnusedGCThingSizes&& other)
       : FOR_EACH_SIZE(COPY_OTHER_SIZE) dummy() {}
 
   void addToKind(JS::TraceKind kind, intptr_t n) {
--- a/js/public/ProtoKey.h
+++ b/js/public/ProtoKey.h
@@ -124,15 +124,15 @@
        &js::CountQueuingStrategy::class_)                                    \
   REAL(WebAssembly, InitWebAssemblyClass, CLASP(WebAssembly))                \
   IMAGINARY(WasmModule, dummy, dummy)                                        \
   IMAGINARY(WasmInstance, dummy, dummy)                                      \
   IMAGINARY(WasmMemory, dummy, dummy)                                        \
   IMAGINARY(WasmTable, dummy, dummy)                                         \
   IMAGINARY(WasmGlobal, dummy, dummy)
 
-#define JS_FOR_PROTOTYPES(REAL, IMAGINARY)                               \
-  JS_FOR_PROTOTYPES_(REAL, IMAGINARY, IF_INTL(REAL, IMAGINARY),          \
+#define JS_FOR_PROTOTYPES(REAL, IMAGINARY)                      \
+  JS_FOR_PROTOTYPES_(REAL, IMAGINARY, IF_INTL(REAL, IMAGINARY), \
                      IF_TYPEDOBJ(REAL, IMAGINARY), IF_SAB(REAL, IMAGINARY))
 
 #define JS_FOR_EACH_PROTOTYPE(MACRO) JS_FOR_PROTOTYPES(MACRO, MACRO)
 
 #endif /* js_ProtoKey_h */
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -717,21 +717,21 @@ union alignas(8) Value {
     return s_.payload_.sym_;
 #elif defined(JS_PUNBOX64)
     return reinterpret_cast<JS::Symbol*>(asBits_ ^ JSVAL_SHIFTED_TAG_SYMBOL);
 #endif
   }
 
   JS::BigInt* toBigInt() const {
     MOZ_ASSERT(isBigInt());
-#  if defined(JS_NUNBOX32)
+#if defined(JS_NUNBOX32)
     return s_.payload_.bi_;
-#  elif defined(JS_PUNBOX64)
+#elif defined(JS_PUNBOX64)
     return reinterpret_cast<JS::BigInt*>(asBits_ ^ JSVAL_SHIFTED_TAG_BIGINT);
-#  endif
+#endif
   }
 
   JSObject& toObject() const {
     MOZ_ASSERT(isObject());
 #if defined(JS_NUNBOX32)
     return *s_.payload_.obj_;
 #elif defined(JS_PUNBOX64)
     uint64_t ptrBits = asBits_ ^ JSVAL_SHIFTED_TAG_OBJECT;
--- a/js/src/NamespaceImports.h
+++ b/js/src/NamespaceImports.h
@@ -99,53 +99,53 @@ using JS::GCHashSet;
 using JS::GCVector;
 
 using JS::CallArgs;
 using JS::CallNonGenericMethod;
 using JS::IsAcceptableThis;
 using JS::NativeImpl;
 
 using JS::Rooted;
+using JS::RootedBigInt;
 using JS::RootedFunction;
 using JS::RootedId;
 using JS::RootedObject;
 using JS::RootedScript;
 using JS::RootedString;
 using JS::RootedSymbol;
-using JS::RootedBigInt;
 using JS::RootedValue;
 
 using JS::PersistentRooted;
+using JS::PersistentRootedBigInt;
 using JS::PersistentRootedFunction;
 using JS::PersistentRootedId;
 using JS::PersistentRootedObject;
 using JS::PersistentRootedScript;
 using JS::PersistentRootedString;
 using JS::PersistentRootedSymbol;
-using JS::PersistentRootedBigInt;
 using JS::PersistentRootedValue;
 
 using JS::Handle;
+using JS::HandleBigInt;
 using JS::HandleFunction;
 using JS::HandleId;
 using JS::HandleObject;
 using JS::HandleScript;
 using JS::HandleString;
 using JS::HandleSymbol;
-using JS::HandleBigInt;
 using JS::HandleValue;
 
 using JS::MutableHandle;
+using JS::MutableHandleBigInt;
 using JS::MutableHandleFunction;
 using JS::MutableHandleId;
 using JS::MutableHandleObject;
 using JS::MutableHandleScript;
 using JS::MutableHandleString;
 using JS::MutableHandleSymbol;
-using JS::MutableHandleBigInt;
 using JS::MutableHandleValue;
 
 using JS::FalseHandleValue;
 using JS::NullHandleValue;
 using JS::TrueHandleValue;
 using JS::UndefinedHandleValue;
 
 using JS::HandleValueArray;
--- a/js/src/devtools/rootAnalysis/t/hazards/source.cpp
+++ b/js/src/devtools/rootAnalysis/t/hazards/source.cpp
@@ -206,29 +206,29 @@ void loopy() {
   for (int i6 = 0; i6 < 10; i6++) {
     GC();
     use(haz8.cell);
     haz8.cell = &cell;
   }
 }
 
 namespace mozilla {
-template<typename T>
-class UniquePtr
-{
+template <typename T>
+class UniquePtr {
   T* val;
+
  public:
   UniquePtr() : val(nullptr) { asm(""); }
   UniquePtr(T* p) : val(p) {}
   UniquePtr(UniquePtr<T>&& u) : val(u.val) { u.val = nullptr; }
   ~UniquePtr() { use(val); }
   T* get() { return val; }
   void reset() { val = nullptr; }
 } ANNOTATE("moz_inherit_type_annotations_from_template_args");
-} // namespace mozilla
+}  // namespace mozilla
 
 extern void consume(mozilla::UniquePtr<Cell> uptr);
 
 void safevals() {
   Cell cell;
 
   // Simple hazard.
   Cell* unsafe1 = &cell;
--- a/js/src/frontend/ParseNode.h
+++ b/js/src/frontend/ParseNode.h
@@ -1538,19 +1538,19 @@ class BigIntLiteral : public ParseNode {
 
   static constexpr ParseNodeArity arity() { return PN_BIGINT; }
 
   template <typename Visitor>
   bool accept(Visitor& visitor) {
     return true;
   }
 
-#  ifdef DEBUG
+#ifdef DEBUG
   void dump(GenericPrinter& out, int indent);
-#  endif
+#endif
 
   BigIntBox* box() const { return box_; }
 };
 
 class LexicalScopeNode : public ParseNode {
   LexicalScope::Data* bindings;
   ParseNode* body;
 
--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -2389,36 +2389,36 @@ class MOZ_STACK_CLASS TokenStreamSpecifi
   using CharsBase::atomizeSourceChars;
   using GeneralCharsBase::badToken;
   using TokenStreamCharsShared::appendCodePointToCharBuffer;
   // Deliberately don't |using| |charBuffer| because of bug 1472569.  :-(
   using CharsBase::consumeKnownCodeUnit;
   using CharsBase::fillCharBufferFromSourceNormalizingAsciiLineBreaks;
   using CharsBase::matchCodeUnit;
   using CharsBase::matchLineTerminator;
+  using CharsBase::peekCodeUnit;
   using GeneralCharsBase::computeColumn;
   using GeneralCharsBase::fillExceptingContext;
   using GeneralCharsBase::getCodeUnit;
   using GeneralCharsBase::getFullAsciiCodePoint;
   using GeneralCharsBase::internalComputeLineOfContext;
   using GeneralCharsBase::matchUnicodeEscapeIdent;
   using GeneralCharsBase::matchUnicodeEscapeIdStart;
   using GeneralCharsBase::newAtomToken;
+  using GeneralCharsBase::newBigIntToken;
   using GeneralCharsBase::newNameToken;
   using GeneralCharsBase::newNumberToken;
   using GeneralCharsBase::newPrivateNameToken;
+  using GeneralCharsBase::newRegExpToken;
+  using GeneralCharsBase::newSimpleToken;
   using SpecializedChars::getNonAsciiCodePoint;
   using SpecializedChars::getNonAsciiCodePointDontNormalize;
   using TokenStreamCharsShared::copyCharBufferTo;
   using TokenStreamCharsShared::drainCharBufferIntoAtom;
   using TokenStreamCharsShared::isAsciiCodePoint;
-  using GeneralCharsBase::newBigIntToken;
-  using CharsBase::peekCodeUnit;
-  using GeneralCharsBase::newRegExpToken;
-  using GeneralCharsBase::newSimpleToken;
   // Deliberately don't |using| |sourceUnits| because of bug 1472569.  :-(
   using CharsBase::toUnit;
   using GeneralCharsBase::ungetCodeUnit;
   using GeneralCharsBase::updateLineInfoForEOL;
 
   template <typename CharU>
   friend class TokenStreamPosition;
 
--- a/js/src/gc/AtomMarking.cpp
+++ b/js/src/gc/AtomMarking.cpp
@@ -179,19 +179,19 @@ void AtomMarkingRuntime::markAtomValue(J
       markAtom(cx, &value.toString()->asAtom());
     }
     return;
   }
   if (value.isSymbol()) {
     markAtom(cx, value.toSymbol());
     return;
   }
-  MOZ_ASSERT_IF(value.isGCThing(),
-                value.isObject() || value.isPrivateGCThing() ||
-                value.isBigInt());
+  MOZ_ASSERT_IF(value.isGCThing(), value.isObject() ||
+                                       value.isPrivateGCThing() ||
+                                       value.isBigInt());
 }
 
 void AtomMarkingRuntime::adoptMarkedAtoms(Zone* target, Zone* source) {
   MOZ_ASSERT(CurrentThreadCanAccessZone(source));
   MOZ_ASSERT(CurrentThreadCanAccessZone(target));
   target->markedAtoms().bitwiseOrWith(source->markedAtoms());
 }
 
@@ -262,19 +262,19 @@ bool AtomMarkingRuntime::valueIsMarked(Z
     }
     return true;
   }
 
   if (value.isSymbol()) {
     return atomIsMarked(zone, value.toSymbol());
   }
 
-  MOZ_ASSERT_IF(value.isGCThing(),
-                value.isObject() || value.isPrivateGCThing() ||
-                value.isBigInt());
+  MOZ_ASSERT_IF(value.isGCThing(), value.isObject() ||
+                                       value.isPrivateGCThing() ||
+                                       value.isBigInt());
   return true;
 }
 
 #endif  // DEBUG
 
 }  // namespace gc
 
 #ifdef DEBUG
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -499,18 +499,17 @@ static const FinalizePhase BackgroundFin
      }},
     {gcstats::PhaseKind::SWEEP_REGEXP_SHARED,
      {
          AllocKind::REGEXP_SHARED,
      }},
     {gcstats::PhaseKind::SWEEP_STRING,
      {AllocKind::FAT_INLINE_STRING, AllocKind::STRING,
       AllocKind::EXTERNAL_STRING, AllocKind::FAT_INLINE_ATOM, AllocKind::ATOM,
-      AllocKind::SYMBOL, AllocKind::BIGINT
-     }},
+      AllocKind::SYMBOL, AllocKind::BIGINT}},
     {gcstats::PhaseKind::SWEEP_SHAPE,
      {AllocKind::SHAPE, AllocKind::ACCESSOR_SHAPE, AllocKind::BASE_SHAPE,
       AllocKind::OBJECT_GROUP}}};
 
 template <>
 JSObject* ArenaCellIterImpl::get<JSObject>() const {
   MOZ_ASSERT(!done());
   return reinterpret_cast<JSObject*>(getCell());
--- a/js/src/gc/Nursery.cpp
+++ b/js/src/gc/Nursery.cpp
@@ -1098,18 +1098,20 @@ MOZ_ALWAYS_INLINE void js::Nursery::setC
   }
 
   currentChunk_ = chunkno;
   position_ = chunk(chunkno).start();
   setCurrentEnd();
 }
 
 MOZ_ALWAYS_INLINE void js::Nursery::setCurrentEnd() {
-  MOZ_ASSERT_IF(isSubChunkMode(), currentChunk_ == 0 && currentEnd_ <= chunk(0).end());
-  currentEnd_ = chunk(currentChunk_).start() + Min(capacity_, NurseryChunkUsableSize);
+  MOZ_ASSERT_IF(isSubChunkMode(),
+                currentChunk_ == 0 && currentEnd_ <= chunk(0).end());
+  currentEnd_ =
+      chunk(currentChunk_).start() + Min(capacity_, NurseryChunkUsableSize);
   if (canAllocateStrings_) {
     currentStringEnd_ = currentEnd_;
   }
 }
 
 bool js::Nursery::allocateNextChunk(const unsigned chunkno,
                                     AutoLockGCBgAlloc& lock) {
   const unsigned priorCount = allocatedChunkCount();
@@ -1163,17 +1165,18 @@ void js::Nursery::maybeResizeNursery(JS:
 
   newMaxNurseryChunks = tunables().gcMaxNurseryBytes() >> ChunkShift;
   if (newMaxNurseryChunks != chunkCountLimit_) {
     chunkCountLimit_ = newMaxNurseryChunks;
     /* The configured maximum nursery size is changing */
     if (maxChunkCount() > newMaxNurseryChunks) {
       /* We need to shrink the nursery */
       static_assert(NurseryChunkUsableSize < ChunkSize,
-          "Usable size must be smaller than total size or this calculation might overflow");
+                    "Usable size must be smaller than total size or this "
+                    "calculation might overflow");
       shrinkAllocableSpace(newMaxNurseryChunks * NurseryChunkUsableSize);
       return;
     }
   }
 
   /*
    * This incorrect promotion rate results in better nursery sizing
    * decisions, however we should to better tuning based on the real
@@ -1190,36 +1193,41 @@ void js::Nursery::maybeResizeNursery(JS:
   const float factor = promotionRate / PromotionGoal;
   const unsigned newCapacity = unsigned(float(capacity()) * factor);
 
   // If one of these conditions is true then we always shrink or grow the
   // nursery.  This way the thresholds still have an effect even if the goal
   // seeking says the current size is ideal.
   if (maxChunkCount() < chunkCountLimit() && promotionRate > GrowThreshold) {
     unsigned lowLimit = capacity() + SubChunkStep;
-    unsigned highLimit = Min(chunkCountLimit() * NurseryChunkUsableSize, capacity() * 2);
+    unsigned highLimit =
+        Min(chunkCountLimit() * NurseryChunkUsableSize, capacity() * 2);
 
     growAllocableSpace(mozilla::Clamp(newCapacity, lowLimit, highLimit));
-  } else if (capacity() >= SubChunkLimit + SubChunkStep && promotionRate < ShrinkThreshold) {
+  } else if (capacity() >= SubChunkLimit + SubChunkStep &&
+             promotionRate < ShrinkThreshold) {
     unsigned lowLimit = Max(SubChunkLimit, capacity() / 2);
     unsigned highLimit = capacity() - SubChunkStep;
 
     shrinkAllocableSpace(mozilla::Clamp(newCapacity, lowLimit, highLimit));
   }
 
   // Assert that the limits are set such that we can shrink the nursery below
   // one chunk.
-  static_assert(SubChunkLimit + SubChunkStep < NurseryChunkUsableSize,
+  static_assert(
+      SubChunkLimit + SubChunkStep < NurseryChunkUsableSize,
       "Nursery limit must be at least one step from the full chunk size");
 }
 
 void js::Nursery::growAllocableSpace(unsigned newCapacity) {
-  MOZ_ASSERT_IF(!isSubChunkMode(), newCapacity > currentChunk_ * NurseryChunkUsableSize);
+  MOZ_ASSERT_IF(!isSubChunkMode(),
+                newCapacity > currentChunk_ * NurseryChunkUsableSize);
   if (isSubChunkMode()) {
-    capacity_ = Min(JS_ROUNDUP(newCapacity, SubChunkStep), NurseryChunkUsableSize);
+    capacity_ =
+        Min(JS_ROUNDUP(newCapacity, SubChunkStep), NurseryChunkUsableSize);
   } else {
     capacity_ = JS_ROUNDUP(newCapacity, NurseryChunkUsableSize);
   }
   MOZ_ASSERT(capacity_ <= chunkCountLimit_ * NurseryChunkUsableSize);
   setCurrentEnd();
 }
 
 void js::Nursery::freeChunksFrom(unsigned firstFreeChunk) {
@@ -1235,18 +1243,19 @@ void js::Nursery::freeChunksFrom(unsigne
 
 void js::Nursery::shrinkAllocableSpace(unsigned newCapacity) {
 #ifdef JS_GC_ZEAL
   if (runtime()->hasZealMode(ZealMode::GenerationalGC)) {
     return;
   }
 #endif
 
-  unsigned stepSize = newCapacity < NurseryChunkUsableSize ? SubChunkStep :
-    NurseryChunkUsableSize;
+  unsigned stepSize = newCapacity < NurseryChunkUsableSize
+                          ? SubChunkStep
+                          : NurseryChunkUsableSize;
   newCapacity -= newCapacity % stepSize;
   // Don't shrink the nursery to zero (use Nursery::disable() instead)
   // This can't happen due to the rounding-down performed above because of the
   // clamping in maybeResizeNursery().
   MOZ_ASSERT(newCapacity != 0);
   // Don't attempt to shrink it to the same size.
   if (newCapacity == capacity()) {
     return;
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -5513,18 +5513,18 @@ MWasmCall* MWasmCall::New(TempAllocator&
   return call;
 }
 
 MWasmCall* MWasmCall::NewBuiltinInstanceMethodCall(
     TempAllocator& alloc, const wasm::CallSiteDesc& desc,
     const wasm::SymbolicAddress builtin, const ABIArg& instanceArg,
     const Args& args, MIRType resultType) {
   auto callee = wasm::CalleeDesc::builtinInstanceMethod(builtin);
-  MWasmCall* call = MWasmCall::New(alloc, desc, callee, args, resultType,
-                                   nullptr);
+  MWasmCall* call =
+      MWasmCall::New(alloc, desc, callee, args, resultType, nullptr);
   if (!call) {
     return nullptr;
   }
 
   MOZ_ASSERT(instanceArg != ABIArg());
   call->instanceArg_ = instanceArg;
   return call;
 }
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -11923,19 +11923,17 @@ class MWasmStackArg : public MUnaryInstr
 
 class MWasmCall final : public MVariadicInstruction, public NoTypePolicy::Data {
   wasm::CallSiteDesc desc_;
   wasm::CalleeDesc callee_;
   FixedList<AnyRegister> argRegs_;
   ABIArg instanceArg_;
 
   MWasmCall(const wasm::CallSiteDesc& desc, const wasm::CalleeDesc& callee)
-      : MVariadicInstruction(classOpcode),
-        desc_(desc),
-        callee_(callee) {}
+      : MVariadicInstruction(classOpcode), desc_(desc), callee_(callee) {}
 
  public:
   INSTRUCTION_HEADER(WasmCall)
 
   struct Arg {
     AnyRegister reg;
     MDefinition* def;
     Arg(AnyRegister reg, MDefinition* def) : reg(reg), def(def) {}
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -1276,18 +1276,17 @@ void AssertValidBigIntPtr(JSContext* cx,
 void AssertValidValue(JSContext* cx, Value* v) {
   AutoUnsafeCallWithABI unsafe;
   if (v->isObject()) {
     AssertValidObjectPtr(cx, &v->toObject());
   } else if (v->isString()) {
     AssertValidStringPtr(cx, v->toString());
   } else if (v->isSymbol()) {
     AssertValidSymbolPtr(cx, v->toSymbol());
-  }
-  else if (v->isBigInt()) {
+  } else if (v->isBigInt()) {
     AssertValidBigIntPtr(cx, v->toBigInt());
   }
 }
 
 bool ObjectIsCallable(JSObject* obj) {
   AutoUnsafeCallWithABI unsafe;
   return obj->isCallable();
 }
@@ -1865,18 +1864,17 @@ const VMFunction AddOrUpdateSparseElemen
 
 typedef bool (*GetSparseElementHelperFn)(JSContext* cx, HandleArrayObject obj,
                                          int32_t int_id,
                                          MutableHandleValue result);
 const VMFunction GetSparseElementHelperInfo =
     FunctionInfo<GetSparseElementHelperFn>(GetSparseElementHelper,
                                            "getSparseElementHelper");
 
-static bool DoToNumber(JSContext* cx, HandleValue arg,
-                       MutableHandleValue ret) {
+static bool DoToNumber(JSContext* cx, HandleValue arg, MutableHandleValue ret) {
   ret.set(arg);
   return ToNumber(cx, ret);
 }
 
 static bool DoToNumeric(JSContext* cx, HandleValue arg,
                         MutableHandleValue ret) {
   ret.set(arg);
   return ToNumeric(cx, ret);
--- a/js/src/jsapi-tests/testGCExactRooting.cpp
+++ b/js/src/jsapi-tests/testGCExactRooting.cpp
@@ -162,17 +162,17 @@ BEGIN_TEST(testGCRootedHashMap) {
 
   return true;
 }
 END_TEST(testGCRootedHashMap)
 
 // Repeat of the test above, but without rooting. This is a rooting hazard. The
 // JS_EXPECT_HAZARDS annotation will cause the hazard taskcluster job to fail
 // if the hazard below is *not* detected.
-BEGIN_TEST_WITH_ATTRIBUTES(testUnrootedGCHashMap,JS_EXPECT_HAZARDS) {
+BEGIN_TEST_WITH_ATTRIBUTES(testUnrootedGCHashMap, JS_EXPECT_HAZARDS) {
   MyHashMap map(cx, 15);
 
   for (size_t i = 0; i < 10; ++i) {
     RootedObject obj(cx, JS_NewObject(cx, nullptr));
     RootedValue val(cx, UndefinedValue());
     // Construct a unique property name to ensure that the object creates a
     // new shape.
     char buffer[2];
@@ -421,19 +421,19 @@ BEGIN_TEST(testGCHandleVector) {
 
   CHECK(CheckVector(cx, vec));
 
   return true;
 }
 END_TEST(testGCHandleVector)
 
 class Foo {
-  public:
-   Foo(int, int) {}
-   void trace(JSTracer*) {}
+ public:
+  Foo(int, int) {}
+  void trace(JSTracer*) {}
 };
 
 using FooVector = JS::GCVector<Foo>;
 
 BEGIN_TEST(testGCVectorEmplaceBack) {
   JS::Rooted<FooVector> vector(cx, FooVector(cx));
 
   CHECK(vector.emplaceBack(1, 2));
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -960,18 +960,17 @@ class JS_PUBLIC_API RealmCreationOptions
         invisibleToDebugger_(false),
         mergeable_(false),
         preserveJitCode_(false),
         cloneSingletons_(false),
         sharedMemoryAndAtomics_(false),
         streams_(false),
         bigint_(false),
         secureContext_(false),
-        clampAndJitterTime_(true) {
-  }
+        clampAndJitterTime_(true) {}
 
   JSTraceOp getTrace() const { return traceGlobal_; }
   RealmCreationOptions& setTrace(JSTraceOp op) {
     traceGlobal_ = op;
     return *this;
   }
 
   JS::Zone* zone() const {
--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -41,17 +41,17 @@ enum JSType {
   JSTYPE_UNDEFINED, /* undefined */
   JSTYPE_OBJECT,    /* object */
   JSTYPE_FUNCTION,  /* function */
   JSTYPE_STRING,    /* string */
   JSTYPE_NUMBER,    /* number */
   JSTYPE_BOOLEAN,   /* boolean */
   JSTYPE_NULL,      /* null */
   JSTYPE_SYMBOL,    /* symbol */
-  JSTYPE_BIGINT, /* BigInt */
+  JSTYPE_BIGINT,    /* BigInt */
   JSTYPE_LIMIT
 };
 
 /* Dense index into cached prototypes and class atoms for standard objects. */
 enum JSProtoKey {
 #define PROTOKEY_AND_INITIALIZER(name, init, clasp) JSProto_##name,
   JS_FOR_EACH_PROTOTYPE(PROTOKEY_AND_INITIALIZER)
 #undef PROTOKEY_AND_INITIALIZER
--- a/js/src/vm/EqualityOperations.cpp
+++ b/js/src/vm/EqualityOperations.cpp
@@ -12,19 +12,19 @@
 #include "jsnum.h"    // js::StringToNumber
 #include "jstypes.h"  // JS_PUBLIC_API
 
 #include "js/Equality.h"  // JS::LooselyEqual, JS::StrictlyEqual, JS::SameValue
 #include "js/Result.h"    // JS_TRY_VAR_OR_RETURN_FALSE
 #include "js/RootingAPI.h"  // JS::Rooted
 #include "js/Value.h"       // JS::Int32Value, JS::SameType, JS::Value
 #include "vm/BigIntType.h"  // JS::BigInt
-#include "vm/JSContext.h"     // CHECK_THREAD
-#include "vm/JSObject.h"      // js::ToPrimitive
-#include "vm/StringType.h"    // js::EqualStrings
+#include "vm/JSContext.h"   // CHECK_THREAD
+#include "vm/JSObject.h"    // js::ToPrimitive
+#include "vm/StringType.h"  // js::EqualStrings
 
 #include "builtin/Boolean-inl.h"  // js::EmulatesUndefined
 #include "vm/JSContext-inl.h"     // JSContext::check
 
 static bool EqualGivenSameType(JSContext* cx, JS::Handle<JS::Value> lval,
                                JS::Handle<JS::Value> rval, bool* equal) {
   MOZ_ASSERT(JS::SameType(lval, rval));
 
--- a/js/src/vm/TypeSet.h
+++ b/js/src/vm/TypeSet.h
@@ -85,20 +85,19 @@ enum : uint32_t {
   TYPE_FLAG_SYMBOL = 0x40,
   TYPE_FLAG_BIGINT = 0x80,
   TYPE_FLAG_LAZYARGS = 0x100,
   TYPE_FLAG_ANYOBJECT = 0x200,
 
   /* Mask containing all primitives */
   TYPE_FLAG_PRIMITIVE = TYPE_FLAG_UNDEFINED | TYPE_FLAG_NULL |
                         TYPE_FLAG_BOOLEAN | TYPE_FLAG_INT32 | TYPE_FLAG_DOUBLE |
-                        TYPE_FLAG_STRING | TYPE_FLAG_SYMBOL |
-                        TYPE_FLAG_BIGINT,
+                        TYPE_FLAG_STRING | TYPE_FLAG_SYMBOL | TYPE_FLAG_BIGINT,
 
-/* Mask/shift for the number of objects in objectSet */
+  /* Mask/shift for the number of objects in objectSet */
   TYPE_FLAG_OBJECT_COUNT_MASK = 0x3c00,
   TYPE_FLAG_OBJECT_COUNT_SHIFT = 10,
   TYPE_FLAG_OBJECT_COUNT_LIMIT = 7,
   TYPE_FLAG_DOMOBJECT_COUNT_LIMIT =
       TYPE_FLAG_OBJECT_COUNT_MASK >> TYPE_FLAG_OBJECT_COUNT_SHIFT,
 
   /* Whether the contents of this type set are totally unknown. */
   TYPE_FLAG_UNKNOWN = 0x00004000,
--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -4417,18 +4417,18 @@ class BaseCompiler final : public BaseCo
 #ifndef JS_CODEGEN_X86
       masm.loadWasmTlsRegFromFrame();
       masm.loadWasmPinnedRegsFromTls();
 #endif
     }
   }
 
   void startCallArgs(size_t stackArgAreaSizeUnaligned, FunctionCall* call) {
-    size_t stackArgAreaSizeAligned
-        = AlignStackArgAreaSize(stackArgAreaSizeUnaligned);
+    size_t stackArgAreaSizeAligned =
+        AlignStackArgAreaSize(stackArgAreaSizeUnaligned);
     MOZ_ASSERT(stackArgAreaSizeUnaligned <= stackArgAreaSizeAligned);
 
     // Record the masm.framePushed() value at this point, before we push args
     // for the call, but including the alignment space placed above the args.
     // This defines the lower limit of the stackmap that will be created for
     // this call.
     MOZ_ASSERT(
         stackMapGenerator_.framePushedExcludingOutboundCallArgs.isNothing());
@@ -6874,17 +6874,17 @@ class BaseCompiler final : public BaseCo
   void emitConvertU64ToF64();
 #endif
   void emitReinterpretI32AsF32();
   void emitReinterpretI64AsF64();
   void emitRound(RoundingMode roundingMode, ValType operandType);
   MOZ_MUST_USE bool emitInstanceCall(uint32_t lineOrBytecode,
                                      const MIRTypeVector& sig, ExprType retType,
                                      SymbolicAddress builtin,
-                                     bool pushReturnedValue=true);
+                                     bool pushReturnedValue = true);
   MOZ_MUST_USE bool emitGrowMemory();
   MOZ_MUST_USE bool emitCurrentMemory();
 
   MOZ_MUST_USE bool emitRefNull();
   void emitRefIsNull();
 
   MOZ_MUST_USE bool emitAtomicCmpXchg(ValType type, Scalar::Type viewType);
   MOZ_MUST_USE bool emitAtomicLoad(ValType type, Scalar::Type viewType);
@@ -9771,17 +9771,17 @@ void BaseCompiler::emitCompareRef(Assemb
   freeRef(rs1);
   freeRef(rs2);
   pushI32(rd);
 }
 
 bool BaseCompiler::emitInstanceCall(uint32_t lineOrBytecode,
                                     const MIRTypeVector& sig, ExprType retType,
                                     SymbolicAddress builtin,
-                                    bool pushReturnedValue/*=true*/) {
+                                    bool pushReturnedValue /*=true*/) {
   MOZ_ASSERT(sig[0] == MIRType::Pointer);
 
   sync();
 
   uint32_t numArgs = sig.length() - 1 /* instance */;
   size_t stackSpace = stackConsumed(numArgs);
 
   FunctionCall baselineCall(lineOrBytecode);
--- a/js/src/wasm/WasmGC.cpp
+++ b/js/src/wasm/WasmGC.cpp
@@ -14,12 +14,10 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #include "wasm/WasmGC.h"
 
 namespace js {
-namespace wasm {
-
-}  // namespace wasm
+namespace wasm {}  // namespace wasm
 }  // namespace js
--- a/js/src/wasm/WasmGC.h
+++ b/js/src/wasm/WasmGC.h
@@ -37,17 +37,17 @@ using namespace js::jit;
 // Note, StackArgAreaSize{Unaligned,Aligned}() must process all the arguments
 // in order to take into account all necessary alignment constraints.  The
 // signature must include any receiver argument -- in other words, it must be
 // the complete native-ABI-level call signature.
 template <class T>
 static inline size_t StackArgAreaSizeUnaligned(const T& argTypes) {
   ABIArgIter<const T> i(argTypes);
   while (!i.done()) {
-     i++;
+    i++;
   }
   return i.stackBytesConsumedSoFar();
 }
 
 static inline size_t AlignStackArgAreaSize(size_t unalignedSize) {
   return AlignBytes(unalignedSize, 16u);
 }
 
--- a/js/src/wasm/WasmIonCompile.cpp
+++ b/js/src/wasm/WasmIonCompile.cpp
@@ -1027,19 +1027,18 @@ class FunctionCompiler {
       callee = CalleeDesc::asmJSTable(table);
     } else {
       MOZ_ASSERT(funcType.id.kind() != FuncTypeIdDescKind::None);
       const TableDesc& table = env_.tables[tableIndex];
       callee = CalleeDesc::wasmTable(table, funcType.id);
     }
 
     CallSiteDesc desc(lineOrBytecode, CallSiteDesc::Dynamic);
-    auto* ins =
-        MWasmCall::New(alloc(), desc, callee, call.regArgs_,
-                       ToMIRType(funcType.ret()), index);
+    auto* ins = MWasmCall::New(alloc(), desc, callee, call.regArgs_,
+                               ToMIRType(funcType.ret()), index);
     if (!ins) {
       return false;
     }
 
     curBlock_->add(ins);
     *def = ins;
     return true;
   }
@@ -1070,18 +1069,18 @@ class FunctionCompiler {
                    MDefinition** def) {
     if (inDeadCode()) {
       *def = nullptr;
       return true;
     }
 
     CallSiteDesc desc(lineOrBytecode, CallSiteDesc::Symbolic);
     auto callee = CalleeDesc::builtin(builtin);
-    auto* ins = MWasmCall::New(alloc(), desc, callee, call.regArgs_,
-                               ToMIRType(ret));
+    auto* ins =
+        MWasmCall::New(alloc(), desc, callee, call.regArgs_, ToMIRType(ret));
     if (!ins) {
       return false;
     }
 
     curBlock_->add(ins);
     *def = ins;
     return true;
   }
@@ -2754,18 +2753,18 @@ static bool EmitWake(FunctionCompiler& f
     return false;
   }
 
   if (!f.finishCall(&args)) {
     return false;
   }
 
   MDefinition* ret;
-  if (!f.builtinInstanceMethodCall(SymbolicAddress::Wake, lineOrBytecode,
-                                   args, ValType::I32, &ret)) {
+  if (!f.builtinInstanceMethodCall(SymbolicAddress::Wake, lineOrBytecode, args,
+                                   ValType::I32, &ret)) {
     return false;
   }
 
   if (!f.checkI32NegativeMeansFailedResult(ret)) {
     return false;
   }
 
   f.iter().setResult(ret);
--- a/js/src/wasm/WasmStubs.cpp
+++ b/js/src/wasm/WasmStubs.cpp
@@ -34,44 +34,44 @@ using namespace js::wasm;
 
 using mozilla::ArrayLength;
 
 typedef Vector<jit::MIRType, 8, SystemAllocPolicy> MIRTypeVector;
 typedef jit::ABIArgIter<MIRTypeVector> ABIArgMIRTypeIter;
 typedef jit::ABIArgIter<ValTypeVector> ABIArgValTypeIter;
 
 #ifdef WASM_CODEGEN_DEBUG
-template<class Closure>
+template <class Closure>
 static void GenPrint(DebugChannel channel, MacroAssembler& masm,
-    const Maybe<Register>& taken, Closure passArgAndCall)
-{
-  if (!IsCodegenDebugEnabled(channel)){
+                     const Maybe<Register>& taken, Closure passArgAndCall) {
+  if (!IsCodegenDebugEnabled(channel)) {
     return;
   }
 
   AllocatableRegisterSet regs(RegisterSet::All());
   LiveRegisterSet save(regs.asLiveSet());
   masm.PushRegsInMask(save);
 
   if (taken) {
     regs.take(taken.value());
   }
   Register temp = regs.takeAnyGeneral();
 
   {
-    MOZ_ASSERT(MaybeGetJitContext(), "codegen debug checks require a jit context");
+    MOZ_ASSERT(MaybeGetJitContext(),
+               "codegen debug checks require a jit context");
     masm.setupUnalignedABICall(temp);
     passArgAndCall(IsCompilingWasm(), temp);
   }
 
   masm.PopRegsInMask(save);
 }
 
-static void GenPrintf(DebugChannel channel, MacroAssembler& masm, const char* fmt, ...)
-{
+static void GenPrintf(DebugChannel channel, MacroAssembler& masm,
+                      const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   UniqueChars str = JS_vsmprintf(fmt, ap);
   va_end(ap);
 
   // We leak the strings! This is done only for debugging purposes, and doing
   // the right thing is cumbersome (in Ion, it'd mean add a vec of strings to
   // the IonScript; in wasm, it'd mean add it to the current Module and
@@ -79,88 +79,99 @@ static void GenPrintf(DebugChannel chann
   const char* text = str.release();
 
   GenPrint(channel, masm, Nothing(), [&](bool inWasm, Register temp) {
     masm.movePtr(ImmPtr((void*)text, ImmPtr::NoCheckToken()), temp);
     masm.passABIArg(temp);
     if (inWasm) {
       masm.callDebugWithABI(SymbolicAddress::PrintText);
     } else {
-      masm.callWithABI((void*)PrintText, MoveOp::GENERAL, CheckUnsafeCallWithABI::DontCheckOther);
+      masm.callWithABI((void*)PrintText, MoveOp::GENERAL,
+                       CheckUnsafeCallWithABI::DontCheckOther);
     }
   });
 }
 
-static void GenPrintIsize(DebugChannel channel, MacroAssembler& masm, const Register& src)
-{
+static void GenPrintIsize(DebugChannel channel, MacroAssembler& masm,
+                          const Register& src) {
   GenPrint(channel, masm, Some(src), [&](bool inWasm, Register _temp) {
     masm.passABIArg(src);
     if (inWasm) {
       masm.callDebugWithABI(SymbolicAddress::PrintI32);
     } else {
-      masm.callWithABI((void*)PrintI32, MoveOp::GENERAL, CheckUnsafeCallWithABI::DontCheckOther);
+      masm.callWithABI((void*)PrintI32, MoveOp::GENERAL,
+                       CheckUnsafeCallWithABI::DontCheckOther);
     }
   });
 }
 
-static void GenPrintPtr(DebugChannel channel, MacroAssembler& masm, const Register& src)
-{
+static void GenPrintPtr(DebugChannel channel, MacroAssembler& masm,
+                        const Register& src) {
   GenPrint(channel, masm, Some(src), [&](bool inWasm, Register _temp) {
     masm.passABIArg(src);
     if (inWasm) {
       masm.callDebugWithABI(SymbolicAddress::PrintPtr);
     } else {
-      masm.callWithABI((void*)PrintPtr, MoveOp::GENERAL, CheckUnsafeCallWithABI::DontCheckOther);
+      masm.callWithABI((void*)PrintPtr, MoveOp::GENERAL,
+                       CheckUnsafeCallWithABI::DontCheckOther);
     }
   });
 }
 
-static void GenPrintI64(DebugChannel channel, MacroAssembler& masm, const Register64& src)
-{
-# if JS_BITS_PER_WORD == 64
+static void GenPrintI64(DebugChannel channel, MacroAssembler& masm,
+                        const Register64& src) {
+#  if JS_BITS_PER_WORD == 64
   GenPrintf(channel, masm, "i64 ");
   GenPrintIsize(channel, masm, src.reg);
-# else
+#  else
   GenPrintf(channel, masm, "i64(");
   GenPrintIsize(channel, masm, src.low);
   GenPrintIsize(channel, masm, src.high);
   GenPrintf(channel, masm, ") ");
-# endif
+#  endif
 }
 
-static void GenPrintF32(DebugChannel channel, MacroAssembler& masm, const FloatRegister& src)
-{
+static void GenPrintF32(DebugChannel channel, MacroAssembler& masm,
+                        const FloatRegister& src) {
   GenPrint(channel, masm, Nothing(), [&](bool inWasm, Register temp) {
     masm.passABIArg(src, MoveOp::FLOAT32);
     if (inWasm) {
       masm.callDebugWithABI(SymbolicAddress::PrintF32);
     } else {
-      masm.callWithABI((void*)PrintF32, MoveOp::GENERAL, CheckUnsafeCallWithABI::DontCheckOther);
+      masm.callWithABI((void*)PrintF32, MoveOp::GENERAL,
+                       CheckUnsafeCallWithABI::DontCheckOther);
     }
   });
 }
 
-static void GenPrintF64(DebugChannel channel, MacroAssembler& masm, const FloatRegister& src)
-{
+static void GenPrintF64(DebugChannel channel, MacroAssembler& masm,
+                        const FloatRegister& src) {
   GenPrint(channel, masm, Nothing(), [&](bool inWasm, Register temp) {
     masm.passABIArg(src, MoveOp::DOUBLE);
     if (inWasm) {
       masm.callDebugWithABI(SymbolicAddress::PrintF64);
     } else {
-      masm.callWithABI((void*)PrintF64, MoveOp::GENERAL, CheckUnsafeCallWithABI::DontCheckOther);
+      masm.callWithABI((void*)PrintF64, MoveOp::GENERAL,
+                       CheckUnsafeCallWithABI::DontCheckOther);
     }
   });
 }
 #else
-static void GenPrintf(DebugChannel channel, MacroAssembler& masm, const char* fmt, ...) {}
-static void GenPrintIsize(DebugChannel channel, MacroAssembler& masm, const Register& src) {}
-static void GenPrintPtr(DebugChannel channel, MacroAssembler& masm, const Register& src) {}
-static void GenPrintI64(DebugChannel channel, MacroAssembler& masm, const Register64& src) {}
-static void GenPrintF32(DebugChannel channel, MacroAssembler& masm, const FloatRegister& src) {}
-static void GenPrintF64(DebugChannel channel, MacroAssembler& masm, const FloatRegister& src) {}
+static void GenPrintf(DebugChannel channel, MacroAssembler& masm,
+                      const char* fmt, ...) {}
+static void GenPrintIsize(DebugChannel channel, MacroAssembler& masm,
+                          const Register& src) {}
+static void GenPrintPtr(DebugChannel channel, MacroAssembler& masm,
+                        const Register& src) {}
+static void GenPrintI64(DebugChannel channel, MacroAssembler& masm,
+                        const Register64& src) {}
+static void GenPrintF32(DebugChannel channel, MacroAssembler& masm,
+                        const FloatRegister& src) {}
+static void GenPrintF64(DebugChannel channel, MacroAssembler& masm,
+                        const FloatRegister& src) {}
 #endif
 
 static bool FinishOffsets(MacroAssembler& masm, Offsets* offsets) {
   // On old ARM hardware, constant pools could be inserted and they need to
   // be flushed before considering the size of the masm.
   masm.flushBuffer();
   offsets->end = masm.size();
   return !masm.oom();
@@ -672,17 +683,18 @@ static bool GenerateJitEntry(MacroAssemb
     GenerateJitEntryThrow(masm, frameSize);
     return FinishOffsets(masm, offsets);
   }
 
   FloatRegister scratchF = ABINonArgDoubleReg;
   Register scratchG = ScratchIonEntry;
   ValueOperand scratchV = ScratchValIonEntry;
 
-  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; arguments ", fe.funcIndex());
+  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; arguments ",
+            fe.funcIndex());
 
   // We do two loops:
   // - one loop up-front will make sure that all the Value tags fit the
   // expected signature argument types. If at least one inline conversion
   // fails, we just jump to the OOL path which will call into C++. Inline
   // conversions are ordered in the way we expect them to happen the most.
   // - the second loop will unbox the arguments into the right registers.
   Label oolCall;
@@ -852,17 +864,18 @@ static bool GenerateJitEntry(MacroAssemb
   // report the exception to the JIT caller by jumping into the exception
   // stub; otherwise the FP value is still set to the parent ion frame value.
   Label exception;
   masm.branchPtr(Assembler::Equal, FramePointer, Imm32(FailFP), &exception);
 
   // Pop arguments.
   masm.freeStack(frameSize);
 
-  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; returns ", fe.funcIndex());
+  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; returns ",
+            fe.funcIndex());
 
   // Store the return value in the JSReturnOperand.
   switch (fe.funcType().ret().code()) {
     case ExprType::Void:
       GenPrintf(DebugChannel::Function, masm, "void");
       masm.moveValue(UndefinedValue(), JSReturnOperand);
       break;
     case ExprType::I32:
@@ -999,27 +1012,35 @@ void wasm::GenerateDirectCallFromJit(Mac
   // Move stack arguments to their final locations.
   unsigned bytesNeeded = StackArgBytes(fe.funcType().args());
   bytesNeeded = StackDecrementForCall(WasmStackAlignment, masm.framePushed(),
                                       bytesNeeded);
   if (bytesNeeded) {
     masm.reserveStack(bytesNeeded);
   }
 
-  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; arguments ", fe.funcIndex());
+  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; arguments ",
+            fe.funcIndex());
 
   for (ABIArgValTypeIter iter(fe.funcType().args()); !iter.done(); iter++) {
     MOZ_ASSERT_IF(iter->kind() == ABIArg::GPR, iter->gpr() != scratch);
     MOZ_ASSERT_IF(iter->kind() == ABIArg::GPR, iter->gpr() != FramePointer);
     if (iter->kind() != ABIArg::Stack) {
       switch (iter.mirType()) {
-       case MIRType::Int32: GenPrintIsize(DebugChannel::Function, masm, iter->gpr()); break;
-       case MIRType::Float32: GenPrintF32(DebugChannel::Function, masm, iter->fpu()); break;
-       case MIRType::Double: GenPrintF64(DebugChannel::Function, masm, iter->fpu()); break;
-       default: MOZ_CRASH("ion to wasm fast path can only handle i32/f32/f64");
+        case MIRType::Int32:
+          GenPrintIsize(DebugChannel::Function, masm, iter->gpr());
+          break;
+        case MIRType::Float32:
+          GenPrintF32(DebugChannel::Function, masm, iter->fpu());
+          break;
+        case MIRType::Double:
+          GenPrintF64(DebugChannel::Function, masm, iter->fpu());
+          break;
+        default:
+          MOZ_CRASH("ion to wasm fast path can only handle i32/f32/f64");
       }
       continue;
     }
 
     Address dst(masm.getStackPointer(), iter->offsetFromArgBase());
 
     const JitCallStackArg& stackArg = stackArgs[iter.index()];
     switch (stackArg.tag()) {
@@ -1103,17 +1124,18 @@ void wasm::GenerateDirectCallFromJit(Mac
   masm.initPseudoStackPtr();
 #endif
   masm.assertStackAlignment(WasmStackAlignment);
 
   masm.branchPtr(Assembler::Equal, FramePointer, Imm32(wasm::FailFP),
                  masm.exceptionLabel());
 
   // Store the return value in the appropriate place.
-  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; returns ", fe.funcIndex());
+  GenPrintf(DebugChannel::Function, masm, "wasm-function[%d]; returns ",
+            fe.funcIndex());
   switch (fe.funcType().ret().code()) {
     case wasm::ExprType::Void:
       masm.moveValue(UndefinedValue(), JSReturnOperand);
       GenPrintf(DebugChannel::Function, masm, "void");
       break;
     case wasm::ExprType::I32:
       // The return value is in ReturnReg, which is what Ion expects.
       GenPrintIsize(DebugChannel::Function, masm, ReturnReg);
@@ -1188,21 +1210,21 @@ static void StackCopy(MacroAssembler& ma
   } else {
     MOZ_CRASH("StackCopy: unexpected type");
   }
 }
 
 typedef bool ToValue;
 
 static void FillArgumentArray(MacroAssembler& masm, unsigned funcImportIndex,
-                              const ValTypeVector& args,
-                              unsigned argOffset,
+                              const ValTypeVector& args, unsigned argOffset,
                               unsigned offsetToCallerStackArgs,
                               Register scratch, ToValue toValue) {
-  GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; arguments ", funcImportIndex);
+  GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; arguments ",
+            funcImportIndex);
   for (ABIArgValTypeIter i(args); !i.done(); i++) {
     Address dst(masm.getStackPointer(), argOffset + i.index() * sizeof(Value));
 
     MIRType type = i.mirType();
     switch (i->kind()) {
       case ABIArg::GPR:
         if (type == MIRType::Int32) {
           GenPrintIsize(DebugChannel::Import, masm, i->gpr());
@@ -1344,17 +1366,18 @@ static bool GenerateImportFunction(jit::
   for (; !i.done(); i++) {
     if (i->kind() != ABIArg::Stack) {
       continue;
     }
 
     Address src(masm.getStackPointer(),
                 offsetToCallerStackArgs + i->offsetFromArgBase());
     Address dst(masm.getStackPointer(), i->offsetFromArgBase());
-    GenPrintf(DebugChannel::Import, masm, "calling exotic import function with arguments: ");
+    GenPrintf(DebugChannel::Import, masm,
+              "calling exotic import function with arguments: ");
     StackCopy(masm, i.mirType(), scratch, src, dst);
     GenPrintf(DebugChannel::Import, masm, "\n");
   }
 
   // Call the import exit stub.
   CallSiteDesc desc(CallSiteDesc::Dynamic);
   MoveSPForJitABI(masm);
   masm.wasmCallImport(desc, CalleeDesc::import(fi.tlsDataOffset()));
@@ -1487,52 +1510,57 @@ static bool GenerateImportInterpExit(Mac
   MOZ_ASSERT(i.done());
 
   // Make the call, test whether it succeeded, and extract the return value.
   AssertStackAlignment(masm, ABIStackAlignment);
   switch (fi.funcType().ret().code()) {
     case ExprType::Void:
       masm.call(SymbolicAddress::CallImport_Void);
       masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
-      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ", funcImportIndex);
+      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ",
+                funcImportIndex);
       GenPrintf(DebugChannel::Import, masm, "void");
       break;
     case ExprType::I32:
       masm.call(SymbolicAddress::CallImport_I32);
       masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
       masm.load32(argv, ReturnReg);
-      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ", funcImportIndex);
+      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ",
+                funcImportIndex);
       GenPrintIsize(DebugChannel::Import, masm, ReturnReg);
       break;
     case ExprType::I64:
       masm.call(SymbolicAddress::CallImport_I64);
       masm.jump(throwLabel);
       break;
     case ExprType::F32:
       masm.call(SymbolicAddress::CallImport_F64);
       masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
       masm.loadDouble(argv, ReturnDoubleReg);
       masm.convertDoubleToFloat32(ReturnDoubleReg, ReturnFloat32Reg);
-      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ", funcImportIndex);
+      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ",
+                funcImportIndex);
       GenPrintF32(DebugChannel::Import, masm, ReturnFloat32Reg);
       break;
     case ExprType::F64:
       masm.call(SymbolicAddress::CallImport_F64);
       masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
       masm.loadDouble(argv, ReturnDoubleReg);
-      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ", funcImportIndex);
+      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ",
+                funcImportIndex);
       GenPrintF64(DebugChannel::Import, masm, ReturnDoubleReg);
       break;
     case ExprType::Ref:
       MOZ_CRASH("No Ref support here yet");
     case ExprType::AnyRef:
       masm.call(SymbolicAddress::CallImport_AnyRef);
       masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
       masm.loadPtr(argv, ReturnReg);
-      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ", funcImportIndex);
+      GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ",
+                funcImportIndex);
       GenPrintPtr(DebugChannel::Import, masm, ReturnReg);
       break;
     case ExprType::NullRef:
       MOZ_CRASH("NullRef not expressible");
     case ExprType::Limit:
       MOZ_CRASH("Limit");
   }
 
@@ -1551,18 +1579,19 @@ static bool GenerateImportInterpExit(Mac
                        offsets);
 
   return FinishOffsets(masm, offsets);
 }
 
 // Generate a stub that is called via the internal ABI derived from the
 // signature of the import and calls into a compatible JIT function,
 // having boxed all the ABI arguments into the JIT stack frame layout.
-static bool GenerateImportJitExit(MacroAssembler& masm, const FuncImport& fi, unsigned funcImportIndex,
-                                  Label* throwLabel, JitExitOffsets* offsets) {
+static bool GenerateImportJitExit(MacroAssembler& masm, const FuncImport& fi,
+                                  unsigned funcImportIndex, Label* throwLabel,
+                                  JitExitOffsets* offsets) {
   AssertExpectedSP(masm);
   masm.setFramePushed(0);
 
   // JIT calls use the following stack layout (sp grows to the left):
   //   | WasmToJSJitFrameLayout | this | arg1..N |
   // Unlike most ABIs, the JIT ABI requires that sp be JitStackAlignment-
   // aligned *after* pushing the return address.
   static_assert(WasmStackAlignment >= JitStackAlignment, "subsumes");
@@ -1617,17 +1646,18 @@ static bool GenerateImportJitExit(MacroA
   argOffset += sizeof(size_t);
   MOZ_ASSERT(argOffset == sizeOfPreFrame + frameAlignExtra);
 
   // 4. |this| value
   masm.storeValue(UndefinedValue(), Address(masm.getStackPointer(), argOffset));
   argOffset += sizeof(Value);
 
   // 5. Fill the arguments
-  unsigned offsetToCallerStackArgs = jitFramePushed + sizeof(Frame) + frameAlignExtra;
+  unsigned offsetToCallerStackArgs =
+      jitFramePushed + sizeof(Frame) + frameAlignExtra;
   FillArgumentArray(masm, funcImportIndex, fi.funcType().args(), argOffset,
                     offsetToCallerStackArgs, scratch, ToValue(true));
   argOffset += fi.funcType().args().length() * sizeof(Value);
   MOZ_ASSERT(argOffset == sizeOfThisAndArgs + sizeOfPreFrame + frameAlignExtra);
 
   // 6. Check if we need to rectify arguments
   masm.load16ZeroExtend(Address(callee, JSFunction::offsetOfNargs()), scratch);
 
@@ -1691,17 +1721,18 @@ static bool GenerateImportJitExit(MacroA
   {
     Label ok;
     masm.branchTestMagic(Assembler::NotEqual, JSReturnOperand, &ok);
     masm.breakpoint();
     masm.bind(&ok);
   }
 #endif
 
-  GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ", funcImportIndex);
+  GenPrintf(DebugChannel::Import, masm, "wasm-import[%u]; returns ",
+            funcImportIndex);
 
   Label oolConvert;
   switch (fi.funcType().ret().code()) {
     case ExprType::Void:
       GenPrintf(DebugChannel::Import, masm, "void");
       break;
     case ExprType::I32:
       masm.truncateValueToInt32(JSReturnOperand, ReturnDoubleReg, ReturnReg,
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -2963,18 +2963,17 @@ nsIFrame* nsCSSFrameConstructor::Constru
                                 childItems);
 
     comboboxFrame->SetInitialChildList(kPrincipalList, childItems);
 
     // Initialize the additional popup child list which contains the
     // dropdown list frame.
     nsFrameItems popupItems;
     popupItems.AddChild(listFrame);
-    comboboxFrame->SetInitialChildList(nsIFrame::kSelectPopupList,
-                                       popupItems);
+    comboboxFrame->SetInitialChildList(nsIFrame::kSelectPopupList, popupItems);
 
     aState.mFrameState = historyState;
     if (aState.mFrameState) {
       // Restore frame state for the entire subtree of |comboboxFrame|.
       RestoreFrameState(comboboxFrame, aState.mFrameState);
     }
     return comboboxFrame;
   }
--- a/layout/forms/nsRangeFrame.cpp
+++ b/layout/forms/nsRangeFrame.cpp
@@ -720,21 +720,20 @@ nsresult nsRangeFrame::AttributeChanged(
 }
 
 nscoord nsRangeFrame::AutoCrossSize(nscoord aEm) {
   nscoord minCrossSize(0);
   if (IsThemed()) {
     bool unused;
     LayoutDeviceIntSize size;
     nsPresContext* pc = PresContext();
-    pc->GetTheme()->GetMinimumWidgetSize(pc, this,
-                                         StyleAppearance::RangeThumb,
+    pc->GetTheme()->GetMinimumWidgetSize(pc, this, StyleAppearance::RangeThumb,
                                          &size, &unused);
-    minCrossSize = pc->DevPixelsToAppUnits(IsHorizontal() ? size.height
-                                                          : size.width);
+    minCrossSize =
+        pc->DevPixelsToAppUnits(IsHorizontal() ? size.height : size.width);
   }
   return std::max(minCrossSize, NSToCoordRound(CROSS_AXIS_EM_SIZE * aEm));
 }
 
 LogicalSize nsRangeFrame::ComputeAutoSize(
     gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
     nscoord aAvailableISize, const LogicalSize& aMargin,
     const LogicalSize& aBorder, const LogicalSize& aPadding,
@@ -765,18 +764,17 @@ nscoord nsRangeFrame::GetMinISize(gfxCon
         pos->ISize(wm).AsLengthPercentage(), nscoord(0));
   }
   return GetPrefISize(aRenderingContext);
 }
 
 nscoord nsRangeFrame::GetPrefISize(gfxContext* aRenderingContext) {
   bool isInline = IsInlineOriented();
   auto em = StyleFont()->mFont.size * nsLayoutUtils::FontSizeInflationFor(this);
-  return isInline ? NSToCoordRound(em * MAIN_AXIS_EM_SIZE)
-                  : AutoCrossSize(em);
+  return isInline ? NSToCoordRound(em * MAIN_AXIS_EM_SIZE) : AutoCrossSize(em);
 }
 
 bool nsRangeFrame::IsHorizontal() const {
   dom::HTMLInputElement* element =
       static_cast<dom::HTMLInputElement*>(GetContent());
   return element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
                               nsGkAtoms::horizontal, eCaseMatters) ||
          (!element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
--- a/layout/generic/WritingModes.h
+++ b/layout/generic/WritingModes.h
@@ -1978,17 +1978,18 @@ inline nsStyleCoord nsStyleSides::GetBEn
   return Get(aWM, mozilla::eLogicalSideBEnd);
 }
 
 // Definitions of inline methods for nsStylePosition, declared in
 // nsStyleStruct.h but not defined there because they need WritingMode.
 inline const mozilla::StyleSize& nsStylePosition::ISize(WritingMode aWM) const {
   return aWM.IsVertical() ? mHeight : mWidth;
 }
-inline const mozilla::StyleSize& nsStylePosition::MinISize(WritingMode aWM) const {
+inline const mozilla::StyleSize& nsStylePosition::MinISize(
+    WritingMode aWM) const {
   return aWM.IsVertical() ? mMinHeight : mMinWidth;
 }
 inline const mozilla::StyleMaxSize& nsStylePosition::MaxISize(
     WritingMode aWM) const {
   return aWM.IsVertical() ? mMaxHeight : mMaxWidth;
 }
 inline const mozilla::StyleSize& nsStylePosition::BSize(WritingMode aWM) const {
   return aWM.IsVertical() ? mWidth : mHeight;
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -379,19 +379,20 @@ bool nsHTMLScrollFrame::TryLayout(Scroll
   nsSize layoutSize = mHelper.mIsUsingMinimumScaleSize
                           ? mHelper.mMinimumScaleSize
                           : aState->mInsideBorderSize;
 
   const nsSize scrollPortSize =
       nsSize(std::max(0, layoutSize.width - vScrollbarDesiredWidth),
              std::max(0, layoutSize.height - hScrollbarDesiredHeight));
   if (mHelper.mIsUsingMinimumScaleSize) {
-    mHelper.mICBSize =
-        nsSize(std::max(0, aState->mInsideBorderSize.width - vScrollbarDesiredWidth),
-               std::max(0, aState->mInsideBorderSize.height - hScrollbarDesiredHeight));
+    mHelper.mICBSize = nsSize(
+        std::max(0, aState->mInsideBorderSize.width - vScrollbarDesiredWidth),
+        std::max(0,
+                 aState->mInsideBorderSize.height - hScrollbarDesiredHeight));
   }
 
   nsSize visualViewportSize = scrollPortSize;
   nsIPresShell* presShell = PresShell();
   if (mHelper.mIsRoot && presShell->IsVisualViewportSizeSet()) {
     nsSize compositionSize =
         nsLayoutUtils::CalculateCompositionSizeForFrame(this, false);
     float resolution = presShell->GetResolution();
--- a/layout/style/Loader.cpp
+++ b/layout/style/Loader.cpp
@@ -1317,18 +1317,17 @@ nsresult Loader::LoadSheet(SheetLoadData
     if (NS_FAILED(rv)) {
       LOG_ERROR(("  Failed to create channel"));
       SheetComplete(aLoadData, rv);
       return rv;
     }
 
     // snapshot the nonce at load start time for performing CSP checks
     if (contentPolicyType == nsIContentPolicy::TYPE_INTERNAL_STYLESHEET) {
-      nsCOMPtr<Element> element =
-          do_QueryInterface(aLoadData->mRequestingNode);
+      nsCOMPtr<Element> element = do_QueryInterface(aLoadData->mRequestingNode);
       if (element && element->IsHTMLElement()) {
         nsAutoString cspNonce;
         element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce);
         nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
         loadInfo->SetCspNonce(cspNonce);
       }
     }
 
--- a/layout/style/nsMediaFeatures.cpp
+++ b/layout/style/nsMediaFeatures.cpp
@@ -233,32 +233,38 @@ nsAtom* Gecko_MediaFeatures_GetOperating
 
 bool Gecko_MediaFeatures_PrefersReducedMotion(Document* aDocument) {
   if (nsContentUtils::ShouldResistFingerprinting(aDocument)) {
     return false;
   }
   return LookAndFeel::GetInt(LookAndFeel::eIntID_PrefersReducedMotion, 0) == 1;
 }
 
-StylePrefersColorScheme Gecko_MediaFeatures_PrefersColorScheme(Document* aDocument) {
+StylePrefersColorScheme Gecko_MediaFeatures_PrefersColorScheme(
+    Document* aDocument) {
   if (nsContentUtils::ShouldResistFingerprinting(aDocument)) {
     return StylePrefersColorScheme::Light;
   }
   if (nsPresContext* pc = aDocument->GetPresContext()) {
     if (pc->IsPrintingOrPrintPreview()) {
       return StylePrefersColorScheme::Light;
     }
   }
-  // If LookAndFeel::eIntID_SystemUsesDarkTheme fails then return 2 (no-preference)
+  // If LookAndFeel::eIntID_SystemUsesDarkTheme fails then return 2
+  // (no-preference)
   switch (LookAndFeel::GetInt(LookAndFeel::eIntID_SystemUsesDarkTheme, 2)) {
-    case 0: return StylePrefersColorScheme::Light;
-    case 1: return StylePrefersColorScheme::Dark;
-    case 2: return StylePrefersColorScheme::NoPreference;
+    case 0:
+      return StylePrefersColorScheme::Light;
+    case 1:
+      return StylePrefersColorScheme::Dark;
+    case 2:
+      return StylePrefersColorScheme::NoPreference;
     default:
-      // This only occurs if the user has set the ui.systemUsesDarkTheme pref to an invalid value.
+      // This only occurs if the user has set the ui.systemUsesDarkTheme pref to
+      // an invalid value.
       return StylePrefersColorScheme::Light;
   }
 }
 
 static PointerCapabilities GetPointerCapabilities(Document* aDocument,
                                                   LookAndFeel::IntID aID) {
   MOZ_ASSERT(aID == LookAndFeel::eIntID_PrimaryPointerCapabilities ||
              aID == LookAndFeel::eIntID_AllPointerCapabilities);
--- a/netwerk/base/nsSocketTransport2.cpp
+++ b/netwerk/base/nsSocketTransport2.cpp
@@ -2939,17 +2939,17 @@ nsSocketTransport::GetInterface(const ns
   if (iid.Equals(NS_GET_IID(nsIDNSRecord))) {
     return mDNSRecord ? mDNSRecord->QueryInterface(iid, result)
                       : NS_ERROR_NO_INTERFACE;
   }
   return this->QueryInterface(iid, result);
 }
 
 NS_IMETHODIMP
-nsSocketTransport::GetInterfaces(nsTArray<nsIID>& array) {
+nsSocketTransport::GetInterfaces(nsTArray<nsIID> &array) {
   return NS_CI_INTERFACE_GETTER_NAME(nsSocketTransport)(array);
 }
 
 NS_IMETHODIMP
 nsSocketTransport::GetScriptableHelper(nsIXPCScriptable **_retval) {
   *_retval = nullptr;
   return NS_OK;
 }
--- a/toolkit/components/places/tests/gtest/places_test_harness_tail.h
+++ b/toolkit/components/places/tests/gtest/places_test_harness_tail.h
@@ -50,17 +50,18 @@ void do_test_finished() {
   NS_ASSERTION(NS_IsMainThread(), "Not running on the main thread?");
   NS_ASSERTION(gPendingTests > 0, "Invalid pending test count!");
   gPendingTests--;
 }
 
 void disable_idle_service() {
   (void)fprintf(stderr, TEST_INFO_STR "Disabling Idle Service.\n");
 
-  nsCOMPtr<nsIIdleService> idle = do_GetService("@mozilla.org/widget/idleservice;1");
+  nsCOMPtr<nsIIdleService> idle =
+      do_GetService("@mozilla.org/widget/idleservice;1");
   idle->SetDisabled(true);
 }
 
 TEST(IHistory, Test) {
   RefPtr<WaitForConnectionClosed> spinClose = new WaitForConnectionClosed();
 
   // Tinderboxes are constantly on idle.  Since idle tasks can interact with
   // tests, causing random failures, disable the idle service.
--- a/toolkit/components/telemetry/core/Telemetry.cpp
+++ b/toolkit/components/telemetry/core/Telemetry.cpp
@@ -2108,18 +2108,16 @@ void RecordEvent(mozilla::Telemetry::Eve
                  const mozilla::Maybe<nsTArray<EventExtraEntry>>& aExtra) {
   TelemetryEvent::RecordEventNative(aId, aValue, aExtra);
 }
 
 void SetEventRecordingEnabled(const nsACString& aCategory, bool aEnabled) {
   TelemetryEvent::SetEventRecordingEnabled(aCategory, aEnabled);
 }
 
-void ShutdownTelemetry() {
-  TelemetryImpl::ShutdownTelemetry();
-}
+void ShutdownTelemetry() { TelemetryImpl::ShutdownTelemetry(); }
 
 }  // namespace Telemetry
 }  // namespace mozilla
 
 NS_IMPL_COMPONENT_FACTORY(nsITelemetry) {
   return TelemetryImpl::CreateTelemetryInstance().downcast<nsISupports>();
 }
--- a/toolkit/system/gnome/nsGConfService.h
+++ b/toolkit/system/gnome/nsGConfService.h
@@ -5,18 +5,18 @@
 
 #ifndef nsGConfService_h_
 #define nsGConfService_h_
 
 #include "nsIGConfService.h"
 #include "mozilla/Attributes.h"
 
 extern "C" {
-  struct _GConfClient;
-  typedef struct _GConfClient GConfClient;
+struct _GConfClient;
+typedef struct _GConfClient GConfClient;
 }
 
 class nsGConfService final : public nsIGConfService {
  public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIGCONFSERVICE
 
   nsGConfService() : mClient(nullptr) {}
--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -2141,17 +2141,18 @@ static nsresult SelectProfile(nsToolkitP
   }
   if (ar == ARG_FOUND) {
     gDoMigration = true;
   }
 
   // Ask the profile manager to select the profile directories to use.
   bool didCreate = false;
   rv = aProfileSvc->SelectStartupProfile(&gArgc, gArgv, gDoProfileReset,
-      aRootDir, aLocalDir, aProfile, &didCreate);
+                                         aRootDir, aLocalDir, aProfile,
+                                         &didCreate);
 
   if (rv == NS_ERROR_SHOW_PROFILE_MANAGER) {
     return ShowProfileManager(aProfileSvc, aNative);
   }
 
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (didCreate) {
@@ -3787,28 +3788,28 @@ int XREMain::XRE_mainStartup(bool* aExit
   if (!aExitFlag) return 1;
   *aExitFlag = false;
 
   SetShutdownChecks();
 
   // Enable Telemetry IO Reporting on DEBUG, nightly and local builds,
   // but disable it on FUZZING builds.
 #ifndef FUZZING
-#ifdef DEBUG
+#  ifdef DEBUG
   mozilla::Telemetry::InitIOReporting(gAppData->xreDirectory);
-#else
+#  else
   {
     const char* releaseChannel = NS_STRINGIFY(MOZ_UPDATE_CHANNEL);
     if (strcmp(releaseChannel, "nightly") == 0 ||
         strcmp(releaseChannel, "default") == 0) {
       mozilla::Telemetry::InitIOReporting(gAppData->xreDirectory);
     }
   }
-#endif /* DEBUG */
-#endif /* FUZZING */
+#  endif /* DEBUG */
+#endif   /* FUZZING */
 
 #if defined(XP_WIN)
   // Enable the HeapEnableTerminationOnCorruption exploit mitigation. We ignore
   // the return code because it always returns success, although it has no
   // effect on Windows older than XP SP3.
   HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
 #endif /* XP_WIN */
 
@@ -4155,17 +4156,17 @@ int XREMain::XRE_mainStartup(bool* aExit
     // We failed to choose or create profile - notify user and quit
     ProfileMissingDialog(mNativeApp);
     return 1;
   }
 
   // We always want to lock the profile even if we're actually going to reset
   // it later.
   rv = LockProfile(mNativeApp, mProfD, mProfLD, profile,
-      getter_AddRefs(mProfileLock));
+                   getter_AddRefs(mProfileLock));
   if (rv == NS_ERROR_LAUNCHED_CHILD_PROCESS || rv == NS_ERROR_ABORT) {
     *aExitFlag = true;
     return 0;
   } else if (NS_FAILED(rv)) {
     return 1;
   }
 
   if (gDoProfileReset) {
@@ -4493,18 +4494,18 @@ nsresult XREMain::XRE_mainRun() {
           aKey = MOZ_APP_NAME;
           gResetOldProfile->GetName(aName);
         }
         pm->Migrate(&mDirProvider, aKey, aName);
       }
     }
 
     if (gDoProfileReset) {
-      nsresult backupCreated = ProfileResetCleanup(mProfileSvc,
-          gResetOldProfile);
+      nsresult backupCreated =
+          ProfileResetCleanup(mProfileSvc, gResetOldProfile);
       if (NS_FAILED(backupCreated))
         NS_WARNING("Could not cleanup the profile that was reset");
     }
   }
 
 #ifndef XP_WIN
   nsCOMPtr<nsIFile> profileDir;
   nsAutoCString path;
--- a/tools/profiler/core/platform.cpp
+++ b/tools/profiler/core/platform.cpp
@@ -771,18 +771,17 @@ class ActivePS {
           MOZ_RELEASE_ASSERT(bufferPosition,
                              "should have unregistered this page");
           return *bufferPosition < bufferRangeStart;
         });
   }
 
 #if !defined(RELEASE_OR_BETA)
   static void UnregisterIOInterposer(PSLockRef) {
-    if (!sInstance->mInterposeObserver)
-      return;
+    if (!sInstance->mInterposeObserver) return;
 
     IOInterposer::Unregister(IOInterposeObserver::OpAll,
                              sInstance->mInterposeObserver);
 
     sInstance->mInterposeObserver = nullptr;
   }
 #endif
 
--- a/tools/profiler/public/GeckoProfiler.h
+++ b/tools/profiler/public/GeckoProfiler.h
@@ -745,20 +745,19 @@ class MOZ_RAII AutoProfilerTextMarker {
   nsCString mText;
   const js::ProfilingStackFrame::Category mCategory;
   mozilla::TimeStamp mStartTime;
   UniqueProfilerBacktrace mCause;
   const mozilla::Maybe<nsID> mDocShellId;
   const mozilla::Maybe<uint32_t> mDocShellHistoryId;
 };
 
-#  define AUTO_PROFILER_TEXT_MARKER_CAUSE(markerName, text, category,    \
-                                          cause)                         \
-    AutoProfilerTextMarker PROFILER_RAII(                                \
-        markerName, text, js::ProfilingStackFrame::Category::category,   \
+#  define AUTO_PROFILER_TEXT_MARKER_CAUSE(markerName, text, category, cause) \
+    AutoProfilerTextMarker PROFILER_RAII(                                    \
+        markerName, text, js::ProfilingStackFrame::Category::category,       \
         Nothing(), Nothing(), cause)
 
 #  define AUTO_PROFILER_TEXT_MARKER_DOCSHELL(markerName, text, category, \
                                              docShell)                   \
     DECLARE_DOCSHELL_AND_HISTORY_ID(docShell);                           \
     AutoProfilerTextMarker PROFILER_RAII(                                \
         markerName, text, js::ProfilingStackFrame::Category::category,   \
         docShellId, docShellHistoryId)
--- a/tools/profiler/public/ProfilerMarkerPayload.h
+++ b/tools/profiler/public/ProfilerMarkerPayload.h
@@ -117,19 +117,20 @@ class TracingMarkerPayload : public Prof
  private:
   const char* mCategory;
   TracingKind mKind;
 };
 
 class DiskIOMarkerPayload : public ProfilerMarkerPayload {
  public:
   DiskIOMarkerPayload(const char* aOperation, const char* aSource,
-                  const char* aFilename, const mozilla::TimeStamp& aStartTime,
-                  const mozilla::TimeStamp& aEndTime,
-                  UniqueProfilerBacktrace aStack)
+                      const char* aFilename,
+                      const mozilla::TimeStamp& aStartTime,
+                      const mozilla::TimeStamp& aEndTime,
+                      UniqueProfilerBacktrace aStack)
       : ProfilerMarkerPayload(aStartTime, aEndTime, mozilla::Nothing(),
                               mozilla::Nothing(), std::move(aStack)),
         mSource(aSource),
         mOperation(aOperation ? strdup(aOperation) : nullptr),
         mFilename(aFilename ? strdup(aFilename) : nullptr) {
     MOZ_ASSERT(aSource);
   }
 
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -2009,20 +2009,20 @@ nsComponentManagerImpl::RemoveBootstrapp
   // Remove reference.
   nsComponentManagerImpl::sModuleLocations->RemoveElement(
       elem, ComponentLocationComparator());
 
   rv = cr->CheckForNewChrome();
   return rv;
 }
 
-
 NS_IMETHODIMP
 nsComponentManagerImpl::GetComponentJSMs(nsIUTF8StringEnumerator** aJSMs) {
-  nsCOMPtr<nsIUTF8StringEnumerator> result = StaticComponents::GetComponentJSMs();
+  nsCOMPtr<nsIUTF8StringEnumerator> result =
+      StaticComponents::GetComponentJSMs();
   result.forget(aJSMs);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::GetManifestLocations(nsIArray** aLocations) {
   NS_ENSURE_ARG_POINTER(aLocations);
   *aLocations = nullptr;
--- a/xpcom/ds/nsObserverService.cpp
+++ b/xpcom/ds/nsObserverService.cpp
@@ -273,18 +273,18 @@ NS_IMETHODIMP nsObserverService::NotifyO
 
   MOZ_TRY(EnsureValidCall());
   if (NS_WARN_IF(!aTopic)) {
     return NS_ERROR_INVALID_ARG;
   }
 
   mozilla::TimeStamp start = TimeStamp::Now();
 
-  AUTO_PROFILER_TEXT_MARKER_CAUSE("NotifyObservers", nsDependentCString(aTopic), OTHER,
-                                  profiler_get_backtrace());
+  AUTO_PROFILER_TEXT_MARKER_CAUSE("NotifyObservers", nsDependentCString(aTopic),
+                                  OTHER, profiler_get_backtrace());
   AUTO_PROFILER_LABEL_DYNAMIC_CSTR("nsObserverService::NotifyObservers", OTHER,
                                    aTopic);
 
   nsObserverList* observerList = mObserverTopicTable.GetEntry(aTopic);
   if (observerList) {
     observerList->NotifyObservers(aSubject, aTopic, aSomeData);
   }