security-and-privacy/CanvasBlocker
security-and-privacy
/
CanvasBlocker
mirror of https://github.com/kkapsner/CanvasBlocker
1
0
Fork 0
Code Releases Activity

Code cleanup: reduce block nesting

This commit is contained in:
kkapsner 2019-12-29 00:18:05 +01:00
parent 10413a89c3
commit abdb95b815
6 changed files with 310 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
lib/intercept.js
View File

@ -394,28 +394,29 @@
){ ){
const protectedAPIFeatures = prefs("protectedAPIFeatures"); const protectedAPIFeatures = prefs("protectedAPIFeatures");
if ( if (
!protectedAPIFeatures.hasOwnProperty(name + " @ " + changedGetter.api) || protectedAPIFeatures.hasOwnProperty(name + " @ " + changedGetter.api) &&
protectedAPIFeatures[name + " @ " + changedGetter.api] !protectedAPIFeatures[name + " @ " + changedGetter.api]
){ ){
switch (functionStatus.mode){ return;
case "ask": case "block": case "fake": }
descriptor.value = changedGetter.valueGenerator({ switch (functionStatus.mode){
mode: functionStatus.mode, case "ask": case "block": case "fake":
original: descriptor.value, descriptor.value = changedGetter.valueGenerator({
notify: function notifyCallback(messageId){ mode: functionStatus.mode,
notify({ original: descriptor.value,
url: getURL(windowToProcess), notify: function notifyCallback(messageId){
errorStack: (new Error()).stack, notify({
messageId, url: getURL(windowToProcess),
timestamp: new Date(), errorStack: (new Error()).stack,
functionName: name, messageId,
api: changedGetter.api timestamp: new Date(),
}); functionName: name,
} api: changedGetter.api
}); });
Object.defineProperty(object, name, descriptor); }
break; });
} Object.defineProperty(object, name, descriptor);
break;
} }
} }
else { else {

138
lib/modifiedCanvasAPI.js
View File

@ -8,7 +8,7 @@
const colorStatistics = require("./colorStatistics"); const colorStatistics = require("./colorStatistics");
const logging = require("./logging"); const logging = require("./logging");
const extension = require("./extension"); const extension = require("./extension");
const {copyCanvasToWebgl} = require("./webgl"); const webgl = require("./webgl");
const {checkerWrapper} = require("./modifiedAPIFunctions"); const {checkerWrapper} = require("./modifiedAPIFunctions");
let randomSupply = null; let randomSupply = null;
@ -182,98 +182,10 @@
scope.setRandomSupply = function(supply){ scope.setRandomSupply = function(supply){
randomSupply = supply; randomSupply = supply;
webgl.setRandomSupply(supply);
}; };
function getNumber(originalValue, max, index, window){
const bitLength = Math.floor(Math.log2(max) + 1);
const rng = randomSupply.getBitRng(bitLength, window);
let value = 0;
for (let i = 0; i < bitLength; i += 1){
value <<= 1;
value ^= rng(originalValue, index + i);
}
return value;
}
const parameterFakeTypes = {
decimal: function(originalValue, definition, window){
const int = Math.floor(originalValue);
if (int !== originalValue){
const decimal = originalValue - int;
const rng = randomSupply.getRng(1, window);
const newDecimal = decimal * (rng(definition.pname) / 0xFFFFFFFF);
return int + newDecimal;
}
else {
return originalValue;
}
},
shift: function(originalValue, definition, window){
const value = getNumber(originalValue, definition.max, definition.pname, window);
return originalValue >>> value;
},
"-": function(originalValue, definition, window){
const value = getNumber(originalValue, definition.max, definition.pname, window) *
(definition.factor || 1);
if (value > originalValue){
return 0;
}
return originalValue - value;
}
};
const parameterChangeDefinition = {
2928: {name: "DEPTH_RANGE", type: "decimal", isArray: true},
3379: {name: "MAX_TEXTURE_SIZE", type: "shift", max: 1},
3386: {name: "MAX_VIEWPORT_DIMS", type: "shift", max: 1, isArray: true},
32883: {name: "MAX_3D_TEXTURE_SIZE", type: "shift", max: 1},
33000: {name: "MAX_ELEMENTS_VERTICES", type: "-", max: 3, factor: 50},
33001: {name: "MAX_ELEMENTS_INDICES", type: "-", max: 3, factor: 50},
33901: {name: "ALIASED_POINT_SIZE_RANGE", type: "decimal", isArray: true},
33902: {name: "ALIASED_LINE_WIDTH_RANGE", type: "decimal", isArray: true},
34024: {name: "MAX_RENDERBUFFER_SIZE", type: "shift", max: 1},
34045: {name: "MAX_TEXTURE_LOD_BIAS", type: "-", max: 1, factor: 1},
34076: {name: "MAX_CUBE_MAP_TEXTURE_SIZE", type: "shift", max: 1},
34921: {name: "MAX_VERTEX_ATTRIBS", type: "shift", max: 1},
34930: {name: "MAX_TEXTURE_IMAGE_UNITS", type: "shift", max: 1},
35071: {name: "MAX_ARRAY_TEXTURE_LAYERS", type: "shift", max: 1},
35371: {name: "MAX_VERTEX_UNIFORM_BLOCKS", type: "-", max: 1, factor: 1},
35373: {name: "MAX_FRAGMENT_UNIFORM_BLOCKS", type: "-", max: 1, factor: 1},
35374: {name: "MAX_COMBINED_UNIFORM_BLOCKS", type: "-", max: 3, factor: 1},
35375: {name: "MAX_UNIFORM_BUFFER_BINDINGS", type: "-", max: 3, factor: 1},
35376: {name: "MAX_UNIFORM_BLOCK_SIZE", type: "shift", max: 1},
35377: {name: "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", type: "-", max: 7, factor: 10},
35379: {name: "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", type: "-", max: 7, factor: 10},
35657: {name: "MAX_FRAGMENT_UNIFORM_COMPONENTS", type: "shift", max: 1},
35658: {name: "MAX_VERTEX_UNIFORM_COMPONENTS", type: "shift", max: 1},
35659: {name: "MAX_VARYING_COMPONENTS", type: "shift", max: 1},
35660: {name: "MAX_VERTEX_TEXTURE_IMAGE_UNITS", type: "shift", max: 1},
35661: {name: "MAX_COMBINED_TEXTURE_IMAGE_UNITS", type: "-", max: 1, factor: 2},
35968: {name: "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", type: "shift", max: 1},
35978: {name: "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", type: "shift", max: 1},
36203: {name: "MAX_ELEMENT_INDEX", type: "-", max: 15, factor: 1},
36347: {name: "MAX_VERTEX_UNIFORM_VECTORS", type: "shift", max: 1},
36348: {name: "MAX_VARYING_VECTORS", type: "shift", max: 1},
36349: {name: "MAX_FRAGMENT_UNIFORM_VECTORS", type: "shift", max: 1},
37154: {name: "MAX_VERTEX_OUTPUT_COMPONENTS", type: "shift", max: 1},
37157: {name: "MAX_FRAGMENT_INPUT_COMPONENTS", type: "shift", max: 1},
7936: {name: "VENDOR", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLVendor") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}},
7937: {name: "RENDERER", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLRenderer") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}},
37445: {name: "UNMASKED_VENDOR_WEBGL", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLUnmaskedVendor") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}},
37446: {name: "UNMASKED_RENDERER_WEBGL", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLUnmaskedRenderer") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}}
};
const canvasContextType = new WeakMap(); const canvasContextType = new WeakMap();
// changed functions and their fakes // changed functions and their fakes
scope.changedFunctions = { scope.changedFunctions = {
@ -592,7 +504,7 @@
if (!this || canvasSizeShouldBeFaked(this.canvas, prefs)){ if (!this || canvasSizeShouldBeFaked(this.canvas, prefs)){
notify("fakedReadout"); notify("fakedReadout");
const fakeCanvas = getFakeCanvas(window, this.canvas, prefs); const fakeCanvas = getFakeCanvas(window, this.canvas, prefs);
const {context} = copyCanvasToWebgl( const {context} = webgl.copyCanvasToWebgl(
window, window,
fakeCanvas, fakeCanvas,
this instanceof window.WebGLRenderingContext? "webgl": "webgl2" this instanceof window.WebGLRenderingContext? "webgl": "webgl2"
@ -616,51 +528,13 @@
}, },
object: ["WebGLRenderingContext", "WebGL2RenderingContext"], object: ["WebGLRenderingContext", "WebGL2RenderingContext"],
fakeGenerator: function(checker){ fakeGenerator: function(checker){
Object.keys(parameterChangeDefinition).forEach(function(parameterName){ webgl.initializeParameterDefinitions();
const definition = parameterChangeDefinition[parameterName];
definition.pname = parameterName;
if (!definition.fake){
definition.fake = definition.isArray?
function fake(originalValue, window){
let faked = false;
let fakedValue = [];
for (let i = 0; i < originalValue.length; i += 1){
fakedValue[i] = parameterFakeTypes[this.type](originalValue[i], this, window);
faked |= originalValue[i] === fakedValue[i];
originalValue[i] = fakedValue[i];
}
this.fake = function(originalValue){
if (faked){
for (let i = 0; i < originalValue.length; i += 1){
originalValue[i] = fakedValue[i];
}
}
return {
value: originalValue,
faked
};
};
return {
value: originalValue,
faked
};
}:
function fake(originalValue, window){
let value = parameterFakeTypes[this.type](originalValue, this, window);
let faked = value === originalValue;
this.fake = function(){
return {value, faked};
};
return {value, faked};
};
}
});
return function getParameter(pname){ return function getParameter(pname){
return checkerWrapper(checker, this, arguments, function(args, check){ return checkerWrapper(checker, this, arguments, function(args, check){
const {prefs, notify, window, original} = check; const {prefs, notify, window, original} = check;
const originalValue = original.apply(this, window.Array.from(args)); const originalValue = original.apply(this, window.Array.from(args));
if (parameterChangeDefinition[pname]){ if (webgl.parameterChangeDefinition[pname]){
const definition = parameterChangeDefinition[pname]; const definition = webgl.parameterChangeDefinition[pname];
const {value, faked} = definition.fake(originalValue, window, prefs); const {value, faked} = definition.fake(originalValue, window, prefs);
if (faked){ if (faked){
notify("fakedReadout"); notify("fakedReadout");

87
lib/modifiedScreenAPI.js
View File

@ -206,6 +206,50 @@
objectGetters: [function(window){return window.MediaQueryList && window.MediaQueryList.prototype;}], objectGetters: [function(window){return window.MediaQueryList && window.MediaQueryList.prototype;}],
name: "matches", name: "matches",
getterGenerator: function(checker){ getterGenerator: function(checker){
function getAlteredMedia(originalMedia, prefs, window){
const dimensions = getScreenDimensions(prefs, window);
return originalMedia.replace(
/\(\s*(?:(min|max)-)?device-(width|height):\s+(\d+\.?\d*)px\s*\)/,
function(m, type, dimension, value){
value = parseFloat(value);
let newCompareValue = value;
switch (type){
case "min":
if (value <= dimensions[dimension]){
newCompareValue = 0;
}
else {
newCompareValue = 2 * physical[dimension];
}
break;
case "max":
if (value >= dimensions[dimension]){
newCompareValue = 2 * physical[dimension];
}
else {
newCompareValue = 0;
}
break;
default:
if (
Math.round(value * 100) ===
Math.round(dimensions[dimension] * 100)
){
newCompareValue = physical[dimension];
}
else {
newCompareValue = 0;
}
}
return "(" + (type? type + "-": "") +
"device-" + dimension + ": " +
(
newCompareValue /
window.devicePixelRatio
) + "px)";
}
);
}
const temp = { const temp = {
get matches(){ get matches(){
return checkerWrapper(checker, this, arguments, function(args, check){ return checkerWrapper(checker, this, arguments, function(args, check){
@ -219,49 +263,8 @@
) && ) &&
this.media.match(/device-(width|height)/) this.media.match(/device-(width|height)/)
){ ){
const dimensions = getScreenDimensions(prefs, window);
const originalMedia = this.media; const originalMedia = this.media;
const alteredMedia = this.media.replace( const alteredMedia = getAlteredMedia(originalMedia, prefs, window);
/\(\s*(?:(min|max)-)?device-(width|height):\s+(\d+\.?\d*)px\s*\)/,
function(m, type, dimension, value){
value = parseFloat(value);
let newCompareValue = value;
switch (type){
case "min":
if (value <= dimensions[dimension]){
newCompareValue = 0;
}
else {
newCompareValue = 2 * physical[dimension];
}
break;
case "max":
if (value >= dimensions[dimension]){
newCompareValue = 2 * physical[dimension];
}
else {
newCompareValue = 0;
}
break;
default:
if (
Math.round(value * 100) ===
Math.round(dimensions[dimension] * 100)
){
newCompareValue = physical[dimension];
}
else {
newCompareValue = 0;
}
}
return "(" + (type? type + "-": "") +
"device-" + dimension + ": " +
(
newCompareValue /
window.devicePixelRatio
) + "px)";
}
);
if (alteredMedia !== originalMedia){ if (alteredMedia !== originalMedia){
const alteredQuery = window.matchMedia(alteredMedia); const alteredQuery = window.matchMedia(alteredMedia);
const fakedValue = original.call(alteredQuery); const fakedValue = original.call(alteredQuery);

131
lib/settingContainers.js
View File

@ -165,76 +165,77 @@
}; };
scope.initializeUrlContainer = function(eventHandler){ scope.initializeUrlContainer = function(eventHandler){
if (scope.urlContainer){ if (!scope.urlContainer){
scope.urlContainer.on(function({newValue, oldValue}){ return;
newValue.forEach(function(urlSetting){ }
let regExp; scope.urlContainer.on(function({newValue, oldValue}){
const domain = !!urlSetting.url.match(/^[A-Za-z0-9_.-]+$/); newValue.forEach(function(urlSetting){
if (domain){ let regExp;
regExp = new RegExp( const domain = !!urlSetting.url.match(/^[A-Za-z0-9_.-]+$/);
"(?:^|\\.)" + urlSetting.url.replace(/([\\+*?[^\]$(){}=!|.])/g, "\\$1") + "\\.?$", if (domain){
"i" regExp = new RegExp(
); "(?:^|\\.)" + urlSetting.url.replace(/([\\+*?[^\]$(){}=!|.])/g, "\\$1") + "\\.?$",
"i"
);
}
else {
regExp = new RegExp(urlSetting.url, "i");
}
const match = function(url){
if (!url){
return false;
}
else if (
url instanceof String ||
(typeof url) === "string"
){
return url === urlSetting.url;
}
else if (domain){
return (url.hostname || "").match(regExp);
} }
else { else {
regExp = new RegExp(urlSetting.url, "i"); return url.href.match(regExp);
} }
const match = function(url){ };
if (!url){ Object.defineProperty(
return false; urlSetting,
} "match",
else if ( {
url instanceof String || enumerable: false,
(typeof url) === "string" writable: true,
){ configurable: true,
return url === urlSetting.url; value: match
} }
else if (domain){ );
return (url.hostname || "").match(regExp); });
}
else { const newUrls = newValue.map(function(entry){return entry.url;});
return url.href.match(regExp); const oldUrls = oldValue.map(function(entry){return entry.url;});
} const matching = {};
}; newUrls.forEach(function(url, i){
Object.defineProperty( matching[url] = {new: i, old: oldUrls.indexOf(url)};
urlSetting, });
"match", oldUrls.forEach(function(url, i){
{ if (!matching[url]){
enumerable: false, matching[url] = {new: -1, old: i};
writable: true, }
configurable: true, });
value: match Object.keys(matching).forEach(function(url){
} const oldEntry = oldValue[matching[url].old] || {};
); const newEntry = newValue[matching[url].new] || {};
}); scope.urlContainer.entries.forEach(function(settingDefinition){
const name = settingDefinition.name;
const newUrls = newValue.map(function(entry){return entry.url;}); const oldValue = oldEntry[name];
const oldUrls = oldValue.map(function(entry){return entry.url;}); const newValue = newEntry[name];
const matching = {};
newUrls.forEach(function(url, i){ if (oldValue !== newValue){
matching[url] = {new: i, old: oldUrls.indexOf(url)}; ((eventHandler[name] || {})[url] || []).forEach(function(callback){
}); callback({name, newValue, oldValue, url});
oldUrls.forEach(function(url, i){ });
if (!matching[url]){
matching[url] = {new: -1, old: i};
} }
});
Object.keys(matching).forEach(function(url){
const oldEntry = oldValue[matching[url].old] || {};
const newEntry = newValue[matching[url].new] || {};
scope.urlContainer.entries.forEach(function(settingDefinition){
const name = settingDefinition.name;
const oldValue = oldEntry[name];
const newValue = newEntry[name];
if (oldValue !== newValue){
((eventHandler[name] || {})[url] || []).forEach(function(callback){
callback({name, newValue, oldValue, url});
});
}
});
}); });
}); });
} });
}; };
}()); }());

66
lib/settingStrings.js
View File

@ -16,40 +16,40 @@
scope.getMessages = function(settingDefinition){ scope.getMessages = function(settingDefinition){
const messages = []; const messages = [];
if (settingDefinition){ if (!settingDefinition){
messages.push(settingDefinition.name + "_title"); return messages;
messages.push(settingDefinition.name + "_description"); }
if (settingDefinition.urlSpecific){
messages.push(settingDefinition.name + "_urlSpecific"); messages.push(settingDefinition.name + "_title");
} messages.push(settingDefinition.name + "_description");
if (settingDefinition.options){ if (settingDefinition.urlSpecific){
settingDefinition.options.forEach(function(option){ messages.push(settingDefinition.name + "_urlSpecific");
if (option !== null){ }
messages.push(settingDefinition.name + "_options." + option); if (settingDefinition.options){
} settingDefinition.options.forEach(function(option){
}); if (option !== null){
} messages.push(settingDefinition.name + "_options." + option);
if (settingDefinition.inputs){ }
settingDefinition.inputs.forEach(function(input){ });
if (input){ }
if (input.options){ if (settingDefinition.inputs){
input.options.forEach(function(option){ settingDefinition.inputs.forEach(function(input){
if (option !== null){ if (input && input.options){
messages.push(input.name + "_options." + option); input.options.forEach(function(option){
} if (option !== null){
}); messages.push(input.name + "_options." + option);
} }
} });
}); }
} });
if (settingDefinition.action){ }
messages.push(settingDefinition.name + "_label"); if (settingDefinition.action){
} messages.push(settingDefinition.name + "_label");
if (settingDefinition.actions){ }
settingDefinition.actions.forEach(function(action){ if (settingDefinition.actions){
messages.push(action.name + "_label"); settingDefinition.actions.forEach(function(action){
}); messages.push(action.name + "_label");
} });
} }
return messages; return messages;
}; };

138
lib/webgl.js
View File

@ -109,4 +109,142 @@
return {webGlCanvas, context}; return {webGlCanvas, context};
}; };
let randomSupply = null;
scope.setRandomSupply = function(supply){
randomSupply = supply;
};
function getNumber(originalValue, max, index, window){
const bitLength = Math.floor(Math.log2(max) + 1);
const rng = randomSupply.getBitRng(bitLength, window);
let value = 0;
for (let i = 0; i < bitLength; i += 1){
value <<= 1;
value ^= rng(originalValue, index + i);
}
return value;
}
const parameterFakeTypes = {
decimal: function(originalValue, definition, window){
const int = Math.floor(originalValue);
if (int !== originalValue){
const decimal = originalValue - int;
const rng = randomSupply.getRng(1, window);
const newDecimal = decimal * (rng(definition.pname) / 0xFFFFFFFF);
return int + newDecimal;
}
else {
return originalValue;
}
},
shift: function(originalValue, definition, window){
const value = getNumber(originalValue, definition.max, definition.pname, window);
return originalValue >>> value;
},
"-": function(originalValue, definition, window){
const value = getNumber(originalValue, definition.max, definition.pname, window) *
(definition.factor || 1);
if (value > originalValue){
return 0;
}
return originalValue - value;
}
};
const parameterChangeDefinition = {
2928: {name: "DEPTH_RANGE", type: "decimal", isArray: true},
3379: {name: "MAX_TEXTURE_SIZE", type: "shift", max: 1},
3386: {name: "MAX_VIEWPORT_DIMS", type: "shift", max: 1, isArray: true},
32883: {name: "MAX_3D_TEXTURE_SIZE", type: "shift", max: 1},
33000: {name: "MAX_ELEMENTS_VERTICES", type: "-", max: 3, factor: 50},
33001: {name: "MAX_ELEMENTS_INDICES", type: "-", max: 3, factor: 50},
33901: {name: "ALIASED_POINT_SIZE_RANGE", type: "decimal", isArray: true},
33902: {name: "ALIASED_LINE_WIDTH_RANGE", type: "decimal", isArray: true},
34024: {name: "MAX_RENDERBUFFER_SIZE", type: "shift", max: 1},
34045: {name: "MAX_TEXTURE_LOD_BIAS", type: "-", max: 1, factor: 1},
34076: {name: "MAX_CUBE_MAP_TEXTURE_SIZE", type: "shift", max: 1},
34921: {name: "MAX_VERTEX_ATTRIBS", type: "shift", max: 1},
34930: {name: "MAX_TEXTURE_IMAGE_UNITS", type: "shift", max: 1},
35071: {name: "MAX_ARRAY_TEXTURE_LAYERS", type: "shift", max: 1},
35371: {name: "MAX_VERTEX_UNIFORM_BLOCKS", type: "-", max: 1, factor: 1},
35373: {name: "MAX_FRAGMENT_UNIFORM_BLOCKS", type: "-", max: 1, factor: 1},
35374: {name: "MAX_COMBINED_UNIFORM_BLOCKS", type: "-", max: 3, factor: 1},
35375: {name: "MAX_UNIFORM_BUFFER_BINDINGS", type: "-", max: 3, factor: 1},
35376: {name: "MAX_UNIFORM_BLOCK_SIZE", type: "shift", max: 1},
35377: {name: "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", type: "-", max: 7, factor: 10},
35379: {name: "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", type: "-", max: 7, factor: 10},
35657: {name: "MAX_FRAGMENT_UNIFORM_COMPONENTS", type: "shift", max: 1},
35658: {name: "MAX_VERTEX_UNIFORM_COMPONENTS", type: "shift", max: 1},
35659: {name: "MAX_VARYING_COMPONENTS", type: "shift", max: 1},
35660: {name: "MAX_VERTEX_TEXTURE_IMAGE_UNITS", type: "shift", max: 1},
35661: {name: "MAX_COMBINED_TEXTURE_IMAGE_UNITS", type: "-", max: 1, factor: 2},
35968: {name: "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", type: "shift", max: 1},
35978: {name: "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", type: "shift", max: 1},
36203: {name: "MAX_ELEMENT_INDEX", type: "-", max: 15, factor: 1},
36347: {name: "MAX_VERTEX_UNIFORM_VECTORS", type: "shift", max: 1},
36348: {name: "MAX_VARYING_VECTORS", type: "shift", max: 1},
36349: {name: "MAX_FRAGMENT_UNIFORM_VECTORS", type: "shift", max: 1},
37154: {name: "MAX_VERTEX_OUTPUT_COMPONENTS", type: "shift", max: 1},
37157: {name: "MAX_FRAGMENT_INPUT_COMPONENTS", type: "shift", max: 1},
7936: {name: "VENDOR", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLVendor") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}},
7937: {name: "RENDERER", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLRenderer") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}},
37445: {name: "UNMASKED_VENDOR_WEBGL", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLUnmaskedVendor") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}},
37446: {name: "UNMASKED_RENDERER_WEBGL", fake: function(originalValue, window, prefs){
const settingValue = prefs("webGLUnmaskedRenderer") || originalValue;
return {value: settingValue, faked: settingValue === originalValue};
}}
};
scope.initializeParameterDefinitions = function(){
Object.keys(parameterChangeDefinition).forEach(function(parameterName){
const definition = parameterChangeDefinition[parameterName];
definition.pname = parameterName;
if (!definition.fake){
definition.fake = definition.isArray?
function fake(originalValue, window){
let faked = false;
let fakedValue = [];
for (let i = 0; i < originalValue.length; i += 1){
fakedValue[i] = parameterFakeTypes[this.type](originalValue[i], this, window);
faked |= originalValue[i] === fakedValue[i];
originalValue[i] = fakedValue[i];
}
this.fake = function(originalValue){
if (faked){
for (let i = 0; i < originalValue.length; i += 1){
originalValue[i] = fakedValue[i];
}
}
return {
value: originalValue,
faked
};
};
return {
value: originalValue,
faked
};
}:
function fake(originalValue, window){
let value = parameterFakeTypes[this.type](originalValue, this, window);
let faked = value === originalValue;
this.fake = function(){
return {value, faked};
};
return {value, faked};
};
}
});
};
scope.parameterChangeDefinition = parameterChangeDefinition;
}()); }());