[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 763 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;
+            callback();
+        }
+        HeapProfilerAgent.takeHeapSnapshot(true, didTakeHeapSnapshot.bind(this));
     },
 
     /**
      * @param {!HeapProfilerAgent.ProfileHeader} profileHeader
      */
     addProfileHeader: function(profileHeader)
     {
         var profile = this.profileBeingRecorded();
         if (!profile)
             return;
@@ skipping 12 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 19 matching lines @@
 }
 
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotProfileType}
  * @param {!WebInspector.ProfilesPanel} profilesPanel
  */
 WebInspector.TrackingHeapSnapshotProfileType = function(profilesPanel)
 {
-    WebInspector.ProfileType.call(this, WebInspector.TrackingHeapSnapshotProfileType.TypeId, WebInspector.UIString("Record Heap Allocations"));
+    WebInspector.HeapSnapshotProfileType.call(this, WebInspector.TrackingHeapSnapshotProfileType.TypeId, WebInspector.UIString("Record Heap Allocations"));
     this._profilesPanel = profilesPanel;
-    WebInspector.HeapProfilerDispatcher._dispatcher.register(this);
 }
 
 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}

[alph, 2013/12/23 14:06:59]

WebInspector.TrackingHeapSnapshotProfileType

+         */
+        function didTakeHeapSnapshot(error)

[alph, 2013/12/23 14:06:59]

It seems to have a bunch of similar code to its friend from
HeapSnapshotProfileType. Perhaps it's worth to extract the common part. wdyt?

+        {
+            profile.uid = this._nextSnapshotId++;
+            var title = WebInspector.UIString("Snapshot %d", profile.uid);
+            profile.title = title;
+            profile.sidebarElement.mainTitle = title;
+            WebInspector.log("didTakeHeapSnapshot " + this._profileBeingRecorded);

[alph, 2013/12/23 14:06:59]

is that intended?

+            profile._finishLoad();
+            this._profileSamples = null;
+            this._profileBeingRecorded = null;
+            WebInspector.panels.profiles._showProfile(profile);

[alph, 2013/12/23 14:06:59]

Event broadcasting would look more elegant here. wdyt?

+            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 70 matching lines @@
      */
     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();
-        }
         var loaderProxy = /** @type {?WebInspector.HeapSnapshotLoaderProxy} */ (this._receiver);
         console.assert(loaderProxy);
         loaderProxy.addConsumer(callback);
     },
 
+    _prepareToLoad: function()
+    {
+        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;
+        }
+    },
+
     _transferSnapshot: function()
     {
         /**
          * @this {WebInspector.HeapProfileHeader}
          */
         function finishTransfer()
         {
             if (this._transferHandler) {
                 this._transferHandler.finishTransfer();
                 this._totalNumberOfChunks = this._transferHandler._totalNumberOfChunks;
@@ skipping 636 matching lines @@
     zeroTime: function()
     {
         return this._minimumBoundaries;
     },
 
     boundarySpan: function()
     {
         return this._maximumBoundaries - this._minimumBoundaries;
     }
 }