The Tor Browser: comparison browser/devtools/profiler/cleopatra/js/parser.js

comparison: browser/devtools/profiler/cleopatra/js/parser.js

browser/devtools/profiler/cleopatra/js/parser.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:ceaac52e9650
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+Array.prototype.clone = function() { return this.slice(0); }
+function makeSample(frames, extraInfo, lines) {
+return {
+frames: frames,
+extraInfo: extraInfo,
+lines: lines
+};
+}
+function cloneSample(sample) {
+return makeSample(sample.frames.clone(), sample.extraInfo, sample.lines.clone());
+}
+function bucketsBySplittingArray(array, maxItemsPerBucket) {
+var buckets = [];
+while (buckets.length * maxItemsPerBucket < array.length) {
+buckets.push(array.slice(buckets.length * maxItemsPerBucket,
+(buckets.length + 1) * maxItemsPerBucket));
+}
+return buckets;
+}
+var gParserWorker = new Worker("profiler/cleopatra/js/parserWorker.js");
+gParserWorker.nextRequestID = 0;
+function WorkerRequest(worker) {
+var self = this;
+this._eventListeners = {};
+var requestID = worker.nextRequestID++;
+this._requestID = requestID;
+this._worker = worker;
+this._totalReporter = new ProgressReporter();
+this._totalReporter.addListener(function (reporter) {
+self._fireEvent("progress", reporter.getProgress(), reporter.getAction());
+})
+this._sendChunkReporter = this._totalReporter.addSubreporter(500);
+this._executeReporter = this._totalReporter.addSubreporter(3000);
+this._receiveChunkReporter = this._totalReporter.addSubreporter(100);
+this._totalReporter.begin("Processing task in worker...");
+var partialResult = null;
+function onMessageFromWorker(msg) {
+pendingMessages.push(msg);
+scheduleMessageProcessing();
+}
+function processMessage(msg) {
+var startTime = Date.now();
+var data = msg.data;
+var readTime = Date.now() - startTime;
+if (data.requestID == requestID || !data.requestID) {
+switch(data.type) {
+case "error":
+self._sendChunkReporter.setAction("Error in worker: " + data.error);
+self._executeReporter.setAction("Error in worker: " + data.error);
+self._receiveChunkReporter.setAction("Error in worker: " + data.error);
+self._totalReporter.setAction("Error in worker: " + data.error);
+PROFILERERROR("Error in worker: " + data.error);
+self._fireEvent("error", data.error);
+break;
+case "progress":
+self._executeReporter.setProgress(data.progress);
+break;
+case "finished":
+self._executeReporter.finish();
+self._receiveChunkReporter.begin("Receiving data from worker...");
+self._receiveChunkReporter.finish();
+self._fireEvent("finished", data.result);
+worker.removeEventListener("message", onMessageFromWorker);
+break;
+case "finishedStart":
+partialResult = null;
+self._totalReceiveChunks = data.numChunks;
+self._gotReceiveChunks = 0;
+self._executeReporter.finish();
+self._receiveChunkReporter.begin("Receiving data from worker...");
+break;
+case "finishedChunk":
+partialResult = partialResult ? partialResult.concat(data.chunk) : data.chunk;
+var chunkIndex = self._gotReceiveChunks++;
+self._receiveChunkReporter.setProgress((chunkIndex + 1) / self._totalReceiveChunks);
+break;
+case "finishedEnd":
+self._receiveChunkReporter.finish();
+self._fireEvent("finished", partialResult);
+worker.removeEventListener("message", onMessageFromWorker);
+break;
+}
+// dump log if present
+if (data.log) {
+for (var line in data.log) {
+PROFILERLOG(line);
+}
+}
+}
+}
+var pendingMessages = [];
+var messageProcessingTimer = 0;
+function processMessages() {
+messageProcessingTimer = 0;
+processMessage(pendingMessages.shift());
+if (pendingMessages.length)
+scheduleMessageProcessing();
+}
+function scheduleMessageProcessing() {
+if (messageProcessingTimer)
+return;
+messageProcessingTimer = setTimeout(processMessages, 10);
+}
+worker.addEventListener("message", onMessageFromWorker);
+}
+WorkerRequest.prototype = {
+send: function WorkerRequest_send(task, taskData) {
+this._sendChunkReporter.begin("Sending data to worker...");
+var startTime = Date.now();
+this._worker.postMessage({
+requestID: this._requestID,
+task: task,
+taskData: taskData
+});
+var postTime = Date.now() - startTime;
+this._sendChunkReporter.finish();
+this._executeReporter.begin("Processing worker request...");
+},
+sendInChunks: function WorkerRequest_sendInChunks(task, taskData, params, maxChunkSize) {
+this._sendChunkReporter.begin("Sending data to worker...");
+var self = this;
+var chunks = bucketsBySplittingArray(taskData, maxChunkSize);
+var pendingMessages = [
+{
+requestID: this._requestID,
+task: "chunkedStart",
+numChunks: chunks.length
+}
+].concat(chunks.map(function (chunk) {
+return {
+requestID: self._requestID,
+task: "chunkedChunk",
+chunk: chunk
+};
+})).concat([
+{
+requestID: this._requestID,
+task: "chunkedEnd"
+},
+{
+requestID: this._requestID,
+params: params,
+task: task
+},
+]);
+var totalMessages = pendingMessages.length;
+var numSentMessages = 0;
+function postMessage(msg) {
+var msgIndex = numSentMessages++;
+var startTime = Date.now();
+self._worker.postMessage(msg);
+var postTime = Date.now() - startTime;
+self._sendChunkReporter.setProgress((msgIndex + 1) / totalMessages);
+}
+var messagePostingTimer = 0;
+function postMessages() {
+messagePostingTimer = 0;
+postMessage(pendingMessages.shift());
+if (pendingMessages.length) {
+scheduleMessagePosting();
+} else {
+self._sendChunkReporter.finish();
+self._executeReporter.begin("Processing worker request...");
+}
+}
+function scheduleMessagePosting() {
+if (messagePostingTimer)
+return;
+messagePostingTimer = setTimeout(postMessages, 10);
+}
+scheduleMessagePosting();
+},
+// TODO: share code with TreeView
+addEventListener: function WorkerRequest_addEventListener(eventName, callbackFunction) {
+if (!(eventName in this._eventListeners))
+this._eventListeners[eventName] = [];
+if (this._eventListeners[eventName].indexOf(callbackFunction) != -1)
+return;
+this._eventListeners[eventName].push(callbackFunction);
+},
+removeEventListener: function WorkerRequest_removeEventListener(eventName, callbackFunction) {
+if (!(eventName in this._eventListeners))
+return;
+var index = this._eventListeners[eventName].indexOf(callbackFunction);
+if (index == -1)
+return;
+this._eventListeners[eventName].splice(index, 1);
+},
+_fireEvent: function WorkerRequest__fireEvent(eventName, eventObject, p1) {
+if (!(eventName in this._eventListeners))
+return;
+this._eventListeners[eventName].forEach(function (callbackFunction) {
+callbackFunction(eventObject, p1);
+});
+},
+}
+var Parser = {
+parse: function Parser_parse(data, params) {
+var request = new WorkerRequest(gParserWorker);
+request.sendInChunks("parseRawProfile", data, params, 3000000);
+return request;
+},
+updateFilters: function Parser_updateFilters(filters) {
+var request = new WorkerRequest(gParserWorker);
+request.send("updateFilters", {
+filters: filters,
+profileID: 0
+});
+return request;
+},
+updateViewOptions: function Parser_updateViewOptions(options) {
+var request = new WorkerRequest(gParserWorker);
+request.send("updateViewOptions", {
+options: options,
+profileID: 0
+});
+return request;
+},
+getSerializedProfile: function Parser_getSerializedProfile(complete, callback) {
+var request = new WorkerRequest(gParserWorker);
+request.send("getSerializedProfile", {
+profileID: 0,
+complete: complete
+});
+request.addEventListener("finished", callback);
+},
+calculateHistogramData: function Parser_calculateHistogramData() {
+var request = new WorkerRequest(gParserWorker);
+request.send("calculateHistogramData", {
+profileID: 0
+});
+return request;
+},
+calculateDiagnosticItems: function Parser_calculateDiagnosticItems(meta) {
+var request = new WorkerRequest(gParserWorker);
+request.send("calculateDiagnosticItems", {
+profileID: 0,
+meta: meta
+});
+return request;
+},
+updateLogSetting: function Parser_updateLogSetting() {
+var request = new WorkerRequest(gParserWorker);
+request.send("initWorker", {
+debugLog: gDebugLog,
+debugTrace: gDebugTrace,
+});
+return request;
+},
+};