mirror of
https://github.com/gorhill/uBlock.git
synced 2024-11-06 10:52:38 +01:00
73ce4e6bcf
Related issue: https://github.com/uBlockOrigin/uBlock-issues/issues/3394 When the "No large media elements" per-site switch is toggled on, it will also act to prevent autoplay of video/audio media, regardless of their size. This also works for xhr-based media streaming. If blocking by size is not desirable while blocking autoplay is desired, one can toggle on "No large media elements" switch while setting "Block media elements larger than ..." to a very high value.
1815 lines
62 KiB
JavaScript
1815 lines
62 KiB
JavaScript
/*******************************************************************************
|
|
|
|
uBlock Origin - a comprehensive, efficient content blocker
|
|
Copyright (C) 2014-2015 The uBlock Origin authors
|
|
Copyright (C) 2014-present Raymond Hill
|
|
|
|
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
|
|
*/
|
|
|
|
// For background page
|
|
|
|
/******************************************************************************/
|
|
|
|
import { ubolog } from './console.js';
|
|
import webext from './webext.js';
|
|
|
|
/******************************************************************************/
|
|
|
|
const manifest = browser.runtime.getManifest();
|
|
|
|
vAPI.cantWebsocket =
|
|
browser.webRequest.ResourceType instanceof Object === false ||
|
|
browser.webRequest.ResourceType.WEBSOCKET !== 'websocket';
|
|
|
|
vAPI.canWASM = vAPI.webextFlavor.soup.has('chromium') === false;
|
|
if ( vAPI.canWASM === false ) {
|
|
const csp = manifest.content_security_policy;
|
|
vAPI.canWASM = csp !== undefined && csp.indexOf("'wasm-unsafe-eval'") !== -1;
|
|
}
|
|
|
|
vAPI.supportsUserStylesheets = vAPI.webextFlavor.soup.has('user_stylesheet');
|
|
|
|
const hasOwnProperty = (o, p) =>
|
|
Object.prototype.hasOwnProperty.call(o, p);
|
|
|
|
/******************************************************************************/
|
|
|
|
vAPI.app = {
|
|
name: manifest.name.replace(/ dev\w+ build/, ''),
|
|
version: (( ) => {
|
|
let version = manifest.version;
|
|
const match = /(\d+\.\d+\.\d+)(?:\.(\d+))?/.exec(version);
|
|
if ( match && match[2] ) {
|
|
const v = parseInt(match[2], 10);
|
|
version = match[1] + (v < 100 ? 'b' + v : 'rc' + (v - 100));
|
|
}
|
|
return version;
|
|
})(),
|
|
|
|
intFromVersion: function(s) {
|
|
const parts = s.match(/(?:^|\.|b|rc)\d+/g);
|
|
if ( parts === null ) { return 0; }
|
|
let vint = 0;
|
|
for ( let i = 0; i < 4; i++ ) {
|
|
const pstr = parts[i] || '';
|
|
let pint;
|
|
if ( pstr === '' ) {
|
|
pint = 0;
|
|
} else if ( pstr.startsWith('.') || pstr.startsWith('b') ) {
|
|
pint = parseInt(pstr.slice(1), 10);
|
|
} else if ( pstr.startsWith('rc') ) {
|
|
pint = parseInt(pstr.slice(2), 10) + 100;
|
|
} else {
|
|
pint = parseInt(pstr, 10);
|
|
}
|
|
vint = vint * 1000 + pint;
|
|
}
|
|
return vint;
|
|
},
|
|
|
|
restart: function() {
|
|
browser.runtime.reload();
|
|
},
|
|
};
|
|
|
|
/******************************************************************************/
|
|
|
|
// Generate segments of random six alphanumeric characters, thus one segment
|
|
// is a value out of 36^6 = over 2x10^9 values.
|
|
|
|
vAPI.generateSecret = (size = 1) => {
|
|
let secret = '';
|
|
while ( size-- ) {
|
|
secret += (Math.floor(Math.random() * 2176782336) + 2176782336).toString(36).slice(1);
|
|
}
|
|
return secret;
|
|
};
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/API/storage/session
|
|
*
|
|
* Session (in-memory) storage is promise-based in all browsers, no need for
|
|
* a webext polyfill. However, not all browsers supports it in MV2.
|
|
*
|
|
* */
|
|
|
|
vAPI.sessionStorage = browser.storage.session || {
|
|
get() {
|
|
return Promise.resolve();
|
|
},
|
|
set() {
|
|
return Promise.resolve();
|
|
},
|
|
remove() {
|
|
return Promise.resolve();
|
|
},
|
|
clear() {
|
|
return Promise.resolve();
|
|
},
|
|
unavailable: true,
|
|
};
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Data written to and read from storage.local will be mirrored to in-memory
|
|
* storage.session.
|
|
*
|
|
* Data read from storage.local will be first fetched from storage.session,
|
|
* then if not available, read from storage.local.
|
|
*
|
|
* */
|
|
|
|
vAPI.storage = {
|
|
get(key, ...args) {
|
|
return webext.storage.local.get(key, ...args).catch(reason => {
|
|
console.log(reason);
|
|
});
|
|
},
|
|
set(...args) {
|
|
return webext.storage.local.set(...args).catch(reason => {
|
|
console.log(reason);
|
|
});
|
|
},
|
|
remove(...args) {
|
|
return webext.storage.local.remove(...args).catch(reason => {
|
|
console.log(reason);
|
|
});
|
|
},
|
|
clear(...args) {
|
|
return webext.storage.local.clear(...args).catch(reason => {
|
|
console.log(reason);
|
|
});
|
|
},
|
|
QUOTA_BYTES: browser.storage.local.QUOTA_BYTES,
|
|
};
|
|
|
|
// Not all platforms support getBytesInUse
|
|
if ( webext.storage.local.getBytesInUse instanceof Function ) {
|
|
vAPI.storage.getBytesInUse = function(...args) {
|
|
return webext.storage.local.getBytesInUse(...args).catch(reason => {
|
|
console.log(reason);
|
|
});
|
|
};
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://github.com/gorhill/uMatrix/issues/234
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/privacy/network
|
|
|
|
// https://github.com/gorhill/uBlock/issues/2048
|
|
// Do not mess up with existing settings if not assigning them stricter
|
|
// values.
|
|
|
|
vAPI.browserSettings = (( ) => {
|
|
// Not all platforms support `browser.privacy`.
|
|
const bp = webext.privacy;
|
|
if ( bp instanceof Object === false ) { return; }
|
|
|
|
return {
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/1723#issuecomment-919913361
|
|
canLeakLocalIPAddresses:
|
|
vAPI.webextFlavor.soup.has('firefox') &&
|
|
vAPI.webextFlavor.soup.has('mobile'),
|
|
|
|
set: function(details) {
|
|
for ( const setting in details ) {
|
|
if ( hasOwnProperty(details, setting) === false ) { continue; }
|
|
switch ( setting ) {
|
|
case 'prefetching': {
|
|
const enabled = !!details[setting];
|
|
if ( enabled ) {
|
|
bp.network.networkPredictionEnabled.clear({
|
|
scope: 'regular',
|
|
});
|
|
} else {
|
|
bp.network.networkPredictionEnabled.set({
|
|
value: false,
|
|
scope: 'regular',
|
|
});
|
|
}
|
|
if ( vAPI.prefetching instanceof Function ) {
|
|
vAPI.prefetching(enabled);
|
|
}
|
|
break;
|
|
}
|
|
case 'hyperlinkAuditing': {
|
|
if ( details[setting] ) {
|
|
bp.websites.hyperlinkAuditingEnabled.clear({
|
|
scope: 'regular',
|
|
});
|
|
} else {
|
|
bp.websites.hyperlinkAuditingEnabled.set({
|
|
value: false,
|
|
scope: 'regular',
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case 'webrtcIPAddress': {
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/1928
|
|
// https://www.reddit.com/r/uBlockOrigin/comments/sl7p74/
|
|
// Hypothetical: some browsers _think_ uBO is still using
|
|
// the setting possibly based on cached state from the
|
|
// past, and making an explicit API call that uBO is not
|
|
// using the setting appears to solve those unexpected
|
|
// reported occurrences of uBO interfering despite never
|
|
// using the API.
|
|
const mustEnable = !details[setting];
|
|
if ( this.canLeakLocalIPAddresses === false ) {
|
|
if ( mustEnable && vAPI.webextFlavor.soup.has('chromium') ) {
|
|
bp.network.webRTCIPHandlingPolicy.clear({
|
|
scope: 'regular',
|
|
});
|
|
}
|
|
continue;
|
|
}
|
|
if ( mustEnable ) {
|
|
bp.network.webRTCIPHandlingPolicy.set({
|
|
value: 'default_public_interface_only',
|
|
scope: 'regular'
|
|
});
|
|
} else {
|
|
bp.network.webRTCIPHandlingPolicy.clear({
|
|
scope: 'regular',
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
vAPI.isBehindTheSceneTabId = function(tabId) {
|
|
return tabId < 0;
|
|
};
|
|
|
|
vAPI.unsetTabId = 0;
|
|
vAPI.noTabId = -1; // definitely not any existing tab
|
|
|
|
// To ensure we always use a good tab id
|
|
const toTabId = function(tabId) {
|
|
return typeof tabId === 'number' && isNaN(tabId) === false
|
|
? tabId
|
|
: 0;
|
|
};
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webNavigation
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs
|
|
|
|
vAPI.Tabs = class {
|
|
constructor() {
|
|
browser.webNavigation.onCreatedNavigationTarget.addListener(details => {
|
|
this.onCreatedNavigationTargetHandler(details);
|
|
});
|
|
browser.webNavigation.onCommitted.addListener(details => {
|
|
const { frameId, tabId } = details;
|
|
if ( frameId === 0 && tabId > 0 && details.transitionType === 'reload' ) {
|
|
if ( vAPI.net && vAPI.net.hasUnprocessedRequest(tabId) ) {
|
|
vAPI.net.removeUnprocessedRequest(tabId);
|
|
}
|
|
}
|
|
this.onCommittedHandler(details);
|
|
});
|
|
browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
|
|
this.onUpdatedHandler(tabId, changeInfo, tab);
|
|
});
|
|
browser.tabs.onActivated.addListener(details => {
|
|
this.onActivated(details);
|
|
});
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/151
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/680#issuecomment-515215220
|
|
if ( browser.windows instanceof Object ) {
|
|
browser.windows.onFocusChanged.addListener(windowId => {
|
|
this.onFocusChangedHandler(windowId);
|
|
});
|
|
}
|
|
browser.tabs.onRemoved.addListener((tabId, details) => {
|
|
if ( vAPI.net && vAPI.net.hasUnprocessedRequest(tabId) ) {
|
|
vAPI.net.removeUnprocessedRequest(tabId);
|
|
}
|
|
this.onRemovedHandler(tabId, details);
|
|
});
|
|
}
|
|
|
|
async executeScript(...args) {
|
|
let result;
|
|
try {
|
|
result = await webext.tabs.executeScript(...args);
|
|
}
|
|
catch(reason) {
|
|
}
|
|
return Array.isArray(result) ? result : [];
|
|
}
|
|
|
|
async get(tabId) {
|
|
if ( tabId === null ) {
|
|
return this.getCurrent();
|
|
}
|
|
if ( tabId <= 0 ) { return null; }
|
|
let tab;
|
|
try {
|
|
tab = await webext.tabs.get(tabId);
|
|
}
|
|
catch(reason) {
|
|
}
|
|
return tab instanceof Object ? tab : null;
|
|
}
|
|
|
|
async getCurrent() {
|
|
const tabs = await this.query({ active: true, currentWindow: true });
|
|
return tabs.length !== 0 ? tabs[0] : null;
|
|
}
|
|
|
|
async insertCSS(tabId, details) {
|
|
if ( vAPI.supportsUserStylesheets ) {
|
|
details.cssOrigin = 'user';
|
|
}
|
|
try {
|
|
await webext.tabs.insertCSS(...arguments);
|
|
}
|
|
catch(reason) {
|
|
}
|
|
}
|
|
|
|
async query(queryInfo) {
|
|
let tabs;
|
|
try {
|
|
tabs = await webext.tabs.query(queryInfo);
|
|
}
|
|
catch(reason) {
|
|
}
|
|
return Array.isArray(tabs) ? tabs : [];
|
|
}
|
|
|
|
async removeCSS(tabId, details) {
|
|
if ( vAPI.supportsUserStylesheets ) {
|
|
details.cssOrigin = 'user';
|
|
}
|
|
try {
|
|
await webext.tabs.removeCSS(...arguments);
|
|
}
|
|
catch(reason) {
|
|
}
|
|
}
|
|
|
|
// Properties of the details object:
|
|
// - url: 'URL', => the address that will be opened
|
|
// - index: -1, => undefined: end of the list, -1: following tab,
|
|
// or after index
|
|
// - active: false, => opens the tab... in background: true,
|
|
// foreground: undefined
|
|
// - popup: 'popup' => open in a new window
|
|
|
|
async create(url, details) {
|
|
if ( details.active === undefined ) {
|
|
details.active = true;
|
|
}
|
|
|
|
const subWrapper = async ( ) => {
|
|
const updateDetails = {
|
|
url: url,
|
|
active: !!details.active
|
|
};
|
|
|
|
// Opening a tab from incognito window won't focus the window
|
|
// in which the tab was opened
|
|
const focusWindow = tab => {
|
|
if ( tab.active && vAPI.windows instanceof Object ) {
|
|
vAPI.windows.update(tab.windowId, { focused: true });
|
|
}
|
|
};
|
|
|
|
if ( !details.tabId ) {
|
|
if ( details.index !== undefined ) {
|
|
updateDetails.index = details.index;
|
|
}
|
|
browser.tabs.create(updateDetails, focusWindow);
|
|
return;
|
|
}
|
|
|
|
// update doesn't accept index, must use move
|
|
const tab = await vAPI.tabs.update(
|
|
toTabId(details.tabId),
|
|
updateDetails
|
|
);
|
|
// if the tab doesn't exist
|
|
if ( tab === null ) {
|
|
browser.tabs.create(updateDetails, focusWindow);
|
|
} else if ( details.index !== undefined ) {
|
|
browser.tabs.move(tab.id, { index: details.index });
|
|
}
|
|
};
|
|
|
|
// Open in a standalone window
|
|
//
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/168#issuecomment-413038191
|
|
// Not all platforms support vAPI.windows.
|
|
//
|
|
// For some reasons, some platforms do not honor the left,top
|
|
// position when specified. I found that further calling
|
|
// windows.update again with the same position _may_ help.
|
|
//
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/2249
|
|
// Mind that the creation of the popup window might fail.
|
|
if ( details.popup !== undefined && vAPI.windows instanceof Object ) {
|
|
const basicDetails = {
|
|
url: details.url,
|
|
type: details.popup,
|
|
};
|
|
const shouldRestorePosition = details.box instanceof Object;
|
|
const extraDetails = shouldRestorePosition
|
|
? Object.assign({}, basicDetails, details.box)
|
|
: basicDetails;
|
|
const win = await vAPI.windows.create(extraDetails);
|
|
if ( win === null ) {
|
|
if ( shouldRestorePosition === false ) { return; }
|
|
return vAPI.windows.create(basicDetails);
|
|
}
|
|
if ( shouldRestorePosition === false ) { return; }
|
|
if ( win.left === details.box.left ) {
|
|
if ( win.top === details.box.top ) { return; }
|
|
}
|
|
vAPI.windows.update(win.id, {
|
|
left: details.box.left,
|
|
top: details.box.top
|
|
});
|
|
return;
|
|
}
|
|
|
|
if ( details.index !== -1 ) {
|
|
subWrapper();
|
|
return;
|
|
}
|
|
|
|
const tab = await vAPI.tabs.getCurrent();
|
|
if ( tab !== null ) {
|
|
details.index = tab.index + 1;
|
|
} else {
|
|
details.index = undefined;
|
|
}
|
|
subWrapper();
|
|
}
|
|
|
|
// Properties of the details object:
|
|
// - url: 'URL', => the address that will be opened
|
|
// - tabId: 1, => the tab is used if set, instead of creating a new one
|
|
// - index: -1, => undefined: end of the list, -1: following tab, or
|
|
// after index
|
|
// - active: false, => opens the tab in background - true and undefined:
|
|
// foreground
|
|
// - select: true, => if a tab is already opened with that url, then select
|
|
// it instead of opening a new one
|
|
// - popup: true => open in a new window
|
|
|
|
async open(details) {
|
|
let targetURL = details.url;
|
|
if ( typeof targetURL !== 'string' || targetURL === '' ) {
|
|
return null;
|
|
}
|
|
|
|
// extension pages
|
|
if ( /^[\w-]{2,}:/.test(targetURL) !== true ) {
|
|
targetURL = vAPI.getURL(targetURL);
|
|
}
|
|
|
|
if ( !details.select ) {
|
|
this.create(targetURL, details);
|
|
return;
|
|
}
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query#Parameters
|
|
// "Note that fragment identifiers are not matched."
|
|
// Fragment identifiers ARE matched -- we need to remove the fragment.
|
|
const pos = targetURL.indexOf('#');
|
|
const targetURLWithoutHash = pos === -1
|
|
? targetURL
|
|
: targetURL.slice(0, pos);
|
|
|
|
const tabs = await vAPI.tabs.query({ url: targetURLWithoutHash });
|
|
if ( tabs.length === 0 ) {
|
|
this.create(targetURL, details);
|
|
return;
|
|
}
|
|
let tab = tabs[0];
|
|
const updateDetails = { active: true };
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/592
|
|
if ( tab.url.startsWith(targetURL) === false ) {
|
|
updateDetails.url = targetURL;
|
|
}
|
|
tab = await vAPI.tabs.update(tab.id, updateDetails);
|
|
if ( vAPI.windows instanceof Object === false ) { return; }
|
|
vAPI.windows.update(tab.windowId, { focused: true });
|
|
}
|
|
|
|
async update() {
|
|
let tab;
|
|
try {
|
|
tab = await webext.tabs.update(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
return tab instanceof Object ? tab : null;
|
|
}
|
|
|
|
// Replace the URL of a tab. Noop if the tab does not exist.
|
|
replace(tabId, url) {
|
|
tabId = toTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
let targetURL = url;
|
|
|
|
// extension pages
|
|
if ( /^[\w-]{2,}:/.test(targetURL) !== true ) {
|
|
targetURL = vAPI.getURL(targetURL);
|
|
}
|
|
|
|
return vAPI.tabs.update(tabId, { url: targetURL });
|
|
}
|
|
|
|
async remove(tabId) {
|
|
tabId = toTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
try {
|
|
await webext.tabs.remove(tabId);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
}
|
|
|
|
async reload(tabId, bypassCache = false) {
|
|
tabId = toTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
try {
|
|
await webext.tabs.reload(
|
|
tabId,
|
|
{ bypassCache: bypassCache === true }
|
|
);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
}
|
|
|
|
async select(tabId) {
|
|
tabId = toTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
const tab = await vAPI.tabs.update(tabId, { active: true });
|
|
if ( tab === null ) { return; }
|
|
if ( vAPI.windows instanceof Object === false ) { return; }
|
|
vAPI.windows.update(tab.windowId, { focused: true });
|
|
}
|
|
|
|
// https://forums.lanik.us/viewtopic.php?f=62&t=32826
|
|
// Chromium-based browsers: sanitize target URL. I've seen data: URI with
|
|
// newline characters in standard fields, possibly as a way of evading
|
|
// filters. As per spec, there should be no whitespaces in a data: URI's
|
|
// standard fields.
|
|
|
|
sanitizeURL(url) {
|
|
if ( url.startsWith('data:') === false ) { return url; }
|
|
const pos = url.indexOf(',');
|
|
if ( pos === -1 ) { return url; }
|
|
const s = url.slice(0, pos);
|
|
if ( s.search(/\s/) === -1 ) { return url; }
|
|
return s.replace(/\s+/, '') + url.slice(pos);
|
|
}
|
|
|
|
onCreatedNavigationTargetHandler(details) {
|
|
if ( typeof details.url !== 'string' ) {
|
|
details.url = '';
|
|
}
|
|
if ( /^https?:\/\//.test(details.url) === false ) {
|
|
details.frameId = 0;
|
|
details.url = this.sanitizeURL(details.url);
|
|
this.onNavigation(details);
|
|
}
|
|
this.onCreated(details);
|
|
}
|
|
|
|
onCommittedHandler(details) {
|
|
details.url = this.sanitizeURL(details.url);
|
|
this.onNavigation(details);
|
|
}
|
|
|
|
onUpdatedHandler(tabId, changeInfo, tab) {
|
|
// Ignore uninteresting update events
|
|
const { status = '', title = '', url = '' } = changeInfo;
|
|
if ( status === '' && title === '' && url === '' ) { return; }
|
|
// https://github.com/gorhill/uBlock/issues/3073
|
|
// Fall back to `tab.url` when `changeInfo.url` is not set.
|
|
if ( url === '' ) {
|
|
changeInfo.url = tab && tab.url;
|
|
}
|
|
if ( changeInfo.url ) {
|
|
changeInfo.url = this.sanitizeURL(changeInfo.url);
|
|
}
|
|
this.onUpdated(tabId, changeInfo, tab);
|
|
}
|
|
|
|
onRemovedHandler(tabId, details) {
|
|
this.onClosed(tabId, details);
|
|
}
|
|
|
|
onFocusChangedHandler(windowId) {
|
|
if ( windowId === browser.windows.WINDOW_ID_NONE ) { return; }
|
|
vAPI.tabs.query({ active: true, windowId }).then(tabs => {
|
|
if ( tabs.length === 0 ) { return; }
|
|
const tab = tabs[0];
|
|
this.onActivated({ tabId: tab.id, windowId: tab.windowId });
|
|
});
|
|
}
|
|
|
|
onActivated(/* details */) {
|
|
}
|
|
|
|
onClosed(/* tabId, details */) {
|
|
}
|
|
|
|
onCreated(/* details */) {
|
|
}
|
|
|
|
onNavigation(/* details */) {
|
|
}
|
|
|
|
onUpdated(/* tabId, changeInfo, tab */) {
|
|
}
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
if ( webext.windows instanceof Object ) {
|
|
vAPI.windows = {
|
|
get: async function() {
|
|
let win;
|
|
try {
|
|
win = await webext.windows.get(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
return win instanceof Object ? win : null;
|
|
},
|
|
create: async function() {
|
|
let win;
|
|
try {
|
|
win = await webext.windows.create(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
return win instanceof Object ? win : null;
|
|
},
|
|
update: async function() {
|
|
let win;
|
|
try {
|
|
win = await webext.windows.update(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
return win instanceof Object ? win : null;
|
|
},
|
|
};
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
if ( webext.browserAction instanceof Object ) {
|
|
vAPI.browserAction = {
|
|
setTitle: async function() {
|
|
try {
|
|
await webext.browserAction.setTitle(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
},
|
|
};
|
|
// Not supported on Firefox for Android
|
|
if ( webext.browserAction.setIcon ) {
|
|
vAPI.browserAction.setBadgeTextColor = async function() {
|
|
try {
|
|
await webext.browserAction.setBadgeTextColor(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
};
|
|
vAPI.browserAction.setBadgeBackgroundColor = async function() {
|
|
try {
|
|
await webext.browserAction.setBadgeBackgroundColor(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
};
|
|
vAPI.browserAction.setBadgeText = async function() {
|
|
try {
|
|
await webext.browserAction.setBadgeText(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
};
|
|
vAPI.browserAction.setIcon = async function() {
|
|
try {
|
|
await webext.browserAction.setIcon(...arguments);
|
|
}
|
|
catch (reason) {
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// Must read: https://code.google.com/p/chromium/issues/detail?id=410868#c8
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/19
|
|
// https://github.com/chrisaljoudi/uBlock/issues/207
|
|
// Since we may be called asynchronously, the tab id may not exist
|
|
// anymore, so this ensures it does still exist.
|
|
|
|
// https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/browserAction#Browser_compatibility
|
|
// Firefox for Android does no support browser.browserAction.setIcon().
|
|
// Performance: use ImageData for platforms supporting it.
|
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/32
|
|
// Ensure ImageData for toolbar icon is valid before use.
|
|
|
|
{
|
|
const browserAction = vAPI.browserAction;
|
|
const titleTemplate = `${browser.runtime.getManifest().browser_action.default_title} ({badge})`;
|
|
const icons = [
|
|
{ path: {
|
|
'16': 'img/icon_16-off.png',
|
|
'32': 'img/icon_32-off.png',
|
|
'64': 'img/icon_64-off.png',
|
|
} },
|
|
{ path: {
|
|
'16': 'img/icon_16.png',
|
|
'32': 'img/icon_32.png',
|
|
'64': 'img/icon_64.png',
|
|
} },
|
|
];
|
|
|
|
(( ) => {
|
|
if ( browserAction.setIcon === undefined ) { return; }
|
|
|
|
// The global badge text and background color.
|
|
if ( browserAction.setBadgeBackgroundColor !== undefined ) {
|
|
browserAction.setBadgeBackgroundColor({ color: '#666666' });
|
|
}
|
|
if ( browserAction.setBadgeTextColor !== undefined ) {
|
|
browserAction.setBadgeTextColor({ color: '#FFFFFF' });
|
|
}
|
|
|
|
// As of 2018-05, benchmarks show that only Chromium benefits for sure
|
|
// from using ImageData.
|
|
//
|
|
// Chromium creates a new ImageData instance every call to setIcon
|
|
// with paths:
|
|
// https://cs.chromium.org/chromium/src/extensions/renderer/resources/set_icon.js?l=56&rcl=99be185c25738437ecfa0dafba72a26114196631
|
|
//
|
|
// Firefox uses an internal cache for each setIcon's paths:
|
|
// https://searchfox.org/mozilla-central/rev/5ff2d7683078c96e4b11b8a13674daded935aa44/browser/components/extensions/parent/ext-browserAction.js#631
|
|
if ( vAPI.webextFlavor.soup.has('chromium') === false ) { return; }
|
|
|
|
const imgs = [];
|
|
for ( let i = 0; i < icons.length; i++ ) {
|
|
for ( const key of Object.keys(icons[i].path) ) {
|
|
if ( parseInt(key, 10) >= 64 ) { continue; }
|
|
imgs.push({ i: i, p: key, cached: false });
|
|
}
|
|
}
|
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/296
|
|
const safeGetImageData = function(ctx, w, h) {
|
|
let data;
|
|
try {
|
|
data = ctx.getImageData(0, 0, w, h);
|
|
} catch(ex) {
|
|
}
|
|
return data;
|
|
};
|
|
|
|
const onLoaded = function() {
|
|
for ( const img of imgs ) {
|
|
if ( img.r.complete === false ) { return; }
|
|
}
|
|
const ctx = document.createElement('canvas')
|
|
.getContext('2d', { willReadFrequently: true });
|
|
const iconData = [ null, null ];
|
|
for ( const img of imgs ) {
|
|
if ( img.cached ) { continue; }
|
|
const w = img.r.naturalWidth, h = img.r.naturalHeight;
|
|
ctx.width = w; ctx.height = h;
|
|
ctx.clearRect(0, 0, w, h);
|
|
ctx.drawImage(img.r, 0, 0);
|
|
if ( iconData[img.i] === null ) { iconData[img.i] = {}; }
|
|
const imgData = safeGetImageData(ctx, w, h);
|
|
if (
|
|
imgData instanceof Object === false ||
|
|
imgData.data instanceof Uint8ClampedArray === false ||
|
|
imgData.data[0] !== 0 ||
|
|
imgData.data[1] !== 0 ||
|
|
imgData.data[2] !== 0 ||
|
|
imgData.data[3] !== 0
|
|
) {
|
|
return;
|
|
}
|
|
iconData[img.i][img.p] = imgData;
|
|
img.cached = true;
|
|
}
|
|
for ( let i = 0; i < iconData.length; i++ ) {
|
|
if ( iconData[i] ) {
|
|
icons[i] = { imageData: iconData[i] };
|
|
}
|
|
}
|
|
};
|
|
for ( const img of imgs ) {
|
|
img.r = new Image();
|
|
img.r.addEventListener('load', onLoaded, { once: true });
|
|
img.r.src = icons[img.i].path[img.p];
|
|
}
|
|
})();
|
|
|
|
// parts: bit 0 = icon
|
|
// bit 1 = badge text
|
|
// bit 2 = badge color
|
|
// bit 3 = hide badge
|
|
|
|
vAPI.setIcon = async function(tabId, details) {
|
|
tabId = toTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
const tab = await vAPI.tabs.get(tabId);
|
|
if ( tab === null ) { return; }
|
|
|
|
const hasUnprocessedRequest = vAPI.net && vAPI.net.hasUnprocessedRequest(tabId);
|
|
const { parts, state } = details;
|
|
const { badge, color } = hasUnprocessedRequest
|
|
? { badge: '!', color: '#FC0' }
|
|
: details;
|
|
|
|
if ( browserAction.setIcon !== undefined ) {
|
|
if ( parts === undefined || (parts & 0b0001) !== 0 ) {
|
|
browserAction.setIcon(
|
|
Object.assign({ tabId: tab.id }, icons[state])
|
|
);
|
|
}
|
|
if ( (parts & 0b0010) !== 0 ) {
|
|
browserAction.setBadgeText({
|
|
tabId: tab.id,
|
|
text: (parts & 0b1000) === 0 ? badge : ''
|
|
});
|
|
}
|
|
if ( (parts & 0b0100) !== 0 ) {
|
|
browserAction.setBadgeBackgroundColor({ tabId: tab.id, color });
|
|
}
|
|
}
|
|
|
|
// Insert the badge text in the title if:
|
|
// - the platform does not support browserAction.setIcon(); OR
|
|
// - the rendering of the badge is disabled
|
|
if ( browserAction.setTitle !== undefined ) {
|
|
const title = titleTemplate.replace('{badge}',
|
|
state === 1 ? (badge !== '' ? badge : '0') : 'off'
|
|
);
|
|
browserAction.setTitle({ tabId: tab.id, title });
|
|
}
|
|
|
|
if ( vAPI.contextMenu instanceof Object ) {
|
|
vAPI.contextMenu.onMustUpdate(tabId);
|
|
}
|
|
};
|
|
|
|
vAPI.setDefaultIcon = function(flavor, text) {
|
|
if ( browserAction.setIcon === undefined ) { return; }
|
|
browserAction.setIcon({
|
|
path: {
|
|
'16': `img/icon_16${flavor}.png`,
|
|
'32': `img/icon_32${flavor}.png`,
|
|
'64': `img/icon_64${flavor}.png`,
|
|
}
|
|
});
|
|
browserAction.setBadgeText({ text });
|
|
browserAction.setBadgeBackgroundColor({
|
|
color: text === '!' ? '#FC0' : '#666'
|
|
});
|
|
};
|
|
}
|
|
|
|
browser.browserAction.onClicked.addListener(function(tab) {
|
|
vAPI.tabs.open({
|
|
select: true,
|
|
url: `popup-fenix.html?tabId=${tab.id}&intab=1`,
|
|
});
|
|
});
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/710
|
|
// uBO uses only ports to communicate with its auxiliary pages and
|
|
// content scripts. Whether a message can trigger a privileged operation is
|
|
// decided based on whether the port from which a message is received is
|
|
// privileged, which is a status evaluated once, at port connection time.
|
|
//
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/1992
|
|
// If present, use MessageSender.origin to determine whether the port is
|
|
// from a privileged page, otherwise use MessageSender.url.
|
|
// MessageSender.origin is more reliable as it is not spoofable by a
|
|
// compromised renderer.
|
|
|
|
vAPI.messaging = {
|
|
ports: new Map(),
|
|
listeners: new Map(),
|
|
defaultHandler: null,
|
|
PRIVILEGED_ORIGIN: vAPI.getURL('').slice(0, -1),
|
|
NOOPFUNC: function(){},
|
|
UNHANDLED: 'vAPI.messaging.notHandled',
|
|
|
|
listen: function(details) {
|
|
this.listeners.set(details.name, {
|
|
fn: details.listener,
|
|
privileged: details.privileged === true
|
|
});
|
|
},
|
|
|
|
onPortDisconnect: function(port) {
|
|
this.ports.delete(port.name);
|
|
void browser.runtime.lastError;
|
|
},
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/Port
|
|
// port.sender is always present for onConnect() listeners.
|
|
onPortConnect: function(port) {
|
|
port.onDisconnect.addListener(port =>
|
|
this.onPortDisconnect(port)
|
|
);
|
|
port.onMessage.addListener((request, port) =>
|
|
this.onPortMessage(request, port)
|
|
);
|
|
const portDetails = { port };
|
|
const sender = port.sender;
|
|
const { origin, tab, url } = sender;
|
|
portDetails.frameId = sender.frameId;
|
|
portDetails.frameURL = url;
|
|
portDetails.privileged = origin !== undefined
|
|
? origin === this.PRIVILEGED_ORIGIN
|
|
: url.startsWith(this.PRIVILEGED_ORIGIN);
|
|
if ( tab ) {
|
|
portDetails.tabId = tab.id;
|
|
portDetails.tabURL = tab.url;
|
|
}
|
|
this.ports.set(port.name, portDetails);
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1652925#c24
|
|
port.sender = undefined;
|
|
},
|
|
|
|
setup: function(defaultHandler) {
|
|
if ( this.defaultHandler !== null ) { return; }
|
|
|
|
if ( typeof defaultHandler !== 'function' ) {
|
|
defaultHandler = function() {
|
|
return this.UNHANDLED;
|
|
};
|
|
}
|
|
this.defaultHandler = defaultHandler;
|
|
|
|
browser.runtime.onConnect.addListener(
|
|
port => this.onPortConnect(port)
|
|
);
|
|
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1392067
|
|
// Workaround: manually remove ports matching removed tab.
|
|
if (
|
|
vAPI.webextFlavor.soup.has('firefox') &&
|
|
vAPI.webextFlavor.major < 61
|
|
) {
|
|
browser.tabs.onRemoved.addListener(tabId => {
|
|
for ( const { port, tabId: portTabId } of this.ports.values() ) {
|
|
if ( portTabId !== tabId ) { continue; }
|
|
this.onPortDisconnect(port);
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
onFrameworkMessage: function(request, port, callback) {
|
|
const portDetails = this.ports.get(port.name) || {};
|
|
const tabId = portDetails.tabId;
|
|
const msg = request.msg;
|
|
switch ( msg.what ) {
|
|
case 'localStorage': {
|
|
if ( portDetails.privileged !== true ) { break; }
|
|
const args = msg.args || [];
|
|
vAPI.localStorage[msg.fn](...args).then(result => {
|
|
callback(result);
|
|
});
|
|
break;
|
|
}
|
|
case 'userCSS': {
|
|
if ( tabId === undefined ) { break; }
|
|
const promises = [];
|
|
if ( msg.add ) {
|
|
const details = {
|
|
code: undefined,
|
|
frameId: portDetails.frameId,
|
|
matchAboutBlank: true,
|
|
runAt: 'document_start',
|
|
};
|
|
for ( const cssText of msg.add ) {
|
|
details.code = cssText;
|
|
promises.push(vAPI.tabs.insertCSS(tabId, details));
|
|
}
|
|
}
|
|
if ( msg.remove ) {
|
|
const details = {
|
|
code: undefined,
|
|
frameId: portDetails.frameId,
|
|
matchAboutBlank: true,
|
|
};
|
|
for ( const cssText of msg.remove ) {
|
|
details.code = cssText;
|
|
promises.push(vAPI.tabs.removeCSS(tabId, details));
|
|
}
|
|
}
|
|
Promise.all(promises).then(( ) => {
|
|
callback();
|
|
});
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
},
|
|
|
|
// Use a wrapper to avoid closure and to allow reuse.
|
|
CallbackWrapper: class {
|
|
constructor(messaging, port, msgId) {
|
|
this.messaging = messaging;
|
|
this.callback = this.proxy.bind(this); // bind once
|
|
this.init(port, msgId);
|
|
}
|
|
init(port, msgId) {
|
|
this.port = port;
|
|
this.msgId = msgId;
|
|
return this;
|
|
}
|
|
proxy(response) {
|
|
// https://github.com/chrisaljoudi/uBlock/issues/383
|
|
try {
|
|
this.port.postMessage({
|
|
msgId: this.msgId,
|
|
msg: response !== undefined ? response : null,
|
|
});
|
|
} catch (ex) {
|
|
this.messaging.onPortDisconnect(this.port);
|
|
}
|
|
// Store for reuse
|
|
this.port = null;
|
|
this.messaging.callbackWrapperJunkyard.push(this);
|
|
}
|
|
},
|
|
|
|
callbackWrapperJunkyard: [],
|
|
|
|
callbackWrapperFactory: function(port, msgId) {
|
|
return this.callbackWrapperJunkyard.length !== 0
|
|
? this.callbackWrapperJunkyard.pop().init(port, msgId)
|
|
: new this.CallbackWrapper(this, port, msgId);
|
|
},
|
|
|
|
onPortMessage: function(request, port) {
|
|
// prepare response
|
|
let callback = this.NOOPFUNC;
|
|
if ( request.msgId !== undefined ) {
|
|
callback = this.callbackWrapperFactory(port, request.msgId).callback;
|
|
}
|
|
|
|
// Content process to main process: framework handler.
|
|
if ( request.channel === 'vapi' ) {
|
|
this.onFrameworkMessage(request, port, callback);
|
|
return;
|
|
}
|
|
|
|
// Auxiliary process to main process: specific handler
|
|
const portDetails = this.ports.get(port.name);
|
|
if ( portDetails === undefined ) { return; }
|
|
|
|
const listenerDetails = this.listeners.get(request.channel);
|
|
let r = this.UNHANDLED;
|
|
if (
|
|
(listenerDetails !== undefined) &&
|
|
(listenerDetails.privileged === false || portDetails.privileged)
|
|
|
|
) {
|
|
r = listenerDetails.fn(request.msg, portDetails, callback);
|
|
}
|
|
if ( r !== this.UNHANDLED ) { return; }
|
|
|
|
// Auxiliary process to main process: default handler
|
|
if ( portDetails.privileged ) {
|
|
r = this.defaultHandler(request.msg, portDetails, callback);
|
|
if ( r !== this.UNHANDLED ) { return; }
|
|
}
|
|
|
|
// Auxiliary process to main process: no handler
|
|
ubolog(
|
|
`vAPI.messaging.onPortMessage > unhandled request: ${JSON.stringify(request.msg)}`,
|
|
request
|
|
);
|
|
|
|
// Need to callback anyways in case caller expected an answer, or
|
|
// else there is a memory leak on caller's side
|
|
callback();
|
|
},
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://github.com/gorhill/uBlock/issues/3474
|
|
// https://github.com/gorhill/uBlock/issues/2823
|
|
// Foil ability of web pages to identify uBO through
|
|
// its web accessible resources.
|
|
// https://github.com/gorhill/uBlock/issues/3497
|
|
// Prevent web pages from interfering with uBO's element picker
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/550
|
|
// Support using a new secret for every network request.
|
|
|
|
{
|
|
const root = vAPI.getURL('/');
|
|
const reSecret = /\?secret=(\w+)/;
|
|
const shortSecrets = [];
|
|
let lastShortSecretTime = 0;
|
|
|
|
// Long secrets are valid until revoked or uBO restarts. The realm is one
|
|
// value out of 36^18 = over 10^28 values.
|
|
const longSecrets = new Set();
|
|
|
|
const guard = details => {
|
|
const match = reSecret.exec(details.url);
|
|
if ( match === null ) { return { cancel: true }; }
|
|
const secret = match[1];
|
|
if ( longSecrets.has(secret) ) { return; }
|
|
const pos = shortSecrets.indexOf(secret);
|
|
if ( pos === -1 ) { return { cancel: true }; }
|
|
shortSecrets.splice(pos, 1);
|
|
};
|
|
|
|
browser.webRequest.onBeforeRequest.addListener(
|
|
guard,
|
|
{
|
|
urls: [ root + 'web_accessible_resources/*' ]
|
|
},
|
|
[ 'blocking' ]
|
|
);
|
|
|
|
vAPI.warSecret = {
|
|
short: ( ) => {
|
|
if ( shortSecrets.length !== 0 ) {
|
|
if ( (Date.now() - lastShortSecretTime) > 5000 ) {
|
|
shortSecrets.splice(0);
|
|
} else if ( shortSecrets.length > 256 ) {
|
|
shortSecrets.splice(0, shortSecrets.length - 192);
|
|
}
|
|
}
|
|
lastShortSecretTime = Date.now();
|
|
const secret = vAPI.generateSecret();
|
|
shortSecrets.push(secret);
|
|
return secret;
|
|
},
|
|
long: previous => {
|
|
if ( previous !== undefined ) {
|
|
longSecrets.delete(previous);
|
|
}
|
|
const secret = vAPI.generateSecret(3);
|
|
longSecrets.add(secret);
|
|
return secret;
|
|
},
|
|
};
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
vAPI.Net = class {
|
|
constructor() {
|
|
this.validTypes = new Set();
|
|
{
|
|
const wrrt = browser.webRequest.ResourceType;
|
|
for ( const typeKey in wrrt ) {
|
|
if ( hasOwnProperty(wrrt, typeKey) ) {
|
|
this.validTypes.add(wrrt[typeKey]);
|
|
}
|
|
}
|
|
}
|
|
this.suspendableListener = undefined;
|
|
this.deferredSuspendableListener = undefined;
|
|
this.listenerMap = new WeakMap();
|
|
this.suspendDepth = 0;
|
|
this.unprocessedTabs = new Map();
|
|
|
|
browser.webRequest.onBeforeRequest.addListener(
|
|
details => {
|
|
this.normalizeDetails(details);
|
|
if ( this.suspendDepth !== 0 && details.tabId >= 0 ) {
|
|
return this.suspendOneRequest(details);
|
|
}
|
|
return this.onBeforeSuspendableRequest(details);
|
|
},
|
|
this.denormalizeFilters({ urls: [ 'http://*/*', 'https://*/*' ] }),
|
|
[ 'blocking' ]
|
|
);
|
|
|
|
vAPI.setDefaultIcon('-loading', '');
|
|
}
|
|
setOptions(/* options */) {
|
|
}
|
|
normalizeDetails(/* details */) {
|
|
}
|
|
denormalizeFilters(filters) {
|
|
const urls = filters.urls || [ '<all_urls>' ];
|
|
let types = filters.types;
|
|
if ( Array.isArray(types) ) {
|
|
types = this.denormalizeTypes(types);
|
|
}
|
|
if (
|
|
(this.validTypes.has('websocket')) &&
|
|
(types === undefined || types.indexOf('websocket') !== -1) &&
|
|
(urls.indexOf('<all_urls>') === -1)
|
|
) {
|
|
if ( urls.indexOf('ws://*/*') === -1 ) {
|
|
urls.push('ws://*/*');
|
|
}
|
|
if ( urls.indexOf('wss://*/*') === -1 ) {
|
|
urls.push('wss://*/*');
|
|
}
|
|
}
|
|
return { types, urls };
|
|
}
|
|
denormalizeTypes(types) {
|
|
return types;
|
|
}
|
|
canonicalNameFromHostname(/* hn */) {
|
|
}
|
|
addListener(which, clientListener, filters, options) {
|
|
const actualFilters = this.denormalizeFilters(filters);
|
|
const actualListener = this.makeNewListenerProxy(clientListener);
|
|
browser.webRequest[which].addListener(
|
|
actualListener,
|
|
actualFilters,
|
|
options
|
|
);
|
|
}
|
|
onBeforeSuspendableRequest(details) {
|
|
if ( this.suspendableListener !== undefined ) {
|
|
return this.suspendableListener(details);
|
|
}
|
|
this.onUnprocessedRequest(details);
|
|
}
|
|
setSuspendableListener(listener) {
|
|
for ( const [ tabId, requests ] of this.unprocessedTabs ) {
|
|
let i = requests.length;
|
|
while ( i-- ) {
|
|
const r = listener(requests[i]);
|
|
if ( r === undefined || r.cancel !== true ) {
|
|
requests.splice(i, 1);
|
|
}
|
|
}
|
|
if ( requests.length !== 0 ) { continue; }
|
|
this.unprocessedTabs.delete(tabId);
|
|
}
|
|
if ( this.unprocessedTabs.size !== 0 ) {
|
|
this.deferredSuspendableListener = listener;
|
|
listener = details => {
|
|
const { tabId, type } = details;
|
|
if ( type === 'main_frame' && this.unprocessedTabs.has(tabId) ) {
|
|
if ( this.removeUnprocessedRequest(tabId) ) {
|
|
return this.suspendableListener(details);
|
|
}
|
|
}
|
|
return this.deferredSuspendableListener(details);
|
|
};
|
|
}
|
|
this.suspendableListener = listener;
|
|
vAPI.setDefaultIcon('', '');
|
|
}
|
|
removeListener(which, clientListener) {
|
|
const actualListener = this.listenerMap.get(clientListener);
|
|
if ( actualListener === undefined ) { return; }
|
|
this.listenerMap.delete(clientListener);
|
|
browser.webRequest[which].removeListener(actualListener);
|
|
}
|
|
makeNewListenerProxy(clientListener) {
|
|
const actualListener = details => {
|
|
this.normalizeDetails(details);
|
|
return clientListener(details);
|
|
};
|
|
this.listenerMap.set(clientListener, actualListener);
|
|
return actualListener;
|
|
}
|
|
handlerBehaviorChanged() {
|
|
browser.webRequest.handlerBehaviorChanged();
|
|
}
|
|
onUnprocessedRequest(details) {
|
|
const { tabId } = details;
|
|
if ( tabId === -1 ) { return; }
|
|
if ( this.unprocessedTabs.size === 0 ) {
|
|
vAPI.setDefaultIcon('-loading', '!');
|
|
}
|
|
let requests = this.unprocessedTabs.get(tabId);
|
|
if ( requests === undefined ) {
|
|
this.unprocessedTabs.set(tabId, (requests = []));
|
|
}
|
|
requests.push(Object.assign({}, details));
|
|
}
|
|
hasUnprocessedRequest(tabId) {
|
|
if ( this.unprocessedTabs.size === 0 ) { return false; }
|
|
if ( tabId === undefined ) { return true; }
|
|
return this.unprocessedTabs.has(tabId);
|
|
}
|
|
removeUnprocessedRequest(tabId) {
|
|
if ( this.deferredSuspendableListener === undefined ) {
|
|
this.unprocessedTabs.clear();
|
|
return true;
|
|
}
|
|
if ( tabId !== undefined ) {
|
|
this.unprocessedTabs.delete(tabId);
|
|
} else {
|
|
this.unprocessedTabs.clear();
|
|
}
|
|
if ( this.unprocessedTabs.size !== 0 ) { return false; }
|
|
this.suspendableListener = this.deferredSuspendableListener;
|
|
this.deferredSuspendableListener = undefined;
|
|
return true;
|
|
}
|
|
suspendOneRequest() {
|
|
}
|
|
unsuspendAllRequests() {
|
|
}
|
|
suspend() {
|
|
this.suspendDepth += 1;
|
|
}
|
|
unsuspend({ all = false, discard = false } = {}) {
|
|
if ( this.suspendDepth === 0 ) { return; }
|
|
if ( all ) {
|
|
this.suspendDepth = 0;
|
|
} else {
|
|
this.suspendDepth -= 1;
|
|
}
|
|
if ( this.suspendDepth !== 0 ) { return; }
|
|
this.unsuspendAllRequests(discard);
|
|
}
|
|
headerValue(headers, name) {
|
|
for ( const header of headers ) {
|
|
if ( header.name.toLowerCase() === name ) {
|
|
return header.value.trim();
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
static canSuspend() {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// To be defined by platform-specific code.
|
|
|
|
vAPI.scriptletsInjector = (( ) => {
|
|
self.uBO_scriptletsInjected = '';
|
|
}).toString();
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/contextMenus#Browser_compatibility
|
|
// Firefox for Android does no support browser.contextMenus.
|
|
|
|
vAPI.contextMenu = webext.menus && {
|
|
_callback: null,
|
|
_hash: '',
|
|
onMustUpdate: function() {},
|
|
setEntries: function(entries, callback) {
|
|
entries = entries || [];
|
|
const hash = entries.map(v => v.id).join();
|
|
if ( hash === this._hash ) { return; }
|
|
this._hash = hash;
|
|
webext.menus.removeAll();
|
|
for ( const entry of entries ) {
|
|
webext.menus.create(JSON.parse(JSON.stringify(entry)));
|
|
}
|
|
const n = entries.length;
|
|
callback = callback || null;
|
|
if ( callback === this._callback ) { return; }
|
|
if ( n !== 0 && callback !== null ) {
|
|
webext.menus.onClicked.addListener(callback);
|
|
this._callback = callback;
|
|
} else if ( n === 0 && this._callback !== null ) {
|
|
webext.menus.onClicked.removeListener(this._callback);
|
|
this._callback = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
vAPI.commands = browser.commands;
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://github.com/gorhill/uBlock/issues/531
|
|
// Storage area dedicated to admin settings. Read-only.
|
|
|
|
// https://github.com/gorhill/uBlock/commit/43a5ed735b95a575a9339b6e71a1fcb27a99663b#commitcomment-13965030
|
|
// Not all Chromium-based browsers support managed storage. Merely testing or
|
|
// exception handling in this case does NOT work: I don't know why. The
|
|
// extension on Opera ends up in a non-sensical state, whereas vAPI become
|
|
// undefined out of nowhere. So only solution left is to test explicitly for
|
|
// Opera.
|
|
// https://github.com/gorhill/uBlock/issues/900
|
|
// Also, UC Browser: http://www.upsieutoc.com/image/WXuH
|
|
|
|
// https://github.com/uBlockOrigin/uAssets/discussions/16939
|
|
// Use a cached version of admin settings, such that there is no blocking
|
|
// call on `storage.managed`. The side effect is that any changes to admin
|
|
// settings will require an extra extension restart to take effect.
|
|
|
|
vAPI.adminStorage = (( ) => {
|
|
if ( webext.storage.managed instanceof Object === false ) {
|
|
return {
|
|
get: function() {
|
|
return Promise.resolve();
|
|
},
|
|
};
|
|
}
|
|
const cacheManagedStorage = async ( ) => {
|
|
let store;
|
|
try {
|
|
store = await webext.storage.managed.get();
|
|
} catch(ex) {
|
|
}
|
|
vAPI.storage.set({ cachedManagedStorage: store || {} });
|
|
};
|
|
|
|
return {
|
|
get: async function(key) {
|
|
let bin;
|
|
try {
|
|
bin = await vAPI.storage.get('cachedManagedStorage') || {};
|
|
if ( Object.keys(bin).length === 0 ) {
|
|
bin = await webext.storage.managed.get() || {};
|
|
} else {
|
|
bin = bin.cachedManagedStorage;
|
|
}
|
|
} catch(ex) {
|
|
bin = {};
|
|
}
|
|
cacheManagedStorage();
|
|
if ( key === undefined || key === null ) {
|
|
return bin;
|
|
}
|
|
if ( typeof key === 'string' && bin instanceof Object ) {
|
|
return bin[key];
|
|
}
|
|
const out = {};
|
|
if ( Array.isArray(key) ) {
|
|
for ( const k of key ) {
|
|
if ( bin[k] === undefined ) { continue; }
|
|
out[k] = bin[k];
|
|
}
|
|
return out;
|
|
}
|
|
for ( const [ k, v ] of Object.entries(key) ) {
|
|
out[k] = bin[k] !== undefined ? bin[k] : v;
|
|
}
|
|
return out;
|
|
}
|
|
};
|
|
})();
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// A localStorage-like object which should be accessible from the
|
|
// background page or auxiliary pages.
|
|
//
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/899
|
|
// Convert into asynchronous access API.
|
|
//
|
|
// Note: vAPI.localStorage should already be defined with the client-side
|
|
// implementation at this point, but we override with the
|
|
// background-side implementation.
|
|
vAPI.localStorage = {
|
|
start: async function() {
|
|
if ( this.cache instanceof Promise ) { return this.cache; }
|
|
if ( this.cache instanceof Object ) { return this.cache; }
|
|
this.cache = vAPI.storage.get('localStorage').then(bin => {
|
|
this.cache = bin && bin.localStorage || {};
|
|
});
|
|
return this.cache;
|
|
},
|
|
clear: function() {
|
|
this.cache = {};
|
|
return vAPI.storage.set({ localStorage: this.cache });
|
|
},
|
|
getItem: function(key) {
|
|
if ( this.cache instanceof Object === false ) {
|
|
console.info(`localStorage.getItem('${key}') not ready`);
|
|
return null;
|
|
}
|
|
const value = this.cache[key];
|
|
return value !== undefined ? value : null;
|
|
},
|
|
getItemAsync: async function(key) {
|
|
await this.start();
|
|
const value = this.cache[key];
|
|
return value !== undefined ? value : null;
|
|
},
|
|
removeItem: async function(key) {
|
|
this.setItem(key);
|
|
},
|
|
setItem: async function(key, value = undefined) {
|
|
await this.start();
|
|
if ( value === this.cache[key] ) { return; }
|
|
this.cache[key] = value;
|
|
return vAPI.storage.set({ localStorage: this.cache });
|
|
},
|
|
cache: undefined,
|
|
};
|
|
|
|
vAPI.localStorage.start();
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage/sync
|
|
|
|
vAPI.cloud = (( ) => {
|
|
// Not all platforms support `webext.storage.sync`.
|
|
if ( webext.storage.sync instanceof Object === false ) { return; }
|
|
|
|
// Currently, only Chromium supports the following constants -- these
|
|
// values will be assumed for platforms which do not define them.
|
|
// https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/storage/sync
|
|
// > You can store up to 100KB of data using this API
|
|
const MAX_ITEMS =
|
|
webext.storage.sync.MAX_ITEMS || 512;
|
|
const QUOTA_BYTES =
|
|
webext.storage.sync.QUOTA_BYTES || 102400;
|
|
const QUOTA_BYTES_PER_ITEM =
|
|
webext.storage.sync.QUOTA_BYTES_PER_ITEM || 8192;
|
|
|
|
const chunkCountPerFetch = 16; // Must be a power of 2
|
|
const maxChunkCountPerItem = Math.floor(MAX_ITEMS * 0.75) & ~(chunkCountPerFetch - 1);
|
|
|
|
// https://github.com/gorhill/uBlock/issues/3006
|
|
// For Firefox, we will use a lower ratio to allow for more overhead for
|
|
// the infrastructure. Unfortunately this leads to less usable space for
|
|
// actual data, but all of this is provided for free by browser vendors,
|
|
// so we need to accept and deal with these limitations.
|
|
const evalMaxChunkSize = function() {
|
|
return Math.floor(
|
|
QUOTA_BYTES_PER_ITEM *
|
|
(vAPI.webextFlavor.soup.has('firefox') ? 0.6 : 0.75)
|
|
);
|
|
};
|
|
|
|
let maxChunkSize = evalMaxChunkSize();
|
|
|
|
// The real actual webextFlavor value may not be set in stone, so listen
|
|
// for possible future changes.
|
|
window.addEventListener('webextFlavor', function() {
|
|
maxChunkSize = evalMaxChunkSize();
|
|
}, { once: true });
|
|
|
|
const options = {
|
|
defaultDeviceName: window.navigator.platform,
|
|
deviceName: undefined,
|
|
};
|
|
|
|
vAPI.localStorage.getItemAsync('deviceName').then(value => {
|
|
options.deviceName = value;
|
|
});
|
|
|
|
// This is used to find out a rough count of how many chunks exists:
|
|
// We "poll" at specific index in order to get a rough idea of how
|
|
// large is the stored string.
|
|
// This allows reading a single item with only 2 sync operations -- a
|
|
// good thing given chrome.storage.sync.MAX_WRITE_OPERATIONS_PER_MINUTE
|
|
// and chrome.storage.sync.MAX_WRITE_OPERATIONS_PER_HOUR.
|
|
|
|
const getCoarseChunkCount = async function(datakey) {
|
|
const keys = {};
|
|
for ( let i = 0; i < maxChunkCountPerItem; i += 16 ) {
|
|
keys[datakey + i.toString()] = '';
|
|
}
|
|
let bin;
|
|
try {
|
|
bin = await webext.storage.sync.get(keys);
|
|
} catch (reason) {
|
|
return String(reason);
|
|
}
|
|
let chunkCount = 0;
|
|
for ( let i = 0; i < maxChunkCountPerItem; i += 16 ) {
|
|
if ( bin[datakey + i.toString()] === '' ) { break; }
|
|
chunkCount = i + 16;
|
|
}
|
|
return chunkCount;
|
|
};
|
|
|
|
const deleteChunks = async function(datakey, start) {
|
|
const keys = [];
|
|
|
|
const n = await getCoarseChunkCount(datakey);
|
|
for ( let i = start; i < n; i++ ) {
|
|
keys.push(datakey + i.toString());
|
|
}
|
|
if ( keys.length !== 0 ) {
|
|
webext.storage.sync.remove(keys);
|
|
}
|
|
};
|
|
|
|
const push = async function(details) {
|
|
const { datakey, data, encode } = details;
|
|
if ( data === undefined || typeof data === 'string' && data === '' ) {
|
|
return deleteChunks(datakey, 0);
|
|
}
|
|
const item = {
|
|
source: options.deviceName || options.defaultDeviceName,
|
|
tstamp: Date.now(),
|
|
data,
|
|
};
|
|
const encoded = encode instanceof Function
|
|
? await encode(item)
|
|
: JSON.stringify(item);
|
|
|
|
// Chunkify taking into account QUOTA_BYTES_PER_ITEM:
|
|
// https://developer.chrome.com/extensions/storage#property-sync
|
|
// "The maximum size (in bytes) of each individual item in sync
|
|
// "storage, as measured by the JSON stringification of its value
|
|
// "plus its key length."
|
|
const bin = {};
|
|
const chunkCount = Math.ceil(encoded.length / maxChunkSize);
|
|
for ( let i = 0; i < chunkCount; i++ ) {
|
|
bin[datakey + i.toString()]
|
|
= encoded.substr(i * maxChunkSize, maxChunkSize);
|
|
}
|
|
bin[datakey + chunkCount.toString()] = ''; // Sentinel
|
|
|
|
// Remove potentially unused trailing chunks before storing the data,
|
|
// this will free storage space which could otherwise cause the push
|
|
// operation to fail.
|
|
try {
|
|
await deleteChunks(datakey, chunkCount + 1);
|
|
} catch (reason) {
|
|
}
|
|
|
|
// Push the data to browser-provided cloud storage.
|
|
try {
|
|
await webext.storage.sync.set(bin);
|
|
} catch (reason) {
|
|
return String(reason);
|
|
}
|
|
};
|
|
|
|
const pull = async function(details) {
|
|
const { datakey, decode } = details;
|
|
|
|
const result = await getCoarseChunkCount(datakey);
|
|
if ( typeof result !== 'number' ) {
|
|
return result;
|
|
}
|
|
const chunkKeys = {};
|
|
for ( let i = 0; i < result; i++ ) {
|
|
chunkKeys[datakey + i.toString()] = '';
|
|
}
|
|
|
|
let bin;
|
|
try {
|
|
bin = await webext.storage.sync.get(chunkKeys);
|
|
} catch (reason) {
|
|
return String(reason);
|
|
}
|
|
|
|
// Assemble chunks into a single string.
|
|
// https://www.reddit.com/r/uMatrix/comments/8lc9ia/my_rules_tab_hangs_with_cloud_storage_support/
|
|
// Explicit sentinel is not necessarily present: this can
|
|
// happen when the number of chunks is a multiple of
|
|
// chunkCountPerFetch. Hence why we must also test against
|
|
// undefined.
|
|
let encoded = [];
|
|
let i = 0;
|
|
for (;;) {
|
|
const slice = bin[datakey + i.toString()];
|
|
if ( slice === '' || slice === undefined ) { break; }
|
|
encoded.push(slice);
|
|
i += 1;
|
|
}
|
|
encoded = encoded.join('');
|
|
|
|
let entry = null;
|
|
try {
|
|
if ( decode instanceof Function ) {
|
|
entry = await decode(encoded) || null;
|
|
}
|
|
if ( typeof entry === 'string' ) {
|
|
entry = JSON.parse(entry);
|
|
}
|
|
} catch(_) {
|
|
}
|
|
return entry;
|
|
};
|
|
|
|
const used = async function(datakey) {
|
|
if ( webext.storage.sync.getBytesInUse instanceof Function === false ) {
|
|
return;
|
|
}
|
|
const coarseCount = await getCoarseChunkCount(datakey);
|
|
if ( typeof coarseCount !== 'number' ) { return; }
|
|
const keys = [];
|
|
for ( let i = 0; i < coarseCount; i++ ) {
|
|
keys.push(`${datakey}${i}`);
|
|
}
|
|
let results;
|
|
try {
|
|
results = await Promise.all([
|
|
webext.storage.sync.getBytesInUse(keys),
|
|
webext.storage.sync.getBytesInUse(null),
|
|
]);
|
|
} catch(ex) {
|
|
}
|
|
if ( Array.isArray(results) === false ) { return; }
|
|
return { used: results[0], total: results[1], max: QUOTA_BYTES };
|
|
};
|
|
|
|
const getOptions = function(callback) {
|
|
if ( typeof callback !== 'function' ) { return; }
|
|
callback(options);
|
|
};
|
|
|
|
const setOptions = function(details, callback) {
|
|
if ( typeof details !== 'object' || details === null ) { return; }
|
|
|
|
if ( typeof details.deviceName === 'string' ) {
|
|
vAPI.localStorage.setItem('deviceName', details.deviceName);
|
|
options.deviceName = details.deviceName;
|
|
}
|
|
|
|
getOptions(callback);
|
|
};
|
|
|
|
return { push, pull, used, getOptions, setOptions };
|
|
})();
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
vAPI.alarms = {
|
|
create(...args) {
|
|
webext.alarms.create(...args);
|
|
},
|
|
createIfNotPresent(name, ...args) {
|
|
webext.alarms.get(name).then(details => {
|
|
if ( details !== undefined ) { return; }
|
|
webext.alarms.create(name, ...args);
|
|
});
|
|
},
|
|
async clear(...args) {
|
|
return webext.alarms.clear(...args);
|
|
},
|
|
onAlarm: {
|
|
addListener(...args) {
|
|
webext.alarms.onAlarm.addListener(...args);
|
|
},
|
|
},
|
|
};
|
|
|
|
/******************************************************************************/
|