Oilpan: have PromiseTracker callback keep a WeakPersistent<>.

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/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "core/inspector/ScriptAsyncCallStack.h"
 #include "wtf/CurrentTime.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::PromiseWeakCallbackData final {
     WTF_MAKE_NONCOPYABLE(PromiseWeakCallbackData);
 public:
     PromiseWeakCallbackData(PromiseTracker* tracker, int id)
+#if ENABLE(OILPAN)
+        : m_tracker(tracker)
+#else
         : m_tracker(tracker->m_weakPtrFactory.createWeakPtr())
+#endif
         , m_id(id)
     {
     }
 
     ~PromiseWeakCallbackData()
     {
         if (!m_tracker)
             return;
         RefPtr<PromiseDetails> promiseDetails = PromiseDetails::create().setId(m_id);
         m_tracker->m_listener->didUpdatePromise(InspectorFrontend::Debugger::EventType::Gc, promiseDetails.release());

[haraken, 2015/08/21 00:16:25]

This does complicated things like posting a message, posting a task etc in a
destructor of PromiseWeakCallbackData. This is no problem since the
PromiseWeakCallbackData is off the heap but a bit nasty.

     }
 
-    WeakPtr<PromiseTracker> m_tracker;
+    WeakPtrWillBeWeakPersistent<PromiseTracker> m_tracker;
     int m_id;
 };
 
 PromiseTracker::IdToPromiseMapTraits::WeakCallbackDataType* PromiseTracker::IdToPromiseMapTraits::WeakCallbackParameter(MapType* map, int key, v8::Local<v8::Object>& value)
 {
     // This method is called when promise is added into the map, hence the map must be alive at this point. The tracker in turn must be alive too.
     PromiseTracker* tracker = reinterpret_cast<PromiseTracker*>(reinterpret_cast<intptr_t>(map) - offsetof(PromiseTracker, m_idToPromise));
     return new PromiseWeakCallbackData(tracker, key);
 }
 
@@ skipping 16 matching lines @@
 {
     return info.GetParameter()->m_id;
 }
 
 PromiseTracker::PromiseTracker(Listener* listener, v8::Isolate* isolate)
     : m_circularSequentialId(0)
     , m_isEnabled(false)
     , m_captureStacks(false)
     , m_listener(listener)
     , m_isolate(isolate)
+#if !ENABLE(OILPAN)
     , m_weakPtrFactory(this)
+#endif
     , m_idToPromise(isolate)
 {
     clear();
 }
 
 PromiseTracker::~PromiseTracker()
 {
 }
 
 DEFINE_TRACE(PromiseTracker)
@@ skipping 108 matching lines @@
 {
     ASSERT(isEnabled());
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> value = m_idToPromise.Get(promiseId);
     if (value.IsEmpty())
         return ScriptValue();
     return ScriptValue(ScriptState::from(value->CreationContext()) , value);
 }
 
 } // namespace blink