Have ScriptPromiseResolver on the Oilpan heap always.

Source/bindings/core/v8/ScriptPromiseResolver.h

Index: Source/bindings/core/v8/ScriptPromiseResolver.h
diff --git a/Source/bindings/core/v8/ScriptPromiseResolver.h b/Source/bindings/core/v8/ScriptPromiseResolver.h
index 62975ad0bc1763beb0fd12fff9eb1824089fb65a..3951db7b68e9b42deb9e030f448f66bdb057b2bb 100644
--- a/Source/bindings/core/v8/ScriptPromiseResolver.h
+++ b/Source/bindings/core/v8/ScriptPromiseResolver.h
@@ -26,15 +26,15 @@ namespace blink {
 //    ExecutionContext state. When the ExecutionContext is suspended,
 //    resolve or reject will be delayed. When it is stopped, resolve or reject
 //    will be ignored.
-class CORE_EXPORT ScriptPromiseResolver : public RefCountedWillBeRefCountedGarbageCollected<ScriptPromiseResolver>, public ActiveDOMObject {
+class CORE_EXPORT ScriptPromiseResolver : public GarbageCollectedFinalized<ScriptPromiseResolver>, public ActiveDOMObject {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(ScriptPromiseResolver);
     WTF_MAKE_NONCOPYABLE(ScriptPromiseResolver);
 public:
-    static PassRefPtrWillBeRawPtr<ScriptPromiseResolver> create(ScriptState* scriptState)
+    static ScriptPromiseResolver* create(ScriptState* scriptState)
     {
-        RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = adoptRefWillBeNoop(new ScriptPromiseResolver(scriptState));
+        ScriptPromiseResolver* resolver = new ScriptPromiseResolver(scriptState);
         resolver->suspendIfNeeded();
-        return resolver.release();
+        return resolver;
     }
 
 #if ENABLE(ASSERT)
@@ -107,10 +107,6 @@ private:
         Rejecting,
         ResolvedOrRejected,
     };
-    enum LifetimeMode {
-        Default,
-        KeepAliveWhilePending,
-    };
 
     template<typename T>
     void resolveOrReject(T value, ResolutionState newState)
@@ -119,16 +115,18 @@ private:
             return;
         ASSERT(newState == Resolving || newState == Rejecting);
         m_state = newState;
-        // Retain this object until it is actually resolved or rejected.
-        // |deref| will be called in |clear|.
-        ref();
 
         ScriptState::Scope scope(m_scriptState.get());
         m_value.set(
             m_scriptState->isolate(),
             toV8(value, m_scriptState->context()->Global(), m_scriptState->isolate()));
-        if (!executionContext()->activeDOMObjectsAreSuspended())
-            resolveOrRejectImmediately();
+
+        if (executionContext()->activeDOMObjectsAreSuspended()) {
+            // Retain this object until it is actually resolved or rejected.
+            keepAliveWhilePending();
+            return;
+        }
+        resolveOrRejectImmediately();
     }
 
     void resolveOrRejectImmediately();
@@ -137,7 +135,6 @@ private:
 
     ResolutionState m_state;
     const RefPtr<ScriptState> m_scriptState;
-    LifetimeMode m_mode;
     Timer<ScriptPromiseResolver> m_timer;
     Resolver m_resolver;
     ScopedPersistent<v8::Value> m_value;
@@ -145,6 +142,11 @@ private:
     // True if promise() is called.
     bool m_isPromiseCalled;
 #endif
+
+    // To support keepAliveWhilePending(), a self-referential
+    // Persistent<> is needed.

[haraken, 2015/07/17 01:40:35]

Can we use RefCountedGarbageCollected instead of manually creating a keep alive
perssitent? RefCountedGarbageCollected is the way to create the keep alive
persistent in a safe manner.

[sof, 2015/07/17 05:34:30]

I don't agree with that suggestion. Two reasons:

 - there's no counting required here.
 - it exposes reference counting as part of the public interface of these
objects; it's an internal implementation detail.

You'll find instances of local Persistent<> self keep alives elsewhere.

[haraken, 2015/07/17 06:52:52]

That is something we need to fix. I'm ok with either plan (i.e., using a self
keep alive handle or using RefCountedGarbageCollected) but we should avoid
mixing the two syntax in the code base.

a) Stop using RefCountedGarbageCollected for the self-keep-alive purpose. Use an
explicit persistent handle.

b) Use RefCountedGarbageCollected for the self-keep-alive purpose. Rename
ref/deref to a better name.

If your plan is to apply a) for all the code base, I'm fine with it :)

[sof, 2015/07/17 07:02:04]

What/where are they? (I don't know of any, off-hand.) We already have self-keep
alives using Persistent<> in places.

+    GC_PLUGIN_IGNORE("")
+    Persistent<ScriptPromiseResolver> m_keepAlive;
 };
 
 } // namespace blink