Tried using CrossThreadPersistent for workerDebuggerAgents

Source/core/inspector/InspectorTimelineAgent.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 139 matching lines @@
         , skipWhenUnbalanced(false)
     {
     }
     RefPtr<TimelineEvent> record;
     RefPtr<JSONObject> data;
     RefPtr<TypeBuilder::Array<TimelineEvent> > children;
     String type;
     bool skipWhenUnbalanced;
 };
 
-class TimelineRecordStack {
+class TimelineRecordStack : public NoBaseWillBeGarbageCollectedFinalized<TimelineRecordStack> {
 private:
     struct Entry {
         Entry(PassRefPtr<TimelineEvent> record, const String& type)
             : record(record)
             , children(TypeBuilder::Array<TimelineEvent>::create())
 #ifndef NDEBUG
             , type(type)
 #endif
         {
         }
 
         RefPtr<TimelineEvent> record;
         RefPtr<TypeBuilder::Array<TimelineEvent> > children;
 #ifndef NDEBUG
         String type;
 #endif
     };
 
 public:
-    TimelineRecordStack() : m_timelineAgent(0) { }
+    TimelineRecordStack() : m_timelineAgent(nullptr) { }
     TimelineRecordStack(InspectorTimelineAgent*);
 
     void addScopedRecord(PassRefPtr<TimelineEvent> record, const String& type);
     void closeScopedRecord(double endTime);
     void addInstantRecord(PassRefPtr<TimelineEvent> record);
 
 #ifndef NDEBUG
     bool isOpenRecordOfType(const String& type);
 #endif
 
+    void trace(Visitor*);
+
 private:
     void send(PassRefPtr<JSONObject>);
 
-    InspectorTimelineAgent* m_timelineAgent;
+    RawPtrWillBeMember<InspectorTimelineAgent> m_timelineAgent;
     Vector<Entry> m_stack;
 };
 
-struct TimelineThreadState {
+struct TimelineThreadState : public NoBaseWillBeGarbageCollectedFinalized<TimelineThreadState> {
     TimelineThreadState() { }
 
     TimelineThreadState(InspectorTimelineAgent* timelineAgent)
-        : recordStack(timelineAgent)
+        : recordStack(adoptPtrWillBeNoop(new TimelineRecordStack(timelineAgent)))
         , inKnownLayerTask(false)
         , decodedPixelRefId(0)
     {
     }
 
-    TimelineRecordStack recordStack;
+    void trace(Visitor*);
+
+    OwnPtrWillBeMember<TimelineRecordStack> recordStack;
     bool inKnownLayerTask;
     unsigned long long decodedPixelRefId;
 };
 
 struct TimelineImageInfo {
     int backendNodeId;
     String url;
 
     TimelineImageInfo() : backendNodeId(0) { }
     TimelineImageInfo(int backendNodeId, String url) : backendNodeId(backendNodeId), url(url) { }
@@ skipping 35 matching lines @@
     addRecordToTimeline(record.release(), time);
     if (m_state->getBoolean(TimelineAgentState::includeCounters)) {
         addRecordToTimeline(createCountersUpdate(), time);
     }
 }
 
 InspectorTimelineAgent::~InspectorTimelineAgent()
 {
 }
 
+void InspectorTimelineAgent::trace(Visitor* visitor)
+{
+    visitor->trace(m_pageAgent);
+    visitor->trace(m_layerTreeAgent);
+    visitor->trace(m_threadStates);
+    InspectorBaseAgent::trace(visitor);
+}
+
 void InspectorTimelineAgent::setFrontend(InspectorFrontend* frontend)
 {
     m_frontend = frontend->timeline();
 }
 
 void InspectorTimelineAgent::clearFrontend()
 {
     ErrorString error;
     RefPtr<TypeBuilder::Array<TimelineEvent> > events;
     stop(&error, events);
@@ skipping 605 matching lines @@
 {
     appendRecord(TimelineRecordFactory::createGenericWebSocketData(identifier), TimelineRecordType::WebSocketDestroy, true, document->frame());
 }
 
 void InspectorTimelineAgent::onBeginImplSideFrame(const TraceEventDispatcher::TraceEvent& event)
 {
     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
     if (layerTreeId != m_layerTreeId)
         return;
     TimelineThreadState& state = threadState(event.threadIdentifier());
-    state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::BeginFrame, JSONObject::create()));
+    state.recordStack->addInstantRecord(createRecordForEvent(event, TimelineRecordType::BeginFrame, JSONObject::create()));
 }
 
 void InspectorTimelineAgent::onPaintSetupBegin(const TraceEventDispatcher::TraceEvent& event)
 {
     ASSERT(!m_paintSetupStart);
     m_paintSetupStart = event.timestamp() * msPerSecond;
 }
 
 void InspectorTimelineAgent::onPaintSetupEnd(const TraceEventDispatcher::TraceEvent& event)
 {
     ASSERT(m_paintSetupStart);
     m_paintSetupEnd = event.timestamp() * msPerSecond;
 }
 
 void InspectorTimelineAgent::onRasterTaskBegin(const TraceEventDispatcher::TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     unsigned long long layerId = event.asUInt(InstrumentationEventArguments::LayerId);
     ASSERT(layerId);
     if (!m_layerToNodeMap.contains(layerId))
         return;
     ASSERT(!state.inKnownLayerTask);
     state.inKnownLayerTask = true;
     double timestamp = event.timestamp() * msPerSecond;
     RefPtr<JSONObject> data = TimelineRecordFactory::createLayerData(m_layerToNodeMap.get(layerId));
     RefPtr<TimelineEvent> record = TimelineRecordFactory::createBackgroundRecord(timestamp, String::number(event.threadIdentifier()), TimelineRecordType::Rasterize, data);
-    state.recordStack.addScopedRecord(record, TimelineRecordType::Rasterize);
+    state.recordStack->addScopedRecord(record, TimelineRecordType::Rasterize);
 }
 
 void InspectorTimelineAgent::onRasterTaskEnd(const TraceEventDispatcher::TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     if (!state.inKnownLayerTask)
         return;
-    ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::Rasterize));
-    state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
+    ASSERT(state.recordStack->isOpenRecordOfType(TimelineRecordType::Rasterize));
+    state.recordStack->closeScopedRecord(event.timestamp() * msPerSecond);
     state.inKnownLayerTask = false;
 }
 
 void InspectorTimelineAgent::onImageDecodeBegin(const TraceEventDispatcher::TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     if (!state.decodedPixelRefId && !state.inKnownLayerTask)
         return;
     TimelineImageInfo imageInfo;
     if (state.decodedPixelRefId) {
         PixelRefToImageInfoMap::const_iterator it = m_pixelRefToImageInfo.find(state.decodedPixelRefId);
         if (it != m_pixelRefToImageInfo.end())
             imageInfo = it->value;
         else
             ASSERT_NOT_REACHED();
     }
     RefPtr<JSONObject> data = JSONObject::create();
     TimelineRecordFactory::setImageDetails(data.get(), imageInfo.backendNodeId, imageInfo.url);
     double timeestamp = event.timestamp() * msPerSecond;
-    state.recordStack.addScopedRecord(TimelineRecordFactory::createBackgroundRecord(timeestamp, String::number(event.threadIdentifier()), TimelineRecordType::DecodeImage, data), TimelineRecordType::DecodeImage);
+    state.recordStack->addScopedRecord(TimelineRecordFactory::createBackgroundRecord(timeestamp, String::number(event.threadIdentifier()), TimelineRecordType::DecodeImage, data), TimelineRecordType::DecodeImage);
 }
 
 void InspectorTimelineAgent::onImageDecodeEnd(const TraceEventDispatcher::TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     if (!state.decodedPixelRefId)
         return;
-    ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::DecodeImage));
-    state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
+    ASSERT(state.recordStack->isOpenRecordOfType(TimelineRecordType::DecodeImage));
+    state.recordStack->closeScopedRecord(event.timestamp() * msPerSecond);
 }
 
 void InspectorTimelineAgent::onRequestMainThreadFrame(const TraceEventDispatcher::TraceEvent& event)
 {
     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
     if (layerTreeId != m_layerTreeId)
         return;
     TimelineThreadState& state = threadState(event.threadIdentifier());
-    state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::RequestMainThreadFrame, JSONObject::create()));
+    state.recordStack->addInstantRecord(createRecordForEvent(event, TimelineRecordType::RequestMainThreadFrame, JSONObject::create()));
 }
 
 void InspectorTimelineAgent::onActivateLayerTree(const TraceEventDispatcher::TraceEvent& event)
 {
     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
     if (layerTreeId != m_layerTreeId)
         return;
     unsigned long long frameId = event.asUInt(InstrumentationEventArguments::FrameId);
     TimelineThreadState& state = threadState(event.threadIdentifier());
-    state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::ActivateLayerTree, TimelineRecordFactory::createFrameData(frameId)));
+    state.recordStack->addInstantRecord(createRecordForEvent(event, TimelineRecordType::ActivateLayerTree, TimelineRecordFactory::createFrameData(frameId)));
 }
 
 void InspectorTimelineAgent::onDrawFrame(const TraceEventDispatcher::TraceEvent& event)
 {
     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
     if (layerTreeId != m_layerTreeId)
         return;
     TimelineThreadState& state = threadState(event.threadIdentifier());
-    state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::DrawFrame, JSONObject::create()));
+    state.recordStack->addInstantRecord(createRecordForEvent(event, TimelineRecordType::DrawFrame, JSONObject::create()));
 }
 
 void InspectorTimelineAgent::onLayerDeleted(const TraceEventDispatcher::TraceEvent& event)
 {
     unsigned long long id = event.id();
     ASSERT(id);
     m_layerToNodeMap.remove(id);
 }
 
 void InspectorTimelineAgent::onDecodeLazyPixelRefBegin(const TraceEventDispatcher::TraceEvent& event)
@@ skipping 44 matching lines @@
         }
     }
 }
 
 void InspectorTimelineAgent::onEmbedderCallbackBegin(const TraceEventDispatcher::TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
     double timestamp = event.timestamp() * msPerSecond;
     RefPtr<JSONObject> data = TimelineRecordFactory::createEmbedderCallbackData(event.asString(InstrumentationEventArguments::CallbackName));
     RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(timestamp, 0, TimelineRecordType::EmbedderCallback, data);
-    state.recordStack.addScopedRecord(record, TimelineRecordType::EmbedderCallback);
+    state.recordStack->addScopedRecord(record, TimelineRecordType::EmbedderCallback);
 }
 
 void InspectorTimelineAgent::onEmbedderCallbackEnd(const TraceEventDispatcher::TraceEvent& event)
 {
     TimelineThreadState& state = threadState(event.threadIdentifier());
-    state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
+    state.recordStack->closeScopedRecord(event.timestamp() * msPerSecond);
 }
 
 void InspectorTimelineAgent::addRecordToTimeline(PassRefPtr<TimelineEvent> record, double ts)
 {
     commitFrameRecord();
     innerAddRecordToTimeline(record);
     if (m_bufferedEvents && ts - m_lastProgressTimestamp > 300) {
         m_lastProgressTimestamp = ts;
         m_frontend->progress(m_bufferedEvents->length());
     }
@@ skipping 130 matching lines @@
     if (hasLowLevelDetails && !m_platformInstrumentationClientInstalledAtStackDepth && !PlatformInstrumentation::hasClient()) {
         m_platformInstrumentationClientInstalledAtStackDepth = m_recordStack.size();
         PlatformInstrumentation::setClient(this);
     }
 }
 
 TimelineThreadState& InspectorTimelineAgent::threadState(ThreadIdentifier thread)
 {
     ThreadStateMap::iterator it = m_threadStates.find(thread);
     if (it != m_threadStates.end())
-        return it->value;
-    return m_threadStates.add(thread, TimelineThreadState(this)).storedValue->value;
+        return *(it->value);
+    return *(m_threadStates.add(thread, adoptPtrWillBeNoop(new TimelineThreadState(this))).storedValue->value);
 }
 
 void InspectorTimelineAgent::commitFrameRecord()
 {
     if (!m_pendingFrameRecord)
         return;
     innerAddRecordToTimeline(m_pendingFrameRecord.release());
 }
 
 void InspectorTimelineAgent::clearRecordStack()
@@ skipping 87 matching lines @@
         m_stack.last().children->addItem(record);
 }
 
 #ifndef NDEBUG
 bool TimelineRecordStack::isOpenRecordOfType(const String& type)
 {
     return !m_stack.isEmpty() && m_stack.last().type == type;
 }
 #endif
 
+void TimelineRecordStack::trace(Visitor* visitor)
+{
+    visitor->trace(m_timelineAgent);
+}
+
+void TimelineThreadState::trace(Visitor* visitor)
+{
+    visitor->trace(recordStack);
+}
+
 } // namespace WebCore