gecko/dom/messages/SystemMessageInternal.js

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

const Cc = Components.classes;
const Ci = Components.interfaces;
const Cu = Components.utils;
const Cr = Components.results;

Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");
Cu.import("resource://gre/modules/SystemMessagePermissionsChecker.jsm");

XPCOMUtils.defineLazyServiceGetter(this, "ppmm",
                                   "@mozilla.org/parentprocessmessagemanager;1",
                                   "nsIMessageBroadcaster");

XPCOMUtils.defineLazyServiceGetter(this, "gUUIDGenerator",
                                   "@mozilla.org/uuid-generator;1",
                                   "nsIUUIDGenerator");

XPCOMUtils.defineLazyServiceGetter(this, "powerManagerService",
                                   "@mozilla.org/power/powermanagerservice;1",
                                   "nsIPowerManagerService");

XPCOMUtils.defineLazyServiceGetter(this, "appsService",
                                   "@mozilla.org/AppsService;1",
                                   "nsIAppsService");

// Limit the number of pending messages for a given page.
let kMaxPendingMessages;
try {
  kMaxPendingMessages =
    Services.prefs.getIntPref("dom.messages.maxPendingMessages");
} catch(e) {
  // getIntPref throws when the pref is not set.
  kMaxPendingMessages = 5;
}

const kMessages =["SystemMessageManager:GetPendingMessages",
                  "SystemMessageManager:Register",
                  "SystemMessageManager:Unregister",
                  "SystemMessageManager:Message:Return:OK",
                  "SystemMessageManager:AskReadyToRegister",
                  "SystemMessageManager:HandleMessagesDone",
                  "SystemMessageManager:HandleMessageDone",
                  "child-process-shutdown"];

function debug(aMsg) {
  // dump("-- SystemMessageInternal " + Date.now() + " : " + aMsg + "\n");
}


let defaultMessageConfigurator = {
  get mustShowRunningApp() {
    return false;
  }
};

const MSG_SENT_SUCCESS = 0;
const MSG_SENT_FAILURE_PERM_DENIED = 1;
const MSG_SENT_FAILURE_APP_NOT_RUNNING = 2;

// Implementation of the component used by internal users.

function SystemMessageInternal() {
  // The set of pages registered by installed apps. We keep the
  // list of pending messages for each page here also.
  this._pages = [];

  // The set of listeners. This is a multi-dimensional object. The _listeners
  // object itself is a map from manifest URL -> an array mapping proccesses to
  // windows. We do this so that we can track both what processes we have to
  // send system messages to as well as supporting the single-process case
  // where we track windows instead.
  this._listeners = {};

  this._webappsRegistryReady = false;
  this._bufferedSysMsgs = [];

  this._cpuWakeLocks = {};

  this._configurators = {};

  this._pendingPromises = new Map();

  Services.obs.addObserver(this, "xpcom-shutdown", false);
  Services.obs.addObserver(this, "webapps-registry-start", false);
  Services.obs.addObserver(this, "webapps-registry-ready", false);
  Services.obs.addObserver(this, "webapps-clear-data", false);
  kMessages.forEach(function(aMsg) {
    ppmm.addMessageListener(aMsg, this);
  }, this);

  Services.obs.notifyObservers(this, "system-message-internal-ready", null);
}

SystemMessageInternal.prototype = {

  _getMessageConfigurator: function(aType) {
    debug("_getMessageConfigurator for type: " + aType);
    if (this._configurators[aType] === undefined) {
      let contractID =
        "@mozilla.org/dom/system-messages/configurator/" + aType + ";1";
      if (contractID in Cc) {
        debug(contractID + " is registered, creating an instance");
        this._configurators[aType] =
          Cc[contractID].createInstance(Ci.nsISystemMessagesConfigurator);
      } else {
        debug(contractID + "is not registered, caching the answer");
        this._configurators[aType] = null;
      }
    }
    return this._configurators[aType] || defaultMessageConfigurator;
  },

  _cancelCpuWakeLock: function(aPageKey) {
    let cpuWakeLock = this._cpuWakeLocks[aPageKey];
    if (cpuWakeLock) {
      debug("Releasing the CPU wake lock for page key = " + aPageKey);
      cpuWakeLock.wakeLock.unlock();
      cpuWakeLock.timer.cancel();
      delete this._cpuWakeLocks[aPageKey];
    }
  },

  _acquireCpuWakeLock: function(aPageKey) {
    let cpuWakeLock = this._cpuWakeLocks[aPageKey];
    if (!cpuWakeLock) {
      // We have to ensure the CPU doesn't sleep during the process of the page
      // handling the system messages, so that they can be handled on time.
      debug("Acquiring a CPU wake lock for page key = " + aPageKey);
      cpuWakeLock = this._cpuWakeLocks[aPageKey] = {
        wakeLock: powerManagerService.newWakeLock("cpu"),
        timer: Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer),
        lockCount: 1
      };
    } else {
      // We've already acquired the CPU wake lock for this page,
      // so just add to the lock count and extend the timeout.
      cpuWakeLock.lockCount++;
    }

    // Set a watchdog to avoid locking the CPU wake lock too long,
    // because it'd exhaust the battery quickly which is very bad.
    // This could probably happen if the app failed to launch or
    // handle the system messages due to any unexpected reasons.
    cpuWakeLock.timer.initWithCallback(function timerCb() {
      debug("Releasing the CPU wake lock because the system messages " +
            "were not handled by its registered page before time out.");
      this._cancelCpuWakeLock(aPageKey);
    }.bind(this), 30000, Ci.nsITimer.TYPE_ONE_SHOT);
  },

  _releaseCpuWakeLock: function _releaseCpuWakeLock(aPageKey, aHandledCount) {
    let cpuWakeLock = this._cpuWakeLocks[aPageKey];
    if (cpuWakeLock) {
      cpuWakeLock.lockCount -= aHandledCount;
      if (cpuWakeLock.lockCount <= 0) {
        debug("Unlocking the CPU wake lock now that the system messages " +
              "have been successfully handled by its registered page.");
        this._cancelCpuWakeLock(aPageKey);
      }
    }
  },

  _findPage: function(aType, aPageURL, aManifestURL) {
    let page = null;
    this._pages.some(function(aPage) {
      if (this._isPageMatched(aPage, aType, aPageURL, aManifestURL)) {
        page = aPage;
      }
      return page !== null;
    }, this);
    return page;
  },

  _findCacheForApp: function(aManifestURL) {
    let cache = [];
    this._pages.forEach(function(aPage) {
      if (aPage.manifestURL === aManifestURL &&
          aPage.pendingMessages.length != 0) {
        cache.push({ type: aPage.type,
                     pageURL: aPage.pageURL,
                     manifestURL: aPage.manifestURL });
      }
    });
    return cache;
  },

  sendMessage: function(aType, aMessage, aPageURI, aManifestURI, aExtra) {
    return new Promise((aResolve, aReject) => {
      this.sendMessageInternal(aType, aMessage, aPageURI, aManifestURI, aExtra,
                               aResolve, aReject);
    });
  },

  sendMessageInternal: function(aType, aMessage, aPageURI, aManifestURI,
                                aExtra, aResolvePromiseCb, aRejectPromiseCb) {
    // Buffer system messages until the webapps' registration is ready,
    // so that we can know the correct pages registered to be sent.
    if (!this._webappsRegistryReady) {
      this._bufferedSysMsgs.push({ how: "send",
                                   type: aType,
                                   msg: aMessage,
                                   pageURI: aPageURI,
                                   manifestURI: aManifestURI,
                                   extra: aExtra,
                                   resolvePromiseCb: aResolvePromiseCb,
                                   rejectPromiseCb: aRejectPromiseCb });
      return;
    }

    // Give this message an ID so that we can identify the message and
    // clean it up from the pending message queue when apps receive it.
    let messageID = gUUIDGenerator.generateUUID().toString();
    let manifestURL = aManifestURI.spec;

    let pendingPromise = { resolvePromiseCb: aResolvePromiseCb,
                           rejectPromiseCb: aRejectPromiseCb,
                           manifestURL: manifestURL,
                           counter: 0 };

    let pageURLs = [];
    if (aPageURI) {
      pageURLs.push(aPageURI.spec);
    } else {
      // Send this message to all the registered pages of the app if |aPageURI|
      // is not specified.
      for (let i = 0; i < this._pages.length; i++) {
        let page = this._pages[i];
        if (page.type === aType && page.manifestURL === manifestURL) {
          pageURLs.push(page.pageURL);
        }
      }
    }

    pageURLs.forEach(function(aPageURL) {
      debug("Sending " + aType + " " + JSON.stringify(aMessage) +
        " for " + aPageURL + " @ " + manifestURL +
        '; extra: ' + JSON.stringify(aExtra));

      let result = this._sendMessageCommon(aType,
                                           aMessage,
                                           messageID,
                                           aPageURL,
                                           manifestURL,
                                           aExtra);
      debug("Returned status of sending message: " + result);

      if (result === MSG_SENT_FAILURE_PERM_DENIED) {
        return;
      }

      // For each page we must receive a confirm.
      ++pendingPromise.counter;

    }, this);

    if (pendingPromise.counter) {
      this._pendingPromises.set(messageID, pendingPromise);
    }
  },

  broadcastMessage: function(aType, aMessage, aExtra) {
    // Buffer system messages until the webapps' registration is ready,
    // so that we can know the correct pages registered to be broadcasted.
    if (!this._webappsRegistryReady) {
      this._bufferedSysMsgs.push({ how: "broadcast",
                                   type: aType,
                                   msg: aMessage,
                                   extra: aExtra });
      return;
    }

    // Give this message an ID so that we can identify the message and
    // clean it up from the pending message queue when apps receive it.
    let messageID = gUUIDGenerator.generateUUID().toString();

    debug("Broadcasting " + aType + " " + JSON.stringify(aMessage) +
      '; extra = ' + JSON.stringify(aExtra));

    let shouldDispatchFunc = this._getMessageConfigurator(aType).shouldDispatch;

    // Find pages that registered an handler for this type.
    this._pages.forEach(function(aPage) {
      if (aPage.type !== aType) {
        return;
      }

      let doDispatch = () => {
        let result = this._sendMessageCommon(aType,
                                             aMessage,
                                             messageID,
                                             aPage.pageURL,
                                             aPage.manifestURL,
                                             aExtra);
        debug("Returned status of sending message: " + result);
      };

      if ('function' !== typeof shouldDispatchFunc) {
        // If the configurator has no 'shouldDispatch' defined,
        // always dispatch this message.
        doDispatch();
        return;
      }

      shouldDispatchFunc(aPage.manifestURL, aPage.pageURL, aType, aMessage, aExtra)
        .then(aShouldDispatch => {
          if (aShouldDispatch) {
            doDispatch();
          }
        });

    }, this);
  },

  registerPage: function(aType, aPageURI, aManifestURI) {
    if (!aPageURI || !aManifestURI) {
      throw Cr.NS_ERROR_INVALID_ARG;
    }

    let pageURL = aPageURI.spec;
    let manifestURL = aManifestURI.spec;

    // Don't register duplicates for this tuple.
    let page = this._findPage(aType, pageURL, manifestURL);
    if (page) {
      debug("Ignoring duplicate registration of " +
            [aType, pageURL, manifestURL]);
      return;
    }

    this._pages.push({ type: aType,
                       pageURL: pageURL,
                       manifestURL: manifestURL,
                       pendingMessages: [] });
  },

  refreshCache: function(aChildMM, aManifestURI) {
    if (!aManifestURI) {
      throw Cr.NS_ERROR_INVALID_ARG;
    }
    this._refreshCacheInternal(aChildMM, aManifestURI.spec);
  },

  _refreshCacheInternal: function(aChildMM, aManifestURL) {
    let cache = this._findCacheForApp(aManifestURL);
    aChildMM.sendAsyncMessage("SystemMessageCache:RefreshCache", cache);
  },

  _findTargetIndex: function(aTargets, aTarget) {
    if (!aTargets || !aTarget) {
      return -1;
    }
    for (let index = 0; index < aTargets.length; ++index) {
      let target = aTargets[index];
      if (target.target === aTarget) {
        return index;
      }
    }
    return -1;
  },

  _isEmptyObject: function(aObj) {
    for (let name in aObj) {
      return false;
    }
    return true;
  },

  _removeTargetFromListener: function(aTarget,
                                      aManifestURL,
                                      aRemoveListener,
                                      aPageURL) {
    let targets = this._listeners[aManifestURL];
    if (!targets) {
      return false;
    }

    let index = this._findTargetIndex(targets, aTarget);
    if (index === -1) {
      return false;
    }

    if (aRemoveListener) {
      debug("remove the listener for " + aManifestURL);
      delete this._listeners[aManifestURL];
      return true;
    }

    let target = targets[index];
    if (aPageURL && target.winCounts[aPageURL] !== undefined &&
        --target.winCounts[aPageURL] === 0) {
      delete target.winCounts[aPageURL];
    }

    if (this._isEmptyObject(target.winCounts)) {
      if (targets.length === 1) {
        // If it's the only one, get rid of the entry of manifest URL entirely.
        debug("remove the listener for " + aManifestURL);
        delete this._listeners[aManifestURL];
      } else {
        // If more than one left, remove this one and leave the rest.
        targets.splice(index, 1);
      }
    }
    return true;
  },

  receiveMessage: function(aMessage) {
    let msg = aMessage.json;

    // To prevent the hacked child process from sending commands to parent
    // to manage system messages, we need to check its manifest URL.
    if (["SystemMessageManager:Register",
         // TODO: fix bug 988142 to re-enable.
         // "SystemMessageManager:Unregister",
         "SystemMessageManager:GetPendingMessages",
         "SystemMessageManager:Message:Return:OK",
         "SystemMessageManager:HandleMessagesDone",
         "SystemMessageManager:HandleMessageDone"].indexOf(aMessage.name) != -1) {
      if (!aMessage.target.assertContainApp(msg.manifestURL)) {
        debug("Got message from a child process containing illegal manifest URL.");
        return null;
      }
    }

    switch(aMessage.name) {
      case "SystemMessageManager:AskReadyToRegister":
        return true;
        break;
      case "SystemMessageManager:Register":
      {
        debug("Got Register from " + msg.pageURL + " @ " + msg.manifestURL);
        let pageURL = msg.pageURL;
        let targets, index;
        if (!(targets = this._listeners[msg.manifestURL])) {
          let winCounts = {};
          winCounts[pageURL] = 1;
          this._listeners[msg.manifestURL] = [{ target: aMessage.target,
                                                winCounts: winCounts }];
        } else if ((index = this._findTargetIndex(targets,
                                                  aMessage.target)) === -1) {
          let winCounts = {};
          winCounts[pageURL] = 1;
          targets.push({ target: aMessage.target,
                         winCounts: winCounts });
        } else {
          let winCounts = targets[index].winCounts;
          if (winCounts[pageURL] === undefined) {
            winCounts[pageURL] = 1;
          } else {
            winCounts[pageURL]++;
          }
        }

        this._refreshCacheInternal(aMessage.target, msg.manifestURL);
        debug("listeners for " + msg.manifestURL +
              " innerWinID " + msg.innerWindowID);
        break;
      }
      case "child-process-shutdown":
      {
        debug("Got child-process-shutdown from " + aMessage.target);
        for (let manifestURL in this._listeners) {
          // See if any processes in this manifest URL have this target.
          this._removeTargetFromListener(aMessage.target,
                                         manifestURL,
                                         true,
                                         null);

          this._rejectPendingPromisesFromManifestURL(manifestURL);
        }
        break;
      }
      case "SystemMessageManager:Unregister":
      {
        debug("Got Unregister from " + aMessage.target +
              " innerWinID " + msg.innerWindowID);
        this._removeTargetFromListener(aMessage.target,
                                       msg.manifestURL,
                                       false,
                                       msg.pageURL);
        this._rejectPendingPromisesFromManifestURL(msg.manifestURL);
        break;
      }
      case "SystemMessageManager:GetPendingMessages":
      {
        debug("received SystemMessageManager:GetPendingMessages " + msg.type +
          " for " + msg.pageURL + " @ " + msg.manifestURL);

        // This is a sync call used to return the pending messages for a page.
        // Find the right page to get its corresponding pending messages.
        let page = this._findPage(msg.type, msg.pageURL, msg.manifestURL);
        if (!page) {
          return;
        }

        // Return the |msg| of each pending message.
        let pendingMessages = [];
        page.pendingMessages.forEach(function(aMessage) {
          pendingMessages.push({ msg: aMessage.msg, msgID: aMessage.msgID });
        });

        // Clear the pending queue for this page. This is OK since we'll store
        // pending messages in the content process (|SystemMessageManager|).
        page.pendingMessages.length = 0;

        // Send the array of pending messages.
        aMessage.target
                .sendAsyncMessage("SystemMessageManager:GetPendingMessages:Return",
                                  { type: msg.type,
                                    manifestURL: msg.manifestURL,
                                    pageURL: msg.pageURL,
                                    msgQueue: pendingMessages });
        this._refreshCacheInternal(aMessage.target, msg.manifestURL);
        break;
      }
      case "SystemMessageManager:Message:Return:OK":
      {
        debug("received SystemMessageManager:Message:Return:OK " + msg.type +
          " for " + msg.pageURL + " @ " + msg.manifestURL);

        // We need to clean up the pending message since the app has already
        // received it, thus avoiding the re-lanunched app handling it again.
        let page = this._findPage(msg.type, msg.pageURL, msg.manifestURL);
        if (page) {
          let pendingMessages = page.pendingMessages;
          for (let i = 0; i < pendingMessages.length; i++) {
            if (pendingMessages[i].msgID === msg.msgID) {
              pendingMessages.splice(i, 1);
              break;
            }
          }
        }
        break;
      }
      case "SystemMessageManager:HandleMessageDone":
      {
        debug("received SystemMessageManager:HandleMessageDone " + msg.type +
          " with msgID " + msg.msgID + " for " + msg.pageURL +
          " @ " + msg.manifestURL + " - promise rejected: " + msg.rejected);

        // Maybe this should resolve/reject a pending promise.
        if (msg.rejected) {
          this._rejectPendingPromises(msg.msgID);
        } else {
          this._resolvePendingPromises(msg.msgID);
        }

        // A page has finished handling some of its system messages, so we try
        // to release the CPU wake lock we acquired on behalf of that page.
        this._releaseCpuWakeLock(this._createKeyForPage(msg), 1);
        break;
      }

      case "SystemMessageManager:HandleMessagesDone":
      {
        debug("received SystemMessageManager:HandleMessagesDone " + msg.type +
          " with " + msg.handledCount + " for " + msg.pageURL +
          " @ " + msg.manifestURL);

        // A page has finished handling some of its system messages, so we try
        // to release the CPU wake lock we acquired on behalf of that page.
        this._releaseCpuWakeLock(this._createKeyForPage(msg), msg.handledCount);
        break;
      }
    }
  },

  observe: function(aSubject, aTopic, aData) {
    switch (aTopic) {
      case "xpcom-shutdown":
        kMessages.forEach(function(aMsg) {
          ppmm.removeMessageListener(aMsg, this);
        }, this);
        Services.obs.removeObserver(this, "xpcom-shutdown");
        Services.obs.removeObserver(this, "webapps-registry-start");
        Services.obs.removeObserver(this, "webapps-registry-ready");
        Services.obs.removeObserver(this, "webapps-clear-data");
        ppmm = null;
        this._pages = null;
        this._bufferedSysMsgs = null;
        this._pendingPromises.clear();
        break;
      case "webapps-registry-start":
        this._webappsRegistryReady = false;
        break;
      case "webapps-registry-ready":
        // After the webapps' registration has been done for sure,
        // re-fire the buffered system messages if there is any.
        this._webappsRegistryReady = true;
        this._bufferedSysMsgs.forEach(function(aSysMsg) {
          switch (aSysMsg.how) {
            case "send":
              this.sendMessageInternal(
                aSysMsg.type, aSysMsg.msg,
                aSysMsg.pageURI, aSysMsg.manifestURI, aSysMsg.extra,
                aSysMsg.resolvePromiseCb, aSysMsg.rejectPromiseCb);
              break;
            case "broadcast":
              this.broadcastMessage(aSysMsg.type, aSysMsg.msg, aSysMsg.extra);
              break;
          }
        }, this);
        this._bufferedSysMsgs.length = 0;
        break;
      case "webapps-clear-data":
        let params =
          aSubject.QueryInterface(Ci.mozIApplicationClearPrivateDataParams);
        if (!params) {
          debug("Error updating registered pages for an uninstalled app.");
          return;
        }

        // Only update registered pages for apps.
        if (params.browserOnly) {
          return;
        }

        let manifestURL = appsService.getManifestURLByLocalId(params.appId);
        if (!manifestURL) {
          debug("Error updating registered pages for an uninstalled app.");
          return;
        }

        for (let i = this._pages.length - 1; i >= 0; i--) {
          let page = this._pages[i];
          if (page.manifestURL === manifestURL) {
            this._pages.splice(i, 1);
            debug("Remove " + page.pageURL + " @ " + page.manifestURL +
                  " from registered pages due to app uninstallation.");
          }
        }

        this._rejectPendingPromisesFromManifestURL(manifestURL);

        debug("Finish updating registered pages for an uninstalled app.");
        break;
    }
  },

  _queueMessage: function(aPage, aMessage, aMessageID) {
    // Queue the message for this page because we've never known if an app is
    // opened or not. We'll clean it up when the app has already received it.
    aPage.pendingMessages.push({ msg: aMessage, msgID: aMessageID });
    if (aPage.pendingMessages.length > kMaxPendingMessages) {
      aPage.pendingMessages.splice(0, 1);
    }
  },

  _openAppPage: function(aPage, aMessage, aExtra, aMsgSentStatus) {
    // This means the app must be brought to the foreground.
    let showApp = this._getMessageConfigurator(aPage.type).mustShowRunningApp;

    // We should send the open-app message if the system message was
    // not sent, or if it was sent but we should show the app anyway.
    if ((aMsgSentStatus === MSG_SENT_SUCCESS) && !showApp) {
      return;
    }

    // This flag means the app must *only* be brought to the foreground
    // and we don't need to load the app to handle messages.
    let onlyShowApp = (aMsgSentStatus === MSG_SENT_SUCCESS) && showApp;

    debug("Asking to open pageURL: " + aPage.pageURL +
          ", manifestURL: " + aPage.manifestURL + ", type: " + aPage.type +
          ", target: " + JSON.stringify(aMessage.target) +
          ", showApp: " + showApp + ", onlyShowApp: " + onlyShowApp +
          ", extra: " + JSON.stringify(aExtra));

    let glue = Cc["@mozilla.org/dom/messages/system-message-glue;1"]
                 .createInstance(Ci.nsISystemMessageGlue);
    if (glue) {
      glue.openApp(aPage.pageURL, aPage.manifestURL, aPage.type, aMessage.target,
                   showApp, onlyShowApp, aExtra);
    } else {
      debug("Error! The UI glue component is not implemented.");
    }
  },

  _isPageMatched: function(aPage, aType, aPageURL, aManifestURL) {
    return (aPage.type === aType &&
            aPage.manifestURL === aManifestURL &&
            aPage.pageURL === aPageURL);
  },

  _createKeyForPage: function _createKeyForPage(aPage) {
    let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"]
                      .createInstance(Ci.nsIScriptableUnicodeConverter);
    converter.charset = "UTF-8";

    let hasher = Cc["@mozilla.org/security/hash;1"]
                   .createInstance(Ci.nsICryptoHash);
    hasher.init(hasher.SHA1);

    // add manifest/page URL and action to the hash
    ["type", "manifestURL", "pageURL"].forEach(function(aProp) {
      let data = converter.convertToByteArray(aPage[aProp], {});
      hasher.update(data, data.length);
    });

    return hasher.finish(true);
  },

  _sendMessageCommon: function(aType, aMessage, aMessageID,
                               aPageURL, aManifestURL, aExtra) {
    // Don't send the system message not granted by the app's permissions.
    if (!SystemMessagePermissionsChecker
          .isSystemMessagePermittedToSend(aType,
                                          aPageURL,
                                          aManifestURL)) {
      return MSG_SENT_FAILURE_PERM_DENIED;
    }

    // Queue this message in the corresponding pages.
    let page = this._findPage(aType, aPageURL, aManifestURL);
    if (!page) {
      debug("Message " + aType + " is not registered for " +
            aPageURL + " @ " + aManifestURL);
      // FIXME bug 1140275 should only send message to page registered in manifest
      // return MSG_SENT_FAILURE_PERM_DENIED;
    }
    if (page)
      this._queueMessage(page, aMessage, aMessageID);

    let appPageIsRunning = false;
    let pageKey = this._createKeyForPage({ type: aType,
                                           manifestURL: aManifestURL,
                                           pageURL: aPageURL });

    let cache = this._findCacheForApp(aManifestURL);
    let targets = this._listeners[aManifestURL];
    if (targets) {
      for (let index = 0; index < targets.length; ++index) {
        let target = targets[index];
        let manager = target.target;

        // Ensure hasPendingMessage cache is refreshed before we open app
        manager.sendAsyncMessage("SystemMessageCache:RefreshCache", cache);

        // We only need to send the system message to the targets (processes)
        // which contain the window page that matches the manifest/page URL of
        // the destination of system message.
        if (target.winCounts[aPageURL] === undefined) {
          continue;
        }

        appPageIsRunning = true;
        // We need to acquire a CPU wake lock for that page and expect that
        // we'll receive a "SystemMessageManager:HandleMessagesDone" or a
        // "SystemMessageManager:HandleMessageDone"  message when the page
        // finishes handling the system message. At that point, we'll release
        // the lock we acquired.
        this._acquireCpuWakeLock(pageKey);

        // Multiple windows can share the same target (process), the content
        // window needs to check if the manifest/page URL is matched. Only
        // *one* window should handle the system message.
        manager.sendAsyncMessage("SystemMessageManager:Message",
                                 { type: aType,
                                   msg: aMessage,
                                   manifestURL: aManifestURL,
                                   pageURL: aPageURL,
                                   msgID: aMessageID });
      }
    }

    let result = MSG_SENT_SUCCESS;
    if (!appPageIsRunning) {
      // The app page isn't running and relies on the 'open-app' chrome event to
      // wake it up. We still need to acquire a CPU wake lock for that page and
      // expect that we will receive a "SystemMessageManager:HandleMessagesDone"
      // or a "SystemMessageManager:HandleMessageDone" message when the page
      // finishes handling the system message with other pending messages. At
      // that point, we'll release the lock we acquired.
      result = MSG_SENT_FAILURE_APP_NOT_RUNNING;
      this._acquireCpuWakeLock(pageKey);
    }
    if (page)
      this._openAppPage(page, aMessage, aExtra, result);
    return result;
  },

  _resolvePendingPromises: function(aMessageID) {
    if (!this._pendingPromises.has(aMessageID)) {
      debug("Unknown pendingPromise messageID. This seems a bug!!");
      return;
    }

    let obj = this._pendingPromises.get(aMessageID);
    if (!--obj.counter) {
      obj.resolvePromiseCb();
      this._pendingPromises.delete(aMessageID);
    }
  },

  _rejectPendingPromises: function(aMessageID) {
    if (!this._pendingPromises.has(aMessageID)) {
      debug("Unknown pendingPromise messageID. This seems a bug!!");
      return;
    }

    let obj = this._pendingPromises.get(aMessageID);
    if (!--obj.counter) {
      obj.rejectPromiseCb();
      this._pendingPromises.delete(aMessageID);
    }
  },

  _rejectPendingPromisesFromManifestURL: function(aManifestURL) {
    for (var [i, obj] of this._pendingPromises) {
      if (obj.manifestURL == aManifestURL) {
        obj.rejectPromiseCb();
        this._pendingPromises.delete(i);
      }
    }
  },

  classID: Components.ID("{70589ca5-91ac-4b9e-b839-d6a88167d714}"),

  QueryInterface: XPCOMUtils.generateQI([Ci.nsISystemMessagesInternal,
                                         Ci.nsIObserver])
}

this.NSGetFactory = XPCOMUtils.generateNSGetFactory([SystemMessageInternal]);