DevTools: Support JS frames save/load for tracing timeline.

Source/devtools/front_end/timeline/TracingTimelineModel.js

 // Copyright 2014 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
  * @param {!WebInspector.TracingManager} tracingManager
  * @param {!WebInspector.TracingModel} tracingModel
  * @param {!WebInspector.TimelineModel.Filter} recordFilter
  * @extends {WebInspector.TimelineModel}
@@ skipping 51 matching lines @@
     MarkFirstPaint: "MarkFirstPaint",
 
     TimeStamp: "TimeStamp",
     ConsoleTime: "ConsoleTime",
 
     ResourceSendRequest: "ResourceSendRequest",
     ResourceReceiveResponse: "ResourceReceiveResponse",
     ResourceReceivedData: "ResourceReceivedData",
     ResourceFinish: "ResourceFinish",
 
+    CpuProfile: "CpuProfile",

[yurys, 2014/10/02 16:17:17]

Can you move this event at the end and add a comment that it is created on the
front-end only.

     FunctionCall: "FunctionCall",
     GCEvent: "GCEvent",
     JSFrame: "JSFrame",
     JSSample: "JSSample",
 
     UpdateCounters: "UpdateCounters",
 
     RequestAnimationFrame: "RequestAnimationFrame",
     CancelAnimationFrame: "CancelAnimationFrame",
     FireAnimationFrame: "FireAnimationFrame",
@@ skipping 65 matching lines @@
                 disabledByDefault("devtools.timeline.layers"),
                 disabledByDefault("devtools.timeline.picture"),
                 disabledByDefault("blink.graphics_context_annotations")]);
         }
         var categories = categoriesArray.join(",");
         this._startRecordingWithCategories(categories);
     },
 
     stopRecording: function()
     {
-        this._stopCallbackBarrier = new CallbackBarrier();
         if (this._jsProfilerStarted) {
+            this._stopCallbackBarrier = new CallbackBarrier();
             this._currentTarget.profilerAgent().stop(this._stopCallbackBarrier.createCallback(this._didStopRecordingJSSamples.bind(this)));
             this._jsProfilerStarted = false;
         }
         this._tracingManager.stop();
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      */
     setEventsForTest: function(events)
@@ skipping 34 matching lines @@
      * @param {!WebInspector.Event} event
      */
     _onEventsCollected: function(event)
     {
         var traceEvents = /** @type {!Array.<!WebInspector.TracingManager.EventPayload>} */ (event.data);
         this._tracingModel.addEvents(traceEvents);
     },
 
     _onTracingComplete: function()
     {
-        this._tracingModel.tracingComplete();
         if (this._stopCallbackBarrier)
             this._stopCallbackBarrier.callWhenDone(this._didStopRecordingTraceEvents.bind(this));
         else
             this._didStopRecordingTraceEvents();
     },
 
     /**
      * @param {?Protocol.Error} error
      * @param {?ProfilerAgent.CPUProfile} cpuProfile
      */
     _didStopRecordingJSSamples: function(error, cpuProfile)
     {
         if (error)
             WebInspector.console.error(error);
-        this._cpuProfile = cpuProfile;
+        this._recordedCpuProfile = cpuProfile;
     },
 
     _didStopRecordingTraceEvents: function()
     {
         this._stopCallbackBarrier = null;
+
+        if (this._recordedCpuProfile) {
+            this._injectCpuProfileEvent(this._recordedCpuProfile);
+            this._recordedCpuProfile = null;
+        }
+        this._tracingModel.tracingComplete();
+
         var events = this._tracingModel.devtoolsPageMetadataEvents();
         var workerMetadataEvents = this._tracingModel.devtoolsWorkerMetadataEvents();
 
         this._resetProcessingState();
         for (var i = 0, length = events.length; i < length; i++) {
             var event = events[i];
             var process = event.thread.process();
             var startTime = event.startTime;
 
             var endTime = Infinity;
             if (i + 1 < length)
                 endTime = events[i + 1].startTime;
 
             var threads = process.sortedThreads();
             for (var j = 0; j < threads.length; j++) {
                 var thread = threads[j];
                 if (thread.name() === "WebCore: Worker" && !workerMetadataEvents.some(function(e) { return e.args["data"]["workerThreadId"] === thread.id(); }))
                     continue;
                 this._processThreadEvents(startTime, endTime, event.thread, thread);
             }
         }
         this._resetProcessingState();
 
         this._inspectedTargetEvents.sort(WebInspector.TracingModel.Event.compareStartTime);
 
         if (this._cpuProfile) {
-            var jsSamples = WebInspector.TimelineJSProfileProcessor.generateTracingEventsFromCpuProfile(this, this._cpuProfile);
-            this._inspectedTargetEvents = this._inspectedTargetEvents.mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime);
-            this._setMainThreadEvents(this.mainThreadEvents().mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime));
+            this._processCpuProfile(this._cpuProfile);
             this._cpuProfile = null;
         }
-
         this._buildTimelineRecords();
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordingStopped);
     },
 
     /**
+     * @param {!ProfilerAgent.CPUProfile} cpuProfile
+     */
+    _injectCpuProfileEvent: function(cpuProfile)
+    {
+        var metaEvent = this._tracingModel.devtoolsPageMetadataEvents().peekLast();
+        if (!metaEvent)
+            return;
+        var cpuProfileEvent = /** @type {!WebInspector.TracingManager.EventPayload} */ ({
+            cat: WebInspector.TracingModel.DevToolsMetadataEventCategory,
+            ph: WebInspector.TracingModel.Phase.Instant,
+            ts: this._tracingModel.maximumRecordTime() * 1000,
+            pid: metaEvent.thread.process().id(),
+            tid: metaEvent.thread.id(),
+            name: WebInspector.TracingTimelineModel.RecordType.CpuProfile,
+            args: { data: { cpuProfile: cpuProfile } }
+        });
+        this._tracingModel.addEvents([cpuProfileEvent]);
+    },
+
+    /**
+     * @param {!ProfilerAgent.CPUProfile} cpuProfile
+     */
+    _processCpuProfile: function(cpuProfile)
+    {
+        var jsSamples = WebInspector.TimelineJSProfileProcessor.generateTracingEventsFromCpuProfile(this, cpuProfile);
+        this._inspectedTargetEvents = this._inspectedTargetEvents.mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime);
+        this._setMainThreadEvents(this.mainThreadEvents().mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime));
+    },
+
+    /**
      * @return {number}
      */
     minimumRecordTime: function()
     {
         return this._tracingModel.minimumRecordTime();
     },
 
     /**
      * @return {number}
      */
@@ skipping 230 matching lines @@
         if (this._currentScriptEvent && event.startTime > this._currentScriptEvent.endTime)
             this._currentScriptEvent = null;
 
         switch (event.name) {
         case recordTypes.CallStack:
             var lastMainThreadEvent = this.mainThreadEvents().peekLast();
             if (lastMainThreadEvent && event.args["stack"] && event.args["stack"].length)
                 lastMainThreadEvent.stackTrace = event.args["stack"];
             break;
 
+        case recordTypes.CpuProfile:
+            this._cpuProfile = event.args["data"]["cpuProfile"];
+            break;
+
         case recordTypes.ResourceSendRequest:
             this._sendRequestEvents[event.args["data"]["requestId"]] = event;
             event.imageURL = event.args["data"]["url"];
             break;
 
         case recordTypes.ResourceReceiveResponse:
         case recordTypes.ResourceReceivedData:
         case recordTypes.ResourceFinish:
             event.initiator = this._sendRequestEvents[event.args["data"]["requestId"]];
             if (event.initiator)
@@ skipping 526 matching lines @@
      * @param {!WebInspector.ChunkedReader} reader
      */
     onChunkTransferred: function(reader) { },
 
     /**
      * @param {!WebInspector.ChunkedReader} reader
      * @param {!Event} event
      */
     onError: function(reader, event) { },
 }