mirror of
https://github.com/gorhill/uBlock.git
synced 2024-11-07 03:12:33 +01:00
ca9b29c7ec
Related issue: - https://github.com/uBlockOrigin/uBlock-issues/issues/710 Messages from unprivileged ports (i.e. from content scripts) are no longer relayed to message handlers which are to be strictly used to execute privileged code. The last remaining case of unprivileged messages which should be converted into a privileged ones will be taken care of when the following issue is fixed: - https://github.com/gorhill/uBlock/issues/3497
1519 lines
54 KiB
JavaScript
1519 lines
54 KiB
JavaScript
/*******************************************************************************
|
|
|
|
uBlock Origin - a browser extension to block requests.
|
|
Copyright (C) 2014-2018 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
|
|
|
|
'use strict';
|
|
|
|
/******************************************************************************/
|
|
|
|
(( ) => {
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
const chrome = self.chrome;
|
|
const manifest = chrome.runtime.getManifest();
|
|
|
|
vAPI.cantWebsocket =
|
|
chrome.webRequest.ResourceType instanceof Object === false ||
|
|
chrome.webRequest.ResourceType.WEBSOCKET !== 'websocket';
|
|
|
|
vAPI.lastError = function() {
|
|
return chrome.runtime.lastError;
|
|
};
|
|
|
|
// https://github.com/gorhill/uBlock/issues/875
|
|
// https://code.google.com/p/chromium/issues/detail?id=410868#c8
|
|
// Must not leave `lastError` unchecked.
|
|
vAPI.resetLastError = function() {
|
|
void chrome.runtime.lastError;
|
|
};
|
|
|
|
vAPI.supportsUserStylesheets = vAPI.webextFlavor.soup.has('user_stylesheet');
|
|
// 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 });
|
|
|
|
vAPI.insertCSS = function(tabId, details) {
|
|
return chrome.tabs.insertCSS(tabId, details, vAPI.resetLastError);
|
|
};
|
|
|
|
const noopFunc = function(){};
|
|
|
|
/******************************************************************************/
|
|
|
|
vAPI.app = (function() {
|
|
let version = manifest.version;
|
|
let match = /(\d+\.\d+\.\d+)(?:\.(\d+))?/.exec(version);
|
|
if ( match && match[2] ) {
|
|
let v = parseInt(match[2], 10);
|
|
version = match[1] + (v < 100 ? 'b' + v : 'rc' + (v - 100));
|
|
}
|
|
|
|
return {
|
|
name: manifest.name.replace(/ dev\w+ build/, ''),
|
|
version: version
|
|
};
|
|
})();
|
|
|
|
/******************************************************************************/
|
|
|
|
vAPI.app.restart = function() {
|
|
chrome.runtime.reload();
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// chrome.storage.local.get(null, function(bin){ console.debug('%o', bin); });
|
|
|
|
vAPI.storage = chrome.storage.local;
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://github.com/gorhill/uMatrix/issues/234
|
|
// https://developer.chrome.com/extensions/privacy#property-network
|
|
|
|
// 2015-08-12: Wrapped Chrome API in try-catch statements. I had a fluke
|
|
// event in which it appeared Chrome 46 decided to restart uBlock (for
|
|
// unknown reasons) and again for unknown reasons the browser acted as if
|
|
// uBlock did not declare the `privacy` permission in its manifest, putting
|
|
// uBlock in a bad, non-functional state -- because call to `chrome.privacy`
|
|
// API threw an exception.
|
|
|
|
// https://github.com/gorhill/uBlock/issues/2048
|
|
// Do not mess up with existing settings if not assigning them stricter
|
|
// values.
|
|
|
|
vAPI.browserSettings = (function() {
|
|
// Not all platforms support `chrome.privacy`.
|
|
if ( chrome.privacy instanceof Object === false ) { return; }
|
|
|
|
return {
|
|
// Whether the WebRTC-related privacy API is crashy is an open question
|
|
// only for Chromium proper (because it can be compiled without the
|
|
// WebRTC feature): hence avoid overhead of the evaluation (which uses
|
|
// an iframe) for platforms where it's a non-issue.
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/9
|
|
// Some Chromium builds are made to look like a Chrome build.
|
|
webRTCSupported: vAPI.webextFlavor.soup.has('chromium') === false || undefined,
|
|
|
|
// Calling with `true` means IP address leak is not prevented.
|
|
// https://github.com/gorhill/uBlock/issues/533
|
|
// We must first check wether this Chromium-based browser was compiled
|
|
// with WebRTC support. To do this, we use an iframe, this way the
|
|
// empty RTCPeerConnection object we create to test for support will
|
|
// be properly garbage collected. This prevents issues such as
|
|
// a computer unable to enter into sleep mode, as reported in the
|
|
// Chrome store:
|
|
// https://github.com/gorhill/uBlock/issues/533#issuecomment-167931681
|
|
setWebrtcIPAddress: function(setting) {
|
|
// We don't know yet whether this browser supports WebRTC: find out.
|
|
if ( this.webRTCSupported === undefined ) {
|
|
// If asked to leave WebRTC setting alone at this point in the
|
|
// code, this means we never grabbed the setting in the first
|
|
// place.
|
|
if ( setting ) { return; }
|
|
this.webRTCSupported = { setting: setting };
|
|
let iframe = document.createElement('iframe');
|
|
const messageHandler = ev => {
|
|
if ( ev.origin !== self.location.origin ) { return; }
|
|
window.removeEventListener('message', messageHandler);
|
|
const setting = this.webRTCSupported.setting;
|
|
this.webRTCSupported = ev.data === 'webRTCSupported';
|
|
this.setWebrtcIPAddress(setting);
|
|
iframe.parentNode.removeChild(iframe);
|
|
iframe = null;
|
|
};
|
|
window.addEventListener('message', messageHandler);
|
|
iframe.src = 'is-webrtc-supported.html';
|
|
document.body.appendChild(iframe);
|
|
return;
|
|
}
|
|
|
|
// We are waiting for a response from our iframe. This makes the code
|
|
// safe to re-entrancy.
|
|
if ( typeof this.webRTCSupported === 'object' ) {
|
|
this.webRTCSupported.setting = setting;
|
|
return;
|
|
}
|
|
|
|
// https://github.com/gorhill/uBlock/issues/533
|
|
// WebRTC not supported: `webRTCMultipleRoutesEnabled` can NOT be
|
|
// safely accessed. Accessing the property will cause full browser
|
|
// crash.
|
|
if ( this.webRTCSupported !== true ) { return; }
|
|
|
|
const cp = chrome.privacy;
|
|
const cpn = cp.network;
|
|
|
|
// Older version of Chromium do not support this setting, and is
|
|
// marked as "deprecated" since Chromium 48.
|
|
if ( typeof cpn.webRTCMultipleRoutesEnabled === 'object' ) {
|
|
try {
|
|
if ( setting ) {
|
|
cpn.webRTCMultipleRoutesEnabled.clear({
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
} else {
|
|
cpn.webRTCMultipleRoutesEnabled.set({
|
|
value: false,
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
}
|
|
} catch(ex) {
|
|
console.error(ex);
|
|
}
|
|
}
|
|
|
|
// This setting became available in Chromium 48.
|
|
if ( typeof cpn.webRTCIPHandlingPolicy === 'object' ) {
|
|
try {
|
|
if ( setting ) {
|
|
cpn.webRTCIPHandlingPolicy.clear({
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
} else {
|
|
// https://github.com/uBlockOrigin/uAssets/issues/333#issuecomment-289426678
|
|
// Leverage virtuous side-effect of strictest setting.
|
|
// https://github.com/gorhill/uBlock/issues/3009
|
|
// Firefox currently works differently, use
|
|
// `default_public_interface_only` for now.
|
|
cpn.webRTCIPHandlingPolicy.set({
|
|
value: vAPI.webextFlavor.soup.has('chromium')
|
|
? 'disable_non_proxied_udp'
|
|
: 'default_public_interface_only',
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
}
|
|
} catch(ex) {
|
|
console.error(ex);
|
|
}
|
|
}
|
|
},
|
|
|
|
set: function(details) {
|
|
for ( var setting in details ) {
|
|
if ( details.hasOwnProperty(setting) === false ) {
|
|
continue;
|
|
}
|
|
switch ( setting ) {
|
|
case 'prefetching':
|
|
const enabled = !!details[setting];
|
|
try {
|
|
if ( enabled ) {
|
|
chrome.privacy.network.networkPredictionEnabled.clear({
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
} else {
|
|
chrome.privacy.network.networkPredictionEnabled.set({
|
|
value: false,
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
}
|
|
} catch(ex) {
|
|
console.error(ex);
|
|
}
|
|
if ( vAPI.prefetching instanceof Function ) {
|
|
vAPI.prefetching(enabled);
|
|
}
|
|
break;
|
|
|
|
case 'hyperlinkAuditing':
|
|
try {
|
|
if ( !!details[setting] ) {
|
|
chrome.privacy.websites.hyperlinkAuditingEnabled.clear({
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
} else {
|
|
chrome.privacy.websites.hyperlinkAuditingEnabled.set({
|
|
value: false,
|
|
scope: 'regular'
|
|
}, vAPI.resetLastError);
|
|
}
|
|
} catch(ex) {
|
|
console.error(ex);
|
|
}
|
|
break;
|
|
|
|
case 'webrtcIPAddress':
|
|
this.setWebrtcIPAddress(!!details[setting]);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
vAPI.isBehindTheSceneTabId = function(tabId) {
|
|
return tabId < 0;
|
|
};
|
|
|
|
vAPI.unsetTabId = 0;
|
|
vAPI.noTabId = -1; // definitely not any existing tab
|
|
|
|
// To remove when tabId-as-integer has been tested enough.
|
|
|
|
const toChromiumTabId = function(tabId) {
|
|
return typeof tabId === 'number' && isNaN(tabId) === false
|
|
? tabId
|
|
: 0;
|
|
};
|
|
|
|
// https://developer.chrome.com/extensions/webNavigation
|
|
// https://developer.chrome.com/extensions/tabs
|
|
|
|
vAPI.Tabs = class {
|
|
constructor() {
|
|
browser.webNavigation.onCreatedNavigationTarget.addListener(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.tabId,
|
|
details.sourceTabId
|
|
);
|
|
});
|
|
|
|
browser.webNavigation.onCommitted.addListener(details => {
|
|
details.url = this.sanitizeURL(details.url);
|
|
this.onNavigation(details);
|
|
});
|
|
|
|
// https://github.com/gorhill/uBlock/issues/3073
|
|
// Fall back to `tab.url` when `changeInfo.url` is not set.
|
|
browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
|
|
if ( typeof changeInfo.url !== 'string' ) {
|
|
changeInfo.url = tab && tab.url;
|
|
}
|
|
if ( changeInfo.url ) {
|
|
changeInfo.url = this.sanitizeURL(changeInfo.url);
|
|
}
|
|
this.onUpdated(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 => {
|
|
if ( windowId === browser.windows.WINDOW_ID_NONE ) { return; }
|
|
browser.tabs.query({ active: true, windowId }, tabs => {
|
|
if ( Array.isArray(tabs) === false ) { return; }
|
|
if ( tabs.length === 0 ) { return; }
|
|
const tab = tabs[0];
|
|
this.onActivated({
|
|
tabId: tab.id,
|
|
windowId: tab.windowId,
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
browser.tabs.onRemoved.addListener((tabId, details) => {
|
|
this.onClosed(tabId, details);
|
|
});
|
|
}
|
|
|
|
get(tabId, callback) {
|
|
if ( tabId === null ) {
|
|
browser.tabs.query(
|
|
{ active: true, currentWindow: true },
|
|
tabs => {
|
|
void browser.runtime.lastError;
|
|
callback(
|
|
Array.isArray(tabs) && tabs.length !== 0
|
|
? tabs[0]
|
|
: null
|
|
);
|
|
}
|
|
);
|
|
return;
|
|
}
|
|
|
|
tabId = toChromiumTabId(tabId);
|
|
if ( tabId === 0 ) {
|
|
callback(null);
|
|
return;
|
|
}
|
|
|
|
browser.tabs.get(tabId, function(tab) {
|
|
void browser.runtime.lastError;
|
|
callback(tab);
|
|
});
|
|
}
|
|
|
|
// 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 and undefined:
|
|
// foreground
|
|
// - popup: true => open in a new window
|
|
|
|
create(url, details) {
|
|
if ( details.active === undefined ) {
|
|
details.active = true;
|
|
}
|
|
|
|
const subWrapper = ( ) => {
|
|
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 && browser.windows instanceof Object ) {
|
|
browser.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
|
|
browser.tabs.update(
|
|
toChromiumTabId(details.tabId),
|
|
updateDetails,
|
|
tab => {
|
|
// if the tab doesn't exist
|
|
if ( vAPI.lastError() ) {
|
|
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 browser.windows API.
|
|
//
|
|
// 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.
|
|
if ( details.popup === true && browser.windows instanceof Object ) {
|
|
const createDetails = {
|
|
url: details.url,
|
|
type: 'popup',
|
|
};
|
|
if ( details.box instanceof Object ) {
|
|
Object.assign(createDetails, details.box);
|
|
}
|
|
browser.windows.create(createDetails, win => {
|
|
if ( win instanceof Object === false ) { return; }
|
|
if ( details.box instanceof Object === false ) { return; }
|
|
if (
|
|
win.left === details.box.left &&
|
|
win.top === details.box.top
|
|
) {
|
|
return;
|
|
}
|
|
browser.windows.update(win.id, {
|
|
left: details.box.left,
|
|
top: details.box.top
|
|
});
|
|
});
|
|
return;
|
|
}
|
|
|
|
if ( details.index !== -1 ) {
|
|
subWrapper();
|
|
return;
|
|
}
|
|
|
|
vAPI.tabs.get(null, tab => {
|
|
if ( tab ) {
|
|
details.index = tab.index + 1;
|
|
} else {
|
|
delete details.index;
|
|
}
|
|
|
|
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
|
|
|
|
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://github.com/gorhill/uBlock/issues/3053#issuecomment-332276818
|
|
// Do not try to lookup uBO's own pages with FF 55 or less.
|
|
if (
|
|
vAPI.webextFlavor.soup.has('firefox') &&
|
|
vAPI.webextFlavor.major < 56
|
|
) {
|
|
this.create(targetURL, details);
|
|
return;
|
|
}
|
|
|
|
// https://developer.chrome.com/extensions/tabs#method-query
|
|
// "Note that fragment identifiers are not matched."
|
|
// It's a lie, fragment identifiers ARE matched. So we need to remove
|
|
// the fragment.
|
|
const pos = targetURL.indexOf('#');
|
|
const targetURLWithoutHash = pos === -1
|
|
? targetURL
|
|
: targetURL.slice(0, pos);
|
|
|
|
browser.tabs.query({ url: targetURLWithoutHash }, tabs => {
|
|
void browser.runtime.lastError;
|
|
const tab = Array.isArray(tabs) && tabs[0];
|
|
if ( !tab ) {
|
|
this.create(targetURL, details);
|
|
return;
|
|
}
|
|
const updateDetails = { active: true };
|
|
// https://github.com/uBlockOrigin/uBlock-issues/issues/592
|
|
if ( tab.url.startsWith(targetURL) === false ) {
|
|
updateDetails.url = targetURL;
|
|
}
|
|
browser.tabs.update(tab.id, updateDetails, tab => {
|
|
if ( browser.windows instanceof Object === false ) { return; }
|
|
browser.windows.update(tab.windowId, { focused: true });
|
|
});
|
|
});
|
|
}
|
|
|
|
// Replace the URL of a tab. Noop if the tab does not exist.
|
|
|
|
replace(tabId, url) {
|
|
tabId = toChromiumTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
let targetURL = url;
|
|
|
|
// extension pages
|
|
if ( /^[\w-]{2,}:/.test(targetURL) !== true ) {
|
|
targetURL = vAPI.getURL(targetURL);
|
|
}
|
|
|
|
browser.tabs.update(tabId, { url: targetURL }, vAPI.resetLastError);
|
|
}
|
|
|
|
remove(tabId) {
|
|
tabId = toChromiumTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
browser.tabs.remove(tabId, vAPI.resetLastError);
|
|
}
|
|
|
|
reload(tabId, bypassCache = false) {
|
|
tabId = toChromiumTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
browser.tabs.reload(
|
|
tabId,
|
|
{ bypassCache: bypassCache === true },
|
|
vAPI.resetLastError
|
|
);
|
|
}
|
|
|
|
select(tabId) {
|
|
tabId = toChromiumTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
browser.tabs.update(tabId, { active: true }, function(tab) {
|
|
void browser.runtime.lastError;
|
|
if ( !tab ) { return; }
|
|
if ( browser.windows instanceof Object === false ) { return; }
|
|
browser.windows.update(tab.windowId, { focused: true });
|
|
});
|
|
}
|
|
|
|
injectScript(tabId, details, callback) {
|
|
const onScriptExecuted = function() {
|
|
// https://code.google.com/p/chromium/issues/detail?id=410868#c8
|
|
void browser.runtime.lastError;
|
|
if ( typeof callback === 'function' ) {
|
|
callback.apply(null, arguments);
|
|
}
|
|
};
|
|
if ( tabId ) {
|
|
browser.tabs.executeScript(
|
|
toChromiumTabId(tabId),
|
|
details,
|
|
onScriptExecuted
|
|
);
|
|
} else {
|
|
browser.tabs.executeScript(
|
|
details,
|
|
onScriptExecuted
|
|
);
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
onActivated(/* details */) {
|
|
}
|
|
|
|
onClosed(/* tabId, details */) {
|
|
}
|
|
|
|
onCreated(/* openedTabId, openerTabId */) {
|
|
}
|
|
|
|
onNavigation(/* details */) {
|
|
}
|
|
|
|
onUpdated(/* tabId, changeInfo, tab */) {
|
|
}
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// 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.
|
|
|
|
vAPI.setIcon = (( ) => {
|
|
const browserAction = chrome.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' } },
|
|
{ path: { '16': 'img/icon_16.png', '32': 'img/icon_32.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++ ) {
|
|
const path = icons[i].path;
|
|
for ( const key in path ) {
|
|
if ( path.hasOwnProperty(key) === false ) { continue; }
|
|
imgs.push({ i: i, p: key });
|
|
}
|
|
}
|
|
|
|
// 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');
|
|
const iconData = [ null, null ];
|
|
for ( const img of imgs ) {
|
|
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;
|
|
}
|
|
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];
|
|
}
|
|
})();
|
|
|
|
const onTabReady = function(tab, details) {
|
|
if ( vAPI.lastError() || !tab ) { return; }
|
|
|
|
const { parts, state, badge, color } = details;
|
|
|
|
if ( browserAction.setIcon !== undefined ) {
|
|
if ( parts === undefined || (parts & 0b001) !== 0 ) {
|
|
browserAction.setIcon(
|
|
Object.assign({ tabId: tab.id }, icons[state])
|
|
);
|
|
}
|
|
if ( (parts & 0b010) !== 0 ) {
|
|
browserAction.setBadgeText({ tabId: tab.id, text: badge });
|
|
}
|
|
if ( (parts & 0b100) !== 0 ) {
|
|
browserAction.setBadgeBackgroundColor({ tabId: tab.id, color });
|
|
}
|
|
}
|
|
|
|
if ( browserAction.setTitle !== undefined ) {
|
|
browserAction.setTitle({
|
|
tabId: tab.id,
|
|
title: titleTemplate.replace(
|
|
'{badge}',
|
|
state === 1 ? (badge !== '' ? badge : '0') : 'off'
|
|
)
|
|
});
|
|
}
|
|
};
|
|
|
|
// parts: bit 0 = icon
|
|
// bit 1 = badge
|
|
// bit 2 = badge color
|
|
|
|
return function(tabId, details) {
|
|
tabId = toChromiumTabId(tabId);
|
|
if ( tabId === 0 ) { return; }
|
|
|
|
browser.tabs.get(tabId, tab => onTabReady(tab, details));
|
|
|
|
if ( vAPI.contextMenu instanceof Object ) {
|
|
vAPI.contextMenu.onMustUpdate(tabId);
|
|
}
|
|
};
|
|
})();
|
|
|
|
chrome.browserAction.onClicked.addListener(function(tab) {
|
|
vAPI.tabs.open({
|
|
select: true,
|
|
url: 'popup.html?tabId=' + tab.id + '&responsive=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.
|
|
|
|
vAPI.messaging = {
|
|
ports: new Map(),
|
|
listeners: new Map(),
|
|
defaultHandler: null,
|
|
PRIVILEGED_URL: vAPI.getURL(''),
|
|
NOOPFUNC: noopFunc,
|
|
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);
|
|
},
|
|
|
|
onPortConnect: function(port) {
|
|
port.onDisconnect.addListener(
|
|
port => this.onPortDisconnect(port)
|
|
);
|
|
port.onMessage.addListener(
|
|
(request, port) => this.onPortMessage(request, port)
|
|
);
|
|
this.ports.set(port.name, {
|
|
port,
|
|
privileged: port.sender.url.startsWith(this.PRIVILEGED_URL)
|
|
});
|
|
},
|
|
|
|
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 } of this.ports.values() ) {
|
|
const tab = port.sender && port.sender.tab;
|
|
if ( !tab ) { continue; }
|
|
if ( tab.id === tabId ) {
|
|
this.onPortDisconnect(port);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
broadcast: function(message) {
|
|
const messageWrapper = { broadcast: true, msg: message };
|
|
for ( const { port } of this.ports.values() ) {
|
|
try {
|
|
port.postMessage(messageWrapper);
|
|
} catch(ex) {
|
|
this.ports.delete(port.name);
|
|
}
|
|
}
|
|
},
|
|
|
|
onFrameworkMessage: function(request, port, callback) {
|
|
const sender = port && port.sender;
|
|
if ( !sender ) { return; }
|
|
const tabId = sender.tab && sender.tab.id || undefined;
|
|
const msg = request.msg;
|
|
switch ( msg.what ) {
|
|
case 'connectionAccepted':
|
|
case 'connectionRefused': {
|
|
const { port: toPort } = this.ports.get(msg.fromToken);
|
|
if ( toPort !== undefined ) {
|
|
msg.tabId = tabId;
|
|
toPort.postMessage(request);
|
|
} else {
|
|
msg.what = 'connectionBroken';
|
|
port.postMessage(request);
|
|
}
|
|
break;
|
|
}
|
|
case 'connectionRequested':
|
|
msg.tabId = tabId;
|
|
for ( const { port: toPort } of this.ports.values() ) {
|
|
toPort.postMessage(request);
|
|
}
|
|
break;
|
|
case 'connectionBroken':
|
|
case 'connectionCheck':
|
|
case 'connectionMessage': {
|
|
const { port: toPort } = this.ports.get(
|
|
port.name === msg.fromToken ? msg.toToken : msg.fromToken
|
|
);
|
|
if ( toPort !== undefined ) {
|
|
msg.tabId = tabId;
|
|
toPort.postMessage(request);
|
|
} else {
|
|
msg.what = 'connectionBroken';
|
|
port.postMessage(request);
|
|
}
|
|
break;
|
|
}
|
|
case 'userCSS':
|
|
if ( tabId === undefined ) { break; }
|
|
const details = {
|
|
code: undefined,
|
|
frameId: sender.frameId,
|
|
matchAboutBlank: true
|
|
};
|
|
if ( vAPI.supportsUserStylesheets ) {
|
|
details.cssOrigin = 'user';
|
|
}
|
|
if ( msg.add ) {
|
|
details.runAt = 'document_start';
|
|
}
|
|
let countdown = 0;
|
|
const countdownHandler = function() {
|
|
void chrome.runtime.lastError;
|
|
countdown -= 1;
|
|
if ( countdown === 0 && typeof callback === 'function' ) {
|
|
callback();
|
|
}
|
|
};
|
|
for ( const cssText of msg.add ) {
|
|
countdown += 1;
|
|
details.code = cssText;
|
|
browser.tabs.insertCSS(tabId, details, countdownHandler);
|
|
}
|
|
if ( typeof chrome.tabs.removeCSS === 'function' ) {
|
|
for ( const cssText of msg.remove ) {
|
|
countdown += 1;
|
|
details.code = cssText;
|
|
browser.tabs.removeCSS(tabId, details, countdownHandler);
|
|
}
|
|
}
|
|
if ( countdown === 0 && typeof callback === 'function' ) {
|
|
callback();
|
|
}
|
|
break;
|
|
}
|
|
},
|
|
|
|
// Use a wrapper to avoid closure and to allow reuse.
|
|
CallbackWrapper: class {
|
|
constructor(messaging, port, request) {
|
|
this.messaging = messaging;
|
|
this.callback = this.proxy.bind(this); // bind once
|
|
this.init(port, request);
|
|
}
|
|
init(port, request) {
|
|
this.port = port;
|
|
this.request = request;
|
|
return this;
|
|
}
|
|
proxy(response) {
|
|
// https://github.com/chrisaljoudi/uBlock/issues/383
|
|
if ( this.messaging.ports.has(this.port.name) ) {
|
|
this.port.postMessage({
|
|
auxProcessId: this.request.auxProcessId,
|
|
channelName: this.request.channelName,
|
|
msg: response !== undefined ? response : null
|
|
});
|
|
}
|
|
// Store for reuse
|
|
this.port = this.request = null;
|
|
this.messaging.callbackWrapperJunkyard.push(this);
|
|
}
|
|
},
|
|
|
|
callbackWrapperJunkyard: [],
|
|
|
|
callbackWrapperFactory: function(port, request) {
|
|
return this.callbackWrapperJunkyard.length !== 0
|
|
? this.callbackWrapperJunkyard.pop().init(port, request)
|
|
: new this.CallbackWrapper(this, port, request);
|
|
},
|
|
|
|
onPortMessage: function(request, port) {
|
|
// prepare response
|
|
let callback = this.NOOPFUNC;
|
|
if ( request.auxProcessId !== undefined ) {
|
|
callback = this.callbackWrapperFactory(port, request).callback;
|
|
}
|
|
|
|
// Content process to main process: framework handler.
|
|
if ( request.channelName === 'vapi' ) {
|
|
this.onFrameworkMessage(request, port, callback);
|
|
return;
|
|
}
|
|
|
|
// Auxiliary process to main process: specific handler
|
|
const fromDetails = this.ports.get(port.name);
|
|
if ( fromDetails === undefined ) { return; }
|
|
|
|
const listenerDetails = this.listeners.get(request.channelName);
|
|
let r = this.UNHANDLED;
|
|
if (
|
|
(listenerDetails !== undefined) &&
|
|
(listenerDetails.privileged === false || fromDetails.privileged)
|
|
|
|
) {
|
|
r = listenerDetails.fn(request.msg, port.sender, callback);
|
|
}
|
|
if ( r !== this.UNHANDLED ) { return; }
|
|
|
|
// Auxiliary process to main process: default handler
|
|
if ( fromDetails.privileged ) {
|
|
r = this.defaultHandler(request.msg, port.sender, callback);
|
|
if ( r !== this.UNHANDLED ) { return; }
|
|
}
|
|
|
|
// Auxiliary process to main process: no handler
|
|
log.info(
|
|
`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.
|
|
|
|
vAPI.warSecret = (( ) => {
|
|
const generateSecret = ( ) => {
|
|
return Math.floor(Math.random() * 982451653 + 982451653).toString(36);
|
|
};
|
|
|
|
const root = vAPI.getURL('/');
|
|
const secrets = [];
|
|
let lastSecretTime = 0;
|
|
|
|
const guard = function(details) {
|
|
const url = details.url;
|
|
const pos = secrets.findIndex(secret =>
|
|
url.lastIndexOf(`?secret=${secret}`) !== -1
|
|
);
|
|
if ( pos === -1 ) {
|
|
return { redirectUrl: root };
|
|
}
|
|
secrets.splice(pos, 1);
|
|
};
|
|
|
|
browser.webRequest.onBeforeRequest.addListener(
|
|
guard,
|
|
{
|
|
urls: [ root + 'web_accessible_resources/*' ]
|
|
},
|
|
[ 'blocking' ]
|
|
);
|
|
|
|
return ( ) => {
|
|
if ( secrets.length !== 0 ) {
|
|
if ( (Date.now() - lastSecretTime) > 5000 ) {
|
|
secrets.splice(0);
|
|
} else if ( secrets.length > 256 ) {
|
|
secrets.splice(0, secrets.length - 192);
|
|
}
|
|
}
|
|
lastSecretTime = Date.now();
|
|
const secret = generateSecret();
|
|
secrets.push(secret);
|
|
return `?secret=${secret}`;
|
|
};
|
|
})();
|
|
|
|
/******************************************************************************/
|
|
|
|
vAPI.Net = class {
|
|
constructor() {
|
|
this.validTypes = new Set();
|
|
{
|
|
const wrrt = browser.webRequest.ResourceType;
|
|
for ( const typeKey in wrrt ) {
|
|
if ( wrrt.hasOwnProperty(typeKey) ) {
|
|
this.validTypes.add(wrrt[typeKey]);
|
|
}
|
|
}
|
|
}
|
|
this.suspendableListener = undefined;
|
|
this.listenerMap = new WeakMap();
|
|
this.suspendDepth = 0;
|
|
|
|
browser.webRequest.onBeforeRequest.addListener(
|
|
details => {
|
|
this.normalizeDetails(details);
|
|
if ( this.suspendDepth === 0 ) {
|
|
if ( this.suspendableListener === undefined ) { return; }
|
|
return this.suspendableListener(details);
|
|
}
|
|
if ( details.tabId < 0 ) { return; }
|
|
return this.suspendOneRequest(details);
|
|
},
|
|
this.denormalizeFilters({ urls: [ 'http://*/*', 'https://*/*' ] }),
|
|
[ 'blocking' ]
|
|
);
|
|
}
|
|
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;
|
|
}
|
|
addListener(which, clientListener, filters, options) {
|
|
const actualFilters = this.denormalizeFilters(filters);
|
|
const actualListener = this.makeNewListenerProxy(clientListener);
|
|
browser.webRequest[which].addListener(
|
|
actualListener,
|
|
actualFilters,
|
|
options
|
|
);
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
unsuspend() {
|
|
if ( this.suspendDepth === 0 ) { return; }
|
|
this.suspendDepth -= 1;
|
|
if ( this.suspendDepth !== 0 ) { return; }
|
|
this.unsuspendAllRequests(this.suspendableListener);
|
|
}
|
|
canSuspend() {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
// https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/contextMenus#Browser_compatibility
|
|
// Firefox for Android does no support browser.contextMenus.
|
|
|
|
vAPI.contextMenu = chrome.contextMenus && {
|
|
_callback: null,
|
|
_entries: [],
|
|
_createEntry: function(entry) {
|
|
chrome.contextMenus.create(
|
|
JSON.parse(JSON.stringify(entry)),
|
|
vAPI.resetLastError
|
|
);
|
|
},
|
|
onMustUpdate: function() {},
|
|
setEntries: function(entries, callback) {
|
|
entries = entries || [];
|
|
var n = Math.max(this._entries.length, entries.length),
|
|
oldEntryId, newEntry;
|
|
for ( var i = 0; i < n; i++ ) {
|
|
oldEntryId = this._entries[i];
|
|
newEntry = entries[i];
|
|
if ( oldEntryId && newEntry ) {
|
|
if ( newEntry.id !== oldEntryId ) {
|
|
chrome.contextMenus.remove(oldEntryId);
|
|
this._createEntry(newEntry);
|
|
this._entries[i] = newEntry.id;
|
|
}
|
|
} else if ( oldEntryId && !newEntry ) {
|
|
chrome.contextMenus.remove(oldEntryId);
|
|
} else if ( !oldEntryId && newEntry ) {
|
|
this._createEntry(newEntry);
|
|
this._entries[i] = newEntry.id;
|
|
}
|
|
}
|
|
n = this._entries.length = entries.length;
|
|
callback = callback || null;
|
|
if ( callback === this._callback ) {
|
|
return;
|
|
}
|
|
if ( n !== 0 && callback !== null ) {
|
|
chrome.contextMenus.onClicked.addListener(callback);
|
|
this._callback = callback;
|
|
} else if ( n === 0 && this._callback !== null ) {
|
|
chrome.contextMenus.onClicked.removeListener(this._callback);
|
|
this._callback = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
vAPI.commands = chrome.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
|
|
|
|
vAPI.adminStorage = chrome.storage.managed && {
|
|
getItem: function(key, callback) {
|
|
var onRead = function(store) {
|
|
var data;
|
|
if (
|
|
!chrome.runtime.lastError &&
|
|
typeof store === 'object' &&
|
|
store !== null
|
|
) {
|
|
data = store[key];
|
|
}
|
|
callback(data);
|
|
};
|
|
try {
|
|
chrome.storage.managed.get(key, onRead);
|
|
} catch (ex) {
|
|
callback();
|
|
}
|
|
}
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
vAPI.cloud = (function() {
|
|
// Not all platforms support `chrome.storage.sync`.
|
|
if ( chrome.storage.sync instanceof Object === false ) {
|
|
return;
|
|
}
|
|
|
|
let chunkCountPerFetch = 16; // Must be a power of 2
|
|
|
|
// Mind chrome.storage.sync.MAX_ITEMS (512 at time of writing)
|
|
let maxChunkCountPerItem = Math.floor(512 * 0.75) & ~(chunkCountPerFetch - 1);
|
|
|
|
// Mind chrome.storage.sync.QUOTA_BYTES_PER_ITEM (8192 at time of writing)
|
|
// 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.
|
|
let evalMaxChunkSize = function() {
|
|
return Math.floor(
|
|
(chrome.storage.sync.QUOTA_BYTES_PER_ITEM || 8192) *
|
|
(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 });
|
|
|
|
// Mind chrome.storage.sync.QUOTA_BYTES (128 kB at time of writing)
|
|
// Firefox:
|
|
// https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/storage/sync
|
|
// > You can store up to 100KB of data using this API/
|
|
let maxStorageSize = chrome.storage.sync.QUOTA_BYTES || 102400;
|
|
|
|
let options = {
|
|
defaultDeviceName: window.navigator.platform,
|
|
deviceName: vAPI.localStorage.getItem('deviceName') || ''
|
|
};
|
|
|
|
// 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.
|
|
|
|
let getCoarseChunkCount = function(dataKey, callback) {
|
|
let bin = {};
|
|
for ( let i = 0; i < maxChunkCountPerItem; i += 16 ) {
|
|
bin[dataKey + i.toString()] = '';
|
|
}
|
|
|
|
chrome.storage.sync.get(bin, function(bin) {
|
|
if ( chrome.runtime.lastError ) {
|
|
return callback(0, chrome.runtime.lastError.message);
|
|
}
|
|
|
|
let chunkCount = 0;
|
|
for ( let i = 0; i < maxChunkCountPerItem; i += 16 ) {
|
|
if ( bin[dataKey + i.toString()] === '' ) { break; }
|
|
chunkCount = i + 16;
|
|
}
|
|
|
|
callback(chunkCount);
|
|
});
|
|
};
|
|
|
|
let deleteChunks = function(dataKey, start) {
|
|
let keys = [];
|
|
|
|
// No point in deleting more than:
|
|
// - The max number of chunks per item
|
|
// - The max number of chunks per storage limit
|
|
let n = Math.min(
|
|
maxChunkCountPerItem,
|
|
Math.ceil(maxStorageSize / maxChunkSize)
|
|
);
|
|
for ( let i = start; i < n; i++ ) {
|
|
keys.push(dataKey + i.toString());
|
|
}
|
|
if ( keys.length !== 0 ) {
|
|
chrome.storage.sync.remove(keys);
|
|
}
|
|
};
|
|
|
|
let start = function(/* dataKeys */) {
|
|
};
|
|
|
|
let push = function(dataKey, data, callback) {
|
|
|
|
let bin = {
|
|
'source': options.deviceName || options.defaultDeviceName,
|
|
'tstamp': Date.now(),
|
|
'data': data,
|
|
'size': 0
|
|
};
|
|
bin.size = JSON.stringify(bin).length;
|
|
let item = JSON.stringify(bin);
|
|
|
|
// 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."
|
|
bin = {};
|
|
let chunkCount = Math.ceil(item.length / maxChunkSize);
|
|
for ( let i = 0; i < chunkCount; i++ ) {
|
|
bin[dataKey + i.toString()] = item.substr(i * maxChunkSize, maxChunkSize);
|
|
}
|
|
bin[dataKey + chunkCount.toString()] = ''; // Sentinel
|
|
|
|
chrome.storage.sync.set(bin, function() {
|
|
let errorStr;
|
|
if ( chrome.runtime.lastError ) {
|
|
errorStr = chrome.runtime.lastError.message;
|
|
// https://github.com/gorhill/uBlock/issues/3006#issuecomment-332597677
|
|
// - Delete all that was pushed in case of failure.
|
|
// - It's unknown whether such issue applies only to Firefox:
|
|
// until such cases are reported for other browsers, we will
|
|
// reset the (now corrupted) content of the cloud storage
|
|
// only on Firefox.
|
|
if ( vAPI.webextFlavor.soup.has('firefox') ) {
|
|
chunkCount = 0;
|
|
}
|
|
}
|
|
callback(errorStr);
|
|
|
|
// Remove potentially unused trailing chunks
|
|
deleteChunks(dataKey, chunkCount);
|
|
});
|
|
};
|
|
|
|
let pull = function(dataKey, callback) {
|
|
|
|
let assembleChunks = function(bin) {
|
|
if ( chrome.runtime.lastError ) {
|
|
callback(null, chrome.runtime.lastError.message);
|
|
return;
|
|
}
|
|
|
|
// 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 json = [], jsonSlice;
|
|
let i = 0;
|
|
for (;;) {
|
|
jsonSlice = bin[dataKey + i.toString()];
|
|
if ( jsonSlice === '' || jsonSlice === undefined ) { break; }
|
|
json.push(jsonSlice);
|
|
i += 1;
|
|
}
|
|
|
|
let entry = null;
|
|
try {
|
|
entry = JSON.parse(json.join(''));
|
|
} catch(ex) {
|
|
}
|
|
callback(entry);
|
|
};
|
|
|
|
let fetchChunks = function(coarseCount, errorStr) {
|
|
if ( coarseCount === 0 || typeof errorStr === 'string' ) {
|
|
callback(null, errorStr);
|
|
return;
|
|
}
|
|
|
|
let bin = {};
|
|
for ( let i = 0; i < coarseCount; i++ ) {
|
|
bin[dataKey + i.toString()] = '';
|
|
}
|
|
|
|
chrome.storage.sync.get(bin, assembleChunks);
|
|
};
|
|
|
|
getCoarseChunkCount(dataKey, fetchChunks);
|
|
};
|
|
|
|
let getOptions = function(callback) {
|
|
if ( typeof callback !== 'function' ) { return; }
|
|
callback(options);
|
|
};
|
|
|
|
let 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 {
|
|
start: start,
|
|
push: push,
|
|
pull: pull,
|
|
getOptions: getOptions,
|
|
setOptions: setOptions
|
|
};
|
|
})();
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
})();
|
|
|
|
/******************************************************************************/
|