[DevTools] Send heap snapshot to the frontend immediatly when it is ready

Source/devtools/front_end/HeapSnapshotView.js

 /*
  * Copyright (C) 2011 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 778 matching lines @@
      */
     addHeapSnapshotChunk: function(uid, chunk)
     {
         this._genericCaller("addHeapSnapshotChunk");
     },
 
     /**
      * @override
      * @param {number} done
      * @param {number} total
+     * @param {boolean=} finished
      */
-    reportHeapSnapshotProgress: function(done, total)
+    reportHeapSnapshotProgress: function(done, total, finished)
     {
         this._genericCaller("reportHeapSnapshotProgress");
     },
 
     /**
      * @override
      */
     resetProfiles: function()
     {
         this._genericCaller("resetProfiles");
     }
 }
 
 WebInspector.HeapProfilerDispatcher._dispatcher = new WebInspector.HeapProfilerDispatcher();
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileType}
  * @implements {HeapProfilerAgent.Dispatcher}
+ * @param {string=} id
+ * @param {string=} title
  */
-WebInspector.HeapSnapshotProfileType = function()
+WebInspector.HeapSnapshotProfileType = function(id, title)
 {
-    WebInspector.ProfileType.call(this, WebInspector.HeapSnapshotProfileType.TypeId, WebInspector.UIString("Take Heap Snapshot"));
+    WebInspector.ProfileType.call(this, id || WebInspector.HeapSnapshotProfileType.TypeId, title || WebInspector.UIString("Take Heap Snapshot"));
     WebInspector.HeapProfilerDispatcher._dispatcher.register(this);
+
+    this._nextSnapshotId = 1;
 }
 
 WebInspector.HeapSnapshotProfileType.TypeId = "HEAP";
 WebInspector.HeapSnapshotProfileType.SnapshotReceived = "SnapshotReceived";
 
 WebInspector.HeapSnapshotProfileType.prototype = {
     /**
      * @override
      * @return {string}
      */
@@ skipping 61 matching lines @@
      */
     createProfileLoadedFromFile: function(title)
     {
         return new WebInspector.HeapProfileHeader(this, title);
     },
 
     _takeHeapSnapshot: function(callback)
     {
         if (this.profileBeingRecorded())
             return;
-        this._profileBeingRecorded = new WebInspector.HeapProfileHeader(this, WebInspector.UIString("Snapshotting\u2026"));
+        var id = this._nextSnapshotId++;
+        this._profileBeingRecorded = new WebInspector.HeapProfileHeader(this, WebInspector.UIString("Snapshotting\u2026"), id);
         this.addProfile(this._profileBeingRecorded);
-        HeapProfilerAgent.takeHeapSnapshot(true, callback);
+        /**
+         * @param {?string} error
+         * @this {WebInspector.HeapSnapshotProfileType}
+         */
+        function didTakeHeapSnapshot(error)
+        {
+            var profile = this._profileBeingRecorded;
+            profile.title = WebInspector.UIString("Snapshot %d", profile.uid);
+            profile._finishLoad();
+            this._profileBeingRecorded = null;
+            WebInspector.panels.profiles.showProfile(profile);
+            profile.existingView()._refreshView();
+            callback();
+        }
+        HeapProfilerAgent.takeHeapSnapshot(true, didTakeHeapSnapshot.bind(this));
     },
 
     /**
      * @param {!HeapProfilerAgent.ProfileHeader} profileHeader
      */
     addProfileHeader: function(profileHeader)
     {
         var profile = this.profileBeingRecorded();
         if (!profile)
             return;
@@ skipping 11 matching lines @@
         profile.existingView()._refreshView();
     },
 
     /**
      * @override
      * @param {number} uid
      * @param {string} chunk
      */
     addHeapSnapshotChunk: function(uid, chunk)
     {
-        var profile = this.getProfile(uid);
-        if (profile)
-            profile.transferChunk(chunk);
+        if (!this.profileBeingRecorded())
+            return;
+        this.profileBeingRecorded().transferChunk(chunk);
     },
 
     /**
      * @override
      * @param {number} done
      * @param {number} total
+     * @param {boolean=} finished
      */
-    reportHeapSnapshotProgress: function(done, total)
+    reportHeapSnapshotProgress: function(done, total, finished)
     {
         var profile = this.profileBeingRecorded();
         if (!profile)
             return;
         profile.sidebarElement.subtitle = WebInspector.UIString("%.0f%", (done / total) * 100);
         profile.sidebarElement.wait = true;
+        if (finished)
+            profile._prepareToLoad();
     },
 
     /**
      * @override
      */
     resetProfiles: function()
     {
         this._reset();
     },
 
@@ skipping 18 matching lines @@
     __proto__: WebInspector.ProfileType.prototype
 }
 
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotProfileType}
  */
 WebInspector.TrackingHeapSnapshotProfileType = function()
 {
-    WebInspector.ProfileType.call(this, WebInspector.TrackingHeapSnapshotProfileType.TypeId, WebInspector.UIString("Record Heap Allocations"));
-    WebInspector.HeapProfilerDispatcher._dispatcher.register(this);
+    WebInspector.HeapSnapshotProfileType.call(this, WebInspector.TrackingHeapSnapshotProfileType.TypeId, WebInspector.UIString("Record Heap Allocations"));
 }
 
 WebInspector.TrackingHeapSnapshotProfileType.TypeId = "HEAP-RECORD";
 
 WebInspector.TrackingHeapSnapshotProfileType.HeapStatsUpdate = "HeapStatsUpdate";
 WebInspector.TrackingHeapSnapshotProfileType.TrackingStarted = "TrackingStarted";
 WebInspector.TrackingHeapSnapshotProfileType.TrackingStopped = "TrackingStopped";
 
 WebInspector.TrackingHeapSnapshotProfileType.prototype = {
 
@@ skipping 90 matching lines @@
         };
         this._profileBeingRecorded._profileSamples = this._profileSamples;
         this._recording = true;
         this.addProfile(this._profileBeingRecorded);
         HeapProfilerAgent.startTrackingHeapObjects();
         this.dispatchEventToListeners(WebInspector.TrackingHeapSnapshotProfileType.TrackingStarted);
     },
 
     _stopRecordingProfile: function()
     {
-        HeapProfilerAgent.stopTrackingHeapObjects(true);
+
+        var profile = this._profileBeingRecorded;
+        var title = WebInspector.UIString("Snapshotting\u2026");
+        profile.title = title;
+        profile.sidebarElement.mainTitle = title;
+        /**
+         * @param {?string} error
+         * @this {WebInspector.HeapSnapshotProfileType}
+         */
+        function didTakeHeapSnapshot(error)
+        {
+            profile.uid = this._nextSnapshotId++;
+            var title = WebInspector.UIString("Snapshot %d", profile.uid);
+            profile.title = title;
+            profile.sidebarElement.mainTitle = title;
+            profile._finishLoad();
+            this._profileSamples = null;
+            this._profileBeingRecorded = null;
+            WebInspector.panels.profiles.showProfile(profile);
+            profile.existingView()._refreshView();
+        }
+
+        HeapProfilerAgent.stopTrackingHeapObjects(true, didTakeHeapSnapshot.bind(this));
         this._recording = false;
         this.dispatchEventToListeners(WebInspector.TrackingHeapSnapshotProfileType.TrackingStopped);
     },
 
     _toggleRecording: function()
     {
         if (this._recording)
             this._stopRecordingProfile();
         else
             this._startRecordingProfile();
@@ skipping 88 matching lines @@
      * @param {function(!WebInspector.HeapSnapshotProxy):void} callback
      */
     load: function(callback)
     {
         if (this.uid === -1)
             return;
         if (this._snapshotProxy) {
             callback(this._snapshotProxy);
             return;
         }
-
-        this._numberOfChunks = 0;
-        if (!this._receiver) {
-            this._setupWorker();
-            this._transferHandler = new WebInspector.BackendSnapshotLoader(this);
-            this.sidebarElement.subtitle = WebInspector.UIString("Loading\u2026");
-            this.sidebarElement.wait = true;
-            this._transferSnapshot();
-        }
-        console.assert(this._receiver);
         this._loadCallbacks.push(callback);
     },
 
-    _transferSnapshot: function()
+    _prepareToLoad: function()
     {
-        /**
-         * @this {WebInspector.HeapProfileHeader}
-         */
-        function finishTransfer()
-        {
-            if (this._transferHandler) {
-                this._transferHandler.finishTransfer();
-                this._totalNumberOfChunks = this._transferHandler._totalNumberOfChunks;
-            }
-            if (this._bufferedWriter) {
-                this._bufferedWriter.close(this._didWriteToTempFile.bind(this));
-                this._bufferedWriter = null;
-            }
+        console.assert(!this._receiver, "Already loading");
+        this._numberOfChunks = 0;
+        this._setupWorker();
+        this._transferHandler = new WebInspector.BackendSnapshotLoader(this);
+        this.sidebarElement.subtitle = WebInspector.UIString("Loading\u2026");
+        this.sidebarElement.wait = true;
+    },
+
+    _finishLoad: function()
+    {
+        if (this._transferHandler) {
+            this._transferHandler.finishTransfer();
+            this._totalNumberOfChunks = this._transferHandler._totalNumberOfChunks;
         }
-        HeapProfilerAgent.getHeapSnapshot(this.uid, finishTransfer.bind(this));
+        if (this._bufferedWriter) {
+            this._bufferedWriter.close(this._didWriteToTempFile.bind(this));
+            this._bufferedWriter = null;
+        }
     },
 
     _didWriteToTempFile: function(tempFile)
     {
         this._tempFile = tempFile;
         if (!tempFile)
             this._failedToCreateTempFile = true;
         if (this._onTempFileReady) {
             this._onTempFileReady();
             this._onTempFileReady = null;
@@ skipping 671 matching lines @@
     },
 
     /**
      * @return {number}
      */
     boundarySpan: function()
     {
         return this._maximumBoundaries - this._minimumBoundaries;
     }
 }