Issue 3258 - Blockable items: fix Size column

lib/requestNotifier.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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 18 matching lines @@
  * @type Map.<number,RequestNotifier>
  */
 let notifiers = new Map();
 
 let messageManager = Cc["@mozilla.org/parentprocessmessagemanager;1"]
                        .getService(Ci.nsIMessageListenerManager)
                        .QueryInterface(Ci.nsIMessageBroadcaster);
 
 Utils.addChildMessageListener("AdblockPlus:FoundNodeData", onNodeData);
 Utils.addChildMessageListener("AdblockPlus:ScanComplete", onScanComplete);
+Utils.addChildMessageListener("AdblockPlus:RetrieveNodeSizeResponse", onNodeSizeReceived);
 
 function onNodeData({notifierID, data})
 {
   let notifier = notifiers.get(notifierID);
   if (notifier)
     notifier.notifyListener(data);
 }
 
 function onScanComplete(notifierID)
 {
   let notifier = notifiers.get(notifierID);
   if (notifier)
     notifier.onComplete();
 }
 
+function onNodeSizeReceived({notifierID, responseID, size})
+{
+  let notifier = notifiers.get(notifierID);
+  if (notifier)
+    notifier.onNodeSizeReceived(responseID, size);
+}
+
 /**
  * Creates a notifier object for a particular window. After creation the window
  * will first be scanned for previously saved requests. Once that scan is
  * complete only new requests for this window will be reported.
  * @param {Integer} outerWindowID  ID of the window to attach the notifier to
  * @param {Function} listener  listener to be called whenever a new request is found
  * @param {Object} [listenerObj]  "this" pointer to be used when calling the listener
  */
 function RequestNotifier(outerWindowID, listener, listenerObj)
 {
   this.listener = listener;
   this.listenerObj = listenerObj || null;
   this.id = ++requestNotifierMaxId;
   notifiers.set(this.id, this);
+  this._nodeSizeCallbacks = new Map();
 
   messageManager.broadcastAsyncMessage("AdblockPlus:StartWindowScan", {
     notifierID: this.id,
     outerWindowID: outerWindowID
   });
 }
 exports.RequestNotifier = RequestNotifier;
 
 RequestNotifier.prototype =
 {
@@ skipping 55 matching lines @@
   flashNodes: function(requests, scrollToItem)
   {
     if (!requests)
       requests = [];
 
     messageManager.broadcastAsyncMessage("AdblockPlus:FlashNodes", {
       notifierID: this.id,
       requests,
       scrollToItem
     });
+  },
+
+  _nodeSizeMaxResponseID: 0,
+  _nodeSizeCallbacks: null,
+
+  /**
+   * Attempts to calculate the size of the nodes associated with the requests.
+   * Callback will only be called on success.
+   * @param {number[]} requests  list of request IDs that were previously
+   *                             reported by this notifier.
+   * @param {Function} callback  function to be called with two parameters (x,y)

[Thomas Greiner, 2015/11/24 14:02:20]

Suggestion: JSDoc provides a way to document callbacks so we could use that to
avoid putting crucial meta data into the parameter description. However, since I
understand that this may be a bit too much overhead, I'll leave it up to you
whether you want to do that.

See http://usejsdoc.org/tags-param.html#callback-functions

[Wladimir Palant, 2015/11/25 22:22:49]

I've seen that but I'd rather not make it too complicated. Might have been
different if this callback were indeed a common type rather than a one-time
thing.

+   */
+  retrieveNodeSize: function(requests, callback)
+  {
+    if (!requests)
+      requests = [];
+
+    let id = ++this._nodeSizeMaxResponseID;
+    this._nodeSizeCallbacks.set(id, callback);
+
+    messageManager.broadcastAsyncMessage("AdblockPlus:RetrieveNodeSize", {
+      notifierID: this.id,
+      responseID: id,
+      requests,
+    });
+  },
+
+  onNodeSizeReceived: function(responseID, size)
+  {
+    let callback = this._nodeSizeCallbacks.get(responseID);
+    this._nodeSizeCallbacks.delete(responseID);
+    if (size && typeof callback == "function")
+      callback(size);
   }
 };
 
 RequestNotifier.storeSelection = function(/**Window*/ wnd, /**String*/ selection)
 {
   windowSelection.set(wnd.document, selection);
 };
 RequestNotifier.getSelection = function(/**Window*/ wnd) /**String*/
 {
   if (windowSelection.has(wnd.document))
@@ skipping 52 matching lines @@
       node = node.parentNode;
     }
     else
     {
       node = null;
     }
   }
 
   return null;
 };