Make vector conversion more general in V8Bindings

Source/bindings/core/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 219 matching lines @@
 template <typename T>
 struct V8ValueTraits {
     static v8::Handle<v8::Value> toV8Value(const T& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
     {
         if (!WTF::getPtr(value))
             return v8::Null(isolate);
         return toV8NoInline(WTF::getPtr(value), creationContext, isolate);
     }
 };
 
+template<typename T, size_t inlineCapacity>
+v8::Handle<v8::Value> v8ArrayNoInline(const Vector<T, inlineCapacity>& iterator, v8::Handle<v8::Object> creationContext, v8::Isolate*);

[gavinp, 2014/07/20 04:15:18]

These two forward declarations are required to make type resolution work for the
basic types like WTFString; I think because they are not in an associated
namespace, but I'm not certain.

I note that these two calls are the only uses of v8ArrayNoInline, so another
option is to move the definition of the two v8ArrayNoInline<>() up above their
corresponding V8ValueTraits<>::toV8Value(). I didn't do that initially and
instead added these forward declarations because... this file looks very
carefully ordered and I didn't want to upset the boat.

+
 template <typename T, size_t inlineCapacity, typename Allocator>
 struct V8ValueTraits<WTF::Vector<T, inlineCapacity, Allocator> > {
     static v8::Handle<v8::Value> toV8Value(const Vector<T, inlineCapacity, Allocator>& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
     {
         return v8ArrayNoInline(value, creationContext, isolate);
     }
 };
 
+template<typename T, size_t inlineCapacity>
+v8::Handle<v8::Value> v8ArrayNoInline(const HeapVector<T, inlineCapacity>& iterator, v8::Handle<v8::Object> creationContext, v8::Isolate*);
+
 template <typename T, size_t inlineCapacity>
 struct V8ValueTraits<HeapVector<T, inlineCapacity> > {
     static v8::Handle<v8::Value> toV8Value(const HeapVector<T, inlineCapacity>& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
     {
         return v8ArrayNoInline(value, creationContext, isolate);
     }
 };
 
+// These explicit specializations allow basic data types to be converted via V8ValueTraits<>::toV8Value(). Where sensible, each data type
+// should also have an explicit specialization of toV8NoInline<>() in V8Binding.cpp, so that vectors of the same type can also be converted.

[haraken, 2014/07/20 04:50:46]

Just help me understand: Why do we need to have explicit specialization of
toV8NoInline<>() whereas we don't need to have explicit specialization of
toV8<>()?

[gavinp, 2014/07/20 05:11:16]

I do not know; I am very new in this coding area.

It's very interesting that IDL can bind function return values of Vector<String>
correctly (this occurs a number of times), but that they didn't work through
V8ValueTraits<>::toV8Value(). I do not know why or understand at present. Do you
have suggestions on where we can look to answer this?

[haraken, 2014/07/20 05:16:35]

I think we can ask yhirano@ or tasak@ :) The toV8 family is insanely complicated
to understand for us...

 template<>
 struct V8ValueTraits<String> {
     static inline v8::Handle<v8::Value> toV8Value(const String& value, v8::Handle<v8::Object>, v8::Isolate* isolate)
     {
         return v8String(isolate, value);
     }
 };
 
 template<>
 struct V8ValueTraits<AtomicString> {
@@ skipping 727 matching lines @@
         m_block.Reset();
     }
 
 private:
     v8::TryCatch& m_block;
 };
 
 } // namespace WebCore
 
 #endif // V8Binding_h