GUACAMOLE-896: Update session recording player to support efficient reading from Blobs.

guacamole-common-js/src/main/webapp/modules/SessionRecording.js

@@ -20,18 +20,20 @@
 var Guacamole = Guacamole || {};
 
 /**
- * A recording of a Guacamole session. Given a {@link Guacamole.Tunnel}, the
+ * A recording of a Guacamole session. Given a {@link Guacamole.Tunnel} or Blob,
- * Guacamole.SessionRecording automatically handles incoming Guacamole
+ * the Guacamole.SessionRecording automatically parses Guacamole instructions
- * instructions, storing them for playback. Playback of the recording may be
+ * within the recording source as it plays back the recording. Playback of the
- * controlled through function calls to the Guacamole.SessionRecording, even
+ * recording may be controlled through function calls to the
- * while the recording has not yet finished being created or downloaded.
+ * Guacamole.SessionRecording, even while the recording has not yet finished
+ * being created or downloaded. Parsing of the contents of the recording will
+ * begin immediately and automatically after this constructor is invoked.
  *
  * @constructor
- * @param {!Guacamole.Tunnel} tunnel
+ * @param {!Blob|Guacamole.Tunnel} source
- *     The Guacamole.Tunnel from which the instructions of the recording should
+ *     The Blob from which the instructions of the recording should
  *     be read.
  */
-Guacamole.SessionRecording = function SessionRecording(tunnel) {
+Guacamole.SessionRecording = function SessionRecording(source) {
 
     /**
      * Reference to this Guacamole.SessionRecording.
@@ -41,13 +43,45 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      */
     var recording = this;
 
+    /**
+     * The Blob from which the instructions of the recording should be read.
+     * Note that this value is initialized far below.
+     *
+     * @private
+     * @type {!Blob}
+     */
+    var recordingBlob;
+
+    /**
+     * The tunnel from which the recording should be read, if the recording is
+     * being read from a tunnel. If the recording was supplied as a Blob, this
+     * will be null.
+     *
+     * @private
+     * @type {Guacamole.Tunnel}
+     */
+    var tunnel = null;
+
+    /**
+     * The number of bytes that this Guacamole.SessionRecording should attempt
+     * to read from the given blob in each read operation. Larger blocks will
+     * generally read the blob more quickly, but may result in excessive
+     * time being spent within the parser, making the page unresponsive
+     * while the recording is loading.
+     *
+     * @private
+     * @constant
+     * @type {Number}
+     */
+    var BLOCK_SIZE = 262144;
+
     /**
      * The minimum number of characters which must have been read between
      * keyframes.
      *
      * @private
      * @constant
-     * @type {!number}
+     * @type {Number}
      */
     var KEYFRAME_CHAR_INTERVAL = 16384;
 
@@ -56,47 +90,18 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      *
      * @private
      * @constant
-     * @type {!number}
+     * @type {Number}
      */
     var KEYFRAME_TIME_INTERVAL = 5000;
 
     /**
-     * The maximum amount of time to spend in any particular seek operation
+     * All frames parsed from the provided blob.
-     * before returning control to the main thread, in milliseconds. Seek
-     * operations exceeding this amount of time will proceed asynchronously.
-     *
-     * @private
-     * @constant
-     * @type {!number}
-     */
-    var MAXIMUM_SEEK_TIME = 5;
-
-    /**
-     * All frames parsed from the provided tunnel.
      *
      * @private
      * @type {!Guacamole.SessionRecording._Frame[]}
      */
     var frames = [];
 
-    /**
-     * All instructions which have been read since the last frame was added to
-     * the frames array.
-     *
-     * @private
-     * @type {!Guacamole.SessionRecording._Frame.Instruction[]}
-     */
-    var instructions = [];
-
-    /**
-     * The approximate number of characters which have been read from the
-     * provided tunnel since the last frame was flagged for use as a keyframe.
-     *
-     * @private
-     * @type {!number}
-     */
-    var charactersSinceLastKeyframe = 0;
-
     /**
      * The timestamp of the last frame which was flagged for use as a keyframe.
      * If no timestamp has yet been flagged, this will be 0.
@@ -104,7 +109,7 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      * @private
      * @type {!number}
      */
-    var lastKeyframeTimestamp = 0;
+    var lastKeyframe = 0;
 
     /**
      * Tunnel which feeds arbitrary instructions to the client used by this
@@ -152,14 +157,180 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
     var startRealTimestamp = null;
 
     /**
-     * The ID of the timeout which will continue the in-progress seek
+     * An object containing a single "aborted" property which is set to
-     * operation. If no seek operation is in progress, the ID stored here (if
+     * true if the in-progress seek operation should be aborted. If no seek
-     * any) will not be valid.
+     * operation is in progress, this will be null.
      *
      * @private
-     * @type {number}
+     * @type {object}
      */
-    var seekTimeout = null;
+    var activeSeek = null;
+
+    /**
+     * The byte offset within the recording blob of the first character of
+     * the first instruction of the current frame. Here, "current frame"
+     * refers to the frame currently being parsed when the provided
+     * recording is initially loading. If the recording is not being
+     * loaded, this value has no meaning.
+     *
+     * @private
+     * @type {!number}
+     */
+    var frameStart = 0;
+
+    /**
+     * The byte offset within the recording blob of the character which
+     * follows the last character of the most recently parsed instruction
+     * of the current frame. Here, "current frame" refers to the frame
+     * currently being parsed when the provided recording is initially
+     * loading. If the recording is not being loaded, this value has no
+     * meaning.
+     *
+     * @private
+     * @type {!number}
+     */
+    var frameEnd = 0;
+
+    /**
+     * Whether the initial loading process has been aborted. If the loading
+     * process has been aborted, no further blocks of data should be read
+     * from the recording.
+     *
+     * @private
+     * @type {!boolean}
+     */
+    var aborted = false;
+
+    /**
+     * The function to invoke when the seek operation initiated by a call
+     * to seek() is cancelled or successfully completed. If no seek
+     * operation is in progress, this will be null.
+     *
+     * @private
+     * @type {function}
+     */
+    var seekCallback = null;
+
+    /**
+     * Parses all Guacamole instructions within the given blob, invoking
+     * the provided instruction callback for each such instruction. Once
+     * the end of the blob has been reached (no instructions remain to be
+     * parsed), the provided completion callback is invoked. If a parse
+     * error prevents reading instructions from the blob, the onerror
+     * callback of the Guacamole.SessionRecording is invoked, and no further
+     * data is handled within the blob.
+     *
+     * @private
+     * @param {!Blob} blob
+     *     The blob to parse Guacamole instructions from.
+     *
+     * @param {function} [instructionCallback]
+     *     The callback to invoke for each Guacamole instruction read from
+     *     the given blob. This function must accept the same arguments
+     *     as the oninstruction handler of Guacamole.Parser.
+     *
+     * @param {function} [completionCallback]
+     *     The callback to invoke once all instructions have been read from
+     *     the given blob.
+     */
+    var parseBlob = function parseBlob(blob, instructionCallback, completionCallback) {
+
+        // Do not read any further blocks if loading has been aborted
+        if (aborted && blob === recordingBlob)
+            return;
+
+        // Prepare a parser to handle all instruction data within the blob,
+        // automatically invoking the provided instruction callback for all
+        // parsed instructions
+        var parser = new Guacamole.Parser();
+        parser.oninstruction = instructionCallback;
+
+        var offset = 0;
+        var reader = new FileReader();
+
+        /**
+         * Reads the block of data at offset bytes within the blob. If no
+         * such block exists, then the completion callback provided to
+         * parseBlob() is invoked as all data has been read.
+         *
+         * @private
+         */
+        var readNextBlock = function readNextBlock() {
+
+            // Do not read any further blocks if loading has been aborted
+            if (aborted && blob === recordingBlob)
+                return;
+
+            // Parse all instructions within the block, invoking the
+            // onerror handler if a parse error occurs
+            if (reader.readyState === 2 /* DONE */) {
+                try {
+                    parser.receive(reader.result);
+                }
+                catch (parseError) {
+                    if (recording.onerror) {
+                        recording.onerror(parseError.message);
+                    }
+                    return;
+                }
+            }
+
+            // If no data remains, the read operation is complete and no
+            // further blocks need to be read
+            if (offset >= blob.size) {
+                if (completionCallback)
+                    completionCallback();
+            }
+
+            // Otherwise, read the next block
+            else {
+                var block = blob.slice(offset, offset + BLOCK_SIZE);
+                offset += block.size;
+                reader.readAsText(block);
+            }
+
+        };
+
+        // Read blocks until the end of the given blob is reached
+        reader.onload = readNextBlock;
+        readNextBlock();
+
+    };
+
+    /**
+     * Calculates the size of the given Guacamole instruction element, in
+     * Unicode characters. The size returned includes the characters which
+     * make up the length, the "." separator between the length and the
+     * element itself, and the "," or ";" terminator which follows the
+     * element.
+     *
+     * @private
+     * @param {!string} value
+     *     The value of the element which has already been parsed (lacks
+     *     the initial length, "." separator, and "," or ";" terminator).
+     *
+     * @returns {!number}
+     *     The number of Unicode characters which would make up the given
+     *     element within a Guacamole instruction.
+     */
+    var getElementSize = function getElementSize(value) {
+
+        var valueLength = value.length;
+
+        // Calculate base size, assuming at least one digit, the "."
+        // separator, and the "," or ";" terminator
+        var protocolSize = valueLength + 3;
+
+        // Add one character for each additional digit that would occur
+        // in the element length prefix
+        while (valueLength >= 10) {
+            protocolSize++;
+            valueLength = Math.floor(valueLength / 10);
+        }
+
+        return protocolSize;
+
+    };
 
     // Start playback client connected
     playbackClient.connect();
@@ -167,13 +338,24 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
     // Hide cursor unless mouse position is received
     playbackClient.getDisplay().showCursor(false);
 
-    // Read instructions from provided tunnel, extracting each frame
+    /**
-    tunnel.oninstruction = function handleInstruction(opcode, args) {
+     * Handles a newly-received instruction, whether from the main Blob or a
+     * tunnel, adding new frames and keyframes as necessary. Load progress is
+     * reported via onprogress automatically.
+     *
+     * @private
+     * @param {!string} opcode
+     *     The opcode of the instruction to handle.
+     *
+     * @param {!string[]} args
+     *     The arguments of the received instruction, if any.
+     */
+    var loadInstruction = function loadInstruction(opcode, args) {
 
-        // Store opcode and arguments for received instruction
+        // Advance end of frame by overall length of parsed instruction
-        var instruction = new Guacamole.SessionRecording._Frame.Instruction(opcode, args.slice());
+        frameEnd += getElementSize(opcode);
-        instructions.push(instruction);
+        for (var i = 0; i < args.length; i++)
-        charactersSinceLastKeyframe += instruction.getSize();
+            frameEnd += getElementSize(args[i]);
 
         // Once a sync is received, store all instructions since the last
         // frame as a new frame
@@ -183,30 +365,97 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
             var timestamp = parseInt(args[0]);
 
             // Add a new frame containing the instructions read since last frame
-            var frame = new Guacamole.SessionRecording._Frame(timestamp, instructions);
+            var frame = new Guacamole.SessionRecording._Frame(timestamp, frameStart, frameEnd);
             frames.push(frame);
+            frameStart = frameEnd;
 
             // This frame should eventually become a keyframe if enough data
             // has been processed and enough recording time has elapsed, or if
             // this is the absolute first frame
-            if (frames.length === 1 || (charactersSinceLastKeyframe >= KEYFRAME_CHAR_INTERVAL
+            if (frames.length === 1 || (frameEnd - frames[lastKeyframe].start >= KEYFRAME_CHAR_INTERVAL
-                    && timestamp - lastKeyframeTimestamp >= KEYFRAME_TIME_INTERVAL)) {
+                    && timestamp - frames[lastKeyframe].timestamp >= KEYFRAME_TIME_INTERVAL)) {
                 frame.keyframe = true;
-                lastKeyframeTimestamp = timestamp;
+                lastKeyframe = frames.length - 1;
-                charactersSinceLastKeyframe = 0;
             }
 
-            // Clear set of instructions in preparation for next frame
-            instructions = [];
-
             // Notify that additional content is available
             if (recording.onprogress)
-                recording.onprogress(recording.getDuration());
+                recording.onprogress(recording.getDuration(), frameEnd);
 
         }
 
     };
 
+    /**
+     * Notifies that the session recording has been fully loaded. If the onload
+     * handler has not been defined, this function has no effect.
+     *
+     * @private
+     */
+    var notifyLoaded = function notifyLoaded() {
+        if (recording.onload)
+            recording.onload();
+    };
+
+    // Read instructions from provided blob, extracting each frame
+    if (source instanceof Blob)
+        parseBlob(recordingBlob, loadInstruction, notifyLoaded);
+
+    // If tunnel provided instead of Blob, extract frames, etc. as instructions
+    // are received, buffering things into a Blob for future seeks
+    else {
+
+        tunnel = source;
+        recordingBlob = new Blob();
+
+        var errorEncountered = false;
+        var instructionBuffer = '';
+
+        // Read instructions from provided tunnel, extracting each frame
+        tunnel.oninstruction = function handleInstruction(opcode, args) {
+
+            // Reconstitute received instruction
+            instructionBuffer += opcode.length + '.' + opcode;
+            args.forEach(function appendArg(arg) {
+                instructionBuffer += ',' + arg.length + '.' + arg;
+            });
+            instructionBuffer += ';';
+
+            // Append to Blob (creating a new Blob in the process)
+            if (instructionBuffer.length >= BLOCK_SIZE) {
+                recordingBlob = new Blob([recordingBlob, instructionBuffer]);
+                instructionBuffer = '';
+            }
+
+            // Load parsed instruction into recording
+            loadInstruction(opcode, args);
+
+        };
+
+        // Report any errors encountered
+        tunnel.onerror = function tunnelError(status) {
+            errorEncountered = true;
+            if (recording.onerror)
+                recording.onerror(status.message);
+        };
+
+        tunnel.onstatechange = function tunnelStateChanged(state) {
+            if (state === Guacamole.Tunnel.State.CLOSED) {
+
+                // Append to Blob (creating a new Blob in the process)
+                if (instructionBuffer.length >= BLOCK_SIZE) {
+                    recordingBlob = new Blob([recordingBlob, instructionBuffer]);
+                    instructionBuffer = '';
+                }
+
+                // Consider recording loaded if tunnel has closed without errors
+                if (!errorEncountered)
+                    notifyLoaded();
+            }
+        };
+
+    }
+
     /**
      * Converts the given absolute timestamp to a timestamp which is relative
      * to the first frame in the recording.
@@ -283,23 +532,33 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      * @param {!number} index
      *     The index of the frame within the frames array which should be
      *     replayed.
+     *
+     * @param {function} callback
+     *     The callback to invoke once replay of the frame has completed.
      */
-    var replayFrame = function replayFrame(index) {
+    var replayFrame = function replayFrame(index, callback) {
 
         var frame = frames[index];
 
         // Replay all instructions within the retrieved frame
-        for (var i = 0; i < frame.instructions.length; i++) {
+        parseBlob(recordingBlob.slice(frame.start, frame.end), function handleInstruction(opcode, args) {
-            var instruction = frame.instructions[i];
+            playbackTunnel.receiveInstruction(opcode, args);
-            playbackTunnel.receiveInstruction(instruction.opcode, instruction.args);
+        }, function replayCompleted() {
-        }
 
-        // Store client state if frame is flagged as a keyframe
+            // Store client state if frame is flagged as a keyframe
-        if (frame.keyframe && !frame.clientState) {
+            if (frame.keyframe && !frame.clientState) {
-            playbackClient.exportState(function storeClientState(state) {
+                playbackClient.exportState(function storeClientState(state) {
-                frame.clientState = state;
+                    frame.clientState = state;
-            });
+                });
-        }
+            }
+
+            // Update state to correctly represent the current frame
+            currentFrame = index;
+
+            if (callback)
+                callback();
+
+        });
 
     };
 
@@ -315,7 +574,7 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      *     The index of the frame which should become the new playback
      *     position.
      *
-     * @param {!function} callback
+     * @param {function} callback
      *     The callback to invoke once the seek operation has completed.
      *
      * @param {number} [delay=0]
@@ -327,63 +586,62 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
         // Abort any in-progress seek
         abortSeek();
 
-        // Replay frames asynchronously
+        // Note that a new seek operation is in progress
-        seekTimeout = window.setTimeout(function continueSeek() {
+        var thisSeek = activeSeek = {
+            aborted : false
+        };
 
-            var startIndex;
+        var startIndex;
 
-            // Back up until startIndex represents current state
+        // Back up until startIndex represents current state
-            for (startIndex = index; startIndex >= 0; startIndex--) {
+        for (startIndex = index; startIndex >= 0; startIndex--) {
 
-                var frame = frames[startIndex];
+            var frame = frames[startIndex];
 
-                // If we've reached the current frame, startIndex represents
+            // If we've reached the current frame, startIndex represents
-                // current state by definition
+            // current state by definition
-                if (startIndex === currentFrame)
+            if (startIndex === currentFrame)
-                    break;
+                break;
-
-                // If frame has associated absolute state, make that frame the
-                // current state
-                if (frame.clientState) {
-                    playbackClient.importState(frame.clientState);
-                    break;
-                }
 
+            // If frame has associated absolute state, make that frame the
+            // current state
+            if (frame.clientState) {
+                playbackClient.importState(frame.clientState);
+                currentFrame = index;
+                break;
             }
 
-            // Advance to frame index after current state
+        }
-            startIndex++;
 
-            var startTime = new Date().getTime();
+        // Replay any applicable incremental frames
-
+        var continueReplay = function continueReplay() {
-            // Replay any applicable incremental frames
-            for (; startIndex <= index; startIndex++) {
-
-                // Stop seeking if the operation is taking too long
-                var currentTime = new Date().getTime();
-                if (currentTime - startTime >= MAXIMUM_SEEK_TIME)
-                    break;
-
-                replayFrame(startIndex);
-            }
-
-            // Current frame is now at requested index
-            currentFrame = startIndex - 1;
 
             // Notify of changes in position
-            if (recording.onseek)
+            if (recording.onseek && currentFrame > startIndex) {
-                recording.onseek(recording.getPosition());
+                recording.onseek(toRelativeTimestamp(frames[currentFrame].timestamp),
+                    currentFrame - startIndex, index - startIndex);
+            }
 
-            // If the seek operation has not yet completed, schedule continuation
+            // Cancel seek if aborted
-            if (currentFrame !== index)
+            if (thisSeek.aborted)
-                seekToFrame(index, callback,
+                return;
-                    Math.max(delay - (new Date().getTime() - startTime), 0));
 
-            // Notify that the requested seek has completed
+            // If frames remain, replay the next frame
+            if (!thisSeek.aborted && currentFrame < index)
+                replayFrame(currentFrame + 1, continueReplay);
+
+            // Otherwise, the seek operation is completed
             else
                 callback();
 
-        }, delay || 0);
+        };
+
+        // Continue replay after requested delay has elapsed, or
+        // immediately if no delay was requested
+        if (delay)
+            window.setTimeout(continueReplay, delay);
+        else
+            continueReplay();
 
     };
 
@@ -394,7 +652,10 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      * @private
      */
     var abortSeek = function abortSeek() {
-        window.clearTimeout(seekTimeout);
+        if (activeSeek) {
+            activeSeek.aborted = true;
+            activeSeek = null;
+        }
     };
 
     /**
@@ -433,6 +694,32 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
 
     };
 
+    /**
+     * Fired when loading of this recording has completed and all frames
+     * are available.
+     *
+     * @event
+     */
+    this.onload = null;
+
+    /**
+     * Fired when an error occurs which prevents the recording from being
+     * played back.
+     *
+     * @event
+     * @param {!string} message
+     *     A human-readable message describing the error that occurred.
+     */
+    this.onerror = null;
+
+    /**
+     * Fired when further loading of this recording has been explicitly
+     * aborted through a call to abort().
+     *
+     * @event
+     */
+    this.onabort = null;
+
     /**
      * Fired when new frames have become available while the recording is
      * being downloaded.
@@ -440,6 +727,9 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      * @event
      * @param {!number} duration
      *     The new duration of the recording, in milliseconds.
+     *
+     * @param {!number} parsedSize
+     *     The number of bytes that have been loaded/parsed.
      */
     this.onprogress = null;
 
@@ -466,27 +756,59 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
      * @event
      * @param {!number} position
      *     The new position within the recording, in milliseconds.
+     *
+     * @param {!number} current
+     *     The number of frames that have been seeked through. If not
+     *     seeking through multiple frames due to a call to seek(), this
+     *     will be 1.
+     *
+     * @param {!number} total
+     *     The number of frames that are being seeked through in the
+     *     current seek operation. If not seeking through multiple frames
+     *     due to a call to seek(), this will be 1.
      */
     this.onseek = null;
 
     /**
      * Connects the underlying tunnel, beginning download of the Guacamole
      * session. Playback of the Guacamole session cannot occur until at least
-     * one frame worth of instructions has been downloaded.
+     * one frame worth of instructions has been downloaded. If the underlying
+     * recording source is a Blob, this function has no effect.
      *
      * @param {string} [data]
      *     The data to send to the tunnel when connecting.
      */
     this.connect = function connect(data) {
-        tunnel.connect(data);
+        if (tunnel)
+            tunnel.connect(data);
     };
 
     /**
      * Disconnects the underlying tunnel, stopping further download of the
-     * Guacamole session.
+     * Guacamole session. If the underlying recording source is a Blob, this
+     * function has no effect.
      */
     this.disconnect = function disconnect() {
-        tunnel.disconnect();
+        if (tunnel)
+            tunnel.disconnect();
+    };
+
+    /**
+     * Aborts the loading process, stopping further processing of the
+     * provided data. If the underlying recording source is a Guacamole tunnel,
+     * it will be disconnected.
+     */
+    this.abort = function abort() {
+        if (!aborted) {
+
+            aborted = true;
+            if (recording.onabort)
+                recording.onabort();
+
+            if (tunnel)
+                tunnel.disconnect();
+
+        }
     };
 
     /**
@@ -603,23 +925,48 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
         if (frames.length === 0)
             return;
 
+        // Abort active seek operation, if any
+        recording.cancel();
+
         // Pause playback, preserving playback state
         var originallyPlaying = recording.isPlaying();
         recording.pause();
 
-        // Perform seek
+        // Restore playback when seek is completed or cancelled
-        seekToFrame(findFrame(0, frames.length - 1, position), function restorePlaybackState() {
+        seekCallback = function restorePlaybackState() {
+
+            // Seek is no longer in progress
+            seekCallback = null;
 
             // Restore playback state
-            if (originallyPlaying)
+            if (originallyPlaying) {
                 recording.play();
+                originallyPlaying = null;
+            }
 
             // Notify that seek has completed
             if (callback)
                 callback();
 
-        });
+        };
 
+        // Perform seek
+        seekToFrame(findFrame(0, frames.length - 1, position), seekCallback);
+
+    };
+
+    /**
+     * Cancels the current seek operation, setting the current frame of the
+     * recording to wherever the seek operation was able to reach prior to
+     * being cancelled. If a callback was provided to seek(), that callback
+     * is invoked. If a seek operation is not currently underway, this
+     * function has no effect.
+     */
+    this.cancel = function cancel() {
+        if (seekCallback) {
+            abortSeek();
+            seekCallback();
+        }
     };
 
     /**
@@ -664,11 +1011,15 @@ Guacamole.SessionRecording = function SessionRecording(tunnel) {
  *     The timestamp of this frame, as dictated by the "sync" instruction which
  *     terminates the frame.
  *
- * @param {!Guacamole.SessionRecording._Frame.Instruction[]} instructions
+ * @param {!number} start
- *     All instructions which are necessary to generate this frame relative to
+ *     The byte offset within the blob of the first character of the first
- *     the previous frame in the Guacamole session.
+ *     instruction of this frame.
+ *
+ * @param {!number} end
+ *     The byte offset within the blob of character which follows the last
+ *     character of the last instruction of this frame.
  */
-Guacamole.SessionRecording._Frame = function _Frame(timestamp, instructions) {
+Guacamole.SessionRecording._Frame = function _Frame(timestamp, start, end) {
 
     /**
      * Whether this frame should be used as a keyframe if possible. This value
@@ -690,12 +1041,20 @@ Guacamole.SessionRecording._Frame = function _Frame(timestamp, instructions) {
     this.timestamp = timestamp;
 
     /**
-     * All instructions which are necessary to generate this frame relative to
+     * The byte offset within the blob of the first character of the first
-     * the previous frame in the Guacamole session.
+     * instruction of this frame.
      *
-     * @type {!Guacamole.SessionRecording._Frame.Instruction[]}
+     * @type {!number}
      */
-    this.instructions = instructions;
+    this.start = start;
+
+    /**
+     * The byte offset within the blob of character which follows the last
+     * character of the last instruction of this frame.
+     *
+     * @type {!number}
+     */
+    this.end = end;
 
     /**
      * A snapshot of client state after this frame was rendered, as returned by
@@ -709,66 +1068,6 @@ Guacamole.SessionRecording._Frame = function _Frame(timestamp, instructions) {
 
 };
 
-/**
- * A Guacamole protocol instruction. Each Guacamole protocol instruction is
- * made up of an opcode and set of arguments.
- *
- * @private
- * @constructor
- * @param {!string} opcode
- *     The opcode of this Guacamole instruction.
- *
- * @param {!string[]} args
- *     All arguments associated with this Guacamole instruction.
- */
-Guacamole.SessionRecording._Frame.Instruction = function Instruction(opcode, args) {
-
-    /**
-     * Reference to this Guacamole.SessionRecording._Frame.Instruction.
-     *
-     * @private
-     * @type {!Guacamole.SessionRecording._Frame.Instruction}
-     */
-    var instruction = this;
-
-    /**
-     * The opcode of this Guacamole instruction.
-     *
-     * @type {!string}
-     */
-    this.opcode = opcode;
-
-    /**
-     * All arguments associated with this Guacamole instruction.
-     *
-     * @type {!string[]}
-     */
-    this.args = args;
-
-    /**
-     * Returns the approximate number of characters which make up this
-     * instruction. This value is only approximate as it excludes the length
-     * prefixes and various delimiters used by the Guacamole protocol; only
-     * the content of the opcode and each argument is taken into account.
-     *
-     * @returns {!number}
-     *     The approximate size of this instruction, in characters.
-     */
-    this.getSize = function getSize() {
-
-        // Init with length of opcode
-        var size = instruction.opcode.length;
-
-        // Add length of all arguments
-        for (var i = 0; i < instruction.args.length; i++)
-            size += instruction.args[i].length;
-
-        return size;
-
-    };
-
-};
-
 /**
  * A read-only Guacamole.Tunnel implementation which streams instructions
  * received through explicit calls to its receiveInstruction() function.
@@ -816,4 +1115,4 @@ Guacamole.SessionRecording._PlaybackTunnel = function _PlaybackTunnel() {
             tunnel.oninstruction(opcode, args);
     };
 
-};
+};