jcarr
/
noVNC
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'camelcase' of https://github.com/samhed/noVNC

This commit is contained in:
Pierre Ossman 2020-06-05 09:41:25 +02:00
parent 0e37a3f83a cfb824ed03
commit f694c32fd5
24 changed files with 532 additions and 522 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.eslintrc
View File

@ -44,5 +44,6 @@
"named": "never",
"asyncArrow": "always" }],
"switch-colon-spacing": ["error"],
"camelcase": ["error", { allow: ["^XK_", "^XF86XK_"] }],
}
}

58
app/ui.js
View File

@ -37,9 +37,9 @@ const UI = {
lastKeyboardinput: null,
defaultKeyboardinputLen: 100,
inhibit_reconnect: true,
reconnect_callback: null,
reconnect_password: null,
inhibitReconnect: true,
reconnectCallback: null,
reconnectPassword: null,
prime() {
return WebUtil.initSettings().then(() => {
@ -394,25 +394,25 @@ const UI = {
document.documentElement.classList.remove("noVNC_disconnecting");
document.documentElement.classList.remove("noVNC_reconnecting");
const transition_elem = document.getElementById("noVNC_transition_text");
const transitionElem = document.getElementById("noVNC_transition_text");
switch (state) {
case 'init':
break;
case 'connecting':
transition_elem.textContent = _("Connecting...");
transitionElem.textContent = _("Connecting...");
document.documentElement.classList.add("noVNC_connecting");
break;
case 'connected':
document.documentElement.classList.add("noVNC_connected");
break;
case 'disconnecting':
transition_elem.textContent = _("Disconnecting...");
transitionElem.textContent = _("Disconnecting...");
document.documentElement.classList.add("noVNC_disconnecting");
break;
case 'disconnected':
break;
case 'reconnecting':
transition_elem.textContent = _("Reconnecting...");
transitionElem.textContent = _("Reconnecting...");
document.documentElement.classList.add("noVNC_reconnecting");
break;
default:
@ -452,11 +452,11 @@ const UI = {
.classList.remove('noVNC_open');
},
showStatus(text, status_type, time) {
showStatus(text, statusType, time) {
const statusElem = document.getElementById('noVNC_status');
if (typeof status_type === 'undefined') {
status_type = 'normal';
if (typeof statusType === 'undefined') {
statusType = 'normal';
}
// Don't overwrite more severe visible statuses and never
@ -466,14 +466,14 @@ const UI = {
return;
}
if (statusElem.classList.contains("noVNC_status_warn") &&
status_type === 'normal') {
statusType === 'normal') {
return;
}
}
clearTimeout(UI.statusTimeout);
switch (status_type) {
switch (statusType) {
case 'error':
statusElem.classList.remove("noVNC_status_warn");
statusElem.classList.remove("noVNC_status_normal");
@ -503,7 +503,7 @@ const UI = {
}
// Error messages do not timeout
if (status_type !== 'error') {
if (statusType !== 'error') {
UI.statusTimeout = window.setTimeout(UI.hideStatus, time);
}
},
@ -1003,7 +1003,7 @@ const UI = {
if (typeof password === 'undefined') {
password = WebUtil.getConfigVar('password');
UI.reconnect_password = password;
UI.reconnectPassword = password;
}
if (password === null) {
@ -1060,7 +1060,7 @@ const UI = {
UI.connected = false;
// Disable automatic reconnecting
UI.inhibit_reconnect = true;
UI.inhibitReconnect = true;
UI.updateVisualState('disconnecting');
@ -1068,20 +1068,20 @@ const UI = {
},
reconnect() {
UI.reconnect_callback = null;
UI.reconnectCallback = null;
// if reconnect has been disabled in the meantime, do nothing.
if (UI.inhibit_reconnect) {
if (UI.inhibitReconnect) {
return;
}
UI.connect(null, UI.reconnect_password);
UI.connect(null, UI.reconnectPassword);
},
cancelReconnect() {
if (UI.reconnect_callback !== null) {
clearTimeout(UI.reconnect_callback);
UI.reconnect_callback = null;
if (UI.reconnectCallback !== null) {
clearTimeout(UI.reconnectCallback);
UI.reconnectCallback = null;
}
UI.updateVisualState('disconnected');
@ -1092,7 +1092,7 @@ const UI = {
connectFinished(e) {
UI.connected = true;
UI.inhibit_reconnect = false;
UI.inhibitReconnect = false;
let msg;
if (UI.getSetting('encrypt')) {
@ -1126,11 +1126,11 @@ const UI = {
} else {
UI.showStatus(_("Failed to connect to server"), 'error');
}
} else if (UI.getSetting('reconnect', false) === true && !UI.inhibit_reconnect) {
} else if (UI.getSetting('reconnect', false) === true && !UI.inhibitReconnect) {
UI.updateVisualState('reconnecting');
const delay = parseInt(UI.getSetting('reconnect_delay'));
UI.reconnect_callback = setTimeout(UI.reconnect, delay);
UI.reconnectCallback = setTimeout(UI.reconnect, delay);
return;
} else {
UI.updateVisualState('disconnected');
@ -1203,7 +1203,7 @@ const UI = {
inputElemPassword.value = "";
UI.rfb.sendCredentials({ username: username, password: password });
UI.reconnect_password = password;
UI.reconnectPassword = password;
document.getElementById('noVNC_credentials_dlg')
.classList.remove('noVNC_open');
},
@ -1634,8 +1634,8 @@ const UI = {
* ------v------*/
setMouseButton(num) {
const view_only = UI.rfb.viewOnly;
if (UI.rfb && !view_only) {
const viewOnly = UI.rfb.viewOnly;
if (UI.rfb && !viewOnly) {
UI.rfb.touchButton = num;
}
@ -1643,7 +1643,7 @@ const UI = {
for (let b = 0; b < blist.length; b++) {
const button = document.getElementById('noVNC_mouse_button' +
blist[b]);
if (blist[b] === num && !view_only) {
if (blist[b] === num && !viewOnly) {
button.classList.remove("noVNC_hidden");
} else {
button.classList.add("noVNC_hidden");
@ -1683,7 +1683,7 @@ const UI = {
},
updateLogging() {
WebUtil.init_logging(UI.getSetting('logging'));
WebUtil.initLogging(UI.getSetting('logging'));
},
updateDesktopName(e) {

14
app/webutil.js
View File

@ -6,16 +6,16 @@
* See README.md for usage and integration instructions.
*/
import { init_logging as main_init_logging } from '../core/util/logging.js';
import { initLogging as mainInitLogging } from '../core/util/logging.js';
// init log level reading the logging HTTP param
export function init_logging(level) {
export function initLogging(level) {
"use strict";
if (typeof level !== "undefined") {
main_init_logging(level);
mainInitLogging(level);
} else {
const param = document.location.href.match(/logging=([A-Za-z0-9._-]*)/);
main_init_logging(param || undefined);
mainInitLogging(param || undefined);
}
}
@ -184,7 +184,7 @@ export function injectParamIfMissing(path, param, value) {
const elem = document.createElement('a');
elem.href = path;
const param_eq = encodeURIComponent(param) + "=";
const paramEq = encodeURIComponent(param) + "=";
let query;
if (elem.search) {
query = elem.search.slice(1).split('&');
@ -192,8 +192,8 @@ export function injectParamIfMissing(path, param, value) {
query = [];
}
if (!query.some(v => v.startsWith(param_eq))) {
query.push(param_eq + encodeURIComponent(value));
if (!query.some(v => v.startsWith(paramEq))) {
query.push(paramEq + encodeURIComponent(value));
elem.search = "?" + query.join("&");
}

8
core/base64.js
View File

@ -57,12 +57,12 @@ export default {
/* eslint-enable comma-spacing */
decode(data, offset = 0) {
let data_length = data.indexOf('=') - offset;
if (data_length < 0) { data_length = data.length - offset; }
let dataLength = data.indexOf('=') - offset;
if (dataLength < 0) { dataLength = data.length - offset; }
/* Every four characters is 3 resulting numbers */
const result_length = (data_length >> 2) * 3 + Math.floor((data_length % 4) / 1.5);
const result = new Array(result_length);
const resultLength = (dataLength >> 2) * 3 + Math.floor((dataLength % 4) / 1.5);
const result = new Array(resultLength);
// Convert one by one.

18
core/decoders/hextile.js
View File

@ -17,10 +17,10 @@ export default class HextileDecoder {
decodeRect(x, y, width, height, sock, display, depth) {
if (this._tiles === 0) {
this._tiles_x = Math.ceil(width / 16);
this._tiles_y = Math.ceil(height / 16);
this._total_tiles = this._tiles_x * this._tiles_y;
this._tiles = this._total_tiles;
this._tilesX = Math.ceil(width / 16);
this._tilesY = Math.ceil(height / 16);
this._totalTiles = this._tilesX * this._tilesY;
this._tiles = this._totalTiles;
}
while (this._tiles > 0) {
@ -39,11 +39,11 @@ export default class HextileDecoder {
subencoding + ")");
}
const curr_tile = this._total_tiles - this._tiles;
const tile_x = curr_tile % this._tiles_x;
const tile_y = Math.floor(curr_tile / this._tiles_x);
const tx = x + tile_x * 16;
const ty = y + tile_y * 16;
const currTile = this._totalTiles - this._tiles;
const tileX = currTile % this._tilesX;
const tileY = Math.floor(currTile / this._tilesX);
const tx = x + tileX * 16;
const ty = y + tileY * 16;
const tw = Math.min(16, (x + width) - tx);
const th = Math.min(16, (y + height) - ty);

12
core/decoders/raw.js
View File

@ -24,15 +24,15 @@ export default class RawDecoder {
return false;
}
const cur_y = y + (height - this._lines);
const curr_height = Math.min(this._lines,
const curY = y + (height - this._lines);
const currHeight = Math.min(this._lines,
Math.floor(sock.rQlen / bytesPerLine));
let data = sock.rQ;
let index = sock.rQi;
// Convert data if needed
if (depth == 8) {
const pixels = width * curr_height;
const pixels = width * currHeight;
const newdata = new Uint8Array(pixels * 4);
for (let i = 0; i < pixels; i++) {
newdata[i * 4 + 0] = ((data[index + i] >> 0) & 0x3) * 255 / 3;
@ -44,9 +44,9 @@ export default class RawDecoder {
index = 0;
}
display.blitImage(x, cur_y, width, curr_height, data, index);
sock.rQskipBytes(curr_height * bytesPerLine);
this._lines -= curr_height;
display.blitImage(x, curY, width, currHeight, data, index);
sock.rQskipBytes(currHeight * bytesPerLine);
this._lines -= currHeight;
if (this._lines > 0) {
return false;
}

6
core/deflator.js
View File

@ -21,12 +21,14 @@ export default class Deflator {
}
deflate(inData) {
/* eslint-disable camelcase */
this.strm.input = inData;
this.strm.avail_in = this.strm.input.length;
this.strm.next_in = 0;
this.strm.output = this.outputBuffer;
this.strm.avail_out = this.chunkSize;
this.strm.next_out = 0;
/* eslint-enable camelcase */
let lastRet = deflate(this.strm, Z_FULL_FLUSH);
let outData = new Uint8Array(this.strm.output.buffer, 0, this.strm.next_out);
@ -41,9 +43,11 @@ export default class Deflator {
let chunks = [outData];
let totalLen = outData.length;
do {
/* eslint-disable camelcase */
this.strm.output = new Uint8Array(this.chunkSize);
this.strm.next_out = 0;
this.strm.avail_out = this.chunkSize;
/* eslint-enable camelcase */
lastRet = deflate(this.strm, Z_FULL_FLUSH);
@ -69,9 +73,11 @@ export default class Deflator {
outData = newData;
}
/* eslint-disable camelcase */
this.strm.input = null;
this.strm.avail_in = 0;
this.strm.next_in = 0;
/* eslint-enable camelcase */
return outData;
}

133
core/display.js
View File

@ -13,20 +13,19 @@ import { supportsImageMetadata } from './util/browser.js';
export default class Display {
constructor(target) {
this._drawCtx = null;
this._c_forceCanvas = false;
this._renderQ = []; // queue drawing actions for in-oder rendering
this._flushing = false;
// the full frame buffer (logical canvas) size
this._fb_width = 0;
this._fb_height = 0;
this._fbWidth = 0;
this._fbHeight = 0;
this._prevDrawStyle = "";
this._tile = null;
this._tile16x16 = null;
this._tile_x = 0;
this._tile_y = 0;
this._tileX = 0;
this._tileY = 0;
Log.Debug(">> Display.constructor");
@ -95,11 +94,11 @@ export default class Display {
}
get width() {
return this._fb_width;
return this._fbWidth;
}
get height() {
return this._fb_height;
return this._fbHeight;
}
// ===== PUBLIC METHODS =====
@ -122,15 +121,15 @@ export default class Display {
if (deltaX < 0 && vp.x + deltaX < 0) {
deltaX = -vp.x;
}
if (vx2 + deltaX >= this._fb_width) {
deltaX -= vx2 + deltaX - this._fb_width + 1;
if (vx2 + deltaX >= this._fbWidth) {
deltaX -= vx2 + deltaX - this._fbWidth + 1;
}
if (vp.y + deltaY < 0) {
deltaY = -vp.y;
}
if (vy2 + deltaY >= this._fb_height) {
deltaY -= (vy2 + deltaY - this._fb_height + 1);
if (vy2 + deltaY >= this._fbHeight) {
deltaY -= (vy2 + deltaY - this._fbHeight + 1);
}
if (deltaX === 0 && deltaY === 0) {
@ -153,18 +152,18 @@ export default class Display {
typeof(height) === "undefined") {
Log.Debug("Setting viewport to full display region");
width = this._fb_width;
height = this._fb_height;
width = this._fbWidth;
height = this._fbHeight;
}
width = Math.floor(width);
height = Math.floor(height);
if (width > this._fb_width) {
width = this._fb_width;
if (width > this._fbWidth) {
width = this._fbWidth;
}
if (height > this._fb_height) {
height = this._fb_height;
if (height > this._fbHeight) {
height = this._fbHeight;
}
const vp = this._viewportLoc;
@ -204,8 +203,8 @@ export default class Display {
resize(width, height) {
this._prevDrawStyle = "";
this._fb_width = width;
this._fb_height = height;
this._fbWidth = width;
this._fbHeight = height;
const canvas = this._backbuffer;
if (canvas.width !== width || canvas.height !== height) {
@ -253,9 +252,9 @@ export default class Display {
// Update the visible canvas with the contents of the
// rendering canvas
flip(from_queue) {
if (this._renderQ.length !== 0 && !from_queue) {
this._renderQ_push({
flip(fromQueue) {
if (this._renderQ.length !== 0 && !fromQueue) {
this._renderQPush({
'type': 'flip'
});
} else {
@ -311,9 +310,9 @@ export default class Display {
}
}
fillRect(x, y, width, height, color, from_queue) {
if (this._renderQ.length !== 0 && !from_queue) {
this._renderQ_push({
fillRect(x, y, width, height, color, fromQueue) {
if (this._renderQ.length !== 0 && !fromQueue) {
this._renderQPush({
'type': 'fill',
'x': x,
'y': y,
@ -328,14 +327,14 @@ export default class Display {
}
}
copyImage(old_x, old_y, new_x, new_y, w, h, from_queue) {
if (this._renderQ.length !== 0 && !from_queue) {
this._renderQ_push({
copyImage(oldX, oldY, newX, newY, w, h, fromQueue) {
if (this._renderQ.length !== 0 && !fromQueue) {
this._renderQPush({
'type': 'copy',
'old_x': old_x,
'old_y': old_y,
'x': new_x,
'y': new_y,
'oldX': oldX,
'oldY': oldY,
'x': newX,
'y': newY,
'width': w,
'height': h,
});
@ -353,9 +352,9 @@ export default class Display {
this._drawCtx.imageSmoothingEnabled = false;
this._drawCtx.drawImage(this._backbuffer,
old_x, old_y, w, h,
new_x, new_y, w, h);
this._damage(new_x, new_y, w, h);
oldX, oldY, w, h,
newX, newY, w, h);
this._damage(newX, newY, w, h);
}
}
@ -368,7 +367,7 @@ export default class Display {
const img = new Image();
img.src = "data: " + mime + ";base64," + Base64.encode(arr);
this._renderQ_push({
this._renderQPush({
'type': 'img',
'img': img,
'x': x,
@ -380,8 +379,8 @@ export default class Display {
// start updating a tile
startTile(x, y, width, height, color) {
this._tile_x = x;
this._tile_y = y;
this._tileX = x;
this._tileY = y;
if (width === 16 && height === 16) {
this._tile = this._tile16x16;
} else {
@ -424,21 +423,21 @@ export default class Display {
// draw the current tile to the screen
finishTile() {
this._drawCtx.putImageData(this._tile, this._tile_x, this._tile_y);
this._damage(this._tile_x, this._tile_y,
this._drawCtx.putImageData(this._tile, this._tileX, this._tileY);
this._damage(this._tileX, this._tileY,
this._tile.width, this._tile.height);
}
blitImage(x, y, width, height, arr, offset, from_queue) {
if (this._renderQ.length !== 0 && !from_queue) {
blitImage(x, y, width, height, arr, offset, fromQueue) {
if (this._renderQ.length !== 0 && !fromQueue) {
// NB(directxman12): it's technically more performant here to use preallocated arrays,
// but it's a lot of extra work for not a lot of payoff -- if we're using the render queue,
// this probably isn't getting called *nearly* as much
const new_arr = new Uint8Array(width * height * 4);
new_arr.set(new Uint8Array(arr.buffer, 0, new_arr.length));
this._renderQ_push({
const newArr = new Uint8Array(width * height * 4);
newArr.set(new Uint8Array(arr.buffer, 0, newArr.length));
this._renderQPush({
'type': 'blit',
'data': new_arr,
'data': newArr,
'x': x,
'y': y,
'width': width,
@ -449,16 +448,16 @@ export default class Display {
}
}
blitRgbImage(x, y, width, height, arr, offset, from_queue) {
if (this._renderQ.length !== 0 && !from_queue) {
blitRgbImage(x, y, width, height, arr, offset, fromQueue) {
if (this._renderQ.length !== 0 && !fromQueue) {
// NB(directxman12): it's technically more performant here to use preallocated arrays,
// but it's a lot of extra work for not a lot of payoff -- if we're using the render queue,
// this probably isn't getting called *nearly* as much
const new_arr = new Uint8Array(width * height * 3);
new_arr.set(new Uint8Array(arr.buffer, 0, new_arr.length));
this._renderQ_push({
const newArr = new Uint8Array(width * height * 3);
newArr.set(new Uint8Array(arr.buffer, 0, newArr.length));
this._renderQPush({
'type': 'blitRgb',
'data': new_arr,
'data': newArr,
'x': x,
'y': y,
'width': width,
@ -469,16 +468,16 @@ export default class Display {
}
}
blitRgbxImage(x, y, width, height, arr, offset, from_queue) {
if (this._renderQ.length !== 0 && !from_queue) {
blitRgbxImage(x, y, width, height, arr, offset, fromQueue) {
if (this._renderQ.length !== 0 && !fromQueue) {
// NB(directxman12): it's technically more performant here to use preallocated arrays,
// but it's a lot of extra work for not a lot of payoff -- if we're using the render queue,
// this probably isn't getting called *nearly* as much
const new_arr = new Uint8Array(width * height * 4);
new_arr.set(new Uint8Array(arr.buffer, 0, new_arr.length));
this._renderQ_push({
const newArr = new Uint8Array(width * height * 4);
newArr.set(new Uint8Array(arr.buffer, 0, newArr.length));
this._renderQPush({
'type': 'blitRgbx',
'data': new_arr,
'data': newArr,
'x': x,
'y': y,
'width': width,
@ -583,23 +582,23 @@ export default class Display {
this._damage(x, y, img.width, img.height);
}
_renderQ_push(action) {
_renderQPush(action) {
this._renderQ.push(action);
if (this._renderQ.length === 1) {
// If this can be rendered immediately it will be, otherwise
// the scanner will wait for the relevant event
this._scan_renderQ();
this._scanRenderQ();
}
}
_resume_renderQ() {
_resumeRenderQ() {
// "this" is the object that is ready, not the
// display object
this.removeEventListener('load', this._noVNC_display._resume_renderQ);
this._noVNC_display._scan_renderQ();
this.removeEventListener('load', this._noVNCDisplay._resumeRenderQ);
this._noVNCDisplay._scanRenderQ();
}
_scan_renderQ() {
_scanRenderQ() {
let ready = true;
while (ready && this._renderQ.length > 0) {
const a = this._renderQ[0];
@ -608,7 +607,7 @@ export default class Display {
this.flip(true);
break;
case 'copy':
this.copyImage(a.old_x, a.old_y, a.x, a.y, a.width, a.height, true);
this.copyImage(a.oldX, a.oldY, a.x, a.y, a.width, a.height, true);
break;
case 'fill':
this.fillRect(a.x, a.y, a.width, a.height, a.color, true);
@ -633,8 +632,8 @@ export default class Display {
}
this.drawImage(a.img, a.x, a.y);
} else {
a.img._noVNC_display = this;
a.img.addEventListener('load', this._resume_renderQ);
a.img._noVNCDisplay = this;
a.img.addEventListener('load', this._resumeRenderQ);
// We need to wait for this image to 'load'
// to keep things in-order
ready = false;

4
core/inflator.js
View File

@ -22,6 +22,7 @@ export default class Inflate {
setInput(data) {
if (!data) {
//FIXME: flush remaining data.
/* eslint-disable camelcase */
this.strm.input = null;
this.strm.avail_in = 0;
this.strm.next_in = 0;
@ -29,6 +30,7 @@ export default class Inflate {
this.strm.input = data;
this.strm.avail_in = this.strm.input.length;
this.strm.next_in = 0;
/* eslint-enable camelcase */
}
}
@ -41,8 +43,10 @@ export default class Inflate {
this.strm.output = new Uint8Array(this.chunkSize);
}
/* eslint-disable camelcase */
this.strm.next_out = 0;
this.strm.avail_out = expected;
/* eslint-enable camelcase */
let ret = inflate(this.strm, 0); // Flush argument not used.
if (ret < 0) {

14
core/rfb.js
View File

@ -947,7 +947,7 @@ export default class RFB extends EventTargetMixin {
while (repeaterID.length < 250) {
repeaterID += "\0";
}
this._sock.send_string(repeaterID);
this._sock.sendString(repeaterID);
return true;
}
@ -957,7 +957,7 @@ export default class RFB extends EventTargetMixin {
const cversion = "00" + parseInt(this._rfbVersion, 10) +
".00" + ((this._rfbVersion * 10) % 10);
this._sock.send_string("RFB " + cversion + "\n");
this._sock.sendString("RFB " + cversion + "\n");
Log.Debug('Sent ProtocolVersion: ' + cversion);
this._rfbInitState = 'Security';
@ -1071,7 +1071,7 @@ export default class RFB extends EventTargetMixin {
String.fromCharCode(this._rfbCredentials.target.length) +
this._rfbCredentials.username +
this._rfbCredentials.target;
this._sock.send_string(xvpAuthStr);
this._sock.sendString(xvpAuthStr);
this._rfbAuthScheme = 2;
return this._negotiateAuthentication();
}
@ -1156,8 +1156,8 @@ export default class RFB extends EventTargetMixin {
// XXX we assume lengths are <= 255 (should not be an issue in the real world)
this._sock.send([0, 0, 0, user.length]);
this._sock.send([0, 0, 0, pass.length]);
this._sock.send_string(user);
this._sock.send_string(pass);
this._sock.sendString(user);
this._sock.sendString(pass);
this._rfbInitState = "SecurityResult";
return true;
@ -1193,8 +1193,8 @@ export default class RFB extends EventTargetMixin {
this._sock.send([0, 0, 0, this._rfbCredentials.username.length]);
this._sock.send([0, 0, 0, this._rfbCredentials.password.length]);
this._sock.send_string(this._rfbCredentials.username);
this._sock.send_string(this._rfbCredentials.password);
this._sock.sendString(this._rfbCredentials.username);
this._sock.sendString(this._rfbCredentials.password);
this._rfbInitState = "SecurityResult";
return true;
}

14
core/util/logging.js
View File

@ -10,18 +10,18 @@
* Logging/debug routines
*/
let _log_level = 'warn';
let _logLevel = 'warn';
let Debug = () => {};
let Info = () => {};
let Warn = () => {};
let Error = () => {};
export function init_logging(level) {
export function initLogging(level) {
if (typeof level === 'undefined') {
level = _log_level;
level = _logLevel;
} else {
_log_level = level;
_logLevel = level;
}
Debug = Info = Warn = Error = () => {};
@ -46,11 +46,11 @@ export function init_logging(level) {
}
}
export function get_logging() {
return _log_level;
export function getLogging() {
return _logLevel;
}
export { Debug, Info, Warn, Error };
// Initialize logging level
init_logging();
initLogging();

34
core/websock.js
View File

@ -144,7 +144,7 @@ export default class Websock {
flush() {
if (this._sQlen > 0 && this._websocket.readyState === WebSocket.OPEN) {
this._websocket.send(this._encode_message());
this._websocket.send(this._encodeMessage());
this._sQlen = 0;
}
}
@ -155,7 +155,7 @@ export default class Websock {
this.flush();
}
send_string(str) {
sendString(str) {
this.send(str.split('').map(chr => chr.charCodeAt(0)));
}
@ -168,13 +168,13 @@ export default class Websock {
this._eventHandlers[evt] = handler;
}
_allocate_buffers() {
_allocateBuffers() {
this._rQ = new Uint8Array(this._rQbufferSize);
this._sQ = new Uint8Array(this._sQbufferSize);
}
init() {
this._allocate_buffers();
this._allocateBuffers();
this._rQi = 0;
this._websocket = null;
}
@ -185,7 +185,7 @@ export default class Websock {
this._websocket = new WebSocket(uri, protocols);
this._websocket.binaryType = 'arraybuffer';
this._websocket.onmessage = this._recv_message.bind(this);
this._websocket.onmessage = this._recvMessage.bind(this);
this._websocket.onopen = () => {
Log.Debug('>> WebSock.onopen');
if (this._websocket.protocol) {
@ -220,7 +220,7 @@ export default class Websock {
}
// private methods
_encode_message() {
_encodeMessage() {
// Put in a binary arraybuffer
// according to the spec, you can send ArrayBufferViews with the send method
return new Uint8Array(this._sQ.buffer, 0, this._sQlen);
@ -231,30 +231,30 @@ export default class Websock {
// The function also expands the receive que if needed, and for
// performance reasons we combine these two actions to avoid
// unneccessary copying.
_expand_compact_rQ(min_fit) {
_expandCompactRQ(minFit) {
// if we're using less than 1/8th of the buffer even with the incoming bytes, compact in place
// instead of resizing
const required_buffer_size = (this._rQlen - this._rQi + min_fit) * 8;
const resizeNeeded = this._rQbufferSize < required_buffer_size;
const requiredBufferSize = (this._rQlen - this._rQi + minFit) * 8;
const resizeNeeded = this._rQbufferSize < requiredBufferSize;
if (resizeNeeded) {
// Make sure we always *at least* double the buffer size, and have at least space for 8x
// the current amount of data
this._rQbufferSize = Math.max(this._rQbufferSize * 2, required_buffer_size);
this._rQbufferSize = Math.max(this._rQbufferSize * 2, requiredBufferSize);
}
// we don't want to grow unboundedly
if (this._rQbufferSize > MAX_RQ_GROW_SIZE) {
this._rQbufferSize = MAX_RQ_GROW_SIZE;
if (this._rQbufferSize - this.rQlen < min_fit) {
if (this._rQbufferSize - this.rQlen < minFit) {
throw new Error("Receive Queue buffer exceeded " + MAX_RQ_GROW_SIZE + " bytes, and the new message could not fit");
}
}
if (resizeNeeded) {
const old_rQbuffer = this._rQ.buffer;
const oldRQbuffer = this._rQ.buffer;
this._rQ = new Uint8Array(this._rQbufferSize);
this._rQ.set(new Uint8Array(old_rQbuffer, this._rQi, this._rQlen - this._rQi));
this._rQ.set(new Uint8Array(oldRQbuffer, this._rQi, this._rQlen - this._rQi));
} else {
if (ENABLE_COPYWITHIN) {
this._rQ.copyWithin(0, this._rQi, this._rQlen);
@ -268,17 +268,17 @@ export default class Websock {
}
// push arraybuffer values onto the end of the receive que
_decode_message(data) {
_DecodeMessage(data) {
const u8 = new Uint8Array(data);
if (u8.length > this._rQbufferSize - this._rQlen) {
this._expand_compact_rQ(u8.length);
this._expandCompactRQ(u8.length);
}
this._rQ.set(u8, this._rQlen);
this._rQlen += u8.length;
}
_recv_message(e) {
this._decode_message(e.data);
_recvMessage(e) {
this._DecodeMessage(e.data);
if (this.rQlen > 0) {
this._eventHandlers.message();
if (this._rQlen == this._rQi) {

28
tests/assertions.js
View File

@ -1,32 +1,32 @@
// noVNC specific assertions
chai.use(function (_chai, utils) {
_chai.Assertion.addMethod('displayed', function (target_data) {
_chai.Assertion.addMethod('displayed', function (targetData) {
const obj = this._obj;
const ctx = obj._target.getContext('2d');
const data_cl = ctx.getImageData(0, 0, obj._target.width, obj._target.height).data;
const dataCl = ctx.getImageData(0, 0, obj._target.width, obj._target.height).data;
// NB(directxman12): PhantomJS 1.x doesn't implement Uint8ClampedArray, so work around that
const data = new Uint8Array(data_cl);
const len = data_cl.length;
new chai.Assertion(len).to.be.equal(target_data.length, "unexpected display size");
const data = new Uint8Array(dataCl);
const len = dataCl.length;
new chai.Assertion(len).to.be.equal(targetData.length, "unexpected display size");
let same = true;
for (let i = 0; i < len; i++) {
if (data[i] != target_data[i]) {
if (data[i] != targetData[i]) {
same = false;
break;
}
}
if (!same) {
// eslint-disable-next-line no-console
console.log("expected data: %o, actual data: %o", target_data, data);
console.log("expected data: %o, actual data: %o", targetData, data);
}
this.assert(same,
"expected #{this} to have displayed the image #{exp}, but instead it displayed #{act}",
"expected #{this} not to have displayed the image #{act}",
target_data,
targetData,
data);
});
_chai.Assertion.addMethod('sent', function (target_data) {
_chai.Assertion.addMethod('sent', function (targetData) {
const obj = this._obj;
obj.inspect = () => {
const res = { _websocket: obj._websocket, rQi: obj._rQi, _rQ: new Uint8Array(obj._rQ.buffer, 0, obj._rQlen),
@ -34,13 +34,13 @@ chai.use(function (_chai, utils) {
res.prototype = obj;
return res;
};
const data = obj._websocket._get_sent_data();
const data = obj._websocket._getSentData();
let same = true;
if (data.length != target_data.length) {
if (data.length != targetData.length) {
same = false;
} else {
for (let i = 0; i < data.length; i++) {
if (data[i] != target_data[i]) {
if (data[i] != targetData[i]) {
same = false;
break;
}
@ -48,12 +48,12 @@ chai.use(function (_chai, utils) {
}
if (!same) {
// eslint-disable-next-line no-console
console.log("expected data: %o, actual data: %o", target_data, data);
console.log("expected data: %o, actual data: %o", targetData, data);
}
this.assert(same,
"expected #{this} to have sent the data #{exp}, but it actually sent #{act}",
"expected #{this} not to have sent the data #{act}",
Array.prototype.slice.call(target_data),
Array.prototype.slice.call(targetData),
Array.prototype.slice.call(data));
});

32
tests/fake.websocket.js
View File

@ -1,7 +1,7 @@
import Base64 from '../core/base64.js';
// PhantomJS can't create Event objects directly, so we need to use this
function make_event(name, props) {
function makeEvent(name, props) {
const evt = document.createEvent('Event');
evt.initEvent(name, true, true);
if (props) {
@ -24,18 +24,18 @@ export default class FakeWebSocket {
this.protocol = protocols[0];
}
this._send_queue = new Uint8Array(20000);
this._sendQueue = new Uint8Array(20000);
this.readyState = FakeWebSocket.CONNECTING;
this.bufferedAmount = 0;
this.__is_fake = true;
this._isFake = true;
}
close(code, reason) {
this.readyState = FakeWebSocket.CLOSED;
if (this.onclose) {
this.onclose(make_event("close", { 'code': code, 'reason': reason, 'wasClean': true }));
this.onclose(makeEvent("close", { 'code': code, 'reason': reason, 'wasClean': true }));
}
}
@ -45,12 +45,12 @@ export default class FakeWebSocket {
} else {
data = new Uint8Array(data);
}
this._send_queue.set(data, this.bufferedAmount);
this._sendQueue.set(data, this.bufferedAmount);
this.bufferedAmount += data.length;
}
_get_sent_data() {
const res = new Uint8Array(this._send_queue.buffer, 0, this.bufferedAmount);
_getSentData() {
const res = new Uint8Array(this._sendQueue.buffer, 0, this.bufferedAmount);
this.bufferedAmount = 0;
return res;
}
@ -58,16 +58,16 @@ export default class FakeWebSocket {
_open() {
this.readyState = FakeWebSocket.OPEN;
if (this.onopen) {
this.onopen(make_event('open'));
this.onopen(makeEvent('open'));
}
}
_receive_data(data) {
_receiveData(data) {
// Break apart the data to expose bugs where we assume data is
// neatly packaged
for (let i = 0;i < data.length;i++) {
let buf = data.subarray(i, i+1);
this.onmessage(make_event("message", { 'data': buf }));
this.onmessage(makeEvent("message", { 'data': buf }));
}
}
}
@ -77,20 +77,20 @@ FakeWebSocket.CONNECTING = WebSocket.CONNECTING;
FakeWebSocket.CLOSING = WebSocket.CLOSING;
FakeWebSocket.CLOSED = WebSocket.CLOSED;
FakeWebSocket.__is_fake = true;
FakeWebSocket._isFake = true;
FakeWebSocket.replace = () => {
if (!WebSocket.__is_fake) {
const real_version = WebSocket;
if (!WebSocket._isFake) {
const realVersion = WebSocket;
// eslint-disable-next-line no-global-assign
WebSocket = FakeWebSocket;
FakeWebSocket.__real_version = real_version;
FakeWebSocket._realVersion = realVersion;
}
};
FakeWebSocket.restore = () => {
if (WebSocket.__is_fake) {
if (WebSocket._isFake) {
// eslint-disable-next-line no-global-assign
WebSocket = WebSocket.__real_version;
WebSocket = WebSocket._realVersion;
}
};

16
tests/playback-ui.js
View File

@ -1,4 +1,4 @@
/* global VNC_frame_data, VNC_frame_encoding */
/* global vncFrameData, vncFrameEncoding */
import * as WebUtil from '../app/webutil.js';
import RecordingPlayer from './playback.js';
@ -41,7 +41,7 @@ function enableUI() {
document.getElementById('mode1').checked = true;
}
message("Loaded " + VNC_frame_data.length + " frames");
message("Loaded " + vncFrameData.length + " frames");
const startButton = document.getElementById('startButton');
startButton.disabled = false;
@ -49,12 +49,12 @@ function enableUI() {
message("Converting...");
frames = VNC_frame_data;
frames = vncFrameData;
let encoding;
// Only present in older recordings
if (window.VNC_frame_encoding) {
encoding = VNC_frame_encoding;
if (window.vncFrameEncoding) {
encoding = vncFrameEncoding;
} else {
let frame = frames[0];
let start = frame.indexOf('{', 1) + 1;
@ -102,7 +102,7 @@ class IterationPlayer {
this._iteration = undefined;
this._player = undefined;
this._start_time = undefined;
this._startTime = undefined;
this._frames = frames;
@ -115,7 +115,7 @@ class IterationPlayer {
start(realtime) {
this._iteration = 0;
this._start_time = (new Date()).getTime();
this._startTime = (new Date()).getTime();
this._realtime = realtime;
@ -139,7 +139,7 @@ class IterationPlayer {
_finish() {
const endTime = (new Date()).getTime();
const totalDuration = endTime - this._start_time;
const totalDuration = endTime - this._startTime;
const evt = new CustomEvent('finish',
{ detail:

30
tests/playback.js
View File

@ -49,10 +49,10 @@ export default class RecordingPlayer {
this._disconnected = disconnected;
this._rfb = undefined;
this._frame_length = this._frames.length;
this._frameLength = this._frames.length;
this._frame_index = 0;
this._start_time = undefined;
this._frameIndex = 0;
this._startTime = undefined;
this._realtime = true;
this._trafficManagement = true;
@ -72,8 +72,8 @@ export default class RecordingPlayer {
this._enablePlaybackMode();
// reset the frame index and timer
this._frame_index = 0;
this._start_time = (new Date()).getTime();
this._frameIndex = 0;
this._startTime = (new Date()).getTime();
this._realtime = realtime;
this._trafficManagement = (trafficManagement === undefined) ? !realtime : trafficManagement;
@ -97,22 +97,22 @@ export default class RecordingPlayer {
_queueNextPacket() {
if (!this._running) { return; }
let frame = this._frames[this._frame_index];
let frame = this._frames[this._frameIndex];
// skip send frames
while (this._frame_index < this._frame_length && frame.fromClient) {
this._frame_index++;
frame = this._frames[this._frame_index];
while (this._frameIndex < this._frameLength && frame.fromClient) {
this._frameIndex++;
frame = this._frames[this._frameIndex];
}
if (this._frame_index >= this._frame_length) {
if (this._frameIndex >= this._frameLength) {
Log.Debug('Finished, no more frames');
this._finish();
return;
}
if (this._realtime) {
const toffset = (new Date()).getTime() - this._start_time;
const toffset = (new Date()).getTime() - this._startTime;
let delay = frame.timestamp - toffset;
if (delay < 1) delay = 1;
@ -134,10 +134,10 @@ export default class RecordingPlayer {
return;
}
const frame = this._frames[this._frame_index];
const frame = this._frames[this._frameIndex];
this._rfb._sock._recv_message({'data': frame.data});
this._frame_index++;
this._frameIndex++;
this._queueNextPacket();
}
@ -155,13 +155,13 @@ export default class RecordingPlayer {
this._running = false;
this._rfb._sock._eventHandlers.close({code: 1000, reason: ""});
delete this._rfb;
this.onfinish((new Date()).getTime() - this._start_time);
this.onfinish((new Date()).getTime() - this._startTime);
}
}
_handleDisconnect(evt) {
this._running = false;
this._disconnected(evt.detail.clean, this._frame_index);
this._disconnected(evt.detail.clean, this._frameIndex);
}
_handleCredentials(evt) {

2
tests/test.deflator.js
View File

@ -17,12 +17,14 @@ function _inflator(compText, expected) {
strm.output = new Uint8Array(chunkSize);
}
/* eslint-disable camelcase */
strm.input = compText;
strm.avail_in = strm.input.length;
strm.next_in = 0;
strm.next_out = 0;
strm.avail_out = expected.length;
/* eslint-enable camelcase */
let ret = inflate(strm, 0);

94
tests/test.display.js
View File

@ -4,28 +4,28 @@ import Base64 from '../core/base64.js';
import Display from '../core/display.js';
describe('Display/Canvas Helper', function () {
const checked_data = new Uint8Array([
const checkedData = new Uint8Array([
0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
]);
const basic_data = new Uint8Array([0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0xff, 0xff, 0xff, 255]);
const basicData = new Uint8Array([0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0xff, 0xff, 0xff, 255]);
function make_image_canvas(input_data) {
function makeImageCanvas(inputData) {
const canvas = document.createElement('canvas');
canvas.width = 4;
canvas.height = 4;
const ctx = canvas.getContext('2d');
const data = ctx.createImageData(4, 4);
for (let i = 0; i < checked_data.length; i++) { data.data[i] = input_data[i]; }
for (let i = 0; i < checkedData.length; i++) { data.data[i] = inputData[i]; }
ctx.putImageData(data, 0, 0);
return canvas;
}
function make_image_png(input_data) {
const canvas = make_image_canvas(input_data);
function makeImagePng(inputData) {
const canvas = makeImageCanvas(inputData);
const url = canvas.toDataURL();
const data = url.split(",")[1];
return Base64.decode(data);
@ -44,11 +44,11 @@ describe('Display/Canvas Helper', function () {
it('should take viewport location into consideration when drawing images', function () {
display.resize(4, 4);
display.viewportChangeSize(2, 2);
display.drawImage(make_image_canvas(basic_data), 1, 1);
display.drawImage(makeImageCanvas(basicData), 1, 1);
display.flip();
const expected = new Uint8Array(16);
for (let i = 0; i < 8; i++) { expected[i] = basic_data[i]; }
for (let i = 0; i < 8; i++) { expected[i] = basicData[i]; }
for (let i = 8; i < 16; i++) { expected[i] = 0; }
expect(display).to.have.displayed(expected);
});
@ -123,8 +123,8 @@ describe('Display/Canvas Helper', function () {
it('should change the size of the logical canvas', function () {
display.resize(5, 7);
expect(display._fb_width).to.equal(5);
expect(display._fb_height).to.equal(7);
expect(display._fbWidth).to.equal(5);
expect(display._fbHeight).to.equal(7);
});
it('should keep the framebuffer data', function () {
@ -275,7 +275,7 @@ describe('Display/Canvas Helper', function () {
display.flip();
display.fillRect(0, 0, 4, 4, [0, 0xff, 0]);
const expected = [];
for (let i = 0; i < 4 * display._fb_width * display._fb_height; i += 4) {
for (let i = 0; i < 4 * display._fbWidth * display._fbHeight; i += 4) {
expected[i] = 0xff;
expected[i+1] = expected[i+2] = 0;
expected[i+3] = 0xff;
@ -288,7 +288,7 @@ describe('Display/Canvas Helper', function () {
display.fillRect(0, 0, 2, 2, [0xff, 0, 0]);
display.fillRect(2, 2, 2, 2, [0xff, 0, 0]);
display.flip();
expect(display).to.have.displayed(checked_data);
expect(display).to.have.displayed(checkedData);
});
it('should support copying an portion of the canvas via #copyImage', function () {
@ -296,14 +296,14 @@ describe('Display/Canvas Helper', function () {
display.fillRect(0, 0, 2, 2, [0xff, 0, 0x00]);
display.copyImage(0, 0, 2, 2, 2, 2);
display.flip();
expect(display).to.have.displayed(checked_data);
expect(display).to.have.displayed(checkedData);
});
it('should support drawing images via #imageRect', function (done) {
display.imageRect(0, 0, 4, 4, "image/png", make_image_png(checked_data));
display.imageRect(0, 0, 4, 4, "image/png", makeImagePng(checkedData));
display.flip();
display.onflush = () => {
expect(display).to.have.displayed(checked_data);
expect(display).to.have.displayed(checkedData);
done();
};
display.flush();
@ -315,12 +315,12 @@ describe('Display/Canvas Helper', function () {
display.subTile(2, 2, 2, 2, [0xff, 0, 0]);
display.finishTile();
display.flip();
expect(display).to.have.displayed(checked_data);
expect(display).to.have.displayed(checkedData);
});
// We have a special cache for 16x16 tiles that we need to test
it('should support drawing a 16x16 tile', function () {
const large_checked_data = new Uint8Array(16*16*4);
const largeCheckedData = new Uint8Array(16*16*4);
display.resize(16, 16);
for (let y = 0;y < 16;y++) {
@ -328,11 +328,11 @@ describe('Display/Canvas Helper', function () {
let pixel;
if ((x < 4) && (y < 4)) {
// NB: of course IE11 doesn't support #slice on ArrayBufferViews...
pixel = Array.prototype.slice.call(checked_data, (y*4+x)*4, (y*4+x+1)*4);
pixel = Array.prototype.slice.call(checkedData, (y*4+x)*4, (y*4+x+1)*4);
} else {
pixel = [0, 0xff, 0, 255];
}
large_checked_data.set(pixel, (y*16+x)*4);
largeCheckedData.set(pixel, (y*16+x)*4);
}
}
@ -341,39 +341,39 @@ describe('Display/Canvas Helper', function () {
display.subTile(2, 2, 2, 2, [0xff, 0, 0]);
display.finishTile();
display.flip();
expect(display).to.have.displayed(large_checked_data);
expect(display).to.have.displayed(largeCheckedData);
});
it('should support drawing BGRX blit images with true color via #blitImage', function () {
const data = [];
for (let i = 0; i < 16; i++) {
data[i * 4] = checked_data[i * 4 + 2];
data[i * 4 + 1] = checked_data[i * 4 + 1];
data[i * 4 + 2] = checked_data[i * 4];
data[i * 4 + 3] = checked_data[i * 4 + 3];
data[i * 4] = checkedData[i * 4 + 2];
data[i * 4 + 1] = checkedData[i * 4 + 1];
data[i * 4 + 2] = checkedData[i * 4];
data[i * 4 + 3] = checkedData[i * 4 + 3];
}
display.blitImage(0, 0, 4, 4, data, 0);
display.flip();
expect(display).to.have.displayed(checked_data);
expect(display).to.have.displayed(checkedData);
});
it('should support drawing RGB blit images with true color via #blitRgbImage', function () {
const data = [];
for (let i = 0; i < 16; i++) {
data[i * 3] = checked_data[i * 4];
data[i * 3 + 1] = checked_data[i * 4 + 1];
data[i * 3 + 2] = checked_data[i * 4 + 2];
data[i * 3] = checkedData[i * 4];
data[i * 3 + 1] = checkedData[i * 4 + 1];
data[i * 3 + 2] = checkedData[i * 4 + 2];
}
display.blitRgbImage(0, 0, 4, 4, data, 0);
display.flip();
expect(display).to.have.displayed(checked_data);
expect(display).to.have.displayed(checkedData);
});
it('should support drawing an image object via #drawImage', function () {
const img = make_image_canvas(checked_data);
const img = makeImageCanvas(checkedData);
display.drawImage(img, 0, 0);
display.flip();
expect(display).to.have.displayed(checked_data);
expect(display).to.have.displayed(checkedData);
});
});
@ -382,22 +382,18 @@ describe('Display/Canvas Helper', function () {
beforeEach(function () {
display = new Display(document.createElement('canvas'));
display.resize(4, 4);
sinon.spy(display, '_scan_renderQ');
});
afterEach(function () {
window.requestAnimationFrame = this.old_requestAnimationFrame;
sinon.spy(display, '_scanRenderQ');
});
it('should try to process an item when it is pushed on, if nothing else is on the queue', function () {
display._renderQ_push({ type: 'noop' }); // does nothing
expect(display._scan_renderQ).to.have.been.calledOnce;
display._renderQPush({ type: 'noop' }); // does nothing
expect(display._scanRenderQ).to.have.been.calledOnce;
});
it('should not try to process an item when it is pushed on if we are waiting for other items', function () {
display._renderQ.length = 2;
display._renderQ_push({ type: 'noop' });
expect(display._scan_renderQ).to.not.have.been.called;
display._renderQPush({ type: 'noop' });
expect(display._scanRenderQ).to.not.have.been.called;
});
it('should wait until an image is loaded to attempt to draw it and the rest of the queue', function () {
@ -407,13 +403,13 @@ describe('Display/Canvas Helper', function () {
display.drawImage = sinon.spy();
display.fillRect = sinon.spy();
display._scan_renderQ();
display._scanRenderQ();
expect(display.drawImage).to.not.have.been.called;
expect(display.fillRect).to.not.have.been.called;
expect(img.addEventListener).to.have.been.calledOnce;
display._renderQ[0].img.complete = true;
display._scan_renderQ();
display._scanRenderQ();
expect(display.drawImage).to.have.been.calledOnce;
expect(display.fillRect).to.have.been.calledOnce;
expect(img.addEventListener).to.have.been.calledOnce;
@ -426,7 +422,7 @@ describe('Display/Canvas Helper', function () {
display.drawImage = sinon.spy();
display.fillRect = sinon.spy();
display._scan_renderQ();
display._scanRenderQ();
expect(display.drawImage).to.not.have.been.called;
expect(display.fillRect).to.not.have.been.called;
expect(img.addEventListener).to.have.been.calledOnce;
@ -434,7 +430,7 @@ describe('Display/Canvas Helper', function () {
display._renderQ[0].img.complete = true;
display._renderQ[0].img.width = 4;
display._renderQ[0].img.height = 4;
display._scan_renderQ();
display._scanRenderQ();
expect(display.drawImage).to.have.been.calledOnce;
expect(display.fillRect).to.have.been.calledOnce;
expect(img.addEventListener).to.have.been.calledOnce;
@ -450,35 +446,35 @@ describe('Display/Canvas Helper', function () {
it('should draw a blit image on type "blit"', function () {
display.blitImage = sinon.spy();
display._renderQ_push({ type: 'blit', x: 3, y: 4, width: 5, height: 6, data: [7, 8, 9] });
display._renderQPush({ type: 'blit', x: 3, y: 4, width: 5, height: 6, data: [7, 8, 9] });
expect(display.blitImage).to.have.been.calledOnce;
expect(display.blitImage).to.have.been.calledWith(3, 4, 5, 6, [7, 8, 9], 0);
});
it('should draw a blit RGB image on type "blitRgb"', function () {
display.blitRgbImage = sinon.spy();
display._renderQ_push({ type: 'blitRgb', x: 3, y: 4, width: 5, height: 6, data: [7, 8, 9] });
display._renderQPush({ type: 'blitRgb', x: 3, y: 4, width: 5, height: 6, data: [7, 8, 9] });
expect(display.blitRgbImage).to.have.been.calledOnce;
expect(display.blitRgbImage).to.have.been.calledWith(3, 4, 5, 6, [7, 8, 9], 0);
});
it('should copy a region on type "copy"', function () {
display.copyImage = sinon.spy();
display._renderQ_push({ type: 'copy', x: 3, y: 4, width: 5, height: 6, old_x: 7, old_y: 8 });
display._renderQPush({ type: 'copy', x: 3, y: 4, width: 5, height: 6, oldX: 7, oldY: 8 });
expect(display.copyImage).to.have.been.calledOnce;
expect(display.copyImage).to.have.been.calledWith(7, 8, 3, 4, 5, 6);
});
it('should fill a rect with a given color on type "fill"', function () {
display.fillRect = sinon.spy();
display._renderQ_push({ type: 'fill', x: 3, y: 4, width: 5, height: 6, color: [7, 8, 9]});
display._renderQPush({ type: 'fill', x: 3, y: 4, width: 5, height: 6, color: [7, 8, 9]});
expect(display.fillRect).to.have.been.calledOnce;
expect(display.fillRect).to.have.been.calledWith(3, 4, 5, 6, [7, 8, 9]);
});
it('should draw an image from an image object on type "img" (if complete)', function () {
display.drawImage = sinon.spy();
display._renderQ_push({ type: 'img', x: 3, y: 4, img: { complete: true } });
display._renderQPush({ type: 'img', x: 3, y: 4, img: { complete: true } });
expect(display.drawImage).to.have.been.calledOnce;
expect(display.drawImage).to.have.been.calledWith({ complete: true }, 3, 4);
});

158
tests/test.rfb.js
View File

@ -70,11 +70,13 @@ function deflateWithSize(data) {
strm.output = new Uint8Array(chunkSize);
deflateInit(strm, 5);
/* eslint-disable camelcase */
strm.input = unCompData;
strm.avail_in = strm.input.length;
strm.next_in = 0;
strm.next_out = 0;
strm.avail_out = chunkSize;
/* eslint-enable camelcase */
deflate(strm, 3);
@ -99,8 +101,8 @@ describe('Remote Frame Buffer Protocol Client', function () {
const _sQ = new Uint8Array(sock._sQbufferSize);
const rQ = new Uint8Array(sock._rQbufferSize);
Websock.prototype._old_allocate_buffers = Websock.prototype._allocate_buffers;
Websock.prototype._allocate_buffers = function () {
Websock.prototype._oldAllocateBuffers = Websock.prototype._allocateBuffers;
Websock.prototype._allocateBuffers = function () {
this._sQ = _sQ;
this._rQ = rQ;
};
@ -108,7 +110,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
});
after(function () {
Websock.prototype._allocate_buffers = Websock.prototype._old_allocate_buffers;
Websock.prototype._allocateBuffers = Websock.prototype._oldAllocateBuffers;
this.clock.restore();
window.requestAnimationFrame = raf;
});
@ -352,7 +354,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
push32(data, toUnsigned32bit(-8));
data = data.concat(flags);
data = data.concat(fileSizes);
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
client.clipboardPasteFrom('extended test');
expect(RFB.messages.extendedClipboardNotify).to.have.been.calledOnce;
@ -450,7 +452,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
sinon.spy(client._display, "viewportChangeSize");
client._sock._websocket._receive_data(new Uint8Array(incoming));
client._sock._websocket._receiveData(new Uint8Array(incoming));
// FIXME: Display implicitly calls viewportChangeSize() when
// resizing the framebuffer, hence calledTwice.
@ -647,7 +649,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
sinon.spy(client._display, "autoscale");
client._sock._websocket._receive_data(new Uint8Array(incoming));
client._sock._websocket._receiveData(new Uint8Array(incoming));
expect(client._display.autoscale).to.have.been.calledOnce;
expect(client._display.autoscale).to.have.been.calledWith(70, 80);
@ -702,7 +704,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._supportsSetDesktopSize = false;
client._sock._websocket._receive_data(new Uint8Array(incoming));
client._sock._websocket._receiveData(new Uint8Array(incoming));
expect(RFB.messages.setDesktopSize).to.have.been.calledOnce;
expect(RFB.messages.setDesktopSize).to.have.been.calledWith(sinon.match.object, 70, 80, 0, 0);
@ -711,7 +713,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
// Second message should not trigger a resize
client._sock._websocket._receive_data(new Uint8Array(incoming));
client._sock._websocket._receiveData(new Uint8Array(incoming));
expect(RFB.messages.setDesktopSize).to.not.have.been.called;
});
@ -794,7 +796,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x04,
0x00, 0x00, 0x00, 0x00 ];
client._sock._websocket._receive_data(new Uint8Array(incoming));
client._sock._websocket._receiveData(new Uint8Array(incoming));
expect(RFB.messages.setDesktopSize).to.not.have.been.called;
});
@ -1012,7 +1014,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
}
arr[0] = 'R'; arr[1] = 'F'; arr[2] = 'B'; arr[3] = ' ';
arr[11] = '\n';
client._sock._websocket._receive_data(arr);
client._sock._websocket._receiveData(arr);
}
describe('version parsing', function () {
@ -1090,7 +1092,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
sendVer('000.000', client);
expect(client._rfbVersion).to.equal(0);
const sentData = client._sock._websocket._get_sent_data();
const sentData = client._sock._websocket._getSentData();
expect(new Uint8Array(sentData.buffer, 0, 9)).to.array.equal(new Uint8Array([73, 68, 58, 49, 50, 51, 52, 53, 0]));
expect(sentData).to.have.length(250);
});
@ -1113,14 +1115,14 @@ describe('Remote Frame Buffer Protocol Client', function () {
const authSchemeRaw = [1, 2, 3, 4];
const authScheme = (authSchemeRaw[0] << 24) + (authSchemeRaw[1] << 16) +
(authSchemeRaw[2] << 8) + authSchemeRaw[3];
client._sock._websocket._receive_data(new Uint8Array(authSchemeRaw));
client._sock._websocket._receiveData(new Uint8Array(authSchemeRaw));
expect(client._rfbAuthScheme).to.equal(authScheme);
});
it('should prefer no authentication is possible', function () {
client._rfbVersion = 3.7;
const authSchemes = [2, 1, 3];
client._sock._websocket._receive_data(new Uint8Array(authSchemes));
client._sock._websocket._receiveData(new Uint8Array(authSchemes));
expect(client._rfbAuthScheme).to.equal(1);
expect(client._sock).to.have.sent(new Uint8Array([1, 1]));
});
@ -1128,7 +1130,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should choose for the most prefered scheme possible for versions >= 3.7', function () {
client._rfbVersion = 3.7;
const authSchemes = [2, 22, 16];
client._sock._websocket._receive_data(new Uint8Array(authSchemes));
client._sock._websocket._receiveData(new Uint8Array(authSchemes));
expect(client._rfbAuthScheme).to.equal(22);
expect(client._sock).to.have.sent(new Uint8Array([22]));
});
@ -1137,7 +1139,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
sinon.spy(client, "_fail");
client._rfbVersion = 3.7;
const authSchemes = [1, 32];
client._sock._websocket._receive_data(new Uint8Array(authSchemes));
client._sock._websocket._receiveData(new Uint8Array(authSchemes));
expect(client._fail).to.have.been.calledOnce;
});
@ -1145,7 +1147,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._rfbVersion = 3.7;
const failureData = [0, 0, 0, 0, 6, 119, 104, 111, 111, 112, 115];
sinon.spy(client, '_fail');
client._sock._websocket._receive_data(new Uint8Array(failureData));
client._sock._websocket._receiveData(new Uint8Array(failureData));
expect(client._fail).to.have.been.calledOnce;
expect(client._fail).to.have.been.calledWith(
@ -1156,7 +1158,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._rfbVersion = 3.7;
const authSchemes = [1, 1];
client._negotiateAuthentication = sinon.spy();
client._sock._websocket._receive_data(new Uint8Array(authSchemes));
client._sock._websocket._receiveData(new Uint8Array(authSchemes));
expect(client._rfbInitState).to.equal('Authentication');
expect(client._negotiateAuthentication).to.have.been.calledOnce;
});
@ -1168,7 +1170,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
});
function sendSecurity(type, cl) {
cl._sock._websocket._receive_data(new Uint8Array([1, type]));
cl._sock._websocket._receiveData(new Uint8Array([1, type]));
}
it('should fail on auth scheme 0 (pre 3.7) with the given message', function () {
@ -1182,7 +1184,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
}
sinon.spy(client, '_fail');
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
expect(client._fail).to.have.been.calledWith(
'Security negotiation failed on authentication scheme (reason: Whoopsies)');
});
@ -1219,7 +1221,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const challenge = [];
for (let i = 0; i < 16; i++) { challenge[i] = i; }
client._sock._websocket._receive_data(new Uint8Array(challenge));
client._sock._websocket._receiveData(new Uint8Array(challenge));
expect(client._rfbCredentials).to.be.empty;
expect(spy).to.have.been.calledOnce;
@ -1229,11 +1231,11 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should encrypt the password with DES and then send it back', function () {
client._rfbCredentials = { password: 'passwd' };
sendSecurity(2, client);
client._sock._websocket._get_sent_data(); // skip the choice of auth reply
client._sock._websocket._getSentData(); // skip the choice of auth reply
const challenge = [];
for (let i = 0; i < 16; i++) { challenge[i] = i; }
client._sock._websocket._receive_data(new Uint8Array(challenge));
client._sock._websocket._receiveData(new Uint8Array(challenge));
const desPass = RFB.genDES('passwd', challenge);
expect(client._sock).to.have.sent(new Uint8Array(desPass));
@ -1245,7 +1247,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const challenge = [];
for (let i = 0; i < 16; i++) { challenge[i] = i; }
client._sock._websocket._receive_data(new Uint8Array(challenge));
client._sock._websocket._receiveData(new Uint8Array(challenge));
expect(client._rfbInitState).to.equal('SecurityResult');
});
@ -1308,7 +1310,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._rfbInitState = 'Security';
client._rfbVersion = 3.8;
sendSecurity(16, client);
client._sock._websocket._get_sent_data(); // skip the security reply
client._sock._websocket._getSentData(); // skip the security reply
});
function sendNumStrPairs(pairs, client) {
@ -1325,11 +1327,11 @@ describe('Remote Frame Buffer Protocol Client', function () {
}
}
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
}
it('should skip tunnel negotiation if no tunnels are requested', function () {
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 0]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 0]));
expect(client._rfbTightVNC).to.be.true;
});
@ -1351,7 +1353,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should continue to sub-auth negotiation after tunnel negotiation', function () {
sendNumStrPairs([[0, 'TGHT', 'NOTUNNEL']], client);
client._sock._websocket._get_sent_data(); // skip the tunnel choice here
client._sock._websocket._getSentData(); // skip the tunnel choice here
sendNumStrPairs([[1, 'STDV', 'NOAUTH__']], client);
expect(client._sock).to.have.sent(new Uint8Array([0, 0, 0, 1]));
expect(client._rfbInitState).to.equal('SecurityResult');
@ -1397,7 +1399,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
});
it('should fall through to ServerInitialisation on a response code of 0', function () {
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 0]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 0]));
expect(client._rfbInitState).to.equal('ServerInitialisation');
});
@ -1405,7 +1407,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._rfbVersion = 3.8;
sinon.spy(client, '_fail');
const failureData = [0, 0, 0, 1, 0, 0, 0, 6, 119, 104, 111, 111, 112, 115];
client._sock._websocket._receive_data(new Uint8Array(failureData));
client._sock._websocket._receiveData(new Uint8Array(failureData));
expect(client._fail).to.have.been.calledWith(
'Security negotiation failed on security result (reason: whoops)');
});
@ -1413,7 +1415,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should fail on an error code of 1 with a standard message for version < 3.8', function () {
sinon.spy(client, '_fail');
client._rfbVersion = 3.7;
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 1]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 1]));
expect(client._fail).to.have.been.calledWith(
'Security handshake failed');
});
@ -1421,7 +1423,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should result in securityfailure event when receiving a non zero status', function () {
const spy = sinon.spy();
client.addEventListener("securityfailure", spy);
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 2]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 2]));
expect(spy).to.have.been.calledOnce;
expect(spy.args[0][0].detail.status).to.equal(2);
});
@ -1432,7 +1434,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client.addEventListener("securityfailure", spy);
const failureData = [0, 0, 0, 1, 0, 0, 0, 12, 115, 117, 99, 104,
32, 102, 97, 105, 108, 117, 114, 101];
client._sock._websocket._receive_data(new Uint8Array(failureData));
client._sock._websocket._receiveData(new Uint8Array(failureData));
expect(spy.args[0][0].detail.status).to.equal(1);
expect(spy.args[0][0].detail.reason).to.equal('such failure');
});
@ -1442,7 +1444,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const spy = sinon.spy();
client.addEventListener("securityfailure", spy);
const failureData = [0, 0, 0, 1, 0, 0, 0, 0];
client._sock._websocket._receive_data(new Uint8Array(failureData));
client._sock._websocket._receiveData(new Uint8Array(failureData));
expect(spy.args[0][0].detail.status).to.equal(1);
expect('reason' in spy.args[0][0].detail).to.be.false;
});
@ -1451,7 +1453,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._rfbVersion = 3.6;
const spy = sinon.spy();
client.addEventListener("securityfailure", spy);
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 2]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 2]));
expect(spy.args[0][0].detail.status).to.equal(2);
expect('reason' in spy.args[0][0].detail).to.be.false;
});
@ -1462,7 +1464,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const client = makeRFB();
client._rfbConnectionState = 'connecting';
client._rfbInitState = 'SecurityResult';
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 0]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 0]));
expect(client._rfbInitState).to.equal('ServerInitialisation');
});
@ -1470,7 +1472,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const client = makeRFB('wss://host:8675', { shared: true });
client._rfbConnectionState = 'connecting';
client._rfbInitState = 'SecurityResult';
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 0]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 0]));
expect(client._sock).to.have.sent(new Uint8Array([1]));
});
@ -1478,7 +1480,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const client = makeRFB('wss://host:8675', { shared: false });
client._rfbConnectionState = 'connecting';
client._rfbInitState = 'SecurityResult';
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 0]));
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 0]));
expect(client._sock).to.have.sent(new Uint8Array([0]));
});
});
@ -1489,8 +1491,8 @@ describe('Remote Frame Buffer Protocol Client', function () {
});
function sendServerInit(opts, client) {
const fullOpts = { width: 10, height: 12, bpp: 24, depth: 24, big_endian: 0,
true_color: 1, redMax: 255, greenMax: 255, blueMax: 255,
const fullOpts = { width: 10, height: 12, bpp: 24, depth: 24, bigEndian: 0,
trueColor: 1, redMax: 255, greenMax: 255, blueMax: 255,
redShift: 16, greenShift: 8, blueShift: 0, name: 'a name' };
for (let opt in opts) {
fullOpts[opt] = opts[opt];
@ -1502,8 +1504,8 @@ describe('Remote Frame Buffer Protocol Client', function () {
data.push(fullOpts.bpp);
data.push(fullOpts.depth);
data.push(fullOpts.big_endian);
data.push(fullOpts.true_color);
data.push(fullOpts.bigEndian);
data.push(fullOpts.trueColor);
push16(data, fullOpts.redMax);
push16(data, fullOpts.greenMax);
@ -1517,15 +1519,15 @@ describe('Remote Frame Buffer Protocol Client', function () {
push8(data, 0);
push8(data, 0);
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
const nameData = [];
let nameLen = [];
pushString(nameData, fullOpts.name);
push32(nameLen, nameData.length);
client._sock._websocket._receive_data(new Uint8Array(nameLen));
client._sock._websocket._receive_data(new Uint8Array(nameData));
client._sock._websocket._receiveData(new Uint8Array(nameLen));
client._sock._websocket._receiveData(new Uint8Array(nameData));
}
it('should set the framebuffer width and height', function () {
@ -1560,7 +1562,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
for (let i = 0; i < 16 + 32 + 48; i++) {
tightData.push(i);
}
client._sock._websocket._receive_data(new Uint8Array(tightData));
client._sock._websocket._receiveData(new Uint8Array(tightData));
expect(client._rfbConnectionState).to.equal('connected');
});
@ -1684,7 +1686,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
data = data.concat(rectData[i]);
}
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
}
it('should send an update request if there is sufficient data', function () {
@ -1692,14 +1694,14 @@ describe('Remote Frame Buffer Protocol Client', function () {
RFB.messages.fbUpdateRequest(expectedMsg, true, 0, 0, 640, 20);
client._framebufferUpdate = () => true;
client._sock._websocket._receive_data(new Uint8Array([0]));
client._sock._websocket._receiveData(new Uint8Array([0]));
expect(client._sock).to.have.sent(expectedMsg._sQ);
});
it('should not send an update request if we need more data', function () {
client._sock._websocket._receive_data(new Uint8Array([0]));
expect(client._sock._websocket._get_sent_data()).to.have.length(0);
client._sock._websocket._receiveData(new Uint8Array([0]));
expect(client._sock._websocket._getSentData()).to.have.length(0);
});
it('should resume receiving an update if we previously did not have enough data', function () {
@ -1707,21 +1709,21 @@ describe('Remote Frame Buffer Protocol Client', function () {
RFB.messages.fbUpdateRequest(expectedMsg, true, 0, 0, 640, 20);
// just enough to set FBU.rects
client._sock._websocket._receive_data(new Uint8Array([0, 0, 0, 3]));
expect(client._sock._websocket._get_sent_data()).to.have.length(0);
client._sock._websocket._receiveData(new Uint8Array([0, 0, 0, 3]));
expect(client._sock._websocket._getSentData()).to.have.length(0);
client._framebufferUpdate = function () { this._sock.rQskipBytes(1); return true; }; // we magically have enough data
// 247 should *not* be used as the message type here
client._sock._websocket._receive_data(new Uint8Array([247]));
client._sock._websocket._receiveData(new Uint8Array([247]));
expect(client._sock).to.have.sent(expectedMsg._sQ);
});
it('should not send a request in continuous updates mode', function () {
client._enabledContinuousUpdates = true;
client._framebufferUpdate = () => true;
client._sock._websocket._receive_data(new Uint8Array([0]));
client._sock._websocket._receiveData(new Uint8Array([0]));
expect(client._sock._websocket._get_sent_data()).to.have.length(0);
expect(client._sock._websocket._getSentData()).to.have.length(0);
});
it('should fail on an unsupported encoding', function () {
@ -2388,7 +2390,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should set the XVP version and fire the callback with the version on XVP_INIT', function () {
const spy = sinon.spy();
client.addEventListener("capabilities", spy);
client._sock._websocket._receive_data(new Uint8Array([250, 0, 10, 1]));
client._sock._websocket._receiveData(new Uint8Array([250, 0, 10, 1]));
expect(client._rfbXvpVer).to.equal(10);
expect(spy).to.have.been.calledOnce;
expect(spy.args[0][0].detail.capabilities.power).to.be.true;
@ -2397,7 +2399,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should fail on unknown XVP message types', function () {
sinon.spy(client, "_fail");
client._sock._websocket._receive_data(new Uint8Array([250, 0, 10, 237]));
client._sock._websocket._receiveData(new Uint8Array([250, 0, 10, 237]));
expect(client._fail).to.have.been.calledOnce;
});
});
@ -2411,7 +2413,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const spy = sinon.spy();
client.addEventListener("clipboard", spy);
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
expect(spy).to.have.been.calledOnce;
expect(spy.args[0][0].detail.text).to.equal(expectedStr);
});
@ -2437,7 +2439,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
push32(data, toUnsigned32bit(-12));
data = data.concat(flags);
data = data.concat(fileSizes);
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
// Check that we give an response caps when we receive one
expect(RFB.messages.extendedClipboardCaps).to.have.been.calledOnce;
@ -2463,7 +2465,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
push32(data, toUnsigned32bit(-8));
data = data.concat(flags);
data = data.concat(fileSizes);
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
});
describe('Handle Provide', function () {
@ -2487,7 +2489,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const spy = sinon.spy();
client.addEventListener("clipboard", spy);
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
expect(spy).to.have.been.calledOnce;
expect(spy.args[0][0].detail.text).to.equal(expectedData);
client.removeEventListener("clipboard", spy);
@ -2514,7 +2516,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const spy = sinon.spy();
client.addEventListener("clipboard", spy);
client._sock._websocket._receive_data(sendData);
client._sock._websocket._receiveData(sendData);
expect(spy).to.have.been.calledOnce;
expect(spy.args[0][0].detail.text).to.equal(expectedData);
client.removeEventListener("clipboard", spy);
@ -2546,7 +2548,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
const spy = sinon.spy();
client.addEventListener("clipboard", spy);
client._sock._websocket._receive_data(sendData);
client._sock._websocket._receiveData(sendData);
expect(spy).to.have.been.calledOnce;
expect(spy.args[0][0].detail.text).to.equal(expectedData);
client.removeEventListener("clipboard", spy);
@ -2570,7 +2572,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
data = data.concat(flags);
let expectedData = [0x01];
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
expect(RFB.messages.extendedClipboardRequest).to.have.been.calledOnce;
expect(RFB.messages.extendedClipboardRequest).to.have.been.calledWith(client._sock, expectedData);
@ -2593,7 +2595,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
data = data.concat(flags);
let expectedData = [];
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
expect(RFB.messages.extendedClipboardNotify).to.have.been.calledOnce;
expect(RFB.messages.extendedClipboardNotify).to.have.been.calledWith(client._sock, expectedData);
@ -2611,7 +2613,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client.clipboardPasteFrom("HejHej");
RFB.messages.extendedClipboardNotify.resetHistory();
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
expect(RFB.messages.extendedClipboardNotify).to.have.been.calledOnce;
expect(RFB.messages.extendedClipboardNotify).to.have.been.calledWith(client._sock, expectedData);
@ -2637,7 +2639,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client.clipboardPasteFrom("HejHej");
expect(RFB.messages.extendedClipboardProvide).to.not.have.been.called;
client._sock._websocket._receive_data(new Uint8Array(data));
client._sock._websocket._receiveData(new Uint8Array(data));
expect(RFB.messages.extendedClipboardProvide).to.have.been.calledOnce;
expect(RFB.messages.extendedClipboardProvide).to.have.been.calledWith(client._sock, expectedData, ["HejHej"]);
@ -2650,7 +2652,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should fire the bell callback on Bell', function () {
const spy = sinon.spy();
client.addEventListener("bell", spy);
client._sock._websocket._receive_data(new Uint8Array([2]));
client._sock._websocket._receiveData(new Uint8Array([2]));
expect(spy).to.have.been.calledOnce;
});
@ -2664,7 +2666,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
RFB.messages.clientFence(expectedMsg, (1<<0) | (1<<1), payload);
RFB.messages.clientFence(incomingMsg, 0xffffffff, payload);
client._sock._websocket._receive_data(incomingMsg._sQ);
client._sock._websocket._receiveData(incomingMsg._sQ);
expect(client._sock).to.have.sent(expectedMsg._sQ);
@ -2674,7 +2676,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
RFB.messages.clientFence(expectedMsg, (1<<0), payload);
RFB.messages.clientFence(incomingMsg, (1<<0) | (1<<31), payload);
client._sock._websocket._receive_data(incomingMsg._sQ);
client._sock._websocket._receiveData(incomingMsg._sQ);
expect(client._sock).to.have.sent(expectedMsg._sQ);
});
@ -2686,7 +2688,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
expect(client._enabledContinuousUpdates).to.be.false;
client._sock._websocket._receive_data(new Uint8Array([150]));
client._sock._websocket._receiveData(new Uint8Array([150]));
expect(client._enabledContinuousUpdates).to.be.true;
expect(client._sock).to.have.sent(expectedMsg._sQ);
@ -2696,7 +2698,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._enabledContinuousUpdates = true;
client._supportsContinuousUpdates = true;
client._sock._websocket._receive_data(new Uint8Array([150]));
client._sock._websocket._receiveData(new Uint8Array([150]));
expect(client._enabledContinuousUpdates).to.be.false;
});
@ -2707,7 +2709,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._resize(450, 160);
expect(client._sock._websocket._get_sent_data()).to.have.length(0);
expect(client._sock._websocket._getSentData()).to.have.length(0);
client._enabledContinuousUpdates = true;
@ -2718,7 +2720,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
it('should fail on an unknown message type', function () {
sinon.spy(client, "_fail");
client._sock._websocket._receive_data(new Uint8Array([87]));
client._sock._websocket._receiveData(new Uint8Array([87]));
expect(client._fail).to.have.been.calledOnce;
});
});
@ -2763,7 +2765,7 @@ describe('Remote Frame Buffer Protocol Client', function () {
});
it('should send a mask of 0 on mouseup', function () {
client._mouse_buttonMask = 0x001;
client._mouseButtonMask = 0x001;
client._handleMouseButton(105, 120, 0, 0x001);
expect(RFB.messages.pointerEvent).to.have.been.calledWith(
client._sock, 105, 120, 0x000);
@ -2892,13 +2894,13 @@ describe('Remote Frame Buffer Protocol Client', function () {
// message events
it('should do nothing if we receive an empty message and have nothing in the queue', function () {
client._normalMsg = sinon.spy();
client._sock._websocket._receive_data(new Uint8Array([]));
client._sock._websocket._receiveData(new Uint8Array([]));
expect(client._normalMsg).to.not.have.been.called;
});
it('should handle a message in the connected state as a normal message', function () {
client._normalMsg = sinon.spy();
client._sock._websocket._receive_data(new Uint8Array([1, 2, 3]));
client._sock._websocket._receiveData(new Uint8Array([1, 2, 3]));
expect(client._normalMsg).to.have.been.called;
});
@ -2906,14 +2908,14 @@ describe('Remote Frame Buffer Protocol Client', function () {
client._rfbConnectionState = 'connecting';
client._rfbInitState = 'ProtocolVersion';
client._initMsg = sinon.spy();
client._sock._websocket._receive_data(new Uint8Array([1, 2, 3]));
client._sock._websocket._receiveData(new Uint8Array([1, 2, 3]));
expect(client._initMsg).to.have.been.called;
});
it('should process all normal messages directly', function () {
const spy = sinon.spy();
client.addEventListener("bell", spy);
client._sock._websocket._receive_data(new Uint8Array([0x02, 0x02]));
client._sock._websocket._receiveData(new Uint8Array([0x02, 0x02]));
expect(spy).to.have.been.calledTwice;
});

12
tests/test.util.js
View File

@ -22,37 +22,37 @@ describe('Utils', function () {
console.warn.restore();
console.error.restore();
console.info.restore();
Log.init_logging();
Log.initLogging();
});
it('should use noop for levels lower than the min level', function () {
Log.init_logging('warn');
Log.initLogging('warn');
Log.Debug('hi');
Log.Info('hello');
expect(console.log).to.not.have.been.called;
});
it('should use console.debug for Debug', function () {
Log.init_logging('debug');
Log.initLogging('debug');
Log.Debug('dbg');
expect(console.debug).to.have.been.calledWith('dbg');
});
it('should use console.info for Info', function () {
Log.init_logging('debug');
Log.initLogging('debug');
Log.Info('inf');
expect(console.info).to.have.been.calledWith('inf');
});
it('should use console.warn for Warn', function () {
Log.init_logging('warn');
Log.initLogging('warn');
Log.Warn('wrn');
expect(console.warn).to.have.been.called;
expect(console.warn).to.have.been.calledWith('wrn');
});
it('should use console.error for Error', function () {
Log.init_logging('error');
Log.initLogging('error');
Log.Error('err');
expect(console.error).to.have.been.called;
expect(console.error).to.have.been.calledWith('err');

92
tests/test.websock.js
View File

@ -13,7 +13,7 @@ describe('Websock', function () {
beforeEach(function () {
sock = new Websock();
// skip init
sock._allocate_buffers();
sock._allocateBuffers();
sock._rQ.set(RQ_TEMPLATE);
sock._rQlen = RQ_TEMPLATE.length;
});
@ -33,51 +33,51 @@ describe('Websock', function () {
describe('rQpeek8', function () {
it('should peek at the next byte without poping it off the queue', function () {
const bef_len = sock.rQlen;
const befLen = sock.rQlen;
const peek = sock.rQpeek8();
expect(sock.rQpeek8()).to.equal(peek);
expect(sock.rQlen).to.equal(bef_len);
expect(sock.rQlen).to.equal(befLen);
});
});
describe('rQshift8()', function () {
it('should pop a single byte from the receive queue', function () {
const peek = sock.rQpeek8();
const bef_len = sock.rQlen;
const befLen = sock.rQlen;
expect(sock.rQshift8()).to.equal(peek);
expect(sock.rQlen).to.equal(bef_len - 1);
expect(sock.rQlen).to.equal(befLen - 1);
});
});
describe('rQshift16()', function () {
it('should pop two bytes from the receive queue and return a single number', function () {
const bef_len = sock.rQlen;
const befLen = sock.rQlen;
const expected = (RQ_TEMPLATE[0] << 8) + RQ_TEMPLATE[1];
expect(sock.rQshift16()).to.equal(expected);
expect(sock.rQlen).to.equal(bef_len - 2);
expect(sock.rQlen).to.equal(befLen - 2);
});
});
describe('rQshift32()', function () {
it('should pop four bytes from the receive queue and return a single number', function () {
const bef_len = sock.rQlen;
const befLen = sock.rQlen;
const expected = (RQ_TEMPLATE[0] << 24) +
(RQ_TEMPLATE[1] << 16) +
(RQ_TEMPLATE[2] << 8) +
RQ_TEMPLATE[3];
expect(sock.rQshift32()).to.equal(expected);
expect(sock.rQlen).to.equal(bef_len - 4);
expect(sock.rQlen).to.equal(befLen - 4);
});
});
describe('rQshiftStr', function () {
it('should shift the given number of bytes off of the receive queue and return a string', function () {
const bef_len = sock.rQlen;
const bef_rQi = sock.rQi;
const befLen = sock.rQlen;
const befRQi = sock.rQi;
const shifted = sock.rQshiftStr(3);
expect(shifted).to.be.a('string');
expect(shifted).to.equal(String.fromCharCode.apply(null, Array.prototype.slice.call(new Uint8Array(RQ_TEMPLATE.buffer, bef_rQi, 3))));
expect(sock.rQlen).to.equal(bef_len - 3);
expect(shifted).to.equal(String.fromCharCode.apply(null, Array.prototype.slice.call(new Uint8Array(RQ_TEMPLATE.buffer, befRQi, 3))));
expect(sock.rQlen).to.equal(befLen - 3);
});
it('should shift the entire rest of the queue off if no length is given', function () {
@ -112,12 +112,12 @@ describe('Websock', function () {
describe('rQshiftBytes', function () {
it('should shift the given number of bytes of the receive queue and return an array', function () {
const bef_len = sock.rQlen;
const bef_rQi = sock.rQi;
const befLen = sock.rQlen;
const befRQi = sock.rQi;
const shifted = sock.rQshiftBytes(3);
expect(shifted).to.be.an.instanceof(Uint8Array);
expect(shifted).to.array.equal(new Uint8Array(RQ_TEMPLATE.buffer, bef_rQi, 3));
expect(sock.rQlen).to.equal(bef_len - 3);
expect(shifted).to.array.equal(new Uint8Array(RQ_TEMPLATE.buffer, befRQi, 3));
expect(sock.rQlen).to.equal(befLen - 3);
});
it('should shift the entire rest of the queue off if no length is given', function () {
@ -132,9 +132,9 @@ describe('Websock', function () {
});
it('should not modify the receive queue', function () {
const bef_len = sock.rQlen;
const befLen = sock.rQlen;
sock.rQslice(0, 2);
expect(sock.rQlen).to.equal(bef_len);
expect(sock.rQlen).to.equal(befLen);
});
it('should return an array containing the given slice of the receive queue', function () {
@ -198,7 +198,7 @@ describe('Websock', function () {
sock._websocket.readyState = WebSocket.OPEN;
sock._sQ = new Uint8Array([1, 2, 3]);
sock._sQlen = 3;
const encoded = sock._encode_message();
const encoded = sock._encodeMessage();
sock.flush();
expect(sock._websocket.send).to.have.been.calledOnce;
@ -232,22 +232,22 @@ describe('Websock', function () {
});
});
describe('send_string', function () {
describe('sendString', function () {
beforeEach(function () {
sock.send = sinon.spy();
});
it('should call send after converting the string to an array', function () {
sock.send_string("\x01\x02\x03");
sock.sendString("\x01\x02\x03");
expect(sock.send).to.have.been.calledWith([1, 2, 3]);
});
});
});
describe('lifecycle methods', function () {
let old_WS;
let oldWS;
before(function () {
old_WS = WebSocket;
oldWS = WebSocket;
});
let sock;
@ -255,10 +255,10 @@ describe('Websock', function () {
sock = new Websock();
// eslint-disable-next-line no-global-assign
WebSocket = sinon.spy();
WebSocket.OPEN = old_WS.OPEN;
WebSocket.CONNECTING = old_WS.CONNECTING;
WebSocket.CLOSING = old_WS.CLOSING;
WebSocket.CLOSED = old_WS.CLOSED;
WebSocket.OPEN = oldWS.OPEN;
WebSocket.CONNECTING = oldWS.CONNECTING;
WebSocket.CLOSING = oldWS.CLOSING;
WebSocket.CLOSED = oldWS.CLOSED;
WebSocket.prototype.binaryType = 'arraybuffer';
});
@ -306,30 +306,30 @@ describe('Websock', function () {
expect(sock._websocket.close).not.to.have.been.called;
});
it('should reset onmessage to not call _recv_message', function () {
sinon.spy(sock, '_recv_message');
it('should reset onmessage to not call _recvMessage', function () {
sinon.spy(sock, '_recvMessage');
sock.close();
sock._websocket.onmessage(null);
try {
expect(sock._recv_message).not.to.have.been.called;
expect(sock._recvMessage).not.to.have.been.called;
} finally {
sock._recv_message.restore();
sock._recvMessage.restore();
}
});
});
describe('event handlers', function () {
beforeEach(function () {
sock._recv_message = sinon.spy();
sock._recvMessage = sinon.spy();
sock.on('open', sinon.spy());
sock.on('close', sinon.spy());
sock.on('error', sinon.spy());
sock.open('ws://');
});
it('should call _recv_message on a message', function () {
it('should call _recvMessage on a message', function () {
sock._websocket.onmessage(null);
expect(sock._recv_message).to.have.been.calledOnce;
expect(sock._recvMessage).to.have.been.calledOnce;
});
it('should call the open event handler on opening', function () {
@ -350,7 +350,7 @@ describe('Websock', function () {
after(function () {
// eslint-disable-next-line no-global-assign
WebSocket = old_WS;
WebSocket = oldWS;
});
});
@ -358,13 +358,13 @@ describe('Websock', function () {
let sock;
beforeEach(function () {
sock = new Websock();
sock._allocate_buffers();
sock._allocateBuffers();
});
it('should support adding binary Uint8Array data to the receive queue', function () {
const msg = { data: new Uint8Array([1, 2, 3]) };
sock._mode = 'binary';
sock._recv_message(msg);
sock._recvMessage(msg);
expect(sock.rQshiftStr(3)).to.equal('\x01\x02\x03');
});
@ -372,7 +372,7 @@ describe('Websock', function () {
sock._eventHandlers.message = sinon.spy();
const msg = { data: new Uint8Array([1, 2, 3]).buffer };
sock._mode = 'binary';
sock._recv_message(msg);
sock._recvMessage(msg);
expect(sock._eventHandlers.message).to.have.been.calledOnce;
});
@ -380,7 +380,7 @@ describe('Websock', function () {
sock._eventHandlers.message = sinon.spy();
const msg = { data: new Uint8Array([]).buffer };
sock._mode = 'binary';
sock._recv_message(msg);
sock._recvMessage(msg);
expect(sock._eventHandlers.message).not.to.have.been.called;
});
@ -391,7 +391,7 @@ describe('Websock', function () {
sock.rQi = 6;
const msg = { data: new Uint8Array([1, 2, 3]).buffer };
sock._mode = 'binary';
sock._recv_message(msg);
sock._recvMessage(msg);
expect(sock._rQlen).to.equal(0);
expect(sock.rQi).to.equal(0);
});
@ -403,7 +403,7 @@ describe('Websock', function () {
sock.rQi = 10;
const msg = { data: new Uint8Array([1, 2]).buffer };
sock._mode = 'binary';
sock._recv_message(msg);
sock._recvMessage(msg);
expect(sock._rQlen).to.equal(12);
expect(sock.rQi).to.equal(0);
});
@ -415,7 +415,7 @@ describe('Websock', function () {
sock._rQbufferSize = 20;
const msg = { data: new Uint8Array(30).buffer };
sock._mode = 'binary';
sock._recv_message(msg);
sock._recvMessage(msg);
expect(sock._rQlen).to.equal(30);
expect(sock.rQi).to.equal(0);
expect(sock._rQ.length).to.equal(240); // keep the invariant that rQbufferSize / 8 >= rQlen
@ -428,7 +428,7 @@ describe('Websock', function () {
sock._rQbufferSize = 20;
const msg = { data: new Uint8Array(6).buffer };
sock._mode = 'binary';
sock._recv_message(msg);
sock._recvMessage(msg);
expect(sock._rQlen).to.equal(6);
expect(sock.rQi).to.equal(0);
expect(sock._rQ.length).to.equal(48);
@ -450,13 +450,13 @@ describe('Websock', function () {
it('should only send the send queue up to the send queue length', function () {
sock._sQ = new Uint8Array([1, 2, 3, 4, 5]);
sock._sQlen = 3;
const res = sock._encode_message();
const res = sock._encodeMessage();
expect(res).to.array.equal(new Uint8Array([1, 2, 3]));
});
it('should properly pass the encoded data off to the actual WebSocket', function () {
sock.send([1, 2, 3]);
expect(sock._websocket._get_sent_data()).to.array.equal(new Uint8Array([1, 2, 3]));
expect(sock._websocket._getSentData()).to.array.equal(new Uint8Array([1, 2, 3]));
});
});
});

8
utils/genkeysymdef.js
View File

@ -9,14 +9,14 @@
const fs = require('fs');
let show_help = process.argv.length === 2;
let showHelp = process.argv.length === 2;
let filename;
for (let i = 2; i < process.argv.length; ++i) {
switch (process.argv[i]) {
case "--help":
case "-h":
show_help = true;
showHelp = true;
break;
case "--file":
case "-f":
@ -26,11 +26,11 @@ for (let i = 2; i < process.argv.length; ++i) {
}
if (!filename) {
show_help = true;
showHelp = true;
console.log("Error: No filename specified\n");
}
if (show_help) {
if (showHelp) {
console.log("Parses a *nix keysymdef.h to generate Unicode code point mappings");
console.log("Usage: node parse.js [options] filename:");
console.log(" -h [ --help ] Produce this help message");

222
utils/use_require.js
View File

@ -22,31 +22,31 @@ const paths = {
core: path.resolve(__dirname, '..', 'core'),
app: path.resolve(__dirname, '..', 'app'),
vendor: path.resolve(__dirname, '..', 'vendor'),
out_dir_base: path.resolve(__dirname, '..', 'build'),
lib_dir_base: path.resolve(__dirname, '..', 'lib'),
outDirBase: path.resolve(__dirname, '..', 'build'),
libDirBase: path.resolve(__dirname, '..', 'lib'),
};
const no_copy_files = new Set([
const noCopyFiles = new Set([
// skip these -- they don't belong in the processed application
path.join(paths.vendor, 'sinon.js'),
path.join(paths.vendor, 'browser-es-module-loader'),
path.join(paths.app, 'images', 'icons', 'Makefile'),
]);
const only_legacy_scripts = new Set([
const onlyLegacyScripts = new Set([
path.join(paths.vendor, 'promise.js'),
]);
const no_transform_files = new Set([
const noTransformFiles = new Set([
// don't transform this -- we want it imported as-is to properly catch loading errors
path.join(paths.app, 'error-handler.js'),
]);
no_copy_files.forEach(file => no_transform_files.add(file));
noCopyFiles.forEach(file => noTransformFiles.add(file));
// util.promisify requires Node.js 8.x, so we have our own
function promisify(original) {
return function promise_wrap() {
return function promiseWrap() {
const args = Array.prototype.slice.call(arguments);
return new Promise((resolve, reject) => {
original.apply(this, args.concat((err, value) => {
@ -72,10 +72,10 @@ const babelTransformFile = promisify(babel.transformFile);
// walkDir *recursively* walks directories trees,
// calling the callback for all normal files found.
function walkDir(base_path, cb, filter) {
return readdir(base_path)
function walkDir(basePath, cb, filter) {
return readdir(basePath)
.then((files) => {
const paths = files.map(filename => path.join(base_path, filename));
const paths = files.map(filename => path.join(basePath, filename));
return Promise.all(paths.map(filepath => lstat(filepath)
.then((stats) => {
if (filter !== undefined && !filter(filepath, stats)) return;
@ -87,157 +87,157 @@ function walkDir(base_path, cb, filter) {
});
}
function transform_html(legacy_scripts, only_legacy) {
function transformHtml(legacyScripts, onlyLegacy) {
// write out the modified vnc.html file that works with the bundle
const src_html_path = path.resolve(__dirname, '..', 'vnc.html');
const out_html_path = path.resolve(paths.out_dir_base, 'vnc.html');
return readFile(src_html_path)
.then((contents_raw) => {
let contents = contents_raw.toString();
const srcHtmlPath = path.resolve(__dirname, '..', 'vnc.html');
const outHtmlPath = path.resolve(paths.outDirBase, 'vnc.html');
return readFile(srcHtmlPath)
.then((contentsRaw) => {
let contents = contentsRaw.toString();
const start_marker = '<!-- begin scripts -->\n';
const end_marker = '<!-- end scripts -->';
const start_ind = contents.indexOf(start_marker) + start_marker.length;
const end_ind = contents.indexOf(end_marker, start_ind);
const startMarker = '<!-- begin scripts -->\n';
const endMarker = '<!-- end scripts -->';
const startInd = contents.indexOf(startMarker) + startMarker.length;
const endInd = contents.indexOf(endMarker, startInd);
let new_script = '';
let newScript = '';
if (only_legacy) {
if (onlyLegacy) {
// Only legacy version, so include things directly
for (let i = 0;i < legacy_scripts.length;i++) {
new_script += ` <script src="${legacy_scripts[i]}"></script>\n`;
for (let i = 0;i < legacyScripts.length;i++) {
newScript += ` <script src="${legacyScripts[i]}"></script>\n`;
}
} else {
// Otherwise include both modules and legacy fallbacks
new_script += ' <script type="module" crossorigin="anonymous" src="app/ui.js"></script>\n';
for (let i = 0;i < legacy_scripts.length;i++) {
new_script += ` <script nomodule src="${legacy_scripts[i]}"></script>\n`;
newScript += ' <script type="module" crossorigin="anonymous" src="app/ui.js"></script>\n';
for (let i = 0;i < legacyScripts.length;i++) {
newScript += ` <script nomodule src="${legacyScripts[i]}"></script>\n`;
}
}
contents = contents.slice(0, start_ind) + `${new_script}\n` + contents.slice(end_ind);
contents = contents.slice(0, startInd) + `${newScript}\n` + contents.slice(endInd);
return contents;
})
.then((contents) => {
console.log(`Writing ${out_html_path}`);
return writeFile(out_html_path, contents);
console.log(`Writing ${outHtmlPath}`);
return writeFile(outHtmlPath, contents);
});
}
function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
if (!import_format) {
function makeLibFiles(importFormat, sourceMaps, withAppDir, onlyLegacy) {
if (!importFormat) {
throw new Error("you must specify an import format to generate compiled noVNC libraries");
} else if (!SUPPORTED_FORMATS.has(import_format)) {
throw new Error(`unsupported output format "${import_format}" for import/export -- only ${Array.from(SUPPORTED_FORMATS)} are supported`);
} else if (!SUPPORTED_FORMATS.has(importFormat)) {
throw new Error(`unsupported output format "${importFormat}" for import/export -- only ${Array.from(SUPPORTED_FORMATS)} are supported`);
}
// NB: we need to make a copy of babel_opts, since babel sets some defaults on it
const babel_opts = () => ({
// NB: we need to make a copy of babelOpts, since babel sets some defaults on it
const babelOpts = () => ({
plugins: [],
presets: [
[ '@babel/preset-env',
{ targets: 'ie >= 11',
modules: import_format } ]
modules: importFormat } ]
],
ast: false,
sourceMaps: source_maps,
sourceMaps: sourceMaps,
});
// No point in duplicate files without the app, so force only converted files
if (!with_app_dir) {
only_legacy = true;
if (!withAppDir) {
onlyLegacy = true;
}
let in_path;
let out_path_base;
if (with_app_dir) {
out_path_base = paths.out_dir_base;
in_path = paths.main;
let inPath;
let outPathBase;
if (withAppDir) {
outPathBase = paths.outDirBase;
inPath = paths.main;
} else {
out_path_base = paths.lib_dir_base;
outPathBase = paths.libDirBase;
}
const legacy_path_base = only_legacy ? out_path_base : path.join(out_path_base, 'legacy');
const legacyPathBase = onlyLegacy ? outPathBase : path.join(outPathBase, 'legacy');
fse.ensureDirSync(out_path_base);
fse.ensureDirSync(outPathBase);
const helpers = require('./use_require_helpers');
const helper = helpers[import_format];
const helper = helpers[importFormat];
const outFiles = [];
const legacyFiles = [];
const handleDir = (js_only, vendor_rewrite, in_path_base, filename) => Promise.resolve()
const handleDir = (jsOnly, vendorRewrite, inPathBase, filename) => Promise.resolve()
.then(() => {
const out_path = path.join(out_path_base, path.relative(in_path_base, filename));
const legacy_path = path.join(legacy_path_base, path.relative(in_path_base, filename));
const outPath = path.join(outPathBase, path.relative(inPathBase, filename));
const legacyPath = path.join(legacyPathBase, path.relative(inPathBase, filename));
if (path.extname(filename) !== '.js') {
if (!js_only) {
console.log(`Writing ${out_path}`);
return copy(filename, out_path);
if (!jsOnly) {
console.log(`Writing ${outPath}`);
return copy(filename, outPath);
}
return; // skip non-javascript files
}
if (no_transform_files.has(filename)) {
return ensureDir(path.dirname(out_path))
if (noTransformFiles.has(filename)) {
return ensureDir(path.dirname(outPath))
.then(() => {
console.log(`Writing ${out_path}`);
return copy(filename, out_path);
console.log(`Writing ${outPath}`);
return copy(filename, outPath);
});
}
if (only_legacy_scripts.has(filename)) {
legacyFiles.push(legacy_path);
return ensureDir(path.dirname(legacy_path))
if (onlyLegacyScripts.has(filename)) {
legacyFiles.push(legacyPath);
return ensureDir(path.dirname(legacyPath))
.then(() => {
console.log(`Writing ${legacy_path}`);
return copy(filename, legacy_path);
console.log(`Writing ${legacyPath}`);
return copy(filename, legacyPath);
});
}
return Promise.resolve()
.then(() => {
if (only_legacy) {
if (onlyLegacy) {
return;
}
return ensureDir(path.dirname(out_path))
return ensureDir(path.dirname(outPath))
.then(() => {
console.log(`Writing ${out_path}`);
return copy(filename, out_path);
console.log(`Writing ${outPath}`);
return copy(filename, outPath);
});
})
.then(() => ensureDir(path.dirname(legacy_path)))
.then(() => ensureDir(path.dirname(legacyPath)))
.then(() => {
const opts = babel_opts();
const opts = babelOpts();
if (helper && helpers.optionsOverride) {
helper.optionsOverride(opts);
}
// Adjust for the fact that we move the core files relative
// to the vendor directory
if (vendor_rewrite) {
if (vendorRewrite) {
opts.plugins.push(["import-redirect",
{"root": legacy_path_base,
{"root": legacyPathBase,
"redirect": { "vendor/(.+)": "./vendor/$1"}}]);
}
return babelTransformFile(filename, opts)
.then((res) => {
console.log(`Writing ${legacy_path}`);
console.log(`Writing ${legacyPath}`);
const {map} = res;
let {code} = res;
if (source_maps === true) {
if (sourceMaps === true) {
// append URL for external source map
code += `\n//# sourceMappingURL=${path.basename(legacy_path)}.map\n`;
code += `\n//# sourceMappingURL=${path.basename(legacyPath)}.map\n`;
}
outFiles.push(`${legacy_path}`);
return writeFile(legacy_path, code)
outFiles.push(`${legacyPath}`);
return writeFile(legacyPath, code)
.then(() => {
if (source_maps === true || source_maps === 'both') {
console.log(` and ${legacy_path}.map`);
outFiles.push(`${legacy_path}.map`);
return writeFile(`${legacy_path}.map`, JSON.stringify(map));
if (sourceMaps === true || sourceMaps === 'both') {
console.log(` and ${legacyPath}.map`);
outFiles.push(`${legacyPath}.map`);
return writeFile(`${legacyPath}.map`, JSON.stringify(map));
}
});
});
@ -246,45 +246,45 @@ function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
Promise.resolve()
.then(() => {
const handler = handleDir.bind(null, true, false, in_path || paths.main);
const filter = (filename, stats) => !no_copy_files.has(filename);
const handler = handleDir.bind(null, true, false, inPath || paths.main);
const filter = (filename, stats) => !noCopyFiles.has(filename);
return walkDir(paths.vendor, handler, filter);
})
.then(() => {
const handler = handleDir.bind(null, true, !in_path, in_path || paths.core);
const filter = (filename, stats) => !no_copy_files.has(filename);
const handler = handleDir.bind(null, true, !inPath, inPath || paths.core);
const filter = (filename, stats) => !noCopyFiles.has(filename);
return walkDir(paths.core, handler, filter);
})
.then(() => {
if (!with_app_dir) return;
const handler = handleDir.bind(null, false, false, in_path);
const filter = (filename, stats) => !no_copy_files.has(filename);
if (!withAppDir) return;
const handler = handleDir.bind(null, false, false, inPath);
const filter = (filename, stats) => !noCopyFiles.has(filename);
return walkDir(paths.app, handler, filter);
})
.then(() => {
if (!with_app_dir) return;
if (!withAppDir) return;
if (!helper || !helper.appWriter) {
throw new Error(`Unable to generate app for the ${import_format} format!`);
throw new Error(`Unable to generate app for the ${importFormat} format!`);
}
const out_app_path = path.join(legacy_path_base, 'app.js');
console.log(`Writing ${out_app_path}`);
return helper.appWriter(out_path_base, legacy_path_base, out_app_path)
.then((extra_scripts) => {
let legacy_scripts = [];
const outAppPath = path.join(legacyPathBase, 'app.js');
console.log(`Writing ${outAppPath}`);
return helper.appWriter(outPathBase, legacyPathBase, outAppPath)
.then((extraScripts) => {
let legacyScripts = [];
legacyFiles.forEach((file) => {
let rel_file_path = path.relative(out_path_base, file);
legacy_scripts.push(rel_file_path);
let relFilePath = path.relative(outPathBase, file);
legacyScripts.push(relFilePath);
});
legacy_scripts = legacy_scripts.concat(extra_scripts);
legacyScripts = legacyScripts.concat(extraScripts);
let rel_app_path = path.relative(out_path_base, out_app_path);
legacy_scripts.push(rel_app_path);
let relAppPath = path.relative(outPathBase, outAppPath);
legacyScripts.push(relAppPath);
transform_html(legacy_scripts, only_legacy);
transformHtml(legacyScripts, onlyLegacy);
})
.then(() => {
if (!helper.removeModules) return;
@ -292,15 +292,15 @@ function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
return Promise.all(outFiles.map((filepath) => {
unlink(filepath)
.then(() => {
// Try to clean up any empty directories if this
// was the last file in there
const rmdir_r = dir =>
// Try to clean up any empty directories if
// this was the last file in there
const rmdirR = dir =>
rmdir(dir)
.then(() => rmdir_r(path.dirname(dir)))
.then(() => rmdirR(path.dirname(dir)))
.catch(() => {
// Assume the error was ENOTEMPTY and ignore it
});
return rmdir_r(path.dirname(filepath));
return rmdirR(path.dirname(filepath));
});
}));
});
@ -312,11 +312,11 @@ function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
}
if (program.clean) {
console.log(`Removing ${paths.lib_dir_base}`);
fse.removeSync(paths.lib_dir_base);
console.log(`Removing ${paths.libDirBase}`);
fse.removeSync(paths.libDirBase);
console.log(`Removing ${paths.out_dir_base}`);
fse.removeSync(paths.out_dir_base);
console.log(`Removing ${paths.outDirBase}`);
fse.removeSync(paths.outDirBase);
}
make_lib_files(program.as, program.withSourceMaps, program.withApp, program.onlyLegacy);
makeLibFiles(program.as, program.withSourceMaps, program.withApp, program.onlyLegacy);

40
utils/use_require_helpers.js
View File

@ -4,7 +4,7 @@ const path = require('path');
// util.promisify requires Node.js 8.x, so we have our own
function promisify(original) {
return function promise_wrap() {
return function promiseWrap() {
const args = Array.prototype.slice.call(arguments);
return new Promise((resolve, reject) => {
original.apply(this, args.concat((err, value) => {
@ -19,39 +19,39 @@ const writeFile = promisify(fs.writeFile);
module.exports = {
'amd': {
appWriter: (base_out_path, script_base_path, out_path) => {
appWriter: (baseOutPath, scriptBasePath, outPath) => {
// setup for requirejs
const ui_path = path.relative(base_out_path,
path.join(script_base_path, 'app', 'ui'));
return writeFile(out_path, `requirejs(["${ui_path}"], function (ui) {});`)
const uiPath = path.relative(baseOutPath,
path.join(scriptBasePath, 'app', 'ui'));
return writeFile(outPath, `requirejs(["${uiPath}"], function (ui) {});`)
.then(() => {
console.log(`Please place RequireJS in ${path.join(script_base_path, 'require.js')}`);
const require_path = path.relative(base_out_path,
path.join(script_base_path, 'require.js'));
return [ require_path ];
console.log(`Please place RequireJS in ${path.join(scriptBasePath, 'require.js')}`);
const requirePath = path.relative(baseOutPath,
path.join(scriptBasePath, 'require.js'));
return [ requirePath ];
});
},
},
'commonjs': {
appWriter: (base_out_path, script_base_path, out_path) => {
appWriter: (baseOutPath, scriptBasePath, outPath) => {
const browserify = require('browserify');
const b = browserify(path.join(script_base_path, 'app/ui.js'), {});
const b = browserify(path.join(scriptBasePath, 'app/ui.js'), {});
return promisify(b.bundle).call(b)
.then(buf => writeFile(out_path, buf))
.then(buf => writeFile(outPath, buf))
.then(() => []);
},
removeModules: true,
},
'systemjs': {
appWriter: (base_out_path, script_base_path, out_path) => {
const ui_path = path.relative(base_out_path,
path.join(script_base_path, 'app', 'ui.js'));
return writeFile(out_path, `SystemJS.import("${ui_path}");`)
appWriter: (baseOutPath, scriptBasePath, outPath) => {
const uiPath = path.relative(baseOutPath,
path.join(scriptBasePath, 'app', 'ui.js'));
return writeFile(outPath, `SystemJS.import("${uiPath}");`)
.then(() => {
console.log(`Please place SystemJS in ${path.join(script_base_path, 'system-production.js')}`);
const systemjs_path = path.relative(base_out_path,
path.join(script_base_path, 'system-production.js'));
return [ systemjs_path ];
console.log(`Please place SystemJS in ${path.join(scriptBasePath, 'system-production.js')}`);
const systemjsPath = path.relative(baseOutPath,
path.join(scriptBasePath, 'system-production.js'));
return [ systemjsPath ];
});
},
},