aboutsummaryrefslogtreecommitdiffstats
path: root/src/js/vapi-background.js
diff options
context:
space:
mode:
Diffstat (limited to 'src/js/vapi-background.js')
-rw-r--r--src/js/vapi-background.js848
1 files changed, 848 insertions, 0 deletions
diff --git a/src/js/vapi-background.js b/src/js/vapi-background.js
new file mode 100644
index 0000000..1db13ae
--- /dev/null
+++ b/src/js/vapi-background.js
@@ -0,0 +1,848 @@
+// for background page only
+
+(function() {
+'use strict';
+
+window.vAPI = window.vAPI || {};
+
+if (window.chrome) {
+ var chrome = window.chrome;
+
+ vAPI.chrome = true;
+
+ vAPI.storage = chrome.storage.local;
+
+ vAPI.tabs = {
+ registerListeners: function() {
+ if (typeof this.onNavigation === 'function') {
+ chrome.webNavigation.onCommitted.addListener(this.onNavigation);
+ }
+
+ if (typeof this.onUpdated === 'function') {
+ chrome.tabs.onUpdated.addListener(this.onUpdated);
+ }
+
+ if (typeof this.onClosed === 'function') {
+ chrome.tabs.onRemoved.addListener(this.onClosed);
+ }
+
+ if (typeof this.onPopup === 'function') {
+ chrome.webNavigation.onCreatedNavigationTarget.addListener(this.onPopup);
+ }
+ },
+ get: function(tabId, callback) {
+ if (tabId === null) {
+ chrome.tabs.query(
+ {
+ active: true,
+ currentWindow: true
+ },
+ function(tabs) {
+ callback(tabs[0]);
+ }
+ );
+ }
+ else {
+ chrome.tabs.get(tabId, callback);
+ }
+ },
+ /*open: function(details) {
+ // to keep incognito context?
+ chrome.windows.getCurrent(function(win) {
+ details.windowId = win.windowId;
+ chrome.tabs.create(details);
+ });
+ },*/
+ open: function(details) {
+ if (!details.url) {
+ return null;
+ }
+ // extension pages
+ else if (!details.url.match(/^\w{2,20}:/)) {
+ details.url = vAPI.getURL(details.url);
+ }
+
+ // dealing with Chrome's asynhronous API
+ var wrapper = function() {
+ if (details.active === undefined) {
+ details.active = true;
+ }
+
+ var subWrapper = function() {
+ var _details = {
+ url: details.url,
+ active: !!details.active
+ };
+
+ if (details.tabId) {
+ // update doesn't accept index, must use move
+ chrome.tabs.update(details.tabId, _details, function(tab) {
+ // if the tab doesn't exist
+ if (chrome.runtime.lastError) {
+ chrome.tabs.create(_details);
+ }
+ else if (details.index !== undefined) {
+ chrome.tabs.move(tab.id, {index: details.index});
+ }
+ });
+ }
+ else {
+ if (details.index !== undefined) {
+ _details.index = details.index;
+ }
+
+ chrome.tabs.create(_details);
+ }
+ };
+
+ if (details.index === -1) {
+ vAPI.tabs.get(null, function(tab) {
+ if (tab) {
+ details.index = tab.index + 1;
+ }
+ else {
+ delete details.index;
+ }
+
+ subWrapper();
+ });
+ }
+ else {
+ subWrapper();
+ }
+ };
+
+ if (details.select) {
+ // note that currentWindow may be even the window of Developer Tools
+ // so, test with setTimeout...
+ chrome.tabs.query({currentWindow: true}, function(tabs) {
+ var url = details.url.replace(rgxHash, '');
+ // this is questionable
+ var rgxHash = /#.*/;
+
+ tabs = tabs.some(function(tab) {
+ if (tab.url.replace(rgxHash, '') === url) {
+ chrome.tabs.update(tab.id, {active: true});
+ return true;
+ }
+ });
+
+ if (!tabs) {
+ wrapper();
+ }
+ });
+ }
+ else {
+ wrapper();
+ }
+ },
+ close: chrome.tabs.remove.bind(chrome.tabs)
+ };
+
+ // Must read: https://code.google.com/p/chromium/issues/detail?id=410868#c8
+
+ // https://github.com/gorhill/uBlock/issues/19
+ // https://github.com/gorhill/uBlock/issues/207
+ // Since we may be called asynchronously, the tab id may not exist
+ // anymore, so this ensures it does still exist.
+
+ vAPI.setIcon = function(tabId, img, badge) {
+ var onIconReady = function() {
+ if ( chrome.runtime.lastError ) {
+ return;
+ }
+
+ chrome.browserAction.setBadgeText({ tabId: tabId, text: badge });
+
+ if ( badge !== '' ) {
+ chrome.browserAction.setBadgeBackgroundColor({ tabId: tabId, color: '#666' });
+ }
+ };
+ chrome.browserAction.setIcon({ tabId: tabId, path: img }, onIconReady);
+ };
+
+ vAPI.messaging = {
+ ports: {},
+ listeners: {},
+ listen: function(name, callback) {
+ this.listeners[name] = callback;
+ },
+ setup: function(connector) {
+ if (this.connector) {
+ return;
+ }
+
+ this.connector = function(port) {
+ var onMessage = function(request) {
+ var callback = function(response) {
+ // stfu
+ if (chrome.runtime.lastError) {
+ return;
+ }
+
+ if (request.requestId) {
+ port.postMessage({
+ requestId: request.requestId,
+ portName: request.portName,
+ msg: response
+ });
+ }
+ };
+
+ var listener = connector(request.msg, port.sender, callback);
+
+ if (listener === null) {
+ listener = vAPI.messaging.listeners[request.portName];
+
+ if (typeof listener === 'function') {
+ listener(request.msg, port.sender, callback);
+ } else {
+ console.error('µBlock> messaging > unknown request: %o', request);
+ }
+ }
+ };
+
+ var onDisconnect = function(port) {
+ port.onDisconnect.removeListener(onDisconnect);
+ port.onMessage.removeListener(onMessage);
+ delete vAPI.messaging.ports[port.name];
+ };
+
+ port.onDisconnect.addListener(onDisconnect);
+ port.onMessage.addListener(onMessage);
+ vAPI.messaging.ports[port.name] = port;
+ };
+
+ chrome.runtime.onConnect.addListener(this.connector);
+ },
+ broadcast: function(message) {
+ message = {
+ broadcast: true,
+ msg: message
+ };
+
+ for (var portName in this.ports) {
+ this.ports[portName].postMessage(message);
+ }
+ }
+ };
+
+ vAPI.net = {
+ registerListeners: function() {
+ var listeners = [
+ 'onBeforeRequest',
+ 'onBeforeSendHeaders',
+ 'onHeadersReceived'
+ ];
+
+ for (var i = 0; i < listeners.length; ++i) {
+ chrome.webRequest[listeners[i]].addListener(
+ this[listeners[i]].callback,
+ {
+ 'urls': this[listeners[i]].urls || ['<all_urls>'],
+ 'types': this[listeners[i]].types || []
+ },
+ this[listeners[i]].extra
+ );
+ }
+ }
+ };
+
+ vAPI.contextMenu = {
+ create: function(details, callback) {
+ this.menuId = details.id;
+ this.callback = callback;
+ chrome.contextMenus.create(details);
+ chrome.contextMenus.onClicked.addListener(this.callback);
+ },
+ remove: function() {
+ chrome.contextMenus.onClicked.removeListener(this.callback);
+ chrome.contextMenus.remove(this.menuId);
+ }
+ };
+} else if (window.safari) {
+ vAPI.safari = true;
+
+ safari.extension.settings.addEventListener('change', function(e) {
+ if (e.key === 'open_prefs') {
+ vAPI.tabs.open({url: 'dashboard.html', active: true});
+ }
+ }, false);
+
+ vAPI.storage = {
+ _storage: safari.extension.settings,
+ QUOTA_BYTES: 50 * 1024 * 1024,
+ get: function(keys, callback) {
+ if (typeof callback !== 'function') {
+ return;
+ }
+
+ var i, value, result = {};
+
+ if (keys === null) {
+ for (i in this._storage) {
+ value = this._storage[i];
+
+ if (typeof value === 'string') {
+ result[i] = JSON.parse(value);
+ }
+ }
+ }
+ else if (typeof keys === 'string') {
+ value = this._storage[keys];
+
+ if (typeof value === 'string') {
+ result[keys] = JSON.parse(value);
+ }
+ }
+ else if (Array.isArray(keys)) {
+ for ( i = 0; i < keys.length; ++i) {
+ value = this._storage[i];
+
+ if (typeof value === 'string') {
+ result[keys[i]] = JSON.parse(value);
+ }
+ }
+ }
+ else if (typeof keys === 'object') {
+ for (i in keys) {
+ value = this._storage[i];
+
+ if (typeof value === 'string') {
+ result[i] = JSON.parse(value);
+ }
+ else {
+ result[i] = keys[i];
+ }
+ }
+ }
+
+ callback(result);
+ },
+ set: function(details, callback) {
+ for (var key in details) {
+ this._storage.setItem(key, JSON.stringify(details[key]));
+ }
+
+ if (typeof callback === 'function') {
+ callback();
+ }
+ },
+ remove: function(keys) {
+ if (typeof keys === 'string') {
+ keys = [keys];
+ }
+
+ for (var i = 0; i < keys.length; ++i) {
+ this._storage.removeItem(keys[i]);
+ }
+ },
+ clear: function(callback) {
+ this._storage.clear();
+ callback();
+ },
+ getBytesInUse: function(keys, callback) {
+ var key, size = 0;
+
+ if (keys === null) {
+ for (key in this._storage) {
+ size += (this._storage[key] || '').length;
+ }
+ }
+ else {
+ if (typeof keys === 'string') {
+ keys = [keys];
+ }
+
+ for (key = 0; key < keys.length; ++key) {
+ size += (this._storage[keys[key]] || '').length;
+ }
+ }
+
+ callback(size);
+ }
+ };
+
+ vAPI.tabs = {
+ stack: {},
+ stackID: 1,
+ registerListeners: function() {
+ var onNavigation = this.onNavigation;
+
+ if (typeof onNavigation === 'function') {
+ this.onNavigation = function(e) {
+ // e.url is not present for local files or data URIs
+ if (!e.target || !e.target.url) {
+ return;
+ }
+
+ onNavigation({
+ frameId: 0,
+ tabId: vAPI.tabs.getTabId(e.target),
+ url: e.target.url
+ });
+ };
+
+ safari.application.addEventListener('navigate', this.onNavigation, true);
+ }
+
+ // ??
+ /*if (typeof onUpdated === 'function') {
+ chrome.tabs.onUpdated.addListener(this.onUpdated);
+ }*/
+
+ // onClosed handled in the main tab-close event
+
+ // maybe intercept window.open on web-pages?
+ /*if (typeof onPopup === 'function') {
+ chrome.webNavigation.onCreatedNavigationTarget.addListener(this.onPopup);
+ }*/
+ },
+ getTabId: function(tab) {
+ for (var i in vAPI.tabs.stack) {
+ if (vAPI.tabs.stack[i] === tab) {
+ return +i;
+ }
+ }
+
+ return -1;
+ },
+ get: function(tabId, callback) {
+ var tab;
+
+ if (tabId === null) {
+ tab = safari.application.activeBrowserWindow.activeTab;
+ tabId = this.getTabId(tab);
+ }
+ else {
+ tab = this.stack[tabId];
+ }
+
+ if (!tab) {
+ callback();
+ return;
+ }
+
+ callback({
+ id: tabId,
+ index: tab.browserWindow.tabs.indexOf(tab),
+ windowId: safari.application.browserWindows.indexOf(tab.browserWindow),
+ active: tab === tab.browserWindow.activeTab,
+ url: tab.url,
+ title: tab.title
+ });
+ },
+ open: function(details) {
+ if (!details.url) {
+ return null;
+ }
+ // extension pages
+ else if (!details.url.match(/^\w{2,20}:/)) {
+ details.url = vAPI.getURL(details.url);
+ }
+
+ // 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
+
+ var curWin, tab;
+
+ if (details.select) {
+ tab = safari.application.browserWindows.some(function(win) {
+ var rgxHash = /#.*/;
+ // this is questionable
+ var url = details.url.replace(rgxHash, '');
+
+ for (var i = 0; i < win.tabs.length; ++i) {
+ if (win.tabs[i].url.replace(rgxHash, '') === url) {
+ win.tabs[i].activate();
+ return true;
+ }
+ }
+ });
+
+ if (tab) {
+ return;
+ }
+ }
+
+ if (details.active === undefined) {
+ details.active = true;
+ }
+
+ curWin = safari.application.activeBrowserWindow;
+
+ // it must be calculated before opening a new tab,
+ // otherwise the new tab will be the active tab here
+ if (details.index === -1) {
+ details.index = curWin.tabs.indexOf(curWin.activeTab) + 1;
+ }
+
+ tab = details.tabId && this.stack[details.tabId]
+ || curWin.openTab(details.active ? 'foreground' : 'background');
+
+ if (details.index !== undefined) {
+ curWin.insertTab(tab, details.index);
+ }
+
+ tab.url = details.url;
+ },
+ close: function(tab) {
+ if (!(tab instanceof SafariBrowserTab)) {
+ tab = this.stack[tab];
+ }
+
+ if (tab) {
+ tab.close();
+ }
+ }
+ };
+
+
+ // bind tabs to unique IDs
+ (function() {
+ var wins = safari.application.browserWindows, i = wins.length, j;
+ var tabs = [];
+
+ while (i--) {
+ j = wins[i].tabs.length;
+
+ while (j--) {
+ tabs.push(wins[i].tabs[j]);
+ }
+ }
+
+ return tabs;
+ })().forEach(function(tab) {
+ vAPI.tabs.stack[vAPI.tabs.stackID++] = tab;
+ });
+
+ safari.application.addEventListener('open', function(e) {
+ // ignore windows
+ if (e.target instanceof SafariBrowserTab) {
+ vAPI.tabs.stack[vAPI.tabs.stackID++] = e.target;
+ }
+ }, true);
+
+ safari.application.addEventListener('close', function(e) {
+ // ignore windows
+ if (!(e.target instanceof SafariBrowserTab)) {
+ return;
+ }
+
+ var tabId = vAPI.tabs.getTabId(e.target);
+
+ if (tabId > -1) {
+ // to not add another listener, put this here
+ // instead of vAPI.tabs.registerListeners
+ if (typeof vAPI.tabs.onClosed === 'function') {
+ vAPI.tabs.onClosed(tabId);
+ }
+
+ delete vAPI.tabIcons[tabId];
+ delete vAPI.tabs.stack[tabId];
+ }
+ }, true);
+
+
+ // update badge when tab is activated
+ safari.application.addEventListener('activate', function(e) {
+ // hide popover, since in some cases won't close by itself
+ var items = safari.extension.toolbarItems;
+
+ for (var i = 0; i < items.length; ++i) {
+ if (items[i].browserWindow === safari.application.activeBrowserWindow) {
+ if (items[i].popover) {
+ items[i].popover.hide();
+ }
+
+ break;
+ }
+ }
+
+ // ignore windows
+ if (!(e.target instanceof SafariBrowserTab)) {
+ return;
+ }
+
+ // update the badge, when tab is selected
+ vAPI.setIcon();
+ }, true);
+
+ // reload the popup when that is opened
+ safari.application.addEventListener('popover', function(e) {
+ e.target.contentWindow.document.body.textContent = '';
+ e.target.contentWindow.location.reload();
+ }, true);
+
+ vAPI.tabIcons = { /*tabId: {badge: 0, img: dict}*/ };
+ vAPI.setIcon = function(tabId, img, badge) {
+ var curTabId = vAPI.tabs.getTabId(safari.application.activeBrowserWindow.activeTab);
+
+ // from 'activate' event
+ if (tabId === undefined) {
+ tabId = curTabId;
+ }
+ else {
+ vAPI.tabIcons[tabId] = {
+ badge: badge || 0/*,
+ img: img*/
+ };
+ }
+
+ // if the selected tab has the same ID, then update the badge too,
+ // or always update it when changing tabs ('activate' event)
+ if (tabId === curTabId) {
+ var items = safari.extension.toolbarItems, i = items.length;
+
+ while (i--) {
+ if (items[i].browserWindow === safari.application.activeBrowserWindow) {
+ if (vAPI.tabIcons[tabId]) {
+ items[i].badge = vAPI.tabIcons[tabId].badge;
+ // items[i].img = vAPI.tabIcons[tabId].img;
+ }
+ else {
+ items[i].badge = 0;
+ }
+
+ return;
+ }
+ }
+ }
+ };
+
+ vAPI.messaging = {
+ listeners: {},
+ listen: function(name, callback) {
+ this.listeners[name] = callback;
+ },
+ setup: function(connector) {
+ if (this.connector) {
+ return;
+ }
+
+ this.connector = function(request) {
+ if (request.name === 'canLoad') {
+ return;
+ }
+
+ var callback = function(response) {
+ if (request.message.requestId) {
+ request.target.page.dispatchMessage(
+ 'message',
+ {
+ requestId: request.message.requestId,
+ portName: request.message.portName,
+ msg: response
+ }
+ );
+ }
+ };
+
+ var sender = {
+ tab: {
+ id: vAPI.tabs.getTabId(request.target)
+ }
+ };
+
+ var listener = connector(request.message.msg, sender, callback);
+
+ if (listener === null) {
+ listener = vAPI.messaging.listeners[request.message.portName];
+
+ if (typeof listener === 'function') {
+ listener(request.message.msg, sender, callback);
+ } else {
+ console.error('µBlock> messaging > unknown request: %o', request.message);
+ }
+ }
+ };
+
+ safari.application.addEventListener('message', this.connector, false);
+ },
+ broadcast: function(message) {
+ message = {
+ broadcast: true,
+ msg: message
+ };
+
+ for (var tabId in vAPI.tabs.stack) {
+ vAPI.tabs.stack[tabId].page.dispatchMessage('message', message);
+ }
+ }
+ };
+
+ vAPI.net = {
+ registerListeners: function() {
+ // onBeforeRequest is used in the messaging above, in the connector method
+ // in order to use only one listener
+ var onBeforeRequest = this.onBeforeRequest;
+
+ if (typeof onBeforeRequest.callback === 'function') {
+ if (!Array.isArray(onBeforeRequest.types)) {
+ onBeforeRequest.types = [];
+ }
+
+ onBeforeRequest = onBeforeRequest.callback;
+ this.onBeforeRequest.callback = function(request) {
+ if (request.name !== 'canLoad') {
+ return;
+ }
+
+ // no stopPropagation if it was called from beforeNavigate event
+ if (request.stopPropagation) {
+ request.stopPropagation();
+ }
+
+ var block = vAPI.net.onBeforeRequest;
+
+ if (block.types.indexOf(request.message.type) < 0) {
+ return;
+ }
+
+ request.message.tabId = vAPI.tabs.getTabId(request.target);
+ block = onBeforeRequest(request.message);
+
+ // truthy return value will allow the request,
+ // except when redirectUrl is present
+ if (block && typeof block === 'object') {
+ if (block.cancel) {
+ request.message = false;
+ }
+ else if (typeof block.redirectUrl === "string") {
+ request.message = block.redirectUrl;
+ }
+ else {
+ request.message = true;
+ }
+ }
+ else {
+ request.message = true;
+ }
+
+ return request.message;
+ };
+ safari.application.addEventListener('message', this.onBeforeRequest.callback, true);
+
+ // 'main_frame' simulation, since this isn't available in beforeload
+ safari.application.addEventListener('beforeNavigate', function(e) {
+ // e.url is not present for local files or data URIs
+ if (!e.url) {
+ return;
+ }
+
+ vAPI.net.onBeforeRequest.callback({
+ name: 'canLoad',
+ target: e.target,
+ message: {
+ url: e.url,
+ type: 'main_frame',
+ frameId: 0,
+ parentFrameId: -1,
+ timeStamp: e.timeStamp
+ }
+ }) || e.preventDefault();
+ }, true);
+ }
+ }
+ };
+
+ vAPI.contextMenu = {
+ create: function(details, callback) {
+ var contexts = details.contexts;
+ var menuItemId = details.id;
+ var menuTitle = details.title;
+
+ if (Array.isArray(contexts) && contexts.length) {
+ contexts = contexts.indexOf('all') === -1 ? contexts : null;
+ }
+ else {
+ // default in Chrome
+ contexts = ['page'];
+ }
+
+ this.onContextMenu = function(e) {
+ var uI = e.userInfo;
+
+ if (uI && /^https?:\/\//i.test(uI.pageUrl)) {
+ if (contexts) {
+ var invalidContext = true;
+
+ for (var i = 0; i < contexts.length; ++i) {
+ if (contexts[i] === 'frame') {
+ if (uI.insideFrame) {
+ invalidContext = false;
+ break;
+ }
+ }
+ else if (contexts[i] === 'link') {
+ if (uI.linkHref) {
+ invalidContext = false;
+ break;
+ }
+ }
+ else if (contexts[i] === 'image') {
+ if (uI.srcUrl) {
+ invalidContext = false;
+ break;
+ }
+ }
+ else if (contexts[i] === 'audio' || contexts[i] === 'video') {
+ if (uI.srcUrl && uI.tagName === contexts[i]) {
+ invalidContext = false;
+ break;
+ }
+ }
+ else if (contexts[i] === 'editable') {
+ if (uI.editable) {
+ invalidContext = false;
+ break;
+ }
+ }
+ else if (contexts[i] === 'page') {
+ if (!(uI.insideFrame || uI.linkHref || uI.mediaType || uI.editable)) {
+ invalidContext = false;
+ break;
+ }
+ }
+ }
+
+ if (invalidContext) {
+ return;
+ }
+ }
+
+ e.contextMenu.appendContextMenuItem(menuItemId, menuTitle);
+ }
+ };
+
+ this.onContextMenuCommand = function(e) {
+ if (e.command === menuItemId) {
+ var tab = e.currentTarget.activeBrowserWindow.activeTab;
+ e.userInfo.menuItemId = menuItemId;
+ callback(e.userInfo, tab ? {
+ id: vAPI.tabs.getTabId(tab),
+ url: tab.url
+ } : undefined);
+ }
+ };
+
+ safari.application.addEventListener('contextmenu', this.onContextMenu);
+ safari.application.addEventListener("command", this.onContextMenuCommand);
+ },
+ remove: function(argument) {
+ safari.application.removeEventListener('contextmenu', this.onContextMenu);
+ safari.application.removeEventListener("command", this.onContextMenuCommand);
+ this.onContextMenu = null;
+ this.onContextMenuCommand = null;
+ }
+ };
+}
+
+if (!window.chrome) {
+ window.chrome = { runtime: { lastError: null } };
+}
+})();
generated by cgit v1.1 at 2024-07-29 20:04:57 +0000