| /* |
| * Copyright (C) 2012 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** |
| * @unrestricted |
| */ |
| HeapSnapshotWorker.HeapSnapshotLoader = class { |
| /** |
| * @param {!HeapSnapshotWorker.HeapSnapshotWorkerDispatcher} dispatcher |
| */ |
| constructor(dispatcher) { |
| this._reset(); |
| this._progress = new HeapSnapshotWorker.HeapSnapshotProgress(dispatcher); |
| } |
| |
| dispose() { |
| this._reset(); |
| } |
| |
| _reset() { |
| this._json = ''; |
| this._state = 'find-snapshot-info'; |
| this._snapshot = {}; |
| } |
| |
| close() { |
| if (this._json) |
| this._parseStringsArray(); |
| } |
| |
| /** |
| * @return {!HeapSnapshotWorker.JSHeapSnapshot} |
| */ |
| buildSnapshot() { |
| this._progress.updateStatus('Processing snapshot\u2026'); |
| const result = new HeapSnapshotWorker.JSHeapSnapshot(this._snapshot, this._progress); |
| this._reset(); |
| return result; |
| } |
| |
| _parseUintArray() { |
| let index = 0; |
| const char0 = '0'.charCodeAt(0); |
| const char9 = '9'.charCodeAt(0); |
| const closingBracket = ']'.charCodeAt(0); |
| const length = this._json.length; |
| while (true) { |
| while (index < length) { |
| const code = this._json.charCodeAt(index); |
| if (char0 <= code && code <= char9) { |
| break; |
| } else if (code === closingBracket) { |
| this._json = this._json.slice(index + 1); |
| return false; |
| } |
| ++index; |
| } |
| if (index === length) { |
| this._json = ''; |
| return true; |
| } |
| let nextNumber = 0; |
| const startIndex = index; |
| while (index < length) { |
| const code = this._json.charCodeAt(index); |
| if (char0 > code || code > char9) |
| break; |
| nextNumber *= 10; |
| nextNumber += (code - char0); |
| ++index; |
| } |
| if (index === length) { |
| this._json = this._json.slice(startIndex); |
| return true; |
| } |
| this._array[this._arrayIndex++] = nextNumber; |
| } |
| } |
| |
| _parseStringsArray() { |
| this._progress.updateStatus('Parsing strings\u2026'); |
| const closingBracketIndex = this._json.lastIndexOf(']'); |
| if (closingBracketIndex === -1) |
| throw new Error('Incomplete JSON'); |
| this._json = this._json.slice(0, closingBracketIndex + 1); |
| this._snapshot.strings = JSON.parse(this._json); |
| } |
| |
| /** |
| * @param {string} chunk |
| */ |
| write(chunk) { |
| if (this._json !== null) |
| this._json += chunk; |
| while (true) { |
| switch (this._state) { |
| case 'find-snapshot-info': { |
| const snapshotToken = '"snapshot"'; |
| const snapshotTokenIndex = this._json.indexOf(snapshotToken); |
| if (snapshotTokenIndex === -1) |
| throw new Error('Snapshot token not found'); |
| |
| const json = this._json.slice(snapshotTokenIndex + snapshotToken.length + 1); |
| this._state = 'parse-snapshot-info'; |
| this._progress.updateStatus('Loading snapshot info\u2026'); |
| this._json = null; // tokenizer takes over input. |
| this._jsonTokenizer = new TextUtils.TextUtils.BalancedJSONTokenizer(this._writeBalancedJSON.bind(this)); |
| // Fall through with adjusted payload. |
| chunk = json; |
| } |
| case 'parse-snapshot-info': { |
| this._jsonTokenizer.write(chunk); |
| if (this._jsonTokenizer) |
| return; // no remainder to process. |
| break; |
| } |
| case 'find-nodes': { |
| const nodesToken = '"nodes"'; |
| const nodesTokenIndex = this._json.indexOf(nodesToken); |
| if (nodesTokenIndex === -1) |
| return; |
| const bracketIndex = this._json.indexOf('[', nodesTokenIndex); |
| if (bracketIndex === -1) |
| return; |
| this._json = this._json.slice(bracketIndex + 1); |
| const node_fields_count = this._snapshot.snapshot.meta.node_fields.length; |
| const nodes_length = this._snapshot.snapshot.node_count * node_fields_count; |
| this._array = new Uint32Array(nodes_length); |
| this._arrayIndex = 0; |
| this._state = 'parse-nodes'; |
| break; |
| } |
| case 'parse-nodes': { |
| const hasMoreData = this._parseUintArray(); |
| this._progress.updateProgress('Loading nodes\u2026 %d%%', this._arrayIndex, this._array.length); |
| if (hasMoreData) |
| return; |
| this._snapshot.nodes = this._array; |
| this._state = 'find-edges'; |
| this._array = null; |
| break; |
| } |
| case 'find-edges': { |
| const edgesToken = '"edges"'; |
| const edgesTokenIndex = this._json.indexOf(edgesToken); |
| if (edgesTokenIndex === -1) |
| return; |
| const bracketIndex = this._json.indexOf('[', edgesTokenIndex); |
| if (bracketIndex === -1) |
| return; |
| this._json = this._json.slice(bracketIndex + 1); |
| const edge_fields_count = this._snapshot.snapshot.meta.edge_fields.length; |
| const edges_length = this._snapshot.snapshot.edge_count * edge_fields_count; |
| this._array = new Uint32Array(edges_length); |
| this._arrayIndex = 0; |
| this._state = 'parse-edges'; |
| break; |
| } |
| case 'parse-edges': { |
| const hasMoreData = this._parseUintArray(); |
| this._progress.updateProgress('Loading edges\u2026 %d%%', this._arrayIndex, this._array.length); |
| if (hasMoreData) |
| return; |
| this._snapshot.edges = this._array; |
| this._array = null; |
| // If there is allocation info parse it, otherwise jump straight to strings. |
| if (this._snapshot.snapshot.trace_function_count) { |
| this._state = 'find-trace-function-infos'; |
| this._progress.updateStatus('Loading allocation traces\u2026'); |
| } else if (this._snapshot.snapshot.meta.sample_fields) { |
| this._state = 'find-samples'; |
| this._progress.updateStatus('Loading samples\u2026'); |
| } else { |
| this._state = 'find-strings'; |
| } |
| break; |
| } |
| case 'find-trace-function-infos': { |
| const tracesToken = '"trace_function_infos"'; |
| const tracesTokenIndex = this._json.indexOf(tracesToken); |
| if (tracesTokenIndex === -1) |
| return; |
| const bracketIndex = this._json.indexOf('[', tracesTokenIndex); |
| if (bracketIndex === -1) |
| return; |
| this._json = this._json.slice(bracketIndex + 1); |
| |
| const trace_function_info_field_count = this._snapshot.snapshot.meta.trace_function_info_fields.length; |
| const trace_function_info_length = |
| this._snapshot.snapshot.trace_function_count * trace_function_info_field_count; |
| this._array = new Uint32Array(trace_function_info_length); |
| this._arrayIndex = 0; |
| this._state = 'parse-trace-function-infos'; |
| break; |
| } |
| case 'parse-trace-function-infos': { |
| if (this._parseUintArray()) |
| return; |
| this._snapshot.trace_function_infos = this._array; |
| this._array = null; |
| this._state = 'find-trace-tree'; |
| break; |
| } |
| case 'find-trace-tree': { |
| const tracesToken = '"trace_tree"'; |
| const tracesTokenIndex = this._json.indexOf(tracesToken); |
| if (tracesTokenIndex === -1) |
| return; |
| const bracketIndex = this._json.indexOf('[', tracesTokenIndex); |
| if (bracketIndex === -1) |
| return; |
| this._json = this._json.slice(bracketIndex); |
| this._state = 'parse-trace-tree'; |
| break; |
| } |
| case 'parse-trace-tree': { |
| // If there is samples array parse it, otherwise jump straight to strings. |
| const nextToken = this._snapshot.snapshot.meta.sample_fields ? '"samples"' : '"strings"'; |
| const nextTokenIndex = this._json.indexOf(nextToken); |
| if (nextTokenIndex === -1) |
| return; |
| const bracketIndex = this._json.lastIndexOf(']', nextTokenIndex); |
| this._snapshot.trace_tree = JSON.parse(this._json.substring(0, bracketIndex + 1)); |
| this._json = this._json.slice(bracketIndex + 1); |
| if (this._snapshot.snapshot.meta.sample_fields) { |
| this._state = 'find-samples'; |
| this._progress.updateStatus('Loading samples\u2026'); |
| } else { |
| this._state = 'find-strings'; |
| this._progress.updateStatus('Loading strings\u2026'); |
| } |
| break; |
| } |
| case 'find-samples': { |
| const samplesToken = '"samples"'; |
| const samplesTokenIndex = this._json.indexOf(samplesToken); |
| if (samplesTokenIndex === -1) |
| return; |
| const bracketIndex = this._json.indexOf('[', samplesTokenIndex); |
| if (bracketIndex === -1) |
| return; |
| this._json = this._json.slice(bracketIndex + 1); |
| this._array = []; |
| this._arrayIndex = 0; |
| this._state = 'parse-samples'; |
| break; |
| } |
| case 'parse-samples': { |
| if (this._parseUintArray()) |
| return; |
| this._snapshot.samples = this._array; |
| this._array = null; |
| this._state = 'find-strings'; |
| this._progress.updateStatus('Loading strings\u2026'); |
| break; |
| } |
| case 'find-strings': { |
| const stringsToken = '"strings"'; |
| const stringsTokenIndex = this._json.indexOf(stringsToken); |
| if (stringsTokenIndex === -1) |
| return; |
| const bracketIndex = this._json.indexOf('[', stringsTokenIndex); |
| if (bracketIndex === -1) |
| return; |
| this._json = this._json.slice(bracketIndex); |
| this._state = 'accumulate-strings'; |
| break; |
| } |
| case 'accumulate-strings': |
| return; |
| } |
| } |
| } |
| |
| /** |
| * @param {string} data |
| */ |
| _writeBalancedJSON(data) { |
| this._json = this._jsonTokenizer.remainder(); // tokenizer releases input. |
| this._jsonTokenizer = null; |
| this._state = 'find-nodes'; |
| this._snapshot.snapshot = /** @type {!HeapSnapshotHeader} */ (JSON.parse(data)); |
| } |
| }; |
