Bug 1519636 - Reformat everything to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Wed, 16 Jan 2019 08:50:07 +0000
changeset 514053 d54846d01280026138135bde6e0bb1bcfe58feae
parent 514052 1e7c60e83b86e18d1c7918d2e4b2fd5d4d79fde2
child 514054 17f1c985c5bc0340dea8d5d3105a07c93b20d93c
push id1953
push userffxbld-merge
push dateMon, 11 Mar 2019 12:10:20 +0000
treeherdermozilla-release@9c35dcbaa899 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1519636
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 1519636 - Reformat everything to the Google coding style r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D16388
dom/base/Document.cpp
dom/base/Document.h
dom/base/DocumentInlines.h
dom/base/IdentifierMapEntry.h
dom/bindings/RemoteObjectProxy.h
dom/html/HTMLFormSubmission.cpp
dom/html/HTMLInputElement.h
dom/ipc/MemoryReportRequest.cpp
dom/media/MediaManager.cpp
dom/media/webrtc/MediaEngineWebRTCAudio.cpp
dom/power/PowerManagerService.cpp
dom/script/LoadedScript.cpp
dom/script/ScriptLoader.cpp
dom/smil/SMILKeySpline.h
dom/svg/SVGContentUtils.h
dom/svg/SVGIntegerPair.h
dom/svg/SVGNumberPair.h
dom/svg/SVGTests.cpp
dom/workers/WorkerDebugger.cpp
dom/xbl/nsXBLService.cpp
editor/libeditor/EditorUtils.cpp
editor/spellchecker/TextServicesDocument.cpp
editor/spellchecker/TextServicesDocument.h
gfx/gl/GLContextProviderEGL.cpp
gfx/layers/FrameMetrics.cpp
gfx/layers/LayersTypes.h
gfx/layers/apz/util/APZCCallbackHelper.cpp
gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
gfx/layers/ipc/LayersMessageUtils.h
gfx/layers/wr/ClipManager.cpp
gfx/layers/wr/RenderRootStateManager.cpp
gfx/layers/wr/RenderRootStateManager.h
gfx/layers/wr/WebRenderCommandBuilder.cpp
gfx/thebes/gfxFont.h
image/decoders/nsWebPDecoder.cpp
ipc/chromium/src/base/at_exit.cc
ipc/chromium/src/base/time_win.cc
ipc/chromium/src/chrome/common/ipc_channel_posix.cc
ipc/glue/CrashReporterHost.cpp
js/src/builtin/ModuleObject.cpp
js/src/frontend/NameFunctions.cpp
js/src/gc/GC.cpp
js/src/gc/Heap.h
js/src/gc/Marking.cpp
js/src/gc/Nursery.cpp
js/src/gc/Nursery.h
js/src/gc/Statistics.cpp
js/src/jit/CodeGenerator.cpp
js/src/jit/JitFrames.cpp
js/src/jit/arm64/Assembler-arm64.h
js/src/jit/arm64/MacroAssembler-arm64.cpp
js/src/jsapi.cpp
js/src/vm/Debugger.cpp
js/src/vm/Interpreter.cpp
js/src/vm/Interpreter.h
js/src/vm/JSScript-inl.h
js/src/vm/JSScript.cpp
js/src/vm/SavedStacks.cpp
js/src/wasm/AsmJS.cpp
js/src/wasm/WasmCompile.cpp
layout/build/nsLayoutModule.cpp
layout/generic/nsIFrame.h
layout/generic/nsImageFrame.cpp
layout/generic/nsTextFrame.cpp
layout/style/nsDOMCSSDeclaration.h
mobile/android/components/geckoview/GeckoViewHistory.h
netwerk/base/nsIOService.cpp
netwerk/ipc/SocketProcessHost.cpp
parser/htmlparser/nsParserModule.cpp
storage/mozStorageConnection.cpp
toolkit/components/reputationservice/ApplicationReputation.cpp
widget/gtk/IMContextWrapper.cpp
widget/windows/nsSound.cpp
xpcom/build/nsXULAppAPI.h
xpcom/threads/TimerThread.cpp
--- a/dom/base/Document.cpp
+++ b/dom/base/Document.cpp
@@ -8701,18 +8701,18 @@ void Document::ScrollToRef() {
           rv = shell->GoToAnchor(utf16Str, mChangeScrollPosWhenScrollingToRef);
         }
       }
 
       // If UTF-8 URI failed then try to assume the string as a
       // document's charset.
       if (NS_FAILED(rv)) {
         const Encoding* encoding = GetDocumentCharacterSet();
-        rv = encoding->DecodeWithoutBOMHandling(
-            unescaped ? buff : mScrollToRef, ref);
+        rv = encoding->DecodeWithoutBOMHandling(unescaped ? buff : mScrollToRef,
+                                                ref);
         if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
           rv = shell->GoToAnchor(ref, mChangeScrollPosWhenScrollingToRef);
         }
       }
     }
     if (NS_SUCCEEDED(rv)) {
       mScrolledToRefAlready = true;
     }
@@ -11691,17 +11691,17 @@ void Document::MaybeNotifyAutoplayBlocke
       CanBubble::eYes, ChromeOnlyDispatch::eYes);
   asyncDispatcher->PostDOMEvent();
 }
 
 void Document::ClearUserGestureActivation() {
   Document* doc = this;
   while (doc) {
     MOZ_LOG(gUserInteractionPRLog, LogLevel::Debug,
-          ("Reset user activation flag for document %p.", this));
+            ("Reset user activation flag for document %p.", this));
     doc->mUserGestureActivated = false;
     doc = doc->GetSameTypeParentDocument();
   }
 }
 
 void Document::SetDocTreeHadAudibleMedia() {
   Document* topLevelDoc = GetTopLevelContentDocument();
   if (!topLevelDoc) {
--- a/dom/base/Document.h
+++ b/dom/base/Document.h
@@ -440,17 +440,18 @@ class Document : public nsINode,
  protected:
   explicit Document(const char* aContentType);
   virtual ~Document();
 
   Document(const Document&) = delete;
   Document& operator=(const Document&) = delete;
 
  public:
-  typedef mozilla::dom::ExternalResourceMap::ExternalResourceLoad ExternalResourceLoad;
+  typedef mozilla::dom::ExternalResourceMap::ExternalResourceLoad
+      ExternalResourceLoad;
   typedef net::ReferrerPolicy ReferrerPolicyEnum;
 
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOCUMENT_IID)
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 
   NS_DECL_ADDSIZEOFEXCLUDINGTHIS
 
@@ -3091,17 +3092,19 @@ class Document : public nsINode,
                                                        JSObject* aObject);
   static bool AreWebAnimationsTimelinesEnabled(JSContext* aCx,
                                                JSObject* aObject);
   // Checks that the caller is either chrome or some addon.
   static bool IsCallerChromeOrAddon(JSContext* aCx, JSObject* aObject);
 
 #ifdef MOZILLA_INTERNAL_API
   bool Hidden() const { return mVisibilityState != VisibilityState::Visible; }
-  mozilla::dom::VisibilityState VisibilityState() const { return mVisibilityState; }
+  mozilla::dom::VisibilityState VisibilityState() const {
+    return mVisibilityState;
+  }
 #endif
   void GetSelectedStyleSheetSet(nsAString& aSheetSet);
   void SetSelectedStyleSheetSet(const nsAString& aSheetSet);
   void GetLastStyleSheetSet(nsAString& aSheetSet) {
     aSheetSet = mLastStyleSheetSet;
   }
   const nsString& GetCurrentStyleSheetSet() const {
     return mLastStyleSheetSet.IsEmpty() ? mPreferredStyleSheetSet
--- a/dom/base/DocumentInlines.h
+++ b/dom/base/DocumentInlines.h
@@ -14,18 +14,18 @@
 namespace mozilla {
 namespace dom {
 
 inline HTMLBodyElement* Document::GetBodyElement() {
   return static_cast<HTMLBodyElement*>(GetHtmlChildElement(nsGkAtoms::body));
 }
 
 template <typename T>
-size_t Document::FindDocStyleSheetInsertionPoint(
-    const nsTArray<T>& aDocSheets, const StyleSheet& aSheet) {
+size_t Document::FindDocStyleSheetInsertionPoint(const nsTArray<T>& aDocSheets,
+                                                 const StyleSheet& aSheet) {
   nsStyleSheetService* sheetService = nsStyleSheetService::GetInstance();
 
   // lowest index first
   int32_t newDocIndex = IndexOfSheet(aSheet);
 
   size_t count = aDocSheets.Length();
   size_t index = 0;
   for (; index < count; index++) {
--- a/dom/base/IdentifierMapEntry.h
+++ b/dom/base/IdentifierMapEntry.h
@@ -26,17 +26,17 @@
 class nsIContent;
 class nsContentList;
 class nsBaseContentList;
 
 namespace mozilla {
 namespace dom {
 class Document;
 class Element;
-}
+}  // namespace dom
 
 /**
  * Right now our identifier map entries contain information for 'name'
  * and 'id' mappings of a given string. This is so that
  * nsHTMLDocument::ResolveName only has to do one hash lookup instead
  * of two. It's not clear whether this still matters for performance.
  *
  * We also store the document.all result list here. This is mainly so that
--- a/dom/bindings/RemoteObjectProxy.h
+++ b/dom/bindings/RemoteObjectProxy.h
@@ -170,18 +170,18 @@ class RemoteObjectProxy : public RemoteO
                               const js::Class* aClasp) const {
     return RemoteObjectProxyBase::CreateProxyObject(aCx, aNative, aClasp);
   }
 
  protected:
   using RemoteObjectProxyBase::RemoteObjectProxyBase;
 
  private:
-  bool DefinePropertiesAndFunctions(
-      JSContext* aCx, JS::Handle<JSObject*> aHolder) const final {
+  bool DefinePropertiesAndFunctions(JSContext* aCx,
+                                    JS::Handle<JSObject*> aHolder) const final {
     return JS_DefineProperties(aCx, aHolder, P) &&
            JS_DefineFunctions(aCx, aHolder, F);
   }
 };
 
 /**
  * Returns true if aObj is a proxy object that represents an object implementing
  * the WebIDL interface for aProtoID.
--- a/dom/html/HTMLFormSubmission.cpp
+++ b/dom/html/HTMLFormSubmission.cpp
@@ -818,34 +818,34 @@ void GetEnumAttr(nsGenericHTMLElement* a
 
   nsresult rv;
 
   // Get action
   nsCOMPtr<nsIURI> actionURL;
   rv = aForm->GetActionURL(getter_AddRefs(actionURL), aOriginatingElement);
   NS_ENSURE_SUCCESS(rv, rv);
 
- // Check if CSP allows this form-action
- nsCOMPtr<nsIContentSecurityPolicy> csp;
- rv = aForm->NodePrincipal()->GetCsp(getter_AddRefs(csp));
- NS_ENSURE_SUCCESS(rv, rv);
- if (csp) {
-   bool permitsFormAction = true;
+  // Check if CSP allows this form-action
+  nsCOMPtr<nsIContentSecurityPolicy> csp;
+  rv = aForm->NodePrincipal()->GetCsp(getter_AddRefs(csp));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (csp) {
+    bool permitsFormAction = true;
 
-   // form-action is only enforced if explicitly defined in the
-   // policy - do *not* consult default-src, see:
-   // http://www.w3.org/TR/CSP2/#directive-default-src
-   rv = csp->Permits(aForm, nullptr /* nsICSPEventListener */, actionURL,
-                     nsIContentSecurityPolicy::FORM_ACTION_DIRECTIVE, true,
-                     &permitsFormAction);
-   NS_ENSURE_SUCCESS(rv, rv);
-   if (!permitsFormAction) {
-     return NS_ERROR_CSP_FORM_ACTION_VIOLATION;
-   }
- }
+    // form-action is only enforced if explicitly defined in the
+    // policy - do *not* consult default-src, see:
+    // http://www.w3.org/TR/CSP2/#directive-default-src
+    rv = csp->Permits(aForm, nullptr /* nsICSPEventListener */, actionURL,
+                      nsIContentSecurityPolicy::FORM_ACTION_DIRECTIVE, true,
+                      &permitsFormAction);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!permitsFormAction) {
+      return NS_ERROR_CSP_FORM_ACTION_VIOLATION;
+    }
+  }
 
   // Get target
   // The target is the originating element formtarget attribute if the element
   // is a submit control and has such an attribute.
   // Otherwise, the target is the form owner's target attribute,
   // if it has such an attribute.
   // Finally, if one of the child nodes of the head element is a base element
   // with a target attribute, then the value of the target attribute of the
--- a/dom/html/HTMLInputElement.h
+++ b/dom/html/HTMLInputElement.h
@@ -745,17 +745,18 @@ class HTMLInputElement final : public ns
    * The following functions are called from datetime picker to let input box
    * know the current state of the picker or to update the input box on changes.
    */
   void GetDateTimeInputBoxValue(DateTimeValue& aValue);
 
   /*
    * This locates the inner datetimebox UA Widget element and only the
    * UA Widget
-   * element. This should fold into GetDateTimeBoxElement() when the XBL binding is removed.
+   * element. This should fold into GetDateTimeBoxElement() when the XBL binding
+   * is removed.
    */
   Element* GetDateTimeBoxElementInUAWidget();
 
   /*
    * This allows chrome JavaScript to dispatch event to the inner datetimebox
    * anonymous or UA Widget element and access nsIDateTimeInputArea
    * implementation.
    */
--- a/dom/ipc/MemoryReportRequest.cpp
+++ b/dom/ipc/MemoryReportRequest.cpp
@@ -49,18 +49,18 @@ MemoryReportRequestHost::~MemoryReportRe
 NS_IMPL_ISUPPORTS(MemoryReportRequestClient, nsIRunnable)
 
 /* static */ void MemoryReportRequestClient::Start(
     uint32_t aGeneration, bool aAnonymize, bool aMinimizeMemoryUsage,
     const MaybeFileDesc& aDMDFile, const nsACString& aProcessString,
     const ReportCallback& aReportCallback,
     const FinishCallback& aFinishCallback) {
   RefPtr<MemoryReportRequestClient> request = new MemoryReportRequestClient(
-      aGeneration, aAnonymize, aDMDFile, aProcessString,
-      aReportCallback, aFinishCallback);
+      aGeneration, aAnonymize, aDMDFile, aProcessString, aReportCallback,
+      aFinishCallback);
 
   DebugOnly<nsresult> rv;
   if (aMinimizeMemoryUsage) {
     nsCOMPtr<nsIMemoryReporterManager> mgr =
         do_GetService("@mozilla.org/memory-reporter-manager;1");
     rv = mgr->MinimizeMemoryUsage(request);
     // mgr will eventually call actor->Run()
   } else {
@@ -122,18 +122,17 @@ NS_IMPL_ISUPPORTS(HandleReportCallback, 
 class FinishReportingCallback final : public nsIFinishReportingCallback {
  public:
   using FinishCallback = typename MemoryReportRequestClient::FinishCallback;
 
   NS_DECL_ISUPPORTS
 
   explicit FinishReportingCallback(uint32_t aGeneration,
                                    const FinishCallback& aFinishCallback)
-      : mGeneration(aGeneration),
-        mFinishCallback(aFinishCallback) {}
+      : mGeneration(aGeneration), mFinishCallback(aFinishCallback) {}
 
   NS_IMETHOD Callback(nsISupports* aUnused) override {
     return mFinishCallback(mGeneration) ? NS_OK : NS_ERROR_FAILURE;
   }
 
  private:
   ~FinishReportingCallback() = default;
 
--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -4175,64 +4175,64 @@ SourceListener::InitializeAsync() {
                                   __func__);
                    return;
                  }
                }
 
                LOG("started all sources");
                aHolder.Resolve(true, __func__);
              })
-      ->Then(GetMainThreadSerialEventTarget(), __func__,
-             [self = RefPtr<SourceListener>(this), this]() {
-               if (mStopped) {
-                 // We were shut down during the async init
-                 return SourceListenerPromise::CreateAndResolve(true, __func__);
-               }
-
-               for (DeviceState* state :
-                    {mAudioDeviceState.get(), mVideoDeviceState.get()}) {
-                 if (!state) {
-                   continue;
-                 }
-                 MOZ_DIAGNOSTIC_ASSERT(!state->mTrackEnabled);
-                 MOZ_DIAGNOSTIC_ASSERT(!state->mDeviceEnabled);
-                 MOZ_DIAGNOSTIC_ASSERT(!state->mStopped);
-
-                 state->mDeviceEnabled = true;
-                 state->mTrackEnabled = true;
-                 state->mTrackEnabledTime = TimeStamp::Now();
-
-                 if (state == mVideoDeviceState.get() &&
-                     !mStream->IsDestroyed()) {
-                   mStream->SetPullingEnabled(kVideoTrack, true);
-                 }
-               }
-               return SourceListenerPromise::CreateAndResolve(true, __func__);
-             },
-             [self = RefPtr<SourceListener>(this),
-              this](RefPtr<MediaMgrError>&& aResult) {
-               if (mStopped) {
-                 return SourceListenerPromise::CreateAndReject(
-                     std::move(aResult), __func__);
-               }
-
-               for (DeviceState* state :
-                    {mAudioDeviceState.get(), mVideoDeviceState.get()}) {
-                 if (!state) {
-                   continue;
-                 }
-                 MOZ_DIAGNOSTIC_ASSERT(!state->mTrackEnabled);
-                 MOZ_DIAGNOSTIC_ASSERT(!state->mDeviceEnabled);
-                 MOZ_DIAGNOSTIC_ASSERT(!state->mStopped);
-
-                 state->mStopped = true;
-               }
-               return SourceListenerPromise::CreateAndReject(std::move(aResult),
-                                                             __func__);
-             });
+      ->Then(
+          GetMainThreadSerialEventTarget(), __func__,
+          [self = RefPtr<SourceListener>(this), this]() {
+            if (mStopped) {
+              // We were shut down during the async init
+              return SourceListenerPromise::CreateAndResolve(true, __func__);
+            }
+
+            for (DeviceState* state :
+                 {mAudioDeviceState.get(), mVideoDeviceState.get()}) {
+              if (!state) {
+                continue;
+              }
+              MOZ_DIAGNOSTIC_ASSERT(!state->mTrackEnabled);
+              MOZ_DIAGNOSTIC_ASSERT(!state->mDeviceEnabled);
+              MOZ_DIAGNOSTIC_ASSERT(!state->mStopped);
+
+              state->mDeviceEnabled = true;
+              state->mTrackEnabled = true;
+              state->mTrackEnabledTime = TimeStamp::Now();
+
+              if (state == mVideoDeviceState.get() && !mStream->IsDestroyed()) {
+                mStream->SetPullingEnabled(kVideoTrack, true);
+              }
+            }
+            return SourceListenerPromise::CreateAndResolve(true, __func__);
+          },
+          [self = RefPtr<SourceListener>(this),
+           this](RefPtr<MediaMgrError>&& aResult) {
+            if (mStopped) {
+              return SourceListenerPromise::CreateAndReject(std::move(aResult),
+                                                            __func__);
+            }
+
+            for (DeviceState* state :
+                 {mAudioDeviceState.get(), mVideoDeviceState.get()}) {
+              if (!state) {
+                continue;
+              }
+              MOZ_DIAGNOSTIC_ASSERT(!state->mTrackEnabled);
+              MOZ_DIAGNOSTIC_ASSERT(!state->mDeviceEnabled);
+              MOZ_DIAGNOSTIC_ASSERT(!state->mStopped);
+
+              state->mStopped = true;
+            }
+            return SourceListenerPromise::CreateAndReject(std::move(aResult),
+                                                          __func__);
+          });
 }
 
 void SourceListener::Stop() {
   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread");
 
   if (mStopped) {
     return;
   }
--- a/dom/media/webrtc/MediaEngineWebRTCAudio.cpp
+++ b/dom/media/webrtc/MediaEngineWebRTCAudio.cpp
@@ -600,30 +600,29 @@ nsresult MediaEngineWebRTCMicrophoneSour
   MOZ_ASSERT(mStream, "SetTrack must have been called before ::Stop");
 
   if (mState == kStopped) {
     // Already stopped - this is allowed
     return NS_OK;
   }
 
   RefPtr<MediaEngineWebRTCMicrophoneSource> that = this;
-  NS_DispatchToMainThread(
-      media::NewRunnableFrom([that, stream = mStream]() {
-        if (stream->IsDestroyed()) {
-          return NS_OK;
-        }
+  NS_DispatchToMainThread(media::NewRunnableFrom([that, stream = mStream]() {
+    if (stream->IsDestroyed()) {
+      return NS_OK;
+    }
 
-        stream->GraphImpl()->AppendMessage(MakeUnique<StartStopMessage>(
-            that->mInputProcessing, StartStopMessage::Stop));
-        CubebUtils::AudioDeviceID deviceID = that->mDeviceInfo->DeviceID();
-        Maybe<CubebUtils::AudioDeviceID> id = Some(deviceID);
-        stream->CloseAudioInput(id, that->mInputProcessing);
+    stream->GraphImpl()->AppendMessage(MakeUnique<StartStopMessage>(
+        that->mInputProcessing, StartStopMessage::Stop));
+    CubebUtils::AudioDeviceID deviceID = that->mDeviceInfo->DeviceID();
+    Maybe<CubebUtils::AudioDeviceID> id = Some(deviceID);
+    stream->CloseAudioInput(id, that->mInputProcessing);
 
-        return NS_OK;
-      }));
+    return NS_OK;
+  }));
 
   MOZ_ASSERT(mState == kStarted, "Should be started when stopping");
   mState = kStopped;
 
   return NS_OK;
 }
 
 void MediaEngineWebRTCMicrophoneSource::GetSettings(
--- a/dom/power/PowerManagerService.cpp
+++ b/dom/power/PowerManagerService.cpp
@@ -147,18 +147,19 @@ already_AddRefed<WakeLock> PowerManagerS
 }
 
 }  // namespace power
 }  // namespace dom
 }  // namespace mozilla
 
 NS_DEFINE_NAMED_CID(NS_POWERMANAGERSERVICE_CID);
 
-NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIPowerManagerService,
-                                         mozilla::dom::power::PowerManagerService::GetInstance)
+NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(
+    nsIPowerManagerService,
+    mozilla::dom::power::PowerManagerService::GetInstance)
 
 static const mozilla::Module::CIDEntry kPowerManagerCIDs[] = {
     // clang-format off
   { &kNS_POWERMANAGERSERVICE_CID, false, nullptr, nsIPowerManagerServiceConstructor, mozilla::Module::ALLOW_IN_GPU_PROCESS },
   { nullptr }
     // clang-format on
 };
 
@@ -166,18 +167,19 @@ static const mozilla::Module::ContractID
     // clang-format off
   { POWERMANAGERSERVICE_CONTRACTID, &kNS_POWERMANAGERSERVICE_CID, mozilla::Module::ALLOW_IN_GPU_PROCESS },
   { nullptr }
     // clang-format on
 };
 
 // We mark the power module as being available in the GPU process because the
 // appshell depends on the power manager service.
-static const mozilla::Module kPowerManagerModule = {mozilla::Module::kVersion,
-                                                    kPowerManagerCIDs,
-                                                    kPowerManagerContracts,
-                                                    nullptr,
-                                                    nullptr,
-                                                    nullptr,
-                                                    nullptr,
-                                                    mozilla::Module::ALLOW_IN_GPU_PROCESS};
+static const mozilla::Module kPowerManagerModule = {
+    mozilla::Module::kVersion,
+    kPowerManagerCIDs,
+    kPowerManagerContracts,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    mozilla::Module::ALLOW_IN_GPU_PROCESS};
 
 NSMODULE_DEFN(nsPowerManagerModule) = &kPowerManagerModule;
--- a/dom/script/LoadedScript.cpp
+++ b/dom/script/LoadedScript.cpp
@@ -35,19 +35,17 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(LoadedScript)
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(LoadedScript)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(LoadedScript)
 
 LoadedScript::LoadedScript(ScriptKind aKind, ScriptFetchOptions* aFetchOptions,
                            nsIURI* aBaseURL)
-    : mKind(aKind),
-      mFetchOptions(aFetchOptions),
-      mBaseURL(aBaseURL) {
+    : mKind(aKind), mFetchOptions(aFetchOptions), mBaseURL(aBaseURL) {
   MOZ_ASSERT(mFetchOptions);
   MOZ_ASSERT(mBaseURL);
 }
 
 LoadedScript::~LoadedScript() { DropJSObjects(this); }
 
 void LoadedScript::AssociateWithScript(JSScript* aScript) {
   // Set a JSScript's private value to point to this object and
--- a/dom/script/ScriptLoader.cpp
+++ b/dom/script/ScriptLoader.cpp
@@ -2296,19 +2296,18 @@ nsresult ScriptLoader::FillCompileOption
   }
 
   if (mDocument) {
     mDocument->NoteScriptTrackingStatus(aRequest->mURL, aRequest->IsTracking());
   }
 
   bool isScriptElement =
       !aRequest->IsModuleRequest() || aRequest->AsModuleRequest()->IsTopLevel();
-  aOptions->setIntroductionInfoToCaller(jsapi.cx(),
-                                        isScriptElement ? "scriptElement"
-                                                        : "importedModule");
+  aOptions->setIntroductionInfoToCaller(
+      jsapi.cx(), isScriptElement ? "scriptElement" : "importedModule");
   aOptions->setFileAndLine(aRequest->mURL.get(), aRequest->mLineNo);
   aOptions->setIsRunOnce(true);
   aOptions->setNoScriptRval(true);
   if (aRequest->mHasSourceMapURL) {
     aOptions->setSourceMapURL(aRequest->mSourceMapURL.get());
   }
   if (aRequest->mOriginPrincipal) {
     nsIPrincipal* scriptPrin = nsContentUtils::ObjectPrincipal(aScopeChain);
--- a/dom/smil/SMILKeySpline.h
+++ b/dom/smil/SMILKeySpline.h
@@ -22,20 +22,20 @@ class SMILKeySpline {
   }
 
     /**
      * Creates a new key spline control point description.
      *
      * aX1, etc. are the x1, y1, x2, y2 cubic Bezier control points as defined
      * by SMILANIM 3.2.3. They must each be in the range 0.0 <= x <= 1.0
      */
-  SMILKeySpline(double aX1, double aY1, double aX2, double aY2)
-      : mX1(0), mY1(0), mX2(0), mY2(0) {
-    Init(aX1, aY1, aX2, aY2);
-  }
+    SMILKeySpline(double aX1, double aY1, double aX2, double aY2)
+        : mX1(0), mY1(0), mX2(0), mY2(0) {
+      Init(aX1, aY1, aX2, aY2);
+    }
 
     double X1() const { return mX1; }
     double Y1() const { return mY1; }
     double X2() const { return mX2; }
     double Y2() const { return mY2; }
 
     void Init(double aX1, double aY1, double aX2, double aY2);
 
--- a/dom/svg/SVGContentUtils.h
+++ b/dom/svg/SVGContentUtils.h
@@ -186,18 +186,17 @@ class SVGContentUtils {
    */
   static float GetFontXHeight(mozilla::dom::Element* aElement);
   static float GetFontXHeight(nsIFrame* aFrame);
   static float GetFontXHeight(ComputedStyle*, nsPresContext*);
 
   /*
    * Report a localized error message to the error console.
    */
-  static nsresult ReportToConsole(dom::Document* doc,
-                                  const char* aWarning,
+  static nsresult ReportToConsole(dom::Document* doc, const char* aWarning,
                                   const char16_t** aParams,
                                   uint32_t aParamsLength);
 
   static Matrix GetCTM(dom::SVGElement* aElement, bool aScreenCTM);
 
   /**
    * Gets the tight bounds-space stroke bounds of the non-scaling-stroked rect
    * aRect.
--- a/dom/svg/SVGIntegerPair.h
+++ b/dom/svg/SVGIntegerPair.h
@@ -72,18 +72,18 @@ class SVGIntegerPair {
   struct DOMAnimatedInteger final : public mozilla::dom::SVGAnimatedInteger {
     DOMAnimatedInteger(SVGIntegerPair* aVal, PairIndex aIndex,
                        SVGElement* aSVGElement)
         : mozilla::dom::SVGAnimatedInteger(aSVGElement),
           mVal(aVal),
           mIndex(aIndex) {}
     virtual ~DOMAnimatedInteger();
 
-    SVGIntegerPair* mVal;    // kept alive because it belongs to content
-    PairIndex mIndex;        // are we the first or second integer
+    SVGIntegerPair* mVal;  // kept alive because it belongs to content
+    PairIndex mIndex;      // are we the first or second integer
 
     virtual int32_t BaseVal() override { return mVal->GetBaseValue(mIndex); }
     virtual void SetBaseVal(int32_t aValue) override {
       mVal->SetBaseValue(aValue, mIndex, mSVGElement);
     }
 
     // Script may have modified animation parameters or timeline -- DOM getters
     // need to flush any resample requests to reflect these modifications.
--- a/dom/svg/SVGNumberPair.h
+++ b/dom/svg/SVGNumberPair.h
@@ -73,18 +73,18 @@ class SVGNumberPair {
   struct DOMAnimatedNumber final : public mozilla::dom::SVGAnimatedNumber {
     DOMAnimatedNumber(SVGNumberPair* aVal, PairIndex aIndex,
                       SVGElement* aSVGElement)
         : mozilla::dom::SVGAnimatedNumber(aSVGElement),
           mVal(aVal),
           mIndex(aIndex) {}
     virtual ~DOMAnimatedNumber();
 
-    SVGNumberPair* mVal;    // kept alive because it belongs to content
-    PairIndex mIndex;       // are we the first or second number
+    SVGNumberPair* mVal;  // kept alive because it belongs to content
+    PairIndex mIndex;     // are we the first or second number
 
     virtual float BaseVal() override { return mVal->GetBaseValue(mIndex); }
     virtual void SetBaseVal(float aValue) override {
       MOZ_ASSERT(mozilla::IsFinite(aValue));
       mVal->SetBaseValue(aValue, mIndex, mSVGElement);
     }
 
     // Script may have modified animation parameters or timeline -- DOM getters
--- a/dom/svg/SVGTests.cpp
+++ b/dom/svg/SVGTests.cpp
@@ -41,17 +41,18 @@ already_AddRefed<DOMSVGStringList> SVGTe
                                          AsSVGElement(), true, LANGUAGE);
 }
 
 bool SVGTests::HasExtension(const nsAString& aExtension) const {
 #define SVG_SUPPORTED_EXTENSION(str) \
   if (aExtension.EqualsLiteral(str)) return true;
   SVG_SUPPORTED_EXTENSION("http://www.w3.org/1999/xhtml")
   nsNameSpaceManager* nameSpaceManager = nsNameSpaceManager::GetInstance();
-  if (AsSVGElement()->IsInChromeDocument() || !nameSpaceManager->mMathMLDisabled) {
+  if (AsSVGElement()->IsInChromeDocument() ||
+      !nameSpaceManager->mMathMLDisabled) {
     SVG_SUPPORTED_EXTENSION("http://www.w3.org/1998/Math/MathML")
   }
 #undef SVG_SUPPORTED_EXTENSION
 
   return false;
 }
 
 bool SVGTests::IsConditionalProcessingAttribute(
--- a/dom/workers/WorkerDebugger.cpp
+++ b/dom/workers/WorkerDebugger.cpp
@@ -455,18 +455,17 @@ RefPtr<PerformanceInfoPromise> WorkerDeb
       }
     }
   }
 
   // getting the worker URL
   RefPtr<nsIURI> scriptURI = mWorkerPrivate->GetResolvedScriptURI();
   if (NS_WARN_IF(!scriptURI)) {
     // This can happen at shutdown, let's stop here.
-    return PerformanceInfoPromise::CreateAndReject(NS_ERROR_FAILURE,
-                                                   __func__);
+    return PerformanceInfoPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
   }
   nsCString url = scriptURI->GetSpecOrDefault();
 
   // Workers only produce metrics for a single category -
   // DispatchCategory::Worker. We still return an array of CategoryDispatch so
   // the PerformanceInfo struct is common to all performance counters throughout
   // Firefox.
   FallibleTArray<CategoryDispatch> items;
--- a/dom/xbl/nsXBLService.cpp
+++ b/dom/xbl/nsXBLService.cpp
@@ -147,18 +147,18 @@ class nsXBLStreamListener final : public
 
  private:
   ~nsXBLStreamListener();
 
   nsCOMPtr<nsIStreamListener> mInner;
   AutoTArray<nsXBLBindingRequest*, 8> mBindingRequests;
 
   nsWeakPtr mBoundDocument;
-  nsCOMPtr<nsIXMLContentSink> mSink;       // Only set until OnStartRequest
-  nsCOMPtr<Document> mBindingDocument;     // Only set until OnStartRequest
+  nsCOMPtr<nsIXMLContentSink> mSink;    // Only set until OnStartRequest
+  nsCOMPtr<Document> mBindingDocument;  // Only set until OnStartRequest
 };
 
 /* Implementation file */
 NS_IMPL_ISUPPORTS(nsXBLStreamListener, nsIStreamListener, nsIRequestObserver,
                   nsIDOMEventListener)
 
 nsXBLStreamListener::nsXBLStreamListener(Document* aBoundDocument,
                                          nsIXMLContentSink* aSink,
--- a/editor/libeditor/EditorUtils.cpp
+++ b/editor/libeditor/EditorUtils.cpp
@@ -30,19 +30,17 @@ using namespace dom;
 
 DOMIterator::DOMIterator(nsINode& aNode MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
     : mIter(&mPostOrderIter) {
   MOZ_GUARD_OBJECT_NOTIFIER_INIT;
   DebugOnly<nsresult> rv = mIter->Init(&aNode);
   MOZ_ASSERT(NS_SUCCEEDED(rv));
 }
 
-nsresult DOMIterator::Init(nsRange& aRange) {
-  return mIter->Init(&aRange);
-}
+nsresult DOMIterator::Init(nsRange& aRange) { return mIter->Init(&aRange); }
 
 DOMIterator::DOMIterator(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL)
     : mIter(&mPostOrderIter) {
   MOZ_GUARD_OBJECT_NOTIFIER_INIT;
 }
 
 void DOMIterator::AppendList(
     const BoolDomIterFunctor& functor,
--- a/editor/spellchecker/TextServicesDocument.cpp
+++ b/editor/spellchecker/TextServicesDocument.cpp
@@ -1,41 +1,41 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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 "TextServicesDocument.h"
 
 #include "FilteredContentIterator.h"  // for FilteredContentIterator
-#include "mozilla/Assertions.h"   // for MOZ_ASSERT, etc
-#include "mozilla/EditorUtils.h"  // for AutoTransactionBatchExternal
+#include "mozilla/Assertions.h"       // for MOZ_ASSERT, etc
+#include "mozilla/EditorUtils.h"      // for AutoTransactionBatchExternal
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Selection.h"
 #include "mozilla/mozalloc.h"    // for operator new, etc
 #include "mozilla/TextEditor.h"  // for TextEditor
 #include "nsAString.h"           // for nsAString::Length, etc
 #include "nsContentUtils.h"      // for nsContentUtils
 #include "nsComposeTxtSrvFilter.h"
-#include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc
-#include "nsDependentSubstring.h"       // for Substring
-#include "nsError.h"                    // for NS_OK, NS_ERROR_FAILURE, etc
-#include "nsGenericHTMLElement.h"       // for nsGenericHTMLElement
-#include "nsIContent.h"                 // for nsIContent, etc
-#include "nsID.h"                       // for NS_GET_IID
-#include "nsIEditor.h"                  // for nsIEditor, etc
-#include "nsINode.h"                    // for nsINode
-#include "nsISelectionController.h"     // for nsISelectionController, etc
-#include "nsISupportsBase.h"            // for nsISupports
-#include "nsISupportsUtils.h"           // for NS_IF_ADDREF, NS_ADDREF, etc
-#include "mozilla/intl/WordBreaker.h"   // for WordRange, WordBreaker
-#include "nsRange.h"                    // for nsRange
-#include "nsString.h"                   // for nsString, nsAutoString
-#include "nscore.h"                     // for nsresult, NS_IMETHODIMP, etc
-#include "mozilla/UniquePtr.h"          // for UniquePtr
+#include "nsDebug.h"                   // for NS_ENSURE_TRUE, etc
+#include "nsDependentSubstring.h"      // for Substring
+#include "nsError.h"                   // for NS_OK, NS_ERROR_FAILURE, etc
+#include "nsGenericHTMLElement.h"      // for nsGenericHTMLElement
+#include "nsIContent.h"                // for nsIContent, etc
+#include "nsID.h"                      // for NS_GET_IID
+#include "nsIEditor.h"                 // for nsIEditor, etc
+#include "nsINode.h"                   // for nsINode
+#include "nsISelectionController.h"    // for nsISelectionController, etc
+#include "nsISupportsBase.h"           // for nsISupports
+#include "nsISupportsUtils.h"          // for NS_IF_ADDREF, NS_ADDREF, etc
+#include "mozilla/intl/WordBreaker.h"  // for WordRange, WordBreaker
+#include "nsRange.h"                   // for nsRange
+#include "nsString.h"                  // for nsString, nsAutoString
+#include "nscore.h"                    // for nsresult, NS_IMETHODIMP, etc
+#include "mozilla/UniquePtr.h"         // for UniquePtr
 
 namespace mozilla {
 
 using namespace dom;
 
 class OffsetEntry final {
  public:
   OffsetEntry(nsINode* aNode, int32_t aOffset, int32_t aLength)
--- a/editor/spellchecker/TextServicesDocument.h
+++ b/editor/spellchecker/TextServicesDocument.h
@@ -24,17 +24,17 @@ namespace mozilla {
 
 class FilteredContentIterator;
 class OffsetEntry;
 class TextEditor;
 
 namespace dom {
 class Document;
 class Element;
-};
+};  // namespace dom
 
 /**
  * The TextServicesDocument presents the document in as a bunch of flattened
  * text blocks. Each text block can be retrieved as an nsString.
  */
 class TextServicesDocument final : public nsIEditActionListener {
  private:
   enum class IteratorStatus : uint8_t {
--- a/gfx/gl/GLContextProviderEGL.cpp
+++ b/gfx/gl/GLContextProviderEGL.cpp
@@ -305,18 +305,17 @@ GLContextEGL::GLContextEGL(CreateContext
       mFallbackSurface(CreateFallbackSurface(config)),
       mContext(context) {
 #ifdef DEBUG
   printf_stderr("Initializing context %p surface %p on display %p\n", mContext,
                 mSurface, EGL_DISPLAY());
 #endif
 }
 
-void
-GLContextEGL::OnMarkDestroyed() {
+void GLContextEGL::OnMarkDestroyed() {
   if (mSurfaceOverride != EGL_NO_SURFACE) {
     SetEGLSurfaceOverride(EGL_NO_SURFACE);
   }
 }
 
 GLContextEGL::~GLContextEGL() {
   MarkDestroyed();
 
--- a/gfx/layers/FrameMetrics.cpp
+++ b/gfx/layers/FrameMetrics.cpp
@@ -12,17 +12,18 @@ namespace mozilla {
 namespace layers {
 
 const ScrollableLayerGuid::ViewID ScrollableLayerGuid::NULL_SCROLL_ID = 0;
 
 void FrameMetrics::RecalculateLayoutViewportOffset() {
   if (!mIsRootContent) {
     return;
   }
-  KeepLayoutViewportEnclosingVisualViewport(GetVisualViewport(), mLayoutViewport);
+  KeepLayoutViewportEnclosingVisualViewport(GetVisualViewport(),
+                                            mLayoutViewport);
 }
 
 /* static */ void FrameMetrics::KeepLayoutViewportEnclosingVisualViewport(
     const CSSRect& aVisualViewport, CSSRect& aLayoutViewport) {
   // If the visual viewport is contained within the layout viewport, we don't
   // need to make any adjustments, so we can exit early.
   //
   // Additionally, if the composition bounds changes (due to an orientation
--- a/gfx/layers/LayersTypes.h
+++ b/gfx/layers/LayersTypes.h
@@ -8,17 +8,17 @@
 #define GFX_LAYERSTYPES_H
 
 #include <stdint.h>  // for uint32_t
 
 #include "Units.h"
 #include "mozilla/DefineEnum.h"  // for MOZ_DEFINE_ENUM
 #include "mozilla/gfx/Point.h"   // for IntPoint
 #include "mozilla/Maybe.h"
-#include "mozilla/TimeStamp.h"   // for TimeStamp
+#include "mozilla/TimeStamp.h"  // for TimeStamp
 #include "mozilla/TypedEnumBits.h"
 #include "nsRegion.h"
 #include "nsStyleConsts.h"
 
 #include <stdio.h>            // FILE
 #include "mozilla/Logging.h"  // for PR_LOG
 
 #ifndef MOZ_LAYERS_HAVE_LOG
@@ -415,17 +415,17 @@ MOZ_DEFINE_ENUM_CLASS_WITH_BASE(ScrollDi
 MOZ_DEFINE_ENUM_CLASS_WITH_BASE(CompositionPayloadType, uint8_t, (
   eKeyPress,
   eAPZScroll,
   eAPZPinchZoom
 ));
 // clang-format on
 
 struct CompositionPayload {
-  bool operator ==(const CompositionPayload& aOther) const {
+  bool operator==(const CompositionPayload& aOther) const {
     return mType == aOther.mType && mTimeStamp == aOther.mTimeStamp;
   }
   /* The type of payload that is in this composition */
   CompositionPayloadType mType;
   /* When this payload was generated */
   TimeStamp mTimeStamp;
 };
 
--- a/gfx/layers/apz/util/APZCCallbackHelper.cpp
+++ b/gfx/layers/apz/util/APZCCallbackHelper.cpp
@@ -200,17 +200,18 @@ static ScreenMargin ScrollFrame(nsIConte
       }
     } else {
       // Correct the display port due to the difference between mScrollOffset
       // and the actual scroll offset.
       displayPortMargins = APZCCallbackHelper::AdjustDisplayPortForScrollDelta(
           aRequest, actualScrollOffset);
     }
   } else if (aRequest.IsRootContent() &&
-             aRequest.GetScrollOffset() != aRequest.GetLayoutViewport().TopLeft()) {
+             aRequest.GetScrollOffset() !=
+                 aRequest.GetLayoutViewport().TopLeft()) {
     // APZ uses the visual viewport's offset to calculate where to place the
     // display port, so the display port is misplaced when a pinch zoom occurs.
     //
     // We need to force a display port adjustment in the following paint to
     // account for a difference between mScrollOffset and the actual scroll
     // offset in repaints requested by
     // AsyncPanZoomController::NotifyLayersUpdated.
     displayPortMargins = APZCCallbackHelper::AdjustDisplayPortForScrollDelta(
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
@@ -165,18 +165,19 @@ class CrossProcessCompositorBridgeParent
       const LayersId& aLayersId) override;
   bool DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor) override;
 
   PAPZParent* AllocPAPZParent(const LayersId& aLayersId) override;
   bool DeallocPAPZParent(PAPZParent* aActor) override;
 
   void UpdatePaintTime(LayerTransactionParent* aLayerTree,
                        const TimeDuration& aPaintTime) override;
-  void RegisterPayload(LayerTransactionParent* aLayerTree,
-                       const InfallibleTArray<CompositionPayload>& aPayload) override;
+  void RegisterPayload(
+      LayerTransactionParent* aLayerTree,
+      const InfallibleTArray<CompositionPayload>& aPayload) override;
 
   PWebRenderBridgeParent* AllocPWebRenderBridgeParent(
       const wr::PipelineId& aPipelineId,
       const LayoutDeviceIntSize& aSize) override;
   bool DeallocPWebRenderBridgeParent(PWebRenderBridgeParent* aActor) override;
 
   void ObserveLayersUpdate(LayersId aLayersId, LayersObserverEpoch aEpoch,
                            bool aActive) override;
--- a/gfx/layers/ipc/LayersMessageUtils.h
+++ b/gfx/layers/ipc/LayersMessageUtils.h
@@ -705,35 +705,35 @@ struct ParamTraits<mozilla::layers::Comp
 
 template <>
 struct ParamTraits<mozilla::layers::SimpleLayerAttributes>
     : public PlainOldDataSerializer<mozilla::layers::SimpleLayerAttributes> {};
 
 template <>
 struct ParamTraits<mozilla::layers::ScrollUpdateInfo>
     : public PlainOldDataSerializer<mozilla::layers::ScrollUpdateInfo> {};
- 
+
 template <>
 struct ParamTraits<mozilla::layers::CompositionPayloadType>
     : public ContiguousEnumSerializerInclusive<
           mozilla::layers::CompositionPayloadType,
           mozilla::layers::CompositionPayloadType::eKeyPress,
           mozilla::layers::kHighestCompositionPayloadType> {};
 
 template <>
-struct ParamTraits<mozilla::layers::CompositionPayload>
-{
+struct ParamTraits<mozilla::layers::CompositionPayload> {
   typedef mozilla::layers::CompositionPayload paramType;
 
   static void Write(Message* aMsg, const paramType& aParam) {
     WriteParam(aMsg, aParam.mType);
     WriteParam(aMsg, aParam.mTimeStamp);
   }
 
-  static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult) {
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
     return ReadParam(aMsg, aIter, &aResult->mType) &&
            ReadParam(aMsg, aIter, &aResult->mTimeStamp);
   }
 };
 
 } /* namespace IPC */
 
 #endif /* mozilla_layers_LayersMessageUtils */
--- a/gfx/layers/wr/ClipManager.cpp
+++ b/gfx/layers/wr/ClipManager.cpp
@@ -15,17 +15,19 @@
 #include "nsDisplayList.h"
 #include "nsStyleStructInlines.h"
 #include "UnitTransforms.h"
 
 #define CLIP_LOG(...)
 
 //#define CLIP_LOG(...) printf_stderr("CLIP: " __VA_ARGS__)
 
+// clang-format off
 //#define CLIP_LOG(...) if (XRE_IsContentProcess()) printf_stderr("CLIP: " __VA_ARGS__)
+// clang-format on
 
 namespace mozilla {
 namespace layers {
 
 ClipManager::ClipManager() : mManager(nullptr), mBuilder(nullptr) {}
 
 void ClipManager::BeginBuild(WebRenderLayerManager* aManager,
                              wr::DisplayListBuilder& aBuilder) {
--- a/gfx/layers/wr/RenderRootStateManager.cpp
+++ b/gfx/layers/wr/RenderRootStateManager.cpp
@@ -6,210 +6,165 @@
 
 #include "mozilla/layers/RenderRootStateManager.h"
 
 #include "mozilla/layers/WebRenderBridgeChild.h"
 
 namespace mozilla {
 namespace layers {
 
-RenderRootStateManager::RenderRootStateManager(WebRenderLayerManager* aLayerManager)
-  : mLayerManager(aLayerManager)
-  , mDestroyed(false)
-{
-}
+RenderRootStateManager::RenderRootStateManager(
+    WebRenderLayerManager* aLayerManager)
+    : mLayerManager(aLayerManager), mDestroyed(false) {}
 
-RenderRootStateManager::~RenderRootStateManager()
-{}
+RenderRootStateManager::~RenderRootStateManager() {}
 
-// RenderRootStateManager shares its ref count with the WebRenderLayerManager that
-// created it. You can think of the two classes as being one unit, except there
-// are multiple RenderRootStateManagers per WebRenderLayerManager. Since we need
-// to reference the WebRenderLayerManager and it needs to reference us, this
-// avoids us needing to involve the cycle collector.
-void
-RenderRootStateManager::AddRef()
-{
-  mLayerManager->AddRef();
-}
+// RenderRootStateManager shares its ref count with the WebRenderLayerManager
+// that created it. You can think of the two classes as being one unit, except
+// there are multiple RenderRootStateManagers per WebRenderLayerManager. Since
+// we need to reference the WebRenderLayerManager and it needs to reference us,
+// this avoids us needing to involve the cycle collector.
+void RenderRootStateManager::AddRef() { mLayerManager->AddRef(); }
 
-void
-RenderRootStateManager::Release()
-{
-  mLayerManager->Release();
-}
+void RenderRootStateManager::Release() { mLayerManager->Release(); }
 
-
-WebRenderBridgeChild*
-RenderRootStateManager::WrBridge() const
-{
+WebRenderBridgeChild* RenderRootStateManager::WrBridge() const {
   return mLayerManager->WrBridge();
 }
 
-WebRenderCommandBuilder&
-RenderRootStateManager::CommandBuilder()
-{
+WebRenderCommandBuilder& RenderRootStateManager::CommandBuilder() {
   return mLayerManager->CommandBuilder();
 }
 
 RenderRootStateManager::WebRenderUserDataRefTable*
-RenderRootStateManager::GetWebRenderUserDataTable()
-{
+RenderRootStateManager::GetWebRenderUserDataTable() {
   return mLayerManager->GetWebRenderUserDataTable();
 }
 
-wr::IpcResourceUpdateQueue&
-RenderRootStateManager::AsyncResourceUpdates()
-{
+wr::IpcResourceUpdateQueue& RenderRootStateManager::AsyncResourceUpdates() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!mAsyncResourceUpdates) {
     mAsyncResourceUpdates.emplace(WrBridge());
 
     RefPtr<Runnable> task = NewRunnableMethod(
-      "RenderRootStateManager::FlushAsyncResourceUpdates",
-      this, &RenderRootStateManager::FlushAsyncResourceUpdates);
+        "RenderRootStateManager::FlushAsyncResourceUpdates", this,
+        &RenderRootStateManager::FlushAsyncResourceUpdates);
     NS_DispatchToMainThread(task.forget());
   }
 
   return mAsyncResourceUpdates.ref();
 }
 
-void
-RenderRootStateManager::Destroy()
-{
+void RenderRootStateManager::Destroy() {
   ClearAsyncAnimations();
 
   if (WrBridge()) {
     // Just clear ImageKeys, they are deleted during WebRenderAPI destruction.
     DiscardLocalImages();
     // CompositorAnimations are cleared by WebRenderBridgeParent.
     mDiscardedCompositorAnimationsIds.Clear();
   }
 
   mActiveCompositorAnimationIds.clear();
 
   mDestroyed = true;
 }
 
-void
-RenderRootStateManager::FlushAsyncResourceUpdates()
-{
+void RenderRootStateManager::FlushAsyncResourceUpdates() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!mAsyncResourceUpdates) {
     return;
   }
 
   if (!IsDestroyed() && WrBridge()) {
     WrBridge()->UpdateResources(mAsyncResourceUpdates.ref());
   }
 
   mAsyncResourceUpdates.reset();
 }
 
-void
-RenderRootStateManager::AddImageKeyForDiscard(wr::ImageKey key)
-{
+void RenderRootStateManager::AddImageKeyForDiscard(wr::ImageKey key) {
   mImageKeysToDelete.AppendElement(key);
 }
 
-void
-RenderRootStateManager::AddBlobImageKeyForDiscard(wr::BlobImageKey key)
-{
+void RenderRootStateManager::AddBlobImageKeyForDiscard(wr::BlobImageKey key) {
   mBlobImageKeysToDelete.AppendElement(key);
 }
 
-void
-RenderRootStateManager::DiscardImagesInTransaction(wr::IpcResourceUpdateQueue& aResources)
-{
+void RenderRootStateManager::DiscardImagesInTransaction(
+    wr::IpcResourceUpdateQueue& aResources) {
   for (const auto& key : mImageKeysToDelete) {
     aResources.DeleteImage(key);
   }
   for (const auto& key : mBlobImageKeysToDelete) {
     aResources.DeleteBlobImage(key);
   }
   mImageKeysToDelete.Clear();
   mBlobImageKeysToDelete.Clear();
 }
 
-void
-RenderRootStateManager::DiscardLocalImages()
-{
+void RenderRootStateManager::DiscardLocalImages() {
   // Removes images but doesn't tell the parent side about them
   // This is useful in empty / failed transactions where we created
   // image keys but didn't tell the parent about them yet.
   mImageKeysToDelete.Clear();
   mBlobImageKeysToDelete.Clear();
 }
 
-void
-RenderRootStateManager::ClearCachedResources()
-{
+void RenderRootStateManager::ClearCachedResources() {
   mActiveCompositorAnimationIds.clear();
   mDiscardedCompositorAnimationsIds.Clear();
 }
 
-void
-RenderRootStateManager::AddActiveCompositorAnimationId(uint64_t aId)
-{
+void RenderRootStateManager::AddActiveCompositorAnimationId(uint64_t aId) {
   // In layers-free mode we track the active compositor animation ids on the
   // client side so that we don't try to discard the same animation id multiple
   // times. We could just ignore the multiple-discard on the parent side, but
   // checking on the content side reduces IPC traffic.
   mActiveCompositorAnimationIds.insert(aId);
 }
 
-void
-RenderRootStateManager::AddCompositorAnimationsIdForDiscard(uint64_t aId)
-{
+void RenderRootStateManager::AddCompositorAnimationsIdForDiscard(uint64_t aId) {
   if (mActiveCompositorAnimationIds.erase(aId)) {
-    // For layers-free ensure we don't try to discard an animation id that wasn't
-    // active. We also remove it from mActiveCompositorAnimationIds so we don't
-    // discard it again unless it gets re-activated.
+    // For layers-free ensure we don't try to discard an animation id that
+    // wasn't active. We also remove it from mActiveCompositorAnimationIds so we
+    // don't discard it again unless it gets re-activated.
     mDiscardedCompositorAnimationsIds.AppendElement(aId);
   }
 }
 
-void
-RenderRootStateManager::DiscardCompositorAnimations()
-{
-  if (WrBridge()->IPCOpen() &&
-      !mDiscardedCompositorAnimationsIds.IsEmpty()) {
-    WrBridge()->
-      SendDeleteCompositorAnimations(mDiscardedCompositorAnimationsIds);
+void RenderRootStateManager::DiscardCompositorAnimations() {
+  if (WrBridge()->IPCOpen() && !mDiscardedCompositorAnimationsIds.IsEmpty()) {
+    WrBridge()->SendDeleteCompositorAnimations(
+        mDiscardedCompositorAnimationsIds);
   }
   mDiscardedCompositorAnimationsIds.Clear();
 }
 
-void
-RenderRootStateManager::RegisterAsyncAnimation(const wr::ImageKey& aKey,
-                                              SharedSurfacesAnimation* aAnimation)
-{
+void RenderRootStateManager::RegisterAsyncAnimation(
+    const wr::ImageKey& aKey, SharedSurfacesAnimation* aAnimation) {
   mAsyncAnimations.insert(std::make_pair(wr::AsUint64(aKey), aAnimation));
 }
 
-void
-RenderRootStateManager::DeregisterAsyncAnimation(const wr::ImageKey& aKey)
-{
+void RenderRootStateManager::DeregisterAsyncAnimation(
+    const wr::ImageKey& aKey) {
   mAsyncAnimations.erase(wr::AsUint64(aKey));
 }
 
-void
-RenderRootStateManager::ClearAsyncAnimations()
-{
+void RenderRootStateManager::ClearAsyncAnimations() {
   for (const auto& i : mAsyncAnimations) {
     i.second->Invalidate(this);
   }
   mAsyncAnimations.clear();
 }
 
-void
-RenderRootStateManager::WrReleasedImages(const nsTArray<wr::ExternalImageKeyPair>& aPairs)
-{
+void RenderRootStateManager::WrReleasedImages(
+    const nsTArray<wr::ExternalImageKeyPair>& aPairs) {
   // A SharedSurfaceAnimation object's lifetime is tied to its owning
   // ImageContainer. When the ImageContainer is released,
   // SharedSurfaceAnimation::Destroy is called which should ensure it is removed
   // from the layer manager. Whenever the namespace for the
   // WebRenderLayerManager itself is invalidated (e.g. we changed windows, or
   // were destroyed ourselves), we callback into the SharedSurfaceAnimation
   // object to remove its image key for us and any bound surfaces. If, for any
   // reason, we somehow missed an WrReleasedImages call before the animation
@@ -218,59 +173,46 @@ RenderRootStateManager::WrReleasedImages
   for (const auto& pair : aPairs) {
     auto i = mAsyncAnimations.find(wr::AsUint64(pair.key));
     if (i != mAsyncAnimations.end()) {
       i->second->ReleasePreviousFrame(this, pair.id);
     }
   }
 }
 
-void
-RenderRootStateManager::AddWebRenderParentCommand(const WebRenderParentCommand& aCmd)
-{
+void RenderRootStateManager::AddWebRenderParentCommand(
+    const WebRenderParentCommand& aCmd) {
   WrBridge()->AddWebRenderParentCommand(aCmd);
 }
-void
-RenderRootStateManager::UpdateResources(wr::IpcResourceUpdateQueue& aResources)
-{
+void RenderRootStateManager::UpdateResources(
+    wr::IpcResourceUpdateQueue& aResources) {
   WrBridge()->UpdateResources(aResources);
 }
-void
-RenderRootStateManager::AddPipelineIdForAsyncCompositable(const wr::PipelineId& aPipelineId,
-                                                   const CompositableHandle& aHandle)
-{
+void RenderRootStateManager::AddPipelineIdForAsyncCompositable(
+    const wr::PipelineId& aPipelineId, const CompositableHandle& aHandle) {
   WrBridge()->AddPipelineIdForAsyncCompositable(aPipelineId, aHandle);
 }
-void
-RenderRootStateManager::AddPipelineIdForCompositable(const wr::PipelineId& aPipelineId,
-                                              const CompositableHandle& aHandle)
-{
+void RenderRootStateManager::AddPipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId, const CompositableHandle& aHandle) {
   WrBridge()->AddPipelineIdForCompositable(aPipelineId, aHandle);
 }
-void
-RenderRootStateManager::RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId)
-{
+void RenderRootStateManager::RemovePipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId) {
   WrBridge()->RemovePipelineIdForCompositable(aPipelineId);
 }
-  /// Release TextureClient that is bounded to ImageKey.
-  /// It is used for recycling TextureClient.
-void
-RenderRootStateManager::ReleaseTextureOfImage(const wr::ImageKey& aKey)
-{
+/// Release TextureClient that is bounded to ImageKey.
+/// It is used for recycling TextureClient.
+void RenderRootStateManager::ReleaseTextureOfImage(const wr::ImageKey& aKey) {
   WrBridge()->ReleaseTextureOfImage(aKey);
 }
 
-wr::FontInstanceKey
-RenderRootStateManager::GetFontKeyForScaledFont(gfx::ScaledFont* aScaledFont,
-                                              wr::IpcResourceUpdateQueue* aResources)
-{
+wr::FontInstanceKey RenderRootStateManager::GetFontKeyForScaledFont(
+    gfx::ScaledFont* aScaledFont, wr::IpcResourceUpdateQueue* aResources) {
   return WrBridge()->GetFontKeyForScaledFont(aScaledFont, aResources);
 }
 
-wr::FontKey
-RenderRootStateManager::GetFontKeyForUnscaledFont(gfx::UnscaledFont* aUnscaledFont,
-                                                wr::IpcResourceUpdateQueue* aResources)
-{
+wr::FontKey RenderRootStateManager::GetFontKeyForUnscaledFont(
+    gfx::UnscaledFont* aUnscaledFont, wr::IpcResourceUpdateQueue* aResources) {
   return WrBridge()->GetFontKeyForUnscaledFont(aUnscaledFont, aResources);
 }
 
-} // namespace layers
-} // namespace mozilla
\ No newline at end of file
+}  // namespace layers
+}  // namespace mozilla
\ No newline at end of file
--- a/gfx/layers/wr/RenderRootStateManager.h
+++ b/gfx/layers/wr/RenderRootStateManager.h
@@ -11,88 +11,90 @@
 
 #include "mozilla/layers/IpcResourceUpdateQueue.h"
 #include "mozilla/layers/WebRenderCommandBuilder.h"
 
 namespace mozilla {
 
 namespace layers {
 
-class RenderRootStateManager
-{
-  typedef nsTHashtable<nsRefPtrHashKey<WebRenderUserData>> WebRenderUserDataRefTable;
+class RenderRootStateManager {
+  typedef nsTHashtable<nsRefPtrHashKey<WebRenderUserData>>
+      WebRenderUserDataRefTable;
 
-public:
+ public:
   void AddRef();
   void Release();
 
   explicit RenderRootStateManager(WebRenderLayerManager* aLayerManager);
 
   void Destroy();
   bool IsDestroyed() { return mDestroyed; }
   wr::IpcResourceUpdateQueue& AsyncResourceUpdates();
   WebRenderBridgeChild* WrBridge() const;
   WebRenderCommandBuilder& CommandBuilder();
   WebRenderUserDataRefTable* GetWebRenderUserDataTable();
-  WebRenderLayerManager* LayerManager()
-  {
-    return mLayerManager;
-  }
+  WebRenderLayerManager* LayerManager() { return mLayerManager; }
 
   void AddImageKeyForDiscard(wr::ImageKey key);
   void AddBlobImageKeyForDiscard(wr::BlobImageKey key);
   void DiscardImagesInTransaction(wr::IpcResourceUpdateQueue& aResources);
   void DiscardLocalImages();
 
   void ClearCachedResources();
 
   // Methods to manage the compositor animation ids. Active animations are still
   // going, and when they end we discard them and remove them from the active
   // list.
   void AddActiveCompositorAnimationId(uint64_t aId);
   void AddCompositorAnimationsIdForDiscard(uint64_t aId);
   void DiscardCompositorAnimations();
 
-  void RegisterAsyncAnimation(const wr::ImageKey& aKey, SharedSurfacesAnimation* aAnimation);
+  void RegisterAsyncAnimation(const wr::ImageKey& aKey,
+                              SharedSurfacesAnimation* aAnimation);
   void DeregisterAsyncAnimation(const wr::ImageKey& aKey);
   void ClearAsyncAnimations();
   void WrReleasedImages(const nsTArray<wr::ExternalImageKeyPair>& aPairs);
 
   void AddWebRenderParentCommand(const WebRenderParentCommand& aCmd);
   void UpdateResources(wr::IpcResourceUpdateQueue& aResources);
   void AddPipelineIdForAsyncCompositable(const wr::PipelineId& aPipelineId,
                                          const CompositableHandle& aHandlee);
   void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineId,
                                     const CompositableHandle& aHandlee);
   void RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId);
   /// Release TextureClient that is bounded to ImageKey.
   /// It is used for recycling TextureClient.
   void ReleaseTextureOfImage(const wr::ImageKey& aKey);
-  wr::FontInstanceKey GetFontKeyForScaledFont(gfx::ScaledFont* aScaledFont,
-                                              wr::IpcResourceUpdateQueue* aResources = nullptr);
-  wr::FontKey GetFontKeyForUnscaledFont(gfx::UnscaledFont* aUnscaledFont,
-                                        wr::IpcResourceUpdateQueue* aResources = nullptr);
+  wr::FontInstanceKey GetFontKeyForScaledFont(
+      gfx::ScaledFont* aScaledFont,
+      wr::IpcResourceUpdateQueue* aResources = nullptr);
+  wr::FontKey GetFontKeyForUnscaledFont(
+      gfx::UnscaledFont* aUnscaledFont,
+      wr::IpcResourceUpdateQueue* aResources = nullptr);
 
   void FlushAsyncResourceUpdates();
-private:
+
+ private:
   ~RenderRootStateManager();
   WebRenderLayerManager* mLayerManager;
   Maybe<wr::IpcResourceUpdateQueue> mAsyncResourceUpdates;
   nsTArray<wr::ImageKey> mImageKeysToDelete;
   nsTArray<wr::BlobImageKey> mBlobImageKeysToDelete;
-  std::unordered_map<uint64_t, RefPtr<SharedSurfacesAnimation>> mAsyncAnimations;
+  std::unordered_map<uint64_t, RefPtr<SharedSurfacesAnimation>>
+      mAsyncAnimations;
 
   // Set of compositor animation ids for which there are active animations (as
   // of the last transaction) on the compositor side.
   std::unordered_set<uint64_t> mActiveCompositorAnimationIds;
   // Compositor animation ids for animations that are done now and that we want
   // the compositor to discard information for.
   nsTArray<uint64_t> mDiscardedCompositorAnimationsIds;
 
   bool mDestroyed;
 
   friend class WebRenderLayerManager;
 };
 
-} // namespace layers
-} // namespace mozilla
+}  // namespace layers
+}  // namespace mozilla
 
 #endif /* GFX_RENDERROOTSTATEMANAGER_H */
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -1062,18 +1062,19 @@ static bool IsItemProbablyActive(nsDispl
     case DisplayItemType::TYPE_TRANSFORM: {
       nsDisplayTransform* transformItem =
           static_cast<nsDisplayTransform*>(aItem);
       const Matrix4x4Flagged& t = transformItem->GetTransform();
       Matrix t2d;
       bool is2D = t.Is2D(&t2d);
       GP("active: %d\n", transformItem->MayBeAnimated(aDisplayListBuilder));
       return transformItem->MayBeAnimated(aDisplayListBuilder, false) ||
-             !is2D || HasActiveChildren(*transformItem->GetChildren(),
-                                        aDisplayListBuilder);
+             !is2D ||
+             HasActiveChildren(*transformItem->GetChildren(),
+                               aDisplayListBuilder);
     }
     case DisplayItemType::TYPE_OPACITY: {
       nsDisplayOpacity* opacityItem = static_cast<nsDisplayOpacity*>(aItem);
       bool active = opacityItem->NeedsActiveLayer(aDisplayListBuilder,
                                                   opacityItem->Frame(), false);
       GP("active: %d\n", active);
       return active || HasActiveChildren(*opacityItem->GetChildren(),
                                          aDisplayListBuilder);
@@ -2298,18 +2299,17 @@ Maybe<wr::WrImageMask> WebRenderCommandB
     bool paintFinished =
         aMaskItem->PaintMask(aDisplayListBuilder, context, &maskPainted);
     if (!maskPainted) {
       return Nothing();
     }
 
     recorder->FlushItem(IntRect(0, 0, size.width, size.height));
     TakeExternalSurfaces(recorder, maskData->mExternalSurfaces,
-                         mManager->GetRenderRootStateManager(),
-                         aResources);
+                         mManager->GetRenderRootStateManager(), aResources);
     recorder->Finish();
 
     Range<uint8_t> bytes((uint8_t*)recorder->mOutputStream.mData,
                          recorder->mOutputStream.mLength);
     wr::BlobImageKey key =
         wr::BlobImageKey{mManager->WrBridge()->GetNextImageKey()};
     wr::ImageDescriptor descriptor(size, 0, dt->GetFormat(),
                                    wr::OpacityType::HasAlphaChannel);
--- a/gfx/thebes/gfxFont.h
+++ b/gfx/thebes/gfxFont.h
@@ -1935,19 +1935,17 @@ class gfxFont {
 
   // subclasses may provide (possibly hinted) glyph widths (in font units);
   // if they do not override this, harfbuzz will use unhinted widths
   // derived from the font tables
   virtual bool ProvidesGlyphWidths() const { return false; }
 
   // The return value is interpreted as a horizontal advance in 16.16 fixed
   // point format.
-  virtual int32_t GetGlyphWidth(uint16_t aGID) {
-    return -1;
-  }
+  virtual int32_t GetGlyphWidth(uint16_t aGID) { return -1; }
 
   bool IsSpaceGlyphInvisible(DrawTarget* aRefDrawTarget,
                              const gfxTextRun* aTextRun);
 
   void AddGlyphChangeObserver(GlyphChangeObserver* aObserver);
   void RemoveGlyphChangeObserver(GlyphChangeObserver* aObserver);
 
   // whether font contains substitution lookups containing spaces
--- a/image/decoders/nsWebPDecoder.cpp
+++ b/image/decoders/nsWebPDecoder.cpp
@@ -303,20 +303,20 @@ void nsWebPDecoder::ApplyColorProfile(co
         ("[this=%p] nsWebPDecoder::ApplyColorProfile -- bad color profile\n",
          this));
     return;
   }
 
   uint32_t profileSpace = qcms_profile_get_color_space(mInProfile);
   if (profileSpace == icSigGrayData) {
     // WebP doesn't produce grayscale data, this must be corrupt.
-    MOZ_LOG(
-        sWebPLog, LogLevel::Error,
-        ("[this=%p] nsWebPDecoder::ApplyColorProfile -- ignoring grayscale color profile\n",
-         this));
+    MOZ_LOG(sWebPLog, LogLevel::Error,
+            ("[this=%p] nsWebPDecoder::ApplyColorProfile -- ignoring grayscale "
+             "color profile\n",
+             this));
     return;
   }
 
   // Calculate rendering intent.
   int intent = gfxPlatform::GetRenderingIntent();
   if (intent == -1) {
     intent = qcms_profile_get_rendering_intent(mInProfile);
   }
--- a/ipc/chromium/src/base/at_exit.cc
+++ b/ipc/chromium/src/base/at_exit.cc
@@ -10,25 +10,23 @@
 namespace base {
 
 // Keep a stack of registered AtExitManagers.  We always operate on the most
 // recent, and we should never have more than one outside of testing, when we
 // use the shadow version of the constructor.  We don't protect this for
 // thread-safe access, since it will only be modified in testing.
 static AtExitManager* g_top_manager = NULL;
 
-AtExitManager::AtExitManager() : lock_("AtExitManager"),
-                                 next_manager_(NULL) {
+AtExitManager::AtExitManager() : lock_("AtExitManager"), next_manager_(NULL) {
   DCHECK(!g_top_manager);
   g_top_manager = this;
 }
 
-AtExitManager::AtExitManager(bool shadow) : lock_("AtExitManager"),
-                                            next_manager_(g_top_manager)
- {
+AtExitManager::AtExitManager(bool shadow)
+    : lock_("AtExitManager"), next_manager_(g_top_manager) {
   DCHECK(shadow || !g_top_manager);
   g_top_manager = this;
 }
 
 AtExitManager::~AtExitManager() {
   if (!g_top_manager) {
     NOTREACHED() << "Tried to ~AtExitManager without an AtExitManager";
     return;
--- a/ipc/chromium/src/base/time_win.cc
+++ b/ipc/chromium/src/base/time_win.cc
@@ -238,25 +238,23 @@ class NowSingleton {
     // pass it into the NowSingleton constructor.
     static mozilla::StaticMutex mutex;
     static NowSingleton now(mutex);
     return now;
   }
 
  private:
   explicit NowSingleton(mozilla::StaticMutex& aMutex)
-    : lock_(aMutex)
-    , rollover_(TimeDelta::FromMilliseconds(0))
-    , last_seen_(0)
-  {
-  }
+      : lock_(aMutex),
+        rollover_(TimeDelta::FromMilliseconds(0)),
+        last_seen_(0) {}
   ~NowSingleton() = default;
 
   mozilla::StaticMutex& lock_;  // To protected last_seen_ and rollover_.
-  TimeDelta rollover_;  // Accumulation of time lost due to rollover.
+  TimeDelta rollover_;          // Accumulation of time lost due to rollover.
   DWORD last_seen_;  // The last timeGetTime value we saw, to detect rollover.
 
   DISALLOW_COPY_AND_ASSIGN(NowSingleton);
 };
 
 }  // namespace
 
 // static
--- a/ipc/chromium/src/chrome/common/ipc_channel_posix.cc
+++ b/ipc/chromium/src/chrome/common/ipc_channel_posix.cc
@@ -145,19 +145,17 @@ class PipeMap {
     // a member variable.  So we have to have this separate variable and pass
     // it into the PipeMap constructor.
     static mozilla::StaticMutex mutex;
     static PipeMap map(mutex);
     return map;
   }
 
  private:
-  explicit PipeMap(mozilla::StaticMutex& aMutex)
-    : lock_(aMutex)
-  {}
+  explicit PipeMap(mozilla::StaticMutex& aMutex) : lock_(aMutex) {}
   ~PipeMap() = default;
 
   mozilla::StaticMutex& lock_;
   typedef std::map<std::string, int> ChannelToFDMap;
   ChannelToFDMap map_;
 };
 
 // This is the file descriptor number that a client process expects to find its
--- a/ipc/glue/CrashReporterHost.cpp
+++ b/ipc/glue/CrashReporterHost.cpp
@@ -15,40 +15,46 @@
 #include "nsICrashService.h"
 #include "nsXULAppAPI.h"
 
 // Consistency checking for nsICrashService constants.  We depend on the
 // equivalence between nsICrashService values and GeckoProcessType values
 // in the code below.  Making them equal also ensures that if new process
 // types are added, people will know they may need to add crash reporting
 // support in various places because compilation errors will be triggered here.
-static_assert(nsICrashService::PROCESS_TYPE_MAIN == (int)GeckoProcessType_Default,
+static_assert(nsICrashService::PROCESS_TYPE_MAIN ==
+                  (int)GeckoProcessType_Default,
               "GeckoProcessType enum is out of sync with nsICrashService!");
-static_assert(nsICrashService::PROCESS_TYPE_PLUGIN == (int)GeckoProcessType_Plugin,
+static_assert(nsICrashService::PROCESS_TYPE_PLUGIN ==
+                  (int)GeckoProcessType_Plugin,
               "GeckoProcessType enum is out of sync with nsICrashService!");
-static_assert(nsICrashService::PROCESS_TYPE_CONTENT == (int)GeckoProcessType_Content,
+static_assert(nsICrashService::PROCESS_TYPE_CONTENT ==
+                  (int)GeckoProcessType_Content,
               "GeckoProcessType enum is out of sync with nsICrashService!");
-static_assert(nsICrashService::PROCESS_TYPE_IPDLUNITTEST == (int)GeckoProcessType_IPDLUnitTest,
+static_assert(nsICrashService::PROCESS_TYPE_IPDLUNITTEST ==
+                  (int)GeckoProcessType_IPDLUnitTest,
               "GeckoProcessType enum is out of sync with nsICrashService!");
-static_assert(nsICrashService::PROCESS_TYPE_GMPLUGIN == (int)GeckoProcessType_GMPlugin,
+static_assert(nsICrashService::PROCESS_TYPE_GMPLUGIN ==
+                  (int)GeckoProcessType_GMPlugin,
               "GeckoProcessType enum is out of sync with nsICrashService!");
 static_assert(nsICrashService::PROCESS_TYPE_GPU == (int)GeckoProcessType_GPU,
               "GeckoProcessType enum is out of sync with nsICrashService!");
 static_assert(nsICrashService::PROCESS_TYPE_VR == (int)GeckoProcessType_VR,
               "GeckoProcessType enum is out of sync with nsICrashService!");
 static_assert(nsICrashService::PROCESS_TYPE_RDD == (int)GeckoProcessType_RDD,
               "GeckoProcessType enum is out of sync with nsICrashService!");
-static_assert(nsICrashService::PROCESS_TYPE_SOCKET == (int)GeckoProcessType_Socket,
+static_assert(nsICrashService::PROCESS_TYPE_SOCKET ==
+                  (int)GeckoProcessType_Socket,
               "GeckoProcessType enum is out of sync with nsICrashService!");
 // Add new static asserts here if you add more process types.
 // Update this static assert as well.
-static_assert(nsICrashService::PROCESS_TYPE_SOCKET + 1 == (int)GeckoProcessType_End,
+static_assert(nsICrashService::PROCESS_TYPE_SOCKET + 1 ==
+                  (int)GeckoProcessType_End,
               "GeckoProcessType enum is out of sync with nsICrashService!");
 
-
 namespace mozilla {
 namespace ipc {
 
 CrashReporterHost::CrashReporterHost(GeckoProcessType aProcessType,
                                      const Shmem& aShmem,
                                      CrashReporter::ThreadId aThreadId)
     : mProcessType(aProcessType),
       mShmem(aShmem),
@@ -111,24 +117,24 @@ bool CrashReporterHost::FinalizeCrashRep
   // as a historical artifact.
   if (mProcessType == GeckoProcessType_GMPlugin) {
     type.AssignLiteral("plugin");
   } else {
     // This check will pick up some cases that will never happen (e.g. IPDL
     // unit tests), but that's OK.
     switch (mProcessType) {
 #define GECKO_PROCESS_TYPE(enum_name, string_name, xre_name) \
-      case GeckoProcessType_##enum_name: \
-        type.AssignLiteral(string_name); \
-        break;
+  case GeckoProcessType_##enum_name:                         \
+    type.AssignLiteral(string_name);                         \
+    break;
 #include "mozilla/GeckoProcessTypes.h"
 #undef GECKO_PROCESS_TYPE
-    default:
-      NS_ERROR("unknown process type");
-      break;
+      default:
+        NS_ERROR("unknown process type");
+        break;
     }
   }
   annotations[CrashReporter::Annotation::ProcessType] = type;
 
   char startTime[32];
   SprintfLiteral(startTime, "%lld", static_cast<long long>(mStartTime));
   annotations[CrashReporter::Annotation::StartupTime] =
       nsDependentCString(startTime);
@@ -183,23 +189,23 @@ bool CrashReporterHost::FinalizeCrashRep
   }
 
   if (aProcessType == GeckoProcessType_Plugin &&
       aCrashType == nsICrashService::CRASH_TYPE_HANG) {
     telemetryKey.AssignLiteral("pluginhang");
   } else {
     switch (aProcessType) {
 #define GECKO_PROCESS_TYPE(enum_name, string_name, xre_name) \
-      case GeckoProcessType_##enum_name:                     \
-        telemetryKey.AssignLiteral(string_name);             \
-        break;
+  case GeckoProcessType_##enum_name:                         \
+    telemetryKey.AssignLiteral(string_name);                 \
+    break;
 #include "mozilla/GeckoProcessTypes.h"
 #undef GECKO_PROCESS_TYPE
-      // We can't really hit this, thanks to the above switch, but having it here
-      // will placate the compiler.
+      // We can't really hit this, thanks to the above switch, but having it
+      // here will placate the compiler.
       default:
         NS_ERROR("unknown process type");
         return;
     }
   }
 
   RefPtr<Promise> promise;
   crashService->AddCrash(processType, aCrashType, aChildDumpID,
--- a/js/src/builtin/ModuleObject.cpp
+++ b/js/src/builtin/ModuleObject.cpp
@@ -376,17 +376,18 @@ bool IndirectBindingMap::lookup(jsid nam
   Rooted<UniquePtr<IndirectBindingMap>> rootedBindings(cx, std::move(bindings));
   RootedObject object(
       cx, NewProxyObject(cx, &proxyHandler, priv, nullptr, options));
   if (!object) {
     return nullptr;
   }
 
   SetProxyReservedSlot(object, ExportsSlot, ObjectValue(*exports));
-  SetProxyReservedSlot(object, BindingsSlot, PrivateValue(rootedBindings.release()));
+  SetProxyReservedSlot(object, BindingsSlot,
+                       PrivateValue(rootedBindings.release()));
 
   return &object->as<ModuleNamespaceObject>();
 }
 
 ModuleObject& ModuleNamespaceObject::module() {
   return GetProxyPrivate(this).toObject().as<ModuleObject>();
 }
 
--- a/js/src/frontend/NameFunctions.cpp
+++ b/js/src/frontend/NameFunctions.cpp
@@ -980,18 +980,18 @@ class NameResolver {
 
     // It would be nice to common up the repeated |parents[initialParents]|
     // in a single variable, but the #if condition required to prevent an
     // unused-variable warning across three separate conditionally-expanded
     // macros would be super-ugly.  :-(
     MOZ_ASSERT(parents[initialParents] == cur,
                "pushed child shouldn't change underneath us");
 
-    AlwaysPoison(&parents[initialParents], 0xFF, sizeof(parents[initialParents]),
-                 MemCheckKind::MakeUndefined);
+    AlwaysPoison(&parents[initialParents], 0xFF,
+                 sizeof(parents[initialParents]), MemCheckKind::MakeUndefined);
 
     return true;
   }
 };
 
 } /* anonymous namespace */
 
 bool frontend::NameFunctions(JSContext* cx, ParseNode* pn) {
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -587,17 +587,17 @@ inline size_t Arena::finalize(FreeOp* fo
                                 thing - thingSize, this);
         newListTail = newListTail->nextSpanUnchecked(this);
       }
       firstThingOrSuccessorOfLastMarkedThing = thing + thingSize;
       nmarked++;
     } else {
       t->finalize(fop);
       AlwaysPoison(t, JS_SWEPT_TENURED_PATTERN, thingSize,
-             MemCheckKind::MakeUndefined);
+                   MemCheckKind::MakeUndefined);
       gcTracer.traceTenuredFinalize(t);
     }
   }
 
   if (nmarked == 0) {
     // Do nothing. The caller will update the arena appropriately.
     MOZ_ASSERT(newListTail == &newListHead);
     DebugOnlyPoison(data, JS_SWEPT_TENURED_PATTERN, sizeof(data),
@@ -3582,18 +3582,18 @@ void GCRuntime::sweepFromBackgroundThrea
     ZoneList zones;
     zones.transferFrom(backgroundSweepZones.ref());
     LifoAlloc freeLifoAlloc(JSContext::TEMP_LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     freeLifoAlloc.transferFrom(&lifoBlocksToFree.ref());
 
     AutoUnlockHelperThreadState unlock(lock);
     sweepBackgroundThings(zones, freeLifoAlloc);
 
-    // The main thread may call queueZonesAndStartBackgroundSweep() while this is
-    // running so we must check there is no more work after releasing the
+    // The main thread may call queueZonesAndStartBackgroundSweep() while this
+    // is running so we must check there is no more work after releasing the
     // lock.
   } while (!backgroundSweepZones.ref().isEmpty());
 }
 
 void GCRuntime::waitBackgroundSweepEnd() {
   sweepTask.join();
 
   // TODO: Improve assertion to work in incremental GC?
@@ -3637,18 +3637,17 @@ void GCRuntime::startBackgroundFree() {
     AutoLockHelperThreadState lock;
     freeTask.startOrRunIfIdle(lock);
   } else {
     freeTask.joinAndRunFromMainThread(rt);
   }
 }
 
 void BackgroundFreeTask::run() {
-  AutoTraceLog logFreeing(TraceLoggerForCurrentThread(),
-                           TraceLogger_GCFree);
+  AutoTraceLog logFreeing(TraceLoggerForCurrentThread(), TraceLogger_GCFree);
 
   AutoLockHelperThreadState lock;
 
   runtime()->gc.freeFromBackgroundThread(lock);
 
   // Signal to the main thread that we're about to finish, because we release
   // the lock again before GCParallelTask's state is changed to finished.
   setFinishing(lock);
@@ -3661,26 +3660,25 @@ void GCRuntime::freeFromBackgroundThread
 
     Nursery::BufferSet buffers;
     mozilla::Swap(buffers, buffersToFreeAfterMinorGC.ref());
 
     AutoUnlockHelperThreadState unlock(lock);
 
     lifoBlocks.freeAll();
 
-    for (Nursery::BufferSet::Range r = buffers.all(); !r.empty(); r.popFront()) {
+    for (Nursery::BufferSet::Range r = buffers.all(); !r.empty();
+         r.popFront()) {
       rt->defaultFreeOp()->free_(r.front());
     }
   } while (!lifoBlocksToFree.ref().isEmpty() ||
            !buffersToFreeAfterMinorGC.ref().empty());
 }
 
-void GCRuntime::waitBackgroundFreeEnd() {
-  freeTask.join();
-}
+void GCRuntime::waitBackgroundFreeEnd() { freeTask.join(); }
 
 struct IsAboutToBeFinalizedFunctor {
   template <typename T>
   bool operator()(Cell** t) {
     mozilla::DebugOnly<const Cell*> prior = *t;
     bool result = IsAboutToBeFinalizedUnbarriered(reinterpret_cast<T**>(t));
     // Sweep should not have to deal with moved pointers, since moving GC
     // handles updating the UID table manually.
@@ -6930,18 +6928,18 @@ static bool ShouldCleanUpEverything(JS::
                                     JSGCInvocationKind gckind) {
   // During shutdown, we must clean everything up, for the sake of leak
   // detection. When a runtime has no contexts, or we're doing a GC before a
   // shutdown CC, those are strong indications that we're shutting down.
   return IsShutdownGC(reason) || gckind == GC_SHRINK;
 }
 
 static bool ShouldSweepOnBackgroundThread(JS::gcreason::Reason reason) {
-  return reason != JS::gcreason::DESTROY_RUNTIME &&
-         !gcTracer.traceEnabled() && CanUseExtraThreads();
+  return reason != JS::gcreason::DESTROY_RUNTIME && !gcTracer.traceEnabled() &&
+         CanUseExtraThreads();
 }
 
 void GCRuntime::incrementalSlice(SliceBudget& budget,
                                  JS::gcreason::Reason reason,
                                  AutoGCSession& session) {
   AutoDisableBarriers disableBarriers(rt);
 
   bool destroyingRuntime = (reason == JS::gcreason::DESTROY_RUNTIME);
--- a/js/src/gc/Heap.h
+++ b/js/src/gc/Heap.h
@@ -161,18 +161,19 @@ class FreeSpan {
       // The last space points to the next free span (which may be empty).
       const FreeSpan* next = nextSpan(arena);
       first = next->first;
       last = next->last;
     } else {
       return nullptr;  // The span is empty.
     }
     checkSpan(arena);
-    DebugOnlyPoison(reinterpret_cast<void*>(thing), JS_ALLOCATED_TENURED_PATTERN,
-                    thingSize, MemCheckKind::MakeUndefined);
+    DebugOnlyPoison(reinterpret_cast<void*>(thing),
+                    JS_ALLOCATED_TENURED_PATTERN, thingSize,
+                    MemCheckKind::MakeUndefined);
     return reinterpret_cast<TenuredCell*>(thing);
   }
 
   inline void checkSpan(const Arena* arena) const;
   inline void checkRange(uintptr_t first, uintptr_t last,
                          const Arena* arena) const;
 };
 
@@ -232,17 +233,17 @@ class Arena {
  private:
   /*
    * When recursive marking uses too much stack we delay marking of
    * arenas and link them into a list for later processing. This
    * uses the following fields.
    */
   static const size_t DELAYED_MARKING_FLAG_BITS = 3;
   static const size_t DELAYED_MARKING_ARENA_BITS =
-    JS_BITS_PER_WORD - 8 - DELAYED_MARKING_FLAG_BITS;
+      JS_BITS_PER_WORD - 8 - DELAYED_MARKING_FLAG_BITS;
   size_t onDelayedMarkingList_ : 1;
   size_t hasDelayedBlackMarking_ : 1;
   size_t hasDelayedGrayMarking_ : 1;
   size_t nextDelayedMarkingArena_ : DELAYED_MARKING_ARENA_BITS;
   static_assert(
       DELAYED_MARKING_ARENA_BITS >= JS_BITS_PER_WORD - ArenaShift,
       "Arena::nextDelayedMarkingArena_ packing assumes that ArenaShift has "
       "enough bits to cover allocKind and delayed marking state.");
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -969,17 +969,17 @@ struct ParticipatesInCCFunctor {
     return TypeParticipatesInCC<T>::value;
   }
 };
 
 static bool TraceKindParticipatesInCC(JS::TraceKind kind) {
   return DispatchTraceKindTyped(ParticipatesInCCFunctor(), kind);
 }
 
-#endif // DEBUG
+#endif  // DEBUG
 
 template <typename T>
 bool js::GCMarker::mark(T* thing) {
   if (IsInsideNursery(thing)) {
     return false;
   }
   AssertShouldMarkInZone(thing);
   TenuredCell* cell = TenuredCell::fromPointer(thing);
--- a/js/src/gc/Nursery.cpp
+++ b/js/src/gc/Nursery.cpp
@@ -67,18 +67,17 @@ static_assert(sizeof(js::NurseryChunk) =
               "Nursery chunk size must match gc::Chunk size.");
 
 } /* namespace js */
 
 inline void js::NurseryChunk::poisonAndInit(JSRuntime* rt, size_t extent) {
   MOZ_ASSERT(extent <= ChunkSize);
   MOZ_MAKE_MEM_UNDEFINED(this, extent);
 
-  Poison(this, JS_FRESH_NURSERY_PATTERN, extent,
-         MemCheckKind::MakeUndefined);
+  Poison(this, JS_FRESH_NURSERY_PATTERN, extent, MemCheckKind::MakeUndefined);
 
   new (&trailer) gc::ChunkTrailer(rt, &rt->gc.storeBuffer());
 }
 
 inline void js::NurseryChunk::poisonAfterSweep(size_t extent) {
   MOZ_ASSERT(extent <= ChunkSize);
   // We can poison the same chunk more than once, so first make sure memory
   // sanitizers will let us poison it.
@@ -177,19 +176,17 @@ bool js::Nursery::init(uint32_t maxNurse
   if (!runtime()->gc.storeBuffer().enable()) {
     return false;
   }
 
   MOZ_ASSERT(isEnabled());
   return true;
 }
 
-js::Nursery::~Nursery() {
-  disable();
-}
+js::Nursery::~Nursery() { disable(); }
 
 void js::Nursery::enable() {
   MOZ_ASSERT(isEmpty());
   MOZ_ASSERT(!runtime()->gc.isVerifyPreBarriersEnabled());
   if (isEnabled() || !chunkCountLimit()) {
     return;
   }
 
--- a/js/src/gc/Nursery.h
+++ b/js/src/gc/Nursery.h
@@ -307,18 +307,17 @@ class Nursery {
 
   MOZ_MUST_USE bool queueDictionaryModeObjectToSweep(NativeObject* obj);
 
   size_t sizeOfHeapCommitted() const {
     return allocatedChunkCount() * gc::ChunkSize;
   }
   size_t sizeOfMallocedBuffers(mozilla::MallocSizeOf mallocSizeOf) const {
     size_t total = 0;
-    for (BufferSet::Range r = mallocedBuffers.all(); !r.empty();
-         r.popFront()) {
+    for (BufferSet::Range r = mallocedBuffers.all(); !r.empty(); r.popFront()) {
       total += mallocSizeOf(r.front());
     }
     total += mallocedBuffers.shallowSizeOfExcludingThis(mallocSizeOf);
     return total;
   }
 
   // The number of bytes from the start position to the end of the nursery.
   // pass maxChunkCount(), allocatedChunkCount() or chunkCountLimit()
--- a/js/src/gc/Statistics.cpp
+++ b/js/src/gc/Statistics.cpp
@@ -176,18 +176,19 @@ Phase Statistics::lookupChildPhase(Phase
   for (phase = phaseKinds[phaseKind].firstPhase; phase != Phase::NONE;
        phase = phases[phase].nextWithPhaseKind) {
     if (phases[phase].parent == currentPhase()) {
       break;
     }
   }
 
   if (phase == Phase::NONE) {
-      MOZ_CRASH_UNSAFE_PRINTF("Child phase kind %u not found under current phase kind %u",
-                              unsigned(phaseKind), unsigned(currentPhaseKind()));
+    MOZ_CRASH_UNSAFE_PRINTF(
+        "Child phase kind %u not found under current phase kind %u",
+        unsigned(phaseKind), unsigned(currentPhaseKind()));
   }
 
   return phase;
 }
 
 inline decltype(mozilla::MakeEnumeratedRange(Phase::FIRST, Phase::LIMIT))
 AllPhases() {
   return mozilla::MakeEnumeratedRange(Phase::FIRST, Phase::LIMIT);
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -5408,19 +5408,19 @@ static const VMFunction DefVarInfo =
     FunctionInfo<DefVarFn>(DefVarOperation, "DefVarOperation");
 
 void CodeGenerator::visitDefVar(LDefVar* lir) {
   Register envChain = ToRegister(lir->environmentChain());
 
   JSScript* script = current->mir()->info().script();
   jsbytecode* pc = lir->mir()->resumePoint()->pc();
 
-  pushArg(ImmPtr(pc));                    // jsbytecode*
-  pushArg(ImmGCPtr(script));              // JSScript*
-  pushArg(envChain);                      // JSObject*
+  pushArg(ImmPtr(pc));        // jsbytecode*
+  pushArg(ImmGCPtr(script));  // JSScript*
+  pushArg(envChain);          // JSObject*
 
   callVM(DefVarInfo, lir);
 }
 
 typedef bool (*DefLexicalFn)(JSContext*, HandleObject, HandleScript,
                              jsbytecode*);
 static const VMFunction DefLexicalInfo =
     FunctionInfo<DefLexicalFn>(DefLexicalOperation, "DefLexicalOperation");
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -145,18 +145,17 @@ class IonTryNoteFilter {
   }
 
   bool operator()(const JSTryNote* note) { return note->stackDepth <= depth_; }
 };
 
 class TryNoteIterIon : public TryNoteIter<IonTryNoteFilter> {
  public:
   TryNoteIterIon(JSContext* cx, const InlineFrameIterator& frame)
-      : TryNoteIter(cx, frame.script(), frame.pc(),
-                    IonTryNoteFilter(frame)) {}
+      : TryNoteIter(cx, frame.script(), frame.pc(), IonTryNoteFilter(frame)) {}
 };
 
 static void HandleExceptionIon(JSContext* cx, const InlineFrameIterator& frame,
                                ResumeFromException* rfe,
                                bool* hitBailoutException) {
   if (cx->realm()->isDebuggee()) {
     // We need to bail when there is a catchable exception, and we are the
     // debuggee of a Debugger with a live onExceptionUnwind hook, or if a
@@ -318,18 +317,17 @@ class BaselineTryNoteFilter {
     uint32_t currDepth = frame_->numValueSlots() - frame_->script()->nfixed();
     return note->stackDepth <= currDepth;
   }
 };
 
 class TryNoteIterBaseline : public TryNoteIter<BaselineTryNoteFilter> {
  public:
   TryNoteIterBaseline(JSContext* cx, BaselineFrame* frame, jsbytecode* pc)
-      : TryNoteIter(cx, frame->script(), pc, BaselineTryNoteFilter(frame)) {
-  }
+      : TryNoteIter(cx, frame->script(), pc, BaselineTryNoteFilter(frame)) {}
 };
 
 // Close all live iterators on a BaselineFrame due to exception unwinding. The
 // pc parameter is updated to where the envs have been unwound to.
 static void CloseLiveIteratorsBaselineForUncatchableException(
     JSContext* cx, const JSJitFrameIter& frame, jsbytecode* pc) {
   for (TryNoteIterBaseline tni(cx, frame.baselineFrame(), pc); !tni.done();
        ++tni) {
--- a/js/src/jit/arm64/Assembler-arm64.h
+++ b/js/src/jit/arm64/Assembler-arm64.h
@@ -38,26 +38,26 @@ static constexpr Register ScratchReg2{Re
 static constexpr ARMRegister ScratchReg2_64 = {ScratchReg2, 64};
 
 static constexpr FloatRegister ReturnDoubleReg = {FloatRegisters::d0,
                                                   FloatRegisters::Double};
 static constexpr FloatRegister ScratchDoubleReg = {FloatRegisters::d31,
                                                    FloatRegisters::Double};
 struct ScratchDoubleScope : public AutoFloatRegisterScope {
   explicit ScratchDoubleScope(MacroAssembler& masm)
-    : AutoFloatRegisterScope(masm, ScratchDoubleReg) {}
+      : AutoFloatRegisterScope(masm, ScratchDoubleReg) {}
 };
 
 static constexpr FloatRegister ReturnFloat32Reg = {FloatRegisters::s0,
                                                    FloatRegisters::Single};
 static constexpr FloatRegister ScratchFloat32Reg = {FloatRegisters::s31,
                                                     FloatRegisters::Single};
 struct ScratchFloat32Scope : public AutoFloatRegisterScope {
   explicit ScratchFloat32Scope(MacroAssembler& masm)
-    : AutoFloatRegisterScope(masm, ScratchFloat32Reg) {}
+      : AutoFloatRegisterScope(masm, ScratchFloat32Reg) {}
 };
 
 static constexpr Register InvalidReg{Registers::invalid_reg};
 static constexpr FloatRegister InvalidFloatReg = {FloatRegisters::invalid_fpreg,
                                                   FloatRegisters::Single};
 
 static constexpr Register OsrFrameReg{Registers::x3};
 static constexpr Register CallTempReg0{Registers::x9};
--- a/js/src/jit/arm64/MacroAssembler-arm64.cpp
+++ b/js/src/jit/arm64/MacroAssembler-arm64.cpp
@@ -488,20 +488,20 @@ void MacroAssembler::storeRegsInMask(Liv
     dest.offset -= reg.size();
     if (reg.isDouble()) {
       storeDouble(reg, dest);
     } else if (reg.isSingle()) {
       storeFloat32(reg, dest);
     } else {
       MOZ_CRASH("Unknown register type.");
     }
-
   }
   MOZ_ASSERT(numFpu == 0);
-  // Padding to keep the stack aligned, taken from the x64 and mips64 implementations.
+  // Padding to keep the stack aligned, taken from the x64 and mips64
+  // implementations.
   diffF -= diffF % sizeof(uintptr_t);
   MOZ_ASSERT(diffF == 0);
 }
 
 void MacroAssembler::PopRegsInMaskIgnore(LiveRegisterSet set,
                                          LiveRegisterSet ignore) {
   // The offset of the data from the stack pointer.
   uint32_t offset = 0;
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -3552,18 +3552,18 @@ CompileOptions& CompileOptions::setIntro
   RootedScript maybeScript(cx);
   const char* filename;
   unsigned lineno;
   uint32_t pcOffset;
   bool mutedErrors;
   DescribeScriptedCallerForCompilation(cx, &maybeScript, &filename, &lineno,
                                        &pcOffset, &mutedErrors);
   if (filename) {
-    return setIntroductionInfo(filename, introductionType, lineno,
-                               maybeScript, pcOffset);
+    return setIntroductionInfo(filename, introductionType, lineno, maybeScript,
+                               pcOffset);
   } else {
     return setIntroductionType(introductionType);
   }
 }
 
 #if defined(JS_BUILD_BINAST)
 
 JSScript* JS::DecodeBinAST(JSContext* cx, const ReadOnlyCompileOptions& options,
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -4208,19 +4208,19 @@ static T* findDebuggerInVector(Debugger*
     }
   }
   MOZ_ASSERT(p != vec->end());
   return p;
 }
 
 // a ReadBarriered version for findDebuggerInVector
 // TODO: Bug 1515934 - findDebuggerInVector<T> triggers read barriers.
-static ReadBarriered<Debugger*>*
-findDebuggerInVector(Debugger* dbg,
-                     Vector<ReadBarriered<Debugger*>, 0, js::SystemAllocPolicy>* vec) {
+static ReadBarriered<Debugger*>* findDebuggerInVector(
+    Debugger* dbg,
+    Vector<ReadBarriered<Debugger*>, 0, js::SystemAllocPolicy>* vec) {
   ReadBarriered<Debugger*>* p;
   for (p = vec->begin(); p != vec->end(); p++) {
     if (p->unbarrieredGet() == dbg) {
       break;
     }
   }
   MOZ_ASSERT(p != vec->end());
   return p;
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -1100,18 +1100,17 @@ class InterpreterTryNoteFilter {
  public:
   explicit InterpreterTryNoteFilter(const InterpreterRegs& regs)
       : regs_(regs) {}
   bool operator()(const JSTryNote* note) {
     return note->stackDepth <= regs_.stackDepth();
   }
 };
 
-class TryNoteIterInterpreter
-    : public TryNoteIter<InterpreterTryNoteFilter> {
+class TryNoteIterInterpreter : public TryNoteIter<InterpreterTryNoteFilter> {
  public:
   TryNoteIterInterpreter(JSContext* cx, const InterpreterRegs& regs)
       : TryNoteIter(cx, regs.fp()->script(), regs.pc,
                     InterpreterTryNoteFilter(regs)) {}
 };
 
 static void UnwindIteratorsForUncatchableException(
     JSContext* cx, const InterpreterRegs& regs) {
--- a/js/src/vm/Interpreter.h
+++ b/js/src/vm/Interpreter.h
@@ -410,17 +410,16 @@ class MOZ_STACK_CLASS TryNoteIter {
 
   bool pcInRange() const {
     // This checks both ends of the range at once
     // because unsigned integers wrap on underflow.
     uint32_t offset = pcOffset_;
     uint32_t start = tn_->start;
     uint32_t length = tn_->length;
     return offset - start < length;
-
   }
   bool done() const { return tn_ == tnEnd_; }
   const JSTryNote* operator*() const { return tn_; }
 };
 
 bool HandleClosingGeneratorReturn(JSContext* cx, AbstractFramePtr frame,
                                   bool ok);
 
--- a/js/src/vm/JSScript-inl.h
+++ b/js/src/vm/JSScript-inl.h
@@ -114,17 +114,17 @@ inline js::RegExpObject* JSScript::getRe
 inline js::GlobalObject& JSScript::global() const {
   /*
    * A JSScript always marks its realm's global (via bindings) so we can
    * assert that maybeGlobal is non-null here.
    */
   return *realm()->maybeGlobal();
 }
 
-inline bool JSScript::hasGlobal(const js::GlobalObject *global) const {
+inline bool JSScript::hasGlobal(const js::GlobalObject* global) const {
   return global == realm()->unsafeUnbarrieredMaybeGlobal();
 }
 
 inline js::LexicalScope* JSScript::maybeNamedLambdaScope() const {
   // Dynamically created Functions via the 'new Function' are considered
   // named lambdas but they do not have the named lambda scope of
   // textually-created named lambdas.
   js::Scope* scope = outermostScope();
--- a/js/src/vm/JSScript.cpp
+++ b/js/src/vm/JSScript.cpp
@@ -1377,17 +1377,18 @@ ScriptSourceObject* ScriptSourceObject::
   }
 
   // The slots below should either be populated by a call to initFromOptions or,
   // if this is a non-canonical ScriptSourceObject, they are unused. Poison
   // them.
   obj->initReservedSlot(ELEMENT_SLOT, MagicValue(JS_GENERIC_MAGIC));
   obj->initReservedSlot(ELEMENT_PROPERTY_SLOT, MagicValue(JS_GENERIC_MAGIC));
   obj->initReservedSlot(INTRODUCTION_SCRIPT_SLOT, MagicValue(JS_GENERIC_MAGIC));
-  obj->initReservedSlot(INTRODUCTION_SOURCE_OBJECT_SLOT, MagicValue(JS_GENERIC_MAGIC));
+  obj->initReservedSlot(INTRODUCTION_SOURCE_OBJECT_SLOT,
+                        MagicValue(JS_GENERIC_MAGIC));
 
   return obj;
 }
 
 ScriptSourceObject* ScriptSourceObject::create(JSContext* cx,
                                                ScriptSource* source) {
   return createInternal(cx, source, nullptr);
 }
--- a/js/src/vm/SavedStacks.cpp
+++ b/js/src/vm/SavedStacks.cpp
@@ -1672,18 +1672,18 @@ bool SavedStacks::getLocation(JSContext*
     }
   }
 
   locationp.set(p->value());
   return true;
 }
 
 void SavedStacks::chooseSamplingProbability(Realm* realm) {
-  // Use unbarriered version to prevent triggering read barrier while collecting,
-  // this is safe as long as global does not escape.
+  // Use unbarriered version to prevent triggering read barrier while
+  // collecting, this is safe as long as global does not escape.
   GlobalObject* global = realm->unsafeUnbarrieredMaybeGlobal();
   if (!global) {
     return;
   }
 
   GlobalObject::DebuggerVector* dbgs = global->getDebuggers();
   if (!dbgs || dbgs->empty()) {
     return;
@@ -1698,18 +1698,17 @@ void SavedStacks::chooseSamplingProbabil
     // such that the vector gets reallocated.
     MOZ_ASSERT(dbgs->begin() == begin);
     // Use unbarrieredGet() to prevent triggering read barrier while collecting,
     // this is safe as long as dbgp does not escape.
     Debugger* dbgp = p->unbarrieredGet();
 
     if (dbgp->trackingAllocationSites && dbgp->enabled) {
       foundAnyDebuggers = true;
-      probability =
-          std::max(dbgp->allocationSamplingProbability, probability);
+      probability = std::max(dbgp->allocationSamplingProbability, probability);
     }
   }
   MOZ_ASSERT(foundAnyDebuggers);
 
   if (!bernoulliSeeded) {
     mozilla::Array<uint64_t, 2> seed;
     GenerateXorShift128PlusSeed(seed);
     bernoulli.setRandomState(seed[0], seed[1]);
--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -1320,17 +1320,17 @@ class MOZ_STACK_CLASS JS_HAZ_ROOTED Modu
   };
 
   using SigSet = HashSet<HashableSig, HashableSig>;
   using FuncImportMap = HashMap<NamedSig, uint32_t, NamedSig>;
   using GlobalMap = HashMap<PropertyName*, Global*>;
   using MathNameMap = HashMap<PropertyName*, MathBuiltin>;
   using ArrayViewVector = Vector<ArrayView>;
 
-protected:
+ protected:
   JSContext* cx_;
   CodeNode* moduleFunctionNode_;
   PropertyName* moduleFunctionName_;
   PropertyName* globalArgumentName_ = nullptr;
   PropertyName* importArgumentName_ = nullptr;
   PropertyName* bufferArgumentName_ = nullptr;
   MathNameMap standardLibraryMathNames_;
   RootedFunction dummyFunction_;
--- a/js/src/wasm/WasmCompile.cpp
+++ b/js/src/wasm/WasmCompile.cpp
@@ -254,18 +254,20 @@ static const double arm64IonBytecodesPer
 
 // Tiering cutoff values: if code section sizes are below these values (when
 // divided by the effective number of cores) we do not tier, because we guess
 // that parallel Ion compilation will be fast enough.
 
 static const double x64DesktopTierCutoff = x64IonBytecodesPerMs * tierCutoffMs;
 static const double x86DesktopTierCutoff = x86IonBytecodesPerMs * tierCutoffMs;
 static const double x86MobileTierCutoff = x86DesktopTierCutoff / 2;  // Guess
-static const double arm32MobileTierCutoff = arm32IonBytecodesPerMs * tierCutoffMs;
-static const double arm64MobileTierCutoff = arm64IonBytecodesPerMs * tierCutoffMs;
+static const double arm32MobileTierCutoff =
+    arm32IonBytecodesPerMs * tierCutoffMs;
+static const double arm64MobileTierCutoff =
+    arm64IonBytecodesPerMs * tierCutoffMs;
 
 static double CodesizeCutoff(SystemClass cls) {
   switch (cls) {
     case SystemClass::DesktopX86:
     case SystemClass::DesktopUnknown32:
       return x86DesktopTierCutoff;
     case SystemClass::DesktopX64:
     case SystemClass::DesktopUnknown64:
--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -696,17 +696,14 @@ static void LayoutModuleDtor() {
   mozilla::image::ShutdownModule();
   gfxPlatform::Shutdown();
   gfx::gfxVars::Shutdown();
 
   nsScriptSecurityManager::Shutdown();
   xpcModuleDtor();
 }
 
-static const mozilla::Module kLayoutModule = {mozilla::Module::kVersion,
-                                              kLayoutCIDs,
-                                              kLayoutContracts,
-                                              kLayoutCategories,
-                                              nullptr,
-                                              Initialize,
-                                              LayoutModuleDtor};
+static const mozilla::Module kLayoutModule = {
+    mozilla::Module::kVersion, kLayoutCIDs, kLayoutContracts,
+    kLayoutCategories,         nullptr,     Initialize,
+    LayoutModuleDtor};
 
 NSMODULE_DEFN(nsLayoutModule) = &kLayoutModule;
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -9,39 +9,40 @@
 #ifndef nsIFrame_h___
 #define nsIFrame_h___
 
 #ifndef MOZILLA_INTERNAL_API
 #error This header/class should only be used within Mozilla code. It should not be used by extensions.
 #endif
 
 #if (defined(XP_WIN) && !defined(HAVE_64BIT_BUILD)) || defined(ANDROID)
-// Blink's magic depth limit from its HTML parser (513) plus as much as fits in the
-// default run-time stack on armv7 Android on Dalvik when using display: block minus
-// a bit just to be sure. The Dalvik default stack crashes at 588. ART can do a few
-// frames more. Using the same number for 32-bit Windows for consistency. Over there,
-// Blink's magic depth of 513 doesn't fit in the default stack of 1 MB, but this magic
-// depth fits when the default is grown by mere 192 KB (tested in 64 KB increments).
+// Blink's magic depth limit from its HTML parser (513) plus as much as fits in
+// the default run-time stack on armv7 Android on Dalvik when using display:
+// block minus a bit just to be sure. The Dalvik default stack crashes at 588.
+// ART can do a few frames more. Using the same number for 32-bit Windows for
+// consistency. Over there, Blink's magic depth of 513 doesn't fit in the
+// default stack of 1 MB, but this magic depth fits when the default is grown by
+// mere 192 KB (tested in 64 KB increments).
 //
 // 32-bit Windows has a different limit compared to 64-bit desktop, because the
-// default stack size affects all threads and consumes address space. Fixing that
-// is bug 1257522.
+// default stack size affects all threads and consumes address space. Fixing
+// that is bug 1257522.
 //
-// 32-bit Android on ARM already happens to have defaults that are close enough to
-// what makes sense as a temporary measure on Windows, so adjusting the Android
-// stack can be a follow-up. The stack on 64-bit ARM needs adjusting in any case
-// before 64-bit ARM can become tier-1. See bug 1400811.
+// 32-bit Android on ARM already happens to have defaults that are close enough
+// to what makes sense as a temporary measure on Windows, so adjusting the
+// Android stack can be a follow-up. The stack on 64-bit ARM needs adjusting in
+// any case before 64-bit ARM can become tier-1. See bug 1400811.
 //
-// Ideally, we'd get rid of this smaller limit and make 32-bit Windows and Android
-// capable of working with the Linux/Mac/Win64 number below.
+// Ideally, we'd get rid of this smaller limit and make 32-bit Windows and
+// Android capable of working with the Linux/Mac/Win64 number below.
 #define MAX_REFLOW_DEPTH 585
 #else
-// Blink's magic depth limit from its HTML parser times two. Also just about fits
-// within the system default runtime stack limit of 8 MB on 64-bit Mac and Linux with
-// display: table-cell.
+// Blink's magic depth limit from its HTML parser times two. Also just about
+// fits within the system default runtime stack limit of 8 MB on 64-bit Mac and
+// Linux with display: table-cell.
 #define MAX_REFLOW_DEPTH 1026
 #endif
 
 /* nsIFrame is in the process of being deCOMtaminated, i.e., this file is
    eventually going to be eliminated, and all callers will use nsFrame instead.
    At the moment we're midway through this process, so you will see inlined
    functions and member variables in this file.  -dwh */
 
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -1622,18 +1622,19 @@ ImgDrawResult nsImageFrame::DisplayAltFe
           LayoutDeviceRect::FromAppUnits(dest, factor));
       destRect.Round();
 
       Maybe<SVGImageContext> svgContext;
       IntSize decodeSize =
           nsLayoutUtils::ComputeImageContainerDrawingParameters(
               imgCon, this, destRect, aSc, aFlags, svgContext);
       RefPtr<ImageContainer> container;
-      result = imgCon->GetImageContainerAtSize(
-          aManager->LayerManager(), decodeSize, svgContext, aFlags, getter_AddRefs(container));
+      result = imgCon->GetImageContainerAtSize(aManager->LayerManager(),
+                                               decodeSize, svgContext, aFlags,
+                                               getter_AddRefs(container));
       if (container) {
         bool wrResult = aManager->CommandBuilder().PushImage(
             aItem, container, aBuilder, aResources, aSc, destRect, bounds);
         result &= wrResult ? ImgDrawResult::SUCCESS : ImgDrawResult::NOT_READY;
       } else {
         // We don't use &= here because we want the result to be NOT_READY so
         // the next block executes.
         result = ImgDrawResult::NOT_READY;
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -1893,17 +1893,17 @@ bool BuildTextRunsScanner::ContinueTextR
         }
 
         aFrame = aFrame->GetParent();
       }
       return false;
     };
 
     const nsIFrame* ancestor =
-      nsLayoutUtils::FindNearestCommonAncestorFrame(aFrame1, aFrame2);
+        nsLayoutUtils::FindNearestCommonAncestorFrame(aFrame1, aFrame2);
     MOZ_ASSERT(ancestor);
 
     // Map inline-end and inline-start to physical sides for checking presence
     // of non-zero margin/border/padding.
     Side side1 = wm.PhysicalSide(eLogicalSideIEnd);
     Side side2 = wm.PhysicalSide(eLogicalSideIStart);
     // If the frames have an embedding level that is opposite to the writing
     // mode, we need to swap which sides we're checking.
--- a/layout/style/nsDOMCSSDeclaration.h
+++ b/layout/style/nsDOMCSSDeclaration.h
@@ -28,17 +28,17 @@ class DeclarationBlock;
 struct DeclarationBlockMutationClosure;
 namespace css {
 class Loader;
 class Rule;
 }  // namespace css
 namespace dom {
 class Document;
 class Element;
-}
+}  // namespace dom
 
 struct MutationClosureData {
   MutationClosureData() : mClosure(nullptr), mElement(nullptr), mModType(0) {}
 
   // mClosure is non-null as long as the closure hasn't been called.
   // This is needed so that it can be guaranteed that
   // InlineStyleDeclarationWillChange is always called before
   // SetInlineStyleDeclaration.
--- a/mobile/android/components/geckoview/GeckoViewHistory.h
+++ b/mobile/android/components/geckoview/GeckoViewHistory.h
@@ -16,17 +16,17 @@
 #include "mozilla/StaticPtr.h"
 
 class nsIWidget;
 
 namespace mozilla {
 namespace dom {
 class Document;
 }
-}
+}  // namespace mozilla
 
 struct VisitedURI {
   nsCOMPtr<nsIURI> mURI;
   bool mVisited = false;
 };
 
 struct TrackedURI {
   // Per `IHistory`, these are not owning references.
--- a/netwerk/base/nsIOService.cpp
+++ b/netwerk/base/nsIOService.cpp
@@ -444,17 +444,18 @@ void nsIOService::NotifySocketProcessPre
 
   if (!XRE_IsParentProcess()) {
     return;
   }
 
   dom::Pref pref(nsCString(aName), /* isLocked */ false, null_t(), null_t());
   Preferences::GetPreference(&pref);
   auto sendPrefUpdate = [pref]() {
-    Unused << gIOService->mSocketProcess->GetActor()->SendPreferenceUpdate(pref);
+    Unused << gIOService->mSocketProcess->GetActor()->SendPreferenceUpdate(
+        pref);
   };
   CallOrWaitForSocketProcess(sendPrefUpdate);
 }
 
 void nsIOService::OnProcessLaunchComplete(SocketProcessHost *aHost,
                                           bool aSucceeded) {
   MOZ_ASSERT(NS_IsMainThread());
 
@@ -464,23 +465,24 @@ void nsIOService::OnProcessLaunchComplet
 
   if (mShutdown || !SocketProcessReady()) {
     return;
   }
 
   if (!mPendingEvents.IsEmpty()) {
     nsTArray<std::function<void()>> pendingEvents;
     mPendingEvents.SwapElements(pendingEvents);
-    for (auto& func : pendingEvents) {
+    for (auto &func : pendingEvents) {
       func();
     }
   }
 }
 
-void nsIOService::CallOrWaitForSocketProcess(const std::function<void()>& aFunc) {
+void nsIOService::CallOrWaitForSocketProcess(
+    const std::function<void()> &aFunc) {
   MOZ_ASSERT(NS_IsMainThread());
   if (IsSocketProcessLaunchComplete() && SocketProcessReady()) {
     aFunc();
   } else {
     mPendingEvents.AppendElement(aFunc);  // infallible
   }
 }
 
@@ -494,19 +496,19 @@ void nsIOService::OnProcessUnexpectedShu
 
   LOG(("nsIOService::OnProcessUnexpectedShutdown\n"));
   DestroySocketProcess();
 }
 
 RefPtr<MemoryReportingProcess> nsIOService::GetSocketProcessMemoryReporter() {
   // Check the prefs here again, since we don't want to create
   // SocketProcessMemoryReporter for some tests.
-  if (!Preferences::GetBool("network.process.enabled") || !SocketProcessReady()) {
+  if (!Preferences::GetBool("network.process.enabled") ||
+      !SocketProcessReady()) {
     return nullptr;
-
   }
 
   return new SocketProcessMemoryReporter();
 }
 
 NS_IMETHODIMP
 nsIOService::SocketProcessTelemetryPing() {
   CallOrWaitForSocketProcess([]() {
--- a/netwerk/ipc/SocketProcessHost.cpp
+++ b/netwerk/ipc/SocketProcessHost.cpp
@@ -57,18 +57,18 @@ class OfflineObserver final : public nsI
       if (!mProcessHost->IsConnected() ||
           mProcessHost->GetActor()->SendSetOffline(
               !strcmp(offline, "true") ? true : false)) {
         return NS_ERROR_NOT_AVAILABLE;
       }
     } else if (!strcmp(aTopic, NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID)) {
       nsCOMPtr<nsIObserverService> obs =
           mozilla::services::GetObserverService();
-        obs->RemoveObserver(this, NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC);
-        obs->RemoveObserver(this, NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID);
+      obs->RemoveObserver(this, NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC);
+      obs->RemoveObserver(this, NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID);
     }
 
     return NS_OK;
   }
   virtual ~OfflineObserver() = default;
 
   SocketProcessHost* mProcessHost;
 };
--- a/parser/htmlparser/nsParserModule.cpp
+++ b/parser/htmlparser/nsParserModule.cpp
@@ -10,18 +10,17 @@
 
 //----------------------------------------------------------------------
 
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsParser)
 
 NS_DEFINE_NAMED_CID(NS_PARSER_CID);
 
 static const mozilla::Module::CIDEntry kParserCIDs[] = {
-    {&kNS_PARSER_CID, false, nullptr, nsParserConstructor},
-    {nullptr}};
+    {&kNS_PARSER_CID, false, nullptr, nsParserConstructor}, {nullptr}};
 
 static nsresult Initialize() {
   nsresult rv = nsHTMLTags::AddRefTable();
   NS_ENSURE_SUCCESS(rv, rv);
 
 #ifdef DEBUG
   CheckElementTable();
   nsHTMLTags::TestTagTable();
--- a/storage/mozStorageConnection.cpp
+++ b/storage/mozStorageConnection.cpp
@@ -598,18 +598,20 @@ nsresult Connection::initialize() {
   // in memory database requested, sqlite uses a magic file name
   int srv = ::sqlite3_open_v2(":memory:", &mDBConn, mFlags, GetVFSName());
   if (srv != SQLITE_OK) {
     mDBConn = nullptr;
     return convertResultCode(srv);
   }
 
 #ifdef MOZ_SQLITE_FTS3_TOKENIZER
-  srv = ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
-  MOZ_ASSERT(srv == SQLITE_OK, "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
+  srv =
+      ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
+  MOZ_ASSERT(srv == SQLITE_OK,
+             "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
 #endif
 
   // Do not set mDatabaseFile or mFileURL here since this is a "memory"
   // database.
 
   nsresult rv = initializeInternal();
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -637,18 +639,20 @@ nsresult Connection::initialize(nsIFile 
   int srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn,
                               mFlags, vfs);
   if (srv != SQLITE_OK) {
     mDBConn = nullptr;
     return convertResultCode(srv);
   }
 
 #ifdef MOZ_SQLITE_FTS3_TOKENIZER
-  srv = ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
-  MOZ_ASSERT(srv == SQLITE_OK, "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
+  srv =
+      ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
+  MOZ_ASSERT(srv == SQLITE_OK,
+             "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
 #endif
 
   // Do not set mFileURL here since this is database does not have an associated
   // URL.
   mDatabaseFile = aDatabaseFile;
 
   rv = initializeInternal();
   NS_ENSURE_SUCCESS(rv, rv);
@@ -671,18 +675,20 @@ nsresult Connection::initialize(nsIFileU
 
   int srv = ::sqlite3_open_v2(spec.get(), &mDBConn, mFlags, GetVFSName());
   if (srv != SQLITE_OK) {
     mDBConn = nullptr;
     return convertResultCode(srv);
   }
 
 #ifdef MOZ_SQLITE_FTS3_TOKENIZER
-  srv = ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
-  MOZ_ASSERT(srv == SQLITE_OK, "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
+  srv =
+      ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
+  MOZ_ASSERT(srv == SQLITE_OK,
+             "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
 #endif
 
   // Set both mDatabaseFile and mFileURL here.
   mFileURL = aFileURL;
   mDatabaseFile = databaseFile;
 
   rv = initializeInternal();
   NS_ENSURE_SUCCESS(rv, rv);
--- a/toolkit/components/reputationservice/ApplicationReputation.cpp
+++ b/toolkit/components/reputationservice/ApplicationReputation.cpp
@@ -478,17 +478,18 @@ static const char* const kBinaryFileExte
     ".cfg",        // Windows
     ".chi",        // Windows Help
     ".chm",        // Windows Help
     ".class",      // Java
     ".cmd",        // Windows executable
     ".com",        // Windows executable
     ".command",    // Mac script
     ".cpgz",       // Mac archive
-    ".cpi",        // Control Panel Item. Executable used for adding icons to Control Panel
+    ".cpi",        // Control Panel Item. Executable used for adding icons
+                   // to Control Panel
     //".cpio",
     ".cpl",         // Windows executable
     ".crt",         // Windows signed certificate
     ".crx",         // Chrome extensions
     ".csh",         // Linux shell
     ".dart",        // Mac disk image
     ".dc42",        // Apple DiskCopy Image
     ".deb",         // Linux package
--- a/widget/gtk/IMContextWrapper.cpp
+++ b/widget/gtk/IMContextWrapper.cpp
@@ -274,17 +274,16 @@ class SelectionStyleProvider final {
       style.AppendPrintf("color:rgba(%u,%u,%u,",
                          NS_GET_R(selectionForegroundColor),
                          NS_GET_G(selectionForegroundColor),
                          NS_GET_B(selectionForegroundColor));
       // We can't use AppendPrintf here, because it does locale-specific
       // formatting of floating-point values.
       style.AppendFloat(alpha);
       style.AppendPrintf(");");
-
     }
     nscolor selectionBackgroundColor;
     if (NS_SUCCEEDED(
             LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectBackground,
                                   &selectionBackgroundColor))) {
       double alpha =
           static_cast<double>(NS_GET_A(selectionBackgroundColor)) / 0xFF;
       style.AppendPrintf("background-color:rgba(%u,%u,%u,",
--- a/widget/windows/nsSound.cpp
+++ b/widget/windows/nsSound.cpp
@@ -110,23 +110,26 @@ NS_IMPL_ISUPPORTS(nsSound, nsISound, nsI
 nsSound::nsSound() : mInited(false) {}
 
 nsSound::~nsSound() {}
 
 void nsSound::PurgeLastSound() {
   // Halt any currently playing sound.
   if (mSoundPlayer) {
     if (mPlayerThread) {
-      mPlayerThread->Dispatch(NS_NewRunnableFunction(
-        "nsSound::PurgeLastSound", [player = std::move(mSoundPlayer)]() {
-          // Capture move mSoundPlayer to lambda then
-          // PlaySoundW(nullptr, nullptr, SND_PURGE) will be called before
-          // freeing the nsSoundPlayer.
-          ::PlaySoundW(nullptr, nullptr, SND_PURGE);
-        }), NS_DISPATCH_NORMAL);
+      mPlayerThread->Dispatch(
+          NS_NewRunnableFunction("nsSound::PurgeLastSound",
+                                 [player = std::move(mSoundPlayer)]() {
+                                   // Capture move mSoundPlayer to lambda then
+                                   // PlaySoundW(nullptr, nullptr, SND_PURGE)
+                                   // will be called before freeing the
+                                   // nsSoundPlayer.
+                                   ::PlaySoundW(nullptr, nullptr, SND_PURGE);
+                                 }),
+          NS_DISPATCH_NORMAL);
     }
   }
 }
 
 NS_IMETHODIMP nsSound::Beep() {
   ::MessageBeep(0);
 
   return NS_OK;
--- a/xpcom/build/nsXULAppAPI.h
+++ b/xpcom/build/nsXULAppAPI.h
@@ -369,18 +369,17 @@ enum GeckoProcessType {
   GeckoProcessType_##enum_name,
 #include "mozilla/GeckoProcessTypes.h"
 #undef GECKO_PROCESS_TYPE
   GeckoProcessType_End,
   GeckoProcessType_Invalid = GeckoProcessType_End
 };
 
 static const char* const kGeckoProcessTypeString[] = {
-#define GECKO_PROCESS_TYPE(enum_name, string_name, xre_name) \
-  string_name,
+#define GECKO_PROCESS_TYPE(enum_name, string_name, xre_name) string_name,
 #include "mozilla/GeckoProcessTypes.h"
 #undef GECKO_PROCESS_TYPE
 };
 
 static_assert(MOZ_ARRAY_LENGTH(kGeckoProcessTypeString) == GeckoProcessType_End,
               "Array length mismatch");
 
 XRE_API(const char*, XRE_ChildProcessTypeToString,
--- a/xpcom/threads/TimerThread.cpp
+++ b/xpcom/threads/TimerThread.cpp
@@ -724,17 +724,18 @@ already_AddRefed<nsTimerImpl> TimerThrea
 #endif
 
   nsCOMPtr<nsIEventTarget> target = timer->mEventTarget;
 
   void* p = nsTimerEvent::operator new(sizeof(nsTimerEvent));
   if (!p) {
     return timer.forget();
   }
-  RefPtr<nsTimerEvent> event = ::new (KnownNotNull, p) nsTimerEvent(timer.forget());
+  RefPtr<nsTimerEvent> event =
+      ::new (KnownNotNull, p) nsTimerEvent(timer.forget());
 
   nsresult rv;
   {
     // We release mMonitor around the Dispatch because if this timer is targeted
     // at the TimerThread we'll deadlock.
     MonitorAutoUnlock unlock(mMonitor);
     rv = target->Dispatch(event, NS_DISPATCH_NORMAL);
   }