Issue 3499 - Create a clean messaging API for internal use

lib/messaging.js

 /*
  * 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
@@ skipping 34 matching lines @@
   {
     Cu.reportError("Unexpected message manager, impossible to send message");
     return 0;
   }
 }
 
 function sendSyncMessage(messageManager, messageName, payload)
 {
   let request = {messageName, payload};
   let responses = messageManager.sendRpcMessage(MESSAGE_NAME, request);
-  return flattenResponses(responses, messageName);
-}
-
-function flattenResponses(responses, messageName)
-{
-  let result = undefined;
+  let processor = new ResponseProcessor(messageName);
   for (let response of responses)
+    processor.add(response);
+  return processor.value;
+}
+
+function ResponseProcessor(messageName)
+{
+  this.value = undefined;
+  this.add = function(response)
   {
     if (typeof response == "undefined")
-      continue;
-
-    if (typeof result == "undefined")
-      result = response;
+      return;
+
+    if (typeof this.value == "undefined")
+      this.value = response;
     else
       Cu.reportError("Got multiple responses to message '" + messageName + "', only first response was accepted.");
-  }
-  return result;
+  };
 }
 
 function getSender(origin)
 {
   if (origin instanceof Ci.nsIDOMXULElement)
     origin = origin.messageManager;
 
   if (origin instanceof Ci.nsIMessageSender)
     return new LightWeightPort(origin);
   else
@@ skipping 92 matching lines @@
     }
     else
       this._sendResponse(sender, callbackID, result);
 
     return result;
   },
 
   _handleResponse: function(message)
   {
     let {callbackID, payload} = message.data;
-    if (!this._responseCallbacks.has(callbackID))
+    let callbackData = this._responseCallbacks.get(callbackID);
+    if (!callbackData)
       return;
 
-    let [callback, messageName, responses, expectedResponses] =
-        this._responseCallbacks.get(callbackID);
-    responses.push(payload);
-    if (responses.length == expectedResponses)
+    let [callback, processor, expectedResponses] = callbackData;
+
+    try
+    {
+      processor.add(payload);
+    }
+    catch (e)
+    {
+      Cu.reportError(e);
+    }
+
+    callbackData[2] = --expectedResponses;
+    if (expectedResponses <= 0)
     {
       this._responseCallbacks.delete(callbackID);
-      callback(flattenResponses(responses, messageName));
+      callback(processor.value);
     }
   },
 
   _dispatch: function(messageName, payload, sender)
   {
     let callbacks = this._callbacks.get(messageName);
     if (!callbacks)
       return undefined;
 
     callbacks = callbacks.slice();
-    let responses = [];
+    let processor = new ResponseProcessor(messageName);
     for (let callback of callbacks)
     {
       try
       {
-        responses.push(callback(payload, sender));
+        processor.add(callback(payload, sender));
       }
       catch (e)
       {
         Cu.reportError(e);
       }
     }
-    return flattenResponses(responses, messageName);
+    return processor.value;
   },
 
   /**
    * Function to be called when a particular message is received
    * @callback Port~messageHandler
    * @param payload data attached to the message if any
    * @param {LightWeightPort} sender object that can be used to communicate with
    *      the sender of the message, could be null
    * @return the handler can return undefined (no response), a value (response
    *      to be sent to sender immediately) or a promise (asynchronous
@@ skipping 47 matching lines @@
    * @return {Promise} promise that will be resolved with the response
    */
   emitWithResponse: function(messageName, payload)
   {
     let callbackID = ++this._responseCallbackCounter;
     let expectedResponses = sendMessage(
         this._messageManager, messageName, payload, callbackID);
     return new Promise((resolve, reject) =>
     {
       this._responseCallbacks.set(callbackID,
-          [resolve, messageName, [], expectedResponses]);
+          [resolve, new ResponseProcessor(messageName), expectedResponses]);
     });
   },
 
   /**
    * Sends a synchonous message (DO NOT USE unless absolutely unavoidable).
    * @param {string} messageName message identifier
    * @param [payload] data to attach to the message
    * @return response returned by the handler
    */
   emitSync: function(messageName, payload)
@@ skipping 12 matching lines @@
 catch (e)
 {
   // Parent
   messageManager = Cc["@mozilla.org/parentprocessmessagemanager;1"]
                      .getService(Ci.nsIMessageListenerManager);
 }
 
 let port = new Port(messageManager);
 onShutdown.add(() => port.disconnect());
 exports.port = port;