Bug 1343545 - Moved necessary code out of nsNetUtilInlines.h and removed the file r=bsmedberg
authorNick <nick@foxsec.io>
Thu, 02 Mar 2017 09:32:37 -0500
changeset 345890 2eef7989fbb6
parent 345889 dc8b32d3d5c6
child 345891 e5b4f79727c8
push id31451
push usercbook@mozilla.com
push dateMon, 06 Mar 2017 09:52:09 +0000
treeherdermozilla-central@7099e03837e8 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbsmedberg
bugs1343545
milestone54.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 1343545 - Moved necessary code out of nsNetUtilInlines.h and removed the file r=bsmedberg 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