Issue 3259 - Store blockable items selection in the content process

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
  * 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/>.
  */
 
 /**
  * @fileOverview Stores Adblock Plus data to be attached to a window.
  */
 
 let {Utils} = require("utils");
 
 let windowSelection = new WeakMap();
 let requestNotifierMaxId = 0;
 
 let windowStatsMaxResponseID = 0;
 let windowStatsCallbacks = new Map();
 
+let windowDataMaxResponseID = 0;
+let windowDataCallbacks = new Map();

[Thomas Greiner, 2016/01/05 15:43:58]

I noticed that most of the message logic (windowDataMaxResponseID,
windowDataCallbacks, onWindowDataReceived, retrieveWindowData) is identical to
the one for window stats so I'm wondering why you didn't reuse but instead
duplicated all of that.

Since there are a bunch of inconsistencies already (e.g. naming inconsistency
with `retrieveWindowData()` vs. `getWindowStats()` and
`onRetrieveWindowStats()`), I assume that the issue is that you don't want to
modify too much of that code or is there a different reason?

[Wladimir Palant, 2016/01/06 12:31:58]

The messaging logic is very suboptimal right now, and unifying it here would be
the wrong approach. Instead, I want our code to require("messaging") and use a
proper API. The goal is providing simple messaging and implicit callbacks, then
the ext.backgroundPage.sendMessage() implementation should use the new messaging
API as well.

[Thomas Greiner, 2016/01/06 13:16:22]

Sounds great. In that case I don't mind implementing it like it is for now.

+
 /**
  * Active RequestNotifier instances by their ID
  * @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:NotifierResponse", onNotifierResponse);
 Utils.addChildMessageListener("AdblockPlus:RetrieveWindowStatsResponse", onWindowStatsReceived);
+Utils.addChildMessageListener("AdblockPlus:RetrieveWindowDataResponse", onWindowDataReceived);
 
 function onNodeData({notifierID, data})
 {
   let notifier = notifiers.get(notifierID);
   if (notifier)
     notifier.notifyListener(data);
 }
 
 function onScanComplete(notifierID)
 {
@@ skipping 10 matching lines @@
 }
 
 function onWindowStatsReceived({responseID, stats})
 {
   let callback = windowStatsCallbacks.get(responseID);
   windowStatsCallbacks.delete(responseID);
   if (typeof callback == "function")
     callback(stats);
 }
 
+function onWindowDataReceived({responseID, data})
+{
+  let callback = windowDataCallbacks.get(responseID);
+  windowDataCallbacks.delete(responseID);
+  if (typeof callback == "function")
+    callback(data);
+}
+
 /**
  * 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)
 {
@@ skipping 128 matching lines @@
     this._callbacks.set(id, callback);
 
     messageManager.broadcastAsyncMessage("AdblockPlus:StoreNodesForEntries", {
       notifierID: this.id,
       responseID: id,
       requests,
     });
   }
 };
 
-RequestNotifier.storeSelection = function(/**Window*/ wnd, /**String*/ selection)
+/**
+ * Associates a piece of data with a particular window.
+ * @param {number} outerWindowID  the ID of the window
+ * @static
+ */
+RequestNotifier.storeWindowData = function(outerWindowID, data)
 {
-  windowSelection.set(wnd.document, selection);
+  messageManager.broadcastAsyncMessage("AdblockPlus:StoreWindowData", {
+    outerWindowID,
+    data
+  });
 };
-RequestNotifier.getSelection = function(/**Window*/ wnd) /**String*/
+
+/**
+ * Retrieves a piece of data previously associated with the window by calling
+ * storeWindowData.
+ * @param {number} outerWindowID  the ID of the window
+ * @param {Function} callback  function to be called with the data.
+ * @static
+ */
+RequestNotifier.retrieveWindowData = function(outerWindowID, callback)
 {
-  if (windowSelection.has(wnd.document))
-    return windowSelection.get(wnd.document);
-  else
-    return null;
+  let id = ++windowDataMaxResponseID;
+  windowDataCallbacks.set(id, callback);
+
+  messageManager.broadcastAsyncMessage("AdblockPlus:RetrieveWindowData", {
+    outerWindowID,
+    responseID: id
+  });
 };
 
 /**
  * Retrieves the statistics for a window.
  * @param {number} outerWindowID  the ID of the window
  * @param {Function} callback  the callback to be called with the resulting
  *                             object (object properties will be items, blocked,
  *                             whitelisted, hidden, filters) or null.
  */
 RequestNotifier.getWindowStatistics = function(outerWindowID, callback)
 {
   let id = ++windowStatsMaxResponseID;
   windowStatsCallbacks.set(id, callback);
 
   messageManager.broadcastAsyncMessage("AdblockPlus:RetrieveWindowStats", {
     responseID: id,
     outerWindowID
   });
 }