Bug 1523969 part 19 - Move method definition inline comments to new line in 'netwerk/'. r=dragana
authorRyan Hunt <rhunt@eqrion.net>
Mon, 25 Feb 2019 16:11:11 -0600
changeset 519782 76dd23f024d5cac080443bf7872ef7103c429542
parent 519781 51a98c1a814f3a805e638149f778f3be1eca6583
child 519783 977a0ba7ec7051844703272ddcc5910d112dfc63
push id10862
push userffxbld-merge
push dateMon, 11 Mar 2019 13:01:11 +0000
treeherdermozilla-beta@a2e7f5c935da [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdragana
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 19 - Move method definition inline comments to new line in 'netwerk/'. r=dragana Differential Revision: https://phabricator.services.mozilla.com/D21120
netwerk/base/RequestContextService.cpp
netwerk/base/nsIOService.cpp
netwerk/base/nsSimpleNestedURI.cpp
netwerk/base/nsSimpleURI.cpp
netwerk/base/nsSocketTransportService2.cpp
netwerk/base/nsStandardURL.cpp
netwerk/cookie/nsCookieService.cpp
netwerk/ipc/SocketProcessChild.cpp
netwerk/ipc/SocketProcessParent.cpp
netwerk/protocol/about/nsAboutCacheEntry.cpp
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/protocol/http/TrackingDummyChannelChild.cpp
netwerk/protocol/http/nsCORSListenerProxy.cpp
netwerk/protocol/http/nsHttpHandler.cpp
netwerk/protocol/http/nsHttpHeaderArray.cpp
netwerk/protocol/res/SubstitutingProtocolHandler.cpp
netwerk/protocol/websocket/WebSocketChannel.cpp
netwerk/protocol/websocket/WebSocketEventService.cpp
netwerk/streamconv/converters/nsHTTPCompressConv.cpp
netwerk/url-classifier/AsyncUrlChannelClassifier.cpp
netwerk/url-classifier/UrlClassifierCommon.cpp
netwerk/url-classifier/UrlClassifierFeatureCryptomining.cpp
netwerk/url-classifier/UrlClassifierFeatureFactory.cpp
netwerk/url-classifier/UrlClassifierFeatureFingerprinting.cpp
netwerk/url-classifier/UrlClassifierFeatureFlash.cpp
netwerk/url-classifier/UrlClassifierFeatureLoginReputation.cpp
netwerk/url-classifier/UrlClassifierFeaturePhishingProtection.cpp
netwerk/url-classifier/UrlClassifierFeatureTrackingAnnotation.cpp
netwerk/url-classifier/UrlClassifierFeatureTrackingProtection.cpp
--- a/netwerk/base/RequestContextService.cpp
+++ b/netwerk/base/RequestContextService.cpp
@@ -477,17 +477,18 @@ void RequestContextService::Shutdown() {
   // shutdown.
   for (auto iter = mTable.Iter(); !iter.Done(); iter.Next()) {
     iter.Data()->CancelTailPendingRequests(NS_ERROR_ABORT);
   }
   mTable.Clear();
   sShutdown = true;
 }
 
-/* static */ already_AddRefed<nsIRequestContextService>
+/* static */
+already_AddRefed<nsIRequestContextService>
 RequestContextService::GetOrCreate() {
   MOZ_ASSERT(NS_IsMainThread());
 
   RefPtr<RequestContextService> svc;
   if (gSingleton) {
     svc = gSingleton;
   } else {
     svc = new RequestContextService();
--- a/netwerk/base/nsIOService.cpp
+++ b/netwerk/base/nsIOService.cpp
@@ -1807,25 +1807,26 @@ nsIOService::SpeculativeConnect(nsIURI *
 }
 
 NS_IMETHODIMP
 nsIOService::SpeculativeAnonymousConnect(nsIURI *aURI, nsIPrincipal *aPrincipal,
                                          nsIInterfaceRequestor *aCallbacks) {
   return SpeculativeConnectInternal(aURI, aPrincipal, aCallbacks, true);
 }
 
-/*static*/ bool nsIOService::IsDataURIUniqueOpaqueOrigin() {
+/*static*/
+bool nsIOService::IsDataURIUniqueOpaqueOrigin() {
   return sIsDataURIUniqueOpaqueOrigin;
 }
 
-/*static*/ bool nsIOService::BlockToplevelDataUriNavigations() {
+/*static*/
+bool nsIOService::BlockToplevelDataUriNavigations() {
   return sBlockToplevelDataUriNavigations;
 }
 
-/*static*/ bool nsIOService::BlockFTPSubresources() {
-  return sBlockFTPSubresources;
-}
+/*static*/
+bool nsIOService::BlockFTPSubresources() { return sBlockFTPSubresources; }
 
 NS_IMETHODIMP
 nsIOService::NotImplemented() { return NS_ERROR_NOT_IMPLEMENTED; }
 
 }  // namespace net
 }  // namespace mozilla
--- a/netwerk/base/nsSimpleNestedURI.cpp
+++ b/netwerk/base/nsSimpleNestedURI.cpp
@@ -141,17 +141,18 @@ nsSimpleNestedURI::GetInnerURI(nsIURI** 
 }
 
 NS_IMETHODIMP
 nsSimpleNestedURI::GetInnermostURI(nsIURI** uri) {
   return NS_ImplGetInnermostURI(this, uri);
 }
 
 // nsSimpleURI overrides
-/* virtual */ nsresult nsSimpleNestedURI::EqualsInternal(
+/* virtual */
+nsresult nsSimpleNestedURI::EqualsInternal(
     nsIURI* other, nsSimpleURI::RefHandlingEnum refHandlingMode, bool* result) {
   *result = false;
   NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED);
 
   if (other) {
     bool correctScheme;
     nsresult rv = other->SchemeIs(mScheme.get(), &correctScheme);
     NS_ENSURE_SUCCESS(rv, rv);
@@ -168,17 +169,18 @@ nsSimpleNestedURI::GetInnermostURI(nsIUR
                    : otherInner->EqualsExceptRef(mInnerURI, result);
       }
     }
   }
 
   return NS_OK;
 }
 
-/* virtual */ nsSimpleURI* nsSimpleNestedURI::StartClone(
+/* virtual */
+nsSimpleURI* nsSimpleNestedURI::StartClone(
     nsSimpleURI::RefHandlingEnum refHandlingMode, const nsACString& newRef) {
   NS_ENSURE_TRUE(mInnerURI, nullptr);
 
   nsCOMPtr<nsIURI> innerClone;
   nsresult rv = NS_OK;
   if (refHandlingMode == eHonorRef) {
     innerClone = mInnerURI;
   } else if (refHandlingMode == eReplaceRef) {
--- a/netwerk/base/nsSimpleURI.cpp
+++ b/netwerk/base/nsSimpleURI.cpp
@@ -26,17 +26,18 @@ using namespace mozilla::ipc;
 
 namespace mozilla {
 namespace net {
 
 static NS_DEFINE_CID(kThisSimpleURIImplementationCID,
                      NS_THIS_SIMPLEURI_IMPLEMENTATION_CID);
 static NS_DEFINE_CID(kSimpleURICID, NS_SIMPLEURI_CID);
 
-/* static */ already_AddRefed<nsSimpleURI> nsSimpleURI::From(nsIURI *aURI) {
+/* static */
+already_AddRefed<nsSimpleURI> nsSimpleURI::From(nsIURI *aURI) {
   RefPtr<nsSimpleURI> uri;
   nsresult rv = aURI->QueryInterface(kThisSimpleURIImplementationCID,
                                      getter_AddRefs(uri));
   if (NS_FAILED(rv)) {
     return nullptr;
   }
 
   return uri.forget();
@@ -477,17 +478,18 @@ nsSimpleURI::Equals(nsIURI *other, bool 
   return EqualsInternal(other, eHonorRef, result);
 }
 
 NS_IMETHODIMP
 nsSimpleURI::EqualsExceptRef(nsIURI *other, bool *result) {
   return EqualsInternal(other, eIgnoreRef, result);
 }
 
-/* virtual */ nsresult nsSimpleURI::EqualsInternal(
+/* virtual */
+nsresult nsSimpleURI::EqualsInternal(
     nsIURI *other, nsSimpleURI::RefHandlingEnum refHandlingMode, bool *result) {
   NS_ENSURE_ARG_POINTER(other);
   MOZ_ASSERT(result, "null pointer");
 
   RefPtr<nsSimpleURI> otherUri;
   nsresult rv = other->QueryInterface(kThisSimpleURIImplementationCID,
                                       getter_AddRefs(otherUri));
   if (NS_FAILED(rv)) {
@@ -538,19 +540,20 @@ nsSimpleURI::SchemeIs(const char *i_Sche
 
 /* virtual */ nsSimpleURI *nsSimpleURI::StartClone(
     nsSimpleURI::RefHandlingEnum refHandlingMode, const nsACString &newRef) {
   nsSimpleURI *url = new nsSimpleURI();
   SetRefOnClone(url, refHandlingMode, newRef);
   return url;
 }
 
-/* virtual */ void nsSimpleURI::SetRefOnClone(
-    nsSimpleURI *url, nsSimpleURI::RefHandlingEnum refHandlingMode,
-    const nsACString &newRef) {
+/* virtual */
+void nsSimpleURI::SetRefOnClone(nsSimpleURI *url,
+                                nsSimpleURI::RefHandlingEnum refHandlingMode,
+                                const nsACString &newRef) {
   if (refHandlingMode == eHonorRef) {
     url->mRef = mRef;
     url->mIsRefValid = mIsRefValid;
   } else if (refHandlingMode == eReplaceRef) {
     url->SetRef(newRef);
   }
 }
 
--- a/netwerk/base/nsSocketTransportService2.cpp
+++ b/netwerk/base/nsSocketTransportService2.cpp
@@ -581,18 +581,19 @@ static const char *gCallbackPrefs[] = {
     MAX_TIME_BETWEEN_TWO_POLLS,
     MAX_TIME_FOR_PR_CLOSE_DURING_SHUTDOWN,
     POLLABLE_EVENT_TIMEOUT,
     ESNI_ENABLED,
     ESNI_DISABLED_MITM,
     nullptr,
 };
 
-/* static */ void nsSocketTransportService::PrefCallback(
-    const char *aPref, nsSocketTransportService *aSelf) {
+/* static */
+void nsSocketTransportService::PrefCallback(const char *aPref,
+                                            nsSocketTransportService *aSelf) {
   aSelf->UpdatePrefs();
 }
 
 // called from main thread only
 NS_IMETHODIMP
 nsSocketTransportService::Init() {
   if (!NS_IsMainThread()) {
     NS_ERROR("wrong thread");
--- a/netwerk/base/nsStandardURL.cpp
+++ b/netwerk/base/nsStandardURL.cpp
@@ -474,18 +474,19 @@ inline nsresult ParseIPv4Number(const ns
   }
 
   // The error case
   number = 0;
   return NS_ERROR_FAILURE;
 }
 
 // IPv4 parser spec: https://url.spec.whatwg.org/#concept-ipv4-parser
-/* static */ nsresult nsStandardURL::NormalizeIPv4(const nsACString &host,
-                                                   nsCString &result) {
+/* static */
+nsresult nsStandardURL::NormalizeIPv4(const nsACString &host,
+                                      nsCString &result) {
   int32_t bases[4] = {10, 10, 10, 10};
   bool onlyBase10 = true;  // Track this as a special case
   int32_t dotIndex[3];     // The positions of the dots in the string
 
   // The length may be adjusted by ValidateIPv4Number (ignoring the trailing
   // period) so use "length", rather than host.Length() after that call.
   int32_t length = static_cast<int32_t>(host.Length());
   int32_t dotCount =
--- a/netwerk/cookie/nsCookieService.cpp
+++ b/netwerk/cookie/nsCookieService.cpp
@@ -563,17 +563,18 @@ already_AddRefed<nsCookieService> nsCook
     } else {
       gCookieService = nullptr;
     }
   }
 
   return do_AddRef(gCookieService);
 }
 
-/* static */ void nsCookieService::AppClearDataObserverInit() {
+/* static */
+void nsCookieService::AppClearDataObserverInit() {
   nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
   nsCOMPtr<nsIObserver> obs = new AppClearDataObserver();
   observerService->AddObserver(obs, TOPIC_CLEAR_ORIGIN_DATA,
                                /* ownsWeak= */ false);
 }
 
 /******************************************************************************
  * nsCookieService impl:
--- a/netwerk/ipc/SocketProcessChild.cpp
+++ b/netwerk/ipc/SocketProcessChild.cpp
@@ -37,17 +37,18 @@ SocketProcessChild::SocketProcessChild()
 }
 
 SocketProcessChild::~SocketProcessChild() {
   LOG(("DESTRUCT SocketProcessChild::SocketProcessChild\n"));
   MOZ_COUNT_DTOR(SocketProcessChild);
   sSocketProcessChild = nullptr;
 }
 
-/* static */ SocketProcessChild* SocketProcessChild::GetSingleton() {
+/* static */
+SocketProcessChild* SocketProcessChild::GetSingleton() {
   return sSocketProcessChild;
 }
 
 bool SocketProcessChild::Init(base::ProcessId aParentPid,
                               const char* aParentBuildID, MessageLoop* aIOLoop,
                               IPC::Channel* aChannel) {
   if (NS_WARN_IF(NS_FAILED(nsThreadManager::get().Init()))) {
     return false;
--- a/netwerk/ipc/SocketProcessParent.cpp
+++ b/netwerk/ipc/SocketProcessParent.cpp
@@ -26,17 +26,18 @@ SocketProcessParent::SocketProcessParent
 
 SocketProcessParent::~SocketProcessParent() {
   MOZ_ASSERT(NS_IsMainThread());
 
   MOZ_COUNT_DTOR(SocketProcessParent);
   sSocketProcessParent = nullptr;
 }
 
-/* static */ SocketProcessParent* SocketProcessParent::GetSingleton() {
+/* static */
+SocketProcessParent* SocketProcessParent::GetSingleton() {
   MOZ_ASSERT(NS_IsMainThread());
 
   return sSocketProcessParent;
 }
 
 mozilla::ipc::IPCResult SocketProcessParent::RecvInitCrashReporter(
     Shmem&& aShmem, const NativeThreadId& aThreadId) {
   mCrashReporter = MakeUnique<CrashReporterHost>(GeckoProcessType_Content,
@@ -134,16 +135,16 @@ class DeferredDeleteSocketProcessParent 
         mParent(std::move(aParent)) {}
 
   NS_IMETHODIMP Run() override { return NS_OK; }
 
  private:
   UniquePtr<SocketProcessParent> mParent;
 };
 
-/* static */ void SocketProcessParent::Destroy(
-    UniquePtr<SocketProcessParent>&& aParent) {
+/* static */
+void SocketProcessParent::Destroy(UniquePtr<SocketProcessParent>&& aParent) {
   NS_DispatchToMainThread(
       new DeferredDeleteSocketProcessParent(std::move(aParent)));
 }
 
 }  // namespace net
 }  // namespace mozilla
--- a/netwerk/protocol/about/nsAboutCacheEntry.cpp
+++ b/netwerk/protocol/about/nsAboutCacheEntry.cpp
@@ -514,17 +514,18 @@ NS_IMETHODIMP
 nsAboutCacheEntry::Channel::OnDataAvailable(nsIRequest *request,
                                             nsIInputStream *aInputStream,
                                             uint64_t aOffset, uint32_t aCount) {
   uint32_t n;
   return aInputStream->ReadSegments(&nsAboutCacheEntry::Channel::PrintCacheData,
                                     this, aCount, &n);
 }
 
-/* static */ nsresult nsAboutCacheEntry::Channel::PrintCacheData(
+/* static */
+nsresult nsAboutCacheEntry::Channel::PrintCacheData(
     nsIInputStream *aInStream, void *aClosure, const char *aFromSegment,
     uint32_t aToOffset, uint32_t aCount, uint32_t *aWriteCount) {
   nsAboutCacheEntry::Channel *a =
       static_cast<nsAboutCacheEntry::Channel *>(aClosure);
 
   nsCString buffer;
   HexDump(&a->mHexDumpState, aFromSegment, aCount, buffer);
 
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -4445,19 +4445,19 @@ nsresult HttpBaseChannel::CheckRedirectL
     return NS_ERROR_REDIRECT_LOOP;
   }
 
   return NS_OK;
 }
 
 // NOTE: This function duplicates code from nsBaseChannel. This will go away
 // once HTTP uses nsBaseChannel (part of bug 312760)
-/* static */ void HttpBaseChannel::CallTypeSniffers(void* aClosure,
-                                                    const uint8_t* aData,
-                                                    uint32_t aCount) {
+/* static */
+void HttpBaseChannel::CallTypeSniffers(void* aClosure, const uint8_t* aData,
+                                       uint32_t aCount) {
   nsIChannel* chan = static_cast<nsIChannel*>(aClosure);
 
   nsAutoCString newType;
   NS_SniffContent(NS_CONTENT_SNIFFER_CATEGORY, chan, aData, aCount, newType);
   if (!newType.IsEmpty()) {
     chan->SetContentType(newType);
   }
 }
--- a/netwerk/protocol/http/TrackingDummyChannelChild.cpp
+++ b/netwerk/protocol/http/TrackingDummyChannelChild.cpp
@@ -8,17 +8,18 @@
 #include "mozilla/ipc/BackgroundUtils.h"
 #include "mozilla/ipc/URIUtils.h"
 #include "nsIChannel.h"
 #include "nsIURI.h"
 
 namespace mozilla {
 namespace net {
 
-/* static */ bool TrackingDummyChannelChild::Create(
+/* static */
+bool TrackingDummyChannelChild::Create(
     nsIHttpChannel* aChannel, nsIURI* aURI,
     const std::function<void(bool)>& aCallback) {
   MOZ_ASSERT(NS_IsMainThread());
 
   MOZ_ASSERT(aChannel);
   MOZ_ASSERT(aURI);
 
   nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
--- a/netwerk/protocol/http/nsCORSListenerProxy.cpp
+++ b/netwerk/protocol/http/nsCORSListenerProxy.cpp
@@ -318,20 +318,19 @@ void nsPreflightCache::RemoveEntries(nsI
   }
 }
 
 void nsPreflightCache::Clear() {
   mList.clear();
   mTable.Clear();
 }
 
-/* static */ bool nsPreflightCache::GetCacheKey(nsIURI* aURI,
-                                                nsIPrincipal* aPrincipal,
-                                                bool aWithCredentials,
-                                                nsACString& _retval) {
+/* static */
+bool nsPreflightCache::GetCacheKey(nsIURI* aURI, nsIPrincipal* aPrincipal,
+                                   bool aWithCredentials, nsACString& _retval) {
   NS_ASSERTION(aURI, "Null uri!");
   NS_ASSERTION(aPrincipal, "Null principal!");
 
   NS_NAMED_LITERAL_CSTRING(space, " ");
 
   nsCOMPtr<nsIURI> uri;
   nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
   NS_ENSURE_SUCCESS(rv, false);
--- a/netwerk/protocol/http/nsHttpHandler.cpp
+++ b/netwerk/protocol/http/nsHttpHandler.cpp
@@ -174,17 +174,18 @@ static nsCString GetDeviceModelId() {
 #endif
 
 //-----------------------------------------------------------------------------
 // nsHttpHandler <public>
 //-----------------------------------------------------------------------------
 
 StaticRefPtr<nsHttpHandler> gHttpHandler;
 
-/* static */ already_AddRefed<nsHttpHandler> nsHttpHandler::GetInstance() {
+/* static */
+already_AddRefed<nsHttpHandler> nsHttpHandler::GetInstance() {
   if (!gHttpHandler) {
     gHttpHandler = new nsHttpHandler();
     DebugOnly<nsresult> rv = gHttpHandler->Init();
     MOZ_ASSERT(NS_SUCCEEDED(rv));
     // There is code that may be executed during the final cycle collection
     // shutdown and still referencing gHttpHandler.
     ClearOnShutdown(&gHttpHandler,
                     ShutdownPhase::ShutdownPostLastCycleCollection);
@@ -847,19 +848,19 @@ nsresult nsHttpHandler::AsyncOnChannelRe
   // TODO E10S This helper has to be initialized on the other process
   RefPtr<nsAsyncRedirectVerifyHelper> redirectCallbackHelper =
       new nsAsyncRedirectVerifyHelper();
 
   return redirectCallbackHelper->Init(oldChan, newChan, flags,
                                       mainThreadEventTarget);
 }
 
-/* static */ nsresult nsHttpHandler::GenerateHostPort(const nsCString &host,
-                                                      int32_t port,
-                                                      nsACString &hostLine) {
+/* static */
+nsresult nsHttpHandler::GenerateHostPort(const nsCString &host, int32_t port,
+                                         nsACString &hostLine) {
   return NS_GenerateHostPort(host, port, hostLine);
 }
 
 //-----------------------------------------------------------------------------
 // nsHttpHandler <private>
 //-----------------------------------------------------------------------------
 
 const nsCString &nsHttpHandler::UserAgent() {
--- a/netwerk/protocol/http/nsHttpHeaderArray.cpp
+++ b/netwerk/protocol/http/nsHttpHeaderArray.cpp
@@ -312,20 +312,21 @@ nsresult nsHttpHeaderArray::VisitHeaders
     rv = visitor->VisitHeader(hdr, entry.value);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   return NS_OK;
 }
 
-/*static*/ nsresult nsHttpHeaderArray::ParseHeaderLine(const nsACString &line,
-                                                       nsHttpAtom *hdr,
-                                                       nsACString *headerName,
-                                                       nsACString *val) {
+/*static*/
+nsresult nsHttpHeaderArray::ParseHeaderLine(const nsACString &line,
+                                            nsHttpAtom *hdr,
+                                            nsACString *headerName,
+                                            nsACString *val) {
   //
   // BNF from section 4.2 of RFC 2616:
   //
   //   message-header = field-name ":" [ field-value ]
   //   field-name     = token
   //   field-value    = *( field-content | LWS )
   //   field-content  = <the OCTETs making up the field-value
   //                     and consisting of either *TEXT or combinations
--- a/netwerk/protocol/res/SubstitutingProtocolHandler.cpp
+++ b/netwerk/protocol/res/SubstitutingProtocolHandler.cpp
@@ -77,17 +77,18 @@ nsresult SubstitutingURL::EnsureFile() {
   // In most cases, the scheme is jar if it's not file.
   // Regardless, net_GetFileFromURLSpec should be avoided
   // when the scheme isn't file.
   if (!scheme.EqualsLiteral("file")) return NS_ERROR_NO_INTERFACE;
 
   return net_GetFileFromURLSpec(spec, getter_AddRefs(mFile));
 }
 
-/* virtual */ nsStandardURL* SubstitutingURL::StartClone() {
+/* virtual */
+nsStandardURL* SubstitutingURL::StartClone() {
   SubstitutingURL* clone = new SubstitutingURL();
   return clone;
 }
 
 NS_IMETHODIMP
 SubstitutingURL::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc) {
   *aClassIDNoAlloc = kSubstitutingURLCID;
   return NS_OK;
--- a/netwerk/protocol/websocket/WebSocketChannel.cpp
+++ b/netwerk/protocol/websocket/WebSocketChannel.cpp
@@ -1847,18 +1847,18 @@ nsresult WebSocketChannel::ProcessInput(
       mBufferSize = kIncomingBufferStableSize;
       free(mBuffer);
       mBuffer = (uint8_t *)moz_xmalloc(mBufferSize);
     }
   }
   return NS_OK;
 }
 
-/* static */ void WebSocketChannel::ApplyMask(uint32_t mask, uint8_t *data,
-                                              uint64_t len) {
+/* static */
+void WebSocketChannel::ApplyMask(uint32_t mask, uint8_t *data, uint64_t len) {
   if (!data || len == 0) return;
 
   // Optimally we want to apply the mask 32 bits at a time,
   // but the buffer might not be alligned. So we first deal with
   // 0 to 3 bytes of preamble individually
 
   while (len && (reinterpret_cast<uintptr_t>(data) & 3)) {
     *data ^= mask >> 24;
--- a/netwerk/protocol/websocket/WebSocketEventService.cpp
+++ b/netwerk/protocol/websocket/WebSocketEventService.cpp
@@ -168,25 +168,25 @@ class WebSocketClosedRunnable final : pu
     NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "WebSocketClosed failed");
   }
 
   bool mWasClean;
   uint16_t mCode;
   const nsString mReason;
 };
 
-/* static */ already_AddRefed<WebSocketEventService>
-WebSocketEventService::Get() {
+/* static */
+already_AddRefed<WebSocketEventService> WebSocketEventService::Get() {
   MOZ_ASSERT(NS_IsMainThread());
   RefPtr<WebSocketEventService> service = gWebSocketEventService.get();
   return service.forget();
 }
 
-/* static */ already_AddRefed<WebSocketEventService>
-WebSocketEventService::GetOrCreate() {
+/* static */
+already_AddRefed<WebSocketEventService> WebSocketEventService::GetOrCreate() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!gWebSocketEventService) {
     gWebSocketEventService = new WebSocketEventService();
   }
 
   RefPtr<WebSocketEventService> service = gWebSocketEventService.get();
   return service.forget();
--- a/netwerk/streamconv/converters/nsHTTPCompressConv.cpp
+++ b/netwerk/streamconv/converters/nsHTTPCompressConv.cpp
@@ -165,19 +165,21 @@ nsHTTPCompressConv::OnStopRequest(nsIReq
   nsCOMPtr<nsIStreamListener> listener;
   {
     MutexAutoLock lock(mMutex);
     listener = mListener;
   }
   return listener->OnStopRequest(request, status);
 }
 
-/* static */ nsresult nsHTTPCompressConv::BrotliHandler(
-    nsIInputStream *stream, void *closure, const char *dataIn, uint32_t,
-    uint32_t aAvail, uint32_t *countRead) {
+/* static */
+nsresult nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream,
+                                           void *closure, const char *dataIn,
+                                           uint32_t, uint32_t aAvail,
+                                           uint32_t *countRead) {
   MOZ_ASSERT(stream);
   nsHTTPCompressConv *self = static_cast<nsHTTPCompressConv *>(closure);
   *countRead = 0;
 
   const size_t kOutSize = 128 * 1024;  // just a chunk size, we call in a loop
   uint8_t *outPtr;
   size_t outSize;
   size_t avail = aAvail;
--- a/netwerk/url-classifier/AsyncUrlChannelClassifier.cpp
+++ b/netwerk/url-classifier/AsyncUrlChannelClassifier.cpp
@@ -78,18 +78,18 @@ class URIData {
   URIData();
   ~URIData();
 
   nsCOMPtr<nsIURI> mURI;
   nsCString mURISpec;
   nsTArray<nsCString> mFragments;
 };
 
-/* static */ nsresult URIData::Create(nsIURI* aURI, nsIURI* aInnermostURI,
-                                      URIData** aData) {
+/* static */
+nsresult URIData::Create(nsIURI* aURI, nsIURI* aInnermostURI, URIData** aData) {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aURI);
   MOZ_ASSERT(aInnermostURI);
 
   RefPtr<URIData> data = new URIData();
   data->mURI = aURI;
 
   nsUrlClassifierUtils* utilsService = nsUrlClassifierUtils::GetInstance();
@@ -506,19 +506,20 @@ class FeatureTask {
   nsTArray<RefPtr<URIData>> mURIs;
   nsTArray<RefPtr<TableData>> mTables;
 };
 
 // Features are able to classify particular URIs from a channel. For instance,
 // tracking-annotation feature uses the top-level URI to whitelist the current
 // channel's URI; flash feature always uses the channel's URI.  Because of
 // this, this function aggregates feature per URI and tables.
-/* static */ nsresult FeatureTask::Create(nsIChannel* aChannel,
-                                          std::function<void()>&& aCallback,
-                                          FeatureTask** aTask) {
+/* static */
+nsresult FeatureTask::Create(nsIChannel* aChannel,
+                             std::function<void()>&& aCallback,
+                             FeatureTask** aTask) {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aChannel);
   MOZ_ASSERT(aTask);
 
   // We need to obtain the list of nsIUrlClassifierFeature objects able to
   // classify this channel. If the list is empty, we do an early return.
   nsTArray<nsCOMPtr<nsIUrlClassifierFeature>> features;
   UrlClassifierFeatureFactory::GetFeaturesFromChannel(aChannel, features);
@@ -730,17 +731,18 @@ nsresult FeatureData::InitializeList(
     aList.AppendElement(data);
   }
 
   return NS_OK;
 }
 
 }  // namespace
 
-/* static */ nsresult AsyncUrlChannelClassifier::CheckChannel(
+/* static */
+nsresult AsyncUrlChannelClassifier::CheckChannel(
     nsIChannel* aChannel, std::function<void()>&& aCallback) {
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(aChannel);
 
   if (!aCallback) {
     return NS_ERROR_INVALID_ARG;
   }
 
--- a/netwerk/url-classifier/UrlClassifierCommon.cpp
+++ b/netwerk/url-classifier/UrlClassifierCommon.cpp
@@ -26,50 +26,52 @@
 namespace mozilla {
 namespace net {
 
 const nsCString::size_type UrlClassifierCommon::sMaxSpecLength = 128;
 
 // MOZ_LOG=nsChannelClassifier:5
 LazyLogModule UrlClassifierCommon::sLog("nsChannelClassifier");
 
-/* static */ bool UrlClassifierCommon::AddonMayLoad(nsIChannel* aChannel,
-                                                    nsIURI* aURI) {
+/* static */
+bool UrlClassifierCommon::AddonMayLoad(nsIChannel* aChannel, nsIURI* aURI) {
   nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->LoadInfo();
   // loadingPrincipal is used here to ensure we are loading into an
   // addon principal.  This allows an addon, with explicit permission, to
   // call out to API endpoints that may otherwise get blocked.
   nsIPrincipal* loadingPrincipal = channelLoadInfo->LoadingPrincipal();
   if (!loadingPrincipal) {
     return false;
   }
 
   return BasePrincipal::Cast(loadingPrincipal)->AddonAllowsLoad(aURI, true);
 }
 
-/* static */ void
-UrlClassifierCommon::NotifyChannelClassifierProtectionDisabled(
+/* static */
+void UrlClassifierCommon::NotifyChannelClassifierProtectionDisabled(
     nsIChannel* aChannel, uint32_t aEvent) {
   // Can be called in EITHER the parent or child process.
   nsCOMPtr<nsIParentChannel> parentChannel;
   NS_QueryNotificationCallbacks(aChannel, parentChannel);
   if (parentChannel) {
     // This channel is a parent-process proxy for a child process request.
     // Tell the child process channel to do this instead.
     parentChannel->NotifyChannelClassifierProtectionDisabled(aEvent);
     return;
   }
 
   nsCOMPtr<nsIURI> uriBeingLoaded =
       AntiTrackingCommon::MaybeGetDocumentURIBeingLoaded(aChannel);
   NotifyChannelBlocked(aChannel, uriBeingLoaded, aEvent);
 }
 
-/* static */ void UrlClassifierCommon::NotifyChannelBlocked(
-    nsIChannel* aChannel, nsIURI* aURIBeingLoaded, unsigned aBlockedReason) {
+/* static */
+void UrlClassifierCommon::NotifyChannelBlocked(nsIChannel* aChannel,
+                                               nsIURI* aURIBeingLoaded,
+                                               unsigned aBlockedReason) {
   nsCOMPtr<mozIThirdPartyUtil> thirdPartyUtil = services::GetThirdPartyUtil();
   if (NS_WARN_IF(!thirdPartyUtil)) {
     return;
   }
 
   nsCOMPtr<mozIDOMWindowProxy> win;
   nsresult rv = thirdPartyUtil->GetTopWindowForChannel(
       aChannel, aURIBeingLoaded, getter_AddRefs(win));
@@ -82,18 +84,18 @@ UrlClassifierCommon::NotifyChannelClassi
   RefPtr<dom::Document> doc = docShell->GetDocument();
   NS_ENSURE_TRUE_VOID(doc);
 
   nsCOMPtr<nsIURI> uri;
   aChannel->GetURI(getter_AddRefs(uri));
   pwin->NotifyContentBlockingEvent(aBlockedReason, aChannel, true, uri);
 }
 
-/* static */ bool UrlClassifierCommon::ShouldEnableClassifier(
-    nsIChannel* aChannel) {
+/* static */
+bool UrlClassifierCommon::ShouldEnableClassifier(nsIChannel* aChannel) {
   MOZ_ASSERT(aChannel);
 
   nsCOMPtr<nsIURI> chanURI;
   nsresult rv = aChannel->GetURI(getter_AddRefs(chanURI));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return false;
   }
 
@@ -128,19 +130,22 @@ UrlClassifierCommon::NotifyChannelClassi
         ("nsChannelClassifier: Enabling url classifier checks on "
          "channel[%p] with uri %s for toplevel window uri %s",
          aChannel, chanSpec.get(), topWinSpec.get()));
   }
 
   return true;
 }
 
-/* static */ nsresult UrlClassifierCommon::SetBlockedContent(
-    nsIChannel* channel, nsresult aErrorCode, const nsACString& aList,
-    const nsACString& aProvider, const nsACString& aFullHash) {
+/* static */
+nsresult UrlClassifierCommon::SetBlockedContent(nsIChannel* channel,
+                                                nsresult aErrorCode,
+                                                const nsACString& aList,
+                                                const nsACString& aProvider,
+                                                const nsACString& aFullHash) {
   NS_ENSURE_ARG(!aList.IsEmpty());
 
   // Can be called in EITHER the parent or child process.
   nsCOMPtr<nsIParentChannel> parentChannel;
   NS_QueryNotificationCallbacks(channel, parentChannel);
   if (parentChannel) {
     // This channel is a parent-process proxy for a child process request.
     // Tell the child process channel to do this instead.
@@ -202,18 +207,19 @@ UrlClassifierCommon::NotifyChannelClassi
 
   nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, category, doc,
                                   nsContentUtils::eNECKO_PROPERTIES, message,
                                   params, ArrayLength(params));
 
   return NS_OK;
 }
 
-/* static */ nsresult UrlClassifierCommon::CreatePairwiseWhiteListURI(
-    nsIChannel* aChannel, nsIURI** aURI) {
+/* static */
+nsresult UrlClassifierCommon::CreatePairwiseWhiteListURI(nsIChannel* aChannel,
+                                                         nsIURI** aURI) {
   MOZ_ASSERT(aChannel);
   MOZ_ASSERT(aURI);
 
   nsresult rv;
   nsCOMPtr<nsIHttpChannelInternal> chan = do_QueryInterface(aChannel, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!chan) {
     return NS_ERROR_FAILURE;
--- a/netwerk/url-classifier/UrlClassifierFeatureCryptomining.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureCryptomining.cpp
@@ -44,35 +44,38 @@ UrlClassifierFeatureCryptomining::UrlCla
           NS_LITERAL_CSTRING(TABLE_CRYPTOMINING_BLACKLIST_PREF),
           NS_LITERAL_CSTRING(TABLE_CRYPTOMINING_WHITELIST_PREF),
           EmptyCString()) {}
 
 /* static */ const char* UrlClassifierFeatureCryptomining::Name() {
   return CRYPTOMINING_FEATURE_NAME;
 }
 
-/* static */ void UrlClassifierFeatureCryptomining::MaybeInitialize() {
+/* static */
+void UrlClassifierFeatureCryptomining::MaybeInitialize() {
   UC_LOG(("UrlClassifierFeatureCryptomining: MaybeInitialize"));
 
   if (!gFeatureCryptomining) {
     gFeatureCryptomining = new UrlClassifierFeatureCryptomining();
     gFeatureCryptomining->InitializePreferences();
   }
 }
 
-/* static */ void UrlClassifierFeatureCryptomining::MaybeShutdown() {
+/* static */
+void UrlClassifierFeatureCryptomining::MaybeShutdown() {
   UC_LOG(("UrlClassifierFeatureCryptomining: MaybeShutdown"));
 
   if (gFeatureCryptomining) {
     gFeatureCryptomining->ShutdownPreferences();
     gFeatureCryptomining = nullptr;
   }
 }
 
-/* static */ already_AddRefed<UrlClassifierFeatureCryptomining>
+/* static */
+already_AddRefed<UrlClassifierFeatureCryptomining>
 UrlClassifierFeatureCryptomining::MaybeCreate(nsIChannel* aChannel) {
   MOZ_ASSERT(aChannel);
 
   UC_LOG(("UrlClassifierFeatureCryptomining: MaybeCreate for channel %p",
           aChannel));
 
   if (!StaticPrefs::privacy_trackingprotection_cryptomining_enabled()) {
     return nullptr;
@@ -107,17 +110,18 @@ UrlClassifierFeatureCryptomining::MaybeC
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureCryptomining);
 
   RefPtr<UrlClassifierFeatureCryptomining> self = gFeatureCryptomining;
   return self.forget();
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureCryptomining::GetIfNameMatches(const nsACString& aName) {
   if (!aName.EqualsLiteral(CRYPTOMINING_FEATURE_NAME)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureCryptomining);
 
--- a/netwerk/url-classifier/UrlClassifierFeatureFactory.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureFactory.cpp
@@ -16,32 +16,34 @@
 #include "UrlClassifierFeatureTrackingAnnotation.h"
 #include "UrlClassifierFeatureCustomTables.h"
 
 #include "nsAppRunner.h"
 
 namespace mozilla {
 namespace net {
 
-/* static */ void UrlClassifierFeatureFactory::Shutdown() {
+/* static */
+void UrlClassifierFeatureFactory::Shutdown() {
   // We want to expose Features only in the parent process.
   if (!XRE_IsParentProcess()) {
     return;
   }
 
   UrlClassifierFeatureCryptomining::MaybeShutdown();
   UrlClassifierFeatureFingerprinting::MaybeShutdown();
   UrlClassifierFeatureFlash::MaybeShutdown();
   UrlClassifierFeatureLoginReputation::MaybeShutdown();
   UrlClassifierFeaturePhishingProtection::MaybeShutdown();
   UrlClassifierFeatureTrackingAnnotation::MaybeShutdown();
   UrlClassifierFeatureTrackingProtection::MaybeShutdown();
 }
 
-/* static */ void UrlClassifierFeatureFactory::GetFeaturesFromChannel(
+/* static */
+void UrlClassifierFeatureFactory::GetFeaturesFromChannel(
     nsIChannel* aChannel,
     nsTArray<nsCOMPtr<nsIUrlClassifierFeature>>& aFeatures) {
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(aChannel);
 
   nsCOMPtr<nsIUrlClassifierFeature> feature;
 
   // Note that the order of the features is extremely important! When more than
@@ -74,28 +76,30 @@ namespace net {
   }
 
   // Flash
   nsTArray<nsCOMPtr<nsIUrlClassifierFeature>> flashFeatures;
   UrlClassifierFeatureFlash::MaybeCreate(aChannel, flashFeatures);
   aFeatures.AppendElements(flashFeatures);
 }
 
-/* static */ void UrlClassifierFeatureFactory::GetPhishingProtectionFeatures(
+/* static */
+void UrlClassifierFeatureFactory::GetPhishingProtectionFeatures(
     nsTArray<RefPtr<nsIUrlClassifierFeature>>& aFeatures) {
   UrlClassifierFeaturePhishingProtection::MaybeCreate(aFeatures);
 }
 
 /* static */
 nsIUrlClassifierFeature*
 UrlClassifierFeatureFactory::GetFeatureLoginReputation() {
   return UrlClassifierFeatureLoginReputation::MaybeGetOrCreate();
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureFactory::GetFeatureByName(const nsACString& aName) {
   if (!XRE_IsParentProcess()) {
     return nullptr;
   }
 
   nsCOMPtr<nsIUrlClassifierFeature> feature;
 
   // Cryptomining
@@ -138,18 +142,18 @@ UrlClassifierFeatureFactory::GetFeatureB
   feature = UrlClassifierFeaturePhishingProtection::GetIfNameMatches(aName);
   if (feature) {
     return feature.forget();
   }
 
   return nullptr;
 }
 
-/* static */ void UrlClassifierFeatureFactory::GetFeatureNames(
-    nsTArray<nsCString>& aArray) {
+/* static */
+void UrlClassifierFeatureFactory::GetFeatureNames(nsTArray<nsCString>& aArray) {
   if (!XRE_IsParentProcess()) {
     return;
   }
 
   // Cryptomining
   nsAutoCString name;
   name.Assign(UrlClassifierFeatureCryptomining::Name());
   if (!name.IsEmpty()) {
@@ -190,17 +194,18 @@ UrlClassifierFeatureFactory::GetFeatureB
   // PhishingProtection features
   {
     nsTArray<nsCString> features;
     UrlClassifierFeaturePhishingProtection::GetFeatureNames(features);
     aArray.AppendElements(features);
   }
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureFactory::CreateFeatureWithTables(
     const nsACString& aName, const nsTArray<nsCString>& aBlacklistTables,
     const nsTArray<nsCString>& aWhitelistTables) {
   nsCOMPtr<nsIUrlClassifierFeature> feature =
       new UrlClassifierFeatureCustomTables(aName, aBlacklistTables,
                                            aWhitelistTables);
   return feature.forget();
 }
@@ -223,41 +228,43 @@ static const BlockingErrorCode sBlocking
      "TrackerUriBlocked", NS_LITERAL_CSTRING("Tracking Protection")},
     {NS_ERROR_CRYPTOMINING_URI,
      nsIWebProgressListener::STATE_BLOCKED_CRYPTOMINING_CONTENT,
      "TrackerUriBlocked", NS_LITERAL_CSTRING("Tracking Protection")},
 };
 
 }  // namespace
 
-/* static */ bool UrlClassifierFeatureFactory::IsClassifierBlockingErrorCode(
+/* static */
+bool UrlClassifierFeatureFactory::IsClassifierBlockingErrorCode(
     nsresult aError) {
   // In theory we can iterate through the features, but at the moment, we can
   // just have a simple check here.
   for (const auto& blockingErrorCode : sBlockingErrorCodes) {
     if (aError == blockingErrorCode.mErrorCode) {
       return true;
     }
   }
 
   return false;
 }
 
-/* static */ bool UrlClassifierFeatureFactory::IsClassifierBlockingEventCode(
+/* static */
+bool UrlClassifierFeatureFactory::IsClassifierBlockingEventCode(
     uint32_t aEventCode) {
   for (const auto& blockingErrorCode : sBlockingErrorCodes) {
     if (aEventCode == blockingErrorCode.mBlockingEventCode) {
       return true;
     }
   }
   return false;
 }
 
-/* static */ uint32_t
-UrlClassifierFeatureFactory::GetClassifierBlockingEventCode(
+/* static */
+uint32_t UrlClassifierFeatureFactory::GetClassifierBlockingEventCode(
     nsresult aErrorCode) {
   for (const auto& blockingErrorCode : sBlockingErrorCodes) {
     if (aErrorCode == blockingErrorCode.mErrorCode) {
       return blockingErrorCode.mBlockingEventCode;
     }
   }
   return 0;
 }
--- a/netwerk/url-classifier/UrlClassifierFeatureFingerprinting.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureFingerprinting.cpp
@@ -46,35 +46,38 @@ UrlClassifierFeatureFingerprinting::UrlC
           NS_LITERAL_CSTRING(TABLE_FINGERPRINTING_BLACKLIST_PREF),
           NS_LITERAL_CSTRING(TABLE_FINGERPRINTING_WHITELIST_PREF),
           EmptyCString()) {}
 
 /* static */ const char* UrlClassifierFeatureFingerprinting::Name() {
   return FINGERPRINTING_FEATURE_NAME;
 }
 
-/* static */ void UrlClassifierFeatureFingerprinting::MaybeInitialize() {
+/* static */
+void UrlClassifierFeatureFingerprinting::MaybeInitialize() {
   UC_LOG(("UrlClassifierFeatureFingerprinting: MaybeInitialize"));
 
   if (!gFeatureFingerprinting) {
     gFeatureFingerprinting = new UrlClassifierFeatureFingerprinting();
     gFeatureFingerprinting->InitializePreferences();
   }
 }
 
-/* static */ void UrlClassifierFeatureFingerprinting::MaybeShutdown() {
+/* static */
+void UrlClassifierFeatureFingerprinting::MaybeShutdown() {
   UC_LOG(("UrlClassifierFeatureFingerprinting: MaybeShutdown"));
 
   if (gFeatureFingerprinting) {
     gFeatureFingerprinting->ShutdownPreferences();
     gFeatureFingerprinting = nullptr;
   }
 }
 
-/* static */ already_AddRefed<UrlClassifierFeatureFingerprinting>
+/* static */
+already_AddRefed<UrlClassifierFeatureFingerprinting>
 UrlClassifierFeatureFingerprinting::MaybeCreate(nsIChannel* aChannel) {
   MOZ_ASSERT(aChannel);
 
   UC_LOG(("UrlClassifierFeatureFingerprinting: MaybeCreate for channel %p",
           aChannel));
 
   if (!StaticPrefs::privacy_trackingprotection_fingerprinting_enabled()) {
     return nullptr;
@@ -109,17 +112,18 @@ UrlClassifierFeatureFingerprinting::Mayb
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureFingerprinting);
 
   RefPtr<UrlClassifierFeatureFingerprinting> self = gFeatureFingerprinting;
   return self.forget();
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureFingerprinting::GetIfNameMatches(const nsACString& aName) {
   if (!aName.EqualsLiteral(FINGERPRINTING_FEATURE_NAME)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureFingerprinting);
 
--- a/netwerk/url-classifier/UrlClassifierFeatureFlash.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureFlash.cpp
@@ -51,50 +51,53 @@ UrlClassifierFeatureFlash::UrlClassifier
           EmptyCString())  // aPrefSkipHosts
       ,
       mFlashPluginState(aFlashFeature.mFlashPluginState) {
   static_assert(nsIHttpChannel::FlashPluginDeniedInSubdocuments ==
                     nsIHttpChannel::FlashPluginLastValue,
                 "nsIHttpChannel::FlashPluginLastValue is out-of-sync!");
 }
 
-/* static */ void UrlClassifierFeatureFlash::GetFeatureNames(
-    nsTArray<nsCString>& aArray) {
+/* static */
+void UrlClassifierFeatureFlash::GetFeatureNames(nsTArray<nsCString>& aArray) {
   for (const FlashFeature& flashFeature : sFlashFeaturesMap) {
     aArray.AppendElement(nsDependentCString(flashFeature.mName));
   }
 }
 
-/* static */ void UrlClassifierFeatureFlash::MaybeInitialize() {
+/* static */
+void UrlClassifierFeatureFlash::MaybeInitialize() {
   MOZ_ASSERT(XRE_IsParentProcess());
 
   if (IsInitialized()) {
     return;
   }
 
   for (FlashFeature& flashFeature : sFlashFeaturesMap) {
     MOZ_ASSERT(!flashFeature.mFeature);
     flashFeature.mFeature = new UrlClassifierFeatureFlash(flashFeature);
     flashFeature.mFeature->InitializePreferences();
   }
 }
 
-/* static */ void UrlClassifierFeatureFlash::MaybeShutdown() {
+/* static */
+void UrlClassifierFeatureFlash::MaybeShutdown() {
   if (!IsInitialized()) {
     return;
   }
 
   for (FlashFeature& flashFeature : sFlashFeaturesMap) {
     MOZ_ASSERT(flashFeature.mFeature);
     flashFeature.mFeature->ShutdownPreferences();
     flashFeature.mFeature = nullptr;
   }
 }
 
-/* static */ void UrlClassifierFeatureFlash::MaybeCreate(
+/* static */
+void UrlClassifierFeatureFlash::MaybeCreate(
     nsIChannel* aChannel,
     nsTArray<nsCOMPtr<nsIUrlClassifierFeature>>& aFeatures) {
   // All disabled.
   if (!StaticPrefs::plugins_flashBlock_enabled()) {
     return;
   }
 
   // We use Flash feature just for document loading.
@@ -121,17 +124,18 @@ UrlClassifierFeatureFlash::UrlClassifier
     MOZ_ASSERT(flashFeature.mFeature);
     if (!flashFeature.mSubdocumentOnly ||
         contentPolicyType == nsIContentPolicy::TYPE_SUBDOCUMENT) {
       aFeatures.AppendElement(flashFeature.mFeature);
     }
   }
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureFlash::GetIfNameMatches(const nsACString& aName) {
   MaybeInitialize();
 
   for (const FlashFeature& flashFeature : sFlashFeaturesMap) {
     MOZ_ASSERT(flashFeature.mFeature);
     if (aName.Equals(flashFeature.mName)) {
       nsCOMPtr<nsIUrlClassifierFeature> self = flashFeature.mFeature.get();
       return self.forget();
--- a/netwerk/url-classifier/UrlClassifierFeatureLoginReputation.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureLoginReputation.cpp
@@ -34,40 +34,43 @@ UrlClassifierFeatureLoginReputation::Url
 {}
 
 /* static */ const char* UrlClassifierFeatureLoginReputation::Name() {
   return StaticPrefs::browser_safebrowsing_passwords_enabled()
              ? LOGIN_REPUTATION_FEATURE_NAME
              : "";
 }
 
-/* static */ void UrlClassifierFeatureLoginReputation::MaybeShutdown() {
+/* static */
+void UrlClassifierFeatureLoginReputation::MaybeShutdown() {
   UC_LOG(("UrlClassifierFeatureLoginReputation: MaybeShutdown"));
 
   if (gFeatureLoginReputation) {
     gFeatureLoginReputation->ShutdownPreferences();
     gFeatureLoginReputation = nullptr;
   }
 }
 
-/* static */ nsIUrlClassifierFeature*
+/* static */
+nsIUrlClassifierFeature*
 UrlClassifierFeatureLoginReputation::MaybeGetOrCreate() {
   if (!StaticPrefs::browser_safebrowsing_passwords_enabled()) {
     return nullptr;
   }
 
   if (!gFeatureLoginReputation) {
     gFeatureLoginReputation = new UrlClassifierFeatureLoginReputation();
     gFeatureLoginReputation->InitializePreferences();
   }
 
   return gFeatureLoginReputation;
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureLoginReputation::GetIfNameMatches(const nsACString& aName) {
   if (!aName.EqualsLiteral(LOGIN_REPUTATION_FEATURE_NAME)) {
     return nullptr;
   }
 
   nsCOMPtr<nsIUrlClassifierFeature> self = MaybeGetOrCreate();
   return self.forget();
 }
--- a/netwerk/url-classifier/UrlClassifierFeaturePhishingProtection.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeaturePhishingProtection.cpp
@@ -40,58 +40,63 @@ UrlClassifierFeaturePhishingProtection::
           EmptyCString(),    // aPrefWhitelistPrefTbles,
           EmptyCString(),    // aPrefBlacklistHosts
           EmptyCString(),    // aPrefWhitelistHosts
           EmptyCString(),    // aPrefBlacklistTableName
           EmptyCString(),    // aPrefWhitelistTableName
           EmptyCString()) {  // aPrefSkipHosts
 }
 
-/* static */ void UrlClassifierFeaturePhishingProtection::GetFeatureNames(
+/* static */
+void UrlClassifierFeaturePhishingProtection::GetFeatureNames(
     nsTArray<nsCString>& aArray) {
   for (const PhishingProtectionFeature& feature :
        sPhishingProtectionFeaturesMap) {
     if (feature.mPref()) {
       aArray.AppendElement(nsDependentCString(feature.mName));
     }
   }
 }
 
-/* static */ void UrlClassifierFeaturePhishingProtection::MaybeInitialize() {
+/* static */
+void UrlClassifierFeaturePhishingProtection::MaybeInitialize() {
   for (PhishingProtectionFeature& feature : sPhishingProtectionFeaturesMap) {
     if (!feature.mFeature && feature.mPref()) {
       feature.mFeature = new UrlClassifierFeaturePhishingProtection(feature);
       feature.mFeature->InitializePreferences();
     }
   }
 }
 
-/* static */ void UrlClassifierFeaturePhishingProtection::MaybeShutdown() {
+/* static */
+void UrlClassifierFeaturePhishingProtection::MaybeShutdown() {
   for (PhishingProtectionFeature& feature : sPhishingProtectionFeaturesMap) {
     if (feature.mFeature) {
       feature.mFeature->ShutdownPreferences();
       feature.mFeature = nullptr;
     }
   }
 }
 
-/* static */ void UrlClassifierFeaturePhishingProtection::MaybeCreate(
+/* static */
+void UrlClassifierFeaturePhishingProtection::MaybeCreate(
     nsTArray<RefPtr<nsIUrlClassifierFeature>>& aFeatures) {
   MaybeInitialize();
 
   for (const PhishingProtectionFeature& feature :
        sPhishingProtectionFeaturesMap) {
     if (feature.mPref()) {
       MOZ_ASSERT(feature.mFeature);
       aFeatures.AppendElement(feature.mFeature);
     }
   }
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeaturePhishingProtection::GetIfNameMatches(
     const nsACString& aName) {
   MaybeInitialize();
 
   for (const PhishingProtectionFeature& feature :
        sPhishingProtectionFeaturesMap) {
     if (feature.mPref() && aName.Equals(feature.mName)) {
       MOZ_ASSERT(feature.mFeature);
--- a/netwerk/url-classifier/UrlClassifierFeatureTrackingAnnotation.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureTrackingAnnotation.cpp
@@ -119,36 +119,39 @@ UrlClassifierFeatureTrackingAnnotation::
           NS_LITERAL_CSTRING(TABLE_ANNOTATION_BLACKLIST_PREF),
           NS_LITERAL_CSTRING(TABLE_ANNOTATION_WHITELIST_PREF),
           NS_LITERAL_CSTRING(URLCLASSIFIER_TRACKING_ANNOTATION_SKIP_URLS)) {}
 
 /* static */ const char* UrlClassifierFeatureTrackingAnnotation::Name() {
   return TRACKING_ANNOTATION_FEATURE_NAME;
 }
 
-/* static */ void UrlClassifierFeatureTrackingAnnotation::MaybeInitialize() {
+/* static */
+void UrlClassifierFeatureTrackingAnnotation::MaybeInitialize() {
   MOZ_ASSERT(XRE_IsParentProcess());
   UC_LOG(("UrlClassifierFeatureTrackingAnnotation: MaybeInitialize"));
 
   if (!gFeatureTrackingAnnotation) {
     gFeatureTrackingAnnotation = new UrlClassifierFeatureTrackingAnnotation();
     gFeatureTrackingAnnotation->InitializePreferences();
   }
 }
 
-/* static */ void UrlClassifierFeatureTrackingAnnotation::MaybeShutdown() {
+/* static */
+void UrlClassifierFeatureTrackingAnnotation::MaybeShutdown() {
   UC_LOG(("UrlClassifierFeatureTrackingAnnotation: MaybeShutdown"));
 
   if (gFeatureTrackingAnnotation) {
     gFeatureTrackingAnnotation->ShutdownPreferences();
     gFeatureTrackingAnnotation = nullptr;
   }
 }
 
-/* static */ already_AddRefed<UrlClassifierFeatureTrackingAnnotation>
+/* static */
+already_AddRefed<UrlClassifierFeatureTrackingAnnotation>
 UrlClassifierFeatureTrackingAnnotation::MaybeCreate(nsIChannel* aChannel) {
   MOZ_ASSERT(aChannel);
 
   UC_LOG(("UrlClassifierFeatureTrackingAnnotation: MaybeCreate for channel %p",
           aChannel));
 
   if (!StaticPrefs::privacy_trackingprotection_annotate_channels()) {
     return nullptr;
@@ -161,17 +164,18 @@ UrlClassifierFeatureTrackingAnnotation::
   MaybeInitialize();
   MOZ_ASSERT(gFeatureTrackingAnnotation);
 
   RefPtr<UrlClassifierFeatureTrackingAnnotation> self =
       gFeatureTrackingAnnotation;
   return self.forget();
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureTrackingAnnotation::GetIfNameMatches(
     const nsACString& aName) {
   if (!aName.EqualsLiteral(TRACKING_ANNOTATION_FEATURE_NAME)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureTrackingAnnotation);
--- a/netwerk/url-classifier/UrlClassifierFeatureTrackingProtection.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureTrackingProtection.cpp
@@ -41,36 +41,39 @@ UrlClassifierFeatureTrackingProtection::
           NS_LITERAL_CSTRING(URLCLASSIFIER_TRACKING_WHITELIST_TEST_ENTRIES),
           NS_LITERAL_CSTRING(TABLE_TRACKING_BLACKLIST_PREF),
           NS_LITERAL_CSTRING(TABLE_TRACKING_WHITELIST_PREF), EmptyCString()) {}
 
 /* static */ const char* UrlClassifierFeatureTrackingProtection::Name() {
   return TRACKING_PROTECTION_FEATURE_NAME;
 }
 
-/* static */ void UrlClassifierFeatureTrackingProtection::MaybeInitialize() {
+/* static */
+void UrlClassifierFeatureTrackingProtection::MaybeInitialize() {
   MOZ_ASSERT(XRE_IsParentProcess());
   UC_LOG(("UrlClassifierFeatureTrackingProtection: MaybeInitialize"));
 
   if (!gFeatureTrackingProtection) {
     gFeatureTrackingProtection = new UrlClassifierFeatureTrackingProtection();
     gFeatureTrackingProtection->InitializePreferences();
   }
 }
 
-/* static */ void UrlClassifierFeatureTrackingProtection::MaybeShutdown() {
+/* static */
+void UrlClassifierFeatureTrackingProtection::MaybeShutdown() {
   UC_LOG(("UrlClassifierFeatureTrackingProtection: Shutdown"));
 
   if (gFeatureTrackingProtection) {
     gFeatureTrackingProtection->ShutdownPreferences();
     gFeatureTrackingProtection = nullptr;
   }
 }
 
-/* static */ already_AddRefed<UrlClassifierFeatureTrackingProtection>
+/* static */
+already_AddRefed<UrlClassifierFeatureTrackingProtection>
 UrlClassifierFeatureTrackingProtection::MaybeCreate(nsIChannel* aChannel) {
   MOZ_ASSERT(aChannel);
 
   UC_LOG(("UrlClassifierFeatureTrackingProtection: MaybeCreate for channel %p",
           aChannel));
 
   nsCOMPtr<nsILoadContext> loadContext;
   NS_QueryNotificationCallbacks(aChannel, loadContext);
@@ -108,17 +111,18 @@ UrlClassifierFeatureTrackingProtection::
   MaybeInitialize();
   MOZ_ASSERT(gFeatureTrackingProtection);
 
   RefPtr<UrlClassifierFeatureTrackingProtection> self =
       gFeatureTrackingProtection;
   return self.forget();
 }
 
-/* static */ already_AddRefed<nsIUrlClassifierFeature>
+/* static */
+already_AddRefed<nsIUrlClassifierFeature>
 UrlClassifierFeatureTrackingProtection::GetIfNameMatches(
     const nsACString& aName) {
   if (!aName.EqualsLiteral(TRACKING_PROTECTION_FEATURE_NAME)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureTrackingProtection);