Oilpan: handle delayed removal of PromiseTracker promises.

Source/core/inspector/PromiseTracker.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/inspector/PromiseTracker.h"
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/WeakPtr.h"
 
 using blink::TypeBuilder::Array;
 using blink::TypeBuilder::Console::CallFrame;
 using blink::TypeBuilder::Debugger::PromiseDetails;
 
 namespace blink {
 
 class PromiseTracker::PromiseData FINAL : public RefCountedWillBeGarbageCollectedFinalized<PromiseData> {
 public:
     static PassRefPtrWillBeRawPtr<PromiseData> create(v8::Isolate* isolate, int promiseHash, int promiseId, v8::Handle<v8::Object> promise)
     {
         return adoptRefWillBeNoop(new PromiseData(isolate, promiseHash, promiseId, promise));
     }
 
     int promiseHash() const { return m_promiseHash; }
     ScopedPersistent<v8::Object>& promise() { return m_promise; }
 
-#if !ENABLE(OILPAN)
+#if ENABLE(OILPAN)
+    void dispose()
+    {
+        m_promise.clear();
+        m_parentPromise.clear();
+    }
+#else
     WeakPtr<PromiseData> createWeakPtr()
     {
         return m_weakPtrFactory.createWeakPtr();
     }
 #endif
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_callStack);
     }
@@ skipping 55 matching lines @@
     {
 #if ENABLE(OILPAN)
         OwnPtr<Persistent<PromiseDataWrapper> > persistentWrapper = adoptPtr(data.GetParameter());
         RawPtr<PromiseDataWrapper> wrapper = *persistentWrapper;
 #else
         OwnPtr<PromiseDataWrapper> wrapper = adoptPtr(data.GetParameter());
 #endif
         WeakPtrWillBeRawPtr<PromiseTracker::PromiseData> promiseData = wrapper->m_data;
         if (!promiseData || !wrapper->m_tracker)
             return;
+
+#if ENABLE(OILPAN)
+        // Oilpan: let go of ScopedPersistent<>s right here (and not wait until the
+        // PromiseDataWrapper is GCed later.) The v8 weak callback handling expects
+        // to see the callback data upon return.
+        promiseData->dispose();
+#endif
         PromiseTracker::PromiseDataMap& map = wrapper->m_tracker->promiseDataMap();
         int promiseHash = promiseData->promiseHash();
-        PromiseTracker::PromiseDataVector* vector = &map.find(promiseHash)->value;
+
+        PromiseTracker::PromiseDataMap::iterator it = map.find(promiseHash);
+        // The PromiseTracker may have been disabled (and, possibly, re-enabled later),
+        // leaving the promiseHash as unmapped.
+        if (it == map.end())
+            return;
+
+        PromiseTracker::PromiseDataVector* vector = &it->value;
         int index = indexOf(vector, promiseData->promise());
         ASSERT(index >= 0);
         vector->remove(index);
         if (vector->isEmpty())
             map.remove(promiseHash);
     }
 
     void trace(Visitor* visitor)
     {
 #if ENABLE(OILPAN)
@@ skipping 126 matching lines @@
             if (data->m_callStack)
                 promiseDetails->setCallFrame(data->m_callStack->at(0).buildInspectorObject());
             result->addItem(promiseDetails);
         }
     }
 
     return result.release();
 }
 
 } // namespace blink