Issue 3687 - Add experimental support for Safari content blockers

safari/contentBlocking.js

Index: safari/contentBlocking.js
diff --git a/safari/contentBlocking.js b/safari/contentBlocking.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d99a75e03040b66ea1875f2986688427b31cd3b
--- /dev/null
+++ b/safari/contentBlocking.js
@@ -0,0 +1,158 @@
+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2016 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
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @module contentBlocking */
+
+"use strict";
+
+let {Prefs} = require("prefs");
+let {ContentBlockerList} = require("abp2blocklist");
+let {FilterStorage} = require("filterStorage");
+let {FilterNotifier} = require("filterNotifier");
+let {port} = require("messaging");
+
+let contentBlockingSupported = "setContentBlocker" in safari.extension;
+let legacyAPISupported = new Promise(resolve =>
+{
+  function onLegacyAPISupported(msg, sender)
+  {
+    port.off("safari.legacyAPISupported", onLegacyAPISupported);
+    resolve(msg.legacyAPISupported);
+  }
+  port.on("safari.legacyAPISupported", onLegacyAPISupported);
+});
+let contentBlockingActive = false;
+let afterContentBlockingFinished = null;
+let contentBlockListDirty = true;
+let lastSetContentBlockerResult;
+
+function clearBlockCounters()
+{
+  ext.pages.query({}, pages =>
+  {
+    for (let page of pages)
+      page.browserAction.setBadge();
+  });
+}
+
+function setContentBlocker(callback)
+{
+  // setContentBlocker returns null if given the same blocklist as last time,
+  // even when there was an error. (It's also wasteful to re-generate the
+  // blocklist when nothing has changed!)
+  if (!contentBlockListDirty)
+  {
+    callback(lastSetContentBlockerResult);
+    return;
+  }
+
+  let contentBlockerList = new ContentBlockerList();
+  for (let subscription of FilterStorage.subscriptions)
+    if (!subscription.disabled)
+      for (let filter of subscription.filters)
+        contentBlockerList.addFilter(filter);
+
+  contentBlockListDirty = false;
+  safari.extension.setContentBlocker(
+    // setContentBlocker seems to not work in Safari 9 when a callback is passed
+    // unless the rules are converted to JSON first. (An error is thrown:
+    // "Extension compilation failed: Failed to parse the JSON String.")
+    // Bug #26322821 filed on bugreport.apple.com
+    JSON.stringify(contentBlockerList.generateRules()),
+    function (result)

[Sebastian Noack, 2016/05/17 18:35:25]

Nit: We usually don't put a space before the arguments list.

[Sebastian Noack, 2016/05/17 18:35:25]

Nit: I think this variable should be called "error".

[kzar, 2016/05/17 19:20:22]

Done.

[kzar, 2016/05/17 19:20:22]

Done.

+    {
+      // Safari 9 performs the callback twice under some conditions, first with

[kzar, 2016/05/17 17:13:06]

As far as I can tell the behaviour of the callback is something like this:

 - If callback is provided and rules aren't converted to JSON the callback will
first be called with an empty string "" and then an Error. Further calls will
result in a callback of "" followed by a callback of null.
 - If the callback is provided and the rules are converted to JSON the callback
will be performed with null on success or Error on error. Further calls with the
same rule string will always result in a callback of null until a call is
performed with a different JSON string. (Even if there was a problem.)
 - If the callback isn't provided things generally work as expected, but there's
no longer a way to verify that!

My only other idea to further improve how things work is to add a flag
`buggySetContentBlocker` that defaults to false. When the callback is performed
with the value of "" the flag is set to true and we start converting the passed
rules to JSON. This adds yet more code however and could make things more
fragile. (It also would mean we are generating the content list twice in a row
for buggy versions and it's already pretty slow when generating it once.)

[Sebastian Noack, 2016/05/17 18:35:25]

Well, if future versions of Safari won't have that bug, while we still have to
target versions with that bug, I suppose we should do something like that.
However, when doing so we can simply keep the list of rules around until the
callback get's called rather than generating it twice. But I agree, that for now
we should leave it like that.

[kzar, 2016/05/17 19:20:22]

Acknowledged.

+      // an empty string and then with an Error!
+      if (result == "")
+        return;
+
+      lastSetContentBlockerResult = result;
+      callback(result);
+    }
+  );
+}
+
+function updateContentBlocker(isStartup, legacyAPISupported)
+{
+  afterContentBlockingFinished = new Promise(resolve =>
+  {
+    setContentBlocker(result =>
+    {
+      if (result instanceof Error)
+      {
+        let suppressErrorMessage = false;
+
+        // If the content blocking API fails the first time it's used the
+        // legacy blocking API (if available) won't have been disabled.
+        if (!contentBlockingActive && legacyAPISupported)
+        {
+          Prefs.safariContentBlocker = false;
+          // If content blocking failed on startup and we're switching back to
+          // the legacy API anyway we don't need to show an error message.
+          if (isStartup)
+            suppressErrorMessage = true;
+        }
+
+        if (!suppressErrorMessage)
+          alert(result.message);
+      }
+      else if (!contentBlockingActive)
+      {
+        contentBlockingActive = true;
+        clearBlockCounters();
+      }
+
+      resolve(contentBlockingActive);
+      afterContentBlockingFinished = null;
+    });
+  });
+}
+
+if (contentBlockingSupported)
+{
+  Promise.all([Prefs.untilLoaded,
+               FilterNotifier.once("load"),
+               legacyAPISupported]).then(resolvedValues =>
+  {
+    let legacyAPISupported = resolvedValues[2];
+    if (!legacyAPISupported)
+      Prefs.safariContentBlocker = true;
+
+    if (Prefs.safariContentBlocker)
+      updateContentBlocker(true, legacyAPISupported);
+
+    Prefs.on("safariContentBlocker", () =>
+    {
+      if (!contentBlockingActive && Prefs.safariContentBlocker)
+        updateContentBlocker(false, legacyAPISupported);
+    });
+
+    FilterNotifier.on("filter.behaviorChanged", () =>
+    {
+      contentBlockListDirty = true;
+      if (contentBlockingActive)
+        updateContentBlocker(false, legacyAPISupported);
+    });
+  });
+}
+
+port.on("safari.contentBlockingActive", (msg, sender) =>
+{
+  if (!contentBlockingActive && afterContentBlockingFinished)
+    return afterContentBlockingFinished;
+  return contentBlockingActive;
+});