Bug 1343545 - Moved necessary code out of nsNetUtilInlines.h and removed the file r=mcmanus draft
authorNick <nick@foxsec.io>
Thu, 02 Mar 2017 09:32:37 -0500
changeset 491942 730f4de98e75
parent 491169 af1edb14a707
child 547593 fb857a3287e2
push id47465
push userbmo:nick@foxsec.io
push dateThu, 02 Mar 2017 14:33:16 +0000
reviewersmcmanus
bugs1343545
milestone54.0a1
Bug 1343545 - Moved necessary code out of nsNetUtilInlines.h and removed the file r=mcmanus MozReview-Commit-ID: AazctrDbCdf
netwerk/base/moz.build
netwerk/base/nsNetUtil.cpp
netwerk/base/nsNetUtilInlines.h
--- a/netwerk/base/moz.build
+++ b/netwerk/base/moz.build
@@ -150,17 +150,16 @@ XPIDL_MODULE = 'necko'
 EXPORTS += [
     'netCore.h',
     'nsASocketHandler.h',
     'nsAsyncRedirectVerifyHelper.h',
     'nsFileStreams.h',
     'nsInputStreamPump.h',
     'nsMIMEInputStream.h',
     'nsNetUtil.h',
-    'nsNetUtilInlines.h',
     'nsReadLine.h',
     'nsSerializationHelper.h',
     'nsSimpleNestedURI.h',
     'nsSimpleURI.h',
     'nsStreamListenerWrapper.h',
     'nsTemporaryFileInputStream.h',
     'nsURIHashKey.h',
     'nsURLHelper.h',
--- a/netwerk/base/nsNetUtil.cpp
+++ b/netwerk/base/nsNetUtil.cpp
@@ -7,17 +7,16 @@
 // HttpLog.h should generally be included first
 #include "HttpLog.h"
 
 #include "mozilla/LoadContext.h"
 #include "mozilla/LoadInfo.h"
 #include "mozilla/BasePrincipal.h"
 #include "mozilla/Telemetry.h"
 #include "nsNetUtil.h"
-#include "nsNetUtilInlines.h"
 #include "nsCategoryCache.h"
 #include "nsContentUtils.h"
 #include "nsHashKeys.h"
 #include "nsHttp.h"
 #include "nsIAsyncStreamCopier.h"
 #include "nsIAuthPrompt.h"
 #include "nsIAuthPrompt2.h"
 #include "nsIAuthPromptAdapterFactory.h"
@@ -79,16 +78,211 @@
 
 using namespace mozilla;
 using namespace mozilla::net;
 
 #define DEFAULT_USER_CONTROL_RP 3
 
 static uint32_t sUserControlRp = DEFAULT_USER_CONTROL_RP;
 
+already_AddRefed<nsIIOService>
+do_GetIOService(nsresult *error /* = 0 */)
+{
+    nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService();
+    if (error)
+        *error = io ? NS_OK : NS_ERROR_FAILURE;
+    return io.forget();
+}
+
+nsresult
+NS_NewLocalFileInputStream(nsIInputStream **result,
+                           nsIFile         *file,
+                           int32_t          ioFlags       /* = -1 */,
+                           int32_t          perm          /* = -1 */,
+                           int32_t          behaviorFlags /* = 0 */)
+{
+    nsresult rv;
+    nsCOMPtr<nsIFileInputStream> in =
+        do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv)) {
+        rv = in->Init(file, ioFlags, perm, behaviorFlags);
+        if (NS_SUCCEEDED(rv))
+            in.forget(result);
+    }
+    return rv;
+}
+
+nsresult
+NS_NewLocalFileOutputStream(nsIOutputStream **result,
+                            nsIFile          *file,
+                            int32_t           ioFlags       /* = -1 */,
+                            int32_t           perm          /* = -1 */,
+                            int32_t           behaviorFlags /* = 0 */)
+{
+    nsresult rv;
+    nsCOMPtr<nsIFileOutputStream> out =
+        do_CreateInstance(NS_LOCALFILEOUTPUTSTREAM_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv)) {
+        rv = out->Init(file, ioFlags, perm, behaviorFlags);
+        if (NS_SUCCEEDED(rv))
+            out.forget(result);
+    }
+    return rv;
+}
+
+nsresult
+net_EnsureIOService(nsIIOService **ios, nsCOMPtr<nsIIOService> &grip)
+{
+    nsresult rv = NS_OK;
+    if (!*ios) {
+        grip = do_GetIOService(&rv);
+        *ios = grip;
+    }
+    return rv;
+}
+
+nsresult
+NS_NewFileURI(nsIURI **result,
+              nsIFile *spec,
+              nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
+{
+    nsresult rv;
+    nsCOMPtr<nsIIOService> grip;
+    rv = net_EnsureIOService(&ioService, grip);
+    if (ioService)
+        rv = ioService->NewFileURI(spec, result);
+    return rv;
+}
+
+nsresult
+NS_NewChannelInternal(nsIChannel           **outChannel,
+                      nsIURI                *aUri,
+                      nsILoadInfo           *aLoadInfo,
+                      nsILoadGroup          *aLoadGroup /* = nullptr */,
+                      nsIInterfaceRequestor *aCallbacks /* = nullptr */,
+                      nsLoadFlags            aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
+                      nsIIOService          *aIoService /* = nullptr */)
+{
+  // NS_NewChannelInternal is mostly called for channel redirects. We should allow
+  // the creation of a channel even if the original channel did not have a loadinfo
+  // attached.
+  NS_ENSURE_ARG_POINTER(outChannel);
+
+  nsCOMPtr<nsIIOService> grip;
+  nsresult rv = net_EnsureIOService(&aIoService, grip);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = aIoService->NewChannelFromURIWithLoadInfo(
+         aUri,
+         aLoadInfo,
+         getter_AddRefs(channel));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aLoadGroup) {
+    rv = channel->SetLoadGroup(aLoadGroup);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (aCallbacks) {
+    rv = channel->SetNotificationCallbacks(aCallbacks);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (aLoadFlags != nsIRequest::LOAD_NORMAL) {
+    // Retain the LOAD_REPLACE load flag if set.
+    nsLoadFlags normalLoadFlags = 0;
+    channel->GetLoadFlags(&normalLoadFlags);
+    rv = channel->SetLoadFlags(aLoadFlags | (normalLoadFlags & nsIChannel::LOAD_REPLACE));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  channel.forget(outChannel);
+  return NS_OK;
+}
+
+nsresult
+NS_NewChannel(nsIChannel           **outChannel,
+              nsIURI                *aUri,
+              nsIPrincipal          *aLoadingPrincipal,
+              nsSecurityFlags        aSecurityFlags,
+              nsContentPolicyType    aContentPolicyType,
+              nsILoadGroup          *aLoadGroup /* = nullptr */,
+              nsIInterfaceRequestor *aCallbacks /* = nullptr */,
+              nsLoadFlags            aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
+              nsIIOService          *aIoService /* = nullptr */)
+{
+  return NS_NewChannelInternal(outChannel,
+                               aUri,
+                               nullptr, // aLoadingNode,
+                               aLoadingPrincipal,
+                               nullptr, // aTriggeringPrincipal
+                               aSecurityFlags,
+                               aContentPolicyType,
+                               aLoadGroup,
+                               aCallbacks,
+                               aLoadFlags,
+                               aIoService);
+}
+
+nsresult
+NS_NewChannelInternal(nsIChannel           **outChannel,
+                      nsIURI                *aUri,
+                      nsINode               *aLoadingNode,
+                      nsIPrincipal          *aLoadingPrincipal,
+                      nsIPrincipal          *aTriggeringPrincipal,
+                      nsSecurityFlags        aSecurityFlags,
+                      nsContentPolicyType    aContentPolicyType,
+                      nsILoadGroup          *aLoadGroup /* = nullptr */,
+                      nsIInterfaceRequestor *aCallbacks /* = nullptr */,
+                      nsLoadFlags            aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
+                      nsIIOService          *aIoService /* = nullptr */)
+{
+  NS_ENSURE_ARG_POINTER(outChannel);
+
+  nsCOMPtr<nsIIOService> grip;
+  nsresult rv = net_EnsureIOService(&aIoService, grip);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = aIoService->NewChannelFromURI2(
+         aUri,
+         aLoadingNode ?
+           aLoadingNode->AsDOMNode() : nullptr,
+         aLoadingPrincipal,
+         aTriggeringPrincipal,
+         aSecurityFlags,
+         aContentPolicyType,
+         getter_AddRefs(channel));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  if (aLoadGroup) {
+    rv = channel->SetLoadGroup(aLoadGroup);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (aCallbacks) {
+    rv = channel->SetNotificationCallbacks(aCallbacks);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (aLoadFlags != nsIRequest::LOAD_NORMAL) {
+    // Retain the LOAD_REPLACE load flag if set.
+    nsLoadFlags normalLoadFlags = 0;
+    channel->GetLoadFlags(&normalLoadFlags);
+    rv = channel->SetLoadFlags(aLoadFlags | (normalLoadFlags & nsIChannel::LOAD_REPLACE));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  channel.forget(outChannel);
+  return NS_OK;
+}
+
 nsresult /*NS_NewChannelWithNodeAndTriggeringPrincipal */
 NS_NewChannelWithTriggeringPrincipal(nsIChannel           **outChannel,
                                      nsIURI                *aUri,
                                      nsINode               *aLoadingNode,
                                      nsIPrincipal          *aTriggeringPrincipal,
                                      nsSecurityFlags        aSecurityFlags,
                                      nsContentPolicyType    aContentPolicyType,
                                      nsILoadGroup          *aLoadGroup /* = nullptr */,
@@ -604,16 +798,34 @@ NS_NewIncrementalStreamLoader(nsIIncreme
             *result = nullptr;
             loader.swap(*result);
         }
     }
     return rv;
 }
 
 nsresult
+NS_NewStreamLoader(nsIStreamLoader        **result,
+                   nsIStreamLoaderObserver *observer,
+                   nsIRequestObserver      *requestObserver /* = nullptr */)
+{
+    nsresult rv;
+    nsCOMPtr<nsIStreamLoader> loader =
+        do_CreateInstance(NS_STREAMLOADER_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv)) {
+        rv = loader->Init(observer, requestObserver);
+        if (NS_SUCCEEDED(rv)) {
+            *result = nullptr;
+            loader.swap(*result);
+        }
+    }
+    return rv;
+}
+
+nsresult
 NS_NewStreamLoaderInternal(nsIStreamLoader        **outStream,
                            nsIURI                  *aUri,
                            nsIStreamLoaderObserver *aObserver,
                            nsINode                 *aLoadingNode,
                            nsIPrincipal            *aLoadingPrincipal,
                            nsSecurityFlags          aSecurityFlags,
                            nsContentPolicyType      aContentPolicyType,
                            nsILoadGroup            *aLoadGroup /* = nullptr */,
@@ -928,16 +1140,29 @@ NS_GetReferrerFromChannel(nsIChannel *ch
         rv = chan->GetReferrer(referrer);
         if (NS_FAILED(rv))
           *referrer = nullptr;
       }
     }
     return rv;
 }
 
+already_AddRefed<nsINetUtil>
+do_GetNetUtil(nsresult *error /* = 0 */)
+{
+    nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService();
+    nsCOMPtr<nsINetUtil> util;
+    if (io)
+        util = do_QueryInterface(io);
+
+    if (error)
+        *error = !!util ? NS_OK : NS_ERROR_FAILURE;
+    return util.forget();
+}
+
 nsresult
 NS_ParseRequestContentType(const nsACString &rawContentType,
                            nsCString        &contentType,
                            nsCString        &contentCharset)
 {
     // contentCharset is left untouched if not present in rawContentType
     nsresult rv;
     nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv);
@@ -1112,16 +1337,33 @@ NS_BufferOutputStream(nsIOutputStream *a
                                              aBufferSize);
     if (NS_SUCCEEDED(rv))
         return bos.forget();
 
     bos = aOutputStream;
     return bos.forget();
 }
 
+MOZ_MUST_USE nsresult
+NS_NewBufferedInputStream(nsIInputStream **result,
+                          nsIInputStream  *str,
+                          uint32_t         bufferSize)
+{
+    nsresult rv;
+    nsCOMPtr<nsIBufferedInputStream> in =
+        do_CreateInstance(NS_BUFFEREDINPUTSTREAM_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv)) {
+        rv = in->Init(str, bufferSize);
+        if (NS_SUCCEEDED(rv)) {
+            in.forget(result);
+        }
+    }
+    return rv;
+}
+
 already_AddRefed<nsIInputStream>
 NS_BufferInputStream(nsIInputStream *aInputStream,
                       uint32_t aBufferSize)
 {
     NS_ASSERTION(aInputStream, "No input stream given!");
 
     nsCOMPtr<nsIInputStream> bis;
     nsresult rv = NS_NewBufferedInputStream(getter_AddRefs(bis), aInputStream,
@@ -1129,16 +1371,52 @@ NS_BufferInputStream(nsIInputStream *aIn
     if (NS_SUCCEEDED(rv))
         return bis.forget();
 
     bis = aInputStream;
     return bis.forget();
 }
 
 nsresult
+NS_NewPostDataStream(nsIInputStream  **result,
+                     bool              isFile,
+                     const nsACString &data)
+{
+    nsresult rv;
+
+    if (isFile) {
+        nsCOMPtr<nsIFile> file;
+        nsCOMPtr<nsIInputStream> fileStream;
+
+        rv = NS_NewNativeLocalFile(data, false, getter_AddRefs(file));
+        if (NS_SUCCEEDED(rv)) {
+            rv = NS_NewLocalFileInputStream(getter_AddRefs(fileStream), file);
+            if (NS_SUCCEEDED(rv)) {
+                // wrap the file stream with a buffered input stream
+                rv = NS_NewBufferedInputStream(result, fileStream, 8192);
+            }
+        }
+        return rv;
+    }
+
+    // otherwise, create a string stream for the data (copies)
+    nsCOMPtr<nsIStringInputStream> stream
+        (do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv));
+    if (NS_FAILED(rv))
+        return rv;
+
+    rv = stream->SetData(data.BeginReading(), data.Length());
+    if (NS_FAILED(rv))
+        return rv;
+
+    stream.forget(result);
+    return NS_OK;
+}
+
+nsresult
 NS_ReadInputStreamToBuffer(nsIInputStream *aInputStream,
                            void **aDest,
                            uint32_t aCount)
 {
     nsresult rv;
 
     if (!*aDest) {
         *aDest = malloc(aCount);
@@ -1170,16 +1448,50 @@ NS_ReadInputStreamToString(nsIInputStrea
 {
     if (!aDest.SetLength(aCount, mozilla::fallible))
         return NS_ERROR_OUT_OF_MEMORY;
     void* dest = aDest.BeginWriting();
     return NS_ReadInputStreamToBuffer(aInputStream, &dest, aCount);
 }
 
 nsresult
+NS_NewURI(nsIURI **result,
+          const nsACString &spec,
+          const char *charset /* = nullptr */,
+          nsIURI *baseURI /* = nullptr */,
+          nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
+{
+    nsresult rv;
+    nsCOMPtr<nsIIOService> grip;
+    rv = net_EnsureIOService(&ioService, grip);
+    if (ioService)
+        rv = ioService->NewURI(spec, charset, baseURI, result);
+    return rv;
+}
+
+nsresult
+NS_NewURI(nsIURI **result,
+          const nsAString &spec,
+          const char *charset /* = nullptr */,
+          nsIURI *baseURI /* = nullptr */,
+          nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
+{
+    return NS_NewURI(result, NS_ConvertUTF16toUTF8(spec), charset, baseURI, ioService);
+}
+
+nsresult
+NS_NewURI(nsIURI **result,
+          const char *spec,
+          nsIURI *baseURI /* = nullptr */,
+          nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
+{
+    return NS_NewURI(result, nsDependentCString(spec), nullptr, baseURI, ioService);
+}
+
+nsresult
 NS_LoadPersistentPropertiesFromURISpec(nsIPersistentProperties **outResult,
                                        const nsACString         &aSpec)
 {
     nsCOMPtr<nsIURI> uri;
     nsresult rv = NS_NewURI(getter_AddRefs(uri), aSpec);
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsCOMPtr<nsIChannel> channel;
@@ -1533,16 +1845,28 @@ NS_GetFinalChannelURI(nsIChannel *channe
 
     if (loadFlags & nsIChannel::LOAD_REPLACE) {
         return channel->GetURI(uri);
     }
 
     return channel->GetOriginalURI(uri);
 }
 
+nsresult
+NS_URIChainHasFlags(nsIURI   *uri,
+                    uint32_t  flags,
+                    bool     *result)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return util->URIChainHasFlags(uri, flags, result);
+}
+
 uint32_t
 NS_SecurityHashURI(nsIURI *aURI)
 {
     nsCOMPtr<nsIURI> baseURI = NS_GetInnermostURI(aURI);
 
     nsAutoCString scheme;
     uint32_t schemeHash = 0;
     if (NS_SUCCEEDED(baseURI->GetScheme(scheme)))
@@ -2369,16 +2693,29 @@ NS_GetDefaultReferrerPolicy()
       return nsIHttpChannel::REFERRER_POLICY_SAME_ORIGIN;
     case 2:
       return nsIHttpChannel::REFERRER_POLICY_STRICT_ORIGIN_WHEN_XORIGIN;
   }
 
   return nsIHttpChannel::REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE;
 }
 
+bool
+NS_IsOffline()
+{
+    bool offline = true;
+    bool connectivity = true;
+    nsCOMPtr<nsIIOService> ios = do_GetIOService();
+    if (ios) {
+        ios->GetOffline(&offline);
+        ios->GetConnectivity(&connectivity);
+    }
+    return offline || !connectivity;
+}
+
 namespace mozilla {
 namespace net {
 
 bool
 InScriptableRange(int64_t val)
 {
     return (val <= kJS_MAX_SAFE_INTEGER) && (val >= kJS_MIN_SAFE_INTEGER);
 }
deleted file mode 100644
--- a/netwerk/base/nsNetUtilInlines.h
+++ /dev/null
@@ -1,397 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* vim:set ts=4 sw=4 sts=4 et cin: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef nsNetUtil_inl
-#define nsNetUtil_inl
-
-#include "mozilla/Services.h"
-
-#include "nsComponentManagerUtils.h"
-#include "nsIBufferedStreams.h"
-#include "nsIChannel.h"
-#include "nsIFile.h"
-#include "nsIFileStreams.h"
-#include "nsIFileURL.h"
-#include "nsIHttpChannel.h"
-#include "nsIInputStreamChannel.h"
-#include "nsIIOService.h"
-#include "nsINestedURI.h"
-#include "nsINode.h"
-#include "nsIProtocolHandler.h"
-#include "nsIStandardURL.h"
-#include "nsIStreamLoader.h"
-#include "nsIIncrementalStreamLoader.h"
-#include "nsIURI.h"
-#include "nsIURIWithPrincipal.h"
-#include "nsIWritablePropertyBag2.h"
-#include "nsNetCID.h"
-#include "nsStringStream.h"
-
-#ifdef MOZILLA_INTERNAL_API
-// Don't allow functions that end up in nsNetUtil.cpp to be inlined out.
-#define INLINE_IF_EXTERN MOZ_NEVER_INLINE
-#else
-// Make sure that functions included via nsNetUtil.h don't get multiply defined.
-#define INLINE_IF_EXTERN MOZ_ALWAYS_INLINE
-#endif
-
-#ifdef MOZILLA_INTERNAL_API
-
-INLINE_IF_EXTERN already_AddRefed<nsIIOService>
-do_GetIOService(nsresult *error /* = 0 */)
-{
-    nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService();
-    if (error)
-        *error = io ? NS_OK : NS_ERROR_FAILURE;
-    return io.forget();
-}
-
-INLINE_IF_EXTERN already_AddRefed<nsINetUtil>
-do_GetNetUtil(nsresult *error /* = 0 */)
-{
-    nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService();
-    nsCOMPtr<nsINetUtil> util;
-    if (io)
-        util = do_QueryInterface(io);
-
-    if (error)
-        *error = !!util ? NS_OK : NS_ERROR_FAILURE;
-    return util.forget();
-}
-
-#else
-
-INLINE_IF_EXTERN const nsGetServiceByContractIDWithError
-do_GetIOService(nsresult *error /* = 0 */)
-{
-    return nsGetServiceByContractIDWithError(NS_IOSERVICE_CONTRACTID, error);
-}
-
-INLINE_IF_EXTERN const nsGetServiceByContractIDWithError
-do_GetNetUtil(nsresult *error /* = 0 */)
-{
-    return do_GetIOService(error);
-}
-#endif
-
-// private little helper function... don't call this directly!
-MOZ_ALWAYS_INLINE nsresult
-net_EnsureIOService(nsIIOService **ios, nsCOMPtr<nsIIOService> &grip)
-{
-    nsresult rv = NS_OK;
-    if (!*ios) {
-        grip = do_GetIOService(&rv);
-        *ios = grip;
-    }
-    return rv;
-}
-
-INLINE_IF_EXTERN nsresult
-NS_URIChainHasFlags(nsIURI   *uri,
-                    uint32_t  flags,
-                    bool     *result)
-{
-    nsresult rv;
-    nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return util->URIChainHasFlags(uri, flags, result);
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewURI(nsIURI **result,
-          const nsACString &spec,
-          const char *charset /* = nullptr */,
-          nsIURI *baseURI /* = nullptr */,
-          nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
-{
-    nsresult rv;
-    nsCOMPtr<nsIIOService> grip;
-    rv = net_EnsureIOService(&ioService, grip);
-    if (ioService)
-        rv = ioService->NewURI(spec, charset, baseURI, result);
-    return rv;
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewURI(nsIURI **result,
-          const nsAString &spec,
-          const char *charset /* = nullptr */,
-          nsIURI *baseURI /* = nullptr */,
-          nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
-{
-    return NS_NewURI(result, NS_ConvertUTF16toUTF8(spec), charset, baseURI, ioService);
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewURI(nsIURI **result,
-          const char *spec,
-          nsIURI *baseURI /* = nullptr */,
-          nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
-{
-    return NS_NewURI(result, nsDependentCString(spec), nullptr, baseURI, ioService);
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewFileURI(nsIURI **result,
-              nsIFile *spec,
-              nsIIOService *ioService /* = nullptr */)     // pass in nsIIOService to optimize callers
-{
-    nsresult rv;
-    nsCOMPtr<nsIIOService> grip;
-    rv = net_EnsureIOService(&ioService, grip);
-    if (ioService)
-        rv = ioService->NewFileURI(spec, result);
-    return rv;
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewChannelInternal(nsIChannel           **outChannel,
-                      nsIURI                *aUri,
-                      nsINode               *aLoadingNode,
-                      nsIPrincipal          *aLoadingPrincipal,
-                      nsIPrincipal          *aTriggeringPrincipal,
-                      nsSecurityFlags        aSecurityFlags,
-                      nsContentPolicyType    aContentPolicyType,
-                      nsILoadGroup          *aLoadGroup /* = nullptr */,
-                      nsIInterfaceRequestor *aCallbacks /* = nullptr */,
-                      nsLoadFlags            aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
-                      nsIIOService          *aIoService /* = nullptr */)
-{
-  NS_ENSURE_ARG_POINTER(outChannel);
-
-  nsCOMPtr<nsIIOService> grip;
-  nsresult rv = net_EnsureIOService(&aIoService, grip);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  nsCOMPtr<nsIChannel> channel;
-  rv = aIoService->NewChannelFromURI2(
-         aUri,
-         aLoadingNode ?
-           aLoadingNode->AsDOMNode() : nullptr,
-         aLoadingPrincipal,
-         aTriggeringPrincipal,
-         aSecurityFlags,
-         aContentPolicyType,
-         getter_AddRefs(channel));
-  if (NS_FAILED(rv)) {
-    return rv;
-  }
-
-  if (aLoadGroup) {
-    rv = channel->SetLoadGroup(aLoadGroup);
-    NS_ENSURE_SUCCESS(rv, rv);
-  }
-
-  if (aCallbacks) {
-    rv = channel->SetNotificationCallbacks(aCallbacks);
-    NS_ENSURE_SUCCESS(rv, rv);
-  }
-
-  if (aLoadFlags != nsIRequest::LOAD_NORMAL) {
-    // Retain the LOAD_REPLACE load flag if set.
-    nsLoadFlags normalLoadFlags = 0;
-    channel->GetLoadFlags(&normalLoadFlags);
-    rv = channel->SetLoadFlags(aLoadFlags | (normalLoadFlags & nsIChannel::LOAD_REPLACE));
-    NS_ENSURE_SUCCESS(rv, rv);
-  }
-
-  channel.forget(outChannel);
-  return NS_OK;
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewChannelInternal(nsIChannel           **outChannel,
-                      nsIURI                *aUri,
-                      nsILoadInfo           *aLoadInfo,
-                      nsILoadGroup          *aLoadGroup /* = nullptr */,
-                      nsIInterfaceRequestor *aCallbacks /* = nullptr */,
-                      nsLoadFlags            aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
-                      nsIIOService          *aIoService /* = nullptr */)
-{
-  // NS_NewChannelInternal is mostly called for channel redirects. We should allow
-  // the creation of a channel even if the original channel did not have a loadinfo
-  // attached.
-  NS_ENSURE_ARG_POINTER(outChannel);
-
-  nsCOMPtr<nsIIOService> grip;
-  nsresult rv = net_EnsureIOService(&aIoService, grip);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  nsCOMPtr<nsIChannel> channel;
-  rv = aIoService->NewChannelFromURIWithLoadInfo(
-         aUri,
-         aLoadInfo,
-         getter_AddRefs(channel));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  if (aLoadGroup) {
-    rv = channel->SetLoadGroup(aLoadGroup);
-    NS_ENSURE_SUCCESS(rv, rv);
-  }
-
-  if (aCallbacks) {
-    rv = channel->SetNotificationCallbacks(aCallbacks);
-    NS_ENSURE_SUCCESS(rv, rv);
-  }
-
-  if (aLoadFlags != nsIRequest::LOAD_NORMAL) {
-    // Retain the LOAD_REPLACE load flag if set.
-    nsLoadFlags normalLoadFlags = 0;
-    channel->GetLoadFlags(&normalLoadFlags);
-    rv = channel->SetLoadFlags(aLoadFlags | (normalLoadFlags & nsIChannel::LOAD_REPLACE));
-    NS_ENSURE_SUCCESS(rv, rv);
-  }
-
-  channel.forget(outChannel);
-  return NS_OK;
-}
-
-INLINE_IF_EXTERN nsresult /* NS_NewChannelPrincipal */
-NS_NewChannel(nsIChannel           **outChannel,
-              nsIURI                *aUri,
-              nsIPrincipal          *aLoadingPrincipal,
-              nsSecurityFlags        aSecurityFlags,
-              nsContentPolicyType    aContentPolicyType,
-              nsILoadGroup          *aLoadGroup /* = nullptr */,
-              nsIInterfaceRequestor *aCallbacks /* = nullptr */,
-              nsLoadFlags            aLoadFlags /* = nsIRequest::LOAD_NORMAL */,
-              nsIIOService          *aIoService /* = nullptr */)
-{
-  return NS_NewChannelInternal(outChannel,
-                               aUri,
-                               nullptr, // aLoadingNode,
-                               aLoadingPrincipal,
-                               nullptr, // aTriggeringPrincipal
-                               aSecurityFlags,
-                               aContentPolicyType,
-                               aLoadGroup,
-                               aCallbacks,
-                               aLoadFlags,
-                               aIoService);
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewStreamLoader(nsIStreamLoader        **result,
-                   nsIStreamLoaderObserver *observer,
-                   nsIRequestObserver      *requestObserver /* = nullptr */)
-{
-    nsresult rv;
-    nsCOMPtr<nsIStreamLoader> loader =
-        do_CreateInstance(NS_STREAMLOADER_CONTRACTID, &rv);
-    if (NS_SUCCEEDED(rv)) {
-        rv = loader->Init(observer, requestObserver);
-        if (NS_SUCCEEDED(rv)) {
-            *result = nullptr;
-            loader.swap(*result);
-        }
-    }
-    return rv;
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewLocalFileInputStream(nsIInputStream **result,
-                           nsIFile         *file,
-                           int32_t          ioFlags       /* = -1 */,
-                           int32_t          perm          /* = -1 */,
-                           int32_t          behaviorFlags /* = 0 */)
-{
-    nsresult rv;
-    nsCOMPtr<nsIFileInputStream> in =
-        do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv);
-    if (NS_SUCCEEDED(rv)) {
-        rv = in->Init(file, ioFlags, perm, behaviorFlags);
-        if (NS_SUCCEEDED(rv))
-            in.forget(result);
-    }
-    return rv;
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewLocalFileOutputStream(nsIOutputStream **result,
-                            nsIFile          *file,
-                            int32_t           ioFlags       /* = -1 */,
-                            int32_t           perm          /* = -1 */,
-                            int32_t           behaviorFlags /* = 0 */)
-{
-    nsresult rv;
-    nsCOMPtr<nsIFileOutputStream> out =
-        do_CreateInstance(NS_LOCALFILEOUTPUTSTREAM_CONTRACTID, &rv);
-    if (NS_SUCCEEDED(rv)) {
-        rv = out->Init(file, ioFlags, perm, behaviorFlags);
-        if (NS_SUCCEEDED(rv))
-            out.forget(result);
-    }
-    return rv;
-}
-
-INLINE_IF_EXTERN MOZ_MUST_USE nsresult
-NS_NewBufferedInputStream(nsIInputStream **result,
-                          nsIInputStream  *str,
-                          uint32_t         bufferSize)
-{
-    nsresult rv;
-    nsCOMPtr<nsIBufferedInputStream> in =
-        do_CreateInstance(NS_BUFFEREDINPUTSTREAM_CONTRACTID, &rv);
-    if (NS_SUCCEEDED(rv)) {
-        rv = in->Init(str, bufferSize);
-        if (NS_SUCCEEDED(rv)) {
-            in.forget(result);
-        }
-    }
-    return rv;
-}
-
-INLINE_IF_EXTERN nsresult
-NS_NewPostDataStream(nsIInputStream  **result,
-                     bool              isFile,
-                     const nsACString &data)
-{
-    nsresult rv;
-
-    if (isFile) {
-        nsCOMPtr<nsIFile> file;
-        nsCOMPtr<nsIInputStream> fileStream;
-
-        rv = NS_NewNativeLocalFile(data, false, getter_AddRefs(file));
-        if (NS_SUCCEEDED(rv)) {
-            rv = NS_NewLocalFileInputStream(getter_AddRefs(fileStream), file);
-            if (NS_SUCCEEDED(rv)) {
-                // wrap the file stream with a buffered input stream
-                rv = NS_NewBufferedInputStream(result, fileStream, 8192);
-            }
-        }
-        return rv;
-    }
-
-    // otherwise, create a string stream for the data (copies)
-    nsCOMPtr<nsIStringInputStream> stream
-        (do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv));
-    if (NS_FAILED(rv))
-        return rv;
-
-    rv = stream->SetData(data.BeginReading(), data.Length());
-    if (NS_FAILED(rv))
-        return rv;
-
-    stream.forget(result);
-    return NS_OK;
-}
-
-INLINE_IF_EXTERN bool
-NS_IsOffline()
-{
-    bool offline = true;
-    bool connectivity = true;
-    nsCOMPtr<nsIIOService> ios = do_GetIOService();
-    if (ios) {
-        ios->GetOffline(&offline);
-        ios->GetConnectivity(&connectivity);
-    }
-    return offline || !connectivity;
-}
-
-#endif // nsNetUtil_inl