Bug 1523969 part 23 - Move method definition inline comments to new line in 'toolkit/'. r=ehsan
authorRyan Hunt <rhunt@eqrion.net>
Mon, 25 Feb 2019 16:12:51 -0600
changeset 461904 15132144bc25145fd4b0571358a676499972aad9
parent 461903 4ec53f720e55582f3450066dcb4f7ff1ec5d6a65
child 461905 9d07b7406ad2f3d1a4ca62321efc56825b04bd93
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)
reviewersehsan
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 23 - Move method definition inline comments to new line in 'toolkit/'. r=ehsan Differential Revision: https://phabricator.services.mozilla.com/D21124
toolkit/components/alerts/nsXULAlerts.cpp
toolkit/components/antitracking/AntiTrackingCommon.cpp
toolkit/components/browser/nsWebBrowser.cpp
toolkit/components/clearsitedata/ClearSiteData.cpp
toolkit/components/extensions/ExtensionPolicyService.cpp
toolkit/components/extensions/MatchPattern.cpp
toolkit/components/extensions/WebExtensionPolicy.cpp
toolkit/components/extensions/webrequest/StreamFilter.cpp
toolkit/components/extensions/webrequest/StreamFilterEvents.cpp
toolkit/components/extensions/webrequest/StreamFilterParent.cpp
toolkit/components/fuzzyfox/Fuzzyfox.cpp
toolkit/components/printingui/nsPrintingPromptService.cpp
toolkit/components/sessionstore/SessionStoreUtils.cpp
toolkit/components/telemetry/core/Stopwatch.cpp
toolkit/components/url-classifier/LookupCache.cpp
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
toolkit/recordreplay/Assembler.cpp
toolkit/recordreplay/File.cpp
toolkit/recordreplay/Lock.cpp
toolkit/recordreplay/Thread.cpp
toolkit/recordreplay/ipc/Channel.cpp
toolkit/recordreplay/ipc/ChildProcess.cpp
toolkit/xre/nsAppStartupNotifier.cpp
--- a/toolkit/components/alerts/nsXULAlerts.cpp
+++ b/toolkit/components/alerts/nsXULAlerts.cpp
@@ -61,17 +61,18 @@ nsXULAlertObserver::Observe(nsISupports*
   return rv;
 }
 
 // We don't cycle collect nsXULAlerts since gXULAlerts will keep the instance
 // alive till shutdown anyway.
 NS_IMPL_ISUPPORTS(nsXULAlerts, nsIAlertsService, nsIAlertsDoNotDisturb,
                   nsIAlertsIconURI)
 
-/* static */ already_AddRefed<nsXULAlerts> nsXULAlerts::GetInstance() {
+/* static */
+already_AddRefed<nsXULAlerts> nsXULAlerts::GetInstance() {
   // Gecko on Android does not fully support XUL windows.
 #ifndef MOZ_WIDGET_ANDROID
   if (!gXULAlerts) {
     gXULAlerts = new nsXULAlerts();
     ClearOnShutdown(&gXULAlerts);
   }
 #endif  // MOZ_WIDGET_ANDROID
   RefPtr<nsXULAlerts> instance = gXULAlerts.get();
--- a/toolkit/components/antitracking/AntiTrackingCommon.cpp
+++ b/toolkit/components/antitracking/AntiTrackingCommon.cpp
@@ -921,18 +921,18 @@ AntiTrackingCommon::AddFirstPartyStorage
             return storePermission(aValue.ResolveValue());
           }
           return StorageAccessGrantPromise::CreateAndReject(false, __func__);
         });
   }
   return storePermission(false);
 }
 
-/* static */ RefPtr<
-    mozilla::AntiTrackingCommon::FirstPartyStorageAccessGrantPromise>
+/* static */
+RefPtr<mozilla::AntiTrackingCommon::FirstPartyStorageAccessGrantPromise>
 AntiTrackingCommon::SaveFirstPartyStorageAccessGrantedForOriginOnParentProcess(
     nsIPrincipal* aParentPrincipal, nsIPrincipal* aTrackingPrincipal,
     const nsCString& aTrackingOrigin, const nsCString& aGrantedOrigin,
     int aAllowMode) {
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(aAllowMode == eAllow || aAllowMode == eAllowAutoGrant ||
              aAllowMode == eAllowOnAnySite);
 
@@ -1502,17 +1502,18 @@ bool AntiTrackingCommon::IsFirstPartySto
     return access != nsICookiePermission::ACCESS_DENY;
   }
 
   int32_t behavior =
       CookiesBehavior(aPrincipal, static_cast<nsIPrincipal*>(nullptr));
   return behavior != nsICookieService::BEHAVIOR_REJECT;
 }
 
-/* static */ bool AntiTrackingCommon::MaybeIsFirstPartyStorageAccessGrantedFor(
+/* static */
+bool AntiTrackingCommon::MaybeIsFirstPartyStorageAccessGrantedFor(
     nsPIDOMWindowInner* aFirstPartyWindow, nsIURI* aURI) {
   MOZ_ASSERT(aFirstPartyWindow);
   MOZ_ASSERT(aURI);
 
   LOG_SPEC(
       ("Computing a best guess as to whether window %p has access to URI %s",
        aFirstPartyWindow, _spec),
       aURI);
@@ -1659,19 +1660,20 @@ nsresult AntiTrackingCommon::IsOnContent
 
   if (!aIsAllowListed) {
     LOG(("No user override found"));
   }
 
   return NS_OK;
 }
 
-/* static */ void AntiTrackingCommon::NotifyBlockingDecision(
-    nsIChannel* aChannel, BlockingDecision aDecision,
-    uint32_t aRejectedReason) {
+/* static */
+void AntiTrackingCommon::NotifyBlockingDecision(nsIChannel* aChannel,
+                                                BlockingDecision aDecision,
+                                                uint32_t aRejectedReason) {
   MOZ_ASSERT(
       aRejectedReason == 0 ||
       aRejectedReason ==
           nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
       aRejectedReason ==
           nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
       aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
       aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN);
@@ -1724,19 +1726,20 @@ nsresult AntiTrackingCommon::IsOnContent
 
     ReportBlockingToConsole(pwin, uri, aRejectedReason);
   }
 
   pwin->NotifyContentBlockingEvent(nsIWebProgressListener::STATE_COOKIES_LOADED,
                                    aChannel, false, uri);
 }
 
-/* static */ void AntiTrackingCommon::NotifyBlockingDecision(
-    nsPIDOMWindowInner* aWindow, BlockingDecision aDecision,
-    uint32_t aRejectedReason) {
+/* static */
+void AntiTrackingCommon::NotifyBlockingDecision(nsPIDOMWindowInner* aWindow,
+                                                BlockingDecision aDecision,
+                                                uint32_t aRejectedReason) {
   MOZ_ASSERT(aWindow);
   MOZ_ASSERT(
       aRejectedReason == 0 ||
       aRejectedReason ==
           nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
       aRejectedReason ==
           nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
       aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
@@ -1773,18 +1776,18 @@ nsresult AntiTrackingCommon::IsOnContent
 
     ReportBlockingToConsole(pwin, uri, aRejectedReason);
   }
 
   pwin->NotifyContentBlockingEvent(nsIWebProgressListener::STATE_COOKIES_LOADED,
                                    channel, false, uri);
 }
 
-/* static */ void AntiTrackingCommon::StoreUserInteractionFor(
-    nsIPrincipal* aPrincipal) {
+/* static */
+void AntiTrackingCommon::StoreUserInteractionFor(nsIPrincipal* aPrincipal) {
   if (XRE_IsParentProcess()) {
     nsCOMPtr<nsIURI> uri;
     Unused << aPrincipal->GetURI(getter_AddRefs(uri));
     LOG_SPEC(("Saving the userInteraction for %s", _spec), uri);
 
     nsPermissionManager* permManager = nsPermissionManager::GetInstance();
     if (NS_WARN_IF(!permManager)) {
       LOG(("Permission manager is null, bailing out early"));
@@ -1819,18 +1822,18 @@ nsresult AntiTrackingCommon::IsOnContent
   nsCOMPtr<nsIURI> uri;
   Unused << aPrincipal->GetURI(getter_AddRefs(uri));
   LOG_SPEC(("Asking the parent process to save the user-interaction for us: %s",
             _spec),
            uri);
   cc->SendStoreUserInteractionAsPermission(IPC::Principal(aPrincipal));
 }
 
-/* static */ bool AntiTrackingCommon::HasUserInteraction(
-    nsIPrincipal* aPrincipal) {
+/* static */
+bool AntiTrackingCommon::HasUserInteraction(nsIPrincipal* aPrincipal) {
   nsPermissionManager* permManager = nsPermissionManager::GetInstance();
   if (NS_WARN_IF(!permManager)) {
     return false;
   }
 
   uint32_t result = 0;
   nsresult rv = permManager->TestPermissionWithoutDefaultsFromPrincipal(
       aPrincipal, USER_INTERACTION_PERM, &result);
@@ -1871,18 +1874,19 @@ void AntiTrackingCommon::OnAntiTrackingS
         MakeUnique<nsTArray<AntiTrackingSettingsChangedCallback>>();
 
     initialized = true;
   }
 
   gSettingsChangedCallbacks->AppendElement(aCallback);
 }
 
-/* static */ already_AddRefed<nsIURI>
-AntiTrackingCommon::MaybeGetDocumentURIBeingLoaded(nsIChannel* aChannel) {
+/* static */
+already_AddRefed<nsIURI> AntiTrackingCommon::MaybeGetDocumentURIBeingLoaded(
+    nsIChannel* aChannel) {
   nsCOMPtr<nsIURI> uriBeingLoaded;
   nsLoadFlags loadFlags = 0;
   nsresult rv = aChannel->GetLoadFlags(&loadFlags);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return nullptr;
   }
   if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI) {
     // If the channel being loaded is a document channel, this call may be
--- a/toolkit/components/browser/nsWebBrowser.cpp
+++ b/toolkit/components/browser/nsWebBrowser.cpp
@@ -94,17 +94,18 @@ nsIWidget* nsWebBrowser::EnsureWidget() 
   mInternalWidget->SetWidgetListener(&mWidgetListenerDelegate);
   NS_ENSURE_SUCCESS(mInternalWidget->Create(nullptr, mParentNativeWindow,
                                             bounds, &widgetInit),
                     nullptr);
 
   return mInternalWidget;
 }
 
-/* static */ already_AddRefed<nsWebBrowser> nsWebBrowser::Create(
+/* static */
+already_AddRefed<nsWebBrowser> nsWebBrowser::Create(
     nsIWebBrowserChrome* aContainerWindow, nsIWidget* aParentWidget,
     const OriginAttributes& aOriginAttributes, mozIDOMWindowProxy* aOpener,
     int aItemType) {
   RefPtr<nsWebBrowser> browser = new nsWebBrowser(aItemType);
 
   // nsWebBrowser::SetContainer also calls nsWebBrowser::EnsureDocShellTreeOwner
   NS_ENSURE_SUCCESS(browser->SetContainerWindow(aContainerWindow), nullptr);
   NS_ENSURE_SUCCESS(browser->SetParentWidget(aParentWidget), nullptr);
@@ -368,17 +369,18 @@ nsWebBrowser::NameEquals(const nsAString
   NS_ENSURE_ARG_POINTER(aResult);
   if (mDocShell) {
     return mDocShell->NameEquals(aName, aResult);
   }
 
   return NS_OK;
 }
 
-/* virtual */ int32_t nsWebBrowser::ItemType() { return mContentType; }
+/* virtual */
+int32_t nsWebBrowser::ItemType() { return mContentType; }
 
 NS_IMETHODIMP
 nsWebBrowser::GetItemType(int32_t* aItemType) {
   NS_ENSURE_ARG_POINTER(aItemType);
 
   *aItemType = ItemType();
   return NS_OK;
 }
--- a/toolkit/components/clearsitedata/ClearSiteData.cpp
+++ b/toolkit/components/clearsitedata/ClearSiteData.cpp
@@ -102,17 +102,18 @@ class ClearSiteData::PendingCleanupHolde
 NS_INTERFACE_MAP_BEGIN(ClearSiteData::PendingCleanupHolder)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIClearDataCallback)
   NS_INTERFACE_MAP_ENTRY(nsIClearDataCallback)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(ClearSiteData::PendingCleanupHolder)
 NS_IMPL_RELEASE(ClearSiteData::PendingCleanupHolder)
 
-/* static */ void ClearSiteData::Initialize() {
+/* static */
+void ClearSiteData::Initialize() {
   MOZ_ASSERT(!gClearSiteData);
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!XRE_IsParentProcess()) {
     return;
   }
 
   RefPtr<ClearSiteData> service = new ClearSiteData();
@@ -122,17 +123,18 @@ NS_IMPL_RELEASE(ClearSiteData::PendingCl
     return;
   }
 
   obs->AddObserver(service, NS_HTTP_ON_EXAMINE_RESPONSE_TOPIC, false);
   obs->AddObserver(service, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
   gClearSiteData = service;
 }
 
-/* static */ void ClearSiteData::Shutdown() {
+/* static */
+void ClearSiteData::Shutdown() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!gClearSiteData) {
     return;
   }
 
   RefPtr<ClearSiteData> service = gClearSiteData;
   gClearSiteData = nullptr;
--- a/toolkit/components/extensions/ExtensionPolicyService.cpp
+++ b/toolkit/components/extensions/ExtensionPolicyService.cpp
@@ -71,17 +71,18 @@ static mozIExtensionProcessScript& Proce
   }
   return *sProcessScript;
 }
 
 /*****************************************************************************
  * ExtensionPolicyService
  *****************************************************************************/
 
-/* static */ bool ExtensionPolicyService::sRemoteExtensions;
+/* static */
+bool ExtensionPolicyService::sRemoteExtensions;
 
 /* static */ ExtensionPolicyService& ExtensionPolicyService::GetSingleton() {
   static RefPtr<ExtensionPolicyService> sExtensionPolicyService;
 
   if (MOZ_UNLIKELY(!sExtensionPolicyService)) {
     sExtensionPolicyService = new ExtensionPolicyService();
     RegisterWeakMemoryReporter(sExtensionPolicyService);
     ClearOnShutdown(&sExtensionPolicyService);
--- a/toolkit/components/extensions/MatchPattern.cpp
+++ b/toolkit/components/extensions/MatchPattern.cpp
@@ -228,17 +228,18 @@ const char* PERMITTED_SCHEMES[] = {"http
 
 // Known schemes that are followed by "://" instead of ":".
 const char* HOST_LOCATOR_SCHEMES[] = {
     "http",   "https",    "ws",  "wss",      "file",    "ftp",  "moz-extension",
     "chrome", "resource", "moz", "moz-icon", "moz-gio", nullptr};
 
 const char* WILDCARD_SCHEMES[] = {"http", "https", "ws", "wss", nullptr};
 
-/* static */ already_AddRefed<MatchPattern> MatchPattern::Constructor(
+/* static */
+already_AddRefed<MatchPattern> MatchPattern::Constructor(
     dom::GlobalObject& aGlobal, const nsAString& aPattern,
     const MatchPatternOptions& aOptions, ErrorResult& aRv) {
   RefPtr<MatchPattern> pattern = new MatchPattern(aGlobal.GetAsSupports());
   pattern->Init(aGlobal.Context(), aPattern, aOptions.mIgnorePath,
                 aOptions.mRestrictSchemes, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
@@ -450,17 +451,18 @@ bool MatchPattern::Overlaps(const MatchP
   return SubsumesDomain(aPattern) || aPattern.SubsumesDomain(*this);
 }
 
 JSObject* MatchPattern::WrapObject(JSContext* aCx,
                                    JS::HandleObject aGivenProto) {
   return MatchPattern_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-/* static */ bool MatchPattern::MatchesAllURLs(const URLInfo& aURL) {
+/* static */
+bool MatchPattern::MatchesAllURLs(const URLInfo& aURL) {
   RefPtr<AtomSet> permittedSchemes = AtomSet::Get<PERMITTED_SCHEMES>();
   return permittedSchemes->Contains(aURL.Scheme());
 }
 
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(MatchPattern, mPath, mParent)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MatchPattern)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
@@ -469,17 +471,18 @@ NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(MatchPattern)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(MatchPattern)
 
 /*****************************************************************************
  * MatchPatternSet
  *****************************************************************************/
 
-/* static */ already_AddRefed<MatchPatternSet> MatchPatternSet::Constructor(
+/* static */
+already_AddRefed<MatchPatternSet> MatchPatternSet::Constructor(
     dom::GlobalObject& aGlobal,
     const nsTArray<dom::OwningStringOrMatchPattern>& aPatterns,
     const MatchPatternOptions& aOptions, ErrorResult& aRv) {
   ArrayType patterns;
 
   for (auto& elem : aPatterns) {
     if (elem.IsMatchPattern()) {
       patterns.AppendElement(elem.GetAsMatchPattern());
@@ -590,19 +593,21 @@ NS_IMPL_CYCLE_COLLECTING_ADDREF(MatchPat
 NS_IMPL_CYCLE_COLLECTING_RELEASE(MatchPatternSet)
 
 /*****************************************************************************
  * MatchGlob
  *****************************************************************************/
 
 MatchGlob::~MatchGlob() { mozilla::DropJSObjects(this); }
 
-/* static */ already_AddRefed<MatchGlob> MatchGlob::Constructor(
-    dom::GlobalObject& aGlobal, const nsAString& aGlob, bool aAllowQuestion,
-    ErrorResult& aRv) {
+/* static */
+already_AddRefed<MatchGlob> MatchGlob::Constructor(dom::GlobalObject& aGlobal,
+                                                   const nsAString& aGlob,
+                                                   bool aAllowQuestion,
+                                                   ErrorResult& aRv) {
   RefPtr<MatchGlob> glob = new MatchGlob(aGlobal.GetAsSupports());
   glob->Init(aGlobal.Context(), aGlob, aAllowQuestion, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
   return glob.forget();
 }
 
--- a/toolkit/components/extensions/WebExtensionPolicy.cpp
+++ b/toolkit/components/extensions/WebExtensionPolicy.cpp
@@ -192,34 +192,37 @@ already_AddRefed<WebExtensionPolicy> Web
   RefPtr<WebExtensionPolicy> policy =
       new WebExtensionPolicy(aGlobal, aInit, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
   return policy.forget();
 }
 
-/* static */ void WebExtensionPolicy::GetActiveExtensions(
+/* static */
+void WebExtensionPolicy::GetActiveExtensions(
     dom::GlobalObject& aGlobal,
     nsTArray<RefPtr<WebExtensionPolicy>>& aResults) {
   EPS().GetAll(aResults);
 }
 
-/* static */ already_AddRefed<WebExtensionPolicy> WebExtensionPolicy::GetByID(
+/* static */
+already_AddRefed<WebExtensionPolicy> WebExtensionPolicy::GetByID(
     dom::GlobalObject& aGlobal, const nsAString& aID) {
   return do_AddRef(EPS().GetByID(aID));
 }
 
-/* static */ already_AddRefed<WebExtensionPolicy>
-WebExtensionPolicy::GetByHostname(dom::GlobalObject& aGlobal,
-                                  const nsACString& aHostname) {
+/* static */
+already_AddRefed<WebExtensionPolicy> WebExtensionPolicy::GetByHostname(
+    dom::GlobalObject& aGlobal, const nsACString& aHostname) {
   return do_AddRef(EPS().GetByHost(aHostname));
 }
 
-/* static */ already_AddRefed<WebExtensionPolicy> WebExtensionPolicy::GetByURI(
+/* static */
+already_AddRefed<WebExtensionPolicy> WebExtensionPolicy::GetByURI(
     dom::GlobalObject& aGlobal, nsIURI* aURI) {
   return do_AddRef(EPS().GetByURL(aURI));
 }
 
 void WebExtensionPolicy::SetActive(bool aActive, ErrorResult& aRv) {
   if (aActive == mActive) {
     return;
   }
@@ -311,23 +314,23 @@ void WebExtensionPolicy::UnregisterConte
 
 void WebExtensionPolicy::InjectContentScripts(ErrorResult& aRv) {
   nsresult rv = EPS().InjectContentScripts(this);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
   }
 }
 
-/* static */ bool WebExtensionPolicy::UseRemoteWebExtensions(
-    GlobalObject& aGlobal) {
+/* static */
+bool WebExtensionPolicy::UseRemoteWebExtensions(GlobalObject& aGlobal) {
   return EPS().UseRemoteExtensions();
 }
 
-/* static */ bool WebExtensionPolicy::IsExtensionProcess(
-    GlobalObject& aGlobal) {
+/* static */
+bool WebExtensionPolicy::IsExtensionProcess(GlobalObject& aGlobal) {
   return EPS().IsExtensionProcess();
 }
 
 namespace {
 /**
  * Maintains a dynamically updated AtomSet based on the comma-separated
  * values in the given string pref.
  */
@@ -377,28 +380,30 @@ AtomSetPref::Observe(nsISupports* aSubje
                      const char16_t* aData) {
   mAtomSet = nullptr;
   return NS_OK;
 }
 
 NS_IMPL_ISUPPORTS(AtomSetPref, nsIObserver, nsISupportsWeakReference)
 };  // namespace
 
-/* static */ bool WebExtensionPolicy::IsRestrictedDoc(const DocInfo& aDoc) {
+/* static */
+bool WebExtensionPolicy::IsRestrictedDoc(const DocInfo& aDoc) {
   // With the exception of top-level about:blank documents with null
   // principals, we never match documents that have non-codebase principals,
   // including those with null principals or system principals.
   if (aDoc.Principal() && !aDoc.Principal()->GetIsCodebasePrincipal()) {
     return true;
   }
 
   return IsRestrictedURI(aDoc.PrincipalURL());
 }
 
-/* static */ bool WebExtensionPolicy::IsRestrictedURI(const URLInfo& aURI) {
+/* static */
+bool WebExtensionPolicy::IsRestrictedURI(const URLInfo& aURI) {
   static RefPtr<AtomSetPref> domains;
   if (!domains) {
     domains = AtomSetPref::Create(nsLiteralCString(kRestrictedDomainPref));
     ClearOnShutdown(&domains);
   }
 
   if (domains->Contains(aURI.HostAtom())) {
     return true;
@@ -482,29 +487,30 @@ NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(WebExtensionPolicy)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(WebExtensionPolicy)
 
 /*****************************************************************************
  * WebExtensionContentScript / MozDocumentMatcher
  *****************************************************************************/
 
-/* static */ already_AddRefed<MozDocumentMatcher>
-MozDocumentMatcher::Constructor(GlobalObject& aGlobal,
-                                const dom::MozDocumentMatcherInit& aInit,
-                                ErrorResult& aRv) {
+/* static */
+already_AddRefed<MozDocumentMatcher> MozDocumentMatcher::Constructor(
+    GlobalObject& aGlobal, const dom::MozDocumentMatcherInit& aInit,
+    ErrorResult& aRv) {
   RefPtr<MozDocumentMatcher> matcher =
       new MozDocumentMatcher(aGlobal, aInit, false, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
   return matcher.forget();
 }
 
-/* static */ already_AddRefed<WebExtensionContentScript>
+/* static */
+already_AddRefed<WebExtensionContentScript>
 WebExtensionContentScript::Constructor(GlobalObject& aGlobal,
                                        WebExtensionPolicy& aExtension,
                                        const ContentScriptInit& aInit,
                                        ErrorResult& aRv) {
   RefPtr<WebExtensionContentScript> script =
       new WebExtensionContentScript(aGlobal, aExtension, aInit, aRv);
   if (aRv.Failed()) {
     return nullptr;
@@ -654,17 +660,18 @@ NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(MozDocumentMatcher)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(MozDocumentMatcher)
 
 /*****************************************************************************
  * MozDocumentObserver
  *****************************************************************************/
 
-/* static */ already_AddRefed<DocumentObserver> DocumentObserver::Constructor(
+/* static */
+already_AddRefed<DocumentObserver> DocumentObserver::Constructor(
     GlobalObject& aGlobal, dom::MozDocumentCallback& aCallbacks,
     ErrorResult& aRv) {
   RefPtr<DocumentObserver> matcher =
       new DocumentObserver(aGlobal.GetAsSupports(), aCallbacks);
   return matcher.forget();
 }
 
 void DocumentObserver::Observe(
--- a/toolkit/components/extensions/webrequest/StreamFilter.cpp
+++ b/toolkit/components/extensions/webrequest/StreamFilter.cpp
@@ -45,18 +45,20 @@ StreamFilter::~StreamFilter() { ForgetAc
 
 void StreamFilter::ForgetActor() {
   if (mActor) {
     mActor->Cleanup();
     mActor->SetStreamFilter(nullptr);
   }
 }
 
-/* static */ already_AddRefed<StreamFilter> StreamFilter::Create(
-    GlobalObject& aGlobal, uint64_t aRequestId, const nsAString& aAddonId) {
+/* static */
+already_AddRefed<StreamFilter> StreamFilter::Create(GlobalObject& aGlobal,
+                                                    uint64_t aRequestId,
+                                                    const nsAString& aAddonId) {
   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
   MOZ_ASSERT(global);
 
   RefPtr<StreamFilter> filter = new StreamFilter(global, aRequestId, aAddonId);
   return filter.forget();
 }
 
 /*****************************************************************************
@@ -246,18 +248,18 @@ void StreamFilter::FireErrorEvent(const 
   mError = aError;
   FireEvent(NS_LITERAL_STRING("error"));
 }
 
 /*****************************************************************************
  * Glue
  *****************************************************************************/
 
-/* static */ bool StreamFilter::IsAllowedInContext(JSContext* aCx,
-                                                   JSObject* /* unused */) {
+/* static */
+bool StreamFilter::IsAllowedInContext(JSContext* aCx, JSObject* /* unused */) {
   return nsContentUtils::CallerHasPermission(aCx,
                                              nsGkAtoms::webRequestBlocking);
 }
 
 JSObject* StreamFilter::WrapObject(JSContext* aCx, HandleObject aGivenProto) {
   return StreamFilter_Binding::Wrap(aCx, this, aGivenProto);
 }
 
--- a/toolkit/components/extensions/webrequest/StreamFilterEvents.cpp
+++ b/toolkit/components/extensions/webrequest/StreamFilterEvents.cpp
@@ -23,20 +23,20 @@ NS_IMPL_CYCLE_COLLECTION_TRACE_END
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(StreamFilterDataEvent, Event)
   tmp->mData = nullptr;
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(StreamFilterDataEvent)
 NS_INTERFACE_MAP_END_INHERITING(Event)
 
-/* static */ already_AddRefed<StreamFilterDataEvent>
-StreamFilterDataEvent::Constructor(EventTarget* aEventTarget,
-                                   const nsAString& aType,
-                                   const StreamFilterDataEventInit& aParam) {
+/* static */
+already_AddRefed<StreamFilterDataEvent> StreamFilterDataEvent::Constructor(
+    EventTarget* aEventTarget, const nsAString& aType,
+    const StreamFilterDataEventInit& aParam) {
   RefPtr<StreamFilterDataEvent> event = new StreamFilterDataEvent(aEventTarget);
 
   bool trusted = event->Init(aEventTarget);
   event->InitEvent(aType, aParam.mBubbles, aParam.mCancelable);
   event->SetTrusted(trusted);
   event->SetComposed(aParam.mComposed);
 
   event->SetData(aParam.mData);
--- a/toolkit/components/extensions/webrequest/StreamFilterParent.cpp
+++ b/toolkit/components/extensions/webrequest/StreamFilterParent.cpp
@@ -139,18 +139,19 @@ bool StreamFilterParent::Create(dom::Con
   if (!chan->AttachStreamFilter(std::move(parent))) {
     return false;
   }
 
   *aEndpoint = std::move(child);
   return true;
 }
 
-/* static */ void StreamFilterParent::Attach(nsIChannel* aChannel,
-                                             ParentEndpoint&& aEndpoint) {
+/* static */
+void StreamFilterParent::Attach(nsIChannel* aChannel,
+                                ParentEndpoint&& aEndpoint) {
   auto self = MakeRefPtr<StreamFilterParent>();
 
   self->ActorThread()->Dispatch(
       NewRunnableMethod<ParentEndpoint&&>("StreamFilterParent::Bind", self,
                                           &StreamFilterParent::Bind,
                                           std::move(aEndpoint)),
       NS_DISPATCH_NORMAL);
 
--- a/toolkit/components/fuzzyfox/Fuzzyfox.cpp
+++ b/toolkit/components/fuzzyfox/Fuzzyfox.cpp
@@ -42,17 +42,18 @@ static LazyLogModule sFuzzyfoxLog("Fuzzy
 #define FUZZYFOX_CLOCKGRAIN_PREF "privacy.fuzzyfox.clockgrainus"
 #define FUZZYFOX_CLOCKGRAIN_PREF_DEFAULT 100
 
 static bool sFuzzyfoxInitializing;
 Atomic<uint32_t, Relaxed> Fuzzyfox::sFuzzyfoxClockGrain;
 
 NS_IMPL_ISUPPORTS_INHERITED(Fuzzyfox, Runnable, nsIObserver)
 
-/* static */ void Fuzzyfox::Start() {
+/* static */
+void Fuzzyfox::Start() {
   MOZ_ASSERT(NS_IsMainThread());
 
   RefPtr<Fuzzyfox> r = new Fuzzyfox();
   SystemGroup::Dispatch(TaskCategory::Other, r.forget());
 }
 
 Fuzzyfox::Fuzzyfox()
     : Runnable("Fuzzyfox"),
--- a/toolkit/components/printingui/nsPrintingPromptService.cpp
+++ b/toolkit/components/printingui/nsPrintingPromptService.cpp
@@ -29,17 +29,18 @@ static const char* kPrtPrvProgressDialog
 
 using namespace mozilla;
 
 NS_IMPL_ISUPPORTS(nsPrintingPromptService, nsIPrintingPromptService,
                   nsIWebProgressListener)
 
 StaticRefPtr<nsPrintingPromptService> sSingleton;
 
-/* static */ already_AddRefed<nsPrintingPromptService>
+/* static */
+already_AddRefed<nsPrintingPromptService>
 nsPrintingPromptService::GetSingleton() {
   MOZ_ASSERT(XRE_IsParentProcess(),
              "The content process must use nsPrintingProxy");
 
   if (!sSingleton) {
     sSingleton = new nsPrintingPromptService();
     sSingleton->Init();
     ClearOnShutdown(&sSingleton);
--- a/toolkit/components/sessionstore/SessionStoreUtils.cpp
+++ b/toolkit/components/sessionstore/SessionStoreUtils.cpp
@@ -79,17 +79,18 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
   NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(DynamicFrameEventFilter)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(DynamicFrameEventFilter)
 
 }  // anonymous namespace
 
-/* static */ void SessionStoreUtils::ForEachNonDynamicChildFrame(
+/* static */
+void SessionStoreUtils::ForEachNonDynamicChildFrame(
     const GlobalObject& aGlobal, WindowProxyHolder& aWindow,
     SessionStoreUtilsFrameCallback& aCallback, ErrorResult& aRv) {
   if (!aWindow.get()) {
     aRv.Throw(NS_ERROR_INVALID_ARG);
     return;
   }
 
   nsCOMPtr<nsIDocShell> docShell = aWindow.get()->GetDocShell();
@@ -125,17 +126,18 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(Dynamic
     }
 
     int32_t childOffset = childDocShell->GetChildOffset();
     aCallback.Call(WindowProxyHolder(item->GetWindow()->GetBrowsingContext()),
                    childOffset);
   }
 }
 
-/* static */ already_AddRefed<nsISupports>
+/* static */
+already_AddRefed<nsISupports>
 SessionStoreUtils::AddDynamicFrameFilteredListener(
     const GlobalObject& aGlobal, EventTarget& aTarget, const nsAString& aType,
     JS::Handle<JS::Value> aListener, bool aUseCapture, bool aMozSystemGroup,
     ErrorResult& aRv) {
   if (NS_WARN_IF(!aListener.isObject())) {
     aRv.Throw(NS_ERROR_INVALID_ARG);
     return nullptr;
   }
@@ -154,35 +156,38 @@ SessionStoreUtils::AddDynamicFrameFilter
   }
   if (aRv.Failed()) {
     return nullptr;
   }
 
   return filter.forget();
 }
 
-/* static */ void SessionStoreUtils::RemoveDynamicFrameFilteredListener(
+/* static */
+void SessionStoreUtils::RemoveDynamicFrameFilteredListener(
     const GlobalObject& global, EventTarget& aTarget, const nsAString& aType,
     nsISupports* aListener, bool aUseCapture, bool aMozSystemGroup,
     ErrorResult& aRv) {
   nsCOMPtr<nsIDOMEventListener> listener = do_QueryInterface(aListener);
   if (!listener) {
     aRv.Throw(NS_ERROR_NO_INTERFACE);
     return;
   }
 
   if (aMozSystemGroup) {
     aTarget.RemoveSystemEventListener(aType, listener, aUseCapture);
   } else {
     aTarget.RemoveEventListener(aType, listener, aUseCapture);
   }
 }
 
-/* static */ void SessionStoreUtils::CollectDocShellCapabilities(
-    const GlobalObject& aGlobal, nsIDocShell* aDocShell, nsCString& aRetVal) {
+/* static */
+void SessionStoreUtils::CollectDocShellCapabilities(const GlobalObject& aGlobal,
+                                                    nsIDocShell* aDocShell,
+                                                    nsCString& aRetVal) {
   bool allow;
 
 #define TRY_ALLOWPROP(y)          \
   PR_BEGIN_MACRO                  \
   aDocShell->GetAllow##y(&allow); \
   if (!allow) {                   \
     if (!aRetVal.IsEmpty()) {     \
       aRetVal.Append(',');        \
@@ -201,17 +206,18 @@ SessionStoreUtils::AddDynamicFrameFilter
   TRY_ALLOWPROP(DNSPrefetch);
   TRY_ALLOWPROP(WindowControl);
   TRY_ALLOWPROP(Auth);
   TRY_ALLOWPROP(ContentRetargeting);
   TRY_ALLOWPROP(ContentRetargetingOnChildren);
 #undef TRY_ALLOWPROP
 }
 
-/* static */ void SessionStoreUtils::RestoreDocShellCapabilities(
+/* static */
+void SessionStoreUtils::RestoreDocShellCapabilities(
     const GlobalObject& aGlobal, nsIDocShell* aDocShell,
     const nsCString& aDisallowCapabilities) {
   aDocShell->SetAllowPlugins(true);
   aDocShell->SetAllowJavascript(true);
   aDocShell->SetAllowMetaRedirects(true);
   aDocShell->SetAllowSubframes(true);
   aDocShell->SetAllowImages(true);
   aDocShell->SetAllowMedia(true);
@@ -262,19 +268,20 @@ static void CollectCurrentScrollPosition
   int scrollX = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.x);
   int scrollY = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.y);
 
   if ((scrollX != 0) || (scrollY != 0)) {
     aRetVal.SetValue().mScroll.Construct() = nsPrintfCString("%d,%d", scrollX, scrollY);
   }
 }
 
-/* static */ void SessionStoreUtils::RestoreScrollPosition(
-    const GlobalObject& aGlobal, nsGlobalWindowInner& aWindow,
-    const CollectedData& aData) {
+/* static */
+void SessionStoreUtils::RestoreScrollPosition(const GlobalObject& aGlobal,
+                                              nsGlobalWindowInner& aWindow,
+                                              const CollectedData& aData) {
   if (!aData.mScroll.WasPassed()) {
     return;
   }
 
   nsCCharSeparatedTokenizer tokenizer(aData.mScroll.Value(), ',');
   nsAutoCString token(tokenizer.nextToken());
   int pos_X = atoi(token.get());
   token = tokenizer.nextToken();
@@ -904,19 +911,20 @@ static Element* FindNodeByXPath(JSContex
       aCx, aDocument, XPathResult::FIRST_ORDERED_NODE_TYPE, nullptr, rv);
   if (rv.Failed()) {
     return nullptr;
   }
   return Element::FromNodeOrNull(result->GetSingleNodeValue(rv));
 }
 
 MOZ_CAN_RUN_SCRIPT_BOUNDARY
-/* static */ bool SessionStoreUtils::RestoreFormData(
-    const GlobalObject& aGlobal, Document& aDocument,
-    const CollectedData& aData) {
+/* static */
+bool SessionStoreUtils::RestoreFormData(const GlobalObject& aGlobal,
+                                        Document& aDocument,
+                                        const CollectedData& aData) {
   if (!aData.mUrl.WasPassed()) {
     return true;
   }
   // Don't restore any data for the given frame if the URL
   // stored in the form data doesn't match its current URL.
   nsAutoCString url;
   Unused << aDocument.GetDocumentURI()->GetSpecIgnoringRef(url);
   if (!aData.mUrl.Value().Equals(url)) {
@@ -1087,25 +1095,27 @@ static void CollectedSessionStorageInter
       continue;
     }
     CollectedSessionStorageInternal(
         aCx, nsDocShell::Cast(childDocShell)->GetBrowsingContext(),
         aVisitedOrigins, aRetVal);
   }
 }
 
-/* static */ void SessionStoreUtils::CollectSessionStorage(
+/* static */
+void SessionStoreUtils::CollectSessionStorage(
     const GlobalObject& aGlobal, WindowProxyHolder& aWindow,
     Record<nsString, Record<nsString, nsString>>& aRetVal) {
   nsTHashtable<nsCStringHashKey> visitedOrigins;
   CollectedSessionStorageInternal(aGlobal.Context(), aWindow.get(),
                                   visitedOrigins, aRetVal);
 }
 
-/* static */ void SessionStoreUtils::RestoreSessionStorage(
+/* static */
+void SessionStoreUtils::RestoreSessionStorage(
     const GlobalObject& aGlobal, nsIDocShell* aDocShell,
     const Record<nsString, Record<nsString, nsString>>& aData) {
   for (auto& entry : aData.Entries()) {
     // NOTE: In capture() we record the full origin for the URI which the
     // sessionStorage is being captured for. As of bug 1235657 this code
     // stopped parsing any origins which have originattributes correctly, as
     // it decided to use the origin attributes from the docshell, and try to
     // interpret the origin as a URI. Since bug 1353844 this code now correctly
--- a/toolkit/components/telemetry/core/Stopwatch.cpp
+++ b/toolkit/components/telemetry/core/Stopwatch.cpp
@@ -343,86 +343,92 @@ int32_t Timers::Finish(JSContext* aCx, c
                       "TelemetryStopwatch: failed to update the Histogram "
                       "\"%s\", using key: \"%s\"",
                       NS_ConvertUTF16toUTF8(aHistogram).get(),
                       NS_ConvertUTF16toUTF8(aKey).get()));
   }
   return NS_SUCCEEDED(rv) ? delta : -1;
 }
 
-/* static */ bool Stopwatch::Start(
-    const dom::GlobalObject& aGlobal, const nsAString& aHistogram,
-    JS::Handle<JSObject*> aObj,
-    const dom::TelemetryStopwatchOptions& aOptions) {
+/* static */
+bool Stopwatch::Start(const dom::GlobalObject& aGlobal,
+                      const nsAString& aHistogram, JS::Handle<JSObject*> aObj,
+                      const dom::TelemetryStopwatchOptions& aOptions) {
   return StartKeyed(aGlobal, aHistogram, VoidString(), aObj, aOptions);
 }
-/* static */ bool Stopwatch::StartKeyed(
-    const dom::GlobalObject& aGlobal, const nsAString& aHistogram,
-    const nsAString& aKey, JS::Handle<JSObject*> aObj,
-    const dom::TelemetryStopwatchOptions& aOptions) {
+/* static */
+bool Stopwatch::StartKeyed(const dom::GlobalObject& aGlobal,
+                           const nsAString& aHistogram, const nsAString& aKey,
+                           JS::Handle<JSObject*> aObj,
+                           const dom::TelemetryStopwatchOptions& aOptions) {
   return Timers::Singleton().Start(aGlobal.Context(), aHistogram, aObj, aKey,
                                    aOptions.mInSeconds);
 }
 
-/* static */ bool Stopwatch::Running(const dom::GlobalObject& aGlobal,
-                                     const nsAString& aHistogram,
-                                     JS::Handle<JSObject*> aObj) {
+/* static */
+bool Stopwatch::Running(const dom::GlobalObject& aGlobal,
+                        const nsAString& aHistogram,
+                        JS::Handle<JSObject*> aObj) {
   return RunningKeyed(aGlobal, aHistogram, VoidString(), aObj);
 }
 
-/* static */ bool Stopwatch::RunningKeyed(const dom::GlobalObject& aGlobal,
-                                          const nsAString& aHistogram,
-                                          const nsAString& aKey,
-                                          JS::Handle<JSObject*> aObj) {
+/* static */
+bool Stopwatch::RunningKeyed(const dom::GlobalObject& aGlobal,
+                             const nsAString& aHistogram, const nsAString& aKey,
+                             JS::Handle<JSObject*> aObj) {
   return TimeElapsedKeyed(aGlobal, aHistogram, aKey, aObj, true) != -1;
 }
 
-/* static */ int32_t Stopwatch::TimeElapsed(const dom::GlobalObject& aGlobal,
-                                            const nsAString& aHistogram,
-                                            JS::Handle<JSObject*> aObj,
-                                            bool aCanceledOkay) {
+/* static */
+int32_t Stopwatch::TimeElapsed(const dom::GlobalObject& aGlobal,
+                               const nsAString& aHistogram,
+                               JS::Handle<JSObject*> aObj, bool aCanceledOkay) {
   return TimeElapsedKeyed(aGlobal, aHistogram, VoidString(), aObj,
                           aCanceledOkay);
 }
 
-/* static */ int32_t Stopwatch::TimeElapsedKeyed(
-    const dom::GlobalObject& aGlobal, const nsAString& aHistogram,
-    const nsAString& aKey, JS::Handle<JSObject*> aObj, bool aCanceledOkay) {
+/* static */
+int32_t Stopwatch::TimeElapsedKeyed(const dom::GlobalObject& aGlobal,
+                                    const nsAString& aHistogram,
+                                    const nsAString& aKey,
+                                    JS::Handle<JSObject*> aObj,
+                                    bool aCanceledOkay) {
   return Timers::Singleton().TimeElapsed(aGlobal.Context(), aHistogram, aObj,
                                          aKey, aCanceledOkay);
 }
 
-/* static */ bool Stopwatch::Finish(const dom::GlobalObject& aGlobal,
-                                    const nsAString& aHistogram,
-                                    JS::Handle<JSObject*> aObj,
-                                    bool aCanceledOkay) {
+/* static */
+bool Stopwatch::Finish(const dom::GlobalObject& aGlobal,
+                       const nsAString& aHistogram, JS::Handle<JSObject*> aObj,
+                       bool aCanceledOkay) {
   return FinishKeyed(aGlobal, aHistogram, VoidString(), aObj, aCanceledOkay);
 }
 
-/* static */ bool Stopwatch::FinishKeyed(const dom::GlobalObject& aGlobal,
-                                         const nsAString& aHistogram,
-                                         const nsAString& aKey,
-                                         JS::Handle<JSObject*> aObj,
-                                         bool aCanceledOkay) {
+/* static */
+bool Stopwatch::FinishKeyed(const dom::GlobalObject& aGlobal,
+                            const nsAString& aHistogram, const nsAString& aKey,
+                            JS::Handle<JSObject*> aObj, bool aCanceledOkay) {
   return Timers::Singleton().Finish(aGlobal.Context(), aHistogram, aObj, aKey,
                                     aCanceledOkay) != -1;
 }
 
-/* static */ bool Stopwatch::Cancel(const dom::GlobalObject& aGlobal,
-                                    const nsAString& aHistogram,
-                                    JS::Handle<JSObject*> aObj) {
+/* static */
+bool Stopwatch::Cancel(const dom::GlobalObject& aGlobal,
+                       const nsAString& aHistogram,
+                       JS::Handle<JSObject*> aObj) {
   return CancelKeyed(aGlobal, aHistogram, VoidString(), aObj);
 }
 
-/* static */ bool Stopwatch::CancelKeyed(const dom::GlobalObject& aGlobal,
-                                         const nsAString& aHistogram,
-                                         const nsAString& aKey,
-                                         JS::Handle<JSObject*> aObj) {
+/* static */
+bool Stopwatch::CancelKeyed(const dom::GlobalObject& aGlobal,
+                            const nsAString& aHistogram, const nsAString& aKey,
+                            JS::Handle<JSObject*> aObj) {
   return Timers::Singleton().Delete(aGlobal.Context(), aHistogram, aObj, aKey);
 }
 
-/* static */ void Stopwatch::SetTestModeEnabled(
-    const dom::GlobalObject& aGlobal, bool aTesting) {
+/* static */
+void Stopwatch::SetTestModeEnabled(const dom::GlobalObject& aGlobal,
+                                   bool aTesting) {
   Timers::Singleton().SuppressErrors() = aTesting;
 }
 
 }  // namespace telemetry
 }  // namespace mozilla
--- a/toolkit/components/url-classifier/LookupCache.cpp
+++ b/toolkit/components/url-classifier/LookupCache.cpp
@@ -258,31 +258,33 @@ void LookupCache::GetCacheInfo(nsIUrlCla
 
     info->entries.AppendElement(
         static_cast<nsIUrlClassifierCacheEntry*>(entry));
   }
 
   info.forget(aCache);
 }
 
-/* static */ bool LookupCache::IsCanonicalizedIP(const nsACString& aHost) {
+/* static */
+bool LookupCache::IsCanonicalizedIP(const nsACString& aHost) {
   // The canonicalization process will have left IP addresses in dotted
   // decimal with no surprises.
   uint32_t i1, i2, i3, i4;
   char c;
   if (PR_sscanf(PromiseFlatCString(aHost).get(), "%u.%u.%u.%u%c", &i1, &i2, &i3,
                 &i4, &c) == 4) {
     return (i1 <= 0xFF && i2 <= 0xFF && i3 <= 0xFF && i4 <= 0xFF);
   }
 
   return false;
 }
 
-/* static */ nsresult LookupCache::GetLookupFragments(
-    const nsACString& aSpec, nsTArray<nsCString>* aFragments)
+/* static */
+nsresult LookupCache::GetLookupFragments(const nsACString& aSpec,
+                                         nsTArray<nsCString>* aFragments)
 
 {
   aFragments->Clear();
 
   nsACString::const_iterator begin, end, iter;
   aSpec.BeginReading(begin);
   aSpec.EndReading(end);
 
@@ -374,18 +376,19 @@ void LookupCache::GetCacheInfo(nsIUrlCla
 
       aFragments->AppendElement(key);
     }
   }
 
   return NS_OK;
 }
 
-/* static */ nsresult LookupCache::GetHostKeys(const nsACString& aSpec,
-                                               nsTArray<nsCString>* aHostKeys) {
+/* static */
+nsresult LookupCache::GetHostKeys(const nsACString& aSpec,
+                                  nsTArray<nsCString>* aHostKeys) {
   nsACString::const_iterator begin, end, iter;
   aSpec.BeginReading(begin);
   aSpec.EndReading(end);
 
   iter = begin;
   if (!FindCharInReadable('/', iter, end)) {
     return NS_OK;
   }
--- a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
@@ -1580,17 +1580,18 @@ NS_INTERFACE_MAP_BEGIN(nsUrlClassifierDB
   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIUrlClassifierDBService,
                                      XRE_IsParentProcess())
   NS_INTERFACE_MAP_ENTRY(nsIURIClassifier)
   NS_INTERFACE_MAP_ENTRY(nsIUrlClassifierInfo)
   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIObserver, XRE_IsParentProcess())
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIURIClassifier)
 NS_INTERFACE_MAP_END
 
-/* static */ already_AddRefed<nsUrlClassifierDBService>
+/* static */
+already_AddRefed<nsUrlClassifierDBService>
 nsUrlClassifierDBService::GetInstance(nsresult* result) {
   *result = NS_OK;
   if (!sUrlClassifierDBService) {
     sUrlClassifierDBService = new (fallible) nsUrlClassifierDBService();
     if (!sUrlClassifierDBService) {
       *result = NS_ERROR_OUT_OF_MEMORY;
       return nullptr;
     }
--- a/toolkit/recordreplay/Assembler.cpp
+++ b/toolkit/recordreplay/Assembler.cpp
@@ -76,17 +76,18 @@ uint8_t* Assembler::Current() {
 
 static void Push16(uint8_t** aIp, uint16_t aValue) {
   (*aIp)[0] = 0x66;
   (*aIp)[1] = 0x68;
   *reinterpret_cast<uint16_t*>(*aIp + 2) = aValue;
   (*aIp) += 4;
 }
 
-/* static */ void Assembler::PatchJump(uint8_t* aIp, void* aTarget) {
+/* static */
+void Assembler::PatchJump(uint8_t* aIp, void* aTarget) {
   // Push the target literal onto the stack, 2 bytes at a time. This is
   // apparently the best way of getting an arbitrary 8 byte literal onto the
   // stack, as 4 byte literals we push will be sign extended to 8 bytes.
   size_t ntarget = reinterpret_cast<size_t>(aTarget);
   Push16(&aIp, ntarget >> 48);
   Push16(&aIp, ntarget >> 32);
   Push16(&aIp, ntarget >> 16);
   Push16(&aIp, ntarget);
@@ -194,18 +195,18 @@ void Assembler::CompareValueWithRax(uint
       break;
     default:
       MOZ_CRASH();
   }
 }
 
 static const size_t MoveImmediateBytes = 10;
 
-/* static */ void Assembler::PatchMoveImmediateToRax(uint8_t* aIp,
-                                                     void* aValue) {
+/* static */
+void Assembler::PatchMoveImmediateToRax(uint8_t* aIp, void* aValue) {
   aIp[0] = 0x40 | (1 << 3);
   aIp[1] = 0xB8;
   *reinterpret_cast<void**>(aIp + 2) = aValue;
 }
 
 void Assembler::MoveImmediateToRax(void* aValue) {
   PatchMoveImmediateToRax(Current(), aValue);
   Advance(MoveImmediateBytes);
@@ -241,50 +242,55 @@ void Assembler::ExchangeByteRegisterWith
     NewInstruction(0x44, 0x86, 0x03 + (aRegister - UD_R_R8) * 8);
   }
 }
 
 void Assembler::ExchangeByteRbxWithAddressAtRax() {
   NewInstruction(0x86, 0x18);
 }
 
-/* static */ /*ud_type*/ int Assembler::NormalizeRegister(
+/* static */ /*ud_type*/
+int Assembler::NormalizeRegister(
     /*ud_type*/ int aRegister) {
   if (aRegister >= UD_R_AL && aRegister <= UD_R_R15B) {
     return aRegister - UD_R_AL + UD_R_RAX;
   }
   if (aRegister >= UD_R_AX && aRegister <= UD_R_R15W) {
     return aRegister - UD_R_AX + UD_R_RAX;
   }
   if (aRegister >= UD_R_EAX && aRegister <= UD_R_R15D) {
     return aRegister - UD_R_EAX + UD_R_RAX;
   }
   if (aRegister >= UD_R_RAX && aRegister <= UD_R_R15) {
     return aRegister;
   }
   return UD_NONE;
 }
 
-/* static */ bool Assembler::CanPatchShortJump(uint8_t* aIp, void* aTarget) {
+/* static */
+bool Assembler::CanPatchShortJump(uint8_t* aIp, void* aTarget) {
   return (aIp + 2 - 128 <= aTarget) && (aIp + 2 + 127 >= aTarget);
 }
 
-/* static */ void Assembler::PatchShortJump(uint8_t* aIp, void* aTarget) {
+/* static */
+void Assembler::PatchShortJump(uint8_t* aIp, void* aTarget) {
   MOZ_RELEASE_ASSERT(CanPatchShortJump(aIp, aTarget));
   aIp[0] = 0xEB;
   aIp[1] = uint8_t(static_cast<uint8_t*>(aTarget) - aIp - 2);
 }
 
-/* static */ void Assembler::PatchJumpClobberRax(uint8_t* aIp, void* aTarget) {
+/* static */
+void Assembler::PatchJumpClobberRax(uint8_t* aIp, void* aTarget) {
   PatchMoveImmediateToRax(aIp, aTarget);
   aIp[10] = 0x50;  // push %rax
   aIp[11] = 0xC3;  // ret
 }
 
-/* static */ void Assembler::PatchClobber(uint8_t* aIp) {
+/* static */
+void Assembler::PatchClobber(uint8_t* aIp) {
   aIp[0] = 0xCC;  // int3
 }
 
 static uint8_t* PageStart(uint8_t* aPtr) {
   static_assert(sizeof(size_t) == sizeof(uintptr_t), "Unsupported Platform");
   return reinterpret_cast<uint8_t*>(reinterpret_cast<size_t>(aPtr) &
                                     ~(PageSize - 1));
 }
--- a/toolkit/recordreplay/File.cpp
+++ b/toolkit/recordreplay/File.cpp
@@ -265,17 +265,18 @@ void Stream::Flush(bool aTakeLock) {
       mFile->WriteChunk(mBallast.get(), compressedSize, mBufferPos,
                         mStreamPos - mBufferPos, aTakeLock);
   mChunks.append(chunk);
   MOZ_ALWAYS_TRUE(++mChunkIndex == mChunks.length());
 
   mBufferPos = 0;
 }
 
-/* static */ size_t Stream::BallastMaxSize() {
+/* static */
+size_t Stream::BallastMaxSize() {
   return Compression::LZ4::maxCompressedSize(BUFFER_MAX);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // File
 ///////////////////////////////////////////////////////////////////////////////
 
 // Information in a file index about a chunk.
--- a/toolkit/recordreplay/Lock.cpp
+++ b/toolkit/recordreplay/Lock.cpp
@@ -63,17 +63,18 @@ static Lock* CreateNewLock(Thread* aThre
 
   if (IsReplaying()) {
     info->ReadAndNotifyNextOwner(aThread);
   }
 
   return new Lock(aId);
 }
 
-/* static */ void Lock::New(void* aNativeLock) {
+/* static */
+void Lock::New(void* aNativeLock) {
   Thread* thread = Thread::Current();
   RecordingEventSection res(thread);
   if (!res.CanAccessEvents()) {
     Destroy(aNativeLock);  // Clean up any old lock, as below.
     return;
   }
 
   thread->Events().RecordOrReplayThreadEvent(ThreadEvent::CreateLock);
@@ -97,32 +98,34 @@ static Lock* CreateNewLock(Thread* aThre
     gLocks = new LockMap();
   }
 
   gLocks->insert(LockMap::value_type(aNativeLock, lock));
 
   thread->EndDisallowEvents();
 }
 
-/* static */ void Lock::Destroy(void* aNativeLock) {
+/* static */
+void Lock::Destroy(void* aNativeLock) {
   Lock* lock = nullptr;
   {
     AutoWriteSpinLock ex(gLocksLock);
     if (gLocks) {
       LockMap::iterator iter = gLocks->find(aNativeLock);
       if (iter != gLocks->end()) {
         lock = iter->second;
         gLocks->erase(iter);
       }
     }
   }
   delete lock;
 }
 
-/* static */ Lock* Lock::Find(void* aNativeLock) {
+/* static */
+Lock* Lock::Find(void* aNativeLock) {
   MOZ_RELEASE_ASSERT(IsRecordingOrReplaying());
 
   Maybe<AutoReadSpinLock> ex;
   ex.emplace(gLocksLock);
 
   if (gLocks) {
     LockMap::iterator iter = gLocks->find(aNativeLock);
     if (iter != gLocks->end()) {
@@ -190,17 +193,18 @@ void Lock::Exit() {
     mOwner = 0;
 
     // Notify the next owner before releasing the lock.
     LockAcquires* acquires = gLockAcquires.Get(mId);
     acquires->ReadAndNotifyNextOwner(thread);
   }
 }
 
-/* static */ void Lock::LockAquiresUpdated(size_t aLockId) {
+/* static */
+void Lock::LockAquiresUpdated(size_t aLockId) {
   LockAcquires* acquires = gLockAcquires.MaybeGet(aLockId);
   if (acquires && acquires->mAcquires &&
       acquires->mNextOwner == LockAcquires::NoNextOwner) {
     acquires->ReadAndNotifyNextOwner(Thread::Current());
   }
 }
 
 // We use a set of Locks to record and replay the order in which atomic
@@ -213,17 +217,18 @@ void Lock::Exit() {
 // overhead, which we want to minimize.
 static const size_t NumAtomicLocks = 89;
 static Lock** gAtomicLocks;
 
 // While recording, these locks prevent multiple threads from simultaneously
 // owning the same atomic lock.
 static SpinLock* gAtomicLockOwners;
 
-/* static */ void Lock::InitializeLocks() {
+/* static */
+void Lock::InitializeLocks() {
   Thread* thread = Thread::Current();
 
   gNumLocks = 1;
   gAtomicLocks = new Lock*[NumAtomicLocks];
   for (size_t i = 0; i < NumAtomicLocks; i++) {
     gAtomicLocks[i] = CreateNewLock(thread, gNumLocks++);
   }
   if (IsRecording()) {
--- a/toolkit/recordreplay/Thread.cpp
+++ b/toolkit/recordreplay/Thread.cpp
@@ -21,29 +21,32 @@ namespace mozilla {
 namespace recordreplay {
 
 ///////////////////////////////////////////////////////////////////////////////
 // Thread Organization
 ///////////////////////////////////////////////////////////////////////////////
 
 static MOZ_THREAD_LOCAL(Thread*) gTlsThreadKey;
 
-/* static */ Monitor* Thread::gMonitor;
+/* static */
+Monitor* Thread::gMonitor;
 
-/* static */ Thread* Thread::Current() {
+/* static */
+Thread* Thread::Current() {
   MOZ_ASSERT(IsRecordingOrReplaying());
   Thread* thread = gTlsThreadKey.get();
   if (!thread && IsReplaying()) {
     // Disable system threads when replaying.
     WaitForeverNoIdle();
   }
   return thread;
 }
 
-/* static */ bool Thread::CurrentIsMainThread() {
+/* static */
+bool Thread::CurrentIsMainThread() {
   Thread* thread = Current();
   return thread && thread->IsMainThread();
 }
 
 void Thread::BindToCurrent() {
   MOZ_ASSERT(!mStackBase);
   gTlsThreadKey.set(this);
 
@@ -66,46 +69,50 @@ void Thread::BindToCurrent() {
   if (mId != MainThreadId) {
     gMonitor->NotifyAll();
   }
 }
 
 // All threads, indexed by the thread ID.
 static Thread* gThreads;
 
-/* static */ Thread* Thread::GetById(size_t aId) {
+/* static */
+Thread* Thread::GetById(size_t aId) {
   MOZ_ASSERT(aId);
   MOZ_ASSERT(aId <= MaxThreadId);
   return &gThreads[aId];
 }
 
-/* static */ Thread* Thread::GetByNativeId(NativeThreadId aNativeId) {
+/* static */
+Thread* Thread::GetByNativeId(NativeThreadId aNativeId) {
   for (size_t id = MainThreadId; id <= MaxRecordedThreadId; id++) {
     Thread* thread = GetById(id);
     if (thread->mNativeId == aNativeId) {
       return thread;
     }
   }
   return nullptr;
 }
 
-/* static */ Thread* Thread::GetByStackPointer(void* aSp) {
+/* static */
+Thread* Thread::GetByStackPointer(void* aSp) {
   if (!gThreads) {
     return nullptr;
   }
   for (size_t i = MainThreadId; i <= MaxThreadId; i++) {
     Thread* thread = &gThreads[i];
     if (MemoryContains(thread->mStackBase, thread->mStackSize, aSp)) {
       return thread;
     }
   }
   return nullptr;
 }
 
-/* static */ void Thread::InitializeThreads() {
+/* static */
+void Thread::InitializeThreads() {
   gThreads = new Thread[MaxThreadId + 1];
   for (size_t i = MainThreadId; i <= MaxThreadId; i++) {
     Thread* thread = &gThreads[i];
     PodZero(thread);
     new (thread) Thread();
 
     thread->mId = i;
 
@@ -116,24 +123,26 @@ static Thread* gThreads;
     DirectCreatePipe(&thread->mNotifyfd, &thread->mIdlefd);
   }
 
   if (!gTlsThreadKey.init()) {
     MOZ_CRASH();
   }
 }
 
-/* static */ void Thread::WaitUntilInitialized(Thread* aThread) {
+/* static */
+void Thread::WaitUntilInitialized(Thread* aThread) {
   MonitorAutoLock lock(*gMonitor);
   while (!aThread->mStackBase) {
     gMonitor->Wait();
   }
 }
 
-/* static */ void Thread::ThreadMain(void* aArgument) {
+/* static */
+void Thread::ThreadMain(void* aArgument) {
   MOZ_ASSERT(IsRecordingOrReplaying());
 
   Thread* thread = (Thread*)aArgument;
   MOZ_ASSERT(thread->mId > MainThreadId);
 
   thread->BindToCurrent();
 
   while (true) {
@@ -161,17 +170,18 @@ static Thread* gThreads;
     thread->mStart = nullptr;
     thread->mStartArg = nullptr;
 
     // Notify any other thread waiting for this to finish in JoinThread.
     gMonitor->NotifyAll();
   }
 }
 
-/* static */ void Thread::SpawnAllThreads() {
+/* static */
+void Thread::SpawnAllThreads() {
   MOZ_ASSERT(AreThreadEventsPassedThrough());
 
   InitializeThreadSnapshots(MaxRecordedThreadId + 1);
 
   gMonitor = new Monitor();
 
   // All Threads are spawned up front. This allows threads to be scanned
   // (e.g. in ReplayUnlock) without worrying about racing with other threads
@@ -180,42 +190,43 @@ static Thread* gThreads;
     SpawnThread(GetById(i));
   }
 }
 
 // The number of non-recorded threads that have been spawned.
 static Atomic<size_t, SequentiallyConsistent, Behavior::DontPreserve>
     gNumNonRecordedThreads;
 
-/* static */ Thread* Thread::SpawnNonRecordedThread(Callback aStart,
-                                                    void* aArgument) {
+/* static */
+Thread* Thread::SpawnNonRecordedThread(Callback aStart, void* aArgument) {
   if (IsMiddleman()) {
     DirectSpawnThread(aStart, aArgument);
     return nullptr;
   }
 
   size_t id = MaxRecordedThreadId + ++gNumNonRecordedThreads;
   MOZ_RELEASE_ASSERT(id <= MaxThreadId);
 
   Thread* thread = GetById(id);
   thread->mStart = aStart;
   thread->mStartArg = aArgument;
 
   SpawnThread(thread);
   return thread;
 }
 
-/* static */ void Thread::SpawnThread(Thread* aThread) {
+/* static */
+void Thread::SpawnThread(Thread* aThread) {
   DirectSpawnThread(ThreadMain, aThread);
   WaitUntilInitialized(aThread);
 }
 
-/* static */ NativeThreadId Thread::StartThread(Callback aStart,
-                                                void* aArgument,
-                                                bool aNeedsJoin) {
+/* static */
+NativeThreadId Thread::StartThread(Callback aStart, void* aArgument,
+                                   bool aNeedsJoin) {
   Thread* thread = Thread::Current();
   RecordingEventSection res(thread);
   if (!res.CanAccessEvents()) {
     return 0;
   }
 
   MonitorAutoLock lock(*gMonitor);
 
@@ -321,17 +332,18 @@ MOZ_EXPORT bool RecordReplayInterface_In
 }
 
 }  // extern "C"
 
 ///////////////////////////////////////////////////////////////////////////////
 // Thread Coordination
 ///////////////////////////////////////////////////////////////////////////////
 
-/* static */ void Thread::WaitForIdleThreads() {
+/* static */
+void Thread::WaitForIdleThreads() {
   MOZ_RELEASE_ASSERT(CurrentIsMainThread());
 
   MonitorAutoLock lock(*gMonitor);
   for (size_t i = MainThreadId + 1; i <= MaxRecordedThreadId; i++) {
     Thread* thread = GetById(i);
     thread->mShouldIdle = true;
     thread->mUnrecordedWaitNotified = false;
   }
@@ -374,22 +386,24 @@ MOZ_EXPORT bool RecordReplayInterface_In
     if (done) {
       break;
     }
     MonitorAutoUnlock unlock(*gMonitor);
     WaitNoIdle();
   }
 }
 
-/* static */ void Thread::ResumeSingleIdleThread(size_t aId) {
+/* static */
+void Thread::ResumeSingleIdleThread(size_t aId) {
   GetById(aId)->mShouldIdle = false;
   Notify(aId);
 }
 
-/* static */ void Thread::ResumeIdleThreads() {
+/* static */
+void Thread::ResumeIdleThreads() {
   MOZ_RELEASE_ASSERT(CurrentIsMainThread());
   for (size_t i = MainThreadId + 1; i <= MaxRecordedThreadId; i++) {
     ResumeSingleIdleThread(i);
   }
 }
 
 void Thread::NotifyUnrecordedWait(
     const std::function<void()>& aNotifyCallback) {
@@ -429,24 +443,26 @@ bool Thread::MaybeWaitForCheckpointSave(
   aReleaseCallback();
   while (mShouldIdle) {
     MonitorAutoUnlock unlock(*gMonitor);
     Wait();
   }
   return true;
 }
 
-/* static */ void Thread::WaitNoIdle() {
+/* static */
+void Thread::WaitNoIdle() {
   Thread* thread = Current();
   uint8_t data = 0;
   size_t read = DirectRead(thread->mIdlefd, &data, 1);
   MOZ_RELEASE_ASSERT(read == 1);
 }
 
-/* static */ void Thread::Wait() {
+/* static */
+void Thread::Wait() {
   Thread* thread = Current();
   MOZ_ASSERT(!thread->mIdle);
   MOZ_ASSERT(thread->IsRecordedThread() && !thread->PassThroughEvents());
 
   if (thread->IsMainThread()) {
     WaitNoIdle();
     return;
   }
@@ -481,31 +497,34 @@ bool Thread::MaybeWaitForCheckpointSave(
       Unreachable();
     }
   } while (thread->mShouldIdle);
 
   thread->mIdle = false;
   thread->SetPassThrough(false);
 }
 
-/* static */ void Thread::WaitForever() {
+/* static */
+void Thread::WaitForever() {
   while (true) {
     Wait();
   }
   Unreachable();
 }
 
-/* static */ void Thread::WaitForeverNoIdle() {
+/* static */
+void Thread::WaitForeverNoIdle() {
   FileHandle writeFd, readFd;
   DirectCreatePipe(&writeFd, &readFd);
   while (true) {
     uint8_t data;
     DirectRead(readFd, &data, 1);
   }
 }
 
-/* static */ void Thread::Notify(size_t aId) {
+/* static */
+void Thread::Notify(size_t aId) {
   uint8_t data = 0;
   DirectWrite(GetById(aId)->mNotifyfd, &data, 1);
 }
 
 }  // namespace recordreplay
 }  // namespace mozilla
--- a/toolkit/recordreplay/ipc/Channel.cpp
+++ b/toolkit/recordreplay/ipc/Channel.cpp
@@ -99,17 +99,18 @@ Channel::Channel(size_t aId, bool aMiddl
     mConnectionFd = connection.ClonePlatformHandle().release();
     int rv = listen(mConnectionFd, 1);
     MOZ_RELEASE_ASSERT(rv >= 0);
   }
 
   Thread::SpawnNonRecordedThread(ThreadMain, this);
 }
 
-/* static */ void Channel::ThreadMain(void* aChannelArg) {
+/* static */
+void Channel::ThreadMain(void* aChannelArg) {
   Channel* channel = (Channel*)aChannelArg;
 
   static const int32_t MagicValue = 0x914522b9;
 
   if (IsRecordingOrReplaying()) {
     HelloMessage msg;
 
     int rv = HANDLE_EINTR(recv(channel->mFd, &msg, sizeof(msg), MSG_WAITALL));
--- a/toolkit/recordreplay/ipc/ChildProcess.cpp
+++ b/toolkit/recordreplay/ipc/ChildProcess.cpp
@@ -18,18 +18,18 @@ namespace parent {
 static IntroductionMessage* gIntroductionMessage;
 
 // How many channels have been constructed so far.
 static size_t gNumChannels;
 
 // Whether children might be debugged and should not be treated as hung.
 static bool gChildrenAreDebugging;
 
-/* static */ void ChildProcessInfo::SetIntroductionMessage(
-    IntroductionMessage* aMessage) {
+/* static */
+void ChildProcessInfo::SetIntroductionMessage(IntroductionMessage* aMessage) {
   gIntroductionMessage = aMessage;
 }
 
 ChildProcessInfo::ChildProcessInfo(
     const Maybe<RecordingProcessData>& aRecordingProcessData)
     : mChannel(nullptr),
       mRecording(aRecordingProcessData.isSome()),
       mPaused(false),
@@ -340,17 +340,18 @@ Message::UniquePtr ChildProcessInfo::Wai
         gMonitor->WaitUntil(deadline);
       }
     }
   }
 }
 
 // Runnable created on the main thread to handle any tasks sent by the replay
 // message loop thread which were not handled while the main thread was blocked.
-/* static */ void ChildProcessInfo::MaybeProcessPendingMessageRunnable() {
+/* static */
+void ChildProcessInfo::MaybeProcessPendingMessageRunnable() {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   MonitorAutoLock lock(*gMonitor);
   MOZ_RELEASE_ASSERT(gHasPendingMessageRunnable);
   gHasPendingMessageRunnable = false;
   while (true) {
     ChildProcessInfo* process = nullptr;
     Message::UniquePtr msg = ExtractChildMessage(&process);
 
--- a/toolkit/xre/nsAppStartupNotifier.cpp
+++ b/toolkit/xre/nsAppStartupNotifier.cpp
@@ -7,18 +7,18 @@
 #include "nsString.h"
 #include "nsIServiceManager.h"
 #include "nsICategoryManager.h"
 #include "nsXPCOM.h"
 #include "nsISupportsPrimitives.h"
 #include "nsAppStartupNotifier.h"
 #include "nsISimpleEnumerator.h"
 
-/* static */ nsresult nsAppStartupNotifier::NotifyObservers(
-    const char* aTopic) {
+/* static */
+nsresult nsAppStartupNotifier::NotifyObservers(const char* aTopic) {
   NS_ENSURE_ARG(aTopic);
   nsresult rv;
 
   // now initialize all startup listeners
   nsCOMPtr<nsICategoryManager> categoryManager =
       do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);