Issue 5539 - Implement "Acceptable Ads notification"

new-options.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 11 matching lines @@
 
 {
   let subscriptionsMap = Object.create(null);
   let filtersMap = Object.create(null);
   let collections = Object.create(null);
   let acceptableAdsUrl = null;
   let acceptableAdsPrivacyUrl = null;
   let isCustomFiltersLoaded = false;
   let {getMessage} = ext.i18n;
   let customFilters = [];
-  let showTrackingWarning = true;

[Thomas Greiner, 2017/09/15 16:15:24]

This value needs to come from the preferences. Otherwise it'd always be `true`
whenever the user opens the page.

[saroyanm, 2017/09/15 18:37:35]

Well spotted, thanks. Done.

   let filterErrors = new Map([
     ["synchronize_invalid_url",
      "options_filterList_lastDownload_invalidURL"],
     ["synchronize_connection_error",
      "options_filterList_lastDownload_connectionError"],
     ["synchronize_invalid_data",
      "options_filterList_lastDownload_invalidData"],
     ["synchronize_checksum_mismatch",
      "options_filterList_lastDownload_checksumMismatch"]
   ]);
@@ skipping 303 matching lines @@
       id: "blocking-languages-table",
       emptyText: ["options_language_empty"]
     }
   ]);
   collections.allLangs = new Collection([
     {
       id: "all-lang-table-add",
       emptyText: ["options_dialog_language_other_empty"]
     }
   ]);
-  collections.custom = new Collection([
-    {
-      id: "custom-list-table"
+  collections.more = new Collection([
+    {
+      id: "more-list-table"
     }
   ]);
   collections.whitelist = new Collection([
     {
       id: "whitelisting-table",
       emptyText: ["options_whitelist_empty_1", "options_whitelist_empty_2"]
     }
   ]);
   collections.filterLists = new Collection([
     {
       id: "all-filter-lists-table",
       useOriginalTitle: true
     }
   ]);
 
   function addSubscription(subscription)
   {
+    let {disabled} = subscription;
     let collection = null;
     if (subscription.recommended)
     {
       if (subscription.recommended == "ads")
       {
-        if (subscription.disabled == false)
+        if (disabled == false)
           collection = collections.langs;
 
         collections.allLangs.addItem(subscription);
       }
       else
       {
         collection = collections.protection;
       }
     }
-    else if (!isAcceptableAds(subscription.url))
-    {
-      collection = collections.custom;
+    else if (!isAcceptableAds(subscription.url) && disabled == false)
+    {
+      collection = collections.more;
     }
 
     if (collection)
       collection.addItem(subscription);
 
     subscriptionsMap[subscription.url] = subscription;
     updateTooltips();
   }
 
   function updateSubscription(subscription)
   {
     for (let name in collections)
       collections[name].updateItem(subscription);
 
     if (subscription.recommended == "ads")
     {
       if (subscription.disabled)
         collections.langs.removeItem(subscription);
       else
         collections.langs.addItem(subscription);
     }
     else if (!subscription.recommended && !isAcceptableAds(subscription.url))
     {
       if (subscription.disabled == false)
       {
-        collections.custom.addItem(subscription);
+        collections.more.addItem(subscription);
         updateTooltips();
       }
       else
       {
-        collections.custom.removeItem(subscription);
+        collections.more.removeItem(subscription);
       }
     }
   }
 
   function updateFilter(filter)
   {
     let match = filter.text.match(whitelistedDomainRegexp);
     if (match && !filtersMap[filter.text])
     {
       filter.title = match[1];
@@ skipping 138 matching lines @@
               type: "subscriptions.add",
               url: findParentData(element, "access", false)
             });
             break;
           }
         }
         break;
       case "close-dialog":
         closeDialog();
         break;
-      case "disallow-tracking":
-        execAction("switch-acceptable-ads", {value: "privacy"});
-        break;
       case "edit-custom-filters":
         setCustomFiltersView("write");
         break;
       case "hide-notification":
         hideNotification();
         break;
       case "import-subscription": {
         let url = E("blockingList-textbox").value;
         addEnableSubscription(url);
         closeDialog();
@@ skipping 27 matching lines @@
           type: "filters.importRaw",
           text: E("custom-filters-raw").value,
           removeExisting: true
         },
         () =>
         {
           setCustomFiltersView("read");
         });
         break;
       case "switch-acceptable-ads":
-        let {value} = element;
+        let value = element.value || element.dataset.value;
         ext.backgroundPage.sendMessage({
           type: value == "privacy" ? "subscriptions.add" :
             "subscriptions.remove",
           url: acceptableAdsPrivacyUrl
         });
         ext.backgroundPage.sendMessage({
           type: value == "ads" ? "subscriptions.add" : "subscriptions.remove",
           url: acceptableAdsUrl
         });
         break;
@@ skipping 29 matching lines @@
         ext.backgroundPage.sendMessage({
           type: "subscriptions.update"
         });
         break;
       case "update-subscription":
         ext.backgroundPage.sendMessage({
           type: "subscriptions.update",
           url: findParentData(element, "access", false)
         });
         break;
+      case "validate-import-subscription":
+        let form = findParentData(element, "validation", true);
+        if (!form)
+          return;
+
+        if (form.checkValidity())
+        {
+          addEnableSubscription(E("import-list-url").value,
+            E("import-list-title").value);
+          form.reset();
+          closeDialog();
+        }
+        else
+        {
+          form.querySelector(":invalid").focus();
+        }
+        break;
     }
   }
 
   function setCustomFiltersView(mode)
   {
     let customFiltersElement = E("custom-filters-raw");
     updateCustomFiltersUi();
     if (mode == "read")
     {
       customFiltersElement.disabled = true;
@@ skipping 142 matching lines @@
     // Initialize interactive UI elements
     document.body.addEventListener("click", onClick, false);
     document.body.addEventListener("keyup", onKeyUp, false);
     let exampleValue = getMessage("options_whitelist_placeholder_example",
       ["www.example.com"]);
     E("whitelisting-textbox").setAttribute("placeholder", exampleValue);
     E("whitelisting-textbox").addEventListener("keyup", (e) =>
     {
       E("whitelisting-add-button").disabled = !e.target.value;
     }, false);
-
 
     getDocLink("contribute", (link) =>
     {
       E("contribute").href = link;
     });
     getDocLink("acceptable_ads_criteria", (link) =>
     {
       setLinks("enable-aa-description", link);
     });
 
@@ skipping 163 matching lines @@
     for (let url in subscriptionsMap)
     {
       let subscription = subscriptionsMap[url];
       if (subscription.recommended == "privacy")
       {
         privacyList = subscription;
         break;
       }
     }
     return acceptableAdsList && acceptableAdsList.disabled == false &&
-      privacyList && privacyList.disabled == false && showTrackingWarning;

[Thomas Greiner, 2017/09/15 16:15:24]

Based on its name, the purpose of this function is to check whether a privacy
conflict exists, not whether the tracking warning should be shown. Therefore
let's check `showTrackingWarning` elsewhere.

[saroyanm, 2017/09/15 18:37:35]

Agree, Done.

+      privacyList && privacyList.disabled == false;
   }
 
   function populateLists()
   {
     subscriptionsMap = Object.create(null);
     filtersMap = Object.create(null);
 
     // Empty collections and lists
     for (let property in collections)
       collections[property].clearAll();
@@ skipping 145 matching lines @@
         updateSubscription(subscription);
         break;
       case "downloading":
       case "downloadStatus":
       case "homepage":
       case "lastDownload":
       case "title":
         updateSubscription(subscription);
         break;
       case "added":
-        let url = subscription.url;
+        let {url, recommended} = subscription;
         if (url in subscriptionsMap)
           updateSubscription(subscription);
         else
           addSubscription(subscription);
 
         if (isAcceptableAds(url))
           setAcceptableAds();
 
-        if (url == acceptableAdsUrl || subscription.recommended == "privacy")
-        {
-          if (hasPrivacyConflict())
-            openDialog("tracking");
+        if ((url == acceptableAdsUrl || recommended == "privacy") &&
+          hasPrivacyConflict())
+        {
+          getPref("ui_warn_tracking", (showTrackingWarning) =>
+          {
+            if (showTrackingWarning)
+              openDialog("tracking");
+          });
         }
 
         collections.filterLists.addItem(subscription);
         break;
       case "removed":
         if (subscription.recommended)
         {
           subscription.disabled = true;
           onSubscriptionMessage("disabled", subscription);
         }
         else
         {
           delete subscriptionsMap[subscription.url];
           if (isAcceptableAds(subscription.url))
           {
             setAcceptableAds();
           }
           else
           {
-            collections.custom.removeItem(subscription);
+            collections.more.removeItem(subscription);
           }
         }
         collections.filterLists.removeItem(subscription);
         break;
     }
-
   }
 
   function hidePref(key, value)
   {
     let element = document.querySelector("[data-pref='" + key + "']");
     if (element)
       element.setAttribute("aria-hidden", value);
   }
 
   function getPref(key, callback)
@@ skipping 30 matching lines @@
   function onPrefMessage(key, value, initial)
   {
     switch (key)
     {
       case "notifications_ignoredcategories":
         value = value.indexOf("*") == -1;
         break;
 
       case "notifications_showui":
         hidePref("notifications_ignoredcategories", !value);
-        break;
-
-      case "ui_warn_tracking":
-        showTrackingWarning = value;
         break;
     }
 
     let checkbox = document.querySelector(
       "[data-pref='" + key + "'] button[role='checkbox']"
     );
     if (checkbox)
       checkbox.setAttribute("aria-checked", value);
   }
 
@@ skipping 67 matching lines @@
   });
   ext.backgroundPage.sendMessage({
     type: "subscriptions.listen",
     filter: ["added", "disabled", "homepage", "lastDownload", "removed",
              "title", "downloadStatus", "downloading"]
   });
 
   window.addEventListener("DOMContentLoaded", onDOMLoaded, false);
   window.addEventListener("hashchange", onHashChange, false);
 }