Use ES6 classes

Always use the shorthand notation if the function is a method of an object or class `{ foo() { ... } }` or `class bar { foo() { ... } }`
unless it's a callback in which case you a fat arrow function should be used `{ cb: () => { ... } }`

core/websock.js

@@ -14,91 +14,88 @@
 
 import * as Log from './util/logging.js';
 
-export default function Websock() {
-    "use strict";
-
-    this._websocket = null;  // WebSocket object
-
-    this._rQi = 0;           // Receive queue index
-    this._rQlen = 0;         // Next write position in the receive queue
-    this._rQbufferSize = 1024 * 1024 * 4; // Receive queue buffer size (4 MiB)
-    this._rQmax = this._rQbufferSize / 8;
-    // called in init: this._rQ = new Uint8Array(this._rQbufferSize);
-    this._rQ = null; // Receive queue
-
-    this._sQbufferSize = 1024 * 10;  // 10 KiB
-    // called in init: this._sQ = new Uint8Array(this._sQbufferSize);
-    this._sQlen = 0;
-    this._sQ = null;  // Send queue
-
-    this._eventHandlers = {
-        'message': function () {},
-        'open': function () {},
-        'close': function () {},
-        'error': function () {}
-    };
-}
-
 // this has performance issues in some versions Chromium, and
 // doesn't gain a tremendous amount of performance increase in Firefox
 // at the moment.  It may be valuable to turn it on in the future.
 const ENABLE_COPYWITHIN = false;
-
 const MAX_RQ_GROW_SIZE = 40 * 1024 * 1024;  // 40 MiB
 
-Websock.prototype = {
+export default class Websock {
+    constructor() {
+        this._websocket = null;  // WebSocket object
+
+        this._rQi = 0;           // Receive queue index
+        this._rQlen = 0;         // Next write position in the receive queue
+        this._rQbufferSize = 1024 * 1024 * 4; // Receive queue buffer size (4 MiB)
+        this._rQmax = this._rQbufferSize / 8;
+        // called in init: this._rQ = new Uint8Array(this._rQbufferSize);
+        this._rQ = null; // Receive queue
+
+        this._sQbufferSize = 1024 * 10;  // 10 KiB
+        // called in init: this._sQ = new Uint8Array(this._sQbufferSize);
+        this._sQlen = 0;
+        this._sQ = null;  // Send queue
+
+        this._eventHandlers = {
+            message: () => {},
+            open: () => {},
+            close: () => {},
+            error: () => {}
+        };
+    }
+
     // Getters and Setters
-    get_sQ: function () {
+    get_sQ() {
         return this._sQ;
-    },
+    }
 
-    get_rQ: function () {
+    get_rQ() {
         return this._rQ;
-    },
+    }
 
-    get_rQi: function () {
+    get_rQi() {
         return this._rQi;
-    },
+    }
 
-    set_rQi: function (val) {
+    set_rQi(val) {
         this._rQi = val;
-    },
+    }
 
     // Receive Queue
-    rQlen: function () {
+    rQlen() {
         return this._rQlen - this._rQi;
-    },
+    }
 
-    rQpeek8: function () {
+    rQpeek8() {
         return this._rQ[this._rQi];
-    },
+    }
 
-    rQshift8: function () {
+    rQshift8() {
         return this._rQ[this._rQi++];
-    },
+    }
 
-    rQskip8: function () {
+    rQskip8() {
         this._rQi++;
-    },
+    }
 
-    rQskipBytes: function (num) {
+    rQskipBytes(num) {
         this._rQi += num;
-    },
+    }
 
     // TODO(directxman12): test performance with these vs a DataView
-    rQshift16: function () {
+    rQshift16() {
         return (this._rQ[this._rQi++] << 8) +
                this._rQ[this._rQi++];
-    },
+    }
 
-    rQshift32: function () {
+    rQshift32() {
         return (this._rQ[this._rQi++] << 24) +
                (this._rQ[this._rQi++] << 16) +
                (this._rQ[this._rQi++] << 8) +
                this._rQ[this._rQi++];
-    },
+    }
 
-    rQshiftStr: function (len) {
+    rQshiftStr(len) {
         if (typeof(len) === 'undefined') { len = this.rQlen(); }
         let str = "";
         // Handle large arrays in steps to avoid long strings on the stack
@@ -107,37 +104,37 @@ Websock.prototype = {
             str += String.fromCharCode.apply(null, part);
         }
         return str;
-    },
+    }
 
-    rQshiftBytes: function (len) {
+    rQshiftBytes(len) {
         if (typeof(len) === 'undefined') { len = this.rQlen(); }
         this._rQi += len;
         return new Uint8Array(this._rQ.buffer, this._rQi - len, len);
-    },
+    }
 
-    rQshiftTo: function (target, len) {
+    rQshiftTo(target, len) {
         if (len === undefined) { len = this.rQlen(); }
         // TODO: make this just use set with views when using a ArrayBuffer to store the rQ
         target.set(new Uint8Array(this._rQ.buffer, this._rQi, len));
         this._rQi += len;
-    },
+    }
 
-    rQwhole: function () {
+    rQwhole() {
         return new Uint8Array(this._rQ.buffer, 0, this._rQlen);
-    },
+    }
 
-    rQslice: function (start, end) {
+    rQslice(start, end) {
         if (end) {
             return new Uint8Array(this._rQ.buffer, this._rQi + start, end - start);
         } else {
             return new Uint8Array(this._rQ.buffer, this._rQi + start, this._rQlen - this._rQi - start);
         }
-    },
+    }
 
     // Check to see if we must wait for 'num' bytes (default to FBU.bytes)
     // to be available in the receive queue. Return true if we need to
     // wait (and possibly print a debug message), otherwise false.
-    rQwait: function (msg, num, goback) {
+    rQwait(msg, num, goback) {
         const rQlen = this._rQlen - this._rQi; // Skip rQlen() function call
         if (rQlen < num) {
             if (goback) {
@@ -149,50 +146,50 @@ Websock.prototype = {
             return true; // true means need more data
         }
         return false;
-    },
+    }
 
     // Send Queue
 
-    flush: function () {
+    flush() {
         if (this._sQlen > 0 && this._websocket.readyState === WebSocket.OPEN) {
             this._websocket.send(this._encode_message());
             this._sQlen = 0;
         }
-    },
+    }
 
-    send: function (arr) {
+    send(arr) {
         this._sQ.set(arr, this._sQlen);
         this._sQlen += arr.length;
         this.flush();
-    },
+    }
 
-    send_string: function (str) {
+    send_string(str) {
         this.send(str.split('').map(function (chr) {
             return chr.charCodeAt(0);
         }));
-    },
+    }
 
     // Event Handlers
-    off: function (evt) {
+    off(evt) {
         this._eventHandlers[evt] = function () {};
-    },
+    }
 
-    on: function (evt, handler) {
+    on(evt, handler) {
         this._eventHandlers[evt] = handler;
-    },
+    }
 
-    _allocate_buffers: function () {
+    _allocate_buffers() {
         this._rQ = new Uint8Array(this._rQbufferSize);
         this._sQ = new Uint8Array(this._sQbufferSize);
-    },
+    }
 
-    init: function () {
+    init() {
         this._allocate_buffers();
         this._rQi = 0;
         this._websocket = null;
-    },
+    }
 
-    open: function (uri, protocols) {
+    open(uri, protocols) {
         this.init();
 
         this._websocket = new WebSocket(uri, protocols);
@@ -218,9 +215,9 @@ Websock.prototype = {
             this._eventHandlers.error(e);
             Log.Debug("<< WebSock.onerror: " + e);
         }).bind(this);
-    },
+    }
 
-    close: function () {
+    close() {
         if (this._websocket) {
             if ((this._websocket.readyState === WebSocket.OPEN) ||
                     (this._websocket.readyState === WebSocket.CONNECTING)) {
@@ -230,16 +227,16 @@ Websock.prototype = {
 
             this._websocket.onmessage = function (e) { return; };
         }
-    },
+    }
 
     // private methods
-    _encode_message: function () {
+    _encode_message() {
         // 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);
-    },
+    }
 
-    _expand_compact_rQ: function (min_fit) {
+    _expand_compact_rQ(min_fit) {
         const resizeNeeded = min_fit || this._rQlen - this._rQi > this._rQbufferSize / 2;
         if (resizeNeeded) {
             if (!min_fit) {
@@ -274,9 +271,9 @@ Websock.prototype = {
 
         this._rQlen = this._rQlen - this._rQi;
         this._rQi = 0;
-    },
+    }
 
-    _decode_message: function (data) {
+    _decode_message(data) {
         // push arraybuffer values onto the end
         const u8 = new Uint8Array(data);
         if (u8.length > this._rQbufferSize - this._rQlen) {
@@ -284,9 +281,9 @@ Websock.prototype = {
         }
         this._rQ.set(u8, this._rQlen);
         this._rQlen += u8.length;
-    },
+    }
 
-    _recv_message: function (e) {
+    _recv_message(e) {
         this._decode_message(e.data);
         if (this.rQlen() > 0) {
             this._eventHandlers.message();
@@ -301,4 +298,4 @@ Websock.prototype = {
             Log.Debug("Ignoring empty message");
         }
     }
-};
+}