DevTools: move session logic from TracingModel to TimelineModel

Source/devtools/front_end/sdk/TracingModel.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.BackingStorage} backingStorage
  */
@@ skipping 37 matching lines @@
 }
 
 WebInspector.TracingModel.TopLevelEventCategory = "toplevel";
 WebInspector.TracingModel.DevToolsMetadataEventCategory = "disabled-by-default-devtools.timeline";
 WebInspector.TracingModel.DevToolsTimelineEventCategory = "disabled-by-default-devtools.timeline";
 
 WebInspector.TracingModel.ConsoleEventCategory = "blink.console";
 
 WebInspector.TracingModel.FrameLifecycleEventCategory = "cc,devtools";
 
-WebInspector.TracingModel.DevToolsMetadataEvent = {
-    TracingStartedInPage: "TracingStartedInPage",
-    TracingSessionIdForWorker: "TracingSessionIdForWorker",
-};
-
 WebInspector.TracingModel._nestableAsyncEventsString =
     WebInspector.TracingModel.Phase.NestableAsyncBegin +
     WebInspector.TracingModel.Phase.NestableAsyncEnd +
     WebInspector.TracingModel.Phase.NestableAsyncInstant;
 
 WebInspector.TracingModel._legacyAsyncEventsString =
     WebInspector.TracingModel.Phase.AsyncBegin +
     WebInspector.TracingModel.Phase.AsyncEnd +
     WebInspector.TracingModel.Phase.AsyncStepInto +
     WebInspector.TracingModel.Phase.AsyncStepPast;
 
 WebInspector.TracingModel._flowEventsString =
     WebInspector.TracingModel.Phase.FlowBegin +
     WebInspector.TracingModel.Phase.FlowStep +
     WebInspector.TracingModel.Phase.FlowEnd;
 
-WebInspector.TracingModel._rendererMainThreadName = "CrRendererMain";
-
 WebInspector.TracingModel._asyncEventsString = WebInspector.TracingModel._nestableAsyncEventsString + WebInspector.TracingModel._legacyAsyncEventsString;
 
 /**
  * @param {string} phase
  * @return {boolean}
  */
 WebInspector.TracingModel.isNestableAsyncPhase = function(phase)
 {
     return WebInspector.TracingModel._nestableAsyncEventsString.indexOf(phase) >= 0;
 }
@@ skipping 57 matching lines @@
     finishWriting: function() { },
 
     reset: function() { },
 }
 
 
 WebInspector.TracingModel.prototype = {
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
-    devtoolsPageMetadataEvents: function()
+    devToolsMetadataEvents: function()
     {
-        return this._devtoolsPageMetadataEvents;
+        return this._devToolsMetadataEvents;
     },
 
     /**
-     * @return {!Array.<!WebInspector.TracingModel.Event>}
-     */
-    devtoolsWorkerMetadataEvents: function()
-    {
-        return this._devtoolsWorkerMetadataEvents;
-    },
-
-    /**
-     * @return {?string}
-     */
-    sessionId: function()
-    {
-        return this._sessionId;
-    },
-
-    /**
      * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      */
     setEventsForTest: function(events)
     {
         this.reset();
         this.addEvents(events);
         this.tracingComplete();
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      */
     addEvents: function(events)
     {
         for (var i = 0; i < events.length; ++i)
             this._addEvent(events[i]);
     },
 
     tracingComplete: function()
     {
-        this._processMetadataEvents();
         this._processPendingAsyncEvents();
         this._backingStorage.finishWriting();
         for (var process of Object.values(this._processById)) {
             for (var thread of Object.values(process._threads))
                 thread.tracingComplete();
         }
     },
 
     reset: function()
     {
         /** @type {!Object.<(number|string), !WebInspector.TracingModel.Process>} */
         this._processById = {};
         this._processByName = new Map();
         this._minimumRecordTime = 0;
         this._maximumRecordTime = 0;
-        this._sessionId = null;
-        this._devtoolsPageMetadataEvents = [];
-        this._devtoolsWorkerMetadataEvents = [];
+        this._devToolsMetadataEvents = [];
         this._backingStorage.reset();
         this._appendDelimiter = false;
-        this._loadedFromFile = false;
         /** @type {!Array<!WebInspector.TracingModel.Event>} */
         this._asyncEvents = [];
         /** @type {!Map<string, !WebInspector.TracingModel.AsyncEvent>} */
         this._openAsyncEvents = new Map();
         /** @type {!Map<string, !Array<!WebInspector.TracingModel.AsyncEvent>>} */
         this._openNestableAsyncEvents = new Map();
         /** @type {!Map<string, !Set<string>>} */
         this._parsedCategories = new Map();
     },
 
+

[alph, 2015/09/01 21:11:41]

revert plz

     /**
       * @param {!WebInspector.TracingManager.EventPayload} payload
       */
     _addEvent: function(payload)
     {
         var process = this._processById[payload.pid];
         if (!process) {
             process = new WebInspector.TracingModel.Process(this, payload.pid);
             this._processById[payload.pid] = process;
         }
@@ skipping 21 matching lines @@
             this._maximumRecordTime = Math.max(this._maximumRecordTime, endTimeStamp);
             var event = process._addEvent(payload);
             if (!event)
                 return;
             // Build async event when we've got events from all threads & processes, so we can sort them and process in the
             // chronological order. However, also add individual async events to the thread flow (above), so we can easily
             // display them on the same chart as other events, should we choose so.
             if (WebInspector.TracingModel.isAsyncPhase(payload.ph))
                 this._asyncEvents.push(event);
             event._setBackingStorage(backingStorage);
-            if (event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInPage &&
-                event.hasCategory(WebInspector.TracingModel.DevToolsMetadataEventCategory)) {
-                this._devtoolsPageMetadataEvents.push(event);
-            }
-            if (event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingSessionIdForWorker &&
-                event.hasCategory(WebInspector.TracingModel.DevToolsMetadataEventCategory)) {
-                this._devtoolsWorkerMetadataEvents.push(event);
-            }
+            if (event.hasCategory(WebInspector.TracingModel.DevToolsMetadataEventCategory))
+                this._devToolsMetadataEvents.push(event);
             return;
         }
         switch (payload.name) {
         case WebInspector.TracingModel.MetadataEvent.ProcessSortIndex:
             process._setSortIndex(payload.args["sort_index"]);
             break;
         case WebInspector.TracingModel.MetadataEvent.ProcessName:
             var processName = payload.args["name"];
             process._setName(processName);
             this._processByName.set(processName, process);
             break;
         case WebInspector.TracingModel.MetadataEvent.ThreadSortIndex:
             process.threadById(payload.tid)._setSortIndex(payload.args["sort_index"]);
             break;
         case WebInspector.TracingModel.MetadataEvent.ThreadName:
             process.threadById(payload.tid)._setName(payload.args["name"]);
             break;
         }
     },
 
-    _processMetadataEvents: function()
-    {
-        this._devtoolsPageMetadataEvents.sort(WebInspector.TracingModel.Event.compareStartTime);
-        if (!this._devtoolsPageMetadataEvents.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.TracingModel.DevToolsMetadataEvent.TracingStartedInPage + " event not found.");
-                return;
-            }
-            this._devtoolsPageMetadataEvents.push(pageMetaEvent);
-        }
-        var sessionId = this._devtoolsPageMetadataEvents[0].args["sessionId"] || this._devtoolsPageMetadataEvents[0].args["data"]["sessionId"];
-        this._sessionId = sessionId;
-
-        var mismatchingIds = {};
-        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[id] = true;
-            return false;
-        }
-        this._devtoolsPageMetadataEvents = this._devtoolsPageMetadataEvents.filter(checkSessionId);
-        this._devtoolsWorkerMetadataEvents = this._devtoolsWorkerMetadataEvents.filter(checkSessionId);
-
-        var idList = Object.keys(mismatchingIds);
-        if (idList.length)
-            WebInspector.console.error("Timeline recording was started in more than one page simultaneously. Session id mismatch: " + this._sessionId + " and " + idList + ".");
-    },
-
-    /**
-     * @return {?WebInspector.TracingModel.Event}
-     */
-    _makeMockPageMetadataEvent: function()
-    {
-        var rendererMainThreadName = WebInspector.TracingModel._rendererMainThreadName;
-        // FIXME: pick up the first renderer process for now.
-        var process = Object.values(this._processById).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.TracingModel.DevToolsMetadataEvent.TracingStartedInPage,
-            WebInspector.TracingModel.Phase.Metadata,
-            this._minimumRecordTime, thread);
-        pageMetaEvent.addArgs({"data": {"sessionId": "mockSessionId"}});
-        return pageMetaEvent;
-    },
-
     /**
      * @return {number}
      */
     minimumRecordTime: function()
     {
         return this._minimumRecordTime;
     },
 
     /**
      * @return {number}
@@ skipping 138 matching lines @@
         if (!parsedCategories) {
             parsedCategories = new Set(str.split(","));
             this._parsedCategories.set(str, parsedCategories);
         }
         return parsedCategories;
     }
 }
 
 /**
  * @constructor
- * @param {!WebInspector.TracingModel} tracingModel
- */
-WebInspector.TracingModel.Loader = function(tracingModel)
-{
-    this._tracingModel = tracingModel;
-    this._firstChunkReceived = false;
-}
-
-WebInspector.TracingModel.Loader.prototype = {
-    /**
-     * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
-     */
-    loadNextChunk: function(events)
-    {
-        if (!this._firstChunkReceived) {
-            this._tracingModel.reset();
-            this._firstChunkReceived = true;
-        }
-        this._tracingModel.addEvents(events);
-    },
-
-    finish: function()
-    {
-        this._tracingModel._loadedFromFile = true;
-        this._tracingModel.tracingComplete();
-    }
-}
-
-
-/**
- * @constructor
  * @param {string} categories
  * @param {string} name
  * @param {!WebInspector.TracingModel.Phase} phase
  * @param {number} startTime
  * @param {!WebInspector.TracingModel.Thread} thread
  */
 WebInspector.TracingModel.Event = function(categories, name, phase, startTime, thread)
 {
     /** @type {string} */
     this.categoriesString = categories;
@@ skipping 382 matching lines @@
     WebInspector.TracingModel.NamedObject.call(this);
     this._process = process;
     this._setName("Thread " + id);
     this._events = [];
     this._asyncEvents = [];
     this._id = id;
     this._model = process._model;
 }
 
 WebInspector.TracingModel.Thread.prototype = {
-    /**
-     * @return {?WebInspector.Target}
-     */
-    target: function()
-    {
-        //FIXME: correctly specify target
-        if (this.name() === WebInspector.TracingModel._rendererMainThreadName)
-            return WebInspector.targetManager.targets()[0] || null;
-        else
-            return null;
-    },
-
     tracingComplete: function()
     {
         this._asyncEvents.stableSort(WebInspector.TracingModel.Event.compareStartTime);
         this._events.stableSort(WebInspector.TracingModel.Event.compareStartTime);
         var phases = WebInspector.TracingModel.Phase;
         var stack = [];
         for (var i = 0; i < this._events.length; ++i) {
             var e = this._events[i];
             e.ordinal = i;
             switch (e.phase) {
@@ skipping 80 matching lines @@
     /**
      * @return {!Array.<!WebInspector.TracingModel.AsyncEvent>}
      */
     asyncEvents: function()
     {
         return this._asyncEvents;
     },
 
     __proto__: WebInspector.TracingModel.NamedObject.prototype
 }