_onDownloadSuccess: function(downloadable, responseText, errorCallback, redirectCallback)
{
let lines = responseText.split(/[\r\n]+/);
let match = /\[Adblock(?:\s*Plus\s*([\d\.]+)?)?\]/i.exec(lines[0]);
if (!match)
return errorCallback("synchronize_invalid_data");
let minVersion = match[1];
// Don't remove parameter comments immediately but add them to a list first,
// they need to be considered in the checksum calculation.
let remove = [];
let params = {
redirect: null,
homepage: null,
title: null,
version: null,
expires: null
};
for (let i = 0; i < lines.length; i++)
{
let match = /^\s*!\s*(\w+)\s*:\s*(.*)/.exec(lines[i]);
if (match)
{
let keyword = match[1].toLowerCase();
let value = match[2];
if (keyword in params)
{
params[keyword] = value;
remove.push(i);
}
else if (keyword == "checksum")
{
lines.splice(i--, 1);
let checksum = Utils.generateChecksum(lines);
if (checksum && checksum != value.replace(/=+$/, ""))
return errorCallback("synchronize_checksum_mismatch");
}
}
}
if (params.redirect)
return redirectCallback(params.redirect);
// Handle redirects
let subscription = Subscription.fromURL(downloadable.redirectURL || downloadable.url);
if (downloadable.redirectURL && downloadable.redirectURL != downloadable.url)
{
let oldSubscription = Subscription.fromURL(downloadable.url);
subscription.title = oldSubscription.title;
subscription.disabled = oldSubscription.disabled;
subscription.lastCheck = oldSubscription.lastCheck;
let listed = (oldSubscription.url in FilterStorage.knownSubscriptions);
if (listed)
FilterStorage.removeSubscription(oldSubscription);
delete Subscription.knownSubscriptions[oldSubscription.url];
if (listed)
FilterStorage.addSubscription(subscription);
}
// The download actually succeeded
subscription.lastSuccess = subscription.lastDownload = Math.round(Date.now() / MILLIS_IN_SECOND);
subscription.downloadStatus = "synchronize_ok";
subscription.downloadCount = downloadable.downloadCount;
subscription.errors = 0;
// Remove lines containing parameters
for (let i = remove.length - 1; i >= 0; i--)
lines.splice(remove[i], 1);
// Process parameters
if (params.homepage)
{
let uri = Utils.makeURI(params.homepage);
if (uri && (uri.scheme == "http" || uri.scheme == "https"))
subscription.homepage = uri.spec;
}
if (params.title)
{
subscription.title = params.title;
subscription.fixedTitle = true;
}
else
subscription.fixedTitle = false;
subscription.version = (params.version ? parseInt(params.version, 10) : 0);
let expirationInterval = DEFAULT_EXPIRATION_INTERVAL;
if (params.expires)
{
let match = /^(\d+)\s*(h)?/.exec(params.expires);
if (match)
{
let interval = parseInt(match[1], 10);
if (match[2])
expirationInterval = interval * MILLIS_IN_HOUR;
else
expirationInterval = interval * MILLIS_IN_DAY;
}
}
let [softExpiration, hardExpiration] = downloader.processExpirationInterval(expirationInterval);
subscription.softExpiration = Math.round(softExpiration / MILLIS_IN_SECOND);
subscription.expires = Math.round(hardExpiration / MILLIS_IN_SECOND);
delete subscription.requiredVersion;
delete subscription.upgradeRequired;
if (minVersion)
{
let {addonVersion} = require("info");
subscription.requiredVersion = minVersion;
if (Services.vc.compare(minVersion, addonVersion) > 0)
subscription.upgradeRequired = true;
}
// Process filters
lines.shift();
let filters = [];
for (let line of lines)
{
line = Filter.normalize(line);
if (line)
filters.push(Filter.fromText(line));
}
FilterStorage.updateSubscriptionFilters(subscription, filters);
return undefined;
},
exports.initAntiAdblockNotification = function initAntiAdblockNotification()
{
let notification = {
id: "antiadblock",
type: "question",
title: Utils.getString("notification_antiadblock_title"),
message: Utils.getString("notification_antiadblock_message"),
urlFilters: []
};
function notificationListener(approved)
{
let subscription = Subscription.fromURL(Prefs.subscriptions_antiadblockurl);
if (subscription.url in FilterStorage.knownSubscriptions)
subscription.disabled = !approved;
}
function addAntiAdblockNotification(subscription)
{
let urlFilters = [];
for (let filter of subscription.filters)
{
if (filter instanceof ActiveFilter)
{
for (let domain in filter.domains)
{
let urlFilter = "||" + domain + "^$document";
if (domain && filter.domains[domain] && urlFilters.indexOf(urlFilter) == -1)
urlFilters.push(urlFilter);
}
}
}
notification.urlFilters = urlFilters;
Notification.addNotification(notification);
Notification.addQuestionListener(notification.id, notificationListener);
}
function removeAntiAdblockNotification()
{
Notification.removeNotification(notification);
Notification.removeQuestionListener(notification.id, notificationListener);
}
let subscription = Subscription.fromURL(Prefs.subscriptions_antiadblockurl);
if (subscription.lastDownload && subscription.disabled)
addAntiAdblockNotification(subscription);
function onSubscriptionChange(subscription)
{
let url = Prefs.subscriptions_antiadblockurl;
if (url != subscription.url)
return;
if (url in FilterStorage.knownSubscriptions && !subscription.disabled)
addAntiAdblockNotification(subscription);
else
removeAntiAdblockNotification();
}
FilterNotifier.on("subscription.updated", onSubscriptionChange);
FilterNotifier.on("subscription.removed", onSubscriptionChange);
FilterNotifier.on("subscription.disabled", onSubscriptionChange);
}
yield new Promise((resolve, reject) => Utils.runAsync(resolve));
ext.windows.getLastFocused(function(win)
{
win.openTab(Utils.getDocLink(activeNotification.links[buttonIndex]));
});
global.ext.onMessage.addListener(function(message, sender, callback)
{
switch (message.type)
{
case "app.get":
if (message.what == "issues")
{
var subscriptionInit = tryRequire("subscriptionInit");
callback({
filterlistsReinitialized: subscriptionInit ? subscriptionInit.reinitialized : false,
legacySafariVersion: (info.platform == "safari" && (
Services.vc.compare(info.platformVersion, "6.0") < 0 || // beforeload breaks websites in Safari 5
Services.vc.compare(info.platformVersion, "6.1") == 0 || // extensions are broken in 6.1 and 7.0
Services.vc.compare(info.platformVersion, "7.0") == 0))
});
}
else if (message.what == "doclink")
callback(Utils.getDocLink(message.link));
else if (message.what == "localeInfo")
{
var bidiDir;
if ("chromeRegistry" in Utils)
bidiDir = Utils.chromeRegistry.isLocaleRTL("stopallads") ? "rtl" : "ltr";
else
bidiDir = ext.i18n.getMessage("@@bidi_dir");
callback({locale: Utils.appLocale, bidiDir: bidiDir});
}
else if (message.what == "features")
{
callback({
devToolsPanel: info.platform == "chromium",
safariContentBlocker: "safari" in global
&& "extension" in global.safari
&& "setContentBlocker" in global.safari.extension
});
}
else
callback(info[message.what]);
break;
case "app.listen":
getListenerFilters(sender.page).app = message.filter;
break;
case "app.open":
if (message.what == "options")
ext.showOptions();
break;
case "filters.add":
var result = require("filterValidation").parseFilter(message.text);
var errors = [];
if (result.error)
errors.push(result.error.toString());
else if (result.filter)
FilterStorage.addFilter(result.filter);
callback(errors);
break;
case "filters.blocked":
var filter = defaultMatcher.matchesAny(message.url,
RegExpFilter.typeMap[message.requestType], message.docDomain,
message.thirdParty);
callback(filter instanceof BlockingFilter);
break;
case "filters.get":
if (message.what == "cssproperties")
{
var filters = [];
var checkWhitelisted = require("whitelisting").checkWhitelisted;
if (!checkWhitelisted(sender.page, sender.frame,
RegExpFilter.typeMap.DOCUMENT |
RegExpFilter.typeMap.ELEMHIDE))
{
filters = CSSRules.getRulesForDomain(sender.frame.url.hostname);
filters = filters.map(function(filter)
{
return {
prefix: filter.selectorPrefix,
suffix: filter.selectorSuffix,
regexp: filter.regexpString,
text: filter.text
};
});
}
callback(filters);
break;
}
var subscription = Subscription.fromURL(message.subscriptionUrl);
if (!subscription)
{
callback([]);
break;
}
callback(subscription.filters.map(convertFilter));
break;
case "filters.importRaw":
var result = require("filterValidation").parseFilters(message.text);
var errors = [];
for (var i = 0; i < result.errors.length; i++)
{
var error = result.errors[i];
if (error.type != "unexpected-filter-list-header")
errors.push(error.toString());
}
callback(errors);
if (errors.length > 0)
return;
var seenFilter = Object.create(null);
for (var i = 0; i < result.filters.length; i++)
{
var filter = result.filters[i];
FilterStorage.addFilter(filter);
seenFilter[filter.text] = null;
}
if (!message.removeExisting)
return;
for (var i = 0; i < FilterStorage.subscriptions.length; i++)
{
var subscription = FilterStorage.subscriptions[i];
if (!(subscription instanceof SpecialSubscription))
continue;
for (var j = subscription.filters.length - 1; j >= 0; j--)
{
var filter = subscription.filters[j];
if (/^@@\|\|([^\/:]+)\^\$document$/.test(filter.text))
continue;
if (!(filter.text in seenFilter))
FilterStorage.removeFilter(filter);
}
}
break;
case "filters.listen":
getListenerFilters(sender.page).filter = message.filter;
addFilterListeners("filter", message.filter);
break;
case "filters.remove":
var filter = Filter.fromText(message.text);
var subscription = null;
if (message.subscriptionUrl)
subscription = Subscription.fromURL(message.subscriptionUrl);
if (!subscription)
FilterStorage.removeFilter(filter);
else
FilterStorage.removeFilter(filter, subscription, message.index);
break;
case "prefs.get":
callback(Prefs[message.key]);
break;
case "prefs.listen":
getListenerFilters(sender.page).pref = message.filter;
message.filter.forEach(function(preference)
{
if (!(preference in listenedPreferences))
{
listenedPreferences[preference] = null;
Prefs.on(preference, function()
{
sendMessage("pref", preference, Prefs[preference]);
});
}
});
break;
case "prefs.toggle":
if (message.key == "notifications_ignoredcategories")
NotificationStorage.toggleIgnoreCategory("*");
else
Prefs[message.key] = !Prefs[message.key];
break;
case "subscriptions.add":
var subscription = Subscription.fromURL(message.url);
if ("title" in message)
subscription.title = message.title;
if ("homepage" in message)
subscription.homepage = message.homepage;
if (message.confirm)
{
ext.showOptions(function()
{
sendMessage("app", "addSubscription", subscription);
});
}
else
{
subscription.disabled = false;
FilterStorage.addSubscription(subscription);
if (subscription instanceof DownloadableSubscription && !subscription.lastDownload)
Synchronizer.execute(subscription);
}
break;
case "subscriptions.get":
var subscriptions = FilterStorage.subscriptions.filter(function(s)
{
if (message.ignoreDisabled && s.disabled)
return false;
if (s instanceof DownloadableSubscription && message.downloadable)
return true;
if (s instanceof SpecialSubscription && message.special)
return true;
return false;
});
callback(subscriptions.map(convertSubscription));
break;
case "subscriptions.listen":
getListenerFilters(sender.page).subscription = message.filter;
addFilterListeners("subscription", message.filter);
break;
case "subscriptions.remove":
var subscription = Subscription.fromURL(message.url);
if (subscription.url in FilterStorage.knownSubscriptions)
FilterStorage.removeSubscription(subscription);
break;
case "subscriptions.toggle":
var subscription = Subscription.fromURL(message.url);
if (subscription.url in FilterStorage.knownSubscriptions)
{
if (subscription.disabled || message.keepInstalled)
subscription.disabled = !subscription.disabled;
else
FilterStorage.removeSubscription(subscription);
}
else
{
subscription.disabled = false;
subscription.title = message.title;
subscription.homepage = message.homepage;
FilterStorage.addSubscription(subscription);
if (!subscription.lastDownload)
Synchronizer.execute(subscription);
}
break;
case "subscriptions.update":
var subscriptions = message.url ? [Subscription.fromURL(message.url)] :
FilterStorage.subscriptions;
for (var i = 0; i < subscriptions.length; i++)
{
var subscription = subscriptions[i];
if (subscription instanceof DownloadableSubscription)
Synchronizer.execute(subscription, true);
}
break;
}
});
notification.links.forEach(function(link)
{
docLinks.push(Utils.getDocLink(link));
});
ext.windows.getLastFocused(function(win)
{
win.openTab(Utils.getDocLink(link));
});
Subscription.fromObject = function(obj)
{
let result;
try
{
obj.url = Services.io.newURI(obj.url, null, null).spec;
// URL is valid - this is a downloadable subscription
result = new DownloadableSubscription(obj.url, obj.title);
if ("downloadStatus" in obj)
result._downloadStatus = obj.downloadStatus;
if ("lastSuccess" in obj)
result.lastSuccess = parseInt(obj.lastSuccess) || 0;
if ("lastCheck" in obj)
result._lastCheck = parseInt(obj.lastCheck) || 0;
if ("expires" in obj)
result.expires = parseInt(obj.expires) || 0;
if ("softExpiration" in obj)
result.softExpiration = parseInt(obj.softExpiration) || 0;
if ("errors" in obj)
result._errors = parseInt(obj.errors) || 0;
if ("version" in obj)
result.version = parseInt(obj.version) || 0;
if ("requiredVersion" in obj)
{
let {addonVersion} = require("info");
result.requiredVersion = obj.requiredVersion;
if (Services.vc.compare(result.requiredVersion, addonVersion) > 0)
result.upgradeRequired = true;
}
if ("homepage" in obj)
result._homepage = obj.homepage;
if ("lastDownload" in obj)
result._lastDownload = parseInt(obj.lastDownload) || 0;
}
catch (e)
{
// Invalid URL - custom filter group
if (!("title" in obj))
{
// Backwards compatibility - titles and filter types were originally
// determined by group identifier.
if (obj.url == "~wl~")
obj.defaults = "whitelist";
else if (obj.url == "~fl~")
obj.defaults = "blocking";
else if (obj.url == "~eh~")
obj.defaults = "elemhide";
if ("defaults" in obj)
{
let {Utils} = require("utils");
obj.title = Utils.getString(obj.defaults + "Group_title");
}
}
result = new SpecialSubscription(obj.url, obj.title);
if ("defaults" in obj)
result.defaults = obj.defaults.split(" ");
}
if ("fixedTitle" in obj)
result._fixedTitle = (obj.fixedTitle == "true");
if ("disabled" in obj)
result._disabled = (obj.disabled == "true");
return result;
}
document.addEventListener("DOMContentLoaded", function splitAllLabelsHandler()
{
document.removeEventListener("DOMContentLoaded", splitAllLabelsHandler, false);
Utils.splitAllLabels(document);
}, false);
removeDomain: function(domain){
if(this.hasDomain(domain)){
Utils.removeElementFromArray(this.domains,this.domains.indexOf(domain));
chrome.storage.local.set({cookieblocklist: this.domains});
}
},
global.ext.onMessage.addListener(function(message, sender, callback)
{
var listenerFilters = null;
switch (message.type)
{
case "app.listen":
case "filters.listen":
case "subscriptions.listen":
if (!changeListeners)
{
changeListeners = new global.ext.PageMap();
FilterNotifier.addListener(onFilterChange);
}
listenerFilters = changeListeners.get(sender.page);
if (!listenerFilters)
{
listenerFilters = Object.create(null);
changeListeners.set(sender.page, listenerFilters);
}
break;
}
switch (message.type)
{
case "add-subscription":
ext.showOptions(function()
{
var subscription = Subscription.fromURL(message.url);
subscription.title = message.title;
onFilterChange("addSubscription", subscription);
});
break;
case "app.get":
if (message.what == "issues")
{
var subscriptionInit;
try
{
subscriptionInit = require("subscriptionInit");
}
catch (e)
{
// Expected exception, this module doesn't exist on Firefox
}
var info = require("info");
callback({
filterlistsReinitialized: subscriptionInit ? subscriptionInit.reinitialized : false,
legacySafariVersion: (info.platform == "safari" && (
Services.vc.compare(info.platformVersion, "6.0") < 0 || // beforeload breaks websites in Safari 5
Services.vc.compare(info.platformVersion, "6.1") == 0 || // extensions are broken in 6.1 and 7.0
Services.vc.compare(info.platformVersion, "7.0") == 0))
});
}
else if (message.what == "doclink")
callback(Utils.getDocLink(message.link));
else if (message.what == "localeInfo")
{
var bidiDir;
if ("chromeRegistry" in Utils)
bidiDir = Utils.chromeRegistry.isLocaleRTL("adblockplus") ? "rtl" : "ltr";
else
bidiDir = ext.i18n.getMessage("@@bidi_dir");
callback({locale: Utils.appLocale, bidiDir: bidiDir});
}
else if (message.what == "addonVersion")
{
callback(require("info").addonVersion);
}
else
callback(null);
break;
case "app.listen":
if (message.filter)
listenerFilters.app = message.filter;
else
delete listenerFilters.app;
break;
case "app.open":
if (message.what == "options")
ext.showOptions();
break;
case "filters.add":
var result = require("filterValidation").parseFilter(message.text);
var errors = [];
if (result.error)
errors.push(result.error.toString());
else if (result.filter)
FilterStorage.addFilter(result.filter);
callback(errors);
break;
case "filters.blocked":
var filter = defaultMatcher.matchesAny(message.url,
RegExpFilter.typeMap[message.requestType], message.docDomain,
message.thirdParty);
callback(filter instanceof BlockingFilter);
break;
case "filters.get":
if (message.what == "cssproperties")
{
var filters = [];
var checkWhitelisted = require("whitelisting").checkWhitelisted;
if (!checkWhitelisted(sender.page, sender.frame,
RegExpFilter.typeMap.DOCUMENT |
RegExpFilter.typeMap.ELEMHIDE))
{
filters = CSSRules.getRulesForDomain(sender.frame.url.hostname);
filters = filters.map(function(filter)
{
return {
prefix: filter.selectorPrefix,
suffix: filter.selectorSuffix,
regexp: filter.regexpString
};
});
}
callback(filters);
break;
}
var subscription = Subscription.fromURL(message.subscriptionUrl);
if (!subscription)
{
callback([]);
break;
}
callback(subscription.filters.map(convertFilter));
break;
case "filters.importRaw":
var result = require("filterValidation").parseFilters(message.text);
var errors = [];
for (var i = 0; i < result.errors.length; i++)
{
var error = result.errors[i];
if (error.type != "unexpected-filter-list-header")
errors.push(error.toString());
}
callback(errors);
if (errors.length > 0)
return;
var seenFilter = Object.create(null);
for (var i = 0; i < result.filters.length; i++)
{
var filter = result.filters[i];
FilterStorage.addFilter(filter);
seenFilter[filter.text] = null;
}
for (var i = 0; i < FilterStorage.subscriptions.length; i++)
{
var subscription = FilterStorage.subscriptions[i];
if (!(subscription instanceof SpecialSubscription))
continue;
for (var j = subscription.filters.length - 1; j >= 0; j--)
{
var filter = subscription.filters[j];
if (/^@@\|\|([^\/:]+)\^\$document$/.test(filter.text))
continue;
if (!(filter.text in seenFilter))
FilterStorage.removeFilter(filter);
}
}
break;
case "filters.listen":
if (message.filter)
listenerFilters.filter = message.filter;
else
delete listenerFilters.filter;
break;
case "filters.remove":
var filter = Filter.fromText(message.text);
var subscription = null;
if (message.subscriptionUrl)
subscription = Subscription.fromURL(message.subscriptionUrl);
if (!subscription)
FilterStorage.removeFilter(filter);
else
FilterStorage.removeFilter(filter, subscription, message.index);
break;
case "prefs.get":
callback(Prefs[message.key]);
break;
case "subscriptions.add":
if (message.url in FilterStorage.knownSubscriptions)
return;
var subscription = Subscription.fromURL(message.url);
if (!subscription)
return;
subscription.disabled = false;
if ("title" in message)
subscription.title = message.title;
if ("homepage" in message)
subscription.homepage = message.homepage;
FilterStorage.addSubscription(subscription);
if (subscription instanceof DownloadableSubscription && !subscription.lastDownload)
Synchronizer.execute(subscription);
break;
case "subscriptions.get":
var subscriptions = FilterStorage.subscriptions.filter(function(s)
{
if (message.ignoreDisabled && s.disabled)
return false;
if (s instanceof DownloadableSubscription && message.downloadable)
return true;
if (s instanceof SpecialSubscription && message.special)
return true;
return false;
});
callback(subscriptions.map(convertSubscription));
break;
case "subscriptions.listen":
if (message.filter)
listenerFilters.subscription = message.filter;
else
delete listenerFilters.subscription;
break;
case "subscriptions.remove":
var subscription = Subscription.fromURL(message.url);
if (subscription.url in FilterStorage.knownSubscriptions)
FilterStorage.removeSubscription(subscription);
break;
case "subscriptions.toggle":
var subscription = Subscription.fromURL(message.url);
if (subscription.url in FilterStorage.knownSubscriptions)
{
if (subscription.disabled || message.keepInstalled)
{
subscription.disabled = !subscription.disabled;
FilterNotifier.triggerListeners("subscription.disabled",
subscription);
}
else
FilterStorage.removeSubscription(subscription);
}
else
{
subscription.disabled = false;
subscription.title = message.title;
subscription.homepage = message.homepage;
FilterStorage.addSubscription(subscription);
if (!subscription.lastDownload)
Synchronizer.execute(subscription);
}
break;
case "subscriptions.update":
var subscriptions = message.url ? [Subscription.fromURL(message.url)] :
FilterStorage.subscriptions;
for (var i = 0; i < subscriptions.length; i++)
{
var subscription = subscriptions[i];
if (subscription instanceof DownloadableSubscription)
Synchronizer.execute(subscription, true);
}
break;
case "subscriptions.isDownloading":
callback(Synchronizer.isExecuting(message.url));
break;
}
});
notification.links.forEach(link =>
{
docLinks.push(Utils.getDocLink(link));
});
let window = Utils.getRequestWindow(this);
shouldAllowAsync(window, window.document, "ELEMHIDE", this.key, allow =>
{
resolve(allow ? allowXBL : hideXBL);
});
});
}
};
let observer = {
QueryInterface: XPCOMUtils.generateQI([
Ci.nsIObserver, Ci.nsISupportsWeakReference
]),
topic: "content-document-global-created",
styleURL: Utils.makeURI("about:abp-elemhide?css"),
sheet: null,
init: function()
{
Services.obs.addObserver(this, this.topic, true);
onShutdown.add(() =>
{
Services.obs.removeObserver(this, this.topic);
});
port.on("elemhideupdate", () =>
{
this.sheet = null;
});
},
let windowStatsCallbacks = new Map();
let windowDataMaxResponseID = 0;
let windowDataCallbacks = new Map();
/**
* Active RequestNotifier instances by their ID
* @type Map.<number,RequestNotifier>
*/
let notifiers = new Map();
let messageManager = Cc["@mozilla.org/parentprocessmessagemanager;1"]
.getService(Ci.nsIMessageListenerManager)
.QueryInterface(Ci.nsIMessageBroadcaster);
Utils.addChildMessageListener("AdblockPlus:FoundNodeData", onNodeData);
Utils.addChildMessageListener("AdblockPlus:ScanComplete", onScanComplete);
Utils.addChildMessageListener("AdblockPlus:NotifierResponse", onNotifierResponse);
Utils.addChildMessageListener("AdblockPlus:RetrieveWindowStatsResponse", onWindowStatsReceived);
Utils.addChildMessageListener("AdblockPlus:RetrieveWindowDataResponse", onWindowDataReceived);
function onNodeData({notifierID, data})
{
let notifier = notifiers.get(notifierID);
if (notifier)
notifier.notifyListener(data);
}
function onScanComplete(notifierID)
{
let notifier = notifiers.get(notifierID);
observe: function(subject, topic, data, uri)
{
switch (topic)
{
case "document-element-inserted":
{
let window = subject.defaultView;
if (!window)
return;
let type = window.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIWebNavigation)
.QueryInterface(Ci.nsIDocShellTreeItem)
.itemType;
if (type != Ci.nsIDocShellTreeItem.typeContent)
return;
let opener = this._openers.get(window);
if (opener == this._alreadyLoaded)
{
// This window has loaded already, ignore it regardless of whether
// window.opener is still set.
return;
}
if (opener && Cu.isDeadWrapper(opener))
opener = null;
if (!opener)
{
// We don't know the opener for this window yet, try to find it
opener = window.opener;
if (!opener)
return;
// The opener might be an intermediate window, get the real one
while (opener.location == "about:blank" && opener.opener)
opener = opener.opener;
this._openers.set(window, opener);
let forgetPopup = event =>
{
subject.removeEventListener("DOMContentLoaded", forgetPopup);
this._openers.set(window, this._alreadyLoaded);
};
subject.addEventListener("DOMContentLoaded", forgetPopup);
}
if (!uri)
uri = window.location.href;
if (!shouldAllow(opener, opener.document, "POPUP", uri))
{
window.stop();
Utils.runAsync(() => window.close());
}
else if (uri == "about:blank")
{
// An about:blank pop-up most likely means that a load will be
// initiated asynchronously. Wait for that.
Utils.runAsync(() =>
{
let channel = window.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIDocShell)
.QueryInterface(Ci.nsIDocumentLoader)
.documentChannel;
if (channel)
this.observe(subject, topic, data, channel.URI.spec);
});
}
break;
}
}
},
download: function(/**Downloadable*/ downloadable)
{
// Make sure to detach download from the current execution context
Utils.runAsync(this._download.bind(this, downloadable, 0));
},