зеркало из https://github.com/mozilla/gecko-dev.git
851 строка
31 KiB
JavaScript
851 строка
31 KiB
JavaScript
/* 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:HasPendingMessages",
|
|
"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:HasPendingMessages",
|
|
"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:HasPendingMessages":
|
|
{
|
|
debug("received SystemMessageManager:HasPendingMessages " + msg.type +
|
|
" for " + msg.pageURL + " @ " + msg.manifestURL);
|
|
|
|
// NB: Sync message SystemMessageManager:HasPendingMessages
|
|
// should only be used by in-process app. For out-of-process
|
|
// app, SystemMessageCache should be used.
|
|
|
|
// This is a sync call used to return if a page has pending messages.
|
|
// Find the right page to get its corresponding pending messages.
|
|
let page = this._findPage(msg.type, msg.pageURL, msg.manifestURL);
|
|
if (!page) {
|
|
return false;
|
|
}
|
|
|
|
return page.pendingMessages.length != 0;
|
|
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]);
|