2014-11-15 19:15:11 +01:00
|
|
|
/*******************************************************************************
|
|
|
|
|
2016-03-22 15:19:41 +01:00
|
|
|
uBlock Origin - a browser extension to block requests.
|
2019-09-19 17:04:12 +02:00
|
|
|
Copyright (C) 2014-2015 The uBlock Origin authors
|
2018-08-25 18:57:21 +02:00
|
|
|
Copyright (C) 2014-present Raymond Hill
|
2014-11-15 19:15:11 +01: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
|
|
|
|
*/
|
|
|
|
|
2014-11-16 14:09:28 +01:00
|
|
|
// For background page
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2016-12-07 15:49:43 +01:00
|
|
|
'use strict';
|
|
|
|
|
2014-11-15 19:15:11 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2021-10-07 20:41:29 +02:00
|
|
|
import webext from './webext.js';
|
2021-08-03 18:08:59 +02:00
|
|
|
import { ubolog } from './console.js';
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
const manifest = browser.runtime.getManifest();
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2017-05-12 16:35:11 +02:00
|
|
|
vAPI.cantWebsocket =
|
2019-09-18 14:34:55 +02:00
|
|
|
browser.webRequest.ResourceType instanceof Object === false ||
|
|
|
|
browser.webRequest.ResourceType.WEBSOCKET !== 'websocket';
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2019-10-29 15:26:34 +01:00
|
|
|
vAPI.canWASM = vAPI.webextFlavor.soup.has('chromium') === false;
|
|
|
|
if ( vAPI.canWASM === false ) {
|
|
|
|
const csp = manifest.content_security_policy;
|
2021-07-29 22:54:51 +02:00
|
|
|
vAPI.canWASM = csp !== undefined && csp.indexOf("'unsafe-eval'") !== -1;
|
2019-10-29 15:26:34 +01:00
|
|
|
}
|
|
|
|
|
2018-04-12 18:17:38 +02:00
|
|
|
vAPI.supportsUserStylesheets = vAPI.webextFlavor.soup.has('user_stylesheet');
|
2019-10-29 15:26:34 +01:00
|
|
|
|
2018-04-21 18:34:54 +02:00
|
|
|
// The real actual webextFlavor value may not be set in stone, so listen
|
|
|
|
// for possible future changes.
|
|
|
|
window.addEventListener('webextFlavor', function() {
|
|
|
|
vAPI.supportsUserStylesheets =
|
|
|
|
vAPI.webextFlavor.soup.has('user_stylesheet');
|
|
|
|
}, { once: true });
|
2018-04-12 23:32:38 +02:00
|
|
|
|
2014-11-15 19:15:11 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-04 16:24:24 +02:00
|
|
|
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;
|
|
|
|
})(),
|
2014-12-01 17:25:33 +01:00
|
|
|
|
2019-09-06 19:03:06 +02:00
|
|
|
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;
|
|
|
|
},
|
|
|
|
|
2019-09-04 16:24:24 +02:00
|
|
|
restart: function() {
|
|
|
|
browser.runtime.reload();
|
|
|
|
},
|
2014-12-02 17:02:17 +01:00
|
|
|
};
|
|
|
|
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
2014-12-02 17:02:17 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
vAPI.storage = webext.storage.local;
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
2014-11-15 19:15:11 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-06-01 21:03:22 +02:00
|
|
|
// https://github.com/gorhill/uMatrix/issues/234
|
2019-09-18 14:34:55 +02:00
|
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/privacy/network
|
2015-06-01 21:03:22 +02:00
|
|
|
|
2016-10-05 12:52:43 +02:00
|
|
|
// https://github.com/gorhill/uBlock/issues/2048
|
|
|
|
// Do not mess up with existing settings if not assigning them stricter
|
|
|
|
// values.
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
vAPI.browserSettings = (( ) => {
|
2019-09-18 14:34:55 +02:00
|
|
|
// Not all platforms support `browser.privacy`.
|
2019-09-19 22:41:44 +02:00
|
|
|
const bp = webext.privacy;
|
|
|
|
if ( bp instanceof Object === false ) { return; }
|
2015-12-31 15:24:55 +01:00
|
|
|
|
2016-10-19 16:20:26 +02:00
|
|
|
return {
|
2021-09-15 14:28:10 +02:00
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/1723#issuecomment-919913361
|
2021-12-11 13:37:18 +01:00
|
|
|
canLeakLocalIPAddresses:
|
|
|
|
vAPI.webextFlavor.soup.has('firefox') &&
|
|
|
|
vAPI.webextFlavor.soup.has('mobile'),
|
2021-09-15 13:40:32 +02:00
|
|
|
|
2016-10-19 16:20:26 +02:00
|
|
|
set: function(details) {
|
2019-09-04 16:24:24 +02:00
|
|
|
for ( const setting in details ) {
|
2019-09-19 22:41:44 +02:00
|
|
|
if ( details.hasOwnProperty(setting) === false ) { continue; }
|
2016-10-19 16:20:26 +02:00
|
|
|
switch ( setting ) {
|
|
|
|
case 'prefetching':
|
2019-04-27 19:12:33 +02:00
|
|
|
const enabled = !!details[setting];
|
2019-09-19 22:41:44 +02:00
|
|
|
if ( enabled ) {
|
|
|
|
bp.network.networkPredictionEnabled.clear({
|
|
|
|
scope: 'regular',
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
bp.network.networkPredictionEnabled.set({
|
|
|
|
value: false,
|
|
|
|
scope: 'regular',
|
|
|
|
});
|
2016-10-19 16:20:26 +02:00
|
|
|
}
|
2019-04-27 19:12:33 +02:00
|
|
|
if ( vAPI.prefetching instanceof Function ) {
|
|
|
|
vAPI.prefetching(enabled);
|
|
|
|
}
|
2016-10-19 16:20:26 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'hyperlinkAuditing':
|
2019-09-19 22:41:44 +02:00
|
|
|
if ( !!details[setting] ) {
|
|
|
|
bp.websites.hyperlinkAuditingEnabled.clear({
|
|
|
|
scope: 'regular',
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
bp.websites.hyperlinkAuditingEnabled.set({
|
|
|
|
value: false,
|
|
|
|
scope: 'regular',
|
|
|
|
});
|
2016-10-19 16:20:26 +02:00
|
|
|
}
|
|
|
|
break;
|
2015-06-25 02:01:27 +02:00
|
|
|
|
2021-09-15 13:40:32 +02:00
|
|
|
case 'webrtcIPAddress':
|
2021-09-15 14:28:10 +02:00
|
|
|
if ( this.canLeakLocalIPAddresses === false ) { return; }
|
|
|
|
if ( !!details[setting] ) {
|
|
|
|
bp.network.webRTCIPHandlingPolicy.clear({
|
|
|
|
scope: 'regular',
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
bp.network.webRTCIPHandlingPolicy.set({
|
|
|
|
value: 'default_public_interface_only',
|
|
|
|
scope: 'regular'
|
|
|
|
});
|
|
|
|
}
|
2021-09-15 13:40:32 +02:00
|
|
|
break;
|
|
|
|
|
2016-10-19 16:20:26 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2015-06-01 21:03:22 +02:00
|
|
|
}
|
|
|
|
}
|
2016-10-19 16:20:26 +02:00
|
|
|
};
|
|
|
|
})();
|
2015-06-01 21:03:22 +02:00
|
|
|
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
2015-06-01 21:03:22 +02:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-04-05 18:03:14 +02:00
|
|
|
vAPI.isBehindTheSceneTabId = function(tabId) {
|
2018-02-26 19:59:16 +01:00
|
|
|
return tabId < 0;
|
2015-01-20 00:42:58 +01:00
|
|
|
};
|
|
|
|
|
2018-02-26 19:59:16 +01:00
|
|
|
vAPI.unsetTabId = 0;
|
|
|
|
vAPI.noTabId = -1; // definitely not any existing tab
|
2015-01-20 00:42:58 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
// To ensure we always use a good tab id
|
|
|
|
const toTabId = function(tabId) {
|
2019-07-21 16:48:44 +02:00
|
|
|
return typeof tabId === 'number' && isNaN(tabId) === false
|
|
|
|
? tabId
|
|
|
|
: 0;
|
2015-04-20 14:28:19 +02:00
|
|
|
};
|
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
// 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
|
2015-03-22 01:30:00 +01:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
vAPI.Tabs = class {
|
|
|
|
constructor() {
|
|
|
|
browser.webNavigation.onCreatedNavigationTarget.addListener(details => {
|
2021-07-15 17:34:37 +02:00
|
|
|
this.onCreatedNavigationTargetHandler(details);
|
2019-07-21 16:48:44 +02:00
|
|
|
});
|
|
|
|
browser.webNavigation.onCommitted.addListener(details => {
|
2021-07-15 17:34:37 +02:00
|
|
|
this.onCommittedHandler(details);
|
2019-07-21 16:48:44 +02:00
|
|
|
});
|
|
|
|
browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
|
2021-07-15 17:34:37 +02:00
|
|
|
this.onUpdatedHandler(tabId, changeInfo, tab);
|
2019-07-21 16:48:44 +02:00
|
|
|
});
|
2019-07-26 14:53:20 +02:00
|
|
|
browser.tabs.onActivated.addListener(details => {
|
|
|
|
this.onActivated(details);
|
2019-07-21 16:48:44 +02:00
|
|
|
});
|
2019-07-26 14:53:20 +02:00
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/151
|
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/680#issuecomment-515215220
|
|
|
|
if ( browser.windows instanceof Object ) {
|
2021-07-15 17:34:37 +02:00
|
|
|
browser.windows.onFocusChanged.addListener(windowId => {
|
|
|
|
this.onFocusChangedHandler(windowId);
|
2019-07-26 14:53:20 +02:00
|
|
|
});
|
|
|
|
}
|
2019-07-21 16:48:44 +02:00
|
|
|
browser.tabs.onRemoved.addListener((tabId, details) => {
|
2021-07-15 17:34:37 +02:00
|
|
|
this.onRemovedHandler(tabId, details);
|
2019-07-21 16:48:44 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-09-16 22:17:48 +02:00
|
|
|
async executeScript() {
|
|
|
|
let result;
|
|
|
|
try {
|
|
|
|
result = await webext.tabs.executeScript(...arguments);
|
|
|
|
}
|
|
|
|
catch(reason) {
|
|
|
|
}
|
|
|
|
return Array.isArray(result) ? result : [];
|
|
|
|
}
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
async get(tabId) {
|
2019-07-21 16:48:44 +02:00
|
|
|
if ( tabId === null ) {
|
2019-09-16 15:45:17 +02:00
|
|
|
return this.getCurrent();
|
2019-07-21 16:48:44 +02:00
|
|
|
}
|
2019-09-16 15:45:17 +02:00
|
|
|
if ( tabId <= 0 ) { return null; }
|
|
|
|
let tab;
|
|
|
|
try {
|
|
|
|
tab = await webext.tabs.get(tabId);
|
|
|
|
}
|
|
|
|
catch(reason) {
|
2019-07-21 16:48:44 +02:00
|
|
|
}
|
2019-09-16 15:45:17 +02:00
|
|
|
return tab instanceof Object ? tab : null;
|
|
|
|
}
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
async getCurrent() {
|
|
|
|
const tabs = await this.query({ active: true, currentWindow: true });
|
|
|
|
return tabs.length !== 0 ? tabs[0] : null;
|
|
|
|
}
|
|
|
|
|
2020-09-07 14:28:01 +02:00
|
|
|
async insertCSS(tabId, details) {
|
|
|
|
if ( vAPI.supportsUserStylesheets ) {
|
|
|
|
details.cssOrigin = 'user';
|
|
|
|
}
|
2019-09-16 22:17:48 +02:00
|
|
|
try {
|
|
|
|
await webext.tabs.insertCSS(...arguments);
|
|
|
|
}
|
|
|
|
catch(reason) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
async query(queryInfo) {
|
|
|
|
let tabs;
|
|
|
|
try {
|
|
|
|
tabs = await webext.tabs.query(queryInfo);
|
|
|
|
}
|
|
|
|
catch(reason) {
|
|
|
|
}
|
|
|
|
return Array.isArray(tabs) ? tabs : [];
|
2014-11-16 14:09:28 +01:00
|
|
|
}
|
2015-08-01 17:30:54 +02:00
|
|
|
|
2020-09-07 14:28:01 +02:00
|
|
|
async removeCSS(tabId, details) {
|
|
|
|
if ( vAPI.supportsUserStylesheets ) {
|
|
|
|
details.cssOrigin = 'user';
|
|
|
|
}
|
2019-09-16 22:17:48 +02:00
|
|
|
try {
|
|
|
|
await webext.tabs.removeCSS(...arguments);
|
|
|
|
}
|
|
|
|
catch(reason) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
// Properties of the details object:
|
|
|
|
// - url: 'URL', => the address that will be opened
|
2019-09-06 17:41:07 +02:00
|
|
|
// - 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
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
async create(url, details) {
|
2014-11-16 14:09:28 +01:00
|
|
|
if ( details.active === undefined ) {
|
|
|
|
details.active = true;
|
|
|
|
}
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
const subWrapper = async ( ) => {
|
2019-05-25 02:15:40 +02:00
|
|
|
const updateDetails = {
|
2019-07-21 16:48:44 +02:00
|
|
|
url: url,
|
2014-11-16 14:09:28 +01:00
|
|
|
active: !!details.active
|
2014-11-15 19:15:11 +01:00
|
|
|
};
|
|
|
|
|
2015-03-12 15:07:55 +01:00
|
|
|
// Opening a tab from incognito window won't focus the window
|
|
|
|
// in which the tab was opened
|
2019-05-25 02:15:40 +02:00
|
|
|
const focusWindow = tab => {
|
2019-09-16 15:45:17 +02:00
|
|
|
if ( tab.active && vAPI.windows instanceof Object ) {
|
|
|
|
vAPI.windows.update(tab.windowId, { focused: true });
|
2015-03-12 15:07:55 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-03-12 14:07:16 +01:00
|
|
|
if ( !details.tabId ) {
|
2014-11-16 14:09:28 +01:00
|
|
|
if ( details.index !== undefined ) {
|
2019-05-25 02:15:40 +02:00
|
|
|
updateDetails.index = details.index;
|
2014-11-16 14:09:28 +01:00
|
|
|
}
|
2019-05-25 02:15:40 +02:00
|
|
|
browser.tabs.create(updateDetails, focusWindow);
|
2015-03-12 14:07:16 +01:00
|
|
|
return;
|
2014-11-15 19:15:11 +01:00
|
|
|
}
|
|
|
|
|
2015-03-12 14:07:16 +01:00
|
|
|
// update doesn't accept index, must use move
|
2019-09-16 15:45:17 +02:00
|
|
|
const tab = await vAPI.tabs.update(
|
|
|
|
toTabId(details.tabId),
|
|
|
|
updateDetails
|
2019-05-25 02:15:40 +02:00
|
|
|
);
|
2019-09-16 15:45:17 +02:00
|
|
|
// 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 });
|
|
|
|
}
|
2015-03-12 14:07:16 +01:00
|
|
|
};
|
|
|
|
|
2015-07-01 18:18:03 +02:00
|
|
|
// Open in a standalone window
|
2018-12-14 17:01:21 +01:00
|
|
|
//
|
2018-08-15 00:47:59 +02:00
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/168#issuecomment-413038191
|
2019-09-16 15:45:17 +02:00
|
|
|
// Not all platforms support vAPI.windows.
|
2018-12-14 17:01:21 +01:00
|
|
|
//
|
|
|
|
// 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.
|
2019-09-16 15:45:17 +02:00
|
|
|
if ( details.popup !== undefined && vAPI.windows instanceof Object ) {
|
2019-05-25 02:15:40 +02:00
|
|
|
const createDetails = {
|
2018-12-14 17:01:21 +01:00
|
|
|
url: details.url,
|
2019-09-06 17:41:07 +02:00
|
|
|
type: details.popup,
|
2018-12-14 17:01:21 +01:00
|
|
|
};
|
|
|
|
if ( details.box instanceof Object ) {
|
2019-05-25 02:15:40 +02:00
|
|
|
Object.assign(createDetails, details.box);
|
2018-12-14 17:01:21 +01:00
|
|
|
}
|
2019-09-16 15:45:17 +02:00
|
|
|
const win = await vAPI.windows.create(createDetails);
|
|
|
|
if ( win === null ) { return; }
|
|
|
|
if ( details.box instanceof Object === false ) { return; }
|
|
|
|
if (
|
|
|
|
win.left === details.box.left &&
|
|
|
|
win.top === details.box.top
|
|
|
|
) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
vAPI.windows.update(win.id, {
|
|
|
|
left: details.box.left,
|
|
|
|
top: details.box.top
|
2018-12-14 17:01:21 +01:00
|
|
|
});
|
2015-07-01 18:18:03 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-03-12 14:07:16 +01:00
|
|
|
if ( details.index !== -1 ) {
|
2014-11-16 14:09:28 +01:00
|
|
|
subWrapper();
|
2015-03-12 14:07:16 +01:00
|
|
|
return;
|
2014-11-15 19:15:11 +01:00
|
|
|
}
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
const tab = await vAPI.tabs.getCurrent();
|
|
|
|
if ( tab !== null ) {
|
|
|
|
details.index = tab.index + 1;
|
|
|
|
} else {
|
|
|
|
details.index = undefined;
|
|
|
|
}
|
|
|
|
subWrapper();
|
2014-11-16 14:09:28 +01:00
|
|
|
}
|
2015-03-12 14:07:16 +01:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
// 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
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
async open(details) {
|
2019-07-21 16:48:44 +02:00
|
|
|
let targetURL = details.url;
|
|
|
|
if ( typeof targetURL !== 'string' || targetURL === '' ) {
|
|
|
|
return null;
|
|
|
|
}
|
2017-09-26 22:09:35 +02:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
// extension pages
|
|
|
|
if ( /^[\w-]{2,}:/.test(targetURL) !== true ) {
|
|
|
|
targetURL = vAPI.getURL(targetURL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !details.select ) {
|
|
|
|
this.create(targetURL, details);
|
2015-08-01 17:30:54 +02:00
|
|
|
return;
|
2015-03-12 14:07:16 +01:00
|
|
|
}
|
2019-07-21 16:48:44 +02:00
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query#Parameters
|
2019-07-21 16:48:44 +02:00
|
|
|
// "Note that fragment identifiers are not matched."
|
2019-09-18 14:34:55 +02:00
|
|
|
// Fragment identifiers ARE matched -- we need to remove the fragment.
|
2019-07-21 16:48:44 +02:00
|
|
|
const pos = targetURL.indexOf('#');
|
|
|
|
const targetURLWithoutHash = pos === -1
|
|
|
|
? targetURL
|
|
|
|
: targetURL.slice(0, pos);
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
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 });
|
2019-07-21 16:48:44 +02:00
|
|
|
}
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
async update() {
|
|
|
|
let tab;
|
|
|
|
try {
|
|
|
|
tab = await webext.tabs.update(...arguments);
|
|
|
|
}
|
|
|
|
catch (reason) {
|
|
|
|
}
|
|
|
|
return tab instanceof Object ? tab : null;
|
|
|
|
}
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
// Replace the URL of a tab. Noop if the tab does not exist.
|
2019-07-21 16:48:44 +02:00
|
|
|
replace(tabId, url) {
|
2019-09-16 15:45:17 +02:00
|
|
|
tabId = toTabId(tabId);
|
2019-07-21 16:48:44 +02:00
|
|
|
if ( tabId === 0 ) { return; }
|
2015-03-27 18:00:55 +01:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
let targetURL = url;
|
2015-04-20 14:28:19 +02:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
// extension pages
|
|
|
|
if ( /^[\w-]{2,}:/.test(targetURL) !== true ) {
|
|
|
|
targetURL = vAPI.getURL(targetURL);
|
|
|
|
}
|
2015-03-27 18:00:55 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
vAPI.tabs.update(tabId, { url: targetURL });
|
2015-03-27 18:00:55 +01:00
|
|
|
}
|
|
|
|
|
2019-09-19 22:41:44 +02:00
|
|
|
async remove(tabId) {
|
2019-09-16 15:45:17 +02:00
|
|
|
tabId = toTabId(tabId);
|
2019-07-21 16:48:44 +02:00
|
|
|
if ( tabId === 0 ) { return; }
|
2019-09-19 22:41:44 +02:00
|
|
|
try {
|
|
|
|
await webext.tabs.remove(tabId);
|
|
|
|
}
|
|
|
|
catch (reason) {
|
|
|
|
}
|
2019-07-21 16:48:44 +02:00
|
|
|
}
|
2015-03-27 18:00:55 +01:00
|
|
|
|
2019-09-19 22:41:44 +02:00
|
|
|
async reload(tabId, bypassCache = false) {
|
2019-09-16 15:45:17 +02:00
|
|
|
tabId = toTabId(tabId);
|
2019-07-21 16:48:44 +02:00
|
|
|
if ( tabId === 0 ) { return; }
|
2019-09-19 22:41:44 +02:00
|
|
|
try {
|
|
|
|
await webext.tabs.reload(
|
|
|
|
tabId,
|
|
|
|
{ bypassCache: bypassCache === true }
|
|
|
|
);
|
|
|
|
}
|
|
|
|
catch (reason) {
|
|
|
|
}
|
2019-07-21 16:48:44 +02:00
|
|
|
}
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
async select(tabId) {
|
|
|
|
tabId = toTabId(tabId);
|
2019-07-21 16:48:44 +02:00
|
|
|
if ( tabId === 0 ) { return; }
|
2019-09-16 15:45:17 +02:00
|
|
|
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 });
|
2019-07-21 16:48:44 +02:00
|
|
|
}
|
2015-04-20 14:28:19 +02:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
// 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);
|
|
|
|
}
|
2015-01-06 14:01:15 +01:00
|
|
|
|
2021-07-15 17:34:37 +02:00
|
|
|
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) {
|
2021-10-17 18:55:31 +02:00
|
|
|
// Ignore uninteresting update events
|
|
|
|
const { status = '', title = '', url = '' } = changeInfo;
|
|
|
|
if ( status === '' && title === '' && url === '' ) { return; }
|
2021-07-15 17:34:37 +02:00
|
|
|
// https://github.com/gorhill/uBlock/issues/3073
|
|
|
|
// Fall back to `tab.url` when `changeInfo.url` is not set.
|
2021-10-17 18:55:31 +02:00
|
|
|
if ( url === '' ) {
|
2021-07-15 17:34:37 +02:00
|
|
|
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 });
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
onActivated(/* details */) {
|
|
|
|
}
|
2015-05-25 00:50:09 +02:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
onClosed(/* tabId, details */) {
|
|
|
|
}
|
2015-05-25 00:50:09 +02:00
|
|
|
|
2019-09-23 14:25:23 +02:00
|
|
|
onCreated(/* details */) {
|
2019-07-21 16:48:44 +02:00
|
|
|
}
|
2015-05-25 00:50:09 +02:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
onNavigation(/* details */) {
|
|
|
|
}
|
2015-05-25 00:50:09 +02:00
|
|
|
|
2019-07-21 16:48:44 +02:00
|
|
|
onUpdated(/* tabId, changeInfo, tab */) {
|
2014-11-15 19:15:11 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
2014-11-15 19:15:11 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-23 15:29:17 +02:00
|
|
|
if ( webext.windows instanceof Object ) {
|
2019-09-16 15:45:17 +02:00
|
|
|
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;
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-23 15:29:17 +02:00
|
|
|
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) {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2014-11-15 19:15:11 +01:00
|
|
|
// Must read: https://code.google.com/p/chromium/issues/detail?id=410868#c8
|
|
|
|
|
2015-04-07 03:26:05 +02:00
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/19
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/207
|
2014-11-15 19:15:11 +01:00
|
|
|
// Since we may be called asynchronously, the tab id may not exist
|
|
|
|
// anymore, so this ensures it does still exist.
|
|
|
|
|
2017-07-24 17:35:22 +02:00
|
|
|
// https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/browserAction#Browser_compatibility
|
|
|
|
// Firefox for Android does no support browser.browserAction.setIcon().
|
2018-05-08 01:03:50 +02:00
|
|
|
// Performance: use ImageData for platforms supporting it.
|
2017-07-24 17:35:22 +02:00
|
|
|
|
2018-05-08 21:01:25 +02:00
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/32
|
|
|
|
// Ensure ImageData for toolbar icon is valid before use.
|
|
|
|
|
2019-08-10 16:57:24 +02:00
|
|
|
vAPI.setIcon = (( ) => {
|
2019-09-23 15:29:17 +02:00
|
|
|
const browserAction = vAPI.browserAction;
|
2019-08-10 16:57:24 +02:00
|
|
|
const titleTemplate =
|
|
|
|
browser.runtime.getManifest().browser_action.default_title +
|
|
|
|
' ({badge})';
|
2018-11-02 12:55:15 +01:00
|
|
|
const icons = [
|
2019-08-10 16:57:24 +02:00
|
|
|
{ path: { '16': 'img/icon_16-off.png', '32': 'img/icon_32-off.png' } },
|
|
|
|
{ path: { '16': 'img/icon_16.png', '32': 'img/icon_32.png' } },
|
2017-07-24 17:35:22 +02:00
|
|
|
];
|
|
|
|
|
2019-08-10 16:57:24 +02:00
|
|
|
(( ) => {
|
2018-05-08 01:03:50 +02:00
|
|
|
if ( browserAction.setIcon === undefined ) { return; }
|
2018-05-08 15:43:25 +02:00
|
|
|
|
2019-08-10 16:57:24 +02:00
|
|
|
// The global badge text and background color.
|
2018-05-08 15:43:25 +02:00
|
|
|
if ( browserAction.setBadgeBackgroundColor !== undefined ) {
|
2019-08-10 16:57:24 +02:00
|
|
|
browserAction.setBadgeBackgroundColor({ color: '#666666' });
|
|
|
|
}
|
|
|
|
if ( browserAction.setBadgeTextColor !== undefined ) {
|
|
|
|
browserAction.setBadgeTextColor({ color: '#FFFFFF' });
|
2018-05-08 15:43:25 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 14:08:19 +02:00
|
|
|
// 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; }
|
|
|
|
|
2018-11-02 12:55:15 +01:00
|
|
|
const imgs = [];
|
2018-05-27 17:13:25 +02:00
|
|
|
for ( let i = 0; i < icons.length; i++ ) {
|
2019-08-10 16:57:24 +02:00
|
|
|
const path = icons[i].path;
|
2018-11-02 12:55:15 +01:00
|
|
|
for ( const key in path ) {
|
2018-05-27 17:13:25 +02:00
|
|
|
if ( path.hasOwnProperty(key) === false ) { continue; }
|
|
|
|
imgs.push({ i: i, p: key });
|
|
|
|
}
|
|
|
|
}
|
2018-11-02 12:55:15 +01:00
|
|
|
|
|
|
|
// 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 ) {
|
2018-05-08 01:03:50 +02:00
|
|
|
if ( img.r.complete === false ) { return; }
|
|
|
|
}
|
2019-08-10 16:57:24 +02:00
|
|
|
const ctx = document.createElement('canvas').getContext('2d');
|
|
|
|
const iconData = [ null, null ];
|
2018-11-02 12:55:15 +01:00
|
|
|
for ( const img of imgs ) {
|
2019-08-10 16:57:24 +02:00
|
|
|
const w = img.r.naturalWidth, h = img.r.naturalHeight;
|
2018-05-08 01:03:50 +02:00
|
|
|
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] = {}; }
|
2018-11-02 12:55:15 +01:00
|
|
|
const imgData = safeGetImageData(ctx, w, h);
|
2018-05-08 21:01:25 +02:00
|
|
|
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;
|
2018-05-08 01:03:50 +02:00
|
|
|
}
|
2018-05-27 17:13:25 +02:00
|
|
|
for ( let i = 0; i < iconData.length; i++ ) {
|
|
|
|
if ( iconData[i] ) {
|
|
|
|
icons[i] = { imageData: iconData[i] };
|
|
|
|
}
|
|
|
|
}
|
2018-05-08 01:03:50 +02:00
|
|
|
};
|
2018-11-02 12:55:15 +01:00
|
|
|
for ( const img of imgs ) {
|
2018-05-08 01:03:50 +02:00
|
|
|
img.r = new Image();
|
|
|
|
img.r.addEventListener('load', onLoaded, { once: true });
|
|
|
|
img.r.src = icons[img.i].path[img.p];
|
|
|
|
}
|
|
|
|
})();
|
|
|
|
|
2019-09-16 15:45:17 +02:00
|
|
|
// parts: bit 0 = icon
|
|
|
|
// bit 1 = badge text
|
|
|
|
// bit 2 = badge color
|
|
|
|
// bit 3 = hide badge
|
|
|
|
|
|
|
|
return async function(tabId, details) {
|
|
|
|
tabId = toTabId(tabId);
|
|
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
|
|
|
|
const tab = await vAPI.tabs.get(tabId);
|
|
|
|
if ( tab === null ) { return; }
|
2017-07-24 17:35:22 +02:00
|
|
|
|
2019-08-10 16:57:24 +02:00
|
|
|
const { parts, state, badge, color } = details;
|
|
|
|
|
2017-07-25 15:16:48 +02:00
|
|
|
if ( browserAction.setIcon !== undefined ) {
|
2019-09-12 18:26:09 +02:00
|
|
|
if ( parts === undefined || (parts & 0b0001) !== 0 ) {
|
2018-05-27 17:13:25 +02:00
|
|
|
browserAction.setIcon(
|
|
|
|
Object.assign({ tabId: tab.id }, icons[state])
|
|
|
|
);
|
2017-09-06 01:51:16 +02:00
|
|
|
}
|
2019-09-12 18:26:09 +02:00
|
|
|
if ( (parts & 0b0010) !== 0 ) {
|
|
|
|
browserAction.setBadgeText({
|
|
|
|
tabId: tab.id,
|
|
|
|
text: (parts & 0b1000) === 0 ? badge : ''
|
|
|
|
});
|
2019-08-10 16:57:24 +02:00
|
|
|
}
|
2019-09-12 18:26:09 +02:00
|
|
|
if ( (parts & 0b0100) !== 0 ) {
|
2019-08-10 16:57:24 +02:00
|
|
|
browserAction.setBadgeBackgroundColor({ tabId: tab.id, color });
|
|
|
|
}
|
2017-07-25 15:16:48 +02:00
|
|
|
}
|
|
|
|
|
2020-01-23 15:16:09 +01:00
|
|
|
// 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 && (
|
|
|
|
browserAction.setIcon === undefined || (parts & 0b1000) !== 0
|
|
|
|
)
|
|
|
|
) {
|
2017-07-25 15:16:48 +02:00
|
|
|
browserAction.setTitle({
|
2017-09-06 01:51:16 +02:00
|
|
|
tabId: tab.id,
|
2017-07-24 17:35:22 +02:00
|
|
|
title: titleTemplate.replace(
|
|
|
|
'{badge}',
|
2018-05-08 15:43:25 +02:00
|
|
|
state === 1 ? (badge !== '' ? badge : '0') : 'off'
|
2017-07-24 17:35:22 +02:00
|
|
|
)
|
2014-12-26 21:41:44 +01:00
|
|
|
});
|
2014-11-15 19:15:11 +01:00
|
|
|
}
|
2014-12-26 21:41:44 +01:00
|
|
|
|
2017-07-25 01:25:49 +02:00
|
|
|
if ( vAPI.contextMenu instanceof Object ) {
|
|
|
|
vAPI.contextMenu.onMustUpdate(tabId);
|
|
|
|
}
|
2017-07-24 17:35:22 +02:00
|
|
|
};
|
|
|
|
})();
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
browser.browserAction.onClicked.addListener(function(tab) {
|
2017-07-25 01:25:49 +02:00
|
|
|
vAPI.tabs.open({
|
|
|
|
select: true,
|
2018-05-04 14:44:54 +02:00
|
|
|
url: 'popup.html?tabId=' + tab.id + '&responsive=1'
|
2017-07-25 01:25:49 +02:00
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
2014-11-15 19:15:11 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
// 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.
|
|
|
|
|
2014-11-15 19:15:11 +01:00
|
|
|
vAPI.messaging = {
|
2017-10-25 17:27:16 +02:00
|
|
|
ports: new Map(),
|
2019-09-01 18:43:12 +02:00
|
|
|
listeners: new Map(),
|
2014-11-16 14:09:28 +01:00
|
|
|
defaultHandler: null,
|
2019-09-01 18:43:12 +02:00
|
|
|
PRIVILEGED_URL: vAPI.getURL(''),
|
2019-09-19 22:41:44 +02:00
|
|
|
NOOPFUNC: function(){},
|
2019-09-01 18:43:12 +02:00
|
|
|
UNHANDLED: 'vAPI.messaging.notHandled',
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
listen: function(details) {
|
|
|
|
this.listeners.set(details.name, {
|
|
|
|
fn: details.listener,
|
|
|
|
privileged: details.privileged === true
|
|
|
|
});
|
|
|
|
},
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
onPortDisconnect: function(port) {
|
|
|
|
this.ports.delete(port.name);
|
|
|
|
},
|
2015-06-26 06:08:41 +02:00
|
|
|
|
2020-11-13 14:32:51 +01:00
|
|
|
// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/Port
|
|
|
|
// port.sender is always present for onConnect() listeners.
|
2019-09-01 18:43:12 +02:00
|
|
|
onPortConnect: function(port) {
|
2020-11-13 14:32:51 +01:00
|
|
|
port.onDisconnect.addListener(port =>
|
|
|
|
this.onPortDisconnect(port)
|
2019-09-01 18:43:12 +02:00
|
|
|
);
|
2020-11-13 14:32:51 +01:00
|
|
|
port.onMessage.addListener((request, port) =>
|
|
|
|
this.onPortMessage(request, port)
|
2019-09-01 18:43:12 +02:00
|
|
|
);
|
2020-11-12 18:14:59 +01:00
|
|
|
const portDetails = { port };
|
|
|
|
const sender = port.sender;
|
2020-11-13 14:32:51 +01:00
|
|
|
const { tab, url } = sender;
|
|
|
|
portDetails.frameId = sender.frameId;
|
|
|
|
portDetails.frameURL = url;
|
|
|
|
portDetails.privileged = url.startsWith(this.PRIVILEGED_URL);
|
|
|
|
if ( tab ) {
|
|
|
|
portDetails.tabId = tab.id;
|
|
|
|
portDetails.tabURL = tab.url;
|
2020-11-12 18:14:59 +01:00
|
|
|
}
|
|
|
|
this.ports.set(port.name, portDetails);
|
|
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1652925#c24
|
|
|
|
port.sender = undefined;
|
2019-09-01 18:43:12 +02:00
|
|
|
},
|
2015-06-26 06:08:41 +02:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
setup: function(defaultHandler) {
|
|
|
|
if ( this.defaultHandler !== null ) { return; }
|
2017-09-16 16:55:28 +02:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
if ( typeof defaultHandler !== 'function' ) {
|
|
|
|
defaultHandler = function() {
|
|
|
|
return this.UNHANDLED;
|
|
|
|
};
|
2015-06-29 16:46:20 +02:00
|
|
|
}
|
2019-09-01 18:43:12 +02:00
|
|
|
this.defaultHandler = defaultHandler;
|
2015-06-29 16:46:20 +02:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
browser.runtime.onConnect.addListener(
|
|
|
|
port => this.onPortConnect(port)
|
|
|
|
);
|
2015-06-26 06:08:41 +02:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
// 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 => {
|
2020-11-13 14:32:51 +01:00
|
|
|
for ( const { port, tabId: portTabId } of this.ports.values() ) {
|
|
|
|
if ( portTabId !== tabId ) { continue; }
|
|
|
|
this.onPortDisconnect(port);
|
2019-09-01 18:43:12 +02:00
|
|
|
}
|
|
|
|
});
|
2015-06-29 16:46:20 +02:00
|
|
|
}
|
2019-09-01 18:43:12 +02:00
|
|
|
},
|
|
|
|
|
|
|
|
broadcast: function(message) {
|
|
|
|
const messageWrapper = { broadcast: true, msg: message };
|
|
|
|
for ( const { port } of this.ports.values() ) {
|
|
|
|
try {
|
|
|
|
port.postMessage(messageWrapper);
|
|
|
|
} catch(ex) {
|
2020-12-02 16:07:14 +01:00
|
|
|
this.onPortDisconnect(port);
|
2019-09-01 18:43:12 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
2015-06-26 06:08:41 +02:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
onFrameworkMessage: function(request, port, callback) {
|
2020-11-12 18:14:59 +01:00
|
|
|
const portDetails = this.ports.get(port.name) || {};
|
|
|
|
const tabId = portDetails.tabId;
|
2019-09-01 18:43:12 +02:00
|
|
|
const msg = request.msg;
|
2017-07-23 17:33:39 +02:00
|
|
|
switch ( msg.what ) {
|
2017-11-20 14:42:32 +01:00
|
|
|
case 'connectionAccepted':
|
2019-09-01 18:43:12 +02:00
|
|
|
case 'connectionRefused': {
|
2019-09-19 14:31:38 +02:00
|
|
|
const toPort = this.ports.get(msg.fromToken);
|
2017-11-20 14:42:32 +01:00
|
|
|
if ( toPort !== undefined ) {
|
2018-02-26 19:59:16 +01:00
|
|
|
msg.tabId = tabId;
|
2019-09-19 14:31:38 +02:00
|
|
|
toPort.port.postMessage(request);
|
2017-11-20 14:42:32 +01:00
|
|
|
} else {
|
|
|
|
msg.what = 'connectionBroken';
|
|
|
|
port.postMessage(request);
|
|
|
|
}
|
|
|
|
break;
|
2019-09-01 18:43:12 +02:00
|
|
|
}
|
2017-11-20 14:42:32 +01:00
|
|
|
case 'connectionRequested':
|
2018-02-26 19:59:16 +01:00
|
|
|
msg.tabId = tabId;
|
2019-09-01 18:43:12 +02:00
|
|
|
for ( const { port: toPort } of this.ports.values() ) {
|
2019-09-19 14:31:38 +02:00
|
|
|
if ( toPort === port ) { continue; }
|
2020-12-02 16:07:14 +01:00
|
|
|
try {
|
|
|
|
toPort.postMessage(request);
|
|
|
|
} catch (ex) {
|
|
|
|
this.onPortDisconnect(toPort);
|
|
|
|
}
|
2017-11-20 14:42:32 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'connectionBroken':
|
|
|
|
case 'connectionCheck':
|
2019-09-01 18:43:12 +02:00
|
|
|
case 'connectionMessage': {
|
2019-09-19 14:31:38 +02:00
|
|
|
const toPort = this.ports.get(
|
2017-11-20 14:42:32 +01:00
|
|
|
port.name === msg.fromToken ? msg.toToken : msg.fromToken
|
|
|
|
);
|
|
|
|
if ( toPort !== undefined ) {
|
2018-02-26 19:59:16 +01:00
|
|
|
msg.tabId = tabId;
|
2019-09-19 14:31:38 +02:00
|
|
|
toPort.port.postMessage(request);
|
2017-11-20 14:42:32 +01:00
|
|
|
} else {
|
|
|
|
msg.what = 'connectionBroken';
|
|
|
|
port.postMessage(request);
|
|
|
|
}
|
|
|
|
break;
|
2019-09-01 18:43:12 +02:00
|
|
|
}
|
2019-09-19 14:31:38 +02:00
|
|
|
case 'extendClient':
|
|
|
|
vAPI.tabs.executeScript(tabId, {
|
|
|
|
file: '/js/vapi-client-extra.js',
|
2020-12-05 21:26:29 +01:00
|
|
|
frameId: portDetails.frameId,
|
2019-09-19 14:31:38 +02:00
|
|
|
}).then(( ) => {
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
break;
|
2020-04-15 21:55:29 +02:00
|
|
|
case 'localStorage': {
|
2020-11-12 18:14:59 +01:00
|
|
|
if ( portDetails.privileged !== true ) { break; }
|
2020-04-15 21:55:29 +02:00
|
|
|
const args = msg.args || [];
|
|
|
|
vAPI.localStorage[msg.fn](...args).then(result => {
|
|
|
|
callback(result);
|
|
|
|
});
|
|
|
|
break;
|
|
|
|
}
|
2017-07-23 17:33:39 +02:00
|
|
|
case 'userCSS':
|
2018-01-08 20:29:39 +01:00
|
|
|
if ( tabId === undefined ) { break; }
|
2019-09-16 22:17:48 +02:00
|
|
|
const promises = [];
|
2020-12-02 16:46:59 +01:00
|
|
|
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));
|
|
|
|
}
|
2017-09-06 01:51:16 +02:00
|
|
|
}
|
2020-12-02 16:46:59 +01:00
|
|
|
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));
|
|
|
|
}
|
2017-11-22 00:08:32 +01:00
|
|
|
}
|
2019-09-16 22:17:48 +02:00
|
|
|
Promise.all(promises).then(( ) => {
|
2018-04-12 23:32:38 +02:00
|
|
|
callback();
|
2019-09-16 22:17:48 +02:00
|
|
|
});
|
2017-07-23 17:33:39 +02:00
|
|
|
break;
|
|
|
|
}
|
2019-09-01 18:43:12 +02:00
|
|
|
},
|
2017-07-23 17:33:39 +02:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
// Use a wrapper to avoid closure and to allow reuse.
|
|
|
|
CallbackWrapper: class {
|
2019-09-17 23:43:52 +02:00
|
|
|
constructor(messaging, port, msgId) {
|
2019-09-01 18:43:12 +02:00
|
|
|
this.messaging = messaging;
|
|
|
|
this.callback = this.proxy.bind(this); // bind once
|
2019-09-17 23:43:52 +02:00
|
|
|
this.init(port, msgId);
|
2019-09-01 18:43:12 +02:00
|
|
|
}
|
2019-09-17 23:43:52 +02:00
|
|
|
init(port, msgId) {
|
2019-09-01 18:43:12 +02:00
|
|
|
this.port = port;
|
2019-09-17 23:43:52 +02:00
|
|
|
this.msgId = msgId;
|
2019-09-01 18:43:12 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
proxy(response) {
|
|
|
|
// https://github.com/chrisaljoudi/uBlock/issues/383
|
2021-07-19 17:25:52 +02:00
|
|
|
try {
|
2019-09-01 18:43:12 +02:00
|
|
|
this.port.postMessage({
|
2019-09-17 23:43:52 +02:00
|
|
|
msgId: this.msgId,
|
|
|
|
msg: response !== undefined ? response : null,
|
2019-09-01 18:43:12 +02:00
|
|
|
});
|
2021-07-19 17:25:52 +02:00
|
|
|
} catch (ex) {
|
|
|
|
this.messaging.onPortDisconnect(this.port);
|
2017-11-20 14:42:32 +01:00
|
|
|
}
|
2019-09-01 18:43:12 +02:00
|
|
|
// Store for reuse
|
2019-09-17 23:43:52 +02:00
|
|
|
this.port = null;
|
2019-09-01 18:43:12 +02:00
|
|
|
this.messaging.callbackWrapperJunkyard.push(this);
|
2015-06-29 16:46:20 +02:00
|
|
|
}
|
2019-09-01 18:43:12 +02:00
|
|
|
},
|
|
|
|
|
|
|
|
callbackWrapperJunkyard: [],
|
|
|
|
|
2019-09-17 23:43:52 +02:00
|
|
|
callbackWrapperFactory: function(port, msgId) {
|
2019-09-01 18:43:12 +02:00
|
|
|
return this.callbackWrapperJunkyard.length !== 0
|
2019-09-17 23:43:52 +02:00
|
|
|
? this.callbackWrapperJunkyard.pop().init(port, msgId)
|
|
|
|
: new this.CallbackWrapper(this, port, msgId);
|
2019-09-01 18:43:12 +02:00
|
|
|
},
|
2014-11-16 14:09:28 +01:00
|
|
|
|
2019-09-01 18:43:12 +02:00
|
|
|
onPortMessage: function(request, port) {
|
2017-11-22 00:08:32 +01:00
|
|
|
// prepare response
|
2019-09-01 18:43:12 +02:00
|
|
|
let callback = this.NOOPFUNC;
|
2019-09-17 23:43:52 +02:00
|
|
|
if ( request.msgId !== undefined ) {
|
|
|
|
callback = this.callbackWrapperFactory(port, request.msgId).callback;
|
2015-06-29 16:46:20 +02:00
|
|
|
}
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2017-11-22 00:08:32 +01:00
|
|
|
// Content process to main process: framework handler.
|
2019-09-19 14:31:38 +02:00
|
|
|
if ( request.channel === 'vapi' ) {
|
2019-09-01 18:43:12 +02:00
|
|
|
this.onFrameworkMessage(request, port, callback);
|
2017-11-22 00:08:32 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-06-29 16:46:20 +02:00
|
|
|
// Auxiliary process to main process: specific handler
|
2020-11-12 18:14:59 +01:00
|
|
|
const portDetails = this.ports.get(port.name);
|
|
|
|
if ( portDetails === undefined ) { return; }
|
2019-09-01 18:43:12 +02:00
|
|
|
|
2019-09-19 14:31:38 +02:00
|
|
|
const listenerDetails = this.listeners.get(request.channel);
|
2019-09-01 18:43:12 +02:00
|
|
|
let r = this.UNHANDLED;
|
|
|
|
if (
|
|
|
|
(listenerDetails !== undefined) &&
|
2020-11-12 18:14:59 +01:00
|
|
|
(listenerDetails.privileged === false || portDetails.privileged)
|
2019-09-01 18:43:12 +02:00
|
|
|
|
|
|
|
) {
|
2020-11-12 18:14:59 +01:00
|
|
|
r = listenerDetails.fn(request.msg, portDetails, callback);
|
2015-06-29 16:46:20 +02:00
|
|
|
}
|
2017-10-25 17:27:16 +02:00
|
|
|
if ( r !== this.UNHANDLED ) { return; }
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2015-06-29 16:46:20 +02:00
|
|
|
// Auxiliary process to main process: default handler
|
2020-11-12 18:14:59 +01:00
|
|
|
if ( portDetails.privileged ) {
|
|
|
|
r = this.defaultHandler(request.msg, portDetails, callback);
|
2019-09-01 18:43:12 +02:00
|
|
|
if ( r !== this.UNHANDLED ) { return; }
|
|
|
|
}
|
2014-11-15 19:15:11 +01:00
|
|
|
|
2015-06-29 16:46:20 +02:00
|
|
|
// Auxiliary process to main process: no handler
|
2021-08-03 18:08:59 +02:00
|
|
|
ubolog(
|
2019-09-01 18:43:12 +02:00
|
|
|
`vAPI.messaging.onPortMessage > unhandled request: ${JSON.stringify(request.msg)}`,
|
2017-10-25 17:27:16 +02:00
|
|
|
request
|
|
|
|
);
|
2014-11-18 14:35:42 +01:00
|
|
|
|
2015-06-29 16:46:20 +02:00
|
|
|
// Need to callback anyways in case caller expected an answer, or
|
|
|
|
// else there is a memory leak on caller's side
|
|
|
|
callback();
|
2019-09-01 18:43:12 +02:00
|
|
|
},
|
2014-11-15 19:15:11 +01:00
|
|
|
};
|
|
|
|
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
2018-02-15 23:25:38 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
// https://github.com/gorhill/uBlock/issues/3474
|
|
|
|
// https://github.com/gorhill/uBlock/issues/2823
|
2019-04-30 20:36:07 +02:00
|
|
|
// Foil ability of web pages to identify uBO through
|
2018-02-15 23:25:38 +01:00
|
|
|
// its web accessible resources.
|
|
|
|
// https://github.com/gorhill/uBlock/issues/3497
|
2019-04-30 20:36:07 +02:00
|
|
|
// Prevent web pages from interfering with uBO's element picker
|
|
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/550
|
2019-06-30 16:09:27 +02:00
|
|
|
// Support using a new secret for every network request.
|
2018-02-15 23:25:38 +01:00
|
|
|
|
2019-06-30 16:09:27 +02:00
|
|
|
vAPI.warSecret = (( ) => {
|
2019-04-30 20:36:07 +02:00
|
|
|
const generateSecret = ( ) => {
|
2019-09-01 18:43:12 +02:00
|
|
|
return Math.floor(Math.random() * 982451653 + 982451653).toString(36);
|
2019-04-30 20:36:07 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
const root = vAPI.getURL('/');
|
2019-05-01 13:41:04 +02:00
|
|
|
const secrets = [];
|
|
|
|
let lastSecretTime = 0;
|
2019-04-30 20:36:07 +02:00
|
|
|
|
|
|
|
const guard = function(details) {
|
|
|
|
const url = details.url;
|
2019-05-01 13:41:04 +02:00
|
|
|
const pos = secrets.findIndex(secret =>
|
|
|
|
url.lastIndexOf(`?secret=${secret}`) !== -1
|
|
|
|
);
|
|
|
|
if ( pos === -1 ) {
|
Add new filter option `queryprune=`
Related issue:
- https://github.com/uBlockOrigin/uBlock-issues/issues/760
The purpose of this new network filter option is to remove
query parameters form the URL of network requests.
The name `queryprune` has been picked over `querystrip`
since the purpose of the option is to remove some
parameters from the URL rather than all parameters.
`queryprune` is a modifier option (like `csp`) in that it
does not cause a network request to be blocked but rather
modified before being emitted.
`queryprune` must be assigned a value, which value will
determine which parameters from a query string will be
removed. The syntax for the value is that of regular
expression *except* for the following rules:
- do not wrap the regex directive between `/`
- do not use regex special values `^` and `$`
- do not use literal comma character in the value,
though you can use hex-encoded version, `\x2c`
- to match the start of a query parameter, prepend `|`
- to match the end of a query parameter, append `|`
`queryprune` regex-like values will be tested against each
key-value parameter pair as `[key]=[value]` string. This
way you can prune according to either the key, the value,
or both.
This commit introduces the concept of modifier filter
options, which as of now are:
- `csp=`
- `queryprune=`
They both work in similar way when used with `important`
option or when used in exception filters. Modifier
options can apply to any network requests, hence the
logger reports the type of the network requests, and no
longer use the modifier as the type, i.e. `csp` filters
are no longer reported as requests of type `csp`.
Though modifier options can apply to any network requests,
for the time being the `csp=` modifier option still apply
only to top or embedded (frame) documents, just as before.
In some future we may want to apply `csp=` directives to
network requests of type script, to control the behavior
of service workers for example.
A new built-in filter expression has been added to the
logger: "modified", which allow to see all the network
requests which were modified before being emitted. The
translation work for this new option will be available
in a future commit.
2020-10-31 15:42:53 +01:00
|
|
|
return { cancel: true };
|
2018-02-15 23:25:38 +01:00
|
|
|
}
|
2019-05-01 13:41:04 +02:00
|
|
|
secrets.splice(pos, 1);
|
2018-02-15 23:25:38 +01:00
|
|
|
};
|
|
|
|
|
2019-06-30 16:09:27 +02:00
|
|
|
browser.webRequest.onBeforeRequest.addListener(
|
2018-02-15 23:25:38 +01:00
|
|
|
guard,
|
|
|
|
{
|
|
|
|
urls: [ root + 'web_accessible_resources/*' ]
|
|
|
|
},
|
|
|
|
[ 'blocking' ]
|
|
|
|
);
|
2019-04-30 20:36:07 +02:00
|
|
|
|
|
|
|
return ( ) => {
|
2019-05-01 13:41:04 +02:00
|
|
|
if ( secrets.length !== 0 ) {
|
|
|
|
if ( (Date.now() - lastSecretTime) > 5000 ) {
|
|
|
|
secrets.splice(0);
|
|
|
|
} else if ( secrets.length > 256 ) {
|
|
|
|
secrets.splice(0, secrets.length - 192);
|
|
|
|
}
|
2019-04-30 20:36:07 +02:00
|
|
|
}
|
2019-05-01 13:41:04 +02:00
|
|
|
lastSecretTime = Date.now();
|
|
|
|
const secret = generateSecret();
|
|
|
|
secrets.push(secret);
|
2020-11-10 16:43:26 +01:00
|
|
|
return secret;
|
2019-04-30 20:36:07 +02:00
|
|
|
};
|
2018-02-15 23:25:38 +01:00
|
|
|
})();
|
|
|
|
|
2019-06-30 16:09:27 +02:00
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
vAPI.Net = class {
|
|
|
|
constructor() {
|
|
|
|
this.validTypes = new Set();
|
|
|
|
{
|
|
|
|
const wrrt = browser.webRequest.ResourceType;
|
|
|
|
for ( const typeKey in wrrt ) {
|
2018-10-28 14:58:25 +01:00
|
|
|
if ( wrrt.hasOwnProperty(typeKey) ) {
|
2019-06-30 16:09:27 +02:00
|
|
|
this.validTypes.add(wrrt[typeKey]);
|
2018-10-28 14:58:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
this.suspendableListener = undefined;
|
|
|
|
this.listenerMap = new WeakMap();
|
|
|
|
this.suspendDepth = 0;
|
|
|
|
|
|
|
|
browser.webRequest.onBeforeRequest.addListener(
|
|
|
|
details => {
|
|
|
|
this.normalizeDetails(details);
|
2019-11-19 18:05:33 +01:00
|
|
|
if ( this.suspendDepth !== 0 && details.tabId >= 0 ) {
|
|
|
|
return this.suspendOneRequest(details);
|
2019-06-30 16:09:27 +02:00
|
|
|
}
|
2019-11-19 18:05:33 +01:00
|
|
|
return this.onBeforeSuspendableRequest(details);
|
2019-06-30 16:09:27 +02:00
|
|
|
},
|
|
|
|
this.denormalizeFilters({ urls: [ 'http://*/*', 'https://*/*' ] }),
|
|
|
|
[ 'blocking' ]
|
|
|
|
);
|
|
|
|
}
|
2019-11-19 18:05:33 +01:00
|
|
|
setOptions(/* options */) {
|
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
normalizeDetails(/* details */) {
|
|
|
|
}
|
|
|
|
denormalizeFilters(filters) {
|
|
|
|
const urls = filters.urls || [ '<all_urls>' ];
|
|
|
|
let types = filters.types;
|
|
|
|
if ( Array.isArray(types) ) {
|
|
|
|
types = this.denormalizeTypes(types);
|
2018-10-28 14:58:25 +01:00
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
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://*/*');
|
|
|
|
}
|
2018-10-28 14:58:25 +01:00
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
return { types, urls };
|
|
|
|
}
|
|
|
|
denormalizeTypes(types) {
|
|
|
|
return types;
|
|
|
|
}
|
2019-12-31 22:36:51 +01:00
|
|
|
canonicalNameFromHostname(/* hn */) {
|
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
addListener(which, clientListener, filters, options) {
|
|
|
|
const actualFilters = this.denormalizeFilters(filters);
|
|
|
|
const actualListener = this.makeNewListenerProxy(clientListener);
|
2018-10-28 14:58:25 +01:00
|
|
|
browser.webRequest[which].addListener(
|
2019-06-30 16:09:27 +02:00
|
|
|
actualListener,
|
|
|
|
actualFilters,
|
2018-10-28 14:58:25 +01:00
|
|
|
options
|
|
|
|
);
|
2019-06-30 16:09:27 +02:00
|
|
|
}
|
2019-11-19 18:05:33 +01:00
|
|
|
onBeforeSuspendableRequest(details) {
|
|
|
|
if ( this.suspendableListener === undefined ) { return; }
|
|
|
|
return this.suspendableListener(details);
|
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
setSuspendableListener(listener) {
|
|
|
|
this.suspendableListener = listener;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
suspendOneRequest() {
|
|
|
|
}
|
|
|
|
unsuspendAllRequests() {
|
|
|
|
}
|
|
|
|
suspend(force = false) {
|
|
|
|
if ( this.canSuspend() || force ) {
|
|
|
|
this.suspendDepth += 1;
|
2018-10-28 14:58:25 +01:00
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
}
|
2019-10-27 16:41:08 +01:00
|
|
|
unsuspend(all = false) {
|
2019-06-30 16:09:27 +02:00
|
|
|
if ( this.suspendDepth === 0 ) { return; }
|
2019-10-27 16:41:08 +01:00
|
|
|
if ( all ) {
|
|
|
|
this.suspendDepth = 0;
|
|
|
|
} else {
|
|
|
|
this.suspendDepth -= 1;
|
|
|
|
}
|
2019-06-30 16:09:27 +02:00
|
|
|
if ( this.suspendDepth !== 0 ) { return; }
|
2019-11-19 18:05:33 +01:00
|
|
|
this.unsuspendAllRequests();
|
2019-06-30 16:09:27 +02:00
|
|
|
}
|
|
|
|
canSuspend() {
|
|
|
|
return false;
|
|
|
|
}
|
2018-10-28 14:58:25 +01:00
|
|
|
};
|
|
|
|
|
2018-02-15 23:25:38 +01:00
|
|
|
/******************************************************************************/
|
2014-11-15 19:15:11 +01:00
|
|
|
/******************************************************************************/
|
2015-02-01 15:03:43 +01:00
|
|
|
|
2017-07-24 17:35:22 +02:00
|
|
|
// https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/contextMenus#Browser_compatibility
|
|
|
|
// Firefox for Android does no support browser.contextMenus.
|
|
|
|
|
2019-09-20 13:59:21 +02:00
|
|
|
vAPI.contextMenu = webext.menus && {
|
2016-01-17 19:30:43 +01:00
|
|
|
_callback: null,
|
2021-07-15 19:14:37 +02:00
|
|
|
_hash: '',
|
2016-01-17 19:30:43 +01:00
|
|
|
onMustUpdate: function() {},
|
|
|
|
setEntries: function(entries, callback) {
|
|
|
|
entries = entries || [];
|
2021-07-15 19:14:37 +02:00
|
|
|
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;
|
2016-01-17 19:30:43 +01:00
|
|
|
callback = callback || null;
|
2021-07-15 19:14:37 +02:00
|
|
|
if ( callback === this._callback ) { return; }
|
2016-01-17 19:30:43 +01:00
|
|
|
if ( n !== 0 && callback !== null ) {
|
2019-09-19 22:41:44 +02:00
|
|
|
webext.menus.onClicked.addListener(callback);
|
2016-01-17 19:30:43 +01:00
|
|
|
this._callback = callback;
|
|
|
|
} else if ( n === 0 && this._callback !== null ) {
|
2019-09-19 22:41:44 +02:00
|
|
|
webext.menus.onClicked.removeListener(this._callback);
|
2016-01-17 19:30:43 +01:00
|
|
|
this._callback = null;
|
|
|
|
}
|
2014-11-15 19:15:11 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
2014-11-15 19:15:11 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
vAPI.commands = browser.commands;
|
2017-05-27 17:51:24 +02:00
|
|
|
|
|
|
|
/******************************************************************************/
|
2015-08-11 21:29:14 +02:00
|
|
|
/******************************************************************************/
|
|
|
|
|
2015-10-21 19:30:04 +02:00
|
|
|
// https://github.com/gorhill/uBlock/issues/531
|
2019-09-15 13:58:28 +02:00
|
|
|
// Storage area dedicated to admin settings. Read-only.
|
2015-10-21 19:30:04 +02:00
|
|
|
|
2015-10-24 15:20:39 +02:00
|
|
|
// https://github.com/gorhill/uBlock/commit/43a5ed735b95a575a9339b6e71a1fcb27a99663b#commitcomment-13965030
|
|
|
|
// Not all Chromium-based browsers support managed storage. Merely testing or
|
2015-10-24 15:37:43 +02:00
|
|
|
// 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.
|
2015-11-03 13:44:18 +01:00
|
|
|
// https://github.com/gorhill/uBlock/issues/900
|
|
|
|
// Also, UC Browser: http://www.upsieutoc.com/image/WXuH
|
2015-10-24 15:20:39 +02:00
|
|
|
|
2019-09-15 13:58:28 +02:00
|
|
|
vAPI.adminStorage = (( ) => {
|
2019-09-16 15:45:17 +02:00
|
|
|
if ( webext.storage.managed instanceof Object === false ) {
|
2019-09-15 13:58:28 +02:00
|
|
|
return {
|
2021-01-04 13:54:24 +01:00
|
|
|
get: function() {
|
2019-09-15 13:58:28 +02:00
|
|
|
return Promise.resolve();
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
return {
|
2021-01-04 13:54:24 +01:00
|
|
|
get: async function(key) {
|
2019-09-15 13:58:28 +02:00
|
|
|
let bin;
|
|
|
|
try {
|
2019-09-16 15:45:17 +02:00
|
|
|
bin = await webext.storage.managed.get(key);
|
2019-09-15 13:58:28 +02:00
|
|
|
} catch(ex) {
|
|
|
|
}
|
2021-01-05 18:16:50 +01:00
|
|
|
if ( typeof key === 'string' && bin instanceof Object ) {
|
2019-09-16 15:45:17 +02:00
|
|
|
return bin[key];
|
2015-10-24 15:20:39 +02:00
|
|
|
}
|
2021-01-05 18:16:50 +01:00
|
|
|
return bin;
|
2015-11-03 14:46:21 +01:00
|
|
|
}
|
2019-09-15 13:58:28 +02:00
|
|
|
};
|
|
|
|
})();
|
|
|
|
|
2015-10-21 19:30:04 +02:00
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2020-04-15 21:55:29 +02:00
|
|
|
// 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 = webext.storage.local.get('localStorage').then(bin => {
|
2020-10-10 20:18:19 +02:00
|
|
|
this.cache = bin instanceof Object &&
|
|
|
|
bin.localStorage instanceof Object
|
|
|
|
? bin.localStorage
|
|
|
|
: {};
|
2020-04-15 21:55:29 +02:00
|
|
|
});
|
|
|
|
return this.cache;
|
|
|
|
},
|
|
|
|
clear: function() {
|
|
|
|
this.cache = {};
|
|
|
|
return webext.storage.local.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 webext.storage.local.set({ localStorage: this.cache });
|
|
|
|
},
|
|
|
|
cache: undefined,
|
|
|
|
};
|
|
|
|
|
|
|
|
vAPI.localStorage.start();
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
// 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; }
|
2016-10-19 16:20:26 +02:00
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
// 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;
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
const chunkCountPerFetch = 16; // Must be a power of 2
|
|
|
|
const maxChunkCountPerItem = Math.floor(MAX_ITEMS * 0.75) & ~(chunkCountPerFetch - 1);
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2017-09-27 14:42:27 +02:00
|
|
|
// https://github.com/gorhill/uBlock/issues/3006
|
2019-09-18 14:34:55 +02:00
|
|
|
// 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() {
|
2018-04-04 18:42:01 +02:00
|
|
|
return Math.floor(
|
2019-09-18 14:34:55 +02:00
|
|
|
QUOTA_BYTES_PER_ITEM *
|
2018-04-05 13:29:15 +02:00
|
|
|
(vAPI.webextFlavor.soup.has('firefox') ? 0.6 : 0.75)
|
2018-04-04 18:42:01 +02:00
|
|
|
);
|
2017-09-27 14:42:27 +02:00
|
|
|
};
|
|
|
|
|
2018-08-25 18:57:21 +02:00
|
|
|
let maxChunkSize = evalMaxChunkSize();
|
2018-04-04 18:42:01 +02:00
|
|
|
|
|
|
|
// 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 });
|
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
const options = {
|
2015-08-12 00:48:52 +02:00
|
|
|
defaultDeviceName: window.navigator.platform,
|
2020-02-20 22:40:29 +01:00
|
|
|
deviceName: undefined,
|
|
|
|
};
|
|
|
|
|
2020-02-25 13:37:12 +01:00
|
|
|
vAPI.localStorage.getItemAsync('deviceName').then(value => {
|
|
|
|
options.deviceName = value;
|
|
|
|
});
|
2015-08-11 21:29:14 +02:00
|
|
|
|
|
|
|
// 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
|
2015-10-03 15:46:45 +02:00
|
|
|
// good thing given chrome.storage.sync.MAX_WRITE_OPERATIONS_PER_MINUTE
|
|
|
|
// and chrome.storage.sync.MAX_WRITE_OPERATIONS_PER_HOUR.
|
2015-08-12 00:48:52 +02:00
|
|
|
|
2020-08-16 17:53:55 +02:00
|
|
|
const getCoarseChunkCount = async function(datakey) {
|
2019-09-18 14:34:55 +02:00
|
|
|
const keys = {};
|
2018-08-25 18:57:21 +02:00
|
|
|
for ( let i = 0; i < maxChunkCountPerItem; i += 16 ) {
|
2020-08-16 17:53:55 +02:00
|
|
|
keys[datakey + i.toString()] = '';
|
2015-08-11 21:29:14 +02:00
|
|
|
}
|
2019-09-18 14:34:55 +02:00
|
|
|
let bin;
|
|
|
|
try {
|
|
|
|
bin = await webext.storage.sync.get(keys);
|
|
|
|
} catch (reason) {
|
|
|
|
return reason;
|
|
|
|
}
|
|
|
|
let chunkCount = 0;
|
|
|
|
for ( let i = 0; i < maxChunkCountPerItem; i += 16 ) {
|
2020-08-16 17:53:55 +02:00
|
|
|
if ( bin[datakey + i.toString()] === '' ) { break; }
|
2019-09-18 14:34:55 +02:00
|
|
|
chunkCount = i + 16;
|
|
|
|
}
|
|
|
|
return chunkCount;
|
2015-08-11 21:29:14 +02:00
|
|
|
};
|
|
|
|
|
2020-08-21 15:18:33 +02:00
|
|
|
const deleteChunks = async function(datakey, start) {
|
2019-09-18 14:34:55 +02:00
|
|
|
const keys = [];
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2020-08-24 17:47:57 +02:00
|
|
|
const n = await getCoarseChunkCount(datakey);
|
2018-08-25 18:57:21 +02:00
|
|
|
for ( let i = start; i < n; i++ ) {
|
2020-08-16 17:53:55 +02:00
|
|
|
keys.push(datakey + i.toString());
|
2015-08-11 21:29:14 +02:00
|
|
|
}
|
2017-09-29 14:49:22 +02:00
|
|
|
if ( keys.length !== 0 ) {
|
2019-09-18 14:34:55 +02:00
|
|
|
webext.storage.sync.remove(keys);
|
2017-09-29 14:49:22 +02:00
|
|
|
}
|
2015-08-11 21:29:14 +02:00
|
|
|
};
|
|
|
|
|
2020-08-16 17:53:55 +02:00
|
|
|
const push = async function(details) {
|
|
|
|
const { datakey, data, encode } = details;
|
2020-08-21 15:18:33 +02:00
|
|
|
if (
|
|
|
|
data === undefined ||
|
|
|
|
typeof data === 'string' && data === ''
|
|
|
|
) {
|
|
|
|
return deleteChunks(datakey, 0);
|
|
|
|
}
|
2020-08-16 17:53:55 +02:00
|
|
|
const item = {
|
|
|
|
source: options.deviceName || options.defaultDeviceName,
|
|
|
|
tstamp: Date.now(),
|
|
|
|
data,
|
2015-08-16 14:17:01 +02:00
|
|
|
};
|
2020-08-16 17:53:55 +02:00
|
|
|
const json = JSON.stringify(item);
|
|
|
|
const encoded = encode instanceof Function
|
|
|
|
? await encode(json)
|
|
|
|
: json;
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2015-10-03 15:46:45 +02:00
|
|
|
// Chunkify taking into account QUOTA_BYTES_PER_ITEM:
|
2015-08-11 21:29:14 +02:00
|
|
|
// 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."
|
2020-08-16 17:53:55 +02:00
|
|
|
const bin = {};
|
|
|
|
const chunkCount = Math.ceil(encoded.length / maxChunkSize);
|
2018-08-25 18:57:21 +02:00
|
|
|
for ( let i = 0; i < chunkCount; i++ ) {
|
2020-08-16 17:53:55 +02:00
|
|
|
bin[datakey + i.toString()]
|
|
|
|
= encoded.substr(i * maxChunkSize, maxChunkSize);
|
2015-08-11 21:29:14 +02:00
|
|
|
}
|
2020-08-16 17:53:55 +02:00
|
|
|
bin[datakey + chunkCount.toString()] = ''; // Sentinel
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2020-08-21 15:18:33 +02:00
|
|
|
// Remove potentially unused trailing chunks before storing the data,
|
|
|
|
// this will free storage space which could otherwise cause the push
|
|
|
|
// operation to fail.
|
|
|
|
try {
|
2020-08-24 17:47:57 +02:00
|
|
|
await deleteChunks(datakey, chunkCount + 1);
|
2020-08-21 15:18:33 +02:00
|
|
|
} catch (reason) {
|
|
|
|
}
|
|
|
|
|
|
|
|
// Push the data to browser-provided cloud storage.
|
2019-09-18 14:34:55 +02:00
|
|
|
try {
|
2020-08-10 14:30:52 +02:00
|
|
|
await webext.storage.sync.set(bin);
|
2019-09-18 14:34:55 +02:00
|
|
|
} catch (reason) {
|
2020-08-10 14:30:52 +02:00
|
|
|
return String(reason);
|
2019-09-18 14:34:55 +02:00
|
|
|
}
|
|
|
|
};
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2020-08-16 17:53:55 +02:00
|
|
|
const pull = async function(details) {
|
|
|
|
const { datakey, decode } = details;
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2020-08-16 17:53:55 +02:00
|
|
|
const result = await getCoarseChunkCount(datakey);
|
2019-09-18 14:34:55 +02:00
|
|
|
if ( typeof result !== 'number' ) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
const chunkKeys = {};
|
|
|
|
for ( let i = 0; i < result; i++ ) {
|
2020-08-16 17:53:55 +02:00
|
|
|
chunkKeys[datakey + i.toString()] = '';
|
2019-09-18 14:34:55 +02:00
|
|
|
}
|
2015-08-11 21:29:14 +02:00
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
let bin;
|
|
|
|
try {
|
|
|
|
bin = await webext.storage.sync.get(chunkKeys);
|
|
|
|
} catch (reason) {
|
2020-08-10 14:30:52 +02:00
|
|
|
return String(reason);
|
2019-09-18 14:34:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
2020-08-16 17:53:55 +02:00
|
|
|
let encoded = [];
|
2019-09-18 14:34:55 +02:00
|
|
|
let i = 0;
|
|
|
|
for (;;) {
|
2020-08-16 17:53:55 +02:00
|
|
|
const slice = bin[datakey + i.toString()];
|
|
|
|
if ( slice === '' || slice === undefined ) { break; }
|
|
|
|
encoded.push(slice);
|
2019-09-18 14:34:55 +02:00
|
|
|
i += 1;
|
|
|
|
}
|
2020-08-16 17:53:55 +02:00
|
|
|
encoded = encoded.join('');
|
|
|
|
const json = decode instanceof Function
|
|
|
|
? await decode(encoded)
|
|
|
|
: encoded;
|
2019-09-18 14:34:55 +02:00
|
|
|
let entry = null;
|
|
|
|
try {
|
2020-08-16 17:53:55 +02:00
|
|
|
entry = JSON.parse(json);
|
2019-09-18 14:34:55 +02:00
|
|
|
} catch(ex) {
|
|
|
|
}
|
|
|
|
return entry;
|
2015-08-11 21:29:14 +02:00
|
|
|
};
|
|
|
|
|
2020-08-16 17:53:55 +02:00
|
|
|
const used = async function(datakey) {
|
2020-08-14 21:29:25 +02:00
|
|
|
if ( webext.storage.sync.getBytesInUse instanceof Function === false ) {
|
|
|
|
return;
|
|
|
|
}
|
2020-08-16 17:53:55 +02:00
|
|
|
const coarseCount = await getCoarseChunkCount(datakey);
|
2020-08-14 21:29:25 +02:00
|
|
|
if ( typeof coarseCount !== 'number' ) { return; }
|
|
|
|
const keys = [];
|
|
|
|
for ( let i = 0; i < coarseCount; i++ ) {
|
2020-08-16 17:53:55 +02:00
|
|
|
keys.push(`${datakey}${i}`);
|
2020-08-14 21:29:25 +02:00
|
|
|
}
|
|
|
|
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 };
|
|
|
|
};
|
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
const getOptions = function(callback) {
|
2018-08-25 18:57:21 +02:00
|
|
|
if ( typeof callback !== 'function' ) { return; }
|
2015-08-11 21:29:14 +02:00
|
|
|
callback(options);
|
|
|
|
};
|
|
|
|
|
2019-09-18 14:34:55 +02:00
|
|
|
const setOptions = function(details, callback) {
|
|
|
|
if ( typeof details !== 'object' || details === null ) { return; }
|
2015-08-11 21:29:14 +02:00
|
|
|
|
|
|
|
if ( typeof details.deviceName === 'string' ) {
|
2017-07-26 14:11:22 +02:00
|
|
|
vAPI.localStorage.setItem('deviceName', details.deviceName);
|
2015-08-12 00:48:52 +02:00
|
|
|
options.deviceName = details.deviceName;
|
2015-08-11 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
2015-08-12 00:48:52 +02:00
|
|
|
getOptions(callback);
|
2015-08-11 21:29:14 +02:00
|
|
|
};
|
|
|
|
|
2020-08-14 21:29:25 +02:00
|
|
|
return { push, pull, used, getOptions, setOptions };
|
2015-08-11 21:29:14 +02:00
|
|
|
})();
|
|
|
|
|
|
|
|
/******************************************************************************/
|