Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 10:44:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Backed out 5 changesets (bug 1552176) for causing multiple build bustages CLOSED TREE

Browse Source 
Backed out changeset 203060e4af95 (bug 1552176)
Backed out changeset b52f0ff800c8 (bug 1552176)
Backed out changeset 9f8d159fe252 (bug 1552176)
Backed out changeset 751b518e08fa (bug 1552176)
Backed out changeset a11ffd474c0c (bug 1552176)
This commit is contained in:
Noemi Erli 2019-11-02 23:20:28 +02:00
parent df35f07d16
commit 853acdf360
47 changed files with 154 additions and 722 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
dom/base/Document.cpp
View File

@ -700,16 +700,6 @@ OnloadBlocker::GetLoadFlags(nsLoadFlags* aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
OnloadBlocker::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
OnloadBlocker::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
OnloadBlocker::SetLoadFlags(nsLoadFlags aLoadFlags) { return NS_OK; }

3
dom/base/nsContentSink.cpp
View File

@ -859,8 +859,7 @@ void nsContentSink::PrefetchDNS(const nsAString& aHref) {
if (!hostname.IsEmpty() && nsHTMLDNSPrefetch::IsAllowed(mDocument)) {
nsHTMLDNSPrefetch::PrefetchLow(
hostname, isHttps, mDocument->NodePrincipal()->OriginAttributesRef(),
mDocument->GetChannel()->GetTRRMode());
hostname, isHttps, mDocument->NodePrincipal()->OriginAttributesRef());
}
}

44
dom/html/nsHTMLDNSPrefetch.cpp
View File

@ -91,21 +91,10 @@ bool nsHTMLDNSPrefetch::IsAllowed(Document* aDocument) {
return aDocument->IsDNSPrefetchAllowed() && aDocument->GetWindow();
}
static uint32_t GetDNSFlagsFromLink(Link* aElement) {
if (!aElement || !aElement->GetElement() ||
!aElement->GetElement()->OwnerDoc()->GetChannel()) {
return 0;
}
nsIRequest::TRRMode mode =
aElement->GetElement()->OwnerDoc()->GetChannel()->GetTRRMode();
return nsIDNSService::GetFlagsFromTRRMode(mode);
}
nsresult nsHTMLDNSPrefetch::Prefetch(Link* aElement, uint32_t flags) {
nsresult nsHTMLDNSPrefetch::Prefetch(Link* aElement, uint16_t flags) {
if (!(sInitialized && sPrefetches && sDNSService && sDNSListener))
return NS_ERROR_NOT_AVAILABLE;
flags |= GetDNSFlagsFromLink(aElement);
return sPrefetches->Add(flags, aElement);
}
@ -123,7 +112,7 @@ nsresult nsHTMLDNSPrefetch::PrefetchHigh(Link* aElement) {
nsresult nsHTMLDNSPrefetch::Prefetch(const nsAString& hostname, bool isHttps,
const OriginAttributes& aOriginAttributes,
uint32_t flags) {
uint16_t flags) {
if (IsNeckoChild()) {
// We need to check IsEmpty() because net_IsValidHostName()
// considers empty strings to be valid hostnames
@ -165,28 +154,25 @@ nsresult nsHTMLDNSPrefetch::Prefetch(const nsAString& hostname, bool isHttps,
nsresult nsHTMLDNSPrefetch::PrefetchLow(
const nsAString& hostname, bool isHttps,
const OriginAttributes& aOriginAttributes, nsIRequest::TRRMode aMode) {
const OriginAttributes& aOriginAttributes) {
return Prefetch(hostname, isHttps, aOriginAttributes,
nsIDNSService::GetFlagsFromTRRMode(aMode) |
nsIDNSService::RESOLVE_PRIORITY_LOW);
}
nsresult nsHTMLDNSPrefetch::PrefetchMedium(
const nsAString& hostname, bool isHttps,
const OriginAttributes& aOriginAttributes, nsIRequest::TRRMode aMode) {
const OriginAttributes& aOriginAttributes) {
return Prefetch(hostname, isHttps, aOriginAttributes,
nsIDNSService::GetFlagsFromTRRMode(aMode) |
nsIDNSService::RESOLVE_PRIORITY_MEDIUM);
}
nsresult nsHTMLDNSPrefetch::PrefetchHigh(
const nsAString& hostname, bool isHttps,
const OriginAttributes& aOriginAttributes, nsIRequest::TRRMode aMode) {
return Prefetch(hostname, isHttps, aOriginAttributes,
nsIDNSService::GetFlagsFromTRRMode(aMode));
const OriginAttributes& aOriginAttributes) {
return Prefetch(hostname, isHttps, aOriginAttributes, 0);
}
nsresult nsHTMLDNSPrefetch::CancelPrefetch(Link* aElement, uint32_t flags,
nsresult nsHTMLDNSPrefetch::CancelPrefetch(Link* aElement, uint16_t flags,
nsresult aReason) {
if (!(sInitialized && sPrefetches && sDNSService && sDNSListener))
return NS_ERROR_NOT_AVAILABLE;
@ -210,7 +196,7 @@ nsresult nsHTMLDNSPrefetch::CancelPrefetch(Link* aElement, uint32_t flags,
nsresult nsHTMLDNSPrefetch::CancelPrefetch(
const nsAString& hostname, bool isHttps,
const OriginAttributes& aOriginAttributes, uint32_t flags,
const OriginAttributes& aOriginAttributes, uint16_t flags,
nsresult aReason) {
// Forward this request to Necko Parent if we're a child process
if (IsNeckoChild()) {
@ -249,20 +235,14 @@ nsresult nsHTMLDNSPrefetch::CancelPrefetch(
nsresult nsHTMLDNSPrefetch::CancelPrefetchLow(Link* aElement,
nsresult aReason) {
return CancelPrefetch(
aElement,
GetDNSFlagsFromLink(aElement) | nsIDNSService::RESOLVE_PRIORITY_LOW,
aReason);
return CancelPrefetch(aElement, nsIDNSService::RESOLVE_PRIORITY_LOW, aReason);
}
nsresult nsHTMLDNSPrefetch::CancelPrefetchLow(
const nsAString& hostname, bool isHttps,
const OriginAttributes& aOriginAttributes, nsIRequest::TRRMode aTRRMode,
nsresult aReason) {
const OriginAttributes& aOriginAttributes, nsresult aReason) {
return CancelPrefetch(hostname, isHttps, aOriginAttributes,
nsIDNSService::GetFlagsFromTRRMode(aTRRMode) |
nsIDNSService::RESOLVE_PRIORITY_LOW,
aReason);
nsIDNSService::RESOLVE_PRIORITY_LOW, aReason);
}
void nsHTMLDNSPrefetch::LinkDestroyed(Link* aLink) {
@ -321,7 +301,7 @@ void nsHTMLDNSPrefetch::nsDeferrals::Flush() {
}
}
nsresult nsHTMLDNSPrefetch::nsDeferrals::Add(uint32_t flags, Link* aElement) {
nsresult nsHTMLDNSPrefetch::nsDeferrals::Add(uint16_t flags, Link* aElement) {
// The FIFO has no lock, so it can only be accessed on main thread
NS_ASSERTION(NS_IsMainThread(), "nsDeferrals::Add must be on main thread");

24
dom/html/nsHTMLDNSPrefetch.h
View File

@ -52,20 +52,16 @@ class nsHTMLDNSPrefetch {
static nsresult PrefetchLow(mozilla::dom::Link* aElement);
static nsresult PrefetchHigh(
const nsAString& host, bool isHttps,
const mozilla::OriginAttributes& aOriginAttributes,
nsIRequest::TRRMode aTRRMode);
const mozilla::OriginAttributes& aOriginAttributes);
static nsresult PrefetchMedium(
const nsAString& host, bool isHttps,
const mozilla::OriginAttributes& aOriginAttributes,
nsIRequest::TRRMode aTRRMode);
const mozilla::OriginAttributes& aOriginAttributes);
static nsresult PrefetchLow(
const nsAString& host, bool isHttps,
const mozilla::OriginAttributes& aOriginAttributes,
nsIRequest::TRRMode aTRRMode);
const mozilla::OriginAttributes& aOriginAttributes);
static nsresult CancelPrefetchLow(
const nsAString& host, bool isHttps,
const mozilla::OriginAttributes& aOriginAttributes,
nsIRequest::TRRMode aTRRMode, nsresult aReason);
const mozilla::OriginAttributes& aOriginAttributes, nsresult aReason);
static nsresult CancelPrefetchLow(mozilla::dom::Link* aElement,
nsresult aReason);
@ -74,13 +70,13 @@ class nsHTMLDNSPrefetch {
private:
static nsresult Prefetch(const nsAString& host, bool isHttps,
const mozilla::OriginAttributes& aOriginAttributes,
uint32_t flags);
static nsresult Prefetch(mozilla::dom::Link* aElement, uint32_t flags);
uint16_t flags);
static nsresult Prefetch(mozilla::dom::Link* aElement, uint16_t flags);
static nsresult CancelPrefetch(
const nsAString& hostname, bool isHttps,
const mozilla::OriginAttributes& aOriginAttributes, uint32_t flags,
const mozilla::OriginAttributes& aOriginAttributes, uint16_t flags,
nsresult aReason);
static nsresult CancelPrefetch(mozilla::dom::Link* aElement, uint32_t flags,
static nsresult CancelPrefetch(mozilla::dom::Link* aElement, uint16_t flags,
nsresult aReason);
public:
@ -107,7 +103,7 @@ class nsHTMLDNSPrefetch {
nsDeferrals();
void Activate();
nsresult Add(uint32_t flags, mozilla::dom::Link* aElement);
nsresult Add(uint16_t flags, mozilla::dom::Link* aElement);
void RemoveUnboundLinks();
@ -129,7 +125,7 @@ class nsHTMLDNSPrefetch {
static const int sMaxDeferredMask = (sMaxDeferred - 1);
struct deferred_entry {
uint32_t mFlags;
uint16_t mFlags;
// Link implementation clears this raw pointer in its destructor.
mozilla::dom::Link* mElement;
} mEntries[sMaxDeferred];

2
dom/ipc/BrowserParent.cpp
View File

@ -3580,8 +3580,6 @@ class FakeChannel final : public nsIChannel,
NS_IMETHOD SetLoadGroup(nsILoadGroup*) NO_IMPL;
NS_IMETHOD SetLoadFlags(nsLoadFlags) NO_IMPL;
NS_IMETHOD GetLoadFlags(nsLoadFlags*) NO_IMPL;
NS_IMETHOD GetTRRMode(nsIRequest::TRRMode* aTRRMode) NO_IMPL;
NS_IMETHOD SetTRRMode(nsIRequest::TRRMode aMode) NO_IMPL;
NS_IMETHOD GetIsDocument(bool*) NO_IMPL;
NS_IMETHOD GetOriginalURI(nsIURI**) NO_IMPL;
NS_IMETHOD SetOriginalURI(nsIURI*) NO_IMPL;

10
dom/ipc/RemoteWebProgressRequest.cpp
View File

@ -223,16 +223,6 @@ NS_IMETHODIMP RemoteWebProgressRequest::GetLoadFlags(nsLoadFlags* aLoadFlags) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP RemoteWebProgressRequest::GetTRRMode(
nsIRequest::TRRMode* aTRRMode) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP RemoteWebProgressRequest::SetTRRMode(
nsIRequest::TRRMode aTRRMode) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP RemoteWebProgressRequest::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_ERROR_NOT_IMPLEMENTED;
}

10
dom/jsurl/nsJSProtocolHandler.cpp
View File

@ -833,16 +833,6 @@ nsJSChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return mStreamChannel->SetLoadFlags(aLoadFlags);
}
NS_IMETHODIMP
nsJSChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsJSChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsJSChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
return mStreamChannel->GetLoadGroup(aLoadGroup);

10
dom/presentation/PresentationConnection.cpp
View File

@ -676,16 +676,6 @@ PresentationConnection::GetLoadFlags(nsLoadFlags* aLoadFlags) {
NS_IMETHODIMP
PresentationConnection::SetLoadFlags(nsLoadFlags aLoadFlags) { return NS_OK; }
NS_IMETHODIMP
PresentationConnection::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
PresentationConnection::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
nsresult PresentationConnection::AddIntoLoadGroup() {
// Avoid adding to loadgroup multiple times
if (mWeakLoadGroup) {

10
dom/websocket/WebSocket.cpp
View File

@ -2546,16 +2546,6 @@ WebSocketImpl::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
WebSocketImpl::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
WebSocketImpl::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
namespace {
class WorkerRunnableDispatcher final : public WorkerRunnable {

10
image/imgRequestProxy.cpp
View File

@ -661,16 +661,6 @@ imgRequestProxy::SetLoadFlags(nsLoadFlags flags) {
return NS_OK;
}
NS_IMETHODIMP
imgRequestProxy::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
imgRequestProxy::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
/** imgIRequest methods **/
NS_IMETHODIMP

10
modules/libjar/nsJARChannel.cpp
View File

@ -614,16 +614,6 @@ nsJARChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsJARChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsJARChannel::GetIsDocument(bool* aIsDocument) {
return NS_GetIsDocumentChannel(this, aIsDocument);

3
netwerk/base/NetworkConnectivityService.cpp
View File

@ -203,10 +203,9 @@ static inline already_AddRefed<nsIChannel> SetupIPCheckChannel(bool ipv4) {
nullptr,
nsIRequest::LOAD_BYPASS_CACHE | // don't read from the cache
nsIRequest::INHIBIT_CACHING | // don't write the response to cache
nsIRequest::LOAD_DISABLE_TRR | // check network capabilities not TRR
nsIRequest::LOAD_ANONYMOUS); // prevent privacy leaks
channel->SetTRRMode(nsIRequest::TRR_DISABLED_MODE);
NS_ENSURE_SUCCESS(rv, nullptr);
nsCOMPtr<nsIHttpChannelInternal> internalChan = do_QueryInterface(channel);

10
netwerk/base/nsAsyncStreamCopier.cpp
View File

@ -202,16 +202,6 @@ nsAsyncStreamCopier::GetLoadFlags(nsLoadFlags* aLoadFlags) {
NS_IMETHODIMP
nsAsyncStreamCopier::SetLoadFlags(nsLoadFlags aLoadFlags) { return NS_OK; }
NS_IMETHODIMP
nsAsyncStreamCopier::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return nsIAsyncStreamCopier::GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsAsyncStreamCopier::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return nsIAsyncStreamCopier::SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsAsyncStreamCopier::GetLoadGroup(nsILoadGroup** aLoadGroup) {
*aLoadGroup = nullptr;

10
netwerk/base/nsBaseChannel.cpp
View File

@ -430,16 +430,6 @@ nsBaseChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
nsBaseChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsBaseChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsBaseChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
NS_IF_ADDREF(*aLoadGroup = mLoadGroup);

6
netwerk/base/nsDNSPrefetch.cpp
View File

@ -33,17 +33,15 @@ nsresult nsDNSPrefetch::Shutdown() {
nsDNSPrefetch::nsDNSPrefetch(nsIURI* aURI,
mozilla::OriginAttributes& aOriginAttributes,
nsIRequest::TRRMode aTRRMode,
nsIDNSListener* aListener, bool storeTiming)
: mOriginAttributes(aOriginAttributes),
mStoreTiming(storeTiming),
mTRRMode(aTRRMode),
mListener(do_GetWeakReference(aListener)) {
aURI->GetAsciiHost(mHostname);
mIsHttps = aURI->SchemeIs("https");
}
nsresult nsDNSPrefetch::Prefetch(uint32_t flags) {
nsresult nsDNSPrefetch::Prefetch(uint16_t flags) {
// This can work properly only if this call is on the main thread.
// Curenlty we use nsDNSPrefetch only in nsHttpChannel which will call
// PrefetchHigh() from the main thread. Let's add assertion to catch
@ -63,8 +61,6 @@ nsresult nsDNSPrefetch::Prefetch(uint32_t flags) {
// TimingsValid() before using the timing.
nsCOMPtr<nsIEventTarget> main = mozilla::GetMainThreadEventTarget();
flags |= nsIDNSService::GetFlagsFromTRRMode(mTRRMode);
nsresult rv = sDNSService->AsyncResolveNative(
mHostname, flags | nsIDNSService::RESOLVE_SPECULATE, this, main,
mOriginAttributes, getter_AddRefs(tmpOutstanding));

6
netwerk/base/nsDNSPrefetch.h
View File

@ -25,8 +25,7 @@ class nsDNSPrefetch final : public nsIDNSListener {
NS_DECL_NSIDNSLISTENER
nsDNSPrefetch(nsIURI* aURI, mozilla::OriginAttributes& aOriginAttributes,
nsIRequest::TRRMode aTRRMode, nsIDNSListener* aListener,
bool storeTiming);
nsIDNSListener* aListener, bool storeTiming);
bool TimingsValid() const {
return !mStartTimestamp.IsNull() && !mEndTimestamp.IsNull();
}
@ -47,12 +46,11 @@ class nsDNSPrefetch final : public nsIDNSListener {
bool mIsHttps;
mozilla::OriginAttributes mOriginAttributes;
bool mStoreTiming;
nsIRequest::TRRMode mTRRMode;
mozilla::TimeStamp mStartTimestamp;
mozilla::TimeStamp mEndTimestamp;
nsWeakPtr mListener;
nsresult Prefetch(uint32_t flags);
nsresult Prefetch(uint16_t flags);
};
#endif

61
netwerk/base/nsIRequest.idl
View File

@ -137,68 +137,11 @@ interface nsIRequest : nsISupports
*/
const unsigned long LOAD_DOCUMENT_NEEDS_COOKIE = 1 << 2;
cenum TRRMode : 8 {
TRR_DEFAULT_MODE = 0,
TRR_DISABLED_MODE = 1,
TRR_FIRST_MODE = 2,
TRR_ONLY_MODE = 3
};
/**
* These methods encode/decode the TRR mode to/from the loadFlags.
* Helper methods Get/SetTRRModeImpl are provided so implementations don't
* need to duplicate code.
*
* Requests with TRR_DEFAULT_MODE will use the mode indicated by the pref
* - see network.trr.mode in all.js
* Requests with TRR_DISABLED_MODE will always use native DNS, even if the
* pref is set to mode3 (TRR-only).
* Requests with TRR_DISABLED_MODE will first use TRR then fallback to
* regular DNS, unless TRR is disabled by setting the pref to mode5,
* parental control being enabled, or the domain being in the exclusion
* list.
* Requests with TRR_ONLY_MODE will only use TRR, unless not allowed by
* the same conditions mentioned above.
* Set this flag to disable TRR for this request.
*/
nsIRequest_TRRMode getTRRMode();
void setTRRMode(in nsIRequest_TRRMode mode);
%{C++
TRRMode GetTRRMode() {
TRRMode mode = TRR_DEFAULT_MODE;
GetTRRMode(&mode);
return mode;
}
nsresult GetTRRModeImpl(nsIRequest::TRRMode* aTRRMode) {
NS_ENSURE_ARG_POINTER(aTRRMode);
nsLoadFlags flags = nsIRequest::LOAD_NORMAL;
nsresult rv = GetLoadFlags(&flags);
if (NS_FAILED(rv)) {
return rv;
}
*aTRRMode = static_cast<nsIRequest::TRRMode>(
(flags & nsIRequest::LOAD_TRR_MASK) >> 3);
return NS_OK;
}
nsresult SetTRRModeImpl(nsIRequest::TRRMode aTRRMode) {
MOZ_ASSERT(aTRRMode <= 3, "invalid value");
nsLoadFlags flags = nsIRequest::LOAD_NORMAL;
nsresult rv = GetLoadFlags(&flags);
if (NS_FAILED(rv)) {
return rv;
}
flags = (flags & ~nsIRequest::LOAD_TRR_MASK) | (aTRRMode << 3);
return SetLoadFlags(flags);
}
%}
/**
* These two bits encode the TRR mode.
* Do not get/set manually, rather use the getTRRMode/setTRRMode methods.
*/
const unsigned long LOAD_TRR_MASK = (1 << 3) | (1 << 4);
const unsigned long LOAD_DISABLE_TRR = 1 << 3;
/**************************************************************************
* The following flags control the flow of data into the cache.

18
netwerk/base/nsISocketTransport.idl
View File

@ -4,7 +4,6 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsITransport.idl"
#include "nsIRequest.idl"
interface nsIInterfaceRequestor;
interface nsINetAddr;
@ -259,23 +258,6 @@ interface nsISocketTransport : nsITransport
*/
const unsigned long DONT_TRY_ESNI = (1 << 10);
/**
* These two bits encode the TRR mode of the request.
* Use the static helper methods convert between the TRR mode and flags.
*/
const unsigned long TRR_MODE_FLAGS = (1 << 11) | (1 << 12);
%{C++
static uint32_t GetFlagsFromTRRMode(nsIRequest::TRRMode aMode) {
return static_cast<uint32_t>(aMode) << 11;
}
static nsIRequest::TRRMode GetTRRModeFromFlags(uint32_t aFlags) {
return static_cast<nsIRequest::TRRMode>((aFlags & TRR_MODE_FLAGS) >> 11);
}
%}
/**
* An opaque flags for non-standard behavior of the TLS system.
* It is unlikely this will need to be set outside of telemetry studies

10
netwerk/base/nsIncrementalDownload.cpp
View File

@ -371,16 +371,6 @@ nsIncrementalDownload::SetLoadFlags(nsLoadFlags loadFlags) {
return NS_OK;
}
NS_IMETHODIMP
nsIncrementalDownload::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsIncrementalDownload::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsIncrementalDownload::GetLoadGroup(nsILoadGroup** loadGroup) {
return NS_ERROR_NOT_IMPLEMENTED;

10
netwerk/base/nsInputStreamPump.cpp
View File

@ -244,16 +244,6 @@ nsInputStreamPump::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamPump::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsInputStreamPump::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsInputStreamPump::GetLoadGroup(nsILoadGroup** aLoadGroup) {
RecursiveMutexAutoLock lock(mMutex);

10
netwerk/base/nsLoadGroup.cpp
View File

@ -344,16 +344,6 @@ nsLoadGroup::SetLoadFlags(uint32_t aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsLoadGroup::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsLoadGroup::GetLoadGroup(nsILoadGroup** loadGroup) {
nsCOMPtr<nsILoadGroup> result = mLoadGroup;

3
netwerk/base/nsSocketTransport2.cpp
View File

@ -1039,9 +1039,6 @@ nsresult nsSocketTransport::ResolveHost() {
if (mConnectionFlags & nsSocketTransport::DISABLE_TRR)
dnsFlags |= nsIDNSService::RESOLVE_DISABLE_TRR;
dnsFlags |= nsIDNSService::GetFlagsFromTRRMode(
nsISocketTransport::GetTRRModeFromFlags(mConnectionFlags));
NS_ASSERTION(!(dnsFlags & nsIDNSService::RESOLVE_DISABLE_IPV6) ||
!(dnsFlags & nsIDNSService::RESOLVE_DISABLE_IPV4),
"Setting both RESOLVE_DISABLE_IPV6 and RESOLVE_DISABLE_IPV4");

8
netwerk/dns/TRR.cpp
View File

@ -172,10 +172,8 @@ nsresult TRR::SendHTTPRequest() {
return NS_ERROR_FAILURE;
}
if (((mType == TRRTYPE_A) || (mType == TRRTYPE_AAAA)) &&
mRec->EffectiveTRRMode() != nsIRequest::TRR_ONLY_MODE) {
if ((mType == TRRTYPE_A) || (mType == TRRTYPE_AAAA)) {
// let NS resolves skip the blacklist check
// we also don't check the blacklist for TRR only requests
MOZ_ASSERT(mRec);
if (gTRRService->IsTRRBlacklisted(mHost, mOriginSuffix, mPB, true)) {
@ -255,10 +253,6 @@ nsresult TRR::SendHTTPRequest() {
return NS_ERROR_UNEXPECTED;
}
// This connection should not use TRR
rv = httpChannel->SetTRRMode(nsIRequest::TRR_DISABLED_MODE);
NS_ENSURE_SUCCESS(rv, rv);
rv = httpChannel->SetRequestHeader(
NS_LITERAL_CSTRING("Accept"),
NS_LITERAL_CSTRING("application/dns-message"), false);

44
netwerk/dns/TRRService.cpp
View File

@ -21,8 +21,7 @@ static const char kOpenCaptivePortalLoginEvent[] = "captive-portal-login";
static const char kClearPrivateData[] = "clear-private-data";
static const char kPurge[] = "browser:purge-session-history";
static const char kDisableIpv6Pref[] = "network.dns.disableIPv6";
static const char kPrefSkipTRRParentalControl[] =
"network.dns.skipTRR-when-parental-control-enabled";
static const char kCaptivedetectCanonicalURL[] = "captivedetect.canonicalURL";
#define TRR_PREF_PREFIX "network.trr."
#define TRR_PREF(x) TRR_PREF_PREFIX x
@ -49,7 +48,6 @@ TRRService::TRRService()
mCaptiveIsPassed(false),
mUseGET(false),
mDisableECS(true),
mSkipTRRWhenParentalControlEnabled(true),
mDisableAfterFails(5),
mClearTRRBLStorage(false),
mConfirmationState(CONFIRM_INIT),
@ -80,7 +78,7 @@ nsresult TRRService::Init() {
if (prefBranch) {
prefBranch->AddObserver(TRR_PREF_PREFIX, this, true);
prefBranch->AddObserver(kDisableIpv6Pref, this, true);
prefBranch->AddObserver(kPrefSkipTRRParentalControl, this, true);
prefBranch->AddObserver(kCaptivedetectCanonicalURL, this, true);
}
nsCOMPtr<nsICaptivePortalService> captivePortalService =
do_GetService(NS_CAPTIVEPORTAL_CID);
@ -116,13 +114,9 @@ void TRRService::GetParentalControlEnabledInternal() {
}
}
bool TRRService::Enabled(nsIRequest::TRRMode aMode) {
if (mMode == MODE_TRROFF) {
return false;
}
bool TRRService::Enabled() {
if (mConfirmationState == CONFIRM_INIT &&
(!mWaitForCaptive || mCaptiveIsPassed ||
(mMode == MODE_TRRONLY || aMode == nsIRequest::TRR_ONLY_MODE))) {
(!mWaitForCaptive || mCaptiveIsPassed || (mMode == MODE_TRRONLY))) {
LOG(("TRRService::Enabled => CONFIRM_TRYING\n"));
mConfirmationState = CONFIRM_TRYING;
}
@ -310,7 +304,8 @@ nsresult TRRService::ReadPrefs(const char* name) {
}
}
if (!name || !strcmp(name, TRR_PREF("excluded-domains")) ||
!strcmp(name, TRR_PREF("builtin-excluded-domains"))) {
!strcmp(name, TRR_PREF("builtin-excluded-domains")) ||
!strcmp(name, kCaptivedetectCanonicalURL)) {
mExcludedDomains.Clear();
auto parseExcludedDomains = [this](const char* aPrefName) {
@ -332,12 +327,18 @@ nsresult TRRService::ReadPrefs(const char* name) {
parseExcludedDomains(TRR_PREF("excluded-domains"));
parseExcludedDomains(TRR_PREF("builtin-excluded-domains"));
clearEntireCache = true;
}
if (!name || !strcmp(name, kPrefSkipTRRParentalControl)) {
bool tmp;
if (NS_SUCCEEDED(Preferences::GetBool(kPrefSkipTRRParentalControl, &tmp))) {
mSkipTRRWhenParentalControlEnabled = tmp;
nsAutoCString canonicalSiteURL;
Preferences::GetCString(kCaptivedetectCanonicalURL, canonicalSiteURL);
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_NewURI(getter_AddRefs(uri), canonicalSiteURL,
UTF_8_ENCODING, nullptr);
if (NS_SUCCEEDED(rv)) {
nsAutoCString host;
uri->GetHost(host);
LOG(("TRRService::ReadPrefs captive portal URL:[%s]\n", host.get()));
mExcludedDomains.PutEntry(host);
}
}
@ -433,9 +434,6 @@ TRRService::Observe(nsISupports* aSubject, const char* aTopic,
}
}
// We should avoid doing calling MaybeConfirm in response to a pref change
// unless the service is in a TRR=enabled mode.
if (mMode == MODE_TRRFIRST || mMode == MODE_TRRONLY) {
if (!mCaptiveIsPassed) {
if (mConfirmationState != CONFIRM_OK) {
mConfirmationState = CONFIRM_TRYING;
@ -444,8 +442,8 @@ TRRService::Observe(nsISupports* aSubject, const char* aTopic,
} else {
LOG(("TRRservice CP clear when already up!\n"));
}
mCaptiveIsPassed = true;
}
} else if (!strcmp(aTopic, kClearPrivateData) || !strcmp(aTopic, kPurge)) {
// flush the TRR blacklist, both in-memory and on-disk
@ -478,7 +476,7 @@ void TRRService::MaybeConfirm() {
void TRRService::MaybeConfirm_locked() {
mLock.AssertCurrentThreadOwns();
if (mMode == MODE_TRROFF || mConfirmer ||
if (TRR_DISABLED(mMode) || mConfirmer ||
mConfirmationState != CONFIRM_TRYING) {
LOG(
("TRRService:MaybeConfirm mode=%d, mConfirmer=%p "
@ -503,7 +501,7 @@ void TRRService::MaybeConfirm_locked() {
bool TRRService::MaybeBootstrap(const nsACString& aPossible,
nsACString& aResult) {
MutexAutoLock lock(mLock);
if (mMode == MODE_TRROFF || mBootstrapAddr.IsEmpty()) {
if (TRR_DISABLED(mMode) || mBootstrapAddr.IsEmpty()) {
return false;
}
@ -560,7 +558,7 @@ bool TRRService::IsTRRBlacklisted(const nsACString& aHost,
return true;
}
if (!Enabled(nsIRequest::TRR_DEFAULT_MODE)) {
if (!Enabled()) {
return true;
}

6
netwerk/dns/TRRService.h
View File

@ -30,7 +30,7 @@ class TRRService : public nsIObserver,
TRRService();
nsresult Init();
nsresult Start();
bool Enabled(nsIRequest::TRRMode aMode);
bool Enabled();
uint32_t Mode() { return mMode; }
bool AllowRFC1918() { return mRfc1918; }
@ -40,9 +40,6 @@ class TRRService : public nsIObserver,
bool WaitForAllResponses() { return mWaitForAllResponses; }
bool DisableIPv6() { return mDisableIPv6; }
bool DisableECS() { return mDisableECS; }
bool SkipTRRWhenParentalControlEnabled() {
return mSkipTRRWhenParentalControlEnabled;
}
nsresult GetURI(nsCString& result);
nsresult GetCredentials(nsCString& result);
uint32_t GetRequestTimeout();
@ -97,7 +94,6 @@ class TRRService : public nsIObserver,
Atomic<bool, Relaxed> mWaitForAllResponses; // Don't notify until all are in
Atomic<bool, Relaxed> mDisableIPv6; // don't even try
Atomic<bool, Relaxed> mDisableECS; // disable EDNS Client Subnet in requests
Atomic<bool, Relaxed> mSkipTRRWhenParentalControlEnabled;
Atomic<uint32_t, Relaxed>
mDisableAfterFails; // this many fails in a row means failed TRR service

99
netwerk/dns/nsHostResolver.cpp
View File

@ -153,8 +153,7 @@ static inline bool IsLowPriority(uint16_t flags) {
// host key. the significant flags are those that would affect the resulting
// host record (i.e., the flags that are passed down to PR_GetAddrInfoByName).
#define RES_KEY_FLAGS(_f) \
((_f) & (nsHostResolver::RES_CANON_NAME | nsHostResolver::RES_DISABLE_TRR | \
nsIDNSService::RESOLVE_TRR_MODE_MASK))
((_f) & (nsHostResolver::RES_CANON_NAME | nsHostResolver::RES_DISABLE_TRR))
#define IS_ADDR_TYPE(_type) ((_type) == nsIDNSService::RESOLVE_TYPE_DEFAULT)
#define IS_OTHER_TYPE(_type) ((_type) != nsIDNSService::RESOLVE_TYPE_DEFAULT)
@ -166,7 +165,12 @@ nsHostKey::nsHostKey(const nsACString& aHost, uint16_t aType, uint16_t aFlags,
flags(aFlags),
af(aAf),
pb(aPb),
originSuffix(aOriginsuffix) {}
originSuffix(aOriginsuffix) {
if (TRR_DISABLED(gTRRService->Mode())) {
// When not using TRR, lookup all answers as TRR-disabled
flags |= nsHostResolver::RES_DISABLE_TRR;
}
}
bool nsHostKey::operator==(const nsHostKey& other) const {
return host == other.host && type == other.type &&
@ -543,6 +547,8 @@ static const char kPrefGetTtl[] = "network.dns.get-ttl";
static const char kPrefNativeIsLocalhost[] = "network.dns.native-is-localhost";
static const char kPrefThreadIdleTime[] =
"network.dns.resolver-thread-extra-idle-time-seconds";
static const char kPrefSkipTRRParentalControl[] =
"network.dns.skipTRR-when-parental-control-enabled";
static bool sGetTtlEnabled = false;
mozilla::Atomic<bool, mozilla::Relaxed> gNativeIsLocalhost;
@ -572,6 +578,7 @@ nsHostResolver::nsHostResolver(uint32_t maxCacheEntries,
mLock("nsHostResolver.mLock"),
mIdleTaskCV(mLock, "nsHostResolver.mIdleTaskCV"),
mEvictionQSize(0),
mSkipTRRWhenParentalControlEnabled(true),
mShutdown(true),
mNumIdleTasks(0),
mActiveTaskCount(0),
@ -595,6 +602,8 @@ nsresult nsHostResolver::Init() {
mShutdown = false;
mNCS = NetworkConnectivityService::GetSingleton();
mSkipTRRWhenParentalControlEnabled =
Preferences::GetBool(kPrefSkipTRRParentalControl, true);
// The preferences probably haven't been loaded from the disk yet, so we
// need to register a callback that will set up the experiment once they
@ -820,7 +829,7 @@ nsresult nsHostResolver::ResolveHost(const nsACString& aHost, uint16_t type,
// By-Type requests use only TRR. If TRR is disabled we can return
// immediately.
if (IS_OTHER_TYPE(type) && Mode() == MODE_TRROFF) {
if (IS_OTHER_TYPE(type) && TRR_DISABLED(Mode())) {
return NS_ERROR_UNKNOWN_HOST;
}
@ -1186,10 +1195,6 @@ nsresult nsHostResolver::TrrLookup_unlocked(nsHostRecord* rec, TRR* pushedTRR) {
// returns error if no TRR resolve is issued
// it is impt this is not called while a native lookup is going on
nsresult nsHostResolver::TrrLookup(nsHostRecord* aRec, TRR* pushedTRR) {
if (Mode() == MODE_TRROFF) {
return NS_ERROR_UNKNOWN_HOST;
}
RefPtr<nsHostRecord> rec(aRec);
mLock.AssertCurrentThreadOwns();
@ -1212,8 +1217,7 @@ nsresult nsHostResolver::TrrLookup(nsHostRecord* aRec, TRR* pushedTRR) {
#endif
MOZ_ASSERT(!rec->mResolving);
nsIRequest::TRRMode reqMode = rec->EffectiveTRRMode();
if (!gTRRService || !gTRRService->Enabled(reqMode)) {
if (!gTRRService || !gTRRService->Enabled()) {
LOG(("TrrLookup:: %s service not enabled\n", rec->host.get()));
return NS_ERROR_UNKNOWN_HOST;
}
@ -1374,49 +1378,6 @@ ResolverMode nsHostResolver::Mode() {
return MODE_NATIVEONLY;
}
nsIRequest::TRRMode nsHostRecord::TRRMode() {
return nsIDNSService::GetTRRModeFromFlags(flags);
}
nsIRequest::TRRMode nsHostRecord::EffectiveTRRMode() {
// For domains that are excluded from TRR or when parental control is enabled,
// we fallback to NativeLookup. This happens even in MODE_TRRONLY. By default
// localhost and local are excluded (so we cover *.local hosts) See the
// network.trr.excluded-domains pref.
bool skipTRR = true;
if (gTRRService) {
skipTRR = gTRRService->IsExcludedFromTRR(host) ||
(gTRRService->SkipTRRWhenParentalControlEnabled() &&
gTRRService->ParentalControlEnabled());
}
nsIRequest::TRRMode aRequestMode = TRRMode();
if (!gTRRService) {
return aRequestMode;
}
ResolverMode aResolverMode = static_cast<ResolverMode>(gTRRService->Mode());
if (skipTRR || aResolverMode == MODE_TRROFF ||
aRequestMode == nsIRequest::TRR_DISABLED_MODE ||
(aRequestMode == nsIRequest::TRR_DEFAULT_MODE &&
aResolverMode == MODE_NATIVEONLY)) {
return nsIRequest::TRR_DISABLED_MODE;
}
if (aRequestMode == nsIRequest::TRR_DEFAULT_MODE &&
aResolverMode == MODE_TRRFIRST) {
return nsIRequest::TRR_FIRST_MODE;
}
if (aRequestMode == nsIRequest::TRR_DEFAULT_MODE &&
aResolverMode == MODE_TRRONLY) {
return nsIRequest::TRR_ONLY_MODE;
}
return aRequestMode;
}
// Kick-off a name resolve operation, using native resolver and/or TRR
nsresult nsHostResolver::NameLookup(nsHostRecord* rec) {
nsresult rv = NS_ERROR_UNKNOWN_HOST;
@ -1425,8 +1386,8 @@ nsresult nsHostResolver::NameLookup(nsHostRecord* rec) {
return NS_OK;
}
rec->mResolverMode = Mode();
MOZ_ASSERT(rec->mResolverMode != MODE_RESERVED1);
ResolverMode mode = rec->mResolverMode = Mode();
MOZ_ASSERT(mode != MODE_RESERVED1);
if (rec->IsAddrRecord()) {
RefPtr<AddrHostRecord> addrRec = do_QueryObject(rec);
@ -1441,20 +1402,30 @@ nsresult nsHostResolver::NameLookup(nsHostRecord* rec) {
addrRec->mTrrAAAAUsed = AddrHostRecord::INIT;
}
nsIRequest::TRRMode effectiveRequestMode = rec->EffectiveTRRMode();
// For domains that are excluded from TRR or when parental control is enabled,
// we fallback to NativeLookup. This happens even in MODE_TRRONLY. By default
// localhost and local are excluded (so we cover *.local hosts) See the
// network.trr.excluded-domains pref.
bool skipTRR = true;
if (gTRRService) {
skipTRR = gTRRService->IsExcludedFromTRR(rec->host) ||
(mSkipTRRWhenParentalControlEnabled &&
gTRRService->ParentalControlEnabled());
}
LOG(("NameLookup: %s effectiveTRRmode: %d", rec->host.get(),
effectiveRequestMode));
if (rec->flags & RES_DISABLE_TRR) {
if (mode == MODE_TRRONLY && !skipTRR) {
return rv;
}
mode = MODE_NATIVEONLY;
}
if (effectiveRequestMode != nsIRequest::TRR_DISABLED_MODE &&
!(effectiveRequestMode == nsIRequest::TRR_FIRST_MODE &&
(rec->flags & RES_DISABLE_TRR))) {
if (!TRR_DISABLED(mode) && !skipTRR) {
rv = TrrLookup(rec);
}
if (effectiveRequestMode == nsIRequest::TRR_DISABLED_MODE ||
(effectiveRequestMode == nsIRequest::TRR_FIRST_MODE &&
(rec->flags & RES_DISABLE_TRR) && NS_FAILED(rv))) {
if (TRR_DISABLED(mode) || ((mode == MODE_TRRFIRST) && NS_FAILED(rv)) ||
(mode == MODE_TRRONLY && skipTRR)) {
if (!rec->IsAddrRecord()) {
return rv;
}

7
netwerk/dns/nsHostResolver.h
View File

@ -81,12 +81,6 @@ class nsHostRecord : public mozilla::LinkedListElement<RefPtr<nsHostRecord>>,
return 0;
}
// Returns the TRR mode encoded by the flags
nsIRequest::TRRMode TRRMode();
// Returns a TRR mode that takes into account if the TRR service is disabled,
// parental controls are on, domain matches exclusion list, etc.
nsIRequest::TRRMode EffectiveTRRMode();
protected:
friend class nsHostResolver;
@ -557,6 +551,7 @@ class nsHostResolver : public nsISupports, public AHostResolver {
PRTime mCreationTime;
mozilla::TimeDuration mLongIdleTimeout;
mozilla::TimeDuration mShortIdleTimeout;
bool mSkipTRRWhenParentalControlEnabled;
RefPtr<nsIThreadPool> mResolverThreads;
RefPtr<mozilla::net::NetworkConnectivityService> mNCS;

17
netwerk/dns/nsIDNSService.idl
View File

@ -3,7 +3,6 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "nsIRequest.idl"
%{ C++
#include "mozilla/BasePrincipal.h"
@ -295,22 +294,6 @@ interface nsIDNSService : nsISupports
*/
const unsigned long RESOLVE_REFRESH_CACHE = (1 << 10);
/**
* These two bits encode the TRR mode of the request.
* Use the static helper methods convert between the TRR mode and flags.
*/
const unsigned long RESOLVE_TRR_MODE_MASK = (1 << 11) | (1 << 12);
%{C++
static uint32_t GetFlagsFromTRRMode(nsIRequest::TRRMode aMode) {
return static_cast<uint32_t>(aMode) << 11;
}
static nsIRequest::TRRMode GetTRRModeFromFlags(uint32_t aFlags) {
return static_cast<nsIRequest::TRRMode>((aFlags & RESOLVE_TRR_MODE_MASK) >> 11);
}
%}
/**
* This ure dns request types that are currently supported.
* RESOLVE_TYPE_DEFAULT is standard A/AAAA lookup

4
netwerk/ipc/NeckoParent.cpp
View File

@ -637,14 +637,14 @@ mozilla::ipc::IPCResult NeckoParent::RecvSpeculativeConnect(
mozilla::ipc::IPCResult NeckoParent::RecvHTMLDNSPrefetch(
const nsString& hostname, const bool& isHttps,
const OriginAttributes& aOriginAttributes, const uint32_t& flags) {
const OriginAttributes& aOriginAttributes, const uint16_t& flags) {
nsHTMLDNSPrefetch::Prefetch(hostname, isHttps, aOriginAttributes, flags);
return IPC_OK();
}
mozilla::ipc::IPCResult NeckoParent::RecvCancelHTMLDNSPrefetch(
const nsString& hostname, const bool& isHttps,
const OriginAttributes& aOriginAttributes, const uint32_t& flags,
const OriginAttributes& aOriginAttributes, const uint16_t& flags,
const nsresult& reason) {
nsHTMLDNSPrefetch::CancelPrefetch(hostname, isHttps, aOriginAttributes, flags,
reason);

4
netwerk/ipc/NeckoParent.h
View File

@ -163,10 +163,10 @@ class NeckoParent : public PNeckoParent {
const bool& aAnonymous);
mozilla::ipc::IPCResult RecvHTMLDNSPrefetch(
const nsString& hostname, const bool& isHttps,
const OriginAttributes& aOriginAttributes, const uint32_t& flags);
const OriginAttributes& aOriginAttributes, const uint16_t& flags);
mozilla::ipc::IPCResult RecvCancelHTMLDNSPrefetch(
const nsString& hostname, const bool& isHttps,
const OriginAttributes& aOriginAttributes, const uint32_t& flags,
const OriginAttributes& aOriginAttributes, const uint16_t& flags,
const nsresult& reason);
PWebSocketEventListenerParent* AllocPWebSocketEventListenerParent(
const uint64_t& aInnerWindowID);

4
netwerk/ipc/PNecko.ipdl
View File

@ -104,10 +104,10 @@ parent:
async SpeculativeConnect(URIParams uri, nsIPrincipal principal, bool anonymous);
async HTMLDNSPrefetch(nsString hostname, bool isHttps,
OriginAttributes originAttributes, uint32_t flags);
OriginAttributes originAttributes, uint16_t flags);
async CancelHTMLDNSPrefetch(nsString hostname, bool isHttps,
OriginAttributes originAttributes,
uint32_t flags, nsresult reason);
uint16_t flags, nsresult reason);
/**
* channelId is used to establish a connection between redirect channels in

10
netwerk/protocol/http/ClassifierDummyChannel.cpp
View File

@ -296,16 +296,6 @@ ClassifierDummyChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
ClassifierDummyChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
ClassifierDummyChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
ClassifierDummyChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_ERROR_NOT_IMPLEMENTED;

10
netwerk/protocol/http/HttpBaseChannel.cpp
View File

@ -484,16 +484,6 @@ HttpBaseChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
HttpBaseChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
HttpBaseChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
HttpBaseChannel::SetDocshellUserAgentOverride() {
// This sets the docshell specific user agent override

2
netwerk/protocol/http/HttpBaseChannel.h
View File

@ -141,8 +141,6 @@ class HttpBaseChannel : public nsHashPropertyBag,
NS_IMETHOD SetLoadGroup(nsILoadGroup* aLoadGroup) override;
NS_IMETHOD GetLoadFlags(nsLoadFlags* aLoadFlags) override;
NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags) override;
NS_IMETHOD GetTRRMode(nsIRequest::TRRMode* aTRRMode) override;
NS_IMETHOD SetTRRMode(nsIRequest::TRRMode aTRRMode) override;
NS_IMETHOD SetDocshellUserAgentOverride();
// nsIChannel

10
netwerk/protocol/http/NullHttpChannel.cpp
View File

@ -449,16 +449,6 @@ NullHttpChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
NullHttpChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
NullHttpChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
NullHttpChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_ERROR_NOT_IMPLEMENTED;

12
netwerk/protocol/http/nsHttp.h
View File

@ -111,6 +111,10 @@ const char kHttp3VersionHEX[] = "ff00000017"; // this is draft 23.
// on ERROR_NET_RESET.
#define NS_HTTP_CONNECTION_RESTARTABLE (1 << 13)
// Disallow name resolutions for this transaction to use TRR - primarily
// for use with TRR implementations themselves
#define NS_HTTP_DISABLE_TRR (1 << 14)
// Allow re-using a spdy/http2 connection with NS_HTTP_ALLOW_KEEPALIVE not set.
// This is primarily used to allow connection sharing for websockets over http/2
// without accidentally allowing it for websockets not over http/2
@ -127,14 +131,6 @@ const char kHttp3VersionHEX[] = "ff00000017"; // this is draft 23.
// The connection should not use IPv6
#define NS_HTTP_DISABLE_IPV6 (1 << 18)
// Encodes the TRR mode.
#define NS_HTTP_TRR_MODE_MASK ((1 << 19) | (1 << 20))
#define NS_HTTP_TRR_FLAGS_FROM_MODE(x) ((static_cast<uint32_t>(x) & 3) << 19)
#define NS_HTTP_TRR_MODE_FROM_FLAGS(x) \
(static_cast<nsIRequest::TRRMode>((((x)&NS_HTTP_TRR_MODE_MASK) >> 19) & 3))
//-----------------------------------------------------------------------------
// some default values
//-----------------------------------------------------------------------------

14
netwerk/protocol/http/nsHttpChannel.cpp
View File

@ -620,10 +620,12 @@ nsresult nsHttpChannel::ContinueOnBeforeConnect(bool aShouldUpgrade,
}
if (mIsTRRServiceChannel) {
mCaps |= NS_HTTP_LARGE_KEEPALIVE;
mCaps |= NS_HTTP_LARGE_KEEPALIVE | NS_HTTP_DISABLE_TRR;
}
mCaps |= NS_HTTP_TRR_FLAGS_FROM_MODE(nsIRequest::GetTRRMode());
if (mLoadFlags & LOAD_DISABLE_TRR) {
mCaps |= NS_HTTP_DISABLE_TRR;
}
// Finalize ConnectionInfo flags before SpeculativeConnect
mConnectionInfo->SetAnonymous((mLoadFlags & LOAD_ANONYMOUS) != 0);
@ -634,7 +636,7 @@ nsresult nsHttpChannel::ContinueOnBeforeConnect(bool aShouldUpgrade,
mBeConservative);
mConnectionInfo->SetTlsFlags(mTlsFlags);
mConnectionInfo->SetIsTrrServiceChannel(mIsTRRServiceChannel);
mConnectionInfo->SetTRRMode(nsIRequest::GetTRRMode());
mConnectionInfo->SetTrrDisabled(mCaps & NS_HTTP_DISABLE_TRR);
mConnectionInfo->SetIPv4Disabled(mCaps & NS_HTTP_DISABLE_IPV4);
mConnectionInfo->SetIPv6Disabled(mCaps & NS_HTTP_DISABLE_IPV6);
@ -907,7 +909,7 @@ void nsHttpChannel::SpeculativeConnect() {
Unused << gHttpHandler->SpeculativeConnect(
mConnectionInfo, callbacks,
mCaps & (NS_HTTP_DISALLOW_SPDY | NS_HTTP_TRR_MODE_MASK |
mCaps & (NS_HTTP_DISALLOW_SPDY | NS_HTTP_DISABLE_TRR |
NS_HTTP_DISABLE_IPV4 | NS_HTTP_DISABLE_IPV6));
}
@ -6839,8 +6841,8 @@ void nsHttpChannel::MaybeStartDNSPrefetch() {
mCaps & NS_HTTP_REFRESH_DNS ? ", refresh requested" : ""));
OriginAttributes originAttributes;
NS_GetOriginAttributes(this, originAttributes);
mDNSPrefetch = new nsDNSPrefetch(
mURI, originAttributes, nsIRequest::GetTRRMode(), this, mTimingEnabled);
mDNSPrefetch =
new nsDNSPrefetch(mURI, originAttributes, this, mTimingEnabled);
mDNSPrefetch->PrefetchHigh(mCaps & NS_HTTP_REFRESH_DNS);
}
}

20
netwerk/protocol/http/nsHttpConnectionInfo.cpp
View File

@ -106,7 +106,7 @@ void nsHttpConnectionInfo::Init(const nsACString& host, int32_t port,
mOriginAttributes = originAttributes;
mTlsFlags = 0x0;
mIsTrrServiceChannel = false;
mTRRMode = nsIRequest::TRR_DEFAULT_MODE;
mTrrDisabled = false;
mIPv4Disabled = false;
mIPv6Disabled = false;
@ -234,13 +234,11 @@ void nsHttpConnectionInfo::BuildHashKey() {
mHashKey.AppendLiteral("}");
}
if (GetTRRMode() != nsIRequest::TRR_DEFAULT_MODE) {
// When connecting with another TRR mode, we enforce a separate connection
if (GetTrrDisabled()) {
// When connecting with TRR disabled, we enforce a separate connection
// hashkey so that we also can trigger a fresh DNS resolver that then
// doesn't use TRR as the previous connection might have.
mHashKey.AppendLiteral("[TRR:");
mHashKey.AppendInt(GetTRRMode());
mHashKey.AppendLiteral("]");
mHashKey.AppendLiteral("[NOTRR]");
}
if (GetIPv4Disabled()) {
@ -327,7 +325,7 @@ already_AddRefed<nsHttpConnectionInfo> nsHttpConnectionInfo::Clone() const {
clone->SetBeConservative(GetBeConservative());
clone->SetTlsFlags(GetTlsFlags());
clone->SetIsTrrServiceChannel(GetIsTrrServiceChannel());
clone->SetTRRMode(GetTRRMode());
clone->SetTrrDisabled(GetTrrDisabled());
clone->SetIPv4Disabled(GetIPv4Disabled());
clone->SetIPv6Disabled(GetIPv6Disabled());
MOZ_ASSERT(clone->Equals(this));
@ -353,7 +351,7 @@ void nsHttpConnectionInfo::CloneAsDirectRoute(nsHttpConnectionInfo** outCI) {
clone->SetBeConservative(GetBeConservative());
clone->SetTlsFlags(GetTlsFlags());
clone->SetIsTrrServiceChannel(GetIsTrrServiceChannel());
clone->SetTRRMode(GetTRRMode());
clone->SetTrrDisabled(GetTrrDisabled());
clone->SetIPv4Disabled(GetIPv4Disabled());
clone->SetIPv6Disabled(GetIPv6Disabled());
@ -380,9 +378,9 @@ nsresult nsHttpConnectionInfo::CreateWildCard(nsHttpConnectionInfo** outParam) {
return NS_OK;
}
void nsHttpConnectionInfo::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
if (mTRRMode != aTRRMode) {
mTRRMode = aTRRMode;
void nsHttpConnectionInfo::SetTrrDisabled(bool aNoTrr) {
if (mTrrDisabled != aNoTrr) {
mTrrDisabled = aNoTrr;
RebuildHashKey();
}
}

8
netwerk/protocol/http/nsHttpConnectionInfo.h
View File

@ -149,8 +149,10 @@ class nsHttpConnectionInfo final : public ARefBase {
}
bool GetIsTrrServiceChannel() const { return mIsTrrServiceChannel; }
void SetTRRMode(nsIRequest::TRRMode aTRRMode);
nsIRequest::TRRMode GetTRRMode() const { return mTRRMode; }
// SetTrrDisabled means don't use TRR to resolve host names for this
// connection
void SetTrrDisabled(bool aNoTrr);
bool GetTrrDisabled() const { return mTrrDisabled; }
void SetIPv4Disabled(bool aNoIPv4);
bool GetIPv4Disabled() const { return mIPv4Disabled; }
@ -231,11 +233,11 @@ class nsHttpConnectionInfo final : public ARefBase {
bool mUsingConnect; // if will use CONNECT with http proxy
nsCString mNPNToken;
OriginAttributes mOriginAttributes;
nsIRequest::TRRMode mTRRMode;
uint32_t mTlsFlags;
uint16_t mIsolated : 1;
uint16_t mIsTrrServiceChannel : 1;
uint16_t mTrrDisabled : 1;
uint16_t mIPv4Disabled : 1;
uint16_t mIPv6Disabled : 1;

5
netwerk/protocol/http/nsHttpConnectionMgr.cpp
View File

@ -4099,8 +4099,9 @@ nsresult nsHttpConnectionMgr::nsHalfOpenSocket::SetupStreams(
uint32_t tmpFlags = 0;
if (mCaps & NS_HTTP_REFRESH_DNS) tmpFlags = nsISocketTransport::BYPASS_CACHE;
tmpFlags |= nsISocketTransport::GetFlagsFromTRRMode(
NS_HTTP_TRR_MODE_FROM_FLAGS(mCaps));
if (mCaps & NS_HTTP_DISABLE_TRR) {
tmpFlags = nsISocketTransport::DISABLE_TRR;
}
if (mCaps & NS_HTTP_LOAD_ANONYMOUS)
tmpFlags |= nsISocketTransport::ANONYMOUS_CONNECT;

10
netwerk/protocol/viewsource/nsViewSourceChannel.cpp
View File

@ -377,16 +377,6 @@ nsViewSourceChannel::SetLoadFlags(uint32_t aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
nsViewSourceChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return nsIViewSourceChannel::GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsViewSourceChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return nsIViewSourceChannel::SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsViewSourceChannel::GetContentType(nsACString& aContentType) {
NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE);

10
netwerk/streamconv/converters/nsMultiMixedConv.cpp
View File

@ -198,16 +198,6 @@ nsPartChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
nsPartChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsPartChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
nsPartChannel::GetIsDocument(bool* aIsDocument) {
return NS_GetIsDocumentChannel(this, aIsDocument);

226
netwerk/test/unit/test_trr.js
View File

@ -1,6 +1,6 @@
"use strict";
const { NodeServer, HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
const { NodeServer } = ChromeUtils.import("resource://testing-common/httpd.js");
const dns = Cc["@mozilla.org/network/dns-service;1"].getService(
Ci.nsIDNSService
);
@ -144,6 +144,7 @@ class DNSListener {
return this.promise.then.apply(this.promise, arguments);
}
}
add_task(async function test0_nodeExecute() {
// This test checks that moz-http2.js running in node is working.
// This should always be the first test in this file (except for setup)
@ -155,126 +156,6 @@ add_task(async function test0_nodeExecute() {
);
});
function makeChan(url, mode) {
let chan = NetUtil.newChannel({
uri: url,
loadUsingSystemPrincipal: true,
}).QueryInterface(Ci.nsIHttpChannel);
chan.setTRRMode(mode);
return chan;
}
add_task(async function test_trr_flags() {
let httpserv = new HttpServer();
httpserv.registerPathHandler("/", function handler(metadata, response) {
let content = "ok";
response.setHeader("Content-Length", `${content.length}`);
response.bodyOutputStream.write(content, content.length);
});
httpserv.start(-1);
const URL = `http://example.com:${httpserv.identity.primaryPort}/`;
dns.clearCache(true);
Services.prefs.setCharPref(
"network.trr.uri",
`https://localhost:${h2Port}/doh?responseIP=127.9.0.9`
);
Services.prefs.setIntPref("network.trr.mode", 0);
dns.clearCache(true);
let chan = makeChan(URL, Ci.nsIRequest.TRR_DEFAULT_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
equal(chan.getTRRMode(), Ci.nsIRequest.TRR_DEFAULT_MODE);
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_DISABLED_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
equal(chan.getTRRMode(), Ci.nsIRequest.TRR_DISABLED_MODE);
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_FIRST_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
equal(chan.getTRRMode(), Ci.nsIRequest.TRR_FIRST_MODE);
dns.clearCache(true);
chan = makeChan(
`http://example.com:${httpserv.identity.primaryPort}/`,
Ci.nsIRequest.TRR_ONLY_MODE
);
// Should fail as it tries to connect to local but unavailable IP
await new Promise(resolve =>
chan.asyncOpen(new ChannelListener(resolve, null, CL_EXPECT_FAILURE))
);
equal(chan.getTRRMode(), Ci.nsIRequest.TRR_ONLY_MODE);
dns.clearCache(true);
Services.prefs.setCharPref(
"network.trr.uri",
`https://localhost:${h2Port}/doh?responseIP=127.9.2.9`
);
Services.prefs.setIntPref("network.trr.mode", 2);
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_DEFAULT_MODE);
// Does get the IP from TRR, but failure means it falls back to DNS.
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_DISABLED_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
// Does get the IP from TRR, but failure means it falls back to DNS.
chan = makeChan(URL, Ci.nsIRequest.TRR_FIRST_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_ONLY_MODE);
await new Promise(resolve =>
chan.asyncOpen(new ChannelListener(resolve, null, CL_EXPECT_FAILURE))
);
dns.clearCache(true);
Services.prefs.setCharPref(
"network.trr.uri",
`https://localhost:${h2Port}/doh?responseIP=127.9.3.9`
);
Services.prefs.setIntPref("network.trr.mode", 3);
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_DEFAULT_MODE);
await new Promise(resolve =>
chan.asyncOpen(new ChannelListener(resolve, null, CL_EXPECT_FAILURE))
);
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_DISABLED_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_FIRST_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_ONLY_MODE);
await new Promise(resolve =>
chan.asyncOpen(new ChannelListener(resolve, null, CL_EXPECT_FAILURE))
);
dns.clearCache(true);
Services.prefs.setIntPref("network.trr.mode", 5);
Services.prefs.setCharPref(
"network.trr.uri",
`https://localhost:${h2Port}/doh?responseIP=1.1.1.1`
);
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_DEFAULT_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_DISABLED_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_FIRST_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
dns.clearCache(true);
chan = makeChan(URL, Ci.nsIRequest.TRR_ONLY_MODE);
await new Promise(resolve => chan.asyncOpen(new ChannelListener(resolve)));
await new Promise(resolve => httpserv.stop(resolve));
});
// verify basic A record
add_task(async function test1() {
dns.clearCache(true);
@ -860,61 +741,15 @@ add_task(async function test24e() {
await new DNSListener("bar.example.com", "127.0.0.1");
});
function observerPromise(topic) {
return new Promise(resolve => {
let observer = {
QueryInterface: ChromeUtils.generateQI([Ci.nsIObserver]),
observe(aSubject, aTopic, aData) {
dump(`observe: ${aSubject}, ${aTopic}, ${aData} \n`);
if (aTopic == topic) {
Services.obs.removeObserver(observer, topic);
resolve(aData);
}
},
};
Services.obs.addObserver(observer, topic);
});
}
// TRR-first check that captivedetect.canonicalURL is resolved via native DNS
add_task(async function test24f() {
dns.clearCache(true);
const cpServer = new HttpServer();
cpServer.registerPathHandler("/cp", function handleRawData(
request,
response
) {
response.setHeader("Content-Type", "text/plain", false);
response.setHeader("Cache-Control", "no-cache", false);
response.bodyOutputStream.write("data", 4);
});
cpServer.start(-1);
cpServer.identity.setPrimary(
"http",
"detectportal.firefox.com",
cpServer.identity.primaryPort
);
let cpPromise = observerPromise("captive-portal-login");
Services.prefs.setCharPref(
"captivedetect.canonicalURL",
`http://detectportal.firefox.com:${cpServer.identity.primaryPort}/cp`
"http://test.detectportal.com/success.txt"
);
Services.prefs.setBoolPref("network.captive-portal-service.testMode", true);
Services.prefs.setBoolPref("network.captive-portal-service.enabled", true);
// The captive portal has to have used native DNS, otherwise creating
// a socket to a non-local IP would trigger a crash.
await cpPromise;
// Simply resolving the captive portal domain should still use TRR
await new DNSListener("detectportal.firefox.com", "192.192.192.192");
Services.prefs.clearUserPref("network.captive-portal-service.enabled");
Services.prefs.clearUserPref("network.captive-portal-service.testMode");
Services.prefs.clearUserPref("captivedetect.canonicalURL");
await new Promise(resolve => cpServer.stop(resolve));
await new DNSListener("test.detectportal.com", "127.0.0.1");
});
// TRR-first check that a domain is resolved via native DNS when parental control is enabled.
@ -1027,46 +862,16 @@ add_task(async function test25d() {
add_task(async function test25e() {
dns.clearCache(true);
Services.prefs.setIntPref("network.trr.mode", 3); // TRR-only
Services.prefs.setCharPref(
"captivedetect.canonicalURL",
"http://test.detectportal.com/success.txt"
);
Services.prefs.setCharPref(
"network.trr.uri",
`https://foo.example.com:${h2Port}/doh?responseIP=192.192.192.192`
);
const cpServer = new HttpServer();
cpServer.registerPathHandler("/cp", function handleRawData(
request,
response
) {
response.setHeader("Content-Type", "text/plain", false);
response.setHeader("Cache-Control", "no-cache", false);
response.bodyOutputStream.write("data", 4);
});
cpServer.start(-1);
cpServer.identity.setPrimary(
"http",
"detectportal.firefox.com",
cpServer.identity.primaryPort
);
let cpPromise = observerPromise("captive-portal-login");
Services.prefs.setCharPref(
"captivedetect.canonicalURL",
`http://detectportal.firefox.com:${cpServer.identity.primaryPort}/cp`
);
Services.prefs.setBoolPref("network.captive-portal-service.testMode", true);
Services.prefs.setBoolPref("network.captive-portal-service.enabled", true);
// The captive portal has to have used native DNS, otherwise creating
// a socket to a non-local IP would trigger a crash.
await cpPromise;
// // Simply resolving the captive portal domain should still use TRR
await new DNSListener("detectportal.firefox.com", "192.192.192.192");
Services.prefs.clearUserPref("network.captive-portal-service.enabled");
Services.prefs.clearUserPref("network.captive-portal-service.testMode");
Services.prefs.clearUserPref("captivedetect.canonicalURL");
await new Promise(resolve => cpServer.stop(resolve));
await new DNSListener("test.detectportal.com", "127.0.0.1");
});
// TRR-only check that a domain is resolved via native DNS when parental control is enabled.
@ -1204,9 +1009,9 @@ add_task(async function test_connection_closed_no_bootstrap_localhost() {
});
add_task(async function test_connection_closed_no_bootstrap_no_excluded() {
// This test makes sure that even in mode 3 without a bootstrap address
// we are able to restart the TRR connection if it drops - the TRR service
// channel will use regular DNS to resolve the TRR address.
// This test exists to document what happens when we're in TRR only mode
// and we don't set a bootstrap address. We use DNS to resolve the
// initial URI, but if the connection fails, we don't fallback to DNS
dns.clearCache(true);
Services.prefs.setIntPref("network.trr.mode", 3); // TRR-only
Services.prefs.setCharPref("network.trr.excluded-domains", "");
@ -1226,8 +1031,11 @@ add_task(async function test_connection_closed_no_bootstrap_no_excluded() {
!Components.isSuccessCode(inStatus),
`${inStatus} should be an error code`
);
dns.clearCache(true);
await new DNSListener("bar2.example.com", "3.3.3.3");
[, , inStatus] = await new DNSListener("bar2.example.com", undefined, false);
Assert.ok(
!Components.isSuccessCode(inStatus),
`${inStatus} should be an error code`
);
});
add_task(async function test_connection_closed_trr_first() {

2
toolkit/components/captivedetect/CaptiveDetect.jsm
View File

@ -34,7 +34,7 @@ function URLFetcher(url, timeout) {
// Prevent privacy leaks
xhr.channel.loadFlags |= Ci.nsIRequest.LOAD_ANONYMOUS;
// Use the system's resolver for this check
xhr.channel.setTRRMode(Ci.nsIRequest.TRR_DISABLED_MODE);
xhr.channel.loadFlags |= Ci.nsIRequest.LOAD_DISABLE_TRR;
// We except this from being classified
xhr.channel.loadFlags |= Ci.nsIChannel.LOAD_BYPASS_URL_CLASSIFIER;

10
toolkit/components/extensions/webrequest/StreamFilterParent.cpp
View File

@ -446,16 +446,6 @@ StreamFilterParent::SetLoadFlags(nsLoadFlags aLoadFlags) {
return mChannel->SetLoadFlags(aLoadFlags);
}
NS_IMETHODIMP
StreamFilterParent::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
StreamFilterParent::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
/*****************************************************************************
* nsIStreamListener
*****************************************************************************/

10
uriloader/exthandler/ExternalHelperAppParent.cpp
View File

@ -293,16 +293,6 @@ ExternalHelperAppParent::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP
ExternalHelperAppParent::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
ExternalHelperAppParent::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP
ExternalHelperAppParent::GetIsDocument(bool* aIsDocument) {
return NS_GetIsDocumentChannel(this, aIsDocument);

8
uriloader/exthandler/nsExternalProtocolHandler.cpp
View File

@ -238,14 +238,6 @@ NS_IMETHODIMP nsExtProtocolChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
return NS_OK;
}
NS_IMETHODIMP nsExtProtocolChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
return GetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP nsExtProtocolChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
return SetTRRModeImpl(aTRRMode);
}
NS_IMETHODIMP nsExtProtocolChannel::GetIsDocument(bool* aIsDocument) {
return NS_GetIsDocumentChannel(this, aIsDocument);
}