DevTools: log worker thread ids on the main thread when Timeline recording is enabled

Source/devtools/front_end/timeline/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
  */
 WebInspector.TracingModel = function()
@@ skipping 32 matching lines @@
 }
 
 WebInspector.TracingModel.DevToolsMetadataEventCategory = "disabled-by-default-devtools.timeline";
 
 WebInspector.TracingModel.ConsoleEventCategory = "blink.console";
 
 WebInspector.TracingModel.FrameLifecycleEventCategory = "cc,devtools";
 
 WebInspector.TracingModel.DevToolsMetadataEvent = {
     TracingStartedInPage: "TracingStartedInPage",
-    TracingStartedInWorker: "TracingStartedInWorker",
+    TracingSessionIdForWorker: "TracingSessionIdForWorker",
 };
 
 /**
  * @param {string} phase
  * @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;
@@ skipping 87 matching lines @@
             // so there's a chance we're getting records from the past.
             if (timestamp && (!this._minimumRecordTime || timestamp < this._minimumRecordTime))
                 this._minimumRecordTime = timestamp;
             var endTimeStamp = (payload.ts + (payload.dur || 0)) / 1000;
             this._maximumRecordTime = Math.max(this._maximumRecordTime, endTimeStamp);
             var event = process._addEvent(payload);
             if (event && event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInPage &&
                 event.category === WebInspector.TracingModel.DevToolsMetadataEventCategory) {
                 this._devtoolsPageMetadataEvents.push(event);
             }
-            if (event && event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInWorker &&
+            if (event && event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingSessionIdForWorker &&
                 event.category === WebInspector.TracingModel.DevToolsMetadataEventCategory) {
                 this._devtoolsWorkerMetadataEvents.push(event);
             }
             return;
         }
         switch (payload.name) {
         case WebInspector.TracingModel.MetadataEvent.ProcessSortIndex:
             process._setSortIndex(payload.args["sort_index"]);
             break;
         case WebInspector.TracingModel.MetadataEvent.ProcessName:
@@ skipping 14 matching lines @@
         if (!this._devtoolsPageMetadataEvents.length) {
             WebInspector.console.error(WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInPage + " event not found.");
             return;
         }
         var sessionId = this._devtoolsPageMetadataEvents[0].args["sessionId"];
         this._sessionId = sessionId;
 
         var mismatchingIds = {};
         function checkSessionId(event)
         {
-            var id = event.args["sessionId"];
+            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)
@@ skipping 379 matching lines @@
  * @param {!WebInspector.TracingModel.Process} process
  * @param {number} id
  */
 WebInspector.TracingModel.Thread = function(process, id)
 {
     WebInspector.TracingModel.NamedObject.call(this);
     this._process = process;
     this._setName("Thread " + id);
     this._events = [];
     this._asyncEvents = [];
+    this._id = id;
 
     this._stack = [];
 }
 
 WebInspector.TracingModel.Thread.prototype = {
 
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
@@ skipping 31 matching lines @@
 
     /**
      * @param {!Array.<!WebInspector.TracingModel.Event>} eventSteps
      */
     _addAsyncEventSteps: function(eventSteps)
     {
         this._asyncEvents.push(eventSteps);
     },
 
     /**
+     * @return {number}
+     */
+    id: function()
+    {
+        return this._id;
+    },
+
+    /**
      * @return {!WebInspector.TracingModel.Process}
      */
     process: function()
     {
         return this._process;
     },
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     events: function()
     {
         return this._events;
     },
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     asyncEvents: function()
     {
         return this._asyncEvents;
     },
 
     __proto__: WebInspector.TracingModel.NamedObject.prototype
 }