2012-07-03 00:16:55 +00:00
|
|
|
/* 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;
|
|
|
|
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
Cu.import("resource://gre/modules/DOMRequestHelper.jsm");
|
|
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
2012-08-19 19:00:19 +00:00
|
|
|
Cu.import("resource://gre/modules/ObjectWrapper.jsm");
|
2012-07-03 00:16:55 +00:00
|
|
|
|
2012-10-09 03:15:47 +00:00
|
|
|
const kSystemMessageInternalReady = "system-message-internal-ready";
|
|
|
|
|
2012-08-27 14:13:02 +00:00
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "cpmm",
|
|
|
|
"@mozilla.org/childprocessmessagemanager;1",
|
|
|
|
"nsISyncMessageSender");
|
2012-07-03 00:16:55 +00:00
|
|
|
|
2012-08-23 18:56:36 +00:00
|
|
|
function debug(aMsg) {
|
|
|
|
//dump("-- SystemMessageManager " + Date.now() + " : " + aMsg + "\n");
|
2012-07-03 00:16:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Implementation of the DOM API for system messages
|
|
|
|
|
|
|
|
function SystemMessageManager() {
|
|
|
|
// Message handlers for this page.
|
|
|
|
// We can have only one handler per message type.
|
|
|
|
this._handlers = {};
|
|
|
|
|
|
|
|
// Pending messages for this page, keyed by message type.
|
|
|
|
this._pendings = {};
|
2012-10-09 03:15:47 +00:00
|
|
|
|
|
|
|
// Flag to specify if this process has already registered manifest.
|
|
|
|
this._registerManifestReady = false;
|
|
|
|
|
|
|
|
// Flag to determine this process is a parent or child process.
|
|
|
|
let appInfo = Cc["@mozilla.org/xre/app-info;1"];
|
|
|
|
this._isParentProcess =
|
|
|
|
!appInfo || appInfo.getService(Ci.nsIXULRuntime)
|
|
|
|
.processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
|
|
|
|
|
|
|
|
// An oberver to listen to whether the |SystemMessageInternal| is ready.
|
|
|
|
if (this._isParentProcess) {
|
|
|
|
Services.obs.addObserver(this, kSystemMessageInternalReady, false);
|
|
|
|
}
|
2012-07-03 00:16:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SystemMessageManager.prototype = {
|
|
|
|
__proto__: DOMRequestIpcHelper.prototype,
|
|
|
|
|
2012-07-20 15:41:30 +00:00
|
|
|
_dispatchMessage: function sysMessMgr_dispatchMessage(aType, aHandler, aMessage) {
|
|
|
|
// We get a json blob, but in some cases we want another kind of object
|
|
|
|
// to be dispatched.
|
|
|
|
// To do so, we check if we have a with a contract ID of
|
|
|
|
// "@mozilla.org/dom/system-messages/wrapper/TYPE;1" component implementing
|
|
|
|
// nsISystemMessageWrapper.
|
|
|
|
debug("Dispatching " + JSON.stringify(aMessage) + "\n");
|
|
|
|
let contractID = "@mozilla.org/dom/system-messages/wrapper/" + aType + ";1";
|
2012-08-23 18:56:36 +00:00
|
|
|
let wrapped = false;
|
2012-07-20 15:41:30 +00:00
|
|
|
|
|
|
|
if (contractID in Cc) {
|
|
|
|
debug(contractID + " is registered, creating an instance");
|
|
|
|
let wrapper = Cc[contractID].createInstance(Ci.nsISystemMessagesWrapper);
|
|
|
|
if (wrapper) {
|
2012-08-25 04:07:58 +00:00
|
|
|
aMessage = wrapper.wrapMessage(aMessage, this._window);
|
2012-08-23 18:56:36 +00:00
|
|
|
wrapped = true;
|
2012-07-20 15:41:30 +00:00
|
|
|
debug("wrapped = " + aMessage);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-09 02:54:50 +00:00
|
|
|
aHandler.handleMessage(wrapped ? aMessage
|
|
|
|
: ObjectWrapper.wrap(aMessage, this._window));
|
2012-10-31 07:52:01 +00:00
|
|
|
|
|
|
|
// Notify the parent process the message is handled.
|
|
|
|
cpmm.sendAsyncMessage("SystemMessageManager:HandleMessageDone",
|
|
|
|
{ type: aType,
|
|
|
|
message: aMessage });
|
2012-07-20 15:41:30 +00:00
|
|
|
},
|
|
|
|
|
2012-07-03 00:16:55 +00:00
|
|
|
mozSetMessageHandler: function sysMessMgr_setMessageHandler(aType, aHandler) {
|
|
|
|
debug("setMessage handler for [" + aType + "] " + aHandler);
|
|
|
|
if (!aType) {
|
|
|
|
// Just bail out if we have no type.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let handlers = this._handlers;
|
|
|
|
if (!aHandler) {
|
|
|
|
// Setting the handler to null means we don't want to receive messages
|
|
|
|
// of this type anymore.
|
|
|
|
delete handlers[aType];
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Last registered handler wins.
|
|
|
|
handlers[aType] = aHandler;
|
|
|
|
|
2012-10-25 18:45:14 +00:00
|
|
|
// Ask for the list of currently pending messages.
|
|
|
|
cpmm.sendAsyncMessage("SystemMessageManager:GetPendingMessages",
|
|
|
|
{ type: aType,
|
|
|
|
uri: this._uri,
|
|
|
|
manifest: this._manifest });
|
2012-07-03 00:16:55 +00:00
|
|
|
},
|
|
|
|
|
2012-10-25 18:45:14 +00:00
|
|
|
mozHasPendingMessage: function sysMessMgr_hasPendingMessage(aType) {
|
2012-07-03 00:16:55 +00:00
|
|
|
// If we have a handler for this type, we can't have any pending message.
|
2012-10-25 18:45:14 +00:00
|
|
|
if (aType in this._handlers) {
|
2012-07-03 00:16:55 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-10-25 18:45:14 +00:00
|
|
|
return cpmm.sendSyncMessage("SystemMessageManager:HasPendingMessages",
|
|
|
|
{ type: aType,
|
|
|
|
uri: this._uri,
|
|
|
|
manifest: this._manifest })[0];
|
2012-07-03 00:16:55 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
uninit: function sysMessMgr_uninit() {
|
|
|
|
this._handlers = null;
|
2012-10-09 03:15:47 +00:00
|
|
|
this._pendings = null;
|
|
|
|
|
|
|
|
if (this._isParentProcess) {
|
|
|
|
Services.obs.removeObserver(this, kSystemMessageInternalReady);
|
|
|
|
}
|
2012-11-07 02:32:09 +00:00
|
|
|
|
|
|
|
cpmm.sendAsyncMessage("SystemMessageManager:Unregister",
|
|
|
|
{ manifest: this._manifest,
|
|
|
|
innerWindowID: this.innerWindowID
|
|
|
|
});
|
2012-07-03 00:16:55 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
receiveMessage: function sysMessMgr_receiveMessage(aMessage) {
|
2012-08-23 18:56:36 +00:00
|
|
|
debug("receiveMessage " + aMessage.name + " - " +
|
2012-10-25 18:45:14 +00:00
|
|
|
aMessage.data.type + " for " + aMessage.data.manifest +
|
2012-07-03 00:16:55 +00:00
|
|
|
" (" + this._manifest + ")");
|
|
|
|
|
2012-10-25 18:45:14 +00:00
|
|
|
let msg = aMessage.data;
|
2012-10-13 08:05:42 +00:00
|
|
|
if (msg.manifest != this._manifest || msg.uri != this._uri) {
|
2012-07-03 00:16:55 +00:00
|
|
|
return;
|
2012-10-13 08:05:42 +00:00
|
|
|
}
|
2012-07-03 00:16:55 +00:00
|
|
|
|
2012-10-25 18:45:14 +00:00
|
|
|
if (aMessage.name == "SystemMessageManager:Message") {
|
|
|
|
// Send an acknowledgement to parent to clean up the pending message,
|
|
|
|
// so a re-launched app won't handle it again, which is redundant.
|
|
|
|
cpmm.sendAsyncMessage(
|
|
|
|
"SystemMessageManager:Message:Return:OK",
|
|
|
|
{ type: msg.type,
|
|
|
|
manifest: msg.manifest,
|
|
|
|
uri: msg.uri,
|
|
|
|
msgID: msg.msgID });
|
|
|
|
}
|
2012-10-09 02:54:50 +00:00
|
|
|
|
2012-07-03 00:16:55 +00:00
|
|
|
// Bail out if we have no handlers registered for this type.
|
|
|
|
if (!(msg.type in this._handlers)) {
|
|
|
|
debug("No handler for this type");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-25 18:45:14 +00:00
|
|
|
let messages = (aMessage.name == "SystemMessageManager:Message")
|
|
|
|
? [msg.msg]
|
|
|
|
: msg.msgQueue;
|
|
|
|
|
|
|
|
messages.forEach(function(aMsg) {
|
|
|
|
this._dispatchMessage(msg.type, this._handlers[msg.type], aMsg);
|
|
|
|
}, this);
|
2012-07-03 00:16:55 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
// nsIDOMGlobalPropertyInitializer implementation.
|
|
|
|
init: function sysMessMgr_init(aWindow) {
|
|
|
|
debug("init");
|
2012-10-25 18:45:14 +00:00
|
|
|
this.initHelper(aWindow, ["SystemMessageManager:Message",
|
|
|
|
"SystemMessageManager:GetPendingMessages:Return"]);
|
2012-08-13 16:58:38 +00:00
|
|
|
|
|
|
|
let principal = aWindow.document.nodePrincipal;
|
|
|
|
this._uri = principal.URI.spec;
|
|
|
|
|
|
|
|
let appsService = Cc["@mozilla.org/AppsService;1"]
|
|
|
|
.getService(Ci.nsIAppsService);
|
|
|
|
this._manifest = appsService.getManifestURLByLocalId(principal.appId);
|
2012-10-09 03:15:47 +00:00
|
|
|
|
|
|
|
// Two cases are valid to register the manifest for the current process:
|
|
|
|
// 1. This is asked by a child process (parent process must be ready).
|
|
|
|
// 2. Parent process has already constructed the |SystemMessageInternal|.
|
|
|
|
// Otherwise, delay to do it when the |SystemMessageInternal| is ready.
|
|
|
|
let readyToRegister = true;
|
|
|
|
if (this._isParentProcess) {
|
|
|
|
let ready = cpmm.sendSyncMessage(
|
|
|
|
"SystemMessageManager:AskReadyToRegister", null);
|
|
|
|
if (ready.length == 0 || !ready[0]) {
|
|
|
|
readyToRegister = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (readyToRegister) {
|
|
|
|
this._registerManifest();
|
|
|
|
}
|
|
|
|
|
2012-09-18 17:34:56 +00:00
|
|
|
debug("done");
|
2012-07-03 00:16:55 +00:00
|
|
|
},
|
|
|
|
|
2012-10-09 03:15:47 +00:00
|
|
|
observe: function sysMessMgr_observe(aSubject, aTopic, aData) {
|
|
|
|
if (aTopic === kSystemMessageInternalReady) {
|
|
|
|
this._registerManifest();
|
|
|
|
}
|
2012-12-05 03:49:34 +00:00
|
|
|
// Call the DOMRequestIpcHelper.observe method.
|
2012-11-07 02:32:09 +00:00
|
|
|
this.__proto__.__proto__.observe.call(this, aSubject, aTopic, aData);
|
2012-10-09 03:15:47 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_registerManifest: function sysMessMgr_registerManifest() {
|
|
|
|
if (!this._registerManifestReady) {
|
|
|
|
cpmm.sendAsyncMessage("SystemMessageManager:Register",
|
2012-11-07 02:32:09 +00:00
|
|
|
{ manifest: this._manifest,
|
|
|
|
innerWindowID: this.innerWindowID
|
|
|
|
});
|
2012-10-09 03:15:47 +00:00
|
|
|
this._registerManifestReady = true;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2012-07-03 00:16:55 +00:00
|
|
|
classID: Components.ID("{bc076ea0-609b-4d8f-83d7-5af7cbdc3bb2}"),
|
|
|
|
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIDOMNavigatorSystemMessages,
|
2012-10-09 03:15:47 +00:00
|
|
|
Ci.nsIDOMGlobalPropertyInitializer,
|
|
|
|
Ci.nsIObserver]),
|
2012-07-03 00:16:55 +00:00
|
|
|
|
|
|
|
classInfo: XPCOMUtils.generateCI({classID: Components.ID("{bc076ea0-609b-4d8f-83d7-5af7cbdc3bb2}"),
|
|
|
|
contractID: "@mozilla.org/system-message-manager;1",
|
|
|
|
interfaces: [Ci.nsIDOMNavigatorSystemMessages],
|
|
|
|
flags: Ci.nsIClassInfo.DOM_OBJECT,
|
|
|
|
classDescription: "System Messages"})
|
|
|
|
}
|
|
|
|
|
2012-10-31 16:13:28 +00:00
|
|
|
this.NSGetFactory = XPCOMUtils.generateNSGetFactory([SystemMessageManager]);
|