1/*
2    This file is part of the Blink open source project.
3    This file has been auto-generated by CodeGeneratorV8.pm. DO NOT MODIFY!
4
5    This library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public
7    License as published by the Free Software Foundation; either
8    version 2 of the License, or (at your option) any later version.
9
10    This library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public License
16    along with this library; see the file COPYING.LIB.  If not, write to
17    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.
19*/
20
21#include "config.h"
22#if ENABLE(Condition1) || ENABLE(Condition2)
23#include "V8TestInterface.h"
24
25#include "RuntimeEnabledFeatures.h"
26#include "V8Node.h"
27#include "V8NodeList.h"
28#include "V8TestObject.h"
29#include "bindings/bindings/tests/idls/TestImplements.h"
30#include "bindings/bindings/tests/idls/TestPartialInterface.h"
31#include "bindings/v8/ExceptionState.h"
32#include "bindings/v8/ScriptController.h"
33#include "bindings/v8/V8Binding.h"
34#include "bindings/v8/V8DOMConfiguration.h"
35#include "bindings/v8/V8DOMWrapper.h"
36#include "bindings/v8/V8ObjectConstructor.h"
37#include "core/dom/ContextFeatures.h"
38#include "core/dom/Document.h"
39#include "core/page/Frame.h"
40#include "core/platform/chromium/TraceEvent.h"
41#include "wtf/GetPtr.h"
42#include "wtf/RefPtr.h"
43#include "wtf/UnusedParam.h"
44
45namespace WebCore {
46
47static void initializeScriptWrappableForInterface(TestInterface* object)
48{
49    if (ScriptWrappable::wrapperCanBeStoredInObject(object))
50        ScriptWrappable::setTypeInfoInObject(object, &V8TestInterface::info);
51    else
52        ASSERT_NOT_REACHED();
53}
54
55} // namespace WebCore
56
57// In ScriptWrappable::init, the use of a local function declaration has an issue on Windows:
58// the local declaration does not pick up the surrounding namespace. Therefore, we provide this function
59// in the global namespace.
60// (More info on the MSVC bug here: http://connect.microsoft.com/VisualStudio/feedback/details/664619/the-namespace-of-local-function-declarations-in-c)
61void webCoreInitializeScriptWrappableForInterface(WebCore::TestInterface* object)
62{
63    WebCore::initializeScriptWrappableForInterface(object);
64}
65
66namespace WebCore {
67WrapperTypeInfo V8TestInterface::info = { V8TestInterface::GetTemplate, V8TestInterface::derefObject, V8TestInterface::toActiveDOMObject, 0, 0, V8TestInterface::installPerContextPrototypeProperties, 0, WrapperTypeObjectPrototype };
68
69namespace TestInterfaceV8Internal {
70
71template <typename T> void V8_USE(T) { }
72
73#if ENABLE(Condition22) || ENABLE(Condition23)
74
75static void implementsStaticReadOnlyAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
76{
77    v8SetReturnValueInt(info, TestImplements::implementsStaticReadOnlyAttr());
78    return;
79}
80
81#endif // ENABLE(Condition22) || ENABLE(Condition23)
82
83#if ENABLE(Condition22) || ENABLE(Condition23)
84
85static void implementsStaticReadOnlyAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
86{
87    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
88    TestInterfaceV8Internal::implementsStaticReadOnlyAttrAttrGetter(name, info);
89    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
90}
91
92#endif // ENABLE(Condition22) || ENABLE(Condition23)
93
94#if ENABLE(Condition22) || ENABLE(Condition23)
95
96static void implementsStaticAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
97{
98    v8SetReturnValueString(info, TestImplements::implementsStaticAttr(), info.GetIsolate());
99    return;
100}
101
102#endif // ENABLE(Condition22) || ENABLE(Condition23)
103
104#if ENABLE(Condition22) || ENABLE(Condition23)
105
106static void implementsStaticAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
107{
108    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
109    TestInterfaceV8Internal::implementsStaticAttrAttrGetter(name, info);
110    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
111}
112
113#endif // ENABLE(Condition22) || ENABLE(Condition23)
114
115#if ENABLE(Condition22) || ENABLE(Condition23)
116
117static void implementsStaticAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
118{
119    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value);
120    TestImplements::setImplementsStaticAttr(v);
121    return;
122}
123
124#endif // ENABLE(Condition22) || ENABLE(Condition23)
125
126#if ENABLE(Condition22) || ENABLE(Condition23)
127
128static void implementsStaticAttrAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
129{
130    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
131    TestInterfaceV8Internal::implementsStaticAttrAttrSetter(name, value, info);
132    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
133}
134
135#endif // ENABLE(Condition22) || ENABLE(Condition23)
136
137#if ENABLE(Condition22) || ENABLE(Condition23)
138
139static void implementsStr1AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
140{
141    TestInterface* imp = V8TestInterface::toNative(info.Holder());
142    v8SetReturnValueString(info, TestImplements::implementsStr1(imp), info.GetIsolate());
143    return;
144}
145
146#endif // ENABLE(Condition22) || ENABLE(Condition23)
147
148#if ENABLE(Condition22) || ENABLE(Condition23)
149
150static void implementsStr1AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
151{
152    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
153    TestInterfaceV8Internal::implementsStr1AttrGetter(name, info);
154    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
155}
156
157#endif // ENABLE(Condition22) || ENABLE(Condition23)
158
159#if ENABLE(Condition22) || ENABLE(Condition23)
160
161static void implementsStr2AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
162{
163    TestInterface* imp = V8TestInterface::toNative(info.Holder());
164    v8SetReturnValueString(info, TestImplements::implementsStr2(imp), info.GetIsolate());
165    return;
166}
167
168#endif // ENABLE(Condition22) || ENABLE(Condition23)
169
170#if ENABLE(Condition22) || ENABLE(Condition23)
171
172static void implementsStr2AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
173{
174    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
175    TestInterfaceV8Internal::implementsStr2AttrGetter(name, info);
176    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
177}
178
179#endif // ENABLE(Condition22) || ENABLE(Condition23)
180
181#if ENABLE(Condition22) || ENABLE(Condition23)
182
183static void implementsStr2AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
184{
185    TestInterface* imp = V8TestInterface::toNative(info.Holder());
186    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value);
187    TestImplements::setImplementsStr2(imp, v);
188    return;
189}
190
191#endif // ENABLE(Condition22) || ENABLE(Condition23)
192
193#if ENABLE(Condition22) || ENABLE(Condition23)
194
195static void implementsStr2AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
196{
197    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
198    TestInterfaceV8Internal::implementsStr2AttrSetter(name, value, info);
199    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
200}
201
202#endif // ENABLE(Condition22) || ENABLE(Condition23)
203
204#if ENABLE(Condition22) || ENABLE(Condition23)
205
206static void implementsStr3AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
207{
208    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
209    V8TestInterface::implementsStr3AttrGetterCustom(name, info);
210    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
211}
212
213#endif // ENABLE(Condition22) || ENABLE(Condition23)
214
215#if ENABLE(Condition22) || ENABLE(Condition23)
216
217static void implementsStr3AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
218{
219    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
220    V8TestInterface::implementsStr3AttrSetterCustom(name, value, info);
221    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
222}
223
224#endif // ENABLE(Condition22) || ENABLE(Condition23)
225
226#if ENABLE(Condition22) || ENABLE(Condition23)
227
228static void implementsNodeAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
229{
230    TestInterface* imp = V8TestInterface::toNative(info.Holder());
231    v8SetReturnValue(info, toV8Fast(TestImplements::implementsNode(imp), info, imp));
232    return;
233}
234
235#endif // ENABLE(Condition22) || ENABLE(Condition23)
236
237#if ENABLE(Condition22) || ENABLE(Condition23)
238
239static void implementsNodeAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
240{
241    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
242    TestInterfaceV8Internal::implementsNodeAttrGetter(name, info);
243    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
244}
245
246#endif // ENABLE(Condition22) || ENABLE(Condition23)
247
248#if ENABLE(Condition22) || ENABLE(Condition23)
249
250static void implementsNodeAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
251{
252    TestInterface* imp = V8TestInterface::toNative(info.Holder());
253    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
254    TestImplements::setImplementsNode(imp, WTF::getPtr(v));
255    return;
256}
257
258#endif // ENABLE(Condition22) || ENABLE(Condition23)
259
260#if ENABLE(Condition22) || ENABLE(Condition23)
261
262static void implementsNodeAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
263{
264    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
265    TestInterfaceV8Internal::implementsNodeAttrSetter(name, value, info);
266    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
267}
268
269#endif // ENABLE(Condition22) || ENABLE(Condition23)
270
271#if ENABLE(Condition22) || ENABLE(Condition23)
272
273static void Node23AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
274{
275    TestInterface* imp = V8TestInterface::toNative(info.Holder());
276    v8SetReturnValue(info, toV8Fast(TestImplements::node23(imp), info, imp));
277    return;
278}
279
280#endif // ENABLE(Condition22) || ENABLE(Condition23)
281
282#if ENABLE(Condition22) || ENABLE(Condition23)
283
284static void Node23AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
285{
286    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
287    TestInterfaceV8Internal::Node23AttrGetter(name, info);
288    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
289}
290
291#endif // ENABLE(Condition22) || ENABLE(Condition23)
292
293#if ENABLE(Condition22) || ENABLE(Condition23)
294
295static void Node23AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
296{
297    TestInterface* imp = V8TestInterface::toNative(info.Holder());
298    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
299    TestImplements::setNode23(imp, WTF::getPtr(v));
300    return;
301}
302
303#endif // ENABLE(Condition22) || ENABLE(Condition23)
304
305#if ENABLE(Condition22) || ENABLE(Condition23)
306
307static void Node23AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
308{
309    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
310    TestInterfaceV8Internal::Node23AttrSetter(name, value, info);
311    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
312}
313
314#endif // ENABLE(Condition22) || ENABLE(Condition23)
315
316#if ENABLE(Condition22) || ENABLE(Condition23)
317
318static void Node24AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
319{
320    TestInterface* imp = V8TestInterface::toNative(info.Holder());
321    v8SetReturnValue(info, toV8Fast(TestImplements::node24(imp), info, imp));
322    return;
323}
324
325#endif // ENABLE(Condition22) || ENABLE(Condition23)
326
327#if ENABLE(Condition22) || ENABLE(Condition23)
328
329static void Node24AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
330{
331    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
332    TestInterfaceV8Internal::Node24AttrGetter(name, info);
333    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
334}
335
336#endif // ENABLE(Condition22) || ENABLE(Condition23)
337
338#if ENABLE(Condition22) || ENABLE(Condition23)
339
340static void Node24AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
341{
342    TestInterface* imp = V8TestInterface::toNative(info.Holder());
343    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
344    TestImplements::setNode24(imp, WTF::getPtr(v));
345    return;
346}
347
348#endif // ENABLE(Condition22) || ENABLE(Condition23)
349
350#if ENABLE(Condition22) || ENABLE(Condition23)
351
352static void Node24AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
353{
354    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
355    TestInterfaceV8Internal::Node24AttrSetter(name, value, info);
356    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
357}
358
359#endif // ENABLE(Condition22) || ENABLE(Condition23)
360
361#if ENABLE(Condition22) || ENABLE(Condition23)
362
363static void Node25AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
364{
365    TestInterface* imp = V8TestInterface::toNative(info.Holder());
366    v8SetReturnValue(info, toV8Fast(TestImplements::node25(imp), info, imp));
367    return;
368}
369
370#endif // ENABLE(Condition22) || ENABLE(Condition23)
371
372#if ENABLE(Condition22) || ENABLE(Condition23)
373
374static void Node25AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
375{
376    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
377    TestInterfaceV8Internal::Node25AttrGetter(name, info);
378    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
379}
380
381#endif // ENABLE(Condition22) || ENABLE(Condition23)
382
383#if ENABLE(Condition22) || ENABLE(Condition23)
384
385static void Node25AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
386{
387    TestInterface* imp = V8TestInterface::toNative(info.Holder());
388    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
389    TestImplements::setNode25(imp, WTF::getPtr(v));
390    return;
391}
392
393#endif // ENABLE(Condition22) || ENABLE(Condition23)
394
395#if ENABLE(Condition22) || ENABLE(Condition23)
396
397static void Node25AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
398{
399    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
400    TestInterfaceV8Internal::Node25AttrSetter(name, value, info);
401    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
402}
403
404#endif // ENABLE(Condition22) || ENABLE(Condition23)
405
406#if ENABLE(Condition11) || ENABLE(Condition12)
407
408static void supplementalStaticReadOnlyAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
409{
410    v8SetReturnValueInt(info, TestPartialInterface::supplementalStaticReadOnlyAttr());
411    return;
412}
413
414#endif // ENABLE(Condition11) || ENABLE(Condition12)
415
416#if ENABLE(Condition11) || ENABLE(Condition12)
417
418static void supplementalStaticReadOnlyAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
419{
420    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
421    TestInterfaceV8Internal::supplementalStaticReadOnlyAttrAttrGetter(name, info);
422    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
423}
424
425#endif // ENABLE(Condition11) || ENABLE(Condition12)
426
427#if ENABLE(Condition11) || ENABLE(Condition12)
428
429static void supplementalStaticAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
430{
431    v8SetReturnValueString(info, TestPartialInterface::supplementalStaticAttr(), info.GetIsolate());
432    return;
433}
434
435#endif // ENABLE(Condition11) || ENABLE(Condition12)
436
437#if ENABLE(Condition11) || ENABLE(Condition12)
438
439static void supplementalStaticAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
440{
441    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
442    TestInterfaceV8Internal::supplementalStaticAttrAttrGetter(name, info);
443    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
444}
445
446#endif // ENABLE(Condition11) || ENABLE(Condition12)
447
448#if ENABLE(Condition11) || ENABLE(Condition12)
449
450static void supplementalStaticAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
451{
452    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value);
453    TestPartialInterface::setSupplementalStaticAttr(v);
454    return;
455}
456
457#endif // ENABLE(Condition11) || ENABLE(Condition12)
458
459#if ENABLE(Condition11) || ENABLE(Condition12)
460
461static void supplementalStaticAttrAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
462{
463    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
464    TestInterfaceV8Internal::supplementalStaticAttrAttrSetter(name, value, info);
465    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
466}
467
468#endif // ENABLE(Condition11) || ENABLE(Condition12)
469
470#if ENABLE(Condition11) || ENABLE(Condition12)
471
472static void supplementalStr1AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
473{
474    TestInterface* imp = V8TestInterface::toNative(info.Holder());
475    v8SetReturnValueString(info, TestPartialInterface::supplementalStr1(imp), info.GetIsolate());
476    return;
477}
478
479#endif // ENABLE(Condition11) || ENABLE(Condition12)
480
481#if ENABLE(Condition11) || ENABLE(Condition12)
482
483static void supplementalStr1AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
484{
485    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
486    TestInterfaceV8Internal::supplementalStr1AttrGetter(name, info);
487    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
488}
489
490#endif // ENABLE(Condition11) || ENABLE(Condition12)
491
492#if ENABLE(Condition11) || ENABLE(Condition12)
493
494static void supplementalStr2AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
495{
496    TestInterface* imp = V8TestInterface::toNative(info.Holder());
497    v8SetReturnValueString(info, TestPartialInterface::supplementalStr2(imp), info.GetIsolate());
498    return;
499}
500
501#endif // ENABLE(Condition11) || ENABLE(Condition12)
502
503#if ENABLE(Condition11) || ENABLE(Condition12)
504
505static void supplementalStr2AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
506{
507    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
508    TestInterfaceV8Internal::supplementalStr2AttrGetter(name, info);
509    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
510}
511
512#endif // ENABLE(Condition11) || ENABLE(Condition12)
513
514#if ENABLE(Condition11) || ENABLE(Condition12)
515
516static void supplementalStr2AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
517{
518    TestInterface* imp = V8TestInterface::toNative(info.Holder());
519    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value);
520    TestPartialInterface::setSupplementalStr2(imp, v);
521    return;
522}
523
524#endif // ENABLE(Condition11) || ENABLE(Condition12)
525
526#if ENABLE(Condition11) || ENABLE(Condition12)
527
528static void supplementalStr2AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
529{
530    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
531    TestInterfaceV8Internal::supplementalStr2AttrSetter(name, value, info);
532    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
533}
534
535#endif // ENABLE(Condition11) || ENABLE(Condition12)
536
537#if ENABLE(Condition11) || ENABLE(Condition12)
538
539static void supplementalStr3AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
540{
541    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
542    V8TestInterface::supplementalStr3AttrGetterCustom(name, info);
543    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
544}
545
546#endif // ENABLE(Condition11) || ENABLE(Condition12)
547
548#if ENABLE(Condition11) || ENABLE(Condition12)
549
550static void supplementalStr3AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
551{
552    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
553    V8TestInterface::supplementalStr3AttrSetterCustom(name, value, info);
554    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
555}
556
557#endif // ENABLE(Condition11) || ENABLE(Condition12)
558
559#if ENABLE(Condition11) || ENABLE(Condition12)
560
561static void supplementalNodeAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
562{
563    TestInterface* imp = V8TestInterface::toNative(info.Holder());
564    v8SetReturnValue(info, toV8Fast(TestPartialInterface::supplementalNode(imp), info, imp));
565    return;
566}
567
568#endif // ENABLE(Condition11) || ENABLE(Condition12)
569
570#if ENABLE(Condition11) || ENABLE(Condition12)
571
572static void supplementalNodeAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
573{
574    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
575    TestInterfaceV8Internal::supplementalNodeAttrGetter(name, info);
576    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
577}
578
579#endif // ENABLE(Condition11) || ENABLE(Condition12)
580
581#if ENABLE(Condition11) || ENABLE(Condition12)
582
583static void supplementalNodeAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
584{
585    TestInterface* imp = V8TestInterface::toNative(info.Holder());
586    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
587    TestPartialInterface::setSupplementalNode(imp, WTF::getPtr(v));
588    return;
589}
590
591#endif // ENABLE(Condition11) || ENABLE(Condition12)
592
593#if ENABLE(Condition11) || ENABLE(Condition12)
594
595static void supplementalNodeAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
596{
597    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
598    TestInterfaceV8Internal::supplementalNodeAttrSetter(name, value, info);
599    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
600}
601
602#endif // ENABLE(Condition11) || ENABLE(Condition12)
603
604#if ENABLE(Condition11) || ENABLE(Condition12)
605
606static void Node13AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
607{
608    TestInterface* imp = V8TestInterface::toNative(info.Holder());
609    v8SetReturnValue(info, toV8Fast(TestPartialInterface::node13(imp), info, imp));
610    return;
611}
612
613#endif // ENABLE(Condition11) || ENABLE(Condition12)
614
615#if ENABLE(Condition11) || ENABLE(Condition12)
616
617static void Node13AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
618{
619    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
620    TestInterfaceV8Internal::Node13AttrGetter(name, info);
621    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
622}
623
624#endif // ENABLE(Condition11) || ENABLE(Condition12)
625
626#if ENABLE(Condition11) || ENABLE(Condition12)
627
628static void Node13AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
629{
630    TestInterface* imp = V8TestInterface::toNative(info.Holder());
631    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
632    TestPartialInterface::setNode13(imp, WTF::getPtr(v));
633    return;
634}
635
636#endif // ENABLE(Condition11) || ENABLE(Condition12)
637
638#if ENABLE(Condition11) || ENABLE(Condition12)
639
640static void Node13AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
641{
642    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
643    TestInterfaceV8Internal::Node13AttrSetter(name, value, info);
644    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
645}
646
647#endif // ENABLE(Condition11) || ENABLE(Condition12)
648
649#if ENABLE(Condition11) || ENABLE(Condition12)
650
651static void Node14AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
652{
653    TestInterface* imp = V8TestInterface::toNative(info.Holder());
654    v8SetReturnValue(info, toV8Fast(TestPartialInterface::node14(imp), info, imp));
655    return;
656}
657
658#endif // ENABLE(Condition11) || ENABLE(Condition12)
659
660#if ENABLE(Condition11) || ENABLE(Condition12)
661
662static void Node14AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
663{
664    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
665    TestInterfaceV8Internal::Node14AttrGetter(name, info);
666    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
667}
668
669#endif // ENABLE(Condition11) || ENABLE(Condition12)
670
671#if ENABLE(Condition11) || ENABLE(Condition12)
672
673static void Node14AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
674{
675    TestInterface* imp = V8TestInterface::toNative(info.Holder());
676    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
677    TestPartialInterface::setNode14(imp, WTF::getPtr(v));
678    return;
679}
680
681#endif // ENABLE(Condition11) || ENABLE(Condition12)
682
683#if ENABLE(Condition11) || ENABLE(Condition12)
684
685static void Node14AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
686{
687    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
688    TestInterfaceV8Internal::Node14AttrSetter(name, value, info);
689    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
690}
691
692#endif // ENABLE(Condition11) || ENABLE(Condition12)
693
694#if ENABLE(Condition11) || ENABLE(Condition12)
695
696static void Node15AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
697{
698    TestInterface* imp = V8TestInterface::toNative(info.Holder());
699    v8SetReturnValue(info, toV8Fast(TestPartialInterface::node15(imp), info, imp));
700    return;
701}
702
703#endif // ENABLE(Condition11) || ENABLE(Condition12)
704
705#if ENABLE(Condition11) || ENABLE(Condition12)
706
707static void Node15AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
708{
709    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
710    TestInterfaceV8Internal::Node15AttrGetter(name, info);
711    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
712}
713
714#endif // ENABLE(Condition11) || ENABLE(Condition12)
715
716#if ENABLE(Condition11) || ENABLE(Condition12)
717
718static void Node15AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
719{
720    TestInterface* imp = V8TestInterface::toNative(info.Holder());
721    V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0);
722    TestPartialInterface::setNode15(imp, WTF::getPtr(v));
723    return;
724}
725
726#endif // ENABLE(Condition11) || ENABLE(Condition12)
727
728#if ENABLE(Condition11) || ENABLE(Condition12)
729
730static void Node15AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
731{
732    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
733    TestInterfaceV8Internal::Node15AttrSetter(name, value, info);
734    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
735}
736
737#endif // ENABLE(Condition11) || ENABLE(Condition12)
738
739#if ENABLE(Condition22) || ENABLE(Condition23)
740
741static void implementsMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& args)
742{
743    TestInterface* imp = V8TestInterface::toNative(args.Holder());
744    TestImplements::implementsMethod1(imp);
745
746    return;
747}
748
749#endif // ENABLE(Condition22) || ENABLE(Condition23)
750
751#if ENABLE(Condition22) || ENABLE(Condition23)
752
753static void implementsMethod1MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
754{
755    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
756    TestInterfaceV8Internal::implementsMethod1Method(args);
757    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
758}
759
760#endif // ENABLE(Condition22) || ENABLE(Condition23)
761
762#if ENABLE(Condition22) || ENABLE(Condition23)
763
764static void implementsMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& args)
765{
766    if (args.Length() < 2) {
767        throwNotEnoughArgumentsError(args.GetIsolate());
768        return;
769    }
770    TestInterface* imp = V8TestInterface::toNative(args.Holder());
771    ExceptionState es(args.GetIsolate());
772    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strArg, args[0]);
773    V8TRYCATCH_VOID(TestObj*, objArg, V8TestObject::HasInstance(args[1], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0);
774    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
775    RefPtr<TestObj> result = TestImplements::implementsMethod2(scriptContext, imp, strArg, objArg, es);
776    if (es.throwIfNeeded())
777        return;
778    v8SetReturnValue(args, toV8(result.release(), args.Holder(), args.GetIsolate()));
779    return;
780}
781
782#endif // ENABLE(Condition22) || ENABLE(Condition23)
783
784#if ENABLE(Condition22) || ENABLE(Condition23)
785
786static void implementsMethod2MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
787{
788    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
789    TestInterfaceV8Internal::implementsMethod2Method(args);
790    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
791}
792
793#endif // ENABLE(Condition22) || ENABLE(Condition23)
794
795#if ENABLE(Condition22) || ENABLE(Condition23)
796
797static void implementsMethod3MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
798{
799    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
800    V8TestInterface::implementsMethod3MethodCustom(args);
801    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
802}
803
804#endif // ENABLE(Condition22) || ENABLE(Condition23)
805
806#if ENABLE(Condition22) || ENABLE(Condition23)
807
808static void implementsMethod4Method(const v8::FunctionCallbackInfo<v8::Value>& args)
809{
810    TestImplements::implementsMethod4();
811
812    return;
813}
814
815#endif // ENABLE(Condition22) || ENABLE(Condition23)
816
817#if ENABLE(Condition22) || ENABLE(Condition23)
818
819static void implementsMethod4MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
820{
821    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
822    TestInterfaceV8Internal::implementsMethod4Method(args);
823    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
824}
825
826#endif // ENABLE(Condition22) || ENABLE(Condition23)
827
828#if ENABLE(Condition11) || ENABLE(Condition12)
829
830static void supplementalMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& args)
831{
832    TestInterface* imp = V8TestInterface::toNative(args.Holder());
833    TestPartialInterface::supplementalMethod1(imp);
834
835    return;
836}
837
838#endif // ENABLE(Condition11) || ENABLE(Condition12)
839
840#if ENABLE(Condition11) || ENABLE(Condition12)
841
842static void supplementalMethod1MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
843{
844    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
845    TestInterfaceV8Internal::supplementalMethod1Method(args);
846    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
847}
848
849#endif // ENABLE(Condition11) || ENABLE(Condition12)
850
851#if ENABLE(Condition11) || ENABLE(Condition12)
852
853static void supplementalMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& args)
854{
855    if (args.Length() < 2) {
856        throwNotEnoughArgumentsError(args.GetIsolate());
857        return;
858    }
859    TestInterface* imp = V8TestInterface::toNative(args.Holder());
860    ExceptionState es(args.GetIsolate());
861    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strArg, args[0]);
862    V8TRYCATCH_VOID(TestObj*, objArg, V8TestObject::HasInstance(args[1], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0);
863    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
864    RefPtr<TestObj> result = TestPartialInterface::supplementalMethod2(scriptContext, imp, strArg, objArg, es);
865    if (es.throwIfNeeded())
866        return;
867    v8SetReturnValue(args, toV8(result.release(), args.Holder(), args.GetIsolate()));
868    return;
869}
870
871#endif // ENABLE(Condition11) || ENABLE(Condition12)
872
873#if ENABLE(Condition11) || ENABLE(Condition12)
874
875static void supplementalMethod2MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
876{
877    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
878    TestInterfaceV8Internal::supplementalMethod2Method(args);
879    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
880}
881
882#endif // ENABLE(Condition11) || ENABLE(Condition12)
883
884#if ENABLE(Condition11) || ENABLE(Condition12)
885
886static void supplementalMethod3MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
887{
888    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
889    V8TestInterface::supplementalMethod3MethodCustom(args);
890    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
891}
892
893#endif // ENABLE(Condition11) || ENABLE(Condition12)
894
895#if ENABLE(Condition11) || ENABLE(Condition12)
896
897static void supplementalMethod4Method(const v8::FunctionCallbackInfo<v8::Value>& args)
898{
899    TestPartialInterface::supplementalMethod4();
900
901    return;
902}
903
904#endif // ENABLE(Condition11) || ENABLE(Condition12)
905
906#if ENABLE(Condition11) || ENABLE(Condition12)
907
908static void supplementalMethod4MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
909{
910    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
911    TestInterfaceV8Internal::supplementalMethod4Method(args);
912    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
913}
914
915#endif // ENABLE(Condition11) || ENABLE(Condition12)
916
917static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
918{
919    if (args.Length() < 1) {
920        throwNotEnoughArgumentsError(args.GetIsolate());
921        return;
922    }
923    ExceptionState es(args.GetIsolate());
924    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, str1, args[0]);
925    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, str2, args[1]);
926
927    ScriptExecutionContext* context = getScriptExecutionContext();
928    RefPtr<TestInterface> impl = TestInterface::create(context, str1, str2, es);
929    v8::Handle<v8::Object> wrapper = args.Holder();
930    if (es.throwIfNeeded())
931        return;
932
933    V8DOMWrapper::associateObjectWithWrapper<V8TestInterface>(impl.release(), &V8TestInterface::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
934    args.GetReturnValue().Set(wrapper);
935}
936
937static void namedPropertyGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
938{
939    if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())
940        return;
941    if (info.Holder()->HasRealNamedCallbackProperty(name))
942        return;
943    if (info.Holder()->HasRealNamedProperty(name))
944        return;
945
946    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
947    TestInterface* collection = V8TestInterface::toNative(info.Holder());
948    AtomicString propertyName = toWebCoreAtomicString(name);
949    bool element0Enabled = false;
950    RefPtr<Node> element0;
951    bool element1Enabled = false;
952    RefPtr<NodeList> element1;
953    collection->getItem(propertyName, element0Enabled, element0, element1Enabled, element1);
954    if (element0Enabled) {
955        v8SetReturnValue(info, toV8Fast(element0.release(), info, collection));
956        return;
957    }
958
959    if (element1Enabled) {
960        v8SetReturnValue(info, toV8Fast(element1.release(), info, collection));
961        return;
962    }
963
964    return;
965}
966
967static void namedPropertyGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
968{
969    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty");
970    TestInterfaceV8Internal::namedPropertyGetter(name, info);
971    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
972}
973
974static void namedPropertySetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
975{
976    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty");
977    V8TestInterface::namedPropertySetterCustom(name, value, info);
978    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
979}
980
981static void namedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info)
982{
983    ExceptionState es(info.GetIsolate());
984    TestInterface* collection = V8TestInterface::toNative(info.Holder());
985    Vector<String> names;
986    collection->namedPropertyEnumerator(names, es);
987    if (es.throwIfNeeded())
988        return;
989    v8::Handle<v8::Array> v8names = v8::Array::New(names.size());
990    for (size_t i = 0; i < names.size(); ++i)
991        v8names->Set(v8::Integer::New(i, info.GetIsolate()), v8String(names[i], info.GetIsolate()));
992    v8SetReturnValue(info, v8names);
993}
994
995static void namedPropertyQuery(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
996{
997    TestInterface* collection = V8TestInterface::toNative(info.Holder());
998    AtomicString propertyName = toWebCoreAtomicString(name);
999    ExceptionState es(info.GetIsolate());
1000    bool result = collection->namedPropertyQuery(propertyName, es);
1001    if (es.throwIfNeeded())
1002        return;
1003    if (!result)
1004        return;
1005    v8SetReturnValueInt(info, v8::None);
1006}
1007
1008static void namedPropertyEnumeratorCallback(const v8::PropertyCallbackInfo<v8::Array>& info)
1009{
1010    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty");
1011    TestInterfaceV8Internal::namedPropertyEnumerator(info);
1012    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
1013}
1014
1015static void namedPropertyQueryCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
1016{
1017    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty");
1018    TestInterfaceV8Internal::namedPropertyQuery(name, info);
1019    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
1020}
1021
1022} // namespace TestInterfaceV8Internal
1023
1024static const V8DOMConfiguration::BatchedAttribute V8TestInterfaceAttrs[] = {
1025#if ENABLE(Condition22) || ENABLE(Condition23)
1026    // Attribute 'implementsStaticReadOnlyAttr'
1027    {"implementsStaticReadOnlyAttr", TestInterfaceV8Internal::implementsStaticReadOnlyAttrAttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1028#endif // ENABLE(Condition22) || ENABLE(Condition23)
1029#if ENABLE(Condition22) || ENABLE(Condition23)
1030    // Attribute 'implementsStaticAttr'
1031    {"implementsStaticAttr", TestInterfaceV8Internal::implementsStaticAttrAttrGetterCallback, TestInterfaceV8Internal::implementsStaticAttrAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1032#endif // ENABLE(Condition22) || ENABLE(Condition23)
1033#if ENABLE(Condition22) || ENABLE(Condition23)
1034    // Attribute 'implementsStr1'
1035    {"implementsStr1", TestInterfaceV8Internal::implementsStr1AttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1036#endif // ENABLE(Condition22) || ENABLE(Condition23)
1037#if ENABLE(Condition22) || ENABLE(Condition23)
1038    // Attribute 'implementsStr2'
1039    {"implementsStr2", TestInterfaceV8Internal::implementsStr2AttrGetterCallback, TestInterfaceV8Internal::implementsStr2AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1040#endif // ENABLE(Condition22) || ENABLE(Condition23)
1041#if ENABLE(Condition22) || ENABLE(Condition23)
1042    // Attribute 'implementsStr3'
1043    {"implementsStr3", TestInterfaceV8Internal::implementsStr3AttrGetterCallback, TestInterfaceV8Internal::implementsStr3AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1044#endif // ENABLE(Condition22) || ENABLE(Condition23)
1045#if ENABLE(Condition22) || ENABLE(Condition23)
1046    // Attribute 'implementsNode'
1047    {"implementsNode", TestInterfaceV8Internal::implementsNodeAttrGetterCallback, TestInterfaceV8Internal::implementsNodeAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1048#endif // ENABLE(Condition22) || ENABLE(Condition23)
1049#if ENABLE(Condition11) || ENABLE(Condition12)
1050    // Attribute 'supplementalStaticReadOnlyAttr'
1051    {"supplementalStaticReadOnlyAttr", TestInterfaceV8Internal::supplementalStaticReadOnlyAttrAttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1052#endif // ENABLE(Condition11) || ENABLE(Condition12)
1053#if ENABLE(Condition11) || ENABLE(Condition12)
1054    // Attribute 'supplementalStaticAttr'
1055    {"supplementalStaticAttr", TestInterfaceV8Internal::supplementalStaticAttrAttrGetterCallback, TestInterfaceV8Internal::supplementalStaticAttrAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1056#endif // ENABLE(Condition11) || ENABLE(Condition12)
1057#if ENABLE(Condition11) || ENABLE(Condition12)
1058    // Attribute 'supplementalStr1'
1059    {"supplementalStr1", TestInterfaceV8Internal::supplementalStr1AttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1060#endif // ENABLE(Condition11) || ENABLE(Condition12)
1061#if ENABLE(Condition11) || ENABLE(Condition12)
1062    // Attribute 'supplementalStr2'
1063    {"supplementalStr2", TestInterfaceV8Internal::supplementalStr2AttrGetterCallback, TestInterfaceV8Internal::supplementalStr2AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1064#endif // ENABLE(Condition11) || ENABLE(Condition12)
1065#if ENABLE(Condition11) || ENABLE(Condition12)
1066    // Attribute 'supplementalStr3'
1067    {"supplementalStr3", TestInterfaceV8Internal::supplementalStr3AttrGetterCallback, TestInterfaceV8Internal::supplementalStr3AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1068#endif // ENABLE(Condition11) || ENABLE(Condition12)
1069#if ENABLE(Condition11) || ENABLE(Condition12)
1070    // Attribute 'supplementalNode'
1071    {"supplementalNode", TestInterfaceV8Internal::supplementalNodeAttrGetterCallback, TestInterfaceV8Internal::supplementalNodeAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
1072#endif // ENABLE(Condition11) || ENABLE(Condition12)
1073};
1074
1075static const V8DOMConfiguration::BatchedMethod V8TestInterfaceMethods[] = {
1076#if ENABLE(Condition22) || ENABLE(Condition23)
1077    {"implementsMethod1", TestInterfaceV8Internal::implementsMethod1MethodCallback, 0, 0},
1078#endif // ENABLE(Condition22) || ENABLE(Condition23)
1079#if ENABLE(Condition22) || ENABLE(Condition23)
1080    {"implementsMethod3", TestInterfaceV8Internal::implementsMethod3MethodCallback, 0, 0},
1081#endif // ENABLE(Condition22) || ENABLE(Condition23)
1082#if ENABLE(Condition11) || ENABLE(Condition12)
1083    {"supplementalMethod1", TestInterfaceV8Internal::supplementalMethod1MethodCallback, 0, 0},
1084#endif // ENABLE(Condition11) || ENABLE(Condition12)
1085#if ENABLE(Condition11) || ENABLE(Condition12)
1086    {"supplementalMethod3", TestInterfaceV8Internal::supplementalMethod3MethodCallback, 0, 0},
1087#endif // ENABLE(Condition11) || ENABLE(Condition12)
1088};
1089
1090static const V8DOMConfiguration::BatchedConstant V8TestInterfaceConsts[] = {
1091#if ENABLE(Condition22) || ENABLE(Condition23)
1092    {"IMPLEMENTSCONSTANT1", 1},
1093#endif
1094#if ENABLE(Condition22) || ENABLE(Condition23)
1095    {"IMPLEMENTSCONSTANT2", 2},
1096#endif
1097#if ENABLE(Condition11) || ENABLE(Condition12)
1098    {"SUPPLEMENTALCONSTANT1", 1},
1099#endif
1100#if ENABLE(Condition11) || ENABLE(Condition12)
1101    {"SUPPLEMENTALCONSTANT2", 2},
1102#endif
1103};
1104
1105
1106#if ENABLE(Condition22) || ENABLE(Condition23)
1107COMPILE_ASSERT(1 == TestImplements::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants);
1108#endif
1109#if ENABLE(Condition22) || ENABLE(Condition23)
1110COMPILE_ASSERT(2 == TestImplements::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
1111#endif
1112#if ENABLE(Condition11) || ENABLE(Condition12)
1113COMPILE_ASSERT(1 == TestPartialInterface::SUPPLEMENTALCONSTANT1, TestInterfaceEnumSUPPLEMENTALCONSTANT1IsWrongUseDoNotCheckConstants);
1114#endif
1115#if ENABLE(Condition11) || ENABLE(Condition12)
1116COMPILE_ASSERT(2 == TestPartialInterface::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
1117#endif
1118
1119void V8TestInterface::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
1120{
1121    TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "DOMConstructor");
1122    if (!args.IsConstructCall()) {
1123        throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
1124        return;
1125    }
1126
1127    if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) {
1128        args.GetReturnValue().Set(args.Holder());
1129        return;
1130    }
1131
1132    TestInterfaceV8Internal::constructor(args);
1133}
1134
1135static v8::Handle<v8::FunctionTemplate> ConfigureV8TestInterfaceTemplate(v8::Handle<v8::FunctionTemplate> desc, v8::Isolate* isolate, WrapperWorldType currentWorldType)
1136{
1137    desc->ReadOnlyPrototype();
1138
1139    v8::Local<v8::Signature> defaultSignature;
1140    defaultSignature = V8DOMConfiguration::configureTemplate(desc, "TestInterface", v8::Local<v8::FunctionTemplate>(), V8TestInterface::internalFieldCount,
1141        V8TestInterfaceAttrs, WTF_ARRAY_LENGTH(V8TestInterfaceAttrs),
1142        V8TestInterfaceMethods, WTF_ARRAY_LENGTH(V8TestInterfaceMethods), isolate, currentWorldType);
1143    UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
1144    desc->SetCallHandler(V8TestInterface::constructorCallback);
1145    desc->SetLength(1);
1146    v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
1147    v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
1148    UNUSED_PARAM(instance); // In some cases, it will not be used.
1149    UNUSED_PARAM(proto); // In some cases, it will not be used.
1150
1151#if ENABLE(Condition22) || ENABLE(Condition23)
1152    if (RuntimeEnabledFeatures::condition23Enabled()) {
1153        static const V8DOMConfiguration::BatchedAttribute attrData =\
1154        // Attribute 'Node23'
1155        {"Node23", TestInterfaceV8Internal::Node23AttrGetterCallback, TestInterfaceV8Internal::Node23AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
1156        V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate, currentWorldType);
1157    }
1158
1159#endif // ENABLE(Condition22) || ENABLE(Condition23)
1160
1161#if ENABLE(Condition11) || ENABLE(Condition12)
1162    if (RuntimeEnabledFeatures::condition13Enabled()) {
1163        static const V8DOMConfiguration::BatchedAttribute attrData =\
1164        // Attribute 'Node13'
1165        {"Node13", TestInterfaceV8Internal::Node13AttrGetterCallback, TestInterfaceV8Internal::Node13AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
1166        V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate, currentWorldType);
1167    }
1168
1169#endif // ENABLE(Condition11) || ENABLE(Condition12)
1170    desc->InstanceTemplate()->SetNamedPropertyHandler(TestInterfaceV8Internal::namedPropertyGetterCallback, TestInterfaceV8Internal::namedPropertySetterCallback, TestInterfaceV8Internal::namedPropertyQueryCallback, 0, TestInterfaceV8Internal::namedPropertyEnumeratorCallback);
1171#if ENABLE(Condition22) || ENABLE(Condition23)
1172
1173    // Custom Signature 'implementsMethod2'
1174    const int implementsMethod2Argc = 2;
1175    v8::Handle<v8::FunctionTemplate> implementsMethod2Argv[implementsMethod2Argc] = { v8::Handle<v8::FunctionTemplate>(), V8PerIsolateData::from(isolate)->rawTemplate(&V8TestObject::info, currentWorldType) };
1176    v8::Handle<v8::Signature> implementsMethod2Signature = v8::Signature::New(desc, implementsMethod2Argc, implementsMethod2Argv);
1177    proto->Set(v8::String::NewSymbol("implementsMethod2"), v8::FunctionTemplate::New(TestInterfaceV8Internal::implementsMethod2MethodCallback, v8Undefined(), implementsMethod2Signature, 2));
1178#endif // ENABLE(Condition22) || ENABLE(Condition23)
1179#if ENABLE(Condition22) || ENABLE(Condition23)
1180    desc->Set(v8::String::NewSymbol("implementsMethod4"), v8::FunctionTemplate::New(TestInterfaceV8Internal::implementsMethod4MethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 0));
1181#endif // ENABLE(Condition22) || ENABLE(Condition23)
1182#if ENABLE(Condition11) || ENABLE(Condition12)
1183
1184    // Custom Signature 'supplementalMethod2'
1185    const int supplementalMethod2Argc = 2;
1186    v8::Handle<v8::FunctionTemplate> supplementalMethod2Argv[supplementalMethod2Argc] = { v8::Handle<v8::FunctionTemplate>(), V8PerIsolateData::from(isolate)->rawTemplate(&V8TestObject::info, currentWorldType) };
1187    v8::Handle<v8::Signature> supplementalMethod2Signature = v8::Signature::New(desc, supplementalMethod2Argc, supplementalMethod2Argv);
1188    proto->Set(v8::String::NewSymbol("supplementalMethod2"), v8::FunctionTemplate::New(TestInterfaceV8Internal::supplementalMethod2MethodCallback, v8Undefined(), supplementalMethod2Signature, 2));
1189#endif // ENABLE(Condition11) || ENABLE(Condition12)
1190#if ENABLE(Condition11) || ENABLE(Condition12)
1191    desc->Set(v8::String::NewSymbol("supplementalMethod4"), v8::FunctionTemplate::New(TestInterfaceV8Internal::supplementalMethod4MethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 0));
1192#endif // ENABLE(Condition11) || ENABLE(Condition12)
1193    V8DOMConfiguration::batchConfigureConstants(desc, proto, V8TestInterfaceConsts, WTF_ARRAY_LENGTH(V8TestInterfaceConsts), isolate);
1194
1195    // Custom toString template
1196    desc->Set(v8::String::NewSymbol("toString"), V8PerIsolateData::current()->toStringTemplate());
1197    return desc;
1198}
1199
1200v8::Handle<v8::FunctionTemplate> V8TestInterface::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
1201{
1202    V8PerIsolateData* data = V8PerIsolateData::from(isolate);
1203    V8PerIsolateData::TemplateMap::iterator result = data->templateMap(currentWorldType).find(&info);
1204    if (result != data->templateMap(currentWorldType).end())
1205        return result->value.newLocal(isolate);
1206
1207    TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
1208    v8::HandleScope handleScope(isolate);
1209    v8::Handle<v8::FunctionTemplate> templ =
1210        ConfigureV8TestInterfaceTemplate(data->rawTemplate(&info, currentWorldType), isolate, currentWorldType);
1211    data->templateMap(currentWorldType).add(&info, UnsafePersistent<v8::FunctionTemplate>(isolate, templ));
1212    return handleScope.Close(templ);
1213}
1214
1215bool V8TestInterface::HasInstance(v8::Handle<v8::Value> value, v8::Isolate* isolate, WrapperWorldType currentWorldType)
1216{
1217    return V8PerIsolateData::from(isolate)->hasInstance(&info, value, currentWorldType);
1218}
1219
1220bool V8TestInterface::HasInstanceInAnyWorld(v8::Handle<v8::Value> value, v8::Isolate* isolate)
1221{
1222    return V8PerIsolateData::from(isolate)->hasInstance(&info, value, MainWorld)
1223        || V8PerIsolateData::from(isolate)->hasInstance(&info, value, IsolatedWorld)
1224        || V8PerIsolateData::from(isolate)->hasInstance(&info, value, WorkerWorld);
1225}
1226
1227void V8TestInterface::installPerContextProperties(v8::Handle<v8::Object> instance, TestInterface* impl, v8::Isolate* isolate)
1228{
1229    v8::Local<v8::Object> proto = v8::Local<v8::Object>::Cast(instance->GetPrototype());
1230
1231#if ENABLE(Condition22) || ENABLE(Condition23)
1232    if (ContextFeatures::condition24Enabled(impl->document())) {
1233        static const V8DOMConfiguration::BatchedAttribute attrData =\
1234        // Attribute 'Node24'
1235        {"Node24", TestInterfaceV8Internal::Node24AttrGetterCallback, TestInterfaceV8Internal::Node24AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
1236        V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate);
1237    }
1238#endif // ENABLE(Condition22) || ENABLE(Condition23)
1239
1240#if ENABLE(Condition22) || ENABLE(Condition23)
1241    if (ContextFeatures::condition26Enabled(impl->document()) && RuntimeEnabledFeatures::condition25Enabled()) {
1242        static const V8DOMConfiguration::BatchedAttribute attrData =\
1243        // Attribute 'Node25'
1244        {"Node25", TestInterfaceV8Internal::Node25AttrGetterCallback, TestInterfaceV8Internal::Node25AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
1245        V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate);
1246    }
1247#endif // ENABLE(Condition22) || ENABLE(Condition23)
1248
1249#if ENABLE(Condition11) || ENABLE(Condition12)
1250    if (ContextFeatures::condition14Enabled(impl->document())) {
1251        static const V8DOMConfiguration::BatchedAttribute attrData =\
1252        // Attribute 'Node14'
1253        {"Node14", TestInterfaceV8Internal::Node14AttrGetterCallback, TestInterfaceV8Internal::Node14AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
1254        V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate);
1255    }
1256#endif // ENABLE(Condition11) || ENABLE(Condition12)
1257
1258#if ENABLE(Condition11) || ENABLE(Condition12)
1259    if (ContextFeatures::condition16Enabled(impl->document()) && RuntimeEnabledFeatures::condition15Enabled()) {
1260        static const V8DOMConfiguration::BatchedAttribute attrData =\
1261        // Attribute 'Node15'
1262        {"Node15", TestInterfaceV8Internal::Node15AttrGetterCallback, TestInterfaceV8Internal::Node15AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
1263        V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate);
1264    }
1265#endif // ENABLE(Condition11) || ENABLE(Condition12)
1266}
1267
1268ActiveDOMObject* V8TestInterface::toActiveDOMObject(v8::Handle<v8::Object> object)
1269{
1270    return toNative(object);
1271}
1272
1273
1274v8::Handle<v8::Object> V8TestInterface::createWrapper(PassRefPtr<TestInterface> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
1275{
1276    ASSERT(impl.get());
1277    ASSERT(DOMDataStore::getWrapper<V8TestInterface>(impl.get(), isolate).IsEmpty());
1278    if (ScriptWrappable::wrapperCanBeStoredInObject(impl.get())) {
1279        const WrapperTypeInfo* actualInfo = ScriptWrappable::getTypeInfoFromObject(impl.get());
1280        // Might be a XXXConstructor::info instead of an XXX::info. These will both have
1281        // the same object de-ref functions, though, so use that as the basis of the check.
1282        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(actualInfo->derefObjectFunction == info.derefObjectFunction);
1283    }
1284
1285
1286    v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &info, toInternalPointer(impl.get()), isolate);
1287    if (UNLIKELY(wrapper.IsEmpty()))
1288        return wrapper;
1289    installPerContextProperties(wrapper, impl.get(), isolate);
1290    V8DOMWrapper::associateObjectWithWrapper<V8TestInterface>(impl, &info, wrapper, isolate, WrapperConfiguration::Dependent);
1291    return wrapper;
1292}
1293void V8TestInterface::derefObject(void* object)
1294{
1295    fromInternalPointer(object)->deref();
1296}
1297
1298} // namespace WebCore
1299
1300#endif // ENABLE(Condition1) || ENABLE(Condition2)
1301