ScriptPromise should understand the ScriptState from which the ScriptPromise is generated

Source/bindings/v8/ScriptPromiseResolver.h

 /*
  * 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 50 matching lines @@
 // To prevent memory leaks, you should release the reference manually
 // by calling resolve or reject.
 // Destroying the object will also release the reference.
 // Note that ScriptPromiseResolver::promise returns an empty value when the
 // resolver is already resolved or rejected. If you want to resolve a resolver
 // immediately and return the associated promise, you should get the promise
 // before resolving.
 class ScriptPromiseResolver : public RefCounted<ScriptPromiseResolver> {
     WTF_MAKE_NONCOPYABLE(ScriptPromiseResolver);
 public:
-    static PassRefPtr<ScriptPromiseResolver> create(ExecutionContext*);
-    static PassRefPtr<ScriptPromiseResolver> create(v8::Isolate*);
+    static PassRefPtr<ScriptPromiseResolver> create(ScriptState*);
 
     // A ScriptPromiseResolver should be resolved / rejected before
     // its destruction.
     // A ScriptPromiseResolver can be destructed safely without
     // entering a v8 context.
     ~ScriptPromiseResolver();
 
     // Returns the underlying Promise.
     // Note that the underlying Promise is cleared when |resolve| or |reject|
     // is called.
     ScriptPromise promise();
 
     template<typename T>
     void resolve(const T& value, ExecutionContext* executionContext)
     {
-        ASSERT(m_isolate->InContext());
+        ASSERT(m_scriptState->isolate()->InContext());
         // You should use ScriptPromiseResolverWithContext when you want
         // to resolve a Promise in a non-original V8 context.
         return resolve(value);
     }
     template<typename T>
     void reject(const T& value, ExecutionContext* executionContext)
     {
-        ASSERT(m_isolate->InContext());
+        ASSERT(m_scriptState->isolate()->InContext());
         // You should use ScriptPromiseResolverWithContext when you want
         // to reject a Promise in a non-original V8 context.
         return reject(value);
     }
     template<typename T>
     void resolve(const T& value)
     {
-        ASSERT(m_isolate->InContext());
+        ASSERT(m_scriptState->isolate()->InContext());
         resolve(toV8Value(value));
     }
     template<typename T>
     void reject(const T& value)
     {
-        ASSERT(m_isolate->InContext());
+        ASSERT(m_scriptState->isolate()->InContext());
         reject(toV8Value(value));
     }
     template<typename T> void resolve(const T& value, v8::Handle<v8::Object> creationContext)
     {
-        ASSERT(m_isolate->InContext());
+        ASSERT(m_scriptState->isolate()->InContext());
         resolve(toV8Value(value, creationContext));
     }
     template<typename T> void reject(const T& value, v8::Handle<v8::Object> creationContext)
     {
-        ASSERT(m_isolate->InContext());
+        ASSERT(m_scriptState->isolate()->InContext());
         reject(toV8Value(value, creationContext));
     }
 
-    v8::Isolate* isolate() const { return m_isolate; }
+    v8::Isolate* isolate() const { return m_scriptState->isolate(); }
 
     void resolve(v8::Handle<v8::Value>);
     void reject(v8::Handle<v8::Value>);
 
     // Used by ToV8Value<ScriptPromiseResolver, v8::Handle<v8::Object> >.
     static v8::Handle<v8::Object> getCreationContext(v8::Handle<v8::Object> creationContext)
     {
         return creationContext;
     }
-    // Used by ToV8Value<ScriptPromiseResolver, v8::Isolate*>.
-    static v8::Handle<v8::Object> getCreationContext(v8::Isolate* isolate)
+    // Used by ToV8Value<ScriptPromiseResolver, ScriptState*>.
+    static v8::Handle<v8::Object> getCreationContext(ScriptState* scriptState)
     {
-        return ScriptState::current(isolate)->context()->Global();
+        return scriptState->context()->Global();
     }
 
 private:
     template<typename T>
     v8::Handle<v8::Value> toV8Value(const T& value, v8::Handle<v8::Object> creationContext)
     {
-        return ToV8Value<ScriptPromiseResolver, v8::Handle<v8::Object> >::toV8Value(value, creationContext, m_isolate);
+        return ToV8Value<ScriptPromiseResolver, v8::Handle<v8::Object> >::toV8Value(value, creationContext, m_scriptState->isolate());
     }
 
     template<typename T>
     v8::Handle<v8::Value> toV8Value(const T& value)
     {
-        return ToV8Value<ScriptPromiseResolver, v8::Isolate*>::toV8Value(value, m_isolate, m_isolate);
+        return ToV8Value<ScriptPromiseResolver, ScriptState*>::toV8Value(value, m_scriptState.get(), m_scriptState->isolate());
     }
 
-    ScriptPromiseResolver(ExecutionContext*);
-    ScriptPromiseResolver(v8::Isolate*);
+    explicit ScriptPromiseResolver(ScriptState*);
 
-    v8::Isolate* m_isolate;
+    // FIXME: Remove this once ScriptValue::scriptState() becomes available.
+    RefPtr<ScriptState> m_scriptState;
     // Used when scriptPromiseOnV8Promise is disabled.
     ScriptPromise m_promise;
     // Used when scriptPromiseOnV8Promise is enabled.
     ScriptValue m_resolver;
 };
 
 } // namespace WebCore
 
 
 #endif // ScriptPromiseResolver_h