DevTools: Show GPU utilization bar on timeline

Source/core/inspector/TimelineTraceEventProcessor.cpp

 /*
 * Copyright (C) 2013 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 130 matching lines @@
 #endif
 
 void TimelineRecordStack::send(PassRefPtr<JSONObject> record)
 {
     InspectorTimelineAgent* timelineAgent = m_timelineAgent.get();
     if (!timelineAgent)
         return;
     timelineAgent->sendEvent(record);
 }
 
-TimelineTraceEventProcessor::TimelineTraceEventProcessor(WeakPtr<InspectorTimelineAgent> timelineAgent, InspectorClient *client)
+TimelineTraceEventProcessor::TimelineTraceEventProcessor(WeakPtr<InspectorTimelineAgent> timelineAgent, InspectorClient *client, bool collectGpuEvents)
     : m_timelineAgent(timelineAgent)
     , m_timeConverter(timelineAgent.get()->timeConverter())
     , m_inspectorClient(client)
     , m_pageId(reinterpret_cast<unsigned long long>(m_timelineAgent.get()->page()))
     , m_layerTreeId(m_timelineAgent.get()->layerTreeId())
     , m_lastEventProcessingTime(0)
     , m_processEventsTaskInFlight(false)
     , m_layerId(0)
     , m_paintSetupStart(0)
     , m_paintSetupEnd(0)
+    , m_gpuTaskStart(0)
 {
     registerHandler(InstrumentationEvents::BeginFrame, TRACE_EVENT_PHASE_INSTANT, &TimelineTraceEventProcessor::onBeginFrame);
     registerHandler(InstrumentationEvents::UpdateLayer, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onUpdateLayerBegin);
     registerHandler(InstrumentationEvents::UpdateLayer, TRACE_EVENT_PHASE_END, &TimelineTraceEventProcessor::onUpdateLayerEnd);
     registerHandler(InstrumentationEvents::PaintLayer, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onPaintLayerBegin);
     registerHandler(InstrumentationEvents::PaintLayer, TRACE_EVENT_PHASE_END, &TimelineTraceEventProcessor::onPaintLayerEnd);
     registerHandler(InstrumentationEvents::PaintSetup, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onPaintSetupBegin);
     registerHandler(InstrumentationEvents::PaintSetup, TRACE_EVENT_PHASE_END, &TimelineTraceEventProcessor::onPaintSetupEnd);
     registerHandler(InstrumentationEvents::RasterTask, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onRasterTaskBegin);
     registerHandler(InstrumentationEvents::RasterTask, TRACE_EVENT_PHASE_END, &TimelineTraceEventProcessor::onRasterTaskEnd);
     registerHandler(InstrumentationEvents::ImageDecodeTask, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onImageDecodeTaskBegin);
     registerHandler(InstrumentationEvents::ImageDecodeTask, TRACE_EVENT_PHASE_END, &TimelineTraceEventProcessor::onImageDecodeTaskEnd);
     registerHandler(InstrumentationEvents::Layer, TRACE_EVENT_PHASE_DELETE_OBJECT, &TimelineTraceEventProcessor::onLayerDeleted);
     registerHandler(InstrumentationEvents::Paint, TRACE_EVENT_PHASE_INSTANT, &TimelineTraceEventProcessor::onPaint);
     registerHandler(PlatformInstrumentation::ImageDecodeEvent, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onImageDecodeBegin);
     registerHandler(PlatformInstrumentation::ImageDecodeEvent, TRACE_EVENT_PHASE_END, &TimelineTraceEventProcessor::onImageDecodeEnd);
     registerHandler(PlatformInstrumentation::DrawLazyPixelRefEvent, TRACE_EVENT_PHASE_INSTANT, &TimelineTraceEventProcessor::onDrawLazyPixelRef);
     registerHandler(PlatformInstrumentation::LazyPixelRef, TRACE_EVENT_PHASE_DELETE_OBJECT, &TimelineTraceEventProcessor::onLazyPixelRefDeleted);
+    if (collectGpuEvents) {
+        // FIXME: Instead of filtering GPU events here on the client side
+        // just don't enable collection in the GPU process.
+        // Make sure GPU process agent can handle both client types connected
+        // simultaneously: ones that need GPU events and ones that do not.
+        registerHandler(PlatformInstrumentation::GpuTask, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onGpuTaskBegin);
+        registerHandler(PlatformInstrumentation::GpuTask, TRACE_EVENT_PHASE_END, &TimelineTraceEventProcessor::onGpuTaskEnd);
+    }
 
     TraceEventDispatcher::instance()->addProcessor(this, m_inspectorClient);
 }
 
 TimelineTraceEventProcessor::~TimelineTraceEventProcessor()
 {
 }
 
 void TimelineTraceEventProcessor::registerHandler(const char* name, char phase, TraceEventHandler handler)
 {
@@ skipping 220 matching lines @@
     if (const ImageResource* resource = renderImage->cachedImage())
         url = resource->url().string();
     m_pixelRefToImageInfo.set(pixelRefId, ImageInfo(nodeId, url));
 }
 
 void TimelineTraceEventProcessor::onLazyPixelRefDeleted(const TraceEvent& event)
 {
     m_pixelRefToImageInfo.remove(event.id());
 }
 
+void TimelineTraceEventProcessor::onGpuTaskBegin(const TraceEvent& event)
+{
+    m_gpuTaskStart = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
+    m_gpuTaskRendererPid = event.asUInt(PlatformInstrumentation::GpuTaskRendererPid);

[caseq, 2013/11/01 13:04:20]

nit: m_gpuTask(Initiator|Owner)Pid

[alph, 2013/11/01 16:40:19]

Done.

+}
+
+void TimelineTraceEventProcessor::onGpuTaskEnd(const TraceEvent& event)
+{
+    InspectorTimelineAgent* timelineAgent = m_timelineAgent.get();
+    if (!timelineAgent || !m_gpuTaskStart)
+        return;
+    RefPtr<JSONObject> gpuEvent = TimelineRecordFactory::createBackgroundRecord(m_gpuTaskStart, "gpu");

[caseq, 2013/11/01 13:04:20]

Use TimelineTraceProcessor::createRecord() instead.

[alph, 2013/11/01 16:40:19]

Done.

+    RefPtr<JSONObject> data = JSONObject::create();
+    gpuEvent->setString("type", TimelineRecordType::GpuTask);
+    gpuEvent->setNumber("endTime", m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp()));
+    gpuEvent->setObject("data", data);
+    data->setString("name", event.name());
+    data->setNumber("rendererPid", m_gpuTaskRendererPid);
+    timelineAgent->sendEvent(gpuEvent);
+    m_gpuTaskStart = 0;
+}
+
 PassRefPtr<JSONObject> TimelineTraceEventProcessor::createRecord(const TraceEvent& event, const String& recordType, PassRefPtr<JSONObject> data)
 {
     double startTime = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
     RefPtr<JSONObject> record = TimelineRecordFactory::createBackgroundRecord(startTime, String::number(event.threadIdentifier()));
     record->setString("type", recordType);
     record->setObject("data", data ? data : JSONObject::create());
     return record.release();
 }
 
 void TimelineTraceEventProcessor::processBackgroundEvents()
@@ skipping 17 matching lines @@
 }
 
 void TimelineTraceEventProcessor::processBackgroundEventsTask()
 {
     m_processEventsTaskInFlight = false;
     processBackgroundEvents();
 }
 
 } // namespace WebCore