Bug 1523969 part 12 - Move method definition inline comments to new line in 'ipc/'. r=froydnj
authorRyan Hunt <rhunt@eqrion.net>
Mon, 25 Feb 2019 16:08:36 -0600
changeset 461893 e16639cc628dd65afbae8bfa83b8da8bef6d8bb3
parent 461892 a683a7c54dc47148e011b356e3d8450bfb2988e3
child 461894 f99b937e9e7ce91e7d648a37251d4af8d1d6da68
push id35631
push userrgurzau@mozilla.com
push dateFri, 01 Mar 2019 13:06:03 +0000
treeherdermozilla-central@d4e19870e27f [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 12 - Move method definition inline comments to new line in 'ipc/'. r=froydnj Differential Revision: https://phabricator.services.mozilla.com/D21112
ipc/glue/BrowserProcessSubThread.cpp
ipc/glue/CrashReporterClient.cpp
ipc/glue/CrashReporterHost.cpp
ipc/glue/CrossProcessSemaphore_posix.cpp
ipc/glue/CrossProcessSemaphore_unimplemented.cpp
ipc/glue/CrossProcessSemaphore_windows.cpp
ipc/glue/IPCStreamChild.cpp
ipc/glue/IPCStreamParent.cpp
ipc/glue/InProcessImpl.cpp
ipc/glue/MessageChannel.cpp
ipc/glue/ProcessChild.cpp
ipc/glue/SharedMemory.cpp
ipc/mscom/ActivationContext.cpp
ipc/mscom/AgileReference.cpp
ipc/mscom/DispatchForwarder.cpp
ipc/mscom/EnsureMTA.cpp
ipc/mscom/Interceptor.cpp
ipc/mscom/InterceptorLog.cpp
ipc/mscom/MainThreadHandoff.cpp
ipc/mscom/MainThreadInvoker.cpp
ipc/mscom/PassthruProxy.cpp
ipc/mscom/ProcessRuntime.cpp
ipc/mscom/Registration.cpp
ipc/mscom/SpinEvent.cpp
--- a/ipc/glue/BrowserProcessSubThread.cpp
+++ b/ipc/glue/BrowserProcessSubThread.cpp
@@ -23,17 +23,18 @@ static const char* kBrowserThreadNames[B
 //  "Chrome_FileThread",  // FILE
 //  "Chrome_DBThread",  // DB
 //  "Chrome_HistoryThread",  // HISTORY
 #if defined(OS_LINUX) || defined(OS_SOLARIS)
     "Gecko_Background_X11Thread",  // BACKGROUND_X11
 #endif
 };
 
-/* static */ StaticMutex BrowserProcessSubThread::sLock;
+/* static */
+StaticMutex BrowserProcessSubThread::sLock;
 BrowserProcessSubThread* BrowserProcessSubThread::sBrowserThreads[ID_COUNT] = {
     nullptr,  // IO
 //  nullptr,  // FILE
 //  nullptr,  // DB
 //  nullptr,  // HISTORY
 #if defined(OS_LINUX) || defined(OS_SOLARIS)
     nullptr,  // BACKGROUND_X11
 #endif
--- a/ipc/glue/CrashReporterClient.cpp
+++ b/ipc/glue/CrashReporterClient.cpp
@@ -29,32 +29,34 @@ void CrashReporterClient::AnnotateCrashR
   mMetadata->AnnotateCrashReport(aKey, aData);
 }
 
 void CrashReporterClient::AppendAppNotes(const nsCString& aData) {
   StaticMutexAutoLock lock(sLock);
   mMetadata->AppendAppNotes(aData);
 }
 
-/* static */ void CrashReporterClient::InitSingletonWithShmem(
-    const Shmem& aShmem) {
+/* static */
+void CrashReporterClient::InitSingletonWithShmem(const Shmem& aShmem) {
   {
     StaticMutexAutoLock lock(sLock);
 
     MOZ_ASSERT(!sClientSingleton);
     sClientSingleton = new CrashReporterClient(aShmem);
   }
 
   CrashReporter::NotifyCrashReporterClientCreated();
 }
 
-/* static */ void CrashReporterClient::DestroySingleton() {
+/* static */
+void CrashReporterClient::DestroySingleton() {
   StaticMutexAutoLock lock(sLock);
   sClientSingleton = nullptr;
 }
 
-/* static */ RefPtr<CrashReporterClient> CrashReporterClient::GetSingleton() {
+/* static */
+RefPtr<CrashReporterClient> CrashReporterClient::GetSingleton() {
   StaticMutexAutoLock lock(sLock);
   return sClientSingleton;
 }
 
 }  // namespace ipc
 }  // namespace mozilla
--- a/ipc/glue/CrashReporterHost.cpp
+++ b/ipc/glue/CrashReporterHost.cpp
@@ -150,19 +150,20 @@ bool CrashReporterHost::FinalizeCrashRep
 
   int32_t crashType = GetCrashType(annotations);
   NotifyCrashService(mProcessType, crashType, mDumpID);
 
   mFinalized = true;
   return true;
 }
 
-/* static */ void CrashReporterHost::NotifyCrashService(
-    GeckoProcessType aProcessType, int32_t aCrashType,
-    const nsString& aChildDumpID) {
+/* static */
+void CrashReporterHost::NotifyCrashService(GeckoProcessType aProcessType,
+                                           int32_t aCrashType,
+                                           const nsString& aChildDumpID) {
   if (!NS_IsMainThread()) {
     RefPtr<Runnable> runnable = NS_NewRunnableFunction(
         "ipc::CrashReporterHost::NotifyCrashService", [&]() -> void {
           CrashReporterHost::NotifyCrashService(aProcessType, aCrashType,
                                                 aChildDumpID);
         });
     RefPtr<nsIThread> mainThread = do_GetMainThread();
     SyncRunnable::DispatchToThread(mainThread, runnable);
--- a/ipc/glue/CrossProcessSemaphore_posix.cpp
+++ b/ipc/glue/CrossProcessSemaphore_posix.cpp
@@ -20,18 +20,19 @@ struct SemaphoreData {
   mozilla::Atomic<int32_t> mRefCount;
   uint32_t mInitialValue;
 };
 
 }  // namespace
 
 namespace mozilla {
 
-/* static */ CrossProcessSemaphore* CrossProcessSemaphore::Create(
-    const char*, uint32_t aInitialValue) {
+/* static */
+CrossProcessSemaphore* CrossProcessSemaphore::Create(const char*,
+                                                     uint32_t aInitialValue) {
   RefPtr<ipc::SharedMemoryBasic> sharedBuffer = new ipc::SharedMemoryBasic;
   if (!sharedBuffer->Create(sizeof(SemaphoreData))) {
     return nullptr;
   }
 
   if (!sharedBuffer->Map(sizeof(SemaphoreData))) {
     return nullptr;
   }
@@ -52,17 +53,18 @@ namespace mozilla {
   sem->mRefCount = &data->mRefCount;
   *sem->mRefCount = 1;
 
   data->mInitialValue = aInitialValue;
 
   return sem;
 }
 
-/* static */ CrossProcessSemaphore* CrossProcessSemaphore::Create(
+/* static */
+CrossProcessSemaphore* CrossProcessSemaphore::Create(
     CrossProcessSemaphoreHandle aHandle) {
   RefPtr<ipc::SharedMemoryBasic> sharedBuffer = new ipc::SharedMemoryBasic;
 
   if (!sharedBuffer->IsHandleValid(aHandle)) {
     return nullptr;
   }
 
   if (!sharedBuffer->SetHandle(aHandle, ipc::SharedMemory::RightsReadWrite)) {
--- a/ipc/glue/CrossProcessSemaphore_unimplemented.cpp
+++ b/ipc/glue/CrossProcessSemaphore_unimplemented.cpp
@@ -5,23 +5,24 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "CrossProcessSemaphore.h"
 
 #include "nsDebug.h"
 
 namespace mozilla {
 
-/* static */ CrossProcessSemaphore* CrossProcessSemaphore::Create(const char*,
-                                                                  uint32_t) {
+/* static */
+CrossProcessSemaphore* CrossProcessSemaphore::Create(const char*, uint32_t) {
   MOZ_CRASH("Cross-process semaphores not allowed on this platform.");
   return nullptr;
 }
 
-/* static */ CrossProcessSemaphore* CrossProcessSemaphore::Create(
+/* static */
+CrossProcessSemaphore* CrossProcessSemaphore::Create(
     CrossProcessSemaphoreHandle) {
   MOZ_CRASH("Cross-process semaphores not allowed on this platform.");
   return nullptr;
 }
 
 CrossProcessSemaphore::CrossProcessSemaphore() {
   MOZ_CRASH(
       "Cross-process semaphores not allowed on this platform - woah! We "
--- a/ipc/glue/CrossProcessSemaphore_windows.cpp
+++ b/ipc/glue/CrossProcessSemaphore_windows.cpp
@@ -12,30 +12,32 @@
 #include "nsISupportsImpl.h"
 #include "ProtocolUtils.h"
 
 using base::GetCurrentProcessHandle;
 using base::ProcessHandle;
 
 namespace mozilla {
 
-/* static */ CrossProcessSemaphore* CrossProcessSemaphore::Create(
-    const char*, uint32_t aInitialValue) {
+/* static */
+CrossProcessSemaphore* CrossProcessSemaphore::Create(const char*,
+                                                     uint32_t aInitialValue) {
   // We explicitly share this using DuplicateHandle, we do -not- want this to
   // be inherited by child processes by default! So no security attributes are
   // given.
   HANDLE semaphore =
       ::CreateSemaphoreA(nullptr, aInitialValue, 0x7fffffff, nullptr);
   if (!semaphore) {
     return nullptr;
   }
   return new CrossProcessSemaphore(semaphore);
 }
 
-/* static */ CrossProcessSemaphore* CrossProcessSemaphore::Create(
+/* static */
+CrossProcessSemaphore* CrossProcessSemaphore::Create(
     CrossProcessSemaphoreHandle aHandle) {
   DWORD flags;
   if (!::GetHandleInformation(aHandle, &flags)) {
     return nullptr;
   }
 
   return new CrossProcessSemaphore(aHandle);
 }
--- a/ipc/glue/IPCStreamChild.cpp
+++ b/ipc/glue/IPCStreamChild.cpp
@@ -61,17 +61,18 @@ class IPCStreamSourceChild final : publi
 
  private:
   explicit IPCStreamSourceChild(nsIAsyncInputStream* aInputStream)
       : IPCStreamSource(aInputStream) {}
 };
 
 }  // anonymous namespace
 
-/* static */ PChildToParentStreamChild* IPCStreamSource::Create(
+/* static */
+PChildToParentStreamChild* IPCStreamSource::Create(
     nsIAsyncInputStream* aInputStream, dom::ContentChild* aManager) {
   MOZ_ASSERT(aInputStream);
   MOZ_ASSERT(aManager);
 
   // PContent can only be used on the main thread
   MOZ_ASSERT(NS_IsMainThread());
 
   IPCStreamSourceChild* source = IPCStreamSourceChild::Create(aInputStream);
@@ -82,17 +83,18 @@ class IPCStreamSourceChild final : publi
   if (!aManager->SendPChildToParentStreamConstructor(source)) {
     return nullptr;
   }
 
   source->ActorConstructed();
   return source;
 }
 
-/* static */ PChildToParentStreamChild* IPCStreamSource::Create(
+/* static */
+PChildToParentStreamChild* IPCStreamSource::Create(
     nsIAsyncInputStream* aInputStream, PBackgroundChild* aManager) {
   MOZ_ASSERT(aInputStream);
   MOZ_ASSERT(aManager);
 
   IPCStreamSourceChild* source = IPCStreamSourceChild::Create(aInputStream);
   if (!source) {
     return nullptr;
   }
@@ -100,18 +102,18 @@ class IPCStreamSourceChild final : publi
   if (!aManager->SendPChildToParentStreamConstructor(source)) {
     return nullptr;
   }
 
   source->ActorConstructed();
   return source;
 }
 
-/* static */ IPCStreamSource* IPCStreamSource::Cast(
-    PChildToParentStreamChild* aActor) {
+/* static */
+IPCStreamSource* IPCStreamSource::Cast(PChildToParentStreamChild* aActor) {
   MOZ_ASSERT(aActor);
   return static_cast<IPCStreamSourceChild*>(aActor);
 }
 
 // Parent to Child implementation
 // ----------------------------------------------------------------------------
 
 namespace {
@@ -162,16 +164,17 @@ PParentToChildStreamChild* AllocPParentT
 
   return actor;
 }
 
 void DeallocPParentToChildStreamChild(PParentToChildStreamChild* aActor) {
   delete aActor;
 }
 
-/* static */ IPCStreamDestination* IPCStreamDestination::Cast(
+/* static */
+IPCStreamDestination* IPCStreamDestination::Cast(
     PParentToChildStreamChild* aActor) {
   MOZ_ASSERT(aActor);
   return static_cast<IPCStreamDestinationChild*>(aActor);
 }
 
 }  // namespace ipc
 }  // namespace mozilla
--- a/ipc/glue/IPCStreamParent.cpp
+++ b/ipc/glue/IPCStreamParent.cpp
@@ -59,17 +59,18 @@ class IPCStreamSourceParent final : publ
 
  private:
   explicit IPCStreamSourceParent(nsIAsyncInputStream* aInputStream)
       : IPCStreamSource(aInputStream) {}
 };
 
 }  // anonymous namespace
 
-/* static */ PParentToChildStreamParent* IPCStreamSource::Create(
+/* static */
+PParentToChildStreamParent* IPCStreamSource::Create(
     nsIAsyncInputStream* aInputStream, dom::ContentParent* aManager) {
   MOZ_ASSERT(aInputStream);
   MOZ_ASSERT(aManager);
 
   // PContent can only be used on the main thread
   MOZ_ASSERT(NS_IsMainThread());
 
   IPCStreamSourceParent* source = IPCStreamSourceParent::Create(aInputStream);
@@ -81,17 +82,18 @@ class IPCStreamSourceParent final : publ
     // no delete here, the manager will delete the actor for us.
     return nullptr;
   }
 
   source->ActorConstructed();
   return source;
 }
 
-/* static */ PParentToChildStreamParent* IPCStreamSource::Create(
+/* static */
+PParentToChildStreamParent* IPCStreamSource::Create(
     nsIAsyncInputStream* aInputStream, PBackgroundParent* aManager) {
   MOZ_ASSERT(aInputStream);
   MOZ_ASSERT(aManager);
 
   IPCStreamSourceParent* source = IPCStreamSourceParent::Create(aInputStream);
   if (!source) {
     return nullptr;
   }
@@ -100,18 +102,18 @@ class IPCStreamSourceParent final : publ
     // no delete here, the manager will delete the actor for us.
     return nullptr;
   }
 
   source->ActorConstructed();
   return source;
 }
 
-/* static */ IPCStreamSource* IPCStreamSource::Cast(
-    PParentToChildStreamParent* aActor) {
+/* static */
+IPCStreamSource* IPCStreamSource::Cast(PParentToChildStreamParent* aActor) {
   MOZ_ASSERT(aActor);
   return static_cast<IPCStreamSourceParent*>(aActor);
 }
 
 // Child to Parent implementation
 // ----------------------------------------------------------------------------
 
 namespace {
@@ -162,16 +164,17 @@ PChildToParentStreamParent* AllocPChildT
 
   return actor;
 }
 
 void DeallocPChildToParentStreamParent(PChildToParentStreamParent* aActor) {
   delete aActor;
 }
 
-/* static */ IPCStreamDestination* IPCStreamDestination::Cast(
+/* static */
+IPCStreamDestination* IPCStreamDestination::Cast(
     PChildToParentStreamParent* aActor) {
   MOZ_ASSERT(aActor);
   return static_cast<IPCStreamDestinationParent*>(aActor);
 }
 
 }  // namespace ipc
 }  // namespace mozilla
--- a/ipc/glue/InProcessImpl.cpp
+++ b/ipc/glue/InProcessImpl.cpp
@@ -18,35 +18,38 @@ namespace ipc {
 StaticRefPtr<InProcessParent> InProcessParent::sSingleton;
 StaticRefPtr<InProcessChild> InProcessChild::sSingleton;
 bool InProcessParent::sShutdown = false;
 
 //////////////////////////////////////////
 // InProcess actor lifecycle management //
 //////////////////////////////////////////
 
-/* static */ InProcessChild* InProcessChild::Singleton() {
+/* static */
+InProcessChild* InProcessChild::Singleton() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sSingleton) {
     InProcessParent::Startup();
   }
   return sSingleton;
 }
 
-/* static */ InProcessParent* InProcessParent::Singleton() {
+/* static */
+InProcessParent* InProcessParent::Singleton() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sSingleton) {
     InProcessParent::Startup();
   }
   return sSingleton;
 }
 
-/* static */ void InProcessParent::Startup() {
+/* static */
+void InProcessParent::Startup() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (sShutdown) {
     NS_WARNING("Could not get in-process actor while shutting down!");
     return;
   }
 
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
@@ -77,17 +80,18 @@ bool InProcessParent::sShutdown = false;
   parent.get()->AddRef();
   child.get()->AddRef();
 
   // Stash global references to fetch the other side of the reference.
   InProcessParent::sSingleton = parent.forget();
   InProcessChild::sSingleton = child.forget();
 }
 
-/* static */ void InProcessParent::Shutdown() {
+/* static */
+void InProcessParent::Shutdown() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sSingleton || sShutdown) {
     return;
   }
 
   sShutdown = true;
 
@@ -171,20 +175,22 @@ static IProtocol* GetOtherInProcessActor
     MOZ_ASSERT(otherActor->GetSide() != aActor->GetSide(), "Wrong side!");
     MOZ_ASSERT(otherActor->GetProtocolTypeId() == aActor->GetProtocolTypeId(),
                "Wrong type of protocol!");
   }
 
   return otherActor;
 }
 
-/* static */ IProtocol* InProcessParent::ChildActorFor(IProtocol* aActor) {
+/* static */
+IProtocol* InProcessParent::ChildActorFor(IProtocol* aActor) {
   MOZ_ASSERT(aActor && aActor->GetSide() == ParentSide);
   return GetOtherInProcessActor(aActor);
 }
 
-/* static */ IProtocol* InProcessChild::ParentActorFor(IProtocol* aActor) {
+/* static */
+IProtocol* InProcessChild::ParentActorFor(IProtocol* aActor) {
   MOZ_ASSERT(aActor && aActor->GetSide() == ChildSide);
   return GetOtherInProcessActor(aActor);
 }
 
 }  // namespace ipc
 }  // namespace mozilla
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -1138,17 +1138,18 @@ bool MessageChannel::MaybeInterceptSpeci
       IPC_LOG("Build IDs match message");
       mBuildIDsConfirmedMatch = true;
       return true;
     }
   }
   return false;
 }
 
-/* static */ bool MessageChannel::IsAlwaysDeferred(const Message& aMsg) {
+/* static */
+bool MessageChannel::IsAlwaysDeferred(const Message& aMsg) {
   // If a message is not NESTED_INSIDE_CPOW and not sync, then we always defer
   // it.
   return aMsg.nested_level() != IPC::Message::NESTED_INSIDE_CPOW &&
          !aMsg.is_sync();
 }
 
 bool MessageChannel::ShouldDeferMessage(const Message& aMsg) {
   // Never defer messages that have the highest nested level, even async
--- a/ipc/glue/ProcessChild.cpp
+++ b/ipc/glue/ProcessChild.cpp
@@ -26,17 +26,18 @@ ProcessChild::ProcessChild(ProcessId aPa
       mParentPid(aParentPid) {
   MOZ_ASSERT(mUILoop, "UILoop should be created by now");
   MOZ_ASSERT(!gProcessChild, "should only be one ProcessChild");
   gProcessChild = this;
 }
 
 ProcessChild::~ProcessChild() { gProcessChild = nullptr; }
 
-/* static */ void ProcessChild::QuickExit() {
+/* static */
+void ProcessChild::QuickExit() {
 #ifdef XP_WIN
   // In bug 1254829, the destructor got called when dll got detached on windows,
   // switch to TerminateProcess to bypass dll detach handler during the process
   // termination.
   TerminateProcess(GetCurrentProcess(), 0);
 #else
   _exit(0);
 #endif
--- a/ipc/glue/SharedMemory.cpp
+++ b/ipc/glue/SharedMemory.cpp
@@ -44,17 +44,18 @@ NS_IMPL_ISUPPORTS(ShmemReporter, nsIMemo
 
 SharedMemory::SharedMemory() : mAllocSize(0), mMappedSize(0) {
   static Atomic<bool> registered;
   if (registered.compareExchange(false, true)) {
     RegisterStrongMemoryReporter(new ShmemReporter());
   }
 }
 
-/*static*/ size_t SharedMemory::PageAlignedSize(size_t aSize) {
+/*static*/
+size_t SharedMemory::PageAlignedSize(size_t aSize) {
   size_t pageSize = SystemPageSize();
   size_t nPagesNeeded = size_t(ceil(double(aSize) / double(pageSize)));
   return pageSize * nPagesNeeded;
 }
 
 void SharedMemory::Created(size_t aNBytes) {
   mAllocSize = aNBytes;
   gShmemAllocated += mAllocSize;
@@ -66,17 +67,18 @@ void SharedMemory::Mapped(size_t aNBytes
 }
 
 void SharedMemory::Unmapped() {
   MOZ_ASSERT(gShmemMapped >= mMappedSize, "Can't unmap more than mapped");
   gShmemMapped -= mMappedSize;
   mMappedSize = 0;
 }
 
-/*static*/ void SharedMemory::Destroyed() {
+/*static*/
+void SharedMemory::Destroyed() {
   MOZ_ASSERT(gShmemAllocated >= mAllocSize,
              "Can't destroy more than allocated");
   gShmemAllocated -= mAllocSize;
   mAllocSize = 0;
 }
 
 }  // namespace ipc
 }  // namespace mozilla
--- a/ipc/mscom/ActivationContext.cpp
+++ b/ipc/mscom/ActivationContext.cpp
@@ -82,18 +82,18 @@ ActivationContext::~ActivationContext() 
   HANDLE actCtx;
   if (!::GetCurrentActCtx(&actCtx)) {
     return Result<uintptr_t, HRESULT>(HRESULT_FROM_WIN32(::GetLastError()));
   }
 
   return reinterpret_cast<uintptr_t>(actCtx);
 }
 
-/* static */ HRESULT ActivationContext::GetCurrentManifestPath(
-    nsAString& aOutManifestPath) {
+/* static */
+HRESULT ActivationContext::GetCurrentManifestPath(nsAString& aOutManifestPath) {
   aOutManifestPath.Truncate();
 
   SIZE_T bytesNeeded;
   BOOL ok = ::QueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX, nullptr,
                            nullptr, ActivationContextDetailedInformation,
                            nullptr, 0, &bytesNeeded);
   if (!ok) {
     DWORD err = ::GetLastError();
--- a/ipc/mscom/AgileReference.cpp
+++ b/ipc/mscom/AgileReference.cpp
@@ -153,17 +153,18 @@ AgileReference::Resolve(REFIID aIid, voi
     return S_OK;
   }
 
   // ...Whereas the GIT requires us to obtain the same interface that we
   // requested and then QI for the desired interface afterward.
   return originalInterface->QueryInterface(aIid, aOutInterface);
 }
 
-/* static */ IGlobalInterfaceTable* AgileReference::ObtainGit() {
+/* static */
+IGlobalInterfaceTable* AgileReference::ObtainGit() {
   // Internally to COM, the Global Interface Table is a singleton, therefore we
   // don't worry about holding onto this reference indefinitely.
   static IGlobalInterfaceTable* sGit = []() -> IGlobalInterfaceTable* {
     IGlobalInterfaceTable* result = nullptr;
     DebugOnly<HRESULT> hr = ::CoCreateInstance(
         CLSID_StdGlobalInterfaceTable, nullptr, CLSCTX_INPROC_SERVER,
         IID_IGlobalInterfaceTable, reinterpret_cast<void**>(&result));
     MOZ_ASSERT(SUCCEEDED(hr));
--- a/ipc/mscom/DispatchForwarder.cpp
+++ b/ipc/mscom/DispatchForwarder.cpp
@@ -8,19 +8,20 @@
 #include "mozilla/mscom/DispatchForwarder.h"
 #include "mozilla/mscom/MainThreadInvoker.h"
 
 #include <oleauto.h>
 
 namespace mozilla {
 namespace mscom {
 
-/* static */ HRESULT DispatchForwarder::Create(IInterceptor* aInterceptor,
-                                               STAUniquePtr<IDispatch>& aTarget,
-                                               IUnknown** aOutput) {
+/* static */
+HRESULT DispatchForwarder::Create(IInterceptor* aInterceptor,
+                                  STAUniquePtr<IDispatch>& aTarget,
+                                  IUnknown** aOutput) {
   MOZ_ASSERT(aInterceptor && aOutput);
   if (!aOutput) {
     return E_INVALIDARG;
   }
   *aOutput = nullptr;
   if (!aInterceptor) {
     return E_INVALIDARG;
   }
--- a/ipc/mscom/EnsureMTA.cpp
+++ b/ipc/mscom/EnsureMTA.cpp
@@ -53,17 +53,18 @@ class BackgroundMTAData {
 
 }  // anonymous namespace
 
 static mozilla::StaticAutoPtr<BackgroundMTAData> sMTAData;
 
 namespace mozilla {
 namespace mscom {
 
-/* static */ nsCOMPtr<nsIThread> EnsureMTA::GetMTAThread() {
+/* static */
+nsCOMPtr<nsIThread> EnsureMTA::GetMTAThread() {
   if (!sMTAData) {
     sMTAData = new BackgroundMTAData();
     ClearOnShutdown(&sMTAData, ShutdownPhase::ShutdownThreads);
   }
   return sMTAData->GetThread();
 }
 
 }  // namespace mscom
--- a/ipc/mscom/Interceptor.cpp
+++ b/ipc/mscom/Interceptor.cpp
@@ -187,20 +187,20 @@ class MOZ_RAII LoggedQIResult final {
 
 static detail::LiveSet& GetLiveSet() {
   static detail::LiveSet sLiveSet;
   return sLiveSet;
 }
 
 MOZ_THREAD_LOCAL(bool) Interceptor::tlsCreatingStdMarshal;
 
-/* static */ HRESULT Interceptor::Create(STAUniquePtr<IUnknown> aTarget,
-                                         IInterceptorSink* aSink,
-                                         REFIID aInitialIid,
-                                         void** aOutInterface) {
+/* static */
+HRESULT Interceptor::Create(STAUniquePtr<IUnknown> aTarget,
+                            IInterceptorSink* aSink, REFIID aInitialIid,
+                            void** aOutInterface) {
   MOZ_ASSERT(aOutInterface && aTarget && aSink);
   if (!aOutInterface) {
     return E_INVALIDARG;
   }
 
   detail::LiveSetAutoLock lock(GetLiveSet());
 
   RefPtr<IWeakReference> existingWeak(GetLiveSet().Get(aTarget.get()));
@@ -807,18 +807,18 @@ Interceptor::WeakRefQueryInterface(REFII
 }
 
 ULONG
 Interceptor::AddRef() { return WeakReferenceSupport::AddRef(); }
 
 ULONG
 Interceptor::Release() { return WeakReferenceSupport::Release(); }
 
-/* static */ HRESULT Interceptor::DisconnectRemotesForTarget(
-    IUnknown* aTarget) {
+/* static */
+HRESULT Interceptor::DisconnectRemotesForTarget(IUnknown* aTarget) {
   MOZ_ASSERT(aTarget);
 
   detail::LiveSetAutoLock lock(GetLiveSet());
 
   // It is not an error if the interceptor doesn't exist, so we return
   // S_FALSE instead of an error in that case.
   RefPtr<IWeakReference> existingWeak(GetLiveSet().Get(aTarget));
   if (!existingWeak) {
--- a/ipc/mscom/InterceptorLog.cpp
+++ b/ipc/mscom/InterceptorLog.cpp
@@ -244,17 +244,18 @@ bool Logger::VariantToString(const VARIA
     default: {
       aOut.AppendPrintf("(VariantToString failed, VARTYPE == 0x%04hx)",
                         aVariant.vt);
       return false;
     }
   }
 }
 
-/* static */ double Logger::GetElapsedTime() {
+/* static */
+double Logger::GetElapsedTime() {
   TimeStamp ts = TimeStamp::Now();
   TimeDuration duration = ts - TimeStamp::ProcessCreation();
   return duration.ToMicroseconds();
 }
 
 void Logger::LogQI(HRESULT aResult, IUnknown* aTarget, REFIID aIid,
                    IUnknown* aInterface, const TimeDuration* aOverheadDuration,
                    const TimeDuration* aGeckoDuration) {
@@ -476,44 +477,48 @@ static bool MaybeCreateLog(const char* a
   }
   ClearOnShutdown(&sLogger);
   return true;
 }
 
 namespace mozilla {
 namespace mscom {
 
-/* static */ bool InterceptorLog::Init() {
+/* static */
+bool InterceptorLog::Init() {
   static const bool isEnabled = MaybeCreateLog("MOZ_MSCOM_LOG_BASENAME");
   return isEnabled;
 }
 
-/* static */ void InterceptorLog::QI(HRESULT aResult, IUnknown* aTarget,
-                                     REFIID aIid, IUnknown* aInterface,
-                                     const TimeDuration* aOverheadDuration,
-                                     const TimeDuration* aGeckoDuration) {
+/* static */
+void InterceptorLog::QI(HRESULT aResult, IUnknown* aTarget, REFIID aIid,
+                        IUnknown* aInterface,
+                        const TimeDuration* aOverheadDuration,
+                        const TimeDuration* aGeckoDuration) {
   if (!sLogger) {
     return;
   }
   sLogger->LogQI(aResult, aTarget, aIid, aInterface, aOverheadDuration,
                  aGeckoDuration);
 }
 
-/* static */ void InterceptorLog::CaptureFrame(ICallFrame* aCallFrame,
-                                               IUnknown* aTargetInterface,
-                                               nsACString& aCapturedFrame) {
+/* static */
+void InterceptorLog::CaptureFrame(ICallFrame* aCallFrame,
+                                  IUnknown* aTargetInterface,
+                                  nsACString& aCapturedFrame) {
   if (!sLogger) {
     return;
   }
   sLogger->CaptureFrame(aCallFrame, aTargetInterface, aCapturedFrame);
 }
 
-/* static */ void InterceptorLog::Event(const nsACString& aCapturedFrame,
-                                        const TimeDuration& aOverheadDuration,
-                                        const TimeDuration& aGeckoDuration) {
+/* static */
+void InterceptorLog::Event(const nsACString& aCapturedFrame,
+                           const TimeDuration& aOverheadDuration,
+                           const TimeDuration& aGeckoDuration) {
   if (!sLogger) {
     return;
   }
   sLogger->LogEvent(aCapturedFrame, aOverheadDuration, aGeckoDuration);
 }
 
 }  // namespace mscom
 }  // namespace mozilla
--- a/ipc/mscom/MainThreadHandoff.cpp
+++ b/ipc/mscom/MainThreadHandoff.cpp
@@ -224,18 +224,19 @@ class MOZ_RAII LogEvent final {
   nsAutoCString mCapturedFrame;
 };
 
 }  // anonymous namespace
 
 namespace mozilla {
 namespace mscom {
 
-/* static */ HRESULT MainThreadHandoff::Create(
-    IHandlerProvider* aHandlerProvider, IInterceptorSink** aOutput) {
+/* static */
+HRESULT MainThreadHandoff::Create(IHandlerProvider* aHandlerProvider,
+                                  IInterceptorSink** aOutput) {
   RefPtr<MainThreadHandoff> handoff(new MainThreadHandoff(aHandlerProvider));
   return handoff->QueryInterface(IID_IInterceptorSink, (void**)aOutput);
 }
 
 MainThreadHandoff::MainThreadHandoff(IHandlerProvider* aHandlerProvider)
     : mRefCnt(0), mHandlerProvider(aHandlerProvider) {}
 
 MainThreadHandoff::~MainThreadHandoff() { MOZ_ASSERT(NS_IsMainThread()); }
--- a/ipc/mscom/MainThreadInvoker.cpp
+++ b/ipc/mscom/MainThreadInvoker.cpp
@@ -91,17 +91,18 @@ NtTestAlertPtr SyncRunnable::sNtTestAler
 
 }  // anonymous namespace
 
 namespace mozilla {
 namespace mscom {
 
 HANDLE MainThreadInvoker::sMainThread = nullptr;
 
-/* static */ bool MainThreadInvoker::InitStatics() {
+/* static */
+bool MainThreadInvoker::InitStatics() {
   nsCOMPtr<nsIThread> mainThread;
   nsresult rv = ::NS_GetMainThread(getter_AddRefs(mainThread));
   if (NS_FAILED(rv)) {
     return false;
   }
 
   PRThread* mainPrThread = nullptr;
   rv = mainThread->GetPRThread(&mainPrThread);
--- a/ipc/mscom/PassthruProxy.cpp
+++ b/ipc/mscom/PassthruProxy.cpp
@@ -372,17 +372,18 @@ PassthruProxyClassObject::CreateInstance
 }
 
 HRESULT
 PassthruProxyClassObject::LockServer(BOOL aLock) {
   // No-op since xul.dll is always in memory
   return S_OK;
 }
 
-/* static */ HRESULT PassthruProxy::Register() {
+/* static */
+HRESULT PassthruProxy::Register() {
   DWORD cookie;
   RefPtr<IClassFactory> classObj(new PassthruProxyClassObject());
   return ::CoRegisterClassObject(CLSID_PassthruProxy, classObj,
                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE,
                                  &cookie);
 }
 
 }  // namespace mscom
--- a/ipc/mscom/ProcessRuntime.cpp
+++ b/ipc/mscom/ProcessRuntime.cpp
@@ -263,17 +263,18 @@ ProcessRuntime::InitializeSecurity() {
 
   return ::CoInitializeSecurity(
       &sd, -1, nullptr, nullptr, RPC_C_AUTHN_LEVEL_DEFAULT,
       RPC_C_IMP_LEVEL_IDENTIFY, nullptr, EOAC_NONE, nullptr);
 }
 
 #if defined(MOZILLA_INTERNAL_API)
 
-/* static */ bool ProcessRuntime::IsWin32kLockedDown() {
+/* static */
+bool ProcessRuntime::IsWin32kLockedDown() {
   static const DynamicallyLinkedFunctionPtr<decltype(
       &::GetProcessMitigationPolicy)>
       pGetProcessMitigationPolicy(L"kernel32.dll",
                                   "GetProcessMitigationPolicy");
   if (!pGetProcessMitigationPolicy) {
     return false;
   }
 
--- a/ipc/mscom/Registration.cpp
+++ b/ipc/mscom/Registration.cpp
@@ -378,33 +378,35 @@ static CRITICAL_SECTION* GetMutex() {
 #if !defined(MOZILLA_INTERNAL_API)
     atexit([]() { DeleteCriticalSection(&UseGetMutexForAccess::sMutex); });
 #endif
     return UseGetMutexForAccess::sMutex;
   }();
   return &mutex;
 }
 
-/* static */ bool RegisteredProxy::Find(REFIID aIid, ITypeInfo** aTypeInfo) {
+/* static */
+bool RegisteredProxy::Find(REFIID aIid, ITypeInfo** aTypeInfo) {
   AutoCriticalSection lock(GetMutex());
 
   if (!sRegistry) {
     return false;
   }
 
   for (auto&& proxy : *sRegistry) {
     if (SUCCEEDED(proxy->GetTypeInfoForGuid(aIid, aTypeInfo))) {
       return true;
     }
   }
 
   return false;
 }
 
-/* static */ void RegisteredProxy::AddToRegistry(RegisteredProxy* aProxy) {
+/* static */
+void RegisteredProxy::AddToRegistry(RegisteredProxy* aProxy) {
   MOZ_ASSERT(aProxy);
 
   AutoCriticalSection lock(GetMutex());
 
   if (!sRegistry) {
     sRegistry = new Vector<RegisteredProxy*>();
 
 #if !defined(MOZILLA_INTERNAL_API)
@@ -413,17 +415,18 @@ static CRITICAL_SECTION* GetMutex() {
       return;
     }
 #endif
   }
 
   MOZ_ALWAYS_TRUE(sRegistry->emplaceBack(aProxy));
 }
 
-/* static */ void RegisteredProxy::DeleteFromRegistry(RegisteredProxy* aProxy) {
+/* static */
+void RegisteredProxy::DeleteFromRegistry(RegisteredProxy* aProxy) {
   MOZ_ASSERT(aProxy);
 
   AutoCriticalSection lock(GetMutex());
 
   MOZ_ASSERT(sRegistry && !sRegistry->empty());
 
   if (!sRegistry) {
     return;
--- a/ipc/mscom/SpinEvent.cpp
+++ b/ipc/mscom/SpinEvent.cpp
@@ -14,17 +14,18 @@
 #include "nsSystemInfo.h"
 
 namespace mozilla {
 namespace mscom {
 
 static const TimeDuration kMaxSpinTime = TimeDuration::FromMilliseconds(30);
 bool SpinEvent::sIsMulticore = false;
 
-/* static */ bool SpinEvent::InitStatics() {
+/* static */
+bool SpinEvent::InitStatics() {
   SYSTEM_INFO sysInfo;
   ::GetSystemInfo(&sysInfo);
   sIsMulticore = sysInfo.dwNumberOfProcessors > 1;
   return true;
 }
 
 SpinEvent::SpinEvent() : mDone(false) {
   static const bool gotStatics = InitStatics();