Clean up the fix of DevTools crashing in AsyncCallTracker.

Source/core/inspector/AsyncCallTracker.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 57 matching lines @@
         , m_animationFrameCallChains(tracker->m_debuggerAgent)
         , m_eventCallChains(tracker->m_debuggerAgent)
         , m_xhrCallChains(tracker->m_debuggerAgent)
         , m_mutationObserverCallChains(tracker->m_debuggerAgent)
         , m_executionContextTaskCallChains(tracker->m_debuggerAgent)
         , m_asyncOperationCallChains(tracker->m_debuggerAgent)
         , m_circularSequentialId(0)
     {
     }
 
     virtual void contextDestroyed() override

[haraken, 2015/01/13 15:17:48]

Who removes the ExecutionContextData from the observee (i.e., ExecutionContext)?
Or are you intentionally leaving the ExecutionContextData on the observee,
assuming that the ExecutionContext will be destructed soon? (That will work but
sound a bit hacky.)

[aandrey, 2015/01/13 15:39:25]

We could not unobserve from contextDestroyed() callback until your recent patch.
In this patch I assume this invariant is still valid.

The new unobserve() calls dispose() from the parent class which actually removes
the ExecutionContextData from the observee.

     {
         ASSERT(executionContext());
-        // It is possible that resetAsyncCallChains() is already called and thus
-        // this ExecutionContextData is removed from m_executionContextDataMap.
         OwnPtrWillBeRawPtr<ExecutionContextData> self = m_tracker->m_executionContextDataMap.take(executionContext());
-        if (self) {
-            dispose();
-        }
+        ASSERT_UNUSED(self, self == this);
         ContextLifecycleObserver::contextDestroyed();
+        clearLifecycleContext();
+        disposeCallChains();
+    }
+
+    void unobserve()
+    {
+        disposeCallChains();
+        dispose();
     }
 
     int nextAsyncOperationUniqueId()
     {
         do {
             ++m_circularSequentialId;
             if (m_circularSequentialId <= 0)
                 m_circularSequentialId = 1;
         } while (m_asyncOperationCallChains.contains(m_circularSequentialId));
         return m_circularSequentialId;
     }
 
     virtual void trace(Visitor* visitor) override
     {
         visitor->trace(m_tracker);
 #if ENABLE(OILPAN)
         visitor->trace(m_timerCallChains);
         visitor->trace(m_animationFrameCallChains);
         visitor->trace(m_eventCallChains);
         visitor->trace(m_xhrCallChains);
         visitor->trace(m_mutationObserverCallChains);
         visitor->trace(m_executionContextTaskCallChains);
         visitor->trace(m_asyncOperationCallChains);
 #endif
         ContextLifecycleObserver::trace(visitor);
     }
 
-    void dispose()
-    {
-        m_timerCallChains.dispose();
-        m_animationFrameCallChains.dispose();
-        m_eventCallChains.dispose();
-        m_xhrCallChains.dispose();
-        m_mutationObserverCallChains.dispose();
-        m_executionContextTaskCallChains.dispose();
-        m_asyncOperationCallChains.dispose();
-    }
-
     RawPtrWillBeMember<AsyncCallTracker> m_tracker;
     HashSet<int> m_intervalTimerIds;
     AsyncCallChainMap<int> m_timerCallChains;
     AsyncCallChainMap<int> m_animationFrameCallChains;
     AsyncCallChainMap<RawPtrWillBeMember<Event> > m_eventCallChains;
     AsyncCallChainMap<RawPtrWillBeMember<EventTarget> > m_xhrCallChains;
     AsyncCallChainMap<RawPtrWillBeMember<MutationObserver> > m_mutationObserverCallChains;
     AsyncCallChainMap<ExecutionContextTask*> m_executionContextTaskCallChains;
     AsyncCallChainMap<int> m_asyncOperationCallChains;
 
 private:
+    void disposeCallChains()
+    {
+        m_timerCallChains.dispose();
+        m_animationFrameCallChains.dispose();
+        m_eventCallChains.dispose();
+        m_xhrCallChains.dispose();
+        m_mutationObserverCallChains.dispose();
+        m_executionContextTaskCallChains.dispose();
+        m_asyncOperationCallChains.dispose();
+    }
+
     int m_circularSequentialId;
 };
 
 static XMLHttpRequest* toXmlHttpRequest(EventTarget* eventTarget)
 {
     const AtomicString& interfaceName = eventTarget->interfaceName();
     if (interfaceName == EventTargetNames::XMLHttpRequest)
         return static_cast<XMLHttpRequest*>(eventTarget);
     if (interfaceName == EventTargetNames::XMLHttpRequestUpload)
         return static_cast<XMLHttpRequestUpload*>(eventTarget)->xmlHttpRequest();
@@ skipping 12 matching lines @@
 }
 
 void AsyncCallTracker::asyncCallTrackingStateChanged(bool tracking)
 {
     m_instrumentingAgents->setAsyncCallTracker(tracking ? this : nullptr);
 }
 
 void AsyncCallTracker::resetAsyncCallChains()
 {
     for (auto& it : m_executionContextDataMap)
-        it.value->dispose();
+        it.value->unobserve();
     m_executionContextDataMap.clear();
 }
 
 void AsyncCallTracker::didInstallTimer(ExecutionContext* context, int timerId, int timeout, bool singleShot)
 {
     ASSERT(context);
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
     RefPtrWillBeRawPtr<AsyncCallChain> callChain = m_debuggerAgent->createAsyncCallChain(singleShot ? setTimeoutName : setIntervalName);
     if (!callChain)
         return;
@@ skipping 267 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContextDataMap);
     visitor->trace(m_debuggerAgent);
     visitor->trace(m_instrumentingAgents);
 #endif
     InspectorDebuggerAgent::AsyncCallTrackingListener::trace(visitor);
 }
 
 } // namespace blink