Bug 1519636 - Reformat recent changes to the Google coding style r=jgilbert
authorSylvestre Ledru <sledru@mozilla.com>
Sun, 05 Apr 2020 13:34:58 +0000
changeset 522171 65fc57fa542cdab20869f8992cdce86f8517f94e
parent 522170 c2bc295035ae1ceaa5b13f190856bf08346eeddb
child 522172 84bc52da6c3b8a78b60c714d0b6ee022f0771acb
push id37284
push usernerli@mozilla.com
push dateSun, 05 Apr 2020 21:25:22 +0000
treeherdermozilla-central@84bc52da6c3b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjgilbert
bugs1519636
milestone76.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1519636 - Reformat recent changes to the Google coding style r=jgilbert # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D67574
accessible/base/ARIAMap.cpp
docshell/shistory/SHistoryChild.cpp
dom/animation/Animation.cpp
dom/base/nsNodeInfoManager.h
dom/canvas/WebGLValidateStrings.cpp
dom/html/input/NumericInputTypes.cpp
dom/ipc/ContentChild.cpp
dom/ipc/ContentParent.h
dom/media/MediaManager.cpp
dom/svg/SVGAnimatedTransformList.cpp
gfx/2d/2D.h
gfx/2d/DrawTargetD2D1.cpp
gfx/layers/TiledLayerBuffer.h
gfx/layers/ipc/CompositorBench.cpp
gfx/layers/ipc/RemoteContentController.cpp
gfx/layers/ipc/UiCompositorControllerParent.cpp
gfx/layers/wr/IpcResourceUpdateQueue.cpp
gfx/layers/wr/IpcResourceUpdateQueue.h
gfx/thebes/gfxFontUtils.cpp
gfx/thebes/gfxPattern.h
gfx/thebes/gfxPlatform.cpp
gfx/thebes/gfxUtils.cpp
gfx/webrender_bindings/WebRenderAPI.h
gfx/webrender_bindings/webrender_ffi.h
ipc/chromium/src/base/shared_memory.h
ipc/chromium/src/base/shared_memory_posix.cc
ipc/glue/ForkServiceChild.cpp
js/src/builtin/MapObject.cpp
js/src/builtin/Promise-inl.h
js/src/builtin/streams/MiscellaneousOperations.h
js/src/builtin/streams/PipeToState.cpp
js/src/builtin/streams/ReadableStreamDefaultControllerOperations.cpp
js/src/builtin/streams/ReadableStreamDefaultReader.cpp
js/src/builtin/streams/ReadableStreamInternals.cpp
js/src/builtin/streams/ReadableStreamReader.cpp
js/src/builtin/streams/WritableStreamDefaultControllerOperations.cpp
js/src/builtin/streams/WritableStreamDefaultWriter.cpp
js/src/builtin/streams/WritableStreamOperations.cpp
js/src/fuzz-tests/tests.cpp
js/src/gc/MaybeRooted.h
js/src/vm/PromiseObject.h
layout/base/PositionedEventTargeting.cpp
layout/base/nsCSSFrameConstructor.cpp
layout/base/nsDocumentViewer.cpp
layout/generic/nsBlockFrame.cpp
layout/xul/nsBox.cpp
layout/xul/nsTextBoxFrame.cpp
memory/replace/phc/test/gtest/TestPHC.cpp
mfbt/CheckedInt.h
mfbt/TsanOptions.h
mozglue/build/TsanOptions.cpp
netwerk/protocol/http/Http3Session.cpp
netwerk/protocol/http/HttpConnectionUDP.cpp
netwerk/protocol/http/nsHttpConnection.h
netwerk/protocol/http/nsHttpConnectionMgr.cpp
netwerk/protocol/http/nsHttpHandler.h
toolkit/components/antitracking/ContentBlockingAllowList.h
toolkit/components/telemetry/core/Telemetry.cpp
toolkit/mozapps/defaultagent/ScheduledTask.cpp
toolkit/mozapps/defaultagent/Telemetry.cpp
toolkit/mozapps/defaultagent/common.h
toolkit/mozapps/update/updater/TsanOptions.cpp
widget/gtk/nsDragService.cpp
xpcom/build/XPCOMInit.cpp
--- a/accessible/base/ARIAMap.cpp
+++ b/accessible/base/ARIAMap.cpp
@@ -1298,17 +1298,17 @@ static const nsRoleMapEntry sWAIRoleMaps
 };
 
 static const nsRoleMapEntry sLandmarkRoleMap = {
     nsGkAtoms::_empty, roles::NOTHING, kUseNativeRole,  eNoValue,
     eNoAction,         eNoLiveAttr,    kGenericAccType, kNoReqStates};
 
 nsRoleMapEntry aria::gEmptyRoleMap = {
     nsGkAtoms::_empty, roles::TEXT_CONTAINER, kUseMapRole,     eNoValue,
-    eNoAction,         eNoLiveAttr,    kGenericAccType, kNoReqStates};
+    eNoAction,         eNoLiveAttr,           kGenericAccType, kNoReqStates};
 
 /**
  * Universal (Global) states:
  * The following state rules are applied to any accessible element,
  * whether there is an ARIA role or not:
  */
 static const EStateRule sWAIUnivStateMap[] = {
     eARIABusy,     eARIACurrent, eARIADisabled,
--- a/docshell/shistory/SHistoryChild.cpp
+++ b/docshell/shistory/SHistoryChild.cpp
@@ -371,19 +371,19 @@ SHistoryChild::CreateEntry(nsISHEntry** 
     return NS_ERROR_FAILURE;
   }
   entry.forget(aEntry);
   return NS_OK;
 }
 
 nsresult SHistoryChild::LoadURI(nsTArray<LoadSHEntryData>& aLoadData) {
   for (LoadSHEntryData& l : aLoadData) {
-     if (l.browsingContext().IsNullOrDiscarded()) {
-       continue;
-     }
+    if (l.browsingContext().IsNullOrDiscarded()) {
+      continue;
+    }
 
     nsCOMPtr<nsIDocShell> docShell = l.browsingContext().get()->GetDocShell();
     if (!docShell) {
       continue;
     }
 
     RefPtr<SHEntryChild> entry;
     if (l.shEntry()) {
--- a/dom/animation/Animation.cpp
+++ b/dom/animation/Animation.cpp
@@ -13,17 +13,17 @@
 #include "mozilla/dom/Document.h"
 #include "mozilla/dom/DocumentInlines.h"
 #include "mozilla/dom/DocumentTimeline.h"
 #include "mozilla/dom/MutationObservers.h"
 #include "mozilla/AnimationEventDispatcher.h"
 #include "mozilla/AnimationTarget.h"
 #include "mozilla/AutoRestore.h"
 #include "mozilla/DeclarationBlock.h"
-#include "mozilla/Maybe.h"       // For Maybe
+#include "mozilla/Maybe.h"  // For Maybe
 #include "mozilla/StaticPrefs_dom.h"
 #include "nsAnimationManager.h"  // For CSSAnimation
 #include "nsComputedDOMStyle.h"
 #include "nsDOMMutationObserver.h"    // For nsAutoAnimationMutationBatch
 #include "nsDOMCSSAttrDeclaration.h"  // For nsDOMCSSAttributeDeclaration
 #include "nsThreadUtils.h"  // For nsRunnableMethod and nsRevocableEventPtr
 #include "nsTransitionManager.h"      // For CSSTransition
 #include "PendingAnimationTracker.h"  // For PendingAnimationTracker
--- a/dom/base/nsNodeInfoManager.h
+++ b/dom/base/nsNodeInfoManager.h
@@ -112,19 +112,17 @@ class nsNodeInfoManager final {
 
   mozilla::dom::DOMArena* GetArenaAllocator() { return mArena; }
   void SetArenaAllocator(mozilla::dom::DOMArena* aArena);
 
   void* Allocate(size_t aSize);
 
   void Free(void* aPtr) { free(aPtr); }
 
-  bool HasAllocated() {
-    return mHasAllocated;
-  }
+  bool HasAllocated() { return mHasAllocated; }
 
   void AddSizeOfIncludingThis(nsWindowSizes& aSizes) const;
 
  protected:
   friend class mozilla::dom::Document;
   friend class nsXULPrototypeDocument;
 
   /**
--- a/dom/canvas/WebGLValidateStrings.cpp
+++ b/dom/canvas/WebGLValidateStrings.cpp
@@ -21,27 +21,29 @@ not including, the terminating newline.
 
   - The begin comment delimiters (/ * or //) are not recognized as comment
 delimiters inside of a comment, hence comments cannot be nested.
 
   - Comments are treated syntactically as a single space.
 */
 
 std::string CommentsToSpaces(const std::string& src) {
-  constexpr auto flags = std::regex::ECMAScript | std::regex::nosubs | std::regex::optimize;
+  constexpr auto flags =
+      std::regex::ECMAScript | std::regex::nosubs | std::regex::optimize;
 
   static const auto RE_COMMENT_BEGIN = std::regex("/[*/]", flags);
   static const auto RE_LINE_COMMENT_END = std::regex(R"([^\\]\n)", flags);
   static const auto RE_BLOCK_COMMENT_END = std::regex(R"(\*/)", flags);
 
   std::string ret;
   ret.reserve(src.size());
 
   // Replace all comments with block comments with the right number of newlines.
-  // Line positions may be off, but line numbers will be accurate, which is more important.
+  // Line positions may be off, but line numbers will be accurate, which is more
+  // important.
 
   auto itr = src.begin();
   const auto end = src.end();
   std::smatch match;
   while (std::regex_search(itr, end, match, RE_COMMENT_BEGIN)) {
     MOZ_ASSERT(match.length() == 2);
     const auto commentBegin = itr + match.position();
     ret.append(itr, commentBegin);
--- a/dom/html/input/NumericInputTypes.cpp
+++ b/dom/html/input/NumericInputTypes.cpp
@@ -133,18 +133,18 @@ bool NumberInputType::IsValueMissing() c
 }
 
 bool NumberInputType::HasBadInput() const {
   nsAutoString value;
   GetNonFileValueInternal(value);
   return !value.IsEmpty() && mInputElement->GetValueAsDecimal().isNaN();
 }
 
-bool NumberInputType::ConvertNumberToString(
-    Decimal aValue, nsAString& aResultString) const {
+bool NumberInputType::ConvertNumberToString(Decimal aValue,
+                                            nsAString& aResultString) const {
   MOZ_ASSERT(aValue.isFinite(), "aValue must be a valid non-Infinite number.");
 
   aResultString.Truncate();
   ICUUtils::LanguageTagIterForContent langTagIter(mInputElement);
   ICUUtils::LocalizeNumber(aValue.toDouble(), langTagIter, aResultString);
   return true;
 }
 
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -1184,17 +1184,18 @@ nsresult ContentChild::ProvideWindowComm
     rv = GetCreateWindowParams(aParent, aLoadState, aForceNoReferrer, &fullZoom,
                                getter_AddRefs(referrerInfo),
                                getter_AddRefs(triggeringPrincipal),
                                getter_AddRefs(csp));
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    SendCreateWindow(aTabOpener, newChild, aChromeFlags, aCalledFromJS, aWidthSpecified, aURI, features, fullZoom,
+    SendCreateWindow(aTabOpener, newChild, aChromeFlags, aCalledFromJS,
+                     aWidthSpecified, aURI, features, fullZoom,
                      Principal(triggeringPrincipal), csp, referrerInfo,
                      std::move(resolve), std::move(reject));
   }
 
   // =======================
   // Begin Nested Event Loop
   // =======================
 
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -525,20 +525,19 @@ class ContentParent final
       const nsCString& aFeatures, const float& aFullZoom,
       const IPC::Principal& aTriggeringPrincipal,
       nsIContentSecurityPolicy* aCsp, nsIReferrerInfo* aReferrerInfo,
       CreateWindowResolver&& aResolve);
 
   mozilla::ipc::IPCResult RecvCreateWindowInDifferentProcess(
       PBrowserParent* aThisTab, const uint32_t& aChromeFlags,
       const bool& aCalledFromJS, const bool& aWidthSpecified,
-      nsIURI* aURIToLoad, const nsCString& aFeatures,
-      const float& aFullZoom, const nsString& aName,
-      nsIPrincipal* aTriggeringPrincipal, nsIContentSecurityPolicy* aCsp,
-      nsIReferrerInfo* aReferrerInfo);
+      nsIURI* aURIToLoad, const nsCString& aFeatures, const float& aFullZoom,
+      const nsString& aName, nsIPrincipal* aTriggeringPrincipal,
+      nsIContentSecurityPolicy* aCsp, nsIReferrerInfo* aReferrerInfo);
 
   static void BroadcastBlobURLRegistration(
       const nsACString& aURI, BlobImpl* aBlobImpl, nsIPrincipal* aPrincipal,
       ContentParent* aIgnoreThisCP = nullptr);
 
   static void BroadcastBlobURLUnregistration(
       const nsACString& aURI, nsIPrincipal* aPrincipal,
       ContentParent* aIgnoreThisCP = nullptr);
--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -4368,30 +4368,34 @@ void SourceListener::SetEnabledFor(Media
               // ux-updating code that everything went fine.
               return DeviceOperationPromise::CreateAndResolve(NS_OK, __func__);
             }
 
             nsString inputDeviceGroupId;
             state.mDevice->GetRawGroupId(inputDeviceGroupId);
 
             return MediaManager::PostTask<DeviceOperationPromise>(
-                __func__, [self, device = state.mDevice, aEnable, inputDeviceGroupId](
-                              MozPromiseHolder<DeviceOperationPromise>& h) {
+                __func__,
+                [self, device = state.mDevice, aEnable, inputDeviceGroupId](
+                    MozPromiseHolder<DeviceOperationPromise>& h) {
                   // Only take this branch when muting, to avoid muting, in case
                   // the default audio output device has changed and we need to
                   // really call `Start` on the source. The AudioInput source
                   // start/stop are idempotent, so this works.
-                  if (device->mKind == dom::MediaDeviceKind::Audioinput && !aEnable) {
-                    // Don't turn off the microphone of a device that is on the same
-                    // physical device as the output.
-                    CubebDeviceEnumerator* enumerator = CubebDeviceEnumerator::GetInstance();
+                  if (device->mKind == dom::MediaDeviceKind::Audioinput &&
+                      !aEnable) {
+                    // Don't turn off the microphone of a device that is on the
+                    // same physical device as the output.
+                    CubebDeviceEnumerator* enumerator =
+                        CubebDeviceEnumerator::GetInstance();
                     // Get the current graph's device info. This is always the
                     // default audio output device for now.
                     RefPtr<AudioDeviceInfo> outputDevice =
-                      enumerator->DefaultDevice(CubebDeviceEnumerator::Side::OUTPUT);
+                        enumerator->DefaultDevice(
+                            CubebDeviceEnumerator::Side::OUTPUT);
                     if (outputDevice->GroupID().Equals(inputDeviceGroupId)) {
                       LOG("Device group id match when %s, "
                           "not turning the input device off (%s)",
                           aEnable ? "unmuting" : "muting",
                           NS_ConvertUTF16toUTF8(outputDevice->GroupID()).get());
                       h.Resolve(NS_OK, __func__);
                       return;
                     }
--- a/dom/svg/SVGAnimatedTransformList.cpp
+++ b/dom/svg/SVGAnimatedTransformList.cpp
@@ -117,18 +117,17 @@ nsresult SVGAnimatedTransformList::SetAn
     return rv;
   }
   int32_t modType;
   if (prevSet) {
     modType = MutationEvent_Binding::MODIFICATION;
   } else {
     modType = MutationEvent_Binding::ADDITION;
   }
-  mCreatedOrRemovedOnLastChange =
-      modType == MutationEvent_Binding::ADDITION;
+  mCreatedOrRemovedOnLastChange = modType == MutationEvent_Binding::ADDITION;
   aElement->DidAnimateTransformList(modType);
   return NS_OK;
 }
 
 void SVGAnimatedTransformList::ClearAnimValue(SVGElement* aElement) {
   DOMSVGAnimatedTransformList* domWrapper =
       DOMSVGAnimatedTransformList::GetDOMWrapperIfExists(this);
   if (domWrapper) {
@@ -141,18 +140,17 @@ void SVGAnimatedTransformList::ClearAnim
   }
   mAnimVal = nullptr;
   int32_t modType;
   if (HasTransform() || aElement->GetAnimateMotionTransform()) {
     modType = MutationEvent_Binding::MODIFICATION;
   } else {
     modType = MutationEvent_Binding::REMOVAL;
   }
-  mCreatedOrRemovedOnLastChange =
-      modType == MutationEvent_Binding::REMOVAL;
+  mCreatedOrRemovedOnLastChange = modType == MutationEvent_Binding::REMOVAL;
   aElement->DidAnimateTransformList(modType);
 }
 
 bool SVGAnimatedTransformList::IsExplicitlySet() const {
   // Like other methods of this name, we need to know when a transform value has
   // been explicitly set.
   //
   // There are three ways an animated list can become set:
--- a/gfx/2d/2D.h
+++ b/gfx/2d/2D.h
@@ -305,18 +305,18 @@ class ConicGradientPattern : public Patt
         mAngle(aAngle),
         mStartOffset(aStartOffset),
         mEndOffset(aEndOffset),
         mStops(aStops),
         mMatrix(aMatrix) {}
 
   PatternType GetType() const override { return PatternType::CONIC_GRADIENT; }
 
-  Point mCenter;  //!< Center of the gradient
-  Float mAngle;   //!< Start angle of gradient
+  Point mCenter;       //!< Center of the gradient
+  Float mAngle;        //!< Start angle of gradient
   Float mStartOffset;  // Offset of first stop
   Float mEndOffset;    // Offset of last stop
   RefPtr<GradientStops>
       mStops;      /**< GradientStops object for this gradient, this
                         should match the backend type of the draw target
                         this pattern will be used with. */
   Matrix mMatrix;  //!< A matrix that transforms the pattern into user space
 };
--- a/gfx/2d/DrawTargetD2D1.cpp
+++ b/gfx/2d/DrawTargetD2D1.cpp
@@ -188,17 +188,18 @@ static const uint32_t kPushedLayersBefor
 static const uint32_t kTransformedGlyphsBeforePurge = 1000;
 
 void DrawTargetD2D1::Flush() { FlushInternal(); }
 
 void DrawTargetD2D1::DrawSurface(SourceSurface* aSurface, const Rect& aDest,
                                  const Rect& aSource,
                                  const DrawSurfaceOptions& aSurfOptions,
                                  const DrawOptions& aOptions) {
-  if (!PrepareForDrawing(aOptions.mCompositionOp, ColorPattern(DeviceColor()))) {
+  if (!PrepareForDrawing(aOptions.mCompositionOp,
+                         ColorPattern(DeviceColor()))) {
     return;
   }
 
   D2D1_RECT_F samplingBounds;
 
   if (aSurfOptions.mSamplingBounds == SamplingBounds::BOUNDED) {
     samplingBounds = D2DRect(aSource);
   } else {
@@ -262,17 +263,18 @@ void DrawTargetD2D1::DrawSurface(SourceS
 void DrawTargetD2D1::DrawFilter(FilterNode* aNode, const Rect& aSourceRect,
                                 const Point& aDestPoint,
                                 const DrawOptions& aOptions) {
   if (aNode->GetBackendType() != FILTER_BACKEND_DIRECT2D1_1) {
     gfxWarning() << *this << ": Incompatible filter passed to DrawFilter.";
     return;
   }
 
-  if (!PrepareForDrawing(aOptions.mCompositionOp, ColorPattern(DeviceColor()))) {
+  if (!PrepareForDrawing(aOptions.mCompositionOp,
+                         ColorPattern(DeviceColor()))) {
     return;
   }
 
   mDC->SetAntialiasMode(D2DAAMode(aOptions.mAntialiasMode));
 
   FilterNodeD2D1* node = static_cast<FilterNodeD2D1*>(aNode);
   node->WillDraw(this);
 
--- a/gfx/layers/TiledLayerBuffer.h
+++ b/gfx/layers/TiledLayerBuffer.h
@@ -7,18 +7,18 @@
 #ifndef GFX_TILEDLAYERBUFFER_H
 #define GFX_TILEDLAYERBUFFER_H
 
 // Debug defines
 //#define GFX_TILEDLAYER_DEBUG_OVERLAY
 //#define GFX_TILEDLAYER_PREF_WARNINGS
 //#define GFX_TILEDLAYER_RETAINING_LOG
 
-#include <stdint.h>         // for uint16_t, uint32_t
-#include <sys/types.h>      // for int32_t
+#include <stdint.h>     // for uint16_t, uint32_t
+#include <sys/types.h>  // for int32_t
 #include <type_traits>
 #include "LayersLogging.h"  // for print_stderr
 #include "mozilla/gfx/gfxVars.h"
 #include "mozilla/gfx/Logging.h"         // for gfxCriticalError
 #include "mozilla/layers/LayersTypes.h"  // for TextureDumpMode
 #include "nsDebug.h"                     // for NS_ASSERTION
 #include "nsPoint.h"                     // for nsIntPoint
 #include "nsRect.h"                      // for mozilla::gfx::IntRect
--- a/gfx/layers/ipc/CompositorBench.cpp
+++ b/gfx/layers/ipc/CompositorBench.cpp
@@ -122,17 +122,18 @@ class EffectSolidColorTrivialBench : pub
 
     DrawFrameTrivialQuad(aCompositor, aScreenRect, aStep, effects);
   }
 
   already_AddRefed<Effect> CreateEffect(size_t i) {
     float tmp;
     float red = modff(i * 0.03f, &tmp);
     EffectChain effects;
-    return MakeAndAddRef<EffectSolidColor>(gfx::DeviceColor(red, 0.4f, 0.4f, 1.0f));
+    return MakeAndAddRef<EffectSolidColor>(
+        gfx::DeviceColor(red, 0.4f, 0.4f, 1.0f));
   }
 };
 
 class EffectSolidColorStressBench : public BenchTest {
  public:
   EffectSolidColorStressBench()
       : BenchTest(
             "EffectSolidColorStressBench (10s various EffectSolidColor)") {}
@@ -144,17 +145,18 @@ class EffectSolidColorStressBench : publ
 
     DrawFrameStressQuad(aCompositor, aScreenRect, aStep, effects);
   }
 
   already_AddRefed<Effect> CreateEffect(size_t i) {
     float tmp;
     float red = modff(i * 0.03f, &tmp);
     EffectChain effects;
-    return MakeAndAddRef<EffectSolidColor>(gfx::DeviceColor(red, 0.4f, 0.4f, 1.0f));
+    return MakeAndAddRef<EffectSolidColor>(
+        gfx::DeviceColor(red, 0.4f, 0.4f, 1.0f));
   }
 };
 
 class UploadBench : public BenchTest {
  public:
   UploadBench() : BenchTest("Upload Bench (10s 256x256 upload)") {}
 
   uint32_t* mBuf;
--- a/gfx/layers/ipc/RemoteContentController.cpp
+++ b/gfx/layers/ipc/RemoteContentController.cpp
@@ -13,17 +13,17 @@
 #include "mozilla/layers/APZCCallbackHelper.h"
 #include "mozilla/layers/APZCTreeManagerParent.h"  // for APZCTreeManagerParent
 #include "mozilla/layers/APZThreadUtils.h"
 #include "mozilla/layers/MatrixMessage.h"
 #include "mozilla/gfx/GPUProcessManager.h"
 #include "mozilla/Unused.h"
 #include "Units.h"
 #ifdef MOZ_WIDGET_ANDROID
-#include "mozilla/jni/Utils.h"
+#  include "mozilla/jni/Utils.h"
 #endif
 
 static mozilla::LazyLogModule sApzRemoteLog("apz.cc.remote");
 
 namespace mozilla {
 namespace layers {
 
 using namespace mozilla::gfx;
--- a/gfx/layers/ipc/UiCompositorControllerParent.cpp
+++ b/gfx/layers/ipc/UiCompositorControllerParent.cpp
@@ -154,17 +154,18 @@ mozilla::ipc::IPCResult UiCompositorCont
     const uint32_t& aColor) {
   LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(mRootLayerTreeId);
 
   if (state && state->mLayerManager) {
     Compositor* compositor = state->mLayerManager->GetCompositor();
     if (compositor) {
       // Android Color is ARGB which is apparently unusual.
-      compositor->SetDefaultClearColor(gfx::DeviceColor::UnusualFromARGB(aColor));
+      compositor->SetDefaultClearColor(
+          gfx::DeviceColor::UnusualFromARGB(aColor));
     }
   }
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 UiCompositorControllerParent::RecvRequestScreenPixels() {
--- a/gfx/layers/wr/IpcResourceUpdateQueue.cpp
+++ b/gfx/layers/wr/IpcResourceUpdateQueue.cpp
@@ -252,18 +252,17 @@ IpcResourceUpdateQueue::IpcResourceUpdat
     layers::WebRenderBridgeChild* aAllocator, wr::RenderRoot aRenderRoot,
     size_t aChunkSize)
     : mWriter(aAllocator, aChunkSize), mRenderRoot(aRenderRoot) {}
 
 IpcResourceUpdateQueue::IpcResourceUpdateQueue(
     IpcResourceUpdateQueue&& aOther) noexcept
     : mWriter(std::move(aOther.mWriter)),
       mUpdates(std::move(aOther.mUpdates)),
-      mRenderRoot(aOther.mRenderRoot) {
-}
+      mRenderRoot(aOther.mRenderRoot) {}
 
 IpcResourceUpdateQueue& IpcResourceUpdateQueue::operator=(
     IpcResourceUpdateQueue&& aOther) noexcept {
   MOZ_ASSERT(IsEmpty(), "Will forget existing updates!");
   mWriter = std::move(aOther.mWriter);
   mUpdates = std::move(aOther.mUpdates);
   mRenderRoot = aOther.mRenderRoot;
   return *this;
--- a/gfx/layers/wr/IpcResourceUpdateQueue.h
+++ b/gfx/layers/wr/IpcResourceUpdateQueue.h
@@ -96,19 +96,17 @@ class IpcResourceUpdateQueue {
   // in any concrete way, they still end up being tied to a render root because
   // we need to know which WR document to generate a frame for when they change.
   IpcResourceUpdateQueue& SubQueue(wr::RenderRoot aRenderRoot) {
     MOZ_ASSERT(mRenderRoot == wr::RenderRoot::Default);
     MOZ_ASSERT(aRenderRoot == wr::RenderRoot::Default);
     return *this;
   }
 
-  bool HasAnySubQueue() {
-    return false;
-  }
+  bool HasAnySubQueue() { return false; }
 
   bool HasSubQueue(wr::RenderRoot aRenderRoot) {
     return aRenderRoot == wr::RenderRoot::Default;
   }
 
   wr::RenderRoot GetRenderRoot() { return mRenderRoot; }
 
   IpcResourceUpdateQueue(IpcResourceUpdateQueue&& aOther) noexcept;
--- a/gfx/thebes/gfxFontUtils.cpp
+++ b/gfx/thebes/gfxFontUtils.cpp
@@ -1806,17 +1806,17 @@ void gfxFontUtils::GetVariationData(
   }
   uint16_t axisCount = fvar->axisCount;
   uint16_t axisSize = fvar->axisSize;
   uint16_t instanceCount = fvar->instanceCount;
   uint16_t instanceSize = fvar->instanceSize;
   if (axisCount ==
           0 ||  // no axes?
                 // https://www.microsoft.com/typography/otspec/fvar.htm#axisSize
-      axisSize != 20 ||      // required value for current table version
+      axisSize != 20 ||  // required value for current table version
       // https://www.microsoft.com/typography/otspec/fvar.htm#instanceSize
       (instanceSize != axisCount * sizeof(int32_t) + 4 &&
        instanceSize != axisCount * sizeof(int32_t) + 6)) {
     return;
   }
   // Check that axis array will not exceed table size
   uint16_t axesOffset = fvar->axesArrayOffset;
   if (axesOffset + uint32_t(axisCount) * axisSize > len) {
--- a/gfx/thebes/gfxPattern.h
+++ b/gfx/thebes/gfxPattern.h
@@ -20,17 +20,17 @@ typedef struct _cairo_pattern cairo_patt
 class gfxPattern final {
   NS_INLINE_DECL_REFCOUNTING(gfxPattern)
 
  public:
   explicit gfxPattern(const mozilla::gfx::DeviceColor& aColor);
   // gradients
   gfxPattern(gfxFloat x0, gfxFloat y0, gfxFloat x1, gfxFloat y1);  // linear
   gfxPattern(gfxFloat cx0, gfxFloat cy0, gfxFloat radius0, gfxFloat cx1,
-             gfxFloat cy1, gfxFloat radius1);            // radial
+             gfxFloat cy1, gfxFloat radius1);  // radial
   gfxPattern(gfxFloat cx, gfxFloat cy, gfxFloat angle, gfxFloat startOffset,
              gfxFloat endOffset);  // conic
   gfxPattern(mozilla::gfx::SourceSurface* aSurface,
              const mozilla::gfx::Matrix& aPatternToUserSpace);
 
   void AddColorStop(gfxFloat offset, const mozilla::gfx::DeviceColor& c);
   void SetColorStops(mozilla::gfx::GradientStops* aStops);
 
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -1212,28 +1212,28 @@ static bool IsFeatureSupported(long aFea
   nsCString blockId;
   int32_t status;
   if (!NS_SUCCEEDED(gfxInfo->GetFeatureStatus(aFeature, blockId, &status))) {
     return aDefault;
   }
   return status == nsIGfxInfo::FEATURE_STATUS_OK;
 }
 
-static void ApplyGfxInfoFeature(long aFeature, FeatureState &aFeatureState) {
+static void ApplyGfxInfoFeature(long aFeature, FeatureState& aFeatureState) {
   nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
   nsCString blockId;
   int32_t status;
   if (!NS_SUCCEEDED(gfxInfo->GetFeatureStatus(aFeature, blockId, &status))) {
-      aFeatureState.Disable(FeatureStatus::BlockedNoGfxInfo, "gfxInfo is broken",
-                            NS_LITERAL_CSTRING("FEATURE_FAILURE_NO_GFX_INFO"));
+    aFeatureState.Disable(FeatureStatus::BlockedNoGfxInfo, "gfxInfo is broken",
+                          NS_LITERAL_CSTRING("FEATURE_FAILURE_NO_GFX_INFO"));
 
   } else {
     if (status != nsIGfxInfo::FEATURE_STATUS_OK) {
-      aFeatureState.Disable(FeatureStatus::Blacklisted, "Blacklisted by gfxInfo",
-                            blockId);
+      aFeatureState.Disable(FeatureStatus::Blacklisted,
+                            "Blacklisted by gfxInfo", blockId);
     }
   }
 }
 
 /* static*/
 bool gfxPlatform::IsDXInterop2Blocked() {
   return !IsFeatureSupported(nsIGfxInfo::FEATURE_DX_INTEROP2, false);
 }
--- a/gfx/thebes/gfxUtils.cpp
+++ b/gfx/thebes/gfxUtils.cpp
@@ -885,17 +885,18 @@ gfxUtils::CopySurfaceToDataSourceSurface
                   DrawOptions(1.0f, CompositionOp::OP_OVER));
   dataSurface->Unmap();
   return dataSurface.forget();
 }
 
 const uint32_t gfxUtils::sNumFrameColors = 8;
 
 /* static */
-const gfx::DeviceColor& gfxUtils::GetColorForFrameNumber(uint64_t aFrameNumber) {
+const gfx::DeviceColor& gfxUtils::GetColorForFrameNumber(
+    uint64_t aFrameNumber) {
   static bool initialized = false;
   static gfx::DeviceColor colors[sNumFrameColors];
 
   if (!initialized) {
     // This isn't truly device color, but it is just for debug.
     uint32_t i = 0;
     colors[i++] = gfx::DeviceColor::FromABGR(0xffff0000);
     colors[i++] = gfx::DeviceColor::FromABGR(0xffcc00ff);
--- a/gfx/webrender_bindings/WebRenderAPI.h
+++ b/gfx/webrender_bindings/WebRenderAPI.h
@@ -231,18 +231,17 @@ class WebRenderAPI final {
                                                 int8_t aLayerIndex,
                                                 wr::RenderRoot aRenderRoot);
 
   already_AddRefed<WebRenderAPI> Clone();
 
   wr::WindowId GetId() const { return mId; }
 
   /// Do a non-blocking hit-testing query on a shared hit-testing information.
-  bool HitTest(const wr::WorldPoint& aPoint,
-               wr::WrPipelineId& aOutPipelineId,
+  bool HitTest(const wr::WorldPoint& aPoint, wr::WrPipelineId& aOutPipelineId,
                layers::ScrollableLayerGuid::ViewID& aOutScrollId,
                gfx::CompositorHitTestInfo& aOutHitInfo, SideBits& aOutSideBits);
 
   /// Do a non-blocking hit-testing query on a shared version of the hit testing
   /// information.
   ///
 
   void SendTransaction(TransactionBuilder& aTxn);
@@ -424,19 +423,17 @@ class DisplayListBuilder final {
   RenderRoot GetRenderRoot() const { return mRenderRoot; }
   bool HasSubBuilder(RenderRoot aRenderRoot);
   DisplayListBuilder& CreateSubBuilder(const wr::LayoutSize& aContentSize,
                                        size_t aCapacity,
                                        layers::DisplayItemCache* aCache,
                                        RenderRoot aRenderRoot);
   DisplayListBuilder& SubBuilder(RenderRoot aRenderRoot);
 
-  bool GetSendSubBuilderDisplayList(RenderRoot aRenderRoot) {
-    return true;
-  }
+  bool GetSendSubBuilderDisplayList(RenderRoot aRenderRoot) { return true; }
 
   Maybe<wr::WrSpatialId> PushStackingContext(
       const StackingContextParams& aParams, const wr::LayoutRect& aBounds,
       const wr::RasterSpace& aRasterSpace);
   void PopStackingContext(bool aIsReferenceFrame);
 
   wr::WrClipChainId DefineClipChain(const nsTArray<wr::WrClipId>& aClips,
                                     bool aParentWithCurrentChain = false);
--- a/gfx/webrender_bindings/webrender_ffi.h
+++ b/gfx/webrender_bindings/webrender_ffi.h
@@ -85,20 +85,20 @@ const uint64_t ROOT_CLIP_CHAIN = ~0;
 void apz_register_updater(mozilla::wr::WrWindowId aWindowId);
 void apz_pre_scene_swap(mozilla::wr::WrWindowId aWindowId);
 void apz_post_scene_swap(mozilla::wr::WrWindowId aWindowId,
                          const mozilla::wr::WrPipelineInfo* aInfo);
 void apz_run_updater(mozilla::wr::WrWindowId aWindowId);
 void apz_deregister_updater(mozilla::wr::WrWindowId aWindowId);
 
 void apz_register_sampler(mozilla::wr::WrWindowId aWindowId);
-void apz_sample_transforms(mozilla::wr::WrWindowId aWindowId,
-                           mozilla::wr::Transaction* aTransaction,
-                           mozilla::wr::DocumentId aRenderRootId,
-                           const mozilla::wr::WrPipelineIdEpochs* aPipelineEpochs);
+void apz_sample_transforms(
+    mozilla::wr::WrWindowId aWindowId, mozilla::wr::Transaction* aTransaction,
+    mozilla::wr::DocumentId aRenderRootId,
+    const mozilla::wr::WrPipelineIdEpochs* aPipelineEpochs);
 void apz_deregister_sampler(mozilla::wr::WrWindowId aWindowId);
 }  // extern "C"
 
 // Work-around wingdi.h define which conflcits with WR color constant
 #pragma push_macro("TRANSPARENT")
 #undef TRANSPARENT
 
 #include "webrender_ffi_generated.h"
--- a/ipc/chromium/src/base/shared_memory.h
+++ b/ipc/chromium/src/base/shared_memory.h
@@ -136,17 +136,17 @@ class SharedMemory {
   // its handle (as if by `Close(false)`), it cannot have been
   // previously shared, and the read-only handle cannot be used to
   // write the memory even by a malicious process.
   //
   // (The out parameter can currently be the same as `this` if and
   // only if the memory was unmapped, but this is an implementation
   // detail and shouldn't be relied on; for that use case Freeze()
   // should be used instead.)
-  MOZ_MUST_USE bool ReadOnlyCopy(SharedMemory *ro_out);
+  MOZ_MUST_USE bool ReadOnlyCopy(SharedMemory* ro_out);
 
   // Closes the open shared memory segment.
   // It is safe to call Close repeatedly.
   void Close(bool unmap_view = true);
 
   // Returns a page-aligned address at which the given number of bytes could
   // probably be mapped.  Returns NULL on error or if there is insufficient
   // contiguous address space to map the required number of pages.
--- a/ipc/chromium/src/base/shared_memory_posix.cc
+++ b/ipc/chromium/src/base/shared_memory_posix.cc
@@ -267,17 +267,18 @@ bool SharedMemory::ReadOnlyCopy(SharedMe
 
   if (ro_out == this) {
     DCHECK(!memory_);
   }
 
   int ro_file = -1;
 #ifdef ANDROID
   if (mozilla::android::ashmem_setProt(mapped_file_, PROT_READ) != 0) {
-    CHROMIUM_LOG(WARNING) << "failed to set ashmem read-only: " << strerror(errno);
+    CHROMIUM_LOG(WARNING) << "failed to set ashmem read-only: "
+                          << strerror(errno);
     return false;
   }
   ro_file = mapped_file_;
 #else
   DCHECK(frozen_file_ >= 0);
   DCHECK(mapped_file_ >= 0);
   close(mapped_file_);
   ro_file = frozen_file_;
--- a/ipc/glue/ForkServiceChild.cpp
+++ b/ipc/glue/ForkServiceChild.cpp
@@ -122,17 +122,17 @@ already_AddRefed<ForkServerLauncher> For
   return launcher.forget();
 }
 
 NS_IMETHODIMP
 ForkServerLauncher::Observe(nsISupports* aSubject, const char* aTopic,
                             const char16_t* aData) {
   if (strcmp(aTopic, NS_XPCOM_STARTUP_CATEGORY) == 0) {
     nsCOMPtr<nsIObserverService> obsSvc =
-      mozilla::services::GetObserverService();
+        mozilla::services::GetObserverService();
     MOZ_ASSERT(obsSvc != nullptr);
     // preferences are not available until final-ui-startup
     obsSvc->AddObserver(this, "final-ui-startup", false);
   } else if (!mHaveStartedClient && strcmp(aTopic, "final-ui-startup") == 0) {
     if (StaticPrefs::dom_ipc_forkserver_enable_AtStartup()) {
       mHaveStartedClient = true;
       ForkServiceChild::StartForkServer();
 
--- a/js/src/builtin/MapObject.cpp
+++ b/js/src/builtin/MapObject.cpp
@@ -533,17 +533,18 @@ inline static MOZ_MUST_USE bool WriteBar
 
   NurseryKeysVector* keys = GetNurseryKeys(obj);
   if (!keys) {
     keys = AllocNurseryKeys(obj);
     if (!keys) {
       return false;
     }
 
-    keyValue.toGCThing()->storeBuffer()->putGeneric(OrderedHashTableRef<ObjectT>(obj));
+    keyValue.toGCThing()->storeBuffer()->putGeneric(
+        OrderedHashTableRef<ObjectT>(obj));
   }
 
   return keys->append(keyValue);
 }
 
 inline static MOZ_MUST_USE bool WriteBarrierPost(MapObject* map,
                                                  const Value& key) {
   return WriteBarrierPostImpl(map, key);
--- a/js/src/builtin/Promise-inl.h
+++ b/js/src/builtin/Promise-inl.h
@@ -2,23 +2,23 @@
  * 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 builtin_Promise_inl_h
 #define builtin_Promise_inl_h
 
-#include "js/Promise.h"          // JS::PromiseState
+#include "js/Promise.h"  // JS::PromiseState
 
 #include "mozilla/Assertions.h"  // MOZ_ASSERT
 
-#include "js/RootingAPI.h"       // JS::Handle
-#include "vm/JSContext.h"        // JSContext
-#include "vm/PromiseObject.h"    // js::PromiseObject
+#include "js/RootingAPI.h"     // JS::Handle
+#include "vm/JSContext.h"      // JSContext
+#include "vm/PromiseObject.h"  // js::PromiseObject
 
 namespace js {
 
 /**
  * Given a settled (i.e. fulfilled or rejected, not pending) promise, sets
  * |promise.[[PromiseIsHandled]]| to true and removes it from the list of
  * unhandled rejected promises.
  *
--- a/js/src/builtin/streams/MiscellaneousOperations.h
+++ b/js/src/builtin/streams/MiscellaneousOperations.h
@@ -6,21 +6,21 @@
 
 /* Miscellaneous operations. */
 
 #ifndef builtin_streams_MiscellaneousOperations_h
 #define builtin_streams_MiscellaneousOperations_h
 
 #include "mozilla/Attributes.h"  // MOZ_MUST_USE
 
-#include "jstypes.h"        // JS_PUBLIC_API
-#include "js/CallArgs.h"    // JS::CallArgs
-#include "js/RootingAPI.h"  // JS::{,Mutable}Handle
-#include "js/Value.h"       // JS::Value
-#include "vm/JSObject.h"    // JSObject
+#include "jstypes.h"           // JS_PUBLIC_API
+#include "js/CallArgs.h"       // JS::CallArgs
+#include "js/RootingAPI.h"     // JS::{,Mutable}Handle
+#include "js/Value.h"          // JS::Value
+#include "vm/JSObject.h"       // JSObject
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 struct JS_PUBLIC_API JSContext;
 
 namespace js {
 
 class PropertyName;
 
--- a/js/src/builtin/streams/PipeToState.cpp
+++ b/js/src/builtin/streams/PipeToState.cpp
@@ -11,19 +11,19 @@
 #include "mozilla/Assertions.h"  // MOZ_ASSERT
 #include "mozilla/Attributes.h"  // MOZ_MUST_USE
 #include "mozilla/Maybe.h"  // mozilla::Maybe, mozilla::Nothing, mozilla::Some
 
 #include "jsapi.h"        // JS_ReportErrorNumberASCII
 #include "jsfriendapi.h"  // js::GetErrorMessage, JSMSG_*
 
 #include "builtin/Promise.h"  // js::RejectPromiseWithPendingError
-#include "builtin/streams/ReadableStream.h"  // js::ReadableStream
+#include "builtin/streams/ReadableStream.h"        // js::ReadableStream
 #include "builtin/streams/ReadableStreamReader.h"  // js::CreateReadableStreamDefaultReader, js::ForAuthorCodeBool, js::ReadableStreamDefaultReader
-#include "builtin/streams/WritableStream.h"  // js::WritableStream
+#include "builtin/streams/WritableStream.h"        // js::WritableStream
 #include "builtin/streams/WritableStreamDefaultWriter.h"  // js::CreateWritableStreamDefaultWriter, js::WritableStreamDefaultWriter
 #include "builtin/streams/WritableStreamOperations.h"  // js::WritableStreamCloseQueuedOrInFlight
 #include "js/CallArgs.h"       // JS::CallArgsFromVp, JS::CallArgs
 #include "js/Class.h"          // JSClass, JSCLASS_HAS_RESERVED_SLOTS
 #include "js/Promise.h"        // JS::AddPromiseReactions
 #include "js/RootingAPI.h"     // JS::Handle, JS::Rooted
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
--- a/js/src/builtin/streams/ReadableStreamDefaultControllerOperations.cpp
+++ b/js/src/builtin/streams/ReadableStreamDefaultControllerOperations.cpp
@@ -20,24 +20,24 @@
 #include "builtin/streams/ReadableStreamInternals.h"  // js::ReadableStream{CloseInternal,ErrorInternal,FulfillReadOrReadIntoRequest,GetNumReadRequests}
 #include "builtin/streams/ReadableStreamOperations.h"  // js::ReadableStreamTee_Pull, js::SetUpReadableStreamDefaultController
 #include "builtin/streams/TeeState.h"  // js::TeeState
 #include "js/CallArgs.h"               // JS::CallArgs{,FromVp}
 #include "js/Promise.h"                // JS::AddPromiseReactions
 #include "js/RootingAPI.h"             // JS::Handle, JS::Rooted
 #include "js/Stream.h"                 // JS::ReadableStreamUnderlyingSource
 #include "js/Value.h"  // JS::{,Int32,Object}Value, JS::UndefinedHandleValue
-#include "vm/Compartment.h"    // JS::Compartment
-#include "vm/Interpreter.h"    // js::Call, js::GetAndClearExceptionAndStack
-#include "vm/JSContext.h"      // JSContext
-#include "vm/JSObject.h"       // JSObject
-#include "vm/List.h"           // js::ListObject
+#include "vm/Compartment.h"  // JS::Compartment
+#include "vm/Interpreter.h"  // js::Call, js::GetAndClearExceptionAndStack
+#include "vm/JSContext.h"    // JSContext
+#include "vm/JSObject.h"     // JSObject
+#include "vm/List.h"         // js::ListObject
 #include "vm/PromiseObject.h"  // js::PromiseObject, js::PromiseResolvedWithUndefined
 #include "vm/Runtime.h"        // JSAtomState
-#include "vm/SavedFrame.h"     // js::SavedFrame
+#include "vm/SavedFrame.h"  // js::SavedFrame
 
 #include "builtin/streams/HandlerFunction-inl.h"          // js::NewHandler
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::PromiseCall
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapCalleeSlot
 #include "vm/JSContext-inl.h"    // JSContext::check
 #include "vm/JSObject-inl.h"     // js::IsCallable, js::NewBuiltinClassInstance
 #include "vm/Realm-inl.h"        // js::AutoRealm
 
--- a/js/src/builtin/streams/ReadableStreamDefaultReader.cpp
+++ b/js/src/builtin/streams/ReadableStreamDefaultReader.cpp
@@ -10,20 +10,20 @@
 
 #include "jsapi.h"        // JS_ReportErrorNumberASCII
 #include "jsfriendapi.h"  // js::GetErrorMessage
 
 #include "builtin/streams/ClassSpecMacro.h"  // JS_STREAMS_CLASS_SPEC
 #include "builtin/streams/MiscellaneousOperations.h"  // js::ReturnPromiseRejectedWithPendingError
 #include "builtin/streams/ReadableStream.h"  // js::ReadableStream
 #include "builtin/streams/ReadableStreamReader.h"  // js::ForAuthorCodeBool, js::ReadableStream{,Default}Reader
-#include "js/CallArgs.h"                           // JS::CallArgs{,FromVp}
-#include "js/Class.h"                              // JSClass, JS_NULL_CLASS_OPS
-#include "js/RootingAPI.h"                         // JS::Handle, JS::Rooted
-#include "vm/PromiseObject.h"                      // js::PromiseObject
+#include "js/CallArgs.h"       // JS::CallArgs{,FromVp}
+#include "js/Class.h"          // JSClass, JS_NULL_CLASS_OPS
+#include "js/RootingAPI.h"     // JS::Handle, JS::Rooted
+#include "vm/PromiseObject.h"  // js::PromiseObject
 
 #include "vm/Compartment-inl.h"   // js::UnwrapAndTypeCheckThis
 #include "vm/JSObject-inl.h"      // js::NewObjectWithClassProto
 #include "vm/NativeObject-inl.h"  // js::ThrowIfNotConstructing
 
 using JS::CallArgs;
 using JS::CallArgsFromVp;
 using JS::Handle;
--- a/js/src/builtin/streams/ReadableStreamInternals.cpp
+++ b/js/src/builtin/streams/ReadableStreamInternals.cpp
@@ -20,23 +20,23 @@
 #include "gc/AllocKind.h"   // js::gc::AllocKind
 #include "js/CallArgs.h"    // JS::CallArgs{,FromVp}
 #include "js/GCAPI.h"       // JS::AutoSuppressGCAnalysis
 #include "js/Promise.h"     // JS::CallOriginalPromiseThen, JS::ResolvePromise
 #include "js/Result.h"      // JS_TRY_VAR_OR_RETURN_NULL
 #include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
 #include "js/Stream.h"  // JS::ReadableStreamUnderlyingSource, JS::ReadableStreamMode
 #include "js/Value.h"  // JS::Value, JS::{Boolean,Object}Value, JS::UndefinedHandleValue
-#include "vm/JSContext.h"      // JSContext
-#include "vm/JSFunction.h"     // JSFunction, js::NewNativeFunction
-#include "vm/NativeObject.h"   // js::NativeObject, js::PlainObject
-#include "vm/ObjectGroup.h"    // js::GenericObject
+#include "vm/JSContext.h"     // JSContext
+#include "vm/JSFunction.h"    // JSFunction, js::NewNativeFunction
+#include "vm/NativeObject.h"  // js::NativeObject, js::PlainObject
+#include "vm/ObjectGroup.h"   // js::GenericObject
 #include "vm/PromiseObject.h"  // js::PromiseObject, js::PromiseResolvedWithUndefined
 #include "vm/Realm.h"          // JS::Realm
-#include "vm/StringType.h"     // js::PropertyName
+#include "vm/StringType.h"  // js::PropertyName
 
 #include "builtin/Promise-inl.h"  // js::SetSettledPromiseIsHandled
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::{Reject,Resolve}UnwrappedPromiseWithUndefined
 #include "builtin/streams/ReadableStreamReader-inl.h"  // js::js::UnwrapReaderFromStream{,NoThrow}
 #include "vm/Compartment-inl.h"                        // JS::Compartment::wrap
 #include "vm/JSContext-inl.h"                          // JSContext::check
 #include "vm/List-inl.h"  // js::ListObject, js::AppendToListInFixedSlot, js::StoreNewListInFixedSlot
 #include "vm/Realm-inl.h"  // JS::Realm
--- a/js/src/builtin/streams/ReadableStreamReader.cpp
+++ b/js/src/builtin/streams/ReadableStreamReader.cpp
@@ -13,23 +13,23 @@
 
 #include "jsfriendapi.h"  // JS_ReportErrorNumberASCII, js::GetErrorMessage
 
 #include "builtin/Stream.h"  // js::ReadableStreamController, js::ReadableStreamControllerPullSteps
 #include "builtin/streams/ReadableStream.h"            // js::ReadableStream
 #include "builtin/streams/ReadableStreamController.h"  // js::ReadableStreamController
 #include "builtin/streams/ReadableStreamInternals.h"  // js::ReadableStream{Cancel,CreateReadResult}
 #include "js/RootingAPI.h"                            // JS::Handle, JS::Rooted
-#include "js/Value.h"          // JS::Value, JS::UndefinedHandleValue
-#include "vm/Interpreter.h"    // js::GetAndClearException
-#include "vm/JSContext.h"      // JSContext
+#include "js/Value.h"        // JS::Value, JS::UndefinedHandleValue
+#include "vm/Interpreter.h"  // js::GetAndClearException
+#include "vm/JSContext.h"    // JSContext
 #include "vm/PromiseObject.h"  // js::PromiseObject, js::PromiseResolvedWithUndefined
 #include "vm/Runtime.h"        // JSRuntime
 
-#include "builtin/Promise-inl.h" // js::SetSettledPromiseIsHandled
+#include "builtin/Promise-inl.h"  // js::SetSettledPromiseIsHandled
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapInternalSlot
 #include "vm/List-inl.h"         // js::StoreNewListInFixedSlot
 #include "vm/Realm-inl.h"        // js::AutoRealm
 
 using JS::Handle;
 using JS::Rooted;
 using JS::Value;
 
--- a/js/src/builtin/streams/WritableStreamDefaultControllerOperations.cpp
+++ b/js/src/builtin/streams/WritableStreamDefaultControllerOperations.cpp
@@ -17,20 +17,20 @@
 #include "builtin/streams/QueueWithSizes.h"  // js::{EnqueueValueWithSize,QueueIsEmpty,ResetQueue}
 #include "builtin/streams/WritableStream.h"  // js::WritableStream
 #include "builtin/streams/WritableStreamDefaultController.h"  // js::WritableStreamDefaultController
 #include "builtin/streams/WritableStreamOperations.h"  // js::WritableStream{CloseQueuedOrInFlight,DealWithRejection,{Start,Finish}Erroring,UpdateBackpressure,Mark{Close,FirstWrite}RequestInFlight}
 #include "js/CallArgs.h"                               // JS::CallArgs{,FromVp}
 #include "js/Promise.h"     // JS::AddPromiseReactions
 #include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
 #include "js/Value.h"  // JS::{,Int32,Magic,Object}Value, JS::UndefinedHandleValue, JS_WRITABLESTREAM_CLOSE_RECORD
-#include "vm/Compartment.h"    // JS::Compartment
-#include "vm/JSContext.h"      // JSContext
-#include "vm/JSObject.h"       // JSObject
-#include "vm/List.h"           // js::ListObject
+#include "vm/Compartment.h"  // JS::Compartment
+#include "vm/JSContext.h"    // JSContext
+#include "vm/JSObject.h"     // JSObject
+#include "vm/List.h"         // js::ListObject
 #include "vm/PromiseObject.h"  // js::PromiseObject, js::PromiseResolvedWithUndefined
 #include "vm/Runtime.h"        // JSAtomState
 
 #include "builtin/streams/HandlerFunction-inl.h"  // js::TargetFromHandler
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::PromiseCall
 #include "builtin/streams/QueueWithSizes-inl.h"           // js::PeekQueueValue
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap
 #include "vm/JSContext-inl.h"    // JSContext::check
--- a/js/src/builtin/streams/WritableStreamDefaultWriter.cpp
+++ b/js/src/builtin/streams/WritableStreamDefaultWriter.cpp
@@ -17,23 +17,23 @@
 #include "builtin/streams/ClassSpecMacro.h"  // JS_STREAMS_CLASS_SPEC
 #include "builtin/streams/MiscellaneousOperations.h"  // js::ReturnPromiseRejectedWithPendingError
 #include "builtin/streams/WritableStream.h"  // js::WritableStream
 #include "builtin/streams/WritableStreamOperations.h"  // js::WritableStreamCloseQueuedOrInFlight
 #include "builtin/streams/WritableStreamWriterOperations.h"  // js::WritableStreamDefaultWriter{Abort,GetDesiredSize,Release,Write}
 #include "js/CallArgs.h"  // JS::CallArgs{,FromVp}
 #include "js/Class.h"     // js::ClassSpec, JS_NULL_CLASS_OPS
 #include "js/PropertySpec.h"  // JS{Function,Property}Spec, JS_{FS,PS}_END, JS_{FN,PSG}
-#include "js/RootingAPI.h"     // JS::Handle
-#include "js/Value.h"          // JS::Value
-#include "vm/Compartment.h"    // JS::Compartment
-#include "vm/JSContext.h"      // JSContext
+#include "js/RootingAPI.h"   // JS::Handle
+#include "js/Value.h"        // JS::Value
+#include "vm/Compartment.h"  // JS::Compartment
+#include "vm/JSContext.h"    // JSContext
 #include "vm/PromiseObject.h"  // js::PromiseObject, js::PromiseResolvedWithUndefined
 
-#include "builtin/Promise-inl.h" // js::SetSettledPromiseIsHandled
+#include "builtin/Promise-inl.h"  // js::SetSettledPromiseIsHandled
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapAndTypeCheck{Argument,This}
 #include "vm/JSObject-inl.h"      // js::NewObjectWithClassProto
 #include "vm/NativeObject-inl.h"  // js::ThrowIfNotConstructing
 #include "vm/Realm-inl.h"         // js::AutoRealm
 
 using JS::CallArgs;
 using JS::CallArgsFromVp;
 using JS::Handle;
--- a/js/src/builtin/streams/WritableStreamOperations.cpp
+++ b/js/src/builtin/streams/WritableStreamOperations.cpp
@@ -20,19 +20,19 @@
 #include "builtin/streams/WritableStream.h"  // js::WritableStream
 #include "builtin/streams/WritableStreamDefaultController.h"  // js::WritableStreamDefaultController{,Close}, js::WritableStream::controller
 #include "builtin/streams/WritableStreamDefaultControllerOperations.h"  // js::WritableStreamControllerErrorSteps
 #include "builtin/streams/WritableStreamWriterOperations.h"  // js::WritableStreamDefaultWriterEnsureReadyPromiseRejected
 #include "js/CallArgs.h"    // JS::CallArgs{,FromVp}
 #include "js/Promise.h"     // JS::{Reject,Resolve}Promise
 #include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
 #include "js/Value.h"  // JS::Value, JS::ObjecValue, JS::UndefinedHandleValue
-#include "vm/Compartment.h"    // JS::Compartment
-#include "vm/JSContext.h"      // JSContext
-#include "vm/List.h"           // js::ListObject
+#include "vm/Compartment.h"  // JS::Compartment
+#include "vm/JSContext.h"    // JSContext
+#include "vm/List.h"         // js::ListObject
 #include "vm/PromiseObject.h"  // js::PromiseObject, js::PromiseResolvedWithUndefined
 
 #include "builtin/Promise-inl.h"  // js::SetSettledPromiseIsHandled
 #include "builtin/streams/HandlerFunction-inl.h"  // js::NewHandler, js::TargetFromHandler
 #include "builtin/streams/MiscellaneousOperations-inl.h"  // js::ResolveUnwrappedPromiseWithUndefined, js::RejectUnwrappedPromiseWithError
 #include "builtin/streams/WritableStream-inl.h"  // js::UnwrapWriterFromStream
 #include "builtin/streams/WritableStreamDefaultWriter-inl.h"  // js::WritableStreamDefaultWriter::closedPromise
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapAndDowncastObject
--- a/js/src/fuzz-tests/tests.cpp
+++ b/js/src/fuzz-tests/tests.cpp
@@ -26,19 +26,17 @@ static const JSClass* getGlobalClass() {
   static const JSClass c = {"global", JSCLASS_GLOBAL_FLAGS,
                             &JS::DefaultGlobalClassOps};
   return &c;
 }
 
 static JSObject* jsfuzz_createGlobal(JSContext* cx, JSPrincipals* principals) {
   /* Create the global object. */
   JS::RealmOptions options;
-  options.creationOptions()
-      .setStreamsEnabled(true)
-      .setWeakRefsEnabled(true);
+  options.creationOptions().setStreamsEnabled(true).setWeakRefsEnabled(true);
   return JS_NewGlobalObject(cx, getGlobalClass(), principals,
                             JS::FireOnNewGlobalHook, options);
 }
 
 static bool jsfuzz_init(JSContext** cx, JS::PersistentRootedObject* global) {
   *cx = JS_NewContext(8L * 1024 * 1024);
   if (!*cx) {
     return false;
--- a/js/src/gc/MaybeRooted.h
+++ b/js/src/gc/MaybeRooted.h
@@ -12,17 +12,17 @@
 
 #ifndef gc_MaybeRooted_h
 #define gc_MaybeRooted_h
 
 #include "mozilla/Attributes.h"  // MOZ_IMPLICIT, MOZ_RAII
 
 #include <type_traits>  // std::true_type
 
-#include "gc/Allocator.h"   // js::AllowGC, js::CanGC, js::NoGC
+#include "gc/Allocator.h"            // js::AllowGC, js::CanGC, js::NoGC
 #include "js/ComparisonOperators.h"  // JS::detail::DefineComparisonOps
 #include "js/RootingAPI.h"  // js::{Rooted,MutableHandle}Base, JS::SafelyInitialized, DECLARE_POINTER_{CONSTREF,ASSIGN}_OPS, DECLARE_NONPOINTER_{,MUTABLE_}ACCESSOR_METHODS, JS::Rooted, JS::{,Mutable}Handle
 
 namespace js {
 
 /**
  * Interface substitute for Rooted<T> which does not root the variable's
  * memory.
--- a/js/src/vm/PromiseObject.h
+++ b/js/src/vm/PromiseObject.h
@@ -7,19 +7,19 @@
 #ifndef vm_PromiseObject_h
 #define vm_PromiseObject_h
 
 #include "mozilla/Assertions.h"  // MOZ_ASSERT
 #include "mozilla/Attributes.h"  // MOZ_MUST_USE
 
 #include <stdint.h>  // int32_t, uint64_t
 
-#include "js/Class.h"         // JSClass
-#include "js/Promise.h"       // JS::PromiseState
-#include "js/RootingAPI.h"    // JS::{,Mutable}Handle
+#include "js/Class.h"       // JSClass
+#include "js/Promise.h"     // JS::PromiseState
+#include "js/RootingAPI.h"  // JS::{,Mutable}Handle
 #include "js/Value.h"  // JS::Value, JS::Int32Value, JS::UndefinedHandleValue
 #include "vm/NativeObject.h"  // js::NativeObject
 
 class JS_PUBLIC_API JSObject;
 
 namespace js {
 
 enum PromiseSlots {
--- a/layout/base/PositionedEventTargeting.cpp
+++ b/layout/base/PositionedEventTargeting.cpp
@@ -316,21 +316,23 @@ static void SubtractFromExposedRegion(ns
   // Don't let *aExposedRegion get too complex, but don't let it fluff out to
   // its bounds either. Do let aExposedRegion get more complex if by doing so
   // we reduce its area by at least half.
   if (tmp.GetNumRects() <= 15 || tmp.Area() <= aExposedRegion->Area() / 2) {
     *aExposedRegion = tmp;
   }
 }
 
-static nsIFrame* GetClosest(
-    nsIFrame* aRoot, const nsPoint& aPointRelativeToRootFrame,
-    const nsRect& aTargetRect, const EventRadiusPrefs* aPrefs,
-    nsIFrame* aRestrictToDescendants, nsIContent* aClickableAncestor,
-    nsTArray<nsIFrame*>& aCandidates) {
+static nsIFrame* GetClosest(nsIFrame* aRoot,
+                            const nsPoint& aPointRelativeToRootFrame,
+                            const nsRect& aTargetRect,
+                            const EventRadiusPrefs* aPrefs,
+                            nsIFrame* aRestrictToDescendants,
+                            nsIContent* aClickableAncestor,
+                            nsTArray<nsIFrame*>& aCandidates) {
   nsIFrame* bestTarget = nullptr;
   // Lower is better; distance is in appunits
   float bestDistance = 1e6f;
   nsRegion exposedRegion(aTargetRect);
   for (uint32_t i = 0; i < aCandidates.Length(); ++i) {
     nsIFrame* f = aCandidates[i];
 
     bool preservesAxisAlignedRectangles = false;
@@ -455,19 +457,19 @@ nsIFrame* FindFrameTargetedByInputEvent(
           mozilla::layers::Stringify(targetRect).c_str());
   AutoTArray<nsIFrame*, 8> candidates;
   nsresult rv = nsLayoutUtils::GetFramesForArea(aRootFrame, targetRect,
                                                 candidates, options);
   if (NS_FAILED(rv)) {
     return target;
   }
 
-  nsIFrame* closestClickable = GetClosest(
-      aRootFrame, aPointRelativeToRootFrame, targetRect, prefs,
-      restrictToDescendants, clickableAncestor, candidates);
+  nsIFrame* closestClickable =
+      GetClosest(aRootFrame, aPointRelativeToRootFrame, targetRect, prefs,
+                 restrictToDescendants, clickableAncestor, candidates);
   if (closestClickable) {
     target = closestClickable;
   }
   PET_LOG("Final target is %p\n", target);
 
 #ifdef DEBUG_FRAME_DUMP
   // At verbose logging level, dump the frame tree to help with debugging.
   // Note that dumping the frame tree at the top of the function may flood
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -3923,19 +3923,19 @@ nsresult nsCSSFrameConstructor::GetAnony
       if (cachedStyles[i]) {
 #ifdef DEBUG
         // Assert that our cached style is the same as one we could compute.
         RefPtr<ComputedStyle> cs = styleSet->ResolveStyleLazily(*elements[i]);
         MOZ_ASSERT(
             cachedStyles[i]->EqualForCachedAnonymousContentStyle(*cs),
             "cached anonymous content styles should be identical to those we "
             "would compute normally");
-#ifdef ANDROID
+#  ifdef ANDROID
         MOZ_ASSERT(cs->StyleUI()->mPointerEvents == StylePointerEvents::None);
-#endif
+#  endif
 #endif
         Servo_SetExplicitStyle(elements[i], cachedStyles[i]);
       }
     }
   }
 
   return NS_OK;
 }
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -2905,19 +2905,17 @@ nsDocumentViewer::GetAuthorStyleDisabled
   }
   return NS_OK;
 }
 
 void nsDocumentViewer::EmulateMediumInternal(nsAtom* aMedia) {
   auto childFn = [&](nsDocumentViewer* aChild) {
     aChild->EmulateMediumInternal(aMedia);
   };
-  auto presContextFn = [&](nsPresContext* aPc) {
-    aPc->EmulateMedium(aMedia);
-  };
+  auto presContextFn = [&](nsPresContext* aPc) { aPc->EmulateMedium(aMedia); };
   PropagateToPresContextsHelper(childFn, presContextFn);
 }
 
 NS_IMETHODIMP
 nsDocumentViewer::EmulateMedium(const nsAString& aMediaType) {
   nsAutoString mediaType;
   nsContentUtils::ASCIIToLower(aMediaType, mediaType);
   RefPtr<nsAtom> media = NS_Atomize(mediaType);
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -6980,20 +6980,20 @@ void nsBlockFrame::BuildDisplayList(nsDi
   // frame in our child list, it's also true for |this|.
   // Also skip the cursor if we're creating text overflow markers,
   // since we need to know what line number we're up to in order
   // to generate unique display item keys.
   // Lastly, the cursor should be skipped if we're drawing
   // backplates behind text. When backplating we consider consecutive
   // runs of text as a whole, which requires we iterate through all lines
   // to find our backplate size.
-  nsLineBox* cursor = (hasDescendantPlaceHolders || textOverflow.isSome() ||
-                       backplateColor)
-                          ? nullptr
-                          : GetFirstLineContaining(aBuilder->GetDirtyRect().y);
+  nsLineBox* cursor =
+      (hasDescendantPlaceHolders || textOverflow.isSome() || backplateColor)
+          ? nullptr
+          : GetFirstLineContaining(aBuilder->GetDirtyRect().y);
   LineIterator line_end = LinesEnd();
 
   TextOverflow* textOverflowPtr = textOverflow.ptrOr(nullptr);
 
   if (cursor) {
     for (LineIterator line = mLines.begin(cursor); line != line_end; ++line) {
       const nsRect lineArea = line->GetVisualOverflowArea();
       if (!lineArea.IsEmpty()) {
--- a/layout/xul/nsBox.cpp
+++ b/layout/xul/nsBox.cpp
@@ -403,33 +403,33 @@ static nscoord GetScrollbarWidthNoTheme(
       return 12 * AppUnitsPerCSSPixel();
     case StyleScrollbarWidth::Thin:
       return 6 * AppUnitsPerCSSPixel();
     case StyleScrollbarWidth::None:
       return 0;
   }
 }
 
-bool nsIFrame::AddXULMinSize(nsIFrame* aBox,
-                             nsSize& aSize, bool& aWidthSet, bool& aHeightSet) {
+bool nsIFrame::AddXULMinSize(nsIFrame* aBox, nsSize& aSize, bool& aWidthSet,
+                             bool& aHeightSet) {
   aWidthSet = false;
   aHeightSet = false;
 
   bool canOverride = true;
 
   nsPresContext* pc = aBox->PresContext();
 
   // See if a native theme wants to supply a minimum size.
   const nsStyleDisplay* display = aBox->StyleDisplay();
   if (display->HasAppearance()) {
     nsITheme* theme = pc->Theme();
     if (theme->ThemeSupportsWidget(pc, aBox, display->mAppearance)) {
       LayoutDeviceIntSize size;
-      theme->GetMinimumWidgetSize(pc, aBox,
-                                  display->mAppearance, &size, &canOverride);
+      theme->GetMinimumWidgetSize(pc, aBox, display->mAppearance, &size,
+                                  &canOverride);
       if (size.width) {
         aSize.width = pc->DevPixelsToAppUnits(size.width);
         aWidthSet = true;
       }
       if (size.height) {
         aSize.height = pc->DevPixelsToAppUnits(size.height);
         aHeightSet = true;
       }
--- a/layout/xul/nsTextBoxFrame.cpp
+++ b/layout/xul/nsTextBoxFrame.cpp
@@ -482,17 +482,18 @@ void nsTextBoxFrame::DrawText(gfxContext
   }
 
   RefPtr<gfxContext> refContext =
       PresShell()->CreateReferenceRenderingContext();
   DrawTarget* refDrawTarget = refContext->GetDrawTarget();
 
   CalculateUnderline(refDrawTarget, *fontMet);
 
-  DeviceColor color = ToDeviceColor(aOverrideColor ? *aOverrideColor : StyleText()->mColor.ToColor());
+  DeviceColor color = ToDeviceColor(
+      aOverrideColor ? *aOverrideColor : StyleText()->mColor.ToColor());
   ColorPattern colorPattern(color);
   aRenderingContext.SetDeviceColor(color);
 
   nsresult rv = NS_ERROR_FAILURE;
 
   if (mState & NS_FRAME_IS_BIDI) {
     presContext->SetBidiEnabled();
     nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(Style());
--- a/memory/replace/phc/test/gtest/TestPHC.cpp
+++ b/memory/replace/phc/test/gtest/TestPHC.cpp
@@ -90,17 +90,17 @@ TEST(PHC, TestPHCAllocations)
 
 #define ASSERT_ALIGN(a1, a2)                                    \
   p = (uint8_t*)GetPHCAllocation(8, (a1));                      \
   ASSERT_EQ((reinterpret_cast<uintptr_t>(p) & (kPageSize - 1)), \
             kPageSize - (a2));                                  \
   ASSERT_EQ(moz_malloc_usable_size(p), (a2));                   \
   free(p);                                                      \
   p = (uint8_t*)moz_xmemalign((a1), 8);                         \
-  ASSERT_EQ(moz_malloc_usable_size(p), (a2));                    \
+  ASSERT_EQ(moz_malloc_usable_size(p), (a2));                   \
   free(p);
 
   // On Win64 the smallest possible allocation is 16 bytes. On other platforms
   // it is 8 bytes.
 #if defined(XP_WIN) && defined(HAVE_64BIT_BUILD)
   ASSERT_ALIGN(8U, 16U);
 #else
   ASSERT_ALIGN(8U, 8U);
--- a/mfbt/CheckedInt.h
+++ b/mfbt/CheckedInt.h
@@ -727,17 +727,17 @@ namespace detail {
 
 template <typename T, typename U>
 struct CastToCheckedIntImpl {
   typedef CheckedInt<T> ReturnType;
   static constexpr CheckedInt<T> run(U aU) { return aU; }
 };
 
 template <typename T>
-struct CastToCheckedIntImpl<T, CheckedInt<T> > {
+struct CastToCheckedIntImpl<T, CheckedInt<T>> {
   typedef const CheckedInt<T>& ReturnType;
   static constexpr const CheckedInt<T>& run(const CheckedInt<T>& aU) {
     return aU;
   }
 };
 
 }  // namespace detail
 
--- a/mfbt/TsanOptions.h
+++ b/mfbt/TsanOptions.h
@@ -34,54 +34,53 @@
 extern "C" const char* __tsan_default_options() {
   return "halt_on_error=1:abort_on_error=1:report_signal_unsafe=0"
          ":allocator_may_return_null=1";
 }
 
 // These are default suppressions for external libraries that probably
 // every application would want to include if it potentially loads external
 // libraries like GTK/X and hence their dependencies.
-#define MOZ_TSAN_DEFAULT_EXTLIB_SUPPRESSIONS     \
-        "called_from_lib:libatk-1\n"             \
-        "called_from_lib:libcairo.so\n"          \
-        "called_from_lib:libcairo-gobject\n"     \
-        "called_from_lib:libgdk-3\n"             \
-        "called_from_lib:libgdk_pixbuf\n"        \
-        "called_from_lib:libgdk-x11\n"           \
-        "called_from_lib:libgio-2\n"             \
-        "called_from_lib:libglib-1\n"            \
-        "called_from_lib:libglib-2\n"            \
-        "called_from_lib:libgobject\n"           \
-        "called_from_lib:libgtk-3\n"             \
-        "called_from_lib:libgtk-x11\n"           \
-        "called_from_lib:libgvfscommon\n"        \
-        "called_from_lib:libgvfsdbus\n"          \
-        "called_from_lib:libibus-1\n"            \
-        "called_from_lib:libogg.so\n"            \
-        "called_from_lib:libpangocairo\n"        \
-        "called_from_lib:libpangoft2\n"          \
-        "called_from_lib:pango-basic-fc\n"       \
-        "called_from_lib:libpixman-1\n"          \
-        "called_from_lib:libpulse.so\n"          \
-        "called_from_lib:libpulsecommon\n"       \
-        "called_from_lib:libsecret-1\n"          \
-        "called_from_lib:libunity-gtk3-parser\n" \
-        "called_from_lib:libvorbis.so\n"         \
-        "called_from_lib:libvorbisfile\n"        \
-        "called_from_lib:libX11.so\n"            \
-        "called_from_lib:libX11-xcb\n"           \
-        "called_from_lib:libXau\n"               \
-        "called_from_lib:libxcb.so\n"            \
-        "called_from_lib:libXcomposite\n"        \
-        "called_from_lib:libXcursor\n"           \
-        "called_from_lib:libXdamage\n"           \
-        "called_from_lib:libXdmcp\n"             \
-        "called_from_lib:libXext\n"              \
-        "called_from_lib:libXfixes\n"            \
-        "called_from_lib:libXi.so\n"             \
-        "called_from_lib:libXrandr\n"            \
-        "called_from_lib:libXrender\n"           \
-        "called_from_lib:libXss\n"
-
+#  define MOZ_TSAN_DEFAULT_EXTLIB_SUPPRESSIONS \
+    "called_from_lib:libatk-1\n"               \
+    "called_from_lib:libcairo.so\n"            \
+    "called_from_lib:libcairo-gobject\n"       \
+    "called_from_lib:libgdk-3\n"               \
+    "called_from_lib:libgdk_pixbuf\n"          \
+    "called_from_lib:libgdk-x11\n"             \
+    "called_from_lib:libgio-2\n"               \
+    "called_from_lib:libglib-1\n"              \
+    "called_from_lib:libglib-2\n"              \
+    "called_from_lib:libgobject\n"             \
+    "called_from_lib:libgtk-3\n"               \
+    "called_from_lib:libgtk-x11\n"             \
+    "called_from_lib:libgvfscommon\n"          \
+    "called_from_lib:libgvfsdbus\n"            \
+    "called_from_lib:libibus-1\n"              \
+    "called_from_lib:libogg.so\n"              \
+    "called_from_lib:libpangocairo\n"          \
+    "called_from_lib:libpangoft2\n"            \
+    "called_from_lib:pango-basic-fc\n"         \
+    "called_from_lib:libpixman-1\n"            \
+    "called_from_lib:libpulse.so\n"            \
+    "called_from_lib:libpulsecommon\n"         \
+    "called_from_lib:libsecret-1\n"            \
+    "called_from_lib:libunity-gtk3-parser\n"   \
+    "called_from_lib:libvorbis.so\n"           \
+    "called_from_lib:libvorbisfile\n"          \
+    "called_from_lib:libX11.so\n"              \
+    "called_from_lib:libX11-xcb\n"             \
+    "called_from_lib:libXau\n"                 \
+    "called_from_lib:libxcb.so\n"              \
+    "called_from_lib:libXcomposite\n"          \
+    "called_from_lib:libXcursor\n"             \
+    "called_from_lib:libXdamage\n"             \
+    "called_from_lib:libXdmcp\n"               \
+    "called_from_lib:libXext\n"                \
+    "called_from_lib:libXfixes\n"              \
+    "called_from_lib:libXi.so\n"               \
+    "called_from_lib:libXrandr\n"              \
+    "called_from_lib:libXrender\n"             \
+    "called_from_lib:libXss\n"
 
 #endif  // _MSC_VER
 
 #endif /* mozilla_TsanOptions_h */
--- a/mozglue/build/TsanOptions.cpp
+++ b/mozglue/build/TsanOptions.cpp
@@ -25,16 +25,17 @@
 //       https://software.intel.com/en-us/blogs/2013/01/06/benign-data-races-what-could-possibly-go-wrong
 //
 //
 // Also, when adding any race suppressions here, make sure to always add
 // a signature for each of the two race stacks. Sometimes, TSan fails to
 // symbolize one of the two traces and this can cause suppressed races to
 // show up intermittently.
 //
+// clang-format off
 extern "C" const char* __tsan_default_suppressions() {
   return "# Add your suppressions below\n"
 
          // External uninstrumented libraries
          MOZ_TSAN_DEFAULT_EXTLIB_SUPPRESSIONS
 
          // These libraries are uninstrumented and cause mutex false positives.
          // However, they can be unloaded by GTK early which we cannot avoid.
@@ -310,9 +311,10 @@ extern "C" const char* __tsan_default_su
          // `message_loop_` to `NULL` on two threads when stopping
          // a thread at the same time it is already finishing.
          // See also bug 1615228 for discussion.
          "race:base::Thread::Stop\n"
 
       // End of suppressions.
       ;  // Please keep this semicolon.
 }
+// clang-format on
 #endif  // _MSC_VER
--- a/netwerk/protocol/http/Http3Session.cpp
+++ b/netwerk/protocol/http/Http3Session.cpp
@@ -228,45 +228,45 @@ nsresult Http3Session::ProcessInput(uint
 nsresult Http3Session::ProcessSingleTransactionRead(Http3Stream* stream,
                                                     uint32_t count,
                                                     uint32_t* countWritten) {
   uint32_t countWrittenSingle = 0;
   nsresult rv = stream->WriteSegments(this, count, &countWrittenSingle);
   *countWritten += countWrittenSingle;
 
   if (ASpdySession::SoftStreamError(rv)) {
-    CloseStream(stream, (rv == NS_BINDING_RETARGETED)
-                            ? NS_BINDING_RETARGETED
-                            : NS_OK);
+    CloseStream(stream,
+                (rv == NS_BINDING_RETARGETED) ? NS_BINDING_RETARGETED : NS_OK);
     return NS_OK;
   }
 
   if (NS_FAILED(rv) && rv != NS_BASE_STREAM_WOULD_BLOCK) {
     return rv;
   }
   return NS_OK;
 }
 
 nsresult Http3Session::ProcessTransactionRead(uint64_t stream_id,
                                               uint32_t count,
                                               uint32_t* countWritten) {
   RefPtr<Http3Stream> stream = mStreamIdHash.Get(stream_id);
   if (!stream) {
-    LOG(("Http3Session::ProcessTransactionRead - stream not found stream_id=0x%"
-         PRIx64 " [this=%p].", stream_id, this));
+    LOG(
+        ("Http3Session::ProcessTransactionRead - stream not found "
+         "stream_id=0x%" PRIx64 " [this=%p].",
+         stream_id, this));
     return NS_OK;
   }
 
   return ProcessTransactionRead(stream, count, countWritten);
 }
 
 nsresult Http3Session::ProcessTransactionRead(Http3Stream* stream,
                                               uint32_t count,
                                               uint32_t* countWritten) {
-
   nsresult rv = ProcessSingleTransactionRead(stream, count, countWritten);
 
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   if (stream->RecvdFin() && !stream->Done() && NS_SUCCEEDED(rv)) {
     // In RECEIVED_FIN state we need to give the httpTransaction the info
@@ -275,17 +275,18 @@ nsresult Http3Session::ProcessTransactio
 
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
 
   if (stream->Done()) {
     LOG3(("Http3Session::ProcessTransactionRead session=%p stream=%p 0x%" PRIx64
-          " cleanup stream.\n", this, stream, stream->StreamId()));
+          " cleanup stream.\n",
+          this, stream, stream->StreamId()));
     CloseStream(stream, NS_OK);
   }
 
   return NS_OK;
 }
 
 nsresult Http3Session::ProcessEvents(uint32_t count) {
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
@@ -306,18 +307,18 @@ nsresult Http3Session::ProcessEvents(uin
           LOG(("Http3Session::ProcessEvents - DataReadable"));
           id = event.data_readable.stream_id;
         }
 
         uint32_t read = 0;
         nsresult rv = ProcessTransactionRead(id, count, &read);
 
         if (NS_FAILED(rv)) {
-          LOG(("Http3Session::ProcessEvents [this=%p] rv=%" PRIx32,
-               this, static_cast<uint32_t>(rv)));
+          LOG(("Http3Session::ProcessEvents [this=%p] rv=%" PRIx32, this,
+               static_cast<uint32_t>(rv)));
           return rv;
         }
 
         break;
       }
       case Http3Event::Tag::DataWritable:
         MOZ_ASSERT(mState == CONNECTED);
         LOG(("Http3Session::ProcessEvents - DataWritable"));
@@ -721,19 +722,18 @@ nsresult Http3Session::ReadSegmentsAgain
   //      to let the error be handled).
 
   nsresult rv = NS_OK;
   Http3Stream* stream = nullptr;
 
   // Step 1)
   while (
       (mState ==
-       CONNECTED) && // Do not send transaction data untill we are connected.
+       CONNECTED) &&  // Do not send transaction data untill we are connected.
       (stream = static_cast<Http3Stream*>(mReadyForWrite.PopFront()))) {
-
     LOG(
         ("Http3Session::ReadSegmentsAgain call ReadSegments from stream=%p "
          "[this=%p]",
          stream, this));
 
     uint32_t countReadSingle = 0;
     do {
       countReadSingle = 0;
@@ -803,18 +803,18 @@ nsresult Http3Session::ProcessSlowConsum
   if (mSlowConsumersReadyForRead.IsEmpty()) {
     return NS_OK;
   }
 
   RefPtr<Http3Stream> slowConsumer = mSlowConsumersReadyForRead.ElementAt(0);
   mSlowConsumersReadyForRead.RemoveElementAt(0);
 
   uint32_t countRead = 0;
-  nsresult rv = ProcessTransactionRead(slowConsumer,
-      nsIOService::gDefaultSegmentSize, &countRead);
+  nsresult rv = ProcessTransactionRead(
+      slowConsumer, nsIOService::gDefaultSegmentSize, &countRead);
 
   if (NS_SUCCEEDED(rv) && (countRead > 0) && !slowConsumer->Done()) {
     // There have been buffered bytes successfully fed into the
     // formerly blocked consumer. Repeat until buffer empty or
     // consumer is blocked again.
     ConnectSlowConsumer(slowConsumer);
   }
 
--- a/netwerk/protocol/http/HttpConnectionUDP.cpp
+++ b/netwerk/protocol/http/HttpConnectionUDP.cpp
@@ -311,23 +311,21 @@ nsresult HttpConnectionUDP::OnHeadersAva
       *reset = true;
       return NS_OK;
     }
   }
 
   return NS_OK;
 }
 
-bool HttpConnectionUDP::IsReused() {
-  return mIsReused;
-}
+bool HttpConnectionUDP::IsReused() { return mIsReused; }
 
-nsresult HttpConnectionUDP::TakeTransport(nsISocketTransport** aTransport,
-                                          nsIAsyncInputStream** aInputStream,
-                                          nsIAsyncOutputStream** aOutputStream) {
+nsresult HttpConnectionUDP::TakeTransport(
+    nsISocketTransport** aTransport, nsIAsyncInputStream** aInputStream,
+    nsIAsyncOutputStream** aOutputStream) {
   return NS_ERROR_FAILURE;
 }
 
 void HttpConnectionUDP::GetSecurityInfo(nsISupports** secinfo) {
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
   LOG(("HttpConnectionUDP::GetSecurityInfo http3Session=%p socket=%p\n",
        mHttp3Session.get(), mSocketTransport.get()));
 
@@ -381,18 +379,17 @@ class HttpConnectionUDPForceIO : public 
 
 nsresult HttpConnectionUDP::ResumeSend() {
   LOG(("HttpConnectionUDP::ResumeSend [this=%p]\n", this));
 
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
 
   if (mSocketOut) {
     nsresult rv = mSocketOut->AsyncWait(this, 0, 0, nullptr);
-    LOG(
-        ("HttpConnectionUDP::ResumeSend [this=%p]\n", this));
+    LOG(("HttpConnectionUDP::ResumeSend [this=%p]\n", this));
     return rv;
   }
 
   MOZ_ASSERT_UNREACHABLE("no socket output stream");
   return NS_ERROR_UNEXPECTED;
 }
 
 nsresult HttpConnectionUDP::ResumeRecv() {
@@ -433,42 +430,39 @@ nsresult HttpConnectionUDP::MaybeForceSe
   // tick interval (kForceDelay) as a backup for those circumstances.
   static const uint32_t kForceDelay = 17;  // ms
 
   if (mForceSendPending) {
     return NS_OK;
   }
   MOZ_ASSERT(!mForceSendTimer);
   mForceSendPending = true;
-  return NS_NewTimerWithFuncCallback(getter_AddRefs(mForceSendTimer),
-                                     HttpConnectionUDP::ForceSendIO, this,
-                                     kForceDelay, nsITimer::TYPE_ONE_SHOT,
-                                     "net::HttpConnectionUDP::MaybeForceSendIO");
+  return NS_NewTimerWithFuncCallback(
+      getter_AddRefs(mForceSendTimer), HttpConnectionUDP::ForceSendIO, this,
+      kForceDelay, nsITimer::TYPE_ONE_SHOT,
+      "net::HttpConnectionUDP::MaybeForceSendIO");
 }
 
 // trigger an asynchronous read
 nsresult HttpConnectionUDP::ForceRecv() {
   LOG(("HttpConnectionUDP::ForceRecv [this=%p]\n", this));
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
 
-  return NS_DispatchToCurrentThread(
-      new HttpConnectionUDPForceIO(this, true));
+  return NS_DispatchToCurrentThread(new HttpConnectionUDPForceIO(this, true));
 }
 
 // trigger an asynchronous write
 nsresult HttpConnectionUDP::ForceSend() {
   LOG(("HttpConnectionUDP::ForceSend [this=%p]\n", this));
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
 
   return MaybeForceSendIO();
 }
 
-HttpVersion HttpConnectionUDP::Version() {
-  return HttpVersion::v3_0;
-}
+HttpVersion HttpConnectionUDP::Version() { return HttpVersion::v3_0; }
 
 //-----------------------------------------------------------------------------
 // HttpConnectionUDP <private>
 //-----------------------------------------------------------------------------
 
 void HttpConnectionUDP::CloseTransaction(nsAHttpTransaction* trans,
                                          nsresult reason, bool aIsShutdown) {
   LOG(("HttpConnectionUDP::CloseTransaction[this=%p trans=%p reason=%" PRIx32
@@ -482,17 +476,17 @@ void HttpConnectionUDP::CloseTransaction
     MOZ_ASSERT(false);
     return;
   }
 
   // The connection and security errors clear out alt-svc mappings
   // in case any previously validated ones are now invalid
   if (((reason == NS_ERROR_NET_RESET) ||
        (NS_ERROR_GET_MODULE(reason) == NS_ERROR_MODULE_SECURITY)) &&
-       mConnInfo && !(mTransactionCaps & NS_HTTP_ERROR_SOFTLY)) {
+      mConnInfo && !(mTransactionCaps & NS_HTTP_ERROR_SOFTLY)) {
     gHttpHandler->ClearHostMapping(mConnInfo);
   }
 
   mDontReuse = true;
   if (mHttp3Session) {
     mHttp3Session->SetCleanShutdown(aIsShutdown);
     mHttp3Session->Close(reason);
     if (!mHttp3Session->IsClosed()) {
@@ -577,17 +571,17 @@ nsresult HttpConnectionUDP::OnWriteSegme
   }
 
   nsresult rv = mSocketIn->Read(buf, count, countWritten);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   if (*countWritten == 0) {
-    return  NS_BASE_STREAM_CLOSED;
+    return NS_BASE_STREAM_CLOSED;
   }
 
   return NS_OK;
 }
 
 void HttpConnectionUDP::OnQuicTimeout(nsITimer* aTimer, void* aClosure) {
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
   LOG(("HttpConnectionUDP::OnQuicTimeout [this=%p]\n", aClosure));
@@ -763,28 +757,24 @@ void HttpConnectionUDP::SetEvent(nsresul
     case NS_NET_STATUS_TLS_HANDSHAKE_ENDED:
       mBootstrappedTimings.connectEnd = TimeStamp::Now();
       break;
     default:
       break;
   }
 }
 
-bool HttpConnectionUDP::IsProxyConnectInProgress() {
-  return false;
-}
+bool HttpConnectionUDP::IsProxyConnectInProgress() { return false; }
 
 bool HttpConnectionUDP::LastTransactionExpectedNoContent() {
   return mLastTransactionExpectedNoContent;
 }
 
 void HttpConnectionUDP::SetLastTransactionExpectedNoContent(bool val) {
   mLastTransactionExpectedNoContent = val;
 }
 
-bool HttpConnectionUDP::IsPersistent() {
-  return !mDontReuse;
-}
+bool HttpConnectionUDP::IsPersistent() { return !mDontReuse; }
 
 nsAHttpTransaction* HttpConnectionUDP::Transaction() { return mHttp3Session; }
 
 }  // namespace net
 }  // namespace mozilla
--- a/netwerk/protocol/http/nsHttpConnection.h
+++ b/netwerk/protocol/http/nsHttpConnection.h
@@ -172,16 +172,17 @@ class nsHttpConnection final : public Ht
   uint8_t GetFastOpenStatus() { return mFastOpenStatus; }
 
   // Return true when the socket this connection is using has not been
   // authenticated using a client certificate.  Before SSL negotiation
   // has finished this returns false.
   bool NoClientCertAuth() const override;
 
   bool CanAcceptWebsocket() override;
+
  private:
   // Value (set in mTCPKeepaliveConfig) indicates which set of prefs to use.
   enum TCPKeepaliveConfig {
     kTCPKeepaliveDisabled = 0,
     kTCPKeepaliveShortLivedConfig,
     kTCPKeepaliveLongLivedConfig
   };
 
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -825,17 +825,18 @@ HttpConnectionBase* nsHttpConnectionMgr:
 void nsHttpConnectionMgr::UpdateCoalescingForNewConn(
     HttpConnectionBase* newConn, nsConnectionEntry* ent) {
   MOZ_ASSERT(OnSocketThread(), "not on socket thread");
   MOZ_ASSERT(newConn);
   MOZ_ASSERT(newConn->ConnectionInfo());
   MOZ_ASSERT(ent);
   MOZ_ASSERT(mCT.GetWeak(newConn->ConnectionInfo()->HashKey()) == ent);
 
-  HttpConnectionBase* existingConn = FindCoalescableConnection(ent, true, false);
+  HttpConnectionBase* existingConn =
+      FindCoalescableConnection(ent, true, false);
   if (existingConn) {
     LOG(
         ("UpdateCoalescingForNewConn() found existing active conn that could "
          "have served newConn "
          "graceful close of newConn=%p to migrate to existingConn %p\n",
          newConn, existingConn));
     newConn->DontReuse();
     return;
@@ -1571,17 +1572,18 @@ nsresult nsHttpConnectionMgr::TryDispatc
 
   RefPtr<HttpConnectionBase> unusedSpdyPersistentConnection;
 
   // step 0
   // look for existing spdy connection - that's always best because it is
   // essentially pipelining without head of line blocking
 
   if (!(caps & NS_HTTP_DISALLOW_SPDY) && gHttpHandler->IsSpdyEnabled()) {
-    RefPtr<HttpConnectionBase> conn = GetH2orH3ActiveConn(ent,
+    RefPtr<HttpConnectionBase> conn = GetH2orH3ActiveConn(
+        ent,
         (!gHttpHandler->IsHttp3Enabled() || (caps & NS_HTTP_DISALLOW_HTTP3)));
     if (conn) {
       if (trans->IsWebsocketUpgrade() && !conn->CanAcceptWebsocket()) {
         // This is a websocket transaction and we already have a h2 connection
         // that do not support websockets, we should disable h2 for this
         // transaction.
         trans->DisableSpdy();
         caps &= NS_HTTP_DISALLOW_SPDY;
@@ -1961,19 +1963,18 @@ nsresult nsHttpConnectionMgr::ProcessNew
                  : NS_ERROR_UNEXPECTED;
     }
   }
 
   nsresult rv = NS_OK;
   nsHttpConnectionInfo* ci = trans->ConnectionInfo();
   MOZ_ASSERT(ci);
 
-  nsConnectionEntry* ent =
-      GetOrCreateConnectionEntry(ci, !!trans->TunnelProvider(),
-                                 trans->Caps() & NS_HTTP_DISALLOW_HTTP3);
+  nsConnectionEntry* ent = GetOrCreateConnectionEntry(
+      ci, !!trans->TunnelProvider(), trans->Caps() & NS_HTTP_DISALLOW_HTTP3);
   MOZ_ASSERT(ent);
 
   ReportProxyTelemetry(ent);
 
   // Check if the transaction already has a sticky reference to a connection.
   // If so, then we can just use it directly by transferring its reference
   // to the new connection variable instead of searching for a new one
 
@@ -2269,18 +2270,18 @@ HttpConnectionBase* nsHttpConnectionMgr:
          "found an active but inexperienced connection %p in native connection "
          "entry\n",
          ent, ci->HashKey().get(), noExperience));
     return noExperience;
   }
 
   // there was no active spdy connection in the connection entry, but
   // there might be one in the hash table for coalescing
-  HttpConnectionBase* existingConn = FindCoalescableConnection(ent, false,
-      aNoHttp3);
+  HttpConnectionBase* existingConn =
+      FindCoalescableConnection(ent, false, aNoHttp3);
   if (existingConn) {
     LOG(
         ("GetH2orH3ActiveConn() request for ent %p %s "
          "found an active connection %p in the coalescing hashtable\n",
          ent, ci->HashKey().get(), existingConn));
     return existingConn;
   }
 
@@ -2688,17 +2689,17 @@ void nsHttpConnectionMgr::OnMsgPruneDead
             timeToNextExpire = std::min(timeToNextExpire, conn->TimeToLive());
           }
         }
       }
 
       if (ent->mUsingSpdy) {
         for (uint32_t i = 0; i < ent->mActiveConns.Length(); ++i) {
           RefPtr<nsHttpConnection> connTCP =
-              do_QueryObject( ent->mActiveConns[i]);
+              do_QueryObject(ent->mActiveConns[i]);
           // Http3 has its own timers, it is not using this one.
           if (connTCP && connTCP->UsingSpdy()) {
             if (!connTCP->CanReuse()) {
               // Marking it don't-reuse will create an active
               // tear down if the spdy session is idle.
               connTCP->DontReuse();
             } else {
               timeToNextExpire =
@@ -5670,17 +5671,18 @@ void nsHttpConnectionMgr::MoveToWildCard
       ("nsHttpConnectionMgr::MakeConnEntryWildCard conn %p using ent %p (spdy "
        "%d)\n",
        proxyConn, ent, ent ? ent->mUsingSpdy : 0));
 
   if (!ent || !ent->mUsingSpdy) {
     return;
   }
 
-  nsConnectionEntry* wcEnt = GetOrCreateConnectionEntry(wildCardCI, true, false);
+  nsConnectionEntry* wcEnt =
+      GetOrCreateConnectionEntry(wildCardCI, true, false);
   if (wcEnt == ent) {
     // nothing to do!
     return;
   }
   wcEnt->mUsingSpdy = true;
 
   LOG(
       ("nsHttpConnectionMgr::MakeConnEntryWildCard ent %p "
--- a/netwerk/protocol/http/nsHttpHandler.h
+++ b/netwerk/protocol/http/nsHttpHandler.h
@@ -346,19 +346,19 @@ class nsHttpHandler final : public nsIHt
     mAltSvcCache->UpdateAltServiceMapping(map, proxyInfo, callbacks, caps,
                                           originAttributes);
   }
 
   already_AddRefed<AltSvcMapping> GetAltServiceMapping(
       const nsACString& scheme, const nsACString& host, int32_t port, bool pb,
       bool isolated, const nsACString& topWindowOrigin,
       const OriginAttributes& originAttributes, bool aHttp3Allowed) {
-    return mAltSvcCache->GetAltServiceMapping(
-        scheme, host, port, pb, isolated, topWindowOrigin, originAttributes,
-        aHttp3Allowed);
+    return mAltSvcCache->GetAltServiceMapping(scheme, host, port, pb, isolated,
+                                              topWindowOrigin, originAttributes,
+                                              aHttp3Allowed);
   }
 
   //
   // The HTTP handler caches pointers to specific XPCOM services, and
   // provides the following helper routines for accessing those services:
   //
   MOZ_MUST_USE nsresult GetStreamConverterService(nsIStreamConverterService**);
   MOZ_MUST_USE nsresult GetIOService(nsIIOService** service);
--- a/toolkit/components/antitracking/ContentBlockingAllowList.h
+++ b/toolkit/components/antitracking/ContentBlockingAllowList.h
@@ -41,16 +41,17 @@ class ContentBlockingAllowList final {
                                  const OriginAttributes& aAttrs,
                                  nsIPrincipal** aPrincipal);
 
  private:
   // Utility APIs for ContentBlocking.
   static bool Check(nsIPrincipal* aTopWinPrincipal, bool aIsPrivateBrowsing);
   static bool Check(nsPIDOMWindowInner* aWindow);
   static bool Check(nsICookieJarSettings* aCookieJarSettings);
-  static nsresult Check(mozilla::dom::BrowsingContext* aBrowsingContext, bool& aIsAllowListed);
+  static nsresult Check(mozilla::dom::BrowsingContext* aBrowsingContext,
+                        bool& aIsAllowListed);
 
   friend class ContentBlocking;
 };
 
 }  // namespace mozilla
 
 #endif  // mozilla_contentblockingallowlist_h
--- a/toolkit/components/telemetry/core/Telemetry.cpp
+++ b/toolkit/components/telemetry/core/Telemetry.cpp
@@ -1161,36 +1161,33 @@ TelemetryImpl::GetIsOfficialTelemetry(bo
   return NS_OK;
 }
 
 #if defined(MOZ_GLEAN)
 // The FOG API is implemented in Rust and exposed to C++ via a set of
 // C functions with the "fog_" prefix.
 // See toolkit/components/glean/*.
 extern "C" {
-nsresult fog_init(
-    const nsACString* dataPath,
-    const nsACString* buildId,
-    const nsACString* appDisplayVersion,
-    const char* channel,
-    const nsACString* osVersion,
-    const nsACString* architecture
-);
+nsresult fog_init(const nsACString* dataPath, const nsACString* buildId,
+                  const nsACString* appDisplayVersion, const char* channel,
+                  const nsACString* osVersion, const nsACString* architecture);
 }
 
 static void internal_initGlean() {
   nsAutoCString dataPath;
-  nsresult rv = Preferences::GetCString("telemetry.fog.temporary_and_just_for_testing.data_path", dataPath);
+  nsresult rv = Preferences::GetCString(
+      "telemetry.fog.temporary_and_just_for_testing.data_path", dataPath);
 
   if (NS_FAILED(rv)) {
     NS_WARNING("Can't read data path preference. FOG will not be initialized");
     return;
   }
 
-  nsCOMPtr<nsIXULAppInfo> appInfo = do_GetService("@mozilla.org/xre/app-info;1");
+  nsCOMPtr<nsIXULAppInfo> appInfo =
+      do_GetService("@mozilla.org/xre/app-info;1");
   if (!appInfo) {
     NS_WARNING("Can't fetch app info. FOG will not be initialized.");
     return;
   }
 
   nsAutoCString buildID;
   rv = appInfo->GetAppBuildID(buildID);
   if (NS_FAILED(rv)) {
@@ -1200,46 +1197,42 @@ static void internal_initGlean() {
 
   nsAutoCString appVersion;
   rv = appInfo->GetVersion(appVersion);
   if (NS_FAILED(rv)) {
     NS_WARNING("Can't get app version. FOG will not be initialized.");
     return;
   }
 
-  nsCOMPtr<nsIPropertyBag2> infoService = do_GetService("@mozilla.org/system-info;1");
+  nsCOMPtr<nsIPropertyBag2> infoService =
+      do_GetService("@mozilla.org/system-info;1");
   if (!appInfo) {
     NS_WARNING("Can't fetch info service. FOG will not be initialized.");
     return;
   }
 
   nsAutoCString osVersion;
-  rv = infoService->GetPropertyAsACString(NS_LITERAL_STRING("version"), osVersion);
+  rv = infoService->GetPropertyAsACString(NS_LITERAL_STRING("version"),
+                                          osVersion);
   if (NS_FAILED(rv)) {
     NS_WARNING("Can't get OS version. FOG will not be initialized.");
     return;
   }
 
   nsAutoCString architecture;
-  rv = infoService->GetPropertyAsACString(NS_LITERAL_STRING("arch"), architecture);
+  rv = infoService->GetPropertyAsACString(NS_LITERAL_STRING("arch"),
+                                          architecture);
   if (NS_FAILED(rv)) {
     NS_WARNING("Can't get architecture. FOG will not be initialized.");
     return;
   }
 
-  Unused << NS_WARN_IF(NS_FAILED(
-        fog_init(
-          &dataPath,
-          &buildID,
-          &appVersion,
-          MOZ_STRINGIFY(MOZ_UPDATE_CHANNEL),
-          &osVersion,
-          &architecture
-        )
-  ));
+  Unused << NS_WARN_IF(NS_FAILED(fog_init(&dataPath, &buildID, &appVersion,
+                                          MOZ_STRINGIFY(MOZ_UPDATE_CHANNEL),
+                                          &osVersion, &architecture)));
 }
 #endif  // defined(MOZ_GLEAN)
 
 already_AddRefed<nsITelemetry> TelemetryImpl::CreateTelemetryInstance() {
   {
     auto lock = sTelemetry.Lock();
     MOZ_ASSERT(
         *lock == nullptr,
--- a/toolkit/mozapps/defaultagent/ScheduledTask.cpp
+++ b/toolkit/mozapps/defaultagent/ScheduledTask.cpp
@@ -175,17 +175,17 @@ HRESULT RegisterTask(const wchar_t* uniq
 
   return hr;
 }
 
 HRESULT UpdateTask(const wchar_t* uniqueToken) {
   RefPtr<ITaskService> scheduler;
   HRESULT hr = S_OK;
   ENSURE(CoCreateInstance(CLSID_TaskScheduler, nullptr, CLSCTX_INPROC_SERVER,
-    IID_ITaskService, getter_AddRefs(scheduler)));
+                          IID_ITaskService, getter_AddRefs(scheduler)));
 
   ENSURE(scheduler->Connect(VARIANT{}, VARIANT{}, VARIANT{}, VARIANT{}));
 
   RefPtr<ITaskFolder> taskFolder;
   BStrPtr folderBStr = BStrPtr(SysAllocString(kTaskVendor));
 
   if (FAILED(
           scheduler->GetFolder(folderBStr.get(), getter_AddRefs(taskFolder)))) {
--- a/toolkit/mozapps/defaultagent/Telemetry.cpp
+++ b/toolkit/mozapps/defaultagent/Telemetry.cpp
@@ -354,19 +354,19 @@ static mozilla::WindowsError SendPing(st
   }
   std::wstring pingsenderPath = pingsenderPathResult.unwrap();
 
   std::wstring url(L"" TELEMETRY_PING_URL);
   url.append(uuid);
 
   const wchar_t* pingsenderArgs[] = {pingsenderPath.c_str(), url.c_str(),
                                      pingFilePath.c_str()};
-  mozilla::UniquePtr<wchar_t[]> pingsenderCmdLine(mozilla::MakeCommandLine(
-      mozilla::ArrayLength(pingsenderArgs),
-      const_cast<wchar_t**>(pingsenderArgs)));
+  mozilla::UniquePtr<wchar_t[]> pingsenderCmdLine(
+      mozilla::MakeCommandLine(mozilla::ArrayLength(pingsenderArgs),
+                               const_cast<wchar_t**>(pingsenderArgs)));
 
   PROCESS_INFORMATION pi;
   STARTUPINFOW si = {sizeof(si)};
   si.dwFlags = STARTF_USESHOWWINDOW;
   si.wShowWindow = SW_HIDE;
   if (!::CreateProcessW(pingsenderPath.c_str(), pingsenderCmdLine.get(),
                         nullptr, nullptr, FALSE, 0, nullptr, nullptr, &si,
                         &pi)) {
@@ -402,12 +402,11 @@ HRESULT SendDefaultBrowserPing() {
   std::string osVersion = osVersionResult.unwrap();
 
   TelemetryFieldResult osLocaleResult = GetOSLocale();
   if (osLocaleResult.isErr()) {
     return osLocaleResult.unwrapErr().AsHResult();
   }
   std::string osLocale = osLocaleResult.unwrap();
 
-  return
-      SendPing(defaultBrowser, previousDefaultBrowser, osVersion, osLocale)
-          .AsHResult();
+  return SendPing(defaultBrowser, previousDefaultBrowser, osVersion, osLocale)
+      .AsHResult();
 }
--- a/toolkit/mozapps/defaultagent/common.h
+++ b/toolkit/mozapps/defaultagent/common.h
@@ -2,13 +2,12 @@
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* 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 __DEFAULT_BROWSER_AGENT_COMMON_H__
 #define __DEFAULT_BROWSER_AGENT_COMMON_H__
 
-#define AGENT_REGKEY_NAME      \
-  L"SOFTWARE\\" MOZ_APP_VENDOR \
-  "\\" MOZ_APP_BASENAME "\\Default Browser Agent"
+#define AGENT_REGKEY_NAME \
+  L"SOFTWARE\\" MOZ_APP_VENDOR "\\" MOZ_APP_BASENAME "\\Default Browser Agent"
 
 #endif  // __DEFAULT_BROWSER_AGENT_COMMON_H__
--- a/toolkit/mozapps/update/updater/TsanOptions.cpp
+++ b/toolkit/mozapps/update/updater/TsanOptions.cpp
@@ -5,21 +5,23 @@
 
 #include "mozilla/Attributes.h"
 #include "mozilla/TsanOptions.h"
 
 #ifndef _MSC_VER  // Not supported by clang-cl yet
 
 // See also mozglue/build/TsanOptions.cpp before modifying this
 extern "C" const char* __tsan_default_suppressions() {
+  // clang-format off
   return "# Add your suppressions below\n"
 
          // External uninstrumented libraries
          MOZ_TSAN_DEFAULT_EXTLIB_SUPPRESSIONS
 
          // Bug 1623034
          "race:QuitProgressUI\n"
          "race:ShowProgressUI\n"
 
       // End of suppressions.
       ;  // Please keep this semicolon.
+  // clang-format on
 }
 #endif  // _MSC_VER
--- a/widget/gtk/nsDragService.cpp
+++ b/widget/gtk/nsDragService.cpp
@@ -1378,21 +1378,18 @@ void nsDragService::SourceDataGet(GtkWid
   MOZ_LOG(sDragLm, LogLevel::Debug, ("nsDragService::SourceDataGet"));
   GdkAtom target = gtk_selection_data_get_target(aSelectionData);
   gchar* typeName = gdk_atom_name(target);
   if (!typeName) {
     MOZ_LOG(sDragLm, LogLevel::Debug, ("failed to get atom name.\n"));
     return;
   }
 
-
   MOZ_LOG(sDragLm, LogLevel::Debug, ("Type is %s\n", typeName));
-  auto freeTypeName = mozilla::MakeScopeExit([&] {
-    g_free(typeName);
-  });
+  auto freeTypeName = mozilla::MakeScopeExit([&] { g_free(typeName); });
   // check to make sure that we have data items to return.
   if (!mSourceDataItems) {
     MOZ_LOG(sDragLm, LogLevel::Debug, ("Failed to get our data items\n"));
     return;
   }
 
   nsDependentCSubstring mimeFlavor(typeName, strlen(typeName));
   nsCOMPtr<nsITransferable> item;
--- a/xpcom/build/XPCOMInit.cpp
+++ b/xpcom/build/XPCOMInit.cpp
@@ -750,20 +750,18 @@ nsresult ShutdownXPCOM(nsIServiceManager
     if (NSS_Shutdown() != SECSuccess) {
       // If you're seeing this crash and/or warning, some NSS resources are
       // still in use (see bugs 1417680 and 1230312). Set the environment
       // variable 'MOZ_IGNORE_NSS_SHUTDOWN_LEAKS' to some value to ignore this.
       // Also, if leak checking is enabled, report this as a fake leak instead
       // of crashing.
 #if defined(DEBUG) && !defined(ANDROID)
       if (!getenv("MOZ_IGNORE_NSS_SHUTDOWN_LEAKS") &&
-          !getenv("XPCOM_MEM_BLOAT_LOG") &&
-          !getenv("XPCOM_MEM_LEAK_LOG") &&
-          !getenv("XPCOM_MEM_REFCNT_LOG") &&
-          !getenv("XPCOM_MEM_COMPTR_LOG")) {
+          !getenv("XPCOM_MEM_BLOAT_LOG") && !getenv("XPCOM_MEM_LEAK_LOG") &&
+          !getenv("XPCOM_MEM_REFCNT_LOG") && !getenv("XPCOM_MEM_COMPTR_LOG")) {
         MOZ_CRASH("NSS_Shutdown failed");
       } else {
 #  ifdef NS_BUILD_REFCNT_LOGGING
         // Create a fake leak.
         NS_LogCtor((void*)0x100, "NSSShutdownFailed", 100);
 #  endif  // NS_BUILD_REFCNT_LOGGING
         NS_WARNING("NSS_Shutdown failed");
       }