bindings: Use Maybe APIs in ScriptPromise

Source/bindings/core/v8/ScriptPromisePropertyBase.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/core/v8/ScriptPromisePropertyBase.h"
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 19 matching lines @@
 {
     data.GetParameter()->clear();
 }
 
 ScriptPromise ScriptPromisePropertyBase::promise(DOMWrapperWorld& world)
 {
     if (!executionContext())
         return ScriptPromise();
 
     v8::HandleScope handleScope(m_isolate);
-    v8::Handle<v8::Context> context = toV8Context(executionContext(), world);
+    v8::Local<v8::Context> context = toV8Context(executionContext(), world);
     if (context.IsEmpty())
         return ScriptPromise();
     ScriptState* scriptState = ScriptState::from(context);
     ScriptState::Scope scope(scriptState);
 
-    v8::Handle<v8::Object> wrapper = ensureHolderWrapper(scriptState);
+    v8::Local<v8::Object> wrapper = ensureHolderWrapper(scriptState);
     ASSERT(wrapper->CreationContext() == context);
 
-    v8::Handle<v8::Value> cachedPromise = V8HiddenValue::getHiddenValue(m_isolate, wrapper, promiseName());
+    v8::Local<v8::Value> cachedPromise = V8HiddenValue::getHiddenValue(m_isolate, wrapper, promiseName());
     if (!cachedPromise.IsEmpty())
         return ScriptPromise(scriptState, cachedPromise);
 
     // Create and cache the Promise
-    v8::Handle<v8::Promise::Resolver> resolver = v8::Promise::Resolver::New(m_isolate);
-    v8::Handle<v8::Promise> promise = resolver->GetPromise();
+    v8::Local<v8::Promise::Resolver> resolver;
+    if (!v8::Promise::Resolver::New(context).ToLocal(&resolver))
+        return ScriptPromise();
+    v8::Local<v8::Promise> promise = resolver->GetPromise();
     V8HiddenValue::setHiddenValue(m_isolate, wrapper, promiseName(), promise);
 
     switch (m_state) {
     case Pending:
         // Cache the resolver too
         V8HiddenValue::setHiddenValue(m_isolate, wrapper, resolverName(), resolver);
         break;
     case Resolved:
     case Rejected:
         resolveOrRejectInternal(resolver);
@@ skipping 34 matching lines @@
 }
 
 void ScriptPromisePropertyBase::resetBase()
 {
     clearWrappers();
     m_state = Pending;
 }
 
 void ScriptPromisePropertyBase::resolveOrRejectInternal(v8::Handle<v8::Promise::Resolver> resolver)
 {
+    v8::Local<v8::Context> context = resolver->CreationContext();
     switch (m_state) {
     case Pending:
         ASSERT_NOT_REACHED();
         break;
     case Resolved:
-        resolver->Resolve(resolvedValue(m_isolate, resolver->CreationContext()->Global()));
+        resolver->Resolve(context, resolvedValue(m_isolate, context->Global()));
         break;
     case Rejected:
-        resolver->Reject(rejectedValue(m_isolate, resolver->CreationContext()->Global()));
+        resolver->Reject(context, rejectedValue(m_isolate, context->Global()));
         break;
     }
 }
 
 v8::Local<v8::Object> ScriptPromisePropertyBase::ensureHolderWrapper(ScriptState* scriptState)
 {
     v8::Local<v8::Context> context = scriptState->context();
     size_t i = 0;
     while (i < m_wrappers.size()) {
         const OwnPtr<ScopedPersistent<v8::Object>>& persistent = m_wrappers[i];
@@ skipping 60 matching lines @@
     ASSERT_NOT_REACHED();
     return v8::Handle<v8::String>();
 }
 
 DEFINE_TRACE(ScriptPromisePropertyBase)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink