Bug 1521000 - Part 1: Reformat the tree to ensure everything is formatted correctly with clang-format r=sylvestre
authorEhsan Akhgari <ehsan@mozilla.com>
Fri, 18 Jan 2019 10:12:56 +0100
changeset 454519 9916e7d6e32720362fd18ed03f1acff4884b86df
parent 454518 326b73629e37a82d5a0778fcc232776d40667b66
child 454520 5f4630838d46dd81dadb13220a4af0da9e23a619
push id35400
push usercsabou@mozilla.com
push dateSat, 19 Jan 2019 09:59:33 +0000
treeherdermozilla-central@f90bab5af97e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssylvestre
bugs1521000
milestone66.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 1521000 - Part 1: Reformat the tree to ensure everything is formatted correctly with clang-format r=sylvestre Summary: # ignore-this-changeset Reviewers: sylvestre Reviewed By: sylvestre Subscribers: reviewbot, emilio, jandem, bbouvier, karlt, jya Bug #: 1521000 Differential Revision: https://phabricator.services.mozilla.com/D16936
accessible/base/nsCoreUtils.cpp
docshell/base/nsDocShell.cpp
dom/events/EventStateManager.cpp
dom/ipc/PreallocatedProcessManager.cpp
dom/media/AutoplayPolicy.cpp
dom/media/webaudio/AudioContext.cpp
dom/xul/XULTreeElement.h
gfx/layers/ipc/LayerTransactionParent.cpp
gfx/layers/wr/WebRenderCommandBuilder.cpp
gfx/src/FilterSupport.h
gfx/vr/ipc/VRGPUChild.cpp
gfx/vr/ipc/VRGPUParent.cpp
gfx/vr/ipc/VRGPUParent.h
gfx/webrender_bindings/WebRenderAPI.cpp
js/ipc/WrapperOwner.cpp
js/src/gc/GC.cpp
js/src/gc/GCLock.h
js/src/gc/Zone.h
js/src/vm/Realm.h
js/src/wasm/WasmInstance.cpp
js/src/wasm/WasmSignalHandlers.cpp
layout/generic/nsFrameSetFrame.cpp
layout/painting/nsDisplayList.cpp
layout/style/nsStyleCoord.h
layout/xul/nsImageBoxFrame.cpp
modules/libpref/Preferences.cpp
netwerk/build/nsNetModule.cpp
netwerk/ipc/SocketProcessChild.cpp
security/manager/pki/nsASN1Tree.h
security/manager/ssl/nsCertTree.h
toolkit/components/reputationservice/ApplicationReputation.cpp
toolkit/components/sessionstore/SessionStoreUtils.cpp
toolkit/components/sessionstore/SessionStoreUtils.h
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
toolkit/recordreplay/ipc/Channel.cpp
toolkit/recordreplay/ipc/Channel.h
toolkit/recordreplay/ipc/ChildIPC.cpp
toolkit/recordreplay/ipc/ChildInternal.h
toolkit/recordreplay/ipc/ChildProcess.cpp
toolkit/recordreplay/ipc/JSControl.cpp
toolkit/recordreplay/ipc/ParentIPC.cpp
toolkit/recordreplay/ipc/ParentInternal.h
toolkit/xre/LauncherRegistryInfo.cpp
toolkit/xre/LauncherRegistryInfo.h
toolkit/xre/test/win/TestLauncherRegistryInfo.cpp
widget/gtk/nsWindow.cpp
xpcom/build/XPCOMInit.cpp
xpcom/components/Module.h
--- a/accessible/base/nsCoreUtils.cpp
+++ b/accessible/base/nsCoreUtils.cpp
@@ -58,18 +58,18 @@ bool nsCoreUtils::HasClickListener(nsICo
       aContent->GetExistingListenerManager();
 
   return listenerManager &&
          (listenerManager->HasListenersFor(nsGkAtoms::onclick) ||
           listenerManager->HasListenersFor(nsGkAtoms::onmousedown) ||
           listenerManager->HasListenersFor(nsGkAtoms::onmouseup));
 }
 
-void nsCoreUtils::DispatchClickEvent(XULTreeElement *aTree,
-                                     int32_t aRowIndex, nsTreeColumn *aColumn,
+void nsCoreUtils::DispatchClickEvent(XULTreeElement *aTree, int32_t aRowIndex,
+                                     nsTreeColumn *aColumn,
                                      const nsAString &aPseudoElt) {
   RefPtr<dom::Element> tcElm = aTree->GetTreeBody();
   if (!tcElm) return;
 
   Document *document = tcElm->GetUncomposedDoc();
   if (!document) return;
 
   nsCOMPtr<nsIPresShell> presShell = document->GetShell();
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -1057,19 +1057,18 @@ nsDOMNavigationTiming* nsDocShell::GetNa
     innerOriginURI = NS_GetInnermostURI(originURI);
   }
 
   rv = targetDocument->NodePrincipal()->GetURI(getter_AddRefs(targetURI));
   if (NS_SUCCEEDED(rv) && targetURI) {
     innerTargetURI = NS_GetInnermostURI(targetURI);
   }
 
-  return innerOriginURI && innerTargetURI &&
-    SchemeIsFile(innerOriginURI) &&
-    SchemeIsFile(innerTargetURI);
+  return innerOriginURI && innerTargetURI && SchemeIsFile(innerOriginURI) &&
+         SchemeIsFile(innerTargetURI);
 }
 
 nsPresContext* nsDocShell::GetEldestPresContext() {
   nsIContentViewer* viewer = mContentViewer;
   while (viewer) {
     nsIContentViewer* prevViewer = viewer->GetPreviousViewer();
     if (!prevViewer) {
       return viewer->GetPresContext();
@@ -5503,18 +5502,18 @@ nsDocShell::GetAllowMixedContentAndConne
   // now get the document from sameTypeRoot
   RefPtr<Document> rootDoc = sameTypeRoot->GetDocument();
   if (rootDoc) {
     nsCOMPtr<nsIPrincipal> rootPrincipal = rootDoc->NodePrincipal();
 
     // For things with system principal (e.g. scratchpad) there is no uri
     // aRootHasSecureConnection should be false.
     nsCOMPtr<nsIURI> rootUri = rootPrincipal->GetURI();
-    if (nsContentUtils::IsSystemPrincipal(rootPrincipal) ||
-        !rootUri || !SchemeIsHTTPS(rootUri)) {
+    if (nsContentUtils::IsSystemPrincipal(rootPrincipal) || !rootUri ||
+        !SchemeIsHTTPS(rootUri)) {
       *aRootHasSecureConnection = false;
     }
 
     // Check the root doc's channel against the root docShell's
     // mMixedContentChannel to see if they are the same. If they are the same,
     // the user has overriden the block.
     nsCOMPtr<nsIDocShell> rootDocShell = do_QueryInterface(sameTypeRoot);
     nsCOMPtr<nsIChannel> mixedChannel;
@@ -9765,19 +9764,18 @@ nsresult nsDocShell::DoURILoad(nsDocShel
   bool inheritAttrs = false, inheritPrincipal = false;
 
   if (aLoadState->PrincipalToInherit()) {
     inheritAttrs = nsContentUtils::ChannelShouldInheritPrincipal(
         aLoadState->PrincipalToInherit(), aLoadState->URI(),
         true,  // aInheritForAboutBlank
         isSrcdoc);
 
-    bool isURIUniqueOrigin =
-        nsIOService::IsDataURIUniqueOpaqueOrigin() &&
-        SchemeIsData(aLoadState->URI());
+    bool isURIUniqueOrigin = nsIOService::IsDataURIUniqueOpaqueOrigin() &&
+                             SchemeIsData(aLoadState->URI());
     inheritPrincipal = inheritAttrs && !isURIUniqueOrigin;
   }
 
   nsLoadFlags loadFlags = mDefaultLoadFlags;
   nsSecurityFlags securityFlags =
       nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL;
 
   if (aLoadState->FirstParty()) {
@@ -9887,18 +9885,18 @@ nsresult nsDocShell::DoURILoad(nsDocShel
   } else if (SchemeIsViewSource(aLoadState->URI())) {
     nsViewSourceHandler* vsh = nsViewSourceHandler::GetInstance();
     NS_ENSURE_TRUE(vsh, NS_ERROR_FAILURE);
 
     rv = vsh->NewSrcdocChannel(aLoadState->URI(), baseURI, aSrcdoc, loadInfo,
                                getter_AddRefs(channel));
   } else {
     rv = NS_NewInputStreamChannelInternal(
-      getter_AddRefs(channel), aLoadState->URI(), aSrcdoc,
-      NS_LITERAL_CSTRING("text/html"), loadInfo, true);
+        getter_AddRefs(channel), aLoadState->URI(), aSrcdoc,
+        NS_LITERAL_CSTRING("text/html"), loadInfo, true);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIInputStreamChannel> isc = do_QueryInterface(channel);
     MOZ_ASSERT(isc);
     isc->SetBaseURI(baseURI);
   }
 
   // Navigational requests that are same origin need to be upgraded in case
   // upgrade-insecure-requests is present. Please note that in that case
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -217,17 +217,17 @@ EventStateManager::WheelPrefs* EventStat
     nullptr;
 bool EventStateManager::WheelPrefs::sWheelEventsEnabledOnPlugins = true;
 bool EventStateManager::WheelPrefs::sIsAutoDirEnabled = false;
 bool EventStateManager::WheelPrefs::sHonoursRootForAutoDir = false;
 EventStateManager::DeltaAccumulator*
     EventStateManager::DeltaAccumulator::sInstance = nullptr;
 
 constexpr const StyleCursorKind kInvalidCursorKind =
-  static_cast<StyleCursorKind>(255);
+    static_cast<StyleCursorKind>(255);
 
 EventStateManager::EventStateManager()
     : mLockCursor(kInvalidCursorKind),
       mLastFrameConsumedSetCursor(false),
       mCurrentTarget(nullptr),
       // init d&d gesture state machine variables
       mGestureDownPoint(0, 0),
       mGestureModifiers(0),
@@ -3660,17 +3660,18 @@ void EventStateManager::UpdateCursor(nsP
     // Check whether or not to show the busy cursor
     nsCOMPtr<nsIDocShell> docShell(aPresContext->GetDocShell());
     if (!docShell) return;
     auto busyFlags = docShell->GetBusyFlags();
 
     // Show busy cursor everywhere before page loads
     // and just replace the arrow cursor after page starts loading
     if (busyFlags & nsIDocShell::BUSY_FLAGS_BUSY &&
-        (cursor == StyleCursorKind::Auto || cursor == StyleCursorKind::Default)) {
+        (cursor == StyleCursorKind::Auto ||
+         cursor == StyleCursorKind::Default)) {
       cursor = StyleCursorKind::Progress;
       container = nullptr;
     }
   }
 
   if (aTargetFrame) {
     SetCursor(cursor, container, haveHotspot, hotspotX, hotspotY,
               aTargetFrame->GetNearestWidget(), false);
--- a/dom/ipc/PreallocatedProcessManager.cpp
+++ b/dom/ipc/PreallocatedProcessManager.cpp
@@ -69,18 +69,17 @@ class PreallocatedProcessManagerImpl fin
   RefPtr<ContentParent> mPreallocatedProcess;
   nsTHashtable<nsUint64HashKey> mBlockers;
 
   bool IsEmpty() const { return !mPreallocatedProcess && !mLaunchInProgress; }
 };
 
 /* static */ StaticRefPtr<PreallocatedProcessManagerImpl>
     PreallocatedProcessManagerImpl::sSingleton;
-/* static */ uint32_t
-    PreallocatedProcessManagerImpl::sPrelaunchDelayMS = 0;
+/* static */ uint32_t PreallocatedProcessManagerImpl::sPrelaunchDelayMS = 0;
 
 /* static */ PreallocatedProcessManagerImpl*
 PreallocatedProcessManagerImpl::Singleton() {
   MOZ_ASSERT(NS_IsMainThread());
   if (!sSingleton) {
     sSingleton = new PreallocatedProcessManagerImpl();
     sSingleton->Init();
     ClearOnShutdown(&sSingleton);
@@ -96,20 +95,19 @@ PreallocatedProcessManagerImpl::Prealloc
 
 PreallocatedProcessManagerImpl::~PreallocatedProcessManagerImpl() {
   // This shouldn't happen, because the promise callbacks should
   // hold strong references, but let't make absolutely sure:
   MOZ_RELEASE_ASSERT(!mLaunchInProgress);
 }
 
 void PreallocatedProcessManagerImpl::Init() {
-  Preferences::AddUintVarCache(
-    &sPrelaunchDelayMS,
-    "dom.ipc.processPrelaunch.delayMs",
-    DEFAULT_ALLOCATE_DELAY);
+  Preferences::AddUintVarCache(&sPrelaunchDelayMS,
+                               "dom.ipc.processPrelaunch.delayMs",
+                               DEFAULT_ALLOCATE_DELAY);
   Preferences::AddStrongObserver(this, "dom.ipc.processPrelaunch.enabled");
   // We have to respect processCount at all time. This is especially important
   // for testing.
   Preferences::AddStrongObserver(this, "dom.ipc.processCount");
   nsCOMPtr<nsIObserverService> os = services::GetObserverService();
   if (os) {
     os->AddObserver(this, "ipc:content-shutdown",
                     /* weakRef = */ false);
--- a/dom/media/AutoplayPolicy.cpp
+++ b/dom/media/AutoplayPolicy.cpp
@@ -230,18 +230,19 @@ static bool IsAllowedToPlayInternal(cons
    * 4. check whether media is allowed under current blocking model
    *    (only support user-gesture-activation)
    */
   if (aContext.IsOffline()) {
     return true;
   }
 
   nsPIDOMWindowInner* window = aContext.GetParentObject();
-  Document* approver = aContext.GetParentObject() ?
-      ApproverDocOf(*(window->GetExtantDoc())) : nullptr;
+  Document* approver = aContext.GetParentObject()
+                           ? ApproverDocOf(*(window->GetExtantDoc()))
+                           : nullptr;
   if (IsSiteInAutoplayWhiteList(approver)) {
     AUTOPLAY_LOG(
         "Allow autoplay as document has permanent autoplay permission.");
     return true;
   }
 
   if (DefaultAutoplayBehaviour() == nsIAutoplay::ALLOWED &&
       !IsSiteInAutoplayBlackList(approver)) {
--- a/dom/media/webaudio/AudioContext.cpp
+++ b/dom/media/webaudio/AudioContext.cpp
@@ -1012,17 +1012,18 @@ void AudioContext::MaybeUpdateAutoplayTe
         mozilla::Telemetry::LABELS_WEB_AUDIO_AUTOPLAY::NeverBlocked);
   } else if (!mWasEverAllowedToStart && mWasEverBlockedToStart) {
     AccumulateCategorical(
         mozilla::Telemetry::LABELS_WEB_AUDIO_AUTOPLAY::NeverAllowed);
   }
 }
 
 void AudioContext::ReportBlocked() {
-  ReportToConsole(nsIScriptError::warningFlag, "BlockAutoplayWebAudioStartError");
+  ReportToConsole(nsIScriptError::warningFlag,
+                  "BlockAutoplayWebAudioStartError");
   mWasAllowedToStart = false;
 
   if (!StaticPrefs::MediaBlockEventEnabled()) {
     return;
   }
 
   RefPtr<AudioContext> self = this;
   RefPtr<nsIRunnable> r =
--- a/dom/xul/XULTreeElement.h
+++ b/dom/xul/XULTreeElement.h
@@ -23,17 +23,17 @@ namespace mozilla {
 namespace dom {
 
 struct TreeCellInfo;
 class DOMRect;
 enum class CallerType : uint32_t;
 
 class XULTreeElement final : public nsXULElement {
  public:
-  explicit XULTreeElement(already_AddRefed<mozilla::dom::NodeInfo> &&aNodeInfo)
+  explicit XULTreeElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
       : nsXULElement(std::move(aNodeInfo)),
         mCachedFirstVisibleRow(0),
         mTreeBody(nullptr) {}
 
   NS_IMPL_FROMNODE_WITH_TAG(XULTreeElement, kNameSpaceID_XUL, tree)
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULTreeElement, nsXULElement)
@@ -113,16 +113,16 @@ class XULTreeElement final : public nsXU
  protected:
   int32_t mCachedFirstVisibleRow;
 
   nsTreeBodyFrame* mTreeBody;
   nsCOMPtr<nsITreeView> mView;
 
   virtual ~XULTreeElement() {}
 
-  JSObject *WrapNode(JSContext *aCx,
-                     JS::Handle<JSObject *> aGivenProto) override;
+  JSObject* WrapNode(JSContext* aCx,
+                     JS::Handle<JSObject*> aGivenProto) override;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif
--- a/gfx/layers/ipc/LayerTransactionParent.cpp
+++ b/gfx/layers/ipc/LayerTransactionParent.cpp
@@ -881,21 +881,21 @@ void LayerTransactionParent::DeallocShme
 
 bool LayerTransactionParent::IsSameProcess() const {
   return OtherPid() == base::GetCurrentProcId();
 }
 
 void LayerTransactionParent::SetPendingTransactionId(
     TransactionId aId, const VsyncId& aVsyncId,
     const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
-    const TimeStamp& aTxnStartTime, const TimeStamp& aTxnEndTime, bool aContainsSVG,
-    const nsCString& aURL, const TimeStamp& aFwdTime) {
-  mPendingTransactions.AppendElement(
-      PendingTransaction{aId, aVsyncId, aVsyncStartTime, aRefreshStartTime,
-                         aTxnStartTime, aTxnEndTime, aFwdTime, aURL, aContainsSVG});
+    const TimeStamp& aTxnStartTime, const TimeStamp& aTxnEndTime,
+    bool aContainsSVG, const nsCString& aURL, const TimeStamp& aFwdTime) {
+  mPendingTransactions.AppendElement(PendingTransaction{
+      aId, aVsyncId, aVsyncStartTime, aRefreshStartTime, aTxnStartTime,
+      aTxnEndTime, aFwdTime, aURL, aContainsSVG});
 }
 
 TransactionId LayerTransactionParent::FlushTransactionId(
     const VsyncId& aCompositeId, TimeStamp& aCompositeEnd) {
   TransactionId id;
   for (auto& transaction : mPendingTransactions) {
     id = transaction.mId;
     if (mId.IsValid() && transaction.mId.IsValid() && !mVsyncRate.IsZero()) {
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -405,19 +405,18 @@ struct DIGroup {
       // This item is being added for the first time, invalidate its entire
       // area.
       UniquePtr<nsDisplayItemGeometry> geometry(
           aItem->AllocateGeometry(aBuilder));
       nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
           geometry->ComputeInvalidationRegion());
       aData->mGeometry = std::move(geometry);
 
-      IntRect transformedRect =
-          ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel,
-                        mLayerBounds.TopLeft());
+      IntRect transformedRect = ToDeviceSpace(
+          clippedBounds, aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
       aData->mRect = transformedRect.Intersect(mImageBounds);
       GP("CGC %s %d %d %d %d\n", aItem->Name(), clippedBounds.x,
          clippedBounds.y, clippedBounds.width, clippedBounds.height);
       GP("%d %d,  %f %f\n", mLayerBounds.TopLeft().x, mLayerBounds.TopLeft().y,
          aMatrix._11, aMatrix._22);
       GP("mRect %d %d %d %d\n", aData->mRect.x, aData->mRect.y,
          aData->mRect.width, aData->mRect.height);
       InvalidateRect(aData->mRect);
@@ -436,19 +435,18 @@ struct DIGroup {
       GP("frame invalid invalidate: %s\n", aItem->Name());
       GP("old rect: %d %d %d %d\n", aData->mRect.x, aData->mRect.y,
          aData->mRect.width, aData->mRect.height);
       InvalidateRect(aData->mRect.Intersect(mImageBounds));
       // We want to snap to outside pixels. When should we multiply by the
       // matrix?
       // XXX: TransformBounds is expensive. We should avoid doing it if we have
       // no transform
-      IntRect transformedRect =
-          ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel,
-                        mLayerBounds.TopLeft());
+      IntRect transformedRect = ToDeviceSpace(
+          clippedBounds, aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
       aData->mRect = transformedRect.Intersect(mImageBounds);
       InvalidateRect(aData->mRect);
       GP("new rect: %d %d %d %d\n", aData->mRect.x, aData->mRect.y,
          aData->mRect.width, aData->mRect.height);
       aData->mInvalid = true;
     } else {
       MOZ_RELEASE_ASSERT(mLayerBounds.TopLeft() == aData->mGroupOffset);
       GP("else invalidate: %s\n", aItem->Name());
@@ -546,42 +544,42 @@ struct DIGroup {
           // we need to catch bounds changes of containers so that we continue
           // to have the correct bounds rects in the recording
           if (UpdateContainerLayerPropertiesAndDetectChange(aItem, aData,
                                                             *geometry)) {
             nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
                 geometry->ComputeInvalidationRegion());
             aData->mGeometry = std::move(geometry);
             IntRect transformedRect =
-                ToDeviceSpace(clippedBounds, aMatrix,
-                              appUnitsPerDevPixel, mLayerBounds.TopLeft());
+                ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel,
+                              mLayerBounds.TopLeft());
             InvalidateRect(aData->mRect.Intersect(mImageBounds));
             aData->mRect = transformedRect.Intersect(mImageBounds);
             InvalidateRect(aData->mRect);
             GP("UpdateContainerLayerPropertiesAndDetectChange change\n");
           } else if (!aData->mImageRect.IsEqualEdges(mImageBounds)) {
             // Make sure we update mRect for mImageBounds changes
             nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
                 geometry->ComputeInvalidationRegion());
             IntRect transformedRect =
-                ToDeviceSpace(clippedBounds, aMatrix,
-                              appUnitsPerDevPixel, mLayerBounds.TopLeft());
+                ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel,
+                              mLayerBounds.TopLeft());
             // The invalid rect should contain the old rect and the new rect
             // but may not because the parent may have been removed.
             InvalidateRect(aData->mRect);
             aData->mRect = transformedRect.Intersect(mImageBounds);
             InvalidateRect(aData->mRect);
             GP("ContainerLayer image rect bounds change\n");
           } else {
             // XXX: this code can eventually be deleted/made debug only
             nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
                 geometry->ComputeInvalidationRegion());
             IntRect transformedRect =
-                ToDeviceSpace(clippedBounds, aMatrix,
-                              appUnitsPerDevPixel, mLayerBounds.TopLeft());
+                ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel,
+                              mLayerBounds.TopLeft());
             auto rect = transformedRect.Intersect(mImageBounds);
             GP("Layer NoChange: %s %d %d %d %d\n", aItem->Name(),
                aData->mRect.x, aData->mRect.y, aData->mRect.XMost(),
                aData->mRect.YMost());
             MOZ_RELEASE_ASSERT(rect.IsEqualEdges(aData->mRect));
           }
         } else if (!aData->mImageRect.IsEqualEdges(mImageBounds)) {
           // Make sure we update mRect for mImageBounds changes
--- a/gfx/src/FilterSupport.h
+++ b/gfx/src/FilterSupport.h
@@ -14,18 +14,18 @@
 #include "mozilla/gfx/2D.h"
 #include "nsClassHashtable.h"
 #include "nsTArray.h"
 #include "nsRegion.h"
 
 namespace mozilla {
 namespace gfx {
 class FilterPrimitiveDescription;
-} // namespace gfx
-} // namespace mozilla
+}  // namespace gfx
+}  // namespace mozilla
 
 DECLARE_USE_COPY_CONSTRUCTORS(mozilla::gfx::FilterPrimitiveDescription)
 
 namespace mozilla {
 namespace gfx {
 
 // Morphology Operators
 const unsigned short SVG_OPERATOR_UNKNOWN = 0;
--- a/gfx/vr/ipc/VRGPUChild.cpp
+++ b/gfx/vr/ipc/VRGPUChild.cpp
@@ -43,18 +43,14 @@ static StaticRefPtr<VRGPUChild> sVRGPUCh
 /*static*/ void VRGPUChild::Shutdown() {
   MOZ_ASSERT(NS_IsMainThread());
   if (sVRGPUChildSingleton && !sVRGPUChildSingleton->IsClosed()) {
     sVRGPUChildSingleton->Close();
   }
   sVRGPUChildSingleton = nullptr;
 }
 
-void VRGPUChild::ActorDestroy(ActorDestroyReason aWhy) {
-  mClosed = true;
-}
+void VRGPUChild::ActorDestroy(ActorDestroyReason aWhy) { mClosed = true; }
 
-bool VRGPUChild::IsClosed() {
-  return mClosed;
-}
+bool VRGPUChild::IsClosed() { return mClosed; }
 
 }  // namespace gfx
 }  // namespace mozilla
--- a/gfx/vr/ipc/VRGPUParent.cpp
+++ b/gfx/vr/ipc/VRGPUParent.cpp
@@ -8,27 +8,24 @@
 
 #include "mozilla/ipc/ProcessChild.h"
 
 namespace mozilla {
 namespace gfx {
 
 using namespace ipc;
 
-VRGPUParent::VRGPUParent(ProcessId aChildProcessId)
- : mClosed(false) {
+VRGPUParent::VRGPUParent(ProcessId aChildProcessId) : mClosed(false) {
   MOZ_COUNT_CTOR(VRGPUParent);
   MOZ_ASSERT(NS_IsMainThread());
 
   SetOtherProcessId(aChildProcessId);
 }
 
-VRGPUParent::~VRGPUParent() {
-  MOZ_COUNT_DTOR(VRGPUParent);
-}
+VRGPUParent::~VRGPUParent() { MOZ_COUNT_DTOR(VRGPUParent); }
 
 void VRGPUParent::ActorDestroy(ActorDestroyReason aWhy) {
 #if !defined(MOZ_WIDGET_ANDROID)
   if (mVRService) {
     mVRService->Stop();
     mVRService = nullptr;
   }
 #endif
@@ -75,14 +72,12 @@ mozilla::ipc::IPCResult VRGPUParent::Rec
     mVRService->Stop();
     mVRService = nullptr;
   }
 #endif
 
   return IPC_OK();
 }
 
-bool VRGPUParent::IsClosed() {
-  return mClosed;
-}
+bool VRGPUParent::IsClosed() { return mClosed; }
 
 }  // namespace gfx
 }  // namespace mozilla
\ No newline at end of file
--- a/gfx/vr/ipc/VRGPUParent.h
+++ b/gfx/vr/ipc/VRGPUParent.h
@@ -17,17 +17,16 @@ class VRGPUParent final : public PVRGPUP
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VRGPUParent)
 
  public:
   static RefPtr<VRGPUParent> CreateForGPU(Endpoint<PVRGPUParent>&& aEndpoint);
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
   bool IsClosed();
 
  protected:
-
   void Bind(Endpoint<PVRGPUParent>&& aEndpoint);
   virtual mozilla::ipc::IPCResult RecvStartVRService() override;
   virtual mozilla::ipc::IPCResult RecvStopVRService() override;
 
  private:
   explicit VRGPUParent(ProcessId aChildProcessId);
   ~VRGPUParent();
 
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -794,22 +794,22 @@ wr::WrSpaceAndClip DisplayListBuilder::D
     const wr::LayoutRect& aContentRect, const wr::LayoutRect& aClipRect) {
   auto it = mScrollIds.find(aViewId);
   if (it != mScrollIds.end()) {
     return it->second;
   }
 
   // We haven't defined aViewId before, so let's define it now.
   wr::WrSpaceAndClip defaultParent = wr::RootScrollNode();
-  //Note: we are currently ignoring the clipId on the stack here
+  // Note: we are currently ignoring the clipId on the stack here
   defaultParent.space = mCurrentSpaceAndClipChain.space;
 
   auto spaceAndClip = wr_dp_define_scroll_layer(
-      mWrState, aViewId, aParent ? aParent.ptr() : &defaultParent,
-      aContentRect, aClipRect);
+      mWrState, aViewId, aParent ? aParent.ptr() : &defaultParent, aContentRect,
+      aClipRect);
 
   WRDL_LOG("DefineScrollLayer id=%" PRIu64 "/%zu p=%s co=%s cl=%s\n", mWrState,
            aViewId, spaceAndClip.space.id,
            aParent ? Stringify(aParent->space.id).c_str() : "(nil)",
            Stringify(aContentRect).c_str(), Stringify(aClipRect).c_str());
 
   mScrollIds[aViewId] = spaceAndClip;
   return spaceAndClip;
--- a/js/ipc/WrapperOwner.cpp
+++ b/js/ipc/WrapperOwner.cpp
@@ -142,19 +142,17 @@ const CPOWProxyHandler CPOWProxyHandler:
   WrapperOwner* owner = OwnerOf(proxy);                                 \
   if (!owner->active()) {                                               \
     JS_ReportErrorASCII(cx, "cannot use a CPOW whose process is gone"); \
     return failRetVal;                                                  \
   }                                                                     \
   if (!owner->allowMessage(cx)) {                                       \
     return failRetVal;                                                  \
   }                                                                     \
-  {                                                                     \
-    return owner->call args;                                            \
-  }
+  { return owner->call args; }
 
 bool CPOWProxyHandler::getOwnPropertyDescriptor(
     JSContext* cx, HandleObject proxy, HandleId id,
     MutableHandle<PropertyDescriptor> desc) const {
   FORWARD(getOwnPropertyDescriptor, (cx, proxy, id, desc), false);
 }
 
 bool WrapperOwner::getOwnPropertyDescriptor(
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -4218,18 +4218,17 @@ bool GCRuntime::prepareZonesForCollectio
   return any;
 }
 
 static void DiscardJITCodeForGC(JSRuntime* rt) {
   js::CancelOffThreadIonCompile(rt, JS::Zone::MarkBlackOnly);
   for (GCZonesIter zone(rt); !zone.done(); zone.next()) {
     gcstats::AutoPhase ap(rt->gc.stats(),
                           gcstats::PhaseKind::MARK_DISCARD_CODE);
-    zone->discardJitCode(rt->defaultFreeOp(),
-                         Zone::DiscardBaselineCode,
+    zone->discardJitCode(rt->defaultFreeOp(), Zone::DiscardBaselineCode,
                          Zone::ReleaseTypes);
   }
 }
 
 static void RelazifyFunctionsForShrinkingGC(JSRuntime* rt) {
   gcstats::AutoPhase ap(rt->gc.stats(), gcstats::PhaseKind::RELAZIFY_FUNCTIONS);
   for (GCZonesIter zone(rt); !zone.done(); zone.next()) {
     if (zone->isSelfHostingZone()) {
--- a/js/src/gc/GCLock.h
+++ b/js/src/gc/GCLock.h
@@ -108,11 +108,11 @@ class MOZ_RAII AutoUnlockGC {
  private:
   AutoLockGC& lock;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
   AutoUnlockGC(const AutoUnlockGC&) = delete;
   AutoUnlockGC& operator=(const AutoUnlockGC&) = delete;
 };
 
-} // namespace js
+}  // namespace js
 
 #endif /* gc_GCLock_h */
--- a/js/src/gc/Zone.h
+++ b/js/src/gc/Zone.h
@@ -186,24 +186,22 @@ class Zone : public JS::shadow::Zone,
 
   void findOutgoingEdges(js::gc::ZoneComponentFinder& finder);
 
   enum ShouldDiscardBaselineCode : bool {
     KeepBaselineCode = false,
     DiscardBaselineCode
   };
 
-  enum ShouldReleaseTypes : bool {
-    KeepTypes = false,
-    ReleaseTypes
-  };
+  enum ShouldReleaseTypes : bool { KeepTypes = false, ReleaseTypes };
 
-  void discardJitCode(js::FreeOp* fop,
-                      ShouldDiscardBaselineCode discardBaselineCode = DiscardBaselineCode,
-                      ShouldReleaseTypes releaseTypes = KeepTypes);
+  void discardJitCode(
+      js::FreeOp* fop,
+      ShouldDiscardBaselineCode discardBaselineCode = DiscardBaselineCode,
+      ShouldReleaseTypes releaseTypes = KeepTypes);
 
   void addSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf,
                               size_t* typePool, size_t* regexpZone,
                               size_t* jitZone, size_t* baselineStubsOptimized,
                               size_t* cachedCFG, size_t* uniqueIdMap,
                               size_t* shapeTables, size_t* atomsMarkBitmaps,
                               size_t* compartmentObjects,
                               size_t* crossCompartmentWrappersTables,
--- a/js/src/vm/Realm.h
+++ b/js/src/vm/Realm.h
@@ -633,19 +633,17 @@ class JS::Realm : public JS::shadow::Rea
   void unmark() { marked_ = false; }
 
   /*
    * The principals associated with this realm. Note that the same several
    * realms may share the same principals and that a realm may change
    * principals during its lifetime (e.g. in case of lazy parsing).
    */
   JSPrincipals* principals() { return principals_; }
-  void setPrincipals(JSPrincipals* principals) {
-    principals_ = principals;
-  }
+  void setPrincipals(JSPrincipals* principals) { principals_ = principals; }
 
   bool isSystem() const { return isSystem_; }
 
   // Used to approximate non-content code when reporting telemetry.
   bool isProbablySystemCode() const { return isSystem_; }
 
   static const size_t IterResultObjectValueSlot = 0;
   static const size_t IterResultObjectDoneSlot = 1;
--- a/js/src/wasm/WasmInstance.cpp
+++ b/js/src/wasm/WasmInstance.cpp
@@ -1138,18 +1138,17 @@ bool Instance::memoryAccessInGuardRegion
     return false;
   }
 
   size_t lastByteOffset = addr - base + (numBytes - 1);
   return lastByteOffset >= memory()->volatileMemoryLength() &&
          lastByteOffset < memoryMappedSize();
 }
 
-bool Instance::memoryAccessInBounds(uint8_t* addr,
-                                    unsigned numBytes) const {
+bool Instance::memoryAccessInBounds(uint8_t* addr, unsigned numBytes) const {
   MOZ_ASSERT(numBytes > 0 && numBytes <= sizeof(double));
 
   if (!metadata().usesMemory()) {
     return false;
   }
 
   uint8_t* base = memoryBase().unwrap(/* comparison */);
   if (addr < base) {
--- a/js/src/wasm/WasmSignalHandlers.cpp
+++ b/js/src/wasm/WasmSignalHandlers.cpp
@@ -442,33 +442,50 @@ struct AutoHandlingTrap {
 };
 
 #if defined(__linux__) && defined(__arm__)
 
 // Code to handle SIGBUS for unaligned floating point accesses on 32-bit ARM.
 
 static uintptr_t ReadGPR(CONTEXT* context, uint32_t rn) {
   switch (rn) {
-    case 0: return context->uc_mcontext.arm_r0;
-    case 1: return context->uc_mcontext.arm_r1;
-    case 2: return context->uc_mcontext.arm_r2;
-    case 3: return context->uc_mcontext.arm_r3;
-    case 4: return context->uc_mcontext.arm_r4;
-    case 5: return context->uc_mcontext.arm_r5;
-    case 6: return context->uc_mcontext.arm_r6;
-    case 7: return context->uc_mcontext.arm_r7;
-    case 8: return context->uc_mcontext.arm_r8;
-    case 9: return context->uc_mcontext.arm_r9;
-    case 10: return context->uc_mcontext.arm_r10;
-    case 11: return context->uc_mcontext.arm_fp;
-    case 12: return context->uc_mcontext.arm_ip;
-    case 13: return context->uc_mcontext.arm_sp;
-    case 14: return context->uc_mcontext.arm_lr;
-    case 15: return context->uc_mcontext.arm_pc;
-    default: MOZ_CRASH();
+    case 0:
+      return context->uc_mcontext.arm_r0;
+    case 1:
+      return context->uc_mcontext.arm_r1;
+    case 2:
+      return context->uc_mcontext.arm_r2;
+    case 3:
+      return context->uc_mcontext.arm_r3;
+    case 4:
+      return context->uc_mcontext.arm_r4;
+    case 5:
+      return context->uc_mcontext.arm_r5;
+    case 6:
+      return context->uc_mcontext.arm_r6;
+    case 7:
+      return context->uc_mcontext.arm_r7;
+    case 8:
+      return context->uc_mcontext.arm_r8;
+    case 9:
+      return context->uc_mcontext.arm_r9;
+    case 10:
+      return context->uc_mcontext.arm_r10;
+    case 11:
+      return context->uc_mcontext.arm_fp;
+    case 12:
+      return context->uc_mcontext.arm_ip;
+    case 13:
+      return context->uc_mcontext.arm_sp;
+    case 14:
+      return context->uc_mcontext.arm_lr;
+    case 15:
+      return context->uc_mcontext.arm_pc;
+    default:
+      MOZ_CRASH();
   }
 }
 
 // Linux kernel data structures.
 //
 // The vfp_sigframe is a kernel type overlaid on the uc_regspace field of the
 // ucontext_t if the first word of the uc_regspace is VFP_MAGIC.  (user_vfp and
 // user_vfp_exc are defined in sys/user.h and are stable.)
@@ -477,21 +494,20 @@ static uintptr_t ReadGPR(CONTEXT* contex
 // when it was changed from being 0x56465001 on ARMv6 and earlier and 0x56465002
 // on ARMv7 and later, to being 0x56465001 on all CPU versions.  This was in
 // Kernel 2.6.34-rc5.
 //
 // My best interpretation of the Android commit history is that Android has had
 // vfp_sigframe and VFP_MAGIC in this form since at least Android 3.4 / 2012;
 // Firefox requires Android 4.0 at least and we're probably safe here.
 
-struct vfp_sigframe
-{
-  unsigned long       magic;
-  unsigned long       size;
-  struct user_vfp     ufp;
+struct vfp_sigframe {
+  unsigned long magic;
+  unsigned long size;
+  struct user_vfp ufp;
   struct user_vfp_exc ufp_exc;
 };
 
 #define VFP_MAGIC 0x56465001
 
 static vfp_sigframe* GetVFPFrame(CONTEXT* context) {
   if (context->uc_regspace[0] != VFP_MAGIC) {
     return nullptr;
@@ -553,39 +569,40 @@ static bool HandleUnalignedTrap(CONTEXT*
   bool isVSTR = masked == 0x0D000A00;
 
   if (!isVLDR && !isVSTR) {
     // Three obvious cases if we don't get our expected instructions:
     // - masm is generating other FP access instructions than it should
     // - we're encountering a device that traps on new kinds of accesses,
     //   perhaps unaligned integer accesses
     // - general code generation bugs that lead to SIGBUS
-#  ifdef ANDROID
-    __android_log_print(ANDROID_LOG_ERROR, "WASM", "Bad SIGBUS instr %08x", instr);
-#  endif
-#  ifdef DEBUG
+#ifdef ANDROID
+    __android_log_print(ANDROID_LOG_ERROR, "WASM", "Bad SIGBUS instr %08x",
+                        instr);
+#endif
+#ifdef DEBUG
     MOZ_CRASH("Unexpected instruction");
-#  endif
+#endif
     return false;
   }
 
   bool isUnconditional = (instr >> 28) == 0xE;
   bool isDouble = (instr & 0x00000100) != 0;
   bool isAdd = (instr & 0x00800000) != 0;
   uint32_t dBit = (instr >> 22) & 1;
   uint32_t offs = (instr & 0xFF) << 2;
   uint32_t rn = (instr >> 16) & 0xF;
 
   MOZ_RELEASE_ASSERT(isUnconditional);
   MOZ_RELEASE_ASSERT(rn != 15);
 
   uint8_t* p = (uint8_t*)ReadGPR(context, rn) + (isAdd ? offs : -offs);
 
-  if (!instance->memoryAccessInBounds(p, isDouble ? sizeof(double)
-                                                  : sizeof(float))) {
+  if (!instance->memoryAccessInBounds(
+          p, isDouble ? sizeof(double) : sizeof(float))) {
     return false;
   }
 
   if (isDouble) {
     uint32_t vd = ((instr >> 12) & 0xF) | (dBit << 4);
     double val;
     if (isVLDR) {
       memcpy(&val, p, sizeof(val));
@@ -614,26 +631,27 @@ static bool HandleUnalignedTrap(CONTEXT*
         memcpy(p, &val, sizeof(val));
         SetContextPC(context, pc + 4);
         return true;
       }
     }
   }
 
 #ifdef DEBUG
-  MOZ_CRASH("SIGBUS handler could not access FP register, incompatible kernel?");
+  MOZ_CRASH(
+      "SIGBUS handler could not access FP register, incompatible kernel?");
 #endif
   return false;
 }
-#else // __linux__ && __arm__
+#else   // __linux__ && __arm__
 static bool HandleUnalignedTrap(CONTEXT* context, uint8_t* pc,
                                 Instance* instance) {
   return false;
 }
-#endif // __linux__ && __arm__
+#endif  // __linux__ && __arm__
 
 static MOZ_MUST_USE bool HandleTrap(CONTEXT* context,
                                     bool isUnalignedSignal = false,
                                     JSContext* assertCx = nullptr) {
   MOZ_ASSERT(sAlreadyHandlingTrap.get());
 
   uint8_t* pc = ContextToPC(context);
   const CodeSegment* codeSegment = LookupCodeSegment(pc);
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -1466,17 +1466,17 @@ nsresult nsHTMLFramesetBorderFrame::Hand
 
 nsresult nsHTMLFramesetBorderFrame::GetCursor(const nsPoint& aPoint,
                                               nsIFrame::Cursor& aCursor) {
   aCursor.mLoading = false;
   if (!mCanResize) {
     aCursor.mCursor = StyleCursorKind::Default;
   } else {
     aCursor.mCursor =
-        (mVertical) ? StyleCursorKind::EwResize: StyleCursorKind::NsResize;
+        (mVertical) ? StyleCursorKind::EwResize : StyleCursorKind::NsResize;
   }
   return NS_OK;
 }
 
 #ifdef DEBUG_FRAME_DUMP
 nsresult nsHTMLFramesetBorderFrame::GetFrameName(nsAString& aResult) const {
   return MakeFrameName(NS_LITERAL_STRING("FramesetBorder"), aResult);
 }
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -7877,19 +7877,18 @@ bool nsDisplayTransform::CreateWebRender
       ActiveLayerTracker::IsStyleMaybeAnimated(Frame(), eCSSProperty_transform);
 
   bool preserve3D = mFrame->Extend3DContext() && !mIsTransformSeparator;
 
   StackingContextHelper sc(
       aSc, GetActiveScrolledRoot(), mFrame, this, aBuilder, filters,
       LayoutDeviceRect(position, LayoutDeviceSize()), &newTransformMatrix,
       animationsId ? &prop : nullptr, nullptr, transformForSC, nullptr,
-      gfx::CompositionOp::OP_OVER, !BackfaceIsHidden(),
-      preserve3D, deferredTransformItem, wr::WrStackingContextClip::None(),
-      animated);
+      gfx::CompositionOp::OP_OVER, !BackfaceIsHidden(), preserve3D,
+      deferredTransformItem, wr::WrStackingContextClip::None(), animated);
 
   return mStoredList.CreateWebRenderCommands(aBuilder, aResources, sc, aManager,
                                              aDisplayListBuilder);
 }
 
 bool nsDisplayTransform::UpdateScrollData(
     mozilla::layers::WebRenderScrollData* aData,
     mozilla::layers::WebRenderLayerScrollData* aLayerData) {
--- a/layout/style/nsStyleCoord.h
+++ b/layout/style/nsStyleCoord.h
@@ -169,17 +169,16 @@ class nsStyleCoord {
   bool CalcHasPercent() const { return GetCalcValue()->mHasPercent; }
 
   bool HasPercent() const {
     return mUnit == eStyleUnit_Percent || (IsCalcUnit() && CalcHasPercent());
   }
 
   static bool ConvertsToPercent(const nsStyleUnit aUnit,
                                 const nsStyleUnion aValue) {
-
     if (aUnit == eStyleUnit_Percent) {
       return true;
     }
     if (!IsCalcUnit(aUnit)) {
       return false;
     }
     auto* calc = AsCalcValue(aValue);
     return calc->mLength == 0 && calc->mHasPercent;
--- a/layout/xul/nsImageBoxFrame.cpp
+++ b/layout/xul/nsImageBoxFrame.cpp
@@ -222,18 +222,18 @@ void nsImageBoxFrame::UpdateImage() {
       nsCOMPtr<nsIURI> baseURI = mContent->GetBaseURI();
       nsCOMPtr<nsIURI> uri;
       nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(uri), src, doc,
                                                 baseURI);
       if (uri) {
         nsresult rv = nsContentUtils::LoadImage(
             uri, mContent, doc, triggeringPrincipal, requestContextID,
             doc->GetDocumentURIAsReferrer(), doc->GetReferrerPolicy(),
-            mListener, mLoadFlags, EmptyString(),
-            getter_AddRefs(mImageRequest), contentPolicyType);
+            mListener, mLoadFlags, EmptyString(), getter_AddRefs(mImageRequest),
+            contentPolicyType);
 
         if (NS_SUCCEEDED(rv) && mImageRequest) {
           nsLayoutUtils::RegisterImageRequestIfAnimated(
               presContext, mImageRequest, &mRequestRegistered);
         }
       }
     }
   } else {
--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -5411,23 +5411,25 @@ static void InitVarCachePref(const nsACS
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(Preferences,
                                          Preferences::GetInstanceForService)
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsPrefLocalizedString, Init)
 
 static NS_DEFINE_CID(kPrefServiceCID, NS_PREFSERVICE_CID);
 static NS_DEFINE_CID(kPrefLocalizedStringCID, NS_PREFLOCALIZEDSTRING_CID);
 
 static mozilla::Module::CIDEntry kPrefCIDs[] = {
-    {&kPrefServiceCID, true, nullptr, PreferencesConstructor, Module::ALLOW_IN_SOCKET_PROCESS},
+    {&kPrefServiceCID, true, nullptr, PreferencesConstructor,
+     Module::ALLOW_IN_SOCKET_PROCESS},
     {&kPrefLocalizedStringCID, false, nullptr,
      nsPrefLocalizedStringConstructor},
     {nullptr}};
 
 static mozilla::Module::ContractIDEntry kPrefContracts[] = {
-    {NS_PREFSERVICE_CONTRACTID, &kPrefServiceCID, Module::ALLOW_IN_SOCKET_PROCESS},
+    {NS_PREFSERVICE_CONTRACTID, &kPrefServiceCID,
+     Module::ALLOW_IN_SOCKET_PROCESS},
     {NS_PREFLOCALIZEDSTRING_CONTRACTID, &kPrefLocalizedStringCID},
     {nullptr}};
 
 static void UnloadPrefsModule() { Preferences::Shutdown(); }
 
 static const mozilla::Module kPrefModule = {mozilla::Module::kVersion,
                                             kPrefCIDs,
                                             kPrefContracts,
--- a/netwerk/build/nsNetModule.cpp
+++ b/netwerk/build/nsNetModule.cpp
@@ -925,18 +925,19 @@ static const mozilla::Module::ContractID
     { NS_NETWORKCONNECTIVITYSERVICE_CONTRACTID, &kNS_NETWORKCONNECTIVITYSERVICE_CID },
 #ifdef BUILD_NETWORK_INFO_SERVICE
     { NETWORKINFOSERVICE_CONTRACT_ID, &kNETWORKINFOSERVICE_CID },
 #endif
     { nullptr }
     // clang-format on
 };
 
-static const mozilla::Module kNeckoModule = {mozilla::Module::kVersion,
-                                             kNeckoCIDs,
-                                             kNeckoContracts,
-                                             kNeckoCategories,
-                                             nullptr,
-                                             nsNetStartup,
-                                             nsNetShutdown,
-                                             mozilla::Module::ALLOW_IN_SOCKET_PROCESS};
+static const mozilla::Module kNeckoModule = {
+    mozilla::Module::kVersion,
+    kNeckoCIDs,
+    kNeckoContracts,
+    kNeckoCategories,
+    nullptr,
+    nsNetStartup,
+    nsNetShutdown,
+    mozilla::Module::ALLOW_IN_SOCKET_PROCESS};
 
 NSMODULE_DEFN(necko) = &kNeckoModule;
--- a/netwerk/ipc/SocketProcessChild.cpp
+++ b/netwerk/ipc/SocketProcessChild.cpp
@@ -153,17 +153,17 @@ mozilla::ipc::IPCResult SocketProcessChi
       mozilla::ChildProfilerController::Create(std::move(aEndpoint));
 #endif
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult SocketProcessChild::RecvSocketProcessTelemetryPing() {
   const uint32_t kExpectedUintValue = 42;
   Telemetry::ScalarSet(Telemetry::ScalarID::TELEMETRY_TEST_SOCKET_ONLY_UINT,
-      kExpectedUintValue);
+                       kExpectedUintValue);
   return IPC_OK();
 }
 
 void SocketProcessChild::DestroySocketProcessBridgeParent(ProcessId aId) {
   MOZ_ASSERT(NS_IsMainThread());
 
   mSocketProcessBridgeParentMap.Remove(aId);
 }
--- a/security/manager/pki/nsASN1Tree.h
+++ b/security/manager/pki/nsASN1Tree.h
@@ -16,25 +16,25 @@
 /* Disable the "base class XXX should be explicitly initialized
    in the copy constructor" warning. */
 #if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wextra"
 #elif defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wextra"
-#endif // __clang__ || __GNUC__
+#endif  // __clang__ || __GNUC__
 
 #include "mozilla/dom/XULTreeElement.h"
 
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #elif defined(__GNUC__)
 #pragma GCC diagnostic pop
-#endif // __clang__ || __GNUC__
+#endif  // __clang__ || __GNUC__
 
 // 4bfaa9f0-1dd2-11b2-afae-a82cbaa0b606
 #define NS_NSSASN1OUTINER_CID                        \
   {                                                  \
     0x4bfaa9f0, 0x1dd2, 0x11b2, {                    \
       0xaf, 0xae, 0xa8, 0x2c, 0xba, 0xa0, 0xb6, 0x06 \
     }                                                \
   }
--- a/security/manager/ssl/nsCertTree.h
+++ b/security/manager/ssl/nsCertTree.h
@@ -21,25 +21,25 @@
 /* Disable the "base class XXX should be explicitly initialized
    in the copy constructor" warning. */
 #if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wextra"
 #elif defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wextra"
-#endif // __clang__ || __GNUC__
+#endif  // __clang__ || __GNUC__
 
 #include "mozilla/dom/XULTreeElement.h"
 
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #elif defined(__GNUC__)
 #pragma GCC diagnostic pop
-#endif // __clang__ || __GNUC__
+#endif  // __clang__ || __GNUC__
 
 typedef struct treeArrayElStr treeArrayEl;
 
 struct CompareCacheHashEntry {
   enum { max_criterions = 3 };
   CompareCacheHashEntry();
 
   void *key;  // no ownership
--- a/toolkit/components/reputationservice/ApplicationReputation.cpp
+++ b/toolkit/components/reputationservice/ApplicationReputation.cpp
@@ -1523,17 +1523,18 @@ nsresult PendingLookup::SendRemoteQueryI
   // (only the URL for now).
   std::string serialized;
   if (!mRequest.SerializeToString(&serialized)) {
     return NS_ERROR_UNEXPECTED;
   }
 
   if (LOG_ENABLED()) {
     nsAutoCString serializedStr(serialized.c_str(), serialized.length());
-    serializedStr.ReplaceSubstring(NS_LITERAL_CSTRING("\0"), NS_LITERAL_CSTRING("\\0"));
+    serializedStr.ReplaceSubstring(NS_LITERAL_CSTRING("\0"),
+                                   NS_LITERAL_CSTRING("\\0"));
 
     LOG(("Serialized protocol buffer [this = %p]: (length=%d) %s", this,
          serializedStr.Length(), serializedStr.get()));
   }
 
   // Set the input stream to the serialized protocol buffer
   nsCOMPtr<nsIStringInputStream> sstream =
       do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv);
--- a/toolkit/components/sessionstore/SessionStoreUtils.cpp
+++ b/toolkit/components/sessionstore/SessionStoreUtils.cpp
@@ -124,18 +124,18 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(Dynamic
     aCallback.Call(WindowProxyHolder(item->GetWindow()->GetBrowsingContext()),
                    childOffset);
   }
 }
 
 /* static */ already_AddRefed<nsISupports>
 SessionStoreUtils::AddDynamicFrameFilteredListener(
     const GlobalObject& aGlobal, EventTarget& aTarget, const nsAString& aType,
-    JS::Handle<JS::Value> aListener, bool aUseCapture,
-    bool aMozSystemGroup, ErrorResult& aRv) {
+    JS::Handle<JS::Value> aListener, bool aUseCapture, bool aMozSystemGroup,
+    ErrorResult& aRv) {
   if (NS_WARN_IF(!aListener.isObject())) {
     aRv.Throw(NS_ERROR_INVALID_ARG);
     return nullptr;
   }
 
   JSContext* cx = aGlobal.Context();
   JS::Rooted<JSObject*> obj(cx, &aListener.toObject());
   JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx));
@@ -152,18 +152,18 @@ SessionStoreUtils::AddDynamicFrameFilter
     return nullptr;
   }
 
   return filter.forget();
 }
 
 /* static */ void SessionStoreUtils::RemoveDynamicFrameFilteredListener(
     const GlobalObject& global, EventTarget& aTarget, const nsAString& aType,
-    nsISupports* aListener, bool aUseCapture,
-    bool aMozSystemGroup, ErrorResult& aRv) {
+    nsISupports* aListener, bool aUseCapture, bool aMozSystemGroup,
+    ErrorResult& aRv) {
   nsCOMPtr<nsIDOMEventListener> listener = do_QueryInterface(aListener);
   if (!listener) {
     aRv.Throw(NS_ERROR_NO_INTERFACE);
     return;
   }
 
   if (aMozSystemGroup) {
     aTarget.RemoveSystemEventListener(aType, listener, aUseCapture);
@@ -378,17 +378,18 @@ static void CollectFromTextAreaElement(D
     textArea->GetId(id);
     if (id.IsEmpty() && (aGeneratedCount > kMaxTraversedXPaths)) {
       continue;
     }
     nsAutoString value;
     textArea->GetValue(value);
     // In order to reduce XPath generation (which is slow), we only save data
     // for form fields that have been changed. (cf. bug 537289)
-    if (textArea->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value, eCaseMatters)) {
+    if (textArea->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value,
+                              eCaseMatters)) {
       continue;
     }
     Record<nsString, OwningStringOrBooleanOrLongOrObject>::EntryType* entry =
         AppendEntryToCollectedData(textArea, id, aGeneratedCount, aRetVal);
     entry->mValue.SetAsString() = value;
   }
 }
 
@@ -401,17 +402,18 @@ static void CollectFromTextAreaElement(D
 static void CollectFromInputElement(JSContext* aCx, Document& aDocument,
                                     uint16_t& aGeneratedCount,
                                     CollectedFormData& aRetVal) {
   RefPtr<nsContentList> inputlist = NS_GetContentList(
       &aDocument, kNameSpaceID_XHTML, NS_LITERAL_STRING("input"));
   uint32_t length = inputlist->Length(true);
   for (uint32_t i = 0; i < length; ++i) {
     MOZ_ASSERT(inputlist->Item(i), "null item in node list!");
-    nsCOMPtr<nsIFormControl> formControl = do_QueryInterface(inputlist->Item(i));
+    nsCOMPtr<nsIFormControl> formControl =
+        do_QueryInterface(inputlist->Item(i));
     if (formControl) {
       uint8_t controlType = formControl->ControlType();
       if (controlType == NS_FORM_INPUT_PASSWORD ||
           controlType == NS_FORM_INPUT_HIDDEN ||
           controlType == NS_FORM_INPUT_BUTTON ||
           controlType == NS_FORM_INPUT_IMAGE ||
           controlType == NS_FORM_INPUT_SUBMIT ||
           controlType == NS_FORM_INPUT_RESET) {
@@ -464,33 +466,35 @@ static void CollectFromInputElement(JSCo
       entry->mValue.SetAsObject() = &jsval.toObject();
     } else {
       input->GetValue(value, CallerType::System);
       // In order to reduce XPath generation (which is slow), we only save data
       // for form fields that have been changed. (cf. bug 537289)
       // Also, don't want to collect credit card number.
       if (value.IsEmpty() || IsValidCCNumber(value) ||
           input->HasBeenTypePassword() ||
-          input->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value, eCaseMatters)) {
+          input->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value,
+                             eCaseMatters)) {
         continue;
       }
       if (!id.IsEmpty()) {
         // We want to avoid saving data for about:sessionrestore as a string.
         // Since it's stored in the form as stringified JSON, stringifying
         // further causes an explosion of escape characters. cf. bug 467409
         if (id.EqualsLiteral("sessionData")) {
           nsAutoCString url;
           Unused << aDocument.GetDocumentURI()->GetSpecIgnoringRef(url);
           if (url.EqualsLiteral("about:sessionrestore") ||
               url.EqualsLiteral("about:welcomeback")) {
             JS::Rooted<JS::Value> jsval(aCx);
             if (JS_ParseJSON(aCx, value.get(), value.Length(), &jsval) &&
                 jsval.isObject()) {
               Record<nsString, OwningStringOrBooleanOrLongOrObject>::EntryType*
-                  entry = AppendEntryToCollectedData(input, id, aGeneratedCount, aRetVal);
+                  entry = AppendEntryToCollectedData(input, id, aGeneratedCount,
+                                                     aRetVal);
               entry->mValue.SetAsObject() = &jsval.toObject();
             } else {
               JS_ClearPendingException(aCx);
             }
             continue;
           }
         }
       }
@@ -617,37 +621,41 @@ static void CollectFromXULTextbox(Docume
       }
       RefPtr<HTMLInputElement> input = HTMLInputElement::FromNode(
           nsFocusManager::GetRedirectedFocus(textboxs->Item(idx)));
       if (!input) {
         continue;
       }
       input->GetValue(value, CallerType::System);
       if (value.IsEmpty() ||
-          input->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value, eCaseMatters)) {
+          input->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value,
+                             eCaseMatters)) {
         continue;
       }
       uint16_t generatedCount = 0;
       Record<nsString, OwningStringOrBooleanOrLongOrObject>::EntryType* entry =
           AppendEntryToCollectedData(input, id, generatedCount, aRetVal);
       entry->mValue.SetAsString() = value;
       return;
     }
   }
 }
 
 /* static */ void SessionStoreUtils::CollectFormData(
-    const GlobalObject& aGlobal, Document& aDocument, CollectedFormData& aRetVal) {
+    const GlobalObject& aGlobal, Document& aDocument,
+    CollectedFormData& aRetVal) {
   uint16_t generatedCount = 0;
   /* textarea element */
   CollectFromTextAreaElement(aDocument, generatedCount, aRetVal);
   /* input element */
-  CollectFromInputElement(aGlobal.Context(), aDocument, generatedCount, aRetVal);
+  CollectFromInputElement(aGlobal.Context(), aDocument, generatedCount,
+                          aRetVal);
   /* select element */
-  CollectFromSelectElement(aGlobal.Context(), aDocument, generatedCount, aRetVal);
+  CollectFromSelectElement(aGlobal.Context(), aDocument, generatedCount,
+                           aRetVal);
   /* special case for about:config's search field */
   CollectFromXULTextbox(aDocument, aRetVal);
 
   Element* bodyElement = aDocument.GetBody();
   if (aDocument.HasFlag(NODE_IS_EDITABLE) && bodyElement) {
     bodyElement->GetInnerHTML(aRetVal.mInnerHTML.Construct(), IgnoreErrors());
   }
   if (!aRetVal.mId.WasPassed() && !aRetVal.mXpath.WasPassed() &&
--- a/toolkit/components/sessionstore/SessionStoreUtils.h
+++ b/toolkit/components/sessionstore/SessionStoreUtils.h
@@ -23,23 +23,23 @@ struct SSScrollPositionDict;
 class SessionStoreUtils {
  public:
   static void ForEachNonDynamicChildFrame(
       const GlobalObject& aGlobal, WindowProxyHolder& aWindow,
       SessionStoreUtilsFrameCallback& aCallback, ErrorResult& aRv);
 
   static already_AddRefed<nsISupports> AddDynamicFrameFilteredListener(
       const GlobalObject& aGlobal, EventTarget& aTarget, const nsAString& aType,
-      JS::Handle<JS::Value> aListener, bool aUseCapture,
-      bool aMozSystemGroup, ErrorResult& aRv);
+      JS::Handle<JS::Value> aListener, bool aUseCapture, bool aMozSystemGroup,
+      ErrorResult& aRv);
 
   static void RemoveDynamicFrameFilteredListener(
       const GlobalObject& aGlobal, EventTarget& aTarget, const nsAString& aType,
-      nsISupports* aListener, bool aUseCapture,
-      bool aMozSystemGroup, ErrorResult& aRv);
+      nsISupports* aListener, bool aUseCapture, bool aMozSystemGroup,
+      ErrorResult& aRv);
 
   static void CollectDocShellCapabilities(const GlobalObject& aGlobal,
                                           nsIDocShell* aDocShell,
                                           nsCString& aRetVal);
 
   static void RestoreDocShellCapabilities(
       const GlobalObject& aGlobal, nsIDocShell* aDocShell,
       const nsCString& aDisallowCapabilities);
--- a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
@@ -2170,18 +2170,18 @@ nsresult nsUrlClassifierDBService::Looku
   } else {
     nsCOMPtr<nsIPermissionManager> permissionManager =
         services::GetPermissionManager();
     if (NS_WARN_IF(!permissionManager)) {
       return NS_ERROR_FAILURE;
     }
 
     uint32_t perm;
-    rv = permissionManager->TestPermissionFromPrincipal(
-        aPrincipal, "safe-browsing", &perm);
+    rv = permissionManager->TestPermissionFromPrincipal(aPrincipal,
+                                                        "safe-browsing", &perm);
     NS_ENSURE_SUCCESS(rv, rv);
 
     bool clean = (perm == nsIPermissionManager::ALLOW_ACTION);
     *didLookup = !clean;
     if (clean) {
       return NS_OK;
     }
   }
--- a/toolkit/recordreplay/ipc/Channel.cpp
+++ b/toolkit/recordreplay/ipc/Channel.cpp
@@ -234,17 +234,17 @@ void Channel::PrintMessage(const char* a
   if (!SpewEnabled()) {
     return;
   }
   AutoEnsurePassThroughThreadEvents pt;
   nsCString data;
   switch (aMsg.mType) {
     case MessageType::HitExecutionPoint: {
       const HitExecutionPointMessage& nmsg =
-        (const HitExecutionPointMessage&)aMsg;
+          (const HitExecutionPointMessage&)aMsg;
       nmsg.mPoint.ToString(data);
       data.AppendPrintf(" Endpoint %d Duration %.2f ms",
                         nmsg.mRecordingEndpoint,
                         nmsg.mDurationMicroseconds / 1000.0);
       break;
     }
     case MessageType::Resume: {
       const ResumeMessage& nmsg = (const ResumeMessage&)aMsg;
--- a/toolkit/recordreplay/ipc/Channel.h
+++ b/toolkit/recordreplay/ipc/Channel.h
@@ -156,17 +156,20 @@ struct Message {
   uint32_t mSize;
 
  protected:
   Message(MessageType aType, uint32_t aSize) : mType(aType), mSize(aSize) {
     MOZ_RELEASE_ASSERT(mSize >= sizeof(*this));
   }
 
  public:
-  struct FreePolicy { void operator()(Message* msg) { /*free(msg);*/ } };
+  struct FreePolicy {
+    void operator()(Message* msg) { /*free(msg);*/
+    }
+  };
   typedef UniquePtr<Message, FreePolicy> UniquePtr;
 
   UniquePtr Clone() const {
     Message* res = static_cast<Message*>(malloc(mSize));
     memcpy(res, this, mSize);
     return UniquePtr(res);
   }
 
--- a/toolkit/recordreplay/ipc/ChildIPC.cpp
+++ b/toolkit/recordreplay/ipc/ChildIPC.cpp
@@ -60,17 +60,17 @@ static FileHandle gCheckpointReadFd;
 // receipt and then processed during InitRecordingOrReplayingProcess.
 static UniquePtr<IntroductionMessage, Message::FreePolicy> gIntroductionMessage;
 
 // When recording, whether developer tools server code runs in the middleman.
 static bool gDebuggerRunsInMiddleman;
 
 // Any response received to the last MiddlemanCallRequest message.
 static UniquePtr<MiddlemanCallResponseMessage, Message::FreePolicy>
-  gCallResponseMessage;
+    gCallResponseMessage;
 
 // Whether some thread has sent a MiddlemanCallRequest and is waiting for
 // gCallResponseMessage to be filled in.
 static bool gWaitingForCallResponse;
 
 // Processing routine for incoming channel messages.
 static void ChannelMessageHandler(Message::UniquePtr aMsg) {
   MOZ_RELEASE_ASSERT(MainThreadShouldPause() || aMsg->CanBeSentWhileUnpaused());
--- a/toolkit/recordreplay/ipc/ChildInternal.h
+++ b/toolkit/recordreplay/ipc/ChildInternal.h
@@ -82,17 +82,18 @@ void AfterCheckpoint(const CheckpointId&
 size_t LastNormalCheckpoint();
 
 }  // namespace navigation
 
 namespace child {
 
 // IPC activity that can be triggered by navigation.
 void RespondToRequest(const js::CharBuffer& aBuffer);
-void HitExecutionPoint(const js::ExecutionPoint& aPoint, bool aRecordingEndpoint);
+void HitExecutionPoint(const js::ExecutionPoint& aPoint,
+                       bool aRecordingEndpoint);
 
 // Optional information about a crash that occurred. If not provided to
 // ReportFatalError, the current thread will be treated as crashed.
 struct MinidumpInfo {
   int mExceptionType;
   int mCode;
   int mSubcode;
   mach_port_t mThread;
--- a/toolkit/recordreplay/ipc/ChildProcess.cpp
+++ b/toolkit/recordreplay/ipc/ChildProcess.cpp
@@ -60,23 +60,23 @@ void ChildProcessInfo::OnIncomingMessage
 
   switch (aMsg.mType) {
     case MessageType::BeginFatalError:
       mHasBegunFatalError = true;
       return;
     case MessageType::FatalError: {
       mHasFatalError = true;
       const FatalErrorMessage& nmsg =
-        static_cast<const FatalErrorMessage&>(aMsg);
+          static_cast<const FatalErrorMessage&>(aMsg);
       OnCrash(nmsg.Error());
       return;
     }
     case MessageType::HitExecutionPoint: {
       const HitExecutionPointMessage& nmsg =
-        static_cast<const HitExecutionPointMessage&>(aMsg);
+          static_cast<const HitExecutionPointMessage&>(aMsg);
       mPaused = true;
       if (this == GetActiveChild() && !nmsg.mPoint.HasPosition()) {
         MaybeUpdateGraphicsAtCheckpoint(nmsg.mPoint.mCheckpoint);
       }
       if (aForwardToControl) {
         js::ForwardHitExecutionPointMessage(GetId(), nmsg);
       }
       break;
@@ -88,17 +88,17 @@ void ChildProcessInfo::OnIncomingMessage
       mPaused = true;
       js::OnDebuggerResponse(aMsg);
       break;
     case MessageType::RecordingFlushed:
       mPaused = true;
       break;
     case MessageType::MiddlemanCallRequest: {
       const MiddlemanCallRequestMessage& nmsg =
-        static_cast<const MiddlemanCallRequestMessage&>(aMsg);
+          static_cast<const MiddlemanCallRequestMessage&>(aMsg);
       Message::UniquePtr response(ProcessMiddlemanCallMessage(nmsg));
       SendMessage(*response);
       break;
     }
     case MessageType::ResetMiddlemanCalls:
       ResetMiddlemanCalls();
       break;
     default:
@@ -158,20 +158,20 @@ void GetArgumentsForChildProcess(base::P
 void ChildProcessInfo::LaunchSubprocess(
     const Maybe<RecordingProcessData>& aRecordingProcessData) {
   size_t channelId = gNumChannels++;
 
   // Create a new channel every time we launch a new subprocess, without
   // deleting or tearing down the old one's state. This is pretty lame and it
   // would be nice if we could do something better here, especially because
   // with restarts we could create any number of channels over time.
-  mChannel = new Channel(channelId, IsRecording(),
-                         [=](Message::UniquePtr aMsg) {
-                           ReceiveChildMessageOnMainThread(std::move(aMsg));
-                         });
+  mChannel =
+      new Channel(channelId, IsRecording(), [=](Message::UniquePtr aMsg) {
+        ReceiveChildMessageOnMainThread(std::move(aMsg));
+      });
 
   MOZ_RELEASE_ASSERT(IsRecording() == aRecordingProcessData.isSome());
   if (IsRecording()) {
     std::vector<std::string> extraArgs;
     GetArgumentsForChildProcess(base::GetCurrentProcId(), channelId,
                                 gRecordingFilename, /* aRecording = */ true,
                                 extraArgs);
 
@@ -254,19 +254,17 @@ struct PendingMessage {
   PendingMessage() : mProcess(nullptr) {}
 
   PendingMessage& operator=(PendingMessage&& aOther) {
     mProcess = aOther.mProcess;
     mMsg = std::move(aOther.mMsg);
     return *this;
   }
 
-  PendingMessage(PendingMessage&& aOther) {
-    *this = std::move(aOther);
-  }
+  PendingMessage(PendingMessage&& aOther) { *this = std::move(aOther); }
 };
 static StaticInfallibleVector<PendingMessage> gPendingMessages;
 
 static Message::UniquePtr ExtractChildMessage(ChildProcessInfo** aProcess) {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 
   for (size_t i = 0; i < gPendingMessages.length(); i++) {
     PendingMessage& pending = gPendingMessages[i];
@@ -359,17 +357,18 @@ Message::UniquePtr ChildProcessInfo::Wai
       break;
     }
   }
 }
 
 // Execute a task that processes a message received from the child. This is
 // called on a channel thread, and the function executes asynchronously on
 // the main thread.
-void ChildProcessInfo::ReceiveChildMessageOnMainThread(Message::UniquePtr aMsg) {
+void ChildProcessInfo::ReceiveChildMessageOnMainThread(
+    Message::UniquePtr aMsg) {
   MOZ_RELEASE_ASSERT(!NS_IsMainThread());
 
   MonitorAutoLock lock(*gMonitor);
 
   PendingMessage pending;
   pending.mProcess = this;
   pending.mMsg = std::move(aMsg);
   gPendingMessages.append(std::move(pending));
--- a/toolkit/recordreplay/ipc/JSControl.cpp
+++ b/toolkit/recordreplay/ipc/JSControl.cpp
@@ -145,21 +145,19 @@ bool BreakpointPosition::Decode(JSContex
       !MaybeGetNumberProperty(aCx, aObject, gFrameIndexProperty,
                               &mFrameIndex)) {
     return false;
   }
 
   return true;
 }
 
-void
-BreakpointPosition::ToString(nsCString& aStr) const
-{
+void BreakpointPosition::ToString(nsCString& aStr) const {
   aStr.AppendPrintf("{ Kind: %s, Script: %d, Offset: %d, Frame: %d }",
-                    KindString(), (int) mScript, (int) mOffset, (int) mFrameIndex);
+                    KindString(), (int)mScript, (int)mOffset, (int)mFrameIndex);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ExecutionPoint Conversion
 ///////////////////////////////////////////////////////////////////////////////
 
 // Names of properties which JS code uses to specify the contents of an
 // ExecutionPoint.
@@ -173,19 +171,18 @@ JSObject* ExecutionPoint::Encode(JSConte
       !JS_DefineProperty(aCx, obj, gCheckpointProperty, (double)mCheckpoint,
                          JSPROP_ENUMERATE) ||
       !JS_DefineProperty(aCx, obj, gProgressProperty, (double)mProgress,
                          JSPROP_ENUMERATE)) {
     return nullptr;
   }
   if (HasPosition()) {
     RootedObject position(aCx, mPosition.Encode(aCx));
-    if (!position ||
-        !JS_DefineProperty(aCx, obj, gPositionProperty, position,
-                           JSPROP_ENUMERATE)) {
+    if (!position || !JS_DefineProperty(aCx, obj, gPositionProperty, position,
+                                        JSPROP_ENUMERATE)) {
       return nullptr;
     }
   }
   return obj;
 }
 
 bool ExecutionPoint::Decode(JSContext* aCx, HandleObject aObject) {
   RootedValue v(aCx);
@@ -200,20 +197,18 @@ bool ExecutionPoint::Decode(JSContext* a
     if (!positionObject || !mPosition.Decode(aCx, positionObject)) {
       return false;
     }
   }
   return GetNumberProperty(aCx, aObject, gCheckpointProperty, &mCheckpoint) &&
          GetNumberProperty(aCx, aObject, gProgressProperty, &mProgress);
 }
 
-void
-ExecutionPoint::ToString(nsCString& aStr) const
-{
-  aStr.AppendPrintf("{ Checkpoint %d", (int) mCheckpoint);
+void ExecutionPoint::ToString(nsCString& aStr) const {
+  aStr.AppendPrintf("{ Checkpoint %d", (int)mCheckpoint);
   if (HasPosition()) {
     aStr.AppendPrintf(" Progress %llu Position ", mProgress);
     mPosition.ToString(aStr);
   }
   aStr.AppendPrintf(" }");
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -224,20 +219,19 @@ static JSObject* EncodeChannelMessage(JS
                                       const HitExecutionPointMessage& aMsg) {
   RootedObject obj(aCx, JS_NewObject(aCx, nullptr));
   if (!obj) {
     return nullptr;
   }
 
   RootedObject pointObject(aCx, aMsg.mPoint.Encode(aCx));
   if (!pointObject ||
-      !JS_DefineProperty(aCx, obj, "point", pointObject,
+      !JS_DefineProperty(aCx, obj, "point", pointObject, JSPROP_ENUMERATE) ||
+      !JS_DefineProperty(aCx, obj, "recordingEndpoint", aMsg.mRecordingEndpoint,
                          JSPROP_ENUMERATE) ||
-      !JS_DefineProperty(aCx, obj, "recordingEndpoint",
-                         aMsg.mRecordingEndpoint, JSPROP_ENUMERATE) ||
       !JS_DefineProperty(aCx, obj, "duration",
                          aMsg.mDurationMicroseconds / 1000.0,
                          JSPROP_ENUMERATE)) {
     return nullptr;
   }
 
   return obj;
 }
@@ -247,17 +241,17 @@ static JSObject* EncodeChannelMessage(JS
 ///////////////////////////////////////////////////////////////////////////////
 
 static StaticRefPtr<rrIControl> gControl;
 
 void SetupMiddlemanControl(const Maybe<size_t>& aRecordingChildId) {
   MOZ_RELEASE_ASSERT(!gControl);
 
   nsCOMPtr<rrIControl> control =
-    do_ImportModule("resource://devtools/server/actors/replay/control.js");
+      do_ImportModule("resource://devtools/server/actors/replay/control.js");
   gControl = control.forget();
   ClearOnShutdown(&gControl);
 
   MOZ_RELEASE_ASSERT(gControl);
 
   AutoSafeJSContext cx;
   JSAutoRealm ar(cx, xpc::PrivilegedJunkScope());
 
@@ -265,17 +259,18 @@ void SetupMiddlemanControl(const Maybe<s
   if (aRecordingChildId.isSome()) {
     recordingChildValue.setInt32(aRecordingChildId.ref());
   }
   if (NS_FAILED(gControl->Initialize(recordingChildValue))) {
     MOZ_CRASH("SetupMiddlemanControl");
   }
 }
 
-void ForwardHitExecutionPointMessage(size_t aId, const HitExecutionPointMessage& aMsg) {
+void ForwardHitExecutionPointMessage(size_t aId,
+                                     const HitExecutionPointMessage& aMsg) {
   MOZ_RELEASE_ASSERT(gControl);
 
   AutoSafeJSContext cx;
   JSAutoRealm ar(cx, xpc::PrivilegedJunkScope());
 
   JSObject* obj = EncodeChannelMessage(cx, aMsg);
   MOZ_RELEASE_ASSERT(obj);
 
@@ -356,42 +351,42 @@ static bool Middleman_RegisterReplayDebu
 }
 
 static bool Middleman_CanRewind(JSContext* aCx, unsigned aArgc, Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
   args.rval().setBoolean(parent::CanRewind());
   return true;
 }
 
-static bool Middleman_SpawnReplayingChild(JSContext* aCx,
-                                          unsigned aArgc, Value* aVp) {
+static bool Middleman_SpawnReplayingChild(JSContext* aCx, unsigned aArgc,
+                                          Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   size_t id = parent::SpawnReplayingChild();
   args.rval().setInt32(id);
   return true;
 }
 
-static bool Middleman_SetActiveChild(JSContext* aCx,
-                                     unsigned aArgc, Value* aVp) {
+static bool Middleman_SetActiveChild(JSContext* aCx, unsigned aArgc,
+                                     Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   parent::SetActiveChild(child);
 
   args.rval().setUndefined();
   return true;
 }
 
-static bool Middleman_SendSetSaveCheckpoint(JSContext* aCx,
-                                            unsigned aArgc, Value* aVp) {
+static bool Middleman_SendSetSaveCheckpoint(JSContext* aCx, unsigned aArgc,
+                                            Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   double checkpoint;
@@ -402,18 +397,18 @@ static bool Middleman_SendSetSaveCheckpo
   bool shouldSave = ToBoolean(args.get(2));
 
   child->SendMessage(SetSaveCheckpointMessage(checkpoint, shouldSave));
 
   args.rval().setUndefined();
   return true;
 }
 
-static bool Middleman_SendFlushRecording(JSContext* aCx,
-                                         unsigned aArgc, Value* aVp) {
+static bool Middleman_SendFlushRecording(JSContext* aCx, unsigned aArgc,
+                                         Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   child->SendMessage(FlushRecordingMessage());
@@ -436,17 +431,18 @@ static bool Middleman_SendResume(JSConte
   bool forward = ToBoolean(args.get(1));
 
   child->SendMessage(ResumeMessage(forward));
 
   args.rval().setUndefined();
   return true;
 }
 
-static bool Middleman_SendRestoreCheckpoint(JSContext* aCx, unsigned aArgc, Value* aVp) {
+static bool Middleman_SendRestoreCheckpoint(JSContext* aCx, unsigned aArgc,
+                                            Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   double checkpoint;
@@ -455,17 +451,18 @@ static bool Middleman_SendRestoreCheckpo
   }
 
   child->SendMessage(RestoreCheckpointMessage(checkpoint));
 
   args.rval().setUndefined();
   return true;
 }
 
-static bool Middleman_SendRunToPoint(JSContext* aCx, unsigned aArgc, Value* aVp) {
+static bool Middleman_SendRunToPoint(JSContext* aCx, unsigned aArgc,
+                                     Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   RootedObject pointObject(aCx, NonNullObject(aCx, args.get(1)));
@@ -484,23 +481,23 @@ static bool Middleman_SendRunToPoint(JSC
   return true;
 }
 
 // Buffer for receiving the next debugger response.
 static js::CharBuffer* gResponseBuffer;
 
 void OnDebuggerResponse(const Message& aMsg) {
   const DebuggerResponseMessage& nmsg =
-    static_cast<const DebuggerResponseMessage&>(aMsg);
+      static_cast<const DebuggerResponseMessage&>(aMsg);
   MOZ_RELEASE_ASSERT(gResponseBuffer && gResponseBuffer->empty());
   gResponseBuffer->append(nmsg.Buffer(), nmsg.BufferSize());
 }
 
-static bool Middleman_SendDebuggerRequest(JSContext* aCx,
-                                          unsigned aArgc, Value* aVp) {
+static bool Middleman_SendDebuggerRequest(JSContext* aCx, unsigned aArgc,
+                                          Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   RootedObject requestObject(aCx, NonNullObject(aCx, args.get(1)));
@@ -514,33 +511,33 @@ static bool Middleman_SendDebuggerReques
     return false;
   }
 
   CharBuffer responseBuffer;
 
   MOZ_RELEASE_ASSERT(!gResponseBuffer);
   gResponseBuffer = &responseBuffer;
 
-  DebuggerRequestMessage* msg =
-    DebuggerRequestMessage::New(requestBuffer.begin(), requestBuffer.length());
+  DebuggerRequestMessage* msg = DebuggerRequestMessage::New(
+      requestBuffer.begin(), requestBuffer.length());
   child->SendMessage(*msg);
   free(msg);
 
   // Wait for the child to respond to the query.
   child->WaitUntilPaused();
   MOZ_RELEASE_ASSERT(gResponseBuffer == &responseBuffer);
   MOZ_RELEASE_ASSERT(gResponseBuffer->length() != 0);
   gResponseBuffer = nullptr;
 
   return JS_ParseJSON(aCx, responseBuffer.begin(), responseBuffer.length(),
                       args.rval());
 }
 
-static bool Middleman_SendAddBreakpoint(JSContext* aCx,
-                                        unsigned aArgc, Value* aVp) {
+static bool Middleman_SendAddBreakpoint(JSContext* aCx, unsigned aArgc,
+                                        Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   RootedObject positionObject(aCx, NonNullObject(aCx, args.get(1)));
@@ -554,18 +551,18 @@ static bool Middleman_SendAddBreakpoint(
   }
 
   child->SendMessage(AddBreakpointMessage(position));
 
   args.rval().setUndefined();
   return true;
 }
 
-static bool Middleman_SendClearBreakpoints(JSContext* aCx,
-                                           unsigned aArgc, Value* aVp) {
+static bool Middleman_SendClearBreakpoints(JSContext* aCx, unsigned aArgc,
+                                           Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::ChildProcessInfo* child = GetChildById(aCx, args.get(0));
   if (!child) {
     return false;
   }
 
   child->SendMessage(ClearBreakpointsMessage());
@@ -597,18 +594,18 @@ static bool Middleman_HadRepaintFailure(
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   parent::UpdateGraphicsInUIProcess(nullptr);
 
   args.rval().setUndefined();
   return true;
 }
 
-static bool Middleman_InRepaintStressMode(JSContext* aCx,
-                                          unsigned aArgc, Value* aVp) {
+static bool Middleman_InRepaintStressMode(JSContext* aCx, unsigned aArgc,
+                                          Value* aVp) {
   CallArgs args = CallArgsFromVp(aArgc, aVp);
 
   args.rval().setBoolean(parent::InRepaintStressMode());
   return true;
 }
 
 // Recording children can idle indefinitely while waiting for input, without
 // creating a checkpoint. If this might be a problem, this method induces the
@@ -636,17 +633,17 @@ static bool Middleman_WaitUntilPaused(JS
   Message::UniquePtr msg = child->WaitUntilPaused();
 
   if (!msg) {
     JS_ReportErrorASCII(aCx, "Child process is already paused");
   }
 
   MOZ_RELEASE_ASSERT(msg->mType == MessageType::HitExecutionPoint);
   const HitExecutionPointMessage& nmsg =
-    static_cast<const HitExecutionPointMessage&>(*msg);
+      static_cast<const HitExecutionPointMessage&>(*msg);
 
   JSObject* obj = EncodeChannelMessage(aCx, nmsg);
   if (!obj) {
     return false;
   }
 
   args.rval().setObject(*obj);
   return true;
--- a/toolkit/recordreplay/ipc/ParentIPC.cpp
+++ b/toolkit/recordreplay/ipc/ParentIPC.cpp
@@ -64,19 +64,17 @@ void Shutdown() {
   gReplayingChildren.clear();
   _exit(0);
 }
 
 bool IsMiddlemanWithRecordingChild() {
   return IsMiddleman() && gRecordingChild;
 }
 
-ChildProcessInfo* GetActiveChild() {
-  return gActiveChild;
-}
+ChildProcessInfo* GetActiveChild() { return gActiveChild; }
 
 ChildProcessInfo* GetChildProcess(size_t aId) {
   if (gRecordingChild && gRecordingChild->GetId() == aId) {
     return gRecordingChild;
   }
   for (const auto& child : gReplayingChildren) {
     if (child->GetId() == aId) {
       return child.get();
--- a/toolkit/recordreplay/ipc/ParentInternal.h
+++ b/toolkit/recordreplay/ipc/ParentInternal.h
@@ -146,17 +146,18 @@ class ChildProcessInfo {
   static void MaybeProcessPendingMessageRunnable();
   void ReceiveChildMessageOnMainThread(Message::UniquePtr aMsg);
 
   void OnCrash(const char* aWhy);
   void LaunchSubprocess(
       const Maybe<RecordingProcessData>& aRecordingProcessData);
 
  public:
-  explicit ChildProcessInfo(const Maybe<RecordingProcessData>& aRecordingProcessData);
+  explicit ChildProcessInfo(
+      const Maybe<RecordingProcessData>& aRecordingProcessData);
   ~ChildProcessInfo();
 
   size_t GetId() { return mChannel->GetId(); }
   bool IsRecording() { return mRecording; }
   bool IsPaused() { return mPaused; }
 
   void SendMessage(const Message& aMessage);
 
--- a/toolkit/xre/LauncherRegistryInfo.cpp
+++ b/toolkit/xre/LauncherRegistryInfo.cpp
@@ -255,17 +255,18 @@ std::wstring LauncherRegistryInfo::Resol
     mImageValueName.append(kImageTimestampSuffix,
                            ArrayLength(kImageTimestampSuffix) - 1);
   }
 
   return mImageValueName;
 }
 
 LauncherVoidResult LauncherRegistryInfo::WriteStartTimestamp(
-    LauncherRegistryInfo::ProcessType aProcessType, const Maybe<uint64_t>& aValue) {
+    LauncherRegistryInfo::ProcessType aProcessType,
+    const Maybe<uint64_t>& aValue) {
   LauncherResult<std::wstring> name = ResolveValueName(aProcessType);
   if (name.isErr()) {
     return LAUNCHER_ERROR_FROM_RESULT(name);
   }
 
   ULARGE_INTEGER timestamp;
   if (aValue.isSome()) {
     timestamp.QuadPart = aValue.value();
--- a/toolkit/xre/LauncherRegistryInfo.h
+++ b/toolkit/xre/LauncherRegistryInfo.h
@@ -39,18 +39,18 @@ class LauncherRegistryInfo final {
   LauncherResult<ProcessType> Check(const ProcessType aDesiredType);
   LauncherVoidResult DisableDueToFailure();
 
  private:
   enum class Disposition { CreatedNew, OpenedExisting };
 
  private:
   LauncherResult<Disposition> Open();
-  LauncherVoidResult WriteStartTimestamp(ProcessType aProcessType,
-                                         const Maybe<uint64_t>& aValue = Nothing());
+  LauncherVoidResult WriteStartTimestamp(
+      ProcessType aProcessType, const Maybe<uint64_t>& aValue = Nothing());
   LauncherResult<DWORD> GetCurrentImageTimestamp();
   LauncherVoidResult WriteImageTimestamp(DWORD aTimestamp);
   LauncherResult<bool> ClearStartTimestamp(ProcessType aProcessType);
   LauncherVoidResult ClearStartTimestamps();
   LauncherResult<DWORD> GetSavedImageTimestamp();
   LauncherResult<uint64_t> GetStartTimestamp(ProcessType aProcessType);
 
   LauncherResult<std::wstring> ResolveValueName(ProcessType aProcessType);
--- a/toolkit/xre/test/win/TestLauncherRegistryInfo.cpp
+++ b/toolkit/xre/test/win/TestLauncherRegistryInfo.cpp
@@ -669,19 +669,18 @@ int main(int argc, char* argv[]) {
   if (!myHeaders) {
     return 1;
   }
 
   if (!myHeaders.GetTimeStamp(gMyImageTimestamp)) {
     return 1;
   }
 
-  auto onExit = mozilla::MakeScopeExit([]() {
-    mozilla::Unused << DeleteAllTimestamps();
-  });
+  auto onExit = mozilla::MakeScopeExit(
+      []() { mozilla::Unused << DeleteAllTimestamps(); });
 
   VoidResult vr = mozilla::Ok();
 
   RUN_TEST(TestEmptyRegistry);
   RUN_TEST(TestNormal);
   RUN_TEST(TestBrowserNoLauncher);
   RUN_TEST(TestLauncherNoBrowser);
   RUN_TEST(TestBrowserLessThanLauncher);
--- a/widget/gtk/nsWindow.cpp
+++ b/widget/gtk/nsWindow.cpp
@@ -3226,24 +3226,24 @@ nsresult nsWindow::Create(nsIWidget *aPa
 
       bool useWebRender =
           gfx::gfxVars::UseWebRender() && AllowWebRenderForThisWindow();
 
       bool shouldAccelerate = ComputeShouldAccelerate();
       MOZ_ASSERT(shouldAccelerate | !useWebRender);
 
       // Some Gtk+ themes use non-rectangular toplevel windows. To fully support
-      // such themes we need to make toplevel window transparent with ARGB visual.
-      // It may cause performanance issue so make it configurable
-      // and enable it by default for selected window managers.
-      // Also disable it for X11 SW rendering (Bug 1516224) by default.
+      // such themes we need to make toplevel window transparent with ARGB
+      // visual. It may cause performanance issue so make it configurable and
+      // enable it by default for selected window managers. Also disable it for
+      // X11 SW rendering (Bug 1516224) by default.
       if (mWindowType == eWindowType_toplevel &&
           (shouldAccelerate || !mIsX11Display ||
-            Preferences::HasUserValue("mozilla.widget.use-argb-visuals"))) {
-          needsAlphaVisual = TopLevelWindowUseARGBVisual();
+           Preferences::HasUserValue("mozilla.widget.use-argb-visuals"))) {
+        needsAlphaVisual = TopLevelWindowUseARGBVisual();
       }
 
       bool isSetVisual = false;
       // If using WebRender on X11, we need to select a visual with a depth
       // buffer, as well as an alpha channel if transparency is requested. This
       // must be done before the widget is realized.
 
       // Use GL/WebRender compatible visual only when it is necessary, since
--- a/xpcom/build/XPCOMInit.cpp
+++ b/xpcom/build/XPCOMInit.cpp
@@ -296,24 +296,25 @@ const mozilla::Module::ContractIDEntry k
     {NS_SECURITY_CONSOLE_MESSAGE_CONTRACTID, &kNS_SECURITY_CONSOLE_MESSAGE_CID},
 #ifdef MOZ_WIDGET_COCOA
     {NS_MACPREFERENCESREADER_CONTRACTID, &kNS_MACPREFERENCESREADER_CID},
 #endif
     {nullptr}};
 #undef COMPONENT
 #undef COMPONENT_M
 
-const mozilla::Module kXPCOMModule = {mozilla::Module::kVersion,
-                                      kXPCOMCIDEntries,
-                                      kXPCOMContracts,
-                                      nullptr,
-                                      nullptr,
-                                      nullptr,
-                                      nullptr,
-                                      Module::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS};
+const mozilla::Module kXPCOMModule = {
+    mozilla::Module::kVersion,
+    kXPCOMCIDEntries,
+    kXPCOMContracts,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    Module::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS};
 
 // gDebug will be freed during shutdown.
 static nsIDebug2* gDebug = nullptr;
 
 EXPORT_XPCOM_API(nsresult)
 NS_GetDebug(nsIDebug2** aResult) {
   return nsDebugImpl::Create(nullptr, NS_GET_IID(nsIDebug2), (void**)aResult);
 }
--- a/xpcom/components/Module.h
+++ b/xpcom/components/Module.h
@@ -48,18 +48,20 @@ struct Module {
      * By default, modules are not loaded in the GPU process, even if
      * ANY_PROCESS is specified. This flag enables a module in the
      * GPU process.
      */
     ALLOW_IN_GPU_PROCESS = 0x4,
     ALLOW_IN_VR_PROCESS = 0x8,
     ALLOW_IN_SOCKET_PROCESS = 0x10,
     ALLOW_IN_GPU_AND_VR_PROCESS = ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS,
-    ALLOW_IN_GPU_AND_SOCKET_PROCESS = ALLOW_IN_GPU_PROCESS | ALLOW_IN_SOCKET_PROCESS,
-    ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS = ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS | ALLOW_IN_SOCKET_PROCESS
+    ALLOW_IN_GPU_AND_SOCKET_PROCESS =
+        ALLOW_IN_GPU_PROCESS | ALLOW_IN_SOCKET_PROCESS,
+    ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS =
+        ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS | ALLOW_IN_SOCKET_PROCESS
   };
 
   /**
    * The constructor callback is an implementation detail of the default binary
    * loader and may be null.
    */
   struct CIDEntry {
     const nsCID* cid;