DevTools: move session logic from TracingModel to TimelineModel

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 146 matching lines @@
 WebInspector.TimelineModel.Events = {
     RecordsCleared: "RecordsCleared",
     RecordingStarted: "RecordingStarted",
     RecordingStopped: "RecordingStopped",
     RecordFilterChanged: "RecordFilterChanged",
     BufferUsage: "BufferUsage",
     RetrieveEventsProgress: "RetrieveEventsProgress"
 }
 
 WebInspector.TimelineModel.MainThreadName = "main";
-
 WebInspector.TimelineModel.WorkerThreadName = "DedicatedWorker Thread";
+WebInspector.TimelineModel.RendererMainThreadName = "CrRendererMain";
 
 /**
  * @param {!Array.<!WebInspector.TracingModel.Event>} events
  * @param {function(!WebInspector.TracingModel.Event)} onStartEvent
  * @param {function(!WebInspector.TracingModel.Event)} onEndEvent
  * @param {function(!WebInspector.TracingModel.Event,?WebInspector.TracingModel.Event)=} onInstantEvent
  */
 WebInspector.TimelineModel.forEachEvent = function(events, onStartEvent, onEndEvent, onInstantEvent)
 {
     var stack = [];
@@ skipping 38 matching lines @@
             if (postOrderCallback && postOrderCallback(record, depth))
                 return true;
         }
         return false;
     }
     return processRecords(recordsArray, 0);
 }
 
 WebInspector.TimelineModel.TransferChunkLengthBytes = 5000000;
 
+WebInspector.TimelineModel.DevToolsMetadataEvent = {
+    TracingStartedInPage: "TracingStartedInPage",
+    TracingSessionIdForWorker: "TracingSessionIdForWorker",
+};
+
 /**
  * @constructor
  * @param {string} name
  */
 WebInspector.TimelineModel.VirtualThread = function(name)
 {
     this.name = name;
     /** @type {!Array<!WebInspector.TracingModel.Event>} */
     this.events = [];
     /** @type {!Map<!WebInspector.AsyncEventGroup, !Array<!WebInspector.TracingModel.AsyncEvent>>} */
@@ skipping 51 matching lines @@
     {
         var initiator = this._event.initiator;
         return initiator ? initiator._timelineRecord : null;
     },
 
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
-        return this._event.thread.target();
+        var threadName = this._event.thread.name();
+        //FIXME: correctly specify target
+        return threadName === WebInspector.TimelineModel.RendererMainThreadName ? WebInspector.targetManager.targets()[0] || null : null;
     },
 
     /**
      * @return {number}
      */
     selfTime: function()
     {
         return this._event.selfTime;
     },
 
@@ skipping 11 matching lines @@
     startTime: function()
     {
         return this._event.startTime;
     },
 
     /**
      * @return {string}
      */
     thread: function()
     {
-        if (this._event.thread.name() === "CrRendererMain")
+        if (this._event.thread.name() === WebInspector.TimelineModel.RendererMainThreadName)
             return WebInspector.TimelineModel.MainThreadName;
         return this._event.thread.name();
     },
 
     /**
      * @return {number}
      */
     endTime: function()
     {
         return this._endTime || this._event.endTime || this._event.startTime;
@@ skipping 100 matching lines @@
 
     /**
      * @return {!WebInspector.TimelineModel}
      */
     timelineModel: function()
     {
         return this._model;
     }
 }
 
+/** @typedef {!{page: !Array<!WebInspector.TracingModel.Event>, workers: !Array<!WebInspector.TracingModel.Event>}} */
+WebInspector.TimelineModel.MetadataEvents;
+
 WebInspector.TimelineModel.prototype = {
     /**
      * @param {boolean} captureCauses
      * @param {boolean} enableJSSampling
      * @param {boolean} captureMemory
      * @param {boolean} capturePictures
      * @param {boolean} captureFilmStrip
      */
     startRecording: function(captureCauses, enableJSSampling, captureMemory, capturePictures, captureFilmStrip)
     {
@@ skipping 110 matching lines @@
 
     /**
      * @return {!Array.<!WebInspector.TimelineModel.Record>}
      */
     records: function()
     {
         return this._records;
     },
 
     /**
+     * @return {?string}
+     */
+    sessionId: function()
+    {
+        return this._sessionId;
+    },
+
+    /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         // FIXME: Consider returning null for loaded traces.
         return this._targets[0];
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
@@ skipping 159 matching lines @@
     {
         if (!cpuProfile)
             return;
         if (!this._cpuProfiles)
             this._cpuProfiles = new Map();
         this._cpuProfiles.set(targetId, cpuProfile);
     },
 
     _didStopRecordingTraceEvents: function()
     {
-        this._injectCpuProfileEvents();
+        var metadataEvents = this._processMetadataEvents();
+        this._injectCpuProfileEvents(metadataEvents);
         this._tracingModel.tracingComplete();
 
-        var metaEvents = this._tracingModel.devtoolsPageMetadataEvents();
-        var workerMetadataEvents = this._tracingModel.devtoolsWorkerMetadataEvents();
-
         this._resetProcessingState();
         var startTime = 0;
-        for (var i = 0, length = metaEvents.length; i < length; i++) {
-            var metaEvent = metaEvents[i];
+        for (var i = 0, length = metadataEvents.page.length; i < length; i++) {
+            var metaEvent = metadataEvents.page[i];
             var process = metaEvent.thread.process();
-            var endTime = i + 1 < length ? metaEvents[i + 1].startTime : Infinity;
+            var endTime = i + 1 < length ? metadataEvents.page[i + 1].startTime : Infinity;
             this._currentPage = metaEvent.args["data"] && metaEvent.args["data"]["page"];
             for (var thread of process.sortedThreads()) {
-                if (thread.name() === WebInspector.TimelineModel.WorkerThreadName && !workerMetadataEvents.some(function(e) { return e.args["data"]["workerThreadId"] === thread.id(); }))
+                if (thread.name() === WebInspector.TimelineModel.WorkerThreadName && !metadataEvents.workers.some(function(e) { return e.args["data"]["workerThreadId"] === thread.id(); }))
                     continue;
                 this._processThreadEvents(startTime, endTime, metaEvent.thread, thread);
             }
             startTime = endTime;
         }
         this._inspectedTargetEvents.sort(WebInspector.TracingModel.Event.compareStartTime);
 
         this._cpuProfiles = null;
         this._buildTimelineRecords();
         this._buildGPUTasks();
         this._insertFirstPaintEvent();
         this._resetProcessingState();
 
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordingStopped);
     },
 
     /**
+     * @return {!WebInspector.TimelineModel.MetadataEvents}
+     */
+    _processMetadataEvents: function()
+    {
+        var metadataEvents = this._tracingModel.devToolsMetadataEvents();
+
+        var pageDevToolsMetadataEvents = [];
+        var workersDevToolsMetadataEvents = [];
+        for (var event of metadataEvents) {
+            if (event.name === WebInspector.TimelineModel.DevToolsMetadataEvent.TracingStartedInPage)
+                pageDevToolsMetadataEvents.push(event);
+            else if (event.name === WebInspector.TimelineModel.DevToolsMetadataEvent.TracingSessionIdForWorker)
+                workersDevToolsMetadataEvents.push(event);
+        }
+        if (!pageDevToolsMetadataEvents.length) {
+            // The trace is probably coming not from DevTools. Make a mock Metadata event.
+            var pageMetaEvent = this._loadedFromFile ? this._makeMockPageMetadataEvent() : null;
+            if (!pageMetaEvent) {
+                console.error(WebInspector.TimelineModel.DevToolsMetadataEvent.TracingStartedInPage + " event not found.");
+                return {page: [], workers: []};
+            }
+            pageDevToolsMetadataEvents.push(pageMetaEvent);
+        }
+        var sessionId = pageDevToolsMetadataEvents[0].args["sessionId"] || pageDevToolsMetadataEvents[0].args["data"]["sessionId"];
+        this._sessionId = sessionId;
+
+        var mismatchingIds = new Set();
+        /**
+         * @param {!WebInspector.TracingModel.Event} event
+         * @return {boolean}
+         */
+        function checkSessionId(event)
+        {
+            var args = event.args;
+            // FIXME: put sessionId into args["data"] for TracingStartedInPage event.
+            if (args["data"])
+                args = args["data"];
+            var id = args["sessionId"];
+            if (id === sessionId)
+                return true;
+            mismatchingIds.add(id);
+            return false;
+        }
+        var result = {
+            page: pageDevToolsMetadataEvents.filter(checkSessionId).sort(WebInspector.TracingModel.Event.compareStartTime),
+            workers: workersDevToolsMetadataEvents.filter(checkSessionId).sort(WebInspector.TracingModel.Event.compareStartTime)
+        };
+        if (mismatchingIds.size)
+            WebInspector.console.error("Timeline recording was started in more than one page simultaneously. Session id mismatch: " + this._sessionId + " and " + mismatchingIds.valuesArray() + ".");
+        return result;
+    },
+
+    /**
+     * @return {?WebInspector.TracingModel.Event}
+     */
+    _makeMockPageMetadataEvent: function()
+    {
+        var rendererMainThreadName = WebInspector.TimelineModel.RendererMainThreadName;
+        // FIXME: pick up the first renderer process for now.
+        var process = Object.values(this._tracingModel.sortedProcesses()).filter(function(p) { return p.threadByName(rendererMainThreadName); })[0];
+        var thread = process && process.threadByName(rendererMainThreadName);
+        if (!thread)
+            return null;
+        var pageMetaEvent = new WebInspector.TracingModel.Event(
+            WebInspector.TracingModel.DevToolsMetadataEventCategory,
+            WebInspector.TimelineModel.DevToolsMetadataEvent.TracingStartedInPage,
+            WebInspector.TracingModel.Phase.Metadata,
+            this._tracingModel.minimumRecordTime(), thread);
+        pageMetaEvent.addArgs({"data": {"sessionId": "mockSessionId"}});
+        return pageMetaEvent;
+    },
+
+    /**
      * @param {number} pid
      * @param {number} tid
      * @param {?ProfilerAgent.CPUProfile} cpuProfile
      */
     _injectCpuProfileEvent: function(pid, tid, cpuProfile)
     {
         if (!cpuProfile)
             return;
         var cpuProfileEvent = /** @type {!WebInspector.TracingManager.EventPayload} */ ({
             cat: WebInspector.TracingModel.DevToolsMetadataEventCategory,
             ph: WebInspector.TracingModel.Phase.Instant,
             ts: this._tracingModel.maximumRecordTime() * 1000,
             pid: pid,
             tid: tid,
             name: WebInspector.TimelineModel.RecordType.CpuProfile,
             args: { data: { cpuProfile: cpuProfile } }
         });
         this._tracingModel.addEvents([cpuProfileEvent]);
     },
 
-    _injectCpuProfileEvents: function()
+    /**
+     * @param {!WebInspector.TimelineModel.MetadataEvents} metadataEvents
+     */
+    _injectCpuProfileEvents: function(metadataEvents)
     {
         if (!this._cpuProfiles)
             return;
-        var mainMetaEvent = this._tracingModel.devtoolsPageMetadataEvents().peekLast();
+        var mainMetaEvent = metadataEvents.page.peekLast();
         if (!mainMetaEvent)
             return;
         var pid = mainMetaEvent.thread.process().id();
         var mainTarget = this._targets[0];
         var mainCpuProfile = this._cpuProfiles.get(mainTarget.id());
         this._injectCpuProfileEvent(pid, mainMetaEvent.thread.id(), mainCpuProfile);
-        var workerMetadataEvents = this._tracingModel.devtoolsWorkerMetadataEvents();
-        for (var metaEvent of workerMetadataEvents) {
+        for (var metaEvent of metadataEvents.workers) {
             var workerId = metaEvent.args["data"]["workerId"];
             var target = mainTarget.workerManager ? mainTarget.workerManager.targetByWorkerId(workerId) : null;
             if (!target)
                 continue;
             var cpuProfile = this._cpuProfiles.get(target.id());
             this._injectCpuProfileEvent(pid, metaEvent.args["data"]["workerThreadId"], cpuProfile);
         }
         this._cpuProfiles = null;
     },
 
@@ skipping 456 matching lines @@
         /** @type {!Array.<!WebInspector.TracingModel.Event>} */
         this._inspectedTargetEvents = [];
         /** @type {!Array.<!WebInspector.TimelineModel.Record>} */
         this._records = [];
         /** @type {!Array.<!WebInspector.TimelineModel.Record>} */
         this._mainThreadTasks = [];
         /** @type {!Array.<!WebInspector.TimelineModel.Record>} */
         this._gpuTasks = [];
         /** @type {!Array.<!WebInspector.TimelineModel.Record>} */
         this._eventDividerRecords = [];
+        /** @type {?string} */
+        this._sessionId = null;
+        this._loadedFromFile = false;
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordsCleared);
     },
 
     /**
      * @return {number}
      */
     minimumRecordTime: function()
     {
         return this._tracingModel.minimumRecordTime();
     },
@@ skipping 568 matching lines @@
 /**
  * @constructor
  * @implements {WebInspector.OutputStream}
  * @param {!WebInspector.TimelineModel} model
  * @param {!WebInspector.Progress} progress
  * @param {function()=} canceledCallback
  */
 WebInspector.TracingModelLoader = function(model, progress, canceledCallback)
 {
     this._model = model;
-    this._loader = new WebInspector.TracingModel.Loader(model._tracingModel);
 
     this._canceledCallback = canceledCallback;
     this._progress = progress;
     this._progress.setTitle(WebInspector.UIString("Loading"));
     this._progress.setTotalWork(WebInspector.TracingModelLoader._totalProgress);  // Unknown, will loop the values.
 
     this._state = WebInspector.TracingModelLoader.State.Initial;
     this._buffer = "";
     this._firstChunk = true;
     this._wasCanceledOnce = false;
@@ skipping 76 matching lines @@
 
         if (this._firstChunk) {
             this._firstChunk = false;
             if (this._looksLikeAppVersion(items[0])) {
                 this._reportErrorAndCancelLoading(WebInspector.UIString("Legacy Timeline format is not supported."));
                 return;
             }
         }
 
         try {
-            this._loader.loadNextChunk(items);
+            this._model._tracingModel.addEvents(items);
         } catch(e) {
             this._reportErrorAndCancelLoading(WebInspector.UIString("Malformed timeline data: %s", e.toString()));
             return;
         }
     },
 
     /**
      * @param {string=} message
      */
     _reportErrorAndCancelLoading: function(message)
@@ skipping 10 matching lines @@
     _looksLikeAppVersion: function(item)
     {
         return typeof item === "string" && item.indexOf("Chrome") !== -1;
     },
 
     /**
      * @override
      */
     close: function()
     {
-        this._loader.finish();
+        this._model._loadedFromFile = true;
         this._model.tracingComplete();
         if (this._progress)
             this._progress.done();
     }
 }
 
 /**
  * @constructor
  * @param {!WebInspector.OutputStream} stream
  * @implements {WebInspector.OutputStreamDelegate}
@@ skipping 335 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;
     }
 }