Bug 1462357 - remove the channel and socket interface id r=bagder,baku
authorPatrick McManus <mcmanus@ducksong.com>
Wed, 16 May 2018 16:05:03 -0400
changeset 419139 610da3d903bec2983d0e56d051d7d915a6bb86bb
parent 419138 723ce0f95ab28a3ab4a8207ecbd15e7bcd181e9e
child 419140 80cc5997d8cce2ab82bc2695a7f8f69356f595d0
push id34028
push usershindli@mozilla.com
push dateMon, 21 May 2018 21:28:55 +0000
treeherdermozilla-central@c8b0df341f44 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbagder, baku
bugs1462357
milestone62.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 1462357 - remove the channel and socket interface id r=bagder,baku the id was a b2g feature only settable via chrome privd xhr and is no longer active in the code base MozReview-Commit-ID: 84GPNvhvjNb
dom/webidl/XMLHttpRequest.webidl
dom/xhr/XMLHttpRequest.h
dom/xhr/XMLHttpRequestMainThread.cpp
dom/xhr/XMLHttpRequestMainThread.h
dom/xhr/XMLHttpRequestWorker.h
netwerk/base/nsISocketTransport.idl
netwerk/base/nsNetUtil.h
netwerk/base/nsSocketTransport2.cpp
netwerk/base/nsSocketTransport2.h
netwerk/dns/ChildDNSService.cpp
netwerk/dns/ChildDNSService.h
netwerk/dns/DNSRequestChild.cpp
netwerk/dns/DNSRequestChild.h
netwerk/dns/DNSRequestParent.cpp
netwerk/dns/DNSRequestParent.h
netwerk/dns/GetAddrInfo.cpp
netwerk/dns/GetAddrInfo.h
netwerk/dns/PDNSRequest.ipdl
netwerk/dns/TRR.cpp
netwerk/dns/nsDNSService2.cpp
netwerk/dns/nsHostResolver.cpp
netwerk/dns/nsHostResolver.h
netwerk/dns/nsIDNSService.idl
netwerk/ipc/NeckoChild.cpp
netwerk/ipc/NeckoChild.h
netwerk/ipc/NeckoParent.cpp
netwerk/ipc/NeckoParent.h
netwerk/ipc/PNecko.ipdl
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/protocol/http/HttpBaseChannel.h
netwerk/protocol/http/TunnelUtils.cpp
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/http/nsHttpConnectionInfo.cpp
netwerk/protocol/http/nsHttpConnectionInfo.h
netwerk/protocol/http/nsHttpConnectionMgr.cpp
netwerk/protocol/http/nsIHttpChannelInternal.idl
netwerk/test/unit/test_dns_per_interface.js
netwerk/test/unit/xpcshell.ini
netwerk/test/unit_ipc/test_dns_per_interface_wrap.js
netwerk/test/unit_ipc/xpcshell.ini
--- a/dom/webidl/XMLHttpRequest.webidl
+++ b/dom/webidl/XMLHttpRequest.webidl
@@ -121,21 +121,16 @@ interface XMLHttpRequest : XMLHttpReques
   // Mozilla-specific stuff
 
   [ChromeOnly, SetterThrows]
   attribute boolean mozBackgroundRequest;
 
   [ChromeOnly, Exposed=Window]
   readonly attribute MozChannel? channel;
 
-  // A platform-specific identifer to represent the network interface 
-  // which the HTTP request would occur on.
-  [ChromeOnly, Exposed=Window]
-  attribute ByteString? networkInterfaceId;
-
   [Throws, ChromeOnly, Exposed=Window]
   any getInterface(IID iid);
 
   [ChromeOnly, Exposed=Window]
   void setOriginAttributes(optional OriginAttributesDictionary originAttributes);
 
   [ChromeOnly, Throws]
   void sendInputStream(InputStream body);
--- a/dom/xhr/XMLHttpRequest.h
+++ b/dom/xhr/XMLHttpRequest.h
@@ -127,22 +127,16 @@ public:
   MozBackgroundRequest() const = 0;
 
   virtual void
   SetMozBackgroundRequest(bool aMozBackgroundRequest, ErrorResult& aRv) = 0;
 
   virtual nsIChannel*
   GetChannel() const = 0;
 
-  virtual void
-  GetNetworkInterfaceId(nsACString& aId) const = 0;
-
-  virtual void
-  SetNetworkInterfaceId(const nsACString& aId) = 0;
-
   // We need a GetInterface callable from JS for chrome JS
   virtual void
   GetInterface(JSContext* aCx, nsIJSID* aIID,
                JS::MutableHandle<JS::Value> aRetval,
                ErrorResult& aRv) = 0;
 
   virtual void
   SetOriginAttributes(const mozilla::dom::OriginAttributesDictionary& aAttrs) = 0;
--- a/dom/xhr/XMLHttpRequestMainThread.cpp
+++ b/dom/xhr/XMLHttpRequestMainThread.cpp
@@ -1534,30 +1534,16 @@ XMLHttpRequestMainThread::SetOriginAttri
 
   nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
   MOZ_ASSERT(loadInfo);
   if (loadInfo) {
     loadInfo->SetOriginAttributes(attrs);
   }
 }
 
-void
-XMLHttpRequestMainThread::PopulateNetworkInterfaceId()
-{
-  if (mNetworkInterfaceId.IsEmpty()) {
-    return;
-  }
-  nsCOMPtr<nsIHttpChannelInternal> channel(do_QueryInterface(mChannel));
-  if (!channel) {
-    return;
-  }
-  DebugOnly<nsresult> rv = channel->SetNetworkInterfaceId(mNetworkInterfaceId);
-  MOZ_ASSERT(NS_SUCCEEDED(rv));
-}
-
 /*
  * "Copy" from a stream.
  */
 nsresult
 XMLHttpRequestMainThread::StreamReaderFunc(nsIInputStream* in,
                                            void* closure,
                                            const char* fromRawSegment,
                                            uint32_t toOffset,
@@ -2784,18 +2770,16 @@ XMLHttpRequestMainThread::SendInternal(c
   // If open() failed to create the channel, then throw a network error
   // as per spec. We really should create the channel here in send(), but
   // we have internal code relying on the channel being created in open().
   if (!mChannel) {
     mFlagSend = true; // so CloseRequestWithError sets us to DONE.
     return MaybeSilentSendFailure(NS_ERROR_DOM_NETWORK_ERR);
   }
 
-  PopulateNetworkInterfaceId();
-
   // XXX We should probably send a warning to the JS console
   //     if there are no event listeners set and we are doing
   //     an asynchronous call.
 
   mUploadTransferred = 0;
   mUploadTotal = 0;
   // By default we don't have any upload, so mark upload complete.
   mUploadComplete = true;
--- a/dom/xhr/XMLHttpRequestMainThread.h
+++ b/dom/xhr/XMLHttpRequestMainThread.h
@@ -301,21 +301,16 @@ private:
   virtual ~XMLHttpRequestMainThread();
 
   nsresult MaybeSilentSendFailure(nsresult aRv);
   nsresult SendInternal(const BodyExtractorBase* aBody);
 
   bool IsCrossSiteCORSRequest() const;
   bool IsDeniedCrossSiteCORSRequest();
 
-  // Tell our channel what network interface ID we were told to use.
-  // If it's an HTTP channel and we were told to use a non-default
-  // interface ID.
-  void PopulateNetworkInterfaceId();
-
   void UnsuppressEventHandlingAndResume();
 
   // Check pref "dom.mapped_arraybuffer.enabled" to make sure ArrayBuffer is
   // supported.
   static bool IsMappedArrayBufferEnabled();
 
   // Check pref "dom.xhr.lowercase_header.enabled" to make sure lowercased
   // response header is supported.
@@ -437,28 +432,16 @@ public:
   MozSystem() const override;
 
   virtual nsIChannel*
   GetChannel() const override
   {
     return mChannel;
   }
 
-  virtual void
-  GetNetworkInterfaceId(nsACString& aId) const override
-  {
-    aId = mNetworkInterfaceId;
-  }
-
-  virtual void
-  SetNetworkInterfaceId(const nsACString& aId) override
-  {
-    mNetworkInterfaceId = aId;
-  }
-
   // We need a GetInterface callable from JS for chrome JS
   virtual void
   GetInterface(JSContext* aCx, nsIJSID* aIID,
                JS::MutableHandle<JS::Value> aRetval,
                ErrorResult& aRv) override;
 
   // This fires a trusted readystatechange event, which is not cancelable and
   // doesn't bubble.
@@ -736,20 +719,16 @@ protected:
   // Ordering of OnProgress and OnDataAvailable is undefined.
   int64_t mLoadTransferred;
   nsCOMPtr<nsITimer> mProgressNotifier;
   void HandleProgressTimerCallback();
 
   bool mIsSystem;
   bool mIsAnon;
 
-  // A platform-specific identifer to represent the network interface
-  // that this request is associated with.
-  nsCString mNetworkInterfaceId;
-
   /**
    * Close the XMLHttpRequest's channels.
    */
   void CloseRequest();
 
   void TerminateOngoingFetch();
 
   /**
--- a/dom/xhr/XMLHttpRequestWorker.h
+++ b/dom/xhr/XMLHttpRequestWorker.h
@@ -143,28 +143,16 @@ public:
   SetMozBackgroundRequest(bool aBackgroundRequest, ErrorResult& aRv) override;
 
   virtual nsIChannel*
   GetChannel() const override
   {
     MOZ_CRASH("This method cannot be called on workers.");
   }
 
-  virtual void
-  GetNetworkInterfaceId(nsACString& aId) const override
-  {
-    MOZ_CRASH("This method cannot be called on workers.");
-  }
-
-  virtual void
-  SetNetworkInterfaceId(const nsACString& aId) override
-  {
-    MOZ_CRASH("This method cannot be called on workers.");
-  }
-
   virtual XMLHttpRequestUpload*
   GetUpload(ErrorResult& aRv) override;
 
   virtual void
   Send(JSContext* aCx,
        const Nullable<DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString>& aData,
        ErrorResult& aRv) override;
 
--- a/netwerk/base/nsISocketTransport.idl
+++ b/netwerk/base/nsISocketTransport.idl
@@ -61,23 +61,16 @@ interface nsISocketTransport : nsITransp
 
     [noscript, nostdcall, binaryname(GetOriginAttributes)]
     OriginAttributes binaryGetOriginAttributes();
 
     [noscript, nostdcall, binaryname(SetOriginAttributes)]
     void binarySetOriginAttributes(in const_OriginAttributesRef aOriginAttrs);
 
     /**
-     * The platform-specific network interface id that this socket
-     * associated with. Note that this attribute can be only accessed
-     * in the socket thread.
-     */
-    attribute ACString networkInterfaceId;
-
-    /**
      * Returns the IP address of the socket connection peer. This
      * attribute is defined only once a connection has been established.
      */
     [noscript] NetAddr getPeerAddr();
 
     /**
      * Returns the IP address of the initiating end. This attribute
      * is defined only once a connection has been established.
--- a/netwerk/base/nsNetUtil.h
+++ b/netwerk/base/nsNetUtil.h
@@ -34,17 +34,16 @@ class nsIChannelPolicy;
 class nsIDownloadObserver;
 class nsIEventTarget;
 class nsIFileProtocolHandler;
 class nsIFileStream;
 class nsIInputStream;
 class nsIInputStreamPump;
 class nsIInterfaceRequestor;
 class nsINestedURI;
-class nsINetworkInterface;
 class nsIOutputStream;
 class nsIParentChannel;
 class nsIPersistentProperties;
 class nsIProxyInfo;
 class nsIRequestObserver;
 class nsIStreamListener;
 class nsIStreamLoader;
 class nsIStreamLoaderObserver;
--- a/netwerk/base/nsSocketTransport2.cpp
+++ b/netwerk/base/nsSocketTransport2.cpp
@@ -1111,19 +1111,19 @@ nsSocketTransport::ResolveHost()
                  "Setting both RESOLVE_DISABLE_IPV6 and RESOLVE_DISABLE_IPV4");
 
     SendStatus(NS_NET_STATUS_RESOLVING_HOST);
 
     if (!SocketHost().Equals(mOriginHost)) {
         SOCKET_LOG(("nsSocketTransport %p origin %s doing dns for %s\n",
                     this, mOriginHost.get(), SocketHost().get()));
     }
-    rv = dns->AsyncResolveExtendedNative(SocketHost(), dnsFlags, mNetworkInterfaceId,
-                                         this, nullptr, mOriginAttributes,
-                                         getter_AddRefs(mDNSRequest));
+    rv = dns->AsyncResolveNative(SocketHost(), dnsFlags,
+                                 this, nullptr, mOriginAttributes,
+                                 getter_AddRefs(mDNSRequest));
     if (NS_SUCCEEDED(rv)) {
         SOCKET_LOG(("  advancing to STATE_RESOLVING\n"));
         mState = STATE_RESOLVING;
     }
     return rv;
 }
 
 nsresult
@@ -2670,32 +2670,16 @@ nsSocketTransport::GetHost(nsACString &h
 NS_IMETHODIMP
 nsSocketTransport::GetPort(int32_t *port)
 {
     *port = (int32_t) SocketPort();
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsSocketTransport::GetNetworkInterfaceId(nsACString &aNetworkInterfaceId)
-{
-    MOZ_ASSERT(OnSocketThread(), "not on socket thread");
-    aNetworkInterfaceId = mNetworkInterfaceId;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsSocketTransport::SetNetworkInterfaceId(const nsACString &aNetworkInterfaceId)
-{
-    MOZ_ASSERT(OnSocketThread(), "not on socket thread");
-    mNetworkInterfaceId = aNetworkInterfaceId;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
 nsSocketTransport::GetScriptableOriginAttributes(JSContext* aCx,
     JS::MutableHandle<JS::Value> aOriginAttributes)
 {
     if (NS_WARN_IF(!ToJSValue(aCx, mOriginAttributes, aOriginAttributes))) {
         return NS_ERROR_FAILURE;
     }
     return NS_OK;
 }
--- a/netwerk/base/nsSocketTransport2.h
+++ b/netwerk/base/nsSocketTransport2.h
@@ -323,20 +323,16 @@ private:
     //-------------------------------------------------------------------------
 
     // socket state vars:
     uint32_t     mState;     // STATE_??? flags
     bool mAttached;
     bool mInputClosed;
     bool mOutputClosed;
 
-    // The platform-specific network interface id that this socket
-    // associated with.
-    nsCString mNetworkInterfaceId;
-
     // this flag is used to determine if the results of a host lookup arrive
     // recursively or not.  this flag is not protected by any lock.
     bool mResolving;
 
     nsCOMPtr<nsICancelable> mDNSRequest;
     nsCOMPtr<nsIDNSRecord>  mDNSRecord;
 
     // mNetAddr/mSelfAddr is valid from GetPeerAddr()/GetSelfAddr() once we have
--- a/netwerk/dns/ChildDNSService.cpp
+++ b/netwerk/dns/ChildDNSService.cpp
@@ -52,30 +52,26 @@ ChildDNSService::ChildDNSService()
 {
   MOZ_ASSERT(IsNeckoChild());
 }
 
 void
 ChildDNSService::GetDNSRecordHashKey(const nsACString &aHost,
                                      const OriginAttributes &aOriginAttributes,
                                      uint32_t aFlags,
-                                     const nsACString &aNetworkInterface,
                                      nsIDNSListener* aListener,
                                      nsACString &aHashKey)
 {
   aHashKey.Assign(aHost);
 
   nsAutoCString originSuffix;
   aOriginAttributes.CreateSuffix(originSuffix);
   aHashKey.Assign(originSuffix);
 
   aHashKey.AppendInt(aFlags);
-  if (!aNetworkInterface.IsEmpty()) {
-    aHashKey.Append(aNetworkInterface);
-  }
   aHashKey.AppendPrintf("%p", aListener);
 }
 
 //-----------------------------------------------------------------------------
 // ChildDNSService::nsIDNSService
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
@@ -92,68 +88,29 @@ ChildDNSService::AsyncResolve(const nsAC
 
   if (aArgc == 1) {
     if (!aOriginAttributes.isObject() ||
         !attrs.Init(aCx, aOriginAttributes)) {
       return NS_ERROR_INVALID_ARG;
     }
   }
 
-  return AsyncResolveExtendedNative(hostname, flags, EmptyCString(),
-                                    listener, target_, attrs,
-                                    result);
+  return AsyncResolveNative(hostname, flags,
+                            listener, target_, attrs,
+                            result);
 }
 
 NS_IMETHODIMP
 ChildDNSService::AsyncResolveNative(const nsACString        &hostname,
                                     uint32_t                 flags,
                                     nsIDNSListener          *listener,
                                     nsIEventTarget          *target_,
                                     const OriginAttributes  &aOriginAttributes,
                                     nsICancelable          **result)
 {
-  return AsyncResolveExtendedNative(hostname, flags, EmptyCString(),
-                                    listener, target_, aOriginAttributes,
-                                    result);
-}
-
-NS_IMETHODIMP
-ChildDNSService::AsyncResolveExtended(const nsACString  &aHostname,
-                                      uint32_t           flags,
-                                      const nsACString  &aNetworkInterface,
-                                      nsIDNSListener    *listener,
-                                      nsIEventTarget    *target_,
-                                      JS::HandleValue    aOriginAttributes,
-                                      JSContext         *aCx,
-                                      uint8_t            aArgc,
-                                      nsICancelable    **result)
-{
-    OriginAttributes attrs;
-
-    if (aArgc == 1) {
-      if (!aOriginAttributes.isObject() ||
-          !attrs.Init(aCx, aOriginAttributes)) {
-          return NS_ERROR_INVALID_ARG;
-      }
-    }
-
-    return AsyncResolveExtendedNative(aHostname, flags, aNetworkInterface,
-                                      listener, target_, attrs,
-                                      result);
-}
-
-NS_IMETHODIMP
-ChildDNSService::AsyncResolveExtendedNative(const nsACString        &hostname,
-                                            uint32_t                 flags,
-                                            const nsACString        &aNetworkInterface,
-                                            nsIDNSListener          *listener,
-                                            nsIEventTarget          *target_,
-                                            const OriginAttributes  &aOriginAttributes,
-                                            nsICancelable          **result)
-{
   NS_ENSURE_TRUE(gNeckoChild != nullptr, NS_ERROR_FAILURE);
 
   if (mDisablePrefetch && (flags & RESOLVE_SPECULATE)) {
     return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
   }
 
   // We need original flags for the pending requests hash.
   uint32_t originalFlags = flags;
@@ -178,23 +135,22 @@ ChildDNSService::AsyncResolveExtendedNat
     // (or in parent in nsDNSService.cpp) but doesn't hurt.
     listener = new DNSListenerProxy(listener, target);
   }
 
   RefPtr<DNSRequestChild> childReq =
     new DNSRequestChild(hostname,
                         aOriginAttributes,
                         flags,
-                        aNetworkInterface,
                         listener, target);
 
   {
     MutexAutoLock lock(mPendingRequestsLock);
     nsCString key;
-    GetDNSRecordHashKey(hostname, aOriginAttributes, originalFlags, aNetworkInterface,
+    GetDNSRecordHashKey(hostname, aOriginAttributes, originalFlags,
                         originalListener, key);
     nsTArray<RefPtr<DNSRequestChild>> *hashEntry;
     if (mPendingRequests.Get(key, &hashEntry)) {
       hashEntry->AppendElement(childReq);
     } else {
       hashEntry = new nsTArray<RefPtr<DNSRequestChild>>();
       hashEntry->AppendElement(childReq);
       mPendingRequests.Put(key, hashEntry);
@@ -220,71 +176,36 @@ ChildDNSService::CancelAsyncResolve(cons
 
   if (aArgc == 1) {
     if (!aOriginAttributes.isObject() ||
         !attrs.Init(aCx, aOriginAttributes)) {
         return NS_ERROR_INVALID_ARG;
     }
   }
 
-  return CancelAsyncResolveExtendedNative(aHostname, aFlags, EmptyCString(),
-                                          aListener, aReason, attrs);
+  return CancelAsyncResolveNative(aHostname, aFlags,
+                                  aListener, aReason, attrs);
 }
 
 NS_IMETHODIMP
 ChildDNSService::CancelAsyncResolveNative(const nsACString       &aHostname,
                                           uint32_t                aFlags,
                                           nsIDNSListener         *aListener,
                                           nsresult                aReason,
                                           const OriginAttributes &aOriginAttributes)
 {
-  return CancelAsyncResolveExtendedNative(aHostname, aFlags, EmptyCString(),
-                                          aListener, aReason, aOriginAttributes);
-}
-
-NS_IMETHODIMP
-ChildDNSService::CancelAsyncResolveExtended(const nsACString &aHostname,
-                                            uint32_t          aFlags,
-                                            const nsACString &aNetworkInterface,
-                                            nsIDNSListener   *aListener,
-                                            nsresult          aReason,
-                                            JS::HandleValue   aOriginAttributes,
-                                            JSContext        *aCx,
-                                            uint8_t           aArgc)
-{
-  OriginAttributes attrs;
-
-  if (aArgc == 1) {
-    if (!aOriginAttributes.isObject() ||
-        !attrs.Init(aCx, aOriginAttributes)) {
-        return NS_ERROR_INVALID_ARG;
-    }
-  }
-
-  return CancelAsyncResolveExtendedNative(aHostname, aFlags, aNetworkInterface,
-                                          aListener, aReason, attrs);
-}
-
-NS_IMETHODIMP
-ChildDNSService::CancelAsyncResolveExtendedNative(const nsACString &aHostname,
-                                                  uint32_t          aFlags,
-                                                  const nsACString &aNetworkInterface,
-                                                  nsIDNSListener   *aListener,
-                                                  nsresult          aReason,
-                                                  const OriginAttributes &aOriginAttributes)
-{
   if (mDisablePrefetch && (aFlags & RESOLVE_SPECULATE)) {
     return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
   }
 
   MutexAutoLock lock(mPendingRequestsLock);
   nsTArray<RefPtr<DNSRequestChild>> *hashEntry;
   nsCString key;
   GetDNSRecordHashKey(aHostname, aOriginAttributes, aFlags,
-                      aNetworkInterface, aListener, key);
+                      aListener, key);
   if (mPendingRequests.Get(key, &hashEntry)) {
     // We cancel just one.
     hashEntry->ElementAt(0)->Cancel(aReason);
   }
 
   return NS_OK;
 }
 
@@ -340,17 +261,17 @@ ChildDNSService::NotifyRequestDone(DNSRe
       return;
     }
   }
 
   MutexAutoLock lock(mPendingRequestsLock);
 
   nsCString key;
   GetDNSRecordHashKey(aDnsRequest->mHost, aDnsRequest->mOriginAttributes, originalFlags,
-                      aDnsRequest->mNetworkInterface, originalListener, key);
+                      originalListener, key);
 
   nsTArray<RefPtr<DNSRequestChild>> *hashEntry;
 
   if (mPendingRequests.Get(key, &hashEntry)) {
     int idx;
     if ((idx = hashEntry->IndexOf(aDnsRequest))) {
       hashEntry->RemoveElementAt(idx);
       if (hashEntry->IsEmpty()) {
--- a/netwerk/dns/ChildDNSService.h
+++ b/netwerk/dns/ChildDNSService.h
@@ -38,17 +38,16 @@ public:
 
   bool GetOffline() const;
 private:
   virtual ~ChildDNSService() = default;
 
   void MOZ_ALWAYS_INLINE GetDNSRecordHashKey(const nsACString &aHost,
                                              const OriginAttributes &aOriginAttributes,
                                              uint32_t aFlags,
-                                             const nsACString &aNetworkInterface,
                                              nsIDNSListener* aListener,
                                              nsACString &aHashKey);
 
   bool mFirstTime;
   bool mDisablePrefetch;
 
   // We need to remember pending dns requests to be able to cancel them.
   nsClassHashtable<nsCStringHashKey, nsTArray<RefPtr<DNSRequestChild>>> mPendingRequests;
--- a/netwerk/dns/DNSRequestChild.cpp
+++ b/netwerk/dns/DNSRequestChild.cpp
@@ -175,43 +175,40 @@ public:
 
   NS_IMETHOD Run() override
   {
     if (mDnsRequest->mIPCOpen) {
       // Send request to Parent process.
       mDnsRequest->SendCancelDNSRequest(mDnsRequest->mHost,
                                         mDnsRequest->mOriginAttributes,
                                         mDnsRequest->mFlags,
-                                        mDnsRequest->mNetworkInterface,
                                         mReasonForCancel);
     }
     return NS_OK;
   }
 private:
   RefPtr<DNSRequestChild> mDnsRequest;
   nsresult mReasonForCancel;
 };
 
 //-----------------------------------------------------------------------------
 // DNSRequestChild
 //-----------------------------------------------------------------------------
 
 DNSRequestChild::DNSRequestChild(const nsACString& aHost,
                                  const OriginAttributes& aOriginAttributes,
                                  const uint32_t& aFlags,
-                                 const nsACString& aNetworkInterface,
                                  nsIDNSListener *aListener,
                                  nsIEventTarget *target)
   : mListener(aListener)
   , mTarget(target)
   , mResultStatus(NS_OK)
   , mHost(aHost)
   , mOriginAttributes(aOriginAttributes)
   , mFlags(aFlags)
-  , mNetworkInterface(aNetworkInterface)
   , mIPCOpen(false)
 {
 }
 
 void
 DNSRequestChild::StartRequest()
 {
   // we can only do IPDL on the main thread
@@ -232,17 +229,17 @@ DNSRequestChild::StartRequest()
   mozilla::dom::ContentChild* cc =
     static_cast<mozilla::dom::ContentChild*>(gNeckoChild->Manager());
   if (cc->IsShuttingDown()) {
     return;
   }
 
   // Send request to Parent process.
   gNeckoChild->SendPDNSRequestConstructor(this, mHost, mOriginAttributes,
-                                          mFlags, mNetworkInterface);
+                                          mFlags);
   mIPCOpen = true;
 
   // IPDL holds a reference until IPDL channel gets destroyed
   AddIPDLReference();
 }
 
 void
 DNSRequestChild::CallOnLookupComplete()
--- a/netwerk/dns/DNSRequestChild.h
+++ b/netwerk/dns/DNSRequestChild.h
@@ -22,17 +22,16 @@ class DNSRequestChild final
 {
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSICANCELABLE
 
   DNSRequestChild(const nsACString& aHost,
                   const OriginAttributes& aOriginAttributes,
                   const uint32_t& aFlags,
-                  const nsACString& aNetworkInterface,
                   nsIDNSListener *aListener, nsIEventTarget *target);
 
   void AddIPDLReference() {
     AddRef();
   }
   void ReleaseIPDLReference();
 
   // Sends IPDL request to parent
@@ -49,16 +48,15 @@ protected:
 
   nsCOMPtr<nsIDNSListener>  mListener;
   nsCOMPtr<nsIEventTarget>  mTarget;
   nsCOMPtr<nsIDNSRecord>    mResultRecord;
   nsresult                  mResultStatus;
   nsCString                 mHost;
   const OriginAttributes    mOriginAttributes;
   uint16_t                  mFlags;
-  nsCString                 mNetworkInterface;
   bool                      mIPCOpen;
 };
 
 } // namespace net
 } // namespace mozilla
 
 #endif // mozilla_net_DNSRequestChild_h
--- a/netwerk/dns/DNSRequestParent.cpp
+++ b/netwerk/dns/DNSRequestParent.cpp
@@ -24,51 +24,47 @@ DNSRequestParent::DNSRequestParent()
   , mIPCClosed(false)
 {
 
 }
 
 void
 DNSRequestParent::DoAsyncResolve(const nsACString &hostname,
                                  const OriginAttributes &originAttributes,
-                                 uint32_t flags,
-                                 const nsACString &networkInterface)
+                                 uint32_t flags)
 {
   nsresult rv;
   mFlags = flags;
   nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID, &rv);
   if (NS_SUCCEEDED(rv)) {
     nsCOMPtr<nsIEventTarget> main = GetMainThreadEventTarget();
     nsCOMPtr<nsICancelable> unused;
-    rv = dns->AsyncResolveExtendedNative(hostname, flags,
-                                         networkInterface, this,
-                                         main, originAttributes,
-                                         getter_AddRefs(unused));
+    rv = dns->AsyncResolveNative(hostname, flags, this,
+                                 main, originAttributes,
+                                 getter_AddRefs(unused));
   }
 
   if (NS_FAILED(rv) && !mIPCClosed) {
     mIPCClosed = true;
     Unused << SendLookupCompleted(DNSRequestResponse(rv));
   }
 }
 
 mozilla::ipc::IPCResult
 DNSRequestParent::RecvCancelDNSRequest(const nsCString& hostName,
                                        const OriginAttributes& originAttributes,
                                        const uint32_t& flags,
-                                       const nsCString& networkInterface,
                                        const nsresult& reason)
 {
   nsresult rv;
   nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID, &rv);
   if (NS_SUCCEEDED(rv)) {
-    rv = dns->CancelAsyncResolveExtendedNative(hostName, flags,
-                                               networkInterface,
-                                               this, reason,
-                                               originAttributes);
+    rv = dns->CancelAsyncResolveNative(hostName, flags,
+                                       this, reason,
+                                       originAttributes);
   }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 DNSRequestParent::Recv__delete__()
 {
   mIPCClosed = true;
--- a/netwerk/dns/DNSRequestParent.h
+++ b/netwerk/dns/DNSRequestParent.h
@@ -21,25 +21,23 @@ class DNSRequestParent
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIDNSLISTENER
 
   DNSRequestParent();
 
   void DoAsyncResolve(const nsACString  &hostname,
                       const OriginAttributes &originAttributes,
-                      uint32_t flags,
-                      const nsACString  &networkInterface);
+                      uint32_t flags);
 
   // Pass args here rather than storing them in the parent; they are only
   // needed if the request is to be canceled.
   mozilla::ipc::IPCResult RecvCancelDNSRequest(const nsCString& hostName,
                                                const OriginAttributes& originAttributes,
                                                const uint32_t& flags,
-                                               const nsCString& networkInterface,
                                                const nsresult& reason) override;
   mozilla::ipc::IPCResult Recv__delete__() override;
 
 protected:
   virtual void ActorDestroy(ActorDestroyReason why) override;
 private:
   virtual ~DNSRequestParent() = default;
 
--- a/netwerk/dns/GetAddrInfo.cpp
+++ b/netwerk/dns/GetAddrInfo.cpp
@@ -245,18 +245,17 @@ static MOZ_ALWAYS_INLINE nsresult
 #endif
 
 ////////////////////////////////////
 // PORTABLE RUNTIME IMPLEMENTATION//
 ////////////////////////////////////
 
 static MOZ_ALWAYS_INLINE nsresult
 _GetAddrInfo_Portable(const char* aCanonHost, uint16_t aAddressFamily,
-                      uint16_t aFlags, const char* aNetworkInterface,
-                      AddrInfo** aAddrInfo)
+                      uint16_t aFlags, AddrInfo** aAddrInfo)
 {
   MOZ_ASSERT(aCanonHost);
   MOZ_ASSERT(aAddrInfo);
 
   // We accept the same aFlags that nsHostResolver::ResolveHost accepts, but we
   // need to translate the aFlags into a form that PR_GetAddrInfoByName
   // accepts.
   int prFlags = PR_AI_ADDRCONFIG;
@@ -317,17 +316,17 @@ GetAddrInfoShutdown() {
   return _GetAddrInfoShutdown_Windows();
 #else
   return NS_OK;
 #endif
 }
 
 nsresult
 GetAddrInfo(const char* aHost, uint16_t aAddressFamily, uint16_t aFlags,
-            const char* aNetworkInterface, AddrInfo** aAddrInfo, bool aGetTtl)
+            AddrInfo** aAddrInfo, bool aGetTtl)
 {
   if (NS_WARN_IF(!aHost) || NS_WARN_IF(!aAddrInfo)) {
     return NS_ERROR_NULL_POINTER;
   }
 
 #ifdef DNSQUERY_AVAILABLE
   // The GetTTLData needs the canonical name to function properly
   if (aGetTtl) {
@@ -338,17 +337,17 @@ GetAddrInfo(const char* aHost, uint16_t 
   if (gNativeIsLocalhost) {
     // pretend we use the given host but use IPv4 localhost instead!
     aHost = "localhost";
     aAddressFamily = PR_AF_INET;
   }
 
   *aAddrInfo = nullptr;
   nsresult rv = _GetAddrInfo_Portable(aHost, aAddressFamily, aFlags,
-                                      aNetworkInterface, aAddrInfo);
+                                      aAddrInfo);
 
 #ifdef DNSQUERY_AVAILABLE
   if (aGetTtl && NS_SUCCEEDED(rv)) {
     // Figure out the canonical name, or if that fails, just use the host name
     // we have.
     const char *name = nullptr;
     if (*aAddrInfo != nullptr && (*aAddrInfo)->mCanonicalName) {
       name = (*aAddrInfo)->mCanonicalName;
--- a/netwerk/dns/GetAddrInfo.h
+++ b/netwerk/dns/GetAddrInfo.h
@@ -33,17 +33,17 @@ class AddrInfo;
  *     hostname (PR_AI_NOCANONNAME will be ignored if the TTL is retrieved).
  * @param aAddrInfo[out] Will point to the results of the host lookup, or be
  *     null if the lookup failed.
  * @param aGetTtl[in] If true, the TTL will be retrieved if DNS provides the
  *     answers..
  */
 nsresult
 GetAddrInfo(const char* aHost, uint16_t aAddressFamily, uint16_t aFlags,
-            const char* aNetworkInterface, AddrInfo** aAddrInfo, bool aGetTtl);
+            AddrInfo** aAddrInfo, bool aGetTtl);
 
 /**
  * Initialize the GetAddrInfo module.
  *
  * GetAddrInfoShutdown() should be called for every time this function is
  * called.
  */
 nsresult
--- a/netwerk/dns/PDNSRequest.ipdl
+++ b/netwerk/dns/PDNSRequest.ipdl
@@ -21,18 +21,17 @@ async protocol PDNSRequest
   manager PNecko;
 
 parent:
   // constructor in PNecko takes AsyncResolve args that initialize request
 
   // Pass args here rather than storing them in the parent; they are only
   // needed if the request is to be canceled.
   async CancelDNSRequest(nsCString hostName, OriginAttributes originAttributes,
-                         uint32_t flags, nsCString networkInterface,
-                         nsresult reason);
+                         uint32_t flags, nsresult reason);
   async __delete__();
 
 child:
   async LookupCompleted(DNSRequestResponse reply);
 
 };
 
 } //namespace net
--- a/netwerk/dns/TRR.cpp
+++ b/netwerk/dns/TRR.cpp
@@ -391,17 +391,17 @@ TRR::ReceivePush(nsIHttpChannel *pushed,
     LOG(("TRR::ReceivePush failed to decode %s\n", mHost.get()));
     return NS_ERROR_UNEXPECTED;
   }
 
   RefPtr<nsHostRecord> hostRecord;
   nsresult rv;
   rv = mHostResolver->GetHostRecord(mHost.get(),
                                     pushedRec->flags, pushedRec->af,
-                                    pushedRec->pb, pushedRec->netInterface,
+                                    pushedRec->pb,
                                     pushedRec->originSuffix,
                                     getter_AddRefs(hostRecord));
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   rv = mHostResolver->TrrLookup_unlocked(hostRecord, this);
   if (NS_FAILED(rv)) {
--- a/netwerk/dns/nsDNSService2.cpp
+++ b/netwerk/dns/nsDNSService2.cpp
@@ -312,41 +312,39 @@ public:
     NS_DECL_THREADSAFE_ISUPPORTS
     NS_DECL_NSICANCELABLE
 
     nsDNSAsyncRequest(nsHostResolver   *res,
                       const nsACString &host,
                       const OriginAttributes &attrs,
                       nsIDNSListener   *listener,
                       uint16_t          flags,
-                      uint16_t          af,
-                      const nsACString &netInterface)
+                      uint16_t          af)
         : mResolver(res)
         , mHost(host)
         , mOriginAttributes(attrs)
         , mListener(listener)
         , mFlags(flags)
         , mAF(af)
-        , mNetworkInterface(netInterface) {}
+    { }
 
     void OnResolveHostComplete(nsHostResolver *, nsHostRecord *, nsresult) override;
     // Returns TRUE if the DNS listener arg is the same as the member listener
     // Used in Cancellations to remove DNS requests associated with a
     // particular hostname and nsIDNSListener
     bool EqualsAsyncListener(nsIDNSListener *aListener) override;
 
     size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const override;
 
     RefPtr<nsHostResolver> mResolver;
     nsCString                mHost; // hostname we're resolving
     const OriginAttributes   mOriginAttributes; // The originAttributes for this resolving
     nsCOMPtr<nsIDNSListener> mListener;
     uint16_t                 mFlags;
     uint16_t                 mAF;
-    nsCString                mNetworkInterface;
 private:
     virtual ~nsDNSAsyncRequest() = default;
 };
 
 NS_IMPL_ISUPPORTS(nsDNSAsyncRequest, nsICancelable)
 
 void
 nsDNSAsyncRequest::OnResolveHostComplete(nsHostResolver *resolver,
@@ -391,17 +389,17 @@ nsDNSAsyncRequest::SizeOfIncludingThis(M
     return n;
 }
 
 NS_IMETHODIMP
 nsDNSAsyncRequest::Cancel(nsresult reason)
 {
     NS_ENSURE_ARG(NS_FAILED(reason));
     mResolver->DetachCallback(mHost.get(), mOriginAttributes, mFlags, mAF,
-                              mNetworkInterface.get(), this, reason);
+                              this, reason);
     return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 
 class nsDNSSyncRequest
     : public nsResolveHostCallback
 {
@@ -805,68 +803,28 @@ nsDNSService::AsyncResolve(const nsACStr
 
     if (aArgc == 1) {
         if (!aOriginAttributes.isObject() ||
             !attrs.Init(aCx, aOriginAttributes)) {
             return NS_ERROR_INVALID_ARG;
         }
     }
 
-    return AsyncResolveExtendedNative(aHostname, flags, EmptyCString(),
-                                      listener, target_, attrs,
-                                      result);
+    return AsyncResolveNative(aHostname, flags, listener,
+                              target_, attrs, result);
 }
 
 NS_IMETHODIMP
 nsDNSService::AsyncResolveNative(const nsACString        &aHostname,
                                  uint32_t                 flags,
-                                 nsIDNSListener          *listener,
+                                 nsIDNSListener          *aListener,
                                  nsIEventTarget          *target_,
                                  const OriginAttributes  &aOriginAttributes,
                                  nsICancelable          **result)
 {
-    return AsyncResolveExtendedNative(aHostname, flags, EmptyCString(),
-                                      listener, target_, aOriginAttributes,
-                                      result);
-}
-
-NS_IMETHODIMP
-nsDNSService::AsyncResolveExtended(const nsACString  &aHostname,
-                                   uint32_t           flags,
-                                   const nsACString  &aNetworkInterface,
-                                   nsIDNSListener    *listener,
-                                   nsIEventTarget    *target_,
-                                   JS::HandleValue    aOriginAttributes,
-                                   JSContext         *aCx,
-                                   uint8_t           aArgc,
-                                   nsICancelable    **result)
-{
-    OriginAttributes attrs;
-
-    if (aArgc == 1) {
-        if (!aOriginAttributes.isObject() ||
-            !attrs.Init(aCx, aOriginAttributes)) {
-            return NS_ERROR_INVALID_ARG;
-        }
-    }
-
-    return AsyncResolveExtendedNative(aHostname, flags, aNetworkInterface,
-                                      listener, target_, attrs,
-                                      result);
-}
-
-NS_IMETHODIMP
-nsDNSService::AsyncResolveExtendedNative(const nsACString        &aHostname,
-                                         uint32_t                 flags,
-                                         const nsACString        &aNetworkInterface,
-                                         nsIDNSListener          *aListener,
-                                         nsIEventTarget          *target_,
-                                         const OriginAttributes  &aOriginAttributes,
-                                         nsICancelable          **result)
-{
     // grab reference to global host resolver and IDN service.  beware
     // simultaneous shutdown!!
     RefPtr<nsHostResolver> res;
     nsCOMPtr<nsIIDNService> idn;
     nsCOMPtr<nsIEventTarget> target = target_;
     nsCOMPtr<nsIDNSListener> listener = aListener;
     bool localDomain = false;
     {
@@ -907,23 +865,21 @@ nsDNSService::AsyncResolveExtendedNative
     if (target) {
         listener = new DNSListenerProxy(listener, target);
     }
 
     uint16_t af = GetAFForLookup(hostname, flags);
 
     MOZ_ASSERT(listener);
     RefPtr<nsDNSAsyncRequest> req =
-        new nsDNSAsyncRequest(res, hostname, aOriginAttributes, listener, flags, af,
-                              aNetworkInterface);
+        new nsDNSAsyncRequest(res, hostname, aOriginAttributes, listener, flags, af);
     if (!req)
         return NS_ERROR_OUT_OF_MEMORY;
 
-    rv = res->ResolveHost(req->mHost.get(), req->mOriginAttributes, flags, af,
-                          req->mNetworkInterface.get(), req);
+    rv = res->ResolveHost(req->mHost.get(), req->mOriginAttributes, flags, af, req);
     req.forget(result);
     return rv;
 }
 
 NS_IMETHODIMP
 nsDNSService::CancelAsyncResolve(const nsACString &aHostname,
                                  uint32_t          aFlags,
                                  nsIDNSListener   *aListener,
@@ -936,62 +892,27 @@ nsDNSService::CancelAsyncResolve(const n
 
     if (aArgc == 1) {
         if (!aOriginAttributes.isObject() ||
             !attrs.Init(aCx, aOriginAttributes)) {
             return NS_ERROR_INVALID_ARG;
         }
     }
 
-    return CancelAsyncResolveExtendedNative(aHostname, aFlags, EmptyCString(),
-                                            aListener, aReason, attrs);
+    return CancelAsyncResolveNative(aHostname, aFlags,
+                                    aListener, aReason, attrs);
 }
 
 NS_IMETHODIMP
 nsDNSService::CancelAsyncResolveNative(const nsACString       &aHostname,
                                        uint32_t                aFlags,
                                        nsIDNSListener         *aListener,
                                        nsresult                aReason,
                                        const OriginAttributes &aOriginAttributes)
 {
-    return CancelAsyncResolveExtendedNative(aHostname, aFlags, EmptyCString(),
-                                            aListener, aReason, aOriginAttributes);
-}
-
-NS_IMETHODIMP
-nsDNSService::CancelAsyncResolveExtended(const nsACString &aHostname,
-                                         uint32_t          aFlags,
-                                         const nsACString &aNetworkInterface,
-                                         nsIDNSListener   *aListener,
-                                         nsresult          aReason,
-                                         JS::HandleValue   aOriginAttributes,
-                                         JSContext        *aCx,
-                                         uint8_t           aArgc)
-{
-    OriginAttributes attrs;
-
-    if (aArgc == 1) {
-        if (!aOriginAttributes.isObject() ||
-            !attrs.Init(aCx, aOriginAttributes)) {
-            return NS_ERROR_INVALID_ARG;
-        }
-    }
-
-    return CancelAsyncResolveExtendedNative(aHostname, aFlags, aNetworkInterface,
-                                            aListener, aReason, attrs);
-}
-
-NS_IMETHODIMP
-nsDNSService::CancelAsyncResolveExtendedNative(const nsACString       &aHostname,
-                                               uint32_t                aFlags,
-                                               const nsACString       &aNetworkInterface,
-                                               nsIDNSListener         *aListener,
-                                               nsresult                aReason,
-                                               const OriginAttributes &aOriginAttributes)
-{
     // grab reference to global host resolver and IDN service.  beware
     // simultaneous shutdown!!
     RefPtr<nsHostResolver> res;
     nsCOMPtr<nsIIDNService> idn;
     bool localDomain = false;
     {
         MutexAutoLock lock(mLock);
 
@@ -1009,18 +930,17 @@ nsDNSService::CancelAsyncResolveExtended
     nsresult rv = PreprocessHostname(localDomain, aHostname, idn, hostname);
     if (NS_FAILED(rv)) {
         return rv;
     }
 
     uint16_t af = GetAFForLookup(hostname, aFlags);
 
     res->CancelAsyncRequest(hostname.get(), aOriginAttributes, aFlags, af,
-                            nsPromiseFlatCString(aNetworkInterface).get(), aListener,
-                            aReason);
+                            aListener, aReason);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDNSService::Resolve(const nsACString  &aHostname,
                       uint32_t           flags,
                       JS::HandleValue    aOriginAttributes,
                       JSContext         *aCx,
@@ -1109,17 +1029,17 @@ nsDNSService::ResolveInternal(const nsAC
     if (!mon)
         return NS_ERROR_OUT_OF_MEMORY;
 
     PR_EnterMonitor(mon);
     RefPtr<nsDNSSyncRequest> syncReq = new nsDNSSyncRequest(mon);
 
     uint16_t af = GetAFForLookup(hostname, flags);
 
-    rv = res->ResolveHost(hostname.get(), aOriginAttributes, flags, af, "", syncReq);
+    rv = res->ResolveHost(hostname.get(), aOriginAttributes, flags, af, syncReq);
     if (NS_SUCCEEDED(rv)) {
         // wait for result
         while (!syncReq->mDone) {
             PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
         }
 
         if (NS_FAILED(syncReq->mStatus)) {
             rv = syncReq->mStatus;
--- a/netwerk/dns/nsHostResolver.cpp
+++ b/netwerk/dns/nsHostResolver.cpp
@@ -76,20 +76,16 @@ static_assert(HighThreadThreshold <= MAX
 namespace mozilla {
 namespace net {
 LazyLogModule gHostResolverLog("nsHostResolver");
 #define LOG(args) MOZ_LOG(mozilla::net::gHostResolverLog, mozilla::LogLevel::Debug, args)
 #define LOG_ENABLED() MOZ_LOG_TEST(mozilla::net::gHostResolverLog, mozilla::LogLevel::Debug)
 }
 }
 
-#define LOG_HOST(host, interface) host,                                        \
-                 (interface && interface[0] != '\0') ? " on interface " : "",  \
-                 (interface && interface[0] != '\0') ? interface : ""
-
 //----------------------------------------------------------------------------
 
 #if defined(RES_RETRY_ON_FAILURE)
 
 // this class represents the resolver state for a given thread.  if we
 // encounter a lookup failure, then we can invoke the Reset method on an
 // instance of this class to reset the resolver (in case /etc/resolv.conf
 // for example changed).  this is mainly an issue on GNU systems since glibc
@@ -156,33 +152,31 @@ IsLowPriority(uint16_t flags)
 #define RES_KEY_FLAGS(_f) ((_f) & nsHostResolver::RES_CANON_NAME)
 
 bool
 nsHostKey::operator==(const nsHostKey& other) const
 {
     return host == other.host &&
         RES_KEY_FLAGS (flags) == RES_KEY_FLAGS(other.flags) &&
         af == other.af &&
-        netInterface == other.netInterface &&
         originSuffix == other.originSuffix;
 }
 
 PLDHashNumber
 nsHostKey::Hash() const
 {
     return AddToHash(HashString(host.get()), RES_KEY_FLAGS(flags), af,
-                     HashString(netInterface.get()), HashString(originSuffix.get()));
+                     HashString(originSuffix.get()));
 }
 
 size_t
 nsHostKey::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
     size_t n = 0;
     n += host.SizeOfExcludingThisIfUnshared(mallocSizeOf);
-    n += netInterface.SizeOfExcludingThisIfUnshared(mallocSizeOf);
     n += originSuffix.SizeOfExcludingThisIfUnshared(mallocSizeOf);
     return n;
 }
 
 nsHostRecord::nsHostRecord(const nsHostKey& key)
     : nsHostKey(key)
     , addr_info_lock("nsHostRecord.addr_info_lock")
     , addr_info_gencnt(0)
@@ -337,68 +331,66 @@ nsHostRecord::~nsHostRecord()
     Telemetry::Accumulate(Telemetry::DNS_BLACKLIST_COUNT, mBlacklistedCount);
     delete addr_info;
 }
 
 bool
 nsHostRecord::Blacklisted(NetAddr *aQuery)
 {
     // must call locked
-    LOG(("Checking blacklist for host [%s%s%s], host record [%p].\n",
-          LOG_HOST(host.get(), netInterface.get()), this));
+    LOG(("Checking blacklist for host [%s], host record [%p].\n",
+         host.get(), this));
 
     // skip the string conversion for the common case of no blacklist
     if (!mBlacklistedItems.Length()) {
         return false;
     }
 
     char buf[kIPv6CStrBufSize];
     if (!NetAddrToString(aQuery, buf, sizeof(buf))) {
         return false;
     }
     nsDependentCString strQuery(buf);
 
     for (uint32_t i = 0; i < mBlacklistedItems.Length(); i++) {
         if (mBlacklistedItems.ElementAt(i).Equals(strQuery)) {
-            LOG(("Address [%s] is blacklisted for host [%s%s%s].\n", buf,
-                 LOG_HOST(host.get(), netInterface.get())));
+            LOG(("Address [%s] is blacklisted for host [%s].\n", buf, host.get()));
             return true;
         }
     }
 
     return false;
 }
 
 void
 nsHostRecord::ReportUnusable(NetAddr *aAddress)
 {
     // must call locked
-    LOG(("Adding address to blacklist for host [%s%s%s], host record [%p]."
-         "used trr=%d\n", LOG_HOST(host.get(), netInterface.get()),
-         this, mTRRSuccess));
+    LOG(("Adding address to blacklist for host [%s], host record [%p]."
+         "used trr=%d\n", host.get(), this, mTRRSuccess));
 
     ++mBlacklistedCount;
 
     if (negative)
         mDoomed = true;
 
     char buf[kIPv6CStrBufSize];
     if (NetAddrToString(aAddress, buf, sizeof(buf))) {
         LOG(("Successfully adding address [%s] to blacklist for host "
-             "[%s%s%s].\n", buf, LOG_HOST(host.get(), netInterface.get())));
+             "[%s].\n", buf, host.get()));
         mBlacklistedItems.AppendElement(nsCString(buf));
     }
 }
 
 void
 nsHostRecord::ResetBlacklist()
 {
     // must call locked
-    LOG(("Resetting blacklist for host [%s%s%s], host record [%p].\n",
-         LOG_HOST(host.get(), netInterface.get()), this));
+    LOG(("Resetting blacklist for host [%s], host record [%p].\n",
+         host.get(), this));
     mBlacklistedItems.Clear();
 }
 
 nsHostRecord::ExpirationStatus
 nsHostRecord::CheckExpiration(const mozilla::TimeStamp& now) const {
     if (!mGraceStart.IsNull() && now >= mGraceStart
             && !mValidEnd.IsNull() && now < mValidEnd) {
         return nsHostRecord::EXP_GRACE;
@@ -712,23 +704,21 @@ nsHostResolver::Shutdown()
         NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
                              "Failed to shutdown GetAddrInfo");
     }
 }
 
 nsresult
 nsHostResolver::GetHostRecord(const char *host,
                               uint16_t flags, uint16_t af, bool pb,
-                              const nsCString &netInterface,
                               const nsCString &originSuffix,
                               nsHostRecord **result)
 {
     MutexAutoLock lock(mLock);
-    nsHostKey key(nsCString(host), flags, af, pb,
-                  netInterface, originSuffix);
+    nsHostKey key(nsCString(host), flags, af, pb, originSuffix);
 
     RefPtr<nsHostRecord>& entry = mRecordDB.GetOrInsert(key);
     if (!entry) {
         entry = new nsHostRecord(key);
     }
 
     RefPtr<nsHostRecord> rec = entry;
     if (rec->addr) {
@@ -741,23 +731,21 @@ nsHostResolver::GetHostRecord(const char
     return NS_OK;
 }
 
 nsresult
 nsHostResolver::ResolveHost(const char             *host,
                             const OriginAttributes &aOriginAttributes,
                             uint16_t                flags,
                             uint16_t                af,
-                            const char             *netInterface,
                             nsResolveHostCallback  *aCallback)
 {
     NS_ENSURE_TRUE(host && *host, NS_ERROR_UNEXPECTED);
-    NS_ENSURE_TRUE(netInterface, NS_ERROR_UNEXPECTED);
 
-    LOG(("Resolving host [%s%s%s]%s%s.\n", LOG_HOST(host, netInterface),
+    LOG(("Resolving host [%s]%s%s.\n", host,
          flags & RES_BYPASS_CACHE ? " - bypassing cache" : "",
          flags & RES_REFRESH_CACHE ? " - refresh cache" : ""));
 
     // ensure that we are working with a valid hostname before proceeding.  see
     // bug 304904 for details.
     if (!net_IsValidHostName(nsDependentCString(host)))
         return NS_ERROR_UNKNOWN_HOST;
 
@@ -784,41 +772,38 @@ nsHostResolver::ResolveHost(const char  
             // any pending callbacks, then add to pending callbacks queue,
             // and return.  otherwise, add ourselves as first pending
             // callback, and proceed to do the lookup.
             nsAutoCString originSuffix;
             aOriginAttributes.CreateSuffix(originSuffix);
 
             nsHostKey key(nsCString(host), flags, af,
                           (aOriginAttributes.mPrivateBrowsingId > 0),
-                          nsCString(netInterface),
                           originSuffix);
             RefPtr<nsHostRecord>& entry = mRecordDB.GetOrInsert(key);
             if (!entry) {
                 entry = new nsHostRecord(key);
             }
 
             RefPtr<nsHostRecord> rec = entry;
             MOZ_ASSERT(rec, "Record should not be null");
             if (!(flags & RES_BYPASS_CACHE) &&
                      rec->HasUsableResult(TimeStamp::NowLoRes(), flags)) {
-                LOG(("  Using cached record for host [%s%s%s].\n",
-                     LOG_HOST(host, netInterface)));
+                LOG(("  Using cached record for host [%s].\n", host));
                 // put reference to host record on stack...
                 result = rec;
                 Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2, METHOD_HIT);
 
                 // For entries that are in the grace period
                 // or all cached negative entries, use the cache but start a new
                 // lookup in the background
                 ConditionallyRefreshRecord(rec, host);
 
                 if (rec->negative) {
-                    LOG(("  Negative cache entry for host [%s%s%s].\n",
-                         LOG_HOST(host, netInterface)));
+                    LOG(("  Negative cache entry for host [%s].\n", host));
                     Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
                                           METHOD_NEGATIVE_HIT);
                     status = NS_ERROR_UNKNOWN_HOST;
                 }
             } else if (rec->addr) {
                 // if the host name is an IP address literal and has been parsed,
                 // go ahead and use it.
                 LOG(("  Using cached address for IP Literal [%s].\n", host));
@@ -837,47 +822,44 @@ nsHostResolver::ResolveHost(const char  
                 // put reference to host record on stack...
                 Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
                                       METHOD_LITERAL);
                 result = rec;
             } else if (mPendingCount >= MAX_NON_PRIORITY_REQUESTS &&
                        !IsHighPriority(flags) &&
                        !rec->mResolving) {
                 LOG(("  Lookup queue full: dropping %s priority request for "
-                     "host [%s%s%s].\n",
-                     IsMediumPriority(flags) ? "medium" : "low",
-                     LOG_HOST(host, netInterface)));
+                     "host [%s].\n",
+                     IsMediumPriority(flags) ? "medium" : "low", host));
                 Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
                                       METHOD_OVERFLOW);
                 // This is a lower priority request and we are swamped, so refuse it.
                 rv = NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
             } else if (flags & RES_OFFLINE) {
-                LOG(("  Offline request for host [%s%s%s]; ignoring.\n",
-                     LOG_HOST(host, netInterface)));
+                LOG(("  Offline request for host [%s]; ignoring.\n", host));
                 rv = NS_ERROR_OFFLINE;
             } else if (!rec->mResolving) {
                 // If this is an IPV4 or IPV6 specific request, check if there is
                 // an AF_UNSPEC entry we can use. Otherwise, hit the resolver...
 
                 if (!(flags & RES_BYPASS_CACHE) &&
                     ((af == PR_AF_INET) || (af == PR_AF_INET6))) {
                     // First, search for an entry with AF_UNSPEC
                     const nsHostKey unspecKey(nsCString(host), flags, PR_AF_UNSPEC,
                                               (aOriginAttributes.mPrivateBrowsingId > 0),
-                                              nsCString(netInterface), originSuffix);
+                                              originSuffix);
                     RefPtr<nsHostRecord> unspecRec = mRecordDB.Get(unspecKey);
 
                     TimeStamp now = TimeStamp::NowLoRes();
                     if (unspecRec && unspecRec->HasUsableResult(now, flags)) {
 
                         MOZ_ASSERT(unspecRec->addr_info || unspecRec->negative,
                                    "Entry should be resolved or negative.");
 
-                        LOG(("  Trying AF_UNSPEC entry for host [%s%s%s] af: %s.\n",
-                             LOG_HOST(host, netInterface),
+                        LOG(("  Trying AF_UNSPEC entry for host [%s] af: %s.\n", host,
                              (af == PR_AF_INET) ? "AF_INET" : "AF_INET6"));
 
                         // We need to lock in case any other thread is reading
                         // addr_info.
                         MutexAutoLock lock(rec->addr_info_lock);
 
                         // XXX: note that this actually leaks addr_info.
                         // For some reason, freeing the memory causes a crash in
@@ -919,61 +901,58 @@ nsHostResolver::ResolveHost(const char  
                                                   METHOD_HIT);
                             ConditionallyRefreshRecord(rec, host);
                         } else if (af == PR_AF_INET6) {
                             // For AF_INET6, a new lookup means another AF_UNSPEC
                             // lookup. We have already iterated through the
                             // AF_UNSPEC addresses, so we mark this record as
                             // negative.
                             LOG(("  No AF_INET6 in AF_UNSPEC entry: "
-                                 "host [%s%s%s] unknown host.",
-                                 LOG_HOST(host, netInterface)));
+                                 "host [%s] unknown host.", host));
                             result = rec;
                             rec->negative = true;
                             status = NS_ERROR_UNKNOWN_HOST;
                             Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
                                                   METHOD_NEGATIVE_HIT);
                         }
                     }
                 }
                 // If no valid address was found in the cache or this is an
                 // AF_UNSPEC request, then start a new lookup.
                 if (!result) {
-                    LOG(("  No usable address in cache for host [%s%s%s].",
-                         LOG_HOST(host, netInterface)));
+                    LOG(("  No usable address in cache for host [%s].", host));
 
                     if (flags & RES_REFRESH_CACHE) {
                         rec->Invalidate();
                     }
 
                     // Add callback to the list of pending callbacks.
                     rec->mCallbacks.insertBack(callback);
                     rec->flags = flags;
                     rv = NameLookup(rec);
                     Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
                                           METHOD_NETWORK_FIRST);
                     if (NS_FAILED(rv) && callback->isInList()) {
                         callback->remove();
                     } else {
-                        LOG(("  DNS lookup for host [%s%s%s] blocking "
+                        LOG(("  DNS lookup for host [%s] blocking "
                              "pending 'getaddrinfo' query: callback [%p]",
-                             LOG_HOST(host, netInterface), callback.get()));
+                             host, callback.get()));
                     }
                 }
             } else if (rec->mDidCallbacks) {
                 // record is still pending more (TRR) data; make the callback
                 // at once
                 result = rec;
                 // make it count as a hit
                 Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2, METHOD_HIT);
-                LOG(("  Host [%s%s%s] re-using early TRR resolve data\n",
-                     LOG_HOST(host, netInterface)));
+                LOG(("  Host [%s] re-using early TRR resolve data\n", host));
             } else {
-                LOG(("  Host [%s%s%s] is being resolved. Appending callback "
-                     "[%p].", LOG_HOST(host, netInterface), callback.get()));
+                LOG(("  Host [%s] is being resolved. Appending callback "
+                     "[%p].", host, callback.get()));
 
                 rec->mCallbacks.insertBack(callback);
                 if (rec->onQueue) {
                     Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
                                           METHOD_NETWORK_SHARED);
 
                     // Consider the case where we are on a pending queue of
                     // lower priority than the request is being made at.
@@ -1011,32 +990,30 @@ nsHostResolver::ResolveHost(const char  
     return rv;
 }
 
 void
 nsHostResolver::DetachCallback(const char             *host,
                                const OriginAttributes &aOriginAttributes,
                                uint16_t                flags,
                                uint16_t                af,
-                               const char             *netInterface,
                                nsResolveHostCallback  *aCallback,
                                nsresult                status)
 {
     RefPtr<nsHostRecord> rec;
     RefPtr<nsResolveHostCallback> callback(aCallback);
 
     {
         MutexAutoLock lock(mLock);
 
         nsAutoCString originSuffix;
         aOriginAttributes.CreateSuffix(originSuffix);
 
         nsHostKey key(nsCString(host), flags, af,
                       (aOriginAttributes.mPrivateBrowsingId > 0),
-                      nsCString(netInterface),
                       originSuffix);
         RefPtr<nsHostRecord> entry = mRecordDB.Get(key);
         if (entry) {
             // walk list looking for |callback|... we cannot assume
             // that it will be there!
 
             for (nsResolveHostCallback* c: entry->mCallbacks) {
                 if (c == callback) {
@@ -1077,18 +1054,17 @@ nsHostResolver::ConditionallyCreateThrea
                                         0);
         if (!thr) {
             mThreadCount--;
             NS_RELEASE_THIS();
             return NS_ERROR_OUT_OF_MEMORY;
         }
     }
     else {
-        LOG(("  Unable to find a thread for looking up host [%s%s%s].\n",
-             LOG_HOST(rec->host.get(), rec->netInterface.get())));
+        LOG(("  Unable to find a thread for looking up host [%s].\n", rec->host.get()));
     }
     return NS_OK;
 }
 
 // make sure the mTrrLock is held when this is used!
 #define TRROutstanding() ((rec->mTrrA || rec->mTrrAAAA))
 
 nsresult
@@ -1394,37 +1370,36 @@ void
 nsHostResolver::PrepareRecordExpiration(nsHostRecord* rec) const
 {
     // NOTE: rec->addr_info_lock is already held by parent
     MOZ_ASSERT(((bool)rec->addr_info) != rec->negative);
     mLock.AssertCurrentThreadOwns();
     if (!rec->addr_info) {
         rec->SetExpiration(TimeStamp::NowLoRes(),
                            NEGATIVE_RECORD_LIFETIME, 0);
-        LOG(("Caching host [%s%s%s] negative record for %u seconds.\n",
-             LOG_HOST(rec->host.get(), rec->netInterface.get()),
-             NEGATIVE_RECORD_LIFETIME));
+        LOG(("Caching host [%s] negative record for %u seconds.\n",
+             rec->host.get(), NEGATIVE_RECORD_LIFETIME));
         return;
     }
 
     unsigned int lifetime = mDefaultCacheLifetime;
     unsigned int grace = mDefaultGracePeriod;
 
     unsigned int ttl = mDefaultCacheLifetime;
     if (sGetTtlEnabled || rec->addr_info->IsTRR()) {
         if (rec->addr_info && rec->addr_info->ttl != AddrInfo::NO_TTL_DATA) {
             ttl = rec->addr_info->ttl;
         }
         lifetime = ttl;
         grace = 0;
     }
 
     rec->SetExpiration(TimeStamp::NowLoRes(), lifetime, grace);
-    LOG(("Caching host [%s%s%s] record for %u seconds (grace %d).",
-         LOG_HOST(rec->host.get(), rec->netInterface.get()), lifetime, grace));
+    LOG(("Caching host [%s] record for %u seconds (grace %d).",
+         rec->host.get(), lifetime, grace));
 }
 
 static nsresult
 merge_rrset(AddrInfo *rrto, AddrInfo *rrfrom)
 {
     if (!rrto || !rrfrom) {
         return NS_ERROR_NULL_POINTER;
     }
@@ -1709,18 +1684,17 @@ nsHostResolver::CompleteLookup(nsHostRec
     {
         MutexAutoLock lock(rec->addr_info_lock);
         if(rec->addr_info && rec->addr_info->IsTRR()) {
             fromTRR = true;
         }
     }
     if (!fromTRR &&
         !mShutdown && !rec->mGetTtl && !rec->mResolving && sGetTtlEnabled) {
-        LOG(("Issuing second async lookup for TTL for host [%s%s%s].",
-             LOG_HOST(rec->host.get(), rec->netInterface.get())));
+        LOG(("Issuing second async lookup for TTL for host [%s].", rec->host.get()));
         rec->flags =
             (rec->flags & ~RES_PRIORITY_MEDIUM) | RES_PRIORITY_LOW |
             RES_DISABLE_TRR;
         DebugOnly<nsresult> rv = NameLookup(rec);
         NS_WARNING_ASSERTION(
             NS_SUCCEEDED(rv),
             "Could not issue second async lookup for TTL.");
     }
@@ -1728,31 +1702,29 @@ nsHostResolver::CompleteLookup(nsHostRec
     return LOOKUP_OK;
 }
 
 void
 nsHostResolver::CancelAsyncRequest(const char             *host,
                                    const OriginAttributes &aOriginAttributes,
                                    uint16_t                flags,
                                    uint16_t                af,
-                                   const char             *netInterface,
                                    nsIDNSListener         *aListener,
                                    nsresult                status)
 
 {
     MutexAutoLock lock(mLock);
 
     nsAutoCString originSuffix;
     aOriginAttributes.CreateSuffix(originSuffix);
 
     // Lookup the host record associated with host, flags & address family
 
     nsHostKey key(nsCString(host), flags, af,
                   (aOriginAttributes.mPrivateBrowsingId > 0),
-                  nsCString(netInterface),
                   originSuffix);
     RefPtr<nsHostRecord> rec = mRecordDB.Get(key);
     if (rec) {
         nsHostRecord* recPtr = nullptr;
 
         for (RefPtr<nsResolveHostCallback> c : rec->mCallbacks) {
             if (c->EqualsAsyncListener(aListener)) {
                 c->remove();
@@ -1818,30 +1790,28 @@ nsHostResolver::ThreadFunc(void *arg)
             if (!resolver->GetHostToLookup(getter_AddRefs(tmpRec))) {
                 break; // thread shutdown signal
             }
             // GetHostToLookup() returns an owning reference
             MOZ_ASSERT(tmpRec);
             rec.swap(tmpRec);
         }
 
-        LOG(("DNS lookup thread - Calling getaddrinfo for host [%s%s%s].\n",
-             LOG_HOST(rec->host.get(), rec->netInterface.get())));
-
+        LOG(("DNS lookup thread - Calling getaddrinfo for host [%s].\n",
+             rec->host.get()));
+        
         TimeStamp startTime = TimeStamp::Now();
         bool getTtl = rec->mGetTtl;
         nsresult status = GetAddrInfo(rec->host.get(), rec->af,
-                                      rec->flags,
-                                      rec->netInterface.get(), &ai,
+                                      rec->flags, &ai,
                                       getTtl);
 #if defined(RES_RETRY_ON_FAILURE)
         if (NS_FAILED(status) && rs.Reset()) {
             status = GetAddrInfo(rec->host.get(), rec->af,
-                                 rec->flags, rec->netInterface.get(), &ai,
-                                 getTtl);
+                                 rec->flags, &ai, getTtl);
         }
 #endif
 
         {   // obtain lock to check shutdown and manage inter-module telemetry
             MutexAutoLock lock(resolver->mLock);
 
             if (!resolver->mShutdown) {
                 TimeDuration elapsed = TimeStamp::Now() - startTime;
@@ -1861,24 +1831,23 @@ nsHostResolver::ThreadFunc(void *arg)
                     }
                     Telemetry::Accumulate(histogramID, millis);
                 } else {
                     Telemetry::Accumulate(Telemetry::DNS_FAILED_LOOKUP_TIME, millis);
                 }
             }
         }
 
-        LOG(("DNS lookup thread - lookup completed for host [%s%s%s]: %s.\n",
-             LOG_HOST(rec->host.get(), rec->netInterface.get()),
+        LOG(("DNS lookup thread - lookup completed for host [%s]: %s.\n",
+             rec->host.get(),
              ai ? "success" : "failure: unknown host"));
 
         if (LOOKUP_RESOLVEAGAIN == resolver->CompleteLookup(rec, status, ai, rec->pb)) {
             // leave 'rec' assigned and loop to make a renewed host resolve
-            LOG(("DNS lookup thread - Re-resolving host [%s%s%s].\n",
-                 LOG_HOST(rec->host.get(), rec->netInterface.get())));
+            LOG(("DNS lookup thread - Re-resolving host [%s].\n", rec->host.get()));
         } else {
             rec = nullptr;
         }
     } while(true);
 
     resolver->mThreadCount--;
     resolver = nullptr;
     LOG(("DNS lookup thread - queue empty, thread finished.\n"));
@@ -1923,17 +1892,16 @@ nsHostResolver::GetDNSCacheEntries(nsTAr
         MOZ_ASSERT(rec, "rec should never be null here!");
         if (!rec || !rec->addr_info) {
             continue;
         }
 
         DNSCacheEntries info;
         info.hostname = rec->host;
         info.family = rec->af;
-        info.netInterface = rec->netInterface;
         info.expiration =
             (int64_t)(rec->mValidEnd - TimeStamp::NowLoRes()).ToSeconds();
         if (info.expiration <= 0) {
             // We only need valid DNS cache entries
             continue;
         }
 
         {
--- a/netwerk/dns/nsHostResolver.h
+++ b/netwerk/dns/nsHostResolver.h
@@ -50,27 +50,24 @@ extern mozilla::Atomic<bool, mozilla::Re
                               MAX_RESOLVER_THREADS_FOR_HIGH_PRIORITY)
 
 struct nsHostKey
 {
     const nsCString host;
     uint16_t flags;
     uint16_t af;
     bool     pb;
-    const nsCString netInterface;
     const nsCString originSuffix;
 
     nsHostKey(const nsACString& host, uint16_t flags,
-              uint16_t af, bool pb, const nsACString& netInterface,
-              const nsACString& originSuffix)
+              uint16_t af, bool pb, const nsACString& originSuffix)
         : host(host)
         , flags(flags)
         , af(af)
         , pb(pb)
-        , netInterface(netInterface)
         , originSuffix(originSuffix) {
     }
 
     bool operator==(const nsHostKey& other) const;
     size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
     PLDHashNumber Hash() const;
 };
 
@@ -277,17 +274,16 @@ public:
      enum LookupStatus {
         LOOKUP_OK,
         LOOKUP_RESOLVEAGAIN,
     };
 
     virtual LookupStatus CompleteLookup(nsHostRecord *, nsresult, mozilla::net::AddrInfo *, bool pb) = 0;
     virtual nsresult GetHostRecord(const char *host,
                                    uint16_t flags, uint16_t af, bool pb,
-                                   const nsCString &netInterface,
                                    const nsCString &originSuffix,
                                    nsHostRecord **result)
     {
         return NS_ERROR_FAILURE;
     }
     virtual nsresult TrrLookup_unlocked(nsHostRecord *, mozilla::net::TRR *pushedTRR = nullptr)
     {
         return NS_ERROR_FAILURE;
@@ -332,45 +328,42 @@ public:
      * above the callback will occur re-entrantly from an unspecified thread.  the
      * host lookup cannot be canceled (cancelation can be layered above this by
      * having the callback implementation return without doing anything).
      */
     nsresult ResolveHost(const char                      *hostname,
                          const mozilla::OriginAttributes &aOriginAttributes,
                          uint16_t                         flags,
                          uint16_t                         af,
-                         const char                      *netInterface,
                          nsResolveHostCallback           *callback);
 
     /**
      * removes the specified callback from the nsHostRecord for the given
      * hostname, originAttributes, flags, and address family.  these parameters
      * should correspond to the parameters passed to ResolveHost.  this function
      * executes the callback if the callback is still pending with the given status.
      */
     void DetachCallback(const char                      *hostname,
                         const mozilla::OriginAttributes &aOriginAttributes,
                         uint16_t                         flags,
                         uint16_t                         af,
-                        const char                      *netInterface,
                         nsResolveHostCallback           *callback,
                         nsresult                         status);
 
     /**
      * Cancels an async request associated with the hostname, originAttributes, flags,
      * address family and listener.  Cancels first callback found which matches
      * these criteria.  These parameters should correspond to the parameters
      * passed to ResolveHost.  If this is the last callback associated with the
      * host record, it is removed from any request queues it might be on.
      */
     void CancelAsyncRequest(const char                      *host,
                             const mozilla::OriginAttributes &aOriginAttributes,
                             uint16_t                         flags,
                             uint16_t                         af,
-                            const char                      *netInterface,
                             nsIDNSListener                  *aListener,
                             nsresult                         status);
     /**
      * values for the flags parameter passed to ResolveHost and DetachCallback
      * that may be bitwise OR'd together.
      *
      * NOTE: in this implementation, these flags correspond exactly in value
      *       to the flags defined on nsIDNSService.
@@ -394,17 +387,16 @@ public:
     /**
      * Flush the DNS cache.
      */
     void FlushCache();
 
     LookupStatus CompleteLookup(nsHostRecord *, nsresult, mozilla::net::AddrInfo *, bool pb) override;
     nsresult GetHostRecord(const char *host,
                            uint16_t flags, uint16_t af, bool pb,
-                           const nsCString &netInterface,
                            const nsCString &originSuffix,
                            nsHostRecord **result) override;
     nsresult TrrLookup_unlocked(nsHostRecord *, mozilla::net::TRR *pushedTRR = nullptr) override;
 
 private:
    explicit nsHostResolver(uint32_t maxCacheEntries,
                            uint32_t defaultCacheEntryLifetime,
                            uint32_t defaultGracePeriod);
--- a/netwerk/dns/nsIDNSService.idl
+++ b/netwerk/dns/nsIDNSService.idl
@@ -124,61 +124,16 @@ interface nsIDNSService : nsISupports
 
     [notxpcom]
     nsresult resolveNative(in AUTF8String       aHostName,
                            in unsigned long     aFlags,
                            in OriginAttributes  aOriginAttributes,
                            out nsIDNSRecord     aResult);
 
     /**
-     * kicks off an asynchronous host lookup.
-     *
-     * This function is identical to asyncResolve except an additional
-     * parameter aNetwortInterface. If parameter aNetworkInterface is an empty
-     * string function will return the same result as asyncResolve.
-     * Setting aNetworkInterface is deprecated.
-     */
-    [implicit_jscontext, optional_argc]
-    nsICancelable asyncResolveExtended(in AUTF8String       aHostName,
-                                       in unsigned long     aFlags,
-                                       in AUTF8String       aNetworkInterface,
-                                       in nsIDNSListener    aListener,
-                                       in nsIEventTarget    aListenerTarget,
-                            [optional] in jsval             aOriginAttributes);
-
-    [notxpcom]
-    nsresult asyncResolveExtendedNative(in AUTF8String       aHostName,
-                                        in unsigned long     aFlags,
-                                        in AUTF8String       aNetworkInterface,
-                                        in nsIDNSListener    aListener,
-                                        in nsIEventTarget    aListenerTarget,
-                                        in OriginAttributes  aOriginAttributes,
-                                        out nsICancelable    aResult);
-
-    /**
-     * Attempts to cancel a previously requested async DNS lookup
-     * This is an extended versin with a additional parameter aNetworkInterface
-     */
-    [implicit_jscontext, optional_argc]
-    void cancelAsyncResolveExtended(in AUTF8String       aHostName,
-                                    in unsigned long     aFlags,
-                                    in AUTF8String       aNetworkInterface,
-                                    in nsIDNSListener    aListener,
-                                    in nsresult          aReason,
-                         [optional] in jsval             aOriginAttributes);
-
-    [notxpcom]
-    nsresult cancelAsyncResolveExtendedNative(in AUTF8String       aHostName,
-                                              in unsigned long     aFlags,
-                                              in AUTF8String       aNetworkInterface,
-                                              in nsIDNSListener    aListener,
-                                              in nsresult          aReason,
-                                              in OriginAttributes  aOriginAttributes);
-
-    /**
      * The method takes a pointer to an nsTArray
      * and fills it with cache entry data
      * Called by the networking dashboard
      */
     [noscript] void getDNSCacheEntries(in EntriesArray args);
 
     /**
      * @return the hostname of the operating system.
--- a/netwerk/ipc/NeckoChild.cpp
+++ b/netwerk/ipc/NeckoChild.cpp
@@ -318,18 +318,17 @@ NeckoChild::DeallocPUDPSocketChild(PUDPS
   UDPSocketChild* p = static_cast<UDPSocketChild*>(child);
   p->ReleaseIPDLReference();
   return true;
 }
 
 PDNSRequestChild*
 NeckoChild::AllocPDNSRequestChild(const nsCString& aHost,
                                   const OriginAttributes& aOriginAttributes,
-                                  const uint32_t& aFlags,
-                                  const nsCString& aNetworkInterface)
+                                  const uint32_t& aFlags)
 {
   // We don't allocate here: instead we always use IPDL constructor that takes
   // an existing object
   NS_NOTREACHED("AllocPDNSRequestChild should not be called on child");
   return nullptr;
 }
 
 bool
--- a/netwerk/ipc/NeckoChild.h
+++ b/netwerk/ipc/NeckoChild.h
@@ -59,18 +59,17 @@ protected:
                                const uint16_t& aBacklog,
                                const bool& aUseArrayBuffers) override;
   virtual bool DeallocPTCPServerSocketChild(PTCPServerSocketChild*) override;
   virtual PUDPSocketChild* AllocPUDPSocketChild(const Principal& aPrincipal,
                                                 const nsCString& aFilter) override;
   virtual bool DeallocPUDPSocketChild(PUDPSocketChild*) override;
   virtual PDNSRequestChild* AllocPDNSRequestChild(const nsCString& aHost,
                                                   const OriginAttributes& aOriginAttributes,
-                                                  const uint32_t& aFlags,
-                                                  const nsCString& aNetworkInterface) override;
+                                                  const uint32_t& aFlags) override;
   virtual bool DeallocPDNSRequestChild(PDNSRequestChild*) override;
   virtual PDataChannelChild* AllocPDataChannelChild(const uint32_t& channelId) override;
   virtual bool DeallocPDataChannelChild(PDataChannelChild* child) override;
   virtual PFileChannelChild* AllocPFileChannelChild(const uint32_t& channelId) override;
   virtual bool DeallocPFileChannelChild(PFileChannelChild* child) override;
   virtual PSimpleChannelChild* AllocPSimpleChannelChild(const uint32_t& channelId) override;
   virtual bool DeallocPSimpleChannelChild(PSimpleChannelChild* child) override;
   virtual PChannelDiverterChild*
--- a/netwerk/ipc/NeckoParent.cpp
+++ b/netwerk/ipc/NeckoParent.cpp
@@ -644,35 +644,32 @@ NeckoParent::DeallocPUDPSocketParent(PUD
   UDPSocketParent* p = static_cast<UDPSocketParent*>(actor);
   p->Release();
   return true;
 }
 
 PDNSRequestParent*
 NeckoParent::AllocPDNSRequestParent(const nsCString& aHost,
                                     const OriginAttributes& aOriginAttributes,
-                                    const uint32_t& aFlags,
-                                    const nsCString& aNetworkInterface)
+                                    const uint32_t& aFlags)
 {
   DNSRequestParent *p = new DNSRequestParent();
   p->AddRef();
   return p;
 }
 
 mozilla::ipc::IPCResult
 NeckoParent::RecvPDNSRequestConstructor(PDNSRequestParent* aActor,
                                         const nsCString& aHost,
                                         const OriginAttributes& aOriginAttributes,
-                                        const uint32_t& aFlags,
-                                        const nsCString& aNetworkInterface)
+                                        const uint32_t& aFlags)
 {
   static_cast<DNSRequestParent*>(aActor)->DoAsyncResolve(aHost,
                                                          aOriginAttributes,
-                                                         aFlags,
-                                                         aNetworkInterface);
+                                                         aFlags);
   return IPC_OK();
 }
 
 bool
 NeckoParent::DeallocPDNSRequestParent(PDNSRequestParent* aParent)
 {
   DNSRequestParent *p = static_cast<DNSRequestParent*>(aParent);
   p->Release();
--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -148,23 +148,21 @@ protected:
   virtual PUDPSocketParent* AllocPUDPSocketParent(const Principal& aPrincipal,
                                                   const nsCString& aFilter) override;
   virtual mozilla::ipc::IPCResult RecvPUDPSocketConstructor(PUDPSocketParent*,
                                                             const Principal& aPrincipal,
                                                             const nsCString& aFilter) override;
   virtual bool DeallocPUDPSocketParent(PUDPSocketParent*) override;
   virtual PDNSRequestParent* AllocPDNSRequestParent(const nsCString& aHost,
                                                     const OriginAttributes& aOriginAttributes,
-                                                    const uint32_t& aFlags,
-                                                    const nsCString& aNetworkInterface) override;
+                                                    const uint32_t& aFlags) override;
   virtual mozilla::ipc::IPCResult RecvPDNSRequestConstructor(PDNSRequestParent* actor,
                                                              const nsCString& hostName,
                                                              const OriginAttributes& aOriginAttributes,
-                                                             const uint32_t& flags,
-                                                             const nsCString& aNetworkInterface) override;
+                                                             const uint32_t& flags) override;
   virtual bool DeallocPDNSRequestParent(PDNSRequestParent*) override;
   virtual mozilla::ipc::IPCResult RecvSpeculativeConnect(const URIParams& aURI,
                                                          const Principal& aPrincipal,
                                                          const bool& aAnonymous) override;
   virtual mozilla::ipc::IPCResult RecvHTMLDNSPrefetch(const nsString& hostname,
                                                       const OriginAttributes& aOriginAttributes,
                                                       const uint16_t& flags) override;
   virtual mozilla::ipc::IPCResult RecvCancelHTMLDNSPrefetch(const nsString& hostname,
--- a/netwerk/ipc/PNecko.ipdl
+++ b/netwerk/ipc/PNecko.ipdl
@@ -75,17 +75,17 @@ parent:
                     FTPChannelCreationArgs args);
 
   async PWebSocket(PBrowserOrId browser, SerializedLoadContext loadContext,
                    uint32_t aSerialID);
   async PTCPServerSocket(uint16_t localPort, uint16_t backlog, bool useArrayBuffers);
   async PUDPSocket(Principal principal, nsCString filter);
 
   async PDNSRequest(nsCString hostName, OriginAttributes originAttributes,
-                    uint32_t flags, nsCString networkInterface);
+                    uint32_t flags);
 
   async PWebSocketEventListener(uint64_t aInnerWindowID);
 
   /* Predictor Methods */
   async PredPredict(OptionalURIParams targetURI, OptionalURIParams sourceURI,
                     uint32_t reason, OriginAttributes originAttributes,
                     bool hasVerifier);
   async PredLearn(URIParams targetURI, OptionalURIParams sourceURI,
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -1531,31 +1531,16 @@ HttpBaseChannel::SetRequestMethod(const 
   if (!nsHttp::IsValidToken(flatMethod))
     return NS_ERROR_INVALID_ARG;
 
   mRequestHead.SetMethod(flatMethod);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-HttpBaseChannel::GetNetworkInterfaceId(nsACString& aNetworkInterfaceId)
-{
-  aNetworkInterfaceId = mNetworkInterfaceId;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-HttpBaseChannel::SetNetworkInterfaceId(const nsACString& aNetworkInterfaceId)
-{
-  ENSURE_CALLED_BEFORE_CONNECT();
-  mNetworkInterfaceId = aNetworkInterfaceId;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
 HttpBaseChannel::GetReferrer(nsIURI **referrer)
 {
   NS_ENSURE_ARG_POINTER(referrer);
   *referrer = mReferrer;
   NS_IF_ADDREF(*referrer);
   return NS_OK;
 }
 
--- a/netwerk/protocol/http/HttpBaseChannel.h
+++ b/netwerk/protocol/http/HttpBaseChannel.h
@@ -242,18 +242,16 @@ public:
   NS_IMETHOD SetTlsFlags(uint32_t aTlsFlags) override;
   NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI) override;
   virtual MOZ_MUST_USE nsresult AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory);
   NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages) override;
   NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable) override;
   NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable) override;
   NS_IMETHOD GetInitialRwin(uint32_t* aRwin) override;
   NS_IMETHOD SetInitialRwin(uint32_t aRwin) override;
-  NS_IMETHOD GetNetworkInterfaceId(nsACString& aNetworkInterfaceId) override;
-  NS_IMETHOD SetNetworkInterfaceId(const nsACString& aNetworkInterfaceId) override;
   NS_IMETHOD ForcePending(bool aForcePending) override;
   NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime) override;
   NS_IMETHOD GetCorsIncludeCredentials(bool* aInclude) override;
   NS_IMETHOD SetCorsIncludeCredentials(bool aInclude) override;
   NS_IMETHOD GetCorsMode(uint32_t* aCorsMode) override;
   NS_IMETHOD SetCorsMode(uint32_t aCorsMode) override;
   NS_IMETHOD GetRedirectMode(uint32_t* aRedirectMode) override;
   NS_IMETHOD SetRedirectMode(uint32_t aRedirectMode) override;
@@ -670,19 +668,16 @@ protected:
   // Defaults to false. Is set to true at the begining of OnStartRequest.
   // Used to ensure methods can't be called before OnStartRequest.
   bool mAfterOnStartRequestBegun;
 
   uint64_t mTransferSize;
   uint64_t mDecodedBodySize;
   uint64_t mEncodedBodySize;
 
-  // The network interface id that's associated with this channel.
-  nsCString mNetworkInterfaceId;
-
   uint64_t mRequestContextID;
   bool EnsureRequestContextID();
   nsCOMPtr<nsIRequestContext> mRequestContext;
   bool EnsureRequestContext();
 
   // Adds/removes this channel as a non-tailed request in its request context
   // these helpers ensure we add it only once and remove it only when added
   // via mAddedAsNonTailRequest member tracking.
--- a/netwerk/protocol/http/TunnelUtils.cpp
+++ b/netwerk/protocol/http/TunnelUtils.cpp
@@ -1598,28 +1598,16 @@ SocketTransportShim::GetHost(nsACString 
 
 NS_IMETHODIMP
 SocketTransportShim::GetTimeout(uint32_t aType, uint32_t *_retval)
 {
   return mWrapped->GetTimeout(aType, _retval);
 }
 
 NS_IMETHODIMP
-SocketTransportShim::GetNetworkInterfaceId(nsACString &aNetworkInterfaceId)
-{
-  return mWrapped->GetNetworkInterfaceId(aNetworkInterfaceId);
-}
-
-NS_IMETHODIMP
-SocketTransportShim::SetNetworkInterfaceId(const nsACString &aNetworkInterfaceId)
-{
-  return mWrapped->SetNetworkInterfaceId(aNetworkInterfaceId);
-}
-
-NS_IMETHODIMP
 SocketTransportShim::SetTimeout(uint32_t aType, uint32_t aValue)
 {
   return mWrapped->SetTimeout(aType, aValue);
 }
 
 NS_IMETHODIMP
 SocketTransportShim::SetReuseAddrPort(bool aReuseAddrPort)
 {
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -6233,22 +6233,16 @@ nsHttpChannel::BeginConnect()
     } else {
         LOG(("nsHttpChannel %p Using default connection info", this));
 
         mConnectionInfo = new nsHttpConnectionInfo(host, port, EmptyCString(), mUsername, proxyInfo,
                                                    originAttributes, isHttps);
         Telemetry::Accumulate(Telemetry::HTTP_TRANSACTION_USE_ALTSVC, false);
     }
 
-    // Set network interface id only when it's not empty to avoid
-    // rebuilding hash key.
-    if (!mNetworkInterfaceId.IsEmpty()) {
-        mConnectionInfo->SetNetworkInterfaceId(mNetworkInterfaceId);
-    }
-
     mAuthProvider =
         do_CreateInstance("@mozilla.org/network/http-channel-auth-provider;1",
                           &rv);
     if (NS_SUCCEEDED(rv))
         rv = mAuthProvider->Init(this);
     if (NS_FAILED(rv)) {
         return rv;
     }
--- a/netwerk/protocol/http/nsHttpConnectionInfo.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionInfo.cpp
@@ -100,23 +100,16 @@ nsHttpConnectionInfo::Init(const nsACStr
             resolveFlags & nsIProtocolProxyService::RESOLVE_ALWAYS_TUNNEL) {
             mUsingConnect = true;
         }
     }
 
     SetOriginServer(host, port);
 }
 
-void
-nsHttpConnectionInfo::SetNetworkInterfaceId(const nsACString& aNetworkInterfaceId)
-{
-    mNetworkInterfaceId = aNetworkInterfaceId;
-    BuildHashKey();
-}
-
 void nsHttpConnectionInfo::BuildHashKey()
 {
     //
     // build hash key:
     //
     // the hash key uniquely identifies the connection type.  two connections
     // are "equal" if they end up talking the same protocol to the same server
     // and are both used for anonymous or non-anonymous connection only;
@@ -142,21 +135,16 @@ void nsHttpConnectionInfo::BuildHashKey(
     // byte 3 is P/. P is for a private browising channel
     // byte 4 is I/. I is for insecure scheme on TLS for http:// uris
     // byte 5 is X/. X is for disallow_spdy flag
     // byte 6 is C/. C is for be Conservative
 
     mHashKey.AssignLiteral(".......[tlsflags0x00000000]");
 
     mHashKey.Append(keyHost);
-    if (!mNetworkInterfaceId.IsEmpty()) {
-        mHashKey.Append('(');
-        mHashKey.Append(mNetworkInterfaceId);
-        mHashKey.Append(')');
-    }
     mHashKey.Append(':');
     mHashKey.AppendInt(keyPort);
     if (!mUsername.IsEmpty()) {
         mHashKey.Append('[');
         mHashKey.Append(mUsername);
         mHashKey.Append(']');
     }
 
@@ -242,20 +230,16 @@ nsHttpConnectionInfo::Clone() const
         clone = new nsHttpConnectionInfo(mOrigin, mOriginPort, mNPNToken, mUsername, mProxyInfo,
                                          mOriginAttributes, mEndToEndSSL);
     } else {
         MOZ_ASSERT(mEndToEndSSL);
         clone = new nsHttpConnectionInfo(mOrigin, mOriginPort, mNPNToken, mUsername, mProxyInfo,
                                          mOriginAttributes, mRoutedHost, mRoutedPort);
     }
 
-    if (!mNetworkInterfaceId.IsEmpty()) {
-        clone->SetNetworkInterfaceId(mNetworkInterfaceId);
-    }
-
     // Make sure the anonymous, insecure-scheme, and private flags are transferred
     clone->SetAnonymous(GetAnonymous());
     clone->SetPrivate(GetPrivate());
     clone->SetInsecureScheme(GetInsecureScheme());
     clone->SetNoSpdy(GetNoSpdy());
     clone->SetBeConservative(GetBeConservative());
     clone->SetTlsFlags(GetTlsFlags());
     MOZ_ASSERT(clone->Equals(this));
@@ -277,19 +261,16 @@ nsHttpConnectionInfo::CloneAsDirectRoute
                                  mOriginAttributes, mEndToEndSSL);
     // Make sure the anonymous, insecure-scheme, and private flags are transferred
     clone->SetAnonymous(GetAnonymous());
     clone->SetPrivate(GetPrivate());
     clone->SetInsecureScheme(GetInsecureScheme());
     clone->SetNoSpdy(GetNoSpdy());
     clone->SetBeConservative(GetBeConservative());
     clone->SetTlsFlags(GetTlsFlags());
-    if (!mNetworkInterfaceId.IsEmpty()) {
-        clone->SetNetworkInterfaceId(mNetworkInterfaceId);
-    }
     clone.forget(outCI);
 }
 
 nsresult
 nsHttpConnectionInfo::CreateWildCard(nsHttpConnectionInfo **outParam)
 {
     // T???mozilla.org:443 (https:proxy.ducksong.com:3128) [specifc form]
     // TS??*:0 (https:proxy.ducksong.com:3128)   [wildcard form]
--- a/netwerk/protocol/http/nsHttpConnectionInfo.h
+++ b/netwerk/protocol/http/nsHttpConnectionInfo.h
@@ -69,21 +69,16 @@ public:
     const nsCString &GetOrigin() const { return mOrigin; }
     const char   *Origin()       const { return mOrigin.get(); }
     int32_t       OriginPort()   const { return mOriginPort; }
 
     const nsCString &GetRoutedHost() const { return mRoutedHost; }
     const char      *RoutedHost() const { return mRoutedHost.get(); }
     int32_t          RoutedPort() const { return mRoutedPort; }
 
-    // With overhead rebuilding the hash key. The initial
-    // network interface is empty. So you can reduce one call
-    // if there's no explicit route after ctor.
-    void SetNetworkInterfaceId(const nsACString& aNetworkInterfaceId);
-
     // OK to treat these as an infalible allocation
     nsHttpConnectionInfo* Clone() const;
     void CloneAsDirectRoute(nsHttpConnectionInfo **outParam);
     MOZ_MUST_USE nsresult CreateWildCard(nsHttpConnectionInfo **outParam);
 
     const char *ProxyHost() const { return mProxyInfo ? mProxyInfo->Host().get() : nullptr; }
     int32_t     ProxyPort() const { return mProxyInfo ? mProxyInfo->Port() : -1; }
     const char *ProxyType() const { return mProxyInfo ? mProxyInfo->Type() : nullptr; }
@@ -120,18 +115,16 @@ public:
 
     void          SetBeConservative(bool aBeConservative)
                                             { mHashKey.SetCharAt(aBeConservative ? 'C' : '.', 6); }
     bool          GetBeConservative() const { return mHashKey.CharAt(6) == 'C'; }
 
     void          SetTlsFlags(uint32_t aTlsFlags);
     uint32_t      GetTlsFlags() const { return mTlsFlags; }
 
-    const nsCString &GetNetworkInterfaceId() const { return mNetworkInterfaceId; }
-
     const nsCString &GetNPNToken() { return mNPNToken; }
     const nsCString &GetUsername() { return mUsername; }
 
     const OriginAttributes &GetOriginAttributes() { return mOriginAttributes; }
 
     // Returns true for any kind of proxy (http, socks, https, etc..)
     bool UsingProxy();
 
@@ -164,17 +157,16 @@ private:
     void SetOriginServer(const nsACString &host, int32_t port);
 
     nsCString              mOrigin;
     int32_t                mOriginPort;
     nsCString              mRoutedHost;
     int32_t                mRoutedPort;
 
     nsCString              mHashKey;
-    nsCString              mNetworkInterfaceId;
     nsCString              mUsername;
     nsCOMPtr<nsProxyInfo>  mProxyInfo;
     bool                   mUsingHttpProxy;
     bool                   mUsingHttpsProxy;
     bool                   mEndToEndSSL;
     bool                   mUsingConnect;  // if will use CONNECT with http proxy
     nsCString              mNPNToken;
     OriginAttributes       mOriginAttributes;
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -4113,20 +4113,16 @@ nsHalfOpenSocket::SetupStreams(nsISocket
 
     const OriginAttributes& originAttributes = mEnt->mConnInfo->GetOriginAttributes();
     if (originAttributes != OriginAttributes()) {
         socketTransport->SetOriginAttributes(originAttributes);
     }
 
     socketTransport->SetQoSBits(gHttpHandler->GetQoSBits());
 
-    if (!ci->GetNetworkInterfaceId().IsEmpty()) {
-        socketTransport->SetNetworkInterfaceId(ci->GetNetworkInterfaceId());
-    }
-
     rv = socketTransport->SetEventSink(this, nullptr);
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = socketTransport->SetSecurityCallbacks(this);
     NS_ENSURE_SUCCESS(rv, rv);
 
     Telemetry::Accumulate(Telemetry::HTTP_CONNECTION_ENTRY_CACHE_HIT_1,
                           mEnt->mUsedForConnection);
--- a/netwerk/protocol/http/nsIHttpChannelInternal.idl
+++ b/netwerk/protocol/http/nsIHttpChannelInternal.idl
@@ -280,21 +280,16 @@ interface nsIHttpChannelInternal : nsISu
     /**
      * Set top-level window URI to this channel only when the topWindowURI
      * is null and there is no window associated to this channel.
      * Note that the current usage of this method is only for xpcshell test.
      */
     [must_use] void setTopWindowURIIfUnknown(in nsIURI topWindowURI);
 
     /**
-     * The network interface id that's associated with this channel.
-     */
-    [must_use] attribute ACString networkInterfaceId;
-
-    /**
      * Read the proxy URI, which, if non-null, will be used to resolve
      * proxies for this channel.
      */
     [must_use] readonly attribute nsIURI proxyURI;
 
     /**
      * Make cross-origin CORS loads happen with a CORS preflight, and specify
      * the CORS preflight parameters.
deleted file mode 100644
--- a/netwerk/test/unit/test_dns_per_interface.js
+++ /dev/null
@@ -1,86 +0,0 @@
-var dns = Cc["@mozilla.org/network/dns-service;1"].getService(Ci.nsIDNSService);
-
-// This test checks DNSService host resolver when a network interface is supplied
-// as well. In the test 3 request are sent: two with a network interface set 
-// and one without a network interface.
-// All requests have the same host to be resolved and the same flags.
-// One of the request with the network interface will be canceled.
-// The request with and without a network interface should not be mixed during
-// the requests lifetime.
-
-var netInterface1 = "interface1";
-var netInterface2 = "interface2";
-
-// We are not using localhost because on e10s a host resolve callback is almost
-// always faster than a cancel request, therefore cancel operation would not be
-// tested.
-var hostname = "thisshouldnotexist.mozilla.com";
-
-// 3 requests.
-var requestWithInterfaceCanceled;
-var requestWithoutInterfaceNotCanceled;
-var requestWithInterfaceNotCanceled;
-
-var listener = {
-  onLookupComplete: function(inRequest, inRecord, inStatus) {
-    // Two requests should be resolved and one request should be canceled.
-    // Since cancalation of a request is racy we will check only for not
-    // canceled request - they should not be canceled.
-    if ((inRequest == requestWithoutInterfaceNotCanceled) ||
-        (inRequest == requestWithInterfaceNotCanceled)) {
-      // This request should not be canceled.
-      Assert.notEqual(inStatus, Cr.NS_ERROR_ABORT);
-
-      do_test_finished();
-    } else if (inRequest == requestWithInterfaceCanceled) {
-      // We do not check the outcome for this one because it is racy -
-      // whether the request cancelation is faster than resolving the request.
-      do_test_finished();
-    }
-  },
-  QueryInterface: function(aIID) {
-    if (aIID.equals(Ci.nsIDNSListener) ||
-        aIID.equals(Ci.nsISupports)) {
-      return this;
-    }
-    throw Cr.NS_ERROR_NO_INTERFACE;
-  }
-};
-
-const defaultOriginAttributes = {};
-
-function run_test() {
-  var threadManager = Cc["@mozilla.org/thread-manager;1"]
-                        .getService(Ci.nsIThreadManager);
-  var mainThread = threadManager.currentThread;
-
-  var flags = Ci.nsIDNSService.RESOLVE_BYPASS_CACHE;
-
-  // This one will be canceled.
-  requestWithInterfaceCanceled = dns.asyncResolveExtended(hostname,
-                                                          flags,
-                                                          netInterface1,
-                                                          listener,
-                                                          mainThread,
-                                                          defaultOriginAttributes);
-  requestWithInterfaceCanceled.cancel(Cr.NS_ERROR_ABORT);
-
-  // This one will not be canceled. This is the request without a network
-  // interface.
-  requestWithoutInterfaceNotCanceled = dns.asyncResolve(hostname, flags, listener,
-                                                        mainThread,
-                                                        defaultOriginAttributes);
-
-  // This one will not be canceled.
-  requestWithInterfaceNotCanceled = dns.asyncResolveExtended(hostname,
-                                                             flags,
-                                                             netInterface2,
-                                                             listener,
-                                                             mainThread,
-                                                             defaultOriginAttributes);
-  // We wait for notifications for the requests.
-  // For each request onLookupComplete will be called.
-  do_test_pending();
-  do_test_pending();
-  do_test_pending();
-}
--- a/netwerk/test/unit/xpcshell.ini
+++ b/netwerk/test/unit/xpcshell.ini
@@ -186,17 +186,16 @@ skip-if = bits != 32
 [test_compareURIs.js]
 [test_compressappend.js]
 [test_content_encoding_gzip.js]
 [test_content_sniffer.js]
 [test_cookie_header.js]
 [test_cookiejars.js]
 [test_cookiejars_safebrowsing.js]
 [test_dns_cancel.js]
-[test_dns_per_interface.js]
 [test_data_protocol.js]
 [test_dns_service.js]
 [test_dns_offline.js]
 [test_dns_onion.js]
 [test_dns_originAttributes.js]
 [test_dns_localredirect.js]
 [test_dns_proxy_bypass.js]
 [test_duplicate_headers.js]
deleted file mode 100644
--- a/netwerk/test/unit_ipc/test_dns_per_interface_wrap.js
+++ /dev/null
@@ -1,7 +0,0 @@
-//
-// Run test script in content process instead of chrome (xpcshell's default)
-//
-
-function run_test() {
-  run_test_in_child("../unit/test_dns_per_interface.js");
-}
--- a/netwerk/test/unit_ipc/xpcshell.ini
+++ b/netwerk/test/unit_ipc/xpcshell.ini
@@ -8,17 +8,16 @@ support-files =
   !/netwerk/test/unit/test_bug528292.js
   !/netwerk/test/unit/test_cache-entry-id.js
   !/netwerk/test/unit/test_cache_jar.js
   !/netwerk/test/unit/test_cacheflags.js
   !/netwerk/test/unit/test_channel_close.js
   !/netwerk/test/unit/test_cookie_header.js
   !/netwerk/test/unit/test_cookiejars.js
   !/netwerk/test/unit/test_dns_cancel.js
-  !/netwerk/test/unit/test_dns_per_interface.js
   !/netwerk/test/unit/test_dns_service.js
   !/netwerk/test/unit/test_duplicate_headers.js
   !/netwerk/test/unit/test_event_sink.js
   !/netwerk/test/unit/test_getHost.js
   !/netwerk/test/unit/test_head.js
   !/netwerk/test/unit/test_headers.js
   !/netwerk/test/unit/test_httpsuspend.js
   !/netwerk/test/unit/test_post.js
@@ -65,17 +64,16 @@ support-files =
 [test_bug248970_cookie_wrap.js]
 [test_cacheflags_wrap.js]
 [test_cache-entry-id_wrap.js]
 [test_cache_jar_wrap.js]
 [test_channel_close_wrap.js]
 [test_cookie_header_wrap.js]
 [test_cookiejars_wrap.js]
 [test_dns_cancel_wrap.js]
-[test_dns_per_interface_wrap.js]
 [test_dns_service_wrap.js]
 [test_duplicate_headers_wrap.js]
 [test_event_sink_wrap.js]
 [test_head_wrap.js]
 [test_headers_wrap.js]
 [test_httpsuspend_wrap.js]
 [test_post_wrap.js]
 [test_predictor_wrap.js]