Timeline: do not rely on UpdateLayer & PaintLayer trace events

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 138 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_lastEventProcessingTime(0)
     , m_processEventsTaskInFlight(false)
-    , m_layerId(0)
     , m_paintSetupStart(0)
     , m_paintSetupEnd(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::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::DecodeLazyPixelRefEvent, TRACE_EVENT_PHASE_BEGIN, &TimelineTraceEventProcessor::onDecodeLazyPixelRefBegin);
@@ skipping 61 matching lines @@
     (this->*(it->value))(event);
 }
 
 void TimelineTraceEventProcessor::onBeginFrame(const TraceEvent&)
 {
     // We don't handle BeginFrame explicitly now, but it still implicitly helps
     // to pump the background events regularly (as opposed to posting a 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 != static_cast<unsigned long long>(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
-    // the layer belongs to the page (see cookie check).
-    m_layerToNodeMap.add(m_layerId, 0);
-}
-
-void TimelineTraceEventProcessor::onUpdateLayerEnd(const TraceEvent& event)
-{
-    m_layerId = 0;
-}
-
-void TimelineTraceEventProcessor::onPaintLayerBegin(const TraceEvent& event)
-{
-    m_layerId = event.asUInt(InstrumentationEventArguments::LayerId);
-    ASSERT(m_layerId);
-    ASSERT(!m_paintSetupStart);
-}
-
-void TimelineTraceEventProcessor::onPaintLayerEnd(const TraceEvent& event)
-{
-    m_layerId = 0;
-}
-
 void TimelineTraceEventProcessor::onPaintSetupBegin(const TraceEvent& event)
 {
     ASSERT(!m_paintSetupStart);
     m_paintSetupStart = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
 }
 
 void TimelineTraceEventProcessor::onPaintSetupEnd(const TraceEvent& event)
 {
     ASSERT(m_paintSetupStart);
     m_paintSetupEnd = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
@@ skipping 67 matching lines @@
     unsigned long long id = event.id();
     ASSERT(id);
     processBackgroundEvents();
     m_layerToNodeMap.remove(id);
 }
 
 void TimelineTraceEventProcessor::onPaint(const TraceEvent& event)
 {
     double paintSetupStart = m_paintSetupStart;
     m_paintSetupStart = 0;
-    if (!m_layerId)
-        return;
     unsigned long long pageId = event.asUInt(InstrumentationEventArguments::PageId);
     if (pageId != m_pageId)
         return;
-    long long nodeId = event.asInt(InstrumentationEventArguments::NodeId);
-    ASSERT(nodeId);
-    m_layerToNodeMap.set(m_layerId, nodeId);
     InspectorTimelineAgent* timelineAgent = m_timelineAgent.get();
-    if (timelineAgent && paintSetupStart) {
-        RefPtr<JSONObject> paintSetupRecord = TimelineRecordFactory::createGenericRecord(paintSetupStart, 0, TimelineRecordType::PaintSetup);
-        paintSetupRecord->setNumber("endTime", m_paintSetupEnd);
-        paintSetupRecord->setObject("data", TimelineRecordFactory::createLayerData(nodeId));
-        timelineAgent->addRecordToTimeline(paintSetupRecord);
+    if (!timelineAgent)
+        return;
+    if (int layerId = timelineAgent->layerBeingPainted()) {
+        int nodeId = timelineAgent->nodeBeingPainted();
+        ASSERT(nodeId);
+        m_layerToNodeMap.set(layerId, nodeId);
+        if (paintSetupStart) {
+            RefPtr<JSONObject> paintSetupRecord = TimelineRecordFactory::createGenericRecord(paintSetupStart, 0, TimelineRecordType::PaintSetup);
+            paintSetupRecord->setNumber("endTime", m_paintSetupEnd);
+            paintSetupRecord->setObject("data", TimelineRecordFactory::createLayerData(nodeId));
+            timelineAgent->addRecordToTimeline(paintSetupRecord);
+        }
     }
 }
 
 void TimelineTraceEventProcessor::onDecodeLazyPixelRefBegin(const TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     ASSERT(!state.decodedPixelRefId);
     unsigned long long pixelRefId = event.asUInt(PlatformInstrumentation::LazyPixelRef);
     ASSERT(pixelRefId);
     if (m_pixelRefToImageInfo.contains(pixelRefId))
         state.decodedPixelRefId = pixelRefId;
 }
 
 void TimelineTraceEventProcessor::onDecodeLazyPixelRefEnd(const TraceEvent& event)
 {
     threadState(event.threadIdentifier()).decodedPixelRefId = 0;
 }
 
 void TimelineTraceEventProcessor::onDrawLazyPixelRef(const TraceEvent& event)
 {
-    // Only track LazyPixelRefs created while we paint known layers
-    if (!m_layerId || !m_layerToNodeMap.contains(m_layerId))
-        return;
     unsigned long long pixelRefId = event.asUInt(PlatformInstrumentation::LazyPixelRef);
     ASSERT(pixelRefId);
     InspectorTimelineAgent* timelineAgent = m_timelineAgent.get();
     if (!timelineAgent)
         return;
     const RenderImage* renderImage = timelineAgent->imageBeingPainted();
     if (!renderImage)
         return;
     int nodeId = timelineAgent->nodeId(renderImage->generatingNode());
     String url;
@@ skipping 36 matching lines @@
 }
 
 void TimelineTraceEventProcessor::processBackgroundEventsTask()
 {
     m_processEventsTaskInFlight = false;
     processBackgroundEvents();
 }
 
 } // namespace WebCore