Bug 1523969 part 27 - Move method definition inline comments to new line in 'xpcom/'. r=froydnj
authorRyan Hunt <rhunt@eqrion.net>
Mon, 25 Feb 2019 16:14:01 -0600
changeset 519790 49477020b62874f586a180d2ff049a3d6fb4e587
parent 519789 0707c5d273227aed4fb04a8f6360875165f83ddd
child 519791 24572052e60fdec6f3ce83efdf0e12633d05d0d8
push id10862
push userffxbld-merge
push dateMon, 11 Mar 2019 13:01:11 +0000
treeherdermozilla-beta@a2e7f5c935da [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1523969
milestone67.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 1523969 part 27 - Move method definition inline comments to new line in 'xpcom/'. r=froydnj Differential Revision: https://phabricator.services.mozilla.com/D21131
xpcom/base/AvailableMemoryTracker.cpp
xpcom/base/CycleCollectedJSContext.cpp
xpcom/base/CycleCollectedJSRuntime.cpp
xpcom/base/DebuggerOnGCRunnable.cpp
xpcom/base/GkRustUtils.cpp
xpcom/base/MemoryInfo.cpp
xpcom/base/nsCycleCollector.cpp
xpcom/base/nsDebugImpl.cpp
xpcom/base/nsDumpUtils.cpp
xpcom/base/nsMemoryImpl.cpp
xpcom/base/nsMemoryInfoDumper.cpp
xpcom/base/nsMemoryReporterManager.cpp
xpcom/build/MainThreadIOLogger.cpp
xpcom/components/nsCategoryManager.cpp
xpcom/components/nsComponentManager.cpp
xpcom/ds/PLDHashTable.cpp
xpcom/io/InputStreamLengthHelper.cpp
xpcom/io/InputStreamLengthWrapper.cpp
xpcom/io/NonBlockingAsyncInputStream.cpp
xpcom/io/nsLocalFileWin.cpp
xpcom/tests/gtest/TestTArray2.cpp
xpcom/threads/AbstractThread.cpp
xpcom/threads/MainThreadIdlePeriod.cpp
xpcom/threads/SchedulerGroup.cpp
xpcom/threads/SystemGroup.cpp
xpcom/threads/nsProcessCommon.cpp
xpcom/threads/nsThread.cpp
xpcom/threads/nsThreadManager.cpp
xpcom/threads/nsTimerImpl.cpp
--- a/xpcom/base/AvailableMemoryTracker.cpp
+++ b/xpcom/base/AvailableMemoryTracker.cpp
@@ -129,42 +129,43 @@ void nsAvailableMemoryWatcher::Shutdown(
   }
 
   if (mTimer) {
     mTimer->Cancel();
     mTimer = nullptr;
   }
 }
 
-/* static */ bool nsAvailableMemoryWatcher::IsVirtualMemoryLow(
-    const MEMORYSTATUSEX& aStat) {
+/* static */
+bool nsAvailableMemoryWatcher::IsVirtualMemoryLow(const MEMORYSTATUSEX& aStat) {
   if ((kLowVirtualMemoryThreshold != 0) &&
       (aStat.ullAvailVirtual < kLowVirtualMemoryThreshold)) {
     sNumLowVirtualMemEvents++;
     return true;
   }
 
   return false;
 }
 
-/* static */ bool nsAvailableMemoryWatcher::IsCommitSpaceLow(
-    const MEMORYSTATUSEX& aStat) {
+/* static */
+bool nsAvailableMemoryWatcher::IsCommitSpaceLow(const MEMORYSTATUSEX& aStat) {
   if ((kLowCommitSpaceThreshold != 0) &&
       (aStat.ullAvailPageFile < kLowCommitSpaceThreshold)) {
     sNumLowCommitSpaceEvents++;
     CrashReporter::AnnotateCrashReport(
         CrashReporter::Annotation::LowCommitSpaceEvents,
         uint32_t(sNumLowCommitSpaceEvents));
     return true;
   }
 
   return false;
 }
 
-/* static */ bool nsAvailableMemoryWatcher::IsPhysicalMemoryLow(
+/* static */
+bool nsAvailableMemoryWatcher::IsPhysicalMemoryLow(
     const MEMORYSTATUSEX& aStat) {
   if ((kLowPhysicalMemoryThreshold != 0) &&
       (aStat.ullAvailPhys < kLowPhysicalMemoryThreshold)) {
     sNumLowPhysicalMemEvents++;
     return true;
   }
 
   return false;
--- a/xpcom/base/CycleCollectedJSContext.cpp
+++ b/xpcom/base/CycleCollectedJSContext.cpp
@@ -178,18 +178,18 @@ nsresult CycleCollectedJSContext::Initia
 
   InitializeCommon();
 
   nsCycleCollector_registerNonPrimaryContext(this);
 
   return NS_OK;
 }
 
-/* static */ CycleCollectedJSContext* CycleCollectedJSContext::GetFor(
-    JSContext* aCx) {
+/* static */
+CycleCollectedJSContext* CycleCollectedJSContext::GetFor(JSContext* aCx) {
   // Cast from void* matching JS_SetContextPrivate.
   auto atomCache = static_cast<PerThreadAtomCache*>(JS_GetContextPrivate(aCx));
   // Down cast.
   return static_cast<CycleCollectedJSContext*>(atomCache);
 }
 
 size_t CycleCollectedJSContext::SizeOfExcludingThis(
     MallocSizeOf aMallocSizeOf) const {
--- a/xpcom/base/CycleCollectedJSRuntime.cpp
+++ b/xpcom/base/CycleCollectedJSRuntime.cpp
@@ -722,18 +722,19 @@ void CycleCollectedJSRuntime::TraverseZo
   /*
    * To find C++ children of things in the zone, we scan every JS Object in
    * the zone. Only JS Objects can have C++ children.
    */
   TraverseObjectShimClosure closure = {aCb, this};
   js::IterateGrayObjects(aZone, TraverseObjectShim, &closure);
 }
 
-/* static */ void CycleCollectedJSRuntime::TraverseObjectShim(
-    void* aData, JS::GCCellPtr aThing) {
+/* static */
+void CycleCollectedJSRuntime::TraverseObjectShim(void* aData,
+                                                 JS::GCCellPtr aThing) {
   TraverseObjectShimClosure* closure =
       static_cast<TraverseObjectShimClosure*>(aData);
 
   MOZ_ASSERT(aThing.is<JSObject>());
   closure->self->TraverseGCThing(CycleCollectedJSRuntime::TRAVERSE_CPP, aThing,
                                  closure->cb);
 }
 
@@ -757,45 +758,46 @@ void CycleCollectedJSRuntime::TraverseNa
     }
 
     if (noteRoot) {
       aCb.NoteNativeRoot(holder, tracer);
     }
   }
 }
 
-/* static */ void CycleCollectedJSRuntime::TraceBlackJS(JSTracer* aTracer,
-                                                        void* aData) {
+/* static */
+void CycleCollectedJSRuntime::TraceBlackJS(JSTracer* aTracer, void* aData) {
   CycleCollectedJSRuntime* self = static_cast<CycleCollectedJSRuntime*>(aData);
 
   self->TraceNativeBlackRoots(aTracer);
 }
 
-/* static */ void CycleCollectedJSRuntime::TraceGrayJS(JSTracer* aTracer,
-                                                       void* aData) {
+/* static */
+void CycleCollectedJSRuntime::TraceGrayJS(JSTracer* aTracer, void* aData) {
   CycleCollectedJSRuntime* self = static_cast<CycleCollectedJSRuntime*>(aData);
 
   // Mark these roots as gray so the CC can walk them later.
   self->TraceNativeGrayRoots(aTracer);
 }
 
-/* static */ void CycleCollectedJSRuntime::GCCallback(JSContext* aContext,
-                                                      JSGCStatus aStatus,
-                                                      void* aData) {
+/* static */
+void CycleCollectedJSRuntime::GCCallback(JSContext* aContext,
+                                         JSGCStatus aStatus, void* aData) {
   CycleCollectedJSRuntime* self = static_cast<CycleCollectedJSRuntime*>(aData);
 
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Context() == aContext);
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Runtime() == self);
 
   self->OnGC(aContext, aStatus);
 }
 
-/* static */ void CycleCollectedJSRuntime::GCSliceCallback(
-    JSContext* aContext, JS::GCProgress aProgress,
-    const JS::GCDescription& aDesc) {
+/* static */
+void CycleCollectedJSRuntime::GCSliceCallback(JSContext* aContext,
+                                              JS::GCProgress aProgress,
+                                              const JS::GCDescription& aDesc) {
   CycleCollectedJSRuntime* self = CycleCollectedJSRuntime::Get();
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Context() == aContext);
 
 #ifdef MOZ_GECKO_PROFILER
   if (profiler_thread_is_being_profiled()) {
     if (aProgress == JS::GC_CYCLE_END) {
       profiler_add_marker(
           "GCMajor", JS::ProfilingCategoryPair::GCCC,
@@ -860,17 +862,18 @@ class MinorGCMarker : public TimelineMar
 
   virtual UniquePtr<AbstractTimelineMarker> Clone() override {
     auto clone = MakeUnique<MinorGCMarker>(GetTracingType(), mReason);
     clone->SetCustomTime(GetTime());
     return UniquePtr<AbstractTimelineMarker>(std::move(clone));
   }
 };
 
-/* static */ void CycleCollectedJSRuntime::GCNurseryCollectionCallback(
+/* static */
+void CycleCollectedJSRuntime::GCNurseryCollectionCallback(
     JSContext* aContext, JS::GCNurseryProgress aProgress,
     JS::GCReason aReason) {
   CycleCollectedJSRuntime* self = CycleCollectedJSRuntime::Get();
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Context() == aContext);
   MOZ_ASSERT(NS_IsMainThread());
 
   RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();
   if (timelines && !timelines->IsEmpty()) {
@@ -892,27 +895,29 @@ class MinorGCMarker : public TimelineMar
   }
 #endif
 
   if (self->mPrevGCNurseryCollectionCallback) {
     self->mPrevGCNurseryCollectionCallback(aContext, aProgress, aReason);
   }
 }
 
-/* static */ void CycleCollectedJSRuntime::OutOfMemoryCallback(
-    JSContext* aContext, void* aData) {
+/* static */
+void CycleCollectedJSRuntime::OutOfMemoryCallback(JSContext* aContext,
+                                                  void* aData) {
   CycleCollectedJSRuntime* self = static_cast<CycleCollectedJSRuntime*>(aData);
 
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Context() == aContext);
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Runtime() == self);
 
   self->OnOutOfMemory();
 }
 
-/* static */ size_t CycleCollectedJSRuntime::SizeofExternalStringCallback(
+/* static */
+size_t CycleCollectedJSRuntime::SizeofExternalStringCallback(
     JSString* aStr, MallocSizeOf aMallocSizeOf) {
   // We promised the JS engine we would not GC.  Enforce that:
   JS::AutoCheckCannotGC autoCannotGC;
 
   if (!XPCStringConvert::IsDOMString(aStr)) {
     // Might be a literal or something we don't understand.  Just claim 0.
     return 0;
   }
@@ -1438,17 +1443,18 @@ void CycleCollectedJSRuntime::Environmen
   DebugOnly<bool> ok = closure(aes.cx());
 
   MOZ_ASSERT_IF(ok, !JS_IsExceptionPending(aes.cx()));
 
   // The AutoEntryScript will check for JS_IsExceptionPending on the
   // JSContext and report it as needed as it comes off the stack.
 }
 
-/* static */ CycleCollectedJSRuntime* CycleCollectedJSRuntime::Get() {
+/* static */
+CycleCollectedJSRuntime* CycleCollectedJSRuntime::Get() {
   auto context = CycleCollectedJSContext::Get();
   if (context) {
     return context->Runtime();
   }
   return nullptr;
 }
 
 #ifdef MOZ_JS_DEV_ERROR_INTERCEPTOR
@@ -1457,17 +1463,18 @@ namespace js {
 extern void DumpValue(const JS::Value& val);
 }
 
 void CycleCollectedJSRuntime::ErrorInterceptor::Shutdown(JSRuntime* rt) {
   JS_SetErrorInterceptorCallback(rt, nullptr);
   mThrownError.reset();
 }
 
-/* virtual */ void CycleCollectedJSRuntime::ErrorInterceptor::interceptError(
+/* virtual */
+void CycleCollectedJSRuntime::ErrorInterceptor::interceptError(
     JSContext* cx, JS::HandleValue exn) {
   if (mThrownError) {
     // We already have an error, we don't need anything more.
     return;
   }
 
   if (!nsContentUtils::ThreadsafeIsSystemCaller(cx)) {
     // We are only interested in chrome code.
--- a/xpcom/base/DebuggerOnGCRunnable.cpp
+++ b/xpcom/base/DebuggerOnGCRunnable.cpp
@@ -9,18 +9,19 @@
 #include "mozilla/dom/ScriptSettings.h"
 #include "mozilla/CycleCollectedJSContext.h"
 #include "mozilla/Move.h"
 #include "mozilla/SystemGroup.h"
 #include "js/Debug.h"
 
 namespace mozilla {
 
-/* static */ nsresult DebuggerOnGCRunnable::Enqueue(
-    JSContext* aCx, const JS::GCDescription& aDesc) {
+/* static */
+nsresult DebuggerOnGCRunnable::Enqueue(JSContext* aCx,
+                                       const JS::GCDescription& aDesc) {
   auto gcEvent = aDesc.toGCEvent(aCx);
   if (!gcEvent) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   RefPtr<DebuggerOnGCRunnable> runOnGC =
       new DebuggerOnGCRunnable(std::move(gcEvent));
   if (NS_IsMainThread()) {
--- a/xpcom/base/GkRustUtils.cpp
+++ b/xpcom/base/GkRustUtils.cpp
@@ -5,11 +5,12 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "gk_rust_utils_ffi_generated.h"
 #include "nsString.h"
 #include "GkRustUtils.h"
 
 using namespace mozilla;
 
-/* static */ void GkRustUtils::GenerateUUID(nsACString& aResult) {
+/* static */
+void GkRustUtils::GenerateUUID(nsACString& aResult) {
   GkRustUtils_GenerateUUID(&aResult);
 };
--- a/xpcom/base/MemoryInfo.cpp
+++ b/xpcom/base/MemoryInfo.cpp
@@ -7,17 +7,18 @@
 #include "mozilla/MemoryInfo.h"
 
 #include "mozilla/DebugOnly.h"
 
 #include <winbase.h>
 
 namespace mozilla {
 
-/* static */ MemoryInfo MemoryInfo::Get(const void* aPtr, size_t aSize) {
+/* static */
+MemoryInfo MemoryInfo::Get(const void* aPtr, size_t aSize) {
   MemoryInfo result;
 
   result.mStart = uintptr_t(aPtr);
   const char* ptr = reinterpret_cast<const char*>(aPtr);
   const char* end = ptr + aSize;
   DebugOnly<void*> base = nullptr;
   while (ptr < end) {
     MEMORY_BASIC_INFORMATION basicInfo;
--- a/xpcom/base/nsCycleCollector.cpp
+++ b/xpcom/base/nsCycleCollector.cpp
@@ -3714,17 +3714,18 @@ void nsCycleCollector_forgetJSContext() 
     data->mContext = nullptr;
   } else {
     data->mContext = nullptr;
     delete data;
     sCollectorData.set(nullptr);
   }
 }
 
-/* static */ CycleCollectedJSContext* CycleCollectedJSContext::Get() {
+/* static */
+CycleCollectedJSContext* CycleCollectedJSContext::Get() {
   CollectorData* data = sCollectorData.get();
   if (data) {
     return data->mContext;
   }
   return nullptr;
 }
 
 MOZ_NEVER_INLINE static void SuspectAfterShutdown(
--- a/xpcom/base/nsDebugImpl.cpp
+++ b/xpcom/base/nsDebugImpl.cpp
@@ -197,17 +197,18 @@ nsDebugImpl::GetIsDebuggerAttached(bool*
   if (info.KP_FLAGS & P_TRACED) {
     *aResult = true;
   }
 #endif
 
   return NS_OK;
 }
 
-/* static */ void nsDebugImpl::SetMultiprocessMode(const char* aDesc) {
+/* static */
+void nsDebugImpl::SetMultiprocessMode(const char* aDesc) {
   sMultiprocessDescription = aDesc;
 }
 
 /* static */ const char* nsDebugImpl::GetMultiprocessMode() {
   return sMultiprocessDescription;
 }
 
 /**
--- a/xpcom/base/nsDumpUtils.cpp
+++ b/xpcom/base/nsDumpUtils.cpp
@@ -100,17 +100,18 @@ void FdWatcher::StopWatching() {
   if (mFd != -1) {
     close(mFd);
     mFd = -1;
   }
 }
 
 StaticRefPtr<SignalPipeWatcher> SignalPipeWatcher::sSingleton;
 
-/* static */ SignalPipeWatcher* SignalPipeWatcher::GetSingleton() {
+/* static */
+SignalPipeWatcher* SignalPipeWatcher::GetSingleton() {
   if (!sSingleton) {
     sSingleton = new SignalPipeWatcher();
     sSingleton->Init();
     ClearOnShutdown(&sSingleton);
   }
   return sSingleton;
 }
 
@@ -215,28 +216,30 @@ void SignalPipeWatcher::OnFileCanReadWit
       }
     }
   }
   LOG("SignalPipeWatcher got unexpected signum.");
 }
 
 StaticRefPtr<FifoWatcher> FifoWatcher::sSingleton;
 
-/* static */ FifoWatcher* FifoWatcher::GetSingleton() {
+/* static */
+FifoWatcher* FifoWatcher::GetSingleton() {
   if (!sSingleton) {
     nsAutoCString dirPath;
     Preferences::GetCString("memory_info_dumper.watch_fifo.directory", dirPath);
     sSingleton = new FifoWatcher(dirPath);
     sSingleton->Init();
     ClearOnShutdown(&sSingleton);
   }
   return sSingleton;
 }
 
-/* static */ bool FifoWatcher::MaybeCreate() {
+/* static */
+bool FifoWatcher::MaybeCreate() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!XRE_IsParentProcess()) {
     // We want this to be main-process only, since two processes can't listen
     // to the same fifo.
     return false;
   }
 
@@ -394,20 +397,19 @@ void FifoWatcher::OnFileCanReadWithoutBl
   LOG("Got unexpected value from fifo; ignoring it.");
 }
 
 #endif  // XP_UNIX }
 
 // In Android case, this function will open a file named aFilename under
 // /data/local/tmp/"aFoldername".
 // Otherwise, it will open a file named aFilename under "NS_OS_TEMP_DIR".
-/* static */ nsresult nsDumpUtils::OpenTempFile(const nsACString& aFilename,
-                                                nsIFile** aFile,
-                                                const nsACString& aFoldername,
-                                                Mode aMode) {
+/* static */
+nsresult nsDumpUtils::OpenTempFile(const nsACString& aFilename, nsIFile** aFile,
+                                   const nsACString& aFoldername, Mode aMode) {
 #ifdef ANDROID
   // For Android, first try the downloads directory which is world-readable
   // rather than the temp directory which is not.
   if (!*aFile) {
     char* env = PR_GetEnv("DOWNLOADS_DIRECTORY");
     if (env) {
       NS_NewNativeLocalFile(nsCString(env), /* followLinks = */ true, aFile);
     }
--- a/xpcom/base/nsMemoryImpl.cpp
+++ b/xpcom/base/nsMemoryImpl.cpp
@@ -59,18 +59,19 @@ nsMemoryImpl::IsLowMemoryPlatform(bool* 
   }
   *aResult = (sLowMemory == 1);
 #else
   *aResult = false;
 #endif
   return NS_OK;
 }
 
-/*static*/ nsresult nsMemoryImpl::Create(nsISupports* aOuter, const nsIID& aIID,
-                                         void** aResult) {
+/*static*/
+nsresult nsMemoryImpl::Create(nsISupports* aOuter, const nsIID& aIID,
+                              void** aResult) {
   if (NS_WARN_IF(aOuter)) {
     return NS_ERROR_NO_AGGREGATION;
   }
   return sGlobalMemory.QueryInterface(aIID, aResult);
 }
 
 nsresult nsMemoryImpl::FlushMemory(const char16_t* aReason, bool aImmediate) {
   nsresult rv = NS_OK;
--- a/xpcom/base/nsMemoryInfoDumper.cpp
+++ b/xpcom/base/nsMemoryInfoDumper.cpp
@@ -240,17 +240,18 @@ void OnFifoEnabledChange(const char* /*u
 #endif  // MOZ_SUPPORTS_FIFO }
 
 NS_IMPL_ISUPPORTS(nsMemoryInfoDumper, nsIMemoryInfoDumper)
 
 nsMemoryInfoDumper::nsMemoryInfoDumper() {}
 
 nsMemoryInfoDumper::~nsMemoryInfoDumper() {}
 
-/* static */ void nsMemoryInfoDumper::Initialize() {
+/* static */
+void nsMemoryInfoDumper::Initialize() {
 #if defined(MOZ_SUPPORTS_RT_SIGNALS)
   SignalPipeWatcher* sw = SignalPipeWatcher::GetSingleton();
 
   // Dump memory reporters (and those of our child processes)
   sDumpAboutMemorySignum = SIGRTMIN;
   sw->RegisterCallback(sDumpAboutMemorySignum, doMemoryReport);
   // Dump our memory reporters after minimizing memory usage
   sDumpAboutMemoryAfterMMUSignum = SIGRTMIN + 1;
--- a/xpcom/base/nsMemoryReporterManager.cpp
+++ b/xpcom/base/nsMemoryReporterManager.cpp
@@ -1983,17 +1983,18 @@ void nsMemoryReporterManager::HandleChil
 
   // If the call fails, ignore and continue.
   s->mHandleReport->Callback(aChildReport.process(), aChildReport.path(),
                              aChildReport.kind(), aChildReport.units(),
                              aChildReport.amount(), aChildReport.desc(),
                              s->mHandleReportData);
 }
 
-/* static */ bool nsMemoryReporterManager::StartChildReport(
+/* static */
+bool nsMemoryReporterManager::StartChildReport(
     mozilla::MemoryReportingProcess* aChild,
     const PendingProcessesState* aState) {
   if (!aChild->IsAlive()) {
     MEMORY_REPORTING_LOG(
         "StartChildReports (gen=%u): child exited before"
         " its report was started\n",
         aState->mGeneration);
     return false;
@@ -2060,18 +2061,18 @@ void nsMemoryReporterManager::EndProcess
     MOZ_ASSERT(s->mChildrenPending.IsEmpty());
     if (s->mTimer) {
       s->mTimer->Cancel();
     }
     FinishReporting();
   }
 }
 
-/* static */ void nsMemoryReporterManager::TimeoutCallback(nsITimer* aTimer,
-                                                           void* aData) {
+/* static */
+void nsMemoryReporterManager::TimeoutCallback(nsITimer* aTimer, void* aData) {
   nsMemoryReporterManager* mgr = static_cast<nsMemoryReporterManager*>(aData);
   PendingProcessesState* s = mgr->mPendingProcessesState;
 
   // Release assert because: if the pointer is null we're about to
   // crash regardless of DEBUG, and this way the compiler doesn't
   // complain about unused variables.
   MOZ_RELEASE_ASSERT(s, "mgr->mPendingProcessesState");
   MEMORY_REPORTING_LOG("TimeoutCallback (s->gen=%u; %u running, %u pending)\n",
@@ -2341,17 +2342,18 @@ nsMemoryReporterManager::GetResidentFast
 #ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
   return ResidentFastDistinguishedAmount(aAmount);
 #else
   *aAmount = 0;
   return NS_ERROR_NOT_AVAILABLE;
 #endif
 }
 
-/*static*/ int64_t nsMemoryReporterManager::ResidentFast() {
+/*static*/
+int64_t nsMemoryReporterManager::ResidentFast() {
 #ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
   int64_t amount;
   nsresult rv = ResidentFastDistinguishedAmount(&amount);
   NS_ENSURE_SUCCESS(rv, 0);
   return amount;
 #else
   return 0;
 #endif
@@ -2362,17 +2364,18 @@ nsMemoryReporterManager::GetResidentPeak
 #ifdef HAVE_RESIDENT_PEAK_REPORTER
   return ResidentPeakDistinguishedAmount(aAmount);
 #else
   *aAmount = 0;
   return NS_ERROR_NOT_AVAILABLE;
 #endif
 }
 
-/*static*/ int64_t nsMemoryReporterManager::ResidentPeak() {
+/*static*/
+int64_t nsMemoryReporterManager::ResidentPeak() {
 #ifdef HAVE_RESIDENT_PEAK_REPORTER
   int64_t amount = 0;
   nsresult rv = ResidentPeakDistinguishedAmount(&amount);
   NS_ENSURE_SUCCESS(rv, 0);
   return amount;
 #else
   return 0;
 #endif
@@ -2383,17 +2386,18 @@ nsMemoryReporterManager::GetResidentUniq
 #ifdef HAVE_RESIDENT_UNIQUE_REPORTER
   return ResidentUniqueDistinguishedAmount(aAmount);
 #else
   *aAmount = 0;
   return NS_ERROR_NOT_AVAILABLE;
 #endif
 }
 
-/*static*/ int64_t nsMemoryReporterManager::ResidentUnique() {
+/*static*/
+int64_t nsMemoryReporterManager::ResidentUnique() {
 #ifdef HAVE_RESIDENT_UNIQUE_REPORTER
   int64_t amount = 0;
   nsresult rv = ResidentUniqueDistinguishedAmount(&amount);
   NS_ENSURE_SUCCESS(rv, 0);
   return amount;
 #else
   return 0;
 #endif
--- a/xpcom/build/MainThreadIOLogger.cpp
+++ b/xpcom/build/MainThreadIOLogger.cpp
@@ -104,17 +104,18 @@ bool MainThreadIOLoggerImpl::Init() {
       PR_CreateThread(PR_USER_THREAD, &sIOThreadFunc, this, PR_PRIORITY_LOW,
                       PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
   if (!mIOThread) {
     return false;
   }
   return true;
 }
 
-/* static */ void MainThreadIOLoggerImpl::sIOThreadFunc(void* aArg) {
+/* static */
+void MainThreadIOLoggerImpl::sIOThreadFunc(void* aArg) {
   AUTO_PROFILER_REGISTER_THREAD("MainThreadIOLogger");
 
   NS_SetCurrentThreadName("MainThreadIOLogger");
   MainThreadIOLoggerImpl* obj = static_cast<MainThreadIOLoggerImpl*>(aArg);
   obj->IOThreadFunc();
 }
 
 void MainThreadIOLoggerImpl::IOThreadFunc() {
--- a/xpcom/components/nsCategoryManager.cpp
+++ b/xpcom/components/nsCategoryManager.cpp
@@ -317,24 +317,26 @@ NS_IMPL_QUERY_INTERFACE(nsCategoryManage
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsCategoryManager::AddRef() { return 2; }
 
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsCategoryManager::Release() { return 1; }
 
 nsCategoryManager* nsCategoryManager::gCategoryManager;
 
-/* static */ nsCategoryManager* nsCategoryManager::GetSingleton() {
+/* static */
+nsCategoryManager* nsCategoryManager::GetSingleton() {
   if (!gCategoryManager) {
     gCategoryManager = new nsCategoryManager();
   }
   return gCategoryManager;
 }
 
-/* static */ void nsCategoryManager::Destroy() {
+/* static */
+void nsCategoryManager::Destroy() {
   // The nsMemoryReporterManager gets destroyed before the nsCategoryManager,
   // so we don't need to unregister the nsCategoryManager as a memory reporter.
   // In debug builds we assert that unregistering fails, as a way (imperfect
   // but better than nothing) of testing the "destroyed before" part.
   MOZ_ASSERT(NS_FAILED(UnregisterWeakMemoryReporter(gCategoryManager)));
 
   delete gCategoryManager;
   gCategoryManager = nullptr;
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -423,28 +423,30 @@ mozilla::Module const* const* begin(AllS
 }
 
 #endif
 
 mozilla::Module const* const* end(AllStaticModules& _) {
   return &__stop_kPStaticModules;
 }
 
-/* static */ void nsComponentManagerImpl::InitializeStaticModules() {
+/* static */
+void nsComponentManagerImpl::InitializeStaticModules() {
   if (sExtraStaticModules) {
     return;
   }
 
   sExtraStaticModules = new nsTArray<const mozilla::Module*>;
 }
 
 nsTArray<nsComponentManagerImpl::ComponentLocation>*
     nsComponentManagerImpl::sModuleLocations;
 
-/* static */ void nsComponentManagerImpl::InitializeModuleLocations() {
+/* static */
+void nsComponentManagerImpl::InitializeModuleLocations() {
   if (sModuleLocations) {
     return;
   }
 
   sModuleLocations = new nsTArray<ComponentLocation>;
 }
 
 nsresult nsComponentManagerImpl::Init() {
--- a/xpcom/ds/PLDHashTable.cpp
+++ b/xpcom/ds/PLDHashTable.cpp
@@ -56,49 +56,55 @@ class AutoDestructorOp {
   explicit AutoDestructorOp(Checker& aChk) : mChk(aChk) {
     mChk.StartDestructorOp();
   }
   ~AutoDestructorOp() { mChk.EndDestructorOp(); }
 };
 
 #endif
 
-/* static */ PLDHashNumber PLDHashTable::HashStringKey(const void* aKey) {
+/* static */
+PLDHashNumber PLDHashTable::HashStringKey(const void* aKey) {
   return HashString(static_cast<const char*>(aKey));
 }
 
-/* static */ PLDHashNumber PLDHashTable::HashVoidPtrKeyStub(const void* aKey) {
+/* static */
+PLDHashNumber PLDHashTable::HashVoidPtrKeyStub(const void* aKey) {
   return nsPtrHashKey<void>::HashKey(aKey);
 }
 
-/* static */ bool PLDHashTable::MatchEntryStub(const PLDHashEntryHdr* aEntry,
-                                               const void* aKey) {
+/* static */
+bool PLDHashTable::MatchEntryStub(const PLDHashEntryHdr* aEntry,
+                                  const void* aKey) {
   const PLDHashEntryStub* stub = (const PLDHashEntryStub*)aEntry;
 
   return stub->key == aKey;
 }
 
-/* static */ bool PLDHashTable::MatchStringKey(const PLDHashEntryHdr* aEntry,
-                                               const void* aKey) {
+/* static */
+bool PLDHashTable::MatchStringKey(const PLDHashEntryHdr* aEntry,
+                                  const void* aKey) {
   const PLDHashEntryStub* stub = (const PLDHashEntryStub*)aEntry;
 
   // XXX tolerate null keys on account of sloppy Mozilla callers.
   return stub->key == aKey ||
          (stub->key && aKey &&
           strcmp((const char*)stub->key, (const char*)aKey) == 0);
 }
 
-/* static */ void PLDHashTable::MoveEntryStub(PLDHashTable* aTable,
-                                              const PLDHashEntryHdr* aFrom,
-                                              PLDHashEntryHdr* aTo) {
+/* static */
+void PLDHashTable::MoveEntryStub(PLDHashTable* aTable,
+                                 const PLDHashEntryHdr* aFrom,
+                                 PLDHashEntryHdr* aTo) {
   memcpy(aTo, aFrom, aTable->mEntrySize);
 }
 
-/* static */ void PLDHashTable::ClearEntryStub(PLDHashTable* aTable,
-                                               PLDHashEntryHdr* aEntry) {
+/* static */
+void PLDHashTable::ClearEntryStub(PLDHashTable* aTable,
+                                  PLDHashEntryHdr* aEntry) {
   memset(aEntry, 0, aTable->mEntrySize);
 }
 
 static const PLDHashTableOps gStubOps = {
     PLDHashTable::HashVoidPtrKeyStub, PLDHashTable::MatchEntryStub,
     PLDHashTable::MoveEntryStub, PLDHashTable::ClearEntryStub, nullptr};
 
 /* static */ const PLDHashTableOps* PLDHashTable::StubOps() {
@@ -267,18 +273,18 @@ void PLDHashTable::Hash2(PLDHashNumber a
 // Reserve mKeyHash 0 for free entries and 1 for removed-entry sentinels. Note
 // that a removed-entry sentinel need be stored only if the removed entry had
 // a colliding entry added after it. Therefore we can use 1 as the collision
 // flag in addition to the removed-entry sentinel value. Multiplicative hash
 // uses the high order bits of mKeyHash, so this least-significant reservation
 // should not hurt the hash function's effectiveness much.
 
 // Match an entry's mKeyHash against an unstored one computed from a key.
-/* static */ bool PLDHashTable::MatchSlotKeyhash(Slot& aSlot,
-                                                 const PLDHashNumber aKeyHash) {
+/* static */
+bool PLDHashTable::MatchSlotKeyhash(Slot& aSlot, const PLDHashNumber aKeyHash) {
   return (aSlot.KeyHash() & ~kCollisionFlag) == aKeyHash;
 }
 
 // Compute the address of the indexed entry in table.
 auto PLDHashTable::SlotForIndex(uint32_t aIndex) const -> Slot {
   return mEntryStore.SlotForIndex(aIndex, mEntrySize, CapacityFromHashShift());
 }
 
--- a/xpcom/io/InputStreamLengthHelper.cpp
+++ b/xpcom/io/InputStreamLengthHelper.cpp
@@ -59,18 +59,19 @@ class AvailableEvent final : public Runn
   std::function<void(int64_t aLength)> mCallback;
   nsCOMPtr<nsIEventTarget> mCallbackTarget;
 
   int64_t mSize;
 };
 
 }  // namespace
 
-/* static */ bool InputStreamLengthHelper::GetSyncLength(
-    nsIInputStream* aStream, int64_t* aLength) {
+/* static */
+bool InputStreamLengthHelper::GetSyncLength(nsIInputStream* aStream,
+                                            int64_t* aLength) {
   MOZ_ASSERT(aStream);
   MOZ_ASSERT(aLength);
 
   *aLength = -1;
 
   // Sync length access.
   nsCOMPtr<nsIInputStreamLength> streamLength = do_QueryInterface(aStream);
   if (streamLength) {
@@ -125,17 +126,18 @@ class AvailableEvent final : public Runn
     // Let's return -1. There is nothing else we can do here.
     return true;
   }
 
   *aLength = (int64_t)available;
   return true;
 }
 
-/* static */ void InputStreamLengthHelper::GetAsyncLength(
+/* static */
+void InputStreamLengthHelper::GetAsyncLength(
     nsIInputStream* aStream,
     const std::function<void(int64_t aLength)>& aCallback) {
   MOZ_ASSERT(aStream);
   MOZ_ASSERT(aCallback);
 
   // We don't want to allow this class to be used on workers because we are not
   // using the correct Runnable types.
   MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread() ||
--- a/xpcom/io/InputStreamLengthWrapper.cpp
+++ b/xpcom/io/InputStreamLengthWrapper.cpp
@@ -30,18 +30,18 @@ NS_INTERFACE_MAP_BEGIN(InputStreamLength
   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream,
                                      mWeakAsyncInputStream || !mInputStream)
   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamCallback,
                                      mWeakAsyncInputStream || !mInputStream)
   NS_INTERFACE_MAP_ENTRY(nsIInputStreamLength)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
 NS_INTERFACE_MAP_END
 
-/* static */ already_AddRefed<nsIInputStream>
-InputStreamLengthWrapper::MaybeWrap(
+/* static */
+already_AddRefed<nsIInputStream> InputStreamLengthWrapper::MaybeWrap(
     already_AddRefed<nsIInputStream> aInputStream, int64_t aLength) {
   nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
   MOZ_ASSERT(inputStream);
 
   nsCOMPtr<nsIInputStreamLength> length = do_QueryInterface(inputStream);
   if (length) {
     return inputStream.forget();
   }
--- a/xpcom/io/NonBlockingAsyncInputStream.cpp
+++ b/xpcom/io/NonBlockingAsyncInputStream.cpp
@@ -52,17 +52,18 @@ NS_INTERFACE_MAP_BEGIN(NonBlockingAsyncI
                                      mWeakIPCSerializableInputStream)
   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsISeekableStream,
                                      mWeakSeekableInputStream)
   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsITellableStream,
                                      mWeakTellableInputStream)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
 NS_INTERFACE_MAP_END
 
-/* static */ nsresult NonBlockingAsyncInputStream::Create(
+/* static */
+nsresult NonBlockingAsyncInputStream::Create(
     already_AddRefed<nsIInputStream> aInputStream,
     nsIAsyncInputStream** aResult) {
   MOZ_DIAGNOSTIC_ASSERT(aResult);
 
   nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
 
   bool nonBlocking = false;
   nsresult rv = inputStream->IsNonBlocking(&nonBlocking);
--- a/xpcom/io/nsLocalFileWin.cpp
+++ b/xpcom/io/nsLocalFileWin.cpp
@@ -1046,18 +1046,18 @@ static void StripRundll32(nsString& aCom
   }
 }
 
 // Returns the fully qualified path to an application handler based on
 // a parameterized command string. Note this routine should not be used
 // to launch the associated application as it strips parameters and
 // rundll.exe from the string. Designed for retrieving display information
 // on a particular handler.
-/* static */ bool nsLocalFile::CleanupCmdHandlerPath(
-    nsAString& aCommandHandler) {
+/* static */
+bool nsLocalFile::CleanupCmdHandlerPath(nsAString& aCommandHandler) {
   nsAutoString handlerCommand(aCommandHandler);
 
   // Straight command path:
   //
   // %SystemRoot%\system32\NOTEPAD.EXE var
   // "C:\Program Files\iTunes\iTunes.exe" var var
   // C:\Program Files\iTunes\iTunes.exe var var
   //
--- a/xpcom/tests/gtest/TestTArray2.cpp
+++ b/xpcom/tests/gtest/TestTArray2.cpp
@@ -278,18 +278,20 @@ class Moveable {
 
   Moveable(Moveable&& aOther) {
     // Do not increment sCount
   }
 
   static int Count() { return sCount; }
 };
 
-/* static */ int Countable::sCount = 0;
-/* static */ int Moveable::sCount = 0;
+/* static */
+int Countable::sCount = 0;
+/* static */
+int Moveable::sCount = 0;
 
 static nsTArray<int> returns_by_value() {
   nsTArray<int> result;
   return result;
 }
 
 TEST(TArray, test_return_by_value) {
   nsTArray<int> result = returns_by_value();
--- a/xpcom/threads/AbstractThread.cpp
+++ b/xpcom/threads/AbstractThread.cpp
@@ -232,17 +232,18 @@ void AbstractThread::InitMainThread() {
   }
 }
 
 void AbstractThread::DispatchStateChange(
     already_AddRefed<nsIRunnable> aRunnable) {
   GetCurrent()->TailDispatcher().AddStateChangeTask(this, std::move(aRunnable));
 }
 
-/* static */ void AbstractThread::DispatchDirectTask(
+/* static */
+void AbstractThread::DispatchDirectTask(
     already_AddRefed<nsIRunnable> aRunnable) {
   GetCurrent()->TailDispatcher().AddDirectTask(std::move(aRunnable));
 }
 
 /* static */
 already_AddRefed<AbstractThread> AbstractThread::CreateXPCOMThreadWrapper(
     nsIThread* aThread, bool aRequireTailDispatch) {
   RefPtr<EventTargetWrapper> wrapper =
--- a/xpcom/threads/MainThreadIdlePeriod.cpp
+++ b/xpcom/threads/MainThreadIdlePeriod.cpp
@@ -48,13 +48,12 @@ MainThreadIdlePeriod::GetIdlePeriodHint(
 
   if (!busySoon) {
     *aIdleDeadline = mLastIdleDeadline = currentGuess;
   }
 
   return NS_OK;
 }
 
-/* static */ float MainThreadIdlePeriod::GetLongIdlePeriod() {
-  return kLongIdlePeriodMS;
-}
+/* static */
+float MainThreadIdlePeriod::GetLongIdlePeriod() { return kLongIdlePeriodMS; }
 
 }  // namespace mozilla
--- a/xpcom/threads/SchedulerGroup.cpp
+++ b/xpcom/threads/SchedulerGroup.cpp
@@ -87,45 +87,46 @@ SchedulerEventTarget::IsOnCurrentThread(
   return NS_OK;
 }
 
 NS_IMETHODIMP_(bool)
 SchedulerEventTarget::IsOnCurrentThreadInfallible() {
   return NS_IsMainThread();
 }
 
-/* static */ nsresult SchedulerGroup::UnlabeledDispatch(
+/* static */
+nsresult SchedulerGroup::UnlabeledDispatch(
     TaskCategory aCategory, already_AddRefed<nsIRunnable>&& aRunnable) {
   if (NS_IsMainThread()) {
     return NS_DispatchToCurrentThread(std::move(aRunnable));
   } else {
     return NS_DispatchToMainThread(std::move(aRunnable));
   }
 }
 
-/* static */ void SchedulerGroup::MarkVsyncReceived() {
+/* static */
+void SchedulerGroup::MarkVsyncReceived() {
   if (gEarliestUnprocessedVsync) {
     // If we've seen a vsync already, but haven't handled it, keep the
     // older one.
     return;
   }
 
   MOZ_ASSERT(!NS_IsMainThread());
   bool inconsistent = false;
   TimeStamp creation = TimeStamp::ProcessCreation(&inconsistent);
   if (inconsistent) {
     return;
   }
 
   gEarliestUnprocessedVsync = (TimeStamp::Now() - creation).ToMicroseconds();
 }
 
-/* static */ void SchedulerGroup::MarkVsyncRan() {
-  gEarliestUnprocessedVsync = 0;
-}
+/* static */
+void SchedulerGroup::MarkVsyncRan() { gEarliestUnprocessedVsync = 0; }
 
 MOZ_THREAD_LOCAL(bool) SchedulerGroup::sTlsValidatingAccess;
 
 SchedulerGroup::SchedulerGroup() : mIsRunning(false) {
   if (NS_IsMainThread()) {
     sTlsValidatingAccess.infallibleInit();
   }
 }
@@ -197,18 +198,18 @@ void SchedulerGroup::Shutdown(bool aXPCO
 
 already_AddRefed<nsISerialEventTarget> SchedulerGroup::CreateEventTargetFor(
     TaskCategory aCategory) {
   RefPtr<SchedulerEventTarget> target =
       new SchedulerEventTarget(this, aCategory);
   return target.forget();
 }
 
-/* static */ SchedulerGroup* SchedulerGroup::FromEventTarget(
-    nsIEventTarget* aEventTarget) {
+/* static */
+SchedulerGroup* SchedulerGroup::FromEventTarget(nsIEventTarget* aEventTarget) {
   RefPtr<SchedulerEventTarget> target = do_QueryObject(aEventTarget);
   if (!target) {
     return nullptr;
   }
   return target->Dispatcher();
 }
 
 nsresult SchedulerGroup::LabeledDispatch(
@@ -218,17 +219,18 @@ nsresult SchedulerGroup::LabeledDispatch
   if (XRE_IsContentProcess()) {
     RefPtr<Runnable> internalRunnable =
         new Runnable(runnable.forget(), this, aDocGroup);
     return InternalUnlabeledDispatch(aCategory, internalRunnable.forget());
   }
   return UnlabeledDispatch(aCategory, runnable.forget());
 }
 
-/*static*/ nsresult SchedulerGroup::InternalUnlabeledDispatch(
+/*static*/
+nsresult SchedulerGroup::InternalUnlabeledDispatch(
     TaskCategory aCategory, already_AddRefed<Runnable>&& aRunnable) {
   if (NS_IsMainThread()) {
     // NS_DispatchToCurrentThread will not leak the passed in runnable
     // when it fails, so we don't need to do anything special.
     return NS_DispatchToCurrentThread(std::move(aRunnable));
   }
 
   RefPtr<Runnable> runnable(aRunnable);
@@ -245,17 +247,18 @@ nsresult SchedulerGroup::LabeledDispatch
     Unused << runnable->mRunnable.forget().take();
     nsrefcnt refcnt = runnable.get()->Release();
     MOZ_RELEASE_ASSERT(refcnt == 1, "still holding an unexpected reference!");
   }
 
   return rv;
 }
 
-/* static */ void SchedulerGroup::SetValidatingAccess(ValidationType aType) {
+/* static */
+void SchedulerGroup::SetValidatingAccess(ValidationType aType) {
   bool validating = aType == StartValidation;
   sTlsValidatingAccess.set(validating);
 
   dom::AutoJSAPI jsapi;
   jsapi.Init();
   js::EnableAccessValidation(jsapi.cx(), validating);
 }
 
--- a/xpcom/threads/SystemGroup.cpp
+++ b/xpcom/threads/SystemGroup.cpp
@@ -31,51 +31,55 @@ class SystemGroupImpl final : public Sch
 };
 
 StaticRefPtr<SystemGroupImpl> SystemGroupImpl::sSingleton;
 
 SystemGroupImpl::SystemGroupImpl() {
   CreateEventTargets(/* aNeedValidation = */ true);
 }
 
-/* static */ void SystemGroupImpl::InitStatic() {
+/* static */
+void SystemGroupImpl::InitStatic() {
   MOZ_ASSERT(!sSingleton);
   MOZ_ASSERT(NS_IsMainThread());
   sSingleton = new SystemGroupImpl();
 }
 
-/* static */ void SystemGroupImpl::ShutdownStatic() {
+/* static */
+void SystemGroupImpl::ShutdownStatic() {
   sSingleton->Shutdown(true);
   sSingleton = nullptr;
 }
 
-/* static */ SystemGroupImpl* SystemGroupImpl::Get() {
+/* static */
+SystemGroupImpl* SystemGroupImpl::Get() {
   MOZ_ASSERT(sSingleton);
   return sSingleton.get();
 }
 
 void SystemGroup::InitStatic() { SystemGroupImpl::InitStatic(); }
 
 void SystemGroup::Shutdown() { SystemGroupImpl::ShutdownStatic(); }
 
 bool SystemGroup::Initialized() { return SystemGroupImpl::Initialized(); }
 
-/* static */ nsresult SystemGroup::Dispatch(
-    TaskCategory aCategory, already_AddRefed<nsIRunnable>&& aRunnable) {
+/* static */
+nsresult SystemGroup::Dispatch(TaskCategory aCategory,
+                               already_AddRefed<nsIRunnable>&& aRunnable) {
   if (!SystemGroupImpl::Initialized()) {
     return NS_DispatchToMainThread(std::move(aRunnable));
   }
   return SystemGroupImpl::Get()->Dispatch(aCategory, std::move(aRunnable));
 }
 
-/* static */ nsISerialEventTarget* SystemGroup::EventTargetFor(
-    TaskCategory aCategory) {
+/* static */
+nsISerialEventTarget* SystemGroup::EventTargetFor(TaskCategory aCategory) {
   if (!SystemGroupImpl::Initialized()) {
     return GetMainThreadSerialEventTarget();
   }
   return SystemGroupImpl::Get()->EventTargetFor(aCategory);
 }
 
-/* static */ AbstractThread* SystemGroup::AbstractMainThreadFor(
-    TaskCategory aCategory) {
+/* static */
+AbstractThread* SystemGroup::AbstractMainThreadFor(TaskCategory aCategory) {
   MOZ_ASSERT(SystemGroupImpl::Initialized());
   return SystemGroupImpl::Get()->AbstractMainThreadFor(aCategory);
 }
--- a/xpcom/threads/nsProcessCommon.cpp
+++ b/xpcom/threads/nsProcessCommon.cpp
@@ -594,17 +594,18 @@ void nsProcess::AddExecutableCrashAnnota
       executableName.EqualsLiteral("pingsender.exe") ||
       executableName.EqualsLiteral("updater.exe")) {
     CrashReporter::AnnotateCrashReport(
         CrashReporter::Annotation::ExecutableName, executableName.get());
   }
 #endif  // defined(XP_WIN)
 }
 
-/* static */ void nsProcess::RemoveExecutableCrashAnnotation() {
+/* static */
+void nsProcess::RemoveExecutableCrashAnnotation() {
 #if defined(XP_WIN)
   CrashReporter::RemoveCrashReportAnnotation(
       CrashReporter::Annotation::ExecutableName);
 #endif  // defined(XP_WIN)
 }
 
 NS_IMETHODIMP
 nsProcess::GetStartHidden(bool* aStartHidden) {
--- a/xpcom/threads/nsThread.cpp
+++ b/xpcom/threads/nsThread.cpp
@@ -363,25 +363,28 @@ struct ThreadInitData {
   return sMutex;
 }
 
 /* static */ LinkedList<nsThread>& nsThread::ThreadList() {
   static LinkedList<nsThread> sList;
   return sList;
 }
 
-/* static */ void nsThread::ClearThreadList() {
+/* static */
+void nsThread::ClearThreadList() {
   OffTheBooksMutexAutoLock mal(ThreadListMutex());
   while (ThreadList().popFirst()) {
   }
 }
 
-/* static */ nsThreadEnumerator nsThread::Enumerate() { return {}; }
+/* static */
+nsThreadEnumerator nsThread::Enumerate() { return {}; }
 
-/* static */ uint32_t nsThread::MaxActiveThreads() {
+/* static */
+uint32_t nsThread::MaxActiveThreads() {
   OffTheBooksMutexAutoLock mal(ThreadListMutex());
   return sMaxActiveThreads;
 }
 
 void nsThread::AddToThreadList() {
   OffTheBooksMutexAutoLock mal(ThreadListMutex());
   MOZ_ASSERT(!isInList());
 
@@ -394,17 +397,18 @@ void nsThread::AddToThreadList() {
 void nsThread::MaybeRemoveFromThreadList() {
   OffTheBooksMutexAutoLock mal(ThreadListMutex());
   if (isInList()) {
     sActiveThreads--;
     removeFrom(ThreadList());
   }
 }
 
-/*static*/ void nsThread::ThreadFunc(void* aArg) {
+/*static*/
+void nsThread::ThreadFunc(void* aArg) {
   using mozilla::ipc::BackgroundChild;
 
   ThreadInitData* initData = static_cast<ThreadInitData*>(aArg);
   nsThread* self = initData->thread;  // strong reference
 
   MOZ_ASSERT(self->mEventTarget);
   MOZ_ASSERT(self->mEvents);
 
--- a/xpcom/threads/nsThreadManager.cpp
+++ b/xpcom/threads/nsThreadManager.cpp
@@ -73,17 +73,18 @@ void AssertIsOnMainThread() { MOZ_ASSERT
 #endif
 
 typedef nsTArray<NotNull<RefPtr<nsThread>>> nsThreadArray;
 
 static bool sShutdownComplete;
 
 //-----------------------------------------------------------------------------
 
-/* static */ void nsThreadManager::ReleaseThread(void* aData) {
+/* static */
+void nsThreadManager::ReleaseThread(void* aData) {
   if (sShutdownComplete) {
     // We've already completed shutdown and released the references to all or
     // our TLS wrappers. Don't try to release them again.
     return;
   }
 
   auto* thread = static_cast<nsThread*>(aData);
 
@@ -174,17 +175,18 @@ StaticRefPtr<ShutdownObserveHelper> gShu
 
 //-----------------------------------------------------------------------------
 
 /*static*/ nsThreadManager& nsThreadManager::get() {
   static nsThreadManager sInstance;
   return sInstance;
 }
 
-/* static */ void nsThreadManager::InitializeShutdownObserver() {
+/* static */
+void nsThreadManager::InitializeShutdownObserver() {
   MOZ_ASSERT(!gShutdownObserveHelper);
 
   RefPtr<ShutdownObserveHelper> observer;
   nsresult rv = ShutdownObserveHelper::Create(getter_AddRefs(observer));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return;
   }
 
--- a/xpcom/threads/nsTimerImpl.cpp
+++ b/xpcom/threads/nsTimerImpl.cpp
@@ -761,25 +761,27 @@ void nsTimerImpl::GetName(nsACString& aN
 void nsTimerImpl::SetHolder(nsTimerImplHolder* aHolder) { mHolder = aHolder; }
 
 nsTimer::~nsTimer() {}
 
 size_t nsTimer::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
   return aMallocSizeOf(this);
 }
 
-/* static */ RefPtr<nsTimer> nsTimer::WithEventTarget(nsIEventTarget* aTarget) {
+/* static */
+RefPtr<nsTimer> nsTimer::WithEventTarget(nsIEventTarget* aTarget) {
   if (!aTarget) {
     aTarget = mozilla::GetCurrentThreadEventTarget();
   }
   return do_AddRef(new nsTimer(aTarget));
 }
 
-/* static */ nsresult nsTimer::XPCOMConstructor(nsISupports* aOuter,
-                                                REFNSIID aIID, void** aResult) {
+/* static */
+nsresult nsTimer::XPCOMConstructor(nsISupports* aOuter, REFNSIID aIID,
+                                   void** aResult) {
   *aResult = nullptr;
   if (aOuter != nullptr) {
     return NS_ERROR_NO_AGGREGATION;
   }
 
   auto timer = WithEventTarget(nullptr);
 
   return timer->QueryInterface(aIID, aResult);