Introduce KeepAliveWhilePending to ScriptPromiseResolverWithContext.

Source/bindings/v8/ScriptPromiseResolverWithContext.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 ScriptPromiseResolverWithContext_h
 #define ScriptPromiseResolverWithContext_h
 
 #include "bindings/v8/ScopedPersistent.h"
 #include "bindings/v8/ScriptPromise.h"
 #include "bindings/v8/ScriptPromiseResolver.h"
@@ skipping 13 matching lines @@
 //  - A ScriptPromiseResolverWithContext 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 ScriptPromiseResolverWithContext : public ActiveDOMObject, public RefCounted<ScriptPromiseResolverWithContext> {
     WTF_MAKE_NONCOPYABLE(ScriptPromiseResolverWithContext);
 
 public:
-    static PassRefPtr<ScriptPromiseResolverWithContext> create(ScriptState* scriptState)
+    enum Mode {
+        Default,
+        KeepSelfWhilePending,

[haraken, 2014/06/16 10:54:04]

KeepAliveWhilePending ?

[yhirano, 2014/06/16 11:47:51]

Done.

+    };
+
+    // Create a ScriptPromiseResolverWithContext.
+    // If |mode| is KeepSelfWhilePending, the resolver refers itself in order
+    // to stay alive while the promise is pending and the accosiated
+    // ExecutionContext isn't stopped.
+    static PassRefPtr<ScriptPromiseResolverWithContext> create(ScriptState* scriptState, Mode mode = Default)
     {
-        RefPtr<ScriptPromiseResolverWithContext> resolver = adoptRef(new ScriptPromiseResolverWithContext(scriptState));
+        RefPtr<ScriptPromiseResolverWithContext> resolver = adoptRef(new ScriptPromiseResolverWithContext(scriptState, mode));
         resolver->suspendIfNeeded();
         return resolver.release();
     }
 
+    virtual ~ScriptPromiseResolverWithContext();
+
     // Anything that can be passed to toV8Value can be passed to this function.
     template <typename T>
     void resolve(T value)
     {
         resolveOrReject(value, Resolving);
     }
 
     // Anything that can be passed to toV8Value can be passed to this function.
     template <typename T>
     void reject(T value)
@@ skipping 11 matching lines @@
     }
 
     ScriptState* scriptState() const { return m_scriptState.get(); }
 
     // ActiveDOMObject implementation.
     virtual void suspend() OVERRIDE;
     virtual void resume() OVERRIDE;
     virtual void stop() OVERRIDE;
 
 protected:
-    explicit ScriptPromiseResolverWithContext(ScriptState*);
+    ScriptPromiseResolverWithContext(ScriptState*, Mode);
 
 private:
     enum ResolutionState {
         Pending,
         Resolving,
         Rejecting,
         ResolvedOrRejected,
     };
 
     template<typename T>
     v8::Handle<v8::Value> toV8Value(const T& value)
     {
         return ToV8Value<ScriptPromiseResolverWithContext, v8::Handle<v8::Object> >::toV8Value(value, m_scriptState->context()->Global(), m_scriptState->isolate());
     }
 
     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();
 
         ScriptState::Scope scope(m_scriptState.get());
         m_value.set(m_scriptState->isolate(), toV8Value(value));
         if (!executionContext()->activeDOMObjectsAreSuspended())
             resolveOrRejectImmediately();
     }
 
     void resolveOrRejectImmediately();
     void onTimerFired(Timer<ScriptPromiseResolverWithContext>*);
     void clear();
 
     ResolutionState m_state;
     const RefPtr<ScriptState> m_scriptState;
+    Mode m_mode;
     Timer<ScriptPromiseResolverWithContext> m_timer;
     RefPtr<ScriptPromiseResolver> m_resolver;
     ScopedPersistent<v8::Value> m_value;
 };
 
 } // namespace WebCore
 
 #endif // #ifndef ScriptPromiseResolverWithContext_h