Introduce KeepAliveWhilePending to ScriptPromiseResolverWithContext.

Source/bindings/v8/ScriptPromiseResolverWithContext.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 "bindings/v8/ScriptPromiseResolverWithContext.h"
 
 #include "bindings/v8/V8RecursionScope.h"
 
 namespace WebCore {
 
-ScriptPromiseResolverWithContext::ScriptPromiseResolverWithContext(ScriptState* scriptState)
+ScriptPromiseResolverWithContext::ScriptPromiseResolverWithContext(ScriptState* scriptState, Mode mode)
     : ActiveDOMObject(scriptState->executionContext())
     , m_state(Pending)
     , m_scriptState(scriptState)
+    , m_mode(mode)
     , m_timer(this, &ScriptPromiseResolverWithContext::onTimerFired)
     , m_resolver(ScriptPromiseResolver::create(m_scriptState.get()))
 {
+    if (mode == KeepSelfWhilePending) {
+        // Keep |this| while the promise is Pending.
+        // deref() will be called in clear().
+        ref();
+    }
+}
+
+ScriptPromiseResolverWithContext::~ScriptPromiseResolverWithContext()
+{
+    if (m_state != ResolvedOrRejected) {
+        ScriptState::Scope scope(m_scriptState.get());
+        reject(v8::Exception::Error(v8::String::NewFromUtf8(m_scriptState->isolate(),
+            "ScriptPromiseResolverWithContext is destructed without resolve / reject")));
+    }
 }
 
 void ScriptPromiseResolverWithContext::suspend()
 {
     m_timer.stop();
 }
 
 void ScriptPromiseResolverWithContext::resume()
 {
     if (m_state == Resolving || m_state == Rejecting)
         m_timer.startOneShot(0, FROM_HERE);
 }
 
 void ScriptPromiseResolverWithContext::stop()
 {
+    ScriptState::Scope scope(m_scriptState.get());
     m_timer.stop();
     clear();
 }
 
 void ScriptPromiseResolverWithContext::onTimerFired(Timer<ScriptPromiseResolverWithContext>*)
 {
     RefPtr<ScriptPromiseResolverWithContext> protect(this);
     ScriptState::Scope scope(m_scriptState.get());
     resolveOrRejectImmediately();
 }
@@ skipping 12 matching lines @@
         } else {
             ASSERT(m_state == Rejecting);
             m_resolver->reject(m_value.newLocal(m_scriptState->isolate()));
         }
     }
     clear();
 }
 
 void ScriptPromiseResolverWithContext::clear()
 {
+    if (m_state == ResolvedOrRejected)
+        return;
+    RefPtr<ScriptPromiseResolverWithContext> protect(this);

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

Why is this protect needed?

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

It was needed because I checked m_mode after calling deref.
Now it is not needed because I exchanged two deref blocks.

     ResolutionState state = m_state;
     m_state = ResolvedOrRejected;
     m_resolver.clear();
     m_value.clear();
     if (state == Resolving || state == Rejecting) {
         // |ref| was called in |resolveOrReject|.
         deref();

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

Just help me understand: What's the relationship between this deref() and the
deref() you introduced in this CL?

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

ref() in constructor is for keeping the resolver while the promise is pending.
ref() in resolveOrReject is for keeping the resolver while the resolver is
resolving or rejecting the Promise and the execution context is suspended.

     }
-    // |this| may be deleted here.
+    if (m_mode == KeepSelfWhilePending) {
+        // |ref| was called in the constructor.
+        deref();
+    }
 }
 
 } // namespace WebCore