Implement V8ValueTraits<T>::toV8Value conversion functions

Source/bindings/v8/V8Binding.h

 /*
 * Copyright (C) 2009 Google Inc. All rights reserved.
 * Copyright (C) 2012 Ericsson AB. 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.
@@ skipping 16 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 V8Binding_h
 #define V8Binding_h
 
 #include "bindings/v8/DOMWrapperWorld.h"
 #include "bindings/v8/ExceptionMessages.h"
+#include "bindings/v8/ScriptValue.h"
 #include "bindings/v8/V8BindingMacros.h"
 #include "bindings/v8/V8PerIsolateData.h"
 #include "bindings/v8/V8StringResource.h"
 #include "bindings/v8/V8ThrowException.h"
 #include "bindings/v8/V8ValueCache.h"
 #include "platform/heap/Heap.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/AtomicString.h"
 #include <v8.h>
 
@@ skipping 162 matching lines @@
 {
     ASSERT(isolate);
     return v8::String::NewFromUtf8(isolate, str, v8::String::kInternalizedString, length);
 }
 
 inline v8::Handle<v8::Value> v8Undefined()
 {
     return v8::Handle<v8::Value>();
 }
 
+v8::Isolate* toIsolate(ExecutionContext*);
+v8::Isolate* toIsolate(LocalFrame*);
+
+DOMWindow* toDOMWindow(v8::Handle<v8::Value>, v8::Isolate*);
+DOMWindow* toDOMWindow(v8::Handle<v8::Context>);
+DOMWindow* enteredDOMWindow(v8::Isolate*);
+DOMWindow* currentDOMWindow(v8::Isolate*);
+DOMWindow* callingDOMWindow(v8::Isolate*);
+ExecutionContext* toExecutionContext(v8::Handle<v8::Context>);
+ExecutionContext* currentExecutionContext(v8::Isolate*);
+ExecutionContext* callingExecutionContext(v8::Isolate*);
+
+// Returns a V8 context associated with a ExecutionContext and a DOMWrapperWorld.
+// This method returns an empty context if there is no frame or the frame is already detached.
+v8::Local<v8::Context> toV8Context(ExecutionContext*, DOMWrapperWorld&);
+// Returns a V8 context associated with a LocalFrame and a DOMWrapperWorld.
+// This method returns an empty context if the frame is already detached.
+v8::Local<v8::Context> toV8Context(v8::Isolate*, LocalFrame*, DOMWrapperWorld&);
+
+// Returns the frame object of the window object associated with
+// a context, if the window is currently being displayed in the LocalFrame.
+LocalFrame* toFrameIfNotDetached(v8::Handle<v8::Context>);
+
+// Converts a DOM object to a v8 value.
+// This is a no-inline version of toV8(). If you want to call toV8()
+// without creating #include cycles, you can use this function instead.
+// Each specialized implementation will be generated.
+template<typename T>
+v8::Handle<v8::Value> toV8NoInline(T* impl, v8::Handle<v8::Object> creationContext, v8::Isolate*);
+template<typename T>
+v8::Handle<v8::Value> toV8NoInline(T* impl, ExecutionContext* context)
+{
+    v8::Isolate* isolate = toIsolate(context);
+    v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current(isolate));
+    return toV8NoInline(impl, v8Context->Global(), isolate);
+}
+
+// Every ValueTraits has the following methods and properties.
+//  - arrayV8Value: A conversion function that is used to construct an array.
+//                  This function may use toV8 and  including the associated
+//                  generated header is needed to call this function.
+//
+//  - toV8: A general conversion function. This function uses toV8NoInline,
+//          This function doesn't use toV8, so this can be called without
+//          including a generated header.
+//          Some V8ValueTraitses have toV8Value whose type is
+//            Handle<Value> toV8Value(const T&, Handle<Object>, Isolate*);
+//          and the other have toV8Value whose type is
+//            Handle<Value> toV8Value(const T&, Isolate*);
+//          .
+//  - toV8ValueNeedsCreationContext: set true if the class provides toV8 which
+//                                   requires a creationContext as a parameter.
+//                                   set false otherwise.

[haraken, 2014/04/17 12:42:27]

I'm not sure if we need the toV8ValueNeedsCreationContext flag. For objects that
need a creation context should use toV8(). For objects that don't need a
creation context should use toV8Value(). Then we don't need the flag to
distinguish these, do we?

It would be confusing to have both toV8() and toV8Value() to wrap one object.

[yhirano, 2014/04/18 01:09:42]

Do you mean that V8ValueTraits are for the types that don't need creationContext
for the conversion and There should not be V8ValueTraits<*Ptr<T> > ?

 template <class T>
 struct V8ValueTraits {
     static inline v8::Handle<v8::Value> arrayV8Value(const T& value, v8::Isolate* isolate)
     {
         return toV8(WTF::getPtr(value), v8::Handle<v8::Object>(), isolate);
     }
+    static inline v8::Handle<v8::Value> toV8Value(const T& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+    {
+        return toV8NoInline(WTF::getPtr(value), creationContext, isolate);
+    }
+    static const bool toV8ValueNeedsCreationContext = true;
+};
+
+template <typename T>
+struct V8ValueTraits<T*> {
+    static inline v8::Handle<v8::Value> arrayV8Value(T* const& value, v8::Isolate* isolate)
+    {
+        return toV8(value, v8::Handle<v8::Object>(), isolate);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(T* const& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+    {
+        return toV8NoInline(value, creationContext, isolate);
+    }
+    static const bool toV8ValueNeedsCreationContext = true;
 };
 
 template<>
 struct V8ValueTraits<String> {
     static inline v8::Handle<v8::Value> arrayV8Value(const String& value, v8::Isolate* isolate)
     {
         return v8String(isolate, value);
     }
+    static inline v8::Handle<v8::Value> toV8Value(const String& value, v8::Isolate* isolate)
+    {
+        return v8String(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
 };
 
 template<>
 struct V8ValueTraits<AtomicString> {
     static inline v8::Handle<v8::Value> arrayV8Value(const AtomicString& value, v8::Isolate* isolate)
     {
         return v8String(isolate, value);
     }
+    static inline v8::Handle<v8::Value> toV8Value(const AtomicString& value, v8::Isolate* isolate)
+    {
+        return v8String(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
 };
 
 template<>
+struct V8ValueTraits<const char*> {
+    static inline v8::Handle<v8::Value> arrayV8Value(const char* const& value, v8::Isolate* isolate)
+    {
+        return v8String(isolate, value);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const char* const& value, v8::Isolate* isolate)
+    {
+        return v8String(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
+struct V8ValueTraits<int> {
+    static inline v8::Handle<v8::Value> arrayV8Value(const int& value, v8::Isolate* isolate)
+    {
+        return v8::Integer::New(isolate, value);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const int& value, v8::Isolate* isolate)
+    {
+        return v8::Integer::New(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
+struct V8ValueTraits<long> {
+    static inline v8::Handle<v8::Value> arrayV8Value(const long& value, v8::Isolate* isolate)
+    {
+        return v8::Integer::New(isolate, value);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const long& value, v8::Isolate* isolate)
+    {
+        return v8::Integer::New(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
 struct V8ValueTraits<unsigned> {
     static inline v8::Handle<v8::Value> arrayV8Value(const unsigned& value, v8::Isolate* isolate)
     {
         return v8::Integer::NewFromUnsigned(isolate, value);
     }
+    static inline v8::Handle<v8::Value> toV8Value(const unsigned& value, v8::Isolate* isolate)
+    {
+        return v8::Integer::NewFromUnsigned(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
 };
 
 template<>
 struct V8ValueTraits<unsigned long> {
     static inline v8::Handle<v8::Value> arrayV8Value(const unsigned long& value, v8::Isolate* isolate)
     {
         return v8::Integer::NewFromUnsigned(isolate, value);
     }
+    static inline v8::Handle<v8::Value> toV8Value(const unsigned long& value, v8::Isolate* isolate)
+    {
+        return v8::Integer::NewFromUnsigned(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
 };
 
 template<>
 struct V8ValueTraits<float> {
     static inline v8::Handle<v8::Value> arrayV8Value(const float& value, v8::Isolate* isolate)
     {
         return v8::Number::New(isolate, value);
     }
+    static inline v8::Handle<v8::Value> toV8Value(const float& value, v8::Isolate* isolate)
+    {
+        return v8::Number::New(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
 };
 
 template<>
 struct V8ValueTraits<double> {
     static inline v8::Handle<v8::Value> arrayV8Value(const double& value, v8::Isolate* isolate)
     {
         return v8::Number::New(isolate, value);
     }
+    static inline v8::Handle<v8::Value> toV8Value(const double& value, v8::Isolate* isolate)
+    {
+        return v8::Number::New(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
+struct V8ValueTraits<bool> {
+    static inline v8::Handle<v8::Value> arrayV8Value(const bool& value, v8::Isolate* isolate)
+    {
+        return v8::Boolean::New(isolate, value);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const bool& value, v8::Isolate* isolate)
+    {
+        return v8::Boolean::New(isolate, value);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+// V8NullType and V8UndefinedType are used only for the value conversion.
+class V8NullType { };
+class V8UndefinedType { };
+
+template<>
+struct V8ValueTraits<V8NullType> {
+    static inline v8::Handle<v8::Value> arrayV8Value(const V8NullType&, v8::Isolate* isolate)
+    {
+        return v8::Null(isolate);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const V8NullType&, v8::Isolate* isolate)
+    {
+        return v8::Null(isolate);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
+struct V8ValueTraits<V8UndefinedType> {
+    static inline v8::Handle<v8::Value> arrayV8Value(const V8UndefinedType&, v8::Isolate* isolate)
+    {
+        return v8::Undefined(isolate);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const V8UndefinedType&, v8::Isolate* isolate)
+    {
+        return v8::Undefined(isolate);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
+struct V8ValueTraits<ScriptValue> {
+    static inline v8::Handle<v8::Value> arrayV8Value(const ScriptValue& value, v8::Isolate*)
+    {
+        return value.v8Value();
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const ScriptValue& value, v8::Isolate*)
+    {
+        return value.v8Value();
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
+struct V8ValueTraits<v8::Handle<v8::Value> > {
+    static inline v8::Handle<v8::Value> arrayV8Value(const v8::Handle<v8::Value>& value, v8::Isolate*)
+    {
+        return value;
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const v8::Handle<v8::Value>& value, v8::Isolate*)
+    {
+        return value;
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
+template<>
+struct V8ValueTraits<v8::Local<v8::Value> > {
+    static inline v8::Handle<v8::Value> arrayV8Value(const v8::Local<v8::Value>& value, v8::Isolate*)
+    {
+        return value;
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const v8::Local<v8::Value>& value, v8::Isolate*)
+    {
+        return value;
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
 };
 
 template<typename T, size_t inlineCapacity>
 v8::Handle<v8::Value> v8Array(const Vector<T, inlineCapacity>& iterator, v8::Isolate* isolate)
 {
     v8::Local<v8::Array> result = v8::Array::New(isolate, iterator.size());
     int index = 0;
     typename Vector<T, inlineCapacity>::const_iterator end = iterator.end();
     typedef V8ValueTraits<T> TraitsType;
     for (typename Vector<T, inlineCapacity>::const_iterator iter = iterator.begin(); iter != end; ++iter)
@@ skipping 17 matching lines @@
 v8::Handle<v8::Value> v8ArrayNoInline(const Vector<T, inlineCapacity>& iterator, v8::Isolate* isolate)
 {
     v8::Local<v8::Array> result = v8::Array::New(isolate, iterator.size());
     int index = 0;
     typename Vector<T, inlineCapacity>::const_iterator end = iterator.end();
     for (typename Vector<T, inlineCapacity>::const_iterator iter = iterator.begin(); iter != end; ++iter)
         result->Set(v8::Integer::New(isolate, index++), toV8NoInline(WTF::getPtr(*iter), v8::Handle<v8::Object>(), isolate));
     return result;
 }
 
+template<typename T, size_t inlinCapacity>
+struct V8ValueTraits<Vector<T, inlinCapacity> > {
+    static inline v8::Handle<v8::Value> arrayV8Value(const Vector<T, inlinCapacity>& value, v8::Isolate* isolate)
+    {
+        return v8Array(value, isolate);
+    }
+    static inline v8::Handle<v8::Value> toV8Value(const Vector<T, inlinCapacity>& value, v8::Isolate* isolate)
+    {
+        return v8ArrayNoInline(value, isolate);
+    }
+    static const bool toV8ValueNeedsCreationContext = false;
+};
+
 // Conversion flags, used in toIntXX/toUIntXX.
 enum IntegerConversionConfiguration {
     NormalConversion,
     EnforceRange,
     Clamp
 };
 
 // Convert a value to a 8-bit signed integer. The conversion fails if the
 // value cannot be converted to a number or the range violated per WebIDL:
 // http://www.w3.org/TR/WebIDL/#es-byte
@@ skipping 323 matching lines @@
     if (lengthValue->IsUndefined() || lengthValue->IsNull()) {
         // The caller is responsible for reporting a TypeError.
         return v8Undefined();
     }
 
     TONATIVE_EXCEPTION(uint32_t, sequenceLength, lengthValue->Int32Value());
     length = sequenceLength;
     return v8Value;
 }
 
-v8::Isolate* toIsolate(ExecutionContext*);
-v8::Isolate* toIsolate(LocalFrame*);
-
-DOMWindow* toDOMWindow(v8::Handle<v8::Value>, v8::Isolate*);
-DOMWindow* toDOMWindow(v8::Handle<v8::Context>);
-DOMWindow* enteredDOMWindow(v8::Isolate*);
-DOMWindow* currentDOMWindow(v8::Isolate*);
-DOMWindow* callingDOMWindow(v8::Isolate*);
-ExecutionContext* toExecutionContext(v8::Handle<v8::Context>);
-ExecutionContext* currentExecutionContext(v8::Isolate*);
-ExecutionContext* callingExecutionContext(v8::Isolate*);
-
-// Returns a V8 context associated with a ExecutionContext and a DOMWrapperWorld.
-// This method returns an empty context if there is no frame or the frame is already detached.
-v8::Local<v8::Context> toV8Context(ExecutionContext*, DOMWrapperWorld&);
-// Returns a V8 context associated with a LocalFrame and a DOMWrapperWorld.
-// This method returns an empty context if the frame is already detached.
-v8::Local<v8::Context> toV8Context(v8::Isolate*, LocalFrame*, DOMWrapperWorld&);
-
-// Returns the frame object of the window object associated with
-// a context, if the window is currently being displayed in the LocalFrame.
-LocalFrame* toFrameIfNotDetached(v8::Handle<v8::Context>);
-
 // If the current context causes out of memory, JavaScript setting
 // is disabled and it returns true.
 bool handleOutOfMemory();
 v8::Local<v8::Value> handleMaxRecursionDepthExceeded(v8::Isolate*);
 void crashIfV8IsDead();
 
 inline bool isUndefinedOrNull(v8::Handle<v8::Value> value)
 {
     return value->IsNull() || value->IsUndefined();
 }
@@ skipping 17 matching lines @@
         properties->Set(integer, integer);
     }
     v8SetReturnValue(info, properties);
 }
 
 // These methods store hidden values into an array that is stored in the internal field of a DOM wrapper.
 void addHiddenValueToArray(v8::Handle<v8::Object>, v8::Local<v8::Value>, int cacheIndex, v8::Isolate*);
 void removeHiddenValueFromArray(v8::Handle<v8::Object>, v8::Local<v8::Value>, int cacheIndex, v8::Isolate*);
 void moveEventListenerToNewWrapper(v8::Handle<v8::Object>, EventListener* oldValue, v8::Local<v8::Value> newValue, int cacheIndex, v8::Isolate*);
 
-// Converts a DOM object to a v8 value.
-// This is a no-inline version of toV8(). If you want to call toV8()
-// without creating #include cycles, you can use this function instead.
-// Each specialized implementation will be generated.
-template<typename T>
-v8::Handle<v8::Value> toV8NoInline(T* impl, v8::Handle<v8::Object> creationContext, v8::Isolate*);
-template<typename T>
-v8::Handle<v8::Value> toV8NoInline(T* impl, ExecutionContext* context)
-{
-    v8::Isolate* isolate = toIsolate(context);
-    v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current(isolate));
-    return toV8NoInline(impl, v8Context->Global(), isolate);
-}
-
 // Result values for platform object 'deleter' methods,
 // http://www.w3.org/TR/WebIDL/#delete
 enum DeleteResult {
     DeleteSuccess,
     DeleteReject,
     DeleteUnknownProperty
 };
 
 class V8IsolateInterruptor : public ThreadState::Interruptor {
 public:
@@ skipping 25 matching lines @@
 
 private:
     v8::HandleScope m_handleScope;
     v8::Context::Scope m_contextScope;
     RefPtr<NewScriptState> m_scriptState;
 };
 
 } // namespace WebCore
 
 #endif // V8Binding_h