DevTools: extract TracingManager from TracingModel

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
  * @extends {WebInspector.Object}
  * @implements {WebInspector.TargetManager.Observer}
  */
-WebInspector.TracingModel = function()
+WebInspector.TracingManager = function()
 {
-    this.reset();
+    WebInspector.Object.call(this);
     this._active = false;
     WebInspector.targetManager.observeTargets(this);
 }
 
-WebInspector.TracingModel.Events = {
+WebInspector.TracingManager.Events = {
     "BufferUsage": "BufferUsage",
     "TracingStarted": "TracingStarted",
+    "EventsCollected": "EventsCollected",
     "TracingStopped": "TracingStopped",
     "TracingComplete": "TracingComplete"
 }
 
 /** @typedef {!{
         cat: string,
         pid: number,
         tid: number,
         ts: number,
         ph: string,
         name: string,
         args: !Object,
         dur: number,
         id: number,
         s: string
     }}
  */
-WebInspector.TracingModel.EventPayload;
+WebInspector.TracingManager.EventPayload;

[yurys, 2014/09/10 09:57:42]

Can we move it somewhere else to avoid dependency TracingModel ->
TracingManager? We can probably describe this type in the protocol.json and drop
this typedef, wdyt?

[caseq, 2014/09/10 11:59:56]

I like the idea, but let's do it as a separate change -- there will be a large
diff if we're also about to move Phase enum.

+
+
+WebInspector.TracingManager.prototype = {
+    /**
+     * @param {!WebInspector.Target} target
+     */
+    targetAdded: function(target)
+    {
+        if (this._target)
+            return;
+        this._target = target;
+        InspectorBackend.registerTracingDispatcher(new WebInspector.TracingDispatcher(this));
+    },
+
+    /**
+     * @param {!WebInspector.Target} target
+     */
+    targetRemoved: function(target)
+    {
+        if (this._target !== target)
+            return;
+        delete this._target;
+    },
+
+    /**
+     * @param {number} usage
+     */
+    _bufferUsage: function(usage)
+    {
+        this.dispatchEventToListeners(WebInspector.TracingManager.Events.BufferUsage, usage);
+    },
+
+    /**
+     * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
+     */
+    _eventsCollected: function(events)
+    {
+        this.dispatchEventToListeners(WebInspector.TracingManager.Events.EventsCollected, events);
+    },
+
+    _tracingComplete: function()
+    {
+        this.dispatchEventToListeners(WebInspector.TracingManager.Events.TracingComplete);
+    },
+
+    /**
+     * @param {string} categoryFilter
+     * @param {string} options
+     * @param {function(?string)=} callback
+     */
+    start: function(categoryFilter, options, callback)
+    {
+        if (this._active)
+            return;
+        WebInspector.profilingLock().acquire();
+        this._active = true;
+        this._shouldReleaseLock = true;
+        var bufferUsageReportingIntervalMs = 500;
+        TracingAgent.start(categoryFilter, options, bufferUsageReportingIntervalMs, callback);
+        this.dispatchEventToListeners(WebInspector.TracingManager.Events.TracingStarted);
+    },
+
+    stop: function()
+    {
+        if (!this._active)
+            return;
+        TracingAgent.end(this._onStop.bind(this));
+        if (this._shouldReleaseLock) {
+            this._shouldReleaseLock = false;
+            WebInspector.profilingLock().release();
+        }
+    },
+
+    _onStop: function()
+    {
+        if (!this._active)
+            return;
+        this.dispatchEventToListeners(WebInspector.TracingManager.Events.TracingStopped);
+        this._active = false;
+    },
+
+    __proto__: WebInspector.Object.prototype
+}
+
+/**
+ * @constructor
+ */
+WebInspector.TracingModel = function()
+{
+    this.reset();
+}
 
 /**
  * @enum {string}
  */
 WebInspector.TracingModel.Phase = {
     Begin: "B",
     End: "E",
     Complete: "X",
     Instant: "I",
     AsyncBegin: "S",
@@ skipping 34 matching lines @@
  * @return {boolean}
  */
 WebInspector.TracingModel.isAsyncPhase = function(phase)
 {
     return phase === WebInspector.TracingModel.Phase.AsyncBegin || phase === WebInspector.TracingModel.Phase.AsyncEnd ||
         phase === WebInspector.TracingModel.Phase.AsyncStepInto || phase === WebInspector.TracingModel.Phase.AsyncStepPast;
 }
 
 WebInspector.TracingModel.prototype = {
     /**
-     * @param {!WebInspector.Target} target
-     */
-    targetAdded: function(target)
-    {
-        if (this._target)
-            return;
-        this._target = target;
-        InspectorBackend.registerTracingDispatcher(new WebInspector.TracingDispatcher(this));
-    },
-
-    /**
-     * @param {!WebInspector.Target} target
-     */
-    targetRemoved: function(target)
-    {
-        if (this._target !== target)
-            return;
-        delete this._target;
-    },
-
-    /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     devtoolsPageMetadataEvents: function()
     {
         return this._devtoolsPageMetadataEvents;
     },
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     devtoolsWorkerMetadataEvents: function()
     {
         return this._devtoolsWorkerMetadataEvents;
     },
 
     /**
-     * @param {string} categoryFilter
-     * @param {string} options
-     * @param {function(?string)=} callback
-     */
-    start: function(categoryFilter, options, callback)
-    {
-        WebInspector.profilingLock().acquire();
-        this._shouldReleaseLock = true;
-        this.reset();
-        var bufferUsageReportingIntervalMs = 500;
-        TracingAgent.start(categoryFilter, options, bufferUsageReportingIntervalMs, callback);
-        this._tracingStarted();
-    },
-
-    stop: function()
-    {
-        if (!this._active)
-            return;
-        TracingAgent.end(this._onStop.bind(this));
-        if (this._shouldReleaseLock) {
-            this._shouldReleaseLock = false;
-            WebInspector.profilingLock().release();
-        }
-    },
-
-    /**
      * @return {?string}
      */
     sessionId: function()
     {
         return this._sessionId;
     },
 
     /**
-     * @param {!Array.<!WebInspector.TracingModel.EventPayload>} events
+     * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      */
     setEventsForTest: function(events)
     {
-        this._tracingStarted();
-        this._eventsCollected(events);
-        this._tracingComplete();
+        this.reset();
+        this.addEvents(events);
+        this.tracingComplete();
     },
 
     /**
-     * @param {number} usage
+     * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      */
-    _bufferUsage: function(usage)
+    addEvents: function(events)
     {
-        this.dispatchEventToListeners(WebInspector.TracingModel.Events.BufferUsage, usage);
-    },
-
-    /**
-     * @param {!Array.<!WebInspector.TracingModel.EventPayload>} events
-     */
-    _eventsCollected: function(events)
-    {
-        this._onStop();
         for (var i = 0; i < events.length; ++i) {
             this._addEvent(events[i]);
             this._rawEvents.push(events[i]);
         }
     },
 
-    _tracingComplete: function()
+    tracingComplete: function()
     {
         this._processMetadataEvents();
-        this._active = false;
         for (var process in this._processById)
             this._processById[process]._tracingComplete(this._maximumRecordTime);
-        this.dispatchEventToListeners(WebInspector.TracingModel.Events.TracingComplete);
-    },
-
-    _tracingStarted: function()
-    {
-        if (this._active)
-            return;
-        this.reset();
-        this._active = true;
-        this._sessionId = null;
-        this.dispatchEventToListeners(WebInspector.TracingModel.Events.TracingStarted);
-    },
-
-    _onStop: function()
-    {
-        if (!this._active)
-            return;
-        this.dispatchEventToListeners(WebInspector.TracingModel.Events.TracingStopped);
-        this._active = false;
     },
 
     reset: function()
     {
         this._processById = {};
         this._minimumRecordTime = 0;
         this._maximumRecordTime = 0;
         this._sessionId = null;
         this._devtoolsPageMetadataEvents = [];
         this._devtoolsWorkerMetadataEvents = [];
         this._rawEvents = [];
     },
 
     /**
-      * @return {!Array.<!WebInspector.TracingModel.EventPayload>}
+      * @return {!Array.<!WebInspector.TracingManager.EventPayload>}
       */
     rawEvents: function()
     {
         return this._rawEvents;
     },
 
     /**
-      * @param {!WebInspector.TracingModel.EventPayload} payload
+      * @param {!WebInspector.TracingManager.EventPayload} payload
       */
     _addEvent: function(payload)
     {
         var process = this._processById[payload.pid];
         if (!process) {
             process = new WebInspector.TracingModel.Process(payload.pid);
             this._processById[payload.pid] = process;
         }
         if (payload.ph !== WebInspector.TracingModel.Phase.Metadata) {
             var timestamp = payload.ts / 1000;
@@ skipping 72 matching lines @@
     {
         return this._maximumRecordTime;
     },
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Process>}
      */
     sortedProcesses: function()
     {
         return WebInspector.TracingModel.NamedObject._sort(Object.values(this._processById));
-    },
-
-    __proto__: WebInspector.Object.prototype
+    }
 }
 
 
 /**
  * @constructor
  * @param {!WebInspector.TracingModel} tracingModel
  */
 WebInspector.TracingModel.Loader = function(tracingModel)
 {
     this._tracingModel = tracingModel;
     this._firstChunkReceived = false;
 }
 
 WebInspector.TracingModel.Loader.prototype = {
     /**
-     * @param {!Array.<!WebInspector.TracingModel.EventPayload>} events
+     * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      */
     loadNextChunk: function(events)
     {
         if (!this._firstChunkReceived) {
-            this._tracingModel._tracingStarted();
+            this._tracingModel.reset();
             this._firstChunkReceived = true;
         }
-        this._tracingModel._eventsCollected(events);
+        this._tracingModel.addEvents(events);
     },
 
     finish: function()
     {
-        this._tracingModel._tracingComplete();
+        this._tracingModel.tracingComplete();
     }
 }
 
 
 /**
  * @constructor
  * @param {string} category
  * @param {string} name
  * @param {string} phase
  * @param {number} startTime
@@ skipping 19 matching lines @@
     /** @type {?string} */
     this.imageURL = null;
     /** @type {number} */
     this.backendNodeId = 0;
 
     /** @type {number} */
     this.selfTime = 0;
 }
 
 /**
- * @param {!WebInspector.TracingModel.EventPayload} payload
+ * @param {!WebInspector.TracingManager.EventPayload} payload
  * @param {?WebInspector.TracingModel.Thread} thread
  * @return {!WebInspector.TracingModel.Event}
  */
 WebInspector.TracingModel.Event.fromPayload = function(payload, thread)
 {
     var event = new WebInspector.TracingModel.Event(payload.cat, payload.name, payload.ph, payload.ts / 1000, thread);
     if (payload.args)
         event.addArgs(payload.args);
     else
         console.error("Missing mandatory event argument 'args' at " + payload.ts / 1000);
@@ skipping 25 matching lines @@
     {
         // Shallow copy args to avoid modifying original payload which may be saved to file.
         for (var name in args) {
             if (name in this.args)
                 console.error("Same argument name (" + name +  ") is used for begin and end phases of " + this.name);
             this.args[name] = args[name];
         }
     },
 
     /**
-     * @param {!WebInspector.TracingModel.EventPayload} payload
+     * @param {!WebInspector.TracingManager.EventPayload} payload
      */
     _complete: function(payload)
     {
         if (payload.args)
             this.addArgs(payload.args);
         else
             console.error("Missing mandatory event argument 'args' at " + payload.ts / 1000);
         this.setEndTime(payload.ts / 1000);
     }
 }
@@ skipping 75 matching lines @@
  * @constructor
  * @extends {WebInspector.TracingModel.NamedObject}
  * @param {number} id
  */
 WebInspector.TracingModel.Process = function(id)
 {
     WebInspector.TracingModel.NamedObject.call(this);
     this._setName("Process " + id);
     this._threads = {};
     this._objects = {};
-    /** @type {!Array.<!WebInspector.TracingModel.EventPayload>} */
+    /** @type {!Array.<!WebInspector.TracingManager.EventPayload>} */
     this._asyncEvents = [];
     /** @type {!Object.<string, ?Array.<!WebInspector.TracingModel.Event>>} */
     this._openAsyncEvents = [];
 }
 
 WebInspector.TracingModel.Process.prototype = {
     /**
      * @param {number} id
      * @return {!WebInspector.TracingModel.Thread}
      */
     threadById: function(id)
     {
         var thread = this._threads[id];
         if (!thread) {
             thread = new WebInspector.TracingModel.Thread(this, id);
             this._threads[id] = thread;
         }
         return thread;
     },
 
     /**
-     * @param {!WebInspector.TracingModel.EventPayload} payload
+     * @param {!WebInspector.TracingManager.EventPayload} payload
      * @return {?WebInspector.TracingModel.Event} event
      */
     _addEvent: function(payload)
     {
         var phase = WebInspector.TracingModel.Phase;
         // Build async event when we've got events from all threads, so we can sort them and process in the chronological order.
         // However, also add individual async events to the thread flow, 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(payload);
 
         var event = this.threadById(payload.tid)._addEvent(payload);
         if (event && payload.ph === phase.SnapshotObject)
             this.objectsByName(event.name).push(event);
         return event;
     },
 
     /**
      * @param {!number} lastEventTime
      */
     _tracingComplete: function(lastEventTime)
     {
         /**
-         * @param {!WebInspector.TracingModel.EventPayload} a
-         * @param {!WebInspector.TracingModel.EventPayload} b
+         * @param {!WebInspector.TracingManager.EventPayload} a
+         * @param {!WebInspector.TracingManager.EventPayload} b
          */
         function comparePayloadTimestamp(a, b)
         {
             return a.ts - b.ts;
         }
         this._asyncEvents.sort(comparePayloadTimestamp).forEach(this._addAsyncEvent, this);
         for (var key in this._openAsyncEvents) {
             var steps = this._openAsyncEvents[key];
             if (!steps)
                 continue;
             var startEvent = steps[0];
             var syntheticEndEvent = new WebInspector.TracingModel.Event(startEvent.category, startEvent.name, WebInspector.TracingModel.Phase.AsyncEnd, lastEventTime, startEvent.thread);
             steps.push(syntheticEndEvent);
         }
         this._asyncEvents = [];
         this._openAsyncEvents = [];
     },
 
     /**
-     * @param {!WebInspector.TracingModel.EventPayload} payload
+     * @param {!WebInspector.TracingManager.EventPayload} payload
      */
     _addAsyncEvent: function(payload)
     {
         var phase = WebInspector.TracingModel.Phase;
         var timestamp = payload.ts / 1000;
         var key = payload.name + "." + payload.id;
         var steps = this._openAsyncEvents[key];
 
         var thread = this.threadById(payload.tid);
         if (payload.ph === phase.AsyncBegin) {
@@ skipping 81 matching lines @@
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         //FIXME: correctly specify target
         return WebInspector.targetManager.targets()[0];
     },
 
     /**
-     * @param {!WebInspector.TracingModel.EventPayload} payload
+     * @param {!WebInspector.TracingManager.EventPayload} payload
      * @return {?WebInspector.TracingModel.Event} event
      */
     _addEvent: function(payload)
     {
         var timestamp = payload.ts / 1000;
         if (payload.ph === WebInspector.TracingModel.Phase.End) {
             // Quietly ignore unbalanced close events, they're legit (we could have missed start one).
             if (!this._stack.length)
                 return null;
             var top = this._stack.pop();
@@ skipping 44 matching lines @@
         return this._asyncEvents;
     },
 
     __proto__: WebInspector.TracingModel.NamedObject.prototype
 }
 
 
 /**
  * @constructor
  * @implements {TracingAgent.Dispatcher}
- * @param {!WebInspector.TracingModel} tracingModel
+ * @param {!WebInspector.TracingManager} tracingManager
  */
-WebInspector.TracingDispatcher = function(tracingModel)
+WebInspector.TracingDispatcher = function(tracingManager)
 {
-    this._tracingModel = tracingModel;
+    this._tracingManager = tracingManager;
 }
 
 WebInspector.TracingDispatcher.prototype = {
     /**
      * @param {number} usage
      */
     bufferUsage: function(usage)
     {
-        this._tracingModel._bufferUsage(usage);
+        this._tracingManager._bufferUsage(usage);
     },
 
     /**
-     * @param {!Array.<!WebInspector.TracingModel.EventPayload>} data
+     * @param {!Array.<!WebInspector.TracingManager.EventPayload>} data
      */
     dataCollected: function(data)
     {
-        this._tracingModel._eventsCollected(data);
+        this._tracingManager._eventsCollected(data);
     },
 
     tracingComplete: function()
     {
-        this._tracingModel._tracingComplete();
+        this._tracingManager._tracingComplete();
     },
 
     started: function()
     {

[yurys, 2014/09/10 09:57:42]

How do we handle console.timeline initiated recording after this is removed?

[caseq, 2014/09/10 11:59:56]

Reverted this one. Sorry, got a bit carried away with refactoring :-)

-        this._tracingModel._tracingStarted();
     }
 }