--- a/uriloader/base/nsDocLoader.cpp
+++ b/uriloader/base/nsDocLoader.cpp
@@ -32,30 +32,28 @@
 
 #include "nsIDOMDocument.h"
 #include "nsIDocument.h"
 #include "nsPresContext.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 
 static NS_DEFINE_CID(kThisImplCID, NS_THIS_DOCLOADER_IMPL_CID);
 
-#if defined(PR_LOGGING)
 //
 // Log module for nsIDocumentLoader logging...
 //
 // To enable logging (see prlog.h for full details):
 //
 //    set NSPR_LOG_MODULES=DocLoader:5
 //    set NSPR_LOG_FILE=nspr.log
 //
 // this enables PR_LOG_DEBUG level information and places all output in
 // the file nspr.log
 //
 PRLogModuleInfo* gDocLoaderLog = nullptr;
-#endif /* PR_LOGGING */
 
 
 #if defined(DEBUG)
 void GetURIStringFromRequest(nsIRequest* request, nsACString &name)
 {
     if (request)
         request->GetName(name);
     else
@@ -100,21 +98,19 @@ nsDocLoader::nsDocLoader()
     mCurrentTotalProgress(0),
     mMaxTotalProgress(0),
     mCompletedTotalProgress(0),
     mIsLoadingDocument(false),
     mIsRestoringDocument(false),
     mDontFlushLayout(false),
     mIsFlushingLayout(false)
 {
-#if defined(PR_LOGGING)
   if (nullptr == gDocLoaderLog) {
       gDocLoaderLog = PR_NewLogModule("DocLoader");
   }
-#endif /* PR_LOGGING */
 
   static const PLDHashTableOps hash_table_ops =
   {
     PL_DHashVoidPtrKeyStub,
     PL_DHashMatchEntryStub,
     PL_DHashMoveEntryStub,
     RequestInfoHashClearEntry,
     RequestInfoHashInitEntry
@@ -397,32 +393,31 @@ nsDocLoader::DestroyChildren()
   mChildList.Clear();
 }
 
 NS_IMETHODIMP
 nsDocLoader::OnStartRequest(nsIRequest *request, nsISupports *aCtxt)
 {
   // called each time a request is added to the group.
 
-#ifdef PR_LOGGING
   if (PR_LOG_TEST(gDocLoaderLog, PR_LOG_DEBUG)) {
     nsAutoCString name;
     request->GetName(name);
 
     uint32_t count = 0;
     if (mLoadGroup)
       mLoadGroup->GetActiveCount(&count);
 
     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
            ("DocLoader:%p: OnStartRequest[%p](%s) mIsLoadingDocument=%s, %u active URLs",
             this, request, name.get(),
             (mIsLoadingDocument ? "true" : "false"),
             count));
   }
-#endif /* PR_LOGGING */
+
   bool bJustStartedLoading = false;
 
   nsLoadFlags loadFlags = 0;
   request->GetLoadFlags(&loadFlags);
 
   if (!mIsLoadingDocument && (loadFlags & nsIChannel::LOAD_DOCUMENT_URI)) {
       bJustStartedLoading = true;
       mIsLoadingDocument = true;
@@ -478,32 +473,30 @@ nsDocLoader::OnStartRequest(nsIRequest *
 
 NS_IMETHODIMP
 nsDocLoader::OnStopRequest(nsIRequest *aRequest,
                            nsISupports *aCtxt,
                            nsresult aStatus)
 {
   nsresult rv = NS_OK;
 
-#ifdef PR_LOGGING
   if (PR_LOG_TEST(gDocLoaderLog, PR_LOG_DEBUG)) {
     nsAutoCString name;
     aRequest->GetName(name);
 
     uint32_t count = 0;
     if (mLoadGroup)
       mLoadGroup->GetActiveCount(&count);
 
     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
            ("DocLoader:%p: OnStopRequest[%p](%s) status=%x mIsLoadingDocument=%s, %u active URLs",
            this, aRequest, name.get(),
            aStatus, (mIsLoadingDocument ? "true" : "false"),
            count));
   }
-#endif
 
   bool bFireTransferring = false;
 
   //
   // Set the Maximum progress to the same value as the current progress.
   // Since the URI has finished loading, all the data is there.  Also,
   // this will allow a more accurate estimation of the max progress (in case
   // the old value was unknown ie. -1)

--- a/uriloader/base/nsURILoader.cpp
+++ b/uriloader/base/nsURILoader.cpp
@@ -46,19 +46,17 @@
 #include "nsNetCID.h"
 
 #include "nsMimeTypes.h"
 
 #include "nsDocLoader.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Preferences.h"
 
-#ifdef PR_LOGGING
 PRLogModuleInfo* nsURILoader::mLog = nullptr;
-#endif
 
 #define LOG(args) PR_LOG(nsURILoader::mLog, PR_LOG_DEBUG, args)
 #define LOG_ERROR(args) PR_LOG(nsURILoader::mLog, PR_LOG_ERROR, args)
 #define LOG_ENABLED() PR_LOG_TEST(nsURILoader::mLog, PR_LOG_DEBUG)
 
 #define NS_PREF_DISABLE_BACKGROUND_HANDLING \
     "security.exthelperapp.disable_background_handling"
 
@@ -470,21 +468,19 @@ nsresult nsDocumentOpenInfo::DispatchCon
         // content is just bizarre!
         if (rv != NS_ERROR_WONT_HANDLE_CONTENT) {
           if (NS_FAILED(rv)) {
             // The content handler has unexpectedly failed.  Cancel the request
             // just in case the handler didn't...
             LOG(("  Content handler failed.  Aborting load"));
             request->Cancel(rv);
           }
-#ifdef PR_LOGGING
           else {
             LOG(("  Content handler taking over load"));
           }
-#endif
 
           return rv;
         }
       }
     } else {
       LOG(("  DONT_RETARGET flag set, so skipped over random other content "
            "listeners and content handlers"));
     }
@@ -754,21 +750,19 @@ nsDocumentOpenInfo::TryContentListener(n
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Implementation of nsURILoader
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 nsURILoader::nsURILoader()
 {
-#ifdef PR_LOGGING
   if (!mLog) {
     mLog = PR_NewLogModule("URILoader");
   }
-#endif
 }
 
 nsURILoader::~nsURILoader()
 {
 }
 
 NS_IMPL_ADDREF(nsURILoader)
 NS_IMPL_RELEASE(nsURILoader)
@@ -802,25 +796,23 @@ NS_IMETHODIMP nsURILoader::UnRegisterCon
 }
 
 NS_IMETHODIMP nsURILoader::OpenURI(nsIChannel *channel, 
                                    uint32_t aFlags,
                                    nsIInterfaceRequestor *aWindowContext)
 {
   NS_ENSURE_ARG_POINTER(channel);
 
-#ifdef PR_LOGGING
   if (LOG_ENABLED()) {
     nsCOMPtr<nsIURI> uri;
     channel->GetURI(getter_AddRefs(uri));
     nsAutoCString spec;
     uri->GetAsciiSpec(spec);
     LOG(("nsURILoader::OpenURI for %s", spec.get()));
   }
-#endif
 
   nsCOMPtr<nsIStreamListener> loader;
   nsresult rv = OpenChannel(channel,
                             aFlags,
                             aWindowContext,
                             false,
                             getter_AddRefs(loader));
 
@@ -849,25 +841,23 @@ nsresult nsURILoader::OpenChannel(nsICha
                                   uint32_t aFlags,
                                   nsIInterfaceRequestor* aWindowContext,
                                   bool aChannelIsOpen,
                                   nsIStreamListener** aListener)
 {
   NS_ASSERTION(channel, "Trying to open a null channel!");
   NS_ASSERTION(aWindowContext, "Window context must not be null");
 
-#ifdef PR_LOGGING
   if (LOG_ENABLED()) {
     nsCOMPtr<nsIURI> uri;
     channel->GetURI(getter_AddRefs(uri));
     nsAutoCString spec;
     uri->GetAsciiSpec(spec);
     LOG(("nsURILoader::OpenChannel for %s", spec.get()));
   }
-#endif
 
   // Let the window context's uriListener know that the open is starting.  This
   // gives that window a chance to abort the load process.
   nsCOMPtr<nsIURIContentListener> winContextListener(do_GetInterface(aWindowContext));
   if (winContextListener) {
     nsCOMPtr<nsIURI> uri;
     channel->GetURI(getter_AddRefs(uri));
     if (uri) {

--- a/uriloader/base/nsURILoader.h
+++ b/uriloader/base/nsURILoader.h
@@ -43,19 +43,17 @@ protected:
 
   /**
    * we shouldn't need to have an owning ref count on registered
    * content listeners because they are supposed to unregister themselves
    * when they go away. This array stores weak references
    */
   nsCOMArray<nsIWeakReference> m_listeners;
 
-#ifdef PR_LOGGING
   /**
    * NSPR logging.  The module is called "URILoader"
    */
   static PRLogModuleInfo* mLog;
-#endif
   
   friend class nsDocumentOpenInfo;
 };
 
 #endif /* nsURILoader_h__ */

--- a/uriloader/exthandler/nsExternalHelperAppService.cpp
+++ b/uriloader/exthandler/nsExternalHelperAppService.cpp
@@ -117,19 +117,17 @@ using namespace mozilla::ipc;
 #define NS_PREF_DOWNLOAD_DIR        "browser.download.dir"
 #define NS_PREF_DOWNLOAD_FOLDERLIST "browser.download.folderList"
 enum {
   NS_FOLDER_VALUE_DESKTOP = 0
 , NS_FOLDER_VALUE_DOWNLOADS = 1
 , NS_FOLDER_VALUE_CUSTOM = 2
 };
 
-#ifdef PR_LOGGING
 PRLogModuleInfo* nsExternalHelperAppService::mLog = nullptr;
-#endif
 
 // Using level 3 here because the OSHelperAppServices use a log level
 // of PR_LOG_DEBUG (4), and we want less detailed output here
 // Using 3 instead of PR_LOG_WARN because we don't output warnings
 #undef LOG
 #define LOG(args) PR_LOG(nsExternalHelperAppService::mLog, 3, args)
 #define LOG_ENABLED() PR_LOG_TEST(nsExternalHelperAppService::mLog, 3)
 
@@ -586,23 +584,21 @@ nsExternalHelperAppService::nsExternalHe
 }
 nsresult nsExternalHelperAppService::Init()
 {
   // Add an observer for profile change
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (!obs)
     return NS_ERROR_FAILURE;
 
-#ifdef PR_LOGGING
   if (!mLog) {
     mLog = PR_NewLogModule("HelperAppService");
     if (!mLog)
       return NS_ERROR_OUT_OF_MEMORY;
   }
-#endif
 
   nsresult rv = obs->AddObserver(this, "profile-before-change", true);
   NS_ENSURE_SUCCESS(rv, rv);
   return obs->AddObserver(this, "last-pb-context-exited", true);
 }
 
 nsExternalHelperAppService::~nsExternalHelperAppService()
 {
@@ -1607,22 +1603,20 @@ NS_IMETHODIMP nsExternalAppHandler::OnSt
     return NS_OK;
   }
 
   rv = SetUpTempFile(aChannel);
   if (NS_FAILED(rv)) {
     nsresult transferError = rv;
 
     rv = CreateFailedTransfer(aChannel && NS_UsePrivateBrowsing(aChannel));
-#ifdef PR_LOGGING
     if (NS_FAILED(rv)) {
       LOG(("Failed to create transfer to report failure."
            "Will fallback to prompter!"));
     }
-#endif
 
     mCanceled = true;
     request->Cancel(transferError);
 
     nsAutoString path;
     if (mTempFile)
       mTempFile->GetPath(path);
 
@@ -2632,26 +2626,24 @@ NS_IMETHODIMP nsExternalHelperAppService
   if (!aFileExt.IsEmpty()) {
     bool matches = false;
     (*_retval)->ExtensionExists(aFileExt, &matches);
     LOG(("Extension '%s' matches mime info: %i\n", PromiseFlatCString(aFileExt).get(), matches));
     if (matches)
       (*_retval)->SetPrimaryExtension(aFileExt);
   }
 
-#ifdef PR_LOGGING
   if (LOG_ENABLED()) {
     nsAutoCString type;
     (*_retval)->GetMIMEType(type);
 
     nsAutoCString ext;
     (*_retval)->GetPrimaryExtension(ext);
     LOG(("MIME Info Summary: Type '%s', Primary Ext '%s'\n", type.get(), ext.get()));
   }
-#endif
 
   return NS_OK;
 }
 
 NS_IMETHODIMP nsExternalHelperAppService::GetTypeFromExtension(const nsACString& aFileExt, nsACString& aContentType) 
 {
   // OK. We want to try the following sources of mimetype information, in this order:
   // 1. defaultMimeEntries array

--- a/uriloader/exthandler/nsExternalHelperAppService.h
+++ b/uriloader/exthandler/nsExternalHelperAppService.h
@@ -136,25 +136,23 @@ protected:
    * Searches the "extra" array for a MIME type, and gets its extension.
    * @param aExtension The extension to search for
    * @param aMIMEType [out] The found MIME type.
    * @return true if the extension was found, false otherwise.
    */
   bool GetTypeFromExtras(const nsACString& aExtension,
                                        nsACString& aMIMEType);
 
-#ifdef PR_LOGGING
   /**
    * NSPR Logging Module. Usage: set NSPR_LOG_MODULES=HelperAppService:level,
    * where level should be 2 for errors, 3 for debug messages from the cross-
    * platform nsExternalHelperAppService, and 4 for os-specific debug messages.
    */
   static PRLogModuleInfo* mLog;
 
-#endif
   // friend, so that it can access the nspr log module.
   friend class nsExternalAppHandler;
 
   /**
    * Helper function for ExpungeTemporaryFiles and ExpungeTemporaryPrivateFiles
    */
   static void ExpungeTemporaryFilesHelper(nsCOMArray<nsIFile> &fileList);
   /**

--- a/uriloader/prefetch/OfflineCacheUpdateChild.cpp
+++ b/uriloader/prefetch/OfflineCacheUpdateChild.cpp
@@ -31,28 +31,26 @@
 #include "prlog.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 
 using namespace mozilla::ipc;
 using namespace mozilla::net;
 using mozilla::dom::TabChild;
 using mozilla::dom::ContentChild;
 
-#if defined(PR_LOGGING)
 //
 // To enable logging (see prlog.h for full details):
 //
 //    set NSPR_LOG_MODULES=nsOfflineCacheUpdate:5
 //    set NSPR_LOG_FILE=offlineupdate.log
 //
 // this enables PR_LOG_ALWAYS level information and places all output in
 // the file offlineupdate.log
 //
 extern PRLogModuleInfo *gOfflineCacheUpdateLog;
-#endif
 
 #undef LOG
 #define LOG(args) PR_LOG(gOfflineCacheUpdateLog, 4, args)
 
 #undef LOG_ENABLED
 #define LOG_ENABLED() PR_LOG_TEST(gOfflineCacheUpdateLog, 4)
 
 namespace mozilla {
@@ -148,26 +146,24 @@ OfflineCacheUpdateChild::AssociateDocume
     if (!container)
         return NS_OK;
 
     nsCOMPtr<nsIApplicationCache> existingCache;
     nsresult rv = container->GetApplicationCache(getter_AddRefs(existingCache));
     NS_ENSURE_SUCCESS(rv, rv);
 
     if (!existingCache) {
-#if defined(PR_LOGGING)
         if (LOG_ENABLED()) {
             nsAutoCString clientID;
             if (aApplicationCache) {
                 aApplicationCache->GetClientID(clientID);
             }
             LOG(("Update %p: associating app cache %s to document %p",
                  this, clientID.get(), aDocument));
         }
-#endif
 
         rv = container->SetApplicationCache(aApplicationCache);
         NS_ENSURE_SUCCESS(rv, rv);
     }
 
     return NS_OK;
 }
 

--- a/uriloader/prefetch/OfflineCacheUpdateGlue.cpp
+++ b/uriloader/prefetch/OfflineCacheUpdateGlue.cpp
@@ -9,28 +9,26 @@
 
 #include "nsIApplicationCache.h"
 #include "nsIApplicationCacheChannel.h"
 #include "nsIApplicationCacheContainer.h"
 #include "nsIChannel.h"
 #include "nsIDocument.h"
 #include "prlog.h"
 
-#if defined(PR_LOGGING)
 //
 // To enable logging (see prlog.h for full details):
 //
 //    set NSPR_LOG_MODULES=nsOfflineCacheUpdate:5
 //    set NSPR_LOG_FILE=offlineupdate.log
 //
 // this enables PR_LOG_ALWAYS level information and places all output in
 // the file offlineupdate.log
 //
 extern PRLogModuleInfo *gOfflineCacheUpdateLog;
-#endif
 
 #undef LOG
 #define LOG(args) PR_LOG(gOfflineCacheUpdateLog, 4, args)
 
 #undef LOG_ENABLED
 #define LOG_ENABLED() PR_LOG_TEST(gOfflineCacheUpdateLog, 4)
 
 namespace mozilla {
@@ -198,26 +196,24 @@ OfflineCacheUpdateGlue::ApplicationCache
     if (!container)
         return NS_OK;
 
     nsCOMPtr<nsIApplicationCache> existingCache;
     nsresult rv = container->GetApplicationCache(getter_AddRefs(existingCache));
     NS_ENSURE_SUCCESS(rv, rv);
 
     if (!existingCache) {
-#if defined(PR_LOGGING)
         if (LOG_ENABLED()) {
             nsAutoCString clientID;
             if (aApplicationCache) {
                 aApplicationCache->GetClientID(clientID);
             }
             LOG(("Update %p: associating app cache %s to document %p",
                  this, clientID.get(), mDocument.get()));
         }
-#endif
 
         rv = container->SetApplicationCache(aApplicationCache);
         NS_ENSURE_SUCCESS(rv, rv);
     }
 
     return NS_OK;
 }
 

--- a/uriloader/prefetch/OfflineCacheUpdateParent.cpp
+++ b/uriloader/prefetch/OfflineCacheUpdateParent.cpp
@@ -12,28 +12,26 @@
 #include "nsIApplicationCache.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsNetUtil.h"
 #include "nsContentUtils.h"
 
 using namespace mozilla::ipc;
 using mozilla::dom::TabParent;
 
-#if defined(PR_LOGGING)
 //
 // To enable logging (see prlog.h for full details):
 //
 //    set NSPR_LOG_MODULES=nsOfflineCacheUpdate:5
 //    set NSPR_LOG_FILE=offlineupdate.log
 //
 // this enables PR_LOG_ALWAYS level information and places all output in
 // the file offlineupdate.log
 //
 extern PRLogModuleInfo *gOfflineCacheUpdateLog;
-#endif
 
 #undef LOG
 #define LOG(args) PR_LOG(gOfflineCacheUpdateLog, 4, args)
 
 #undef LOG_ENABLED
 #define LOG_ENABLED() PR_LOG_TEST(gOfflineCacheUpdateLog, 4)
 
 namespace mozilla {

--- a/uriloader/prefetch/nsOfflineCacheUpdate.cpp
+++ b/uriloader/prefetch/nsOfflineCacheUpdate.cpp
@@ -46,28 +46,26 @@ static const uint32_t kRescheduleLimit =
 // Max number of retries for every entry of pinned app.
 static const uint32_t kPinnedEntryRetriesLimit = 3;
 // Maximum number of parallel items loads
 static const uint32_t kParallelLoadLimit = 15;
 
 // Quota for offline apps when preloading
 static const int32_t  kCustomProfileQuota = 512000;
 
-#if defined(PR_LOGGING)
 //
 // To enable logging (see prlog.h for full details):
 //
 //    set NSPR_LOG_MODULES=nsOfflineCacheUpdate:5
 //    set NSPR_LOG_FILE=offlineupdate.log
 //
 // this enables PR_LOG_ALWAYS level information and places all output in
 // the file offlineupdate.log
 //
 extern PRLogModuleInfo *gOfflineCacheUpdateLog;
-#endif
 
 #undef LOG
 #define LOG(args) PR_LOG(gOfflineCacheUpdateLog, 4, args)
 
 #undef LOG_ENABLED
 #define LOG_ENABLED() PR_LOG_TEST(gOfflineCacheUpdateLog, 4)
 
 class AutoFreeArray {
@@ -338,23 +336,21 @@ nsOfflineCacheUpdateItem::nsOfflineCache
 
 nsOfflineCacheUpdateItem::~nsOfflineCacheUpdateItem()
 {
 }
 
 nsresult
 nsOfflineCacheUpdateItem::OpenChannel(nsOfflineCacheUpdate *aUpdate)
 {
-#if defined(PR_LOGGING)
     if (LOG_ENABLED()) {
         nsAutoCString spec;
         mURI->GetSpec(spec);
         LOG(("%p: Opening channel for %s", this, spec.get()));
     }
-#endif
 
     if (mUpdate) {
         // Holding a reference to the update means this item is already
         // in progress (has a channel, or is just in between OnStopRequest()
         // and its Run() call.  We must never open channel on this item again.
         LOG(("  %p is already running! ignoring", this));
         return NS_ERROR_ALREADY_OPENED;
     }
@@ -461,24 +457,22 @@ nsOfflineCacheUpdateItem::OnDataAvailabl
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsOfflineCacheUpdateItem::OnStopRequest(nsIRequest *aRequest,
                                         nsISupports *aContext,
                                         nsresult aStatus)
 {
-#if defined(PR_LOGGING)
     if (LOG_ENABLED()) {
         nsAutoCString spec;
         mURI->GetSpec(spec);
         LOG(("%p: Done fetching offline item %s [status=%x]\n",
             this, spec.get(), aStatus));
     }
-#endif
 
     if (mBytesRead == 0 && aStatus == NS_OK) {
         // we didn't need to read (because LOAD_ONLY_IF_MODIFIED was
         // specified), but the object should report loadedSize as if it
         // did.
         mChannel->GetContentLength(&mBytesRead);
         mUpdate->OnByteProgress(mBytesRead);
     }
@@ -1874,23 +1868,21 @@ nsOfflineCacheUpdate::ProcessNextURI()
     }
 
     if (!runItem) {
         LOG(("nsOfflineCacheUpdate::ProcessNextURI [%p]:"
              " No more items to include in parallel load", this));
         return NS_OK;
     }
 
-#if defined(PR_LOGGING)
     if (LOG_ENABLED()) {
         nsAutoCString spec;
         runItem->mURI->GetSpec(spec);
         LOG(("%p: Opening channel for %s", this, spec.get()));
     }
-#endif
 
     ++mItemsInProgress;
     NotifyState(nsIOfflineCacheUpdateObserver::STATE_ITEMSTARTED);
 
     nsresult rv = runItem->OpenChannel(this);
     if (NS_FAILED(rv)) {
         LoadCompleted(runItem);
         return rv;

--- a/uriloader/prefetch/nsOfflineCacheUpdateService.cpp
+++ b/uriloader/prefetch/nsOfflineCacheUpdateService.cpp
@@ -65,28 +65,26 @@ nsTHashtable<nsCStringHashKey>* nsOfflin
     return mAllowedDomains;
 }
 
 
 typedef mozilla::docshell::OfflineCacheUpdateParent OfflineCacheUpdateParent;
 typedef mozilla::docshell::OfflineCacheUpdateChild OfflineCacheUpdateChild;
 typedef mozilla::docshell::OfflineCacheUpdateGlue OfflineCacheUpdateGlue;
 
-#if defined(PR_LOGGING)
 //
 // To enable logging (see prlog.h for full details):
 //
 //    set NSPR_LOG_MODULES=nsOfflineCacheUpdate:5
 //    set NSPR_LOG_FILE=offlineupdate.log
 //
 // this enables PR_LOG_ALWAYS level information and places all output in
 // the file offlineupdate.log
 //
 PRLogModuleInfo *gOfflineCacheUpdateLog;
-#endif
 
 #undef LOG
 #define LOG(args) PR_LOG(gOfflineCacheUpdateLog, 4, args)
 
 #undef LOG_ENABLED
 #define LOG_ENABLED() PR_LOG_TEST(gOfflineCacheUpdateLog, 4)
 
 namespace { // anon
@@ -290,20 +288,18 @@ nsOfflineCacheUpdateService::nsOfflineCa
 nsOfflineCacheUpdateService::~nsOfflineCacheUpdateService()
 {
     gOfflineCacheUpdateService = nullptr;
 }
 
 nsresult
 nsOfflineCacheUpdateService::Init()
 {
-#if defined(PR_LOGGING)
     if (!gOfflineCacheUpdateLog)
         gOfflineCacheUpdateLog = PR_NewLogModule("nsOfflineCacheUpdate");
-#endif
 
     // Observe xpcom-shutdown event
     nsCOMPtr<nsIObserverService> observerService =
       mozilla::services::GetObserverService();
     if (!observerService)
       return NS_ERROR_FAILURE;
 
     nsresult rv = observerService->AddObserver(this,

--- a/uriloader/prefetch/nsPrefetchService.cpp
+++ b/uriloader/prefetch/nsPrefetchService.cpp
@@ -27,28 +27,26 @@
 #include "mozilla/Attributes.h"
 #include "nsIDOMNode.h"
 #include "nsINode.h"
 #include "nsIDocument.h"
 #include "nsContentUtils.h"
 
 using namespace mozilla;
 
-#if defined(PR_LOGGING)
 //
 // To enable logging (see prlog.h for full details):
 //
 //    set NSPR_LOG_MODULES=nsPrefetch:5
 //    set NSPR_LOG_FILE=prefetch.log
 //
 // this enables PR_LOG_ALWAYS level information and places all output in
 // the file http.log
 //
 static PRLogModuleInfo *gPrefetchLog;
-#endif
 
 #undef LOG
 #define LOG(args) PR_LOG(gPrefetchLog, 4, args)
 
 #undef LOG_ENABLED
 #define LOG_ENABLED() PR_LOG_TEST(gPrefetchLog, 4)
 
 #define PREFETCH_PREF "network.prefetch-next"
@@ -405,20 +403,18 @@ nsPrefetchService::~nsPrefetchService()
     // cannot reach destructor if prefetch in progress (listener owns reference
     // to this service)
     EmptyQueue();
 }
 
 nsresult
 nsPrefetchService::Init()
 {
-#if defined(PR_LOGGING)
     if (!gPrefetchLog)
         gPrefetchLog = PR_NewLogModule("nsPrefetch");
-#endif
 
     nsresult rv;
 
     // read prefs and hook up pref observer
     mDisabled = !Preferences::GetBool(PREFETCH_PREF, !mDisabled);
     Preferences::AddWeakObserver(this, PREFETCH_PREF);
 
     // Observe xpcom-shutdown event
@@ -444,23 +440,21 @@ nsPrefetchService::ProcessNextURI()
 
     mCurrentNode = nullptr;
 
     do {
         rv = DequeueNode(getter_AddRefs(mCurrentNode));
 
         if (NS_FAILED(rv)) break;
 
-#if defined(PR_LOGGING)
         if (LOG_ENABLED()) {
             nsAutoCString spec;
             mCurrentNode->mURI->GetSpec(spec);
             LOG(("ProcessNextURI [%s]\n", spec.get()));
         }
-#endif
 
         //
         // if opening the channel fails, then just skip to the next uri
         //
         nsRefPtr<nsPrefetchNode> node = mCurrentNode;
         rv = node->OpenChannel();
     }
     while (NS_FAILED(rv));
@@ -631,23 +625,21 @@ nsPrefetchService::Prefetch(nsIURI *aURI
                             nsIDOMNode *aSource,
                             bool aExplicit)
 {
     nsresult rv;
 
     NS_ENSURE_ARG_POINTER(aURI);
     NS_ENSURE_ARG_POINTER(aReferrerURI);
 
-#if defined(PR_LOGGING)
     if (LOG_ENABLED()) {
         nsAutoCString spec;
         aURI->GetSpec(spec);
         LOG(("PrefetchURI [%s]\n", spec.get()));
     }
-#endif
 
     if (mDisabled) {
         LOG(("rejected: prefetch service is disabled\n"));
         return NS_ERROR_ABORT;
     }
 
     //
     // XXX we should really be asking the protocol handler if it supports