Implement V8ValueTraits<T>::toV8Value conversion functions

Source/bindings/v8/ScriptPromiseResolverWithContext.h

 // 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.
 
 #ifndef ScriptPromiseResolverWithContext_h
 #define ScriptPromiseResolverWithContext_h
 
 #include "bindings/v8/NewScriptState.h"
 #include "bindings/v8/ScopedPersistent.h"
 #include "bindings/v8/ScriptPromise.h"
@@ skipping 12 matching lines @@
 // functionalities in addition to ScriptPromiseResolver's.
 //  - A ScriptPromiseResolverWithContext retains a ScriptState. A caller
 //    can call resolve or reject from outside of a V8 context.
 //  - This class is an ActiveDOMObject and keeps track of the associated
 //    ExecutionContext state. When the ExecutionContext is suspended,
 //    resolve or reject will be delayed. When it is stopped, resolve or reject
 //    will be ignored.
 class ScriptPromiseResolverWithContext FINAL : public ActiveDOMObject, public RefCounted<ScriptPromiseResolverWithContext> {
     WTF_MAKE_NONCOPYABLE(ScriptPromiseResolverWithContext);
 
+    class NullType {
+    };
+    class UndefinedType {
+    };
 public:
     static PassRefPtr<ScriptPromiseResolverWithContext> create(NewScriptState* scriptState)
     {
         RefPtr<ScriptPromiseResolverWithContext> resolver = adoptRef(new ScriptPromiseResolverWithContext(scriptState));
         resolver->suspendIfNeeded();
         return resolver.release();
     }
 
+    // Anything that can be passed to one of the toV8 functions defined in this
+    // class can be passed to this function.
     template <typename T>
     void resolve(T value)
     {
         if (m_state != Pending || !executionContext() || executionContext()->activeDOMObjectsAreStopped())
             return;
         m_state = Resolving;
         NewScriptState::Scope scope(m_scriptState.get());
         m_value.set(m_scriptState->isolate(), toV8(value));

[haraken, 2014/04/17 03:46:23]

I'm not sure if it's a good idea to introduce toV8() just for Promise.

As a bottom line, we can write:

  resolve(v8::Integer::New(value));

in the call sites. Then you just need to define resolve(v8::Handle<v8::Value>).

If you feel that writing v8::Integer::New(value) in all call sites of
resolve/reject, you can define helper methods in V8Binding.h and use them. The
helper methods are not only for Promise but also for all other bindings.

What do you think? (I'm OK with introducing the helper methods in a follow-up CL
if you need them.)

[yhirano, 2014/04/17 03:52:24]

I think HandleScope is needed to use v8::Undefined(), v8::...::New, etc, because
they create handles (whereas entering a v8 Context is not needed). Is that
correct?

         if (!executionContext()->activeDOMObjectsAreSuspended())
             resolveOrRejectImmediately(&m_timer);
     }
 
+    // Anything that can be passed to one of the toV8 functions defined in this
+    // class can be passed to this function.
     template <typename T>
     void reject(T value)
     {
         if (m_state != Pending || !executionContext() || executionContext()->activeDOMObjectsAreStopped())
             return;
         m_state = Rejecting;
         NewScriptState::Scope scope(m_scriptState.get());
         m_value.set(m_scriptState->isolate(), toV8(value));
         if (!executionContext()->activeDOMObjectsAreSuspended())
             resolveOrRejectImmediately(&m_timer);
     }
 
+    // null and undefined can be passed to resolve and reject functions.
+    static NullType null() { return NullType(); }
+    static UndefinedType undefined() { return UndefinedType(); }
+    struct Boolean {
+        explicit Boolean(bool value) : value(value) { }
+        const bool value;
+    };
+
     // Note that an empty ScriptPromise will be returned after resolve or
     // reject is called.
     ScriptPromise promise()
     {
         return m_resolver ? m_resolver->promise() : ScriptPromise();
     }
 
     // ActiveDOMObject implementation.
     virtual void suspend() OVERRIDE;
     virtual void resume() OVERRIDE;
@@ skipping 21 matching lines @@
     template <typename T, size_t inlineCapacity>
     v8::Handle<v8::Value> toV8(const Vector<T, inlineCapacity>& value)
     {
         ASSERT(m_scriptState);
         return v8ArrayNoInline(value, m_scriptState->isolate());
     }
     v8::Handle<v8::Value> toV8(ScriptValue value)
     {
         return value.v8Value();
     }
+    v8::Handle<v8::Value> toV8(v8::Handle<v8::Value> value) { return value; }
+    v8::Handle<v8::Value> toV8(NullType) { return v8::Null(m_scriptState->isolate()); }
+    v8::Handle<v8::Value> toV8(UndefinedType) { return v8::Undefined(m_scriptState->isolate()); }
+    // We don't define toV8(bool) to avoid implicit conversion.
+    v8::Handle<v8::Value> toV8(Boolean value) { return v8::Boolean::New(m_scriptState->isolate(), value.value); }
+    v8::Handle<v8::Value> toV8(int8_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint8_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }

[haraken, 2014/04/17 03:46:23]

Don't you want to use v8::Integer::NewFromUnsigned?

+    v8::Handle<v8::Value> toV8(int16_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint16_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }

[haraken, 2014/04/17 03:46:23]

Ditto.

+    v8::Handle<v8::Value> toV8(int32_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint32_t value) { return v8::Number::New(m_scriptState->isolate(), value); }

[haraken, 2014/04/17 03:46:23]

Ditto.

+    v8::Handle<v8::Value> toV8(int64_t value) { return v8::Number::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint64_t value) { return v8::Number::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(double value) { return v8::Number::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(const char* value)
+    {
+        return v8::String::NewFromUtf8(m_scriptState->isolate(), value, v8::String::kInternalizedString, strlen(value));
+    }
+    v8::Handle<v8::Value> toV8(const String& value)
+    {
+        return v8String(m_scriptState->isolate(), value);
+    }
 
     void resolveOrRejectImmediately(Timer<ScriptPromiseResolverWithContext>*);
     void clear();
 
     ResolutionState m_state;
     RefPtr<NewScriptState> m_scriptState;
     Timer<ScriptPromiseResolverWithContext> m_timer;
     RefPtr<ScriptPromiseResolver> m_resolver;
     ScopedPersistent<v8::Value> m_value;
 };
 
 } // namespace WebCore
 
 #endif // #ifndef ScriptPromiseResolverWithContext_h