LocalCDN-Firefox-Chrome-Brave/core/state-manager.js

389 lines
13 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* State Manager
* Belongs to LocalCDN (since 2020-02-26)
* (Origin: Decentraleyes)
*
* @author Thomas Rientjes
* @since 2017-03-10
*
* @author nobody
* @since 2020-02-26
*
* @license MPL 2.0
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/.
*/
'use strict';
/**
* State Manager
*/
let stateManager = {};
/**
* Public Methods
*/
stateManager.registerInjection = function (tabIdentifier, injection, url) {
let injectionIdentifier, registeredTab, injectionCount, missingCount, blockedCount,
initiatorDomain, htmlFilterIsActive;
if (injection['result'] !== false) {
injectionIdentifier = injection.source + injection.path;
registeredTab = stateManager.tabs[tabIdentifier];
registeredTab.injections[injectionIdentifier] = injection;
}
initiatorDomain = helpers.extractDomainFromUrl(url, true) || Address.EXAMPLE;
htmlFilterIsActive = manipulateDOM.checkHtmlFilterEnabled(initiatorDomain);
if (registeredTab !== undefined) {
injectionCount = Object.keys(registeredTab.injections).length || 0;
missingCount = registeredTab.missing || 0;
blockedCount = registeredTab.blocked || 0;
} else {
return;
}
if (injectionCount > 0) {
chrome.browserAction.setTitle({
'tabId': tabIdentifier,
'title': `LocalCDN (${injectionCount})`
});
}
if (stateManager.showIconBadge === true) {
if ((missingCount > 0 || blockedCount > 0) && stateManager.changeBadgeColorMissingResources) {
wrappers.setBadgeColoring(tabIdentifier, BadgeSettingMissingResource.TYPE);
} else if (htmlFilterIsActive) {
wrappers.setBadgeColoring(tabIdentifier, BadgeSettingHTMLFilter.TYPE);
} else {
wrappers.setBadgeColoring(tabIdentifier, BadgeSetting.TYPE);
}
wrappers.setBadgeText(tabIdentifier, (injectionCount + missingCount + blockedCount));
}
if (isNaN(storageManager.amountInjected)) {
storageManager.type.get(Setting.AMOUNT_INJECTED, function (items) {
storageManager.amountInjected = items.amountInjected;
storageManager.type.set({
[Setting.AMOUNT_INJECTED]: ++storageManager.amountInjected
});
});
} else {
chrome.storage.local.set({
[Setting.AMOUNT_INJECTED]: ++storageManager.amountInjected
});
}
if (stateManager.internalStatistics) {
stats.setStats(injection);
}
};
stateManager.addDomainToAllowlist = function (domain) {
return new Promise((resolve) => {
let allowlistedDomains = requestAnalyzer.allowlistedDomains;
allowlistedDomains[domain] = true;
storageManager.type.set({allowlistedDomains}, resolve);
});
};
stateManager.removeDomainFromAllowlist = function (domain) {
return new Promise((resolve) => {
let allowlistedDomains;
allowlistedDomains = requestAnalyzer.allowlistedDomains;
if (allowlistedDomains[domain]) {
delete allowlistedDomains[domain];
} else {
for (const key in allowlistedDomains) {
if (key.startsWith('*.') && domain.endsWith(key.substring(2))) {
delete allowlistedDomains[key];
break;
}
}
}
storageManager.type.set({allowlistedDomains}, resolve);
});
};
stateManager.addDomainToManipulateDOMlist = function (domain) {
return new Promise((resolve) => {
let domainsManipulateDOM = requestAnalyzer.domainsManipulateDOM;
domainsManipulateDOM[domain] = true;
storageManager.type.set({domainsManipulateDOM}, resolve);
});
};
stateManager.removeDomainFromManipulateDOMlist = function (domain) {
return new Promise((resolve) => {
let domainsManipulateDOM = requestAnalyzer.domainsManipulateDOM;
delete domainsManipulateDOM[domain];
storageManager.type.set({domainsManipulateDOM}, resolve);
});
};
stateManager.addDomainToGoogleFontsList = function (domain) {
return new Promise((resolve) => {
let allowedDomainsGoogleFonts = interceptor.allowedDomainsGoogleFonts;
allowedDomainsGoogleFonts[domain] = true;
storageManager.type.set({allowedDomainsGoogleFonts}, resolve);
});
};
stateManager.removeDomainFromGoogleFontsList = function (domain) {
return new Promise((resolve) => {
let allowedDomainsGoogleFonts = interceptor.allowedDomainsGoogleFonts;
delete allowedDomainsGoogleFonts[domain];
storageManager.type.set({allowedDomainsGoogleFonts}, resolve);
});
};
/**
* Private Methods
*/
stateManager._createTab = function (tab) {
let tabIdentifier, requestFilters;
tabIdentifier = tab.id;
stateManager.tabs[tabIdentifier] = {
'injections': {},
'missing': 0,
'blocked': 0
};
requestFilters = {
'tabId': tabIdentifier,
'urls': stateManager.validHosts
};
chrome.webRequest.onBeforeRequest.addListener(function (requestDetails) {
tab = stateManager.tabs[tabIdentifier].details || {};
return interceptor.handleRequest(requestDetails, tabIdentifier, tab);
}, requestFilters, [WebRequest.BLOCKING]);
};
stateManager._removeTab = function (tabIdentifier) {
delete stateManager.tabs[tabIdentifier];
};
stateManager._updateTab = function (details) {
let tabDomain, domainIsAllowlisted, frameIdentifier, tabIdentifier;
tabDomain = helpers.extractDomainFromUrl(details.url, true);
domainIsAllowlisted = stateManager._domainIsListed(tabDomain);
frameIdentifier = details.frameId;
tabIdentifier = details.tabId;
if (frameIdentifier !== 0 || tabIdentifier === -1) {
return;
}
chrome.browserAction.setTitle({
'tabId': tabIdentifier,
'title': 'LocalCDN (0)'
});
if (domainIsAllowlisted) {
stateManager._setIconDisabled(tabIdentifier);
chrome.browserAction.setTitle({
'tabId': tabIdentifier,
'title': 'LocalCDN ()'
});
}
if (stateManager.showIconBadge === true) {
stateManager._clearBadgeText(tabIdentifier);
}
if (stateManager.tabs[tabIdentifier]) {
stateManager.tabs[tabIdentifier].injections = {};
stateManager.tabs[tabIdentifier].missing = 0;
stateManager.tabs[tabIdentifier].blocked = 0;
}
};
stateManager._handleStorageChanged = function (changes) {
if (Setting.SHOW_ICON_BADGE in changes) {
stateManager.showIconBadge = changes.showIconBadge.newValue;
if (changes.showIconBadge.newValue !== true) {
chrome.tabs.query({}, function (tabs) {
tabs.forEach(stateManager._removeIconBadgeFromTab);
});
}
} else if (Setting.STRIP_METADATA in changes) {
requestSanitizer.disable();
if (changes.stripMetadata.newValue !== false) {
requestSanitizer.enable();
}
} else if (Setting.NEGATE_HTML_FILTER_LIST in changes) {
stateManager.getInvertOption = changes.negateHtmlFilterList.newValue;
} else if (Setting.SELECTED_ICON in changes) {
stateManager.selectedIcon = changes.selectedIcon.newValue;
} else if (Setting.INTERNAL_STATISTICS in changes) {
stateManager.internalStatistics = changes.internalStatistics.newValue;
} else if (Setting.INTERNAL_STATISTICS_DATA in changes) {
stats.data = changes.internalStatisticsData.newValue;
} else if (Setting.HIDE_DONATION_BUTTON in changes) {
stateManager.hideDonationButton = changes.hideDonationButton.newValue;
} else if (Setting.CHANGE_BADGE_COLOR_MISSING_RESOURCES in changes) {
stateManager.changeBadgeColorMissingResources = changes.changeBadgeColorMissingResources.newValue;
} else if (Setting.LOGGING in changes) {
stateManager.logging = changes.enableLogging.newValue;
} else if (Setting.BADGE_DEFAULT_TEXT_COLOR in changes) {
wrappers.badgeDefaultTextColor = changes.badgeDefaultTextColor.newValue;
} else if (Setting.BADGE_DEFAULT_BACKGROUND_COLOR in changes) {
wrappers.badgeDefaultBackgroundColor = changes.badgeDefaultBackgroundColor.newValue;
} else if (Setting.BADGE_HTML_FILTER_TEXT_COLOR in changes) {
wrappers.badgeHTMLfilterTextColor = changes.badgeHTMLfilterTextColor.newValue;
} else if (Setting.BADGE_HTML_FILTER_BACKGROUND_COLOR in changes) {
wrappers.badgeHTMLFilterBackgroundColor = changes.badgeHTMLFilterBackgroundColor.newValue;
}
};
stateManager._clearBadgeText = function (tabIdentifier) {
wrappers.setBadgeText(tabIdentifier, '');
};
stateManager._removeIconBadgeFromTab = function (tab) {
stateManager._clearBadgeText(tab.id);
};
stateManager._domainIsListed = function (domain, listname) {
if (domain !== null) {
let allowlistRecord, isAllowlisted;
if (listname === 'manipulate-dom') {
allowlistRecord = helpers.checkAllowlisted(domain, requestAnalyzer.domainsManipulateDOM);
isAllowlisted = Boolean(allowlistRecord);
} else {
allowlistRecord = helpers.checkAllowlisted(domain, requestAnalyzer.allowlistedDomains);
isAllowlisted = Boolean(allowlistRecord);
}
return isAllowlisted;
}
return false;
};
stateManager._setIconDisabled = function (tabIdentifier) {
wrappers.setIcon({
'path': stateManager.selectedIcon || 'Default',
'tabId': tabIdentifier
}, 'Disabled');
};
/**
* Initializations
*/
stateManager.requests = {};
stateManager.tabs = {};
stateManager.getInvertOption = true;
stateManager.validHosts = [];
stateManager.selectedIcon = 'Default';
stateManager.internalStatistics = false;
stateManager.hideDonationButton = false;
stateManager.changeBadgeColorMissingResources = false;
stateManager.logging = false;
for (let mapping in mappings.cdn) {
let supportedHost = Address.ANY_PROTOCOL + mapping + Address.ANY_PATH;
stateManager.validHosts.push(supportedHost);
}
chrome.tabs.query({}, function (tabs) {
tabs.forEach(stateManager._createTab);
});
storageManager.type.get([
Setting.SHOW_ICON_BADGE,
Setting.NEGATE_HTML_FILTER_LIST,
Setting.SELECTED_ICON,
Setting.INTERNAL_STATISTICS,
Setting.HIDE_DONATION_BUTTON,
Setting.CHANGE_BADGE_COLOR_MISSING_RESOURCES,
Setting.LOGGING,
Setting.AMOUNT_INJECTED
], function (items) {
if (items.showIconBadge === undefined) {
items.showIconBadge = true;
}
if (items.selectedIcon === undefined) {
stateManager.selectedIcon = 'Default';
}
if (items.negateHtmlFilterList === undefined) {
stateManager.getInvertOption = true;
} else {
stateManager.getInvertOption = items.negateHtmlFilterList;
}
stateManager.showIconBadge = items.showIconBadge;
stateManager.selectedIcon = items.selectedIcon;
stateManager.internalStatistics = items.internalStatistics;
stateManager.hideDonationButton = items.hideDonationButton;
stateManager.changeBadgeColorMissingResources = items.changeBadgeColorMissingResources;
stateManager.logging = items.enableLogging;
stateManager.amountInjected = items.amountInjected;
});
chrome.storage.local.get([Setting.INTERNAL_STATISTICS], function (items) {
stateManager.internalStatistics = items.internalStatistics;
});
/**
* Event Handlers
*/
chrome.tabs.onCreated.addListener(stateManager._createTab);
chrome.tabs.onRemoved.addListener(stateManager._removeTab);
chrome.webRequest.onBeforeRequest.addListener(function (requestDetails) {
if (requestDetails.tabId !== -1 && stateManager.tabs[requestDetails.tabId]) {
stateManager.tabs[requestDetails.tabId].details = {
'url': requestDetails.url
};
}
}, {'types': [WebRequestType.MAIN_FRAME], 'urls': [Address.ANY]}, [WebRequest.BLOCKING]);
chrome.webNavigation.onCommitted.addListener(stateManager._updateTab, {
'url': [{'urlContains': ':'}]
});
chrome.webRequest.onErrorOccurred.addListener(function (requestDetails) {
if (stateManager.requests[requestDetails.requestId]) {
delete stateManager.requests[requestDetails.requestId];
}
}, {'urls': [Address.ANY]});
chrome.webRequest.onBeforeRedirect.addListener(function (requestDetails) {
let knownRequest = stateManager.requests[requestDetails.requestId];
if (knownRequest) {
stateManager.registerInjection(
knownRequest.tabIdentifier,
knownRequest.targetDetails,
requestDetails.originUrl
);
delete stateManager.requests[requestDetails.requestId];
}
}, {'urls': [Address.ANY]});
chrome.storage.onChanged.addListener(stateManager._handleStorageChanged);