Issue 3225 - Make Diagnostics compatible with the upcoming Adblock Plus 2.7 release

chrome/content/watcher.js

 /*
  * This Source Code is subject to the terms of the Mozilla Public License
  * version 2.0 (the "License"). You can obtain a copy of the License at
  * http://mozilla.org/MPL/2.0/.
  */
 
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 const Cr = Components.results;
 const Cu = Components.utils;
 
 Cu.import("resource://gre/modules/Services.jsm");
 
 function abprequire(module)
 {
   let result = {};
   result.wrappedJSObject = result;
   Services.obs.notifyObservers(result, "adblockplus-require", module);
   return result.exports;
 }
 
 let {Policy} = abprequire("contentPolicy");
-let {RequestNotifier} = abprequire("requestNotifier");
 let {Filter} = abprequire("filterClasses");
 
 let origShouldAllow = Policy.shouldAllow;
 if (!origShouldAllow)
   window.close();
 
-let currentData = null;
 let processingQueue = [];
 let notifier = null;
 
 // Randomize URI to work around bug 719376
 let stringBundle = Services.strings.createBundle("chrome://abpwatcher/locale/global.properties?" + Math.random());
 
 let clipboardHelper = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(Ci.nsIClipboardHelper);
 
 function init()
 {
   let list = document.getElementById("list");
   list.view = treeView;
   list.focus();
 
   treeView.addObserver(updateProcessingTime);
   updateProcessingTime(treeView, "refresh");
 
   // Make sure the tree view has correct filters
   document.getElementById("filterText").doCommand();
 
-  notifier = new RequestNotifier(null, handleFilterHit);

[Wladimir Palant, 2015/12/07 12:17:55]

I realized that I didn't test the Filter column - this wasn't actually working.
RequestNotifier no longer supports null as parameter that used to mean "track
all windows." Luckily, using RequestNotifier isn't even necessary - the result
of the shouldAllow call already contains all the hits. So the new patchsets
extracts the filters from this data structure now.

-
   Policy.shouldAllow = replacementShouldAllow;
   setInterval(processQueue, 200);
 }
 
 function E(id)
 {
   return document.getElementById(id);
 }
 
 function replacementShouldAllow({contentType, location, frames, isPrivate})
 {
-  let startTime = null;
-  try
-  {
-    currentData = {
-      filters: [],
-      type: contentType,
-      location: location,
-      frames: frames,
-      isPrivate: isPrivate
-    };
-    startTime = Date.now();
-  }
-  catch(e)
-  {
-    Cu.reportError(e);
-  }
-
+  let startTime = Date.now();
+  let currentData = {
+    type: contentType,
+    location: location,
+    frames: frames,
+    isPrivate: isPrivate
+  };
   let ret;
+
   try
   {
     ret = origShouldAllow.apply(this, arguments);
     return ret;
   }
   finally
   {
     if (startTime !== null)
     {
       currentData.processingTime = (Date.now() - startTime);
       currentData.result = ret;
+      currentData.filters = ret.hits.filter(h => h.filter).map(h => h.filter);
 
       processingQueue.push(currentData);
       currentData = null;
     }
   }
 }
 
 function destroy()
 {
-  if (notifier)
-    notifier.shutdown();
   if (origShouldAllow)
     Policy.shouldAllow = origShouldAllow;
-}
-
-function handleFilterHit(data)
-{
-  if (data.filter && currentData)
-    currentData.filters.push(data.filter);
 }
 
 function processQueue()
 {
   if (!processingQueue.length)
     return;
 
   function stringify(value)
   {
     if (typeof value == "undefined" || value == null)
       return "";
     else
       return String(value);
   }
 
   for each (let entry in processingQueue)
   {
     entry.cols = {
       address: stringify(entry.location),
       type: stringify(entry.type),
       result: stringBundle.GetStringFromName(entry.result && entry.result.allow ? "decision.allow" : "decision.block"),
       origin: stringify(entry.frames && entry.frames[0] && entry.frames[0].location),
-      filters: stringify(entry.filters && entry.filters.join(", ")),
+      filter: stringify(entry.filters && entry.filters.join(", ")),
       time: stringify(entry.processingTime)
     };
     treeView.add(entry);
   }
 
   processingQueue = [];
 }
 
 function fillInTooltip(event)
 {
@@ skipping 403 matching lines @@
     for (let i = 0; i < this.observers.length; i++)
       if (this.observers[i] == observer)
         this.observers.splice(i--, 1);
   },
   notifyObservers: function(operation, entry)
   {
     for each (let observer in this.observers)
       observer(this, operation, entry);
   }
 };