Implement V8ValueTraits<T>::toV8Value conversion functions

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 67 matching lines @@
     // 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();
 
-    // To use following template methods, T must be a DOM class.
-    template<typename T>
-    void resolve(T* value, v8::Handle<v8::Object> creationContext) { resolve(toV8NoInline(value, creationContext, m_isolate)); }
-    template<typename T>
-    void reject(T* value, v8::Handle<v8::Object> creationContext) { reject(toV8NoInline(value, creationContext, m_isolate)); }
+    template <typename T>
+    void resolve(T value)
+    {
+        ASSERT(m_isolate->InContext());
+        resolve(value, v8::Object::New(m_isolate));

[haraken, 2014/04/18 03:59:58]

Do you want to create a new object just for getting a creation context? Can't we
use a global object of the current context?

+    }
+    template <typename T>
+    inline void reject(T value)
+    {
+        ASSERT(m_isolate->InContext());
+        reject(value, v8::Object::New(m_isolate));

[haraken, 2014/04/18 03:59:58]

Ditto.

+    }
 
-    template<typename T>
-    void resolve(PassRefPtr<T> value, v8::Handle<v8::Object> creationContext) { resolve(value.get(), creationContext); }
-    template<typename T>
-    void resolve(RawPtr<T> value, v8::Handle<v8::Object> creationContext) { resolve(value.get(), creationContext); }
-    template<typename T>
-    void reject(PassRefPtr<T> value, v8::Handle<v8::Object> creationContext) { reject(value.get(), creationContext); }
-    template<typename T>
-    void reject(RawPtr<T> value, v8::Handle<v8::Object> creationContext) { reject(value.get(), creationContext); }
-
-    template<typename T>
-    inline void resolve(T* value, ExecutionContext*);
-    template<typename T>
-    inline void reject(T* value, ExecutionContext*);
-
-    template<typename T>
-    void resolve(PassRefPtr<T> value, ExecutionContext* context) { resolve(value.get(), context); }
-    template<typename T>
-    void resolve(RawPtr<T> value, ExecutionContext* context) { resolve(value.get(), context); }
-    template<typename T>
-    void reject(PassRefPtr<T> value, ExecutionContext* context) { reject(value.get(), context); }
-    template<typename T>
-    void reject(RawPtr<T> value, ExecutionContext* context) { reject(value.get(), context); }
-
-    template<typename T>
-    inline void resolve(T* value);
-    template<typename T>
-    inline void reject(T* value);
-
-    template<typename T, size_t inlineCapacity>
-    void resolve(const Vector<T, inlineCapacity>& iterator) { resolve(v8ArrayNoInline(iterator, m_isolate)); }
-    template<typename T, size_t inlineCapacity>
-    void reject(const Vector<T, inlineCapacity>& iterator) { reject(v8ArrayNoInline(iterator, m_isolate)); }
-
-    template<typename T>
-    void resolve(PassRefPtr<T> value) { resolve(value.get()); }
-    template<typename T>
-    void resolve(RawPtr<T> value) { resolve(value.get()); }
-    template<typename T>
-    void reject(PassRefPtr<T> value) { reject(value.get()); }
-    template<typename T>
-    void reject(RawPtr<T> value) { reject(value.get()); }
-
-    void resolve(ScriptValue);
-    void reject(ScriptValue);
-
-    v8::Isolate* isolate() const { return m_isolate; }
+    template <typename T>
+    inline void resolve(T value, ExecutionContext* context)
+    {
+        ASSERT(m_isolate->InContext());
+        resolve(toV8Value(value, context));
+    }
+    template <typename T>
+    inline void reject(T value, ExecutionContext* context)
+    {
+        ASSERT(m_isolate->InContext());
+        reject(toV8Value(value, context));
+    }
+    template <typename T>
+    inline void resolve(T value, v8::Handle<v8::Object> creationContext)
+    {
+        ASSERT(m_isolate->InContext());
+        resolve(toV8Value(value, creationContext));
+    }
+    template <typename T>
+    inline void reject(T value, v8::Handle<v8::Object> creationContext)
+    {
+        ASSERT(m_isolate->InContext());
+        reject(toV8Value(value, creationContext));
+    }
 
     void resolve(v8::Handle<v8::Value>);
     void reject(v8::Handle<v8::Value>);
 
+    v8::Isolate* isolate() const { return m_isolate; }
+
 private:
+
+    template <typename T>
+    struct ToV8ValueHelper {
+        static v8::Handle<v8::Value> toV8Value(const T& value, ExecutionContext* context, v8::Isolate* isolate)
+        {
+            v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current(isolate));

[haraken, 2014/04/18 03:59:58]

Not related to this CL, I think it's wrong to use the current world here. It's
not guaranteed that the current world at this point is the world in which we
want to create a new V8 object. (I'll fix the issue in the near future.)

+            return V8ValueTraits<T>::toV8Value(value, v8Context->Global(), isolate);
+        }
+        static v8::Handle<v8::Value> toV8Value(const T& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+        {
+            return V8ValueTraits<T>::toV8Value(value, creationContext, isolate);
+        }
+        static v8::Handle<v8::Value> toV8Value(const T& value, v8::Isolate* isolate)
+        {
+            return V8ValueTraits<T>::toV8Value(value, isolate);
+        }
+    };
+
+    template <typename T>
+    v8::Handle<v8::Value> toV8Value(const T& value, ExecutionContext* context)
+    {
+        return WebCore::ToV8ValueHelper<ExecutionContext*, ToV8ValueHelper<T> >::toV8Value(value, context, m_isolate);
+    }
+    template <typename T>
+    v8::Handle<v8::Value> toV8Value(const T& value, v8::Handle<v8::Object> creationContext)
+    {
+        return WebCore::ToV8ValueHelper<v8::Handle<v8::Object>, ToV8ValueHelper<T> >::toV8Value(value, creationContext, m_isolate);
+    }
+
     ScriptPromiseResolver(ExecutionContext*);
     ScriptPromiseResolver(v8::Isolate*);
 
     v8::Isolate* m_isolate;
     // Used when scriptPromiseOnV8Promise is disabled.
     ScriptPromise m_promise;
     // Used when scriptPromiseOnV8Promise is enabled.
     ScriptValue m_resolver;
 };
 
-template<typename T>
-void ScriptPromiseResolver::resolve(T* value, ExecutionContext* context)
-{
-    ASSERT(m_isolate->InContext());
-    v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current(m_isolate));
-    resolve(value, v8Context->Global());
-}
-
-template<typename T>
-void ScriptPromiseResolver::reject(T* value, ExecutionContext* context)
-{
-    ASSERT(m_isolate->InContext());
-    v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current(m_isolate));
-    reject(value, v8Context->Global());
-}
-
-template<typename T>
-void ScriptPromiseResolver::resolve(T* value)
-{
-    ASSERT(m_isolate->InContext());
-    resolve(value, v8::Object::New(m_isolate));
-}
-
-template<typename T>
-void ScriptPromiseResolver::reject(T* value)
-{
-    ASSERT(m_isolate->InContext());
-    reject(value, v8::Object::New(m_isolate));
-}
-
 } // namespace WebCore
 
 
 #endif // ScriptPromiseResolver_h