3ce0526b906e819b5ce5324042313f147d4b3a5a
[WebKit-https.git] / WebCore / bindings / v8 / V8Binding.h
1 /*
2 * Copyright (C) 2009 Google Inc. All rights reserved.
3
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7
8 *     * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *     * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 *     * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #ifndef V8Binding_h
32 #define V8Binding_h
33
34 #include "AtomicString.h"
35 #include "MathExtras.h"
36 #include "PlatformString.h"
37 #include "V8DOMWrapper.h"
38 #include "V8Index.h"
39
40 #include <v8.h>
41
42 namespace WebCore {
43     
44     class EventListener;
45     class EventTarget;
46     
47     // A helper function extract native object pointer from a DOM wrapper
48     // and cast to the specified type.
49     void* v8DOMWrapperToNative(v8::Handle<v8::Object>);
50     
51     template <class C>
52     C* v8DOMWrapperTo(v8::Handle<v8::Object> object)
53     {
54         ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
55         return reinterpret_cast<C*>(v8DOMWrapperToNative(object));
56     }
57     template <class C>
58     C* v8DOMWrapperToNode(v8::Handle<v8::Object> object)
59     {
60         ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
61         ASSERT(V8DOMWrapper::domWrapperType(object) == V8ClassIndex::NODE);
62         return reinterpret_cast<C*>(v8DOMWrapperToNative(object));
63     }
64     
65     void* v8DOMWrapperToNative(const v8::AccessorInfo&);
66     
67     template <class C>
68     C* v8DOMWrapperTo(const v8::AccessorInfo& info) {
69         ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
70         return reinterpret_cast<C*>(v8DOMWrapperToNative(info));
71     }
72     template <class C>
73     C* v8DOMWrapperToNode(const v8::AccessorInfo& info) {
74         ASSERT(V8DOMWrapper::domWrapperType(info.Holder()) == V8ClassIndex::NODE);
75         return reinterpret_cast<C*>(v8DOMWrapperToNative(info));
76     }
77     
78     template <class C>
79     C* v8DOMWrapperTo(V8ClassIndex::V8WrapperType type, v8::Handle<v8::Object> object)
80     {
81         // Native event listener is per frame, it cannot be handled by this generic function.
82         ASSERT(type != V8ClassIndex::EVENTLISTENER);
83         ASSERT(type != V8ClassIndex::EVENTTARGET);
84         
85         ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
86         
87 #ifndef NDEBUG
88         const bool typeIsValid =
89 #define MAKE_CASE(TYPE, NAME) (type != V8ClassIndex::TYPE) &&
90         DOM_NODE_TYPES(MAKE_CASE)
91 #if ENABLE(SVG)
92         SVG_NODE_TYPES(MAKE_CASE)
93 #endif
94 #undef MAKE_CASE
95         true;
96         ASSERT(typeIsValid);
97 #endif
98         
99         return v8DOMWrapperTo<C>(object);
100     }
101     
102     template <class C>
103     C* v8DOMWrapperTo(V8ClassIndex::V8WrapperType type, const v8::AccessorInfo& info)
104     {
105 #ifndef NDEBUG
106         return v8DOMWrapperTo<C>(type, info.Holder());
107 #else
108         return reinterpret_cast<C*>(v8DOMWrapperToNative(info));
109 #endif
110     }
111
112     
113     enum ExternalMode {
114         Externalize,
115         DoNotExternalize
116     };
117     
118     template <typename StringType>
119     StringType v8StringToWebCoreString(v8::Handle<v8::String> v8String, ExternalMode external);
120
121     // Convert v8 types to a WebCore::String. If the V8 string is not already
122     // an external string then it is transformed into an external string at this
123     // point to avoid repeated conversions.
124     inline String v8StringToWebCoreString(v8::Handle<v8::String> v8String)
125     {
126         return v8StringToWebCoreString<String>(v8String, Externalize);
127     }
128     String v8NonStringValueToWebCoreString(v8::Handle<v8::Value>);
129     String v8ValueToWebCoreString(v8::Handle<v8::Value> value);
130
131     // Convert v8 types to a WebCore::AtomicString.
132     inline AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String> v8String)
133     {
134         return v8StringToWebCoreString<AtomicString>(v8String, Externalize);
135     }
136     AtomicString v8NonStringValueToAtomicWebCoreString(v8::Handle<v8::Value>);
137     AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> value);
138
139     // Return a V8 external string that shares the underlying buffer with the given
140     // WebCore string. The reference counting mechanism is used to keep the
141     // underlying buffer alive while the string is still live in the V8 engine.
142     v8::Local<v8::String> v8ExternalString(const String&);
143
144     // Convert a string to a V8 string.
145     inline v8::Handle<v8::String> v8String(const String& string)
146     {
147         return v8ExternalString(string);
148     }
149
150     // Enables caching v8 wrappers created for WebCore::StringImpl.  Currently this cache requires
151     // all the calls (both to convert WebCore::String to v8::String and to GC the handle)
152     // to be performed on the main thread.
153     void enableStringImplCache();
154
155     // Convert a value to a 32-bit integer.  The conversion fails if the
156     // value cannot be converted to an integer or converts to nan or to an infinity.
157     int toInt32(v8::Handle<v8::Value> value, bool& ok);
158
159     // Convert a value to a 32-bit integer assuming the conversion cannot fail.
160     inline int toInt32(v8::Handle<v8::Value> value)
161     {
162         bool ok;
163         return toInt32(value, ok);
164     }
165
166     inline float toFloat(v8::Local<v8::Value> value)
167     {
168         return static_cast<float>(value->NumberValue());
169     }
170
171     // FIXME: Drop this in favor of the type specific v8ValueToWebCoreString when we rework the code generation.
172     inline String toWebCoreString(v8::Handle<v8::Value> object)
173     {
174         return v8ValueToWebCoreString(object);
175     }
176     
177     String toWebCoreString(const v8::Arguments&, int index);
178
179     // The string returned by this function is still owned by the argument
180     // and will be deallocated when the argument is deallocated.
181     inline const uint16_t* fromWebCoreString(const String& str)
182     {
183         return reinterpret_cast<const uint16_t*>(str.characters());
184     }
185
186     bool isUndefinedOrNull(v8::Handle<v8::Value> value);
187
188     v8::Handle<v8::Boolean> v8Boolean(bool value);
189
190     String toWebCoreStringWithNullCheck(v8::Handle<v8::Value> value);
191
192     AtomicString toAtomicWebCoreStringWithNullCheck(v8::Handle<v8::Value> value);
193
194     String toWebCoreStringWithNullOrUndefinedCheck(v8::Handle<v8::Value> value);
195  
196     v8::Handle<v8::String> v8UndetectableString(const String& str);
197
198     v8::Handle<v8::Value> v8StringOrNull(const String& str);
199
200     v8::Handle<v8::Value> v8StringOrUndefined(const String& str);
201
202     v8::Handle<v8::Value> v8StringOrFalse(const String& str);
203     
204     v8::Persistent<v8::FunctionTemplate> createRawTemplate();
205
206     struct BatchedAttribute;
207     struct BatchedCallback;
208     
209     v8::Local<v8::Signature> configureTemplate(v8::Persistent<v8::FunctionTemplate>,
210                                                const char *interfaceName,
211                                                V8ClassIndex::V8WrapperType parentClassIndex,
212                                                int fieldCount,
213                                                const BatchedAttribute*, 
214                                                size_t attributeCount,
215                                                const BatchedCallback*,
216                                                size_t callbackCount);
217     
218     void createCallback(v8::Local<v8::ObjectTemplate> proto,
219                         const char *name,
220                         v8::InvocationCallback,
221                         v8::Handle<v8::Signature>,
222                         v8::PropertyAttribute attributes = v8::DontDelete);
223     
224 } // namespace WebCore
225
226 #endif // V8Binding_h