DevTools: n^2 -> n while loading heap snapshots and timeline files.

Source/devtools/front_end/timeline/TimelineModel.js

 /*
  * 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
@@ skipping 1178 matching lines @@
     },
 
     /**
      * @param {!Blob} file
      * @param {!WebInspector.Progress} progress
      */
     loadFromFile: function(file, progress)
     {
         var delegate = new WebInspector.TimelineModelLoadFromFileDelegate(this, progress);
         var fileReader = this._createFileReader(file, delegate);
-        var loader = this.createLoader(fileReader, progress);
+        var loader = new WebInspector.TracingModelLoader(this, new WebInspector.ProgressStub(), fileReader.cancel.bind(fileReader));
         fileReader.start(loader);
     },
 
     _createFileReader: function(file, delegate)
     {
         return new WebInspector.ChunkedFileReader(file, WebInspector.TimelineModel.TransferChunkLengthBytes, delegate);
     },
 
     reset: function()
     {
@@ skipping 65 matching lines @@
 
     /**
      * @return {!Array.<!WebInspector.TimelineModel.VirtualThread>}
      */
     virtualThreads: function()
     {
         return this._virtualThreads;
     },
 
     /**
-     * @param {!WebInspector.ChunkedFileReader} fileReader
-     * @param {!WebInspector.Progress} progress
-     * @return {!WebInspector.OutputStream}
-     */
-    createLoader: function(fileReader, progress)
-    {
-        return new WebInspector.TracingModelLoader(this, fileReader, progress);
-    },
-
-    /**
      * @return {boolean}
      */
     isEmpty: function()
     {
         return this.minimumRecordTime() === 0 && this.maximumRecordTime() === 0;
     },
 
     /**
      * @return {!Array.<!WebInspector.TimelineModel.Record>}
      */
@@ skipping 227 matching lines @@
         return !this._eventNames[event.name];
     },
 
     __proto__: WebInspector.TraceEventNameFilter.prototype
 }
 
 /**
  * @constructor
  * @implements {WebInspector.OutputStream}
  * @param {!WebInspector.TimelineModel} model
- * @param {!{cancel: function()}} reader
  * @param {!WebInspector.Progress} progress
+ * @param {function()=} canceledCallback
  */
-WebInspector.TracingModelLoader = function(model, reader, progress)
+WebInspector.TracingModelLoader = function(model, progress, canceledCallback)
 {
     this._model = model;
-    this._reader = reader;
+    this._loader = new WebInspector.TracingModel.Loader(model._tracingModel);
+
+    this._canceledCallback = canceledCallback;
     this._progress = progress;
-    this._buffer = "";
+    this._progress.setTitle(WebInspector.UIString("Loading"));
+    this._progress.setTotalWork(WebInspector.TracingModelLoader._totalProgress);  // Unknown, will loop the values.
+
     this._firstChunk = true;
-    this._loader = new WebInspector.TracingModel.Loader(model._tracingModel);
+    this._wasCanceledOnce = false;
+
+    this._loadedBytes = 0;
+    this._jsonTokenizer = new WebInspector.TextUtils.BalancedJSONTokenizer(this._writeBalancedJSON.bind(this), true);
 }
 
+WebInspector.TracingModelLoader._totalProgress = 100000;
+
 WebInspector.TracingModelLoader.prototype = {
     /**
      * @override
      * @param {string} chunk
      */
     write: function(chunk)
     {
-        var data = this._buffer + chunk;
-        var lastIndex = 0;
-        var index;
-        do {
-            index = lastIndex;
-            lastIndex = WebInspector.TextUtils.findBalancedCurlyBrackets(data, index);
-        } while (lastIndex !== -1);
+        this._loadedBytes += chunk.length;
+        if (this._progress.isCanceled() && !this._wasCanceledOnce) {
+            this._wasCanceled = true;
+            this._reportErrorAndCancelLoading();
+            return;
+        }
+        this._progress.setWorked(this._loadedBytes % WebInspector.TracingModelLoader._totalProgress,
+                                 WebInspector.UIString("Loaded %s", Number.bytesToString(this._loadedBytes)));
+        this._jsonTokenizer.write(chunk);
+    },
 
-        var json = data.slice(0, index) + "]";
-        this._buffer = data.slice(index);
-
-        if (!index)
-            return;
+    /**
+     * @param {string} data
+     */
+    _writeBalancedJSON: function(data)
+    {
+        var json = data + "]";
 
         if (this._firstChunk) {
             this._model._startCollectingTraceEvents(true);
         } else {
             var commaIndex = json.indexOf(",");
             if (commaIndex !== -1)
                 json = json.slice(commaIndex + 1);
             json = "[" + json;
         }
 
         var items;
         try {
             items = /** @type {!Array.<!WebInspector.TracingManager.EventPayload>} */ (JSON.parse(json));
         } catch (e) {
-            this._reportErrorAndCancelLoading("Malformed timeline data: " + e);
+            this._reportErrorAndCancelLoading(WebInspector.UIString("Malformed timeline data: " + e));
             return;
         }
 
         if (this._firstChunk) {
             this._firstChunk = false;
             if (this._looksLikeAppVersion(items[0])) {
-                this._reportErrorAndCancelLoading("Old Timeline format is not supported.");
+                this._reportErrorAndCancelLoading(WebInspector.UIString("Legacy Timeline format is not supported."));
                 return;
             }
         }
 
         try {
             this._loader.loadNextChunk(items);
         } catch(e) {
-            this._reportErrorAndCancelLoading("Malformed timeline data: " + e);
+            this._reportErrorAndCancelLoading(WebInspector.UIString("Malformed timeline data: " + e));
             return;
         }
     },
 
-    _reportErrorAndCancelLoading: function(messsage)
+    /**
+     * @param {string=} message
+     */
+    _reportErrorAndCancelLoading: function(message)
     {
-        WebInspector.console.error(messsage);
+        if (message)
+            WebInspector.console.error(message);
         this._model.tracingComplete();
         this._model.reset();
-        this._reader.cancel();
+        if (this._canceledCallback)
+            this._canceledCallback();
         this._progress.done();
     },
 
     _looksLikeAppVersion: function(item)
     {
         return typeof item === "string" && item.indexOf("Chrome") !== -1;
     },
 
     /**
      * @override
      */
     close: function()
     {
         this._loader.finish();
         this._model.tracingComplete();
+        if (this._progress)
+            this._progress.done();
     }
 }
 
 /**
  * @constructor
  * @param {!WebInspector.OutputStream} stream
  * @implements {WebInspector.OutputStreamDelegate}
  */
 WebInspector.TracingTimelineSaver = function(stream)
 {
@@ skipping 331 matching lines @@
         /** @type {!Object.<string, !Array.<!WebInspector.InvalidationTrackingEvent>>} */
         this._invalidations = {};
         /** @type {!Object.<number, !Array.<!WebInspector.InvalidationTrackingEvent>>} */
         this._invalidationsByNodeId = {};
 
         this._lastRecalcStyle = undefined;
         this._lastPaintWithLayer = undefined;
         this._didPaint = false;
     }
 }