fetchIcons: function () {
// On demand, retrieve apps icons in order to be able
// to synchronously retrieve it on `App` objects
let promises = [];
for (let [, app] of this._apps) {
promises.push(app.getIcon());
}
return DevToolsUtils.settleAll(promises)
.then(null, () => {});
},
},
hasRequests() {
return !!this._requests.length;
},
/**
* Wait for all current requests from this front to settle. This is especially useful
* for tests and other utility environments that may not have events or mechanisms to
* await the completion of requests without this utility.
*
* @return Promise
* Resolved when all requests have settled.
*/
waitForRequestsToSettle() {
return settleAll(this._requests.map(({ deferred }) => deferred.promise));
},
});
exports.Front = Front;
/**
* A method tagged with preEvent will be called after recieving a packet
* for that event, and before the front emits the event.
*/
exports.preEvent = function(eventName, fn) {
fn._preEvent = eventName;
return fn;
};
/**
}
}
// For each front, wait for its requests to settle
for (const front of fronts) {
if (front.hasRequests()) {
requests.push(front.waitForRequestsToSettle());
}
}
// Abort early if there are no requests
if (!requests.length) {
return Promise.resolve();
}
return DevToolsUtils.settleAll(requests).catch(() => {
// One of the requests might have failed, but ignore that situation here and pipe
// both success and failure through the same path. The important part is just that
// we waited.
}).then(() => {
// Repeat, more requests may have started in response to those we just waited for
return this.waitForRequestsToSettle();
});
},
registerClient: function(client) {
const actorID = client.actor;
if (!actorID) {
throw new Error("DebuggerServer.registerClient expects " +
"a client instance with an `actor` attribute.");
}