mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-25 03:05:34 +00:00
ef89767387
Differential Revision: https://phabricator.services.mozilla.com/D17638
623 lines
16 KiB
C++
623 lines
16 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set sw=2 ts=8 et tw=80 : */
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "TrackingDummyChannel.h"
|
|
|
|
#include "mozilla/AntiTrackingCommon.h"
|
|
#include "mozilla/net/TrackingDummyChannelChild.h"
|
|
#include "mozilla/dom/ContentChild.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "nsIChannel.h"
|
|
#include "nsIURI.h"
|
|
#include "nsProxyRelease.h"
|
|
|
|
namespace mozilla {
|
|
namespace net {
|
|
|
|
/* static */ TrackingDummyChannel::StorageAllowedState
|
|
TrackingDummyChannel::StorageAllowed(
|
|
nsIChannel* aChannel, const std::function<void(bool)>& aCallback) {
|
|
MOZ_ASSERT(!XRE_IsParentProcess());
|
|
|
|
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
|
|
if (!httpChannel) {
|
|
// Any non-http channel is allowed.
|
|
return eStorageGranted;
|
|
}
|
|
|
|
if (!nsContentUtils::IsNonSubresourceRequest(aChannel)) {
|
|
// If this is a sub-resource, we don't need to check if the channel is
|
|
// annotated as tracker because:
|
|
// - if the SW doesn't respond, or it sends us back to the network, the
|
|
// channel will be annotated on the parent process.
|
|
// - if the SW answers, the content is taken from the cache, which is
|
|
// considered trusted.
|
|
return eStorageGranted;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
aChannel->GetURI(getter_AddRefs(uri));
|
|
|
|
if (StaticPrefs::privacy_trackingprotection_annotate_channels()) {
|
|
ContentChild* cc = static_cast<ContentChild*>(gNeckoChild->Manager());
|
|
if (cc->IsShuttingDown()) {
|
|
return eStorageDenied;
|
|
}
|
|
|
|
if (!TrackingDummyChannelChild::Create(httpChannel, uri, aCallback)) {
|
|
return eStorageDenied;
|
|
}
|
|
|
|
return eAsyncNeeded;
|
|
}
|
|
|
|
if (AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(httpChannel, uri,
|
|
nullptr)) {
|
|
return eStorageGranted;
|
|
}
|
|
|
|
return eStorageDenied;
|
|
}
|
|
|
|
NS_IMPL_ADDREF(TrackingDummyChannel)
|
|
NS_IMPL_RELEASE(TrackingDummyChannel)
|
|
|
|
NS_INTERFACE_MAP_BEGIN(TrackingDummyChannel)
|
|
NS_INTERFACE_MAP_ENTRY(nsIRequest)
|
|
NS_INTERFACE_MAP_ENTRY(nsIChannel)
|
|
NS_INTERFACE_MAP_ENTRY(nsIHttpChannelInternal)
|
|
NS_INTERFACE_MAP_ENTRY_CONCRETE(TrackingDummyChannel)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
TrackingDummyChannel::TrackingDummyChannel(nsIURI* aURI, nsIURI* aTopWindowURI,
|
|
nsresult aTopWindowURIResult,
|
|
nsILoadInfo* aLoadInfo)
|
|
: mTopWindowURI(aTopWindowURI),
|
|
mTopWindowURIResult(aTopWindowURIResult),
|
|
mIsTrackingResource(false) {
|
|
MOZ_ASSERT(XRE_IsParentProcess());
|
|
|
|
SetOriginalURI(aURI);
|
|
SetLoadInfo(aLoadInfo);
|
|
}
|
|
|
|
TrackingDummyChannel::~TrackingDummyChannel() {
|
|
NS_ReleaseOnMainThreadSystemGroup("TrackingDummyChannel::mLoadInfo",
|
|
mLoadInfo.forget());
|
|
NS_ReleaseOnMainThreadSystemGroup("TrackingDummyChannel::mURI",
|
|
mURI.forget());
|
|
NS_ReleaseOnMainThreadSystemGroup("TrackingDummyChannel::mTopWindowURI",
|
|
mTopWindowURI.forget());
|
|
}
|
|
|
|
bool TrackingDummyChannel::IsTrackingResource() const {
|
|
return mIsTrackingResource;
|
|
}
|
|
|
|
void TrackingDummyChannel::SetIsTrackingResource() {
|
|
mIsTrackingResource = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TrackingDummyChannel::nsIChannel
|
|
//-----------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetOriginalURI(nsIURI** aOriginalURI) {
|
|
NS_IF_ADDREF(*aOriginalURI = mURI);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetOriginalURI(nsIURI* aOriginalURI) {
|
|
mURI = aOriginalURI;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetURI(nsIURI** aURI) {
|
|
NS_IF_ADDREF(*aURI = mURI);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetOwner(nsISupports** aOwner) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetOwner(nsISupports* aOwner) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetNotificationCallbacks(
|
|
nsIInterfaceRequestor** aNotificationCallbacks) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetNotificationCallbacks(
|
|
nsIInterfaceRequestor* aNotificationCallbacks) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetSecurityInfo(nsISupports** aSecurityInfo) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetContentType(nsACString& aContentType) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetContentType(const nsACString& aContentType) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetContentCharset(nsACString& aContentCharset) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetContentCharset(const nsACString& aContentCharset) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetContentLength(int64_t* aContentLength) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetContentLength(int64_t aContentLength) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::Open(nsIInputStream** aRetval) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::Open2(nsIInputStream** aStream) {
|
|
nsCOMPtr<nsIStreamListener> listener;
|
|
nsresult rv =
|
|
nsContentSecurityManager::doContentSecurityCheck(this, listener);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return Open(aStream);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::AsyncOpen(nsIStreamListener* aListener,
|
|
nsISupports* aContext) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::AsyncOpen2(nsIStreamListener* aListener) {
|
|
nsCOMPtr<nsIStreamListener> listener = aListener;
|
|
nsresult rv =
|
|
nsContentSecurityManager::doContentSecurityCheck(this, listener);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return AsyncOpen(listener, nullptr);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetContentDisposition(uint32_t* aContentDisposition) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetContentDisposition(uint32_t aContentDisposition) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetContentDispositionFilename(
|
|
nsAString& aContentDispositionFilename) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetContentDispositionFilename(
|
|
const nsAString& aContentDispositionFilename) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetContentDispositionHeader(
|
|
nsACString& aContentDispositionHeader) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) {
|
|
NS_IF_ADDREF(*aLoadInfo = mLoadInfo);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) {
|
|
mLoadInfo = aLoadInfo;
|
|
return NS_OK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TrackingDummyChannel::nsIRequest
|
|
//-----------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetName(nsACString& aName) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::IsPending(bool* aRetval) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetStatus(nsresult* aStatus) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::Cancel(nsresult aStatus) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; }
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::Resume() { return NS_ERROR_NOT_IMPLEMENTED; }
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetLoadGroup(nsILoadGroup* aLoadGroup) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetIsDocument(bool* aIsDocument) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TrackingDummyChannel::nsIHttpChannelInternal
|
|
//-----------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetDocumentURI(nsIURI** aDocumentURI) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetDocumentURI(nsIURI* aDocumentURI) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetRequestVersion(uint32_t* aMajor, uint32_t* aMinor) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetResponseVersion(uint32_t* aMajor, uint32_t* aMinor) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::TakeAllSecurityMessages(
|
|
nsCOMArray<nsISecurityConsoleMessage>& aMessages) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetCookie(const char* aCookieHeader) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetupFallbackChannel(const char* aFallbackKey) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetThirdPartyFlags(uint32_t* aThirdPartyFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetThirdPartyFlags(uint32_t aThirdPartyFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetForceAllowThirdPartyCookie(
|
|
bool* aForceAllowThirdPartyCookie) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetForceAllowThirdPartyCookie(
|
|
bool aForceAllowThirdPartyCookie) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetCanceled(bool* aCanceled) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetChannelIsForDownload(bool* aChannlIsForDownload) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetChannelIsForDownload(bool aChannlIsForDownload) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetLocalAddress(nsACString& aLocalAddress) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetLocalPort(int32_t* aLocalPort) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetRemoteAddress(nsACString& aRemoteAddress) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetRemotePort(int32_t* aRemotePort) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetCacheKeysRedirectChain(
|
|
nsTArray<nsCString>* aCacheKeys) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::HTTPUpgrade(const nsACString& aProtocolName,
|
|
nsIHttpUpgradeListener* aListener) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetOnlyConnect(bool* aOnlyConnect) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetConnectOnly() { return NS_ERROR_NOT_IMPLEMENTED; }
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetAllowSpdy(bool* aAllowSpdy) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetAllowSpdy(bool aAllowSpdy) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetResponseTimeoutEnabled(bool* aResponseTimeoutEnabled) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetResponseTimeoutEnabled(bool aResponseTimeoutEnabled) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetInitialRwin(uint32_t* aInitialRwin) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetInitialRwin(uint32_t aInitialRwin) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetApiRedirectToURI(nsIURI** aApiRedirectToURI) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetAllowAltSvc(bool* aAllowAltSvc) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetAllowAltSvc(bool aAllowAltSvc) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetBeConservative(bool* aBeConservative) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetBeConservative(bool aBeConservative) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetTrr(bool* aTrr) { return NS_ERROR_NOT_IMPLEMENTED; }
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetTrr(bool aTrr) { return NS_ERROR_NOT_IMPLEMENTED; }
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetTlsFlags(uint32_t* aTlsFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetTlsFlags(uint32_t aTlsFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetLastModifiedTime(PRTime* aLastModifiedTime) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetCorsIncludeCredentials(bool* aCorsIncludeCredentials) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetCorsIncludeCredentials(bool aCorsIncludeCredentials) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetCorsMode(uint32_t* aCorsMode) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetCorsMode(uint32_t aCorsMode) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetRedirectMode(uint32_t* aRedirectMode) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetRedirectMode(uint32_t aRedirectMode) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetFetchCacheMode(uint32_t* aFetchCacheMode) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetFetchCacheMode(uint32_t aFetchCacheMode) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetTopWindowURI(nsIURI** aTopWindowURI) {
|
|
nsCOMPtr<nsIURI> topWindowURI = mTopWindowURI;
|
|
topWindowURI.forget(aTopWindowURI);
|
|
return mTopWindowURIResult;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetTopWindowURIIfUnknown(nsIURI* aTopWindowURI) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetProxyURI(nsIURI** aProxyURI) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
void TrackingDummyChannel::SetCorsPreflightParameters(
|
|
const nsTArray<nsCString>& aUnsafeHeaders) {}
|
|
|
|
void TrackingDummyChannel::SetAltDataForChild(bool aIsForChild) {}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetBlockAuthPrompt(bool* aBlockAuthPrompt) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetBlockAuthPrompt(bool aBlockAuthPrompt) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetIntegrityMetadata(nsAString& aIntegrityMetadata) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetIntegrityMetadata(
|
|
const nsAString& aIntegrityMetadata) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetConnectionInfoHashKey(
|
|
nsACString& aConnectionInfoHashKey) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetLastRedirectFlags(uint32_t* aLastRedirectFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetLastRedirectFlags(uint32_t aLastRedirectFlags) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::GetNavigationStartTimeStamp(
|
|
TimeStamp* aNavigationStartTimeStamp) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::SetNavigationStartTimeStamp(
|
|
TimeStamp aNavigationStartTimeStamp) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TrackingDummyChannel::CancelByChannelClassifier(nsresult aErrorCode) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
void TrackingDummyChannel::SetIPv4Disabled() {}
|
|
|
|
void TrackingDummyChannel::SetIPv6Disabled() {}
|
|
|
|
} // namespace net
|
|
} // namespace mozilla
|