diff --git a/browser/base/content/browser-plugins.js b/browser/base/content/browser-plugins.js
index ded5fba37ab3..f1919ded49b7 100644
--- a/browser/base/content/browser-plugins.js
+++ b/browser/base/content/browser-plugins.js
@@ -395,7 +395,7 @@ var gPluginHandler = {
       }
       let classifier = Cc["@mozilla.org/url-classifier/dbservice;1"]
         .getService(Ci.nsIURIClassifier);
-      classifier.asyncClassifyLocalWithTables(uri, tableName, (c, list) => {
+      classifier.asyncClassifyLocalWithTables(uri, tableName, [], [], (c, list) => {
         resolve(list.length > 0);
       });
     });
diff --git a/dom/base/nsDocument.cpp b/dom/base/nsDocument.cpp
index ad29695ee89b..b82a4864bb3d 100644
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -13165,8 +13165,11 @@ PrincipalFlashClassifier::AsyncClassifyInternal(nsIPrincipal* aPrincipal)
     return FlashClassification::Denied;
   }
 
+  // We don't support extra entries by pref for this classifier.
   rv = mUriClassifier->AsyncClassifyLocalWithTables(mClassificationURI,
                                                     tables,
+                                                    nsTArray<nsCString>(),
+                                                    nsTArray<nsCString>(),
                                                     this);
 
   if (NS_FAILED(rv)) {
diff --git a/dom/ipc/URLClassifierParent.cpp b/dom/ipc/URLClassifierParent.cpp
index a83ec5de5b7c..8aef6cdeca8c 100644
--- a/dom/ipc/URLClassifierParent.cpp
+++ b/dom/ipc/URLClassifierParent.cpp
@@ -65,7 +65,10 @@ URLClassifierLocalParent::StartClassify(nsIURI* aURI, const nsACString& aTables)
     do_GetService(NS_URICLASSIFIERSERVICE_CONTRACTID, &rv);
   if (NS_SUCCEEDED(rv)) {
     MOZ_ASSERT(aURI);
-    rv = uriClassifier->AsyncClassifyLocalWithTables(aURI, aTables, this);
+    rv = uriClassifier->AsyncClassifyLocalWithTables(aURI, aTables,
+                                                     nsTArray<nsCString>(),
+                                                     nsTArray<nsCString>(),
+                                                     this);
   }
   if (NS_FAILED(rv)) {
     // Cannot do ClassificationFailed() because the child side
diff --git a/netwerk/base/nsChannelClassifier.cpp b/netwerk/base/nsChannelClassifier.cpp
index b2a968c00f1e..2c74c073a703 100644
--- a/netwerk/base/nsChannelClassifier.cpp
+++ b/netwerk/base/nsChannelClassifier.cpp
@@ -64,9 +64,18 @@ static LazyLogModule gChannelClassifierLog("nsChannelClassifier");
 
 #define URLCLASSIFIER_SKIP_HOSTNAMES       "urlclassifier.skipHostnames"
 #define URLCLASSIFIER_ANNOTATION_TABLE     "urlclassifier.trackingAnnotationTable"
+#define URLCLASSIFIER_ANNOTATION_TABLE_TEST_ENTRIES "urlclassifier.trackingAnnotationTable.testEntries"
 #define URLCLASSIFIER_ANNOTATION_WHITELIST "urlclassifier.trackingAnnotationWhitelistTable"
+#define URLCLASSIFIER_ANNOTATION_WHITELIST_TEST_ENTRIES "urlclassifier.trackingAnnotationWhitelistTable.testEntries"
 #define URLCLASSIFIER_TRACKING_TABLE       "urlclassifier.trackingTable"
+#define URLCLASSIFIER_TRACKING_TABLE_TEST_ENTRIES "urlclassifier.trackingTable.testEntries"
 #define URLCLASSIFIER_TRACKING_WHITELIST   "urlclassifier.trackingWhitelistTable"
+#define URLCLASSIFIER_TRACKING_WHITELIST_TEST_ENTRIES "urlclassifier.trackingWhitelistTable.testEntries"
+
+#define TABLE_TRACKING_BLACKLIST_PREF "tracking-blacklist-pref"
+#define TABLE_TRACKING_WHITELIST_PREF "tracking-whitelist-pref"
+#define TABLE_ANNOTATION_BLACKLIST_PREF "annotation-blacklist-pref"
+#define TABLE_ANNOTATION_WHITELIST_PREF "annotation-whitelist-pref"
 
 static const nsCString::size_type sMaxSpecLength = 128;
 
@@ -91,15 +100,23 @@ public:
 
   nsCString GetSkipHostnames() const { return mSkipHostnames; }
   nsCString GetAnnotationBlackList() const { return mAnnotationBlacklist; }
+  nsCString GetAnnotationBlackListExtraEntries() const { return mAnnotationBlacklistExtraEntries; }
   nsCString GetAnnotationWhiteList() const { return mAnnotationWhitelist; }
+  nsCString GetAnnotationWhiteListExtraEntries() const { return mAnnotationWhitelistExtraEntries; }
   nsCString GetTrackingBlackList() const { return mTrackingBlacklist; }
+  nsCString GetTrackingBlackListExtraEntries() { return mTrackingBlacklistExtraEntries; }
   nsCString GetTrackingWhiteList() const { return mTrackingWhitelist; }
+  nsCString GetTrackingWhiteListExtraEntries() { return mTrackingWhitelistExtraEntries; }
 
   void SetSkipHostnames(const nsACString& aHostnames) { mSkipHostnames = aHostnames; }
   void SetAnnotationBlackList(const nsACString& aList) { mAnnotationBlacklist = aList; }
+  void SetAnnotationBlackListExtraEntries(const nsACString& aList) { mAnnotationBlacklistExtraEntries = aList; }
   void SetAnnotationWhiteList(const nsACString& aList) { mAnnotationWhitelist = aList; }
+  void SetAnnotationWhiteListExtraEntries(const nsACString& aList) { mAnnotationWhitelistExtraEntries = aList; }
   void SetTrackingBlackList(const nsACString& aList) { mTrackingBlacklist = aList; }
+  void SetTrackingBlackListExtraEntries(const nsACString& aList) { mTrackingBlacklistExtraEntries = aList; }
   void SetTrackingWhiteList(const nsACString& aList) { mTrackingWhitelist = aList; }
+  void SetTrackingWhiteListExtraEntries(const nsACString& aList) { mTrackingWhitelistExtraEntries = aList; }
 
 private:
   friend class StaticAutoPtr<CachedPrefs>;
@@ -118,9 +135,13 @@ private:
 
   nsCString mSkipHostnames;
   nsCString mAnnotationBlacklist;
+  nsCString mAnnotationBlacklistExtraEntries;
   nsCString mAnnotationWhitelist;
+  nsCString mAnnotationWhitelistExtraEntries;
   nsCString mTrackingBlacklist;
+  nsCString mTrackingBlacklistExtraEntries;
   nsCString mTrackingWhitelist;
+  nsCString mTrackingWhitelistExtraEntries;
 
   static StaticAutoPtr<CachedPrefs> sInstance;
 };
@@ -145,20 +166,39 @@ CachedPrefs::OnPrefsChange(const char* aPref, CachedPrefs* aPrefs)
     Preferences::GetCString(URLCLASSIFIER_ANNOTATION_TABLE,
                             annotationBlacklist);
     aPrefs->SetAnnotationBlackList(annotationBlacklist);
+  } else if (!strcmp(aPref, URLCLASSIFIER_ANNOTATION_TABLE_TEST_ENTRIES)) {
+    nsAutoCString annotationBlacklistExtraEntries;
+    Preferences::GetCString(URLCLASSIFIER_ANNOTATION_TABLE_TEST_ENTRIES,
+                            annotationBlacklistExtraEntries);
+    aPrefs->SetAnnotationBlackListExtraEntries(annotationBlacklistExtraEntries);
   } else if (!strcmp(aPref, URLCLASSIFIER_ANNOTATION_WHITELIST)) {
     nsAutoCString annotationWhitelist;
     Preferences::GetCString(URLCLASSIFIER_ANNOTATION_WHITELIST,
                             annotationWhitelist);
     aPrefs->SetAnnotationWhiteList(annotationWhitelist);
+  } else if (!strcmp(aPref, URLCLASSIFIER_ANNOTATION_WHITELIST_TEST_ENTRIES)) {
+    nsAutoCString annotationWhitelistExtraEntries;
+    Preferences::GetCString(URLCLASSIFIER_ANNOTATION_WHITELIST_TEST_ENTRIES,
+                            annotationWhitelistExtraEntries);
+    aPrefs->SetAnnotationWhiteListExtraEntries(annotationWhitelistExtraEntries);
   } else if (!strcmp(aPref, URLCLASSIFIER_TRACKING_WHITELIST)) {
     nsCString trackingWhitelist;
     Preferences::GetCString(URLCLASSIFIER_TRACKING_WHITELIST,
                             trackingWhitelist);
     aPrefs->SetTrackingWhiteList(trackingWhitelist);
+  } else if (!strcmp(aPref, URLCLASSIFIER_TRACKING_WHITELIST_TEST_ENTRIES)) {
+    nsCString trackingWhitelistExtraEntries;
+    Preferences::GetCString(URLCLASSIFIER_TRACKING_WHITELIST_TEST_ENTRIES,
+                            trackingWhitelistExtraEntries);
+    aPrefs->SetTrackingWhiteListExtraEntries(trackingWhitelistExtraEntries);
   } else if (!strcmp(aPref, URLCLASSIFIER_TRACKING_TABLE)) {
     nsCString trackingBlacklist;
     Preferences::GetCString(URLCLASSIFIER_TRACKING_TABLE, trackingBlacklist);
     aPrefs->SetTrackingBlackList(trackingBlacklist);
+  } else if (!strcmp(aPref, URLCLASSIFIER_TRACKING_TABLE_TEST_ENTRIES)) {
+    nsCString trackingBlacklistExtraEntries;
+    Preferences::GetCString(URLCLASSIFIER_TRACKING_TABLE_TEST_ENTRIES, trackingBlacklistExtraEntries);
+    aPrefs->SetTrackingBlackListExtraEntries(trackingBlacklistExtraEntries);
   }
 }
 
@@ -175,12 +215,20 @@ CachedPrefs::Init()
                                        URLCLASSIFIER_SKIP_HOSTNAMES, this);
   Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
                                        URLCLASSIFIER_ANNOTATION_TABLE, this);
+  Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
+                                       URLCLASSIFIER_ANNOTATION_TABLE_TEST_ENTRIES, this);
   Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
                                        URLCLASSIFIER_ANNOTATION_WHITELIST, this);
+  Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
+                                       URLCLASSIFIER_ANNOTATION_WHITELIST_TEST_ENTRIES, this);
   Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
                                        URLCLASSIFIER_TRACKING_WHITELIST, this);
+  Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
+                                       URLCLASSIFIER_TRACKING_WHITELIST_TEST_ENTRIES, this);
   Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
                                        URLCLASSIFIER_TRACKING_TABLE, this);
+  Preferences::RegisterCallbackAndCall(CachedPrefs::OnPrefsChange,
+                                       URLCLASSIFIER_TRACKING_TABLE_TEST_ENTRIES, this);
 }
 
 // static
@@ -207,9 +255,13 @@ CachedPrefs::~CachedPrefs()
 
   Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_SKIP_HOSTNAMES, this);
   Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_ANNOTATION_TABLE, this);
+  Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_ANNOTATION_TABLE_TEST_ENTRIES, this);
   Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_ANNOTATION_WHITELIST, this);
+  Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_ANNOTATION_WHITELIST_TEST_ENTRIES, this);
   Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_TRACKING_WHITELIST, this);
+  Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_TRACKING_WHITELIST_TEST_ENTRIES, this);
   Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_TRACKING_TABLE, this);
+  Preferences::UnregisterCallback(CachedPrefs::OnPrefsChange, URLCLASSIFIER_TRACKING_TABLE_TEST_ENTRIES, this);
 }
 } // anonymous namespace
 
@@ -974,15 +1026,18 @@ TrackingURICallback::OnClassifyComplete(nsresult aErrorCode,
     bool inTrackingTable = false;
     bool inAnnotationTable = false;
 
+
     nsCCharSeparatedTokenizer tokenizer(aLists, ',');
     while (tokenizer.hasMoreTokens()) {
       const nsACString& list = tokenizer.nextToken();
       if (shouldEnableTrackingProtection && !inTrackingTable &&
-          FindInReadable(list, trackingTable)) {
+          (list == TABLE_TRACKING_BLACKLIST_PREF ||
+           FindInReadable(list, trackingTable))) {
         inTrackingTable = true;
       }
       if (shouldEnableTrackingAnnotation && !inAnnotationTable &&
-          FindInReadable(list, annotationTable)) {
+          (list == TABLE_ANNOTATION_BLACKLIST_PREF ||
+           FindInReadable(list, annotationTable))) {
         inAnnotationTable = true;
       }
     }
@@ -1025,10 +1080,14 @@ TrackingURICallback::OnClassifyComplete(nsresult aErrorCode,
     nsCCharSeparatedTokenizer tokenizer(aLists, ',');
     while (tokenizer.hasMoreTokens() && (isTracker || isAnnotation)) {
       const nsACString& list = tokenizer.nextToken();
-      if (isTracker && FindInReadable(list, trackingWhitelistTable)) {
+      if (isTracker &&
+          (list == TABLE_TRACKING_WHITELIST_PREF ||
+           FindInReadable(list, trackingWhitelistTable))) {
         isTracker = false;
       }
-      if (isAnnotation && FindInReadable(list, annotationWhitelistTable)) {
+      if (isAnnotation &&
+          (list == TABLE_ANNOTATION_WHITELIST_PREF ||
+           FindInReadable(list, annotationWhitelistTable))) {
         isAnnotation = false;
       }
     }
@@ -1299,12 +1358,18 @@ nsChannelClassifier::IsTrackerWhitelisted(nsIURI* aWhiteListURI,
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsAutoCString whitelist;
+  nsTArray<nsCString> whitelistExtraTables;
+  nsTArray<nsCString> whitelistExtraEntries;
   if (aUseAnnotationTable) {
     whitelist += CachedPrefs::GetInstance()->GetAnnotationWhiteList();
     whitelist += NS_LITERAL_CSTRING(",");
+    whitelistExtraTables.AppendElement(TABLE_ANNOTATION_WHITELIST_PREF);
+    whitelistExtraEntries.AppendElement(CachedPrefs::GetInstance()->GetAnnotationWhiteListExtraEntries());
   }
   if (aUseTrackingTable) {
     whitelist += CachedPrefs::GetInstance()->GetTrackingWhiteList();
+    whitelistExtraTables.AppendElement(TABLE_TRACKING_WHITELIST_PREF);
+    whitelistExtraEntries.AppendElement(CachedPrefs::GetInstance()->GetTrackingWhiteListExtraEntries());
   }
 
   if (whitelist.IsEmpty()) {
@@ -1315,6 +1380,8 @@ nsChannelClassifier::IsTrackerWhitelisted(nsIURI* aWhiteListURI,
   }
 
   return uriClassifier->AsyncClassifyLocalWithTables(aWhiteListURI, whitelist,
+                                                     whitelistExtraTables,
+                                                     whitelistExtraEntries,
                                                      aCallback);
 }
 
@@ -1432,12 +1499,18 @@ nsChannelClassifier::CheckIsTrackerWithLocalTable(std::function<void()>&& aCallb
   }
 
   nsAutoCString blacklist;
+  nsTArray<nsCString> blacklistExtraTables;
+  nsTArray<nsCString> blacklistExtraEntries;
   if (shouldEnableTrackingAnnotation) {
     blacklist += CachedPrefs::GetInstance()->GetAnnotationBlackList();
     blacklist += NS_LITERAL_CSTRING(",");
+    blacklistExtraTables.AppendElement(TABLE_ANNOTATION_BLACKLIST_PREF);
+    blacklistExtraEntries.AppendElement(CachedPrefs::GetInstance()->GetAnnotationBlackListExtraEntries());
   }
   if (shouldEnableTrackingProtection) {
     blacklist += CachedPrefs::GetInstance()->GetTrackingBlackList();
+    blacklistExtraTables.AppendElement(TABLE_TRACKING_BLACKLIST_PREF);
+    blacklistExtraEntries.AppendElement(CachedPrefs::GetInstance()->GetTrackingBlackListExtraEntries());
   }
   if (blacklist.IsEmpty()) {
     LOG_WARN(("nsChannelClassifier[%p]:CheckIsTrackerWithLocalTable blacklist is empty",
@@ -1455,7 +1528,10 @@ nsChannelClassifier::CheckIsTrackerWithLocalTable(std::function<void()>&& aCallb
     LOG(("nsChannelClassifier[%p]: Checking blacklist for uri=%s\n",
          this, spec.get()));
   }
-  return uriClassifier->AsyncClassifyLocalWithTables(uri, blacklist, callback);
+  return uriClassifier->AsyncClassifyLocalWithTables(uri, blacklist,
+                                                     blacklistExtraTables,
+                                                     blacklistExtraEntries,
+                                                     callback);
 }
 
 already_AddRefed<nsIChannel>
diff --git a/netwerk/base/nsIURIClassifier.idl b/netwerk/base/nsIURIClassifier.idl
index dd01238cd782..9af86acca354 100644
--- a/netwerk/base/nsIURIClassifier.idl
+++ b/netwerk/base/nsIURIClassifier.idl
@@ -95,6 +95,8 @@ interface nsIURIClassifier : nsISupports
    */
   void asyncClassifyLocalWithTables(in nsIURI aURI,
                                     in ACString aTables,
+                                    in Array<ACString> aExtraTablesByPrefs,
+                                    in Array<ACString> aExtraEntriesByPrefs,
                                     in nsIURIClassifierCallback aCallback);
   /**
    * Same as above, but returns a comma separated list of table names.
diff --git a/testing/specialpowers/content/specialpowersAPI.js b/testing/specialpowers/content/specialpowersAPI.js
index 9b6399482d34..fc3961fce0fb 100644
--- a/testing/specialpowers/content/specialpowersAPI.js
+++ b/testing/specialpowers/content/specialpowersAPI.js
@@ -2261,7 +2261,7 @@ SpecialPowersAPI.prototype = {
     };
 
     return classifierService.asyncClassifyLocalWithTables(unwrapIfWrapped(uri),
-                                                          tables,
+                                                          tables, [], [],
                                                           wrapCallback);
   },
 
diff --git a/toolkit/components/antitracking/test/browser/browser_script.js b/toolkit/components/antitracking/test/browser/browser_script.js
index 57e02150e967..ce52acbb17de 100644
--- a/toolkit/components/antitracking/test/browser/browser_script.js
+++ b/toolkit/components/antitracking/test/browser/browser_script.js
@@ -119,8 +119,6 @@ add_task(async function() {
 
   info("Removing the tab");
   BrowserTestUtils.removeTab(tab);
-
-  UrlClassifierTestUtils.cleanupTestTrackers();
 });
 
 add_task(async function() {
diff --git a/toolkit/components/antitracking/test/browser/browser_subResources.js b/toolkit/components/antitracking/test/browser/browser_subResources.js
index 518a5d891f8a..37333c2eccc1 100644
--- a/toolkit/components/antitracking/test/browser/browser_subResources.js
+++ b/toolkit/components/antitracking/test/browser/browser_subResources.js
@@ -156,8 +156,6 @@ add_task(async function() {
 
   info("Removing the tab");
   BrowserTestUtils.removeTab(tab);
-
-  UrlClassifierTestUtils.cleanupTestTrackers();
 });
 
 add_task(async function() {
diff --git a/toolkit/components/antitracking/test/browser/head.js b/toolkit/components/antitracking/test/browser/head.js
index fa827bfff6d1..9e3434bf367a 100644
--- a/toolkit/components/antitracking/test/browser/head.js
+++ b/toolkit/components/antitracking/test/browser/head.js
@@ -150,8 +150,6 @@ this.AntiTracking = {
 
       info("Removing the tab");
       BrowserTestUtils.removeTab(tab);
-
-      UrlClassifierTestUtils.cleanupTestTrackers();
     });
   },
 
@@ -222,8 +220,6 @@ this.AntiTracking = {
 
       info("Removing the tab");
       BrowserTestUtils.removeTab(tab);
-
-      UrlClassifierTestUtils.cleanupTestTrackers();
     });
   },
 
@@ -319,8 +315,6 @@ this.AntiTracking = {
 
       info("Removing the tab");
       BrowserTestUtils.removeTab(tab);
-
-      UrlClassifierTestUtils.cleanupTestTrackers();
     });
   }
 };
diff --git a/toolkit/components/reputationservice/LoginReputation.cpp b/toolkit/components/reputationservice/LoginReputation.cpp
index b43cea92c916..e634104d5257 100644
--- a/toolkit/components/reputationservice/LoginReputation.cpp
+++ b/toolkit/components/reputationservice/LoginReputation.cpp
@@ -145,7 +145,11 @@ LoginWhitelist::QueryLoginWhitelist(nsILoginReputationQuery* aParam)
 
   // AsyncClassifyLocalWithTables API won't trigger a gethash request on
   // a full-length match, so this API call should only include local operation.
-  rv = uriClassifier->AsyncClassifyLocalWithTables(uri, mTables, this);
+  // We don't support prefs overwrite for this classification.
+  rv = uriClassifier->AsyncClassifyLocalWithTables(uri, mTables,
+                                                   nsTArray<nsCString>(),
+                                                   nsTArray<nsCString>(),
+                                                   this);
   if (NS_FAILED(rv)) {
     return p;
   }
diff --git a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
index 0dcd8f368387..200688e9d87d 100644
--- a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
@@ -57,6 +57,9 @@
 #include "nsToolkitCompsCID.h"
 #include "nsIClassifiedChannel.h"
 
+#define TABLE_TRACKING_BLACKLIST_PREF "tracking-blacklist-pref"
+#define TABLE_TRACKING_WHITELIST_PREF "tracking-whitelist-pref"
+
 namespace mozilla {
 namespace safebrowsing {
 
@@ -1537,6 +1540,8 @@ nsUrlClassifierDBService::ReadTablesFromPrefs()
 
   mBaseTables.Truncate();
   mTrackingProtectionTables.Truncate();
+  mTrackingProtectionWhitelistExtraEntriesByPrefs.Truncate();
+  mTrackingProtectionBlacklistExtraEntriesByPrefs.Truncate();
 
   Preferences::GetCString(PHISH_TABLE_PREF, allTables);
   if (mCheckPhishing) {
@@ -1568,10 +1573,16 @@ nsUrlClassifierDBService::ReadTablesFromPrefs()
   AppendTables(tables, allTables);
   AppendTables(tables, mTrackingProtectionTables);
 
+  Preferences::GetCString(TRACKING_TABLE_TEST_ENTRIES_PREF, tables);
+  AppendTables(tables, mTrackingProtectionBlacklistExtraEntriesByPrefs);
+
   Preferences::GetCString(TRACKING_WHITELIST_TABLE_PREF, tables);
   AppendTables(tables, allTables);
   AppendTables(tables, mTrackingProtectionTables);
 
+  Preferences::GetCString(TRACKING_WHITELIST_TABLE_TEST_ENTRIES_PREF, tables);
+  AppendTables(tables, mTrackingProtectionWhitelistExtraEntriesByPrefs);
+
   Classifier::SplitTables(allTables, mGethashTables);
 
   Preferences::GetCString(DISALLOW_COMPLETION_TABLE_PREF, tables);
@@ -1735,11 +1746,19 @@ nsUrlClassifierDBService::Classify(nsIPrincipal* aPrincipal,
   if (!callback) return NS_ERROR_OUT_OF_MEMORY;
 
   nsCString tables = mBaseTables;
+  nsTArray<nsCString> extraTablesByPrefs;
+  nsTArray<nsCString> extraEntriesByPrefs;
   if (aTrackingProtectionEnabled) {
     AppendTables(mTrackingProtectionTables, tables);
+    extraTablesByPrefs.AppendElement(TABLE_TRACKING_WHITELIST_PREF);
+    extraEntriesByPrefs.AppendElement(mTrackingProtectionWhitelistExtraEntriesByPrefs);
+
+    extraTablesByPrefs.AppendElement(TABLE_TRACKING_BLACKLIST_PREF);
+    extraEntriesByPrefs.AppendElement(mTrackingProtectionBlacklistExtraEntriesByPrefs);
   }
 
-  nsresult rv = LookupURI(aPrincipal, tables, callback, false, result);
+  nsresult rv = LookupURI(aPrincipal, tables, extraTablesByPrefs,
+                          extraEntriesByPrefs, callback, false, result);
   if (rv == NS_ERROR_MALFORMED_URI) {
     *result = false;
     // The URI had no hostname, don't try to classify it.
@@ -1775,21 +1794,57 @@ nsUrlClassifierDBService::ClassifyLocal(nsIURI *aURI,
 NS_IMETHODIMP
 nsUrlClassifierDBService::AsyncClassifyLocalWithTables(nsIURI *aURI,
                                                        const nsACString& aTables,
+                                                       const nsTArray<nsCString>& aExtraTablesByPrefs,
+                                                       const nsTArray<nsCString>& aExtraEntriesByPrefs,
                                                        nsIURIClassifierCallback* aCallback)
 {
   MOZ_ASSERT(NS_IsMainThread(), "AsyncClassifyLocalWithTables must be called "
                                 "on main thread");
 
+  nsresult rv;
+
   // We do this check no matter what process we are in to return
   // error as early as possible.
   nsCOMPtr<nsIURI> uri = NS_GetInnermostURI(aURI);
   NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
 
+  if (aExtraTablesByPrefs.Length() != aExtraEntriesByPrefs.Length()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Let's see if we have special entries set by prefs.
+  if (!aExtraEntriesByPrefs.IsEmpty()) {
+    nsAutoCString host;
+    rv = uri->GetHost(host);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    for (uint32_t i = 0; i < aExtraEntriesByPrefs.Length(); ++i) {
+      nsTArray<nsCString> entries;
+      Classifier::SplitTables(aExtraEntriesByPrefs[i], entries);
+
+      if (entries.Contains(host)) {
+        nsCString table = aExtraTablesByPrefs[i];
+        nsCOMPtr<nsIURIClassifierCallback> callback(aCallback);
+        nsCOMPtr<nsIRunnable> cbRunnable = NS_NewRunnableFunction(
+          "nsUrlClassifierDBService::AsyncClassifyLocalWithTables",
+          [callback, table]() -> void {
+            callback->OnClassifyComplete(NS_OK, // Not used.
+                                         table,
+                                         EmptyCString(),  // provider. (Not used)
+                                         EmptyCString()); // prefix. (Not used)
+          });
+
+        NS_DispatchToMainThread(cbRunnable);
+        return NS_OK;
+      }
+    }
+  }
+
   nsAutoCString key;
   // Canonicalize the url
   nsCOMPtr<nsIUrlClassifierUtils> utilsService =
     do_GetService(NS_URLCLASSIFIERUTILS_CONTRACTID);
-  nsresult rv = utilsService->GetKeyForURI(uri, key);
+  rv = utilsService->GetKeyForURI(uri, key);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (XRE_IsContentProcess()) {
@@ -2145,12 +2200,15 @@ nsUrlClassifierDBService::Lookup(nsIPrincipal* aPrincipal,
   NS_ENSURE_TRUE(gDbBackgroundThread, NS_ERROR_NOT_INITIALIZED);
 
   bool dummy;
-  return LookupURI(aPrincipal, tables, c, true, &dummy);
+  return LookupURI(aPrincipal, tables, nsTArray<nsCString>(),
+                   nsTArray<nsCString>(), c, true, &dummy);
 }
 
 nsresult
 nsUrlClassifierDBService::LookupURI(nsIPrincipal* aPrincipal,
                                     const nsACString& tables,
+                                    const nsTArray<nsCString>& aExtraTablesByPrefs,
+                                    const nsTArray<nsCString>& aExtraEntriesByPrefs,
                                     nsIUrlClassifierCallback* c,
                                     bool forceLookup,
                                     bool *didLookup)
@@ -2171,6 +2229,35 @@ nsUrlClassifierDBService::LookupURI(nsIPrincipal* aPrincipal,
   uri = NS_GetInnermostURI(uri);
   NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
 
+  if (aExtraTablesByPrefs.Length() != aExtraEntriesByPrefs.Length()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!aExtraEntriesByPrefs.IsEmpty()) {
+    nsAutoCString host;
+    rv = uri->GetHost(host);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    for (uint32_t i = 0; i < aExtraEntriesByPrefs.Length(); ++i) {
+      nsTArray<nsCString> entries;
+      Classifier::SplitTables(aExtraEntriesByPrefs[i], entries);
+      if (entries.Contains(host)) {
+        *didLookup = true;
+
+        nsCString table = aExtraTablesByPrefs[i];
+        nsCOMPtr<nsIUrlClassifierCallback> callback(c);
+        nsCOMPtr<nsIRunnable> cbRunnable = NS_NewRunnableFunction(
+          "nsUrlClassifierDBService::AsyncClassifyLocalWithTables",
+          [callback, table]() -> void {
+            callback->HandleEvent(table);
+          });
+
+        NS_DispatchToMainThread(cbRunnable);
+        return NS_OK;
+      }
+    }
+  }
+
   nsAutoCString key;
   // Canonicalize the url
   nsCOMPtr<nsIUrlClassifierUtils> utilsService =
diff --git a/toolkit/components/url-classifier/nsUrlClassifierDBService.h b/toolkit/components/url-classifier/nsUrlClassifierDBService.h
index b8b346635dfe..e2ba4d9c4a26 100644
--- a/toolkit/components/url-classifier/nsUrlClassifierDBService.h
+++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.h
@@ -57,7 +57,9 @@
 #define MALWARE_TABLE_PREF              "urlclassifier.malwareTable"
 #define PHISH_TABLE_PREF                "urlclassifier.phishTable"
 #define TRACKING_TABLE_PREF             "urlclassifier.trackingTable"
+#define TRACKING_TABLE_TEST_ENTRIES_PREF "urlclassifier.trackingTable.testEntries"
 #define TRACKING_WHITELIST_TABLE_PREF   "urlclassifier.trackingWhitelistTable"
+#define TRACKING_WHITELIST_TABLE_TEST_ENTRIES_PREF "urlclassifier.trackingWhitelistTable.testEntries"
 #define BLOCKED_TABLE_PREF              "urlclassifier.blockedTable"
 #define DOWNLOAD_BLOCK_TABLE_PREF       "urlclassifier.downloadBlockTable"
 #define DOWNLOAD_ALLOW_TABLE_PREF       "urlclassifier.downloadAllowTable"
@@ -122,7 +124,9 @@ private:
     NS_LITERAL_CSTRING(MALWARE_TABLE_PREF),
     NS_LITERAL_CSTRING(PHISH_TABLE_PREF),
     NS_LITERAL_CSTRING(TRACKING_TABLE_PREF),
+    NS_LITERAL_CSTRING(TRACKING_TABLE_TEST_ENTRIES_PREF),
     NS_LITERAL_CSTRING(TRACKING_WHITELIST_TABLE_PREF),
+    NS_LITERAL_CSTRING(TRACKING_WHITELIST_TABLE_TEST_ENTRIES_PREF),
     NS_LITERAL_CSTRING(BLOCKED_TABLE_PREF),
     NS_LITERAL_CSTRING(DOWNLOAD_BLOCK_TABLE_PREF),
     NS_LITERAL_CSTRING(DOWNLOAD_ALLOW_TABLE_PREF),
@@ -137,6 +141,8 @@ private:
 
   nsresult LookupURI(nsIPrincipal* aPrincipal,
                      const nsACString& tables,
+                     const nsTArray<nsCString>& extraTablesByPrefs,
+                     const nsTArray<nsCString>& extraEntriesByPrefs,
                      nsIUrlClassifierCallback* c,
                      bool forceCheck, bool *didCheck);
 
@@ -181,6 +187,10 @@ private:
   nsCString mTrackingProtectionTables;
   nsCString mBaseTables;
 
+  // Comma-separated hosts set by prefs to use in lookups.
+  nsCString mTrackingProtectionWhitelistExtraEntriesByPrefs;
+  nsCString mTrackingProtectionBlacklistExtraEntriesByPrefs;
+
   // Thread that we do the updates on.
   static nsIThread* gDbBackgroundThread;
 };