2014-06-23 16:42:43 -06:00
|
|
|
/*******************************************************************************
|
|
|
|
|
2016-02-26 07:48:43 -07:00
|
|
|
uBlock Origin - a browser extension to block requests.
|
2018-09-03 12:06:49 -06:00
|
|
|
Copyright (C) 2014-present Raymond Hill
|
2014-06-23 16:42:43 -06:00
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see {http://www.gnu.org/licenses/}.
|
|
|
|
|
|
|
|
Home: https://github.com/gorhill/uBlock
|
|
|
|
*/
|
|
|
|
|
2017-06-21 05:17:44 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/2720
|
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
(function() {
|
|
|
|
|
2014-10-19 05:11:27 -06:00
|
|
|
'use strict';
|
2014-06-23 16:42:43 -06:00
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
var µb = µBlock;
|
|
|
|
|
2015-04-08 16:46:08 -06:00
|
|
|
// https://github.com/gorhill/httpswitchboard/issues/303
|
|
|
|
// Some kind of trick going on here:
|
|
|
|
// Any scheme other than 'http' and 'https' is remapped into a fake
|
|
|
|
// URL which trick the rest of µBlock into being able to process an
|
|
|
|
// otherwise unmanageable scheme. µBlock needs web page to have a proper
|
|
|
|
// hostname to work properly, so just like the 'chromium-behind-the-scene'
|
|
|
|
// fake domain name, we map unknown schemes into a fake '{scheme}-scheme'
|
|
|
|
// hostname. This way, for a specific scheme you can create scope with
|
|
|
|
// rules which will apply only to that scheme.
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
µb.normalizePageURL = function(tabId, pageURL) {
|
2018-12-14 05:03:19 -07:00
|
|
|
if ( tabId < 0 ) {
|
2015-04-08 16:46:08 -06:00
|
|
|
return 'http://behind-the-scene/';
|
|
|
|
}
|
2018-12-14 05:03:19 -07:00
|
|
|
const uri = this.URI.set(pageURL);
|
|
|
|
const scheme = uri.scheme;
|
2015-04-08 16:46:08 -06:00
|
|
|
if ( scheme === 'https' || scheme === 'http' ) {
|
|
|
|
return uri.normalizedURI();
|
|
|
|
}
|
|
|
|
|
2018-12-14 05:03:19 -07:00
|
|
|
let fakeHostname = scheme + '-scheme';
|
2015-04-08 16:46:08 -06:00
|
|
|
|
|
|
|
if ( uri.hostname !== '' ) {
|
2015-04-27 08:54:13 -06:00
|
|
|
fakeHostname = uri.hostname + '.' + fakeHostname;
|
|
|
|
} else if ( scheme === 'about' && uri.path !== '' ) {
|
|
|
|
fakeHostname = uri.path + '.' + fakeHostname;
|
2015-04-08 16:46:08 -06:00
|
|
|
}
|
|
|
|
|
2015-04-27 08:54:13 -06:00
|
|
|
return 'http://' + fakeHostname + '/';
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
|
|
|
|
|
|
To keep track from which context *exactly* network requests are made. This is
|
|
|
|
often tricky for various reasons, and the challenge is not specific to one
|
|
|
|
browser.
|
|
|
|
|
|
|
|
The time at which a URL is assigned to a tab and the time when a network
|
|
|
|
request for a root document is made must be assumed to be unrelated: it's all
|
|
|
|
asynchronous. There is no guaranteed order in which the two events are fired.
|
|
|
|
|
|
|
|
Also, other "anomalies" can occur:
|
|
|
|
|
|
|
|
- a network request for a root document is fired without the corresponding
|
|
|
|
tab being really assigned a new URL
|
|
|
|
<https://github.com/chrisaljoudi/uBlock/issues/516>
|
|
|
|
|
|
|
|
- a network request for a secondary resource is labeled with a tab id for
|
|
|
|
which no root document was pulled for that tab.
|
|
|
|
<https://github.com/chrisaljoudi/uBlock/issues/1001>
|
|
|
|
|
|
|
|
- a network request for a secondary resource is made without the root
|
|
|
|
document to which it belongs being formally bound yet to the proper tab id,
|
|
|
|
causing a bad scope to be used for filtering purpose.
|
|
|
|
<https://github.com/chrisaljoudi/uBlock/issues/1205>
|
|
|
|
<https://github.com/chrisaljoudi/uBlock/issues/1140>
|
|
|
|
|
|
|
|
So the solution here is to keep a lightweight data structure which only
|
|
|
|
purpose is to keep track as accurately as possible of which root document
|
|
|
|
belongs to which tab. That's the only purpose, and because of this, there are
|
|
|
|
no restrictions for when the URL of a root document can be associated to a tab.
|
|
|
|
|
|
|
|
Before, the PageStore object was trying to deal with this, but it had to
|
|
|
|
enforce some restrictions so as to not descend into one of the above issues, or
|
|
|
|
other issues. The PageStore object can only be associated with a tab for which
|
|
|
|
a definitive navigation event occurred, because it collects information about
|
|
|
|
what occurred in the tab (for example, the number of requests blocked for a
|
|
|
|
page).
|
|
|
|
|
|
|
|
The TabContext objects do not suffer this restriction, and as a result they
|
|
|
|
offer the most reliable picture of which root document URL is really associated
|
|
|
|
to which tab. Moreover, the TabObject can undo an association from a root
|
|
|
|
document, and automatically re-associate with the next most recent. This takes
|
|
|
|
care of <https://github.com/chrisaljoudi/uBlock/issues/516>.
|
|
|
|
|
|
|
|
The PageStore object no longer cache the various information about which
|
|
|
|
root document it is currently bound. When it needs to find out, it will always
|
|
|
|
defer to the TabContext object, which will provide the real answer. This takes
|
|
|
|
case of <https://github.com/chrisaljoudi/uBlock/issues/1205>. In effect, the
|
|
|
|
master switch and dynamic filtering rules can be evaluated now properly even
|
|
|
|
in the absence of a PageStore object, this was not the case before.
|
|
|
|
|
|
|
|
Also, the TabContext object will try its best to find a good candidate root
|
|
|
|
document URL for when none exists. This takes care of
|
|
|
|
<https://github.com/chrisaljoudi/uBlock/issues/1001>.
|
|
|
|
|
|
|
|
The TabContext manager is self-contained, and it takes care to properly
|
|
|
|
housekeep itself.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
µb.tabContextManager = (function() {
|
2018-02-26 11:59:16 -07:00
|
|
|
var tabContexts = new Map();
|
2015-04-08 16:46:08 -06:00
|
|
|
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/1001
|
|
|
|
// This is to be used as last-resort fallback in case a tab is found to not
|
|
|
|
// be bound while network requests are fired for the tab.
|
|
|
|
var mostRecentRootDocURL = '';
|
|
|
|
var mostRecentRootDocURLTimestamp = 0;
|
|
|
|
|
2018-02-27 04:54:48 -07:00
|
|
|
var popupCandidates = new Map();
|
2015-12-01 13:07:22 -07:00
|
|
|
|
|
|
|
var PopupCandidate = function(targetTabId, openerTabId) {
|
|
|
|
this.targetTabId = targetTabId;
|
2017-10-13 07:33:02 -06:00
|
|
|
this.opener = {
|
|
|
|
tabId: openerTabId,
|
|
|
|
popunder: false,
|
|
|
|
trustedURL: openerTabId === µb.mouseEventRegister.tabId ?
|
|
|
|
µb.mouseEventRegister.url :
|
|
|
|
''
|
|
|
|
};
|
2015-12-01 13:07:22 -07:00
|
|
|
this.selfDestructionTimer = null;
|
|
|
|
this.launchSelfDestruction();
|
|
|
|
};
|
|
|
|
|
|
|
|
PopupCandidate.prototype.destroy = function() {
|
|
|
|
if ( this.selfDestructionTimer !== null ) {
|
|
|
|
clearTimeout(this.selfDestructionTimer);
|
|
|
|
}
|
2018-02-27 04:54:48 -07:00
|
|
|
popupCandidates.delete(this.targetTabId);
|
2015-12-01 13:07:22 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
PopupCandidate.prototype.launchSelfDestruction = function() {
|
|
|
|
if ( this.selfDestructionTimer !== null ) {
|
|
|
|
clearTimeout(this.selfDestructionTimer);
|
|
|
|
}
|
|
|
|
this.selfDestructionTimer = vAPI.setTimeout(this.destroy.bind(this), 10000);
|
|
|
|
};
|
|
|
|
|
|
|
|
var popupCandidateTest = function(targetTabId) {
|
2018-02-27 04:54:48 -07:00
|
|
|
for ( var entry of popupCandidates ) {
|
|
|
|
var tabId = entry[0];
|
|
|
|
var candidate = entry[1];
|
|
|
|
if (
|
|
|
|
targetTabId !== tabId &&
|
|
|
|
targetTabId !== candidate.opener.tabId
|
|
|
|
) {
|
2015-12-01 13:07:22 -07:00
|
|
|
continue;
|
|
|
|
}
|
2017-10-13 07:33:02 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/3129
|
|
|
|
// If the trigger is a change in the opener's URL, mark the entry
|
|
|
|
// as candidate for popunder filtering.
|
2018-02-27 04:54:48 -07:00
|
|
|
if ( targetTabId === candidate.opener.tabId ) {
|
|
|
|
candidate.opener.popunder = true;
|
2017-10-13 07:33:02 -06:00
|
|
|
}
|
2018-02-27 04:54:48 -07:00
|
|
|
if ( vAPI.tabs.onPopupUpdated(tabId, candidate.opener) === true ) {
|
|
|
|
candidate.destroy();
|
2015-12-01 13:07:22 -07:00
|
|
|
} else {
|
2018-02-27 04:54:48 -07:00
|
|
|
candidate.launchSelfDestruction();
|
2015-12-01 13:07:22 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
vAPI.tabs.onPopupCreated = function(targetTabId, openerTabId) {
|
2018-02-27 04:54:48 -07:00
|
|
|
var popup = popupCandidates.get(targetTabId);
|
2017-01-08 12:36:08 -07:00
|
|
|
if ( popup === undefined ) {
|
2018-02-27 04:54:48 -07:00
|
|
|
popupCandidates.set(
|
|
|
|
targetTabId,
|
|
|
|
new PopupCandidate(targetTabId, openerTabId)
|
|
|
|
);
|
2015-12-01 13:07:22 -07:00
|
|
|
}
|
|
|
|
popupCandidateTest(targetTabId);
|
|
|
|
};
|
|
|
|
|
2015-04-08 16:46:08 -06:00
|
|
|
var gcPeriod = 10 * 60 * 1000;
|
|
|
|
|
2015-05-28 12:47:19 -06:00
|
|
|
// A pushed entry is removed from the stack unless it is committed with
|
|
|
|
// a set time.
|
|
|
|
var StackEntry = function(url, commit) {
|
|
|
|
this.url = url;
|
|
|
|
this.committed = commit;
|
|
|
|
this.tstamp = Date.now();
|
|
|
|
};
|
|
|
|
|
2015-04-08 16:46:08 -06:00
|
|
|
var TabContext = function(tabId) {
|
2018-02-26 11:59:16 -07:00
|
|
|
this.tabId = tabId;
|
2015-04-08 16:46:08 -06:00
|
|
|
this.stack = [];
|
|
|
|
this.rawURL =
|
|
|
|
this.normalURL =
|
2018-12-13 10:30:54 -07:00
|
|
|
this.origin =
|
2015-04-08 16:46:08 -06:00
|
|
|
this.rootHostname =
|
|
|
|
this.rootDomain = '';
|
2015-05-28 12:47:19 -06:00
|
|
|
this.commitTimer = null;
|
|
|
|
this.gcTimer = null;
|
2016-08-25 13:47:18 -06:00
|
|
|
this.onGCBarrier = false;
|
2015-10-22 07:45:21 -06:00
|
|
|
this.netFiltering = true;
|
|
|
|
this.netFilteringReadTime = 0;
|
2015-04-08 16:46:08 -06:00
|
|
|
|
2018-02-26 11:59:16 -07:00
|
|
|
tabContexts.set(tabId, this);
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
TabContext.prototype.destroy = function() {
|
2018-02-26 11:59:16 -07:00
|
|
|
if ( vAPI.isBehindTheSceneTabId(this.tabId) ) { return; }
|
2015-05-28 12:47:19 -06:00
|
|
|
if ( this.gcTimer !== null ) {
|
|
|
|
clearTimeout(this.gcTimer);
|
|
|
|
this.gcTimer = null;
|
2015-04-08 16:46:08 -06:00
|
|
|
}
|
2018-02-26 11:59:16 -07:00
|
|
|
tabContexts.delete(this.tabId);
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
TabContext.prototype.onTab = function(tab) {
|
|
|
|
if ( tab ) {
|
2015-05-28 12:47:19 -06:00
|
|
|
this.gcTimer = vAPI.setTimeout(this.onGC.bind(this), gcPeriod);
|
2015-04-08 16:46:08 -06:00
|
|
|
} else {
|
|
|
|
this.destroy();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-05-28 12:47:19 -06:00
|
|
|
TabContext.prototype.onGC = function() {
|
|
|
|
if ( vAPI.isBehindTheSceneTabId(this.tabId) ) {
|
|
|
|
return;
|
|
|
|
}
|
2016-08-25 13:47:18 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/1713
|
|
|
|
// For unknown reasons, Firefox's setTimeout() will sometimes
|
|
|
|
// causes the callback function to be called immediately, bypassing
|
|
|
|
// the main event loop. For now this should prevent uBO from crashing
|
|
|
|
// as a result of the bad setTimeout() behavior.
|
|
|
|
if ( this.onGCBarrier ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
this.onGCBarrier = true;
|
|
|
|
this.gcTimer = null;
|
2015-05-28 12:47:19 -06:00
|
|
|
vAPI.tabs.get(this.tabId, this.onTab.bind(this));
|
2016-08-25 13:47:18 -06:00
|
|
|
this.onGCBarrier = false;
|
2015-05-28 12:47:19 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
// https://github.com/gorhill/uBlock/issues/248
|
|
|
|
// Stack entries have to be committed to stick. Non-committed stack
|
|
|
|
// entries are removed after a set delay.
|
|
|
|
TabContext.prototype.onCommit = function() {
|
2015-04-08 16:46:08 -06:00
|
|
|
if ( vAPI.isBehindTheSceneTabId(this.tabId) ) {
|
|
|
|
return;
|
|
|
|
}
|
2015-05-28 12:47:19 -06:00
|
|
|
this.commitTimer = null;
|
|
|
|
// Remove uncommitted entries at the top of the stack.
|
|
|
|
var i = this.stack.length;
|
|
|
|
while ( i-- ) {
|
|
|
|
if ( this.stack[i].committed ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-06-05 11:37:46 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/300
|
|
|
|
// If no committed entry was found, fall back on the bottom-most one
|
|
|
|
// as being the committed one by default.
|
|
|
|
if ( i === -1 && this.stack.length !== 0 ) {
|
|
|
|
this.stack[0].committed = true;
|
|
|
|
i = 0;
|
|
|
|
}
|
2015-05-28 12:47:19 -06:00
|
|
|
i += 1;
|
|
|
|
if ( i < this.stack.length ) {
|
|
|
|
this.stack.length = i;
|
|
|
|
this.update();
|
|
|
|
}
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
// This takes care of orphanized tab contexts. Can't be started for all
|
|
|
|
// contexts, as the behind-the-scene context is permanent -- so we do not
|
2015-07-16 16:15:57 -06:00
|
|
|
// want to flush it.
|
2015-04-08 16:46:08 -06:00
|
|
|
TabContext.prototype.autodestroy = function() {
|
|
|
|
if ( vAPI.isBehindTheSceneTabId(this.tabId) ) {
|
|
|
|
return;
|
|
|
|
}
|
2015-05-28 12:47:19 -06:00
|
|
|
this.gcTimer = vAPI.setTimeout(this.onGC.bind(this), gcPeriod);
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
2015-05-28 12:47:19 -06:00
|
|
|
// Update just force all properties to be updated to match the most recent
|
2015-04-08 16:46:08 -06:00
|
|
|
// root URL.
|
|
|
|
TabContext.prototype.update = function() {
|
2015-10-22 07:45:21 -06:00
|
|
|
this.netFilteringReadTime = 0;
|
2015-04-08 16:46:08 -06:00
|
|
|
if ( this.stack.length === 0 ) {
|
2018-12-13 10:30:54 -07:00
|
|
|
this.rawURL =
|
|
|
|
this.normalURL =
|
|
|
|
this.origin =
|
|
|
|
this.rootHostname =
|
|
|
|
this.rootDomain = '';
|
2015-05-28 12:47:19 -06:00
|
|
|
return;
|
2015-04-08 16:46:08 -06:00
|
|
|
}
|
2015-05-28 12:47:19 -06:00
|
|
|
var stackEntry = this.stack[this.stack.length - 1];
|
|
|
|
this.rawURL = stackEntry.url;
|
|
|
|
this.normalURL = µb.normalizePageURL(this.tabId, this.rawURL);
|
2018-12-13 10:30:54 -07:00
|
|
|
this.origin = µb.URI.originFromURI(this.normalURL);
|
|
|
|
this.rootHostname = µb.URI.hostnameFromURI(this.origin);
|
|
|
|
this.rootDomain =
|
|
|
|
µb.URI.domainFromHostname(this.rootHostname) ||
|
|
|
|
this.rootHostname;
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
// Called whenever a candidate root URL is spotted for the tab.
|
|
|
|
TabContext.prototype.push = function(url) {
|
|
|
|
if ( vAPI.isBehindTheSceneTabId(this.tabId) ) {
|
|
|
|
return;
|
|
|
|
}
|
2015-04-29 08:29:23 -06:00
|
|
|
var count = this.stack.length;
|
2015-05-28 12:47:19 -06:00
|
|
|
if ( count !== 0 && this.stack[count - 1].url === url ) {
|
2015-04-29 08:29:23 -06:00
|
|
|
return;
|
|
|
|
}
|
2015-05-28 12:47:19 -06:00
|
|
|
this.stack.push(new StackEntry(url));
|
2015-04-08 16:46:08 -06:00
|
|
|
this.update();
|
2015-12-01 13:07:22 -07:00
|
|
|
popupCandidateTest(this.tabId);
|
2015-11-15 06:56:36 -07:00
|
|
|
if ( this.commitTimer !== null ) {
|
2015-05-28 12:47:19 -06:00
|
|
|
clearTimeout(this.commitTimer);
|
|
|
|
}
|
2015-12-01 13:07:22 -07:00
|
|
|
this.commitTimer = vAPI.setTimeout(this.onCommit.bind(this), 500);
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
// This tells that the url is definitely the one to be associated with the
|
|
|
|
// tab, there is no longer any ambiguity about which root URL is really
|
|
|
|
// sitting in which tab.
|
|
|
|
TabContext.prototype.commit = function(url) {
|
2017-10-23 20:27:39 -06:00
|
|
|
if ( vAPI.isBehindTheSceneTabId(this.tabId) ) { return; }
|
|
|
|
if ( this.stack.length !== 0 ) {
|
|
|
|
var top = this.stack[this.stack.length - 1];
|
|
|
|
if ( top.url === url && top.committed ) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-04-08 16:46:08 -06:00
|
|
|
}
|
2015-05-28 12:47:19 -06:00
|
|
|
this.stack = [new StackEntry(url, true)];
|
2015-04-08 16:46:08 -06:00
|
|
|
this.update();
|
2017-10-23 20:27:39 -06:00
|
|
|
return true;
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
2015-10-22 07:45:21 -06:00
|
|
|
TabContext.prototype.getNetFilteringSwitch = function() {
|
|
|
|
if ( this.netFilteringReadTime > µb.netWhitelistModifyTime ) {
|
|
|
|
return this.netFiltering;
|
|
|
|
}
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/1078
|
|
|
|
// Use both the raw and normalized URLs.
|
|
|
|
this.netFiltering = µb.getNetFilteringSwitch(this.normalURL);
|
2015-10-23 10:52:51 -06:00
|
|
|
if ( this.netFiltering && this.rawURL !== this.normalURL && this.rawURL !== '' ) {
|
2015-10-22 07:45:21 -06:00
|
|
|
this.netFiltering = µb.getNetFilteringSwitch(this.rawURL);
|
|
|
|
}
|
|
|
|
this.netFilteringReadTime = Date.now();
|
|
|
|
return this.netFiltering;
|
|
|
|
};
|
|
|
|
|
2015-04-08 16:46:08 -06:00
|
|
|
// These are to be used for the API of the tab context manager.
|
|
|
|
|
|
|
|
var push = function(tabId, url) {
|
2018-02-26 11:59:16 -07:00
|
|
|
var entry = tabContexts.get(tabId);
|
2015-04-08 16:46:08 -06:00
|
|
|
if ( entry === undefined ) {
|
|
|
|
entry = new TabContext(tabId);
|
|
|
|
entry.autodestroy();
|
|
|
|
}
|
|
|
|
entry.push(url);
|
|
|
|
mostRecentRootDocURL = url;
|
|
|
|
mostRecentRootDocURLTimestamp = Date.now();
|
|
|
|
return entry;
|
|
|
|
};
|
|
|
|
|
2015-12-01 22:59:51 -07:00
|
|
|
// Find a tab context for a specific tab.
|
|
|
|
var lookup = function(tabId) {
|
2018-02-26 11:59:16 -07:00
|
|
|
return tabContexts.get(tabId) || null;
|
2015-12-01 22:59:51 -07:00
|
|
|
};
|
|
|
|
|
2015-04-08 16:46:08 -06:00
|
|
|
// Find a tab context for a specific tab. If none is found, attempt to
|
|
|
|
// fix this. When all fail, the behind-the-scene context is returned.
|
2015-12-01 22:59:51 -07:00
|
|
|
var mustLookup = function(tabId) {
|
2018-02-26 11:59:16 -07:00
|
|
|
var entry = tabContexts.get(tabId);
|
2015-04-08 16:46:08 -06:00
|
|
|
if ( entry !== undefined ) {
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/1025
|
|
|
|
// Google Hangout popup opens without a root frame. So for now we will
|
|
|
|
// just discard that best-guess root frame if it is too far in the
|
|
|
|
// future, at which point it ceases to be a "best guess".
|
|
|
|
if ( mostRecentRootDocURL !== '' && mostRecentRootDocURLTimestamp + 500 < Date.now() ) {
|
|
|
|
mostRecentRootDocURL = '';
|
|
|
|
}
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/1001
|
|
|
|
// Not a behind-the-scene request, yet no page store found for the
|
|
|
|
// tab id: we will thus bind the last-seen root document to the
|
|
|
|
// unbound tab. It's a guess, but better than ending up filtering
|
|
|
|
// nothing at all.
|
|
|
|
if ( mostRecentRootDocURL !== '' ) {
|
|
|
|
return push(tabId, mostRecentRootDocURL);
|
|
|
|
}
|
|
|
|
// If all else fail at finding a page store, re-categorize the
|
|
|
|
// request as behind-the-scene. At least this ensures that ultimately
|
|
|
|
// the user can still inspect/filter those net requests which were
|
|
|
|
// about to fall through the cracks.
|
|
|
|
// Example: Chromium + case #12 at
|
|
|
|
// http://raymondhill.net/ublock/popup.html
|
2018-02-26 11:59:16 -07:00
|
|
|
return tabContexts.get(vAPI.noTabId);
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
2016-09-13 09:25:24 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/1735
|
2016-09-13 09:56:13 -06:00
|
|
|
// Filter for popups if actually committing.
|
2015-04-08 16:46:08 -06:00
|
|
|
var commit = function(tabId, url) {
|
2018-02-26 11:59:16 -07:00
|
|
|
var entry = tabContexts.get(tabId);
|
2015-04-08 16:46:08 -06:00
|
|
|
if ( entry === undefined ) {
|
|
|
|
entry = push(tabId, url);
|
2017-10-23 20:27:39 -06:00
|
|
|
} else if ( entry.commit(url) ) {
|
2016-09-13 09:56:13 -06:00
|
|
|
popupCandidateTest(tabId);
|
2015-04-08 16:46:08 -06:00
|
|
|
}
|
|
|
|
return entry;
|
|
|
|
};
|
|
|
|
|
|
|
|
var exists = function(tabId) {
|
2018-02-26 11:59:16 -07:00
|
|
|
return tabContexts.get(tabId) !== undefined;
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
// Behind-the-scene tab context
|
|
|
|
(function() {
|
2018-12-13 10:30:54 -07:00
|
|
|
const entry = new TabContext(vAPI.noTabId);
|
2015-05-28 12:47:19 -06:00
|
|
|
entry.stack.push(new StackEntry('', true));
|
2015-04-08 16:46:08 -06:00
|
|
|
entry.rawURL = '';
|
|
|
|
entry.normalURL = µb.normalizePageURL(entry.tabId);
|
2018-12-13 10:30:54 -07:00
|
|
|
entry.origin = µb.URI.originFromURI(entry.normalURL);
|
|
|
|
entry.rootHostname = µb.URI.hostnameFromURI(entry.origin);
|
2015-04-08 16:46:08 -06:00
|
|
|
entry.rootDomain = µb.URI.domainFromHostname(entry.rootHostname);
|
|
|
|
})();
|
|
|
|
|
|
|
|
// Context object, typically to be used to feed filtering engines.
|
2016-06-30 20:03:29 -06:00
|
|
|
var contextJunkyard = [];
|
2015-04-08 16:46:08 -06:00
|
|
|
var Context = function(tabId) {
|
2016-06-30 20:03:29 -06:00
|
|
|
this.init(tabId);
|
|
|
|
};
|
|
|
|
Context.prototype.init = function(tabId) {
|
2015-04-08 16:46:08 -06:00
|
|
|
var tabContext = lookup(tabId);
|
|
|
|
this.rootHostname = tabContext.rootHostname;
|
|
|
|
this.rootDomain = tabContext.rootDomain;
|
2018-02-26 11:59:16 -07:00
|
|
|
this.pageHostname =
|
2015-04-08 16:46:08 -06:00
|
|
|
this.pageDomain =
|
|
|
|
this.requestURL =
|
2018-12-13 10:30:54 -07:00
|
|
|
this.origin =
|
2015-04-08 16:46:08 -06:00
|
|
|
this.requestHostname =
|
|
|
|
this.requestDomain = '';
|
2016-06-30 20:03:29 -06:00
|
|
|
return this;
|
|
|
|
};
|
|
|
|
Context.prototype.dispose = function() {
|
|
|
|
contextJunkyard.push(this);
|
2015-04-08 16:46:08 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
var createContext = function(tabId) {
|
2016-06-30 20:03:29 -06:00
|
|
|
if ( contextJunkyard.length ) {
|
|
|
|
return contextJunkyard.pop().init(tabId);
|
|
|
|
}
|
2015-04-08 16:46:08 -06:00
|
|
|
return new Context(tabId);
|
|
|
|
};
|
|
|
|
|
|
|
|
return {
|
|
|
|
push: push,
|
|
|
|
commit: commit,
|
|
|
|
lookup: lookup,
|
2015-12-01 22:59:51 -07:00
|
|
|
mustLookup: mustLookup,
|
2015-04-08 16:46:08 -06:00
|
|
|
exists: exists,
|
|
|
|
createContext: createContext
|
|
|
|
};
|
|
|
|
})();
|
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2014-10-17 13:44:19 -06:00
|
|
|
// When the DOM content of root frame is loaded, this means the tab
|
|
|
|
// content has changed.
|
2015-03-08 09:06:36 -06:00
|
|
|
|
2014-10-17 13:44:19 -06:00
|
|
|
vAPI.tabs.onNavigation = function(details) {
|
2018-05-17 05:33:21 -06:00
|
|
|
if ( details.frameId === 0 ) {
|
|
|
|
µb.tabContextManager.commit(details.tabId, details.url);
|
|
|
|
let pageStore = µb.bindTabToPageStats(details.tabId, 'tabCommitted');
|
|
|
|
if ( pageStore ) {
|
|
|
|
pageStore.journalAddRootFrame('committed', details.url);
|
|
|
|
}
|
2015-01-28 14:19:46 -07:00
|
|
|
}
|
2018-05-18 08:19:14 -06:00
|
|
|
if ( µb.canInjectScriptletsNow ) {
|
2018-05-22 07:26:49 -06:00
|
|
|
let pageStore = µb.pageStoreFromTabId(details.tabId);
|
|
|
|
if ( pageStore !== null && pageStore.getNetFilteringSwitch() ) {
|
|
|
|
µb.scriptletFilteringEngine.injectNow(details);
|
|
|
|
}
|
2018-05-18 08:19:14 -06:00
|
|
|
}
|
2014-10-17 13:44:19 -06:00
|
|
|
};
|
2014-09-08 11:45:03 -06:00
|
|
|
|
2015-03-08 09:06:36 -06:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2014-10-17 13:44:19 -06:00
|
|
|
// It may happen the URL in the tab changes, while the page's document
|
|
|
|
// stays the same (for instance, Google Maps). Without this listener,
|
|
|
|
// the extension icon won't be properly refreshed.
|
2015-03-08 09:06:36 -06:00
|
|
|
|
2014-10-17 13:44:19 -06:00
|
|
|
vAPI.tabs.onUpdated = function(tabId, changeInfo, tab) {
|
2018-05-22 07:26:49 -06:00
|
|
|
if ( !tab.url || tab.url === '' ) { return; }
|
|
|
|
if ( !changeInfo.url ) { return; }
|
2015-04-08 16:46:08 -06:00
|
|
|
µb.tabContextManager.commit(tabId, changeInfo.url);
|
|
|
|
µb.bindTabToPageStats(tabId, 'tabUpdated');
|
2014-10-17 13:44:19 -06:00
|
|
|
};
|
2014-06-23 16:42:43 -06:00
|
|
|
|
2015-03-08 09:06:36 -06:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2014-10-17 13:44:19 -06:00
|
|
|
vAPI.tabs.onClosed = function(tabId) {
|
2019-07-02 07:43:26 -06:00
|
|
|
if ( vAPI.isBehindTheSceneTabId(tabId) ) { return; }
|
2015-01-02 11:42:35 -07:00
|
|
|
µb.unbindTabFromPageStats(tabId);
|
2019-07-02 07:43:26 -06:00
|
|
|
µb.contextMenu.update();
|
2014-10-17 13:44:19 -06:00
|
|
|
};
|
2014-10-15 11:14:25 -06:00
|
|
|
|
2015-03-08 09:06:36 -06:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// https://github.com/gorhill/uBlock/issues/99
|
|
|
|
// https://github.com/gorhill/uBlock/issues/991
|
|
|
|
//
|
|
|
|
// popup:
|
|
|
|
// Test/close target URL
|
|
|
|
// popunder:
|
|
|
|
// Test/close opener URL
|
|
|
|
//
|
|
|
|
// popup filter match:
|
|
|
|
// 0 = false
|
|
|
|
// 1 = true
|
|
|
|
//
|
|
|
|
// opener: 0 0 1 1
|
|
|
|
// target: 0 1 0 1
|
|
|
|
// ---- ---- ---- ----
|
|
|
|
// result: a b c d
|
|
|
|
//
|
|
|
|
// a: do nothing
|
|
|
|
// b: close target
|
|
|
|
// c: close opener
|
|
|
|
// d: close target
|
|
|
|
|
2015-12-01 13:07:22 -07:00
|
|
|
vAPI.tabs.onPopupUpdated = (function() {
|
2015-11-30 16:50:22 -07:00
|
|
|
// The same context object will be reused everytime. This also allows to
|
|
|
|
// remember whether a popup or popunder was matched.
|
2018-12-13 10:30:54 -07:00
|
|
|
const fctxt = µBlock.filteringContext.setFilter(undefined);
|
2015-11-30 16:50:22 -07:00
|
|
|
|
2015-12-13 11:46:22 -07:00
|
|
|
// https://github.com/gorhill/uBlock/commit/1d448b85b2931412508aa01bf899e0b6f0033626#commitcomment-14944764
|
2017-11-27 12:48:01 -07:00
|
|
|
// See if two URLs are different, disregarding scheme -- because the
|
|
|
|
// scheme can be unilaterally changed by the browser.
|
|
|
|
// https://github.com/gorhill/uBlock/issues/1378
|
|
|
|
// Maybe no link element was clicked.
|
2017-11-27 15:09:22 -07:00
|
|
|
// https://github.com/gorhill/uBlock/issues/3287
|
|
|
|
// Do not bail out if the target URL has no hostname.
|
2018-12-13 10:30:54 -07:00
|
|
|
const areDifferentURLs = function(a, b) {
|
2017-09-05 17:49:48 -06:00
|
|
|
if ( b === '' ) { return true; }
|
2017-11-27 12:48:01 -07:00
|
|
|
if ( b.startsWith('about:') ) { return false; }
|
2018-12-13 10:30:54 -07:00
|
|
|
let pos = a.indexOf('://');
|
2017-09-05 17:49:48 -06:00
|
|
|
if ( pos === -1 ) { return false; }
|
2015-12-13 11:46:22 -07:00
|
|
|
a = a.slice(pos);
|
|
|
|
pos = b.indexOf('://');
|
2017-11-27 12:48:01 -07:00
|
|
|
if ( pos !== -1 ) {
|
|
|
|
b = b.slice(pos);
|
|
|
|
}
|
|
|
|
return b !== a;
|
2015-12-13 11:46:22 -07:00
|
|
|
};
|
|
|
|
|
2018-12-13 10:30:54 -07:00
|
|
|
const popupMatch = function(openerURL, targetURL, popupType) {
|
|
|
|
fctxt.setTabOriginFromURL(openerURL)
|
|
|
|
.setDocOriginFromURL(openerURL)
|
|
|
|
.setURL(targetURL)
|
|
|
|
.setType('popup');
|
|
|
|
let result;
|
2015-11-30 16:50:22 -07:00
|
|
|
|
2016-09-13 09:25:24 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/1735
|
|
|
|
// Do not bail out on `data:` URI, they are commonly used for popups.
|
2017-01-02 08:50:03 -07:00
|
|
|
// https://github.com/uBlockOrigin/uAssets/issues/255
|
|
|
|
// Do not bail out on `about:blank`: an `about:blank` popup can be
|
|
|
|
// opened, with the sole purpose to serve as an intermediary in
|
|
|
|
// a sequence of chained popups.
|
2017-01-18 11:01:13 -07:00
|
|
|
// https://github.com/uBlockOrigin/uAssets/issues/263#issuecomment-272615772
|
|
|
|
// Do not bail out, period: the static filtering engine must be
|
|
|
|
// able to examine all sorts of URLs for popup filtering purpose.
|
2015-12-13 11:46:22 -07:00
|
|
|
|
2017-01-18 11:01:13 -07:00
|
|
|
// Dynamic filtering makes sense only when we have a valid opener
|
|
|
|
// hostname.
|
|
|
|
// https://github.com/gorhill/uBlock/commit/1d448b85b2931412508aa01bf899e0b6f0033626#commitcomment-14944764
|
|
|
|
// Ignore bad target URL. On Firefox, an `about:blank` tab may be
|
|
|
|
// opened for a new tab before it is filled in with the real target
|
|
|
|
// URL.
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( fctxt.getTabHostname() !== '' && targetURL !== 'about:blank' ) {
|
2017-01-02 08:50:03 -07:00
|
|
|
// Check per-site switch first
|
2017-09-27 08:27:29 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/3060
|
|
|
|
// - The no-popups switch must apply only to popups, not to
|
|
|
|
// popunders.
|
|
|
|
if (
|
|
|
|
popupType === 'popup' &&
|
2018-12-13 10:30:54 -07:00
|
|
|
µb.sessionSwitches.evaluateZ(
|
|
|
|
'no-popups',
|
|
|
|
fctxt.getTabHostname()
|
|
|
|
)
|
2017-09-27 08:27:29 -06:00
|
|
|
) {
|
2018-12-13 10:30:54 -07:00
|
|
|
fctxt.filter = {
|
2018-09-03 12:06:49 -06:00
|
|
|
raw: 'no-popups: ' + µb.sessionSwitches.z + ' true',
|
2017-10-23 20:39:30 -06:00
|
|
|
result: 1,
|
|
|
|
source: 'switch'
|
2017-09-05 17:49:48 -06:00
|
|
|
};
|
|
|
|
return 1;
|
2015-11-30 16:50:22 -07:00
|
|
|
}
|
2015-06-14 05:46:58 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// https://github.com/gorhill/uBlock/issues/581
|
2017-09-27 08:27:29 -06:00
|
|
|
// Take into account popup-specific rules in dynamic URL
|
|
|
|
// filtering, OR generic allow rules.
|
|
|
|
result = µb.sessionURLFiltering.evaluateZ(
|
2018-12-13 10:30:54 -07:00
|
|
|
fctxt.getTabHostname(),
|
2017-09-27 08:27:29 -06:00
|
|
|
targetURL,
|
|
|
|
popupType
|
|
|
|
);
|
2015-11-30 16:50:22 -07:00
|
|
|
if (
|
2017-05-12 08:35:11 -06:00
|
|
|
result === 1 && µb.sessionURLFiltering.type === popupType ||
|
|
|
|
result === 2
|
2015-11-30 16:50:22 -07:00
|
|
|
) {
|
2018-12-13 10:30:54 -07:00
|
|
|
fctxt.filter = µb.sessionURLFiltering.toLogData();
|
2017-05-12 08:35:11 -06:00
|
|
|
return result;
|
2015-11-30 16:50:22 -07:00
|
|
|
}
|
2015-03-08 09:06:36 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// https://github.com/gorhill/uBlock/issues/581
|
2017-09-27 08:27:29 -06:00
|
|
|
// Take into account `allow` rules in dynamic filtering: `block`
|
|
|
|
// rules are ignored, as block rules are not meant to block
|
|
|
|
// specific types like `popup` (just like with static filters).
|
|
|
|
result = µb.sessionFirewall.evaluateCellZY(
|
2018-12-13 10:30:54 -07:00
|
|
|
fctxt.getTabHostname(),
|
|
|
|
fctxt.getHostname(),
|
2017-09-27 08:27:29 -06:00
|
|
|
popupType
|
|
|
|
);
|
2017-05-12 08:35:11 -06:00
|
|
|
if ( result === 2 ) {
|
2018-12-13 10:30:54 -07:00
|
|
|
fctxt.filter = µb.sessionFirewall.toLogData();
|
2017-05-12 08:35:11 -06:00
|
|
|
return 2;
|
2015-11-30 16:50:22 -07:00
|
|
|
}
|
|
|
|
}
|
2015-03-27 11:00:55 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/323
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/1142
|
|
|
|
// Don't block if uBlock is turned off in popup's context
|
2017-05-12 08:35:11 -06:00
|
|
|
if ( µb.getNetFilteringSwitch(targetURL) ) {
|
2019-05-22 15:51:03 -06:00
|
|
|
fctxt.type = popupType;
|
|
|
|
result = µb.staticNetFilteringEngine.matchString(fctxt, 0b0001);
|
2017-05-12 08:35:11 -06:00
|
|
|
if ( result !== 0 ) {
|
2018-12-13 10:30:54 -07:00
|
|
|
fctxt.filter = µb.staticNetFilteringEngine.toLogData();
|
2017-05-12 08:35:11 -06:00
|
|
|
return result;
|
|
|
|
}
|
2015-03-27 11:00:55 -06:00
|
|
|
}
|
|
|
|
|
2017-05-12 08:35:11 -06:00
|
|
|
return 0;
|
2015-03-27 12:59:17 -06:00
|
|
|
};
|
|
|
|
|
2018-12-13 10:30:54 -07:00
|
|
|
const mapPopunderResult = function(popunderURL, popunderHostname, result) {
|
2017-05-12 08:35:11 -06:00
|
|
|
if (
|
2018-12-13 10:30:54 -07:00
|
|
|
fctxt.filter === undefined ||
|
|
|
|
fctxt.filter !== 'static' ||
|
|
|
|
fctxt.filter.token === µb.staticNetFilteringEngine.noTokenHash
|
2017-05-12 08:35:11 -06:00
|
|
|
) {
|
|
|
|
return 0;
|
2016-02-26 07:48:43 -07:00
|
|
|
}
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( fctxt.filter.token === µb.staticNetFilteringEngine.dotTokenHash ) {
|
2017-05-19 06:45:19 -06:00
|
|
|
return result;
|
|
|
|
}
|
2018-12-13 10:30:54 -07:00
|
|
|
const re = new RegExp(fctxt.filter.regex, 'i');
|
|
|
|
const matches = re.exec(popunderURL);
|
2017-07-09 08:39:23 -06:00
|
|
|
if ( matches === null ) { return 0; }
|
2018-12-13 10:30:54 -07:00
|
|
|
const beg = matches.index;
|
|
|
|
const end = beg + matches[0].length;
|
|
|
|
const pos = popunderURL.indexOf(popunderHostname);
|
2017-07-09 08:39:23 -06:00
|
|
|
if ( pos === -1 ) { return 0; }
|
2016-03-12 08:48:31 -07:00
|
|
|
// https://github.com/gorhill/uBlock/issues/1471
|
2016-08-16 10:12:35 -06:00
|
|
|
// We test whether the opener hostname as at least one character
|
|
|
|
// within matched portion of URL.
|
|
|
|
// https://github.com/gorhill/uBlock/issues/1903
|
|
|
|
// Ignore filters which cause a match before the start of the
|
|
|
|
// hostname in the URL.
|
2017-05-12 08:35:11 -06:00
|
|
|
return beg >= pos && beg < pos + popunderHostname.length && end > pos
|
|
|
|
? result
|
|
|
|
: 0;
|
2016-04-28 09:28:08 -06:00
|
|
|
};
|
|
|
|
|
2018-12-13 10:30:54 -07:00
|
|
|
const popunderMatch = function(openerURL, targetURL) {
|
|
|
|
let result = popupMatch(targetURL, openerURL, 'popunder');
|
|
|
|
if ( result === 1 ) { return result; }
|
|
|
|
|
2016-04-28 09:28:08 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/1010#issuecomment-186824878
|
|
|
|
// Check the opener tab as if it were the newly opened tab: if there
|
|
|
|
// is a hit against a popup filter, and if the matching filter is not
|
|
|
|
// a broad one, we will consider the opener tab to be a popunder tab.
|
|
|
|
// For now, a "broad" filter is one which does not touch any part of
|
|
|
|
// the hostname part of the opener URL.
|
2018-12-13 10:30:54 -07:00
|
|
|
let popunderURL = openerURL,
|
2017-05-12 08:35:11 -06:00
|
|
|
popunderHostname = µb.URI.hostnameFromURI(popunderURL);
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( popunderHostname === '' ) { return 0; }
|
|
|
|
|
2016-04-28 09:28:08 -06:00
|
|
|
result = mapPopunderResult(
|
|
|
|
popunderURL,
|
|
|
|
popunderHostname,
|
2017-09-26 05:54:06 -06:00
|
|
|
popupMatch(targetURL, popunderURL, 'popup')
|
2016-04-28 09:28:08 -06:00
|
|
|
);
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( result !== 0 ) { return result; }
|
|
|
|
|
2016-04-28 09:28:08 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/1598
|
2018-12-13 10:30:54 -07:00
|
|
|
// Try to find a match against origin part of the opener URL.
|
2016-04-28 09:28:08 -06:00
|
|
|
popunderURL = µb.URI.originFromURI(popunderURL);
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( popunderURL === '' ) { return 0; }
|
|
|
|
|
2016-04-28 09:28:08 -06:00
|
|
|
return mapPopunderResult(
|
|
|
|
popunderURL,
|
|
|
|
popunderHostname,
|
2017-09-26 05:54:06 -06:00
|
|
|
popupMatch(targetURL, popunderURL, 'popup')
|
2016-04-28 09:28:08 -06:00
|
|
|
);
|
2016-02-26 07:48:43 -07:00
|
|
|
};
|
|
|
|
|
2017-10-13 07:33:02 -06:00
|
|
|
return function(targetTabId, openerDetails) {
|
2015-12-01 13:07:22 -07:00
|
|
|
// Opener details.
|
2018-12-13 10:30:54 -07:00
|
|
|
const openerTabId = openerDetails.tabId;
|
|
|
|
let tabContext = µb.tabContextManager.lookup(openerTabId);
|
2015-12-01 22:59:51 -07:00
|
|
|
if ( tabContext === null ) { return; }
|
2018-12-13 10:30:54 -07:00
|
|
|
const openerURL = tabContext.rawURL;
|
2015-12-01 22:59:51 -07:00
|
|
|
if ( openerURL === '' ) { return; }
|
2015-12-01 13:07:22 -07:00
|
|
|
|
|
|
|
// Popup details.
|
|
|
|
tabContext = µb.tabContextManager.lookup(targetTabId);
|
2015-12-01 22:59:51 -07:00
|
|
|
if ( tabContext === null ) { return; }
|
2018-12-13 10:30:54 -07:00
|
|
|
let targetURL = tabContext.rawURL;
|
2015-12-01 22:59:51 -07:00
|
|
|
if ( targetURL === '' ) { return; }
|
2015-03-27 11:00:55 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// https://github.com/gorhill/uBlock/issues/341
|
|
|
|
// Allow popups if uBlock is turned off in opener's context.
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( µb.getNetFilteringSwitch(openerURL) === false ) { return; }
|
2015-08-17 15:10:15 -06:00
|
|
|
|
2016-04-05 07:59:23 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/1538
|
2018-12-13 10:30:54 -07:00
|
|
|
if (
|
|
|
|
µb.getNetFilteringSwitch(µb.normalizePageURL(
|
|
|
|
openerTabId,
|
|
|
|
openerURL)
|
|
|
|
) === false
|
|
|
|
) {
|
2016-04-05 07:59:23 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// If the page URL is that of our "blocked page" URL, extract the URL of
|
|
|
|
// the page which was blocked.
|
2015-12-15 08:40:40 -07:00
|
|
|
if ( targetURL.startsWith(vAPI.getURL('document-blocked.html')) ) {
|
2018-12-13 10:30:54 -07:00
|
|
|
const matches = /details=([^&]+)/.exec(targetURL);
|
2015-11-30 16:50:22 -07:00
|
|
|
if ( matches !== null ) {
|
|
|
|
targetURL = JSON.parse(atob(matches[1])).url;
|
|
|
|
}
|
2015-08-17 15:10:15 -06:00
|
|
|
}
|
|
|
|
|
2017-09-26 05:54:06 -06:00
|
|
|
// Popup test.
|
2018-12-13 10:30:54 -07:00
|
|
|
let popupType = 'popup',
|
2017-09-26 05:54:06 -06:00
|
|
|
result = 0;
|
2017-09-05 17:49:48 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/2919
|
2017-09-26 05:54:06 -06:00
|
|
|
// - If the target tab matches a clicked link, assume it's legit.
|
2017-10-13 07:33:02 -06:00
|
|
|
if ( areDifferentURLs(targetURL, openerDetails.trustedURL) ) {
|
2017-09-05 17:49:48 -06:00
|
|
|
result = popupMatch(openerURL, targetURL, 'popup');
|
2017-09-26 05:54:06 -06:00
|
|
|
}
|
2014-10-15 11:14:25 -06:00
|
|
|
|
2015-12-13 17:04:58 -07:00
|
|
|
// Popunder test.
|
2017-10-13 07:33:02 -06:00
|
|
|
if ( result === 0 && openerDetails.popunder ) {
|
2016-02-26 07:48:43 -07:00
|
|
|
result = popunderMatch(openerURL, targetURL);
|
2017-05-12 08:35:11 -06:00
|
|
|
if ( result === 1 ) {
|
2016-02-26 07:48:43 -07:00
|
|
|
popupType = 'popunder';
|
|
|
|
}
|
2015-11-30 16:50:22 -07:00
|
|
|
}
|
2015-06-14 05:46:58 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// Log only for when there was a hit against an actual filter (allow or block).
|
2017-07-09 04:58:34 -06:00
|
|
|
// https://github.com/gorhill/uBlock/issues/2776
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( µb.logger.enabled ) {
|
2019-01-12 14:36:20 -07:00
|
|
|
fctxt.setRealm('network').setType(popupType);
|
2018-12-13 10:30:54 -07:00
|
|
|
if ( popupType === 'popup' ) {
|
|
|
|
fctxt.setURL(targetURL)
|
|
|
|
.setTabId(openerTabId)
|
|
|
|
.setTabOriginFromURL(openerURL)
|
|
|
|
.setDocOriginFromURL(openerURL);
|
|
|
|
} else {
|
|
|
|
fctxt.setURL(openerURL)
|
|
|
|
.setTabId(targetTabId)
|
|
|
|
.setTabOriginFromURL(targetURL)
|
|
|
|
.setDocOriginFromURL(targetURL);
|
|
|
|
}
|
|
|
|
fctxt.toLogger();
|
2015-11-30 16:50:22 -07:00
|
|
|
}
|
2014-10-15 11:14:25 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// Not blocked
|
2017-05-12 08:35:11 -06:00
|
|
|
if ( result !== 1 ) {
|
2015-11-30 16:50:22 -07:00
|
|
|
return;
|
|
|
|
}
|
2014-10-17 13:44:19 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// Only if a popup was blocked do we report it in the dynamic
|
|
|
|
// filtering pane.
|
2018-12-13 10:30:54 -07:00
|
|
|
const pageStore = µb.pageStoreFromTabId(openerTabId);
|
2015-11-30 16:50:22 -07:00
|
|
|
if ( pageStore ) {
|
2018-12-13 10:30:54 -07:00
|
|
|
pageStore.journalAddRequest(fctxt.getHostname(), result);
|
2016-01-04 08:48:28 -07:00
|
|
|
pageStore.popupBlockedCount += 1;
|
2015-11-30 16:50:22 -07:00
|
|
|
}
|
2014-10-24 08:14:25 -06:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// Blocked
|
|
|
|
if ( µb.userSettings.showIconBadge ) {
|
2018-05-08 07:43:25 -06:00
|
|
|
µb.updateToolbarIcon(openerTabId, 0x02);
|
2015-11-30 16:50:22 -07:00
|
|
|
}
|
2014-12-01 12:45:00 -07:00
|
|
|
|
2015-11-30 16:50:22 -07:00
|
|
|
// It is a popup, block and remove the tab.
|
2016-02-27 10:04:28 -07:00
|
|
|
if ( popupType === 'popup' ) {
|
|
|
|
µb.unbindTabFromPageStats(targetTabId);
|
2016-11-16 14:08:03 -07:00
|
|
|
vAPI.tabs.remove(targetTabId, false);
|
2016-02-27 10:04:28 -07:00
|
|
|
} else {
|
|
|
|
µb.unbindTabFromPageStats(openerTabId);
|
|
|
|
vAPI.tabs.remove(openerTabId, true);
|
2016-02-26 07:48:43 -07:00
|
|
|
}
|
2015-11-30 16:50:22 -07:00
|
|
|
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
})();
|
2014-10-17 13:44:19 -06:00
|
|
|
|
|
|
|
vAPI.tabs.registerListeners();
|
2014-10-15 11:14:25 -06:00
|
|
|
|
2014-06-23 16:42:43 -06:00
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
// Create an entry for the tab if it doesn't exist.
|
|
|
|
|
2015-04-08 16:46:08 -06:00
|
|
|
µb.bindTabToPageStats = function(tabId, context) {
|
2018-05-08 07:43:25 -06:00
|
|
|
this.updateToolbarIcon(tabId, 0x03);
|
2014-07-06 17:14:32 -06:00
|
|
|
|
2014-07-14 09:24:59 -06:00
|
|
|
// Do not create a page store for URLs which are of no interests
|
2015-04-08 16:46:08 -06:00
|
|
|
if ( µb.tabContextManager.exists(tabId) === false ) {
|
2014-07-14 09:24:59 -06:00
|
|
|
this.unbindTabFromPageStats(tabId);
|
2014-06-23 16:42:43 -06:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2015-01-17 05:19:48 -07:00
|
|
|
// Reuse page store if one exists: this allows to guess if a tab is a popup
|
2018-02-26 11:59:16 -07:00
|
|
|
var pageStore = this.pageStores.get(tabId);
|
2014-08-02 09:40:27 -06:00
|
|
|
|
2015-01-17 05:19:48 -07:00
|
|
|
// Tab is not bound
|
2018-02-26 11:59:16 -07:00
|
|
|
if ( pageStore === undefined ) {
|
2015-05-18 06:12:35 -06:00
|
|
|
this.updateTitle(tabId);
|
2018-02-26 11:59:16 -07:00
|
|
|
pageStore = this.PageStore.factory(tabId, context);
|
|
|
|
this.pageStores.set(tabId, pageStore);
|
2018-05-27 06:31:17 -06:00
|
|
|
this.pageStoresToken = Date.now();
|
2018-02-26 11:59:16 -07:00
|
|
|
return pageStore;
|
2015-01-17 05:19:48 -07:00
|
|
|
}
|
|
|
|
|
2015-04-06 19:26:05 -06:00
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/516
|
2016-10-08 08:15:31 -06:00
|
|
|
// Never rebind behind-the-scene scope.
|
2015-04-05 10:03:14 -06:00
|
|
|
if ( vAPI.isBehindTheSceneTabId(tabId) ) {
|
|
|
|
return pageStore;
|
|
|
|
}
|
|
|
|
|
2016-10-08 08:15:31 -06:00
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/516
|
|
|
|
// If context is 'beforeRequest', do not rebind, wait for confirmation.
|
2015-01-17 05:19:48 -07:00
|
|
|
if ( context === 'beforeRequest' ) {
|
|
|
|
return pageStore;
|
|
|
|
}
|
|
|
|
|
2015-01-24 10:34:36 -07:00
|
|
|
// Rebind according to context. We rebind even if the URL did not change,
|
|
|
|
// as maybe the tab was force-reloaded, in which case the page stats must
|
|
|
|
// be all reset.
|
2015-04-08 16:46:08 -06:00
|
|
|
pageStore.reuse(context);
|
2014-06-23 16:42:43 -06:00
|
|
|
|
2015-05-18 06:12:35 -06:00
|
|
|
this.updateTitle(tabId);
|
|
|
|
this.pageStoresToken = Date.now();
|
|
|
|
|
2014-06-23 16:42:43 -06:00
|
|
|
return pageStore;
|
|
|
|
};
|
|
|
|
|
2015-04-08 16:46:08 -06:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
µb.unbindTabFromPageStats = function(tabId) {
|
2014-07-16 15:20:11 -06:00
|
|
|
//console.debug('µBlock> unbindTabFromPageStats(%d)', tabId);
|
2018-02-26 11:59:16 -07:00
|
|
|
var pageStore = this.pageStores.get(tabId);
|
2014-09-14 14:20:40 -06:00
|
|
|
if ( pageStore !== undefined ) {
|
|
|
|
pageStore.dispose();
|
2018-02-26 11:59:16 -07:00
|
|
|
this.pageStores.delete(tabId);
|
2015-05-18 06:12:35 -06:00
|
|
|
this.pageStoresToken = Date.now();
|
2014-09-14 14:20:40 -06:00
|
|
|
}
|
2014-06-23 16:42:43 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
µb.pageStoreFromTabId = function(tabId) {
|
2018-02-26 11:59:16 -07:00
|
|
|
return this.pageStores.get(tabId) || null;
|
2014-06-23 16:42:43 -06:00
|
|
|
};
|
|
|
|
|
2016-03-22 08:19:41 -06:00
|
|
|
µb.mustPageStoreFromTabId = function(tabId) {
|
2018-02-26 11:59:16 -07:00
|
|
|
return this.pageStores.get(tabId) || this.pageStores.get(vAPI.noTabId);
|
2016-03-22 08:19:41 -06:00
|
|
|
};
|
|
|
|
|
2015-01-19 16:42:58 -07:00
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
// Permanent page store for behind-the-scene requests. Must never be removed.
|
|
|
|
|
2018-02-26 11:59:16 -07:00
|
|
|
(function() {
|
2018-12-13 10:30:54 -07:00
|
|
|
const pageStore = µb.PageStore.factory(vAPI.noTabId);
|
2018-02-26 11:59:16 -07:00
|
|
|
µb.pageStores.set(pageStore.tabId, pageStore);
|
|
|
|
pageStore.title = vAPI.i18n('logBehindTheScene');
|
|
|
|
})();
|
2015-01-19 16:42:58 -07:00
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
/******************************************************************************/
|
2015-05-16 08:15:02 -06:00
|
|
|
|
2015-11-29 15:06:58 -07:00
|
|
|
// Update visual of extension icon.
|
|
|
|
|
2018-05-08 07:43:25 -06:00
|
|
|
µb.updateToolbarIcon = (function() {
|
|
|
|
let tabIdToDetails = new Map();
|
2015-11-29 15:06:58 -07:00
|
|
|
|
2018-05-08 07:43:25 -06:00
|
|
|
let updateBadge = function(tabId) {
|
|
|
|
let parts = tabIdToDetails.get(tabId);
|
|
|
|
tabIdToDetails.delete(tabId);
|
2015-11-29 15:06:58 -07:00
|
|
|
|
2018-05-08 07:43:25 -06:00
|
|
|
let state = 0;
|
|
|
|
let badge = '';
|
2015-11-29 15:06:58 -07:00
|
|
|
|
2018-05-08 07:43:25 -06:00
|
|
|
let pageStore = this.pageStoreFromTabId(tabId);
|
2015-11-29 15:06:58 -07:00
|
|
|
if ( pageStore !== null ) {
|
2018-05-08 07:43:25 -06:00
|
|
|
state = pageStore.getNetFilteringSwitch() ? 1 : 0;
|
|
|
|
if (
|
|
|
|
state === 1 &&
|
|
|
|
this.userSettings.showIconBadge &&
|
|
|
|
pageStore.perLoadBlockedRequestCount
|
|
|
|
) {
|
2015-12-29 09:34:41 -07:00
|
|
|
badge = this.formatCount(pageStore.perLoadBlockedRequestCount);
|
2015-11-29 15:06:58 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-08 07:43:25 -06:00
|
|
|
vAPI.setIcon(tabId, state, badge, parts);
|
2015-11-29 15:06:58 -07:00
|
|
|
};
|
|
|
|
|
2018-05-08 07:43:25 -06:00
|
|
|
// parts: bit 0 = icon
|
|
|
|
// bit 1 = badge
|
|
|
|
|
|
|
|
return function(tabId, newParts) {
|
2018-02-26 11:59:16 -07:00
|
|
|
if ( vAPI.isBehindTheSceneTabId(tabId) ) { return; }
|
2018-05-08 07:43:25 -06:00
|
|
|
if ( newParts === undefined ) { newParts = 0x03; }
|
|
|
|
let currentParts = tabIdToDetails.get(tabId);
|
|
|
|
if ( currentParts === newParts ) { return; }
|
|
|
|
if ( currentParts === undefined ) {
|
|
|
|
vAPI.setTimeout(updateBadge.bind(this, tabId), 701);
|
|
|
|
} else {
|
|
|
|
newParts |= currentParts;
|
|
|
|
}
|
|
|
|
tabIdToDetails.set(tabId, newParts);
|
2015-11-29 15:06:58 -07:00
|
|
|
};
|
|
|
|
})();
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-05-16 08:15:02 -06:00
|
|
|
µb.updateTitle = (function() {
|
2018-02-26 11:59:16 -07:00
|
|
|
var tabIdToTimer = new Map();
|
2015-05-16 08:15:02 -06:00
|
|
|
var delay = 499;
|
|
|
|
|
2018-02-26 11:59:16 -07:00
|
|
|
var tryAgain = function(entry) {
|
|
|
|
if ( entry.count === 1 ) { return false; }
|
|
|
|
entry.count -= 1;
|
|
|
|
tabIdToTimer.set(
|
|
|
|
entry.tabId,
|
|
|
|
vAPI.setTimeout(updateTitle.bind(null, entry), delay)
|
|
|
|
);
|
2015-05-16 08:15:02 -06:00
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
2018-02-26 11:59:16 -07:00
|
|
|
var onTabReady = function(entry, tab) {
|
|
|
|
if ( !tab ) { return; }
|
|
|
|
var µb = µBlock;
|
|
|
|
var pageStore = µb.pageStoreFromTabId(entry.tabId);
|
|
|
|
if ( pageStore === null ) { return; }
|
2015-05-18 06:12:35 -06:00
|
|
|
// Firefox needs this: if you detach a tab, the new tab won't have
|
|
|
|
// its rawURL set. Concretely, this causes the logger to report an
|
|
|
|
// entry to itself in the logger's tab selector.
|
|
|
|
// TODO: Investigate for a fix vAPI-side.
|
|
|
|
pageStore.rawURL = tab.url;
|
2018-02-26 11:59:16 -07:00
|
|
|
µb.pageStoresToken = Date.now();
|
|
|
|
if ( !tab.title && tryAgain(entry) ) { return; }
|
2015-05-26 15:16:16 -06:00
|
|
|
// https://github.com/gorhill/uMatrix/issues/225
|
|
|
|
// Sometimes title changes while page is loading.
|
|
|
|
var settled = tab.title && tab.title === pageStore.title;
|
2015-05-16 08:15:02 -06:00
|
|
|
pageStore.title = tab.title || tab.url || '';
|
2018-02-26 11:59:16 -07:00
|
|
|
if ( !settled ) {
|
|
|
|
tryAgain(entry);
|
2015-05-26 15:16:16 -06:00
|
|
|
}
|
2015-05-16 08:15:02 -06:00
|
|
|
};
|
|
|
|
|
2018-02-26 11:59:16 -07:00
|
|
|
var updateTitle = function(entry) {
|
|
|
|
tabIdToTimer.delete(entry.tabId);
|
|
|
|
vAPI.tabs.get(entry.tabId, onTabReady.bind(null, entry));
|
2015-05-16 08:15:02 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
return function(tabId) {
|
2018-02-26 11:59:16 -07:00
|
|
|
if ( vAPI.isBehindTheSceneTabId(tabId) ) { return; }
|
|
|
|
var timer = tabIdToTimer.get(tabId);
|
|
|
|
if ( timer !== undefined ) {
|
|
|
|
clearTimeout(timer);
|
2015-05-16 08:15:02 -06:00
|
|
|
}
|
2018-02-26 11:59:16 -07:00
|
|
|
tabIdToTimer.set(
|
|
|
|
tabId,
|
|
|
|
vAPI.setTimeout(
|
|
|
|
updateTitle.bind(null, { tabId: tabId, count: 5 }),
|
|
|
|
delay
|
|
|
|
)
|
|
|
|
);
|
2015-05-16 08:15:02 -06:00
|
|
|
};
|
|
|
|
})();
|
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
// Stale page store entries janitor
|
2015-04-06 19:26:05 -06:00
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/455
|
2015-01-02 11:42:35 -07:00
|
|
|
|
|
|
|
var pageStoreJanitorPeriod = 15 * 60 * 1000;
|
|
|
|
var pageStoreJanitorSampleAt = 0;
|
|
|
|
var pageStoreJanitorSampleSize = 10;
|
|
|
|
|
|
|
|
var pageStoreJanitor = function() {
|
|
|
|
var vapiTabs = vAPI.tabs;
|
2018-02-26 11:59:16 -07:00
|
|
|
var tabIds = Array.from(µb.pageStores.keys()).sort();
|
2015-01-02 11:42:35 -07:00
|
|
|
var checkTab = function(tabId) {
|
|
|
|
vapiTabs.get(tabId, function(tab) {
|
|
|
|
if ( !tab ) {
|
|
|
|
µb.unbindTabFromPageStats(tabId);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
|
|
if ( pageStoreJanitorSampleAt >= tabIds.length ) {
|
|
|
|
pageStoreJanitorSampleAt = 0;
|
|
|
|
}
|
|
|
|
var n = Math.min(pageStoreJanitorSampleAt + pageStoreJanitorSampleSize, tabIds.length);
|
|
|
|
for ( var i = pageStoreJanitorSampleAt; i < n; i++ ) {
|
2018-02-26 11:59:16 -07:00
|
|
|
var tabId = tabIds[i];
|
|
|
|
if ( vAPI.isBehindTheSceneTabId(tabId) ) { continue; }
|
2015-01-19 16:42:58 -07:00
|
|
|
checkTab(tabId);
|
2015-01-02 11:42:35 -07:00
|
|
|
}
|
|
|
|
pageStoreJanitorSampleAt = n;
|
|
|
|
|
2015-05-17 11:02:56 -06:00
|
|
|
vAPI.setTimeout(pageStoreJanitor, pageStoreJanitorPeriod);
|
2015-01-02 11:42:35 -07:00
|
|
|
};
|
|
|
|
|
2015-05-17 11:02:56 -06:00
|
|
|
vAPI.setTimeout(pageStoreJanitor, pageStoreJanitorPeriod);
|
2015-01-02 11:42:35 -07:00
|
|
|
|
2014-06-23 16:42:43 -06:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-01-02 11:42:35 -07:00
|
|
|
})();
|
|
|
|
|
|
|
|
/******************************************************************************/
|