Timeline: quit using Progress, introduce TimelineLifecycleDelegate

third_party/WebKit/Source/devtools/front_end/timeline/TimelineLoader.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @constructor
  * @implements {WebInspector.OutputStream}
  * @implements {WebInspector.OutputStreamDelegate}
- * @param {!WebInspector.TimelineModel} model
- * @param {!WebInspector.Progress} progress
+ * @param {!WebInspector.TracingModel} model
+ * @param {!WebInspector.TimelineLifecycleDelegate} delegate
  */
-WebInspector.TimelineLoader = function(model, progress)
+WebInspector.TimelineLoader = function(model, delegate)
 {
     this._model = model;
+    this._delegate = delegate;
 
     /** @type {?function()} */
     this._canceledCallback = null;
-    this._progress = progress;
-    this._progress.setTitle(WebInspector.UIString("Loading"));
-    this._progress.setTotalWork(WebInspector.TimelineLoader._totalProgress);  // Unknown, will loop the values.
 
     this._state = WebInspector.TimelineLoader.State.Initial;
     this._buffer = "";
     this._firstChunk = true;
-    this._wasCanceledOnce = false;
 
     this._loadedBytes = 0;
     /** @type {number} */
     this._totalSize;
     this._jsonTokenizer = new WebInspector.TextUtils.BalancedJSONTokenizer(this._writeBalancedJSON.bind(this), true);
 }
 
 /**
- * @param {!WebInspector.TimelineModel} model
+ * @param {!WebInspector.TracingModel} model
  * @param {!File} file
- * @param {!WebInspector.Progress} progress
+ * @param {!WebInspector.TimelineLifecycleDelegate} delegate
+ * @return {!WebInspector.TimelineLoader}
  */
-WebInspector.TimelineLoader.loadFromFile = function(model, file, progress)
+WebInspector.TimelineLoader.loadFromFile = function(model, file, delegate)
 {
-    var loader = new WebInspector.TimelineLoader(model, progress);
+    var loader = new WebInspector.TimelineLoader(model, delegate);
     var fileReader = WebInspector.TimelineLoader._createFileReader(file, loader);
     loader._canceledCallback = fileReader.cancel.bind(fileReader);
     loader._totalSize = file.size;
-    progress.setTotalWork(loader._totalSize);
     fileReader.start(loader);
+    return loader;
 }
 
 /**
- * @param {!WebInspector.TimelineModel} model
+ * @param {!WebInspector.TracingModel} model
  * @param {string} url
- * @param {!WebInspector.Progress} progress
+ * @param {!WebInspector.TimelineLifecycleDelegate} delegate
+ * @return {!WebInspector.TimelineLoader}
  */
-WebInspector.TimelineLoader.loadFromURL = function(model, url, progress)
+WebInspector.TimelineLoader.loadFromURL = function(model, url, delegate)
 {
-    var stream = new WebInspector.TimelineLoader(model, progress);
+    var stream = new WebInspector.TimelineLoader(model, delegate);
     WebInspector.ResourceLoader.loadAsStream(url, null, stream);
+    return stream;
 }
 
+WebInspector.TimelineLoader.TransferChunkLengthBytes = 5000000;
+
 /**
  * @param {!File} file
  * @param {!WebInspector.OutputStreamDelegate} delegate
  * @return {!WebInspector.ChunkedReader}
  */
 WebInspector.TimelineLoader._createFileReader = function(file, delegate)
 {
-    return new WebInspector.ChunkedFileReader(file, WebInspector.TimelineModel.TransferChunkLengthBytes, delegate);
+    return new WebInspector.ChunkedFileReader(file, WebInspector.TimelineLoader.TransferChunkLengthBytes, delegate);
 }
 
-
-WebInspector.TimelineLoader._totalProgress = 100000;
-
 WebInspector.TimelineLoader.State = {
     Initial: "Initial",
     LookingForEvents: "LookingForEvents",
     ReadingEvents: "ReadingEvents"
 }
 
 WebInspector.TimelineLoader.prototype = {
+    cancel: function()
+    {
+        this._model.reset();
+        this._delegate.loadingComplete(false);
+        this._delegate = null;
+        if (this._canceledCallback)
+            this._canceledCallback();
+    },
+
     /**
      * @override
      * @param {string} chunk
      */
     write: function(chunk)
     {
+        if (!this._delegate)
+            return;
         this._loadedBytes += chunk.length;
-        if (this._progress.isCanceled() && !this._wasCanceledOnce) {
-            this._wasCanceled = true;
-            this._reportErrorAndCancelLoading();
-            return;
-        }
-        if (this._firstChunk)
-            this._progress.setTitle(WebInspector.UIString("Loading\u2026"));
-        if (this._totalSize) {
-            this._progress.setWorked(this._loadedBytes);
-        } else {
-            this._progress.setWorked(this._loadedBytes % WebInspector.TimelineLoader._totalProgress,
-                                     WebInspector.UIString("Loaded %s", Number.bytesToString(this._loadedBytes)));
-        }
+        if (!this._firstChunk)
+            this._delegate.loadingProgress(this._totalSize ? this._loadedBytes / this._totalSize : undefined);
+
         if (this._state === WebInspector.TimelineLoader.State.Initial) {
             if (chunk[0] === "{")
                 this._state = WebInspector.TimelineLoader.State.LookingForEvents;
             else if (chunk[0] === "[")
                 this._state = WebInspector.TimelineLoader.State.ReadingEvents;
             else {
                 this._reportErrorAndCancelLoading(WebInspector.UIString("Malformed timeline data: Unknown JSON format"));
                 return;
             }
         }
@@ skipping 13 matching lines @@
     },
 
     /**
      * @param {string} data
      */
     _writeBalancedJSON: function(data)
     {
         var json = data + "]";
 
         if (this._firstChunk) {
-            this._model.startCollectingTraceEvents(true);
+            this._delegate.loadingStarted();
         } 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(WebInspector.UIString("Malformed timeline data: %s", e.toString()));
             return;
         }
 
         if (this._firstChunk) {
             this._firstChunk = false;
             if (this._looksLikeAppVersion(items[0])) {
                 this._reportErrorAndCancelLoading(WebInspector.UIString("Legacy Timeline format is not supported."));
                 return;
             }
         }
 
         try {
-            this._model.traceEventsCollected(items);
+            this._model.addEvents(items);
         } catch(e) {
             this._reportErrorAndCancelLoading(WebInspector.UIString("Malformed timeline data: %s", e.toString()));
             return;
         }
     },
 
     /**
      * @param {string=} message
      */
     _reportErrorAndCancelLoading: function(message)
     {
         if (message)
             WebInspector.console.error(message);
-        this._model.tracingComplete();
-        this._model.reset();
-        if (this._canceledCallback)
-            this._canceledCallback();
-        this._progress.done();
+        this.cancel();
     },
 
     /**
      * @param {*} item
      * @return {boolean}
      */
     _looksLikeAppVersion: function(item)
     {
         return typeof item === "string" && item.indexOf("Chrome") !== -1;
     },
 
     /**
      * @override
      */
     close: function()
     {
         this._model._loadedFromFile = true;
-        this._model.tracingComplete();
-        this._progress.done();
+        if (this._delegate)
+            this._delegate.loadingComplete(true);
     },
 
     /**
      * @override
      */
     onTransferStarted: function() {},
 
     /**
      * @override
      * @param {!WebInspector.ChunkedReader} reader
@@ skipping 56 matching lines @@
      * @override
      * @param {!WebInspector.ChunkedReader} reader
      * @param {!Event} event
      */
     onError: function(reader, event)
     {
         var error = event.target.error;
         WebInspector.console.error(WebInspector.UIString("Failed to save timeline: %s (%s, %s)", error.message, error.name, error.code));
     }
 }