Oilpan: fix PromiseTracker's handling of its persistent promise wrappers.

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)
+    WeakPtr<PromiseData> createWeakPtr()
+    {
+        return m_weakPtrFactory.createWeakPtr();
+    }
+#endif
+
     void trace(Visitor* visitor)
     {
         visitor->trace(m_callStack);
     }
 
-    WeakPtrWillBeRawPtr<PromiseData> createWeakPtr()
-    {
-#if ENABLE(OILPAN)
-        return this;
-#else
-        return m_weakPtrFactory.createWeakPtr();
-#endif
-    }
-
 private:
     friend class PromiseTracker;
 
     PromiseData(v8::Isolate* isolate, int promiseHash, int promiseId, v8::Handle<v8::Object> promise)
         : m_promiseHash(promiseHash)
         , m_promiseId(promiseId)
         , m_promise(isolate, promise)
         , m_parentPromiseId(0)
         , m_status(0)
 #if !ENABLE(OILPAN)
@@ skipping 20 matching lines @@
         if (vector->at(index)->promise() == promise)
             return index;
     }
     return -1;
 }
 
 namespace {
 
 class PromiseDataWrapper FINAL : public NoBaseWillBeGarbageCollected<PromiseDataWrapper> {
 public:
-    static PassOwnPtrWillBeRawPtr<PromiseDataWrapper> create(PromiseTracker::PromiseData* data, PromiseTracker::PromiseDataMap* map)
+    static PassOwnPtrWillBeRawPtr<PromiseDataWrapper> create(PromiseTracker::PromiseData* data, PromiseTracker* tracker)
     {
-        return adoptPtrWillBeNoop(new PromiseDataWrapper(data->createWeakPtr(), map));
+#if ENABLE(OILPAN)
+        return new PromiseDataWrapper(data, tracker);
+#else
+        return adoptPtr(new PromiseDataWrapper(data->createWeakPtr(), tracker));
+#endif
     }
 
+#if ENABLE(OILPAN)
+    static void didRemovePromise(const v8::WeakCallbackData<v8::Object, Persistent<PromiseDataWrapper> >& data)
+#else
     static void didRemovePromise(const v8::WeakCallbackData<v8::Object, PromiseDataWrapper>& data)
+#endif
     {
-        OwnPtrWillBeRawPtr<PromiseDataWrapper> wrapper = adoptPtrWillBeNoop(data.GetParameter());
+#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)
+        if (!promiseData || !wrapper->m_tracker)
             return;
-        PromiseTracker::PromiseDataMap* map = wrapper->m_promiseDataMap;
+        PromiseTracker::PromiseDataMap& map = wrapper->m_tracker->promiseDataMap();
         int promiseHash = promiseData->promiseHash();
-        PromiseTracker::PromiseDataVector* vector = &map->find(promiseHash)->value;
+        PromiseTracker::PromiseDataVector* vector = &map.find(promiseHash)->value;
         int index = indexOf(vector, promiseData->promise());
         ASSERT(index >= 0);
         vector->remove(index);
-        if (vector->size() == 0)
-            map->remove(promiseHash);
+        if (!vector->size())

[aandrey, 2014/09/10 14:42:18]

if (vector->isEmpty())

[sof, 2014/09/11 05:20:53]

Done.

+            map.remove(promiseHash);
     }
 
     void trace(Visitor* visitor)
     {
 #if ENABLE(OILPAN)
         visitor->trace(m_data);
-        visitor->trace(m_promiseDataMap);
+        visitor->trace(m_tracker);
 #endif
     }
 
 private:
-    PromiseDataWrapper(WeakPtrWillBeRawPtr<PromiseTracker::PromiseData> data, PromiseTracker::PromiseDataMap* map)
+    PromiseDataWrapper(WeakPtrWillBeRawPtr<PromiseTracker::PromiseData> data,  PromiseTracker* tracker)

[aandrey, 2014/09/10 14:42:18]

nit: extra space before PromiseTracker*

[sof, 2014/09/11 05:20:53]

Well spotted :)

         : m_data(data)
-        , m_promiseDataMap(map)
+        , m_tracker(tracker)
     {
     }
 
-    WeakPtrWillBeMember<PromiseTracker::PromiseData> m_data;
-    RawPtrWillBeMember<PromiseTracker::PromiseDataMap> m_promiseDataMap;
+    WeakPtrWillBeWeakMember<PromiseTracker::PromiseData> m_data;
+    RawPtrWillBeWeakMember<PromiseTracker> m_tracker;
 };
 
 }
 
 PromiseTracker::PromiseTracker()
-    : m_isEnabled(false)
-    , m_circularSequentialId(0)
+    : m_circularSequentialId(0)
+    , m_isEnabled(false)
 {
 }
 
-PromiseTracker::~PromiseTracker()
-{
-}
+DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(PromiseTracker);
 
 void PromiseTracker::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_promiseDataMap);
 #endif
 }
 
 void PromiseTracker::setEnabled(bool enabled)
 {
@@ skipping 18 matching lines @@
 PassRefPtrWillBeRawPtr<PromiseTracker::PromiseData> PromiseTracker::createPromiseDataIfNeeded(v8::Isolate* isolate, v8::Handle<v8::Object> promise)
 {
     int promiseHash = promise->GetIdentityHash();
     RawPtr<PromiseDataVector> vector = nullptr;
     PromiseDataMap::iterator it = m_promiseDataMap.find(promiseHash);
     if (it != m_promiseDataMap.end())
         vector = &it->value;
     else
         vector = &m_promiseDataMap.add(promiseHash, PromiseDataVector()).storedValue->value;
 
-    RefPtrWillBeRawPtr<PromiseData> data = nullptr;
     int index = indexOf(vector, ScopedPersistent<v8::Object>(isolate, promise));
-    if (index == -1) {
-        data = PromiseData::create(isolate, promiseHash, circularSequentialId(), promise);
-        OwnPtrWillBeRawPtr<PromiseDataWrapper> wrapper = PromiseDataWrapper::create(data.get(), &m_promiseDataMap);
-        data->m_promise.setWeak(wrapper.leakPtr(), &PromiseDataWrapper::didRemovePromise);
-        vector->append(data);
-    } else {
-        data = vector->at(index);
-    }
+    if (index != -1)
+        return vector->at(index);
+
+    RefPtrWillBeRawPtr<PromiseData> data = PromiseData::create(isolate, promiseHash, circularSequentialId(), promise);
+    OwnPtrWillBeRawPtr<PromiseDataWrapper> dataWrapper = PromiseDataWrapper::create(data.get(), this);
+#if ENABLE(OILPAN)
+    OwnPtr<Persistent<PromiseDataWrapper> > wrapper = adoptPtr(new Persistent<PromiseDataWrapper>(dataWrapper.leakPtr()));
+#else
+    OwnPtr<PromiseDataWrapper> wrapper = dataWrapper.release();
+#endif
+    data->m_promise.setWeak(wrapper.leakPtr(), &PromiseDataWrapper::didRemovePromise);
+    vector->append(data);
 
     return data.release();
 }
 
 void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status)
 {
     ASSERT(isEnabled());
 
     v8::Isolate* isolate = scriptState->isolate();
     RefPtrWillBeRawPtr<PromiseData> data = createPromiseDataIfNeeded(isolate, promise);
@@ skipping 37 matching lines @@
             if (data->m_callStack)
                 promiseDetails->setCallFrame(data->m_callStack->at(0).buildInspectorObject());
             result->addItem(promiseDetails);
         }
     }
 
     return result.release();
 }
 
 } // namespace blink