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

Bug 1476967 - Allow the adding of tracking-protection entries via prefs, r=francois

This commit is contained in:
Andrea Marchesini 2018-08-27 21:01:14 +02:00
Родитель 7519f8515f
Коммит c80c929412
12 изменённых файлов: 197 добавлений и 22 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
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);
});
});

3
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)) {

5
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

86
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>

2
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.

2
testing/specialpowers/content/specialpowersAPI.js
Просмотреть файл

@ -2261,7 +2261,7 @@ SpecialPowersAPI.prototype = {
};
return classifierService.asyncClassifyLocalWithTables(unwrapIfWrapped(uri),
tables,
tables, [], [],
wrapCallback);
},

2
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() {

2
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() {

6
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();
});
}
};

6
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;
}

93
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 =

10
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;
};