Have ScriptPromiseResolver on the Oilpan heap always.

Source/bindings/core/v8/ScriptPromiseResolver.h

 // 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.
 
 #ifndef ScriptPromiseResolver_h
 #define ScriptPromiseResolver_h
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ToV8.h"
 #include "core/CoreExport.h"
 #include "core/dom/ActiveDOMObject.h"
 #include "core/dom/ExecutionContext.h"
 #include "platform/Timer.h"
 #include "wtf/RefCounted.h"
 #include <v8.h>
 
 namespace blink {
 
 // This class wraps v8::Promise::Resolver and provides the following
 // functionalities.
 //  - A ScriptPromiseResolver retains a ScriptState. A caller
 //    can call resolve or reject from outside of a V8 context.
 //  - This class is an ActiveDOMObject and keeps track of the associated
 //    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)
     // Eagerly finalized so as to ensure valid access to executionContext()
     // from the destructor's assert.
     EAGERLY_FINALIZE();
 
     ~ScriptPromiseResolver() override
     {
         // This assertion fails if:
@@ skipping 52 matching lines @@
     explicit ScriptPromiseResolver(ScriptState*);
 
 private:
     typedef ScriptPromise::InternalResolver Resolver;
     enum ResolutionState {
         Pending,
         Resolving,
         Rejecting,
         ResolvedOrRejected,
     };
-    enum LifetimeMode {
-        Default,
-        KeepAliveWhilePending,
-    };
 
     template<typename T>
     void resolveOrReject(T value, ResolutionState newState)
     {
         if (m_state != Pending || !executionContext() || executionContext()->activeDOMObjectsAreStopped())
             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();

[yhirano, 2015/07/16 07:09:30]

This ref() was called to keep the resolver alive while suspending even if
unreacheable. How do you guarantee that without this call?

[sof, 2015/07/16 07:13:54]

The object is on the stack and thereby reachable.

[yhirano, 2015/07/16 07:19:38]

I think about the following case, for example.

// Assume the document is suspended.
// |resolver| is the only reference to the resolver.
resolver->resolve(...);
// |resolveOrRejectImmediately| is not called. it will be called when
// resumed.

resolver = nullptr;

// Here the resolver is unreacheable but should be alive until
// resume() or stop() is called.

[sof, 2015/07/16 07:33:23]

Thanks. Yes, we need retain a strong reference for that case now also. Updated
to do so.

 
         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();
     }
 
     void resolveOrRejectImmediately();
     void onTimerFired(Timer<ScriptPromiseResolver>*);
     void clear();
 
     ResolutionState m_state;
     const RefPtr<ScriptState> m_scriptState;
-    LifetimeMode m_mode;
     Timer<ScriptPromiseResolver> m_timer;
     Resolver m_resolver;
     ScopedPersistent<v8::Value> m_value;
 #if ENABLE(ASSERT)
     // True if promise() is called.
     bool m_isPromiseCalled;
 #endif
+
+    // To support keepAliveWhilePending(), a self-referential
+    // Persistent<> is needed.
+    GC_PLUGIN_IGNORE("")
+    Persistent<ScriptPromiseResolver> m_keepAlive;
 };
 
 } // namespace blink
 
 #endif // ScriptPromiseResolver_h