mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out changeset 365e0d2414bf (bug 1504728) for browser-chrome failures. CLOSED TREE

This commit is contained in:
Dorel Luca 2018-11-09 18:48:39 +02:00
Родитель fc396face6
Коммит 2f261feba3
29 изменённых файлов: 69 добавлений и 350 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

8
docshell/base/nsDocShell.cpp
Просмотреть файл

@ -1511,14 +1511,6 @@ nsDocShell::GetHasForeignCookiesBeenBlocked(bool* aHasForeignCookiesBeenBlocked)
return NS_OK;
}
NS_IMETHODIMP
nsDocShell::GetHasCookiesLoaded(bool* aHasCookiesLoaded)
{
nsCOMPtr<nsIDocument> doc(GetDocument());
*aHasCookiesLoaded = doc && doc->GetHasCookiesLoaded();
return NS_OK;
}
NS_IMETHODIMP
nsDocShell::GetAllowPlugins(bool* aAllowPlugins)
{

6
docshell/base/nsIDocShell.idl
Просмотреть файл

@ -649,12 +649,6 @@ interface nsIDocShell : nsIDocShellTreeItem
*/
[infallible] readonly attribute boolean hasForeignCookiesBeenBlocked;
/**
* This attribute determines whether a document seen cookies or storage
* attempts ever whether they've been allowed or blocked.
*/
[infallible] readonly attribute boolean hasCookiesLoaded;
/**
* Disconnects this docshell's editor from its window, and stores the
* editor data in the open document's session history entry. This

17
dom/base/Navigator.cpp
Просмотреть файл

@ -544,17 +544,16 @@ Navigator::CookieEnabled()
}
uint32_t rejectedReason = 0;
bool granted =
AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(mWindow,
if (AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(mWindow,
codebaseURI,
&rejectedReason);
&rejectedReason)) {
return true;
}
AntiTrackingCommon::NotifyBlockingDecision(mWindow,
granted ?
AntiTrackingCommon::BlockingDecision::eAllow :
AntiTrackingCommon::BlockingDecision::eBlock,
rejectedReason);
return granted;
if (rejectedReason) {
AntiTrackingCommon::NotifyRejection(mWindow, rejectedReason);
}
return false;
}
bool

14
dom/base/nsContentUtils.cpp
Просмотреть файл

@ -8902,19 +8902,11 @@ nsContentUtils::StorageDisabledByAntiTracking(nsPIDOMWindowInner* aWindow,
bool disabled =
StorageDisabledByAntiTrackingInternal(aWindow, aChannel, aPrincipal, aURI,
&rejectedReason);
if (sAntiTrackingControlCenterUIEnabled) {
if (disabled && sAntiTrackingControlCenterUIEnabled && rejectedReason) {
if (aWindow) {
AntiTrackingCommon::NotifyBlockingDecision(aWindow,
disabled ?
AntiTrackingCommon::BlockingDecision::eBlock :
AntiTrackingCommon::BlockingDecision::eAllow,
rejectedReason);
AntiTrackingCommon::NotifyRejection(aWindow, rejectedReason);
} else if (aChannel) {
AntiTrackingCommon::NotifyBlockingDecision(aChannel,
disabled ?
AntiTrackingCommon::BlockingDecision::eBlock :
AntiTrackingCommon::BlockingDecision::eAllow,
rejectedReason);
AntiTrackingCommon::NotifyRejection(aChannel, rejectedReason);
}
}
return disabled;

9
dom/base/nsGlobalWindowOuter.cpp
Просмотреть файл

@ -5375,15 +5375,6 @@ nsGlobalWindowOuter::NotifyContentBlockingState(unsigned aState,
if (!aBlocked) {
unblocked = !doc->GetHasForeignCookiesBlocked();
}
} else if (aState == nsIWebProgressListener::STATE_COOKIES_LOADED) {
MOZ_ASSERT(!aBlocked, "We don't expected to see blocked STATE_COOKIES_LOADED");
// Note that the logic in this branch is the logical negation of the logic
// in other branches, since the nsIDocument API we have is phrased in
// "loaded" terms as opposed to "blocked" terms.
doc->SetHasCookiesLoaded(!aBlocked, origin);
if (!aBlocked) {
unblocked = doc->GetHasCookiesLoaded();
}
} else {
// Ignore nsIWebProgressListener::STATE_BLOCKED_UNSAFE_CONTENT;
}

20
dom/base/nsIDocument.h
Просмотреть файл

@ -1111,26 +1111,6 @@ public:
aHasCookiesBlockedByPermission);
}
/**
* Set the cookies loaded flag for this document.
*/
void SetHasCookiesLoaded(bool aHasCookiesLoaded,
const nsAString& aOriginLoaded)
{
RecordContentBlockingLog(aOriginLoaded,
nsIWebProgressListener::STATE_COOKIES_LOADED,
!aHasCookiesLoaded);
}
/**
* Get cookies loaded flag for this document.
*/
bool GetHasCookiesLoaded()
{
return !mContentBlockingLog.HasBlockedAnyOfType(
nsIWebProgressListener::STATE_COOKIES_LOADED);
}
/**
* Get tracking content loaded flag for this document.
*/

7
netwerk/base/SimpleChannelParent.cpp
Просмотреть файл

@ -38,13 +38,6 @@ SimpleChannelParent::NotifyTrackingProtectionDisabled()
return NS_OK;
}
NS_IMETHODIMP
SimpleChannelParent::NotifyCookieAllowed()
{
// Nothing to do.
return NS_OK;
}
NS_IMETHODIMP
SimpleChannelParent::NotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{

6
netwerk/base/nsIParentChannel.idl
Просмотреть файл

@ -34,12 +34,6 @@ interface nsIParentChannel : nsIStreamListener
*/
[noscript] void notifyTrackingProtectionDisabled();
/**
* Called to notify the HttpChannelChild that cookie has been allowed for
* this load.
*/
[noscript] void notifyCookieAllowed();
/**
* Called to notify the HttpChannelChild that cookie has been blocked for
* this load.

13
netwerk/cookie/nsCookieService.cpp
Просмотреть файл

@ -2269,7 +2269,6 @@ nsCookieService::SetCookieStringInternal(nsIURI *aHostURI,
return;
case STATUS_ACCEPTED: // Fallthrough
case STATUS_ACCEPT_SESSION:
NotifyAccepted(aChannel);
if (aIsForeign) {
NotifyThirdParty(aHostURI, true, aChannel);
}
@ -2289,14 +2288,6 @@ nsCookieService::SetCookieStringInternal(nsIURI *aHostURI,
}
}
void
nsCookieService::NotifyAccepted(nsIChannel* aChannel)
{
AntiTrackingCommon::NotifyBlockingDecision(aChannel,
AntiTrackingCommon::BlockingDecision::eAllow,
0);
}
// notify observers that a cookie was rejected due to the users' prefs.
void
nsCookieService::NotifyRejected(nsIURI *aHostURI, nsIChannel* aChannel,
@ -2307,9 +2298,7 @@ nsCookieService::NotifyRejected(nsIURI *aHostURI, nsIChannel* aChannel,
os->NotifyObservers(aHostURI, "cookie-rejected", nullptr);
}
AntiTrackingCommon::NotifyBlockingDecision(aChannel,
AntiTrackingCommon::BlockingDecision::eBlock,
aRejectedReason);
AntiTrackingCommon::NotifyRejection(aChannel, aRejectedReason);
}
// notify observers that a third-party cookie was accepted/rejected

1
netwerk/cookie/nsCookieService.h
Просмотреть файл

@ -319,7 +319,6 @@ class nsCookieService final : public nsICookieService
bool FindSecureCookie(const nsCookieKey& aKey, nsCookie* aCookie);
void FindStaleCookies(nsCookieEntry *aEntry, int64_t aCurrentTime, const mozilla::Maybe<bool> &aIsSecure, nsTArray<nsListIter>& aOutput, uint32_t aLimit);
void TelemetryForEvictingStaleCookie(nsCookie* aEvicted, int64_t oldestCookieTime);
void NotifyAccepted(nsIChannel* aChannel);
void NotifyRejected(nsIURI *aHostURI, nsIChannel* aChannel, uint32_t aRejectedReason);
void NotifyThirdParty(nsIURI *aHostURI, bool aAccepted, nsIChannel *aChannel);
void NotifyChanged(nsISupports *aSubject, const char16_t *aData, bool aOldCookieIsSession = false, bool aFromHttp = false);

7
netwerk/protocol/data/DataChannelParent.cpp
Просмотреть файл

@ -38,13 +38,6 @@ DataChannelParent::NotifyTrackingProtectionDisabled()
return NS_OK;
}
NS_IMETHODIMP
DataChannelParent::NotifyCookieAllowed()
{
// Nothing to do.
return NS_OK;
}
NS_IMETHODIMP
DataChannelParent::NotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{

7
netwerk/protocol/file/FileChannelParent.cpp
Просмотреть файл

@ -38,13 +38,6 @@ FileChannelParent::NotifyTrackingProtectionDisabled()
return NS_OK;
}
NS_IMETHODIMP
FileChannelParent::NotifyCookieAllowed()
{
// Nothing to do.
return NS_OK;
}
NS_IMETHODIMP
FileChannelParent::NotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{

7
netwerk/protocol/ftp/FTPChannelParent.cpp
Просмотреть файл

@ -577,13 +577,6 @@ FTPChannelParent::NotifyTrackingProtectionDisabled()
return NS_OK;
}
NS_IMETHODIMP
FTPChannelParent::NotifyCookieAllowed()
{
// One day, this should probably be filled in.
return NS_OK;
}
NS_IMETHODIMP
FTPChannelParent::NotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{

15
netwerk/protocol/http/HttpBackgroundChannelChild.cpp
Просмотреть файл

@ -348,21 +348,6 @@ HttpBackgroundChannelChild::RecvNotifyTrackingProtectionDisabled()
return IPC_OK();
}
IPCResult
HttpBackgroundChannelChild::RecvNotifyCookieAllowed()
{
LOG(("HttpBackgroundChannelChild::RecvNotifyCookieAllowed [this=%p]\n", this));
MOZ_ASSERT(OnSocketThread());
if (NS_WARN_IF(!mChannelChild)) {
return IPC_OK();
}
mChannelChild->ProcessNotifyCookieAllowed();
return IPC_OK();
}
IPCResult
HttpBackgroundChannelChild::RecvNotifyTrackingCookieBlocked(const uint32_t& aRejectedReason)
{

2
netwerk/protocol/http/HttpBackgroundChannelChild.h
Просмотреть файл

@ -65,8 +65,6 @@ protected:
IPCResult RecvNotifyTrackingProtectionDisabled() override;
IPCResult RecvNotifyCookieAllowed() override;
IPCResult RecvNotifyTrackingCookieBlocked(const uint32_t& aRejectedReason) override;
IPCResult RecvNotifyTrackingResource(const bool& aIsThirdParty) override;

29
netwerk/protocol/http/HttpBackgroundChannelParent.cpp
Просмотреть файл

@ -379,35 +379,6 @@ HttpBackgroundChannelParent::OnNotifyTrackingProtectionDisabled()
return SendNotifyTrackingProtectionDisabled();
}
bool
HttpBackgroundChannelParent::OnNotifyCookieAllowed()
{
LOG(("HttpBackgroundChannelParent::OnNotifyCookieAllowed [this=%p]\n", this));
AssertIsInMainProcess();
if (NS_WARN_IF(!mIPCOpened)) {
return false;
}
if (!IsOnBackgroundThread()) {
MutexAutoLock lock(mBgThreadMutex);
RefPtr<HttpBackgroundChannelParent> self = this;
nsresult rv = mBackgroundThread->Dispatch(
NS_NewRunnableFunction(
"net::HttpBackgroundChannelParent::OnNotifyCookieAllowed",
[self]() {
self->OnNotifyCookieAllowed();
}),
NS_DISPATCH_NORMAL);
MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
return NS_SUCCEEDED(rv);
}
return SendNotifyCookieAllowed();
}
bool
HttpBackgroundChannelParent::OnNotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{

3
netwerk/protocol/http/HttpBackgroundChannelParent.h
Просмотреть файл

@ -69,9 +69,6 @@ public:
// To send NotifyTrackingProtectionDisabled message over background channel.
bool OnNotifyTrackingProtectionDisabled();
// To send NotifyCookieAllowed message over background channel.
bool OnNotifyCookieAllowed();
// To send NotifyTrackingCookieBlocked message over background channel.
bool OnNotifyTrackingCookieBlocked(uint32_t aRejectedReason);

23
netwerk/protocol/http/HttpChannelChild.cpp
Просмотреть файл

@ -2049,25 +2049,6 @@ HttpChannelChild::ProcessNotifyTrackingProtectionDisabled()
NS_DISPATCH_NORMAL);
}
void
HttpChannelChild::ProcessNotifyCookieAllowed()
{
LOG(("HttpChannelChild::ProcessNotifyCookieAllowed [this=%p]\n", this));
MOZ_ASSERT(OnSocketThread());
RefPtr<HttpChannelChild> self = this;
nsCOMPtr<nsIEventTarget> neckoTarget = GetNeckoTarget();
neckoTarget->Dispatch(
NS_NewRunnableFunction(
"nsChannelClassifier::NotifyBlockingDecision",
[self]() {
AntiTrackingCommon::NotifyBlockingDecision(self,
AntiTrackingCommon::BlockingDecision::eAllow,
0);
}),
NS_DISPATCH_NORMAL);
}
void
HttpChannelChild::ProcessNotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{
@ -2080,9 +2061,7 @@ HttpChannelChild::ProcessNotifyTrackingCookieBlocked(uint32_t aRejectedReason)
NS_NewRunnableFunction(
"nsChannelClassifier::NotifyTrackingCookieBlocked",
[self, aRejectedReason]() {
AntiTrackingCommon::NotifyBlockingDecision(self,
AntiTrackingCommon::BlockingDecision::eBlock,
aRejectedReason);
AntiTrackingCommon::NotifyRejection(self, aRejectedReason);
}),
NS_DISPATCH_NORMAL);
}

1
netwerk/protocol/http/HttpChannelChild.h
Просмотреть файл

@ -259,7 +259,6 @@ private:
void ProcessFlushedForDiversion();
void ProcessDivertMessages();
void ProcessNotifyTrackingProtectionDisabled();
void ProcessNotifyCookieAllowed();
void ProcessNotifyTrackingCookieBlocked(uint32_t aRejectedReason);
void ProcessNotifyTrackingResource(bool aIsThirdParty);
void ProcessSetClassifierMatchedInfo(const nsCString& aList,

11
netwerk/protocol/http/HttpChannelParent.cpp
Просмотреть файл

@ -1903,17 +1903,6 @@ HttpChannelParent::NotifyTrackingProtectionDisabled()
return NS_OK;
}
NS_IMETHODIMP
HttpChannelParent::NotifyCookieAllowed()
{
LOG(("HttpChannelParent::NotifyCookieAllowed [this=%p]\n", this));
if (!mIPCClosed) {
MOZ_ASSERT(mBgParent);
Unused << NS_WARN_IF(!mBgParent->OnNotifyCookieAllowed());
}
return NS_OK;
}
NS_IMETHODIMP
HttpChannelParent::NotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{

3
netwerk/protocol/http/PHttpBackgroundChannel.ipdl
Просмотреть файл

@ -56,9 +56,6 @@ child:
// Tell the child that tracking protection was disabled for this load.
async NotifyTrackingProtectionDisabled();
// Tell the child that cookies are allowed for this load.
async NotifyCookieAllowed();
// Tell the child that tracking cookies are blocked for this load.
async NotifyTrackingCookieBlocked(uint32_t aRejectedReason);

10
netwerk/protocol/http/nsHttpChannel.cpp
Просмотреть файл

@ -838,19 +838,13 @@ nsHttpChannel::ConnectOnTailUnblock()
LOG(("nsHttpChannel::ConnectOnTailUnblock [this=%p]\n", this));
bool isTrackingResource = mIsThirdPartyTrackingResource; // is atomic
if (isTrackingResource) {
bool engageFastBlock = CheckFastBlocked();
AntiTrackingCommon::NotifyBlockingDecision(this,
engageFastBlock ?
AntiTrackingCommon::BlockingDecision::eBlock :
AntiTrackingCommon::BlockingDecision::eAllow,
if (isTrackingResource && CheckFastBlocked()) {
AntiTrackingCommon::NotifyRejection(this,
nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT);
if (engageFastBlock) {
Unused << AsyncAbort(NS_ERROR_TRACKING_ANNOTATION_URI);
CloseCacheEntry(false);
return NS_OK;
}
}
// Consider opening a TCP connection right away.
SpeculativeConnect();

4
security/manager/ssl/nsSecureBrowserUIImpl.cpp
Просмотреть файл

@ -205,10 +205,6 @@ nsSecureBrowserUIImpl::CheckForBlockedContent()
if (docShell->GetHasAllCookiesBeenBlocked()) {
mState |= STATE_COOKIES_BLOCKED_ALL;
}
if (docShell->GetHasCookiesLoaded()) {
mState |= STATE_COOKIES_LOADED;
}
}
// Helper function to determine if the given URI can be considered secure.

48
toolkit/components/antitracking/AntiTrackingCommon.cpp
Просмотреть файл

@ -494,7 +494,7 @@ AntiTrackingCommon::AddFirstPartyStorageAccessGrantedFor(nsIPrincipal* aPrincipa
LOG_SPEC(("Tracking principal (%s) hasn't been interacted with before, "
"refusing to add a first-party storage permission to access it",
_spec), trackingURI);
NotifyBlockingDecision(aParentWindow, BlockingDecision::eBlock, blockReason);
NotifyRejection(aParentWindow, blockReason);
return StorageAccessGrantPromise::CreateAndReject(false, __func__);
}
@ -1205,41 +1205,26 @@ AntiTrackingCommon::IsOnContentBlockingAllowList(nsIURI* aTopWinURI,
}
/* static */ void
AntiTrackingCommon::NotifyBlockingDecision(nsIChannel* aChannel,
BlockingDecision aDecision,
AntiTrackingCommon::NotifyRejection(nsIChannel* aChannel,
uint32_t aRejectedReason)
{
MOZ_ASSERT(aRejectedReason == 0 ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
MOZ_ASSERT(aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN ||
aRejectedReason == nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT);
MOZ_ASSERT(aDecision == BlockingDecision::eBlock ||
aDecision == BlockingDecision::eAllow);
if (!aChannel) {
return;
}
// When we allow loads, collapse all cookie related reason codes into STATE_COOKIES_LOADED.
bool sendCookieLoadedNotification = false;
if (aRejectedReason != nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT) {
sendCookieLoadedNotification = true;
}
// Can be called in EITHER the parent or child process.
nsCOMPtr<nsIParentChannel> parentChannel;
NS_QueryNotificationCallbacks(aChannel, parentChannel);
if (parentChannel) {
// This channel is a parent-process proxy for a child process request.
// Tell the child process channel to do this instead.
if (aDecision == BlockingDecision::eBlock) {
parentChannel->NotifyTrackingCookieBlocked(aRejectedReason);
} else {
// Ignore the code related to fastblock
parentChannel->NotifyCookieAllowed();
}
return;
}
@ -1261,38 +1246,22 @@ AntiTrackingCommon::NotifyBlockingDecision(nsIChannel* aChannel,
nsCOMPtr<nsIURI> uri;
aChannel->GetURI(getter_AddRefs(uri));
if (aDecision == BlockingDecision::eBlock) {
pwin->NotifyContentBlockingState(aRejectedReason, aChannel, true, uri);
ReportBlockingToConsole(pwin, uri, aRejectedReason);
}
if (sendCookieLoadedNotification) {
pwin->NotifyContentBlockingState(nsIWebProgressListener::STATE_COOKIES_LOADED,
aChannel, false, uri);
}
}
/* static */ void
AntiTrackingCommon::NotifyBlockingDecision(nsPIDOMWindowInner* aWindow,
BlockingDecision aDecision,
AntiTrackingCommon::NotifyRejection(nsPIDOMWindowInner* aWindow,
uint32_t aRejectedReason)
{
MOZ_ASSERT(aWindow);
MOZ_ASSERT(aRejectedReason == 0 ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
MOZ_ASSERT(aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN ||
aRejectedReason == nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT);
MOZ_ASSERT(aDecision == BlockingDecision::eBlock ||
aDecision == BlockingDecision::eAllow);
// When we allow loads, collapse all cookie related reason codes into STATE_COOKIES_LOADED.
bool sendCookieLoadedNotification = false;
if (aRejectedReason != nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT) {
sendCookieLoadedNotification = true;
}
nsCOMPtr<nsPIDOMWindowOuter> pwin = GetTopWindow(aWindow);
if (!pwin) {
@ -1318,16 +1287,9 @@ AntiTrackingCommon::NotifyBlockingDecision(nsPIDOMWindowInner* aWindow,
}
nsIURI* uri = document->GetDocumentURI();
if (aDecision == BlockingDecision::eBlock) {
pwin->NotifyContentBlockingState(aRejectedReason, channel, true, uri);
ReportBlockingToConsole(pwin, uri, aRejectedReason);
}
if (sendCookieLoadedNotification) {
pwin->NotifyContentBlockingState(nsIWebProgressListener::STATE_COOKIES_LOADED,
channel, false, uri);
}
}
/* static */ void

14
toolkit/components/antitracking/AntiTrackingCommon.h
Просмотреть файл

@ -129,18 +129,10 @@ public:
ContentBlockingAllowListPurpose aPurpose,
bool& aIsAllowListed);
enum class BlockingDecision {
eBlock,
eAllow,
};
// This method can be called on the parent process or on the content process.
// The notification is propagated to the child channel if aChannel is a parent
// channel proxy.
//
// aDecision can be eBlock if we have decided to block some content, or eAllow
// if we have decided to allow the content through.
//
// aRejectedReason must be one of these values:
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER
@ -148,12 +140,10 @@ public:
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN
// * nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT
static void
NotifyBlockingDecision(nsIChannel* aChannel, BlockingDecision aDecision,
uint32_t aRejectedReason);
NotifyRejection(nsIChannel* aChannel, uint32_t aRejectedReason);
static void
NotifyBlockingDecision(nsPIDOMWindowInner* aWindow, BlockingDecision aDecision,
uint32_t aRejectedReason);
NotifyRejection(nsPIDOMWindowInner* aWindow, uint32_t aRejectedReason);
};
} // namespace mozilla

63
toolkit/components/antitracking/test/browser/browser_subResources.js
Просмотреть файл

@ -156,54 +156,29 @@ add_task(async function() {
is(text, 1, "One cookie received received for scripts.");
});
let expectTrackerBlocked = (item, blocked) => {
is(item[0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
"Correct blocking type reported");
is(item[1], blocked,
"Correct blocking status reported");
ok(item[2] >= 1,
"Correct repeat count reported");
};
let expectTrackerFound = item => {
is(item[0], Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT,
"Correct blocking type reported");
is(item[1], true,
"Correct blocking status reported");
ok(item[2] >= 1,
"Correct repeat count reported");
};
let expectCookiesLoaded = item => {
is(item[0], Ci.nsIWebProgressListener.STATE_COOKIES_LOADED,
"Correct blocking type reported");
is(item[1], false,
"Correct blocking status reported");
ok(item[2] >= 1,
"Correct repeat count reported");
};
let log = JSON.parse(await browser.getContentBlockingLog());
for (let trackerOrigin in log) {
is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
let originLog = log[trackerOrigin];
is(originLog.length, 16, "We should have 16 entries in the compressed log");
expectTrackerFound(originLog[0]);
expectCookiesLoaded(originLog[1]);
expectTrackerBlocked(originLog[2], true);
expectCookiesLoaded(originLog[3]);
expectTrackerBlocked(originLog[4], true);
expectCookiesLoaded(originLog[5]);
expectTrackerBlocked(originLog[6], true);
expectCookiesLoaded(originLog[7]);
expectTrackerBlocked(originLog[8], true);
expectCookiesLoaded(originLog[9]);
expectTrackerBlocked(originLog[10], true);
expectCookiesLoaded(originLog[11]);
expectTrackerBlocked(originLog[12], true);
expectCookiesLoaded(originLog[13]);
expectTrackerBlocked(originLog[14], false);
expectCookiesLoaded(originLog[15]);
is(originLog.length, 3, "We should have 3 entries in the compressed log");
is(originLog[0][0], Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT,
"Correct blocking type reported");
is(originLog[0][1], true,
"Correct blocking status reported");
ok(originLog[0][2] >= 1,
"Correct repeat count reported");
is(originLog[1][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
"Correct blocking type reported");
is(originLog[1][1], true,
"Correct blocking status reported");
is(originLog[1][2], 6,
"Correct repeat count reported");
is(originLog[2][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
"Correct blocking type reported");
is(originLog[2][1], false,
"Correct blocking status reported");
ok(originLog[2][2] >= 1,
"Correct repeat count reported");
}
info("Removing the tab");

36
toolkit/components/antitracking/test/browser/head.js
Просмотреть файл

@ -365,16 +365,10 @@ this.AntiTracking = {
let originLog = contentBlockingLog[trackerOrigin];
for (let i = 0; i < originLog.length; ++i) {
let item = originLog[i];
switch (item[0]) {
case Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT:
is(item[0], Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT,
"Correct blocking type must be reported");
is(item[1], true, "Correct blocking status reported");
ok(item[2] >= 1, "Correct repeat count reported");
break;
case Ci.nsIWebProgressListener.STATE_COOKIES_LOADED:
is(item[1], false, "Correct blocking status reported");
ok(item[2] >= 1, "Correct repeat count reported");
break;
}
}
}
}
@ -554,11 +548,20 @@ this.AntiTracking = {
contentBlockingLog = JSON.parse(contentBlockingLogJSON);
} catch (e) {
}
// If this is the first cookie to be blocked, our state should have
// just changed, otherwise it should have previously contained the
// STATE_COOKIES_BLOCKED_TRACKER bit too.
if (cookieBlocked) {
if (cookieBlocked == 1) {
is(oldState & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER, 0,
"When blocking the first cookie, old state should not have had the " +
"STATE_COOKIES_BLOCKED_TRACKER bit");
}
for (let trackerOrigin in contentBlockingLog) {
is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
let originLog = contentBlockingLog[trackerOrigin];
ok(originLog.length >= 1, "We should have at least two items in the log");
ok(originLog.length > 1, "We should have at least two items in the log");
for (let i = 0; i < originLog.length; ++i) {
let item = originLog[i];
switch (item[0]) {
@ -580,10 +583,6 @@ this.AntiTracking = {
is(item[2], 1, "Correct repeat count reported");
}
break;
case Ci.nsIWebProgressListener.STATE_COOKIES_LOADED:
is(item[1], false, "Correct blocking status reported");
ok(item[2] >= 1, "Correct repeat count reported");
break;
}
}
}
@ -697,18 +696,17 @@ this.AntiTracking = {
}
for (let trackerOrigin in contentBlockingLog) {
is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
let originLog = contentBlockingLog[trackerOrigin];
ok(originLog.length >= 1, "We should have at least two items in the log");
ok(originLog.length > 1, "We should have at least two items in the log");
for (let i = 0; i < originLog.length; ++i) {
let item = originLog[i];
switch (item[0]) {
case Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT:
is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
is(item[1], true, "Correct blocking status reported");
ok(item[2] >= 1, "Correct repeat count reported");
break;
case Ci.nsIWebProgressListener.STATE_BLOCKED_TRACKING_CONTENT:
is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
if (item[1]) {
ok(item[2] >= 1, "Correct repeat count reported");
} else {
@ -718,16 +716,10 @@ this.AntiTracking = {
}
break;
case Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER:
is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
// We can expect 1 or more repeat count whether or not blocking has happened,
// so nothing to assert on item[1].
ok(item[2] >= 1, "Correct repeat count reported");
break;
case Ci.nsIWebProgressListener.STATE_COOKIES_LOADED:
// The trackerOrigin here is sometimes TEST_DOMAIN, sometimes TEST_3RD_PARTY_DOMAIN.
is(item[1], false, "Correct blocking status reported");
ok(item[2] >= 1, "Correct repeat count reported");
break;
}
}
}

1
uriloader/base/nsIWebProgressListener.idl
Просмотреть файл

@ -327,7 +327,6 @@ interface nsIWebProgressListener : nsISupports
* STATE_BLOCKED_SLOW_TRACKING_CONTENT
* Rejected because of the FastBlock feature.
*/
const unsigned long STATE_COOKIES_LOADED = 0x00008000;
const unsigned long STATE_COOKIES_BLOCKED_BY_PERMISSION = 0x10000000;
const unsigned long STATE_COOKIES_BLOCKED_TRACKER = 0x20000000;
const unsigned long STATE_COOKIES_BLOCKED_ALL = 0x40000000;

6
uriloader/exthandler/nsExternalProtocolHandler.cpp
Просмотреть файл

@ -422,12 +422,6 @@ NS_IMETHODIMP nsExtProtocolChannel::NotifyTrackingProtectionDisabled()
return NS_OK;
}
NS_IMETHODIMP nsExtProtocolChannel::NotifyCookieAllowed()
{
// nothing to do
return NS_OK;
}
NS_IMETHODIMP nsExtProtocolChannel::NotifyTrackingCookieBlocked(uint32_t aRejectedReason)
{
// nothing to do