Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Sat, 06 Jul 2019 08:18:28 +0000
changeset 544392 50b6e4480ea0cdc62c9d28d40b277dad6e2878e5
parent 544391 01f4651b1ca8010dd2b900fe8236ed9f449359bd
child 544393 3dc9d0ab9eeae14b6a5b369c3235d69249cad37d
push id2131
push userffxbld-merge
push dateMon, 26 Aug 2019 18:30:20 +0000
treeherdermozilla-release@b19ffb3ca153 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1519636
milestone69.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D35622
docshell/base/nsDocShell.h
dom/base/BindContext.h
dom/base/DocGroup.cpp
dom/base/DocGroup.h
dom/base/ShadowRoot.h
dom/base/nsGlobalWindowInner.h
dom/base/nsGlobalWindowOuter.h
dom/base/nsImageLoadingContent.cpp
dom/base/nsNodeUtils.cpp
dom/bindings/RemoteObjectProxy.h
dom/gamepad/fallback/FallbackGamepad.cpp
dom/html/nsIFormControl.h
dom/ipc/BrowserChild.h
dom/localstorage/ActorsParent.cpp
dom/media/AutoplayPolicy.cpp
gfx/2d/DrawTargetD2D1.cpp
gfx/2d/PathCairo.cpp
gfx/2d/PathRecording.cpp
gfx/2d/PathRecording.h
gfx/2d/PathSkia.cpp
gfx/2d/PathSkia.h
gfx/2d/ScaledFontDWrite.cpp
gfx/config/gfxVars.h
gfx/layers/apz/public/APZUpdater.h
gfx/layers/apz/src/APZCTreeManager.h
gfx/layers/apz/src/APZUpdater.cpp
gfx/layers/apz/src/AsyncPanZoomController.cpp
gfx/layers/apz/src/HitTestingTreeNode.cpp
gfx/layers/client/TextureClient.cpp
gfx/layers/client/TextureClient.h
gfx/layers/composite/CompositableHost.cpp
gfx/layers/composite/TiledContentHost.cpp
gfx/layers/ipc/CompositorBridgeParent.cpp
gfx/layers/ipc/ImageBridgeChild.cpp
gfx/layers/ipc/LayersMessageUtils.h
gfx/layers/opengl/TextureHostOGL.cpp
gfx/layers/wr/WebRenderCommandBuilder.cpp
gfx/thebes/gfxMacPlatformFontList.mm
js/public/Value.h
js/src/gc/Statistics.cpp
js/src/jit/BaselineIC.h
js/src/vm/Initialization.cpp
js/src/vm/RegExpShared.h
js/src/wasm/WasmCraneliftCompile.cpp
layout/base/nsDocumentViewer.cpp
layout/generic/nsGridContainerFrame.cpp
layout/painting/FrameLayerBuilder.cpp
layout/painting/nsCSSRenderingGradients.cpp
layout/painting/nsDisplayList.h
layout/style/ServoStyleConstsInlines.h
layout/style/nsStyleStruct.cpp
layout/svg/nsSVGImageFrame.h
layout/xul/nsXULPopupManager.cpp
media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
mozglue/misc/interceptor/MMPolicies.h
mozglue/tests/gtest/TestDLLBlocklist.cpp
toolkit/components/places/FaviconHelpers.cpp
toolkit/xre/test/gtest/TestCompatVersionCompare.cpp
uriloader/base/nsDocLoader.cpp
uriloader/base/nsDocLoader.h
widget/GfxInfoBase.cpp
widget/InputData.h
xpcom/base/nsVersionComparator.cpp
xpcom/ds/nsGkAtoms.h
--- a/docshell/base/nsDocShell.h
+++ b/docshell/base/nsDocShell.h
@@ -265,19 +265,20 @@ class nsDocShell final : public nsDocLoa
 
   // We need dummy OnLocationChange in some cases to update the UI without
   // updating security info.
   void FireDummyOnLocationChange() {
     FireOnLocationChange(this, nullptr, mCurrentURI,
                          LOCATION_CHANGE_SAME_DOCUMENT);
   }
 
-  // This function is created exclusively for dom.background_loading_iframe is set.
-  // As soon as the current DocShell knows itself can be treated as background loading,
-  // it triggers the parent docshell to see if the parent document can fire load event earlier.
+  // This function is created exclusively for dom.background_loading_iframe is
+  // set. As soon as the current DocShell knows itself can be treated as
+  // background loading, it triggers the parent docshell to see if the parent
+  // document can fire load event earlier.
   void TriggerParentCheckDocShellIsEmpty() {
     RefPtr<nsDocShell> parent = GetParentDocshell();
     if (parent) {
       parent->DocLoaderIsEmpty(true);
     }
   }
 
   nsresult HistoryEntryRemoved(int32_t aIndex);
--- a/dom/base/BindContext.h
+++ b/dom/base/BindContext.h
@@ -108,17 +108,16 @@ struct MOZ_STACK_CLASS BindContext final
             ShouldCollectDisplayedNodeDataDuringLoad(mInComposedDoc, mDoc,
                                                      aParentElement)) {}
 
   bool CollectingDisplayedNodeDataDuringLoad() const {
     return mCollectingDisplayedNodeDataDuringLoad;
   }
 
  private:
-
   static bool IsLikelyUndisplayed(const nsINode& aParent) {
     return aParent.IsAnyOfHTMLElements(nsGkAtoms::style, nsGkAtoms::script);
   }
 
   static bool ShouldCollectDisplayedNodeDataDuringLoad(bool aConnected,
                                                        Document& aDoc,
                                                        nsINode& aParent) {
     return aDoc.GetReadyStateEnum() == Document::READYSTATE_LOADING &&
--- a/dom/base/DocGroup.cpp
+++ b/dom/base/DocGroup.cpp
@@ -189,24 +189,22 @@ void DocGroup::SignalSlotChange(HTMLSlot
     nsDOMMutationObserver::QueueMutationObserverMicroTask();
     sPendingDocGroups = new AutoTArray<RefPtr<DocGroup>, 2>;
   }
 
   sPendingDocGroups->AppendElement(this);
 }
 
 bool DocGroup::TryToLoadIframesInBackground() {
-  return
-    StaticPrefs::dom_separate_event_queue_for_post_message_enabled() &&
-    StaticPrefs::dom_cross_origin_iframes_loaded_in_background();
+  return StaticPrefs::dom_separate_event_queue_for_post_message_enabled() &&
+         StaticPrefs::dom_cross_origin_iframes_loaded_in_background();
 }
 
 nsresult DocGroup::QueueIframePostMessages(
-    already_AddRefed<nsIRunnable>&& aRunnable,
-    uint64_t aWindowId) {
+    already_AddRefed<nsIRunnable>&& aRunnable, uint64_t aWindowId) {
   if (DocGroup::TryToLoadIframesInBackground()) {
     if (!mIframePostMessageQueue) {
       nsCOMPtr<nsISerialEventTarget> target = GetMainThreadSerialEventTarget();
       mIframePostMessageQueue = ThrottledEventQueue::Create(
           target, "Background Loading Iframe PostMessage Queue",
           nsIRunnablePriority::PRIORITY_DEFERRED_TIMERS);
       nsresult rv = mIframePostMessageQueue->SetIsPaused(true);
       MOZ_ALWAYS_SUCCEEDS(rv);
@@ -216,28 +214,26 @@ nsresult DocGroup::QueueIframePostMessag
     // TabGroup, this postMessage queue should always be paused, because if
     // we leave it open, the postMessage may get dispatched to an unloaded
     // iframe
     MOZ_ASSERT(mIframePostMessageQueue);
     MOZ_ASSERT(mIframePostMessageQueue->IsPaused());
 
     mIframesUsedPostMessageQueue.PutEntry(aWindowId);
 
-    mIframePostMessageQueue->Dispatch(std::move(aRunnable),
-                                      NS_DISPATCH_NORMAL);
+    mIframePostMessageQueue->Dispatch(std::move(aRunnable), NS_DISPATCH_NORMAL);
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 
 void DocGroup::TryFlushIframePostMessages(uint64_t aWindowId) {
   if (DocGroup::TryToLoadIframesInBackground()) {
     mIframesUsedPostMessageQueue.RemoveEntry(aWindowId);
-    if (mIframePostMessageQueue &&
-        mIframesUsedPostMessageQueue.IsEmpty()) {
+    if (mIframePostMessageQueue && mIframesUsedPostMessageQueue.IsEmpty()) {
       MOZ_ASSERT(mIframePostMessageQueue->IsPaused());
       nsresult rv = mIframePostMessageQueue->SetIsPaused(true);
       MOZ_ALWAYS_SUCCEEDS(rv);
       FlushIframePostMessageQueue();
     }
   }
 }
 
--- a/dom/base/DocGroup.h
+++ b/dom/base/DocGroup.h
@@ -100,19 +100,18 @@ class DocGroup final {
   void MoveSignalSlotListTo(nsTArray<RefPtr<HTMLSlotElement>>& aDest);
 
   // List of DocGroups that has non-empty signal slot list.
   static AutoTArray<RefPtr<DocGroup>, 2>* sPendingDocGroups;
 
   // Returns true if any of its documents are active but not in the bfcache.
   bool IsActive() const;
 
-  nsresult QueueIframePostMessages(
-      already_AddRefed<nsIRunnable>&& aRunnable,
-      uint64_t aWindowId);
+  nsresult QueueIframePostMessages(already_AddRefed<nsIRunnable>&& aRunnable,
+                                   uint64_t aWindowId);
 
   void TryFlushIframePostMessages(uint64_t aWindowId);
 
   static bool TryToLoadIframesInBackground();
 
  private:
   DocGroup(TabGroup* aTabGroup, const nsACString& aKey);
   ~DocGroup();
--- a/dom/base/ShadowRoot.h
+++ b/dom/base/ShadowRoot.h
@@ -156,19 +156,17 @@ class ShadowRoot final : public Document
   HTMLSlotElement* GetDefaultSlot() const {
     SlotArray* list = mSlotMap.Get(NS_LITERAL_STRING(""));
     return list ? (*list)->ElementAt(0) : nullptr;
   }
 
   void PartAdded(const Element&);
   void PartRemoved(const Element&);
 
-  const nsTArray<const Element*>& Parts() const {
-    return mParts;
-  }
+  const nsTArray<const Element*>& Parts() const { return mParts; }
 
   const RawServoAuthorStyles* GetServoStyles() const {
     return mServoStyles.get();
   }
 
   RawServoAuthorStyles* GetServoStyles() { return mServoStyles.get(); }
 
   mozilla::ServoStyleRuleMap& ServoStyleRuleMap();
--- a/dom/base/nsGlobalWindowInner.h
+++ b/dom/base/nsGlobalWindowInner.h
@@ -1438,17 +1438,18 @@ class nsGlobalWindowInner final : public
   class DeprioritizedLoadRunner
       : public mozilla::Runnable,
         public mozilla::LinkedListElement<DeprioritizedLoadRunner> {
    public:
     explicit DeprioritizedLoadRunner(nsIRunnable* aInner)
         : Runnable("DeprioritizedLoadRunner"), mInner(aInner) {}
 
     NS_IMETHOD Run() override {
-      if (mInner) {;
+      if (mInner) {
+        ;
         RefPtr<nsIRunnable> inner = std::move(mInner);
         inner->Run();
       }
 
       return NS_OK;
     }
 
    private:
--- a/dom/base/nsGlobalWindowOuter.h
+++ b/dom/base/nsGlobalWindowOuter.h
@@ -536,16 +536,17 @@ class nsGlobalWindowOuter final : public
   void BlurOuter();
   mozilla::dom::BrowsingContext* GetFramesOuter();
   uint32_t Length();
   mozilla::dom::Nullable<mozilla::dom::WindowProxyHolder> GetTopOuter();
 
   nsresult GetPrompter(nsIPrompt** aPrompt) override;
 
   RefPtr<mozilla::ThrottledEventQueue> mPostMessageEventQueue;
+
  protected:
   nsPIDOMWindowOuter* GetOpenerWindowOuter();
   // Initializes the mWasOffline member variable
   void InitWasOffline();
 
  public:
   nsPIDOMWindowOuter* GetSanitizedOpener(nsPIDOMWindowOuter* aOpener);
 
--- a/dom/base/nsImageLoadingContent.cpp
+++ b/dom/base/nsImageLoadingContent.cpp
@@ -1141,17 +1141,16 @@ nsresult nsImageLoadingContent::LoadImag
   nsIContent* thisContent = AsContent();
   MOZ_ASSERT(thisContent->NodePrincipal() == aDocument->NodePrincipal(),
              "Principal mismatch?");
 #endif
 
   nsLoadFlags loadFlags =
       aLoadFlags | nsContentUtils::CORSModeToLoadImageFlags(GetCORSMode());
 
-
   RefPtr<imgRequestProxy>& req = PrepareNextRequest(aImageLoadType);
   nsCOMPtr<nsIContent> content =
       do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
 
   nsCOMPtr<nsIPrincipal> triggeringPrincipal;
   bool result = nsContentUtils::QueryTriggeringPrincipal(
       content, aTriggeringPrincipal, getter_AddRefs(triggeringPrincipal));
 
--- a/dom/base/nsNodeUtils.cpp
+++ b/dom/base/nsNodeUtils.cpp
@@ -315,18 +315,19 @@ void nsNodeUtils::LastRelease(nsINode* a
       }
     }
 #endif
 
     nsContentUtils::RemoveListenerManager(aNode);
     aNode->UnsetFlags(NODE_HAS_LISTENERMANAGER);
   }
 
-  NS_ASSERTION(!Element::FromNode(aNode) ||
-               !Element::FromNode(aNode)->GetXBLBinding(), "Node has binding on destruction");
+  NS_ASSERTION(
+      !Element::FromNode(aNode) || !Element::FromNode(aNode)->GetXBLBinding(),
+      "Node has binding on destruction");
 
   aNode->ReleaseWrapper(aNode);
 
   FragmentOrElement::RemoveBlackMarkedNode(aNode);
 }
 
 /* static */
 already_AddRefed<nsINode> nsNodeUtils::CloneNodeImpl(nsINode* aNode, bool aDeep,
--- a/dom/bindings/RemoteObjectProxy.h
+++ b/dom/bindings/RemoteObjectProxy.h
@@ -167,18 +167,17 @@ class RemoteObjectProxy : public RemoteO
   static const js::Class sClass;
 };
 
 /**
  * Returns true if aObj is a cross-process proxy object that
  * represents an object implementing the WebIDL interface for
  * aProtoID.
  */
-inline bool IsRemoteObjectProxy(JSObject* aObj,
-                                prototypes::ID aProtoID) {
+inline bool IsRemoteObjectProxy(JSObject* aObj, prototypes::ID aProtoID) {
   if (!js::IsProxy(aObj)) {
     return false;
   }
   return RemoteObjectProxyBase::IsRemoteObjectProxy(aObj, aProtoID);
 }
 
 /**
  * Returns true if aObj is a cross-process proxy object, no matter
--- a/dom/gamepad/fallback/FallbackGamepad.cpp
+++ b/dom/gamepad/fallback/FallbackGamepad.cpp
@@ -8,12 +8,13 @@
 
 namespace mozilla {
 namespace dom {
 
 void StartGamepadMonitoring() {}
 
 void StopGamepadMonitoring() {}
 
-void SetGamepadLightIndicatorColor(uint32_t, uint32_t, uint8_t, uint8_t, uint8_t) {}
+void SetGamepadLightIndicatorColor(uint32_t, uint32_t, uint8_t, uint8_t,
+                                   uint8_t) {}
 
 }  // namespace dom
 }  // namespace mozilla
--- a/dom/html/nsIFormControl.h
+++ b/dom/html/nsIFormControl.h
@@ -288,18 +288,18 @@ bool nsIFormControl::IsSingleLineTextCon
          aType == NS_FORM_INPUT_MONTH || aType == NS_FORM_INPUT_WEEK ||
          aType == NS_FORM_INPUT_DATETIME_LOCAL ||
          (!aExcludePassword && aType == NS_FORM_INPUT_PASSWORD);
 }
 
 bool nsIFormControl::IsSubmittableControl() const {
   uint32_t type = ControlType();
   return type == NS_FORM_OBJECT || type == NS_FORM_TEXTAREA ||
-         type == NS_FORM_SELECT ||
-         type & NS_FORM_BUTTON_ELEMENT || type & NS_FORM_INPUT_ELEMENT;
+         type == NS_FORM_SELECT || type & NS_FORM_BUTTON_ELEMENT ||
+         type & NS_FORM_INPUT_ELEMENT;
 }
 
 bool nsIFormControl::AllowDraggableChildren() const {
   uint32_t type = ControlType();
   return type == NS_FORM_OBJECT || type == NS_FORM_FIELDSET ||
          type == NS_FORM_OUTPUT;
 }
 
--- a/dom/ipc/BrowserChild.h
+++ b/dom/ipc/BrowserChild.h
@@ -251,19 +251,19 @@ class BrowserChild final : public nsMess
                                      nsTArray<StructuredCloneData>* aRetVal,
                                      bool aIsSync) override;
 
   virtual nsresult DoSendAsyncMessage(JSContext* aCx, const nsAString& aMessage,
                                       StructuredCloneData& aData,
                                       JS::Handle<JSObject*> aCpows,
                                       nsIPrincipal* aPrincipal) override;
 
-  bool DoUpdateZoomConstraints(
-      const uint32_t& aPresShellId, const ViewID& aViewId,
-      const Maybe<ZoomConstraints>& aConstraints);
+  bool DoUpdateZoomConstraints(const uint32_t& aPresShellId,
+                               const ViewID& aViewId,
+                               const Maybe<ZoomConstraints>& aConstraints);
 
   mozilla::ipc::IPCResult RecvLoadURL(const nsCString& aURI,
                                       const ShowInfo& aInfo);
 
   mozilla::ipc::IPCResult RecvResumeLoad(const uint64_t& aPendingSwitchID,
                                          const ShowInfo& aInfo);
 
   MOZ_CAN_RUN_SCRIPT_BOUNDARY
--- a/dom/localstorage/ActorsParent.cpp
+++ b/dom/localstorage/ActorsParent.cpp
@@ -4382,18 +4382,18 @@ nsresult Connection::GetCachedStatement(
   return NS_OK;
 }
 
 nsresult Connection::BeginWriteTransaction() {
   AssertIsOnConnectionThread();
   MOZ_ASSERT(mStorageConnection);
 
   CachedStatement stmt;
-  nsresult rv = GetCachedStatement(NS_LITERAL_CSTRING("BEGIN IMMEDIATE;"),
-                                       &stmt);
+  nsresult rv =
+      GetCachedStatement(NS_LITERAL_CSTRING("BEGIN IMMEDIATE;"), &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -9420,19 +9420,17 @@ QuotaClient::MatchFunction::OnFunctionCa
   return NS_OK;
 }
 
 /*******************************************************************************
  * AutoWriteTransaction
  ******************************************************************************/
 
 AutoWriteTransaction::AutoWriteTransaction(bool aShadowWrites)
-    : mConnection(nullptr)
-    , mShadowWrites(aShadowWrites)
-{
+    : mConnection(nullptr), mShadowWrites(aShadowWrites) {
   AssertIsOnConnectionThread();
 
   MOZ_COUNT_CTOR(mozilla::dom::AutoWriteTransaction);
 }
 
 AutoWriteTransaction::~AutoWriteTransaction() {
   AssertIsOnConnectionThread();
 
@@ -9489,34 +9487,36 @@ nsresult AutoWriteTransaction::Commit() 
     }
   }
 
   mConnection = nullptr;
 
   return NS_OK;
 }
 
-nsresult AutoWriteTransaction::LockAndAttachShadowDatabase(Connection* aConnection) {
+nsresult AutoWriteTransaction::LockAndAttachShadowDatabase(
+    Connection* aConnection) {
   AssertIsOnConnectionThread();
   MOZ_ASSERT(aConnection);
   MOZ_ASSERT(!mConnection);
   MOZ_ASSERT(mShadowDatabaseLock.isNothing());
   MOZ_ASSERT(mShadowWrites);
 
   QuotaManager* quotaManager = QuotaManager::Get();
   MOZ_ASSERT(quotaManager);
 
   nsCOMPtr<mozIStorageConnection> storageConnection =
       aConnection->StorageConnection();
   MOZ_ASSERT(storageConnection);
 
   mShadowDatabaseLock.emplace(
       aConnection->GetQuotaClient()->ShadowDatabaseMutex());
 
-  nsresult rv = AttachShadowDatabase(quotaManager->GetBasePath(), storageConnection);
+  nsresult rv =
+      AttachShadowDatabase(quotaManager->GetBasePath(), storageConnection);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult AutoWriteTransaction::DetachShadowDatabaseAndUnlock() {
--- a/dom/media/AutoplayPolicy.cpp
+++ b/dom/media/AutoplayPolicy.cpp
@@ -69,17 +69,18 @@ static uint32_t SiteAutoplayPerm(const D
   if (!aDocument) {
     return nsIPermissionManager::DENY_ACTION;
   }
   nsIPrincipal* principal = aDocument->NodePrincipal();
   nsCOMPtr<nsIPermissionManager> permMgr = services::GetPermissionManager();
   NS_ENSURE_TRUE(permMgr, nsIPermissionManager::DENY_ACTION);
 
   uint32_t perm;
-  nsresult rv = permMgr->TestExactPermissionFromPrincipal(principal, NS_LITERAL_CSTRING("autoplay-media"), &perm);
+  nsresult rv = permMgr->TestExactPermissionFromPrincipal(
+      principal, NS_LITERAL_CSTRING("autoplay-media"), &perm);
   NS_ENSURE_SUCCESS(rv, nsIPermissionManager::DENY_ACTION);
   return perm;
 }
 
 static bool IsWindowAllowedToPlay(nsPIDOMWindowInner* aWindow) {
   if (!aWindow) {
     return false;
   }
@@ -182,19 +183,20 @@ static bool IsAllowedToPlayInternal(cons
   Document* approver = ApproverDocOf(*aElement.OwnerDoc());
 
   bool isInaudible = IsMediaElementInaudible(aElement);
   bool isUsingAutoplayModel = IsAllowedToPlayByBlockingModel(aElement);
 
   uint32_t defaultBehaviour = DefaultAutoplayBehaviour();
   uint32_t sitePermission = SiteAutoplayPerm(approver);
 
-  AUTOPLAY_LOG("IsAllowedToPlayInternal, isInaudible=%d,"
-    "isUsingAutoplayModel=%d, sitePermission=%d, defaultBehaviour=%d",
-    isInaudible, isUsingAutoplayModel, sitePermission, defaultBehaviour);
+  AUTOPLAY_LOG(
+      "IsAllowedToPlayInternal, isInaudible=%d,"
+      "isUsingAutoplayModel=%d, sitePermission=%d, defaultBehaviour=%d",
+      isInaudible, isUsingAutoplayModel, sitePermission, defaultBehaviour);
 
   // For site permissions we store permissionManager values except
   // for BLOCKED_ALL, for the default pref values we store
   // nsIAutoplay values.
   if (sitePermission == nsIPermissionManager::ALLOW_ACTION) {
     return true;
   }
 
--- a/gfx/2d/DrawTargetD2D1.cpp
+++ b/gfx/2d/DrawTargetD2D1.cpp
@@ -2167,17 +2167,18 @@ already_AddRefed<ID2D1Image> DrawTargetD
     case SurfaceType::D2D1_1_IMAGE: {
       SourceSurfaceD2D1* surf = static_cast<SourceSurfaceD2D1*>(surface.get());
       image = surf->GetImage();
       AddDependencyOnSource(surf);
     } break;
     case SurfaceType::DUAL_DT: {
       // Sometimes we have a dual drawtarget but the underlying targets
       // are d2d surfaces. Let's not readback and reupload in those cases.
-      SourceSurfaceDual* dualSurface = static_cast<SourceSurfaceDual*>(surface.get());
+      SourceSurfaceDual* dualSurface =
+          static_cast<SourceSurfaceDual*>(surface.get());
       SourceSurface* first = dualSurface->GetFirstSurface();
       if (first->GetType() == SurfaceType::D2D1_1_IMAGE) {
         MOZ_ASSERT(dualSurface->SameSurfaceTypes());
         SourceSurfaceD2D1* d2dSurface = static_cast<SourceSurfaceD2D1*>(first);
         image = d2dSurface->GetImage();
         AddDependencyOnSource(d2dSurface);
         break;
       }
--- a/gfx/2d/PathCairo.cpp
+++ b/gfx/2d/PathCairo.cpp
@@ -98,23 +98,23 @@ void PathBuilderCairo::Close() {
 void PathBuilderCairo::Arc(const Point& aOrigin, float aRadius,
                            float aStartAngle, float aEndAngle,
                            bool aAntiClockwise) {
   ArcToBezier(this, aOrigin, Size(aRadius, aRadius), aStartAngle, aEndAngle,
               aAntiClockwise);
 }
 
 already_AddRefed<Path> PathBuilderCairo::Finish() {
-  return MakeAndAddRef<PathCairo>(mFillRule, mPathData, mCurrentPoint, mBeginPoint);
+  return MakeAndAddRef<PathCairo>(mFillRule, mPathData, mCurrentPoint,
+                                  mBeginPoint);
 }
 
 PathCairo::PathCairo(FillRule aFillRule,
                      std::vector<cairo_path_data_t>& aPathData,
-                     const Point& aCurrentPoint,
-                     const Point& aBeginPoint)
+                     const Point& aCurrentPoint, const Point& aBeginPoint)
     : mFillRule(aFillRule),
       mContainingContext(nullptr),
       mCurrentPoint(aCurrentPoint),
       mBeginPoint(aBeginPoint) {
   mPathData.swap(aPathData);
 }
 
 PathCairo::PathCairo(cairo_t* aContext)
--- a/gfx/2d/PathRecording.cpp
+++ b/gfx/2d/PathRecording.cpp
@@ -6,17 +6,17 @@
 
 #include "PathRecording.h"
 #include "DrawEventRecorder.h"
 #include "RecordedEventImpl.h"
 
 namespace mozilla {
 namespace gfx {
 
-#define NEXT_PARAMS(_type)                                         \
+#define NEXT_PARAMS(_type)                                        \
   const _type params = *reinterpret_cast<const _type*>(nextByte); \
   nextByte += sizeof(_type);
 
 using namespace std;
 
 bool PathOps::StreamToSink(PathSink& aPathSink) const {
   if (mPathData.empty()) {
     return true;
--- a/gfx/2d/PathRecording.h
+++ b/gfx/2d/PathRecording.h
@@ -156,23 +156,19 @@ class PathBuilderRecording final : publi
 
   /* Add an arc to the current figure */
   void Arc(const Point& aOrigin, float aRadius, float aStartAngle,
            float aEndAngle, bool aAntiClockwise) final;
 
   /* Point the current subpath is at - or where the next subpath will start
    * if there is no active subpath.
    */
-  Point CurrentPoint() const final {
-    return mPathBuilder->CurrentPoint();
-  }
+  Point CurrentPoint() const final { return mPathBuilder->CurrentPoint(); }
 
-  Point BeginPoint() const final {
-    return mPathBuilder->BeginPoint();
-  }
+  Point BeginPoint() const final { return mPathBuilder->BeginPoint(); }
 
   void SetCurrentPoint(const Point& aPoint) final {
     mPathBuilder->SetCurrentPoint(aPoint);
   }
 
   void SetBeginPoint(const Point& aPoint) final {
     mPathBuilder->SetBeginPoint(aPoint);
   }
@@ -188,18 +184,21 @@ class PathBuilderRecording final : publi
 };
 
 class PathRecording final : public Path {
  public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PathRecording, override)
 
   PathRecording(Path* aPath, PathOps&& aOps, FillRule aFillRule,
                 const Point& aCurrentPoint, const Point& aBeginPoint)
-      : mPath(aPath), mPathOps(std::move(aOps)), mFillRule(aFillRule),
-        mCurrentPoint(aCurrentPoint), mBeginPoint(aBeginPoint) {}
+      : mPath(aPath),
+        mPathOps(std::move(aOps)),
+        mFillRule(aFillRule),
+        mCurrentPoint(aCurrentPoint),
+        mBeginPoint(aBeginPoint) {}
 
   ~PathRecording();
 
   BackendType GetBackendType() const final { return BackendType::RECORDING; }
   already_AddRefed<PathBuilder> CopyToBuilder(FillRule aFillRule) const final;
   already_AddRefed<PathBuilder> TransformedCopyToBuilder(
       const Matrix& aTransform, FillRule aFillRule) const final;
   bool ContainsPoint(const Point& aPoint,
--- a/gfx/2d/PathSkia.cpp
+++ b/gfx/2d/PathSkia.cpp
@@ -77,34 +77,34 @@ void PathBuilderSkia::Close() {
 void PathBuilderSkia::Arc(const Point& aOrigin, float aRadius,
                           float aStartAngle, float aEndAngle,
                           bool aAntiClockwise) {
   ArcToBezier(this, aOrigin, Size(aRadius, aRadius), aStartAngle, aEndAngle,
               aAntiClockwise);
 }
 
 already_AddRefed<Path> PathBuilderSkia::Finish() {
-  RefPtr<Path> path = MakeAndAddRef<PathSkia>(mPath, mFillRule,
-                                              mCurrentPoint, mBeginPoint);
+  RefPtr<Path> path =
+      MakeAndAddRef<PathSkia>(mPath, mFillRule, mCurrentPoint, mBeginPoint);
   mCurrentPoint = Point(0.0, 0.0);
   mBeginPoint = Point(0.0, 0.0);
   return path.forget();
 }
 
 void PathBuilderSkia::AppendPath(const SkPath& aPath) { mPath.addPath(aPath); }
 
 already_AddRefed<PathBuilder> PathSkia::CopyToBuilder(
     FillRule aFillRule) const {
   return TransformedCopyToBuilder(Matrix(), aFillRule);
 }
 
 already_AddRefed<PathBuilder> PathSkia::TransformedCopyToBuilder(
     const Matrix& aTransform, FillRule aFillRule) const {
-  RefPtr<PathBuilderSkia> builder = MakeAndAddRef<PathBuilderSkia>(
-    aTransform, mPath, aFillRule);
+  RefPtr<PathBuilderSkia> builder =
+      MakeAndAddRef<PathBuilderSkia>(aTransform, mPath, aFillRule);
 
   builder->mCurrentPoint = aTransform.TransformPoint(mCurrentPoint);
   builder->mBeginPoint = aTransform.TransformPoint(mBeginPoint);
 
   return builder.forget();
 }
 
 static bool SkPathContainsPoint(const SkPath& aPath, const Point& aPoint,
--- a/gfx/2d/PathSkia.h
+++ b/gfx/2d/PathSkia.h
@@ -45,23 +45,21 @@ class PathBuilderSkia : public PathBuild
   SkPath mPath;
   FillRule mFillRule;
 };
 
 class PathSkia : public Path {
  public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PathSkia, override)
 
-  PathSkia(SkPath& aPath,
-           FillRule aFillRule,
-           Point aCurrentPoint = Point(),
+  PathSkia(SkPath& aPath, FillRule aFillRule, Point aCurrentPoint = Point(),
            Point aBeginPoint = Point())
-  : mFillRule(aFillRule)
-  , mCurrentPoint(aCurrentPoint)
-  , mBeginPoint(aBeginPoint) {
+      : mFillRule(aFillRule),
+        mCurrentPoint(aCurrentPoint),
+        mBeginPoint(aBeginPoint) {
     mPath.swap(aPath);
   }
 
   BackendType GetBackendType() const override { return BackendType::SKIA; }
 
   already_AddRefed<PathBuilder> CopyToBuilder(
       FillRule aFillRule) const override;
   already_AddRefed<PathBuilder> TransformedCopyToBuilder(
--- a/gfx/2d/ScaledFontDWrite.cpp
+++ b/gfx/2d/ScaledFontDWrite.cpp
@@ -301,17 +301,18 @@ bool UnscaledFontDWrite::GetFontFileData
 
   RefPtr<IDWriteFontFileLoader> loader;
   hr = file->GetLoader(getter_AddRefs(loader));
   if (FAILED(hr)) {
     return false;
   }
 
   RefPtr<IDWriteFontFileStream> stream;
-  hr = loader->CreateStreamFromKey(referenceKey, refKeySize, getter_AddRefs(stream));
+  hr = loader->CreateStreamFromKey(referenceKey, refKeySize,
+                                   getter_AddRefs(stream));
   if (FAILED(hr)) {
     return false;
   }
 
   UINT64 fileSize64;
   hr = stream->GetFileSize(&fileSize64);
   if (FAILED(hr) || fileSize64 > UINT32_MAX) {
     MOZ_ASSERT(false);
--- a/gfx/config/gfxVars.h
+++ b/gfx/config/gfxVars.h
@@ -46,17 +46,17 @@ class gfxVarReceiver;
   _(WebRenderDebugFlags, int32_t, 0)                               \
   _(ScreenDepth, int32_t, 0)                                       \
   _(GREDirectory, nsString, nsString())                            \
   _(ProfDirectory, nsString, nsString())                           \
   _(UseOMTP, bool, false)                                          \
   _(AllowD3D11KeyedMutex, bool, false)                             \
   _(SystemTextQuality, int32_t, 5 /* CLEARTYPE_QUALITY */)         \
   _(LayersWindowRecordingPath, nsCString, nsCString())             \
-  _(RemoteCanvasEnabled, bool, false)                              \
+  _(RemoteCanvasEnabled, bool, false)
 
 /* Add new entries above this line. */
 
 // Some graphics settings are computed on the UI process and must be
 // communicated to content and GPU processes. gfxVars helps facilitate
 // this. Its function is similar to StaticPrefs, except rather than hold
 // user preferences, it holds dynamically computed values.
 //
--- a/gfx/layers/apz/public/APZUpdater.h
+++ b/gfx/layers/apz/public/APZUpdater.h
@@ -57,18 +57,18 @@ class APZUpdater {
   static void CompleteSceneSwap(const wr::WrWindowId& aWindowId,
                                 const wr::WrPipelineInfo& aInfo);
   static void ProcessPendingTasks(const wr::WrWindowId& aWindowId);
 
   void ClearTree(LayersId aRootLayersId);
   void UpdateFocusState(LayersId aRootLayerTreeId,
                         WRRootId aOriginatingWrRootId,
                         const FocusTarget& aFocusTarget);
-  void UpdateHitTestingTree(Layer* aRoot,
-                            bool aIsFirstPaint, LayersId aOriginatingLayersId,
+  void UpdateHitTestingTree(Layer* aRoot, bool aIsFirstPaint,
+                            LayersId aOriginatingLayersId,
                             uint32_t aPaintSequenceNumber);
   /**
    * This should be called (in the WR-enabled case) when the compositor receives
    * a new WebRenderScrollData for a layers id. The |aScrollData| parameter is
    * the scroll data for |aOriginatingLayersId| and |aEpoch| is the
    * corresponding epoch for the transaction that transferred the scroll data.
    * This function will store the new scroll data and update the focus state and
    * hit-testing tree.
--- a/gfx/layers/apz/src/APZCTreeManager.h
+++ b/gfx/layers/apz/src/APZCTreeManager.h
@@ -180,29 +180,30 @@ class APZCTreeManager : public IAPZCTree
    * Rebuild the hit-testing tree based on the layer update that just came up.
    * Preserve nodes and APZC instances where possible, but retire those whose
    * layers are no longer in the layer tree.
    *
    * This must be called on the updater thread as it walks the layer tree.
    *
    * @param aRoot The root of the (full) layer tree
    * @param aOriginatingLayersId The layers id of the subtree that triggered
-   *                             this repaint, and to which aIsFirstPaint applies.
+   *                             this repaint, and to which aIsFirstPaint
+   * applies.
    * @param aIsFirstPaint True if the layers update that this is called in
    *                      response to included a first-paint. If this is true,
    *                      the part of the tree that is affected by the
    *                      first-paint flag is indicated by the
    *                      aFirstPaintLayersId parameter.
    * @param aPaintSequenceNumber The sequence number of the paint that triggered
    *                             this layer update. Note that every layer child
    *                             process' layer subtree has its own sequence
    *                             numbers.
    */
-  void UpdateHitTestingTree(Layer* aRoot,
-                            bool aIsFirstPaint, LayersId aOriginatingLayersId,
+  void UpdateHitTestingTree(Layer* aRoot, bool aIsFirstPaint,
+                            LayersId aOriginatingLayersId,
                             uint32_t aPaintSequenceNumber);
 
   /**
    * Same as the above UpdateHitTestingTree, except slightly modified to take
    * the scrolling data passed over PWebRenderBridge instead of the raw layer
    * tree. This version is used when WebRender is enabled because we don't have
    * shadow layers in that scenario.
    */
--- a/gfx/layers/apz/src/APZUpdater.cpp
+++ b/gfx/layers/apz/src/APZUpdater.cpp
@@ -172,24 +172,23 @@ void APZUpdater::UpdateFocusState(Layers
   }
   RunOnUpdaterThread(selector,
                      NewRunnableMethod<LayersId, LayersId, FocusTarget>(
                          "APZUpdater::UpdateFocusState", mApz,
                          &APZCTreeManager::UpdateFocusState, aRootLayerTreeId,
                          aOriginatingWrRootId.mLayersId, aFocusTarget));
 }
 
-void APZUpdater::UpdateHitTestingTree(Layer* aRoot,
-                                      bool aIsFirstPaint,
+void APZUpdater::UpdateHitTestingTree(Layer* aRoot, bool aIsFirstPaint,
                                       LayersId aOriginatingWrRootId,
                                       uint32_t aPaintSequenceNumber) {
   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
   AssertOnUpdaterThread();
-  mApz->UpdateHitTestingTree(aRoot, aIsFirstPaint,
-                             aOriginatingWrRootId, aPaintSequenceNumber);
+  mApz->UpdateHitTestingTree(aRoot, aIsFirstPaint, aOriginatingWrRootId,
+                             aPaintSequenceNumber);
 }
 
 void APZUpdater::UpdateScrollDataAndTreeState(
     WRRootId aRootLayerTreeId, WRRootId aOriginatingWrRootId,
     const wr::Epoch& aEpoch, WebRenderScrollData&& aScrollData) {
   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
   RefPtr<APZUpdater> self = this;
   // Insert an epoch requirement update into the queue, so that
--- a/gfx/layers/apz/src/AsyncPanZoomController.cpp
+++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp
@@ -2582,17 +2582,17 @@ nsEventStatus AsyncPanZoomController::On
                                      pageScrollSize.height / 2.0) *
                             zoom.yScale;
     // ... and pan displacements are in units of "page proportion count"
     // here, so the products of them and scrollUnit* are in ParentLayer pixels
     ParentLayerPoint physicalPanDisplacementPL(
         physicalPanDisplacement.x * scrollUnitWidth,
         physicalPanDisplacement.y * scrollUnitHeight);
     physicalPanDisplacement = ToScreenCoordinates(physicalPanDisplacementPL,
-        aEvent.mLocalPanStartPoint);
+                                                  aEvent.mLocalPanStartPoint);
     logicalPanDisplacement.x *= scrollUnitWidth;
     logicalPanDisplacement.y *= scrollUnitHeight;
   }
 
   MOZ_ASSERT(GetCurrentPanGestureBlock());
   AdjustDeltaForAllowedScrollDirections(
       logicalPanDisplacement,
       GetCurrentPanGestureBlock()->GetAllowedScrollDirections());
@@ -3962,18 +3962,17 @@ void AsyncPanZoomController::RequestCont
   mLastPaintRequestMetrics = request;
 
   // We're holding the APZC lock here, so redispatch this so we can get
   // the tree lock without the APZC lock.
   controller->DispatchToRepaintThread(
       NewRunnableMethod<AsyncPanZoomController*>(
           "layers::APZCTreeManager::SendSubtreeTransformsToChromeMainThread",
           GetApzcTreeManager(),
-          &APZCTreeManager::SendSubtreeTransformsToChromeMainThread,
-          this));
+          &APZCTreeManager::SendSubtreeTransformsToChromeMainThread, this));
 }
 
 bool AsyncPanZoomController::UpdateAnimation(
     const TimeStamp& aSampleTime,
     nsTArray<RefPtr<Runnable>>* aOutDeferredTasks) {
   AssertOnSamplerThread();
 
   // This function may get called multiple with the same sample time, for two
--- a/gfx/layers/apz/src/HitTestingTreeNode.cpp
+++ b/gfx/layers/apz/src/HitTestingTreeNode.cpp
@@ -1,16 +1,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "HitTestingTreeNode.h"
 
-#include "AsyncPanZoomController.h"   // for AsyncPanZoomController
-#include "LayersLogging.h"            // for Stringify
+#include "AsyncPanZoomController.h"  // for AsyncPanZoomController
+#include "LayersLogging.h"           // for Stringify
 #include "mozilla/StaticPrefs.h"
 #include "mozilla/gfx/Point.h"        // for Point4D
 #include "mozilla/layers/APZUtils.h"  // for CompleteAsyncTransform
 #include "mozilla/layers/AsyncCompositionManager.h"  // for ViewTransform::operator Matrix4x4()
 #include "mozilla/layers/AsyncDragMetrics.h"  // for AsyncDragMetrics
 #include "nsPrintfCString.h"                  // for nsPrintfCString
 #include "UnitTransforms.h"                   // for ViewAs
 
@@ -317,19 +317,19 @@ const CSSTransformMatrix& HitTestingTree
   return mTransform;
 }
 
 LayerToScreenMatrix4x4 HitTestingTreeNode::GetTransformToGecko() const {
   if (mParent) {
     LayerToParentLayerMatrix4x4 thisToParent =
         mTransform * AsyncTransformMatrix();
     if (mApzc) {
-      thisToParent = thisToParent *
-          ViewAs<ParentLayerToParentLayerMatrix4x4>(
-              mApzc->GetTransformToLastDispatchedPaint());
+      thisToParent =
+          thisToParent * ViewAs<ParentLayerToParentLayerMatrix4x4>(
+                             mApzc->GetTransformToLastDispatchedPaint());
     }
     ParentLayerToScreenMatrix4x4 parentToRoot =
         ViewAs<ParentLayerToScreenMatrix4x4>(
             mParent->GetTransformToGecko(),
             PixelCastJustification::MovingDownToChildren);
     return thisToParent * parentToRoot;
   }
 
--- a/gfx/layers/client/TextureClient.cpp
+++ b/gfx/layers/client/TextureClient.cpp
@@ -232,68 +232,64 @@ class TextureChild final : PTextureChild
   bool mIPCOpen;
   bool mOwnsTextureData;
   bool mOwnerCalledDestroy;
 
   friend class TextureClient;
   friend void DeallocateTextureClient(TextureDeallocParams params);
 };
 
-static inline gfx::BackendType
-BackendTypeForBackendSelector(LayersBackend aLayersBackend, BackendSelector aSelector)
-{
+static inline gfx::BackendType BackendTypeForBackendSelector(
+    LayersBackend aLayersBackend, BackendSelector aSelector) {
   switch (aSelector) {
     case BackendSelector::Canvas:
       return gfxPlatform::GetPlatform()->GetPreferredCanvasBackend();
     case BackendSelector::Content:
       return gfxPlatform::GetPlatform()->GetContentBackendFor(aLayersBackend);
     default:
       MOZ_ASSERT_UNREACHABLE("Unknown backend selector");
       return gfx::BackendType::NONE;
   }
 };
 
-static TextureType
-GetTextureType(gfx::SurfaceFormat aFormat, gfx::IntSize aSize,
-               LayersBackend aLayersBackend, gfx::BackendType aBackendType,
-               int32_t aMaxTextureSize, TextureAllocationFlags aAllocFlags)
-{
+static TextureType GetTextureType(gfx::SurfaceFormat aFormat,
+                                  gfx::IntSize aSize,
+                                  LayersBackend aLayersBackend,
+                                  gfx::BackendType aBackendType,
+                                  int32_t aMaxTextureSize,
+                                  TextureAllocationFlags aAllocFlags) {
 #ifdef XP_WIN
   if ((aLayersBackend == LayersBackend::LAYERS_D3D11 ||
        aLayersBackend == LayersBackend::LAYERS_WR) &&
-       (aBackendType == gfx::BackendType::DIRECT2D ||
-        aBackendType == gfx::BackendType::DIRECT2D1_1 ||
-        (!!(aAllocFlags & ALLOC_FOR_OUT_OF_BAND_CONTENT) &&
-         DeviceManagerDx::Get()->GetContentDevice())) &&
-      aSize.width <= aMaxTextureSize &&
-      aSize.height <= aMaxTextureSize &&
+      (aBackendType == gfx::BackendType::DIRECT2D ||
+       aBackendType == gfx::BackendType::DIRECT2D1_1 ||
+       (!!(aAllocFlags & ALLOC_FOR_OUT_OF_BAND_CONTENT) &&
+        DeviceManagerDx::Get()->GetContentDevice())) &&
+      aSize.width <= aMaxTextureSize && aSize.height <= aMaxTextureSize &&
       !(aAllocFlags & ALLOC_UPDATE_FROM_SURFACE)) {
     return TextureType::D3D11;
   }
 
   if (aLayersBackend != LayersBackend::LAYERS_WR &&
       aFormat == SurfaceFormat::B8G8R8X8 &&
-      aBackendType == gfx::BackendType::CAIRO &&
-      NS_IsMainThread()) {
+      aBackendType == gfx::BackendType::CAIRO && NS_IsMainThread()) {
     return TextureType::DIB;
   }
 #endif
 
 #ifdef MOZ_X11
   gfxSurfaceType type =
-    gfxPlatform::GetPlatform()->ScreenReferenceSurface()->GetType();
+      gfxPlatform::GetPlatform()->ScreenReferenceSurface()->GetType();
 
   if (aLayersBackend == LayersBackend::LAYERS_BASIC &&
-      aBackendType == gfx::BackendType::CAIRO &&
-      type == gfxSurfaceType::Xlib) {
+      aBackendType == gfx::BackendType::CAIRO && type == gfxSurfaceType::Xlib) {
     return TextureType::X11;
   }
   if (aLayersBackend == LayersBackend::LAYERS_OPENGL &&
-      type == gfxSurfaceType::Xlib &&
-      aFormat != SurfaceFormat::A8 &&
+      type == gfxSurfaceType::Xlib && aFormat != SurfaceFormat::A8 &&
       gl::sGLXLibrary.UseTextureFromPixmap()) {
     return TextureType::X11;
   }
 #endif
 
 #ifdef XP_MACOSX
   if (StaticPrefs::gfx_use_iosurface_textures()) {
     return TextureType::MacIOSurface;
@@ -304,19 +300,18 @@ GetTextureType(gfx::SurfaceFormat aForma
   if (StaticPrefs::gfx_use_surfacetexture_textures()) {
     return TextureType::AndroidNativeWindow;
   }
 #endif
 
   return TextureType::Unknown;
 }
 
-static bool
-ShouldRemoteTextureType(TextureType aTextureType, BackendSelector aSelector)
-{
+static bool ShouldRemoteTextureType(TextureType aTextureType,
+                                    BackendSelector aSelector) {
   if (!XRE_IsContentProcess()) {
     return false;
   }
 
   if (aSelector != BackendSelector::Canvas || !gfxVars::RemoteCanvasEnabled()) {
     return false;
   }
 
@@ -324,39 +319,39 @@ ShouldRemoteTextureType(TextureType aTex
     case TextureType::D3D11:
       return true;
     default:
       return false;
   }
 }
 
 /* static */
-TextureData*
-TextureData::Create(TextureForwarder* aAllocator, gfx::SurfaceFormat aFormat,
-                    gfx::IntSize aSize, LayersBackend aLayersBackend,
-                    int32_t aMaxTextureSize, BackendSelector aSelector,
-                    TextureFlags aTextureFlags,
-                    TextureAllocationFlags aAllocFlags)
-{
+TextureData* TextureData::Create(TextureForwarder* aAllocator,
+                                 gfx::SurfaceFormat aFormat, gfx::IntSize aSize,
+                                 LayersBackend aLayersBackend,
+                                 int32_t aMaxTextureSize,
+                                 BackendSelector aSelector,
+                                 TextureFlags aTextureFlags,
+                                 TextureAllocationFlags aAllocFlags) {
   gfx::BackendType moz2DBackend =
-    BackendTypeForBackendSelector(aLayersBackend, aSelector);
+      BackendTypeForBackendSelector(aLayersBackend, aSelector);
 
-  TextureType textureType = GetTextureType(aFormat, aSize, aLayersBackend,
-                                           moz2DBackend, aMaxTextureSize,
-                                           aAllocFlags);
+  TextureType textureType =
+      GetTextureType(aFormat, aSize, aLayersBackend, moz2DBackend,
+                     aMaxTextureSize, aAllocFlags);
 
   if (ShouldRemoteTextureType(textureType, aSelector)) {
     RefPtr<CanvasChild> canvasChild = aAllocator->GetCanvasChild();
     if (canvasChild) {
       return new RecordedTextureData(canvasChild.forget(), aSize, aFormat,
                                      textureType);
     }
   }
 
-  switch(textureType) {
+  switch (textureType) {
 #ifdef XP_WIN
     case TextureType::D3D11:
       return D3D11TextureData::Create(aSize, aFormat, aAllocFlags);
     case TextureType::DIB:
       return DIBTextureData::Create(aSize, aFormat, aAllocator);
 #endif
 #ifdef MOZ_X11
     case TextureType::X11:
@@ -371,26 +366,24 @@ TextureData::Create(TextureForwarder* aA
       return AndroidNativeWindowTextureData::Create(aSize, aFormat);
 #endif
     default:
       return nullptr;
   }
 }
 
 /* static */
-bool
-TextureData::IsRemote(LayersBackend aLayersBackend, BackendSelector aSelector)
-{
+bool TextureData::IsRemote(LayersBackend aLayersBackend,
+                           BackendSelector aSelector) {
   gfx::BackendType moz2DBackend =
-    BackendTypeForBackendSelector(aLayersBackend, aSelector);
+      BackendTypeForBackendSelector(aLayersBackend, aSelector);
 
-  TextureType textureType =
-    GetTextureType(gfx::SurfaceFormat::UNKNOWN, gfx::IntSize(1,1),
-                   aLayersBackend, moz2DBackend, INT32_MAX,
-                   TextureAllocationFlags::ALLOC_DEFAULT);
+  TextureType textureType = GetTextureType(
+      gfx::SurfaceFormat::UNKNOWN, gfx::IntSize(1, 1), aLayersBackend,
+      moz2DBackend, INT32_MAX, TextureAllocationFlags::ALLOC_DEFAULT);
 
   return ShouldRemoteTextureType(textureType, aSelector);
 }
 
 static void DestroyTextureData(TextureData* aTextureData,
                                LayersIPCChannel* aAllocator, bool aDeallocate,
                                bool aMainThreadOnly) {
   if (!aTextureData) {
@@ -1191,19 +1184,19 @@ already_AddRefed<TextureClient> TextureC
   if (!aAllocator || !aAllocator->IPCOpen()) {
     return nullptr;
   }
 
   if (!gfx::Factory::AllowedSurfaceSize(aSize)) {
     return nullptr;
   }
 
-  TextureData* data =
-    TextureData::Create(aAllocator, aFormat, aSize, aLayersBackend,
-                        aMaxTextureSize, aSelector, aTextureFlags, aAllocFlags);
+  TextureData* data = TextureData::Create(
+      aAllocator, aFormat, aSize, aLayersBackend, aMaxTextureSize, aSelector,
+      aTextureFlags, aAllocFlags);
 
   if (data) {
     return MakeAndAddRef<TextureClient>(data, aTextureFlags, aAllocator);
   }
 
   // Can't do any better than a buffer texture client.
   return TextureClient::CreateForRawBufferAccess(aAllocator, aFormat, aSize,
                                                  moz2DBackend, aLayersBackend,
--- a/gfx/layers/client/TextureClient.h
+++ b/gfx/layers/client/TextureClient.h
@@ -241,21 +241,19 @@ class TextureData {
           hasIntermediateBuffer(false),
           hasSynchronization(false),
           supportsMoz2D(false),
           canExposeMappedData(false),
           canConcurrentlyReadLock(true) {}
   };
 
   static TextureData* Create(TextureForwarder* aAllocator,
-                             gfx::SurfaceFormat aFormat,
-                             gfx::IntSize aSize,
+                             gfx::SurfaceFormat aFormat, gfx::IntSize aSize,
                              LayersBackend aLayersBackend,
-                             int32_t aMaxTextureSize,
-                             BackendSelector aSelector,
+                             int32_t aMaxTextureSize, BackendSelector aSelector,
                              TextureFlags aTextureFlags,
                              TextureAllocationFlags aAllocFlags);
 
   static bool IsRemote(LayersBackend aLayersBackend, BackendSelector aSelector);
 
   virtual ~TextureData() { MOZ_COUNT_DTOR(TextureData); }
 
   virtual void FillInfo(TextureData::Info& aInfo) const = 0;
@@ -309,17 +307,17 @@ class TextureData {
   virtual D3D11TextureData* AsD3D11TextureData() { return nullptr; }
   virtual DXGIYCbCrTextureData* AsDXGIYCbCrTextureData() { return nullptr; }
 #endif
 
   virtual BufferTextureData* AsBufferTextureData() { return nullptr; }
 
   virtual GPUVideoTextureData* AsGPUVideoTextureData() { return nullptr; }
 
-protected:
+ protected:
   TextureData() { MOZ_COUNT_CTOR(TextureData); }
 };
 
 /**
  * TextureClient is a thin abstraction over texture data that need to be shared
  * between the content process and the compositor process. It is the
  * content-side half of a TextureClient/TextureHost pair. A corresponding
  * TextureHost lives on the compositor-side.
--- a/gfx/layers/composite/CompositableHost.cpp
+++ b/gfx/layers/composite/CompositableHost.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "CompositableHost.h"
 #include <map>            // for _Rb_tree_iterator, map, etc
 #include <utility>        // for pair
 #include "ContentHost.h"  // for ContentHostDoubleBuffered, etc
 #include "Effects.h"      // for EffectMask, Effect, etc
 #include "gfxUtils.h"
-#include "ImageHost.h"         // for ImageHostBuffered, etc
+#include "ImageHost.h"  // for ImageHostBuffered, etc
 #include "Layers.h"
 #include "TiledContentHost.h"  // for TiledContentHost
 #include "mozilla/gfx/gfxVars.h"
 #include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor
 #include "mozilla/layers/TextureHost.h"     // for TextureHost, etc
 #include "mozilla/layers/WebRenderImageHost.h"
 #include "mozilla/RefPtr.h"   // for nsRefPtr
 #include "nsDebug.h"          // for NS_WARNING
--- a/gfx/layers/composite/TiledContentHost.cpp
+++ b/gfx/layers/composite/TiledContentHost.cpp
@@ -11,17 +11,17 @@
 #include "mozilla/gfx/Point.h"          // for IntSize
 #include "mozilla/layers/Compositor.h"  // for Compositor
 // clang-format off
 //#include "mozilla/layers/CompositorBridgeParent.h"  // for CompositorBridgeParent
 // clang-format on
 #include "mozilla/layers/Effects.h"  // for TexturedEffect, Effect, etc
 #include "mozilla/layers/LayerMetricsWrapper.h"  // for LayerMetricsWrapper
 #include "mozilla/layers/PTextureParent.h"
-#include "mozilla/layers/TextureHostOGL.h"       // for TextureHostOGL
+#include "mozilla/layers/TextureHostOGL.h"  // for TextureHostOGL
 #ifdef XP_DARWIN
 #  include "mozilla/layers/TextureSync.h"  // for TextureSync
 #endif
 #include "nsAString.h"
 #include "nsDebug.h"          // for NS_WARNING
 #include "nsPoint.h"          // for IntPoint
 #include "nsPrintfCString.h"  // for nsPrintfCString
 #include "nsRect.h"           // for IntRect
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -848,18 +848,17 @@ void CompositorBridgeParent::NotifyShado
     }
 #endif
 
     if (mApzUpdater) {
       mApzUpdater->UpdateFocusState(mRootLayerTreeID,
                                     WRRootId::NonWebRender(aId), aFocusTarget);
       if (aHitTestUpdate) {
         mApzUpdater->UpdateHitTestingTree(
-            mLayerManager->GetRoot(), aIsFirstPaint, aId,
-            aPaintSequenceNumber);
+            mLayerManager->GetRoot(), aIsFirstPaint, aId, aPaintSequenceNumber);
       }
     }
 
     mLayerManager->NotifyShadowTreeTransaction();
   }
   if (aScheduleComposite) {
     ScheduleComposition();
   }
@@ -1243,18 +1242,18 @@ void CompositorBridgeParent::ShadowLayer
   if (mApzUpdater && !aInfo.isRepeatTransaction()) {
     mApzUpdater->UpdateFocusState(mRootLayerTreeID,
                                   WRRootId::NonWebRender(mRootLayerTreeID),
                                   aInfo.focusTarget());
 
     if (aHitTestUpdate) {
       AutoResolveRefLayers resolve(mCompositionManager);
 
-      mApzUpdater->UpdateHitTestingTree(root,
-                                        aInfo.isFirstPaint(), mRootLayerTreeID,
+      mApzUpdater->UpdateHitTestingTree(root, aInfo.isFirstPaint(),
+                                        mRootLayerTreeID,
                                         aInfo.paintSequenceNumber());
     }
   }
 
   // The transaction ID might get reset to 1 if the page gets reloaded, see
   // https://bugzilla.mozilla.org/show_bug.cgi?id=1145295#c41
   // Otherwise, it should be continually increasing.
   MOZ_ASSERT(aInfo.id() == TransactionId{1} ||
--- a/gfx/layers/ipc/ImageBridgeChild.cpp
+++ b/gfx/layers/ipc/ImageBridgeChild.cpp
@@ -16,17 +16,17 @@
 #include "base/task.h"                   // for NewRunnableFunction, etc
 #include "base/thread.h"                 // for Thread
 #include "mozilla/Assertions.h"          // for MOZ_ASSERT, etc
 #include "mozilla/Monitor.h"             // for Monitor, MonitorAutoLock
 #include "mozilla/ReentrantMonitor.h"    // for ReentrantMonitor, etc
 #include "mozilla/ipc/MessageChannel.h"  // for MessageChannel, etc
 #include "mozilla/ipc/Transport.h"       // for Transport
 #include "mozilla/gfx/gfxVars.h"
-#include "mozilla/gfx/Point.h"           // for IntSize
+#include "mozilla/gfx/Point.h"  // for IntSize
 #include "mozilla/layers/AsyncCanvasRenderer.h"
 #include "mozilla/media/MediaSystemResourceManager.h"  // for MediaSystemResourceManager
 #include "mozilla/media/MediaSystemResourceManagerChild.h"  // for MediaSystemResourceManagerChild
 #include "mozilla/layers/CompositableClient.h"  // for CompositableChild, etc
 #include "mozilla/layers/CompositorThread.h"
 #include "mozilla/layers/ISurfaceAllocator.h"  // for ISurfaceAllocator
 #include "mozilla/layers/ImageClient.h"        // for ImageClient
 #include "mozilla/layers/LayersMessages.h"     // for CompositableOperation
--- a/gfx/layers/ipc/LayersMessageUtils.h
+++ b/gfx/layers/ipc/LayersMessageUtils.h
@@ -79,20 +79,19 @@ template <>
 struct ParamTraits<mozilla::layers::LayersBackend>
     : public ContiguousEnumSerializer<
           mozilla::layers::LayersBackend,
           mozilla::layers::LayersBackend::LAYERS_NONE,
           mozilla::layers::LayersBackend::LAYERS_LAST> {};
 
 template <>
 struct ParamTraits<mozilla::layers::TextureType>
-    : public ContiguousEnumSerializer<
-          mozilla::layers::TextureType,
-          mozilla::layers::TextureType::Unknown,
-          mozilla::layers::TextureType::Last> {};
+    : public ContiguousEnumSerializer<mozilla::layers::TextureType,
+                                      mozilla::layers::TextureType::Unknown,
+                                      mozilla::layers::TextureType::Last> {};
 
 template <>
 struct ParamTraits<mozilla::layers::ScaleMode>
     : public ContiguousEnumSerializerInclusive<
           mozilla::layers::ScaleMode, mozilla::layers::ScaleMode::SCALE_NONE,
           mozilla::layers::kHighestScaleMode> {};
 
 template <>
--- a/gfx/layers/opengl/TextureHostOGL.cpp
+++ b/gfx/layers/opengl/TextureHostOGL.cpp
@@ -713,18 +713,17 @@ void EGLImageTextureSource::BindTexture(
 #ifdef DEBUG
   const bool supportsEglImage = [&]() {
     const auto& gle = GLContextEGL::Cast(gl);
     const auto& egl = gle->mEgl;
 
     return egl->HasKHRImageBase() && egl->HasKHRImageTexture2D() &&
            gl->IsExtensionSupported(GLContext::OES_EGL_image);
   }();
-  MOZ_ASSERT(supportsEglImage,
-             "EGLImage not supported or disabled in runtime");
+  MOZ_ASSERT(supportsEglImage, "EGLImage not supported or disabled in runtime");
 #endif
 
   GLuint tex = mCompositor->GetTemporaryTexture(mTextureTarget, aTextureUnit);
 
   gl->fActiveTexture(aTextureUnit);
   gl->fBindTexture(mTextureTarget, tex);
 
   gl->fEGLImageTargetTexture2D(mTextureTarget, mImage);
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -1068,17 +1068,18 @@ void WebRenderScrollDataCollection::Appe
       layerScrollData.back().InitializeRoot(layerScrollData.size() - 1);
 
       if (aRootMetadata) {
         // Put the fallback root metadata on the rootmost layer that is
         // a matching async zoom container, or the root layer that we just
         // created above.
         size_t rootMetadataTarget = layerScrollData.size() - 1;
         for (size_t i = rootMetadataTarget; i > 0; i--) {
-          if (auto zoomContainerId = layerScrollData[i - 1].GetAsyncZoomContainerId()) {
+          if (auto zoomContainerId =
+                  layerScrollData[i - 1].GetAsyncZoomContainerId()) {
             if (*zoomContainerId == aRootMetadata->GetMetrics().GetScrollId()) {
               rootMetadataTarget = i - 1;
               break;
             }
           }
         }
         layerScrollData[rootMetadataTarget].AppendScrollMetadata(
             aScrollDatas[renderRoot], aRootMetadata.ref());
--- a/gfx/thebes/gfxMacPlatformFontList.mm
+++ b/gfx/thebes/gfxMacPlatformFontList.mm
@@ -1371,32 +1371,30 @@ gfxFontEntry* gfxMacPlatformFontList::Lo
   MacOSFontEntry* newFontEntry;
 
   // lookup face based on postscript or full name
   CGFontRef fontRef = ::CGFontCreateWithFontName(CFStringRef(faceName));
   if (!fontRef) {
     return nullptr;
   }
 
-  newFontEntry = new MacOSFontEntry(aFontName, fontRef, aWeightForEntry,
-                                    aStretchForEntry, aStyleForEntry, false,
-                                    true);
+  newFontEntry = new MacOSFontEntry(aFontName, fontRef, aWeightForEntry, aStretchForEntry,
+                                    aStyleForEntry, false, true);
   ::CFRelease(fontRef);
 
   return newFontEntry;
 }
 
-static void ReleaseData(void* info, const void* data, size_t size) {
-  free((void*)data);
-}
+static void ReleaseData(void* info, const void* data, size_t size) { free((void*)data); }
 
-gfxFontEntry* gfxMacPlatformFontList::MakePlatformFont(
-    const nsACString& aFontName, WeightRange aWeightForEntry,
-    StretchRange aStretchForEntry, SlantStyleRange aStyleForEntry,
-    const uint8_t* aFontData, uint32_t aLength) {
+gfxFontEntry* gfxMacPlatformFontList::MakePlatformFont(const nsACString& aFontName,
+                                                       WeightRange aWeightForEntry,
+                                                       StretchRange aStretchForEntry,
+                                                       SlantStyleRange aStyleForEntry,
+                                                       const uint8_t* aFontData, uint32_t aLength) {
   NS_ASSERTION(aFontData, "MakePlatformFont called with null data");
 
   // create the font entry
   nsAutoString uniqueName;
 
   nsresult rv = gfxFontUtils::MakeUniqueUserFontName(uniqueName);
   if (NS_FAILED(rv)) {
     return nullptr;
@@ -1407,19 +1405,18 @@ gfxFontEntry* gfxMacPlatformFontList::Ma
   CGFontRef fontRef = ::CGFontCreateWithDataProvider(provider);
   ::CGDataProviderRelease(provider);
 
   if (!fontRef) {
     return nullptr;
   }
 
   auto newFontEntry =
-      MakeUnique<MacOSFontEntry>(NS_ConvertUTF16toUTF8(uniqueName), fontRef,
-                                 aWeightForEntry, aStretchForEntry,
-                                 aStyleForEntry, true, false);
+      MakeUnique<MacOSFontEntry>(NS_ConvertUTF16toUTF8(uniqueName), fontRef, aWeightForEntry,
+                                 aStretchForEntry, aStyleForEntry, true, false);
   ::CFRelease(fontRef);
   return newFontEntry.release();
 }
 
 // Webkit code uses a system font meta name, so mimic that here
 // WebCore/platform/graphics/mac/FontCacheMac.mm
 static const char kSystemFont_system[] = "-apple-system";
 
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -278,17 +278,17 @@ static inline double CanonicalizeNaN(dou
   }
   return d;
 }
 
 #if defined(__sparc__)
 // Some architectures (not to name names) generate NaNs with bit
 // patterns that don't conform to JS::Value's bit pattern
 // restrictions.
-#define JS_NONCANONICAL_HARDWARE_NAN
+#  define JS_NONCANONICAL_HARDWARE_NAN
 #endif
 
 /**
  * [SMDOC] JS::Value type
  *
  * JS::Value is the interface for a single JavaScript Engine value.  A few
  * general notes on JS::Value:
  *
--- a/js/src/gc/Statistics.cpp
+++ b/js/src/gc/Statistics.cpp
@@ -1051,18 +1051,17 @@ void Statistics::endGC() {
   runtime->addTelemetry(JS_TELEMETRY_GC_MMU_50, mmu50 * 100);
 
   // Record scheduling telemetry for the main runtime but not for workers, which
   // are scheduled differently.
   if (!runtime->parentRuntime && timeSinceLastGC) {
     runtime->addTelemetry(JS_TELEMETRY_GC_TIME_BETWEEN_S,
                           timeSinceLastGC.ToSeconds());
     if (!nonincremental()) {
-      runtime->addTelemetry(JS_TELEMETRY_GC_SLICE_COUNT,
-                            slices_.length());
+      runtime->addTelemetry(JS_TELEMETRY_GC_SLICE_COUNT, slices_.length());
     }
   }
 
   thresholdTriggered = false;
 }
 
 void Statistics::beginNurseryCollection(JS::GCReason reason) {
   count(COUNT_MINOR_GC);
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -1672,17 +1672,16 @@ class ICCall_Fallback : public ICMonitor
  public:
   static const uint32_t MAX_OPTIMIZED_STUBS = 16;
 
  private:
   explicit ICCall_Fallback(TrampolinePtr stubCode)
       : ICMonitoredFallbackStub(ICStub::Call_Fallback, stubCode) {}
 };
 
-
 // IC for constructing an iterator from an input value.
 class ICGetIterator_Fallback : public ICFallbackStub {
   friend class ICStubSpace;
 
   explicit ICGetIterator_Fallback(TrampolinePtr stubCode)
       : ICFallbackStub(ICStub::GetIterator_Fallback, stubCode) {}
 };
 
--- a/js/src/vm/Initialization.cpp
+++ b/js/src/vm/Initialization.cpp
@@ -63,19 +63,19 @@ static void CheckMessageParameterCounts(
 #endif /* DEBUG */
 
 static void CheckCanonicalNaN() {
 #if defined(JS_NONCANONICAL_HARDWARE_NAN)
   // If the NaN generated by hardware operations is not compatible
   // with our canonical NaN, we must canonicalize every double. This
   // is implemented for C++ code in Value::bitsFromDouble, but is not
   // implemented for JIT code.
-#if !defined(JS_CODEGEN_NONE)
-#error "No JIT support for non-canonical hardware NaN"
-#endif
+#  if !defined(JS_CODEGEN_NONE)
+#    error "No JIT support for non-canonical hardware NaN"
+#  endif
 
 #else
   // Assert that the NaN generated by hardware operations is
   // compatible with the canonical NaN we use for JS::Value. This is
   // true for all of our supported platforms, but not for SPARC.
   double infinity = mozilla::PositiveInfinity<double>();
   double hardwareNaN = infinity - infinity;
   uint64_t bits = mozilla::BitwiseCast<uint64_t>(hardwareNaN);
--- a/js/src/vm/RegExpShared.h
+++ b/js/src/vm/RegExpShared.h
@@ -43,20 +43,19 @@ enum RegExpRunStatus {
   RegExpRunStatus_Error,
   RegExpRunStatus_Success,
   RegExpRunStatus_Success_NotFound
 };
 
 /*
  * Layout of the reg exp bytecode header.
  */
-struct RegExpByteCodeHeader
-{
-  uint32_t length;          // Number of instructions.
-  uint32_t numRegisters;    // Number of registers used.
+struct RegExpByteCodeHeader {
+  uint32_t length;        // Number of instructions.
+  uint32_t numRegisters;  // Number of registers used.
 };
 
 /*
  * A RegExpShared is the compiled representation of a regexp. A RegExpShared is
  * potentially pointed to by multiple RegExpObjects. Additionally, C++ code may
  * have pointers to RegExpShareds on the stack. The RegExpShareds are kept in a
  * table so that they can be reused when compiling the same regex string.
  *
--- a/js/src/wasm/WasmCraneliftCompile.cpp
+++ b/js/src/wasm/WasmCraneliftCompile.cpp
@@ -71,18 +71,18 @@ static inline SymbolicAddress ToSymbolic
   }
   MOZ_CRASH("unknown baldrdash symbolic address");
 }
 
 static void DisassembleCode(uint8_t* code, size_t codeLen) {
 #if defined(JS_CODEGEN_X64) && defined(JS_JITSPEW) && \
     defined(ENABLE_WASM_CRANELIFT)
   zydisDisassemble(code, codeLen, [](const char* text) {
-                                    JitSpew(JitSpew_Codegen, "%s", text);
-                                  });
+    JitSpew(JitSpew_Codegen, "%s", text);
+  });
 #else
   JitSpew(JitSpew_Codegen, "*** No disassembly available ***");
 #endif
 }
 
 static bool GenerateCraneliftCode(WasmMacroAssembler& masm,
                                   const CraneliftCompiledFunc& func,
                                   const FuncTypeIdDesc& funcTypeId,
@@ -436,31 +436,31 @@ bool wasm::CraneliftCompileFunctions(con
 
   if (jitSpew) {
     // The disassembler uses the jitspew for output, so re-enable now.
     EnableChannel(js::jit::JitSpew_Codegen);
 
     uint32_t totalCodeSize = masm.currentOffset();
     uint8_t* codeBuf = (uint8_t*)js_malloc(totalCodeSize);
     if (codeBuf) {
-        masm.executableCopy(codeBuf, totalCodeSize);
+      masm.executableCopy(codeBuf, totalCodeSize);
 
-        for (const FuncCompileInput& func : inputs) {
-          JitSpew(JitSpew_Codegen, "# ========================================");
-          JitSpew(JitSpew_Codegen, "# Start of wasm cranelift code for index %d",
-                  (int)func.index);
+      for (const FuncCompileInput& func : inputs) {
+        JitSpew(JitSpew_Codegen, "# ========================================");
+        JitSpew(JitSpew_Codegen, "# Start of wasm cranelift code for index %d",
+                (int)func.index);
 
-          uint32_t codeStart = code->codeRanges[func.index].begin();
-          uint32_t codeEnd = code->codeRanges[func.index].end();
-          DisassembleCode(codeBuf + codeStart, codeEnd - codeStart);
+        uint32_t codeStart = code->codeRanges[func.index].begin();
+        uint32_t codeEnd = code->codeRanges[func.index].end();
+        DisassembleCode(codeBuf + codeStart, codeEnd - codeStart);
 
-          JitSpew(JitSpew_Codegen, "# End of wasm cranelift code for index %d",
-                  (int)func.index);
-        }
-        js_free(codeBuf);
+        JitSpew(JitSpew_Codegen, "# End of wasm cranelift code for index %d",
+                (int)func.index);
+      }
+      js_free(codeBuf);
     }
   }
 
   return code->swap(masm);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -1119,37 +1119,38 @@ nsDocumentViewer::LoadComplete(nsresult 
           // us from skipping some events.
           for (int32_t i = 0; i < count; ++i) {
             nsCOMPtr<nsIDocShellTreeItem> child;
             container->GetChildAt(i, getter_AddRefs(child));
             nsCOMPtr<nsIDocShell> childIDocShell = do_QueryInterface(child);
             RefPtr<nsDocShell> docShell = nsDocShell::Cast(childIDocShell);
             if (docShell && docShell->TreatAsBackgroundLoad() &&
                 docShell->GetDocument()->GetReadyStateEnum() <
-                Document::READYSTATE_COMPLETE) {
+                    Document::READYSTATE_COMPLETE) {
               docShells.AppendElement(childIDocShell);
             }
           }
 
           // Re-iterate the stored docShells to fire artificial load events
           for (size_t i = 0; i < docShells.Length(); ++i) {
             RefPtr<nsDocShell> docShell = nsDocShell::Cast(docShells[i]);
             if (docShell && docShell->TreatAsBackgroundLoad() &&
                 docShell->GetDocument()->GetReadyStateEnum() <
-                Document::READYSTATE_COMPLETE) {
+                    Document::READYSTATE_COMPLETE) {
               nsEventStatus status = nsEventStatus_eIgnore;
               WidgetEvent event(true, eLoad);
               event.mFlags.mBubbles = false;
               event.mFlags.mCancelable = false;
 
               nsCOMPtr<nsPIDOMWindowOuter> win = docShell->GetWindow();
               nsCOMPtr<Element> element = win->GetFrameElementInternal();
 
               docShell->SetFakeOnLoadDispatched();
-              EventDispatcher::Dispatch(element, nullptr, &event, nullptr, &status);
+              EventDispatcher::Dispatch(element, nullptr, &event, nullptr,
+                                        &status);
             }
           }
         }
       }
 
       d->SetLoadEventFiring(true);
       EventDispatcher::Dispatch(window, mPresContext, &event, nullptr, &status);
       d->SetLoadEventFiring(false);
--- a/layout/generic/nsGridContainerFrame.cpp
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -830,17 +830,18 @@ struct nsGridContainerFrame::UsedTrackSi
    * sizes for an axis (if it's already true then this method is a NOP).
    */
   void ResolveTrackSizesForAxis(nsGridContainerFrame* aFrame, LogicalAxis aAxis,
                                 gfxContext& aRC);
 
   /** Helper function for the above method */
   void ResolveSubgridTrackSizesForAxis(nsGridContainerFrame* aFrame,
                                        LogicalAxis aAxis, Subgrid* aSubgrid,
-                                       gfxContext& aRC, nscoord aContentBoxSize);
+                                       gfxContext& aRC,
+                                       nscoord aContentBoxSize);
 
   // This only has valid sizes when mCanResolveLineRangeSize is true in
   // the same axis.  It may have zero tracks (a grid with only abs.pos.
   // subgrids/items may have zero tracks).
   PerLogicalAxis<nsTArray<TrackSize>> mSizes;
   // True if mSizes can be used to resolve line range sizes in an axis.
   PerLogicalAxis<bool> mCanResolveLineRangeSize;
 
@@ -3006,19 +3007,21 @@ void nsGridContainerFrame::UsedTrackSize
   if (aFrame->IsSubgrid(aAxis)) {
     CopyUsedTrackSizes(mSizes[aAxis], parent, parentSizes, aFrame, subgrid,
                        aAxis);
     mCanResolveLineRangeSize[aAxis] = true;
   } else {
     const auto& range = subgrid->mArea.LineRangeForAxis(parentAxis);
     nscoord contentBoxSize = range.ToLength(parentSizes->mSizes[parentAxis]);
     auto parentWM = aFrame->GetParent()->GetWritingMode();
-    contentBoxSize -= subgrid->mMarginBorderPadding.StartEnd(parentAxis, parentWM);
+    contentBoxSize -=
+        subgrid->mMarginBorderPadding.StartEnd(parentAxis, parentWM);
     contentBoxSize = std::max(nscoord(0), contentBoxSize);
-    ResolveSubgridTrackSizesForAxis(aFrame, aAxis, subgrid, aRC, contentBoxSize);
+    ResolveSubgridTrackSizesForAxis(aFrame, aAxis, subgrid, aRC,
+                                    contentBoxSize);
   }
 }
 
 void nsGridContainerFrame::UsedTrackSizes::ResolveSubgridTrackSizesForAxis(
     nsGridContainerFrame* aFrame, LogicalAxis aAxis, Subgrid* aSubgrid,
     gfxContext& aRC, nscoord aContentBoxSize) {
   GridReflowInput state(aFrame, aRC);
   state.mGridItems = aSubgrid->mGridItems;
@@ -3045,17 +3048,18 @@ void nsGridContainerFrame::GridReflowInp
       aAxis == eLogicalAxisInline ? aGrid.mGridColEnd : aGrid.mGridRowEnd;
   Maybe<SubgridFallbackTrackSizingFunctions> fallbackTrackSizing;
 
   bool useParentGaps = false;
   const bool isSubgriddedAxis = mFrame->IsSubgrid(aAxis);
   if (MOZ_LIKELY(!isSubgriddedAxis)) {
     tracks.Initialize(sizingFunctions, gapStyle, gridEnd, aContentBoxSize);
   } else {
-    tracks.mGridGap = nsLayoutUtils::ResolveGapToLength(gapStyle, aContentBoxSize);
+    tracks.mGridGap =
+        nsLayoutUtils::ResolveGapToLength(gapStyle, aContentBoxSize);
     tracks.mContentBoxSize = aContentBoxSize;
     const auto* subgrid = mFrame->GetProperty(Subgrid::Prop());
     tracks.mSizes.SetLength(gridEnd);
     auto* parent = mFrame->ParentGridContainerForSubgrid();
     auto parentAxis = subgrid->mIsOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
     const auto* parentSizes = parent->GetUsedTrackSizes();
     if (parentSizes && parentSizes->mCanResolveLineRangeSize[parentAxis]) {
       CopyUsedTrackSizes(tracks.mSizes, parent, parentSizes, mFrame, subgrid,
@@ -3092,17 +3096,18 @@ void nsGridContainerFrame::GridReflowInp
         aConstraint);
     // XXXmats we're losing the baseline state of subgrid descendants that
     // CollectSubgridItemsForAxis added here.  We need to propagate that
     // state into the subgrid's Reflow somehow...
     mGridItems.TruncateLength(origGridItemCount);
   }
 
   if (aContentBoxSize != NS_UNCONSTRAINEDSIZE) {
-    tracks.AlignJustifyContent(mGridStyle, mWM, aContentBoxSize, isSubgriddedAxis);
+    tracks.AlignJustifyContent(mGridStyle, mWM, aContentBoxSize,
+                               isSubgriddedAxis);
   } else if (!useParentGaps) {
     const nscoord gridGap = tracks.mGridGap;
     nscoord pos = 0;
     for (TrackSize& sz : tracks.mSizes) {
       sz.mPosition = pos;
       pos += sz.mBase + gridGap;
     }
   }
--- a/layout/painting/FrameLayerBuilder.cpp
+++ b/layout/painting/FrameLayerBuilder.cpp
@@ -3792,17 +3792,17 @@ UniquePtr<InactiveLayerData> PaintedLaye
     tempManager = new BasicLayerManager(BasicLayerManager::BLM_INACTIVE);
   }
   UniquePtr<InactiveLayerData> data = MakeUnique<InactiveLayerData>();
   data->mLayerManager = tempManager;
 
   FrameLayerBuilder* layerBuilder = new FrameLayerBuilder();
   // Ownership of layerBuilder is passed to tempManager.
   layerBuilder->Init(aState->Builder(), tempManager, this, true,
-                            &aItem->GetClip());
+                     &aItem->GetClip());
 
   tempManager->BeginTransaction();
   if (aState->LayerBuilder()->GetRetainingLayerManager()) {
     layerBuilder->DidBeginRetainedLayerTransaction(tempManager);
   }
 
   data->mProps = LayerProperties::CloneFrom(tempManager->GetRoot());
   data->mLayer = aItem->BuildLayer(aState->Builder(), tempManager,
--- a/layout/painting/nsCSSRenderingGradients.cpp
+++ b/layout/painting/nsCSSRenderingGradients.cpp
@@ -114,17 +114,16 @@ static Tuple<gfxPoint, gfxPoint> Compute
       }
 
       gfxFloat startX = h == X::Left ? 0.0 : aBoxSize.width;
       gfxFloat startY = v == Y::Top ? 0.0 : aBoxSize.height;
 
       gfxPoint start(startX, startY);
       gfxPoint end = gfxPoint(aBoxSize.width, aBoxSize.height) - start;
       return MakeTuple(start, end);
-
     }
     default:
       break;
   }
   MOZ_ASSERT_UNREACHABLE("Unknown line direction");
   return MakeTuple(gfxPoint(), gfxPoint());
 }
 
--- a/layout/painting/nsDisplayList.h
+++ b/layout/painting/nsDisplayList.h
@@ -621,19 +621,17 @@ class nsDisplayListBuilder {
   bool IsBuildingCaret() const { return mBuildCaret; }
 
   bool IsRetainingDisplayList() const { return mRetainingDisplayList; }
 
   bool IsPartialUpdate() const { return mPartialUpdate; }
   void SetPartialUpdate(bool aPartial) { mPartialUpdate = aPartial; }
 
   bool IsBuilding() const { return mIsBuilding; }
-  void SetIsBuilding(bool aIsBuilding) {
-    mIsBuilding = aIsBuilding;
-  }
+  void SetIsBuilding(bool aIsBuilding) { mIsBuilding = aIsBuilding; }
 
   bool InInvalidSubtree() const { return mInInvalidSubtree; }
 
   /**
    * Allows callers to selectively override the regular paint suppression
    * checks, so that methods like GetFrameForPoint work when painting is
    * suppressed.
    */
--- a/layout/style/ServoStyleConstsInlines.h
+++ b/layout/style/ServoStyleConstsInlines.h
@@ -247,17 +247,17 @@ inline void StyleAtom::Release() {
     AsAtom()->Release();
   }
 }
 
 inline StyleAtom::StyleAtom(already_AddRefed<nsAtom> aAtom) {
   nsAtom* atom = aAtom.take();
   if (atom->IsStatic()) {
     ptrdiff_t offset = reinterpret_cast<const uint8_t*>(atom->AsStatic()) -
-        reinterpret_cast<const uint8_t*>(&detail::gGkAtoms);
+                       reinterpret_cast<const uint8_t*>(&detail::gGkAtoms);
     _0 = (offset << 1) | 1;
   } else {
     _0 = reinterpret_cast<uintptr_t>(atom);
   }
   MOZ_ASSERT(IsStatic() == atom->IsStatic());
   MOZ_ASSERT(AsAtom() == atom);
 }
 
--- a/layout/style/nsStyleStruct.cpp
+++ b/layout/style/nsStyleStruct.cpp
@@ -1397,17 +1397,18 @@ nsChangeHint nsStylePosition::CalcDiffer
   // right now.
   // Don't try to handle changes between "auto" and non-auto efficiently;
   // that's tricky to do and will hardly ever be able to avoid a reflow.
   if (mOffset != aNewData.mOffset) {
     if (IsAutonessEqual(mOffset, aNewData.mOffset)) {
       hint |=
           nsChangeHint_RecomputePosition | nsChangeHint_UpdateParentOverflow;
     } else {
-      hint |= nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition;
+      hint |=
+          nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition;
     }
   }
   return hint;
 }
 
 uint8_t nsStylePosition::UsedAlignSelf(ComputedStyle* aParent) const {
   if (mAlignSelf != NS_STYLE_ALIGN_AUTO) {
     return mAlignSelf;
@@ -3062,17 +3063,18 @@ nsChangeHint nsStyleDisplay::CalcDiffere
   if (mOriginalDisplay != aNewData.mOriginalDisplay) {
     // Our hypothetical box position may have changed.
     //
     // Note that it doesn't matter if we look at the old or the new struct,
     // since a change on whether we need a hypothetical position would trigger
     // reflow anyway.
     if (IsAbsolutelyPositionedStyle() &&
         aOldPosition.NeedsHypotheticalPositionIfAbsPos()) {
-      hint |= nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition;
+      hint |=
+          nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition;
     } else {
       hint |= nsChangeHint_NeutralChange;
     }
   }
 
   // Note:  Our current behavior for handling changes to the
   // transition-duration, transition-delay, and transition-timing-function
   // properties is to do nothing.  In other words, the transition
--- a/layout/svg/nsSVGImageFrame.h
+++ b/layout/svg/nsSVGImageFrame.h
@@ -84,17 +84,17 @@ class nsSVGImageFrame final : public moz
       const Maybe<OnNonvisible>& aNonvisibleAction = Nothing()) override;
 
   virtual void Init(nsIContent* aContent, nsContainerFrame* aParent,
                     nsIFrame* aPrevInFlow) override;
   virtual void DestroyFrom(nsIFrame* aDestructRoot,
                            PostDestroyData& aPostDestroyData) override;
 
   bool GetIntrinsicImageDimensions(mozilla::gfx::Size& aSize,
-                                  mozilla::AspectRatio& aAspectRatio) const;
+                                   mozilla::AspectRatio& aAspectRatio) const;
 
 #ifdef DEBUG_FRAME_DUMP
   virtual nsresult GetFrameName(nsAString& aResult) const override {
     return MakeFrameName(NS_LITERAL_STRING("SVGImage"), aResult);
   }
 #endif
 
   // nsIReflowCallback
--- a/layout/xul/nsXULPopupManager.cpp
+++ b/layout/xul/nsXULPopupManager.cpp
@@ -2241,20 +2241,18 @@ bool nsXULPopupManager::HandleKeyboardEv
 // that could be selectable?
 static nsIContent* FindDefaultInsertionPoint(nsIContent* aParent) {
   if (ShadowRoot* shadow = aParent->GetShadowRoot()) {
     if (HTMLSlotElement* slot = shadow->GetDefaultSlot()) {
       return slot;
     }
   }
   bool multiple = false;  // Unused
-  return aParent
-          ->OwnerDoc()
-          ->BindingManager()
-          ->FindNestedSingleInsertionPoint(aParent, &multiple);
+  return aParent->OwnerDoc()->BindingManager()->FindNestedSingleInsertionPoint(
+      aParent, &multiple);
 }
 
 nsContainerFrame* nsXULPopupManager::ImmediateParentFrame(
     nsContainerFrame* aFrame) {
   MOZ_ASSERT(aFrame && aFrame->GetContent());
   nsIContent* insertionPoint = FindDefaultInsertionPoint(aFrame->GetContent());
 
   nsCSSFrameConstructor* fc = aFrame->PresContext()->FrameConstructor();
--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
@@ -211,19 +211,17 @@ class PeerConnectionImpl final
                               const std::string& defaultRtcpAddr,
                               uint16_t defaultRtcpPort,
                               const std::string& transportId);
 
   static void ListenThread(void* aData);
   static void ConnectThread(void* aData);
 
   // Get the main thread
-  nsCOMPtr<nsIThread> GetMainThread() {
-    return mThread;
-  }
+  nsCOMPtr<nsIThread> GetMainThread() { return mThread; }
 
   // Get the STS thread
   nsIEventTarget* GetSTSThread() {
     PC_AUTO_ENTER_API_CALL_NO_CHECK();
     return mSTSThread;
   }
 
   nsPIDOMWindowInner* GetWindow() const {
--- a/mozglue/misc/interceptor/MMPolicies.h
+++ b/mozglue/misc/interceptor/MMPolicies.h
@@ -16,47 +16,47 @@
 #include "mozilla/Types.h"
 #include "mozilla/WindowsMapRemoteView.h"
 
 #include <windows.h>
 
 // MinGW does not have these definitions yet
 #if defined(__MINGW32__)
 typedef struct _MEM_ADDRESS_REQUIREMENTS {
-    PVOID LowestStartingAddress;
-    PVOID HighestEndingAddress;
-    SIZE_T Alignment;
+  PVOID LowestStartingAddress;
+  PVOID HighestEndingAddress;
+  SIZE_T Alignment;
 } MEM_ADDRESS_REQUIREMENTS, *PMEM_ADDRESS_REQUIREMENTS;
 
 typedef enum MEM_EXTENDED_PARAMETER_TYPE {
-    MemExtendedParameterInvalidType = 0,
-    MemExtendedParameterAddressRequirements,
-    MemExtendedParameterNumaNode,
-    MemExtendedParameterPartitionHandle,
-    MemExtendedParameterUserPhysicalHandle,
-    MemExtendedParameterAttributeFlags,
-    MemExtendedParameterMax
-} MEM_EXTENDED_PARAMETER_TYPE, *PMEM_EXTENDED_PARAMETER_TYPE;
+  MemExtendedParameterInvalidType = 0,
+  MemExtendedParameterAddressRequirements,
+  MemExtendedParameterNumaNode,
+  MemExtendedParameterPartitionHandle,
+  MemExtendedParameterUserPhysicalHandle,
+  MemExtendedParameterAttributeFlags,
+  MemExtendedParameterMax
+} MEM_EXTENDED_PARAMETER_TYPE,
+    *PMEM_EXTENDED_PARAMETER_TYPE;
 
-#define MEM_EXTENDED_PARAMETER_TYPE_BITS    8
+#  define MEM_EXTENDED_PARAMETER_TYPE_BITS 8
 
 typedef struct DECLSPEC_ALIGN(8) MEM_EXTENDED_PARAMETER {
-
-    struct {
-        DWORD64 Type : MEM_EXTENDED_PARAMETER_TYPE_BITS;
-        DWORD64 Reserved : 64 - MEM_EXTENDED_PARAMETER_TYPE_BITS;
-    } DUMMYSTRUCTNAME;
+  struct {
+    DWORD64 Type : MEM_EXTENDED_PARAMETER_TYPE_BITS;
+    DWORD64 Reserved : 64 - MEM_EXTENDED_PARAMETER_TYPE_BITS;
+  } DUMMYSTRUCTNAME;
 
-    union {
-        DWORD64 ULong64;
-        PVOID Pointer;
-        SIZE_T Size;
-        HANDLE Handle;
-        DWORD ULong;
-    } DUMMYUNIONNAME;
+  union {
+    DWORD64 ULong64;
+    PVOID Pointer;
+    SIZE_T Size;
+    HANDLE Handle;
+    DWORD ULong;
+  } DUMMYUNIONNAME;
 
 } MEM_EXTENDED_PARAMETER, *PMEM_EXTENDED_PARAMETER;
 #endif  // defined(__MINGW32__)
 
 #if (NTDDI_VERSION < NTDDI_WIN10_RS4) || defined(__MINGW32__)
 PVOID WINAPI VirtualAlloc2(HANDLE Process, PVOID BaseAddress, SIZE_T Size,
                            ULONG AllocationType, ULONG PageProtection,
                            MEM_EXTENDED_PARAMETER* ExtendedParameters,
--- a/mozglue/tests/gtest/TestDLLBlocklist.cpp
+++ b/mozglue/tests/gtest/TestDLLBlocklist.cpp
@@ -30,53 +30,57 @@ static nsString GetFullPath(const nsAStr
   bool exists;
   EXPECT_TRUE(NS_SUCCEEDED(f->Exists(&exists)) && exists);
 
   nsString ret;
   EXPECT_TRUE(NS_SUCCEEDED(f->GetPath(ret)));
   return ret;
 }
 
-TEST(TestDllBlocklist, BlockDllByName) {
+TEST(TestDllBlocklist, BlockDllByName)
+{
   // The DLL name has capital letters, so this also tests that the comparison
   // is case-insensitive.
   NS_NAMED_LITERAL_STRING(kLeafName, "TestDllBlocklist_MatchByName.dll");
   nsString dllPath = GetFullPath(kLeafName);
 
   nsModuleHandle hDll(::LoadLibraryW(dllPath.get()));
 
   EXPECT_TRUE(!hDll);
   EXPECT_TRUE(!::GetModuleHandleW(kLeafName.get()));
 }
 
-TEST(TestDllBlocklist, BlockDllByVersion) {
+TEST(TestDllBlocklist, BlockDllByVersion)
+{
   NS_NAMED_LITERAL_STRING(kLeafName, "TestDllBlocklist_MatchByVersion.dll");
   nsString dllPath = GetFullPath(kLeafName);
 
   nsModuleHandle hDll(::LoadLibraryW(dllPath.get()));
 
   EXPECT_TRUE(!hDll);
   EXPECT_TRUE(!::GetModuleHandleW(kLeafName.get()));
 }
 
-TEST(TestDllBlocklist, AllowDllByVersion) {
+TEST(TestDllBlocklist, AllowDllByVersion)
+{
   NS_NAMED_LITERAL_STRING(kLeafName, "TestDllBlocklist_AllowByVersion.dll");
   nsString dllPath = GetFullPath(kLeafName);
 
   nsModuleHandle hDll(::LoadLibraryW(dllPath.get()));
 
   EXPECT_TRUE(!!hDll);
   EXPECT_TRUE(!!::GetModuleHandleW(kLeafName.get()));
 }
 
 #define DLL_BLOCKLIST_ENTRY(name, ...) {name, __VA_ARGS__},
 #define DLL_BLOCKLIST_STRING_TYPE const char*
 #include "mozilla/WindowsDllBlocklistDefs.h"
 
-TEST(TestDllBlocklist, BlocklistIntegrity) {
+TEST(TestDllBlocklist, BlocklistIntegrity)
+{
   nsTArray<DLL_BLOCKLIST_STRING_TYPE> dupes;
   DECLARE_POINTER_TO_FIRST_DLL_BLOCKLIST_ENTRY(pFirst);
   DECLARE_POINTER_TO_LAST_DLL_BLOCKLIST_ENTRY(pLast);
 
   EXPECT_FALSE(pLast->name || pLast->maxVersion || pLast->flags);
 
   for (size_t i = 0; i < mozilla::ArrayLength(gWindowsDllBlocklist) - 1; ++i) {
     auto pEntry = pFirst + i;
@@ -94,17 +98,18 @@ TEST(TestDllBlocklist, BlocklistIntegrit
     for (auto&& dupe : dupes) {
       EXPECT_NE(stricmp(dupe, pEntry->name), 0);
     }
 
     dupes.AppendElement(pEntry->name);
   }
 }
 
-TEST(TestDllBlocklist, BlockThreadWithLoadLibraryEntryPoint) {
+TEST(TestDllBlocklist, BlockThreadWithLoadLibraryEntryPoint)
+{
   // Only supported on Nightly
 #if defined(NIGHTLY_BUILD)
   using ThreadProc = unsigned(__stdcall*)(void*);
 
   NS_NAMED_LITERAL_STRING(kLeafNameW, "TestDllBlocklist_MatchByVersion.dll");
 
   nsString fullPathW = GetFullPath(kLeafNameW);
   EXPECT_FALSE(fullPathW.IsEmpty());
@@ -128,9 +133,8 @@ TEST(TestDllBlocklist, BlockThreadWithLo
                      (void*)fullPathA.get(), 0, nullptr)));
 
   EXPECT_TRUE(!!threadA);
   EXPECT_EQ(::WaitForSingleObject(threadA, INFINITE), WAIT_OBJECT_0);
   EXPECT_TRUE(::GetExitCodeThread(threadA, &exitCode) && !exitCode);
   EXPECT_TRUE(!::GetModuleHandleW(kLeafNameW.get()));
 #endif  // defined(NIGHTLY_BUILD)
 }
-
--- a/toolkit/components/places/FaviconHelpers.cpp
+++ b/toolkit/components/places/FaviconHelpers.cpp
@@ -843,17 +843,18 @@ AsyncAssociateIconToPage::Run() {
   if (mPage.id > 0) {
     nsCOMPtr<mozIStorageStatement> stmt;
     stmt = DB->GetStatement(
         "DELETE FROM moz_icons_to_pages "
         "WHERE icon_id IN ( "
         "  SELECT icon_id FROM moz_icons_to_pages "
         "  JOIN moz_icons i ON icon_id = i.id "
         "  WHERE page_id = :page_id "
-        "  AND expire_ms < strftime('%s','now','localtime','start of day','-7 days','utc') * 1000 "
+        "  AND expire_ms < strftime('%s','now','localtime','start of day','-7 "
+        "days','utc') * 1000 "
         ") AND page_id = :page_id ");
     NS_ENSURE_STATE(stmt);
     mozStorageStatementScoper scoper(stmt);
     rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), mPage.id);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = stmt->Execute();
     NS_ENSURE_SUCCESS(rv, rv);
   }
--- a/toolkit/xre/test/gtest/TestCompatVersionCompare.cpp
+++ b/toolkit/xre/test/gtest/TestCompatVersionCompare.cpp
@@ -5,37 +5,41 @@
 
 #include "gtest/gtest.h"
 #include "nsAppRunner.h"
 #include "nsString.h"
 
 void CheckCompatVersionCompare(const nsCString& aOldCompatVersion,
                                const nsCString& aNewCompatVersion,
                                bool aExpectedSame, bool aExpectedDowngrade) {
-  printf("Comparing '%s' to '%s'.\n", aOldCompatVersion.get(), aNewCompatVersion.get());
+  printf("Comparing '%s' to '%s'.\n", aOldCompatVersion.get(),
+         aNewCompatVersion.get());
 
   int32_t result = CompareCompatVersions(aOldCompatVersion, aNewCompatVersion);
 
-  ASSERT_EQ(aExpectedSame, result == 0) << "Version sameness check should match.";
-  ASSERT_EQ(aExpectedDowngrade, result > 0) << "Version downgrade check should match.";
+  ASSERT_EQ(aExpectedSame, result == 0)
+      << "Version sameness check should match.";
+  ASSERT_EQ(aExpectedDowngrade, result > 0)
+      << "Version downgrade check should match.";
 }
 
-void CheckExpectedResult(
-  const char* aOldAppVersion, const char* aOldAppID, const char* aOldToolkitID,
-  const char* aNewAppVersion, const char* aNewAppID, const char* aNewToolkitID,
-  bool aExpectedSame, bool aExpectedDowngrade) {
-
+void CheckExpectedResult(const char* aOldAppVersion, const char* aOldAppID,
+                         const char* aOldToolkitID, const char* aNewAppVersion,
+                         const char* aNewAppID, const char* aNewToolkitID,
+                         bool aExpectedSame, bool aExpectedDowngrade) {
   nsCString oldCompatVersion;
-  BuildCompatVersion(aOldAppVersion, aOldAppID, aOldToolkitID, oldCompatVersion);
+  BuildCompatVersion(aOldAppVersion, aOldAppID, aOldToolkitID,
+                     oldCompatVersion);
 
   nsCString newCompatVersion;
-  BuildCompatVersion(aNewAppVersion, aNewAppID, aNewToolkitID, newCompatVersion);
+  BuildCompatVersion(aNewAppVersion, aNewAppID, aNewToolkitID,
+                     newCompatVersion);
 
-  CheckCompatVersionCompare(oldCompatVersion, newCompatVersion,
-                            aExpectedSame, aExpectedDowngrade);
+  CheckCompatVersionCompare(oldCompatVersion, newCompatVersion, aExpectedSame,
+                            aExpectedDowngrade);
 }
 
 // clang-format off
 TEST(CompatVersionCompare, CompareVersionChange) {
   // Identical
   CheckExpectedResult(
     "67.0",   "20000000000000", "20000000000000",
     "67.0",   "20000000000000", "20000000000000",
--- a/uriloader/base/nsDocLoader.cpp
+++ b/uriloader/base/nsDocLoader.cpp
@@ -255,23 +255,19 @@ nsDocLoader::Stop(void) {
   // we wouldn't need the call here....
 
   NS_ASSERTION(!IsBusy(), "Shouldn't be busy here");
   DocLoaderIsEmpty(false);
 
   return rv;
 }
 
-bool nsDocLoader::TreatAsBackgroundLoad() {
-   return mTreatAsBackgroundLoad;
-}
+bool nsDocLoader::TreatAsBackgroundLoad() { return mTreatAsBackgroundLoad; }
 
-void nsDocLoader::SetBackgroundLoadIframe() {
-   mTreatAsBackgroundLoad = true;
-}
+void nsDocLoader::SetBackgroundLoadIframe() { mTreatAsBackgroundLoad = true; }
 
 bool nsDocLoader::IsBusy() {
   nsresult rv;
 
   //
   // A document loader is busy if either:
   //
   //   1. One of its children is in the middle of an onload handler.  Note that
@@ -301,17 +297,17 @@ bool nsDocLoader::IsBusy() {
 
   /* check its child document loaders... */
   uint32_t count = mChildList.Length();
   for (uint32_t i = 0; i < count; i++) {
     nsIDocumentLoader* loader = ChildAt(i);
 
     // If 'dom.cross_origin_iframes_loaded_in_background' is set, the parent
     // document treats cross domain iframes as background loading frame
-    if (loader && static_cast<nsDocLoader *>(loader)->TreatAsBackgroundLoad()) {
+    if (loader && static_cast<nsDocLoader*>(loader)->TreatAsBackgroundLoad()) {
       continue;
     }
     // This is a safe cast, because we only put nsDocLoader objects into the
     // array
     if (loader && static_cast<nsDocLoader*>(loader)->IsBusy()) return true;
   }
 
   return false;
@@ -756,33 +752,33 @@ void nsDocLoader::DocLoaderIsEmpty(bool 
                                        /* updateTimingInformation = */ false);
 
             nsCOMPtr<nsPIDOMWindowOuter> window = doc->GetWindow();
             if (window && !doc->SkipLoadEventAfterClose()) {
               if (!mozilla::dom::DocGroup::TryToLoadIframesInBackground() ||
                   (mozilla::dom::DocGroup::TryToLoadIframesInBackground() &&
                    !HasFakeOnLoadDispatched())) {
                 MOZ_LOG(gDocLoaderLog, LogLevel::Debug,
-                    ("DocLoader:%p: Firing load event for document.open\n",
-                     this));
+                        ("DocLoader:%p: Firing load event for document.open\n",
+                         this));
 
                 // This is a very cut-down version of
                 // nsDocumentViewer::LoadComplete that doesn't do various things
                 // that are not relevant here because this wasn't an actual
                 // navigation.
                 WidgetEvent event(true, eLoad);
                 event.mFlags.mBubbles = false;
                 event.mFlags.mCancelable = false;
                 // Dispatching to |window|, but using |document| as the target,
                 // per spec.
                 event.mTarget = doc;
                 nsEventStatus unused = nsEventStatus_eIgnore;
                 doc->SetLoadEventFiring(true);
                 EventDispatcher::Dispatch(window, nullptr, &event, nullptr,
-                    &unused);
+                                          &unused);
                 doc->SetLoadEventFiring(false);
 
                 // Now unsuppress painting on the presshell, if we
                 // haven't done that yet.
                 RefPtr<PresShell> presShell = doc->GetPresShell();
                 if (presShell && !presShell->IsDestroying()) {
                   presShell->UnsuppressPainting();
 
--- a/uriloader/base/nsDocLoader.h
+++ b/uriloader/base/nsDocLoader.h
@@ -120,19 +120,19 @@ class nsDocLoader : public nsIDocumentLo
    * nsIWebProgressListeners.idl.
    */
   void OnContentBlockingEvent(nsISupports* aContext, uint32_t aEvent);
 
   void SetDocumentOpenedButNotLoaded() { mDocumentOpenedButNotLoaded = true; }
 
   bool TreatAsBackgroundLoad();
 
-  void SetFakeOnLoadDispatched(){ mHasFakeOnLoadDispatched = true; };
+  void SetFakeOnLoadDispatched() { mHasFakeOnLoadDispatched = true; };
 
-  bool HasFakeOnLoadDispatched(){ return mHasFakeOnLoadDispatched; };
+  bool HasFakeOnLoadDispatched() { return mHasFakeOnLoadDispatched; };
 
   void ResetToFirstLoad() {
     mHasFakeOnLoadDispatched = false;
     mIsReadyToHandlePostMessage = false;
     mTreatAsBackgroundLoad = false;
   };
 
  protected:
@@ -218,16 +218,17 @@ class nsDocLoader : public nsIDocumentLo
   }
 
   // DocLoaderIsEmpty should be called whenever the docloader may be empty.
   // This method is idempotent and does nothing if the docloader is not in
   // fact empty.  This method _does_ make sure that layout is flushed if our
   // loadgroup has no active requests before checking for "real" emptiness if
   // aFlushLayout is true.
   void DocLoaderIsEmpty(bool aFlushLayout);
+
  protected:
   struct nsStatusInfo : public mozilla::LinkedListElement<nsStatusInfo> {
     nsString mStatusMessage;
     nsresult mStatusCode;
     // Weak mRequest is ok; we'll be told if it decides to go away.
     nsIRequest* const mRequest;
 
     explicit nsStatusInfo(nsIRequest* aRequest)
--- a/widget/GfxInfoBase.cpp
+++ b/widget/GfxInfoBase.cpp
@@ -1082,17 +1082,18 @@ NS_IMETHODIMP GfxInfoBase::GetFailures(n
   if (!logForwarder) {
     return NS_ERROR_UNEXPECTED;
   }
 
   // There are two string copies in this method, starting with this one. We are
   // assuming this is not a big deal, as the size of the array should be small
   // and the strings in it should be small as well (the error messages in the
   // code.)  The second copy happens with the AppendElement() calls.
-  // Technically, we don't need the mutex lock after the StringVectorCopy() call.
+  // Technically, we don't need the mutex lock after the StringVectorCopy()
+  // call.
   LoggingRecord loggedStrings = logForwarder->LoggingRecordCopy();
   LoggingRecord::const_iterator it;
   for (it = loggedStrings.begin(); it != loggedStrings.end(); ++it) {
     failures.AppendElement(
         nsDependentCSubstring(Get<1>(*it).c_str(), Get<1>(*it).size()));
     indices.AppendElement(Get<0>(*it));
   }
 
--- a/widget/InputData.h
+++ b/widget/InputData.h
@@ -376,46 +376,53 @@ class PanGestureInput : public InputData
   int32_t mLineOrPageDeltaY;
 
   // User-set delta multipliers.
   double mUserDeltaMultiplierX;
   double mUserDeltaMultiplierY;
 
   PanDeltaType mDeltaType = PANDELTA_PIXEL;
 
-  bool mHandledByAPZ: 1;
+  bool mHandledByAPZ : 1;
 
   // true if this is a PANGESTURE_END event that will be followed by a
   // PANGESTURE_MOMENTUMSTART event.
-  bool mFollowedByMomentum: 1;
+  bool mFollowedByMomentum : 1;
 
   // If this is true, and this event started a new input block that couldn't
   // find a scrollable target which is scrollable in the horizontal component
   // of the scroll start direction, then this input block needs to be put on
   // hold until a content response has arrived, even if the block has a
   // confirmed target.
   // This is used by events that can result in a swipe instead of a scroll.
-  bool mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection: 1;
+  bool mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection : 1;
 
   // This is used by APZ to communicate to the macOS widget code whether
   // the overscroll-behavior of the scroll frame handling this swipe allows
   // non-local overscroll behaviors in the horizontal direction (such as
   // swipe navigation).
-  bool mOverscrollBehaviorAllowsSwipe: 1;
+  bool mOverscrollBehaviorAllowsSwipe : 1;
 
   // true if APZ should do a fling animation after this pan ends, like
-  // it would with touchscreens. (For platforms that don't emit momentum events.)
-  bool mSimulateMomentum: 1;
+  // it would with touchscreens. (For platforms that don't emit momentum
+  // events.)
+  bool mSimulateMomentum : 1;
 
   void SetHandledByAPZ(bool aHandled) { mHandledByAPZ = aHandled; }
-  void SetFollowedByMomentum(bool aFollowed) { mFollowedByMomentum = aFollowed; }
-  void SetRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(bool aRequires) {
-    mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection = aRequires;
+  void SetFollowedByMomentum(bool aFollowed) {
+    mFollowedByMomentum = aFollowed;
   }
-  void SetOverscrollBehaviorAllowsSwipe(bool aAllows) { mOverscrollBehaviorAllowsSwipe = aAllows; }
+  void SetRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(
+      bool aRequires) {
+    mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection =
+        aRequires;
+  }
+  void SetOverscrollBehaviorAllowsSwipe(bool aAllows) {
+    mOverscrollBehaviorAllowsSwipe = aAllows;
+  }
   void SetSimulateMomentum(bool aSimulate) { mSimulateMomentum = aSimulate; }
 };
 
 /**
  * Encapsulation class for pinch events. In general, these will be generated by
  * a gesture listener by looking at SingleTouchData/MultiTouchInput instances
  * and determining whether or not the user was trying to do a gesture.
  */
--- a/xpcom/base/nsVersionComparator.cpp
+++ b/xpcom/base/nsVersionComparator.cpp
@@ -191,17 +191,18 @@ static wchar_t* ParseVP(wchar_t* aPart, 
       aResult.strB = kPre;
       aResult.strBlen = sizeof(kPre) - 1;
     } else {
       const wchar_t* numstart = wcspbrk(aResult.strB, L"0123456789+-");
       if (!numstart) {
         aResult.strBlen = wcslen(aResult.strB);
       } else {
         aResult.strBlen = numstart - aResult.strB;
-        aResult.numC = ns_wcstol(numstart, const_cast<wchar_t**>(&aResult.extraD));
+        aResult.numC =
+            ns_wcstol(numstart, const_cast<wchar_t**>(&aResult.extraD));
 
         if (!*aResult.extraD) {
           aResult.extraD = nullptr;
         }
       }
     }
   }
 
--- a/xpcom/ds/nsGkAtoms.h
+++ b/xpcom/ds/nsGkAtoms.h
@@ -175,13 +175,11 @@ class nsGkAtoms {
 #define GK_ATOM(name_, value_, hash_, is_ascii_lower_, type_, atom_type_) \
   static constexpr nsStaticAtom* name_ = const_cast<nsStaticAtom*>(       \
       &mozilla::detail::gGkAtoms.mAtoms[static_cast<size_t>(              \
           mozilla::detail::GkAtoms::Atoms::name_)]);
 #include "nsGkAtomList.h"
 #undef GK_ATOM
 };
 
-inline bool nsAtom::IsEmpty() const {
-  return this == nsGkAtoms::_empty;
-}
+inline bool nsAtom::IsEmpty() const { return this == nsGkAtoms::_empty; }
 
 #endif /* nsGkAtoms_h___ */