Oilpan: clear out AsyncCallChainMaps in an orderly manner.

Source/core/inspector/AsyncCallStackTracker.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 45 matching lines @@
 
 }
 
 namespace blink {
 
 template <class K>
 class AsyncCallStackTracker::AsyncCallChainMap final {
     ALLOW_ONLY_INLINE_ALLOCATION();
 public:
     using MapType = WillBeHeapHashMap<K, RefPtrWillBeMember<AsyncCallStackTracker::AsyncCallChain>>;
-    explicit AsyncCallChainMap(AsyncCallStackTracker* tracker) : m_tracker(tracker) { }
+    explicit AsyncCallChainMap(AsyncCallStackTracker* tracker)
+        : m_tracker(tracker)
+    {
+    }
 
     ~AsyncCallChainMap()
     {
-        clear();
+        // Verify that this object has been explicitly cleared already.
+        ASSERT(!m_tracker);
     }
 
-    void clear()
+    void dispose()

[aandrey, 2014/12/12 10:18:53]

turns out, we also need clear(), see comment below.

[sof, 2014/12/12 10:32:47]

Done.

     {
+        ASSERT(m_tracker);
         for (auto it : m_asyncCallChains) {
             if (AsyncCallStackTracker::Listener* listener = m_tracker->m_listener)
                 listener->didRemoveAsyncCallChain(it.value.get());
             else
                 break;
         }
         m_asyncCallChains.clear();
+        m_tracker = nullptr;
     }
 
     void set(typename MapType::KeyPeekInType key, PassRefPtrWillBeRawPtr<AsyncCallChain> chain)
     {
         m_asyncCallChains.set(key, chain);
     }
 
     bool contains(typename MapType::KeyPeekInType key) const
     {
         return m_asyncCallChains.contains(key);
     }
 
     PassRefPtrWillBeRawPtr<AsyncCallChain> get(typename MapType::KeyPeekInType key) const
     {
         return m_asyncCallChains.get(key);
     }
 
     void remove(typename MapType::KeyPeekInType key)
     {
+        ASSERT(m_tracker);
         RefPtrWillBeRawPtr<AsyncCallStackTracker::AsyncCallChain> chain = m_asyncCallChains.take(key);
         if (chain && m_tracker->m_listener)
             m_tracker->m_listener->didRemoveAsyncCallChain(chain.get());
     }
 
     void trace(Visitor* visitor)
     {
+        visitor->trace(m_tracker);
         visitor->trace(m_asyncCallChains);
     }
 
 private:
-    AsyncCallStackTracker* m_tracker;
+    RawPtrWillBeMember<AsyncCallStackTracker> m_tracker;
     MapType m_asyncCallChains;
 };
 
 class AsyncCallStackTracker::ExecutionContextData final : public NoBaseWillBeGarbageCollectedFinalized<ExecutionContextData>, public ContextLifecycleObserver {
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
     ExecutionContextData(AsyncCallStackTracker* tracker, ExecutionContext* executionContext)
         : ContextLifecycleObserver(executionContext)
         , m_tracker(tracker)
         , m_timerCallChains(tracker)
         , m_animationFrameCallChains(tracker)
         , m_eventCallChains(tracker)
         , m_xhrCallChains(tracker)
         , m_mutationObserverCallChains(tracker)
         , m_executionContextTaskCallChains(tracker)
         , m_v8AsyncTaskCallChains(tracker)
         , m_asyncOperationCallChains(tracker)
         , m_circularSequentialId(0)
     {
     }
 
     virtual void contextDestroyed() override
     {
         ASSERT(executionContext());
         OwnPtrWillBeRawPtr<ExecutionContextData> self = m_tracker->m_executionContextDataMap.take(executionContext());
         ASSERT_UNUSED(self, self == this);
         ContextLifecycleObserver::contextDestroyed();
+        dispose();
     }
 
     int nextAsyncOperationUniqueId()
     {
         do {
             ++m_circularSequentialId;
             if (m_circularSequentialId <= 0)
                 m_circularSequentialId = 1;
         } while (m_asyncOperationCallChains.contains(m_circularSequentialId));
         return m_circularSequentialId;
     }
 
     void trace(Visitor* visitor)
     {
         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_v8AsyncTaskCallChains);
         visitor->trace(m_asyncOperationCallChains);
 #endif
     }
 
+    void dispose()
+    {
+        m_timerCallChains.dispose();
+        m_animationFrameCallChains.dispose();
+        m_eventCallChains.dispose();
+        m_xhrCallChains.dispose();
+        m_mutationObserverCallChains.dispose();
+        m_executionContextTaskCallChains.dispose();
+        m_v8AsyncTaskCallChains.dispose();
+        m_asyncOperationCallChains.dispose();
+    }
+
     RawPtrWillBeMember<AsyncCallStackTracker> 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<String> m_v8AsyncTaskCallChains;
     AsyncCallChainMap<int> m_asyncOperationCallChains;
@@ skipping 250 matching lines @@
         return;
     ExecutionContextData* data = createContextDataIfNeeded(context);
     data->m_executionContextTaskCallChains.set(task, createAsyncCallChain(task->taskNameForInstrumentation(), callFrames));
 }
 
 void AsyncCallStackTracker::didKillAllExecutionContextTasks(ExecutionContext* context)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
-        data->m_executionContextTaskCallChains.clear();
+        data->m_executionContextTaskCallChains.dispose();

[aandrey, 2014/12/12 10:18:53]

this should be clear() and leave m_executionContextTaskCallChains reusable (do
not clear m_tracker).

[sof, 2014/12/12 10:26:06]

Seems like the null check in clear() wasn't such a bad idea?

[sof, 2014/12/12 10:32:47]

Done.

 }
 
 void AsyncCallStackTracker::willPerformExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     if (ExecutionContextData* data = m_executionContextDataMap.get(context)) {
         setCurrentAsyncCallChain(context, data->m_executionContextTaskCallChains.get(task));
         data->m_executionContextTaskCallChains.remove(task);
     } else {
@@ skipping 143 matching lines @@
         data = m_executionContextDataMap.set(context, adoptPtrWillBeNoop(new AsyncCallStackTracker::ExecutionContextData(this, context)))
             .storedValue->value.get();
     }
     return data;
 }
 
 void AsyncCallStackTracker::clear()
 {
     m_currentAsyncCallChain.clear();
     m_nestedAsyncCallCount = 0;
+    for (auto& it : m_executionContextDataMap)
+        it.value->dispose();
     m_executionContextDataMap.clear();
 }
 
 void AsyncCallStackTracker::trace(Visitor* visitor)
 {
     visitor->trace(m_currentAsyncCallChain);
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContextDataMap);
 #endif
 }
 
 } // namespace blink