bindings: Use Maybe APIs in ScriptPromise

Source/bindings/core/v8/ScriptPromise.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 35 matching lines @@
     // Used by ToV8Value<WithScriptState, ScriptState*>.
     static v8::Handle<v8::Object> getCreationContext(ScriptState* scriptState)
     {
         return scriptState->context()->Global();
     }
 };
 
 } // 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
 {
     if (m_resolver.isEmpty())
         return v8::Local<v8::Promise>();
     return m_resolver.v8Value().As<v8::Promise::Resolver>()->GetPromise();
 }
 
 ScriptPromise ScriptPromise::InternalResolver::promise() const
 {
     if (m_resolver.isEmpty())
         return ScriptPromise();
     return ScriptPromise(m_resolver.scriptState(), v8Promise());
 }
 
 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();
 }
 
 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();
 }
 
 ScriptPromise::ScriptPromise(ScriptState* scriptState, v8::Handle<v8::Value> value)
     : m_scriptState(scriptState)
 {
     if (value.IsEmpty())
         return;
 
     if (!value->IsPromise()) {
@@ skipping 10 matching lines @@
         return ScriptPromise();
 
     v8::Local<v8::Object> promise = m_promise.v8Value().As<v8::Object>();
 
     ASSERT(promise->IsPromise());
     // Return this Promise if no handlers are given.
     // In fact it is not the exact bahavior of Promise.prototype.then
     // 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())
-        resultPromise = resultPromise->Catch(onRejected);
+    if (!onRejected.IsEmpty()) {
+        if (!resultPromise->Catch(m_scriptState->context(), onRejected).ToLocal(&resultPromise))
+            return ScriptPromise();
+    }
 
     return ScriptPromise(m_scriptState.get(), resultPromise);
 }
 
 ScriptPromise ScriptPromise::cast(ScriptState* scriptState, const ScriptValue& value)
 {
     return ScriptPromise::cast(scriptState, value.v8Value());
 }
 
 ScriptPromise ScriptPromise::cast(ScriptState* scriptState, v8::Handle<v8::Value> value)
@@ skipping 27 matching lines @@
 ScriptPromise ScriptPromise::rejectWithDOMException(ScriptState* scriptState, PassRefPtrWillBeRawPtr<DOMException> exception)
 {
     ASSERT(scriptState->isolate()->InContext());
     return reject(scriptState, toV8(exception, scriptState->context()->Global(), scriptState->isolate()));
 }
 
 v8::Local<v8::Promise> ScriptPromise::rejectRaw(v8::Isolate* isolate, v8::Handle<v8::Value> value)
 {
     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;
 }
 
 } // namespace blink