Backed out 4 changesets (bug 1525458) for mochitest failures on test_chrome_ext_trackingprotection.html . CLOSED TREE
authorNarcis Beleuzu <nbeleuzu@mozilla.com>
Thu, 28 Feb 2019 20:35:58 +0200
changeset 519649 b3a4dde40f1543ca4b4579485cceadd9aefd7eca
parent 519648 184d162629aa8272fa2181c85c62dd9f2eeee1f8
child 519650 8fd4c49718305ec4d1f95c6d5c62f1ff798249e5
push id10862
push userffxbld-merge
push dateMon, 11 Mar 2019 13:01:11 +0000
treeherdermozilla-beta@a2e7f5c935da [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1525458
milestone67.0a1
backs out96c38e4a3d2302598a81e4928d8c9dd09b8afe08
1755b771e8c70495fedce427e27184db0bfb44d0
c6177206b968960439a5ccd0fdef1437095dec4d
5ce026db31b0f3d5f9831b2f3c546a26c9f8e093
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 4 changesets (bug 1525458) for mochitest failures on test_chrome_ext_trackingprotection.html . CLOSED TREE Backed out changeset 96c38e4a3d23 (bug 1525458) Backed out changeset 1755b771e8c7 (bug 1525458) Backed out changeset c6177206b968 (bug 1525458) Backed out changeset 5ce026db31b0 (bug 1525458)
netwerk/url-classifier/UrlClassifierCommon.cpp
netwerk/url-classifier/UrlClassifierCommon.h
netwerk/url-classifier/UrlClassifierFeatureBase.cpp
netwerk/url-classifier/UrlClassifierFeatureBase.h
netwerk/url-classifier/UrlClassifierFeatureCryptomining.cpp
netwerk/url-classifier/UrlClassifierFeatureFingerprinting.cpp
netwerk/url-classifier/UrlClassifierFeatureTrackingAnnotation.cpp
netwerk/url-classifier/UrlClassifierFeatureTrackingProtection.cpp
toolkit/components/antitracking/test/browser/3rdParty.html
toolkit/components/antitracking/test/browser/browser.ini
toolkit/components/antitracking/test/browser/browser_allowListNotifications.js
toolkit/components/antitracking/test/browser/browser_blockingCookies.js
toolkit/components/antitracking/test/browser/browser_blockingDOMCache.js
toolkit/components/antitracking/test/browser/browser_blockingIndexedDb.js
toolkit/components/antitracking/test/browser/browser_blockingIndexedDbInWorkers.js
toolkit/components/antitracking/test/browser/browser_blockingLocalStorage.js
toolkit/components/antitracking/test/browser/browser_blockingMessaging.js
toolkit/components/antitracking/test/browser/browser_blockingServiceWorkers.js
toolkit/components/antitracking/test/browser/browser_blockingSessionStorage.js
toolkit/components/antitracking/test/browser/browser_blockingSharedWorkers.js
toolkit/components/antitracking/test/browser/browser_partitionedLocalStorage.js
toolkit/components/antitracking/test/browser/browser_storageAccessRemovalNavigateSubframe.js
toolkit/components/antitracking/test/browser/head.js
toolkit/components/antitracking/test/browser/storageAccessAPIHelpers.js
toolkit/components/url-classifier/tests/browser/classifierTester.js
--- a/netwerk/url-classifier/UrlClassifierCommon.cpp
+++ b/netwerk/url-classifier/UrlClassifierCommon.cpp
@@ -83,54 +83,120 @@ UrlClassifierCommon::NotifyChannelClassi
   NS_ENSURE_TRUE_VOID(doc);
 
   nsCOMPtr<nsIURI> uri;
   aChannel->GetURI(getter_AddRefs(uri));
   pwin->NotifyContentBlockingEvent(aBlockedReason, aChannel, true, uri);
 }
 
 /* static */ bool UrlClassifierCommon::ShouldEnableClassifier(
-    nsIChannel* aChannel) {
+    nsIChannel* aChannel,
+    AntiTrackingCommon::ContentBlockingAllowListPurpose aBlockingPurpose) {
   MOZ_ASSERT(aChannel);
+  MOZ_ASSERT(aBlockingPurpose == AntiTrackingCommon::eTrackingProtection ||
+             aBlockingPurpose == AntiTrackingCommon::eTrackingAnnotations ||
+             aBlockingPurpose == AntiTrackingCommon::eFingerprinting ||
+             aBlockingPurpose == AntiTrackingCommon::eCryptomining);
+
+  nsCOMPtr<nsIHttpChannelInternal> channel = do_QueryInterface(aChannel);
+  if (!channel) {
+    UC_LOG(("nsChannelClassifier: Not an HTTP channel"));
+    return false;
+  }
 
   nsCOMPtr<nsIURI> chanURI;
   nsresult rv = aChannel->GetURI(getter_AddRefs(chanURI));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return false;
   }
 
   if (UrlClassifierCommon::AddonMayLoad(aChannel, chanURI)) {
     return false;
   }
 
+  nsCOMPtr<nsIIOService> ios = services::GetIOService();
+  if (NS_WARN_IF(!ios)) {
+    return false;
+  }
+
+  nsCOMPtr<nsIURI> topWinURI;
+  rv = channel->GetTopWindowURI(getter_AddRefs(topWinURI));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  if (!topWinURI && StaticPrefs::channelclassifier_allowlist_example()) {
+    UC_LOG(("nsChannelClassifier: Allowlisting test domain"));
+    rv = ios->NewURI(NS_LITERAL_CSTRING("http://allowlisted.example.com"),
+                     nullptr, nullptr, getter_AddRefs(topWinURI));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return false;
+    }
+  }
+
+  bool isAllowListed;
+  rv = AntiTrackingCommon::IsOnContentBlockingAllowList(
+      topWinURI, NS_UsePrivateBrowsing(aChannel), aBlockingPurpose,
+      isAllowListed);
+  if (NS_FAILED(rv)) {  // normal for some loads, no need to print a warning
+    return false;
+  }
+
+  if (isAllowListed) {
+    if (UC_LOG_ENABLED()) {
+      nsCString chanSpec = chanURI->GetSpecOrDefault();
+      chanSpec.Truncate(
+          std::min(chanSpec.Length(), UrlClassifierCommon::sMaxSpecLength));
+      UC_LOG(("nsChannelClassifier: User override on channel[%p] (%s)",
+              aChannel, chanSpec.get()));
+    }
+
+    // Channel classifier protection will be disabled so update the security
+    // state of the document and fire a secure change event. If we can't get the
+    // window for the channel, then the shield won't show up so we can't send an
+    // event to the securityUI anyway.
+
+    uint32_t event = 0;
+    switch (aBlockingPurpose) {
+      case AntiTrackingCommon::eTrackingProtection:
+        MOZ_FALLTHROUGH;
+      case AntiTrackingCommon::eTrackingAnnotations:
+        event = nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT;
+        break;
+
+      case AntiTrackingCommon::eFingerprinting:
+        event = nsIWebProgressListener::STATE_LOADED_FINGERPRINTING_CONTENT;
+        break;
+
+      case AntiTrackingCommon::eCryptomining:
+        event = nsIWebProgressListener::STATE_LOADED_CRYPTOMINING_CONTENT;
+        break;
+
+      default:
+        MOZ_CRASH("Invalidate blocking purpose.");
+    }
+
+    UrlClassifierCommon::NotifyChannelClassifierProtectionDisabled(aChannel,
+                                                                   event);
+
+    return false;
+  }
+
   // Tracking protection will be enabled so return without updating
   // the security state. If any channels are subsequently cancelled
   // (page elements blocked) the state will be then updated.
   if (UC_LOG_ENABLED()) {
-    nsCOMPtr<nsIURI> topWinURI;
-    nsCOMPtr<nsIHttpChannelInternal> channel = do_QueryInterface(aChannel);
-    if (!channel) {
-      UC_LOG(("nsChannelClassifier: Not an HTTP channel"));
-      return false;
-    }
-
-    nsresult rv = channel->GetTopWindowURI(getter_AddRefs(topWinURI));
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return false;
-    }
-
     nsCString chanSpec = chanURI->GetSpecOrDefault();
     chanSpec.Truncate(
         std::min(chanSpec.Length(), UrlClassifierCommon::sMaxSpecLength));
-    nsCString topWinSpec = topWinURI ? topWinURI->GetSpecOrDefault()
-                                     : NS_LITERAL_CSTRING("(null)");
+    nsCString topWinSpec = topWinURI->GetSpecOrDefault();
     topWinSpec.Truncate(
         std::min(topWinSpec.Length(), UrlClassifierCommon::sMaxSpecLength));
     UC_LOG(
-        ("nsChannelClassifier: Enabling url classifier checks on "
+        ("nsChannelClassifier: Enabling tracking protection checks on "
          "channel[%p] with uri %s for toplevel window uri %s",
          aChannel, chanSpec.get(), topWinSpec.get()));
   }
 
   return true;
 }
 
 /* static */ nsresult UrlClassifierCommon::SetBlockedContent(
--- a/netwerk/url-classifier/UrlClassifierCommon.h
+++ b/netwerk/url-classifier/UrlClassifierCommon.h
@@ -25,17 +25,19 @@ class UrlClassifierCommon final {
 
   static LazyLogModule sLog;
 
   static bool AddonMayLoad(nsIChannel* aChannel, nsIURI* aURI);
 
   static void NotifyChannelClassifierProtectionDisabled(
       nsIChannel* aChannel, uint32_t aAcceptedReason);
 
-  static bool ShouldEnableClassifier(nsIChannel* aChannel);
+  static bool ShouldEnableClassifier(
+      nsIChannel* aChannel,
+      AntiTrackingCommon::ContentBlockingAllowListPurpose aBlockingPurpose);
 
   static nsresult SetBlockedContent(nsIChannel* channel, nsresult aErrorCode,
                                     const nsACString& aList,
                                     const nsACString& aProvider,
                                     const nsACString& aFullHash);
 
   // Use this function only when you are looking for a pairwise whitelist uri
   // with the format: http://toplevel.page/?resource=channel.uri.domain
--- a/netwerk/url-classifier/UrlClassifierFeatureBase.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureBase.cpp
@@ -154,70 +154,10 @@ UrlClassifierFeatureBase::HasHostInPrefe
 }
 
 NS_IMETHODIMP
 UrlClassifierFeatureBase::GetSkipHostList(nsACString& aList) {
   aList = mSkipHosts;
   return NS_OK;
 }
 
-bool UrlClassifierFeatureBase::IsAllowListed(
-    nsIChannel* aChannel,
-    AntiTrackingCommon::ContentBlockingAllowListPurpose aPurpose) {
-  MOZ_ASSERT(aPurpose == AntiTrackingCommon::eTrackingProtection ||
-             aPurpose == AntiTrackingCommon::eTrackingAnnotations ||
-             aPurpose == AntiTrackingCommon::eFingerprinting ||
-             aPurpose == AntiTrackingCommon::eCryptomining);
-
-  nsCOMPtr<nsIHttpChannelInternal> channel = do_QueryInterface(aChannel);
-  if (!channel) {
-    UC_LOG(("nsChannelClassifier: Not an HTTP channel"));
-    return false;
-  }
-
-  nsCOMPtr<nsIURI> topWinURI;
-  nsresult rv = channel->GetTopWindowURI(getter_AddRefs(topWinURI));
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return false;
-  }
-
-  if (!topWinURI && StaticPrefs::channelclassifier_allowlist_example()) {
-    UC_LOG(("nsChannelClassifier: Allowlisting test domain"));
-    nsCOMPtr<nsIIOService> ios = services::GetIOService();
-    if (NS_WARN_IF(!ios)) {
-      return false;
-    }
-
-    rv = ios->NewURI(NS_LITERAL_CSTRING("http://allowlisted.example.com"),
-                     nullptr, nullptr, getter_AddRefs(topWinURI));
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return false;
-    }
-  }
-
-  bool isAllowListed = false;
-  rv = AntiTrackingCommon::IsOnContentBlockingAllowList(
-      topWinURI, NS_UsePrivateBrowsing(aChannel), aPurpose, isAllowListed);
-  if (NS_FAILED(rv)) {  // normal for some loads, no need to print a warning
-    return false;
-  }
-
-  if (isAllowListed) {
-    if (UC_LOG_ENABLED()) {
-      nsCOMPtr<nsIURI> chanURI;
-      nsresult rv = aChannel->GetURI(getter_AddRefs(chanURI));
-      if (NS_WARN_IF(NS_FAILED(rv))) {
-        return isAllowListed;
-      }
-
-      nsCString chanSpec = chanURI->GetSpecOrDefault();
-      chanSpec.Truncate(
-          std::min(chanSpec.Length(), UrlClassifierCommon::sMaxSpecLength));
-      UC_LOG(("nsChannelClassifier: User override on channel[%p] (%s)",
-              aChannel, chanSpec.get()));
-    }
-  }
-
-  return isAllowListed;
-}
-
 }  // namespace net
 }  // namespace mozilla
--- a/netwerk/url-classifier/UrlClassifierFeatureBase.h
+++ b/netwerk/url-classifier/UrlClassifierFeatureBase.h
@@ -5,17 +5,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_net_UrlClassifierFeatureBase_h
 #define mozilla_net_UrlClassifierFeatureBase_h
 
 #include "nsIUrlClassifierFeature.h"
 #include "nsTArray.h"
 #include "nsString.h"
-#include "mozilla/AntiTrackingCommon.h"
 
 namespace mozilla {
 namespace net {
 
 class UrlClassifierFeatureBase : public nsIUrlClassifierFeature {
  public:
   NS_DECL_ISUPPORTS
 
@@ -48,20 +47,16 @@ class UrlClassifierFeatureBase : public 
                            const nsACString& aPrefWhitelistTableName,
                            const nsACString& aPrefSkipHosts);
 
   virtual ~UrlClassifierFeatureBase();
 
   void InitializePreferences();
   void ShutdownPreferences();
 
-  bool IsAllowListed(
-      nsIChannel* aChannel,
-      AntiTrackingCommon::ContentBlockingAllowListPurpose aPurpose);
-
  private:
   nsCString mName;
 
   nsCString mPrefSkipHosts;
 
   // 2: blacklist and whitelist.
   nsCString mPrefTables[2];
   nsTArray<nsCString> mTables[2];
--- a/netwerk/url-classifier/UrlClassifierFeatureCryptomining.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureCryptomining.cpp
@@ -96,17 +96,18 @@ UrlClassifierFeatureCryptomining::MaybeC
            "for first party or top-level load channel[%p] "
            "with uri %s",
            aChannel, spec.get()));
     }
 
     return nullptr;
   }
 
-  if (!UrlClassifierCommon::ShouldEnableClassifier(aChannel)) {
+  if (!UrlClassifierCommon::ShouldEnableClassifier(
+          aChannel, AntiTrackingCommon::eCryptomining)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureCryptomining);
 
   RefPtr<UrlClassifierFeatureCryptomining> self = gFeatureCryptomining;
   return self.forget();
@@ -127,47 +128,32 @@ UrlClassifierFeatureCryptomining::GetIfN
 
 NS_IMETHODIMP
 UrlClassifierFeatureCryptomining::ProcessChannel(nsIChannel* aChannel,
                                                  const nsACString& aList,
                                                  bool* aShouldContinue) {
   NS_ENSURE_ARG_POINTER(aChannel);
   NS_ENSURE_ARG_POINTER(aShouldContinue);
 
-  bool isAllowListed =
-      IsAllowListed(aChannel, AntiTrackingCommon::eCryptomining);
+  // This is a blocking feature.
+  *aShouldContinue = false;
 
-  // This is a blocking feature.
-  *aShouldContinue = isAllowListed;
+  UrlClassifierCommon::SetBlockedContent(aChannel, NS_ERROR_CRYPTOMINING_URI,
+                                         aList, EmptyCString(), EmptyCString());
 
-  if (isAllowListed) {
-    // Even with cryptomining blocking disabled, we still want to show the user
-    // that there are unblocked cryptominers on the site, so notify the UI that
-    // we loaded cryptomining content.  UI code can treat this notification
-    // differently depending on whether cryptomining blocking is enabled or
-    // disabled.
-    UrlClassifierCommon::NotifyChannelClassifierProtectionDisabled(
-        aChannel, nsIWebProgressListener::STATE_LOADED_CRYPTOMINING_CONTENT);
+  UC_LOG(
+      ("UrlClassifierFeatureCryptomining::ProcessChannel, cancelling "
+       "channel[%p]",
+       aChannel));
+  nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
+
+  if (httpChannel) {
+    Unused << httpChannel->CancelByChannelClassifier(NS_ERROR_CRYPTOMINING_URI);
   } else {
-    UrlClassifierCommon::SetBlockedContent(aChannel, NS_ERROR_CRYPTOMINING_URI,
-                                           aList, EmptyCString(),
-                                           EmptyCString());
-
-    UC_LOG(
-        ("UrlClassifierFeatureCryptomining::ProcessChannel, cancelling "
-         "channel[%p]",
-         aChannel));
-    nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
-
-    if (httpChannel) {
-      Unused << httpChannel->CancelByChannelClassifier(
-          NS_ERROR_CRYPTOMINING_URI);
-    } else {
-      Unused << aChannel->Cancel(NS_ERROR_CRYPTOMINING_URI);
-    }
+    Unused << aChannel->Cancel(NS_ERROR_CRYPTOMINING_URI);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 UrlClassifierFeatureCryptomining::GetURIByListType(
     nsIChannel* aChannel, nsIUrlClassifierFeature::listType aListType,
--- a/netwerk/url-classifier/UrlClassifierFeatureFingerprinting.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureFingerprinting.cpp
@@ -98,17 +98,18 @@ UrlClassifierFeatureFingerprinting::Mayb
            "for first party or top-level load channel[%p] "
            "with uri %s",
            aChannel, spec.get()));
     }
 
     return nullptr;
   }
 
-  if (!UrlClassifierCommon::ShouldEnableClassifier(aChannel)) {
+  if (!UrlClassifierCommon::ShouldEnableClassifier(
+          aChannel, AntiTrackingCommon::eFingerprinting)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureFingerprinting);
 
   RefPtr<UrlClassifierFeatureFingerprinting> self = gFeatureFingerprinting;
   return self.forget();
@@ -129,47 +130,33 @@ UrlClassifierFeatureFingerprinting::GetI
 
 NS_IMETHODIMP
 UrlClassifierFeatureFingerprinting::ProcessChannel(nsIChannel* aChannel,
                                                    const nsACString& aList,
                                                    bool* aShouldContinue) {
   NS_ENSURE_ARG_POINTER(aChannel);
   NS_ENSURE_ARG_POINTER(aShouldContinue);
 
-  bool isAllowListed =
-      IsAllowListed(aChannel, AntiTrackingCommon::eFingerprinting);
+  // This is a blocking feature.
+  *aShouldContinue = false;
 
-  // This is a blocking feature.
-  *aShouldContinue = isAllowListed;
+  UrlClassifierCommon::SetBlockedContent(aChannel, NS_ERROR_FINGERPRINTING_URI,
+                                         aList, EmptyCString(), EmptyCString());
 
-  if (isAllowListed) {
-    // Even with fingerprinting blocking disabled, we still want to show the
-    // user that there are unblocked trackers on the site, so notify the UI that
-    // we loaded tracking content.  UI code can treat this notification
-    // differently depending on whether fingerprinting blocking is enabled or
-    // not.
-    UrlClassifierCommon::NotifyChannelClassifierProtectionDisabled(
-        aChannel, nsIWebProgressListener::STATE_LOADED_FINGERPRINTING_CONTENT);
+  UC_LOG(
+      ("UrlClassifierFeatureFingerprinting::ProcessChannel, cancelling "
+       "channel[%p]",
+       aChannel));
+  nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
+
+  if (httpChannel) {
+    Unused << httpChannel->CancelByChannelClassifier(
+        NS_ERROR_FINGERPRINTING_URI);
   } else {
-    UrlClassifierCommon::SetBlockedContent(aChannel,
-                                           NS_ERROR_FINGERPRINTING_URI, aList,
-                                           EmptyCString(), EmptyCString());
-
-    UC_LOG(
-        ("UrlClassifierFeatureFingerprinting::ProcessChannel, cancelling "
-         "channel[%p]",
-         aChannel));
-    nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
-
-    if (httpChannel) {
-      Unused << httpChannel->CancelByChannelClassifier(
-          NS_ERROR_FINGERPRINTING_URI);
-    } else {
-      Unused << aChannel->Cancel(NS_ERROR_FINGERPRINTING_URI);
-    }
+    Unused << aChannel->Cancel(NS_ERROR_FINGERPRINTING_URI);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 UrlClassifierFeatureFingerprinting::GetURIByListType(
     nsIChannel* aChannel, nsIUrlClassifierFeature::listType aListType,
--- a/netwerk/url-classifier/UrlClassifierFeatureTrackingAnnotation.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureTrackingAnnotation.cpp
@@ -149,17 +149,18 @@ UrlClassifierFeatureTrackingAnnotation::
 
   UC_LOG(("UrlClassifierFeatureTrackingAnnotation: MaybeCreate for channel %p",
           aChannel));
 
   if (!StaticPrefs::privacy_trackingprotection_annotate_channels()) {
     return nullptr;
   }
 
-  if (!UrlClassifierCommon::ShouldEnableClassifier(aChannel)) {
+  if (!UrlClassifierCommon::ShouldEnableClassifier(
+          aChannel, AntiTrackingCommon::eTrackingAnnotations)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureTrackingAnnotation);
 
   RefPtr<UrlClassifierFeatureTrackingAnnotation> self =
       gFeatureTrackingAnnotation;
@@ -199,38 +200,34 @@ UrlClassifierFeatureTrackingAnnotation::
          "nsIChannel::GetURI(%p) failed",
          (void*)aChannel));
     return NS_OK;
   }
 
   bool isThirdPartyWithTopLevelWinURI =
       nsContentUtils::IsThirdPartyWindowOrChannel(nullptr, aChannel, chanURI);
 
-  bool isAllowListed =
-      IsAllowListed(aChannel, AntiTrackingCommon::eTrackingAnnotations);
-
   UC_LOG(
       ("UrlClassifierFeatureTrackingAnnotation::ProcessChannel, annotating "
        "channel[%p]",
        aChannel));
 
   SetIsTrackingResourceHelper(aChannel, isThirdPartyWithTopLevelWinURI);
 
-  if (isThirdPartyWithTopLevelWinURI || isAllowListed) {
+  if (isThirdPartyWithTopLevelWinURI) {
     // Even with TP disabled, we still want to show the user that there
     // are unblocked trackers on the site, so notify the UI that we loaded
     // tracking content. UI code can treat this notification differently
     // depending on whether TP is enabled or disabled.
     UrlClassifierCommon::NotifyChannelClassifierProtectionDisabled(
         aChannel, nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT);
-  }
 
-  if (isThirdPartyWithTopLevelWinURI &&
-      StaticPrefs::privacy_trackingprotection_lower_network_priority()) {
-    LowerPriorityHelper(aChannel);
+    if (StaticPrefs::privacy_trackingprotection_lower_network_priority()) {
+      LowerPriorityHelper(aChannel);
+    }
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 UrlClassifierFeatureTrackingAnnotation::GetURIByListType(
     nsIChannel* aChannel, nsIUrlClassifierFeature::listType aListType,
--- a/netwerk/url-classifier/UrlClassifierFeatureTrackingProtection.cpp
+++ b/netwerk/url-classifier/UrlClassifierFeatureTrackingProtection.cpp
@@ -96,17 +96,18 @@ UrlClassifierFeatureTrackingProtection::
            "protection checks for first party or top-level load channel[%p] "
            "with uri %s",
            aChannel, spec.get()));
     }
 
     return nullptr;
   }
 
-  if (!UrlClassifierCommon::ShouldEnableClassifier(aChannel)) {
+  if (!UrlClassifierCommon::ShouldEnableClassifier(
+          aChannel, AntiTrackingCommon::eTrackingProtection)) {
     return nullptr;
   }
 
   MaybeInitialize();
   MOZ_ASSERT(gFeatureTrackingProtection);
 
   RefPtr<UrlClassifierFeatureTrackingProtection> self =
       gFeatureTrackingProtection;
@@ -130,36 +131,31 @@ UrlClassifierFeatureTrackingProtection::
 
 NS_IMETHODIMP
 UrlClassifierFeatureTrackingProtection::ProcessChannel(nsIChannel* aChannel,
                                                        const nsACString& aList,
                                                        bool* aShouldContinue) {
   NS_ENSURE_ARG_POINTER(aChannel);
   NS_ENSURE_ARG_POINTER(aShouldContinue);
 
-  bool isAllowListed =
-      IsAllowListed(aChannel, AntiTrackingCommon::eTrackingProtection);
+  // This is a blocking feature.
+  *aShouldContinue = false;
 
-  // This is a blocking feature.
-  *aShouldContinue = isAllowListed;
-
-  if (isAllowListed) {
-    UrlClassifierCommon::SetBlockedContent(
-        aChannel, NS_ERROR_TRACKING_URI, aList, EmptyCString(), EmptyCString());
+  UrlClassifierCommon::SetBlockedContent(aChannel, NS_ERROR_TRACKING_URI, aList,
+                                         EmptyCString(), EmptyCString());
 
-    UC_LOG(
-        ("UrlClassifierFeatureTrackingProtection::ProcessChannel, cancelling "
-         "channel[%p]",
-         aChannel));
-    nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
-    if (httpChannel) {
-      Unused << httpChannel->CancelByChannelClassifier(NS_ERROR_TRACKING_URI);
-    } else {
-      Unused << aChannel->Cancel(NS_ERROR_TRACKING_URI);
-    }
+  UC_LOG(
+      ("UrlClassifierFeatureTrackingProtection::ProcessChannel, cancelling "
+       "channel[%p]",
+       aChannel));
+  nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
+  if (httpChannel) {
+    Unused << httpChannel->CancelByChannelClassifier(NS_ERROR_TRACKING_URI);
+  } else {
+    Unused << aChannel->Cancel(NS_ERROR_TRACKING_URI);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 UrlClassifierFeatureTrackingProtection::GetURIByListType(
     nsIChannel* aChannel, nsIUrlClassifierFeature::listType aListType,
--- a/toolkit/components/antitracking/test/browser/3rdParty.html
+++ b/toolkit/components/antitracking/test/browser/3rdParty.html
@@ -15,30 +15,17 @@ function ok(what, msg) {
   parent.postMessage({ type: "ok", what: !!what, msg }, "*");
 }
 
 function is(a, b, msg) {
   ok(a === b, msg);
 }
 
 onmessage = function(e) {
-  let data = e.data;
-  if (data.includes("!!!")) {
-    // The data argument may be packed with information about whether we are on
-    // the allow list.  In that case, extract that information and prepare it
-    // for our callbacks to access it.
-    let parts = data.split("!!!");
-    // Only consider ourselves allow-listed when the cookie policy is set to
-    // block third-party trackers, since otherwise we won't obtain storage
-    // access by default, which is what this data is used for in tests.
-    window.allowListed = parts[0] === "true" &&
-                         (SpecialPowers.Services.prefs.getIntPref("network.cookie.cookieBehavior") == SpecialPowers.Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER);
-    data = parts[1];
-  }
-  let runnableStr = `(() => {return (${data});})();`;
+  let runnableStr = `(() => {return (${e.data});})();`;
   let runnable = eval(runnableStr); // eslint-disable-line no-eval
   runnable.call(this, /* Phase */ 1).then(_ => {
     parent.postMessage({ type: "finish" }, "*");
   });
 };
 
 </script>
 </body>
--- a/toolkit/components/antitracking/test/browser/browser.ini
+++ b/toolkit/components/antitracking/test/browser/browser.ini
@@ -19,19 +19,16 @@ support-files =
   3rdPartyOpen.html
   3rdPartyOpenUI.html
   empty.js
   popup.html
   server.sjs
   storageAccessAPIHelpers.js
   !/browser/modules/test/browser/head.js
 
-[browser_allowListNotifications.js]
-skip-if = serviceworker_e10s
-support-files = subResources.sjs
 [browser_addonHostPermissionIgnoredInTP.js]
 [browser_allowListSeparationInPrivateAndNormalWindows.js]
 skip-if = os == "mac" && !debug # Bug 1503778
 [browser_backgroundImageAssertion.js]
 [browser_blockingCookies.js]
 [browser_blockingDOMCache.js]
 skip-if = (os == "win" && os_version == "6.1" && bits == 32 && !debug) # Bug 1491937
 [browser_blockingIndexedDb.js]
deleted file mode 100644
--- a/toolkit/components/antitracking/test/browser/browser_allowListNotifications.js
+++ /dev/null
@@ -1,113 +0,0 @@
-add_task(async function() {
-  info("Starting subResources test");
-
-  await SpecialPowers.flushPrefEnv();
-  await SpecialPowers.pushPrefEnv({"set": [
-    ["browser.contentblocking.allowlist.annotations.enabled", true],
-    ["browser.contentblocking.allowlist.storage.enabled", true],
-    ["network.cookie.cookieBehavior", Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER],
-    ["privacy.trackingprotection.enabled", false],
-    ["privacy.trackingprotection.pbmode.enabled", false],
-    ["privacy.trackingprotection.annotate_channels", true],
-  ]});
-
-  await UrlClassifierTestUtils.addTestTrackers();
-
-  info("Creating a new tab");
-  let tab = BrowserTestUtils.addTab(gBrowser, TEST_TOP_PAGE);
-  gBrowser.selectedTab = tab;
-
-  let browser = gBrowser.getBrowserForTab(tab);
-  await BrowserTestUtils.browserLoaded(browser);
-
-  ContentBlocking.disableForCurrentPage();
-
-  // The previous function reloads the browser, so wait for it to load again!
-  await BrowserTestUtils.browserLoaded(browser);
-
-  // Now load subresources from a few third-party origins.
-  // We should expect to see none of these origins in the content blocking log at the end.
-  await fetch("https://test1.example.com/browser/toolkit/components/antitracking/test/browser/subResources.sjs?result&what=image")
-    .then(r => r.text())
-    .then(text => {
-      is(text, 0, "Cookies received for images");
-    });
-
-  await fetch("https://test2.example.com/browser/toolkit/components/antitracking/test/browser/subResources.sjs?result&what=image")
-    .then(r => r.text())
-    .then(text => {
-      is(text, 0, "Cookies received for images");
-    });
-
-  info("Creating a 3rd party content");
-  await ContentTask.spawn(browser,
-                          { page: TEST_3RD_PARTY_PAGE,
-                            blockingCallback: (async _ => {}).toString(),
-                            nonBlockingCallback: (async _ => {}).toString(),
-                          },
-                          async function(obj) {
-    await new content.Promise(resolve => {
-      let ifr = content.document.createElement("iframe");
-      ifr.onload = function() {
-        info("Sending code to the 3rd party content");
-        ifr.contentWindow.postMessage(obj.blockingCallback, "*");
-      };
-
-      content.addEventListener("message", function msg(event) {
-        if (event.data.type == "finish") {
-          content.removeEventListener("message", msg);
-          resolve();
-          return;
-        }
-
-        if (event.data.type == "ok") {
-          ok(event.data.what, event.data.msg);
-          return;
-        }
-
-        if (event.data.type == "info") {
-          info(event.data.msg);
-          return;
-        }
-
-        ok(false, "Unknown message");
-      });
-
-      content.document.body.appendChild(ifr);
-      ifr.src = obj.page;
-    });
-  });
-
-  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 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, 1, "We should have 1 entry in the compressed log");
-    expectTrackerFound(originLog[0]);
-  }
-
-  ContentBlocking.enableForCurrentPage();
-
-  // The previous function reloads the browser, so wait for it to load again!
-  await BrowserTestUtils.browserLoaded(browser);
-
-  info("Removing the tab");
-  BrowserTestUtils.removeTab(tab);
-});
-
-add_task(async function() {
-  info("Cleaning up.");
-  await new Promise(resolve => {
-    Services.clearData.deleteData(Ci.nsIClearDataService.CLEAR_ALL, value => resolve());
-  });
-});
-
--- a/toolkit/components/antitracking/test/browser/browser_blockingCookies.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingCookies.js
@@ -73,21 +73,17 @@ AntiTracking.runTest("Cookies and Storag
     } else {
       is(document.cookie, "name=value", "I have the cookies!");
     }
   },
 
   // Non blocking callback
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     is(document.cookie, "", "No cookies for me");
 
     await fetch("server.sjs").then(r => r.text()).then(text => {
       is(text, "cookie-not-present", "We should not have cookies");
     });
 
     document.cookie = "name=value";
--- a/toolkit/components/antitracking/test/browser/browser_blockingDOMCache.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingDOMCache.js
@@ -32,21 +32,17 @@ AntiTracking.runTest("DOM Cache and Stor
     let shouldThrow = SpecialPowers.Services.prefs.getIntPref("network.cookie.cookieBehavior") == SpecialPowers.Ci.nsICookieService.BEHAVIOR_REJECT;
 
     await caches.open("wow").then(
       _ => { ok(!shouldThrow, "DOM Cache can be used!"); },
       _ => { ok(shouldThrow, "DOM Cache can be used!"); });
   },
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     await caches.open("wow").then(
       _ => { ok(true, "DOM Cache can be used!"); },
       _ => { ok(false, "DOM Cache can be used!"); });
 
     /* import-globals-from storageAccessAPIHelpers.js */
     await callRequestStorageAccess();
 
--- a/toolkit/components/antitracking/test/browser/browser_blockingIndexedDb.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingIndexedDb.js
@@ -49,21 +49,17 @@ AntiTracking.runTest("IndexedDB and Stor
       is(e.name, "SecurityError", "We want a security error message.");
     }
 
     is(hasThrown, shouldThrow, "IDB should be allowed if not in BEHAVIOR_REJECT");
   },
   // non-blocking callback
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     indexedDB.open("test", "1");
     ok(true, "IDB should be allowed");
 
     await callRequestStorageAccess();
 
     // For non-tracking windows, calling the API is a no-op
     indexedDB.open("test", "1");
--- a/toolkit/components/antitracking/test/browser/browser_blockingIndexedDbInWorkers.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingIndexedDbInWorkers.js
@@ -140,21 +140,17 @@ AntiTracking.runTest("IndexedDB in worke
   },
   async _ => {
     function nonBlockCode() {
       indexedDB.open("test", "1");
       postMessage(true);
     }
 
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     let blob = new Blob([nonBlockCode.toString() + "; nonBlockCode();"]);
     ok(blob, "Blob has been created");
 
     let blobURL = URL.createObjectURL(blob);
     ok(blobURL, "Blob URL has been created");
 
     let worker = new Worker(blobURL);
--- a/toolkit/components/antitracking/test/browser/browser_blockingLocalStorage.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingLocalStorage.js
@@ -47,21 +47,17 @@ AntiTracking.runTest("localStorage and S
       }
     } else {
       localStorage.foo = 42;
       ok(true, "LocalStorage is allowed");
     }
   },
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     localStorage.foo = 42;
     ok(true, "LocalStorage is allowed");
 
     /* import-globals-from storageAccessAPIHelpers.js */
     await callRequestStorageAccess();
 
     // For non-tracking windows, calling the API is a no-op
--- a/toolkit/components/antitracking/test/browser/browser_blockingMessaging.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingMessaging.js
@@ -113,21 +113,17 @@ AntiTracking.runTest("BroadcastChannel a
       }
     } else {
       new BroadcastChannel("hello");
       ok(true, "BroadcastChannel can be used");
     }
   },
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     new BroadcastChannel("hello");
     ok(true, "BroadcastChanneli can be used");
 
     /* import-globals-from storageAccessAPIHelpers.js */
     await callRequestStorageAccess();
 
     new BroadcastChannel("hello");
@@ -214,21 +210,17 @@ AntiTracking.runTest("BroadcastChannel i
   },
   async _ => {
     function nonBlockingCode() {
       new BroadcastChannel("hello");
       postMessage(true);
     }
 
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     let blob = new Blob([nonBlockingCode.toString() + "; nonBlockingCode();"]);
     ok(blob, "Blob has been created");
 
     let blobURL = URL.createObjectURL(blob);
     ok(blobURL, "Blob URL has been created");
 
     let worker = new Worker(blobURL);
--- a/toolkit/components/antitracking/test/browser/browser_blockingServiceWorkers.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingServiceWorkers.js
@@ -56,21 +56,17 @@ AntiTracking.runTest("ServiceWorkers and
     await SpecialPowers.pushPrefEnv({"set": [
        ["dom.serviceWorkers.exemptFromPerDomainMax", true],
        ["dom.ipc.processCount", 1],
        ["dom.serviceWorkers.enabled", true],
        ["dom.serviceWorkers.testing.enabled", true],
     ]});
 
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     await navigator.serviceWorker.register("empty.js").then(
       reg => { ok(true, "ServiceWorker can be used!"); return reg; },
       _ => { ok(false, "ServiceWorker cannot be used!"); }).then(
       reg => reg.unregister(),
       _ => { ok(false, "unregister failed"); }).
       catch(e => ok(false, "Promise rejected: " + e));
 
--- a/toolkit/components/antitracking/test/browser/browser_blockingSessionStorage.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingSessionStorage.js
@@ -55,21 +55,17 @@ AntiTracking.runTest("sessionStorage and
       hasThrown = true;
       is(e.name, "SecurityError", "We want a security error message.");
     }
 
     is(hasThrown, shouldThrow, "SessionStorage show thrown only if cookieBehavior is REJECT");
   },
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     sessionStorage.foo = 42;
     ok(true, "SessionStorage is always allowed");
 
     /* import-globals-from storageAccessAPIHelpers.js */
     await callRequestStorageAccess();
 
     // For non-tracking windows, calling the API is a no-op
--- a/toolkit/components/antitracking/test/browser/browser_blockingSharedWorkers.js
+++ b/toolkit/components/antitracking/test/browser/browser_blockingSharedWorkers.js
@@ -46,21 +46,17 @@ AntiTracking.runTest("SharedWorkers and 
       }
     } else {
       new SharedWorker("a.js", "foo");
       ok(true, "SharedWorker is allowed");
     }
   },
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     new SharedWorker("a.js", "foo");
     ok(true, "SharedWorker is allowed");
 
     /* import-globals-from storageAccessAPIHelpers.js */
     await callRequestStorageAccess();
 
     // For non-tracking windows, calling the API is a no-op
--- a/toolkit/components/antitracking/test/browser/browser_partitionedLocalStorage.js
+++ b/toolkit/components/antitracking/test/browser/browser_partitionedLocalStorage.js
@@ -42,21 +42,17 @@ AntiTracking.runTest("localStorage and S
 
       localStorage.foo = 42;
       ok(true, "LocalStorage is still allowed");
       is(localStorage.foo, "42", "The value matches");
     }
   },
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     localStorage.foo = 42;
     ok(true, "LocalStorage is allowed");
     is(localStorage.foo, "42", "The value matches");
 
     var prevLocalStorage = localStorage;
 
     /* import-globals-from storageAccessAPIHelpers.js */
--- a/toolkit/components/antitracking/test/browser/browser_storageAccessRemovalNavigateSubframe.js
+++ b/toolkit/components/antitracking/test/browser/browser_storageAccessRemovalNavigateSubframe.js
@@ -3,21 +3,17 @@ AntiTracking.runTest("Storage Access is 
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
     await noStorageAccessInitially();
   },
 
   // non-blocking callback
   async _ => {
     /* import-globals-from storageAccessAPIHelpers.js */
-    if (allowListed) {
-      await hasStorageAccessInitially();
-    } else {
-      await noStorageAccessInitially();
-    }
+    await noStorageAccessInitially();
 
     /* import-globals-from storageAccessAPIHelpers.js */
     let [threw, rejected] = await callRequestStorageAccess();
     ok(!threw, "requestStorageAccess should not throw");
     ok(!rejected, "requestStorageAccess should be available");
   },
   // cleanup function
   async _ => {
--- a/toolkit/components/antitracking/test/browser/head.js
+++ b/toolkit/components/antitracking/test/browser/head.js
@@ -352,27 +352,25 @@ this.AntiTracking = {
       await ContentTask.spawn(browser,
                               { page: thirdPartyPage,
                                 nextPage: TEST_4TH_PARTY_PAGE,
                                 callback: options.callback.toString(),
                                 callbackAfterRemoval: options.callbackAfterRemoval ?
                                   options.callbackAfterRemoval.toString() : null,
                                 accessRemoval: options.accessRemoval,
                                 iframeSandbox: options.iframeSandbox,
-                                allowList: options.allowList,
                                 doAccessRemovalChecks },
                               async function(obj) {
         let id = "id" + Math.random();
         await new content.Promise(resolve => {
           let ifr = content.document.createElement("iframe");
           ifr.id = id;
           ifr.onload = function() {
             info("Sending code to the 3rd party content");
-            let callback = obj.allowList + "!!!" + obj.callback;
-            ifr.contentWindow.postMessage(callback, "*");
+            ifr.contentWindow.postMessage(obj.callback, "*");
           };
           if (typeof obj.iframeSandbox == "string") {
             ifr.setAttribute("sandbox", obj.iframeSandbox);
           }
 
           content.addEventListener("message", function msg(event) {
             if (event.data.type == "finish") {
               content.removeEventListener("message", msg);
--- a/toolkit/components/antitracking/test/browser/storageAccessAPIHelpers.js
+++ b/toolkit/components/antitracking/test/browser/storageAccessAPIHelpers.js
@@ -1,10 +1,8 @@
-/* global allowListed */
-
 async function hasStorageAccessInitially() {
   let hasAccess = await document.hasStorageAccess();
   ok(hasAccess, "Has storage access");
 }
 
 async function noStorageAccessInitially() {
   let hasAccess = await document.hasStorageAccess();
   ok(!hasAccess, "Doesn't yet have storage access");
--- a/toolkit/components/url-classifier/tests/browser/classifierTester.js
+++ b/toolkit/components/url-classifier/tests/browser/classifierTester.js
@@ -9,17 +9,16 @@ var classifierTester = {
   IFRAME_ID: "testFrame",
   FLASHBLOCK_ENABLE_PREF: "plugins.flashBlock.enabled",
   FLASH_PLUGIN_USER_SETTING_PREF: "plugin.state.flash",
   URLCLASSIFIER_DISALLOW_COMPLETIONS_PREF: "urlclassifier.disallow_completions",
   NEVER_ACTIVATE_PREF_VALUE: 0,
   ASK_TO_ACTIVATE_PREF_VALUE: 1,
   ALWAYS_ACTIVATE_PREF_VALUE: 2,
   ALLOW_CTA_PREF: "plugins.click_to_play",
-  TRACKING_ANNOTATIONS_PREF: "privacy.trackingprotection.annotate_channels",
 
   dbUrls: [
     {
       url: "flashallow.example.com/",
       db: "test-flashallow-simple",
       pref: "urlclassifier.flashAllowTable",
     },
     {
@@ -63,30 +62,27 @@ var classifierTester = {
       Services.prefs.setCharPref(classifierTester.URLCLASSIFIER_DISALLOW_COMPLETIONS_PREF, completions);
     }
 
     Services.prefs.setBoolPref(classifierTester.FLASHBLOCK_ENABLE_PREF,
                                flashBlockEnable);
     Services.prefs.setIntPref(classifierTester.FLASH_PLUGIN_USER_SETTING_PREF,
                               flashSetting);
     Services.prefs.setBoolPref(classifierTester.ALLOW_CTA_PREF, true);
-    // Work around bug 1529728
-    Services.prefs.setBoolPref(classifierTester.TRACKING_ANNOTATIONS_PREF, false);
   },
 
   unsetPrefs() {
     for (let dbData of classifierTester.dbUrls) {
       Services.prefs.clearUserPref(dbData.pref);
     }
 
     Services.prefs.clearUserPref(classifierTester.URLCLASSIFIER_DISALLOW_COMPLETIONS_PREF);
     Services.prefs.clearUserPref(classifierTester.FLASHBLOCK_ENABLE_PREF);
     Services.prefs.clearUserPref(classifierTester.FLASH_PLUGIN_USER_SETTING_PREF);
     Services.prefs.clearUserPref(classifierTester.ALLOW_CTA_PREF);
-    Services.prefs.clearUserPref(classifierTester.TRACKING_ANNOTATIONS_PREF);
   },
 
   // The |domains| property describes the domains of the nested documents making
   // up the page. |domains[0]| represents the domain in the URL bar. The last
   // domain in the list is the domain of the most deeply nested iframe.
   // Only the plugin in the most deeply nested document will be checked.
   testCases: [
     {