Timeline addTraceProvider API

third_party/WebKit/Source/devtools/front_end/timeline_model/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 142 matching lines @@
     LatencyInfoFlow: "LatencyInfo.Flow",
     InputLatencyMouseMove: "InputLatency::MouseMove",
     InputLatencyMouseWheel: "InputLatency::MouseWheel",
     ImplSideFling: "InputHandlerProxy::HandleGestureFling::started",
     GCIdleLazySweep: "ThreadState::performIdleLazySweep",
     GCCompleteSweep: "ThreadState::completeSweep",
     GCCollectGarbage: "BlinkGCMarking",
 
     // CpuProfile is a virtual event created on frontend to support
     // serialization of CPU Profiles within tracing timeline data.
-    CpuProfile: "CpuProfile"
+    CpuProfile: "CpuProfile",
+
+    Extension: "Extension"

[caseq, 2016/07/11 18:58:38]

This shouldn't be necessary.

 }
 
 WebInspector.TimelineModel.Category = {
     Console: "blink.console",
     UserTiming: "blink.user_timing",
     LatencyInfo: "latencyInfo"
 };
 
 /**
  * @enum {string}
  */
 WebInspector.TimelineModel.WarningType = {
     ForcedStyle: "ForcedStyle",
     ForcedLayout: "ForcedLayout",
     IdleDeadlineExceeded: "IdleDeadlineExceeded",
     V8Deopt: "V8Deopt"
 }
 
 WebInspector.TimelineModel.MainThreadName = "main";
+WebInspector.TimelineModel.ExtensionThreadName = "extension";

[caseq, 2016/07/11 18:58:38]

ditto.

 WebInspector.TimelineModel.WorkerThreadName = "DedicatedWorker Thread";
 WebInspector.TimelineModel.RendererMainThreadName = "CrRendererMain";
 
 /**
  * @enum {symbol}
  */
 WebInspector.TimelineModel.AsyncEventGroup = {
     animation: Symbol("animation"),
     console: Symbol("console"),
     userTiming: Symbol("userTiming"),
@@ skipping 281 matching lines @@
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         // FIXME: Consider returning null for loaded traces.
         return WebInspector.targetManager.targets()[0];
     },
 
     /**
      * @param {!WebInspector.TracingModel} tracingModel
+     * @param {!Array.<!WebInspector.ExtensionTraceProvider>} traceProviders
      * @param {boolean=} produceTraceStartedInPage
      */
-    setEvents: function(tracingModel, produceTraceStartedInPage)
+    setEvents: function(tracingModel, traceProviders, produceTraceStartedInPage)
     {
         this.reset();
         this._resetProcessingState();
 
         this._minimumRecordTime = tracingModel.minimumRecordTime();
         this._maximumRecordTime = tracingModel.maximumRecordTime();
 
         var metadataEvents = this._processMetadataEvents(tracingModel, !!produceTraceStartedInPage);
         var startTime = 0;
         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 ? 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 && !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._processBrowserEvents(tracingModel);
+        this._processExtensionEvents(traceProviders);
         this._buildTimelineRecords();
         this._buildGPUEvents(tracingModel);
         this._insertFirstPaintEvent();
         this._resetProcessingState();
     },
 
     /**
      * @param {!WebInspector.TracingModel} tracingModel
      * @param {boolean} produceTraceStartedInPage
      * @return {!WebInspector.TimelineModel.MetadataEvents}
@@ skipping 100 matching lines @@
         if (!browserMain)
             return;
         // Disregard regular events, we don't need them yet, but still process to get proper metadata.
         browserMain.events().forEach(this._processBrowserEvent, this);
         /** @type {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array<!WebInspector.TracingModel.AsyncEvent>>} */
         var asyncEventsByGroup = new Map();
         this._processAsyncEvents(asyncEventsByGroup, browserMain.asyncEvents());
         this._mergeAsyncEvents(this._mainThreadAsyncEventsByGroup, asyncEventsByGroup);
     },
 
+    /**
+     * @param {!Array.<!WebInspector.ExtensionTraceProvider>} traceProviders
+     */
+    _processExtensionEvents: function(traceProviders)
+    {
+        for (var traceProvider of traceProviders) {
+            traceProvider.tracingModel.threadByName("Extension", "Thread 0").events().forEach(function(entry) {
+                this._extensionEvents.push(entry);
+            }, this);
+        }
+    },
+
     _buildTimelineRecords: function()
     {
         var topLevelRecords = this._buildTimelineRecordsForThread(this.mainThreadEvents());
         for (var i = 0; i < topLevelRecords.length; i++) {
             var record = topLevelRecords[i];
             if (WebInspector.TracingModel.isTopLevelEvent(record.traceEvent()))
                 this._mainThreadTasks.push(record);
         }
 
         /**
@@ skipping 427 matching lines @@
             events = events.mergeOrdered(source.get(group) || [], WebInspector.TracingModel.Event.compareStartAndEndTime);
             target.set(group, events);
         }
     },
 
     reset: function()
     {
         this._virtualThreads = [];
         /** @type {!Array<!WebInspector.TracingModel.Event>} */
         this._mainThreadEvents = [];
+        /** @type {!Array<!WebInspector.TracingModel.Event>} */
+        this._extensionEvents = [];
         /** @type {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array<!WebInspector.TracingModel.AsyncEvent>>} */
         this._mainThreadAsyncEventsByGroup = new Map();
         /** @type {!Array<!WebInspector.TracingModel.Event>} */
         this._inspectedTargetEvents = [];
         /** @type {!Array<!WebInspector.TimelineModel.Record>} */
         this._records = [];
         /** @type {!Array<!WebInspector.TimelineModel.Record>} */
         this._mainThreadTasks = [];
         /** @type {!Array<!WebInspector.TracingModel.Event>} */
         this._gpuEvents = [];
@@ skipping 35 matching lines @@
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     mainThreadEvents: function()
     {
         return this._mainThreadEvents;
     },
 
     /**
+     * @return {!Array.<!WebInspector.TracingModel.Event>}
+     */
+    extensionEvents: function()
+    {
+        return this._extensionEvents;
+    },
+
+    /**
      * @param {!Array.<!WebInspector.TracingModel.Event>} events
      */
     _setMainThreadEvents: function(events)
     {
         this._mainThreadEvents = events;
     },
 
     /**
      * @return {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array.<!WebInspector.TracingModel.AsyncEvent>>}
      */
@@ skipping 605 matching lines @@
         if (!id)
             return;
         /** @type {!Map<string, !WebInspector.TracingModel.Event>|undefined} */
         var initiatorMap = this._initiatorByType.get(initiatorType);
         if (isInitiator)
             initiatorMap.set(id, event);
         else
             event.initiator = initiatorMap.get(id) || null;
     }
 }