Merge mozilla-inbound to mozilla-central. a=merge
authorDaniel Varga <dvarga@mozilla.com>
Sun, 17 Feb 2019 23:44:23 +0200
changeset 517598 3d6a4067fd12
parent 517587 3cfaf4c60ad2 (current diff)
parent 517597 dc08d3602655 (diff)
child 517600 cb522060b7a7
child 517625 d01ca584035b
push id10862
push userffxbld-merge
push dateMon, 11 Mar 2019 13:01:11 +0000
treeherdermozilla-beta@a2e7f5c935da [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone67.0a1
first release with
nightly linux32
3d6a4067fd12 / 67.0a1 / 20190217214556 / files
nightly linux64
3d6a4067fd12 / 67.0a1 / 20190217214556 / files
nightly mac
3d6a4067fd12 / 67.0a1 / 20190217214556 / files
nightly win32
3d6a4067fd12 / 67.0a1 / 20190217214556 / files
nightly win64
3d6a4067fd12 / 67.0a1 / 20190217214556 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-inbound to mozilla-central. a=merge
--- 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/nsFocusManager.cpp
+++ b/dom/base/nsFocusManager.cpp
@@ -2839,17 +2839,18 @@ nsresult nsFocusManager::DetermineElemen
     // to, so just break out
     if (startContent == originalStartContent) break;
   }
 
   return NS_OK;
 }
 
 static bool IsHostOrSlot(const nsIContent* aContent) {
-  return aContent->GetShadowRoot() || aContent->IsHTMLElement(nsGkAtoms::slot);
+  return aContent && (aContent->GetShadowRoot() ||
+                      aContent->IsHTMLElement(nsGkAtoms::slot));
 }
 
 // Helper class to iterate contents in scope by traversing flattened tree
 // in tree order
 class MOZ_STACK_CLASS ScopedContentTraversal {
  public:
   ScopedContentTraversal(nsIContent* aStartContent, nsIContent* aOwner)
       : mCurrent(aStartContent), mOwner(aOwner) {
--- 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
@@ -2342,18 +2342,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
@@ -2964,18 +2964,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/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/taskcluster/taskgraph/transforms/job/common.py
+++ b/taskcluster/taskgraph/transforms/job/common.py
@@ -155,31 +155,39 @@ def support_vcs_checkout(config, job, ta
     # for hg.mozilla.org.
     taskdesc['scopes'].append('secrets:get:project/taskcluster/gecko/hgfingerprint')
 
     # only some worker platforms have taskcluster-proxy enabled
     if job['worker']['implementation'] in ('docker-worker',):
         taskdesc['worker']['taskcluster-proxy'] = True
 
 
-def generic_worker_hg_commands(base_repo, head_repo, head_rev, path):
+def generic_worker_hg_commands(base_repo, head_repo, head_rev, path,
+                               sparse_profile=None):
     """Obtain commands needed to obtain a Mercurial checkout on generic-worker.
 
     Returns two command strings. One performs the checkout. Another logs.
     """
     args = [
         r'"c:\Program Files\Mercurial\hg.exe"',
         'robustcheckout',
         '--sharebase', r'y:\hg-shared',
         '--purge',
         '--upstream', base_repo,
         '--revision', head_rev,
+    ]
+
+    if sparse_profile:
+        args.extend(['--config', 'extensions.sparse='])
+        args.extend(['--sparseprofile', sparse_profile])
+
+    args.extend([
         head_repo,
         path,
-    ]
+    ])
 
     logging_args = [
         b":: TinderboxPrint:<a href={source_repo}/rev/{revision} "
         b"title='Built from {repo_name} revision {revision}'>{revision}</a>"
         b"\n".format(
             revision=head_rev,
             source_repo=head_repo,
             repo_name=head_repo.split('/')[-1]),
--- a/taskcluster/taskgraph/transforms/job/toolchain.py
+++ b/taskcluster/taskgraph/transforms/job/toolchain.py
@@ -118,17 +118,17 @@ def docker_worker_toolchain(config, job,
     worker.setdefault('docker-image', {'in-tree': 'toolchain-build'})
 
     # Allow the job to specify where artifacts come from, but add
     # public/build if it's not there already.
     artifacts = worker.setdefault('artifacts', [])
     if not any(artifact.get('name') == 'public/build' for artifact in artifacts):
         docker_worker_add_artifacts(config, job, taskdesc)
 
-    support_vcs_checkout(config, job, taskdesc, sparse=True)
+    support_vcs_checkout(config, job, taskdesc, sparse=('sparse-profile' in run))
 
     # Toolchain checkouts don't live under {workdir}/checkouts
     workspace = '{workdir}/workspace/build'.format(**run)
     gecko_path = '{}/src'.format(workspace)
 
     env = worker['env']
     env.update({
         'MOZ_BUILD_DATE': config.params['moz_build_date'],
@@ -192,30 +192,38 @@ def windows_toolchain(config, job, taskd
     worker = taskdesc['worker']
 
     worker['artifacts'] = [{
         'path': r'public\build',
         'type': 'directory',
     }]
     worker['chain-of-trust'] = True
 
-    support_vcs_checkout(config, job, taskdesc)
+    # There were no caches on generic-worker before bug 1519472, and they cause
+    # all sorts of problems with toolchain tasks, disable them until
+    # tasks are ready.
+    run['use-caches'] = False
+    support_vcs_checkout(config, job, taskdesc, sparse=('sparse-profile' in run))
 
     env = worker['env']
     env.update({
         'MOZ_BUILD_DATE': config.params['moz_build_date'],
         'MOZ_SCM_LEVEL': config.params['level'],
         'MOZ_AUTOMATION': '1',
     })
 
+    sparse_profile = run.get('sparse-profile')
+    if sparse_profile:
+        sparse_profile = 'build/sparse-profiles/{}'.format(run['sparse-profile'])
+
     hg_command = generic_worker_hg_commands(
         'https://hg.mozilla.org/mozilla-unified',
         env['GECKO_HEAD_REPOSITORY'],
         env['GECKO_HEAD_REV'],
-        r'.\build\src')[0]
+        r'.\build\src', sparse_profile=sparse_profile)[0]
 
     # Use `mach` to invoke python scripts so in-tree libraries are available.
     if run['script'].endswith('.py'):
         raise NotImplementedError("Python scripts don't work on Windows")
 
     args = run.get('arguments', '')
     if args:
         args = ' ' + shell_quote(*args)
--- 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) {
@@ -4239,17 +4240,18 @@ int XREMain::XRE_mainStartup(bool* aExit
   nsCString lastVersion;
   bool versionOK = CheckCompatibility(
       mProfD, version, osABI, mDirProvider.GetGREDir(), mAppData->directory,
       flagFile, &cachesOK, &isDowngrade, lastVersion);
 
 #ifdef MOZ_BLOCK_PROFILE_DOWNGRADE
   // The argument check must come first so the argument is always removed from
   // the command line regardless of whether this is a downgrade or not.
-  if (!CheckArg("allow-downgrade") && isDowngrade) {
+  if (!CheckArg("allow-downgrade") && isDowngrade &&
+      !EnvHasValue("MOZ_ALLOW_DOWNGRADE")) {
     rv = CheckDowngrade(mProfD, mNativeApp, mProfileSvc, lastVersion);
     if (rv == NS_ERROR_LAUNCHED_CHILD_PROCESS || rv == NS_ERROR_ABORT) {
       *aExitFlag = true;
       return 0;
     }
   }
 #endif
 
@@ -4493,18 +4495,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/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);
   }