Issue 6699 - Support the "circumvention" filter list as default subscription

lib/subscriptionInit.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 71 matching lines @@
         subscription.filters.length > 0)
       return false;
   }
 
   return true;
 }
 
 /**
  * @typedef {object} DefaultSubscriptions
  * @property {?Element} ads
- * @property {?Element} cv
+ * @property {?Element} circumvention
  */
 /**
  * Finds the elements for the default ad blocking filter subscriptions based
  * on the user's locale.
  *
  * @param {HTMLCollection} subscriptions
  * @return {DefaultSubscriptions}
  */
 function chooseFilterSubscriptions(subscriptions)
 {
   let selectedItem = {};
   let selectedPrefix = null;
   let matchCount = 0;
   for (let subscription of subscriptions)
   {
     let prefixes = subscription.getAttribute("prefixes");
     let prefix = prefixes && prefixes.split(",").find(
       lang => new RegExp("^" + lang + "\\b").test(Utils.appLocale)
     );
 
     let subscriptionType = subscription.getAttribute("type");
 
-    if (subscriptionType in ["ads", "cv"] && !selectedItem[subscriptionType])
+    if ((subscriptionType == "ads" || subscriptionType == "circumvention") &&
+        !selectedItem[subscriptionType])
       selectedItem[subscriptionType] = subscription;
 
     if (prefix)
     {
       // The "ads" subscription is the one driving the selection.
       if (subscriptionType == "ads")
       {
         if (!selectedPrefix || selectedPrefix.length < prefix.length)
         {
           selectedItem[subscriptionType] = subscription;
           selectedPrefix = prefix;
           matchCount = 1;
         }
         else if (selectedPrefix && selectedPrefix.length == prefix.length)
         {
           matchCount++;
 
           // If multiple items have a matching prefix of the same length:
           // Select one of the items randomly, probability should be the same
           // for all items. So we replace the previous match here with
           // probability 1/N (N being the number of matches).
           if (Math.random() * matchCount < 1)
           {
             selectedItem[subscriptionType] = subscription;
             selectedPrefix = prefix;
           }
         }
       }
-      else if (subscriptionType == "cv")
+      else if (subscriptionType == "circumvention")
       {
         selectedItem[subscriptionType] = subscription;
       }
     }
   }
   return selectedItem;
 }
 
 function supportsNotificationsWithButtons()
 {
@@ skipping 57 matching lines @@
   // Add default ad blocking subscription (e.g. EasyList)
   if (shouldAddDefaultSubscription())
   {
     return fetch("subscriptions.xml")
       .then(response => response.text())
       .then(text =>
       {
         let doc = new DOMParser().parseFromString(text, "application/xml");
         let nodes = doc.getElementsByTagName("subscription");
 
-        let subs = chooseFilterSubscriptions(nodes);
-        if (subs)
+        let defaultSubscriptions = chooseFilterSubscriptions(nodes);
+        if (defaultSubscriptions)
         {
-          for (let name in subs)

[Manish Jethani, 2018/06/13 16:58:12]

By the way, if you want to keep the return type a plain object rather than a Map
object, I think Object.keys would be faster and more appropriate because it only
returns the _own_ enumerable properties.

[hub, 2018/06/13 21:58:19]

There are at most two properties.

[Manish Jethani, 2018/06/14 05:07:34]

Acknowledged.

Since the calling code is now assuming the number of properties, maybe it could
assume the names as well? So `for (let name of ["ads", "circumvention"])`.

[Manish Jethani, 2018/06/14 05:42:56]

OK, forget this, it makes it worse.

Like you said it doesn't matter in this case, but when the names of the keys are
unknown (coming from an XML file for example), a Map object performs
significantly better (regardless of the number of keys).

Here's a test:

  (function()
  {
    function choose()
    {
      //return new Map([
      //  ["" + Math.random(), (Math.random() * 2) | 0],
      //  ["" + Math.random(), (Math.random() * 3) | 0]
      //]);
      return {
        ["" + Math.random()]: (Math.random() * 2) | 0,
        ["" + Math.random()]: (Math.random() * 3) | 0
      };
    }

    let array = new Array(100000);
    for (let i = 0; i < array.length; i++)
      array[i] = choose();

    let s = Date.now();
    let n = 0;
    for (let i = 0; i < array.length; i++)
    {
      let item = array[i];
      //for (let [, value] of item)
      //  n += value;
      for (let prop in item)
        n += item[prop];
    }
    console.log(Date.now() - s, n);
  })();

[hub, 2018/06/14 19:59:57]

Acknowledged.

+          for (let name in defaultSubscriptions)
           {
-            let node = subs[name];
+            let node = defaultSubscriptions[name];
             if (!node)
               continue;
 
             let url = node.getAttribute("url");
             if (url)
             {
               let subscription = Subscription.fromURL(url);
               subscription.disabled = false;
               subscription.title = node.getAttribute("title");
               subscription.homepage = node.getAttribute("homepage");
@@ skipping 85 matching lines @@
  *
  * @param {function} callback
  */
 exports.setSubscriptionsCallback = callback =>
 {
   subscriptionsCallback = callback;
 };
 
 // Exports for tests only
 exports.chooseFilterSubscriptions = chooseFilterSubscriptions;