DevTools: process trace events from background threads by a timed task.

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 20 matching lines @@
 #include "config.h"
 #include "core/inspector/TimelineTraceEventProcessor.h"
 
 #include "core/fetch/ImageResource.h"
 #include "core/inspector/InspectorClient.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/TimelineRecordFactory.h"
 #include "core/rendering/RenderImage.h"
 
 #include "wtf/CurrentTime.h"
+#include "wtf/Functional.h"
 #include "wtf/MainThread.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 namespace {
 
 class TraceEventDispatcher {
     WTF_MAKE_NONCOPYABLE(TraceEventDispatcher);
 public:
@@ skipping 98 matching lines @@
 
 TimelineTraceEventProcessor::TimelineTraceEventProcessor(WeakPtr<InspectorTimelineAgent> timelineAgent, InspectorClient *client)
     : 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_layerId(0)
     , m_paintSetupStart(0)
     , m_paintSetupEnd(0)
+    , m_lastEventProcessingTime(0)
+    , m_processEventsTaskPosted(false)
 {
     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);
@@ skipping 44 matching lines @@
 }
 
 void TimelineTraceEventProcessor::processEventOnAnyThread(char phase, const char* name, unsigned long long id,
     int numArgs, const char* const* argNames, const unsigned char* argTypes, const unsigned long long* argValues,
     unsigned char)
 {
     HandlersMap::iterator it = m_handlersByType.find(std::make_pair(name, phase));
     if (it == m_handlersByType.end())
         return;
 
-    TraceEvent event(WTF::monotonicallyIncreasingTime(), phase, name, id, currentThread(), numArgs, argNames, argTypes, argValues);
+    double timestamp = WTF::monotonicallyIncreasingTime();
+    TraceEvent event(timestamp, phase, name, id, currentThread(), numArgs, argNames, argTypes, argValues);
 
     if (!isMainThread()) {
         MutexLocker locker(m_backgroundEventsMutex);
+        const float EventProcessingThresholdInSeconds = 0.1;
         m_backgroundEvents.append(event);
+        if (!m_processEventsTaskPosted && timestamp - m_lastEventProcessingTime > EventProcessingThresholdInSeconds) {
+            m_processEventsTaskPosted = true;
+            callOnMainThread(bind(&TimelineTraceEventProcessor::processBackgroundEventsTask, this));
+        }
         return;
     }
+    processBackgroundEvents();
     (this->*(it->value))(event);
 }
 
 void TimelineTraceEventProcessor::onBeginFrame(const TraceEvent&)
 {
-    processBackgroundEvents();
+    // We don't handle BeginFrame explicitly now, but it still implicitly helps
+    // to pump the background events regularly (as opponsed to a special task),
+    // as this is only done upon events we recognize.
 }
 
 void TimelineTraceEventProcessor::onUpdateLayerBegin(const TraceEvent& event)
 {
     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
     if (layerTreeId != m_layerTreeId)
         return;
     m_layerId = event.asUInt(InstrumentationEventArguments::LayerId);
     // We don't know the node yet. For content layers, the node will be updated
     // by paint. For others, let it remain 0 -- we just need the fact that
@@ skipping 30 matching lines @@
     m_paintSetupEnd = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
 }
 
 void TimelineTraceEventProcessor::onRasterTaskBegin(const TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     if (!maybeEnterLayerTask(event, state))
         return;
     unsigned long long layerId = event.asUInt(InstrumentationEventArguments::LayerId);
     ASSERT(layerId);
-    RefPtr<JSONObject> record = createRecord(event, TimelineRecordType::Rasterize);
-    record->setObject("data", TimelineRecordFactory::createLayerData(m_layerToNodeMap.get(layerId)));
+    RefPtr<JSONObject> record = createRecord(event, TimelineRecordType::Rasterize, TimelineRecordFactory::createLayerData(m_layerToNodeMap.get(layerId)));
     state.recordStack.addScopedRecord(record.release());
 }
 
 void TimelineTraceEventProcessor::onRasterTaskEnd(const TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     if (!state.inKnownLayerTask)
         return;
     ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::Rasterize));
     state.recordStack.closeScopedRecord(m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp()));
@@ skipping 117 matching lines @@
     record->setObject("data", data ? data : JSONObject::create());
     return record.release();
 }
 
 void TimelineTraceEventProcessor::processBackgroundEvents()
 {
     ASSERT(isMainThread());
     Vector<TraceEvent> events;
     {
         MutexLocker locker(m_backgroundEventsMutex);
+        m_lastEventProcessingTime = WTF::monotonicallyIncreasingTime();
+        if (!m_backgroundEvents.size())

[alph, 2013/10/16 15:22:23]

nit: isEmpty()

+            return;
         events.reserveCapacity(m_backgroundEvents.capacity());
         m_backgroundEvents.swap(events);
     }
     for (size_t i = 0, size = events.size(); i < size; ++i) {
         const TraceEvent& event = events[i];
         HandlersMap::iterator it = m_handlersByType.find(std::make_pair(event.name(), event.phase()));
         ASSERT(it != m_handlersByType.end() && it->value);
         (this->*(it->value))(event);
     }
 }
 
+void TimelineTraceEventProcessor::processBackgroundEventsTask()
+{
+    m_processEventsTaskPosted = false;
+    processBackgroundEvents();
+}
+
 } // namespace WebCore