Introduce Promise mapping to the IDL generator

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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ScriptPromiseResolver_h
 #define ScriptPromiseResolver_h
 
 #include "bindings/v8/ScopedPersistent.h"
 #include "bindings/v8/ScriptObject.h"
+#include "bindings/v8/ScriptPromise.h"
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/ScriptValue.h"
 #include "wtf/RefPtr.h"
 
 #include <v8.h>
 
 namespace WebCore {
 
 class ScriptExecutionContext;
 
@@ skipping 30 matching lines @@
 
     // Detach the promise object.
     void detachPromise() { m_promise.clear(); }
 
     // Return true if the following conditions are met:
     //  - The resolver object is not detached.
     //  - The resolver's promise object is in pending state.
     //  - The resolver's resolved flag is not set.
     bool isPending() const;
 
-    ScriptObject promise()
+    ScriptPromise promise()
     {
         ASSERT(v8::Context::InContext());
-        return ScriptObject(ScriptState::current(), m_promise.newLocal(m_isolate));
+        return m_promise;
     }
 
     // Fulfill with a C++ object which can be converted to a v8 object by toV8.
     template<typename T>
     inline void fulfill(PassRefPtr<T>);
     // Resolve with a C++ object which can be converted to a v8 object by toV8.
     template<typename T>
     inline void resolve(PassRefPtr<T>);
     // Reject with a C++ object which can be converted to a v8 object by toV8.
     template<typename T>
     inline void reject(PassRefPtr<T>);
 
     void fulfill(ScriptValue);
     void resolve(ScriptValue);
     void reject(ScriptValue);
 
 private:
     ScriptPromiseResolver(v8::Handle<v8::Object> creationContext, v8::Isolate*);
     void fulfill(v8::Handle<v8::Value>);
     void resolve(v8::Handle<v8::Value>);
     void reject(v8::Handle<v8::Value>);
 
     v8::Isolate* m_isolate;
-    ScopedPersistent<v8::Object> m_promise;
+    ScriptPromise m_promise;

[haraken, 2013/09/03 17:03:07]

I still don't fully understand why this doesn't cause memory leaks nor leaks
between isolated worlds. Would you add a comment about it?

[yhirano, 2013/09/04 02:14:15]

Users of ScriptPromiseResolver should call detachPromise if they do  not need
the Promise object, as the class comment says. Otherwise a memory leak may be
introduced.
In a similar way, users of ScriptPromiseResolver should call fulfill / resolve /
reject if the operation completes or fails. Otherwise a memory leak may be
introduced.
Destroying the ScriptPromiseResolver object will detach the Promise and the
PromiseResolver objects.

In short, you have to call such methods manually if you hold
ScriptPromiseResolver as a member variable.

     ScopedPersistent<v8::Object> m_resolver;
     bool isPendingInternal() const;
 };
 
 template<typename T>
 void ScriptPromiseResolver::fulfill(PassRefPtr<T> value)
 {
     ASSERT(v8::Context::InContext());
     fulfill(toV8(value.get(), v8::Object::New(), m_isolate));
 }
 
 template<typename T>
 void ScriptPromiseResolver::resolve(PassRefPtr<T> value)
 {
     ASSERT(v8::Context::InContext());
     resolve(toV8(value.get(), v8::Object::New(), m_isolate));
 }
 
 template<typename T>
 void ScriptPromiseResolver::reject(PassRefPtr<T> value)
 {
     ASSERT(v8::Context::InContext());
     reject(toV8(value.get(), v8::Object::New(), m_isolate));
 }
 
 } // namespace WebCore
 
 
 #endif // ScriptPromiseResolver_h