--- a/dom/plugins/base/nsPluginHost.cpp
+++ b/dom/plugins/base/nsPluginHost.cpp
@@ -575,18 +575,17 @@ nsresult nsPluginHost::PostURL(nsISuppor
       } else if (0 == PL_strcmp(target, "_current")) {
         target = "_self";
       }
       rv = owner->GetURL(url, target, postStream,
                          (void*)postHeaders, postHeadersLength);
     }
   }
 
-  // if we don't have a target, just create a stream.  This does
-  // NS_OpenURI()!
+  // if we don't have a target, just create a stream.
   if (streamListener)
     rv = NewPluginURLStream(NS_ConvertUTF8toUTF16(url), instance,
                             streamListener,
                             postStream, postHeaders, postHeadersLength);
 
   return rv;
 }
 

--- a/dom/xul/XULDocument.cpp
+++ b/dom/xul/XULDocument.cpp
@@ -2706,29 +2706,27 @@ XULDocument::LoadOverlayInternal(nsIURI*
         if (NS_FAILED(rv)) {
             // Abandon this prototype
             mCurrentPrototype = nullptr;
 
             // The parser won't get an OnStartRequest and
             // OnStopRequest, so it needs a Terminate.
             parser->Terminate();
 
-            // Just move on to the next overlay.  NS_OpenURI could fail
-            // just because a channel could not be opened, which can happen
-            // if a file or chrome package does not exist.
+            // Just move on to the next overlay.
             ReportMissingOverlay(aURI);
-            
+
             // XXX the error could indicate an internal error as well...
             *aFailureFromContent = true;
             return rv;
         }
 
         // If it's a 'chrome:' prototype document, then put it into
         // the prototype cache; other XUL documents will be reloaded
-        // each time.  We must do this after NS_OpenURI and AsyncOpen,
+        // each time.  We must do this after AsyncOpen,
         // or chrome code will wrongly create a cached chrome channel
         // instead of a real one. Prototypes are only cached when the
         // document to be overlayed is chrome to avoid caching overlay
         // scripts with incorrect principals, see bug 565610.
         if (useXULCache && overlayIsChrome && documentIsChrome) {
             nsXULPrototypeCache::GetInstance()->PutPrototype(mCurrentPrototype);
         }
 

--- a/editor/libeditor/nsHTMLDataTransfer.cpp
+++ b/editor/libeditor/nsHTMLDataTransfer.cpp
@@ -1078,22 +1078,25 @@ nsresult nsHTMLEditor::InsertObject(cons
       0 == nsCRT::strcmp(type, kJPGImageMime) ||
       0 == nsCRT::strcmp(type, kPNGImageMime) ||
       0 == nsCRT::strcmp(type, kGIFImageMime) ||
       insertAsImage)
   {
     nsCOMPtr<nsIInputStream> imageStream;
     if (insertAsImage) {
       NS_ASSERTION(fileURI, "The file URI should be retrieved earlier");
-      rv = NS_OpenURI(getter_AddRefs(imageStream),
-                      fileURI,
-                      nsContentUtils::GetSystemPrincipal(),
-                      nsILoadInfo::SEC_NORMAL,
-                      nsIContentPolicy::TYPE_OTHER);
 
+      nsCOMPtr<nsIChannel> channel;
+      rv = NS_NewChannel(getter_AddRefs(channel),
+                         fileURI,
+                         nsContentUtils::GetSystemPrincipal(),
+                         nsILoadInfo::SEC_NORMAL,
+                         nsIContentPolicy::TYPE_OTHER);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = channel->Open(getter_AddRefs(imageStream));
       NS_ENSURE_SUCCESS(rv, rv);
     } else {
       imageStream = do_QueryInterface(aObject);
       NS_ENSURE_TRUE(imageStream, NS_ERROR_FAILURE);
     }
 
     nsCString imageData;
     rv = NS_ConsumeStream(imageStream, UINT32_MAX, imageData);

--- a/intl/hyphenation/hnjstdio.cpp
+++ b/intl/hyphenation/hnjstdio.cpp
@@ -31,23 +31,28 @@ hnjFopen(const char* aURISpec, const cha
     NS_ASSERTION(!strcmp(aMode, "r"), "unsupported fopen() mode in hnjFopen");
 
     nsCOMPtr<nsIURI> uri;
     nsresult rv = NS_NewURI(getter_AddRefs(uri), aURISpec);
     if (NS_FAILED(rv)) {
         return nullptr;
     }
 
+    nsCOMPtr<nsIChannel> channel;
+    rv = NS_NewChannel(getter_AddRefs(channel),
+                       uri,
+                       nsContentUtils::GetSystemPrincipal(),
+                       nsILoadInfo::SEC_NORMAL,
+                       nsIContentPolicy::TYPE_OTHER);
+    if (NS_FAILED(rv)) {
+        return nullptr;
+    }
+
     nsCOMPtr<nsIInputStream> instream;
-    rv = NS_OpenURI(getter_AddRefs(instream),
-                    uri,
-                    nsContentUtils::GetSystemPrincipal(),
-                    nsILoadInfo::SEC_NORMAL,
-                    nsIContentPolicy::TYPE_OTHER);
-
+    rv = channel->Open(getter_AddRefs(instream));
     if (NS_FAILED(rv)) {
         return nullptr;
     }
 
     hnjFile *f = new hnjFile;
     f->mStream = instream;
     f->mCurPos = 0;
     f->mLimit = 0;

--- a/intl/strres/nsStringBundle.cpp
+++ b/intl/strres/nsStringBundle.cpp
@@ -64,17 +64,16 @@ nsStringBundle::LoadProperties()
 
   nsresult rv;
 
   // do it synchronously
   nsCOMPtr<nsIURI> uri;
   rv = NS_NewURI(getter_AddRefs(uri), mPropertiesURL);
   if (NS_FAILED(rv)) return rv;
 
-  // We don't use NS_OpenURI because we want to tweak the channel
   nsCOMPtr<nsIChannel> channel;
   rv = NS_NewChannel(getter_AddRefs(channel),
                      uri,
                      nsContentUtils::GetSystemPrincipal(),
                      nsILoadInfo::SEC_NORMAL,
                      nsIContentPolicy::TYPE_OTHER);
 
   if (NS_FAILED(rv)) return rv;

--- a/intl/strres/nsStringBundleTextOverride.cpp
+++ b/intl/strres/nsStringBundleTextOverride.cpp
@@ -141,26 +141,29 @@ nsStringBundleTextOverride::Init()
     // chrome://package/locale/foo.properties:keyname
 
     nsAutoCString customStringsURLSpec;
     rv = NS_GetURLSpecFromFile(customStringsFile, customStringsURLSpec);
     if (NS_FAILED(rv)) return rv;
     
     nsCOMPtr<nsIURI> uri;
     rv = NS_NewURI(getter_AddRefs(uri), customStringsURLSpec);
-    if (NS_FAILED(rv)) return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
+    nsCOMPtr<nsIChannel> channel;
+    rv = NS_NewChannel(getter_AddRefs(channel),
+                       uri,
+                       nsContentUtils::GetSystemPrincipal(),
+                       nsILoadInfo::SEC_NORMAL,
+                       nsIContentPolicy::TYPE_OTHER);
+
+    NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIInputStream> in;
-    rv = NS_OpenURI(getter_AddRefs(in),
-                    uri,
-                    nsContentUtils::GetSystemPrincipal(),
-                    nsILoadInfo::SEC_NORMAL,
-                    nsIContentPolicy::TYPE_OTHER);
-
-    if (NS_FAILED(rv)) return rv;
+    rv = channel->Open(getter_AddRefs(in));
+    NS_ENSURE_SUCCESS(rv, rv);
 
     static NS_DEFINE_CID(kPersistentPropertiesCID, NS_IPERSISTENTPROPERTIES_CID);
     mValues = do_CreateInstance(kPersistentPropertiesCID, &rv);
     if (NS_FAILED(rv)) return rv;
 
     rv = mValues->Load(in);
 
     // turn this on to see the contents of custom-strings.txt

--- a/js/xpconnect/loader/mozJSSubScriptLoader.cpp
+++ b/js/xpconnect/loader/mozJSSubScriptLoader.cpp
@@ -131,18 +131,18 @@ mozJSSubScriptLoader::ReadScript(nsIURI 
                                  bool reuseGlobal, JS::MutableHandleScript script,
                                  JS::MutableHandleFunction function)
 {
     RootedObject target_obj(cx, targetObjArg);
 
     script.set(nullptr);
     function.set(nullptr);
 
-    // Instead of calling NS_OpenURI, we create the channel ourselves and call
-    // SetContentType, to avoid expensive MIME type lookups (bug 632490).
+    // We create a channel and call SetContentType, to avoid expensive MIME type
+    // lookups (bug 632490).
     nsCOMPtr<nsIChannel> chan;
     nsCOMPtr<nsIInputStream> instream;
     nsresult rv;
     rv = NS_NewChannel(getter_AddRefs(chan),
                        uri,
                        nsContentUtils::GetSystemPrincipal(),
                        nsILoadInfo::SEC_NORMAL,
                        nsIContentPolicy::TYPE_OTHER,

--- a/layout/style/Loader.cpp
+++ b/layout/style/Loader.cpp
@@ -1459,68 +1459,60 @@ Loader::LoadSheet(SheetLoadData* aLoadDa
 
     if (mDocument) {
       mozilla::net::PredictorLearn(aLoadData->mURI, mDocument->GetDocumentURI(),
                                    nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE,
                                    mDocument);
     }
 
     // Just load it
-    nsCOMPtr<nsIInputStream> stream;
     nsCOMPtr<nsIChannel> channel;
-    // Note that we are calling NS_OpenURIInternal() with both a node and a
-    // principal.  This is because of a case where the node is the document
-    // being styled and the principal is the stylesheet (perhaps from a
-    // different origin)  that is applying the styles.
+    // Note that we are calling NS_NewChannelWithTriggeringPrincipal() with both
+    // a node and a principal.
+    // This is because of a case where the node is the document being styled and
+    // the principal is the stylesheet (perhaps from a different origin) that is
+    // applying the styles.
     if (aLoadData->mRequestingNode) {
-      rv = NS_OpenURIWithTriggeringPrincipal(getter_AddRefs(stream),
-                                             aLoadData->mURI,
-                                             aLoadData->mRequestingNode,
-                                             triggeringPrincipal,
-                                             nsILoadInfo::SEC_NORMAL,
-                                             nsIContentPolicy::TYPE_OTHER,
-                                             nullptr,   // aLoadGroup
-                                             nullptr,   // aCallbacks
-                                             nsIRequest::LOAD_NORMAL,
-                                             nullptr,   // aIoService
-                                             getter_AddRefs(channel));
+      rv = NS_NewChannelWithTriggeringPrincipal(getter_AddRefs(channel),
+                                                aLoadData->mURI,
+                                                aLoadData->mRequestingNode,
+                                                triggeringPrincipal,
+                                                nsILoadInfo::SEC_NORMAL,
+                                                nsIContentPolicy::TYPE_OTHER);
     }
     else {
       // either we are loading something inside a document, in which case
       // we should always have a requestingNode, or we are loading something
       // outside a document, in which case the triggeringPrincipal
       // should always be the systemPrincipal.
       MOZ_ASSERT(nsContentUtils::IsSystemPrincipal(triggeringPrincipal));
-      rv = NS_OpenURI(getter_AddRefs(stream),
-                      aLoadData->mURI,
-                      triggeringPrincipal,
-                      nsILoadInfo::SEC_NORMAL,
-                      nsIContentPolicy::TYPE_OTHER,
-                      nullptr,   // aLoadGroup
-                      nullptr,   // aCallbacks
-                      nsIRequest::LOAD_NORMAL,
-                      nullptr,   // aIoService
-                      getter_AddRefs(channel));
+      rv = NS_NewChannel(getter_AddRefs(channel),
+                         aLoadData->mURI,
+                         triggeringPrincipal,
+                         nsILoadInfo::SEC_NORMAL,
+                         nsIContentPolicy::TYPE_OTHER);
     }
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIInputStream> stream;
+    rv = channel->Open(getter_AddRefs(stream));
 
     if (NS_FAILED(rv)) {
       LOG_ERROR(("  Failed to open URI synchronously"));
       SheetComplete(aLoadData, rv);
       return rv;
     }
 
-    NS_ASSERTION(channel, "NS_OpenURI lied?");
-
     // Force UA sheets to be UTF-8.
     // XXX this is only necessary because the default in
     // SheetLoadData::OnDetermineCharset is wrong (bug 521039).
     channel->SetContentCharset(NS_LITERAL_CSTRING("UTF-8"));
 
-    // Manually feed the streamloader the contents of the stream we
-    // got from NS_OpenURI.  This will call back into OnStreamComplete
+    // Manually feed the streamloader the contents of the stream.
+    // This will call back into OnStreamComplete
     // and thence to ParseSheet.  Regardless of whether this fails,
     // SheetComplete has been called.
     return nsSyncLoadService::PushSyncStreamToListener(stream,
                                                        streamLoader,
                                                        channel);
   }
 
   SheetLoadData* existingData = nullptr;

--- a/modules/libjar/nsJARChannel.cpp
+++ b/modules/libjar/nsJARChannel.cpp
@@ -857,43 +857,51 @@ nsJARChannel::AsyncOpen(nsIStreamListene
     // These variables must only be set if we're going to trigger an
     // OnStartRequest, either from AsyncRead or OnDownloadComplete.
     // 
     // That means: Do not add early return statements beyond this point!
     mListener = listener;
     mListenerContext = ctx;
     mIsPending = true;
 
+    nsCOMPtr<nsIChannel> channel;
+
     if (!mJarFile) {
         // Not a local file...
         // kick off an async download of the base URI...
         rv = NS_NewDownloader(getter_AddRefs(mDownloader), this);
         if (NS_SUCCEEDED(rv)) {
             // Since we might not have a loadinfo on all channels yet
             // we have to provide default arguments in case mLoadInfo is null;
+            uint32_t loadFlags =
+              mLoadFlags & ~(LOAD_DOCUMENT_URI | LOAD_CALL_CONTENT_SNIFFERS);
             if (mLoadInfo) {
-              rv = NS_OpenURIInternal(mDownloader,
-                                      nullptr,   // aContext
-                                      mJarBaseURI,
-                                      mLoadInfo,
-                                      mLoadGroup,
-                                      mCallbacks,
-                                      mLoadFlags & ~(LOAD_DOCUMENT_URI | LOAD_CALL_CONTENT_SNIFFERS));
+              rv = NS_NewChannelInternal(getter_AddRefs(channel),
+                                         mJarBaseURI,
+                                         mLoadInfo,
+                                         mLoadGroup,
+                                         mCallbacks,
+                                         loadFlags);
+            } else {
+              rv = NS_NewChannel(getter_AddRefs(channel),
+                                 mJarBaseURI,
+                                 nsContentUtils::GetSystemPrincipal(),
+                                 nsILoadInfo::SEC_NORMAL,
+                                 nsIContentPolicy::TYPE_OTHER,
+                                 mLoadGroup,
+                                 mCallbacks,
+                                 loadFlags);
             }
-            else {
-              rv = NS_OpenURI(mDownloader,
-                              nullptr,   // aContext
-                              mJarBaseURI,
-                              nsContentUtils::GetSystemPrincipal(),
-                              nsILoadInfo::SEC_NORMAL,
-                              nsIContentPolicy::TYPE_OTHER,
-                              mLoadGroup,
-                              mCallbacks,
-                              mLoadFlags & ~(LOAD_DOCUMENT_URI | LOAD_CALL_CONTENT_SNIFFERS));
+            if (NS_FAILED(rv)) {
+              mIsPending = false;
+              mListenerContext = nullptr;
+              mListener = nullptr;
+              return rv;
             }
+            channel->AsyncOpen(mDownloader, nullptr);
         }
     } else if (mOpeningRemote) {
         // nothing to do: already asked parent to open file.
     } else {
         rv = OpenLocalFile();
     }
 
     if (NS_FAILED(rv)) {

--- a/netwerk/base/public/nsNetUtil.h
+++ b/netwerk/base/public/nsNetUtil.h
@@ -184,17 +184,17 @@ NS_NewFileURI(nsIURI* *result,
     rv = net_EnsureIOService(&ioService, grip);
     if (ioService)
         rv = ioService->NewFileURI(spec, result);
     return rv;
 }
 
 /*
 * How to create a new Channel, using NS_NewChannel,
-* NS_NewChannelWithTriggeringPrincipal, NS_OpenURI,
+* NS_NewChannelWithTriggeringPrincipal,
 * NS_NewInputStreamChannel, NS_NewChannelInternal
 * and it's variations:
 *
 * What specific API function to use:
 * * The NS_NewChannelInternal functions should almost never be directly
 *   called outside of necko code.
 * * If possible, use NS_NewChannel() providing a loading *nsINode*
 * * If no loading *nsINode* is avaialable, call NS_NewChannel() providing
@@ -444,199 +444,16 @@ NS_NewChannel(nsIChannel**           out
                                aSecurityFlags,
                                aContentPolicyType,
                                aLoadGroup,
                                aCallbacks,
                                aLoadFlags,
                                aIoService);
 }
 
-// Use this function with CAUTION. It creates a stream that blocks when you
-// Read() from it and blocking the UI thread is a bad idea. If you don't want
-// to implement a full blown asynchronous consumer (via nsIStreamListener) look
-// at nsIStreamLoader instead.
-inline nsresult
-NS_OpenURIInternal(nsIInputStream**       outStream,
-                   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,  // pass in nsIIOService to optimize callers
-                   nsIChannel**           outChannel = nullptr)
-{
-  NS_ASSERTION(aLoadingPrincipal, "Can not create channel without a loading Principal!");
-
-  nsCOMPtr<nsIChannel> channel;
-  nsresult rv = NS_NewChannelInternal(getter_AddRefs(channel),
-                                      aUri,
-                                      aLoadingNode,
-                                      aLoadingPrincipal,
-                                      aTriggeringPrincipal,
-                                      aSecurityFlags,
-                                      aContentPolicyType,
-                                      aLoadGroup,
-                                      aCallbacks,
-                                      aLoadFlags,
-                                      aIoService);
-
-  NS_ENSURE_SUCCESS(rv, rv);
-  nsIInputStream *stream;
-  rv = channel->Open(&stream);
-  NS_ENSURE_SUCCESS(rv, rv);
-  *outStream = stream;
-  if (outChannel) {
-    *outChannel = nullptr;
-     channel.swap(*outChannel);
-  }
-  return NS_OK;
-}
-
-inline nsresult /* NS_OpenURIprincipal */
-NS_OpenURI(nsIInputStream**       outStream,
-           nsIURI*                aUri,
-           nsIPrincipal*          aLoadingPrincipal,
-           nsSecurityFlags        aSecurityFlags,
-           nsContentPolicyType    aContentPolicyType,
-           nsILoadGroup*          aLoadGroup = nullptr,
-           nsIInterfaceRequestor* aCallbacks = nullptr,
-           nsLoadFlags            aLoadFlags = nsIRequest::LOAD_NORMAL,
-           nsIIOService*          aIoService = nullptr,
-           nsIChannel**           outChannel = nullptr)
-{
-  return NS_OpenURIInternal(outStream,
-                            aUri,
-                            nullptr, // aLoadingNode
-                            aLoadingPrincipal,
-                            nullptr, // aTriggeringPrincipal
-                            aSecurityFlags,
-                            aContentPolicyType,
-                            aLoadGroup,
-                            aCallbacks,
-                            aLoadFlags,
-                            aIoService,
-                            outChannel);
-}
-
-inline nsresult /* NS_OpenURIWithTriggeringPrincipalAndNode */
-NS_OpenURIWithTriggeringPrincipal(nsIInputStream**       outStream,
-                                  nsIURI*                aUri,
-                                  nsINode*               aLoadingNode,
-                                  nsIPrincipal*          aTriggeringPrincipal,
-                                  nsSecurityFlags        aSecurityFlags,
-                                  nsContentPolicyType    aContentPolicyType,
-                                  nsILoadGroup*          aLoadGroup = nullptr,
-                                  nsIInterfaceRequestor* aCallbacks = nullptr,
-                                  nsLoadFlags            aLoadFlags = nsIRequest::LOAD_NORMAL,
-                                  nsIIOService*          aIoService = nullptr,
-                                  nsIChannel**           outChannel = nullptr)
-{
-  MOZ_ASSERT(aLoadingNode);
-  NS_ASSERTION(aTriggeringPrincipal, "Can not open uri without a triggering Principal!");
-  return NS_OpenURIInternal(outStream,
-                            aUri,
-                            aLoadingNode,
-                            aLoadingNode->NodePrincipal(),
-                            aTriggeringPrincipal,
-                            aSecurityFlags,
-                            aContentPolicyType,
-                            aLoadGroup,
-                            aCallbacks,
-                            aLoadFlags,
-                            aIoService,
-                            outChannel);
-}
-
-inline nsresult
-NS_OpenURIInternal(nsIStreamListener*     aListener,
-                   nsISupports*           aContext,
-                   nsIURI*                aUri,
-                   nsILoadInfo*           aLoadInfo,
-                   nsILoadGroup*          aLoadGroup = nullptr,
-                   nsIInterfaceRequestor* aCallbacks = nullptr,
-                   nsLoadFlags            aLoadFlags = nsIRequest::LOAD_NORMAL,
-                   nsIIOService*          aIoService = nullptr)
-{
-  nsCOMPtr<nsIChannel> channel;
-  nsresult rv = NS_NewChannelInternal(getter_AddRefs(channel),
-                                      aUri,
-                                      aLoadInfo,
-                                      aLoadGroup,
-                                      aCallbacks,
-                                      aLoadFlags,
-                                      aIoService);
-  NS_ENSURE_SUCCESS(rv, rv);
-  return channel->AsyncOpen(aListener, aContext);
-}
-
-inline nsresult
-NS_OpenURIInternal(nsIStreamListener*     aListener,
-                   nsISupports*           aContext,
-                   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_ASSERTION(aLoadingPrincipal, "Can not create channel without a loading Principal!");
-
-  nsCOMPtr<nsILoadInfo> loadInfo =
-    new mozilla::LoadInfo(aLoadingPrincipal,
-                          aTriggeringPrincipal,
-                          aLoadingNode,
-                          aSecurityFlags,
-                          aContentPolicyType);
-  if (!loadInfo) {
-    return NS_ERROR_UNEXPECTED;
-  }
-  return NS_OpenURIInternal(aListener,
-                            aContext,
-                            aUri,
-                            loadInfo,
-                            aLoadGroup,
-                            aCallbacks,
-                            aLoadFlags,
-                            aIoService);
-}
-
-inline nsresult
-NS_OpenURI(nsIStreamListener*     aListener,
-           nsISupports*           aContext,
-           nsIURI*                aUri,
-           nsIPrincipal*          aLoadingPrincipal,
-           nsSecurityFlags        aSecurityFlags,
-           nsContentPolicyType    aContentPolicyType,
-           nsILoadGroup*          aLoadGroup = nullptr,
-           nsIInterfaceRequestor* aCallbacks = nullptr,
-           nsLoadFlags            aLoadFlags = nsIRequest::LOAD_NORMAL,
-           nsIIOService*          aIoService = nullptr)
-{
-  return NS_OpenURIInternal(aListener,
-                            aContext,
-                            aUri,
-                            nullptr, // aLoadingNode
-                            aLoadingPrincipal,
-                            nullptr, // aTriggeringPrincipal
-                            aSecurityFlags,
-                            aContentPolicyType,
-                            aLoadGroup,
-                            aCallbacks,
-                            aLoadFlags,
-                            aIoService);
-}
-
 inline nsresult
 NS_MakeAbsoluteURI(nsACString       &result,
                    const nsACString &spec, 
                    nsIURI           *baseURI)
 {
     nsresult rv;
     if (!baseURI) {
         NS_WARNING("It doesn't make sense to not supply a base URI");
@@ -1739,37 +1556,39 @@ NS_ReadInputStreamToString(nsIInputStrea
 
 inline nsresult
 NS_LoadPersistentPropertiesFromURI(nsIPersistentProperties** outResult,
                                    nsIURI*                   aUri,
                                    nsIPrincipal*             aLoadingPrincipal,
                                    nsContentPolicyType       aContentPolicyType,
                                    nsIIOService*             aIoService = nullptr)
 {
+    nsCOMPtr<nsIChannel> channel;
+    nsresult rv = NS_NewChannel(getter_AddRefs(channel),
+                                aUri,
+                                aLoadingPrincipal,
+                                nsILoadInfo::SEC_NORMAL,
+                                aContentPolicyType,
+                                nullptr,     // aLoadGroup
+                                nullptr,     // aCallbacks
+                                nsIRequest::LOAD_NORMAL,
+                                aIoService);
+    NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIInputStream> in;
-    nsresult rv = NS_OpenURI(getter_AddRefs(in),
-                             aUri,
-                             aLoadingPrincipal,
-                             nsILoadInfo::SEC_NORMAL,
-                             aContentPolicyType,
-                             nullptr,     // aLoadGroup
-                             nullptr,     // aCallbacks
-                             nsIRequest::LOAD_NORMAL, //aLoadFlags
-                             aIoService);
+    rv = channel->Open(getter_AddRefs(in));
+    NS_ENSURE_SUCCESS(rv, rv);
 
-    NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIPersistentProperties> properties =
       do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = properties->Load(in);
-    if (NS_SUCCEEDED(rv)) {
-      *outResult = nullptr;
-      properties.swap(*outResult);
-    }
-    return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    properties.swap(*outResult);
+    return NS_OK;
  }
 
 inline nsresult
 NS_LoadPersistentPropertiesFromURISpec(nsIPersistentProperties** outResult,
                                        const nsACString&         aSpec,
                                        nsIPrincipal*             aLoadingPrincipal,
                                        nsContentPolicyType       aContentPolicyType,
                                        const char*               aCharset = nullptr,

--- a/netwerk/test/TestOpen.cpp
+++ b/netwerk/test/TestOpen.cpp
@@ -54,23 +54,26 @@ main(int argc, char **argv)
 
     nsCOMPtr<nsIScriptSecurityManager> secman =
       do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
     RETURN_IF_FAILED(rv, "Couldn't get script security manager!");
        nsCOMPtr<nsIPrincipal> systemPrincipal;
     rv = secman->GetSystemPrincipal(getter_AddRefs(systemPrincipal));
     RETURN_IF_FAILED(rv, "Couldn't get system principal!");
 
-    rv = NS_OpenURI(getter_AddRefs(stream),
-                    uri,
-                    systemPrincipal,
-                    nsILoadInfo::SEC_NORMAL,
-                    nsIContentPolicy::TYPE_OTHER);
+    nsCOMPtr<nsIChannel> channel;
+    rv = NS_NewChannel(getter_AddRefs(channel),
+                       uri,
+                       systemPrincipal,
+                       nsILoadInfo::SEC_NORMAL,
+                       nsIContentPolicy::TYPE_OTHER);
+    RETURN_IF_FAILED(rv, "NS_NewChannel");
 
-    RETURN_IF_FAILED(rv, "NS_OpenURI");
+    rv = channel->Open(getter_AddRefs(stream));
+    RETURN_IF_FAILED(rv, "channel->Open()");
 
     FILE* outfile = fopen(argv[2], "wb");
     if (!outfile) {
       printf("error opening %s\n", argv[2]);
       return 1;
     }
 
     uint32_t read;

--- a/rdf/base/nsRDFXMLDataSource.cpp
+++ b/rdf/base/nsRDFXMLDataSource.cpp
@@ -950,26 +950,27 @@ RDFXMLDataSourceImpl::Refresh(bool aBloc
         rv = BlockingParse(mURL, this);
 
         mListener = nullptr; // release the parser
 
         if (NS_FAILED(rv)) return rv;
     }
     else {
         // Null LoadGroup ?
-        rv = NS_OpenURI(this,
-                        nullptr,   // aContext
-                        mURL,
-                        nsContentUtils::GetSystemPrincipal(),
-                        nsILoadInfo::SEC_NORMAL,
-                        nsIContentPolicy::TYPE_OTHER,
-                        nullptr, // aLoadGroup
-                        this);   // aCallbacks
-
-        if (NS_FAILED(rv)) return rv;
+        nsCOMPtr<nsIChannel> channel;
+        rv = NS_NewChannel(getter_AddRefs(channel),
+                           mURL,
+                           nsContentUtils::GetSystemPrincipal(),
+                           nsILoadInfo::SEC_NORMAL,
+                           nsIContentPolicy::TYPE_OTHER,
+                           nullptr, // aLoadGroup
+                           this);   // aCallbacks
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = channel->AsyncOpen(this, nullptr);
+        NS_ENSURE_SUCCESS(rv, rv);
 
         // So we don't try to issue two asynchronous loads at once.
         mLoadState = eLoadState_Pending;
     }
 
     return NS_OK;
 }