diff options
Diffstat (limited to 'toolkit/modules/addons/WebRequest.jsm')
| -rw-r--r-- | toolkit/modules/addons/WebRequest.jsm | 918 |
1 files changed, 918 insertions, 0 deletions
diff --git a/toolkit/modules/addons/WebRequest.jsm b/toolkit/modules/addons/WebRequest.jsm new file mode 100644 index 000000000..c720dae5d --- /dev/null +++ b/toolkit/modules/addons/WebRequest.jsm @@ -0,0 +1,918 @@ +/* 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 EXPORTED_SYMBOLS = ["WebRequest"]; + +/* exported WebRequest */ + +const Ci = Components.interfaces; +const Cc = Components.classes; +const Cu = Components.utils; +const Cr = Components.results; + +const {nsIHttpActivityObserver, nsISocketTransport} = Ci; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/Task.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "AppConstants", + "resource://gre/modules/AppConstants.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "BrowserUtils", + "resource://gre/modules/BrowserUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ExtensionUtils", + "resource://gre/modules/ExtensionUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "WebRequestCommon", + "resource://gre/modules/WebRequestCommon.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "WebRequestUpload", + "resource://gre/modules/WebRequestUpload.jsm"); + +XPCOMUtils.defineLazyGetter(this, "ExtensionError", () => ExtensionUtils.ExtensionError); + +function attachToChannel(channel, key, data) { + if (channel instanceof Ci.nsIWritablePropertyBag2) { + let wrapper = {wrappedJSObject: data}; + channel.setPropertyAsInterface(key, wrapper); + } + return data; +} + +function extractFromChannel(channel, key) { + if (channel instanceof Ci.nsIPropertyBag2 && channel.hasKey(key)) { + let data = channel.get(key); + return data && data.wrappedJSObject; + } + return null; +} + +function getData(channel) { + const key = "mozilla.webRequest.data"; + return extractFromChannel(channel, key) || attachToChannel(channel, key, {}); +} + +var RequestId = { + count: 1, + create(channel = null) { + let id = (this.count++).toString(); + if (channel) { + getData(channel).requestId = id; + } + return id; + }, + + get(channel) { + return channel && getData(channel).requestId || this.create(channel); + }, +}; + +function runLater(job) { + Services.tm.currentThread.dispatch(job, Ci.nsIEventTarget.DISPATCH_NORMAL); +} + +function parseFilter(filter) { + if (!filter) { + filter = {}; + } + + // FIXME: Support windowId filtering. + return {urls: filter.urls || null, types: filter.types || null}; +} + +function parseExtra(extra, allowed = []) { + if (extra) { + for (let ex of extra) { + if (allowed.indexOf(ex) == -1) { + throw new ExtensionError(`Invalid option ${ex}`); + } + } + } + + let result = {}; + for (let al of allowed) { + if (extra && extra.indexOf(al) != -1) { + result[al] = true; + } + } + return result; +} + +function mergeStatus(data, channel, event) { + try { + data.statusCode = channel.responseStatus; + let statusText = channel.responseStatusText; + let maj = {}; + let min = {}; + channel.QueryInterface(Ci.nsIHttpChannelInternal).getResponseVersion(maj, min); + data.statusLine = `HTTP/${maj.value}.${min.value} ${data.statusCode} ${statusText}`; + } catch (e) { + // NS_ERROR_NOT_AVAILABLE might be thrown if it's an internal redirect, happening before + // any actual HTTP traffic. Otherwise, let's report. + if (event !== "onRedirect" || e.result !== Cr.NS_ERROR_NOT_AVAILABLE) { + Cu.reportError(`webRequest Error: ${e} trying to merge status in ${event}@${channel.name}`); + } + } +} + +function isThenable(value) { + return value && typeof value === "object" && typeof value.then === "function"; +} + +class HeaderChanger { + constructor(channel) { + this.channel = channel; + + this.originalHeaders = new Map(); + this.visitHeaders((name, value) => { + this.originalHeaders.set(name.toLowerCase(), value); + }); + } + + toArray() { + return Array.from(this.originalHeaders, + ([name, value]) => ({name, value})); + } + + validateHeaders(headers) { + // We should probably use schema validation for this. + + if (!Array.isArray(headers)) { + return false; + } + + return headers.every(header => { + if (typeof header !== "object" || header === null) { + return false; + } + + if (typeof header.name !== "string") { + return false; + } + + return (typeof header.value === "string" || + Array.isArray(header.binaryValue)); + }); + } + + applyChanges(headers) { + if (!this.validateHeaders(headers)) { + /* globals uneval */ + Cu.reportError(`Invalid header array: ${uneval(headers)}`); + return; + } + + let newHeaders = new Set(headers.map( + ({name}) => name.toLowerCase())); + + // Remove missing headers. + for (let name of this.originalHeaders.keys()) { + if (!newHeaders.has(name)) { + this.setHeader(name, ""); + } + } + + // Set new or changed headers. + for (let {name, value, binaryValue} of headers) { + if (binaryValue) { + value = String.fromCharCode(...binaryValue); + } + if (value !== this.originalHeaders.get(name.toLowerCase())) { + this.setHeader(name, value); + } + } + } +} + +class RequestHeaderChanger extends HeaderChanger { + setHeader(name, value) { + try { + this.channel.setRequestHeader(name, value, false); + } catch (e) { + Cu.reportError(new Error(`Error setting request header ${name}: ${e}`)); + } + } + + visitHeaders(visitor) { + if (this.channel instanceof Ci.nsIHttpChannel) { + this.channel.visitRequestHeaders(visitor); + } + } +} + +class ResponseHeaderChanger extends HeaderChanger { + setHeader(name, value) { + try { + if (name.toLowerCase() === "content-type" && value) { + // The Content-Type header value can't be modified, so we + // set the channel's content type directly, instead, and + // record that we made the change for the sake of + // subsequent observers. + this.channel.contentType = value; + + getData(this.channel).contentType = value; + } else { + this.channel.setResponseHeader(name, value, false); + } + } catch (e) { + Cu.reportError(new Error(`Error setting response header ${name}: ${e}`)); + } + } + + visitHeaders(visitor) { + if (this.channel instanceof Ci.nsIHttpChannel) { + try { + this.channel.visitResponseHeaders((name, value) => { + if (name.toLowerCase() === "content-type") { + value = getData(this.channel).contentType || value; + } + + visitor(name, value); + }); + } catch (e) { + // Throws if response headers aren't available yet. + } + } + } +} + +var HttpObserverManager; + +var ContentPolicyManager = { + policyData: new Map(), + policies: new Map(), + idMap: new Map(), + nextId: 0, + + init() { + Services.ppmm.initialProcessData.webRequestContentPolicies = this.policyData; + + Services.ppmm.addMessageListener("WebRequest:ShouldLoad", this); + Services.mm.addMessageListener("WebRequest:ShouldLoad", this); + }, + + receiveMessage(msg) { + let browser = msg.target instanceof Ci.nsIDOMXULElement ? msg.target : null; + + let requestId = RequestId.create(); + for (let id of msg.data.ids) { + let callback = this.policies.get(id); + if (!callback) { + // It's possible that this listener has been removed and the + // child hasn't learned yet. + continue; + } + let response = null; + let listenerKind = "onStop"; + let data = Object.assign({requestId, browser}, msg.data); + delete data.ids; + try { + response = callback(data); + if (response) { + if (response.cancel) { + listenerKind = "onError"; + data.error = "NS_ERROR_ABORT"; + return {cancel: true}; + } + // FIXME: Need to handle redirection here (for non-HTTP URIs only) + } + } catch (e) { + Cu.reportError(e); + } finally { + runLater(() => this.runChannelListener(listenerKind, data)); + } + } + + return {}; + }, + + runChannelListener(kind, data) { + let listeners = HttpObserverManager.listeners[kind]; + let uri = BrowserUtils.makeURI(data.url); + let policyType = data.type; + for (let [callback, opts] of listeners.entries()) { + if (!HttpObserverManager.shouldRunListener(policyType, uri, opts.filter)) { + continue; + } + callback(data); + } + }, + + addListener(callback, opts) { + // Clone opts, since we're going to modify them for IPC. + opts = Object.assign({}, opts); + let id = this.nextId++; + opts.id = id; + if (opts.filter.urls) { + opts.filter = Object.assign({}, opts.filter); + opts.filter.urls = opts.filter.urls.serialize(); + } + Services.ppmm.broadcastAsyncMessage("WebRequest:AddContentPolicy", opts); + + this.policyData.set(id, opts); + + this.policies.set(id, callback); + this.idMap.set(callback, id); + }, + + removeListener(callback) { + let id = this.idMap.get(callback); + Services.ppmm.broadcastAsyncMessage("WebRequest:RemoveContentPolicy", {id}); + + this.policyData.delete(id); + this.idMap.delete(callback); + this.policies.delete(id); + }, +}; +ContentPolicyManager.init(); + +function StartStopListener(manager, loadContext) { + this.manager = manager; + this.loadContext = loadContext; + this.orig = null; +} + +StartStopListener.prototype = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsIRequestObserver, + Ci.nsIStreamListener]), + + onStartRequest: function(request, context) { + this.manager.onStartRequest(request, this.loadContext); + this.orig.onStartRequest(request, context); + }, + + onStopRequest(request, context, statusCode) { + try { + this.orig.onStopRequest(request, context, statusCode); + } catch (e) { + Cu.reportError(e); + } + this.manager.onStopRequest(request, this.loadContext); + }, + + onDataAvailable(...args) { + return this.orig.onDataAvailable(...args); + }, +}; + +var ChannelEventSink = { + _classDescription: "WebRequest channel event sink", + _classID: Components.ID("115062f8-92f1-11e5-8b7f-080027b0f7ec"), + _contractID: "@mozilla.org/webrequest/channel-event-sink;1", + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIChannelEventSink, + Ci.nsIFactory]), + + init() { + Components.manager.QueryInterface(Ci.nsIComponentRegistrar) + .registerFactory(this._classID, this._classDescription, this._contractID, this); + }, + + register() { + let catMan = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager); + catMan.addCategoryEntry("net-channel-event-sinks", this._contractID, this._contractID, false, true); + }, + + unregister() { + let catMan = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager); + catMan.deleteCategoryEntry("net-channel-event-sinks", this._contractID, false); + }, + + // nsIChannelEventSink implementation + asyncOnChannelRedirect(oldChannel, newChannel, flags, redirectCallback) { + runLater(() => redirectCallback.onRedirectVerifyCallback(Cr.NS_OK)); + try { + HttpObserverManager.onChannelReplaced(oldChannel, newChannel); + } catch (e) { + // we don't wanna throw: it would abort the redirection + } + }, + + // nsIFactory implementation + createInstance(outer, iid) { + if (outer) { + throw Cr.NS_ERROR_NO_AGGREGATION; + } + return this.QueryInterface(iid); + }, +}; + +ChannelEventSink.init(); + +HttpObserverManager = { + modifyInitialized: false, + examineInitialized: false, + redirectInitialized: false, + activityInitialized: false, + needTracing: false, + + listeners: { + opening: new Map(), + modify: new Map(), + afterModify: new Map(), + headersReceived: new Map(), + onRedirect: new Map(), + onStart: new Map(), + onError: new Map(), + onStop: new Map(), + }, + + get activityDistributor() { + return Cc["@mozilla.org/network/http-activity-distributor;1"].getService(Ci.nsIHttpActivityDistributor); + }, + + addOrRemove() { + let needModify = this.listeners.opening.size || this.listeners.modify.size || this.listeners.afterModify.size; + if (needModify && !this.modifyInitialized) { + this.modifyInitialized = true; + Services.obs.addObserver(this, "http-on-modify-request", false); + } else if (!needModify && this.modifyInitialized) { + this.modifyInitialized = false; + Services.obs.removeObserver(this, "http-on-modify-request"); + } + this.needTracing = this.listeners.onStart.size || + this.listeners.onError.size || + this.listeners.onStop.size; + + let needExamine = this.needTracing || + this.listeners.headersReceived.size; + + if (needExamine && !this.examineInitialized) { + this.examineInitialized = true; + Services.obs.addObserver(this, "http-on-examine-response", false); + Services.obs.addObserver(this, "http-on-examine-cached-response", false); + Services.obs.addObserver(this, "http-on-examine-merged-response", false); + } else if (!needExamine && this.examineInitialized) { + this.examineInitialized = false; + Services.obs.removeObserver(this, "http-on-examine-response"); + Services.obs.removeObserver(this, "http-on-examine-cached-response"); + Services.obs.removeObserver(this, "http-on-examine-merged-response"); + } + + let needRedirect = this.listeners.onRedirect.size; + if (needRedirect && !this.redirectInitialized) { + this.redirectInitialized = true; + ChannelEventSink.register(); + } else if (!needRedirect && this.redirectInitialized) { + this.redirectInitialized = false; + ChannelEventSink.unregister(); + } + + let needActivity = this.listeners.onError.size; + if (needActivity && !this.activityInitialized) { + this.activityInitialized = true; + this.activityDistributor.addObserver(this); + } else if (!needActivity && this.activityInitialized) { + this.activityInitialized = false; + this.activityDistributor.removeObserver(this); + } + }, + + addListener(kind, callback, opts) { + this.listeners[kind].set(callback, opts); + this.addOrRemove(); + }, + + removeListener(kind, callback) { + this.listeners[kind].delete(callback); + this.addOrRemove(); + }, + + getLoadContext(channel) { + try { + return channel.QueryInterface(Ci.nsIChannel) + .notificationCallbacks + .getInterface(Components.interfaces.nsILoadContext); + } catch (e) { + try { + return channel.loadGroup + .notificationCallbacks + .getInterface(Components.interfaces.nsILoadContext); + } catch (e) { + return null; + } + } + }, + + observe(subject, topic, data) { + let channel = subject.QueryInterface(Ci.nsIHttpChannel); + switch (topic) { + case "http-on-modify-request": + let loadContext = this.getLoadContext(channel); + + this.runChannelListener(channel, loadContext, "opening"); + break; + case "http-on-examine-cached-response": + case "http-on-examine-merged-response": + getData(channel).fromCache = true; + // falls through + case "http-on-examine-response": + this.examine(channel, topic, data); + break; + } + }, + + // We map activity values with tentative error names, e.g. "STATUS_RESOLVING" => "NS_ERROR_NET_ON_RESOLVING". + get activityErrorsMap() { + let prefix = /^(?:ACTIVITY_SUBTYPE_|STATUS_)/; + let map = new Map(); + for (let iface of [nsIHttpActivityObserver, nsISocketTransport]) { + for (let c of Object.keys(iface).filter(name => prefix.test(name))) { + map.set(iface[c], c.replace(prefix, "NS_ERROR_NET_ON_")); + } + } + delete this.activityErrorsMap; + this.activityErrorsMap = map; + return this.activityErrorsMap; + }, + GOOD_LAST_ACTIVITY: nsIHttpActivityObserver.ACTIVITY_SUBTYPE_RESPONSE_HEADER, + observeActivity(channel, activityType, activitySubtype /* , aTimestamp, aExtraSizeData, aExtraStringData */) { + let channelData = getData(channel); + let lastActivity = channelData.lastActivity || 0; + if (activitySubtype === nsIHttpActivityObserver.ACTIVITY_SUBTYPE_RESPONSE_COMPLETE && + lastActivity && lastActivity !== this.GOOD_LAST_ACTIVITY) { + let loadContext = this.getLoadContext(channel); + if (!this.errorCheck(channel, loadContext, channelData)) { + this.runChannelListener(channel, loadContext, "onError", + {error: this.activityErrorsMap.get(lastActivity) || + `NS_ERROR_NET_UNKNOWN_${lastActivity}`}); + } + } else if (lastActivity !== this.GOOD_LAST_ACTIVITY && + lastActivity !== nsIHttpActivityObserver.ACTIVITY_SUBTYPE_TRANSACTION_CLOSE) { + channelData.lastActivity = activitySubtype; + } + }, + + shouldRunListener(policyType, uri, filter) { + return WebRequestCommon.typeMatches(policyType, filter.types) && + WebRequestCommon.urlMatches(uri, filter.urls); + }, + + get resultsMap() { + delete this.resultsMap; + this.resultsMap = new Map(Object.keys(Cr).map(name => [Cr[name], name])); + return this.resultsMap; + }, + maybeError(channel, extraData = null, channelData = null) { + if (!(extraData && extraData.error)) { + if (!Components.isSuccessCode(channel.status)) { + extraData = {error: this.resultsMap.get(channel.status)}; + } + } + return extraData; + }, + errorCheck(channel, loadContext, channelData = null) { + let errorData = this.maybeError(channel, null, channelData); + if (errorData) { + this.runChannelListener(channel, loadContext, "onError", errorData); + } + return errorData; + }, + + /** + * Resumes the channel if it is currently suspended due to this + * listener. + * + * @param {nsIChannel} channel + * The channel to possibly suspend. + */ + maybeResume(channel) { + let data = getData(channel); + if (data.suspended) { + channel.resume(); + data.suspended = false; + } + }, + + /** + * Suspends the channel if it is not currently suspended due to this + * listener. Returns true if the channel was suspended as a result of + * this call. + * + * @param {nsIChannel} channel + * The channel to possibly suspend. + * @returns {boolean} + * True if this call resulted in the channel being suspended. + */ + maybeSuspend(channel) { + let data = getData(channel); + if (!data.suspended) { + channel.suspend(); + data.suspended = true; + return true; + } + }, + + getRequestData(channel, loadContext, policyType, extraData) { + let {loadInfo} = channel; + + let data = { + requestId: RequestId.get(channel), + url: channel.URI.spec, + method: channel.requestMethod, + browser: loadContext && loadContext.topFrameElement, + type: WebRequestCommon.typeForPolicyType(policyType), + fromCache: getData(channel).fromCache, + windowId: 0, + parentWindowId: 0, + }; + + if (loadInfo) { + let originPrincipal = loadInfo.triggeringPrincipal; + if (originPrincipal.URI) { + data.originUrl = originPrincipal.URI.spec; + } + + // If there is no loadingPrincipal, check that the request is not going to + // inherit a system principal. triggeringPrincipal is the context that + // initiated the load, but is not necessarily the principal that the + // request results in, only rely on that if no other principal is available. + let {isSystemPrincipal} = Services.scriptSecurityManager; + let isTopLevel = !loadInfo.loadingPrincipal && !!data.browser; + data.isSystemPrincipal = !isTopLevel && + isSystemPrincipal(loadInfo.loadingPrincipal || + loadInfo.principalToInherit || + loadInfo.triggeringPrincipal); + + if (loadInfo.frameOuterWindowID) { + Object.assign(data, { + windowId: loadInfo.frameOuterWindowID, + parentWindowId: loadInfo.outerWindowID, + }); + } else { + Object.assign(data, { + windowId: loadInfo.outerWindowID, + parentWindowId: loadInfo.parentOuterWindowID, + }); + } + } + + if (channel instanceof Ci.nsIHttpChannelInternal) { + try { + data.ip = channel.remoteAddress; + } catch (e) { + // The remoteAddress getter throws if the address is unavailable, + // but ip is an optional property so just ignore the exception. + } + } + + return Object.assign(data, extraData); + }, + + runChannelListener(channel, loadContext = null, kind, extraData = null) { + let handlerResults = []; + let requestHeaders; + let responseHeaders; + + try { + if (this.activityInitialized) { + let channelData = getData(channel); + if (kind === "onError") { + if (channelData.errorNotified) { + return; + } + channelData.errorNotified = true; + } else if (this.errorCheck(channel, loadContext, channelData)) { + return; + } + } + + let {loadInfo} = channel; + let policyType = (loadInfo ? loadInfo.externalContentPolicyType + : Ci.nsIContentPolicy.TYPE_OTHER); + + let includeStatus = (["headersReceived", "onRedirect", "onStart", "onStop"].includes(kind) && + channel instanceof Ci.nsIHttpChannel); + + let commonData = null; + let uri = channel.URI; + let requestBody; + for (let [callback, opts] of this.listeners[kind].entries()) { + if (!this.shouldRunListener(policyType, uri, opts.filter)) { + continue; + } + + if (!commonData) { + commonData = this.getRequestData(channel, loadContext, policyType, extraData); + } + let data = Object.assign({}, commonData); + + if (opts.requestHeaders) { + requestHeaders = requestHeaders || new RequestHeaderChanger(channel); + data.requestHeaders = requestHeaders.toArray(); + } + + if (opts.responseHeaders) { + responseHeaders = responseHeaders || new ResponseHeaderChanger(channel); + data.responseHeaders = responseHeaders.toArray(); + } + + if (opts.requestBody) { + requestBody = requestBody || WebRequestUpload.createRequestBody(channel); + data.requestBody = requestBody; + } + + if (includeStatus) { + mergeStatus(data, channel, kind); + } + + try { + let result = callback(data); + + if (result && typeof result === "object" && opts.blocking + && !AddonManagerPermissions.isHostPermitted(uri.host) + && (!loadInfo || !loadInfo.loadingPrincipal + || !loadInfo.loadingPrincipal.URI + || !AddonManagerPermissions.isHostPermitted(loadInfo.loadingPrincipal.URI.host))) { + handlerResults.push({opts, result}); + } + } catch (e) { + Cu.reportError(e); + } + } + } catch (e) { + Cu.reportError(e); + } + + return this.applyChanges(kind, channel, loadContext, handlerResults, + requestHeaders, responseHeaders); + }, + + applyChanges: Task.async(function* (kind, channel, loadContext, handlerResults, requestHeaders, responseHeaders) { + let asyncHandlers = handlerResults.filter(({result}) => isThenable(result)); + let isAsync = asyncHandlers.length > 0; + let shouldResume = false; + + try { + if (isAsync) { + shouldResume = this.maybeSuspend(channel); + + for (let value of asyncHandlers) { + try { + value.result = yield value.result; + } catch (e) { + Cu.reportError(e); + value.result = {}; + } + } + } + + for (let {opts, result} of handlerResults) { + if (!result || typeof result !== "object") { + continue; + } + + if (result.cancel) { + this.maybeResume(channel); + channel.cancel(Cr.NS_ERROR_ABORT); + + this.errorCheck(channel, loadContext); + return; + } + + if (result.redirectUrl) { + try { + this.maybeResume(channel); + + channel.redirectTo(BrowserUtils.makeURI(result.redirectUrl)); + return; + } catch (e) { + Cu.reportError(e); + } + } + + if (opts.requestHeaders && result.requestHeaders && requestHeaders) { + requestHeaders.applyChanges(result.requestHeaders); + } + + if (opts.responseHeaders && result.responseHeaders && responseHeaders) { + responseHeaders.applyChanges(result.responseHeaders); + } + } + + if (kind === "opening") { + yield this.runChannelListener(channel, loadContext, "modify"); + } else if (kind === "modify") { + yield this.runChannelListener(channel, loadContext, "afterModify"); + } + } catch (e) { + Cu.reportError(e); + } + + // Only resume the channel if it was suspended by this call. + if (shouldResume) { + this.maybeResume(channel); + } + }), + + examine(channel, topic, data) { + let loadContext = this.getLoadContext(channel); + + if (this.needTracing) { + // Check whether we've already added a listener to this channel, + // so we don't wind up chaining multiple listeners. + let channelData = getData(channel); + if (!channelData.hasListener && channel instanceof Ci.nsITraceableChannel) { + let responseStatus = channel.responseStatus; + // skip redirections, https://bugzilla.mozilla.org/show_bug.cgi?id=728901#c8 + if (responseStatus < 300 || responseStatus >= 400) { + let listener = new StartStopListener(this, loadContext); + let orig = channel.setNewListener(listener); + listener.orig = orig; + channelData.hasListener = true; + } + } + } + + this.runChannelListener(channel, loadContext, "headersReceived"); + }, + + onChannelReplaced(oldChannel, newChannel) { + this.runChannelListener(oldChannel, this.getLoadContext(oldChannel), + "onRedirect", {redirectUrl: newChannel.URI.spec}); + }, + + onStartRequest(channel, loadContext) { + this.runChannelListener(channel, loadContext, "onStart"); + }, + + onStopRequest(channel, loadContext) { + this.runChannelListener(channel, loadContext, "onStop"); + }, +}; + +var onBeforeRequest = { + get allowedOptions() { + delete this.allowedOptions; + this.allowedOptions = ["blocking"]; + if (!AppConstants.RELEASE_OR_BETA) { + this.allowedOptions.push("requestBody"); + } + return this.allowedOptions; + }, + addListener(callback, filter = null, opt_extraInfoSpec = null) { + let opts = parseExtra(opt_extraInfoSpec, this.allowedOptions); + opts.filter = parseFilter(filter); + ContentPolicyManager.addListener(callback, opts); + HttpObserverManager.addListener("opening", callback, opts); + }, + + removeListener(callback) { + HttpObserverManager.removeListener("opening", callback); + ContentPolicyManager.removeListener(callback); + }, +}; + +function HttpEvent(internalEvent, options) { + this.internalEvent = internalEvent; + this.options = options; +} + +HttpEvent.prototype = { + addListener(callback, filter = null, opt_extraInfoSpec = null) { + let opts = parseExtra(opt_extraInfoSpec, this.options); + opts.filter = parseFilter(filter); + HttpObserverManager.addListener(this.internalEvent, callback, opts); + }, + + removeListener(callback) { + HttpObserverManager.removeListener(this.internalEvent, callback); + }, +}; + +var onBeforeSendHeaders = new HttpEvent("modify", ["requestHeaders", "blocking"]); +var onSendHeaders = new HttpEvent("afterModify", ["requestHeaders"]); +var onHeadersReceived = new HttpEvent("headersReceived", ["blocking", "responseHeaders"]); +var onBeforeRedirect = new HttpEvent("onRedirect", ["responseHeaders"]); +var onResponseStarted = new HttpEvent("onStart", ["responseHeaders"]); +var onCompleted = new HttpEvent("onStop", ["responseHeaders"]); +var onErrorOccurred = new HttpEvent("onError"); + +var WebRequest = { + // http-on-modify observer for HTTP(S), content policy for the other protocols (notably, data:) + onBeforeRequest: onBeforeRequest, + + // http-on-modify observer. + onBeforeSendHeaders: onBeforeSendHeaders, + + // http-on-modify observer. + onSendHeaders: onSendHeaders, + + // http-on-examine-*observer. + onHeadersReceived: onHeadersReceived, + + // nsIChannelEventSink. + onBeforeRedirect: onBeforeRedirect, + + // OnStartRequest channel listener. + onResponseStarted: onResponseStarted, + + // OnStopRequest channel listener. + onCompleted: onCompleted, + + // nsIHttpActivityObserver. + onErrorOccurred: onErrorOccurred, +}; + +Services.ppmm.loadProcessScript("resource://gre/modules/WebRequestContent.js", true); |