bindings: Use Maybe APIs in ScriptPromise

Source/bindings/core/v8/ScriptPromise.cpp

Index: Source/bindings/core/v8/ScriptPromise.cpp
diff --git a/Source/bindings/core/v8/ScriptPromise.cpp b/Source/bindings/core/v8/ScriptPromise.cpp
index e059e6a77069576bf0db05fa8a737c63f6f68630..b1c17c4ab8f561dd2203fa3e43cb4d60c108b943 100644
--- a/Source/bindings/core/v8/ScriptPromise.cpp
+++ b/Source/bindings/core/v8/ScriptPromise.cpp
@@ -53,7 +53,7 @@ struct WithScriptState {
 } // namespace
 
 ScriptPromise::InternalResolver::InternalResolver(ScriptState* scriptState)
-    : m_resolver(scriptState, v8::Promise::Resolver::New(scriptState->isolate())) { }
+    : m_resolver(scriptState, v8::Promise::Resolver::New(scriptState->context())) { }
 
 v8::Local<v8::Promise> ScriptPromise::InternalResolver::v8Promise() const
 {
@@ -73,7 +73,7 @@ void ScriptPromise::InternalResolver::resolve(v8::Local<v8::Value> value)
 {
     if (m_resolver.isEmpty())
         return;
-    m_resolver.v8Value().As<v8::Promise::Resolver>()->Resolve(value);
+    m_resolver.v8Value().As<v8::Promise::Resolver>()->Resolve(m_resolver.context(), value);
     clear();
 }
 
@@ -81,7 +81,7 @@ void ScriptPromise::InternalResolver::reject(v8::Local<v8::Value> value)
 {
     if (m_resolver.isEmpty())
         return;
-    m_resolver.v8Value().As<v8::Promise::Resolver>()->Reject(value);
+    m_resolver.v8Value().As<v8::Promise::Resolver>()->Reject(m_resolver.context(), value);
     clear();
 }
 
@@ -112,15 +112,13 @@ ScriptPromise ScriptPromise::then(v8::Handle<v8::Function> onFulfilled, v8::Hand
     // but that is not a problem in this case.
     v8::Local<v8::Promise> resultPromise = promise.As<v8::Promise>();
     if (!onFulfilled.IsEmpty()) {
-        resultPromise = resultPromise->Then(onFulfilled);
-        if (resultPromise.IsEmpty()) {
-            // v8::Promise::Then may return an empty value, for example when

[bashi, 2015/03/25 03:52:29]

Removed this comment as this can be said on all other Maybe APIs.

-            // the stack is exhausted.
+        if (!resultPromise->Then(m_scriptState->context(), onFulfilled).ToLocal(&resultPromise))
+            return ScriptPromise();
+    }
+    if (!onRejected.IsEmpty()) {
+        if (!resultPromise->Catch(m_scriptState->context(), onRejected).ToLocal(&resultPromise))
             return ScriptPromise();
-        }
     }
-    if (!onRejected.IsEmpty())
-        resultPromise = resultPromise->Catch(onRejected);
 
     return ScriptPromise(m_scriptState.get(), resultPromise);
 }
@@ -168,9 +166,11 @@ v8::Local<v8::Promise> ScriptPromise::rejectRaw(v8::Isolate* isolate, v8::Handle
 {
     if (value.IsEmpty())
         return v8::Local<v8::Promise>();
-    v8::Local<v8::Promise::Resolver> resolver = v8::Promise::Resolver::New(isolate);
+    v8::Local<v8::Promise::Resolver> resolver;
+    if (!v8::Promise::Resolver::New(isolate->GetCurrentContext()).ToLocal(&resolver))

[haraken, 2015/03/25 04:29:59]

It seems better to pass ScriptState* to rejectWithDOMException. We want to avoid
calling GetCurrentContext in places where it's not clear we're in a correct
context or not. It's OK to call GetCurrentContext in binding callbacks (that are
directly called back by JS) but we want to avoid GetCurrentContext in other
places as much as possible.

[bashi, 2015/03/25 04:56:00]

Done.

+        return v8::Local<v8::Promise>();
     v8::Local<v8::Promise> promise = resolver->GetPromise();
-    resolver->Reject(value);
+    resolver->Reject(isolate->GetCurrentContext(), value);
     return promise;
 }