DevTools: use async operation id instead of AsyncCallChain

Source/core/inspector/AsyncCallTracker.cpp

Index: Source/core/inspector/AsyncCallTracker.cpp
diff --git a/Source/core/inspector/AsyncCallTracker.cpp b/Source/core/inspector/AsyncCallTracker.cpp
index 4800999323634e697aa919cb4c4f047ad19bd9f3..ec63c851430626512020e9d9f013adfaff103811 100644
--- a/Source/core/inspector/AsyncCallTracker.cpp
+++ b/Source/core/inspector/AsyncCallTracker.cpp
@@ -53,6 +53,8 @@ static const char requestAnimationFrameName[] = "requestAnimationFrame";
 static const char xhrSendName[] = "XMLHttpRequest.send";
 static const char enqueueMutationRecordName[] = "Mutation";
 
+const int noOperationId = 0;

[aandrey, 2015/01/20 14:33:35]

noAsyncOperationId or nullAsyncOperationId?
make a public const?

[yurys, 2015/01/20 17:15:38]

Done.

+
 }
 
 namespace blink {
@@ -178,12 +180,12 @@ void AsyncCallTracker::didInstallTimer(ExecutionContext* context, int timerId, i
 {
     ASSERT(context);
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
-    RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->traceAsyncOperationStarting(singleShot ? setTimeoutName : setIntervalName);
-    if (!callChain)
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(singleShot ? setTimeoutName : setIntervalName);
+    if (!operationId)
         return;
     ASSERT(timerId > 0);
     ExecutionContextData* data = createContextDataIfNeeded(context);
-    data->m_timerCallChains.set(timerId, callChain.release());
+    data->m_timerCallChains.set(timerId, operationId);
     if (!singleShot)
         data->m_intervalTimerIds.add(timerId);
 }
@@ -212,7 +214,7 @@ bool AsyncCallTracker::willFireTimer(ExecutionContext* context, int timerId)
         if (!data->m_intervalTimerIds.contains(timerId))
             data->m_timerCallChains.remove(timerId);
     } else {
-        setCurrentAsyncCallChain(context, nullptr);
+        setCurrentAsyncCallChain(context, noOperationId);
     }
     return true;
 }
@@ -221,12 +223,12 @@ void AsyncCallTracker::didRequestAnimationFrame(ExecutionContext* context, int c
 {
     ASSERT(context);
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
-    RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->traceAsyncOperationStarting(requestAnimationFrameName);
-    if (!callChain)
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(requestAnimationFrameName);
+    if (!operationId)
         return;
     ASSERT(callbackId > 0);
     ExecutionContextData* data = createContextDataIfNeeded(context);
-    data->m_animationFrameCallChains.set(callbackId, callChain.release());
+    data->m_animationFrameCallChains.set(callbackId, operationId);
 }
 
 void AsyncCallTracker::didCancelAnimationFrame(ExecutionContext* context, int callbackId)
@@ -249,7 +251,7 @@ bool AsyncCallTracker::willFireAnimationFrame(ExecutionContext* context, int cal
         setCurrentAsyncCallChain(context, data->m_animationFrameCallChains.get(callbackId));
         data->m_animationFrameCallChains.remove(callbackId);
     } else {
-        setCurrentAsyncCallChain(context, nullptr);
+        setCurrentAsyncCallChain(context, noOperationId);
     }
     return true;
 }
@@ -258,11 +260,11 @@ void AsyncCallTracker::didEnqueueEvent(EventTarget* eventTarget, Event* event)
 {
     ASSERT(eventTarget->executionContext());
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
-    RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->traceAsyncOperationStarting(event->type());
-    if (!callChain)
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(event->type());
+    if (!operationId)
         return;
     ExecutionContextData* data = createContextDataIfNeeded(eventTarget->executionContext());
-    data->m_eventCallChains.set(event, callChain.release());
+    data->m_eventCallChains.set(event, operationId);
 }
 
 void AsyncCallTracker::didRemoveEvent(EventTarget* eventTarget, Event* event)
@@ -284,7 +286,7 @@ void AsyncCallTracker::willHandleEvent(EventTarget* eventTarget, Event* event, E
         if (ExecutionContextData* data = m_executionContextDataMap.get(context))
             setCurrentAsyncCallChain(context, data->m_eventCallChains.get(event));
         else
-            setCurrentAsyncCallChain(context, nullptr);
+            setCurrentAsyncCallChain(context, noOperationId);
     }
 }
 
@@ -294,11 +296,11 @@ void AsyncCallTracker::willLoadXHR(XMLHttpRequest* xhr, ThreadableLoaderClient*,
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
     if (!async)
         return;
-    RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->traceAsyncOperationStarting(xhrSendName);
-    if (!callChain)
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(xhrSendName);
+    if (!operationId)
         return;
     ExecutionContextData* data = createContextDataIfNeeded(xhr->executionContext());
-    data->m_xhrCallChains.set(xhr, callChain.release());
+    data->m_xhrCallChains.set(xhr, operationId);
 }
 
 void AsyncCallTracker::didDispatchXHRLoadendEvent(XMLHttpRequest* xhr)
@@ -317,7 +319,7 @@ void AsyncCallTracker::willHandleXHREvent(XMLHttpRequest* xhr, Event* event)
     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
         setCurrentAsyncCallChain(context, data->m_xhrCallChains.get(xhr));
     else
-        setCurrentAsyncCallChain(context, nullptr);
+        setCurrentAsyncCallChain(context, noOperationId);
 }
 
 void AsyncCallTracker::didEnqueueMutationRecord(ExecutionContext* context, MutationObserver* observer)
@@ -327,10 +329,10 @@ void AsyncCallTracker::didEnqueueMutationRecord(ExecutionContext* context, Mutat
     ExecutionContextData* data = createContextDataIfNeeded(context);
     if (data->m_mutationObserverCallChains.contains(observer))
         return;
-    RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->traceAsyncOperationStarting(enqueueMutationRecordName);
-    if (!callChain)
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(enqueueMutationRecordName);
+    if (!operationId)
         return;
-    data->m_mutationObserverCallChains.set(observer, callChain.release());
+    data->m_mutationObserverCallChains.set(observer, operationId);
 }
 
 void AsyncCallTracker::didClearAllMutationRecords(ExecutionContext* context, MutationObserver* observer)
@@ -349,7 +351,7 @@ void AsyncCallTracker::willDeliverMutationRecords(ExecutionContext* context, Mut
         setCurrentAsyncCallChain(context, data->m_mutationObserverCallChains.get(observer));
         data->m_mutationObserverCallChains.remove(observer);
     } else {
-        setCurrentAsyncCallChain(context, nullptr);
+        setCurrentAsyncCallChain(context, noOperationId);
     }
 }
 
@@ -359,11 +361,11 @@ void AsyncCallTracker::didPostExecutionContextTask(ExecutionContext* context, Ex
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
     if (task->taskNameForInstrumentation().isEmpty())
         return;
-    RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->traceAsyncOperationStarting(task->taskNameForInstrumentation());
-    if (!callChain)
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(task->taskNameForInstrumentation());
+    if (!operationId)
         return;
     ExecutionContextData* data = createContextDataIfNeeded(context);
-    data->m_executionContextTaskCallChains.set(task, callChain.release());
+    data->m_executionContextTaskCallChains.set(task, operationId);
 }
 
 void AsyncCallTracker::didKillAllExecutionContextTasks(ExecutionContext* context)
@@ -382,7 +384,7 @@ void AsyncCallTracker::willPerformExecutionContextTask(ExecutionContext* context
         setCurrentAsyncCallChain(context, data->m_executionContextTaskCallChains.get(task));
         data->m_executionContextTaskCallChains.remove(task);
     } else {
-        setCurrentAsyncCallChain(context, nullptr);
+        setCurrentAsyncCallChain(context, noOperationId);
     }
 }
 
@@ -392,12 +394,12 @@ int AsyncCallTracker::traceAsyncOperationStarting(ExecutionContext* context, con
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
     if (prevOperationId)
         traceAsyncOperationCompleted(context, prevOperationId);
-    RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->traceAsyncOperationStarting(operationName);
-    if (!callChain)
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(operationName);
+    if (!operationId)
         return 0;
     ExecutionContextData* data = createContextDataIfNeeded(context);
     int id = data->nextAsyncOperationUniqueId();

[aandrey, 2015/01/20 14:33:35]

remove, use a Set of operationId's

[yurys, 2015/01/20 17:15:38]

Done.

-    data->m_asyncOperationCallChains.set(id, callChain.release());
+    data->m_asyncOperationCallChains.set(id, operationId);
     return id;
 }
 
@@ -422,9 +424,9 @@ void AsyncCallTracker::traceAsyncCallbackStarting(ExecutionContext* context, int
     ASSERT(context);
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
-        setCurrentAsyncCallChain(context, operationId > 0 ? data->m_asyncOperationCallChains.get(operationId) : nullptr);
+        setCurrentAsyncCallChain(context, operationId > 0 ? data->m_asyncOperationCallChains.get(operationId) : noOperationId);
     else
-        setCurrentAsyncCallChain(context, nullptr);
+        setCurrentAsyncCallChain(context, noOperationId);
 }
 
 void AsyncCallTracker::didFireAsyncCall()
@@ -432,9 +434,9 @@ void AsyncCallTracker::didFireAsyncCall()
     m_debuggerAgent->traceAsyncCallbackCompleted();
 }
 
-void AsyncCallTracker::setCurrentAsyncCallChain(ExecutionContext* context, PassRefPtrWillBeRawPtr<AsyncCallChain> chain)
+void AsyncCallTracker::setCurrentAsyncCallChain(ExecutionContext* context, int operationId)
 {
-    m_debuggerAgent->traceAsyncCallbackStarting(toIsolate(context), chain);
+    m_debuggerAgent->traceAsyncCallbackStarting(toIsolate(context), operationId);
 }
 
 AsyncCallTracker::ExecutionContextData* AsyncCallTracker::createContextDataIfNeeded(ExecutionContext* context)