Timeline: add reference to root node of layer in Rasterize event

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 225 matching lines @@
 void TimelineTraceEventProcessor::onPaintLayerEnd(const TraceEvent&)
 {
     m_layerId = 0;
 }
 
 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<InspectorObject> record = createRecord(event, TimelineRecordType::Rasterize);
+    record->setObject("data", TimelineRecordFactory::createRasterizeData(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()));
     leaveLayerTask(state);
 }
 
 void TimelineTraceEventProcessor::onImageDecodeTaskBegin(const TraceEvent& event)
 {
     maybeEnterLayerTask(event, threadState(event.threadIdentifier()));
 }
 
 void TimelineTraceEventProcessor::onImageDecodeTaskEnd(const TraceEvent& event)
 {
     leaveLayerTask(threadState(event.threadIdentifier()));
 }
 
 bool TimelineTraceEventProcessor::maybeEnterLayerTask(const TraceEvent& event, TimelineThreadState& threadState)
 {
     unsigned long long layerId = event.asUInt(InstrumentationEventArguments::LayerId);
-    if (!m_knownLayers.contains(layerId))
+    if (!m_layerToNodeMap.contains(layerId))
         return false;
     ASSERT(!threadState.inKnownLayerTask);
     threadState.inKnownLayerTask = true;
     return true;
 }
 
 void TimelineTraceEventProcessor::leaveLayerTask(TimelineThreadState& threadState)
 {
     threadState.inKnownLayerTask = false;
 }
@@ skipping 13 matching lines @@
         return;
     ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::DecodeImage));
     state.recordStack.closeScopedRecord(m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp()));
 }
 
 void TimelineTraceEventProcessor::onLayerDeleted(const TraceEvent& event)
 {
     unsigned long long id = event.id();
     ASSERT(id);
     processBackgroundEvents();
-    m_knownLayers.remove(id);
+    m_layerToNodeMap.remove(id);
 }
 
 void TimelineTraceEventProcessor::onPaint(const TraceEvent& event)
 {
     if (!m_layerId)
         return;
 
     unsigned long long pageId = event.asUInt(InstrumentationEventArguments::PageId);
-    if (pageId == m_pageId)
-        m_knownLayers.add(m_layerId);
+    if (pageId != m_pageId)
+        return;
+    long long nodeId = event.asInt(InstrumentationEventArguments::NodeId);
+    ASSERT(nodeId);
+    m_layerToNodeMap.set(m_layerId, nodeId);
 }
 
 PassRefPtr<InspectorObject> TimelineTraceEventProcessor::createRecord(const TraceEvent& event, const String& recordType, PassRefPtr<InspectorObject> data)
 {
     double startTime = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
     RefPtr<InspectorObject> record = TimelineRecordFactory::createBackgroundRecord(startTime, String::number(event.threadIdentifier()));
     record->setString("type", recordType);
     record->setObject("data", data ? data : InspectorObject::create());
     return record.release();
 }
@@ skipping 10 matching lines @@
     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);
     }
 }
 
 } // namespace WebCore