1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/* 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/. */
/**
* This component serves as integration between the platform and AddonManager.
* It is responsible for initializing and shutting down the AddonManager as well
* as passing new installs from webpages to the AddonManager.
*/
"use strict";
const { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
const PREF_EM_UPDATE_INTERVAL = "extensions.update.interval";
// The old XPInstall error codes
const EXECUTION_ERROR = -203;
const CANT_READ_ARCHIVE = -207;
const USER_CANCELLED = -210;
const DOWNLOAD_ERROR = -228;
const UNSUPPORTED_TYPE = -244;
const SUCCESS = 0;
const MSG_INSTALL_ENABLED = "WebInstallerIsInstallEnabled";
const MSG_INSTALL_ADDONS = "WebInstallerInstallAddonsFromWebpage";
const MSG_INSTALL_CALLBACK = "WebInstallerInstallCallback";
const CHILD_SCRIPT = "resource://gre/modules/addons/Content.js";
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");
var gSingleton = null;
var gParentMM = null;
function amManager() {
Cu.import("resource://gre/modules/AddonManager.jsm");
let globalMM = Cc["@mozilla.org/globalmessagemanager;1"]
.getService(Ci.nsIMessageListenerManager);
globalMM.loadFrameScript(CHILD_SCRIPT, true);
globalMM.addMessageListener(MSG_INSTALL_ADDONS, this);
gParentMM = Cc["@mozilla.org/parentprocessmessagemanager;1"]
.getService(Ci.nsIMessageListenerManager);
gParentMM.addMessageListener(MSG_INSTALL_ENABLED, this);
// Needed so receiveMessage can be called directly by JS callers
this.wrappedJSObject = this;
}
amManager.prototype = {
observe: function AMC_observe(aSubject, aTopic, aData) {
if (aTopic == "addons-startup")
AddonManagerPrivate.startup();
},
/**
* @see amIAddonManager.idl
*/
mapURIToAddonID: function AMC_mapURIToAddonID(uri, id) {
id.value = AddonManager.mapURIToAddonID(uri);
return !!id.value;
},
/**
* @see amIWebInstaller.idl
*/
isInstallEnabled: function AMC_isInstallEnabled(aMimetype, aReferer) {
return AddonManager.isInstallEnabled(aMimetype);
},
/**
* @see amIWebInstaller.idl
*/
installAddonsFromWebpage: function AMC_installAddonsFromWebpage(aMimetype,
aBrowser,
aInstallingPrincipal,
aUris, aHashes,
aNames, aIcons,
aCallback) {
if (aUris.length == 0)
return false;
let retval = true;
if (!AddonManager.isInstallAllowed(aMimetype, aInstallingPrincipal)) {
aCallback = null;
retval = false;
}
let installs = [];
function buildNextInstall() {
if (aUris.length == 0) {
AddonManager.installAddonsFromWebpage(aMimetype, aBrowser, aInstallingPrincipal, installs);
return;
}
let uri = aUris.shift();
AddonManager.getInstallForURL(uri, function buildNextInstall_getInstallForURL(aInstall) {
function callCallback(aUri, aStatus) {
try {
aCallback.onInstallEnded(aUri, aStatus);
}
catch (e) {
Components.utils.reportError(e);
}
}
if (aInstall) {
installs.push(aInstall);
if (aCallback) {
aInstall.addListener({
onDownloadCancelled: function buildNextInstall_onDownloadCancelled(aInstall) {
callCallback(uri, USER_CANCELLED);
},
onDownloadFailed: function buildNextInstall_onDownloadFailed(aInstall) {
if (aInstall.error == AddonManager.ERROR_CORRUPT_FILE)
callCallback(uri, CANT_READ_ARCHIVE);
else
callCallback(uri, DOWNLOAD_ERROR);
},
onInstallFailed: function buildNextInstall_onInstallFailed(aInstall) {
callCallback(uri, EXECUTION_ERROR);
},
onInstallEnded: function buildNextInstall_onInstallEnded(aInstall, aStatus) {
callCallback(uri, SUCCESS);
}
});
}
}
else if (aCallback) {
aCallback.onInstallEnded(uri, UNSUPPORTED_TYPE);
}
buildNextInstall();
}, aMimetype, aHashes.shift(), aNames.shift(), aIcons.shift(), null, aBrowser);
}
buildNextInstall();
return retval;
},
notify: function AMC_notify(aTimer) {
AddonManagerPrivate.backgroundUpdateTimerHandler();
},
/**
* messageManager callback function.
*
* Listens to requests from child processes for InstallTrigger
* activity, and sends back callbacks.
*/
receiveMessage: function AMC_receiveMessage(aMessage) {
let payload = aMessage.data;
switch (aMessage.name) {
case MSG_INSTALL_ENABLED:
return AddonManager.isInstallEnabled(payload.mimetype);
case MSG_INSTALL_ADDONS: {
let callback = null;
if (payload.callbackID != -1) {
callback = {
onInstallEnded: function ITP_callback(url, status) {
gParentMM.broadcastAsyncMessage(MSG_INSTALL_CALLBACK, {
callbackID: payload.callbackID,
url: url,
status: status
});
},
};
}
return this.installAddonsFromWebpage(payload.mimetype,
aMessage.target, payload.triggeringPrincipal, payload.uris,
payload.hashes, payload.names, payload.icons, callback);
}
}
},
classID: Components.ID("{4399533d-08d1-458c-a87a-235f74451cfa}"),
_xpcom_factory: {
createInstance: function AMC_createInstance(aOuter, aIid) {
if (aOuter != null)
throw Components.Exception("Component does not support aggregation",
Cr.NS_ERROR_NO_AGGREGATION);
if (!gSingleton)
gSingleton = new amManager();
return gSingleton.QueryInterface(aIid);
}
},
QueryInterface: XPCOMUtils.generateQI([Ci.amIAddonManager,
Ci.amIWebInstaller,
Ci.nsITimerCallback,
Ci.nsIObserver,
Ci.nsIMessageListener])
};
this.NSGetFactory = XPCOMUtils.generateNSGetFactory([amManager]);
|
